![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to route.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / netstat|
Return to route.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / netstat |
1.1 root 1: /*
2: * Copyright (c) 1983, 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)route.c 5.19 (Berkeley) 6/18/90";
22: #endif /* not lint */
23:
24: #include <sys/param.h>
25: #include <sys/socket.h>
26: #include <sys/mbuf.h>
27:
28: #include <net/if.h>
29: #define KERNEL
30: #include <net/route.h>
31: #undef KERNEL
32: #include <netinet/in.h>
33:
34: #include <netns/ns.h>
35:
36: #include <netdb.h>
37: #include <sys/kinfo.h>
38:
39: #include <stdio.h>
40: #include <string.h>
41:
42: extern int nflag;
43: extern char *routename(), *netname(), *ns_print(), *plural();
44: extern char *malloc();
45: #define kget(p, d) \
46: (kvm_read((off_t)(p), (char *)&(d), sizeof (d)))
47:
48: /*
49: * Definitions for showing gateway flags.
50: */
51: struct bits {
52: short b_mask;
53: char b_val;
54: } bits[] = {
55: { RTF_UP, 'U' },
56: { RTF_GATEWAY, 'G' },
57: { RTF_HOST, 'H' },
58: { RTF_DYNAMIC, 'D' },
59: { RTF_MODIFIED, 'M' },
60: { RTF_CLONING, 'C' },
61: { RTF_XRESOLVE, 'R' },
62: { RTF_LLINFO, 'L' },
63: { 0 }
64: };
65:
66: /*
67: * Print routing tables.
68: */
69: routepr(hostaddr, netaddr, hashsizeaddr, treeaddr)
70: off_t hostaddr, netaddr, hashsizeaddr, treeaddr;
71: {
72: struct mbuf mb;
73: register struct ortentry *rt;
74: register struct mbuf *m;
75: char name[16], *flags;
76: struct mbuf **routehash;
77: int hashsize;
78: int i, doinghost = 1;
79:
80: printf("Routing tables\n");
81: printf("%-16.16s %-18.18s %-6.6s %6.6s%8.8s %s\n",
82: "Destination", "Gateway",
83: "Flags", "Refs", "Use", "Interface");
84: if (treeaddr)
85: return treestuff(treeaddr);
86: if (hostaddr == 0) {
87: printf("rthost: symbol not in namelist\n");
88: return;
89: }
90: if (netaddr == 0) {
91: printf("rtnet: symbol not in namelist\n");
92: return;
93: }
94: if (hashsizeaddr == 0) {
95: printf("rthashsize: symbol not in namelist\n");
96: return;
97: }
98: kget(hashsizeaddr, hashsize);
99: routehash = (struct mbuf **)malloc( hashsize*sizeof (struct mbuf *) );
100: kvm_read(hostaddr, (char *)routehash, hashsize*sizeof (struct mbuf *));
101: again:
102: for (i = 0; i < hashsize; i++) {
103: if (routehash[i] == 0)
104: continue;
105: m = routehash[i];
106: while (m) {
107: kget(m, mb);
108: p_rtentry((struct rtentry *)(mb.m_dat));
109: m = mb.m_next;
110: }
111: }
112: if (doinghost) {
113: kvm_read(netaddr, (char *)routehash,
114: hashsize*sizeof (struct mbuf *));
115: doinghost = 0;
116: goto again;
117: }
118: free((char *)routehash);
119: return;
120: }
121:
122: static union {
123: struct sockaddr u_sa;
124: u_short u_data[128];
125: } pt_u;
126: static struct rtentry rtentry;
127:
128: int NewTree = 0;
129: treestuff(rtree)
130: off_t rtree;
131: {
132: struct radix_node_head *rnh, head;
133:
134: if (NewTree)
135: return(ntreestuff());
136: for (kget(rtree, rnh); rnh; rnh = head.rnh_next) {
137: kget(rnh, head);
138: if (head.rnh_af == 0) {
139: printf("Netmasks:\n");
140: p_tree(head.rnh_treetop, 0);
141: } else {
142: printf("\nRoute Tree for Protocol Family %d:\n",
143: head.rnh_af);
144: p_tree(head.rnh_treetop, 1);
145: }
146: }
147: }
148:
149: struct sockaddr *
150: kgetsa(dst)
151: register struct sockaddr *dst;
152: {
153: kget(dst, pt_u.u_sa);
154: if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa)) {
155: kvm_read((off_t)dst, pt_u.u_data, pt_u.u_sa.sa_len);
156: }
157: return (&pt_u.u_sa);
158: }
159:
160: p_tree(rn, do_rtent)
161: struct radix_node *rn;
162: {
163: struct radix_node rnode;
164: register u_short *s, *slim;
165: int len;
166:
167: again:
168: kget(rn, rnode);
169: if (rnode.rn_b < 0) {
170: if (rnode.rn_flags & RNF_ROOT)
171: printf("(root node)\n");
172: else if (do_rtent) {
173: kget(rn, rtentry);
174: p_rtentry(&rtentry);
175: } else {
176: p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
177: 0, 44);
178: putchar('\n');
179: }
180: if (rn = rnode.rn_dupedkey)
181: goto again;
182: } else {
183: p_tree(rnode.rn_l, do_rtent);
184: p_tree(rnode.rn_r, do_rtent);
185: }
186: }
187:
188: ntreestuff()
189: {
190: int needed;
191: char *buf, *next, *lim;
192: register struct rt_msghdr *rtm;
193:
194: if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
195: { perror("route-getkerninfo-estimate"); exit(1);}
196: if ((buf = malloc(needed)) == 0)
197: { printf("out of space\n"); exit(1);}
198: if (getkerninfo(KINFO_RT_DUMP, buf, &needed, 0) < 0)
199: { perror("actual retrieval of routing table"); exit(1);}
200: lim = buf + needed;
201: for (next = buf; next < lim; next += rtm->rtm_msglen) {
202: rtm = (struct rt_msghdr *)next;
203: np_rtentry(rtm);
204: }
205: }
206:
207: np_rtentry(rtm)
208: register struct rt_msghdr *rtm;
209: {
210: register struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
211: static int masks_done, old_af, banner_printed;
212: int af = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST;
213:
214: #ifdef notdef
215: /* for the moment, netmasks are skipped over */
216: if (!banner_printed) {
217: printf("Netmasks:\n");
218: banner_printed = 1;
219: }
220: if (masks_done == 0) {
221: if (rtm->rtm_addrs != RTA_DST ) {
222: masks_done = 1;
223: af = sa->sa_family;
224: }
225: } else
226: #endif
227: af = sa->sa_family;
228: if (af != old_af) {
229: printf("\nRoute Tree for Protocol Family %d:\n", af);
230: old_af = af;
231: }
232: if (rtm->rtm_addrs == RTA_DST)
233: p_sockaddr(sa, 0, 36);
234: else {
235: p_sockaddr(sa, rtm->rtm_flags, 16);
236: if (sa->sa_len == 0)
237: sa->sa_len = sizeof(long);
238: sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
239: p_sockaddr(sa, 0, 18);
240: }
241: p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
242: putchar('\n');
243: }
244:
245: p_sockaddr(sa, flags, width)
246: struct sockaddr *sa;
247: int flags, width;
248: {
249: char format[20], workbuf[128], *cp, *cplim;
250: register char *cpout;
251:
252: switch(sa->sa_family) {
253: case AF_INET:
254: {
255: register struct sockaddr_in *sin = (struct sockaddr_in *)sa;
256:
257: cp = (sin->sin_addr.s_addr == 0) ? "default" :
258: ((flags & RTF_HOST) ?
259: routename(sin->sin_addr) : netname(sin->sin_addr, 0L));
260: }
261: break;
262:
263: case AF_NS:
264: cp = ns_print((struct sockaddr_ns *)sa);
265: break;
266:
267: default:
268: {
269: register u_short *s = ((u_short *)sa->sa_data),
270: *slim = ((sa->sa_len + 1)/2) + s;
271:
272: cp = workbuf;
273: cplim = cp + sizeof(workbuf) - 6;
274: cp += sprintf(cp, "(%d)", sa->sa_family);
275: while (s < slim && cp < cplim)
276: cp += sprintf(cp, "%x ", *s++);
277: cp = workbuf;
278: }
279: }
280: if (nflag)
281: printf("%-*s ", width, cp);
282: else
283: printf("%-*.*s ", width, width, cp);
284: }
285:
286: p_flags(f, format)
287: register int f;
288: char *format;
289: {
290: char name[33], *flags;
291: register struct bits *p = bits;
292: for (flags = name; p->b_mask; p++)
293: if (p->b_mask & f)
294: *flags++ = p->b_val;
295: *flags = '\0';
296: printf(format, name);
297: }
298:
299: p_rtentry(rt)
300: register struct rtentry *rt;
301: {
302: char name[16];
303: register struct sockaddr *sa;
304: struct ifnet ifnet;
305:
306: p_sockaddr(kgetsa(rt_key(rt)), rt->rt_flags, 16);
307: p_sockaddr(kgetsa(rt->rt_gateway), 0, 18);
308: p_flags(rt->rt_flags, "%-6.6s ");
309: printf("%6d %8d ", rt->rt_refcnt, rt->rt_use);
310: if (rt->rt_ifp == 0) {
311: putchar('\n');
312: return;
313: }
314: kget(rt->rt_ifp, ifnet);
315: kvm_read((off_t)ifnet.if_name, name, 16);
316: printf(" %.15s%d\n", name, ifnet.if_unit);
317: }
318:
319: p_ortentry(rt)
320: register struct ortentry *rt;
321: {
322: char name[16], *flags;
323: register struct bits *p;
324: register struct sockaddr_in *sin;
325: struct ifnet ifnet;
326:
327: p_sockaddr(&rt->rt_dst, rt->rt_flags, 16);
328: p_sockaddr(&rt->rt_gateway, 0, 18);
329: p_flags(rt->rt_flags, "%-6.6s ");
330: printf("%6d %8d ", rt->rt_refcnt, rt->rt_use);
331: if (rt->rt_ifp == 0) {
332: putchar('\n');
333: return;
334: }
335: kget(rt->rt_ifp, ifnet);
336: kvm_read((off_t)ifnet.if_name, name, 16);
337: printf(" %.15s%d\n", name, ifnet.if_unit);
338: }
339:
340: char *
341: routename(in)
342: struct in_addr in;
343: {
344: register char *cp;
345: static char line[MAXHOSTNAMELEN + 1];
346: struct hostent *hp;
347: static char domain[MAXHOSTNAMELEN + 1];
348: static int first = 1;
349: char *index();
350:
351: if (first) {
352: first = 0;
353: if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
354: (cp = index(domain, '.')))
355: (void) strcpy(domain, cp + 1);
356: else
357: domain[0] = 0;
358: }
359: cp = 0;
360: if (!nflag) {
361: hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
362: AF_INET);
363: if (hp) {
364: if ((cp = index(hp->h_name, '.')) &&
365: !strcmp(cp + 1, domain))
366: *cp = 0;
367: cp = hp->h_name;
368: }
369: }
370: if (cp)
371: strncpy(line, cp, sizeof(line) - 1);
372: else {
373: #define C(x) ((x) & 0xff)
374: in.s_addr = ntohl(in.s_addr);
375: sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
376: C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
377: }
378: return (line);
379: }
380:
381: /*
382: * Return the name of the network whose address is given.
383: * The address is assumed to be that of a net or subnet, not a host.
384: */
385: char *
386: netname(in, mask)
387: struct in_addr in;
388: u_long mask;
389: {
390: char *cp = 0;
391: static char line[MAXHOSTNAMELEN + 1];
392: struct netent *np = 0;
393: u_long net;
394: register i;
395: int subnetshift;
396:
397: i = ntohl(in.s_addr);
398: if (!nflag && i) {
399: if (mask == 0) {
400: if (IN_CLASSA(i)) {
401: mask = IN_CLASSA_NET;
402: subnetshift = 8;
403: } else if (IN_CLASSB(i)) {
404: mask = IN_CLASSB_NET;
405: subnetshift = 8;
406: } else {
407: mask = IN_CLASSC_NET;
408: subnetshift = 4;
409: }
410: /*
411: * If there are more bits than the standard mask
412: * would suggest, subnets must be in use.
413: * Guess at the subnet mask, assuming reasonable
414: * width subnet fields.
415: */
416: while (i &~ mask)
417: mask = (long)mask >> subnetshift;
418: }
419: net = i & mask;
420: while ((mask & 1) == 0)
421: mask >>= 1, net >>= 1;
422: np = getnetbyaddr(net, AF_INET);
423: if (np)
424: cp = np->n_name;
425: }
426: if (cp)
427: strncpy(line, cp, sizeof(line) - 1);
428: else if ((i & 0xffffff) == 0)
429: sprintf(line, "%u", C(i >> 24));
430: else if ((i & 0xffff) == 0)
431: sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
432: else if ((i & 0xff) == 0)
433: sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
434: else
435: sprintf(line, "%u.%u.%u.%u", C(i >> 24),
436: C(i >> 16), C(i >> 8), C(i));
437: return (line);
438: }
439:
440: /*
441: * Print routing statistics
442: */
443: rt_stats(off)
444: off_t off;
445: {
446: struct rtstat rtstat;
447:
448: if (off == 0) {
449: printf("rtstat: symbol not in namelist\n");
450: return;
451: }
452: kvm_read(off, (char *)&rtstat, sizeof (rtstat));
453: printf("routing:\n");
454: printf("\t%u bad routing redirect%s\n",
455: rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
456: printf("\t%u dynamically created route%s\n",
457: rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
458: printf("\t%u new gateway%s due to redirects\n",
459: rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
460: printf("\t%u destination%s found unreachable\n",
461: rtstat.rts_unreach, plural(rtstat.rts_unreach));
462: printf("\t%u use%s of a wildcard route\n",
463: rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
464: }
465: short ns_nullh[] = {0,0,0};
466: short ns_bh[] = {-1,-1,-1};
467:
468: char *
469: ns_print(sns)
470: struct sockaddr_ns *sns;
471: {
472: struct ns_addr work;
473: union { union ns_net net_e; u_long long_e; } net;
474: u_short port;
475: static char mybuf[50], cport[10], chost[25];
476: char *host = "";
477: register char *p; register u_char *q;
478:
479: work = sns->sns_addr;
480: port = ntohs(work.x_port);
481: work.x_port = 0;
482: net.net_e = work.x_net;
483: if (ns_nullhost(work) && net.long_e == 0) {
484: if (port ) {
485: sprintf(mybuf, "*.%xH", port);
486: upHex(mybuf);
487: } else
488: sprintf(mybuf, "*.*");
489: return (mybuf);
490: }
491:
492: if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) {
493: host = "any";
494: } else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
495: host = "*";
496: } else {
497: q = work.x_host.c_host;
498: sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
499: q[0], q[1], q[2], q[3], q[4], q[5]);
500: for (p = chost; *p == '0' && p < chost + 12; p++);
501: host = p;
502: }
503: if (port)
504: sprintf(cport, ".%xH", htons(port));
505: else
506: *cport = 0;
507:
508: sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
509: upHex(mybuf);
510: return(mybuf);
511: }
512:
513: char *
514: ns_phost(sns)
515: struct sockaddr_ns *sns;
516: {
517: struct sockaddr_ns work;
518: static union ns_net ns_zeronet;
519: char *p;
520:
521: work = *sns;
522: work.sns_addr.x_port = 0;
523: work.sns_addr.x_net = ns_zeronet;
524:
525: p = ns_print(&work);
526: if (strncmp("0H.", p, 3) == 0) p += 3;
527: return(p);
528: }
529: upHex(p0)
530: char *p0;
531: {
532: register char *p = p0;
533: for (; *p; p++) switch (*p) {
534:
535: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
536: *p += ('A' - 'a');
537: }
538: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.