1 /* $OpenBSD: route.c,v 1.267 2024/05/09 08:35:40 florian Exp $ */
2 /* $NetBSD: route.c,v 1.16 1996/04/15 18:27:05 cgd Exp $ */
3
4 /*
5 * Copyright (c) 1983, 1989, 1991, 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/socket.h>
34 #include <sys/sysctl.h>
35
36 #include <net/if.h>
37 #include <net/if_dl.h>
38 #include <net/if_media.h>
39 #include <net/if_types.h>
40 #include <net/route.h>
41 #include <netinet/in.h>
42 #include <netmpls/mpls.h>
43
44 #ifdef BFD
45 #include <sys/time.h>
46 #include <net/bfd.h>
47 #endif
48
49 #include <arpa/inet.h>
50 #include <netdb.h>
51
52 #include <ifaddrs.h>
53 #include <errno.h>
54 #include <fcntl.h>
55 #include <unistd.h>
56 #include <limits.h>
57 #include <stdio.h>
58 #include <ctype.h>
59 #include <stddef.h>
60 #include <stdlib.h>
61 #include <string.h>
62 #include <time.h>
63 #include <paths.h>
64 #include <err.h>
65
66 #include "keywords.h"
67 #include "show.h"
68
69 const struct if_status_description
70 if_status_descriptions[] = LINK_STATE_DESCRIPTIONS;
71
72 union sockunion so_dst, so_gate, so_mask, so_ifa, so_ifp, so_src, so_label,
73 so_source;
74
75 typedef union sockunion *sup;
76 pid_t pid;
77 int rtm_addrs, s;
78 int forcehost, forcenet, Fflag, nflag, qflag, tflag, Tflag;
79 int iflag, verbose, aflen = sizeof(struct sockaddr_in);
80 int locking, lockrest, debugonly;
81 u_long mpls_flags = MPLS_OP_LOCAL;
82 u_long rtm_inits;
83 uid_t uid;
84 u_int tableid;
85
86 struct rt_metrics rt_metrics;
87
88 int flushroutes(int, char **);
89 int newroute(int, char **);
90 int setsource(int, char **);
91 int pushsrc(int, char *, int);
92 int show(int, char *[]);
93 int keycmp(const void *, const void *);
94 int keyword(char *);
95 void monitor(int, char *[]);
96 int nameserver(int, char **);
97 int prefixlen(int, char *);
98 void sockaddr(char *, struct sockaddr *);
99 void sodump(sup, char *);
100 char *priorityname(uint8_t);
101 uint8_t getpriority(char *);
102 void print_getmsg(struct rt_msghdr *, int);
103 #ifdef BFD
104 const char *bfd_state(unsigned int);
105 const char *bfd_diag(unsigned int);
106 const char *bfd_calc_uptime(time_t);
107 void print_bfdmsg(struct rt_msghdr *);
108 void print_sabfd(struct sockaddr_bfd *, int);
109 #endif
110 const char *get_linkstate(int, int);
111 void print_rtmsg(struct rt_msghdr *, int);
112 void pmsg_common(struct rt_msghdr *);
113 void pmsg_addrs(char *, int);
114 void bprintf(FILE *, int, char *);
115 int getaddr(int, int, char *, struct hostent **);
116 void getmplslabel(char *, int);
117 int rtmsg(int, int, int, uint8_t);
118 __dead void usage(char *);
119 void set_metric(char *, int);
120 void inet_makenetandmask(u_int32_t, struct sockaddr_in *, int);
121 void getlabel(char *);
122 int gettable(const char *);
123 int rdomain(int, char **);
124 void print_rtdns(struct sockaddr_rtdns *);
125 void print_rtstatic(struct sockaddr_rtstatic *);
126 void print_rtsearch(struct sockaddr_rtsearch *);
127 void print_80211info(struct if_ieee80211_msghdr *);
128
129 __dead void
usage(char * cp)130 usage(char *cp)
131 {
132 extern char *__progname;
133
134 if (cp)
135 warnx("botched keyword: %s", cp);
136 fprintf(stderr,
137 #ifndef SMALL
138 "usage: %s [-dnqtv] [-T rtable] command [[modifier ...] arg ...]\n",
139 #else
140 "usage: %s [-dnqtv] command [[modifier ...] arg ...]\n",
141 #endif
142 __progname);
143 exit(1);
144 }
145
146 #define ROUNDUP(a) \
147 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
148 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
149
150 int
main(int argc,char ** argv)151 main(int argc, char **argv)
152 {
153 unsigned int filter = 0;
154 int ch;
155 int rval = 0;
156 int kw;
157 int af = AF_UNSPEC;
158 #ifndef SMALL
159 int Terr = 0;
160 u_int rtable_any = RTABLE_ANY;
161 #endif
162
163 if (argc < 2)
164 usage(NULL);
165
166 #ifndef SMALL
167 tableid = getrtable();
168 #endif
169 while ((ch = getopt(argc, argv, "dnqtT:v")) != -1)
170 switch (ch) {
171 case 'n':
172 nflag = 1;
173 break;
174 case 'q':
175 qflag = 1;
176 break;
177 case 'v':
178 verbose = 1;
179 break;
180 case 't':
181 tflag = 1;
182 break;
183 #ifndef SMALL
184 case 'T':
185 Terr = gettable(optarg);
186 Tflag = 1;
187 break;
188 #endif
189 case 'd':
190 debugonly = 1;
191 break;
192 default:
193 usage(NULL);
194 /* NOTREACHED */
195 }
196 argc -= optind;
197 argv += optind;
198
199 pid = getpid();
200 uid = geteuid();
201 if (*argv == NULL)
202 usage(NULL);
203
204 kw = keyword(*argv);
205 #ifndef SMALL
206 if (Tflag && Terr != 0 && kw != K_ADD) {
207 errno = Terr;
208 err(1, "routing table %u", tableid);
209 }
210 if (kw == K_EXEC)
211 exit(rdomain(argc - 1, argv + 1));
212 #endif
213
214 if (kw == K_MONITOR) {
215 while (--argc > 0) {
216 if (**(++argv)== '-')
217 switch (keyword(*argv + 1)) {
218 case K_INET:
219 af = AF_INET;
220 break;
221 case K_INET6:
222 af = AF_INET6;
223 break;
224 case K_MPLS:
225 af = AF_MPLS;
226 break;
227 case K_IFACE:
228 case K_INTERFACE:
229 filter = ROUTE_FILTER(RTM_IFINFO) |
230 ROUTE_FILTER(RTM_IFANNOUNCE) |
231 ROUTE_FILTER(RTM_80211INFO);
232 break;
233 default:
234 usage(*argv);
235 /* NOTREACHED */
236 }
237 else
238 usage(*argv);
239 }
240 }
241
242 if (tflag)
243 s = open(_PATH_DEVNULL, O_WRONLY);
244 else
245 s = socket(AF_ROUTE, SOCK_RAW, af);
246 if (s == -1)
247 err(1, "socket");
248
249 if (filter != 0) {
250 if (setsockopt(s, AF_ROUTE, ROUTE_MSGFILTER, &filter,
251 sizeof(filter)) == -1)
252 err(1, "setsockopt(ROUTE_MSGFILTER)");
253 }
254
255 #ifndef SMALL
256 if (!tflag) {
257 /* force socket onto table user requested */
258 if (Tflag == 1 && Terr == 0) {
259 if (setsockopt(s, AF_ROUTE, ROUTE_TABLEFILTER,
260 &tableid, sizeof(tableid)) == -1)
261 err(1, "setsockopt(ROUTE_TABLEFILTER)");
262 } else {
263 if (setsockopt(s, AF_ROUTE, ROUTE_TABLEFILTER,
264 &rtable_any, sizeof(tableid)) == -1)
265 err(1, "setsockopt(ROUTE_TABLEFILTER)");
266 }
267 }
268 #endif
269
270 if (pledge("stdio dns route", NULL) == -1)
271 err(1, "pledge");
272
273 switch (kw) {
274 case K_SHOW:
275 uid = 0;
276 exit(show(argc, argv));
277 break;
278 case K_FLUSH:
279 exit(flushroutes(argc, argv));
280 break;
281 case K_SOURCEADDR:
282 nflag = 1;
283 exit(setsource(argc, argv));
284 break;
285 }
286
287 if (pledge("stdio dns", NULL) == -1)
288 err(1, "pledge");
289
290 switch (kw) {
291 case K_GET:
292 uid = 0;
293 /* FALLTHROUGH */
294 case K_CHANGE:
295 case K_ADD:
296 case K_DEL:
297 case K_DELETE:
298 rval = newroute(argc, argv);
299 break;
300 case K_MONITOR:
301 monitor(argc, argv);
302 break;
303 case K_NAMESERVER:
304 rval = nameserver(argc, argv);
305 break;
306 default:
307 usage(*argv);
308 /* NOTREACHED */
309 }
310 exit(rval);
311 }
312
313 /*
314 * Purge all entries in the routing tables not
315 * associated with network interfaces.
316 */
317 int
flushroutes(int argc,char ** argv)318 flushroutes(int argc, char **argv)
319 {
320 size_t needed;
321 int mib[7], mcnt, rlen, seqno, af = AF_UNSPEC;
322 char *buf = NULL, *next, *lim = NULL;
323 struct rt_msghdr *rtm;
324 struct sockaddr *sa;
325 uint8_t prio = 0;
326 unsigned int ifindex = 0;
327
328 if (uid)
329 errx(1, "must be root to alter routing table");
330 shutdown(s, SHUT_RD); /* Don't want to read back our messages */
331 while (--argc > 0) {
332 if (**(++argv) == '-')
333 switch (keyword(*argv + 1)) {
334 case K_INET:
335 af = AF_INET;
336 break;
337 case K_INET6:
338 af = AF_INET6;
339 break;
340 case K_LINK:
341 af = AF_LINK;
342 break;
343 case K_MPLS:
344 af = AF_MPLS;
345 break;
346 case K_IFACE:
347 case K_INTERFACE:
348 if (!--argc)
349 usage(1+*argv);
350 ifindex = if_nametoindex(*++argv);
351 if (ifindex == 0)
352 errx(1, "no such interface %s", *argv);
353 break;
354 case K_PRIORITY:
355 if (!--argc)
356 usage(1+*argv);
357 prio = getpriority(*++argv);
358 break;
359 default:
360 usage(*argv);
361 /* NOTREACHED */
362 }
363 else
364 usage(*argv);
365 }
366 mib[0] = CTL_NET;
367 mib[1] = PF_ROUTE;
368 mib[2] = 0; /* protocol */
369 mib[3] = af;
370 mib[4] = NET_RT_DUMP;
371 mib[5] = prio;
372 mib[6] = tableid;
373 mcnt = 7;
374
375 needed = get_sysctl(mib, mcnt, &buf);
376 lim = buf + needed;
377
378 if (pledge("stdio dns", NULL) == -1)
379 err(1, "pledge");
380
381 if (verbose) {
382 printf("Examining routing table from sysctl\n");
383 if (af)
384 printf("(address family %s)\n", (*argv + 1));
385 }
386 if (buf == NULL)
387 return (1);
388
389 seqno = 0;
390 for (next = buf; next < lim; next += rtm->rtm_msglen) {
391 rtm = (struct rt_msghdr *)next;
392 if (rtm->rtm_version != RTM_VERSION)
393 continue;
394 if (verbose)
395 print_rtmsg(rtm, rtm->rtm_msglen);
396 if ((rtm->rtm_flags & (RTF_GATEWAY|RTF_STATIC|RTF_LLINFO)) == 0)
397 continue;
398 if ((rtm->rtm_flags & (RTF_LOCAL|RTF_BROADCAST)) != 0)
399 continue;
400 sa = (struct sockaddr *)(next + rtm->rtm_hdrlen);
401 if (ifindex && rtm->rtm_index != ifindex)
402 continue;
403 if (sa->sa_family == AF_KEY)
404 continue; /* Don't flush SPD */
405 if (debugonly)
406 continue;
407 rtm->rtm_type = RTM_DELETE;
408 rtm->rtm_seq = seqno;
409 rtm->rtm_tableid = tableid;
410 rlen = write(s, next, rtm->rtm_msglen);
411 if (rlen < (int)rtm->rtm_msglen) {
412 warn("write to routing socket");
413 printf("got only %d for rlen\n", rlen);
414 break;
415 }
416 seqno++;
417 if (qflag)
418 continue;
419 if (verbose)
420 print_rtmsg(rtm, rlen);
421 else {
422 struct sockaddr *mask, *rti_info[RTAX_MAX];
423
424 sa = (struct sockaddr *)(next + rtm->rtm_hdrlen);
425
426 get_rtaddrs(rtm->rtm_addrs, sa, rti_info);
427
428 sa = rti_info[RTAX_DST];
429 mask = rti_info[RTAX_NETMASK];
430
431 p_sockaddr(sa, mask, rtm->rtm_flags, 20);
432 p_sockaddr(rti_info[RTAX_GATEWAY], NULL, RTF_HOST, 20);
433 printf("done\n");
434 }
435 }
436 free(buf);
437 return (0);
438 }
439
440 void
set_metric(char * value,int key)441 set_metric(char *value, int key)
442 {
443 long long relative_expire;
444 const char *errstr;
445 int flag = 0;
446
447 switch (key) {
448 case K_MTU:
449 rt_metrics.rmx_mtu = strtonum(value, 0, UINT_MAX, &errstr);
450 if (errstr)
451 errx(1, "set_metric mtu: %s is %s", value, errstr);
452 flag = RTV_MTU;
453 break;
454 case K_EXPIRE:
455 relative_expire = strtonum(value, 0, INT_MAX, &errstr);
456 if (errstr)
457 errx(1, "set_metric expire: %s is %s", value, errstr);
458 rt_metrics.rmx_expire = relative_expire ?
459 relative_expire + time(NULL) : 0;
460 flag = RTV_EXPIRE;
461 break;
462 case K_HOPCOUNT:
463 case K_RECVPIPE:
464 case K_SENDPIPE:
465 case K_SSTHRESH:
466 case K_RTT:
467 case K_RTTVAR:
468 /* no longer used, only for compatibility */
469 return;
470 default:
471 errx(1, "king bula sez: set_metric with invalid key");
472 }
473 rtm_inits |= flag;
474 if (lockrest || locking)
475 rt_metrics.rmx_locks |= flag;
476 if (locking)
477 locking = 0;
478 }
479
480
481 int
setsource(int argc,char ** argv)482 setsource(int argc, char **argv)
483 {
484 struct ifaddrs *ifap, *ifa = NULL;
485 char *cmd;
486 int af = AF_UNSPEC, ret = 0, key;
487 unsigned int ifindex = 0;
488
489 cmd = argv[0];
490
491 if (argc == 1)
492 printsource(AF_UNSPEC, tableid);
493
494 while (--argc > 0) {
495 if (**(++argv)== '-') {
496 switch (key = keyword(1 + *argv)) {
497 case K_INET:
498 af = AF_INET;
499 aflen = sizeof(struct sockaddr_in);
500 break;
501 case K_INET6:
502 af = AF_INET6;
503 aflen = sizeof(struct sockaddr_in6);
504 break;
505 case K_IFP:
506 if (!--argc)
507 usage(1+*argv);
508 ifindex = if_nametoindex(*++argv);
509 if (ifindex == 0)
510 errx(1, "no such interface %s", *argv);
511 break;
512 default:
513 usage(NULL);
514 }
515 } else
516 break;
517 }
518
519 if (!(argc == 1 && ifindex == 0) && !(argc == 0 && ifindex != 0))
520 usage(NULL);
521
522 if (uid)
523 errx(1, "must be root to alter source address");
524
525 if (ifindex) {
526 if (getifaddrs(&ifap) == -1)
527 err(1, "getifaddrs");
528 for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
529 if (if_nametoindex(ifa->ifa_name) != ifindex)
530 continue;
531 if (ifa->ifa_addr == NULL ||
532 !(ifa->ifa_addr->sa_family == AF_INET ||
533 ifa->ifa_addr->sa_family == AF_INET6))
534 continue;
535 if ((af != AF_UNSPEC) &&
536 (ifa->ifa_addr->sa_family != af))
537 continue;
538 if (ifa->ifa_addr->sa_family == AF_INET6) {
539 struct sockaddr_in6 *sin6 =
540 (struct sockaddr_in6 *)ifa->ifa_addr;
541 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
542 IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
543 continue;
544 }
545 if (pushsrc(*cmd, routename(ifa->ifa_addr),
546 ifa->ifa_addr->sa_family))
547 break;
548 }
549 freeifaddrs(ifap);
550 } else {
551 ret = pushsrc(*cmd, *argv, af);
552 }
553
554 return (ret != 0);
555 }
556
557 int
pushsrc(int cmd,char * src,int af)558 pushsrc(int cmd, char *src, int af)
559 {
560 int ret = 0;
561
562 getaddr(RTA_IFA, af, src, NULL);
563
564 errno = 0;
565 ret = rtmsg(cmd, 0, 0, 0);
566 if (!qflag && ret != 0)
567 printf("sourceaddr %s: %s\n", src, strerror(errno));
568
569 return (ret);
570 }
571 int
newroute(int argc,char ** argv)572 newroute(int argc, char **argv)
573 {
574 char *cmd, *dest = "", *gateway = "", *error;
575 int ishost = 0, ret = 0, attempts, oerrno, flags = RTF_STATIC;
576 int fmask = 0, af = AF_UNSPEC;
577 int key;
578 uint8_t prio = 0;
579 struct hostent *hp = NULL;
580 int sawdest = 0;
581
582 if (uid)
583 errx(1, "must be root to alter routing table");
584 cmd = argv[0];
585 if (*cmd != 'g')
586 shutdown(s, SHUT_RD); /* Don't want to read back our messages */
587 while (--argc > 0) {
588 if (**(++argv) == '-') {
589 switch (key = keyword(1 + *argv)) {
590 case K_LINK:
591 af = AF_LINK;
592 aflen = sizeof(struct sockaddr_dl);
593 break;
594 case K_INET:
595 af = AF_INET;
596 aflen = sizeof(struct sockaddr_in);
597 break;
598 case K_INET6:
599 af = AF_INET6;
600 aflen = sizeof(struct sockaddr_in6);
601 break;
602 case K_SA:
603 af = PF_ROUTE;
604 aflen = sizeof(struct sockaddr_storage) - 1;
605 break;
606 case K_MPLS:
607 af = AF_MPLS;
608 aflen = sizeof(struct sockaddr_mpls);
609 fmask |= RTF_MPLS;
610 break;
611 case K_MPLSLABEL:
612 if (!--argc)
613 usage(1+*argv);
614 if (af != AF_INET && af != AF_INET6)
615 errx(1, "-mplslabel requires "
616 "-inet or -inet6");
617 getmplslabel(*++argv, 0);
618 mpls_flags = MPLS_OP_PUSH;
619 flags |= RTF_MPLS;
620 break;
621 case K_IN:
622 if (!--argc)
623 usage(1+*argv);
624 if (af != AF_MPLS)
625 errx(1, "-in requires -mpls");
626 getmplslabel(*++argv, 1);
627 break;
628 case K_OUT:
629 if (!--argc)
630 usage(1+*argv);
631 if (af != AF_MPLS)
632 errx(1, "-out requires -mpls");
633 if (mpls_flags == MPLS_OP_LOCAL)
634 errx(1, "-out requires -push, -pop, "
635 "-swap");
636 getmplslabel(*++argv, 0);
637 flags |= RTF_MPLS;
638 break;
639 case K_POP:
640 if (af != AF_MPLS)
641 errx(1, "-pop requires -mpls");
642 mpls_flags = MPLS_OP_POP;
643 break;
644 case K_PUSH:
645 if (af != AF_MPLS)
646 errx(1, "-push requires -mpls");
647 mpls_flags = MPLS_OP_PUSH;
648 break;
649 case K_SWAP:
650 if (af != AF_MPLS)
651 errx(1, "-swap requires -mpls");
652 mpls_flags = MPLS_OP_SWAP;
653 break;
654 case K_IFACE:
655 case K_INTERFACE:
656 iflag++;
657 break;
658 case K_NOSTATIC:
659 flags &= ~RTF_STATIC;
660 break;
661 case K_LLINFO:
662 flags |= RTF_LLINFO;
663 break;
664 case K_LOCK:
665 locking = 1;
666 break;
667 case K_LOCKREST:
668 lockrest = 1;
669 break;
670 case K_HOST:
671 forcehost++;
672 break;
673 case K_REJECT:
674 flags |= RTF_REJECT;
675 break;
676 case K_BLACKHOLE:
677 flags |= RTF_BLACKHOLE;
678 break;
679 case K_PROTO1:
680 flags |= RTF_PROTO1;
681 break;
682 case K_PROTO2:
683 flags |= RTF_PROTO2;
684 break;
685 case K_CLONING:
686 flags |= RTF_CLONING;
687 break;
688 case K_STATIC:
689 flags |= RTF_STATIC;
690 break;
691 case K_IFA:
692 if (!--argc)
693 usage(1+*argv);
694 getaddr(RTA_IFA, af, *++argv, NULL);
695 break;
696 case K_IFP:
697 if (!--argc)
698 usage(1+*argv);
699 getaddr(RTA_IFP, AF_LINK, *++argv, NULL);
700 break;
701 case K_GATEWAY:
702 if (!--argc)
703 usage(1+*argv);
704 getaddr(RTA_GATEWAY, af, *++argv, NULL);
705 gateway = *argv;
706 break;
707 case K_DST:
708 if (!--argc)
709 usage(1+*argv);
710 ishost = getaddr(RTA_DST, af, *++argv, &hp);
711 dest = *argv;
712 sawdest = 1;
713 break;
714 case K_LABEL:
715 if (!--argc)
716 usage(1+*argv);
717 getlabel(*++argv);
718 break;
719 case K_NETMASK:
720 if (!sawdest)
721 errx(1, "-netmask must follow "
722 "destination parameter");
723 if (!--argc)
724 usage(1+*argv);
725 getaddr(RTA_NETMASK, af, *++argv, NULL);
726 /* FALLTHROUGH */
727 case K_NET:
728 forcenet++;
729 break;
730 case K_PREFIXLEN:
731 if (!sawdest)
732 errx(1, "-prefixlen must follow "
733 "destination parameter");
734 if (!--argc)
735 usage(1+*argv);
736 ishost = prefixlen(af, *++argv);
737 break;
738 case K_MPATH:
739 flags |= RTF_MPATH;
740 break;
741 case K_MTU:
742 case K_HOPCOUNT:
743 case K_EXPIRE:
744 case K_RECVPIPE:
745 case K_SENDPIPE:
746 case K_SSTHRESH:
747 case K_RTT:
748 case K_RTTVAR:
749 if (!--argc)
750 usage(1+*argv);
751 set_metric(*++argv, key);
752 break;
753 case K_PRIORITY:
754 if (!--argc)
755 usage(1+*argv);
756 prio = getpriority(*++argv);
757 break;
758 case K_BFD:
759 flags |= RTF_BFD;
760 fmask |= RTF_BFD;
761 break;
762 case K_NOBFD:
763 flags &= ~RTF_BFD;
764 fmask |= RTF_BFD;
765 break;
766 default:
767 usage(1+*argv);
768 /* NOTREACHED */
769 }
770 } else {
771 if ((rtm_addrs & RTA_DST) == 0) {
772 dest = *argv;
773 sawdest = 1;
774 ishost = getaddr(RTA_DST, af, *argv, &hp);
775 } else if ((rtm_addrs & RTA_GATEWAY) == 0) {
776 gateway = *argv;
777 getaddr(RTA_GATEWAY, af, *argv, &hp);
778 } else
779 usage(NULL);
780 }
781 }
782 if (forcehost)
783 ishost = 1;
784 if (forcenet)
785 ishost = 0;
786 if (forcenet && !(rtm_addrs & RTA_NETMASK))
787 errx(1, "netmask missing");
788 flags |= RTF_UP;
789 if (ishost)
790 flags |= RTF_HOST;
791 if (iflag == 0)
792 flags |= RTF_GATEWAY;
793 for (attempts = 1; ; attempts++) {
794 errno = 0;
795 if ((ret = rtmsg(*cmd, flags, fmask, prio)) == 0)
796 break;
797 if (errno != ENETUNREACH && errno != ESRCH)
798 break;
799 if (af == AF_INET && *gateway && hp && hp->h_addr_list[1]) {
800 hp->h_addr_list++;
801 memcpy(&so_gate.sin.sin_addr, hp->h_addr_list[0],
802 hp->h_length);
803 } else
804 break;
805 }
806 oerrno = errno;
807 if (!qflag && (*cmd != 'g' || ret != 0)) {
808 printf("%s %s %s", cmd, ishost ? "host" : "net", dest);
809 if (*gateway) {
810 printf(": gateway %s", gateway);
811 if (attempts > 1 && ret == 0 && af == AF_INET)
812 printf(" (%s)", inet_ntoa(so_gate.sin.sin_addr));
813 }
814 if (ret == 0)
815 printf("\n");
816 if (ret != 0) {
817 switch (oerrno) {
818 case ESRCH:
819 error = "not in table";
820 break;
821 case EBUSY:
822 error = "entry in use";
823 break;
824 case ENOBUFS:
825 error = "routing table overflow";
826 break;
827 default:
828 error = strerror(oerrno);
829 break;
830 }
831 printf(": %s\n", error);
832 }
833 }
834 return (ret != 0);
835 }
836
837 int
show(int argc,char * argv[])838 show(int argc, char *argv[])
839 {
840 int af = AF_UNSPEC;
841 char prio = 0;
842
843 while (--argc > 0) {
844 if (**(++argv)== '-')
845 switch (keyword(*argv + 1)) {
846 case K_INET:
847 af = AF_INET;
848 break;
849 case K_INET6:
850 af = AF_INET6;
851 break;
852 case K_LINK:
853 af = AF_LINK;
854 break;
855 case K_MPLS:
856 af = AF_MPLS;
857 break;
858 case K_GATEWAY:
859 Fflag = 1;
860 break;
861 case K_LABEL:
862 if (!--argc)
863 usage(1+*argv);
864 getlabel(*++argv);
865 break;
866 case K_PRIORITY:
867 if (!--argc)
868 usage(1+*argv);
869 prio = getpriority(*++argv);
870 break;
871 default:
872 usage(*argv);
873 /* NOTREACHED */
874 }
875 else
876 usage(*argv);
877 }
878
879 p_rttables(af, tableid, prio);
880 return (0);
881 }
882
883 void
inet_makenetandmask(u_int32_t net,struct sockaddr_in * sin,int bits)884 inet_makenetandmask(u_int32_t net, struct sockaddr_in *sin, int bits)
885 {
886 u_int32_t mask;
887
888 rtm_addrs |= RTA_NETMASK;
889 if (bits == 0 && net == 0)
890 mask = 0;
891 else {
892 if (bits == 0)
893 bits = 32;
894 mask = 0xffffffff << (32 - bits);
895 net &= mask;
896 }
897 sin->sin_addr.s_addr = htonl(net);
898 sin = &so_mask.sin;
899 sin->sin_addr.s_addr = htonl(mask);
900 sin->sin_family = AF_INET;
901 sin->sin_len = sizeof(struct sockaddr_in);
902 }
903
904 /*
905 * Interpret an argument as a network address of some kind,
906 * returning 1 if a host address, 0 if a network address.
907 */
908 int
getaddr(int which,int af,char * s,struct hostent ** hpp)909 getaddr(int which, int af, char *s, struct hostent **hpp)
910 {
911 sup su = NULL;
912 struct hostent *hp;
913 int aflength, afamily, bits;
914
915 if (af == AF_UNSPEC) {
916 if (strchr(s, ':') != NULL) {
917 af = AF_INET6;
918 aflen = sizeof(struct sockaddr_in6);
919 } else {
920 af = AF_INET;
921 aflen = sizeof(struct sockaddr_in);
922 }
923 }
924 /* local copy of len and af so we can change it */
925 aflength = aflen;
926 afamily = af;
927
928 rtm_addrs |= which;
929 switch (which) {
930 case RTA_DST:
931 su = &so_dst;
932 break;
933 case RTA_GATEWAY:
934 su = &so_gate;
935 break;
936 case RTA_NETMASK:
937 su = &so_mask;
938 break;
939 case RTA_IFP:
940 su = &so_ifp;
941 aflength = sizeof(struct sockaddr_dl);
942 afamily = AF_LINK;
943 break;
944 case RTA_IFA:
945 su = &so_ifa;
946 break;
947 default:
948 errx(1, "internal error");
949 /* NOTREACHED */
950 }
951 memset(su, 0, sizeof(union sockunion));
952 su->sa.sa_len = aflength;
953 su->sa.sa_family = afamily;
954
955 if (strcmp(s, "default") == 0) {
956 switch (which) {
957 case RTA_DST:
958 forcenet++;
959 getaddr(RTA_NETMASK, af, s, NULL);
960 break;
961 case RTA_NETMASK:
962 su->sa.sa_len = 0;
963 }
964 return (0);
965 }
966
967 switch (afamily) {
968 case AF_INET6:
969 {
970 struct addrinfo hints, *res;
971 char buf[
972 sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255:255:255:255/128")
973 ];
974 char *sep;
975 int error;
976
977 if (strlcpy(buf, s, sizeof buf) >= sizeof buf) {
978 errx(1, "%s: bad value", s);
979 }
980
981 sep = strchr(buf, '/');
982 if (sep != NULL)
983 *sep++ = '\0';
984 memset(&hints, 0, sizeof(hints));
985 hints.ai_family = afamily; /*AF_INET6*/
986 hints.ai_flags = AI_NUMERICHOST;
987 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
988 error = getaddrinfo(buf, "0", &hints, &res);
989 if (error) {
990 hints.ai_flags = 0;
991 error = getaddrinfo(buf, "0", &hints, &res);
992 if (error)
993 errx(1, "%s: %s", s, gai_strerror(error));
994 }
995 if (res->ai_next)
996 errx(1, "%s: resolved to multiple values", s);
997 memcpy(&su->sin6, res->ai_addr, sizeof(su->sin6));
998 freeaddrinfo(res);
999 #ifdef __KAME__
1000 if ((IN6_IS_ADDR_LINKLOCAL(&su->sin6.sin6_addr) ||
1001 IN6_IS_ADDR_MC_LINKLOCAL(&su->sin6.sin6_addr) ||
1002 IN6_IS_ADDR_MC_INTFACELOCAL(&su->sin6.sin6_addr)) &&
1003 su->sin6.sin6_scope_id) {
1004 *(u_int16_t *)&su->sin6.sin6_addr.s6_addr[2] =
1005 htons(su->sin6.sin6_scope_id);
1006 su->sin6.sin6_scope_id = 0;
1007 }
1008 #endif
1009 if (hints.ai_flags == AI_NUMERICHOST) {
1010 if (which == RTA_DST) {
1011 if (sep == NULL && su->sin6.sin6_scope_id == 0 &&
1012 IN6_IS_ADDR_UNSPECIFIED(&su->sin6.sin6_addr))
1013 sep = "0";
1014 if (sep == NULL || prefixlen(AF_INET6, sep))
1015 return (1);
1016 }
1017 return (0);
1018 } else
1019 return (1);
1020 }
1021
1022 case AF_LINK:
1023 su->sdl.sdl_index = if_nametoindex(s);
1024 memset(&su->sdl.sdl_data, 0, sizeof(su->sdl.sdl_data));
1025 return (1);
1026 case AF_MPLS:
1027 errx(1, "mpls labels require -in or -out switch");
1028 case PF_ROUTE:
1029 su->sa.sa_len = sizeof(struct sockaddr_storage) - 1;
1030 sockaddr(s, &su->sa);
1031 return (1);
1032
1033 case AF_INET:
1034 if (hpp != NULL)
1035 *hpp = NULL;
1036 if (which == RTA_DST && !forcehost) {
1037 bits = inet_net_pton(AF_INET, s, &su->sin.sin_addr,
1038 sizeof(su->sin.sin_addr));
1039 if (bits == 32)
1040 return (1);
1041 if (bits >= 0) {
1042 inet_makenetandmask(ntohl(
1043 su->sin.sin_addr.s_addr),
1044 &su->sin, bits);
1045 return (0);
1046 }
1047 } else if (which != RTA_DST || !forcenet)
1048 if (inet_pton(AF_INET, s, &su->sin.sin_addr) == 1)
1049 return (1);
1050 hp = gethostbyname(s);
1051 if (hp == NULL)
1052 errx(1, "%s: bad address", s);
1053 if (hpp != NULL)
1054 *hpp = hp;
1055 su->sin.sin_addr = *(struct in_addr *)hp->h_addr;
1056 return (1);
1057
1058 default:
1059 errx(1, "%d: bad address family", afamily);
1060 /* NOTREACHED */
1061 }
1062 }
1063
1064 void
getmplslabel(char * s,int in)1065 getmplslabel(char *s, int in)
1066 {
1067 sup su = NULL;
1068 const char *errstr;
1069 u_int32_t label;
1070
1071 label = strtonum(s, 0, MPLS_LABEL_MAX, &errstr);
1072 if (errstr)
1073 errx(1, "bad label: %s is %s", s, errstr);
1074 if (in) {
1075 rtm_addrs |= RTA_DST;
1076 su = &so_dst;
1077 su->smpls.smpls_label = htonl(label << MPLS_LABEL_OFFSET);
1078 } else {
1079 rtm_addrs |= RTA_SRC;
1080 su = &so_src;
1081 su->smpls.smpls_label = htonl(label << MPLS_LABEL_OFFSET);
1082 }
1083
1084 su->sa.sa_len = sizeof(struct sockaddr_mpls);
1085 su->sa.sa_family = AF_MPLS;
1086 }
1087
1088 int
prefixlen(int af,char * s)1089 prefixlen(int af, char *s)
1090 {
1091 const char *errstr;
1092 int len, q, r;
1093 int max;
1094
1095 switch (af) {
1096 case AF_INET:
1097 max = sizeof(struct in_addr) * 8;
1098 break;
1099 case AF_INET6:
1100 max = sizeof(struct in6_addr) * 8;
1101 break;
1102 default:
1103 errx(1, "prefixlen is not supported with af %d", af);
1104 /* NOTREACHED */
1105 }
1106
1107 rtm_addrs |= RTA_NETMASK;
1108 len = strtonum(s, 0, max, &errstr);
1109 if (errstr)
1110 errx(1, "prefixlen %s is %s", s, errstr);
1111
1112 q = len >> 3;
1113 r = len & 7;
1114 switch (af) {
1115 case AF_INET:
1116 memset(&so_mask, 0, sizeof(so_mask));
1117 so_mask.sin.sin_family = AF_INET;
1118 so_mask.sin.sin_len = sizeof(struct sockaddr_in);
1119 if (len != 0)
1120 so_mask.sin.sin_addr.s_addr = htonl(0xffffffff << (32 - len));
1121 break;
1122 case AF_INET6:
1123 so_mask.sin6.sin6_family = AF_INET6;
1124 so_mask.sin6.sin6_len = sizeof(struct sockaddr_in6);
1125 memset((void *)&so_mask.sin6.sin6_addr, 0,
1126 sizeof(so_mask.sin6.sin6_addr));
1127 if (q > 0)
1128 memset((void *)&so_mask.sin6.sin6_addr, 0xff, q);
1129 if (r > 0)
1130 *((u_char *)&so_mask.sin6.sin6_addr + q) =
1131 (0xff00 >> r) & 0xff;
1132 break;
1133 }
1134 return (len == max);
1135 }
1136
1137 void
monitor(int argc,char * argv[])1138 monitor(int argc, char *argv[])
1139 {
1140 int n;
1141 char msg[2048];
1142 time_t now;
1143 char *ct;
1144
1145 verbose = 1;
1146 for (;;) {
1147 if ((n = read(s, msg, sizeof(msg))) == -1) {
1148 if (errno == EINTR)
1149 continue;
1150 err(1, "read");
1151 }
1152 now = time(NULL);
1153 ct = ctime(&now);
1154 if (ct)
1155 printf("got message of size %d on %s", n, ct);
1156 else
1157 printf("got message of size %d on %lld\n", n, now);
1158 print_rtmsg((struct rt_msghdr *)msg, n);
1159 }
1160 }
1161
1162
1163 int
nameserver(int argc,char * argv[])1164 nameserver(int argc, char *argv[])
1165 {
1166 struct rt_msghdr rtm;
1167 struct sockaddr_rtdns rtdns;
1168 struct iovec iov[3];
1169 struct addrinfo hints, *res;
1170 struct in_addr ns4[5];
1171 struct in6_addr ns6[5];
1172 size_t ns4_count = 0, ns6_count = 0;
1173 long pad = 0;
1174 unsigned int if_index;
1175 int error = 0, iovcnt = 0, padlen, i;
1176 char *if_name, buf[INET6_ADDRSTRLEN];
1177
1178
1179 argc--;
1180 argv++;
1181 if (argc == 0)
1182 usage(NULL);
1183
1184 if_name = *argv;
1185 argc--;
1186 argv++;
1187
1188 if ((if_index = if_nametoindex(if_name)) == 0)
1189 errx(1, "unknown interface: %s", if_name);
1190
1191 memset(&hints, 0, sizeof(hints));
1192 hints.ai_family = AF_UNSPEC;
1193 hints.ai_socktype = SOCK_STREAM;
1194 hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
1195
1196 #ifndef nitems
1197 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
1198 #endif
1199
1200 for (; argc > 0 && ns4_count + ns6_count < 5; argc--, argv++) {
1201 error = getaddrinfo(*argv, NULL, &hints, &res);
1202 if (error) {
1203 errx(1, "%s", gai_strerror(error));
1204 }
1205 if (res == NULL) {
1206 errx(1, "%s: unknown", *argv);
1207 }
1208
1209 switch (res->ai_addr->sa_family) {
1210 case AF_INET:
1211 memcpy(&ns4[ns4_count++],
1212 &((struct sockaddr_in *)res->ai_addr)->sin_addr,
1213 sizeof(struct in_addr));
1214 break;
1215 case AF_INET6:
1216 memcpy(&ns6[ns6_count++],
1217 &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr,
1218 sizeof(struct in6_addr));
1219 break;
1220 default:
1221 errx(1, "unknown address family");
1222 }
1223 freeaddrinfo(res);
1224 }
1225
1226 if (argc > 0)
1227 warnx("ignoring additional nameservers");
1228
1229 if (verbose) {
1230 for (i = 0; i < ns4_count; i++)
1231 warnx("v4: %s", inet_ntop(AF_INET, &ns4[i], buf,
1232 sizeof(buf)));
1233 for (i = 0; i < ns6_count; i++)
1234 warnx("v6: %s", inet_ntop(AF_INET6, &ns6[i], buf,
1235 sizeof(buf)));
1236 }
1237
1238 memset(&rtm, 0, sizeof(rtm));
1239
1240 rtm.rtm_version = RTM_VERSION;
1241 rtm.rtm_type = RTM_PROPOSAL;
1242 rtm.rtm_msglen = sizeof(rtm);
1243 rtm.rtm_tableid = tableid;
1244 rtm.rtm_index = if_index;
1245 rtm.rtm_seq = 1;
1246 rtm.rtm_priority = RTP_PROPOSAL_STATIC;
1247 rtm.rtm_addrs = RTA_DNS;
1248 rtm.rtm_flags = RTF_UP;
1249
1250 iov[iovcnt].iov_base = &rtm;
1251 iov[iovcnt++].iov_len = sizeof(rtm);
1252
1253 iov[iovcnt].iov_base = &rtdns;
1254 iov[iovcnt++].iov_len = sizeof(rtdns);
1255 rtm.rtm_msglen += sizeof(rtdns);
1256
1257 padlen = ROUNDUP(sizeof(rtdns)) - sizeof(rtdns);
1258 if (padlen > 0) {
1259 iov[iovcnt].iov_base = &pad;
1260 iov[iovcnt++].iov_len = padlen;
1261 rtm.rtm_msglen += padlen;
1262 }
1263
1264 memset(&rtdns, 0, sizeof(rtdns));
1265 rtdns.sr_family = AF_INET;
1266 rtdns.sr_len = 2 + ns4_count * sizeof(struct in_addr);
1267 memcpy(rtdns.sr_dns, ns4, rtdns.sr_len - 2);
1268
1269 if (debugonly)
1270 return (0);
1271
1272 if (writev(s, iov, iovcnt) == -1) {
1273 warn("failed to send route message");
1274 error = 1;
1275 }
1276
1277 rtm.rtm_seq++;
1278
1279 memset(&rtdns, 0, sizeof(rtdns));
1280 rtdns.sr_family = AF_INET6;
1281 rtdns.sr_len = 2 + ns6_count * sizeof(struct in6_addr);
1282 memcpy(rtdns.sr_dns, ns6, rtdns.sr_len - 2);
1283
1284 if (writev(s, iov, iovcnt) == -1) {
1285 warn("failed to send route message");
1286 error = 1;
1287 }
1288
1289 return (error);
1290 }
1291
1292 struct {
1293 struct rt_msghdr m_rtm;
1294 char m_space[512];
1295 } m_rtmsg;
1296
1297 int
rtmsg(int cmd,int flags,int fmask,uint8_t prio)1298 rtmsg(int cmd, int flags, int fmask, uint8_t prio)
1299 {
1300 static int seq;
1301 char *cp = m_rtmsg.m_space;
1302 int l;
1303
1304 #define NEXTADDR(w, u) \
1305 if (rtm_addrs & (w)) { \
1306 l = ROUNDUP(u.sa.sa_len); \
1307 memcpy(cp, &(u), l); \
1308 cp += l; \
1309 if (verbose) \
1310 sodump(&(u), #u); \
1311 }
1312
1313 errno = 0;
1314 memset(&m_rtmsg, 0, sizeof(m_rtmsg));
1315 if (cmd == 'a')
1316 cmd = RTM_ADD;
1317 else if (cmd == 'c')
1318 cmd = RTM_CHANGE;
1319 else if (cmd == 'g') {
1320 cmd = RTM_GET;
1321 if (so_ifp.sa.sa_family == AF_UNSPEC) {
1322 so_ifp.sa.sa_family = AF_LINK;
1323 so_ifp.sa.sa_len = sizeof(struct sockaddr_dl);
1324 rtm_addrs |= RTA_IFP;
1325 }
1326 } else if (cmd == 's') {
1327 cmd = RTM_SOURCE;
1328 } else
1329 cmd = RTM_DELETE;
1330 #define rtm m_rtmsg.m_rtm
1331 rtm.rtm_type = cmd;
1332 rtm.rtm_flags = flags;
1333 rtm.rtm_fmask = fmask;
1334 rtm.rtm_version = RTM_VERSION;
1335 rtm.rtm_seq = ++seq;
1336 rtm.rtm_addrs = rtm_addrs;
1337 rtm.rtm_rmx = rt_metrics;
1338 rtm.rtm_inits = rtm_inits;
1339 rtm.rtm_tableid = tableid;
1340 rtm.rtm_priority = prio;
1341 rtm.rtm_mpls = mpls_flags;
1342 rtm.rtm_hdrlen = sizeof(rtm);
1343
1344 /* store addresses in ascending order of RTA values */
1345 NEXTADDR(RTA_DST, so_dst);
1346 NEXTADDR(RTA_GATEWAY, so_gate);
1347 NEXTADDR(RTA_NETMASK, so_mask);
1348 NEXTADDR(RTA_IFP, so_ifp);
1349 NEXTADDR(RTA_IFA, so_ifa);
1350 NEXTADDR(RTA_SRC, so_src);
1351 NEXTADDR(RTA_LABEL, so_label);
1352 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
1353 if (verbose)
1354 print_rtmsg(&rtm, l);
1355 if (debugonly)
1356 return (0);
1357 if (write(s, &m_rtmsg, l) != l) {
1358 return (-1);
1359 }
1360 if (cmd == RTM_GET) {
1361 do {
1362 l = read(s, &m_rtmsg, sizeof(m_rtmsg));
1363 } while (l > 0 && (rtm.rtm_version != RTM_VERSION ||
1364 rtm.rtm_seq != seq || rtm.rtm_pid != pid));
1365 if (l == -1)
1366 warn("read from routing socket");
1367 else
1368 print_getmsg(&rtm, l);
1369 }
1370 #undef rtm
1371 return (0);
1372 }
1373
1374 char *msgtypes[] = {
1375 "",
1376 "RTM_ADD: Add Route",
1377 "RTM_DELETE: Delete Route",
1378 "RTM_CHANGE: Change Metrics or flags",
1379 "RTM_GET: Report Metrics",
1380 "RTM_LOSING: Kernel Suspects Partitioning",
1381 "RTM_REDIRECT: Told to use different route",
1382 "RTM_MISS: Lookup failed on this address",
1383 "",
1384 "",
1385 "",
1386 "RTM_RESOLVE: Route created by cloning",
1387 "RTM_NEWADDR: address being added to iface",
1388 "RTM_DELADDR: address being removed from iface",
1389 "RTM_IFINFO: iface status change",
1390 "RTM_IFANNOUNCE: iface arrival/departure",
1391 "RTM_DESYNC: route socket overflow",
1392 "RTM_INVALIDATE: invalidate cache of L2 route",
1393 "RTM_BFD: bidirectional forwarding detection",
1394 "RTM_PROPOSAL: config proposal",
1395 "RTM_CHGADDRATTR: address attributes being changed",
1396 "RTM_80211INFO: 802.11 iface status change"
1397 };
1398
1399 char metricnames[] =
1400 "\011priority\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";
1401 char routeflags[] =
1402 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010XMASK_PRESENT"
1403 "\011CLONING\012MULTICAST\013LLINFO\014STATIC\015BLACKHOLE\016PROTO3\017PROTO2"
1404 "\020PROTO1\021CLONED\022CACHED\023MPATH\025MPLS\026LOCAL\027BROADCAST"
1405 "\030CONNECTED\031BFD";
1406 char ifnetflags[] =
1407 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6STATICARP\7RUNNING\010NOARP\011PPROMISC"
1408 "\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST"
1409 "\23AUTOCONF6TEMP\24MPLS\25WOL\26AUTOCONF6\27INET6_NOSOII\30AUTOCONF4";
1410 char addrnames[] =
1411 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD\011SRC\012SRCMASK\013LABEL\014BFD\015DNS\016STATIC\017SEARCH";
1412 char ieee80211flags[] =
1413 "\1ASCAN\2SIBSS\011WEPON\012IBSSON\013PMGTON\014DESBSSID\016ROAMING"
1414 "\020TXPOW_FIXED\021TXPOW_AUTO\022SHSLOT\023SHPREAMBLE\024QOS"
1415 "\025USEPROT\026RSNON\027PSK\030COUNTERM\031MFPR\032HTON\033PBAR"
1416 "\034BGSCAN\035AUTO_JOIN\036VHTON";
1417 char ieee80211xflags[] =
1418 "\1TX_MGMT_ONLY";
1419
1420 const char *
get_linkstate(int mt,int link_state)1421 get_linkstate(int mt, int link_state)
1422 {
1423 const struct if_status_description *p;
1424 static char buf[8];
1425
1426 for (p = if_status_descriptions; p->ifs_string != NULL; p++) {
1427 if (LINK_STATE_DESC_MATCH(p, mt, link_state))
1428 return (p->ifs_string);
1429 }
1430 snprintf(buf, sizeof(buf), "[#%d]", link_state);
1431 return buf;
1432 }
1433
1434 void
print_rtmsg(struct rt_msghdr * rtm,int msglen)1435 print_rtmsg(struct rt_msghdr *rtm, int msglen)
1436 {
1437 long long relative_expire;
1438 struct if_msghdr *ifm;
1439 struct ifa_msghdr *ifam;
1440 struct if_announcemsghdr *ifan;
1441 char ifname[IF_NAMESIZE];
1442
1443 if (verbose == 0)
1444 return;
1445 if (rtm->rtm_version != RTM_VERSION) {
1446 warnx("routing message version %u not understood",
1447 rtm->rtm_version);
1448 return;
1449 }
1450 if (rtm->rtm_type > 0 &&
1451 rtm->rtm_type < sizeof(msgtypes)/sizeof(msgtypes[0]))
1452 printf("%s", msgtypes[rtm->rtm_type]);
1453 else
1454 printf("[rtm_type %u out of range]", rtm->rtm_type);
1455
1456 printf(": len %u", rtm->rtm_msglen);
1457 switch (rtm->rtm_type) {
1458 case RTM_DESYNC:
1459 printf("\n");
1460 break;
1461 case RTM_IFINFO:
1462 ifm = (struct if_msghdr *)rtm;
1463 printf(", if# %u, ", ifm->ifm_index);
1464 if (if_indextoname(ifm->ifm_index, ifname) != NULL)
1465 printf("name %s, ", ifname);
1466 printf("link: %s, mtu: %u, flags:",
1467 get_linkstate(ifm->ifm_data.ifi_type,
1468 ifm->ifm_data.ifi_link_state),
1469 ifm->ifm_data.ifi_mtu);
1470 bprintf(stdout, ifm->ifm_flags | (ifm->ifm_xflags << 16),
1471 ifnetflags);
1472 pmsg_addrs((char *)ifm + ifm->ifm_hdrlen, ifm->ifm_addrs);
1473 break;
1474 case RTM_80211INFO:
1475 printf(", if# %u, ", rtm->rtm_index);
1476 if (if_indextoname(rtm->rtm_index, ifname) != NULL)
1477 printf("name %s, ", ifname);
1478 print_80211info((struct if_ieee80211_msghdr *)rtm);
1479 break;
1480 case RTM_NEWADDR:
1481 case RTM_DELADDR:
1482 case RTM_CHGADDRATTR:
1483 ifam = (struct ifa_msghdr *)rtm;
1484 printf(", if# %u, ", ifam->ifam_index);
1485 if (if_indextoname(ifam->ifam_index, ifname) != NULL)
1486 printf("name %s, ", ifname);
1487 printf("metric %d, flags:", ifam->ifam_metric);
1488 bprintf(stdout, ifam->ifam_flags, routeflags);
1489 pmsg_addrs((char *)ifam + ifam->ifam_hdrlen, ifam->ifam_addrs);
1490 break;
1491 case RTM_IFANNOUNCE:
1492 ifan = (struct if_announcemsghdr *)rtm;
1493 printf(", if# %u, name %s, what: ",
1494 ifan->ifan_index, ifan->ifan_name);
1495 switch (ifan->ifan_what) {
1496 case IFAN_ARRIVAL:
1497 printf("arrival");
1498 break;
1499 case IFAN_DEPARTURE:
1500 printf("departure");
1501 break;
1502 default:
1503 printf("#%u", ifan->ifan_what);
1504 break;
1505 }
1506 printf("\n");
1507 break;
1508 #ifdef BFD
1509 case RTM_BFD:
1510 print_bfdmsg(rtm);
1511 break;
1512 #endif
1513 case RTM_PROPOSAL:
1514 printf(", source ");
1515 switch (rtm->rtm_priority) {
1516 case RTP_PROPOSAL_STATIC:
1517 printf("static");
1518 break;
1519 case RTP_PROPOSAL_DHCLIENT:
1520 printf("dhcp");
1521 break;
1522 case RTP_PROPOSAL_SLAAC:
1523 printf("slaac");
1524 break;
1525 case RTP_PROPOSAL_UMB:
1526 printf("umb");
1527 break;
1528 case RTP_PROPOSAL_PPP:
1529 printf("ppp");
1530 break;
1531 case RTP_PROPOSAL_SOLICIT:
1532 printf("solicit");
1533 break;
1534 default:
1535 printf("unknown");
1536 break;
1537 }
1538 printf(", table %u, if# %u, ",
1539 rtm->rtm_tableid, rtm->rtm_index);
1540 if (if_indextoname(rtm->rtm_index, ifname) != NULL)
1541 printf("name %s, ", ifname);
1542 printf("pid: %ld, seq %d, errno %d\nflags:",
1543 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1544 bprintf(stdout, rtm->rtm_flags, routeflags);
1545 printf("\nfmask:");
1546 bprintf(stdout, rtm->rtm_fmask, routeflags);
1547 if (verbose) {
1548 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1549 relative_expire = rtm->rtm_rmx.rmx_expire ?
1550 rtm->rtm_rmx.rmx_expire - time(NULL) : 0;
1551 printf("\nuse: %8llu mtu: %8u%c expire: %8lld%c",
1552 rtm->rtm_rmx.rmx_pksent,
1553 rtm->rtm_rmx.rmx_mtu, lock(MTU),
1554 relative_expire, lock(EXPIRE));
1555 #undef lock
1556 }
1557 printf("\nlocks: ");
1558 bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
1559 printf(" inits: ");
1560 bprintf(stdout, rtm->rtm_inits, metricnames);
1561 pmsg_addrs(((char *)rtm + rtm->rtm_hdrlen),
1562 rtm->rtm_addrs & ~(RTA_STATIC | RTA_SEARCH | RTA_DNS));
1563
1564 if(!(rtm->rtm_addrs & (RTA_STATIC | RTA_SEARCH | RTA_DNS)))
1565 break;
1566
1567 printf("proposals: ");
1568 bprintf(stdout, rtm->rtm_addrs & (RTA_STATIC | RTA_SEARCH |
1569 RTA_DNS), addrnames);
1570 putchar('\n');
1571
1572 if (rtm->rtm_addrs & RTA_STATIC) {
1573 char *next = (char *)rtm + rtm->rtm_hdrlen;
1574 struct sockaddr *sa, *rti_info[RTAX_MAX];
1575 struct sockaddr_rtstatic *rtstatic;
1576 sa = (struct sockaddr *)next;
1577 get_rtaddrs(rtm->rtm_addrs, sa, rti_info);
1578 rtstatic = (struct sockaddr_rtstatic *)
1579 rti_info[RTAX_STATIC];
1580 if (rtstatic != NULL)
1581 print_rtstatic(rtstatic);
1582 }
1583
1584 if (rtm->rtm_addrs & RTA_SEARCH) {
1585 char *next = (char *)rtm + rtm->rtm_hdrlen;
1586 struct sockaddr *sa, *rti_info[RTAX_MAX];
1587 struct sockaddr_rtsearch *rtsearch;
1588 sa = (struct sockaddr *)next;
1589 get_rtaddrs(rtm->rtm_addrs, sa, rti_info);
1590 rtsearch = (struct sockaddr_rtsearch *)
1591 rti_info[RTAX_SEARCH];
1592 if (rtsearch != NULL)
1593 print_rtsearch(rtsearch);
1594 }
1595
1596 if (rtm->rtm_addrs & RTA_DNS) {
1597 char *next = (char *)rtm + rtm->rtm_hdrlen;
1598 struct sockaddr *sa, *rti_info[RTAX_MAX];
1599 struct sockaddr_rtdns *rtdns;
1600 sa = (struct sockaddr *)next;
1601 get_rtaddrs(rtm->rtm_addrs, sa, rti_info);
1602 rtdns = (struct sockaddr_rtdns *)rti_info[RTAX_DNS];
1603 if (rtdns != NULL)
1604 print_rtdns(rtdns);
1605 }
1606 putchar('\n');
1607 break;
1608 default:
1609 printf(", priority %u, table %u, if# %u, ",
1610 rtm->rtm_priority, rtm->rtm_tableid, rtm->rtm_index);
1611 if (if_indextoname(rtm->rtm_index, ifname) != NULL)
1612 printf("name %s, ", ifname);
1613 printf("pid: %ld, seq %d, errno %d\nflags:",
1614 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1615 bprintf(stdout, rtm->rtm_flags, routeflags);
1616 printf("\nfmask:");
1617 bprintf(stdout, rtm->rtm_fmask, routeflags);
1618 if (verbose) {
1619 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1620 relative_expire = rtm->rtm_rmx.rmx_expire ?
1621 rtm->rtm_rmx.rmx_expire - time(NULL) : 0;
1622 printf("\nuse: %8llu mtu: %8u%c expire: %8lld%c",
1623 rtm->rtm_rmx.rmx_pksent,
1624 rtm->rtm_rmx.rmx_mtu, lock(MTU),
1625 relative_expire, lock(EXPIRE));
1626 #undef lock
1627 }
1628 pmsg_common(rtm);
1629 }
1630 }
1631
1632 char *
priorityname(uint8_t prio)1633 priorityname(uint8_t prio)
1634 {
1635 switch (prio) {
1636 case RTP_NONE:
1637 return ("none");
1638 case RTP_LOCAL:
1639 return ("local");
1640 case RTP_CONNECTED:
1641 return ("connected");
1642 case RTP_STATIC:
1643 return ("static");
1644 case RTP_OSPF:
1645 return ("ospf");
1646 case RTP_ISIS:
1647 return ("is-is");
1648 case RTP_RIP:
1649 return ("rip");
1650 case RTP_BGP:
1651 return ("bgp");
1652 case RTP_DEFAULT:
1653 return ("default");
1654 default:
1655 return ("");
1656 }
1657 }
1658
1659 uint8_t
getpriority(char * priostr)1660 getpriority(char *priostr)
1661 {
1662 const char *errstr;
1663 uint8_t prio;
1664
1665 switch (keyword(priostr)) {
1666 case K_LOCAL:
1667 prio = RTP_LOCAL;
1668 break;
1669 case K_CONNECTED:
1670 prio = RTP_CONNECTED;
1671 break;
1672 case K_STATIC:
1673 prio = RTP_STATIC;
1674 break;
1675 case K_OSPF:
1676 prio = RTP_OSPF;
1677 break;
1678 case K_RIP:
1679 prio = RTP_RIP;
1680 break;
1681 case K_BGP:
1682 prio = RTP_BGP;
1683 break;
1684 default:
1685 prio = strtonum(priostr, -RTP_MAX, RTP_MAX, &errstr);
1686 if (errstr)
1687 errx(1, "priority is %s: %s", errstr, priostr);
1688 }
1689
1690 return (prio);
1691 }
1692
1693 void
print_getmsg(struct rt_msghdr * rtm,int msglen)1694 print_getmsg(struct rt_msghdr *rtm, int msglen)
1695 {
1696 long long relative_expire;
1697 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL, *ifa = NULL;
1698 struct sockaddr_dl *ifp = NULL;
1699 struct sockaddr_rtlabel *sa_rl = NULL;
1700 #ifdef BFD
1701 struct sockaddr_bfd *sa_bfd = NULL;
1702 #endif
1703 struct sockaddr *mpls = NULL;
1704 struct sockaddr *sa;
1705 char *cp;
1706 int i;
1707
1708 printf(" route to: %s\n", routename(&so_dst.sa));
1709 if (rtm->rtm_version != RTM_VERSION) {
1710 warnx("routing message version %u not understood",
1711 rtm->rtm_version);
1712 return;
1713 }
1714 if (rtm->rtm_msglen > msglen)
1715 warnx("message length mismatch, in packet %u, returned %d",
1716 rtm->rtm_msglen, msglen);
1717 if (rtm->rtm_errno) {
1718 warnx("RTM_GET: %s (errno %d)",
1719 strerror(rtm->rtm_errno), rtm->rtm_errno);
1720 return;
1721 }
1722 cp = ((char *)rtm + rtm->rtm_hdrlen);
1723 if (rtm->rtm_addrs)
1724 for (i = 1; i; i <<= 1)
1725 if (i & rtm->rtm_addrs) {
1726 sa = (struct sockaddr *)cp;
1727 switch (i) {
1728 case RTA_DST:
1729 dst = sa;
1730 break;
1731 case RTA_GATEWAY:
1732 gate = sa;
1733 break;
1734 case RTA_NETMASK:
1735 mask = sa;
1736 break;
1737 case RTA_IFA:
1738 ifa = sa;
1739 break;
1740 case RTA_IFP:
1741 if (sa->sa_family == AF_LINK &&
1742 ((struct sockaddr_dl *)sa)->sdl_nlen)
1743 ifp = (struct sockaddr_dl *)sa;
1744 break;
1745 case RTA_SRC:
1746 mpls = sa;
1747 break;
1748 case RTA_LABEL:
1749 sa_rl = (struct sockaddr_rtlabel *)sa;
1750 break;
1751 #ifdef BFD
1752 case RTA_BFD:
1753 sa_bfd = (struct sockaddr_bfd *)sa;
1754 break;
1755 #endif
1756 }
1757 ADVANCE(cp, sa);
1758 }
1759 if (dst && mask)
1760 mask->sa_family = dst->sa_family; /* XXX */
1761 if (dst)
1762 printf("destination: %s\n", routename(dst));
1763 if (mask) {
1764 int savenflag = nflag;
1765
1766 nflag = 1;
1767 printf(" mask: %s\n", routename(mask));
1768 nflag = savenflag;
1769 }
1770 if (gate && rtm->rtm_flags & RTF_GATEWAY)
1771 printf(" gateway: %s\n", routename(gate));
1772 if (ifp)
1773 printf(" interface: %.*s\n",
1774 ifp->sdl_nlen, ifp->sdl_data);
1775 if (ifa)
1776 printf(" if address: %s\n", routename(ifa));
1777 if (mpls) {
1778 printf(" mpls label: %s %s\n", mpls_op(rtm->rtm_mpls),
1779 routename(mpls));
1780 }
1781 printf(" priority: %u (%s)\n", rtm->rtm_priority,
1782 priorityname(rtm->rtm_priority));
1783 printf(" flags: ");
1784 bprintf(stdout, rtm->rtm_flags, routeflags);
1785 printf("\n");
1786 if (sa_rl != NULL)
1787 printf(" label: %s\n", sa_rl->sr_label);
1788 #ifdef BFD
1789 if (sa_bfd)
1790 print_sabfd(sa_bfd, rtm->rtm_fmask);
1791 #endif
1792
1793 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1794 relative_expire = rtm->rtm_rmx.rmx_expire ?
1795 rtm->rtm_rmx.rmx_expire - time(NULL) : 0;
1796 printf(" use mtu expire\n");
1797 printf("%8llu %8u%c %8lld%c\n",
1798 rtm->rtm_rmx.rmx_pksent,
1799 rtm->rtm_rmx.rmx_mtu, lock(MTU),
1800 relative_expire, lock(EXPIRE));
1801 #undef lock
1802 #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD)
1803 if (verbose)
1804 pmsg_common(rtm);
1805 else if (rtm->rtm_addrs &~ RTA_IGN) {
1806 printf("sockaddrs: ");
1807 bprintf(stdout, rtm->rtm_addrs, addrnames);
1808 putchar('\n');
1809 }
1810 #undef RTA_IGN
1811 }
1812
1813 #ifdef BFD
1814 const char *
bfd_state(unsigned int state)1815 bfd_state(unsigned int state)
1816 {
1817 switch (state) {
1818 case BFD_STATE_ADMINDOWN:
1819 return("admindown");
1820 break;
1821 case BFD_STATE_DOWN:
1822 return("down");
1823 break;
1824 case BFD_STATE_INIT:
1825 return("init");
1826 break;
1827 case BFD_STATE_UP:
1828 return("up");
1829 break;
1830 }
1831 return "invalid";
1832 }
1833
1834 const char *
bfd_diag(unsigned int diag)1835 bfd_diag(unsigned int diag)
1836 {
1837 switch (diag) {
1838 case BFD_DIAG_NONE:
1839 return("none");
1840 break;
1841 case BFD_DIAG_EXPIRED:
1842 return("expired");
1843 break;
1844 case BFD_DIAG_ECHO_FAILED:
1845 return("echo-failed");
1846 break;
1847 case BFD_DIAG_NEIGHBOR_SIGDOWN:
1848 return("neighbor-down");
1849 break;
1850 case BFD_DIAG_FIB_RESET:
1851 return("fib-reset");
1852 break;
1853 case BFD_DIAG_PATH_DOWN:
1854 return("path-down");
1855 break;
1856 case BFD_DIAG_CONCAT_PATH_DOWN:
1857 return("concat-path-down");
1858 break;
1859 case BFD_DIAG_ADMIN_DOWN:
1860 return("admindown");
1861 break;
1862 case BFD_DIAG_CONCAT_REVERSE_DOWN:
1863 return("concat-reverse-down");
1864 break;
1865 }
1866 return "invalid";
1867 }
1868
1869 const char *
bfd_calc_uptime(time_t time)1870 bfd_calc_uptime(time_t time)
1871 {
1872 static char buf[256];
1873 struct tm *tp;
1874 const char *fmt;
1875
1876 if (time > 2*86400)
1877 fmt = "%dd%kh%Mm%Ss";
1878 else if (time > 2*3600)
1879 fmt = "%kh%Mm%Ss";
1880 else if (time > 2*60)
1881 fmt = "%Mm%Ss";
1882 else
1883 fmt = "%Ss";
1884
1885 tp = localtime(&time);
1886 if (tp)
1887 (void)strftime(buf, sizeof(buf), fmt, tp);
1888 else
1889 buf[0] = '\0';
1890 return (buf);
1891 }
1892
1893 void
print_bfdmsg(struct rt_msghdr * rtm)1894 print_bfdmsg(struct rt_msghdr *rtm)
1895 {
1896 struct bfd_msghdr *bfdm = (struct bfd_msghdr *)rtm;
1897
1898 printf("\n");
1899 print_sabfd(&bfdm->bm_sa, rtm->rtm_fmask);
1900 pmsg_addrs(((char *)rtm + rtm->rtm_hdrlen), rtm->rtm_addrs);
1901 }
1902
1903 void
print_sabfd(struct sockaddr_bfd * sa_bfd,int fmask)1904 print_sabfd(struct sockaddr_bfd *sa_bfd, int fmask)
1905 {
1906 struct timeval tv;
1907
1908 gettimeofday(&tv, NULL);
1909
1910 printf(" BFD:");
1911
1912 /* only show the state, unless verbose or -bfd */
1913 if (!verbose && ((fmask & RTF_BFD) != RTF_BFD)) {
1914 printf(" %s\n", bfd_state(sa_bfd->bs_state));
1915 return;
1916 }
1917
1918 switch (sa_bfd->bs_mode) {
1919 case BFD_MODE_ASYNC:
1920 printf(" async");
1921 break;
1922 case BFD_MODE_DEMAND:
1923 printf(" demand");
1924 break;
1925 default:
1926 printf(" unknown %u", sa_bfd->bs_mode);
1927 break;
1928 }
1929
1930 printf(" state %s", bfd_state(sa_bfd->bs_state));
1931 printf(" remote %s", bfd_state(sa_bfd->bs_remotestate));
1932 printf(" laststate %s", bfd_state(sa_bfd->bs_laststate));
1933
1934 printf(" error %u", sa_bfd->bs_error);
1935 printf("\n ");
1936 printf(" diag %s", bfd_diag(sa_bfd->bs_localdiag));
1937 printf(" remote %s", bfd_diag(sa_bfd->bs_remotediag));
1938 printf("\n ");
1939 printf(" discr %u", sa_bfd->bs_localdiscr);
1940 printf(" remote %u", sa_bfd->bs_remotediscr);
1941 printf("\n ");
1942 printf(" uptime %s", bfd_calc_uptime(tv.tv_sec - sa_bfd->bs_uptime));
1943 if (sa_bfd->bs_lastuptime)
1944 printf(" last state time %s",
1945 bfd_calc_uptime(sa_bfd->bs_lastuptime));
1946 printf("\n ");
1947 printf(" mintx %u", sa_bfd->bs_mintx);
1948 printf(" minrx %u", sa_bfd->bs_minrx);
1949 printf(" minecho %u", sa_bfd->bs_minecho);
1950 printf(" multiplier %u", sa_bfd->bs_multiplier);
1951 printf("\n");
1952 }
1953 #endif /* BFD */
1954
1955 void
pmsg_common(struct rt_msghdr * rtm)1956 pmsg_common(struct rt_msghdr *rtm)
1957 {
1958 printf("\nlocks: ");
1959 bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
1960 printf(" inits: ");
1961 bprintf(stdout, rtm->rtm_inits, metricnames);
1962 pmsg_addrs(((char *)rtm + rtm->rtm_hdrlen), rtm->rtm_addrs);
1963 }
1964
1965 void
pmsg_addrs(char * cp,int addrs)1966 pmsg_addrs(char *cp, int addrs)
1967 {
1968 struct sockaddr *sa;
1969 int family = AF_UNSPEC;
1970 int i;
1971 char *p;
1972
1973 if (addrs != 0) {
1974 printf("\nsockaddrs: ");
1975 bprintf(stdout, addrs, addrnames);
1976 putchar('\n');
1977 /* first run, search for address family */
1978 p = cp;
1979 for (i = 1; i; i <<= 1)
1980 if (i & addrs) {
1981 sa = (struct sockaddr *)p;
1982 if (family == AF_UNSPEC)
1983 switch (i) {
1984 case RTA_DST:
1985 case RTA_IFA:
1986 family = sa->sa_family;
1987 }
1988 ADVANCE(p, sa);
1989 }
1990 /* second run, set address family for mask and print */
1991 p = cp;
1992 for (i = 1; i; i <<= 1)
1993 if (i & addrs) {
1994 sa = (struct sockaddr *)p;
1995 if (family != AF_UNSPEC)
1996 switch (i) {
1997 case RTA_NETMASK:
1998 sa->sa_family = family;
1999 }
2000 printf(" %s", routename(sa));
2001 ADVANCE(p, sa);
2002 }
2003 }
2004 putchar('\n');
2005 fflush(stdout);
2006 }
2007
2008 void
bprintf(FILE * fp,int b,char * s)2009 bprintf(FILE *fp, int b, char *s)
2010 {
2011 int i;
2012 int gotsome = 0;
2013
2014 if (b == 0)
2015 return;
2016 while ((i = *s++)) {
2017 if ((b & (1 << (i-1)))) {
2018 if (gotsome == 0)
2019 i = '<';
2020 else
2021 i = ',';
2022 putc(i, fp);
2023 gotsome = 1;
2024 for (; (i = *s) > 32; s++)
2025 putc(i, fp);
2026 } else
2027 while (*s > 32)
2028 s++;
2029 }
2030 if (gotsome)
2031 putc('>', fp);
2032 }
2033
2034 int
keycmp(const void * key,const void * kt)2035 keycmp(const void *key, const void *kt)
2036 {
2037 return (strcmp(key, ((struct keytab *)kt)->kt_cp));
2038 }
2039
2040 int
keyword(char * cp)2041 keyword(char *cp)
2042 {
2043 struct keytab *kt;
2044
2045 kt = bsearch(cp, keywords, sizeof(keywords)/sizeof(keywords[0]),
2046 sizeof(keywords[0]), keycmp);
2047 if (!kt)
2048 return (0);
2049
2050 return (kt->kt_i);
2051 }
2052
2053 void
sodump(sup su,char * which)2054 sodump(sup su, char *which)
2055 {
2056 switch (su->sa.sa_family) {
2057 case AF_LINK:
2058 printf("%s: link %s; ", which, link_ntoa(&su->sdl));
2059 break;
2060 case AF_INET:
2061 printf("%s: inet %s; ", which, inet_ntoa(su->sin.sin_addr));
2062 break;
2063 case AF_INET6:
2064 {
2065 char ntop_buf[NI_MAXHOST];
2066
2067 printf("%s: inet6 %s; ",
2068 which, inet_ntop(AF_INET6, &su->sin6.sin6_addr,
2069 ntop_buf, sizeof(ntop_buf)));
2070 break;
2071 }
2072 }
2073 fflush(stdout);
2074 }
2075
2076 /* States*/
2077 #define VIRGIN 0
2078 #define GOTONE 1
2079 #define GOTTWO 2
2080 /* Inputs */
2081 #define DIGIT (4*0)
2082 #define END (4*1)
2083 #define DELIM (4*2)
2084
2085 void
sockaddr(char * addr,struct sockaddr * sa)2086 sockaddr(char *addr, struct sockaddr *sa)
2087 {
2088 char *cp = (char *)sa;
2089 int size = sa->sa_len;
2090 char *cplim = cp + size;
2091 int byte = 0, state = VIRGIN, new = 0;
2092
2093 memset(cp, 0, size);
2094 cp++;
2095 do {
2096 if ((*addr >= '0') && (*addr <= '9')) {
2097 new = *addr - '0';
2098 } else if ((*addr >= 'a') && (*addr <= 'f')) {
2099 new = *addr - 'a' + 10;
2100 } else if ((*addr >= 'A') && (*addr <= 'F')) {
2101 new = *addr - 'A' + 10;
2102 } else if (*addr == '\0')
2103 state |= END;
2104 else
2105 state |= DELIM;
2106 addr++;
2107 switch (state /* | INPUT */) {
2108 case GOTTWO | DIGIT:
2109 *cp++ = byte; /*FALLTHROUGH*/
2110 case VIRGIN | DIGIT:
2111 state = GOTONE; byte = new; continue;
2112 case GOTONE | DIGIT:
2113 state = GOTTWO; byte = new + (byte << 4); continue;
2114 default: /* | DELIM */
2115 state = VIRGIN; *cp++ = byte; byte = 0; continue;
2116 case GOTONE | END:
2117 case GOTTWO | END:
2118 *cp++ = byte; /* FALLTHROUGH */
2119 case VIRGIN | END:
2120 break;
2121 }
2122 break;
2123 } while (cp < cplim);
2124 sa->sa_len = cp - (char *)sa;
2125 }
2126
2127 void
getlabel(char * name)2128 getlabel(char *name)
2129 {
2130 so_label.rtlabel.sr_len = sizeof(so_label.rtlabel);
2131 so_label.rtlabel.sr_family = AF_UNSPEC;
2132 if (strlcpy(so_label.rtlabel.sr_label, name,
2133 sizeof(so_label.rtlabel.sr_label)) >=
2134 sizeof(so_label.rtlabel.sr_label))
2135 errx(1, "label too long");
2136 rtm_addrs |= RTA_LABEL;
2137 }
2138
2139 #ifndef SMALL
2140 int
gettable(const char * s)2141 gettable(const char *s)
2142 {
2143 const char *errstr;
2144 struct rt_tableinfo info;
2145 int mib[6];
2146 size_t len;
2147
2148 tableid = strtonum(s, 0, RT_TABLEID_MAX, &errstr);
2149 if (errstr)
2150 errx(1, "invalid table id: %s", errstr);
2151
2152 mib[0] = CTL_NET;
2153 mib[1] = PF_ROUTE;
2154 mib[2] = 0;
2155 mib[3] = 0;
2156 mib[4] = NET_RT_TABLE;
2157 mib[5] = tableid;
2158
2159 len = sizeof(info);
2160 if (sysctl(mib, 6, &info, &len, NULL, 0) == -1)
2161 return (errno);
2162 else
2163 return (0);
2164 }
2165
2166 int
rdomain(int argc,char ** argv)2167 rdomain(int argc, char **argv)
2168 {
2169 if (!argc)
2170 usage(NULL);
2171 if (setrtable(tableid) == -1)
2172 err(1, "setrtable");
2173 execvp(*argv, argv);
2174 warn("%s", argv[0]);
2175 return (errno == ENOENT ? 127 : 126);
2176 }
2177 #endif /* SMALL */
2178
2179 /*
2180 * Print RTM_PROPOSAL DNS server addresses.
2181 */
2182 void
print_rtdns(struct sockaddr_rtdns * rtdns)2183 print_rtdns(struct sockaddr_rtdns *rtdns)
2184 {
2185 struct in_addr server;
2186 struct in6_addr in6;
2187 size_t srclen, offset;
2188 unsigned int servercnt;
2189 int i;
2190 char *src = rtdns->sr_dns;
2191 char ntopbuf[INET6_ADDRSTRLEN];
2192
2193 offset = offsetof(struct sockaddr_rtdns, sr_dns);
2194 if (rtdns->sr_len < offset) {
2195 printf("<invalid sr_len (%u <= %zu)>\n", rtdns->sr_len,
2196 offset);
2197 return;
2198 }
2199 srclen = rtdns->sr_len - offset;
2200 if (srclen > sizeof(rtdns->sr_dns)) {
2201 printf("<invalid sr_len (%zu > %zu)>\n", srclen,
2202 sizeof(rtdns->sr_dns));
2203 return;
2204 }
2205 switch (rtdns->sr_family) {
2206 case AF_INET:
2207 printf(" INET [");
2208 /* An array of IPv4 addresses. */
2209 servercnt = srclen / sizeof(struct in_addr);
2210 if (servercnt * sizeof(struct in_addr) != srclen) {
2211 printf("<invalid server count>\n");
2212 return;
2213 }
2214 for (i = 0; i < servercnt; i++) {
2215 memcpy(&server.s_addr, src, sizeof(server.s_addr));
2216 printf("%s%s", inet_ntoa(server), i == servercnt - 1 ?
2217 "": ", ");
2218 src += sizeof(struct in_addr);
2219 }
2220 break;
2221 case AF_INET6:
2222 printf(" INET6 [");
2223 servercnt = srclen / sizeof(struct in6_addr);
2224 if (servercnt * sizeof(struct in6_addr) != srclen) {
2225 printf("<invalid server count>\n");
2226 return;
2227 }
2228 for (i = 0; i < servercnt; i++) {
2229 memcpy(&in6, src, sizeof(in6));
2230 src += sizeof(in6);
2231 printf("%s%s", inet_ntop(AF_INET6, &in6, ntopbuf,
2232 INET6_ADDRSTRLEN), i == servercnt - 1 ? "": ", ");
2233 }
2234 break;
2235 default:
2236 printf(" UNKNOWN [");
2237 break;
2238 }
2239 printf("]");
2240 }
2241
2242 /*
2243 * Print RTM_PROPOSAL static routes.
2244 */
2245 void
print_rtstatic(struct sockaddr_rtstatic * rtstatic)2246 print_rtstatic(struct sockaddr_rtstatic *rtstatic)
2247 {
2248 struct sockaddr_in6 gateway6;
2249 struct in6_addr prefix;
2250 struct in_addr dest, gateway;
2251 size_t srclen, offset;
2252 int bits, bytes, error, first = 1;
2253 uint8_t prefixlen;
2254 unsigned char *src = rtstatic->sr_static;
2255 char ntoabuf[INET_ADDRSTRLEN];
2256 char hbuf[NI_MAXHOST];
2257 char ntopbuf[INET6_ADDRSTRLEN];
2258
2259 offset = offsetof(struct sockaddr_rtstatic, sr_static);
2260 if (rtstatic->sr_len <= offset) {
2261 printf("<invalid sr_len (%u <= %zu)>\n", rtstatic->sr_len,
2262 offset);
2263 return;
2264 }
2265 srclen = rtstatic->sr_len - offset;
2266 if (srclen > sizeof(rtstatic->sr_static)) {
2267 printf("<invalid sr_len (%zu > %zu)>\n", srclen,
2268 sizeof(rtstatic->sr_static));
2269 return;
2270 }
2271 printf(" [");
2272 switch (rtstatic->sr_family) {
2273 case AF_INET:
2274 /* AF_INET -> RFC 3442 encoded static routes. */
2275 while (srclen) {
2276 bits = *src;
2277 src++;
2278 srclen--;
2279 bytes = (bits + 7) / 8;
2280 if (srclen < bytes || bytes > sizeof(dest.s_addr))
2281 break;
2282 memset(&dest, 0, sizeof(dest));
2283 memcpy(&dest.s_addr, src, bytes);
2284 src += bytes;
2285 srclen -= bytes;
2286 strlcpy(ntoabuf, inet_ntoa(dest), sizeof(ntoabuf));
2287 if (srclen < sizeof(gateway.s_addr))
2288 break;
2289 memcpy(&gateway.s_addr, src, sizeof(gateway.s_addr));
2290 src += sizeof(gateway.s_addr);
2291 srclen -= sizeof(gateway.s_addr);
2292 printf("%s%s/%u %s ", first ? "" : ", ", ntoabuf, bits,
2293 inet_ntoa(gateway));
2294 first = 0;
2295 }
2296 break;
2297 case AF_INET6:
2298 while (srclen >= sizeof(prefixlen) + sizeof(prefix) +
2299 sizeof(gateway6)) {
2300 memcpy(&prefixlen, src, sizeof(prefixlen));
2301 srclen -= sizeof(prefixlen);
2302 src += sizeof(prefixlen);
2303
2304 memcpy(&prefix, src, sizeof(prefix));
2305 srclen -= sizeof(prefix);
2306 src += sizeof(prefix);
2307
2308 memcpy(&gateway6, src, sizeof(gateway6));
2309 srclen -= sizeof(gateway6);
2310 src += sizeof(gateway6);
2311
2312 if ((error = getnameinfo((struct sockaddr *)&gateway6,
2313 gateway6.sin6_len, hbuf, sizeof(hbuf), NULL, 0,
2314 NI_NUMERICHOST | NI_NUMERICSERV))) {
2315 warnx("cannot get gateway address: %s",
2316 gai_strerror(error));
2317 return;
2318 }
2319 printf("%s%s/%u %s ", first ? "" : ", ",
2320 inet_ntop(AF_INET6, &prefix, ntopbuf,
2321 INET6_ADDRSTRLEN), prefixlen, hbuf);
2322 first = 0;
2323 }
2324 break;
2325 default:
2326 printf("<unknown address family %u>", rtstatic->sr_family);
2327 break;
2328 }
2329 printf("]");
2330 }
2331
2332 /*
2333 * Print RTM_PROPOSAL domain search list.
2334 */
2335 void
print_rtsearch(struct sockaddr_rtsearch * rtsearch)2336 print_rtsearch(struct sockaddr_rtsearch *rtsearch)
2337 {
2338 char *src = rtsearch->sr_search;
2339 size_t srclen, offset;
2340
2341 offset = offsetof(struct sockaddr_rtsearch, sr_search);
2342 if (rtsearch->sr_len <= offset) {
2343 printf("<invalid sr_len (%u <= %zu)>\n", rtsearch->sr_len,
2344 offset);
2345 return;
2346 }
2347 srclen = rtsearch->sr_len - offset;
2348 if (srclen > sizeof(rtsearch->sr_search)) {
2349 printf("<invalid sr_len (%zu > %zu)>\n", srclen,
2350 sizeof(rtsearch->sr_search));
2351 return;
2352 }
2353
2354 printf(" [%.*s]", (int)srclen, src);
2355 }
2356
2357 /*
2358 * Print RTM_80211INFO info.
2359 */
2360 void
print_80211info(struct if_ieee80211_msghdr * ifim)2361 print_80211info(struct if_ieee80211_msghdr *ifim)
2362 {
2363 unsigned int ascii, nwidlen, i;
2364 u_int8_t *nwid, *bssid;
2365
2366 ascii = 1;
2367 nwid = ifim->ifim_ifie.ifie_nwid;
2368 nwidlen = ifim->ifim_ifie.ifie_nwid_len;
2369 for (i = 0; i < nwidlen; i++) {
2370 if (i == 0)
2371 printf("nwid ");
2372 else
2373 printf(":");
2374 printf("%02x", nwid[i]);
2375 if (!isprint((unsigned int)nwid[i]))
2376 ascii = 0;
2377 }
2378 if (i > 0) {
2379 if (ascii == 1)
2380 printf(" (%.*s)", nwidlen, nwid);
2381 printf(", ");
2382 }
2383 printf("channel %u, ", ifim->ifim_ifie.ifie_channel);
2384 bssid = ifim->ifim_ifie.ifie_addr;
2385 printf("bssid %02x:%02x:%02x:%02x:%02x:%02x\n",
2386 bssid[0], bssid[1], bssid[2],
2387 bssid[3], bssid[4], bssid[5]);
2388 printf("flags:");
2389 bprintf(stdout, ifim->ifim_ifie.ifie_flags, ieee80211flags);
2390 printf("\nxflags:");
2391 bprintf(stdout, ifim->ifim_ifie.ifie_xflags, ieee80211xflags);
2392 printf("\n");
2393 }
2394