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