Return to route.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / nstat

Annotation of cci/usr/src/etc/nstat/route.c, revision 1.1

1.1     ! root        1: 
        !             2: #include <stdio.h>
        !             3: #include <sys/types.h>
        !             4: #include <sys/socket.h>
        !             5: #include <sys/mbuf.h>
        !             6: 
        !             7: #include <net/if.h>
        !             8: #define        KERNEL          /* to get routehash and RTHASHSIZ */
        !             9: #include <net/route.h>
        !            10: #include <netinet/in.h>
        !            11: #include <netdb.h>
        !            12: #include <nlist.h>
        !            13: #include "nstat.h"
        !            14: 
        !            15: 
        !            16: struct nlist   routenl[] = {
        !            17: #                      define  N_RTHOST        0
        !            18:        { "_rthost" },
        !            19: #                      define  N_RTNET         1
        !            20:        { "_rtnet" },
        !            21: #                      define  N_RTSTAT        2
        !            22:        { "_rtstat" },
        !            23:        { "" },
        !            24: };
        !            25: static int     getvm = 0;
        !            26: extern long    flaggiven;
        !            27: extern int     kmem;           /* file descriptor of kmem file */
        !            28: extern char    *routename();
        !            29: extern char    *system;
        !            30: 
        !            31: /*
        !            32:  * Definitions for showing gateway flags.
        !            33:  */
        !            34: struct bits {
        !            35:        short   b_mask;
        !            36:        char    b_val;
        !            37: } bits[] = {
        !            38:        { RTF_UP,       'U' },
        !            39:        { RTF_GATEWAY,  'G' },
        !            40:        { RTF_HOST,     'H' },
        !            41:        { 0 }
        !            42: };
        !            43: 
        !            44: /*
        !            45:  * Print routing tables.
        !            46:  */
        !            47: routepr()
        !            48: {
        !            49:        off_t hostaddr, netaddr;
        !            50:        struct mbuf mb;
        !            51:        register struct rtentry *rt;
        !            52:        register struct mbuf *m;
        !            53:        register struct bits *p;
        !            54:        struct netent *np;
        !            55:        struct hostent *hp;
        !            56:        char name[16], *flags;
        !            57:        struct mbuf *routehash[RTHASHSIZ];
        !            58:        struct ifnet ifnet;
        !            59:        int first = 1, i, doinghost = 1;
        !            60: 
        !            61: 
        !            62:        if (!getvm) {
        !            63:                nlist(system, routenl);
        !            64:                ++getvm;
        !            65:        }
        !            66:        hostaddr = routenl[N_RTHOST].n_value;
        !            67:        netaddr = routenl[N_RTNET].n_value;
        !            68:        if (hostaddr == 0) {
        !            69:                printf("rthost: symbol not in namelist\n");
        !            70:                return;
        !            71:        }
        !            72:        if (netaddr == 0) {
        !            73:                printf("rtnet: symbol not in namelist\n");
        !            74:                return;
        !            75:        }
        !            76:        klseek(kmem, hostaddr, 0);
        !            77:        read(kmem, routehash, sizeof (routehash));
        !            78:        printf("Routing Tables\n");
        !            79:        printf("%-15.15s %-15.15s %-8.8s %-6.6s %-10.10s %s\n",
        !            80:                "Destination", "Gateway",
        !            81:                "Flags", "Refcnt", "Use", "Interface");
        !            82: again:
        !            83:        for (i = 0; i < RTHASHSIZ; i++) {
        !            84:                if (routehash[i] == 0)
        !            85:                        continue;
        !            86:                m = routehash[i];
        !            87:                while (m) {
        !            88:                        struct sockaddr_in *sin;
        !            89: 
        !            90:                        klseek(kmem, m, 0);
        !            91:                        read(kmem, &mb, sizeof (mb));
        !            92:                        rt = mtod(&mb, struct rtentry *);
        !            93:                        sin = (struct sockaddr_in *)&rt->rt_dst;
        !            94:                        printf("%-15.15s ",
        !            95:                            sin->sin_addr.s_addr ?
        !            96:                                routename(sin->sin_addr) : "default");
        !            97:                        sin = (struct sockaddr_in *)&rt->rt_gateway;
        !            98:                        printf("%-15.15s ", routename(sin->sin_addr));
        !            99:                        for (flags = name, p = bits; p->b_mask; p++)
        !           100:                                if (p->b_mask & rt->rt_flags)
        !           101:                                        *flags++ = p->b_val;
        !           102:                        *flags = '\0';
        !           103:                        printf("%-8.8s %-6d %-10d ", name,
        !           104:                                rt->rt_refcnt, rt->rt_use);
        !           105:                        if (rt->rt_ifp == 0) {
        !           106:                                putchar('\n');
        !           107:                                m = mb.m_next;
        !           108:                                continue;
        !           109:                        }
        !           110:                        klseek(kmem, rt->rt_ifp, 0);
        !           111:                        read(kmem, &ifnet, sizeof (ifnet));
        !           112:                        klseek(kmem, (int)ifnet.if_name, 0);
        !           113:                        read(kmem, name, 16);
        !           114:                        printf("%s%d\n", name, ifnet.if_unit);
        !           115:                        m = mb.m_next;
        !           116:                }
        !           117:        }
        !           118:        if (doinghost) {
        !           119:                klseek(kmem, netaddr, 0);
        !           120:                read(kmem, routehash, sizeof (routehash));
        !           121:                doinghost = 0;
        !           122:                goto again;
        !           123:        }
        !           124: }
        !           125: 
        !           126: char *
        !           127: routename(in)
        !           128:        struct in_addr in;
        !           129: {
        !           130:        char *cp = 0;
        !           131:        static char line[50];
        !           132:        int lna, net;
        !           133: 
        !           134:        net = inet_netof(in);
        !           135:        lna = inet_lnaof(in);
        !           136:        if (!nflag) {
        !           137:                if (lna == INADDR_ANY) {
        !           138:                        struct netent *np = getnetbyaddr(net, AF_INET);
        !           139: 
        !           140:                        if (np)
        !           141:                                cp = np->n_name;
        !           142:                } else {
        !           143:                        struct hostent *hp;
        !           144: 
        !           145:                        hp = gethostbyaddr(&in, sizeof (struct in_addr),
        !           146:                                AF_INET);
        !           147:                        if (hp)
        !           148:                                cp = hp->h_name;
        !           149:                }
        !           150:        }
        !           151:        if (cp)
        !           152:                strcpy(line, cp);
        !           153:        else {
        !           154:                u_char *ucp = (u_char *)&in;
        !           155:                if (lna == INADDR_ANY)
        !           156:                        sprintf(line, "%u.%u.%u", ucp[0], ucp[1], ucp[2]);
        !           157:                else
        !           158:                        sprintf(line, "%u.%u.%u.%u", ucp[0], ucp[1],
        !           159:                                ucp[2], ucp[3]);
        !           160:        }
        !           161:        return (line);
        !           162: }
        !           163: 
        !           164: /*
        !           165:  * Print routing statistics
        !           166:  */
        !           167: rt_stats()
        !           168: {
        !           169:        off_t off;
        !           170:        struct rtstat rtstat;
        !           171: 
        !           172:        if (!getvm) {
        !           173:                nlist(system, routenl);
        !           174:                ++getvm;
        !           175:        }
        !           176:        off = routenl[N_RTSTAT].n_value;
        !           177:        if (off == 0) {
        !           178:                printf("rtstat: symbol not in namelist\n");
        !           179:                return;
        !           180:        }
        !           181:        klseek(kmem, off, 0);
        !           182:        read(kmem, (char *)&rtstat, sizeof (rtstat));
        !           183:        printf("routing:\n");
        !           184:        printf("\t%d bad routing redirect%s\n",
        !           185:                rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
        !           186:        printf("\t%d dynamically created route%s\n",
        !           187:                rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
        !           188:        printf("\t%d new gateway%s due to redirects\n",
        !           189:                rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
        !           190:        printf("\t%d destination%s found unreachable\n",
        !           191:                rtstat.rts_unreach, plural(rtstat.rts_unreach));
        !           192:        printf("\t%d use%s of a wildcard route\n",
        !           193:                rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
        !           194: }
        !           195: /*
        !           196:  * 
        !           197:  */
        !           198: printrt(rt)
        !           199: register struct rtentry *rt;
        !           200: {
        !           201:        struct mbuf mb;
        !           202:        register struct bits *p;
        !           203:        struct rtentry routentry;
        !           204:        struct netent *np;
        !           205:        struct hostent *hp;
        !           206:        char name[16], *flags;
        !           207:        struct mbuf *routehash[RTHASHSIZ];
        !           208:        struct ifnet ifnet;
        !           209:        struct sockaddr_in *sin;
        !           210:        int first = 1, i, doinghost = 1;
        !           211: 
        !           212:        printf("---Ro_rt:");fflush(stdout);
        !           213: 
        !           214:        klseek(kmem, rt, 0);
        !           215:        read(kmem, &routentry, sizeof (routentry));
        !           216:        rt = &routentry;
        !           217:        sin = (struct sockaddr_in *)&rt->rt_dst;
        !           218:        printf("Dest:%s; ",
        !           219:            sin->sin_addr.s_addr ?
        !           220:                routename(sin->sin_addr) : "default");
        !           221:        sin = (struct sockaddr_in *)&rt->rt_gateway;
        !           222:        printf("\n\tGate:%s; ", routename(sin->sin_addr));
        !           223:        for (flags = name, p = bits; p->b_mask; p++)
        !           224:                if (p->b_mask & rt->rt_flags)
        !           225:                        *flags++ = p->b_val;
        !           226:        *flags = '\0';
        !           227:        printf("flag:%s; refc:%d; use:%d ", name,
        !           228:                rt->rt_refcnt, rt->rt_use);
        !           229:        if (rt->rt_ifp == 0) {
        !           230:                return;
        !           231:        }
        !           232:        klseek(kmem, rt->rt_ifp, 0);
        !           233:        read(kmem, &ifnet, sizeof (ifnet));
        !           234:        klseek(kmem, (int)ifnet.if_name, 0);
        !           235:        read(kmem, name, 16);
        !           236:        printf("interf:%s, unit:%d", name, ifnet.if_unit);
        !           237: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.