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