xref: /netbsd-src/sbin/route/rtutil.c (revision bdc22b2e01993381dcefeff2bc9b56ca75a4235c)
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