1 /* $NetBSD: rtutil.c,v 1.12 2026/11/08 16:17:24 christos Exp $ */ 2 /* $OpenBSD: show.c,v 1.1 2006/05/27 19:16:37 claudio Exp $ */ 3 4 /* 5 * Copyright (c) 1983, 1988, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #include <sys/param.h> 34 #include <sys/protosw.h> 35 #include <sys/socket.h> 36 #include <sys/sysctl.h> 37 38 #include <net/if.h> 39 #include <net/if_dl.h> 40 #include <net/if_types.h> 41 #include <net/pfvar.h> 42 #include <net/pfkeyv2.h> 43 #include <net/route.h> 44 #include <netinet/in.h> 45 #include <netinet/if_ether.h> 46 #include <netatalk/at.h> 47 #include <netmpls/mpls.h> 48 #include <arpa/inet.h> 49 50 #include <err.h> 51 #include <errno.h> 52 #include <netdb.h> 53 #include <stdio.h> 54 #include <stddef.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <unistd.h> 58 59 #include "prog_ops.h" 60 #include "rtutil.h" 61 62 #define PLEN (LONG_BIT / 4 + 2) 63 #define PFKEYV2_CHUNK sizeof(u_int64_t) 64 static char *link_print(const struct sockaddr *); 65 66 /* 67 * Definitions for showing gateway flags. 68 */ 69 struct bits { 70 int b_mask; 71 char b_val; 72 }; 73 static const struct bits bits[] = { 74 { RTF_UP, 'U' }, 75 { RTF_GATEWAY, 'G' }, 76 { RTF_HOST, 'H' }, 77 { RTF_REJECT, 'R' }, 78 { RTF_BLACKHOLE, 'B' }, 79 { RTF_DYNAMIC, 'D' }, 80 { RTF_MODIFIED, 'M' }, 81 { RTF_DONE, 'd' }, /* Completed -- for routing messages only */ 82 { RTF_MASK, 'm' }, /* Mask Present -- for routing messages only */ 83 /* { RTF_CLONING, 'C' }, */ 84 { RTF_CONNECTED, 'C' }, 85 /* { RTF_XRESOLVE, 'X' }, */ 86 { RTF_LLDATA, 'L' }, 87 { RTF_STATIC, 'S' }, 88 { RTF_PROTO1, '1' }, 89 { RTF_PROTO2, '2' }, 90 /* { RTF_PROTO3, '3' }, */ 91 /* { RTF_CLONED, 'c' }, */ 92 /* { RTF_JUMBO, 'J' }, */ 93 { RTF_ANNOUNCE, 'p' }, 94 { RTF_LOCAL, 'l'}, 95 { RTF_BROADCAST, 'b'}, 96 { 0, 0 } 97 }; 98 99 /* 100 * Width of the flags column: with RT_SFLAG every entry of the table 101 * above gets its own character position so that the flags line up. 102 * 6 is the default field width. 103 */ 104 static int 105 p_flags_width(int flags) 106 { 107 108 return (flags & RT_SFLAG) ? (int)__arraycount(bits) - 1 : 6; 109 } 110 111 #ifndef SMALL 112 static void p_tag(const struct sockaddr *sa); 113 #endif 114 static void p_rtentry(struct rt_msghdr *, int, int); 115 116 /* 117 * Print routing tables. 118 */ 119 void 120 p_rttables(int paf, int flags, int pflags, int interesting) 121 { 122 struct rt_msghdr *rtm; 123 char *buf = NULL, *next, *lim = NULL; 124 size_t needed; 125 int mib[6]; 126 struct sockaddr *sa; 127 128 mib[0] = CTL_NET; 129 mib[1] = PF_ROUTE; 130 mib[2] = 0; 131 mib[3] = paf; 132 mib[4] = NET_RT_DUMP; 133 mib[5] = 0; 134 if (prog_sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 135 err(1, "route-sysctl-estimate"); 136 if (needed > 0) { 137 if ((buf = malloc(needed)) == 0) 138 err(1, NULL); 139 if (prog_sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 140 err(1, "sysctl of routing table"); 141 lim = buf + needed; 142 } 143 144 printf("Routing tables\n"); 145 146 if (buf) { 147 for (next = buf; next < lim; next += rtm->rtm_msglen) { 148 rtm = (struct rt_msghdr *)next; 149 sa = (struct sockaddr *)(rtm + 1); 150 if ((rtm->rtm_flags & pflags) != pflags) 151 continue; 152 if (paf != AF_UNSPEC && sa->sa_family != paf) 153 continue; 154 p_rtentry(rtm, flags, interesting); 155 } 156 free(buf); 157 buf = NULL; 158 } 159 160 if (paf != 0 && paf != PF_KEY) 161 return; 162 163 #if 0 /* XXX-elad */ 164 mib[0] = CTL_NET; 165 mib[1] = PF_KEY; 166 mib[2] = PF_KEY_V2; 167 mib[3] = NET_KEY_SPD_DUMP; 168 mib[4] = mib[5] = 0; 169 170 if (prog_sysctl(mib, 4, NULL, &needed, NULL, 0) == -1) { 171 if (errno == ENOPROTOOPT) 172 return; 173 err(1, "spd-sysctl-estimate"); 174 } 175 if (needed > 0) { 176 if ((buf = malloc(needed)) == 0) 177 err(1, NULL); 178 if (prog_sysctl(mib, 4, buf, &needed, NULL, 0) == -1) 179 err(1,"sysctl of spd"); 180 lim = buf + needed; 181 } 182 183 if (buf) { 184 printf("\nEncap:\n"); 185 186 for (next = buf; next < lim; next += msg->sadb_msg_len * 187 PFKEYV2_CHUNK) { 188 msg = (struct sadb_msg *)next; 189 if (msg->sadb_msg_len == 0) 190 break; 191 p_pfkentry(msg); 192 } 193 free(buf); 194 buf = NULL; 195 } 196 #endif /* 0 */ 197 } 198 199 /* 200 * column widths; each followed by one space 201 * width of destination/gateway column 202 * strlen("fe80::aaaa:bbbb:cccc:dddd@gif0") == 30, strlen("/128") == 4 = 34 203 * strlen("aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh") == 39 204 */ 205 #ifndef INET6 206 #define WID_DST(af) 18 /* width of destination column */ 207 #define WID_GW(af) 18 /* width of gateway column */ 208 #else 209 #define WID_DST(af) ((af) == AF_INET6 ? ((flags & RT_NFLAG) ? 39 : 18) : 18) 210 #define WID_GW(af) ((af) == AF_INET6 ? ((flags & RT_NFLAG) ? 30 : 18) : 18) 211 #endif 212 213 /* 214 * Print header for routing table columns. 215 */ 216 void 217 p_rthdr(int paf, int flags) 218 { 219 int fw = p_flags_width(flags); 220 #ifndef SMALL 221 if (flags & RT_AFLAG) 222 printf("%-*.*s ", PLEN, PLEN, "Address"); 223 if (paf == PF_KEY) { 224 printf("%-18s %-5s %-18s %-5s %-5s %-22s\n", 225 "Source", "Port", "Destination", 226 "Port", "Proto", "SA(Address/Proto/Type/Direction)"); 227 return; 228 } 229 if (flags & RT_TFLAG) { 230 printf("%-*.*s %-*.*s %-*.*s %6.6s %8.8s %6.6s %7.7s" 231 " %s\n", WID_DST(paf), WID_DST(paf), "Destination", 232 WID_GW(paf), WID_GW(paf), "Gateway", 233 fw, fw, "Flags", "Refs", "Use", "Mtu", "Tag", "Interface"); 234 return; 235 } 236 #endif 237 #ifndef SMALL 238 printf("%-*.*s %-*.*s %-*.*s %6.6s %8.8s %6.6s %s\n", 239 WID_DST(paf), WID_DST(paf), "Destination", 240 WID_GW(paf), WID_GW(paf), "Gateway", 241 fw, fw, "Flags", "Refs", "Use", "Mtu", "Interface"); 242 #else 243 printf("%-*.*s %-*.*s %-*.*s\n", 244 WID_DST(paf), WID_DST(paf), "Destination", 245 WID_GW(paf), WID_GW(paf), "Gateway", 246 fw, fw, "Flags"); 247 #endif 248 } 249 250 static void 251 get_rtaddrs(int addrs, struct sockaddr *sa, struct sockaddr **rti_info) 252 { 253 int i; 254 255 for (i = 0; i < RTAX_MAX; i++) { 256 if (addrs & (1 << i)) { 257 rti_info[i] = sa; 258 sa = (struct sockaddr *)((char *)(sa) + 259 RT_ROUNDUP(sa->sa_len)); 260 } else 261 rti_info[i] = NULL; 262 } 263 } 264 265 /* 266 * Print a routing table entry. 267 */ 268 static void 269 p_rtentry(struct rt_msghdr *rtm, int flags, int interesting) 270 { 271 static int old_af = -1; 272 struct sockaddr *sa = (struct sockaddr *)(rtm + 1); 273 struct sockaddr *mask, *rti_info[RTAX_MAX]; 274 #ifndef SMALL 275 char ifbuf[IF_NAMESIZE]; 276 #endif 277 278 if ((flags & RT_LFLAG) && (rtm->rtm_flags & RTF_LLDATA)) 279 return; 280 281 if (old_af != sa->sa_family) { 282 old_af = sa->sa_family; 283 p_family(sa->sa_family); 284 p_rthdr(sa->sa_family, flags); 285 } 286 get_rtaddrs(rtm->rtm_addrs, sa, rti_info); 287 288 mask = rti_info[RTAX_NETMASK]; 289 if ((sa = rti_info[RTAX_DST]) == NULL) 290 return; 291 292 p_sockaddr(sa, mask, rtm->rtm_flags, WID_DST(sa->sa_family), flags); 293 p_sockaddr(rti_info[RTAX_GATEWAY], NULL, RTF_HOST, 294 WID_GW(sa->sa_family), flags); 295 p_flags(rtm->rtm_flags & interesting, flags); 296 #if 0 /* XXX-elad */ 297 printf("%6d %8"PRId64" ", (int)rtm->rtm_rmx.rmx_refcnt, 298 rtm->rtm_rmx.rmx_pksent); 299 #else 300 printf("%6s %8s ", "-", "-"); 301 #endif 302 #ifndef SMALL 303 if (rtm->rtm_rmx.rmx_mtu) 304 printf("%6"PRId64, rtm->rtm_rmx.rmx_mtu); 305 else 306 printf("%6s", "-"); 307 putchar((rtm->rtm_rmx.rmx_locks & RTV_MTU) ? 'L' : ' '); 308 if (flags & RT_TFLAG) 309 p_tag(rti_info[RTAX_TAG]); 310 printf(" %.16s", if_indextoname(rtm->rtm_index, ifbuf)); 311 putchar('\n'); 312 if (flags & RT_VFLAG) 313 p_rtrmx(&rtm->rtm_rmx); 314 #else 315 putchar('\n'); 316 #endif 317 } 318 319 /* 320 * Print address family header before a section of the routing table. 321 */ 322 void 323 p_family(int paf) 324 { 325 const char *afname; 326 327 switch (paf) { 328 case AF_INET: 329 afname = "Internet"; 330 break; 331 #ifdef INET6 332 case AF_INET6: 333 afname = "Internet6"; 334 break; 335 #endif 336 case PF_KEY: 337 afname = "Encap"; 338 break; 339 case AF_APPLETALK: 340 afname = "AppleTalk"; 341 break; 342 #ifndef SMALL 343 case AF_MPLS: 344 afname = "MPLS"; 345 break; 346 #endif 347 default: 348 afname = NULL; 349 break; 350 } 351 if (afname) 352 printf("\n%s:\n", afname); 353 else 354 printf("\nProtocol Family %d:\n", paf); 355 } 356 357 void 358 p_sockaddr(const struct sockaddr *sa, const struct sockaddr *mask, int rflags, 359 int width, int flags) 360 { 361 char *cp; 362 363 switch (sa->sa_family) { 364 #ifdef INET6 365 case AF_INET6: 366 { 367 struct sockaddr_in6 sa6 = *(const struct sockaddr_in6 *)sa; 368 369 inet6_getscopeid(&sa6, INET6_IS_ADDR_LINKLOCAL| 370 INET6_IS_ADDR_MC_LINKLOCAL); 371 if (rflags & RTF_HOST) 372 cp = routename((const struct sockaddr *)&sa6, flags); 373 else 374 cp = netname((const struct sockaddr *)&sa6, mask, flags); 375 break; 376 } 377 #endif 378 default: 379 if ((rflags & RTF_HOST) || mask == NULL) 380 cp = routename(sa, flags); 381 else 382 cp = netname(sa, mask, flags); 383 break; 384 } 385 if (width < 0) 386 printf("%s", cp); 387 else { 388 if (flags & RT_NFLAG) 389 printf("%-*s ", width, cp); 390 else 391 printf("%-*.*s ", width, width, cp); 392 } 393 } 394 395 void 396 p_flags(int f, int fl) 397 { 398 char name[33], *flags; 399 const struct bits *p = bits; 400 int width = p_flags_width(fl); 401 402 for (flags = name; p->b_mask && flags < &name[sizeof(name) - 2]; p++) 403 if (p->b_mask & f) 404 *flags++ = p->b_val; 405 else if (fl & RT_SFLAG) 406 *flags++ = ' '; 407 *flags = '\0'; 408 printf("%-*.*s ", width, width, name); 409 } 410 411 #ifndef SMALL 412 void 413 p_rtrmx(const struct rt_metrics *rmx) 414 { 415 printf("\texpire %10"PRId64"%c recvpipe %10"PRIu64"%c " 416 "sendpipe %10"PRIu64"%c\n", 417 (int64_t)rmx->rmx_expire, 418 (rmx->rmx_locks & RTV_EXPIRE) ? 'L' : ' ', rmx->rmx_recvpipe, 419 (rmx->rmx_locks & RTV_RPIPE) ? 'L' : ' ', rmx->rmx_sendpipe, 420 (rmx->rmx_locks & RTV_SPIPE) ? 'L' : ' '); 421 printf("\tssthresh %10"PRIu64"%c rtt %10"PRIu64"%c " 422 "rttvar %10"PRIu64"%c\n", rmx->rmx_ssthresh, 423 (rmx->rmx_locks & RTV_SSTHRESH) ? 'L' : ' ', 424 rmx->rmx_rtt, (rmx->rmx_locks & RTV_RTT) ? 'L' : ' ', 425 rmx->rmx_rttvar, (rmx->rmx_locks & RTV_RTTVAR) ? 'L' : ' '); 426 printf("\thopcount %10"PRIu64"%c\n", 427 rmx->rmx_hopcount, (rmx->rmx_locks & RTV_HOPCOUNT) ? 'L' : ' '); 428 } 429 430 static void 431 p_tag(const struct sockaddr *sa) 432 { 433 char *line; 434 435 if (sa == NULL || sa->sa_family != AF_MPLS) { 436 printf("%7s", "-"); 437 return; 438 } 439 line = mpls_ntoa(sa); 440 if (strlen(line) < 7) 441 printf("%7s", line); 442 else 443 printf("%s", line); 444 } 445 #endif 446 447 static char line[MAXHOSTNAMELEN]; 448 static char domain[MAXHOSTNAMELEN]; 449 450 char * 451 routename(const struct sockaddr *sa, int flags) 452 { 453 char *cp = NULL; 454 static int first = 1; 455 456 if (first) { 457 first = 0; 458 if (gethostname(domain, sizeof(domain)) == 0 && 459 (cp = strchr(domain, '.'))) 460 (void)strlcpy(domain, cp + 1, sizeof(domain)); 461 else 462 domain[0] = '\0'; 463 cp = NULL; 464 } 465 466 if (sa->sa_len == 0) { 467 (void)strlcpy(line, "default", sizeof(line)); 468 return (line); 469 } 470 471 switch (sa->sa_family) { 472 case AF_INET: 473 return routename4( 474 ((const struct sockaddr_in *)sa)->sin_addr.s_addr, 475 flags); 476 #ifdef INET6 477 case AF_INET6: 478 { 479 struct sockaddr_in6 sin6; 480 481 memset(&sin6, 0, sizeof(sin6)); 482 memcpy(&sin6, sa, sa->sa_len); 483 sin6.sin6_len = sizeof(struct sockaddr_in6); 484 sin6.sin6_family = AF_INET6; 485 if (sa->sa_len == sizeof(struct sockaddr_in6)) 486 inet6_getscopeid(&sin6, INET6_IS_ADDR_LINKLOCAL| 487 INET6_IS_ADDR_MC_LINKLOCAL); 488 return routename6(&sin6, flags); 489 } 490 #endif 491 case AF_LINK: 492 return link_print(sa); 493 494 #ifndef SMALL 495 case AF_MPLS: 496 return mpls_ntoa(sa); 497 498 case AF_APPLETALK: 499 (void)snprintf(line, sizeof(line), "atalk %d.%d", 500 ((const struct sockaddr_at *)sa)->sat_addr.s_net, 501 ((const struct sockaddr_at *)sa)->sat_addr.s_node); 502 break; 503 #endif 504 505 #if 0 /* XXX-elad */ 506 case AF_UNSPEC: 507 if (sa->sa_len == sizeof(struct sockaddr_rtlabel)) { 508 static char name[RTLABEL_LEN]; 509 struct sockaddr_rtlabel *sr; 510 511 sr = (struct sockaddr_rtlabel *)sa; 512 strlcpy(name, sr->sr_label, sizeof(name)); 513 return (name); 514 } 515 /* FALLTHROUGH */ 516 #endif 517 default: 518 (void)snprintf(line, sizeof(line), "(%d) %s", 519 sa->sa_family, any_ntoa(sa)); 520 break; 521 } 522 return (line); 523 } 524 525 char * 526 routename4(in_addr_t in, int flags) 527 { 528 const char *cp = NULL; 529 struct in_addr ina; 530 struct hostent *hp; 531 532 if (in == INADDR_ANY) 533 cp = "default"; 534 if (!cp && (flags & RT_NFLAG) == 0) { 535 if ((hp = gethostbyaddr((char *)&in, 536 sizeof(in), AF_INET)) != NULL) { 537 char *p; 538 if ((p = strchr(hp->h_name, '.')) && 539 !strcmp(p + 1, domain)) 540 *p = '\0'; 541 cp = hp->h_name; 542 } 543 } 544 ina.s_addr = in; 545 strlcpy(line, cp ? cp : inet_ntoa(ina), sizeof(line)); 546 547 return (line); 548 } 549 550 #ifdef INET6 551 char * 552 routename6(const struct sockaddr_in6 *sin6, int flags) 553 { 554 int niflags = 0; 555 556 if ((flags & RT_NFLAG)) 557 niflags |= NI_NUMERICHOST; 558 else 559 niflags |= NI_NOFQDN; 560 561 if (getnameinfo((const struct sockaddr *)sin6, sin6->sin6_len, 562 line, sizeof(line), NULL, 0, niflags) != 0) 563 strncpy(line, "invalid", sizeof(line)); 564 565 return (line); 566 } 567 #endif 568 569 /* 570 * Return the name of the network whose address is given. 571 * The address is assumed to be that of a net or subnet, not a host. 572 */ 573 char * 574 netname4(const struct sockaddr_in* sa4, const struct sockaddr_in *mask, int flags) 575 { 576 const char *cp = NULL; 577 struct netent *np = NULL; 578 int mbits; 579 in_addr_t in = sa4->sin_addr.s_addr; 580 581 if (mask) { 582 in_addr_t m = mask->sin_addr.s_addr ; 583 m = ntohl(m); 584 mbits = m ? 33 - ffs(m) : 0; 585 } else 586 mbits = 0; 587 588 in = ntohl(in); 589 if (in == INADDR_ANY && !mbits) 590 cp = "default"; 591 else if (!(flags & RT_NFLAG) && in != INADDR_ANY) { 592 if ((np = getnetbyaddr(in, AF_INET)) != NULL) 593 cp = np->n_name; 594 } 595 if (cp) 596 strlcpy(line, cp, sizeof(line)); 597 #define C(x) ((x) & 0xff) 598 else if (mbits < 9) 599 snprintf(line, sizeof(line), "%u/%d", C(in >> 24), mbits); 600 else if (mbits < 17) 601 snprintf(line, sizeof(line), "%u.%u/%d", 602 C(in >> 24) , C(in >> 16), mbits); 603 else if (mbits < 25) 604 snprintf(line, sizeof(line), "%u.%u.%u/%d", 605 C(in >> 24), C(in >> 16), C(in >> 8), mbits); 606 else 607 snprintf(line, sizeof(line), "%u.%u.%u.%u/%d", C(in >> 24), 608 C(in >> 16), C(in >> 8), C(in), mbits); 609 #undef C 610 return line; 611 } 612 613 #ifdef INET6 614 char * 615 netname6(const struct sockaddr_in6 *sa6, const struct sockaddr_in6 *mask, int flags) 616 { 617 struct sockaddr_in6 sin6; 618 const u_char *p; 619 int masklen, final = 0, illegal = 0; 620 int i, lim, flag, error; 621 char hbuf[NI_MAXHOST]; 622 623 sin6 = *sa6; 624 625 flag = 0; 626 masklen = 0; 627 if (mask) { 628 lim = mask->sin6_len - offsetof(struct sockaddr_in6, sin6_addr); 629 if (lim < 0) 630 lim = 0; 631 else if (lim > (int)sizeof(struct in6_addr)) 632 lim = sizeof(struct in6_addr); 633 for (p = (const u_char *)&mask->sin6_addr, i = 0; i < lim; p++) { 634 if (final && *p) { 635 illegal++; 636 sin6.sin6_addr.s6_addr[i++] = 0x00; 637 continue; 638 } 639 640 switch (*p & 0xff) { 641 case 0xff: 642 masklen += 8; 643 break; 644 case 0xfe: 645 masklen += 7; 646 final++; 647 break; 648 case 0xfc: 649 masklen += 6; 650 final++; 651 break; 652 case 0xf8: 653 masklen += 5; 654 final++; 655 break; 656 case 0xf0: 657 masklen += 4; 658 final++; 659 break; 660 case 0xe0: 661 masklen += 3; 662 final++; 663 break; 664 case 0xc0: 665 masklen += 2; 666 final++; 667 break; 668 case 0x80: 669 masklen += 1; 670 final++; 671 break; 672 case 0x00: 673 final++; 674 break; 675 default: 676 final++; 677 illegal++; 678 break; 679 } 680 681 if (!illegal) 682 sin6.sin6_addr.s6_addr[i++] &= *p; 683 else 684 sin6.sin6_addr.s6_addr[i++] = 0x00; 685 } 686 while (i < (int)sizeof(struct in6_addr)) 687 sin6.sin6_addr.s6_addr[i++] = 0x00; 688 } else 689 masklen = 128; 690 691 if (masklen == 0 && IN6_IS_ADDR_UNSPECIFIED(&sin6.sin6_addr)) { 692 snprintf(line, sizeof(line), "default"); 693 return (line); 694 } 695 696 if (illegal) 697 warnx("illegal prefixlen"); 698 699 if (flags & RT_NFLAG) 700 flag |= NI_NUMERICHOST; 701 error = getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, 702 hbuf, sizeof(hbuf), NULL, 0, flag); 703 if (error) 704 snprintf(hbuf, sizeof(hbuf), "invalid"); 705 706 snprintf(line, sizeof(line), "%s/%d", hbuf, masklen); 707 return (line); 708 } 709 #endif 710 711 /* 712 * Return the name of the network whose address is given. 713 * The address is assumed to be that of a net or subnet, not a host. 714 */ 715 char * 716 netname(const struct sockaddr *sa, const struct sockaddr *mask, int flags) 717 { 718 switch (sa->sa_family) { 719 720 case AF_INET: 721 return netname4((const struct sockaddr_in *)sa, 722 (const struct sockaddr_in *)mask, flags); 723 #ifdef INET6 724 case AF_INET6: 725 return netname6((const struct sockaddr_in6 *)sa, 726 (const struct sockaddr_in6 *)mask, flags); 727 #endif 728 case AF_LINK: 729 return link_print(sa); 730 default: 731 snprintf(line, sizeof(line), "af %d: %s", 732 sa->sa_family, any_ntoa(sa)); 733 break; 734 } 735 return (line); 736 } 737 738 static const char hexlist[] = "0123456789abcdef"; 739 740 char * 741 any_ntoa(const struct sockaddr *sa) 742 { 743 static char obuf[240]; 744 const char *in = sa->sa_data; 745 char *out = obuf; 746 int len = sa->sa_len - offsetof(struct sockaddr, sa_data); 747 748 *out++ = 'Q'; 749 do { 750 *out++ = hexlist[(*in >> 4) & 15]; 751 *out++ = hexlist[(*in++) & 15]; 752 *out++ = '.'; 753 } while (--len > 0 && (out + 3) < &obuf[sizeof(obuf) - 1]); 754 out[-1] = '\0'; 755 return (obuf); 756 } 757 758 static char * 759 link_print(const struct sockaddr *sa) 760 { 761 const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)sa; 762 const u_char *lla = (const u_char *)sdl->sdl_data + sdl->sdl_nlen; 763 764 if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 && 765 sdl->sdl_slen == 0) { 766 (void)snprintf(line, sizeof(line), "link#%d", sdl->sdl_index); 767 return (line); 768 } 769 switch (sdl->sdl_type) { 770 case IFT_ETHER: 771 case IFT_CARP: 772 return ether_ntoa((const struct ether_addr *)lla); 773 default: 774 return link_ntoa(sdl); 775 } 776 } 777 778 #ifndef SMALL 779 char * 780 mpls_ntoa(const struct sockaddr *sa) 781 { 782 static char obuf[16]; 783 size_t olen; 784 const union mpls_shim *pms; 785 union mpls_shim ms; 786 int psize = sizeof(struct sockaddr_mpls); 787 788 pms = &((const struct sockaddr_mpls*)sa)->smpls_addr; 789 ms.s_addr = ntohl(pms->s_addr); 790 791 snprintf(obuf, sizeof(obuf), "%u", ms.shim.label); 792 793 while(psize < sa->sa_len) { 794 pms++; 795 ms.s_addr = ntohl(pms->s_addr); 796 olen = strlen(obuf); 797 snprintf(obuf + olen, sizeof(obuf) - olen, ",%u", 798 ms.shim.label); 799 psize+=sizeof(ms); 800 } 801 return obuf; 802 } 803 #endif 804 805 void 806 p_addr(const struct sockaddr *sa, const struct sockaddr *mask, int rflags, int flags) 807 { 808 p_sockaddr(sa, mask, rflags, WID_DST(sa->sa_family), flags); 809 } 810 811 void 812 p_gwaddr(const struct sockaddr *sa, int gwaf, int flags) 813 { 814 p_sockaddr(sa, 0, RTF_HOST, WID_GW(gwaf), flags); 815 } 816