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