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