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