route.c revision 1.112
1 /* $NetBSD: route.c,v 1.112 2008/09/09 19:58:46 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.112 2008/09/09 19:58:46 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(char *, int); 81 static int newroute(int, char **); 82 static void inet_makenetandmask(u_int32_t, struct sockaddr_in *); 83 #ifdef INET6 84 static int inet6_makenetandmask(struct sockaddr_in6 *); 85 #endif 86 static int getaddr(int, char *, struct hostent **); 87 static int flushroutes(int, char *[], 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(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 **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 *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(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 **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(u_int32_t net, struct sockaddr_in *isin) 999 { 1000 u_int32_t addr, mask = 0; 1001 char *cp; 1002 1003 rtm_addrs |= RTA_NETMASK; 1004 if (net == 0) 1005 mask = addr = 0; 1006 else if (net < 128) { 1007 addr = net << IN_CLASSA_NSHIFT; 1008 mask = IN_CLASSA_NET; 1009 } else if (net < 192) { 1010 addr = net << IN_CLASSA_NSHIFT; 1011 mask = IN_CLASSB_NET; 1012 } else if (net < 224) { 1013 addr = net << IN_CLASSA_NSHIFT; 1014 mask = IN_CLASSC_NET; 1015 } else if (net < 256) { 1016 addr = net << IN_CLASSA_NSHIFT; 1017 mask = IN_CLASSD_NET; 1018 } else if (net < 49152) { /* 192 * 256 */ 1019 addr = net << IN_CLASSB_NSHIFT; 1020 mask = IN_CLASSB_NET; 1021 } else if (net < 57344) { /* 224 * 256 */ 1022 addr = net << IN_CLASSB_NSHIFT; 1023 mask = IN_CLASSC_NET; 1024 } else if (net < 65536) { 1025 addr = net << IN_CLASSB_NSHIFT; 1026 mask = IN_CLASSB_NET; 1027 } else if (net < 14680064L) { /* 224 * 65536 */ 1028 addr = net << IN_CLASSC_NSHIFT; 1029 mask = IN_CLASSC_NET; 1030 } else if (net < 16777216L) { 1031 addr = net << IN_CLASSC_NSHIFT; 1032 mask = IN_CLASSD_NET; 1033 } else { 1034 addr = net; 1035 if ((addr & IN_CLASSA_HOST) == 0) 1036 mask = IN_CLASSA_NET; 1037 else if ((addr & IN_CLASSB_HOST) == 0) 1038 mask = IN_CLASSB_NET; 1039 else if ((addr & IN_CLASSC_HOST) == 0) 1040 mask = IN_CLASSC_NET; 1041 else 1042 mask = -1; 1043 } 1044 isin->sin_addr.s_addr = htonl(addr); 1045 isin = &so_mask.sin; 1046 isin->sin_addr.s_addr = htonl(mask); 1047 isin->sin_len = 0; 1048 isin->sin_family = 0; 1049 cp = (char *)(&isin->sin_addr + 1); 1050 while (*--cp == 0 && cp > (char *)isin) 1051 ; 1052 isin->sin_len = 1 + cp - (char *)isin; 1053 isin->sin_family = AF_INET; 1054 } 1055 1056 #ifdef INET6 1057 /* 1058 * XXX the function may need more improvement... 1059 */ 1060 static int 1061 inet6_makenetandmask(struct sockaddr_in6 *sin6) 1062 { 1063 const char *plen; 1064 struct in6_addr in6; 1065 1066 plen = NULL; 1067 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) && 1068 sin6->sin6_scope_id == 0) { 1069 plen = "0"; 1070 } else if ((sin6->sin6_addr.s6_addr[0] & 0xe0) == 0x20) { 1071 /* aggregatable global unicast - RFC2374 */ 1072 memset(&in6, 0, sizeof(in6)); 1073 if (!memcmp(&sin6->sin6_addr.s6_addr[8], &in6.s6_addr[8], 8)) 1074 plen = "64"; 1075 } 1076 1077 if (!plen || strcmp(plen, "128") == 0) 1078 return 1; 1079 else { 1080 rtm_addrs |= RTA_NETMASK; 1081 (void)prefixlen(plen); 1082 return 0; 1083 } 1084 } 1085 #endif 1086 1087 /* 1088 * Interpret an argument as a network address of some kind, 1089 * returning 1 if a host address, 0 if a network address. 1090 */ 1091 static int 1092 getaddr(int which, char *s, struct hostent **hpp) 1093 { 1094 sup su; 1095 struct hostent *hp; 1096 struct netent *np; 1097 u_int32_t val; 1098 char *t; 1099 int afamily; /* local copy of af so we can change it */ 1100 1101 if (af == AF_UNSPEC) { 1102 af = AF_INET; 1103 aflen = sizeof(struct sockaddr_in); 1104 } 1105 afamily = af; 1106 rtm_addrs |= which; 1107 switch (which) { 1108 case RTA_DST: 1109 su = &so_dst; 1110 break; 1111 case RTA_GATEWAY: 1112 su = &so_gate; 1113 break; 1114 case RTA_NETMASK: 1115 su = &so_mask; 1116 break; 1117 case RTA_GENMASK: 1118 su = &so_genmask; 1119 break; 1120 case RTA_IFP: 1121 su = &so_ifp; 1122 afamily = AF_LINK; 1123 break; 1124 case RTA_IFA: 1125 su = &so_ifa; 1126 su->sa.sa_family = af; 1127 break; 1128 default: 1129 su = NULL; 1130 usage("Internal Error"); 1131 /*NOTREACHED*/ 1132 } 1133 su->sa.sa_len = aflen; 1134 su->sa.sa_family = afamily; /* cases that don't want it have left already */ 1135 if (strcmp(s, "default") == 0) { 1136 switch (which) { 1137 case RTA_DST: 1138 forcenet++; 1139 (void)getaddr(RTA_NETMASK, s, 0); 1140 break; 1141 case RTA_NETMASK: 1142 case RTA_GENMASK: 1143 su->sa.sa_len = 0; 1144 } 1145 return 0; 1146 } 1147 switch (afamily) { 1148 #ifdef INET6 1149 case AF_INET6: 1150 { 1151 struct addrinfo hints, *res; 1152 char *slash = 0; 1153 1154 if (which == RTA_DST && (slash = (strrchr(s, '/'))) != 0) 1155 *slash = '\0'; 1156 memset(&hints, 0, sizeof(hints)); 1157 hints.ai_family = afamily; /*AF_INET6*/ 1158 hints.ai_flags = AI_NUMERICHOST; 1159 hints.ai_socktype = SOCK_DGRAM; /*dummy*/ 1160 if (getaddrinfo(s, "0", &hints, &res) != 0) { 1161 hints.ai_flags = 0; 1162 if (slash) { 1163 *slash = '/'; 1164 slash = 0; 1165 } 1166 if (getaddrinfo(s, "0", &hints, &res) != 0) 1167 errx(EXIT_FAILURE, "%s: bad value", s); 1168 } 1169 if (slash) 1170 *slash = '/'; 1171 if (sizeof(su->sin6) != res->ai_addrlen) 1172 errx(EXIT_FAILURE, "%s: bad value", s); 1173 if (res->ai_next) { 1174 errx(EXIT_FAILURE, 1175 "%s: address resolved to multiple values", s); 1176 } 1177 memcpy(&su->sin6, res->ai_addr, sizeof(su->sin6)); 1178 freeaddrinfo(res); 1179 #ifdef __KAME__ 1180 if ((IN6_IS_ADDR_LINKLOCAL(&su->sin6.sin6_addr) || 1181 IN6_IS_ADDR_MC_LINKLOCAL(&su->sin6.sin6_addr)) && 1182 su->sin6.sin6_scope_id) { 1183 *(u_int16_t *)&su->sin6.sin6_addr.s6_addr[2] = 1184 htons(su->sin6.sin6_scope_id); 1185 su->sin6.sin6_scope_id = 0; 1186 } 1187 #endif 1188 if (hints.ai_flags == AI_NUMERICHOST) { 1189 if (slash) 1190 return prefixlen(slash + 1); 1191 if (which == RTA_DST) 1192 return inet6_makenetandmask(&su->sin6); 1193 return 0; 1194 } else 1195 return 1; 1196 } 1197 #endif 1198 1199 #ifndef SMALL 1200 case AF_OSI: 1201 su->siso.siso_addr = *iso_addr(s); 1202 if (which == RTA_NETMASK || which == RTA_GENMASK) { 1203 const char *cp = TSEL(&su->siso); 1204 su->siso.siso_nlen = 0; 1205 do {--cp ;} while ((cp > (char *)su) && (*cp == 0)); 1206 su->siso.siso_len = 1 + cp - (char *)su; 1207 } 1208 return 1; 1209 #endif /* SMALL */ 1210 1211 case PF_ROUTE: 1212 su->sa.sa_len = sizeof(*su); 1213 sockaddr(s, &su->sa); 1214 return 1; 1215 1216 #ifndef SMALL 1217 case AF_APPLETALK: 1218 t = strchr (s, '.'); 1219 if (!t) { 1220 badataddr: 1221 errx(EXIT_FAILURE, "bad address: %s", s); 1222 } 1223 val = atoi (s); 1224 if (val > 65535) 1225 goto badataddr; 1226 su->sat.sat_addr.s_net = val; 1227 val = atoi (t); 1228 if (val > 256) 1229 goto badataddr; 1230 su->sat.sat_addr.s_node = val; 1231 rtm_addrs |= RTA_NETMASK; 1232 return(forcehost || su->sat.sat_addr.s_node != 0); 1233 #endif 1234 1235 case AF_LINK: 1236 link_addr(s, &su->sdl); 1237 return 1; 1238 1239 case AF_INET: 1240 default: 1241 break; 1242 } 1243 1244 if (hpp == NULL) 1245 hpp = &hp; 1246 *hpp = NULL; 1247 1248 if ((t = strchr(s, '/')) != NULL && which == RTA_DST) { 1249 *t = '\0'; 1250 if (forcenet == 0) { 1251 if ((val = inet_addr(s)) != INADDR_NONE) { 1252 inet_makenetandmask(htonl(val), &su->sin); 1253 return prefixlen(&t[1]); 1254 } 1255 } else { 1256 if ((val = inet_network(s)) != INADDR_NONE) { 1257 inet_makenetandmask(val, &su->sin); 1258 return prefixlen(&t[1]); 1259 } 1260 } 1261 *t = '/'; 1262 } 1263 if (inet_aton(s, &su->sin.sin_addr) && 1264 (which != RTA_DST || forcenet == 0)) { 1265 val = su->sin.sin_addr.s_addr; 1266 if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY) 1267 return 1; 1268 else { 1269 val = ntohl(val); 1270 goto netdone; 1271 } 1272 } 1273 if ((val = inet_network(s)) != INADDR_NONE || 1274 ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0)) { 1275 netdone: 1276 if (which == RTA_DST) 1277 inet_makenetandmask(val, &su->sin); 1278 return 0; 1279 } 1280 hp = gethostbyname(s); 1281 if (hp) { 1282 *hpp = hp; 1283 su->sin.sin_family = hp->h_addrtype; 1284 memmove(&su->sin.sin_addr, hp->h_addr, hp->h_length); 1285 return 1; 1286 } 1287 errx(EXIT_FAILURE, "%s: bad value", s); 1288 /*NOTREACHED*/ 1289 } 1290 1291 int 1292 prefixlen(const char *s) 1293 { 1294 int len = atoi(s), q, r; 1295 int max; 1296 1297 switch (af) { 1298 case AF_INET: 1299 max = sizeof(struct in_addr) * 8; 1300 break; 1301 #ifdef INET6 1302 case AF_INET6: 1303 max = sizeof(struct in6_addr) * 8; 1304 break; 1305 #endif 1306 default: 1307 errx(EXIT_FAILURE, "prefixlen is not supported with af %d", af); 1308 /*NOTREACHED*/ 1309 } 1310 1311 rtm_addrs |= RTA_NETMASK; 1312 if (len < -1 || len > max) 1313 errx(EXIT_FAILURE, "%s: bad value", s); 1314 1315 q = len >> 3; 1316 r = len & 7; 1317 switch (af) { 1318 case AF_INET: 1319 memset(&so_mask, 0, sizeof(so_mask)); 1320 so_mask.sin.sin_family = AF_INET; 1321 so_mask.sin.sin_len = sizeof(struct sockaddr_in); 1322 so_mask.sin.sin_addr.s_addr = (len == 0 ? 0 1323 : htonl(0xffffffff << (32 - len))); 1324 break; 1325 #ifdef INET6 1326 case AF_INET6: 1327 so_mask.sin6.sin6_family = AF_INET6; 1328 so_mask.sin6.sin6_len = sizeof(struct sockaddr_in6); 1329 memset((void *)&so_mask.sin6.sin6_addr, 0, 1330 sizeof(so_mask.sin6.sin6_addr)); 1331 if (q > 0) 1332 memset((void *)&so_mask.sin6.sin6_addr, 0xff, q); 1333 if (r > 0) 1334 *((u_char *)&so_mask.sin6.sin6_addr + q) = 1335 (0xff00 >> r) & 0xff; 1336 break; 1337 #endif 1338 } 1339 return len == max; 1340 } 1341 1342 #ifndef SMALL 1343 static void 1344 interfaces(void) 1345 { 1346 size_t needed; 1347 int mib[6]; 1348 char *buf, *lim, *next; 1349 struct rt_msghdr *rtm; 1350 1351 mib[0] = CTL_NET; 1352 mib[1] = PF_ROUTE; 1353 mib[2] = 0; /* protocol */ 1354 mib[3] = 0; /* wildcard address family */ 1355 mib[4] = NET_RT_IFLIST; 1356 mib[5] = 0; /* no flags */ 1357 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 1358 err(EXIT_FAILURE, "route-sysctl-estimate"); 1359 if (needed) { 1360 if ((buf = malloc(needed)) == NULL) 1361 err(EXIT_FAILURE, "malloc"); 1362 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) { 1363 err(EXIT_FAILURE, 1364 "actual retrieval of interface table"); 1365 } 1366 lim = buf + needed; 1367 for (next = buf; next < lim; next += rtm->rtm_msglen) { 1368 rtm = (struct rt_msghdr *)next; 1369 print_rtmsg(rtm, rtm->rtm_msglen); 1370 } 1371 free(buf); 1372 } 1373 } 1374 1375 static void 1376 monitor(void) 1377 { 1378 int n; 1379 union { 1380 char msg[2048]; 1381 struct rt_msghdr hdr; 1382 } u; 1383 1384 verbose = 1; 1385 if (debugonly) { 1386 interfaces(); 1387 exit(0); 1388 } 1389 for(;;) { 1390 time_t now; 1391 n = read(sock, &u, sizeof(u)); 1392 now = time(NULL); 1393 (void)printf("got message of size %d on %s", n, ctime(&now)); 1394 print_rtmsg(&u.hdr, n); 1395 } 1396 } 1397 1398 #endif /* SMALL */ 1399 1400 1401 struct { 1402 struct rt_msghdr m_rtm; 1403 char m_space[512]; 1404 } m_rtmsg; 1405 1406 static int 1407 rtmsg(int cmd, int flags) 1408 { 1409 static int seq; 1410 int rlen; 1411 char *cp = m_rtmsg.m_space; 1412 int l; 1413 1414 #define NEXTADDR(w, u) \ 1415 if (rtm_addrs & (w)) {\ 1416 l = ROUNDUP(u.sa.sa_len); memmove(cp, &(u), l); cp += l;\ 1417 if (verbose && ! shortoutput) sodump(&(u),#u);\ 1418 } 1419 1420 errno = 0; 1421 memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 1422 if (cmd == 'a') 1423 cmd = RTM_ADD; 1424 else if (cmd == 'c') 1425 cmd = RTM_CHANGE; 1426 else if (cmd == 'g') { 1427 #ifdef SMALL 1428 return -1; 1429 #else /* SMALL */ 1430 cmd = RTM_GET; 1431 if (so_ifp.sa.sa_family == AF_UNSPEC) { 1432 so_ifp.sa.sa_family = AF_LINK; 1433 so_ifp.sa.sa_len = sizeof(struct sockaddr_dl); 1434 rtm_addrs |= RTA_IFP; 1435 } 1436 #endif /* SMALL */ 1437 } else 1438 cmd = RTM_DELETE; 1439 #define rtm m_rtmsg.m_rtm 1440 rtm.rtm_type = cmd; 1441 rtm.rtm_flags = flags; 1442 rtm.rtm_version = RTM_VERSION; 1443 rtm.rtm_seq = ++seq; 1444 rtm.rtm_addrs = rtm_addrs; 1445 rtm.rtm_rmx = rt_metrics; 1446 rtm.rtm_inits = rtm_inits; 1447 1448 if (rtm_addrs & RTA_NETMASK) 1449 mask_addr(); 1450 NEXTADDR(RTA_DST, so_dst); 1451 NEXTADDR(RTA_GATEWAY, so_gate); 1452 NEXTADDR(RTA_NETMASK, so_mask); 1453 NEXTADDR(RTA_GENMASK, so_genmask); 1454 NEXTADDR(RTA_IFP, so_ifp); 1455 NEXTADDR(RTA_IFA, so_ifa); 1456 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; 1457 if (verbose && ! shortoutput) { 1458 if (rtm_addrs) 1459 putchar('\n'); 1460 print_rtmsg(&rtm, l); 1461 } 1462 if (debugonly) 1463 return 0; 1464 if ((rlen = write(sock, (char *)&m_rtmsg, l)) < 0) { 1465 warnx("writing to routing socket: %s", route_strerror(errno)); 1466 return -1; 1467 } 1468 if (rlen < l) { 1469 warnx("write to routing socket, got %d for rlen", rlen); 1470 return 1; 1471 } 1472 #ifndef SMALL 1473 if (cmd == RTM_GET) { 1474 do { 1475 l = read(sock, (char *)&m_rtmsg, sizeof(m_rtmsg)); 1476 } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid)); 1477 if (l < 0) 1478 err(EXIT_FAILURE, "read from routing socket"); 1479 else 1480 return print_getmsg(&rtm, l); 1481 } 1482 #endif /* SMALL */ 1483 #undef rtm 1484 return 0; 1485 } 1486 1487 static void 1488 mask_addr(void) 1489 { 1490 int olen = so_mask.sa.sa_len; 1491 char *cp1 = olen + (char *)&so_mask, *cp2; 1492 1493 for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; ) 1494 if (*--cp1 != 0) { 1495 so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask; 1496 break; 1497 } 1498 if ((rtm_addrs & RTA_DST) == 0) 1499 return; 1500 switch (so_dst.sa.sa_family) { 1501 case AF_INET: 1502 #ifdef INET6 1503 case AF_INET6: 1504 #endif 1505 #ifndef SMALL 1506 case AF_APPLETALK: 1507 #endif /* SMALL */ 1508 case 0: 1509 return; 1510 #ifndef SMALL 1511 case AF_ISO: 1512 olen = MIN(so_dst.siso.siso_nlen, 1513 MAX(so_mask.sa.sa_len - 6, 0)); 1514 break; 1515 #endif /* SMALL */ 1516 } 1517 cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst; 1518 cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst; 1519 while (cp2 > cp1) 1520 *--cp2 = 0; 1521 cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask; 1522 while (cp1 > so_dst.sa.sa_data) 1523 *--cp1 &= *--cp2; 1524 #ifndef SMALL 1525 switch (so_dst.sa.sa_family) { 1526 case AF_ISO: 1527 so_dst.siso.siso_nlen = olen; 1528 break; 1529 } 1530 #endif /* SMALL */ 1531 } 1532 1533 const char *msgtypes[] = { 1534 "", 1535 "RTM_ADD: Add Route", 1536 "RTM_DELETE: Delete Route", 1537 "RTM_CHANGE: Change Metrics or flags", 1538 "RTM_GET: Report Metrics", 1539 "RTM_LOSING: Kernel Suspects Partitioning", 1540 "RTM_REDIRECT: Told to use different route", 1541 "RTM_MISS: Lookup failed on this address", 1542 "RTM_LOCK: fix specified metrics", 1543 "RTM_OLDADD: caused by SIOCADDRT", 1544 "RTM_OLDDEL: caused by SIOCDELRT", 1545 "RTM_RESOLVE: Route created by cloning", 1546 "RTM_NEWADDR: address being added to iface", 1547 "RTM_DELADDR: address being removed from iface", 1548 "RTM_OIFINFO: iface status change (pre-1.5)", 1549 "RTM_IFINFO: iface status change", 1550 "RTM_IFANNOUNCE: iface arrival/departure", 1551 "RTM_IEEE80211: IEEE80211 wireless event", 1552 0, 1553 }; 1554 1555 const char metricnames[] = 1556 "\011pksent\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu"; 1557 const char routeflags[] = 1558 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE\016CLONED\017PROTO2\020PROTO1"; 1559 const char ifnetflags[] = 1560 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6NOTRAILERS\7RUNNING\010NOARP\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST"; 1561 const char addrnames[] = 1562 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD"; 1563 1564 1565 #ifndef SMALL 1566 static const char * 1567 linkstate(struct if_msghdr *ifm) 1568 { 1569 static char buf[64]; 1570 1571 switch (ifm->ifm_data.ifi_link_state) { 1572 case LINK_STATE_UNKNOWN: 1573 return "carrier: unknown"; 1574 case LINK_STATE_DOWN: 1575 return "carrier: no carrier"; 1576 case LINK_STATE_UP: 1577 return "carrier: active"; 1578 default: 1579 (void)snprintf(buf, sizeof(buf), "carrier: 0x%x", 1580 ifm->ifm_data.ifi_link_state); 1581 return buf; 1582 } 1583 } 1584 #endif /* SMALL */ 1585 1586 static void 1587 print_rtmsg(struct rt_msghdr *rtm, int msglen) 1588 { 1589 struct if_msghdr *ifm; 1590 struct ifa_msghdr *ifam; 1591 struct if_announcemsghdr *ifan; 1592 union { 1593 struct ieee80211_join_event join; 1594 struct ieee80211_leave_event leave; 1595 struct ieee80211_replay_event replay; 1596 struct ieee80211_michael_event michael; 1597 } ev; 1598 size_t evlen = 0; 1599 1600 if (verbose == 0) 1601 return; 1602 if (rtm->rtm_version != RTM_VERSION) { 1603 (void)printf("routing message version %d not understood\n", 1604 rtm->rtm_version); 1605 return; 1606 } 1607 if (msgtypes[rtm->rtm_type]) 1608 (void)printf("%s: ", msgtypes[rtm->rtm_type]); 1609 else 1610 (void)printf("#%d: ", rtm->rtm_type); 1611 (void)printf("len %d, ", rtm->rtm_msglen); 1612 switch (rtm->rtm_type) { 1613 case RTM_IFINFO: 1614 ifm = (struct if_msghdr *)rtm; 1615 (void)printf("if# %d, %s, flags: ", ifm->ifm_index, 1616 #ifdef SMALL 1617 "" 1618 #else 1619 linkstate(ifm) 1620 #endif /* SMALL */ 1621 ); 1622 bprintf(stdout, ifm->ifm_flags, ifnetflags); 1623 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs); 1624 break; 1625 case RTM_NEWADDR: 1626 case RTM_DELADDR: 1627 ifam = (struct ifa_msghdr *)rtm; 1628 (void)printf("metric %d, flags: ", ifam->ifam_metric); 1629 bprintf(stdout, ifam->ifam_flags, routeflags); 1630 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs); 1631 break; 1632 case RTM_IEEE80211: 1633 ifan = (struct if_announcemsghdr *)rtm; 1634 (void)printf("if# %d, what: ", ifan->ifan_index); 1635 switch (ifan->ifan_what) { 1636 case RTM_IEEE80211_ASSOC: 1637 printf("associate"); 1638 break; 1639 case RTM_IEEE80211_REASSOC: 1640 printf("re-associate"); 1641 break; 1642 case RTM_IEEE80211_DISASSOC: 1643 printf("disassociate"); 1644 break; 1645 case RTM_IEEE80211_SCAN: 1646 printf("scan complete"); 1647 break; 1648 case RTM_IEEE80211_JOIN: 1649 evlen = sizeof(ev.join); 1650 printf("join"); 1651 break; 1652 case RTM_IEEE80211_LEAVE: 1653 evlen = sizeof(ev.leave); 1654 printf("leave"); 1655 break; 1656 case RTM_IEEE80211_MICHAEL: 1657 evlen = sizeof(ev.michael); 1658 printf("michael"); 1659 break; 1660 case RTM_IEEE80211_REPLAY: 1661 evlen = sizeof(ev.replay); 1662 printf("replay"); 1663 break; 1664 default: 1665 evlen = 0; 1666 printf("#%d", ifan->ifan_what); 1667 break; 1668 } 1669 if (sizeof(*ifan) + evlen > ifan->ifan_msglen) { 1670 printf(" (truncated)\n"); 1671 break; 1672 } 1673 (void)memcpy(&ev, (ifan + 1), evlen); 1674 switch (ifan->ifan_what) { 1675 case RTM_IEEE80211_JOIN: 1676 case RTM_IEEE80211_LEAVE: 1677 printf(" mac %" PRIETHER, 1678 PRIETHER_ARGS(ev.join.iev_addr)); 1679 break; 1680 case RTM_IEEE80211_REPLAY: 1681 case RTM_IEEE80211_MICHAEL: 1682 printf(" src %" PRIETHER " dst %" PRIETHER 1683 " cipher %" PRIu8 " keyix %" PRIu8, 1684 PRIETHER_ARGS(ev.replay.iev_src), 1685 PRIETHER_ARGS(ev.replay.iev_dst), 1686 ev.replay.iev_cipher, 1687 ev.replay.iev_keyix); 1688 if (ifan->ifan_what == RTM_IEEE80211_REPLAY) { 1689 printf(" key rsc %#" PRIx64 1690 " frame rsc %#" PRIx64, 1691 ev.replay.iev_keyrsc, ev.replay.iev_rsc); 1692 } 1693 break; 1694 default: 1695 break; 1696 } 1697 printf("\n"); 1698 break; 1699 case RTM_IFANNOUNCE: 1700 ifan = (struct if_announcemsghdr *)rtm; 1701 (void)printf("if# %d, what: ", ifan->ifan_index); 1702 switch (ifan->ifan_what) { 1703 case IFAN_ARRIVAL: 1704 printf("arrival"); 1705 break; 1706 case IFAN_DEPARTURE: 1707 printf("departure"); 1708 break; 1709 default: 1710 printf("#%d", ifan->ifan_what); 1711 break; 1712 } 1713 printf("\n"); 1714 break; 1715 default: 1716 (void)printf("pid %d, seq %d, errno %d, flags: ", 1717 rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno); 1718 bprintf(stdout, rtm->rtm_flags, routeflags); 1719 pmsg_common(rtm); 1720 } 1721 } 1722 1723 #ifndef SMALL 1724 static int 1725 print_getmsg(struct rt_msghdr *rtm, int msglen) 1726 { 1727 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL, *ifa = NULL; 1728 struct sockaddr_dl *ifp = NULL; 1729 struct sockaddr *sa; 1730 char *cp; 1731 int i; 1732 1733 if (! shortoutput) 1734 (void)printf(" route to: %s\n", 1735 routename((struct sockaddr *) &so_dst, NULL, RTF_HOST)); 1736 if (rtm->rtm_version != RTM_VERSION) { 1737 warnx("routing message version %d not understood", 1738 rtm->rtm_version); 1739 return 1; 1740 } 1741 if (rtm->rtm_msglen > msglen) { 1742 warnx("message length mismatch, in packet %d, returned %d", 1743 rtm->rtm_msglen, msglen); 1744 } 1745 if (rtm->rtm_errno) { 1746 warnx("RTM_GET: %s (errno %d)", 1747 strerror(rtm->rtm_errno), rtm->rtm_errno); 1748 return 1; 1749 } 1750 cp = ((char *)(rtm + 1)); 1751 if (rtm->rtm_addrs) 1752 for (i = 1; i; i <<= 1) 1753 if (i & rtm->rtm_addrs) { 1754 sa = (struct sockaddr *)cp; 1755 switch (i) { 1756 case RTA_DST: 1757 dst = sa; 1758 break; 1759 case RTA_GATEWAY: 1760 gate = sa; 1761 break; 1762 case RTA_NETMASK: 1763 mask = sa; 1764 break; 1765 case RTA_IFP: 1766 if (sa->sa_family == AF_LINK && 1767 ((struct sockaddr_dl *)sa)->sdl_nlen) 1768 ifp = (struct sockaddr_dl *)sa; 1769 break; 1770 case RTA_IFA: 1771 ifa = sa; 1772 break; 1773 } 1774 ADVANCE(cp, sa); 1775 } 1776 if (dst && mask) 1777 mask->sa_family = dst->sa_family; /* XXX */ 1778 if (dst && ! shortoutput) 1779 (void)printf("destination: %s\n", 1780 routename(dst, mask, RTF_HOST)); 1781 if (mask && ! shortoutput) { 1782 int savenflag = nflag; 1783 1784 nflag = 1; 1785 (void)printf(" mask: %s\n", 1786 routename(mask, NULL, RTF_HOST)); 1787 nflag = savenflag; 1788 } 1789 if (gate && rtm->rtm_flags & RTF_GATEWAY) { 1790 const char *name; 1791 1792 name = routename(gate, NULL, RTF_HOST); 1793 if (shortoutput) { 1794 if (*name == '\0') 1795 return 1; 1796 (void)printf("%s\n", name); 1797 } else 1798 (void)printf(" gateway: %s\n", name); 1799 } 1800 if (ifa && ! shortoutput) 1801 (void)printf(" local addr: %s\n", 1802 routename(ifa, NULL, RTF_HOST)); 1803 if (ifp && ! shortoutput) 1804 (void)printf(" interface: %.*s\n", 1805 ifp->sdl_nlen, ifp->sdl_data); 1806 if (! shortoutput) { 1807 (void)printf(" flags: "); 1808 bprintf(stdout, rtm->rtm_flags, routeflags); 1809 } 1810 1811 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ') 1812 #define msec(u) (((u) + 500) / 1000) /* usec to msec */ 1813 1814 if (! shortoutput) { 1815 (void)printf("\n%s\n", "\ 1816 recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire"); 1817 printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE)); 1818 printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE)); 1819 printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH)); 1820 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT)); 1821 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rttvar), lock(RTTVAR)); 1822 printf("%8ld%c ", rtm->rtm_rmx.rmx_hopcount, lock(HOPCOUNT)); 1823 printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU)); 1824 if (rtm->rtm_rmx.rmx_expire) 1825 rtm->rtm_rmx.rmx_expire -= time(0); 1826 printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE)); 1827 } 1828 #undef lock 1829 #undef msec 1830 #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD) 1831 1832 if (shortoutput) 1833 return (rtm->rtm_addrs & RTF_GATEWAY) == 0; 1834 else if (verbose) 1835 pmsg_common(rtm); 1836 else if (rtm->rtm_addrs &~ RTA_IGN) { 1837 (void)printf("sockaddrs: "); 1838 bprintf(stdout, rtm->rtm_addrs, addrnames); 1839 putchar('\n'); 1840 } 1841 return 0; 1842 #undef RTA_IGN 1843 } 1844 #endif /* SMALL */ 1845 1846 void 1847 pmsg_common(struct rt_msghdr *rtm) 1848 { 1849 (void)printf("\nlocks: "); 1850 bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames); 1851 (void)printf(" inits: "); 1852 bprintf(stdout, rtm->rtm_inits, metricnames); 1853 pmsg_addrs((char *)(rtm + 1), rtm->rtm_addrs); 1854 } 1855 1856 static void 1857 extract_addrs(const char *cp, int addrs, const struct sockaddr *sa[], int *nmfp) 1858 { 1859 int i, nmf = -1; 1860 1861 for (i = 0; i < RTAX_MAX; i++) { 1862 if ((1 << i) & addrs) { 1863 sa[i] = (const struct sockaddr *)cp; 1864 if ((i == RTAX_DST || i == RTAX_IFA) && 1865 nmf == -1) 1866 nmf = sa[i]->sa_family; 1867 ADVANCE(cp, sa[i]); 1868 } else 1869 sa[i] = NULL; 1870 } 1871 1872 if (nmfp != NULL) 1873 *nmfp = nmf; 1874 } 1875 1876 static void 1877 pmsg_addrs(const char *cp, int addrs) 1878 { 1879 const struct sockaddr *sa[RTAX_MAX]; 1880 int i, nmf; 1881 1882 if (addrs != 0) { 1883 (void)printf("\nsockaddrs: "); 1884 bprintf(stdout, addrs, addrnames); 1885 (void)putchar('\n'); 1886 extract_addrs(cp, addrs, sa, &nmf); 1887 for (i = 0; i < RTAX_MAX; i++) { 1888 if (sa[i] == NULL) 1889 continue; 1890 1891 if (i == RTAX_NETMASK && sa[i]->sa_len) 1892 (void)printf(" %s", 1893 netmask_string(sa[i], -1, nmf)); 1894 else 1895 (void)printf(" %s", 1896 routename(sa[i], NULL, RTF_HOST)); 1897 } 1898 } 1899 (void)putchar('\n'); 1900 (void)fflush(stdout); 1901 } 1902 1903 static void 1904 bprintf(FILE *fp, int b, const char *f) 1905 { 1906 int i; 1907 int gotsome = 0; 1908 const uint8_t *s = (const uint8_t *)f; 1909 1910 if (b == 0) 1911 return; 1912 while ((i = *s++) != 0) { 1913 if (b & (1 << (i-1))) { 1914 if (gotsome == 0) 1915 i = '<'; 1916 else 1917 i = ','; 1918 (void)putc(i, fp); 1919 gotsome = 1; 1920 for (; (i = *s) > 32; s++) 1921 (void)putc(i, fp); 1922 } else 1923 while (*s > 32) 1924 s++; 1925 } 1926 if (gotsome) 1927 (void)putc('>', fp); 1928 } 1929 1930 int 1931 keyword(const char *cp) 1932 { 1933 struct keytab *kt = keywords; 1934 1935 while (kt->kt_cp && strcmp(kt->kt_cp, cp)) 1936 kt++; 1937 return kt->kt_i; 1938 } 1939 1940 static void 1941 sodump(sup su, const char *which) 1942 { 1943 #ifdef INET6 1944 char ntop_buf[NI_MAXHOST]; 1945 #endif 1946 1947 switch (su->sa.sa_family) { 1948 case AF_INET: 1949 (void)printf("%s: inet %s; ", 1950 which, inet_ntoa(su->sin.sin_addr)); 1951 break; 1952 #ifndef SMALL 1953 case AF_APPLETALK: 1954 (void)printf("%s: atalk %d.%d; ", 1955 which, su->sat.sat_addr.s_net, su->sat.sat_addr.s_node); 1956 break; 1957 #endif 1958 case AF_LINK: 1959 (void)printf("%s: link %s; ", 1960 which, link_ntoa(&su->sdl)); 1961 break; 1962 #ifdef INET6 1963 case AF_INET6: 1964 (void)printf("%s: inet6 %s; ", 1965 which, inet_ntop(AF_INET6, &su->sin6.sin6_addr, 1966 ntop_buf, sizeof(ntop_buf))); 1967 break; 1968 #endif 1969 #ifndef SMALL 1970 case AF_ISO: 1971 (void)printf("%s: iso %s; ", 1972 which, iso_ntoa(&su->siso.siso_addr)); 1973 break; 1974 #endif /* SMALL */ 1975 default: 1976 (void)printf("%s: (%d) %s; ", 1977 which, su->sa.sa_family, any_ntoa(&su->sa)); 1978 } 1979 (void)fflush(stdout); 1980 } 1981 1982 /* States*/ 1983 #define VIRGIN 0 1984 #define GOTONE 1 1985 #define GOTTWO 2 1986 /* Inputs */ 1987 #define DIGIT (4*0) 1988 #define END (4*1) 1989 #define DELIM (4*2) 1990 1991 static void 1992 sockaddr(char *addr, struct sockaddr *sa) 1993 { 1994 char *cp = (char *)sa; 1995 int size = sa->sa_len; 1996 char *cplim = cp + size; 1997 int byte = 0, state = VIRGIN, new = 0; 1998 1999 (void)memset(cp, 0, size); 2000 cp++; 2001 do { 2002 if ((*addr >= '0') && (*addr <= '9')) { 2003 new = *addr - '0'; 2004 } else if ((*addr >= 'a') && (*addr <= 'f')) { 2005 new = *addr - 'a' + 10; 2006 } else if ((*addr >= 'A') && (*addr <= 'F')) { 2007 new = *addr - 'A' + 10; 2008 } else if (*addr == 0) 2009 state |= END; 2010 else 2011 state |= DELIM; 2012 addr++; 2013 switch (state /* | INPUT */) { 2014 case GOTTWO | DIGIT: 2015 *cp++ = byte; /*FALLTHROUGH*/ 2016 case VIRGIN | DIGIT: 2017 state = GOTONE; byte = new; continue; 2018 case GOTONE | DIGIT: 2019 state = GOTTWO; byte = new + (byte << 4); continue; 2020 default: /* | DELIM */ 2021 state = VIRGIN; *cp++ = byte; byte = 0; continue; 2022 case GOTONE | END: 2023 case GOTTWO | END: 2024 *cp++ = byte; /* FALLTHROUGH */ 2025 case VIRGIN | END: 2026 break; 2027 } 2028 break; 2029 } while (cp < cplim); 2030 sa->sa_len = cp - (char *)sa; 2031 } 2032
Indexes created Thu Sep 25 16:09:42 GMT 2025