Home | History | Annotate | Line # | Download | only in route
      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