Annotation of src/sbin/route/route.c, Revision 1.66
1.66 ! christos 1: /* $NetBSD: route.c,v 1.65 2003/06/03 04:41:42 itojun Exp $ */
1.11 cgd 2:
1.1 cgd 3: /*
1.7 mycroft 4: * Copyright (c) 1983, 1989, 1991, 1993
5: * The Regents of the University of California. All rights reserved.
1.1 cgd 6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by the University of
18: * California, Berkeley and its contributors.
19: * 4. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: */
35:
1.23 lukem 36: #include <sys/cdefs.h>
1.1 cgd 37: #ifndef lint
1.23 lukem 38: __COPYRIGHT("@(#) Copyright (c) 1983, 1989, 1991, 1993\n\
39: The Regents of the University of California. All rights reserved.\n");
1.1 cgd 40: #endif /* not lint */
41:
42: #ifndef lint
1.11 cgd 43: #if 0
1.24 lukem 44: static char sccsid[] = "@(#)route.c 8.6 (Berkeley) 4/28/95";
1.11 cgd 45: #else
1.66 ! christos 46: __RCSID("$NetBSD: route.c,v 1.65 2003/06/03 04:41:42 itojun Exp $");
1.11 cgd 47: #endif
1.1 cgd 48: #endif /* not lint */
49:
50: #include <sys/param.h>
51: #include <sys/file.h>
52: #include <sys/socket.h>
53: #include <sys/ioctl.h>
54: #include <sys/mbuf.h>
1.7 mycroft 55: #include <sys/sysctl.h>
1.1 cgd 56:
1.7 mycroft 57: #include <net/if.h>
1.1 cgd 58: #include <net/route.h>
59: #include <net/if_dl.h>
60: #include <netinet/in.h>
1.19 christos 61: #include <netatalk/at.h>
1.1 cgd 62: #include <netns/ns.h>
63: #include <netiso/iso.h>
64: #include <netccitt/x25.h>
65: #include <arpa/inet.h>
66: #include <netdb.h>
67:
68: #include <errno.h>
69: #include <unistd.h>
70: #include <stdio.h>
71: #include <ctype.h>
72: #include <stdlib.h>
73: #include <string.h>
1.28 kleink 74: #include <time.h>
1.1 cgd 75: #include <paths.h>
1.26 christos 76: #include <err.h>
1.1 cgd 77:
78: #include "keywords.h"
1.19 christos 79: #include "extern.h"
80:
81: typedef union sockunion *sup;
82:
83: int main __P((int, char **));
1.52 christos 84: static void usage __P((char *)) __attribute__((__noreturn__));
1.19 christos 85: static char *any_ntoa __P((const struct sockaddr *));
86: static void set_metric __P((char *, int));
1.52 christos 87: static int newroute __P((int, char **));
1.27 ross 88: static void inet_makenetandmask __P((u_int32_t, struct sockaddr_in *));
1.36 itojun 89: #ifdef INET6
1.54 itojun 90: static int inet6_makenetandmask __P((struct sockaddr_in6 *));
1.36 itojun 91: #endif
1.19 christos 92: static int getaddr __P((int, char *, struct hostent **));
1.52 christos 93: static int flushroutes __P((int, char *[]));
1.19 christos 94: #ifndef SMALL
1.31 itojun 95: static int prefixlen __P((char *));
1.19 christos 96: static int x25_makemask __P((void));
97: static void interfaces __P((void));
98: static void monitor __P((void));
99: static void print_getmsg __P((struct rt_msghdr *, int));
1.53 christos 100: static const char *linkstate __P((struct if_msghdr *));
101: #endif /* SMALL */
1.19 christos 102: static int rtmsg __P((int, int ));
103: static void mask_addr __P((void));
104: static void print_rtmsg __P((struct rt_msghdr *, int));
105: static void pmsg_common __P((struct rt_msghdr *));
106: static void pmsg_addrs __P((char *, int));
107: static void bprintf __P((FILE *, int, u_char *));
108: static int keyword __P((char *));
109: static void sodump __P((sup, char *));
110: static void sockaddr __P((char *, struct sockaddr *));
1.1 cgd 111:
112: union sockunion {
113: struct sockaddr sa;
114: struct sockaddr_in sin;
1.31 itojun 115: #ifdef INET6
116: struct sockaddr_in6 sin6;
117: #endif
1.19 christos 118: struct sockaddr_at sat;
1.30 lukem 119: struct sockaddr_dl sdl;
120: #ifndef SMALL
1.1 cgd 121: struct sockaddr_ns sns;
122: struct sockaddr_iso siso;
123: struct sockaddr_x25 sx25;
1.30 lukem 124: #endif /* SMALL */
1.1 cgd 125: } so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp;
126:
1.18 carrel 127: int pid, rtm_addrs;
1.51 lukem 128: int sock;
1.19 christos 129: int forcehost, forcenet, doflush, nflag, af, qflag, tflag;
1.1 cgd 130: int iflag, verbose, aflen = sizeof (struct sockaddr_in);
1.50 atatat 131: int locking, lockrest, debugonly, shortoutput, rv;
1.1 cgd 132: struct rt_metrics rt_metrics;
1.27 ross 133: u_int32_t rtm_inits;
1.44 christos 134: short ns_nullh[] = {0,0,0};
135: short ns_bh[] = {-1,-1,-1};
136:
1.1 cgd 137:
1.23 lukem 138: static void
1.1 cgd 139: usage(cp)
140: char *cp;
141: {
1.45 cgd 142:
1.1 cgd 143: if (cp)
1.26 christos 144: warnx("botched keyword: %s", cp);
1.1 cgd 145: (void) fprintf(stderr,
1.50 atatat 146: "Usage: %s [ -fnqvs ] cmd [[ -<qualifers> ] args ]\n",
1.45 cgd 147: getprogname());
1.1 cgd 148: exit(1);
149: /* NOTREACHED */
150: }
151:
152: #define ROUNDUP(a) \
1.33 itojun 153: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
1.1 cgd 154: #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
155:
1.7 mycroft 156: int
1.1 cgd 157: main(argc, argv)
158: int argc;
159: char **argv;
160: {
161: int ch;
162:
163: if (argc < 2)
1.26 christos 164: usage(NULL);
1.1 cgd 165:
1.50 atatat 166: while ((ch = getopt(argc, argv, "fnqvdts")) != -1)
1.1 cgd 167: switch(ch) {
1.30 lukem 168: case 'f':
169: doflush = 1;
170: break;
1.1 cgd 171: case 'n':
172: nflag = 1;
173: break;
174: case 'q':
175: qflag = 1;
176: break;
177: case 'v':
178: verbose = 1;
179: break;
180: case 't':
181: tflag = 1;
182: break;
1.7 mycroft 183: case 'd':
184: debugonly = 1;
185: break;
1.50 atatat 186: case 's':
187: shortoutput = 1;
188: break;
1.1 cgd 189: case '?':
190: default:
1.26 christos 191: usage(NULL);
1.52 christos 192: /*NOTREACHED*/
1.1 cgd 193: }
194: argc -= optind;
195: argv += optind;
196:
197: pid = getpid();
198: if (tflag)
1.51 lukem 199: sock = open("/dev/null", O_WRONLY, 0);
1.1 cgd 200: else
1.51 lukem 201: sock = socket(PF_ROUTE, SOCK_RAW, 0);
202: if (sock < 0)
1.26 christos 203: err(1, "socket");
1.17 gwr 204:
1.30 lukem 205: if (*argv == NULL) {
206: if (doflush)
207: ch = K_FLUSH;
208: else
209: goto no_cmd;
210: } else
211: ch = keyword(*argv);
212:
213: switch (ch) {
1.17 gwr 214: #ifndef SMALL
215: case K_GET:
216: #endif /* SMALL */
217: case K_CHANGE:
218: case K_ADD:
219: case K_DELETE:
1.30 lukem 220: if (doflush)
1.52 christos 221: (void)flushroutes(1, argv);
222: return newroute(argc, argv);
1.17 gwr 223:
224: case K_SHOW:
225: show(argc, argv);
1.52 christos 226: return 0;
1.17 gwr 227:
228: #ifndef SMALL
229: case K_MONITOR:
230: monitor();
1.52 christos 231: return 0;
1.17 gwr 232:
1.30 lukem 233: #endif /* SMALL */
1.17 gwr 234: case K_FLUSH:
1.52 christos 235: return flushroutes(argc, argv);
1.17 gwr 236:
237: no_cmd:
238: default:
239: usage(*argv);
1.52 christos 240: /*NOTREACHED*/
1.17 gwr 241: }
1.1 cgd 242: }
243:
244: /*
245: * Purge all entries in the routing tables not
246: * associated with network interfaces.
247: */
1.52 christos 248: static int
1.1 cgd 249: flushroutes(argc, argv)
250: int argc;
251: char *argv[];
252: {
1.7 mycroft 253: size_t needed;
254: int mib[6], rlen, seqno;
1.1 cgd 255: char *buf, *next, *lim;
1.23 lukem 256: struct rt_msghdr *rtm;
1.1 cgd 257:
1.30 lukem 258: af = 0;
1.51 lukem 259: shutdown(sock, SHUT_RD); /* Don't want to read back our messages */
1.1 cgd 260: if (argc > 1) {
261: argv++;
262: if (argc == 2 && **argv == '-')
263: switch (keyword(*argv + 1)) {
264: case K_INET:
265: af = AF_INET;
266: break;
1.31 itojun 267: #ifdef INET6
268: case K_INET6:
269: af = AF_INET6;
270: break;
271: #endif
1.66 ! christos 272: #ifndef SMALL
1.19 christos 273: case K_ATALK:
274: af = AF_APPLETALK;
275: break;
1.1 cgd 276: case K_XNS:
277: af = AF_NS;
278: break;
1.30 lukem 279: #endif /* SMALL */
1.1 cgd 280: case K_LINK:
281: af = AF_LINK;
282: break;
1.30 lukem 283: #ifndef SMALL
1.1 cgd 284: case K_ISO:
285: case K_OSI:
286: af = AF_ISO;
287: break;
288: case K_X25:
289: af = AF_CCITT;
1.30 lukem 290: #endif /* SMALL */
1.1 cgd 291: default:
292: goto bad;
293: } else
294: bad: usage(*argv);
295: }
1.7 mycroft 296: mib[0] = CTL_NET;
297: mib[1] = PF_ROUTE;
298: mib[2] = 0; /* protocol */
299: mib[3] = 0; /* wildcard address family */
300: mib[4] = NET_RT_DUMP;
301: mib[5] = 0; /* no flags */
302: if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
1.26 christos 303: err(1, "route-sysctl-estimate");
1.22 thorpej 304: if (needed == 0)
1.52 christos 305: return 0;
1.1 cgd 306: if ((buf = malloc(needed)) == NULL)
1.26 christos 307: err(1, "malloc");
1.7 mycroft 308: if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
1.26 christos 309: err(1, "actual retrieval of routing table");
1.7 mycroft 310: lim = buf + needed;
1.17 gwr 311: if (verbose) {
1.7 mycroft 312: (void) printf("Examining routing table from sysctl\n");
1.17 gwr 313: if (af) printf("(address family %s)\n", (*argv + 1));
314: }
1.1 cgd 315: seqno = 0; /* ??? */
316: for (next = buf; next < lim; next += rtm->rtm_msglen) {
317: rtm = (struct rt_msghdr *)next;
1.7 mycroft 318: if (verbose)
319: print_rtmsg(rtm, rtm->rtm_msglen);
1.1 cgd 320: if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
321: continue;
322: if (af) {
323: struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
324:
325: if (sa->sa_family != af)
326: continue;
327: }
1.7 mycroft 328: if (debugonly)
329: continue;
1.1 cgd 330: rtm->rtm_type = RTM_DELETE;
331: rtm->rtm_seq = seqno;
1.51 lukem 332: rlen = write(sock, next, rtm->rtm_msglen);
1.1 cgd 333: if (rlen < (int)rtm->rtm_msglen) {
1.26 christos 334: warn("write to routing socket, got %d for rlen", rlen);
1.1 cgd 335: break;
336: }
337: seqno++;
338: if (qflag)
339: continue;
340: if (verbose)
341: print_rtmsg(rtm, rlen);
342: else {
343: struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
1.49 atatat 344: (void) printf("%-20.20s ",
345: routename(sa, NULL, rtm->rtm_flags));
1.33 itojun 346: sa = (struct sockaddr *)(ROUNDUP(sa->sa_len) + (char *)sa);
1.49 atatat 347: (void) printf("%-20.20s ",
348: routename(sa, NULL, RTF_HOST));
1.1 cgd 349: (void) printf("done\n");
350: }
351: }
1.52 christos 352: return 0;
1.1 cgd 353: }
1.17 gwr 354:
355:
356: static char hexlist[] = "0123456789abcdef";
357:
1.19 christos 358: static char *
1.17 gwr 359: any_ntoa(sa)
360: const struct sockaddr *sa;
361: {
362: static char obuf[64];
363: const char *in;
364: char *out;
365: int len;
366:
367: len = sa->sa_len;
368: in = sa->sa_data;
369: out = obuf;
370:
371: do {
372: *out++ = hexlist[(*in >> 4) & 15];
373: *out++ = hexlist[(*in++) & 15];
374: *out++ = '.';
375: } while (--len > 0);
376: out[-1] = '\0';
377: return obuf;
378: }
379:
1.7 mycroft 380:
1.49 atatat 381: int
1.51 lukem 382: netmask_length(nm, family)
1.49 atatat 383: struct sockaddr *nm;
1.51 lukem 384: int family;
1.49 atatat 385: {
386: static int
387: /* number of bits in a nibble */
388: _t[] = { 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4 },
389: /* good nibbles are 1111, 1110, 1100, 1000, 0000 */
390: _g[] = { 1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,1 };
391: int mask, good, zeroes, maskbytes, bit, i;
392: unsigned char *maskdata;
393:
394: if (nm == NULL)
395: return 0;
396:
397: mask = 0;
398: good = 1;
399: zeroes = 0;
400:
1.51 lukem 401: switch (family) {
1.49 atatat 402: case AF_INET: {
1.51 lukem 403: struct sockaddr_in *nsin = (struct sockaddr_in *)nm;
404: maskdata = (unsigned char *) &nsin->sin_addr;
405: maskbytes = nsin->sin_len -
406: ((caddr_t)&nsin->sin_addr - (caddr_t)nsin);
1.49 atatat 407: break;
408: }
409: case AF_INET6: {
410: struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nm;
411: maskdata = (unsigned char *) &sin6->sin6_addr;
412: maskbytes = sin6->sin6_len -
413: ((caddr_t)&sin6->sin6_addr - (caddr_t)sin6);
414: break;
415: }
416: default:
417: return 0;
418: }
419:
420: /*
421: * Count the bits in the nibbles of the mask, and marking the
422: * netmask as not good (or at best, non-standard and very
423: * discouraged, in the case of AF_INET) if we find either of
424: * a nibble with non-contiguous bits, or a non-zero nibble
425: * after we've found a zero nibble.
426: */
427: for (i = 0; i < maskbytes; i++) {
428: /* high nibble */
429: mask += bit = _t[maskdata[i] >> 4];
430: good &= _g[maskdata[i] >> 4];
431: if (zeroes && bit)
432: good = 0;
433: if (bit == 0)
434: zeroes = 1;
435: /* low nibble */
436: mask += bit = _t[maskdata[i] & 0xf];
437: good &= _g[maskdata[i] & 0xf];
438: if (zeroes && bit)
439: good = 0;
440: if (bit == 0)
441: zeroes = 1;
442: }
443:
444: /*
445: * Always return the number of bits found, but as a negative
446: * if the mask wasn't one we like.
447: */
448: return good ? mask : -mask;
449: }
450:
451: char *
452: netmask_string(mask, len)
453: struct sockaddr *mask;
454: int len;
455: {
456: static char smask[16];
457:
458: if (len >= 0)
459: snprintf(smask, sizeof(smask), "%d", len);
460: else {
461: /* XXX AF_INET only?! */
1.51 lukem 462: struct sockaddr_in nsin;
1.49 atatat 463:
1.51 lukem 464: memset(&nsin, 0, sizeof(nsin));
465: memcpy(&nsin, mask, mask->sa_len);
466: snprintf(smask, sizeof(smask), "%s", inet_ntoa(nsin.sin_addr));
1.49 atatat 467: }
468:
469: return smask;
470: }
471:
472:
1.1 cgd 473: char *
1.49 atatat 474: routename(sa, nm, flags)
475: struct sockaddr *sa, *nm;
476: int flags;
1.1 cgd 477: {
1.23 lukem 478: char *cp;
1.1 cgd 479: static char line[50];
480: struct hostent *hp;
481: static char domain[MAXHOSTNAMELEN + 1];
482: static int first = 1;
1.17 gwr 483: struct in_addr in;
1.49 atatat 484: int nml;
485:
486: if ((flags & RTF_HOST) == 0)
487: return netname(sa, nm);
1.1 cgd 488:
489: if (first) {
490: first = 0;
491: if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
1.64 itojun 492: (cp = strchr(domain, '.')))
493: (void)strlcpy(domain, cp + 1, sizeof(domain));
494: else
1.1 cgd 495: domain[0] = 0;
496: }
1.7 mycroft 497:
1.64 itojun 498: if (sa->sa_len == 0)
499: strlcpy(line, "default", sizeof(line));
500: else switch (sa->sa_family) {
1.1 cgd 501:
502: case AF_INET:
503: in = ((struct sockaddr_in *)sa)->sin_addr;
1.49 atatat 504: nml = netmask_length(nm, AF_INET);
1.1 cgd 505:
506: cp = 0;
1.49 atatat 507: if (in.s_addr == INADDR_ANY || sa->sa_len < 4) {
508: if (nml == 0)
509: cp = "default";
510: else {
511: static char notdefault[sizeof(NOTDEFSTRING)];
512:
513: snprintf(notdefault, sizeof(notdefault),
514: "0.0.0.0/%s", netmask_string(nm, nml));
515: cp = notdefault;
516: }
517: }
1.1 cgd 518: if (cp == 0 && !nflag) {
519: hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
520: AF_INET);
521: if (hp) {
1.8 mycroft 522: if ((cp = strchr(hp->h_name, '.')) &&
1.1 cgd 523: !strcmp(cp + 1, domain))
524: *cp = 0;
525: cp = hp->h_name;
526: }
527: }
528: if (cp)
1.64 itojun 529: (void)strlcpy(line, cp, sizeof(line));
1.17 gwr 530: else
1.64 itojun 531: (void)strlcpy(line, inet_ntoa(in), sizeof(line));
1.1 cgd 532: break;
533:
1.17 gwr 534: case AF_LINK:
535: return (link_ntoa((struct sockaddr_dl *)sa));
536:
537: #ifndef SMALL
1.31 itojun 538: #ifdef INET6
539: case AF_INET6:
1.36 itojun 540: {
541: struct sockaddr_in6 sin6;
542: int niflags;
1.31 itojun 543:
1.36 itojun 544: #ifdef NI_WITHSCOPEID
545: niflags = NI_WITHSCOPEID;
546: #else
547: niflags = 0;
548: #endif
549: if (nflag)
550: niflags |= NI_NUMERICHOST;
551: memset(&sin6, 0, sizeof(sin6));
552: memcpy(&sin6, sa, sa->sa_len);
553: sin6.sin6_len = sizeof(struct sockaddr_in6);
554: sin6.sin6_family = AF_INET6;
555: #ifdef __KAME__
556: if (sa->sa_len == sizeof(struct sockaddr_in6) &&
1.37 itojun 557: (IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr) ||
558: IN6_IS_ADDR_MC_LINKLOCAL(&sin6.sin6_addr)) &&
1.36 itojun 559: sin6.sin6_scope_id == 0) {
560: sin6.sin6_scope_id =
561: ntohs(*(u_int16_t *)&sin6.sin6_addr.s6_addr[2]);
562: sin6.sin6_addr.s6_addr[2] = 0;
563: sin6.sin6_addr.s6_addr[3] = 0;
564: }
565: #endif
1.49 atatat 566: nml = netmask_length(nm, AF_INET6);
567: if (IN6_IS_ADDR_UNSPECIFIED(&sin6.sin6_addr)) {
1.64 itojun 568: if (nml == 0)
569: strlcpy(line, "::", sizeof(line));
1.49 atatat 570: else
571: /* noncontiguous never happens in ipv6 */
572: snprintf(line, sizeof(line), "::/%d", nml);
573: }
574:
575: else if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
1.36 itojun 576: line, sizeof(line), NULL, 0, niflags) != 0)
1.64 itojun 577: strlcpy(line, "invalid", sizeof(line));
1.36 itojun 578: break;
1.31 itojun 579: }
580: #endif
581:
1.1 cgd 582: case AF_NS:
583: return (ns_print((struct sockaddr_ns *)sa));
584:
585: case AF_ISO:
1.20 mrg 586: (void)snprintf(line, sizeof line, "iso %s",
1.1 cgd 587: iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr));
588: break;
1.19 christos 589:
590: case AF_APPLETALK:
591: (void) snprintf(line, sizeof(line), "atalk %d.%d",
592: ((struct sockaddr_at *)sa)->sat_addr.s_net,
593: ((struct sockaddr_at *)sa)->sat_addr.s_node);
594: break;
1.66 ! christos 595: #endif /* SMALL */
1.1 cgd 596:
597: default:
1.20 mrg 598: (void)snprintf(line, sizeof line, "(%d) %s",
1.17 gwr 599: sa->sa_family, any_ntoa(sa));
600: break;
1.1 cgd 601:
602: }
603: return (line);
604: }
605:
606: /*
607: * Return the name of the network whose address is given.
608: * The address is assumed to be that of a net or subnet, not a host.
609: */
610: char *
1.49 atatat 611: netname(sa, nm)
612: struct sockaddr *sa, *nm;
1.1 cgd 613: {
614: char *cp = 0;
615: static char line[50];
616: struct netent *np = 0;
1.27 ross 617: u_int32_t net, mask;
618: u_int32_t i;
1.49 atatat 619: int subnetshift, nml;
1.17 gwr 620: struct in_addr in;
1.1 cgd 621:
622: switch (sa->sa_family) {
623:
624: case AF_INET:
625: in = ((struct sockaddr_in *)sa)->sin_addr;
1.17 gwr 626: i = ntohl(in.s_addr);
1.49 atatat 627: nml = netmask_length(nm, AF_INET);
628: if (i == 0) {
629: if (nml == 0)
630: cp = "default";
631: else {
632: static char notdefault[sizeof(NOTDEFSTRING)];
633:
634: snprintf(notdefault, sizeof(notdefault),
635: "0.0.0.0/%s", netmask_string(nm, nml));
636: cp = notdefault;
637: }
638: }
1.1 cgd 639: else if (!nflag) {
640: if (IN_CLASSA(i)) {
641: mask = IN_CLASSA_NET;
642: subnetshift = 8;
643: } else if (IN_CLASSB(i)) {
644: mask = IN_CLASSB_NET;
645: subnetshift = 8;
646: } else {
647: mask = IN_CLASSC_NET;
648: subnetshift = 4;
649: }
650: /*
651: * If there are more bits than the standard mask
652: * would suggest, subnets must be in use.
653: * Guess at the subnet mask, assuming reasonable
654: * width subnet fields.
655: */
1.17 gwr 656: while (i &~ mask)
1.27 ross 657: mask = (int32_t)mask >> subnetshift;
1.17 gwr 658: net = i & mask;
1.1 cgd 659: while ((mask & 1) == 0)
660: mask >>= 1, net >>= 1;
661: np = getnetbyaddr(net, AF_INET);
662: if (np)
663: cp = np->n_name;
664: }
1.64 itojun 665: if (cp)
666: (void)strlcpy(line, cp, sizeof(line));
667: else {
1.17 gwr 668: #if 0 /* XXX - This is silly... */
669: #define C(x) ((x) & 0xff)
670: if ((i & 0xffffff) == 0)
1.20 mrg 671: (void)snprintf(line, sizeof line, "%u",
672: C(i >> 24));
1.17 gwr 673: else if ((i & 0xffff) == 0)
1.20 mrg 674: (void)snprintf(line, sizeof line, "%u.%u",
675: C(i >> 24), C(i >> 16));
1.17 gwr 676: else if ((i & 0xff) == 0)
1.20 mrg 677: (void)snprintf(line, sizeof line, "%u.%u.%u",
678: C(i >> 24), C(i >> 16), C(i >> 8));
1.17 gwr 679: else
1.20 mrg 680: (void)snprintf(line, sizeof line, "%u.%u.%u.%u",
681: C(i >> 24), C(i >> 16), C(i >> 8), C(i));
1.17 gwr 682: #undef C
683: #else /* XXX */
1.64 itojun 684: (void)strlcpy(line, inet_ntoa(in), sizeof(line));
1.17 gwr 685: #endif /* XXX */
1.20 mrg 686: }
1.1 cgd 687: break;
688:
1.17 gwr 689: case AF_LINK:
690: return (link_ntoa((struct sockaddr_dl *)sa));
691:
692: #ifndef SMALL
1.31 itojun 693: #ifdef INET6
694: case AF_INET6:
1.36 itojun 695: {
696: struct sockaddr_in6 sin6;
697: int niflags;
1.31 itojun 698:
1.36 itojun 699: #ifdef NI_WITHSCOPEID
700: niflags = NI_WITHSCOPEID;
701: #else
702: niflags = 0;
703: #endif
704: if (nflag)
705: niflags |= NI_NUMERICHOST;
706: memset(&sin6, 0, sizeof(sin6));
707: memcpy(&sin6, sa, sa->sa_len);
708: sin6.sin6_len = sizeof(struct sockaddr_in6);
709: sin6.sin6_family = AF_INET6;
710: #ifdef __KAME__
711: if (sa->sa_len == sizeof(struct sockaddr_in6) &&
1.37 itojun 712: (IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr) ||
713: IN6_IS_ADDR_MC_LINKLOCAL(&sin6.sin6_addr)) &&
1.36 itojun 714: sin6.sin6_scope_id == 0) {
715: sin6.sin6_scope_id =
716: ntohs(*(u_int16_t *)&sin6.sin6_addr.s6_addr[2]);
717: sin6.sin6_addr.s6_addr[2] = 0;
718: sin6.sin6_addr.s6_addr[3] = 0;
719: }
720: #endif
1.49 atatat 721: nml = netmask_length(nm, AF_INET6);
722: if (IN6_IS_ADDR_UNSPECIFIED(&sin6.sin6_addr)) {
1.64 itojun 723: if (nml == 0)
724: strlcpy(line, "::", sizeof(line));
1.49 atatat 725: else
726: /* noncontiguous never happens in ipv6 */
727: snprintf(line, sizeof(line), "::/%d", nml);
728: }
729:
730: else if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
1.36 itojun 731: line, sizeof(line), NULL, 0, niflags) != 0)
1.64 itojun 732: strlcpy(line, "invalid", sizeof(line));
1.36 itojun 733: break;
1.31 itojun 734: }
735: #endif
736:
1.1 cgd 737: case AF_NS:
738: return (ns_print((struct sockaddr_ns *)sa));
739:
740: case AF_ISO:
1.20 mrg 741: (void)snprintf(line, sizeof line, "iso %s",
1.1 cgd 742: iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr));
743: break;
1.19 christos 744:
745: case AF_APPLETALK:
746: (void) snprintf(line, sizeof(line), "atalk %d.%d",
747: ((struct sockaddr_at *)sa)->sat_addr.s_net,
748: ((struct sockaddr_at *)sa)->sat_addr.s_node);
749: break;
1.66 ! christos 750: #endif /* SMALL */
1.1 cgd 751:
752: default:
1.20 mrg 753: (void)snprintf(line, sizeof line, "af %d: %s",
1.17 gwr 754: sa->sa_family, any_ntoa(sa));
1.1 cgd 755: break;
756: }
757: return (line);
758: }
759:
1.19 christos 760: static void
1.1 cgd 761: set_metric(value, key)
762: char *value;
763: int key;
764: {
1.7 mycroft 765: int flag = 0;
1.1 cgd 766: u_long noval, *valp = &noval;
767:
768: switch (key) {
769: #define caseof(x, y, z) case x: valp = &rt_metrics.z; flag = y; break
770: caseof(K_MTU, RTV_MTU, rmx_mtu);
771: caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount);
772: caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire);
773: caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe);
774: caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe);
775: caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh);
776: caseof(K_RTT, RTV_RTT, rmx_rtt);
777: caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar);
778: }
779: rtm_inits |= flag;
780: if (lockrest || locking)
781: rt_metrics.rmx_locks |= flag;
782: if (locking)
783: locking = 0;
784: *valp = atoi(value);
785: }
786:
1.52 christos 787: static int
1.1 cgd 788: newroute(argc, argv)
789: int argc;
1.23 lukem 790: char **argv;
1.1 cgd 791: {
1.29 mycroft 792: char *cmd, *dest = "", *gateway = "";
1.51 lukem 793: const char *error;
1.7 mycroft 794: int ishost = 0, ret, attempts, oerrno, flags = RTF_STATIC;
1.1 cgd 795: int key;
796: struct hostent *hp = 0;
797:
798: cmd = argv[0];
1.30 lukem 799: af = 0;
1.1 cgd 800: if (*cmd != 'g')
1.51 lukem 801: shutdown(sock, SHUT_RD); /* Don't want to read back our messages */
1.1 cgd 802: while (--argc > 0) {
803: if (**(++argv)== '-') {
804: switch (key = keyword(1 + *argv)) {
1.17 gwr 805:
806: case K_SA:
807: af = PF_ROUTE;
808: aflen = sizeof(union sockunion);
809: break;
810:
1.66 ! christos 811: #ifndef SMALL
1.19 christos 812: case K_ATALK:
813: af = AF_APPLETALK;
814: aflen = sizeof(struct sockaddr_at);
815: break;
1.66 ! christos 816: #endif
1.19 christos 817:
1.17 gwr 818: case K_INET:
819: af = AF_INET;
820: aflen = sizeof(struct sockaddr_in);
821: break;
822:
1.31 itojun 823: #ifdef INET6
824: case K_INET6:
825: af = AF_INET6;
826: aflen = sizeof(struct sockaddr_in6);
827: break;
828: #endif
829:
1.1 cgd 830: case K_LINK:
831: af = AF_LINK;
832: aflen = sizeof(struct sockaddr_dl);
833: break;
1.17 gwr 834:
1.30 lukem 835: #ifndef SMALL
1.1 cgd 836: case K_OSI:
837: case K_ISO:
838: af = AF_ISO;
839: aflen = sizeof(struct sockaddr_iso);
840: break;
1.17 gwr 841:
1.1 cgd 842: case K_X25:
843: af = AF_CCITT;
844: aflen = sizeof(struct sockaddr_x25);
845: break;
1.17 gwr 846:
1.1 cgd 847: case K_XNS:
848: af = AF_NS;
849: aflen = sizeof(struct sockaddr_ns);
850: break;
1.30 lukem 851: #endif /* SMALL */
1.17 gwr 852:
1.1 cgd 853: case K_IFACE:
854: case K_INTERFACE:
855: iflag++;
1.14 mycroft 856: break;
1.7 mycroft 857: case K_NOSTATIC:
858: flags &= ~RTF_STATIC;
1.13 mycroft 859: break;
860: case K_LLINFO:
861: flags |= RTF_LLINFO;
1.1 cgd 862: break;
863: case K_LOCK:
864: locking = 1;
865: break;
866: case K_LOCKREST:
867: lockrest = 1;
868: break;
869: case K_HOST:
870: forcehost++;
871: break;
872: case K_REJECT:
873: flags |= RTF_REJECT;
874: break;
1.7 mycroft 875: case K_BLACKHOLE:
876: flags |= RTF_BLACKHOLE;
1.43 itojun 877: break;
878: case K_CLONED:
879: flags |= RTF_CLONED;
1.7 mycroft 880: break;
1.1 cgd 881: case K_PROTO1:
882: flags |= RTF_PROTO1;
883: break;
884: case K_PROTO2:
885: flags |= RTF_PROTO2;
886: break;
887: case K_CLONING:
888: flags |= RTF_CLONING;
889: break;
890: case K_XRESOLVE:
891: flags |= RTF_XRESOLVE;
892: break;
1.7 mycroft 893: case K_STATIC:
894: flags |= RTF_STATIC;
895: break;
1.1 cgd 896: case K_IFA:
1.21 thorpej 897: if (!--argc)
898: usage(1+*argv);
1.1 cgd 899: (void) getaddr(RTA_IFA, *++argv, 0);
900: break;
901: case K_IFP:
1.21 thorpej 902: if (!--argc)
903: usage(1+*argv);
1.1 cgd 904: (void) getaddr(RTA_IFP, *++argv, 0);
905: break;
906: case K_GENMASK:
1.21 thorpej 907: if (!--argc)
908: usage(1+*argv);
1.1 cgd 909: (void) getaddr(RTA_GENMASK, *++argv, 0);
910: break;
911: case K_GATEWAY:
1.21 thorpej 912: if (!--argc)
913: usage(1+*argv);
1.1 cgd 914: (void) getaddr(RTA_GATEWAY, *++argv, 0);
915: break;
916: case K_DST:
1.21 thorpej 917: if (!--argc)
918: usage(1+*argv);
1.1 cgd 919: ishost = getaddr(RTA_DST, *++argv, &hp);
920: dest = *argv;
921: break;
922: case K_NETMASK:
1.21 thorpej 923: if (!--argc)
924: usage(1+*argv);
1.1 cgd 925: (void) getaddr(RTA_NETMASK, *++argv, 0);
926: /* FALLTHROUGH */
927: case K_NET:
928: forcenet++;
929: break;
1.31 itojun 930: case K_PREFIXLEN:
1.60 itojun 931: if (!--argc)
932: usage(1+*argv);
1.61 itojun 933: ishost = prefixlen(*++argv);
1.31 itojun 934: break;
1.1 cgd 935: case K_MTU:
936: case K_HOPCOUNT:
937: case K_EXPIRE:
938: case K_RECVPIPE:
939: case K_SENDPIPE:
940: case K_SSTHRESH:
941: case K_RTT:
942: case K_RTTVAR:
1.21 thorpej 943: if (!--argc)
944: usage(1+*argv);
1.1 cgd 945: set_metric(*++argv, key);
946: break;
947: default:
948: usage(1+*argv);
949: }
950: } else {
951: if ((rtm_addrs & RTA_DST) == 0) {
952: dest = *argv;
953: ishost = getaddr(RTA_DST, *argv, &hp);
954: } else if ((rtm_addrs & RTA_GATEWAY) == 0) {
955: gateway = *argv;
956: (void) getaddr(RTA_GATEWAY, *argv, &hp);
957: } else {
1.51 lukem 958: ret = atoi(*argv);
1.7 mycroft 959:
1.1 cgd 960: if (ret == 0) {
1.66 ! christos 961: if (strcmp(*argv, "0") == 0) {
! 962: if (!qflag) {
! 963: warnx("%s, %s",
! 964: "old usage of trailing 0",
! 965: "assuming route to if");
! 966: }
! 967: } else
1.7 mycroft 968: usage((char *)NULL);
1.1 cgd 969: iflag = 1;
970: continue;
971: } else if (ret > 0 && ret < 10) {
1.15 pk 972: if (!qflag) {
1.66 ! christos 973: warnx("%s, %s",
1.26 christos 974: "old usage of trailing digit",
975: "assuming route via gateway");
1.15 pk 976: }
1.1 cgd 977: iflag = 0;
978: continue;
979: }
980: (void) getaddr(RTA_NETMASK, *argv, 0);
981: }
982: }
983: }
1.66 ! christos 984: if (forcehost && forcenet)
! 985: errx(1, "-host and -net conflict");
! 986: else if (forcehost)
1.1 cgd 987: ishost = 1;
1.66 ! christos 988: else if (forcenet)
1.1 cgd 989: ishost = 0;
990: flags |= RTF_UP;
991: if (ishost)
992: flags |= RTF_HOST;
993: if (iflag == 0)
994: flags |= RTF_GATEWAY;
995: for (attempts = 1; ; attempts++) {
996: errno = 0;
1.7 mycroft 997: if ((ret = rtmsg(*cmd, flags)) == 0)
998: break;
1.1 cgd 999: if (errno != ENETUNREACH && errno != ESRCH)
1000: break;
1.7 mycroft 1001: if (af == AF_INET && *gateway && hp && hp->h_addr_list[1]) {
1.1 cgd 1002: hp->h_addr_list++;
1.24 lukem 1003: memmove(&so_gate.sin.sin_addr, hp->h_addr_list[0],
1.1 cgd 1004: hp->h_length);
1005: } else
1006: break;
1007: }
1008: if (*cmd == 'g')
1.52 christos 1009: return rv;
1.1 cgd 1010: oerrno = errno;
1.15 pk 1011: if (!qflag) {
1012: (void) printf("%s %s %s", cmd, ishost? "host" : "net", dest);
1013: if (*gateway) {
1014: (void) printf(": gateway %s", gateway);
1015: if (attempts > 1 && ret == 0 && af == AF_INET)
1016: (void) printf(" (%s)",
1.40 itojun 1017: inet_ntoa(so_gate.sin.sin_addr));
1.15 pk 1018: }
1019: if (ret == 0)
1020: (void) printf("\n");
1021: }
1022: if (ret != 0) {
1.1 cgd 1023: switch (oerrno) {
1024: case ESRCH:
1.51 lukem 1025: error = "not in table";
1.1 cgd 1026: break;
1027: case EBUSY:
1.51 lukem 1028: error = "entry in use";
1.1 cgd 1029: break;
1030: case ENOBUFS:
1.51 lukem 1031: error = "routing table overflow";
1.1 cgd 1032: break;
1033: default:
1.51 lukem 1034: error = strerror(oerrno);
1.1 cgd 1035: break;
1036: }
1.51 lukem 1037: (void) printf(": %s\n", error);
1.52 christos 1038: return 1;
1.1 cgd 1039: }
1.52 christos 1040: return 0;
1.1 cgd 1041: }
1042:
1.19 christos 1043: static void
1.65 itojun 1044: inet_makenetandmask(u_int32_t net, struct sockaddr_in *isin)
1.1 cgd 1045: {
1.27 ross 1046: u_int32_t addr, mask = 0;
1.23 lukem 1047: char *cp;
1.1 cgd 1048:
1049: rtm_addrs |= RTA_NETMASK;
1050: if (net == 0)
1051: mask = addr = 0;
1052: else if (net < 128) {
1053: addr = net << IN_CLASSA_NSHIFT;
1054: mask = IN_CLASSA_NET;
1.63 jrf 1055: } else if (net < 192) {
1056: addr = net << IN_CLASSA_NSHIFT;
1057: mask = IN_CLASSB_NET;
1058: } else if (net < 224) {
1059: addr = net << IN_CLASSA_NSHIFT;
1060: mask = IN_CLASSC_NET;
1061: } else if (net < 256) {
1062: addr = net << IN_CLASSA_NSHIFT;
1063: mask = IN_CLASSD_NET;
1064: } else if (net < 49152) { /* 192 * 256 */
1.1 cgd 1065: addr = net << IN_CLASSB_NSHIFT;
1066: mask = IN_CLASSB_NET;
1.63 jrf 1067: } else if (net < 57344) { /* 224 * 256 */
1068: addr = net << IN_CLASSB_NSHIFT;
1069: mask = IN_CLASSC_NET;
1070: } else if (net < 65536) { /* XXX See above */
1071: addr = net << IN_CLASSB_NSHIFT;
1072: mask = IN_CLASSB_NET;
1073: } else if (net < 14680064L) { /* 224 * 65536 */
1.1 cgd 1074: addr = net << IN_CLASSC_NSHIFT;
1075: mask = IN_CLASSC_NET;
1.63 jrf 1076: } else if (net < 16777216L) {
1077: addr = net << IN_CLASSC_NSHIFT;
1078: mask = IN_CLASSD_NET;
1.1 cgd 1079: } else {
1080: addr = net;
1081: if ((addr & IN_CLASSA_HOST) == 0)
1082: mask = IN_CLASSA_NET;
1083: else if ((addr & IN_CLASSB_HOST) == 0)
1084: mask = IN_CLASSB_NET;
1085: else if ((addr & IN_CLASSC_HOST) == 0)
1086: mask = IN_CLASSC_NET;
1087: else
1088: mask = -1;
1089: }
1.51 lukem 1090: isin->sin_addr.s_addr = htonl(addr);
1091: isin = &so_mask.sin;
1092: isin->sin_addr.s_addr = htonl(mask);
1093: isin->sin_len = 0;
1094: isin->sin_family = 0;
1095: cp = (char *)(&isin->sin_addr + 1);
1096: while (*--cp == 0 && cp > (char *)isin)
1.1 cgd 1097: ;
1.51 lukem 1098: isin->sin_len = 1 + cp - (char *)isin;
1.1 cgd 1099: }
1100:
1.36 itojun 1101: #ifdef INET6
1102: /*
1103: * XXX the function may need more improvement...
1104: */
1.54 itojun 1105: static int
1.36 itojun 1106: inet6_makenetandmask(sin6)
1107: struct sockaddr_in6 *sin6;
1108: {
1109: char *plen;
1110: struct in6_addr in6;
1111:
1112: plen = NULL;
1113: if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
1114: sin6->sin6_scope_id == 0) {
1115: plen = "0";
1116: } else if ((sin6->sin6_addr.s6_addr[0] & 0xe0) == 0x20) {
1117: /* aggregatable global unicast - RFC2374 */
1118: memset(&in6, 0, sizeof(in6));
1119: if (!memcmp(&sin6->sin6_addr.s6_addr[8], &in6.s6_addr[8], 8))
1120: plen = "64";
1121: }
1122:
1.56 itojun 1123: if (!plen || strcmp(plen, "128") == 0)
1124: return 1;
1125: else {
1.36 itojun 1126: rtm_addrs |= RTA_NETMASK;
1.56 itojun 1127: (void)prefixlen(plen);
1128: return 0;
1.36 itojun 1129: }
1130: }
1131: #endif
1132:
1.1 cgd 1133: /*
1134: * Interpret an argument as a network address of some kind,
1135: * returning 1 if a host address, 0 if a network address.
1136: */
1.19 christos 1137: static int
1.1 cgd 1138: getaddr(which, s, hpp)
1139: int which;
1140: char *s;
1141: struct hostent **hpp;
1142: {
1.23 lukem 1143: sup su;
1.1 cgd 1144: struct hostent *hp;
1145: struct netent *np;
1.27 ross 1146: u_int32_t val;
1.19 christos 1147: char *t;
1.31 itojun 1148: int afamily; /* local copy of af so we can change it */
1.1 cgd 1149:
1150: if (af == 0) {
1151: af = AF_INET;
1152: aflen = sizeof(struct sockaddr_in);
1153: }
1.31 itojun 1154: afamily = af;
1.1 cgd 1155: rtm_addrs |= which;
1156: switch (which) {
1.7 mycroft 1157: case RTA_DST:
1158: su = &so_dst;
1159: break;
1160: case RTA_GATEWAY:
1161: su = &so_gate;
1162: break;
1163: case RTA_NETMASK:
1164: su = &so_mask;
1165: break;
1166: case RTA_GENMASK:
1167: su = &so_genmask;
1168: break;
1169: case RTA_IFP:
1170: su = &so_ifp;
1.31 itojun 1171: afamily = AF_LINK;
1.7 mycroft 1172: break;
1173: case RTA_IFA:
1174: su = &so_ifa;
1175: su->sa.sa_family = af;
1176: break;
1177: default:
1.19 christos 1178: su = NULL;
1.7 mycroft 1179: usage("Internal Error");
1180: /*NOTREACHED*/
1.1 cgd 1181: }
1182: su->sa.sa_len = aflen;
1.31 itojun 1183: su->sa.sa_family = afamily; /* cases that don't want it have left already */
1.1 cgd 1184: if (strcmp(s, "default") == 0) {
1185: switch (which) {
1186: case RTA_DST:
1187: forcenet++;
1188: (void) getaddr(RTA_NETMASK, s, 0);
1189: break;
1190: case RTA_NETMASK:
1191: case RTA_GENMASK:
1192: su->sa.sa_len = 0;
1193: }
1.7 mycroft 1194: return (0);
1.1 cgd 1195: }
1.31 itojun 1196: switch (afamily) {
1.17 gwr 1197: #ifndef SMALL
1.31 itojun 1198: #ifdef INET6
1199: case AF_INET6:
1.36 itojun 1200: {
1201: struct addrinfo hints, *res;
1.66 ! christos 1202: char *slash = 0;
1.36 itojun 1203:
1.66 ! christos 1204: if (which == RTA_DST && (slash = (strrchr(s, '/'))) != 0)
! 1205: *slash = '\0';
1.36 itojun 1206: memset(&hints, 0, sizeof(hints));
1207: hints.ai_family = afamily; /*AF_INET6*/
1208: hints.ai_flags = AI_NUMERICHOST;
1209: hints.ai_socktype = SOCK_DGRAM; /*dummy*/
1.58 itojun 1210: if (getaddrinfo(s, "0", &hints, &res) != 0) {
1211: hints.ai_flags = 0;
1.66 ! christos 1212: if (slash) {
! 1213: *slash = '/';
! 1214: slash = 0;
! 1215: }
1.58 itojun 1216: if (getaddrinfo(s, "0", &hints, &res) != 0) {
1217: (void) fprintf(stderr, "%s: bad value\n", s);
1218: exit(1);
1219: }
1220: }
1.66 ! christos 1221: if (slash)
! 1222: *slash = '/';
1.58 itojun 1223: if (sizeof(su->sin6) != res->ai_addrlen) {
1.31 itojun 1224: (void) fprintf(stderr, "%s: bad value\n", s);
1225: exit(1);
1226: }
1.58 itojun 1227: if (res->ai_next) {
1228: (void) fprintf(stderr,
1229: "%s: resolved to multiple values\n", s);
1230: exit(1);
1231: }
1.36 itojun 1232: memcpy(&su->sin6, res->ai_addr, sizeof(su->sin6));
1.58 itojun 1233: freeaddrinfo(res);
1.36 itojun 1234: #ifdef __KAME__
1.37 itojun 1235: if ((IN6_IS_ADDR_LINKLOCAL(&su->sin6.sin6_addr) ||
1236: IN6_IS_ADDR_MC_LINKLOCAL(&su->sin6.sin6_addr)) &&
1.36 itojun 1237: su->sin6.sin6_scope_id) {
1238: *(u_int16_t *)&su->sin6.sin6_addr.s6_addr[2] =
1239: htons(su->sin6.sin6_scope_id);
1240: su->sin6.sin6_scope_id = 0;
1241: }
1242: #endif
1.58 itojun 1243: if (hints.ai_flags == AI_NUMERICHOST) {
1.66 ! christos 1244: if (slash)
! 1245: return (prefixlen(slash + 1));
1.58 itojun 1246: if (which == RTA_DST)
1247: return (inet6_makenetandmask(&su->sin6));
1248: return (0);
1249: } else
1250: return (1);
1.36 itojun 1251: }
1.31 itojun 1252: #endif
1253:
1.7 mycroft 1254: case AF_NS:
1255: if (which == RTA_DST) {
1256: struct sockaddr_ns *sms = &(so_mask.sns);
1.8 mycroft 1257: memset(sms, 0, sizeof(*sms));
1.7 mycroft 1258: sms->sns_family = 0;
1259: sms->sns_len = 6;
1260: sms->sns_addr.x_net = *(union ns_net *)ns_bh;
1261: rtm_addrs |= RTA_NETMASK;
1262: }
1263: su->sns.sns_addr = ns_addr(s);
1264: return (!ns_nullhost(su->sns.sns_addr));
1265:
1266: case AF_OSI:
1267: su->siso.siso_addr = *iso_addr(s);
1268: if (which == RTA_NETMASK || which == RTA_GENMASK) {
1.23 lukem 1269: char *cp = (char *)TSEL(&su->siso);
1.7 mycroft 1270: su->siso.siso_nlen = 0;
1271: do {--cp ;} while ((cp > (char *)su) && (*cp == 0));
1272: su->siso.siso_len = 1 + cp - (char *)su;
1273: }
1274: return (1);
1275:
1276: case AF_CCITT:
1277: ccitt_addr(s, &su->sx25);
1278: return (which == RTA_DST ? x25_makemask() : 1);
1.17 gwr 1279: #endif /* SMALL */
1.7 mycroft 1280:
1281: case PF_ROUTE:
1282: su->sa.sa_len = sizeof(*su);
1283: sockaddr(s, &su->sa);
1284: return (1);
1285:
1.66 ! christos 1286: #ifndef SMALL
1.19 christos 1287: case AF_APPLETALK:
1288: t = strchr (s, '.');
1289: if (!t) {
1290: badataddr:
1.26 christos 1291: errx(1, "bad address: %s", s);
1.19 christos 1292: }
1293: val = atoi (s);
1294: if (val > 65535)
1295: goto badataddr;
1296: su->sat.sat_addr.s_net = val;
1297: val = atoi (t);
1298: if (val > 256)
1299: goto badataddr;
1300: su->sat.sat_addr.s_node = val;
1301: rtm_addrs |= RTA_NETMASK;
1302: return(forcehost || su->sat.sat_addr.s_node != 0);
1.66 ! christos 1303: #endif
1.19 christos 1304:
1.17 gwr 1305: case AF_LINK:
1306: link_addr(s, &su->sdl);
1307: return (1);
1308:
1.7 mycroft 1309: case AF_INET:
1310: default:
1311: break;
1312: }
1313:
1.1 cgd 1314: if (hpp == NULL)
1315: hpp = &hp;
1316: *hpp = NULL;
1.65 itojun 1317:
1318: if ((t = strchr(s, '/')) != NULL && which == RTA_DST) {
1319: *t = '\0';
1320: if ((val = inet_addr(s)) != INADDR_NONE) {
1321: inet_makenetandmask(htonl(val), &su->sin);
1.66 ! christos 1322: return prefixlen(&t[1]);
1.65 itojun 1323: }
1324: *t = '/';
1325: }
1.16 cgd 1326: if (((val = inet_addr(s)) != INADDR_NONE) &&
1.1 cgd 1327: (which != RTA_DST || forcenet == 0)) {
1328: su->sin.sin_addr.s_addr = val;
1329: if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY)
1330: return (1);
1331: else {
1332: val = ntohl(val);
1.7 mycroft 1333: goto netdone;
1.1 cgd 1334: }
1335: }
1.16 cgd 1336: if ((val = inet_network(s)) != INADDR_NONE ||
1.7 mycroft 1337: ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0)) {
1338: netdone:
1339: if (which == RTA_DST)
1340: inet_makenetandmask(val, &su->sin);
1341: return (0);
1.1 cgd 1342: }
1343: hp = gethostbyname(s);
1344: if (hp) {
1345: *hpp = hp;
1346: su->sin.sin_family = hp->h_addrtype;
1.24 lukem 1347: memmove(&su->sin.sin_addr, hp->h_addr, hp->h_length);
1.1 cgd 1348: return (1);
1349: }
1.26 christos 1350: errx(1, "bad value: %s", s);
1.7 mycroft 1351: }
1352:
1.31 itojun 1353: int
1354: prefixlen(s)
1355: char *s;
1356: {
1357: int len = atoi(s), q, r;
1.47 itojun 1358: int max;
1359:
1360: switch (af) {
1361: case AF_INET:
1362: max = sizeof(struct in_addr) * 8;
1363: break;
1364: #ifdef INET6
1365: case AF_INET6:
1366: max = sizeof(struct in6_addr) * 8;
1367: break;
1368: #endif
1369: default:
1370: (void) fprintf(stderr,
1371: "prefixlen is not supported with af %d\n", af);
1372: exit(1);
1373: }
1.31 itojun 1374:
1375: rtm_addrs |= RTA_NETMASK;
1.48 itojun 1376: if (len < -1 || len > max) {
1.31 itojun 1377: (void) fprintf(stderr, "%s: bad value\n", s);
1378: exit(1);
1379: }
1380:
1381: q = len >> 3;
1382: r = len & 7;
1.47 itojun 1383: switch (af) {
1384: case AF_INET:
1385: memset(&so_mask, 0, sizeof(so_mask));
1386: so_mask.sin.sin_family = AF_INET;
1387: so_mask.sin.sin_len = sizeof(struct sockaddr_in);
1388: so_mask.sin.sin_addr.s_addr = htonl(0xffffffff << (32 - len));
1389: break;
1390: #ifdef INET6
1391: case AF_INET6:
1392: so_mask.sin6.sin6_family = AF_INET6;
1393: so_mask.sin6.sin6_len = sizeof(struct sockaddr_in6);
1394: memset((void *)&so_mask.sin6.sin6_addr, 0,
1395: sizeof(so_mask.sin6.sin6_addr));
1396: if (q > 0)
1397: memset((void *)&so_mask.sin6.sin6_addr, 0xff, q);
1398: if (r > 0)
1399: *((u_char *)&so_mask.sin6.sin6_addr + q) =
1400: (0xff00 >> r) & 0xff;
1401: break;
1402: #endif
1403: }
1.61 itojun 1404: return (len == max);
1.31 itojun 1405: }
1406:
1.38 sommerfe 1407: #ifndef SMALL
1.7 mycroft 1408: int
1409: x25_makemask()
1410: {
1.23 lukem 1411: char *cp;
1.7 mycroft 1412:
1413: if ((rtm_addrs & RTA_NETMASK) == 0) {
1.1 cgd 1414: rtm_addrs |= RTA_NETMASK;
1.7 mycroft 1415: for (cp = (char *)&so_mask.sx25.x25_net;
1416: cp < &so_mask.sx25.x25_opts.op_flags; cp++)
1417: *cp = -1;
1418: so_mask.sx25.x25_len = (u_char)&(((sup)0)->sx25.x25_opts);
1.1 cgd 1419: }
1.7 mycroft 1420: return 0;
1.1 cgd 1421: }
1422:
1423:
1424: char *
1425: ns_print(sns)
1426: struct sockaddr_ns *sns;
1427: {
1428: struct ns_addr work;
1.27 ross 1429: union { union ns_net net_e; u_int32_t int32_t_e; } net;
1.1 cgd 1430: u_short port;
1431: static char mybuf[50], cport[10], chost[25];
1432: char *host = "";
1.23 lukem 1433: char *p;
1434: u_char *q;
1.1 cgd 1435:
1436: work = sns->sns_addr;
1437: port = ntohs(work.x_port);
1438: work.x_port = 0;
1439: net.net_e = work.x_net;
1.27 ross 1440: if (ns_nullhost(work) && net.int32_t_e == 0) {
1.1 cgd 1441: if (!port)
1442: return ("*.*");
1.20 mrg 1443: (void)snprintf(mybuf, sizeof mybuf, "*.%XH", port);
1.1 cgd 1444: return (mybuf);
1445: }
1446:
1.9 mycroft 1447: if (memcmp(ns_bh, work.x_host.c_host, 6) == 0)
1.1 cgd 1448: host = "any";
1.9 mycroft 1449: else if (memcmp(ns_nullh, work.x_host.c_host, 6) == 0)
1.1 cgd 1450: host = "*";
1451: else {
1452: q = work.x_host.c_host;
1.20 mrg 1453: (void)snprintf(chost, sizeof chost, "%02X%02X%02X%02X%02X%02XH",
1.1 cgd 1454: q[0], q[1], q[2], q[3], q[4], q[5]);
1455: for (p = chost; *p == '0' && p < chost + 12; p++)
1456: /* void */;
1457: host = p;
1458: }
1459: if (port)
1.20 mrg 1460: (void)snprintf(cport, sizeof cport, ".%XH", htons(port));
1.1 cgd 1461: else
1462: *cport = 0;
1463:
1.20 mrg 1464: (void)snprintf(mybuf, sizeof mybuf, "%XH.%s%s",
1.27 ross 1465: (u_int32_t)ntohl(net.int32_t_e), host, cport);
1.1 cgd 1466: return (mybuf);
1467: }
1468:
1.19 christos 1469: static void
1.7 mycroft 1470: interfaces()
1471: {
1472: size_t needed;
1473: int mib[6];
1474: char *buf, *lim, *next;
1.23 lukem 1475: struct rt_msghdr *rtm;
1.7 mycroft 1476:
1477: mib[0] = CTL_NET;
1478: mib[1] = PF_ROUTE;
1479: mib[2] = 0; /* protocol */
1480: mib[3] = 0; /* wildcard address family */
1481: mib[4] = NET_RT_IFLIST;
1482: mib[5] = 0; /* no flags */
1483: if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
1.26 christos 1484: err(1, "route-sysctl-estimate");
1.7 mycroft 1485: if ((buf = malloc(needed)) == NULL)
1.26 christos 1486: err(1, "malloc");
1.7 mycroft 1487: if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
1.26 christos 1488: err(1, "actual retrieval of interface table");
1.7 mycroft 1489: lim = buf + needed;
1490: for (next = buf; next < lim; next += rtm->rtm_msglen) {
1491: rtm = (struct rt_msghdr *)next;
1492: print_rtmsg(rtm, rtm->rtm_msglen);
1493: }
1494: }
1495:
1.19 christos 1496: static void
1.1 cgd 1497: monitor()
1498: {
1499: int n;
1500: char msg[2048];
1501:
1502: verbose = 1;
1.7 mycroft 1503: if (debugonly) {
1504: interfaces();
1505: exit(0);
1506: }
1.1 cgd 1507: for(;;) {
1.32 mjacob 1508: time_t now;
1.51 lukem 1509: n = read(sock, msg, 2048);
1.31 itojun 1510: now = time(NULL);
1511: (void) printf("got message of size %d on %s", n, ctime(&now));
1.7 mycroft 1512: print_rtmsg((struct rt_msghdr *)msg, n);
1.1 cgd 1513: }
1514: }
1515:
1.17 gwr 1516: #endif /* SMALL */
1517:
1518:
1.1 cgd 1519: struct {
1520: struct rt_msghdr m_rtm;
1521: char m_space[512];
1522: } m_rtmsg;
1523:
1.19 christos 1524: static int
1.1 cgd 1525: rtmsg(cmd, flags)
1526: int cmd, flags;
1527: {
1528: static int seq;
1529: int rlen;
1.23 lukem 1530: char *cp = m_rtmsg.m_space;
1531: int l;
1.1 cgd 1532:
1533: #define NEXTADDR(w, u) \
1534: if (rtm_addrs & (w)) {\
1.24 lukem 1535: l = ROUNDUP(u.sa.sa_len); memmove(cp, &(u), l); cp += l;\
1.50 atatat 1536: if (verbose && ! shortoutput) sodump(&(u),"u");\
1.1 cgd 1537: }
1538:
1539: errno = 0;
1.8 mycroft 1540: memset(&m_rtmsg, 0, sizeof(m_rtmsg));
1.1 cgd 1541: if (cmd == 'a')
1542: cmd = RTM_ADD;
1543: else if (cmd == 'c')
1544: cmd = RTM_CHANGE;
1.7 mycroft 1545: else if (cmd == 'g') {
1.17 gwr 1546: #ifdef SMALL
1547: return (-1);
1548: #else /* SMALL */
1.1 cgd 1549: cmd = RTM_GET;
1.7 mycroft 1550: if (so_ifp.sa.sa_family == 0) {
1.10 cgd 1551: so_ifp.sa.sa_family = AF_LINK;
1552: so_ifp.sa.sa_len = sizeof(struct sockaddr_dl);
1.7 mycroft 1553: rtm_addrs |= RTA_IFP;
1554: }
1.17 gwr 1555: #endif /* SMALL */
1.7 mycroft 1556: } else
1.1 cgd 1557: cmd = RTM_DELETE;
1558: #define rtm m_rtmsg.m_rtm
1559: rtm.rtm_type = cmd;
1560: rtm.rtm_flags = flags;
1561: rtm.rtm_version = RTM_VERSION;
1562: rtm.rtm_seq = ++seq;
1563: rtm.rtm_addrs = rtm_addrs;
1564: rtm.rtm_rmx = rt_metrics;
1565: rtm.rtm_inits = rtm_inits;
1566:
1567: if (rtm_addrs & RTA_NETMASK)
1568: mask_addr();
1569: NEXTADDR(RTA_DST, so_dst);
1570: NEXTADDR(RTA_GATEWAY, so_gate);
1571: NEXTADDR(RTA_NETMASK, so_mask);
1572: NEXTADDR(RTA_GENMASK, so_genmask);
1573: NEXTADDR(RTA_IFP, so_ifp);
1574: NEXTADDR(RTA_IFA, so_ifa);
1575: rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
1.50 atatat 1576: if (verbose && ! shortoutput)
1.1 cgd 1577: print_rtmsg(&rtm, l);
1578: if (debugonly)
1.7 mycroft 1579: return (0);
1.51 lukem 1580: if ((rlen = write(sock, (char *)&m_rtmsg, l)) < 0) {
1.1 cgd 1581: perror("writing to routing socket");
1582: return (-1);
1583: }
1.17 gwr 1584: #ifndef SMALL
1.1 cgd 1585: if (cmd == RTM_GET) {
1586: do {
1.51 lukem 1587: l = read(sock, (char *)&m_rtmsg, sizeof(m_rtmsg));
1.1 cgd 1588: } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid));
1589: if (l < 0)
1.26 christos 1590: err(1, "read from routing socket");
1.1 cgd 1591: else
1592: print_getmsg(&rtm, l);
1593: }
1.17 gwr 1594: #endif /* SMALL */
1.1 cgd 1595: #undef rtm
1596: return (0);
1597: }
1598:
1.19 christos 1599: static void
1.7 mycroft 1600: mask_addr()
1601: {
1602: int olen = so_mask.sa.sa_len;
1.23 lukem 1603: char *cp1 = olen + (char *)&so_mask, *cp2;
1.1 cgd 1604:
1.7 mycroft 1605: for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; )
1606: if (*--cp1 != 0) {
1607: so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask;
1608: break;
1609: }
1.1 cgd 1610: if ((rtm_addrs & RTA_DST) == 0)
1611: return;
1.7 mycroft 1612: switch (so_dst.sa.sa_family) {
1.30 lukem 1613: case AF_INET:
1.31 itojun 1614: #ifdef INET6
1615: case AF_INET6:
1616: #endif
1.66 ! christos 1617: #ifndef SMALL
1.30 lukem 1618: case AF_APPLETALK:
1.1 cgd 1619: case AF_NS:
1.7 mycroft 1620: case AF_CCITT:
1.30 lukem 1621: #endif /* SMALL */
1.7 mycroft 1622: case 0:
1.1 cgd 1623: return;
1.30 lukem 1624: #ifndef SMALL
1.1 cgd 1625: case AF_ISO:
1.7 mycroft 1626: olen = MIN(so_dst.siso.siso_nlen,
1627: MAX(so_mask.sa.sa_len - 6, 0));
1628: break;
1.30 lukem 1629: #endif /* SMALL */
1.1 cgd 1630: }
1631: cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst;
1632: cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst;
1633: while (cp2 > cp1)
1634: *--cp2 = 0;
1635: cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask;
1636: while (cp1 > so_dst.sa.sa_data)
1637: *--cp1 &= *--cp2;
1.30 lukem 1638: #ifndef SMALL
1.7 mycroft 1639: switch (so_dst.sa.sa_family) {
1.1 cgd 1640: case AF_ISO:
1641: so_dst.siso.siso_nlen = olen;
1.7 mycroft 1642: break;
1.1 cgd 1643: }
1.30 lukem 1644: #endif /* SMALL */
1.1 cgd 1645: }
1646:
1647: char *msgtypes[] = {
1648: "",
1649: "RTM_ADD: Add Route",
1650: "RTM_DELETE: Delete Route",
1651: "RTM_CHANGE: Change Metrics or flags",
1652: "RTM_GET: Report Metrics",
1653: "RTM_LOSING: Kernel Suspects Partitioning",
1654: "RTM_REDIRECT: Told to use different route",
1655: "RTM_MISS: Lookup failed on this address",
1656: "RTM_LOCK: fix specified metrics",
1657: "RTM_OLDADD: caused by SIOCADDRT",
1658: "RTM_OLDDEL: caused by SIOCDELRT",
1.7 mycroft 1659: "RTM_RESOLVE: Route created by cloning",
1660: "RTM_NEWADDR: address being added to iface",
1661: "RTM_DELADDR: address being removed from iface",
1.39 itojun 1662: "RTM_OIFINFO: iface status change (pre-1.5)",
1.7 mycroft 1663: "RTM_IFINFO: iface status change",
1.39 itojun 1664: "RTM_IFANNOUNCE: iface arrival/departure",
1.1 cgd 1665: 0,
1666: };
1667:
1668: char metricnames[] =
1.7 mycroft 1669: "\011pksent\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";
1670: char routeflags[] =
1.42 itojun 1671: "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE\016CLONED\017PROTO2\020PROTO1";
1.7 mycroft 1672: char ifnetflags[] =
1673: "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6NOTRAILERS\7RUNNING\010NOARP\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST";
1674: char addrnames[] =
1675: "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD";
1.1 cgd 1676:
1.53 christos 1677:
1678: #ifndef SMALL
1679: static const char *
1680: linkstate(ifm)
1681: struct if_msghdr *ifm;
1682: {
1683: static char buf[64];
1684:
1685: switch (ifm->ifm_data.ifi_link_state) {
1686: case LINK_STATE_UNKNOWN:
1687: return "carrier: unknown";
1688: case LINK_STATE_DOWN:
1689: return "carrier: no carrier";
1690: case LINK_STATE_UP:
1691: return "carrier: active";
1692: default:
1693: (void)snprintf(buf, sizeof(buf), "carrier: 0x%x",
1694: ifm->ifm_data.ifi_link_state);
1695: return buf;
1696: }
1697: }
1698: #endif /* SMALL */
1699:
1.19 christos 1700: static void
1.1 cgd 1701: print_rtmsg(rtm, msglen)
1.23 lukem 1702: struct rt_msghdr *rtm;
1.1 cgd 1703: int msglen;
1704: {
1.7 mycroft 1705: struct if_msghdr *ifm;
1706: struct ifa_msghdr *ifam;
1.39 itojun 1707: struct if_announcemsghdr *ifan;
1.7 mycroft 1708:
1.1 cgd 1709: if (verbose == 0)
1710: return;
1711: if (rtm->rtm_version != RTM_VERSION) {
1712: (void) printf("routing message version %d not understood\n",
1713: rtm->rtm_version);
1714: return;
1715: }
1.39 itojun 1716: if (msgtypes[rtm->rtm_type])
1717: (void)printf("%s: ", msgtypes[rtm->rtm_type]);
1718: else
1719: (void)printf("#%d: ", rtm->rtm_type);
1720: (void)printf("len %d, ", rtm->rtm_msglen);
1.7 mycroft 1721: switch (rtm->rtm_type) {
1722: case RTM_IFINFO:
1723: ifm = (struct if_msghdr *)rtm;
1.53 christos 1724: (void) printf("if# %d, %s, flags:", ifm->ifm_index,
1725: #ifdef SMALL
1726: ""
1727: #else
1728: linkstate(ifm)
1729: #endif /* SMALL */
1730: );
1.7 mycroft 1731: bprintf(stdout, ifm->ifm_flags, ifnetflags);
1732: pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs);
1733: break;
1734: case RTM_NEWADDR:
1735: case RTM_DELADDR:
1736: ifam = (struct ifa_msghdr *)rtm;
1737: (void) printf("metric %d, flags:", ifam->ifam_metric);
1738: bprintf(stdout, ifam->ifam_flags, routeflags);
1739: pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs);
1.39 itojun 1740: break;
1741: case RTM_IFANNOUNCE:
1742: ifan = (struct if_announcemsghdr *)rtm;
1743: (void) printf("if# %d, what: ", ifan->ifan_index);
1744: switch (ifan->ifan_what) {
1745: case IFAN_ARRIVAL:
1746: printf("arrival");
1747: break;
1748: case IFAN_DEPARTURE:
1749: printf("departure");
1750: break;
1751: default:
1752: printf("#%d", ifan->ifan_what);
1753: break;
1754: }
1755: printf("\n");
1.7 mycroft 1756: break;
1757: default:
1758: (void) printf("pid: %d, seq %d, errno %d, flags:",
1759: rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1760: bprintf(stdout, rtm->rtm_flags, routeflags);
1761: pmsg_common(rtm);
1762: }
1.1 cgd 1763: }
1764:
1.17 gwr 1765: #ifndef SMALL
1.19 christos 1766: static void
1.1 cgd 1767: print_getmsg(rtm, msglen)
1.23 lukem 1768: struct rt_msghdr *rtm;
1.1 cgd 1769: int msglen;
1770: {
1.34 sommerfe 1771: struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL, *ifa = NULL;
1.7 mycroft 1772: struct sockaddr_dl *ifp = NULL;
1.23 lukem 1773: struct sockaddr *sa;
1774: char *cp;
1775: int i;
1.7 mycroft 1776:
1.50 atatat 1777: if (! shortoutput)
1778: (void) printf(" route to: %s\n",
1779: routename((struct sockaddr *) &so_dst, NULL, RTF_HOST));
1.1 cgd 1780: if (rtm->rtm_version != RTM_VERSION) {
1.26 christos 1781: warnx("routing message version %d not understood",
1.1 cgd 1782: rtm->rtm_version);
1783: return;
1784: }
1785: if (rtm->rtm_msglen > msglen) {
1.59 grant 1786: warnx("message length mismatch, in packet %d, returned %d",
1.1 cgd 1787: rtm->rtm_msglen, msglen);
1788: }
1.7 mycroft 1789: if (rtm->rtm_errno) {
1.26 christos 1790: warn("RTM_GET");
1.7 mycroft 1791: return;
1792: }
1793: cp = ((char *)(rtm + 1));
1794: if (rtm->rtm_addrs)
1795: for (i = 1; i; i <<= 1)
1796: if (i & rtm->rtm_addrs) {
1797: sa = (struct sockaddr *)cp;
1798: switch (i) {
1799: case RTA_DST:
1800: dst = sa;
1801: break;
1802: case RTA_GATEWAY:
1803: gate = sa;
1804: break;
1805: case RTA_NETMASK:
1806: mask = sa;
1807: break;
1808: case RTA_IFP:
1809: if (sa->sa_family == AF_LINK &&
1810: ((struct sockaddr_dl *)sa)->sdl_nlen)
1811: ifp = (struct sockaddr_dl *)sa;
1812: break;
1.34 sommerfe 1813: case RTA_IFA:
1814: ifa = sa;
1815: break;
1.7 mycroft 1816: }
1817: ADVANCE(cp, sa);
1818: }
1819: if (dst && mask)
1820: mask->sa_family = dst->sa_family; /* XXX */
1.50 atatat 1821: if (dst && ! shortoutput)
1.49 atatat 1822: (void)printf("destination: %s\n",
1823: routename(dst, mask, RTF_HOST));
1.50 atatat 1824: if (mask && ! shortoutput) {
1.7 mycroft 1825: int savenflag = nflag;
1826:
1827: nflag = 1;
1.49 atatat 1828: (void)printf(" mask: %s\n",
1829: routename(mask, NULL, RTF_HOST));
1.7 mycroft 1830: nflag = savenflag;
1831: }
1.50 atatat 1832: if (gate && rtm->rtm_flags & RTF_GATEWAY && ! shortoutput)
1.49 atatat 1833: (void)printf(" gateway: %s\n",
1834: routename(gate, NULL, RTF_HOST));
1.50 atatat 1835: if (ifa && ! shortoutput)
1.49 atatat 1836: (void)printf(" local addr: %s\n",
1837: routename(ifa, NULL, RTF_HOST));
1.50 atatat 1838: if (ifp && ! shortoutput)
1.7 mycroft 1839: (void)printf(" interface: %.*s\n",
1840: ifp->sdl_nlen, ifp->sdl_data);
1.50 atatat 1841: if (! shortoutput) {
1842: (void)printf(" flags: ");
1843: bprintf(stdout, rtm->rtm_flags, routeflags);
1844: }
1.7 mycroft 1845:
1846: #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1847: #define msec(u) (((u) + 500) / 1000) /* usec to msec */
1848:
1.50 atatat 1849: if (! shortoutput) {
1850: (void) printf("\n%s\n", "\
1.7 mycroft 1851: recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire");
1.50 atatat 1852: printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE));
1853: printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE));
1854: printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH));
1855: printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT));
1856: printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rttvar), lock(RTTVAR));
1857: printf("%8ld%c ", rtm->rtm_rmx.rmx_hopcount, lock(HOPCOUNT));
1858: printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU));
1859: if (rtm->rtm_rmx.rmx_expire)
1860: rtm->rtm_rmx.rmx_expire -= time(0);
1861: printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE));
1862: }
1.7 mycroft 1863: #undef lock
1864: #undef msec
1865: #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD)
1.50 atatat 1866:
1867: if ((rtm->rtm_addrs & RTF_GATEWAY) == 0)
1868: rv = 1;
1869: else {
1.51 lukem 1870: char *name;
1871: int addrs;
1.50 atatat 1872:
1873: cp = (char *)(rtm + 1);
1874: addrs = rtm->rtm_addrs;
1875:
1876: for (i = 1; i; i <<= 1) {
1877: sa = (struct sockaddr *)cp;
1878: if (i == RTF_GATEWAY) {
1879: name = routename(sa, NULL, RTF_HOST);
1880: if (name[0] == '\0')
1881: rv = 1;
1882: else if (shortoutput)
1883: printf("%s\n", name);
1884: }
1885: if (i & addrs)
1886: ADVANCE(cp, sa);
1887: }
1888: }
1889:
1890: if (shortoutput)
1891: return;
1892: else if (verbose)
1.7 mycroft 1893: pmsg_common(rtm);
1894: else if (rtm->rtm_addrs &~ RTA_IGN) {
1895: (void) printf("sockaddrs: ");
1896: bprintf(stdout, rtm->rtm_addrs, addrnames);
1897: putchar('\n');
1898: }
1899: #undef RTA_IGN
1.1 cgd 1900: }
1.17 gwr 1901: #endif /* SMALL */
1.1 cgd 1902:
1903: void
1904: pmsg_common(rtm)
1.23 lukem 1905: struct rt_msghdr *rtm;
1.1 cgd 1906: {
1907: (void) printf("\nlocks: ");
1908: bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
1909: (void) printf(" inits: ");
1910: bprintf(stdout, rtm->rtm_inits, metricnames);
1.7 mycroft 1911: pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs);
1912: }
1913:
1.19 christos 1914: static void
1.7 mycroft 1915: pmsg_addrs(cp, addrs)
1916: char *cp;
1917: int addrs;
1918: {
1.23 lukem 1919: struct sockaddr *sa;
1.7 mycroft 1920: int i;
1921:
1.46 bad 1922: if (addrs != 0) {
1923: (void) printf("\nsockaddrs: ");
1924: bprintf(stdout, addrs, addrnames);
1925: (void) putchar('\n');
1926: for (i = 1; i; i <<= 1)
1927: if (i & addrs) {
1928: sa = (struct sockaddr *)cp;
1.49 atatat 1929: (void) printf(" %s",
1930: routename(sa, NULL, RTF_HOST));
1.46 bad 1931: ADVANCE(cp, sa);
1932: }
1933: }
1.1 cgd 1934: (void) putchar('\n');
1935: (void) fflush(stdout);
1936: }
1937:
1.19 christos 1938: static void
1.1 cgd 1939: bprintf(fp, b, s)
1.23 lukem 1940: FILE *fp;
1941: int b;
1942: u_char *s;
1.1 cgd 1943: {
1.23 lukem 1944: int i;
1.1 cgd 1945: int gotsome = 0;
1946:
1947: if (b == 0)
1948: return;
1.19 christos 1949: while ((i = *s++) != 0) {
1.1 cgd 1950: if (b & (1 << (i-1))) {
1951: if (gotsome == 0)
1952: i = '<';
1953: else
1954: i = ',';
1955: (void) putc(i, fp);
1956: gotsome = 1;
1957: for (; (i = *s) > 32; s++)
1958: (void) putc(i, fp);
1959: } else
1960: while (*s > 32)
1961: s++;
1962: }
1963: if (gotsome)
1964: (void) putc('>', fp);
1965: }
1966:
1.19 christos 1967: static int
1.1 cgd 1968: keyword(cp)
1969: char *cp;
1970: {
1.23 lukem 1971: struct keytab *kt = keywords;
1.1 cgd 1972:
1973: while (kt->kt_cp && strcmp(kt->kt_cp, cp))
1974: kt++;
1975: return kt->kt_i;
1976: }
1977:
1.19 christos 1978: static void
1.1 cgd 1979: sodump(su, which)
1.23 lukem 1980: sup su;
1.1 cgd 1981: char *which;
1982: {
1.35 itojun 1983: #ifdef INET6
1984: char ntop_buf[NI_MAXHOST];
1985: #endif
1986:
1.1 cgd 1987: switch (su->sa.sa_family) {
1.17 gwr 1988: case AF_INET:
1989: (void) printf("%s: inet %s; ",
1990: which, inet_ntoa(su->sin.sin_addr));
1991: break;
1.66 ! christos 1992: #ifndef SMALL
1.19 christos 1993: case AF_APPLETALK:
1994: (void) printf("%s: atalk %d.%d; ",
1995: which, su->sat.sat_addr.s_net, su->sat.sat_addr.s_node);
1996: break;
1.66 ! christos 1997: #endif
1.1 cgd 1998: case AF_LINK:
1999: (void) printf("%s: link %s; ",
2000: which, link_ntoa(&su->sdl));
2001: break;
1.17 gwr 2002: #ifndef SMALL
1.31 itojun 2003: #ifdef INET6
2004: case AF_INET6:
2005: (void) printf("%s: inet6 %s; ",
2006: which, inet_ntop(AF_INET6, &su->sin6.sin6_addr,
2007: ntop_buf, sizeof(ntop_buf)));
2008: break;
2009: #endif
1.1 cgd 2010: case AF_ISO:
2011: (void) printf("%s: iso %s; ",
2012: which, iso_ntoa(&su->siso.siso_addr));
2013: break;
2014: case AF_NS:
2015: (void) printf("%s: xns %s; ",
2016: which, ns_ntoa(su->sns.sns_addr));
2017: break;
1.17 gwr 2018: #endif /* SMALL */
2019: default:
1.19 christos 2020: (void) printf("af %p: %s; ",
1.17 gwr 2021: which, any_ntoa(&su->sa));
1.1 cgd 2022: }
2023: (void) fflush(stdout);
2024: }
1.7 mycroft 2025:
1.1 cgd 2026: /* States*/
2027: #define VIRGIN 0
2028: #define GOTONE 1
2029: #define GOTTWO 2
2030: /* Inputs */
2031: #define DIGIT (4*0)
2032: #define END (4*1)
2033: #define DELIM (4*2)
2034:
1.19 christos 2035: static void
1.1 cgd 2036: sockaddr(addr, sa)
1.23 lukem 2037: char *addr;
2038: struct sockaddr *sa;
1.1 cgd 2039: {
1.23 lukem 2040: char *cp = (char *)sa;
1.1 cgd 2041: int size = sa->sa_len;
2042: char *cplim = cp + size;
1.23 lukem 2043: int byte = 0, state = VIRGIN, new = 0;
1.1 cgd 2044:
1.19 christos 2045: (void) memset(cp, 0, size);
1.7 mycroft 2046: cp++;
1.1 cgd 2047: do {
2048: if ((*addr >= '0') && (*addr <= '9')) {
2049: new = *addr - '0';
2050: } else if ((*addr >= 'a') && (*addr <= 'f')) {
2051: new = *addr - 'a' + 10;
2052: } else if ((*addr >= 'A') && (*addr <= 'F')) {
2053: new = *addr - 'A' + 10;
1.7 mycroft 2054: } else if (*addr == 0)
1.1 cgd 2055: state |= END;
2056: else
2057: state |= DELIM;
2058: addr++;
2059: switch (state /* | INPUT */) {
2060: case GOTTWO | DIGIT:
2061: *cp++ = byte; /*FALLTHROUGH*/
2062: case VIRGIN | DIGIT:
2063: state = GOTONE; byte = new; continue;
2064: case GOTONE | DIGIT:
2065: state = GOTTWO; byte = new + (byte << 4); continue;
2066: default: /* | DELIM */
2067: state = VIRGIN; *cp++ = byte; byte = 0; continue;
2068: case GOTONE | END:
2069: case GOTTWO | END:
2070: *cp++ = byte; /* FALLTHROUGH */
2071: case VIRGIN | END:
2072: break;
2073: }
2074: break;
1.7 mycroft 2075: } while (cp < cplim);
1.1 cgd 2076: sa->sa_len = cp - (char *)sa;
2077: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to route.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sbin / route