1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1983, 1989, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/param.h>
33 #include <sys/file.h>
34 #include <sys/socket.h>
35 #include <sys/ioctl.h>
36 #ifdef JAIL
37 #include <sys/jail.h>
38 #endif
39 #include <sys/sysctl.h>
40 #include <sys/types.h>
41 #include <sys/queue.h>
42
43 #include <net/if.h>
44 #include <net/route.h>
45 #include <net/if_dl.h>
46 #include <netinet/in.h>
47 #include <netinet/if_ether.h>
48 #include <arpa/inet.h>
49 #include <netdb.h>
50
51 #include <ctype.h>
52 #include <err.h>
53 #include <errno.h>
54 #ifdef JAIL
55 #include <jail.h>
56 #endif
57 #include <paths.h>
58 #include <signal.h>
59 #include <stdbool.h>
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #include <sysexits.h>
64 #include <time.h>
65 #include <unistd.h>
66 #include <ifaddrs.h>
67
68 struct fibl {
69 TAILQ_ENTRY(fibl) fl_next;
70
71 int fl_num;
72 int fl_error;
73 int fl_errno;
74 };
75
76 static struct keytab {
77 const char *kt_cp;
78 int kt_i;
79 } const keywords[] = {
80 #include "keywords.h"
81 {0, 0}
82 };
83
84 int verbose, debugonly, nexthop;
85 #ifdef JAIL
86 char * jail_name;
87 #endif
88 static struct sockaddr_storage so[RTAX_MAX];
89 static int pid, rtm_addrs;
90 static int nflag, af, aflen, qflag, tflag;
91 static int locking, lockrest;
92 static struct rt_metrics rt_metrics;
93 static u_long rtm_inits;
94 static uid_t uid;
95 static int defaultfib;
96 static int numfibs;
97 static char domain_storage[MAXHOSTNAMELEN + 1];
98 static const char *domain;
99 static char rt_line[NI_MAXHOST];
100 static char net_line[MAXHOSTNAMELEN + 1];
101
102 #ifdef WITHOUT_NETLINK
103 static int s;
104 static int rtm_seq;
105
106 static struct {
107 struct rt_msghdr m_rtm;
108 char m_space[512];
109 } m_rtmsg;
110
111 static int rtmsg_rtsock(int, int, int);
112 static int flushroutes_fib_rtsock(int);
113 static void monitor_rtsock(void);
114 #else
115 int rtmsg_nl(int, int, int, int, struct sockaddr_storage *, struct rt_metrics *);
116 int flushroutes_fib_nl(int, int);
117 void monitor_nl(int);
118 #endif
119
120 static TAILQ_HEAD(fibl_head_t, fibl) fibl_head;
121
122 void printb(int, const char *);
123 static void flushroutes(int argc, char *argv[]);
124 static int flushroutes_fib(int);
125 static int getaddr(int, char *, int);
126 static int keyword(const char *);
127 #ifdef INET
128 static void inet_makemask(struct sockaddr_in *, u_long);
129 #endif
130 #ifdef INET6
131 static int inet6_makenetandmask(struct sockaddr_in6 *, const char *);
132 #endif
133 static void interfaces(void);
134 static void monitor(int, char*[]);
135 const char *netname(struct sockaddr *);
136 static void newroute(int, char **);
137 static int newroute_fib(int, char *, int);
138 static void pmsg_addrs(char *, int, size_t);
139 static void pmsg_common(struct rt_msghdr *, size_t);
140 static int prefixlen(const char *);
141 static void print_getmsg(struct rt_msghdr *, int, int);
142 static void print_rtmsg(struct rt_msghdr *, size_t);
143 const char *routename(struct sockaddr *);
144 static int rtmsg(int, int, int);
145 static void set_metric(char *, int);
146 static int set_sofib(int);
147 static void sockaddr(char *, struct sockaddr *, size_t);
148 static void sodump(struct sockaddr *, const char *);
149 static int fiboptlist_csv(const char *, struct fibl_head_t *);
150 static int fiboptlist_range(const char *, struct fibl_head_t *);
151
152 static void usage(const char *) __dead2;
153
154 #define READ_TIMEOUT 10
155 static volatile sig_atomic_t stop_read;
156
157 static void
stopit(int sig __unused)158 stopit(int sig __unused)
159 {
160
161 stop_read = 1;
162 }
163
164 static void
usage(const char * cp)165 usage(const char *cp)
166 {
167 if (cp != NULL)
168 warnx("bad keyword: %s", cp);
169 errx(EX_USAGE, "usage: route [-j jail] [-46dnqtvo] command [[modifiers] args]");
170 /* NOTREACHED */
171 }
172
173 int
main(int argc,char ** argv)174 main(int argc, char **argv)
175 {
176 int ch;
177 #ifdef JAIL
178 int jid;
179 #endif
180 size_t len;
181
182 if (argc < 2)
183 usage(NULL);
184
185 while ((ch = getopt(argc, argv, "46nqdtvoj:")) != -1)
186 switch(ch) {
187 case '4':
188 #ifdef INET
189 af = AF_INET;
190 aflen = sizeof(struct sockaddr_in);
191 #else
192 errx(1, "IPv4 support is not compiled in");
193 #endif
194 break;
195 case '6':
196 #ifdef INET6
197 af = AF_INET6;
198 aflen = sizeof(struct sockaddr_in6);
199 #else
200 errx(1, "IPv6 support is not compiled in");
201 #endif
202 break;
203 case 'n':
204 nflag = 1;
205 break;
206 case 'q':
207 qflag = 1;
208 break;
209 case 'v':
210 verbose = 1;
211 break;
212 case 't':
213 tflag = 1;
214 break;
215 case 'd':
216 debugonly = 1;
217 break;
218 case 'o':
219 nexthop = 1;
220 break;
221 case 'j':
222 #ifdef JAIL
223 if (optarg == NULL)
224 usage(NULL);
225 jail_name = optarg;
226 #else
227 errx(1, "Jail support is not compiled in");
228 #endif
229 break;
230 case '?':
231 default:
232 usage(NULL);
233 }
234 argc -= optind;
235 argv += optind;
236
237 pid = getpid();
238 uid = geteuid();
239
240 #ifdef JAIL
241 if (jail_name != NULL) {
242 jid = jail_getid(jail_name);
243 if (jid == -1)
244 errx(1, "Jail not found");
245 if (jail_attach(jid) != 0)
246 errx(1, "Cannot attach to jail");
247 }
248 #endif
249
250 #ifdef WITHOUT_NETLINK
251 if (tflag)
252 s = open(_PATH_DEVNULL, O_WRONLY, 0);
253 else
254 s = socket(PF_ROUTE, SOCK_RAW, 0);
255 if (s < 0)
256 err(EX_OSERR, "socket");
257 #endif
258
259 len = sizeof(numfibs);
260 if (sysctlbyname("net.fibs", (void *)&numfibs, &len, NULL, 0) == -1)
261 numfibs = -1;
262
263 len = sizeof(defaultfib);
264 if (numfibs != -1 &&
265 sysctlbyname("net.my_fibnum", (void *)&defaultfib, &len, NULL,
266 0) == -1)
267 defaultfib = -1;
268
269 if (*argv != NULL)
270 switch (keyword(*argv)) {
271 case K_GET:
272 case K_SHOW:
273 uid = 0;
274 /* FALLTHROUGH */
275
276 case K_CHANGE:
277 case K_ADD:
278 case K_DEL:
279 case K_DELETE:
280 newroute(argc, argv);
281 /* NOTREACHED */
282
283 case K_MONITOR:
284 monitor(argc, argv);
285 /* NOTREACHED */
286
287 case K_FLUSH:
288 flushroutes(argc, argv);
289 exit(0);
290 /* NOTREACHED */
291 }
292 usage(*argv);
293 /* NOTREACHED */
294 }
295
296 static int
set_sofib(int fib)297 set_sofib(int fib)
298 {
299
300 #ifdef WITHOUT_NETLINK
301 if (fib < 0)
302 return (0);
303 return (setsockopt(s, SOL_SOCKET, SO_SETFIB, (void *)&fib,
304 sizeof(fib)));
305 #else
306 return (0);
307 #endif
308 }
309
310 static int
fiboptlist_range(const char * arg,struct fibl_head_t * flh)311 fiboptlist_range(const char *arg, struct fibl_head_t *flh)
312 {
313 struct fibl *fl;
314 char *str0, *str, *token, *endptr;
315 int fib[2], i, error;
316
317 str0 = str = strdup(arg);
318 error = 0;
319 i = 0;
320 while ((token = strsep(&str, "-")) != NULL) {
321 switch (i) {
322 case 0:
323 case 1:
324 errno = 0;
325 fib[i] = strtol(token, &endptr, 0);
326 if (errno == 0) {
327 if (*endptr != '\0' ||
328 fib[i] < 0 ||
329 (numfibs != -1 && fib[i] > numfibs - 1))
330 errno = EINVAL;
331 }
332 if (errno)
333 error = 1;
334 break;
335 default:
336 error = 1;
337 }
338 if (error)
339 goto fiboptlist_range_ret;
340 i++;
341 }
342 if (fib[0] >= fib[1]) {
343 error = 1;
344 goto fiboptlist_range_ret;
345 }
346 for (i = fib[0]; i <= fib[1]; i++) {
347 fl = calloc(1, sizeof(*fl));
348 if (fl == NULL) {
349 error = 1;
350 goto fiboptlist_range_ret;
351 }
352 fl->fl_num = i;
353 TAILQ_INSERT_TAIL(flh, fl, fl_next);
354 }
355 fiboptlist_range_ret:
356 free(str0);
357 return (error);
358 }
359
360 #define ALLSTRLEN 64
361 static int
fiboptlist_csv(const char * arg,struct fibl_head_t * flh)362 fiboptlist_csv(const char *arg, struct fibl_head_t *flh)
363 {
364 struct fibl *fl;
365 char *str0, *str, *token, *endptr;
366 int fib, error;
367
368 str0 = str = NULL;
369 if (strcmp("all", arg) == 0) {
370 str = calloc(1, ALLSTRLEN);
371 if (str == NULL) {
372 error = 1;
373 goto fiboptlist_csv_ret;
374 }
375 if (numfibs > 1)
376 snprintf(str, ALLSTRLEN - 1, "%d-%d", 0, numfibs - 1);
377 else
378 snprintf(str, ALLSTRLEN - 1, "%d", 0);
379 } else if (strcmp("default", arg) == 0) {
380 str0 = str = calloc(1, ALLSTRLEN);
381 if (str == NULL) {
382 error = 1;
383 goto fiboptlist_csv_ret;
384 }
385 snprintf(str, ALLSTRLEN - 1, "%d", defaultfib);
386 } else
387 str0 = str = strdup(arg);
388
389 error = 0;
390 while ((token = strsep(&str, ",")) != NULL) {
391 if (*token != '-' && strchr(token, '-') != NULL) {
392 error = fiboptlist_range(token, flh);
393 if (error)
394 goto fiboptlist_csv_ret;
395 } else {
396 errno = 0;
397 fib = strtol(token, &endptr, 0);
398 if (errno == 0) {
399 if (*endptr != '\0' ||
400 fib < 0 ||
401 (numfibs != -1 && fib > numfibs - 1))
402 errno = EINVAL;
403 }
404 if (errno) {
405 error = 1;
406 goto fiboptlist_csv_ret;
407 }
408 fl = calloc(1, sizeof(*fl));
409 if (fl == NULL) {
410 error = 1;
411 goto fiboptlist_csv_ret;
412 }
413 fl->fl_num = fib;
414 TAILQ_INSERT_TAIL(flh, fl, fl_next);
415 }
416 }
417 fiboptlist_csv_ret:
418 if (str0 != NULL)
419 free(str0);
420 return (error);
421 }
422
423 /*
424 * Purge all entries in the routing tables not
425 * associated with network interfaces.
426 */
427 static void
flushroutes(int argc,char * argv[])428 flushroutes(int argc, char *argv[])
429 {
430 struct fibl *fl;
431 int error;
432
433 if (uid != 0 && !debugonly && !tflag)
434 errx(EX_NOPERM, "must be root to alter routing table");
435 #ifdef WITHOUT_NETLINK
436 shutdown(s, SHUT_RD); /* Don't want to read back our messages */
437 #endif
438
439 TAILQ_INIT(&fibl_head);
440 while (argc > 1) {
441 argc--;
442 argv++;
443 if (**argv != '-')
444 usage(*argv);
445 switch (keyword(*argv + 1)) {
446 #ifdef INET
447 case K_4:
448 case K_INET:
449 af = AF_INET;
450 break;
451 #endif
452 #ifdef INET6
453 case K_6:
454 case K_INET6:
455 af = AF_INET6;
456 break;
457 #endif
458 case K_LINK:
459 af = AF_LINK;
460 break;
461 case K_FIB:
462 if (!--argc)
463 usage(*argv);
464 error = fiboptlist_csv(*++argv, &fibl_head);
465 if (error)
466 errx(EX_USAGE, "invalid fib number: %s", *argv);
467 break;
468 default:
469 usage(*argv);
470 }
471 }
472 if (TAILQ_EMPTY(&fibl_head)) {
473 error = fiboptlist_csv("default", &fibl_head);
474 if (error)
475 errx(EX_OSERR, "fiboptlist_csv failed.");
476 }
477 TAILQ_FOREACH(fl, &fibl_head, fl_next)
478 flushroutes_fib(fl->fl_num);
479 }
480
481 static int
flushroutes_fib(int fib)482 flushroutes_fib(int fib)
483 {
484 #ifdef WITHOUT_NETLINK
485 return (flushroutes_fib_rtsock(fib));
486 #else
487 return (flushroutes_fib_nl(fib, af));
488 #endif
489 }
490
491 #ifdef WITHOUT_NETLINK
492 static int
flushroutes_fib_rtsock(int fib)493 flushroutes_fib_rtsock(int fib)
494 {
495 struct rt_msghdr *rtm;
496 size_t needed;
497 char *buf, *next, *lim;
498 int mib[7], rlen, seqno, count = 0;
499 int error;
500
501 error = set_sofib(fib);
502 if (error) {
503 warn("fib number %d is ignored", fib);
504 return (error);
505 }
506
507 retry:
508 mib[0] = CTL_NET;
509 mib[1] = PF_ROUTE;
510 mib[2] = 0; /* protocol */
511 mib[3] = AF_UNSPEC;
512 mib[4] = NET_RT_DUMP;
513 mib[5] = 0; /* no flags */
514 mib[6] = fib;
515 if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0)
516 err(EX_OSERR, "route-sysctl-estimate");
517 if ((buf = malloc(needed)) == NULL)
518 errx(EX_OSERR, "malloc failed");
519 if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0) {
520 if (errno == ENOMEM && count++ < 10) {
521 warnx("Routing table grew, retrying");
522 sleep(1);
523 free(buf);
524 goto retry;
525 }
526 err(EX_OSERR, "route-sysctl-get");
527 }
528 lim = buf + needed;
529 if (verbose)
530 (void)printf("Examining routing table from sysctl\n");
531 seqno = 0; /* ??? */
532 for (next = buf; next < lim; next += rtm->rtm_msglen) {
533 rtm = (struct rt_msghdr *)(void *)next;
534 if (verbose)
535 print_rtmsg(rtm, rtm->rtm_msglen);
536 if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
537 continue;
538 if (af != 0) {
539 struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
540
541 if (sa->sa_family != af)
542 continue;
543 }
544 if (debugonly)
545 continue;
546 rtm->rtm_type = RTM_DELETE;
547 rtm->rtm_seq = seqno;
548 rlen = write(s, next, rtm->rtm_msglen);
549 if (rlen < 0 && errno == EPERM)
550 err(1, "write to routing socket");
551 if (rlen < (int)rtm->rtm_msglen) {
552 warn("write to routing socket");
553 (void)printf("got only %d for rlen\n", rlen);
554 free(buf);
555 goto retry;
556 break;
557 }
558 seqno++;
559 if (qflag)
560 continue;
561 if (verbose)
562 print_rtmsg(rtm, rlen);
563 else {
564 struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
565
566 printf("%-20.20s ", rtm->rtm_flags & RTF_HOST ?
567 routename(sa) : netname(sa));
568 sa = (struct sockaddr *)(SA_SIZE(sa) + (char *)sa);
569 printf("%-20.20s ", routename(sa));
570 if (fib >= 0)
571 printf("-fib %-3d ", fib);
572 printf("done\n");
573 }
574 }
575 free(buf);
576 return (error);
577 }
578 #endif
579
580 const char *
routename(struct sockaddr * sa)581 routename(struct sockaddr *sa)
582 {
583 struct sockaddr_dl *sdl;
584 const char *cp;
585 int n;
586
587 if (domain == NULL) {
588 if (gethostname(domain_storage,
589 sizeof(domain_storage) - 1) == 0 &&
590 (cp = strchr(domain_storage, '.')) != NULL) {
591 domain_storage[sizeof(domain_storage) - 1] = '\0';
592 domain = cp + 1;
593 } else {
594 domain_storage[0] = '\0';
595 domain = domain_storage;
596 }
597 }
598
599 /* If the address is zero-filled, use "default". */
600 if (sa->sa_len == 0 && nflag == 0)
601 return ("default");
602 #if defined(INET) || defined(INET6)
603 switch (sa->sa_family) {
604 #ifdef INET
605 case AF_INET:
606 /* If the address is zero-filled, use "default". */
607 if (nflag == 0 &&
608 ((struct sockaddr_in *)(void *)sa)->sin_addr.s_addr ==
609 INADDR_ANY)
610 return("default");
611 break;
612 #endif
613 #ifdef INET6
614 case AF_INET6:
615 /* If the address is zero-filled, use "default". */
616 if (nflag == 0 &&
617 IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)(void *)sa)->sin6_addr))
618 return("default");
619 break;
620 #endif
621 }
622 #endif
623
624 switch (sa->sa_family) {
625 #if defined(INET) || defined(INET6)
626 #ifdef INET
627 case AF_INET:
628 #endif
629 #ifdef INET6
630 case AF_INET6:
631 #endif
632 {
633 struct sockaddr_storage ss;
634 int error;
635 char *p;
636
637 memset(&ss, 0, sizeof(ss));
638 if (sa->sa_len == 0)
639 ss.ss_family = sa->sa_family;
640 else
641 memcpy(&ss, sa, sa->sa_len);
642 /* Expand sa->sa_len because it could be shortened. */
643 if (sa->sa_family == AF_INET)
644 ss.ss_len = sizeof(struct sockaddr_in);
645 else if (sa->sa_family == AF_INET6)
646 ss.ss_len = sizeof(struct sockaddr_in6);
647 error = getnameinfo((struct sockaddr *)&ss, ss.ss_len,
648 rt_line, sizeof(rt_line), NULL, 0,
649 (nflag == 0) ? 0 : NI_NUMERICHOST);
650 if (error) {
651 warnx("getnameinfo(): %s", gai_strerror(error));
652 strncpy(rt_line, "invalid", sizeof(rt_line));
653 }
654
655 /* Remove the domain part if any. */
656 p = strchr(rt_line, '.');
657 if (p != NULL && strcmp(p + 1, domain) == 0)
658 *p = '\0';
659
660 return (rt_line);
661 break;
662 }
663 #endif
664 case AF_LINK:
665 sdl = (struct sockaddr_dl *)(void *)sa;
666
667 if (sdl->sdl_nlen == 0 &&
668 sdl->sdl_alen == 0 &&
669 sdl->sdl_slen == 0) {
670 n = snprintf(rt_line, sizeof(rt_line), "link#%d",
671 sdl->sdl_index);
672 if (n > (int)sizeof(rt_line))
673 rt_line[0] = '\0';
674 return (rt_line);
675 } else
676 return (link_ntoa(sdl));
677 break;
678
679 default:
680 {
681 u_short *sp = (u_short *)(void *)sa;
682 u_short *splim = sp + ((sa->sa_len + 1) >> 1);
683 char *cps = rt_line + sprintf(rt_line, "(%d)", sa->sa_family);
684 char *cpe = rt_line + sizeof(rt_line);
685
686 while (++sp < splim && cps < cpe) /* start with sa->sa_data */
687 if ((n = snprintf(cps, cpe - cps, " %x", *sp)) > 0)
688 cps += n;
689 else
690 *cps = '\0';
691 break;
692 }
693 }
694 return (rt_line);
695 }
696
697 /*
698 * Return the name of the network whose address is given.
699 * The address is assumed to be that of a net, not a host.
700 */
701 const char *
netname(struct sockaddr * sa)702 netname(struct sockaddr *sa)
703 {
704 struct sockaddr_dl *sdl;
705 int n;
706 #ifdef INET
707 struct netent *np = NULL;
708 const char *cp = NULL;
709 u_long i;
710 #endif
711
712 switch (sa->sa_family) {
713 #ifdef INET
714 case AF_INET:
715 {
716 struct in_addr in;
717
718 in = ((struct sockaddr_in *)(void *)sa)->sin_addr;
719 i = in.s_addr = ntohl(in.s_addr);
720 if (in.s_addr == 0)
721 cp = "default";
722 else if (!nflag) {
723 np = getnetbyaddr(i, AF_INET);
724 if (np != NULL)
725 cp = np->n_name;
726 }
727 #define C(x) (unsigned)((x) & 0xff)
728 if (cp != NULL)
729 strncpy(net_line, cp, sizeof(net_line));
730 else if ((in.s_addr & 0xffffff) == 0)
731 (void)sprintf(net_line, "%u", C(in.s_addr >> 24));
732 else if ((in.s_addr & 0xffff) == 0)
733 (void)sprintf(net_line, "%u.%u", C(in.s_addr >> 24),
734 C(in.s_addr >> 16));
735 else if ((in.s_addr & 0xff) == 0)
736 (void)sprintf(net_line, "%u.%u.%u", C(in.s_addr >> 24),
737 C(in.s_addr >> 16), C(in.s_addr >> 8));
738 else
739 (void)sprintf(net_line, "%u.%u.%u.%u", C(in.s_addr >> 24),
740 C(in.s_addr >> 16), C(in.s_addr >> 8),
741 C(in.s_addr));
742 #undef C
743 break;
744 }
745 #endif
746 #ifdef INET6
747 case AF_INET6:
748 {
749 struct sockaddr_in6 sin6;
750 int niflags = 0;
751
752 memset(&sin6, 0, sizeof(sin6));
753 memcpy(&sin6, sa, sa->sa_len);
754 sin6.sin6_len = sizeof(sin6);
755 sin6.sin6_family = AF_INET6;
756 if (nflag)
757 niflags |= NI_NUMERICHOST;
758 if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
759 net_line, sizeof(net_line), NULL, 0, niflags) != 0)
760 strncpy(net_line, "invalid", sizeof(net_line));
761
762 return(net_line);
763 }
764 #endif
765 case AF_LINK:
766 sdl = (struct sockaddr_dl *)(void *)sa;
767
768 if (sdl->sdl_nlen == 0 &&
769 sdl->sdl_alen == 0 &&
770 sdl->sdl_slen == 0) {
771 n = snprintf(net_line, sizeof(net_line), "link#%d",
772 sdl->sdl_index);
773 if (n > (int)sizeof(net_line))
774 net_line[0] = '\0';
775 return (net_line);
776 } else
777 return (link_ntoa(sdl));
778 break;
779
780 default:
781 {
782 u_short *sp = (u_short *)(void *)sa->sa_data;
783 u_short *splim = sp + ((sa->sa_len + 1)>>1);
784 char *cps = net_line + sprintf(net_line, "af %d:", sa->sa_family);
785 char *cpe = net_line + sizeof(net_line);
786
787 while (sp < splim && cps < cpe)
788 if ((n = snprintf(cps, cpe - cps, " %x", *sp++)) > 0)
789 cps += n;
790 else
791 *cps = '\0';
792 break;
793 }
794 }
795 return (net_line);
796 }
797
798 static void
set_metric(char * value,int key)799 set_metric(char *value, int key)
800 {
801 int flag = 0;
802 char *endptr;
803 u_long noval, *valp = &noval;
804
805 switch (key) {
806 #define caseof(x, y, z) case x: valp = &rt_metrics.z; flag = y; break
807 caseof(K_MTU, RTV_MTU, rmx_mtu);
808 caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount);
809 caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire);
810 caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe);
811 caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe);
812 caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh);
813 caseof(K_RTT, RTV_RTT, rmx_rtt);
814 caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar);
815 caseof(K_WEIGHT, RTV_WEIGHT, rmx_weight);
816 caseof(K_METRIC, RTV_METRIC, rmx_metric);
817 }
818 rtm_inits |= flag;
819 if (lockrest || locking)
820 rt_metrics.rmx_locks |= flag;
821 if (locking)
822 locking = 0;
823 errno = 0;
824 *valp = strtol(value, &endptr, 0);
825 if (errno == 0 && *endptr != '\0')
826 errno = EINVAL;
827 if (flag & RTV_METRIC && *valp == RT_WILDCARD_METRIC)
828 err(EX_USAGE, "Metric can not be zero");
829 if (errno)
830 err(EX_USAGE, "%s", value);
831 if (flag & RTV_EXPIRE && (value[0] == '+' || value[0] == '-')) {
832 struct timespec ts;
833
834 clock_gettime(CLOCK_REALTIME_FAST, &ts);
835 *valp += ts.tv_sec;
836 }
837 }
838
839 #define F_ISHOST 0x01
840 #define F_FORCENET 0x02
841 #define F_FORCEHOST 0x04
842 #define F_PROXY 0x08
843 #define F_INTERFACE 0x10
844
845 static void
newroute(int argc,char ** argv)846 newroute(int argc, char **argv)
847 {
848 struct sigaction sa;
849 struct fibl *fl;
850 char *cmd;
851 const char *dest, *gateway, *errmsg;
852 int key, error, flags, nrflags, fibnum;
853
854 if (uid != 0 && !debugonly && !tflag)
855 errx(EX_NOPERM, "must be root to alter routing table");
856 dest = NULL;
857 gateway = NULL;
858 flags = RTF_STATIC;
859 nrflags = 0;
860 TAILQ_INIT(&fibl_head);
861
862 sigemptyset(&sa.sa_mask);
863 sa.sa_flags = 0;
864 sa.sa_handler = stopit;
865 if (sigaction(SIGALRM, &sa, 0) == -1)
866 warn("sigaction SIGALRM");
867
868 cmd = argv[0];
869 #ifdef WITHOUT_NETLINK
870 if (*cmd != 'g' && *cmd != 's')
871 shutdown(s, SHUT_RD); /* Don't want to read back our messages */
872 #endif
873 while (--argc > 0) {
874 if (**(++argv)== '-') {
875 switch (key = keyword(1 + *argv)) {
876 case K_LINK:
877 af = AF_LINK;
878 aflen = sizeof(struct sockaddr_dl);
879 break;
880 #ifdef INET
881 case K_4:
882 case K_INET:
883 af = AF_INET;
884 aflen = sizeof(struct sockaddr_in);
885 break;
886 #endif
887 #ifdef INET6
888 case K_6:
889 case K_INET6:
890 af = AF_INET6;
891 aflen = sizeof(struct sockaddr_in6);
892 break;
893 #endif
894 case K_SA:
895 af = PF_ROUTE;
896 aflen = sizeof(struct sockaddr_storage);
897 break;
898 case K_IFACE:
899 case K_INTERFACE:
900 nrflags |= F_INTERFACE;
901 break;
902 case K_NOSTATIC:
903 flags &= ~RTF_STATIC;
904 break;
905 case K_LOCK:
906 locking = 1;
907 break;
908 case K_LOCKREST:
909 lockrest = 1;
910 break;
911 case K_HOST:
912 nrflags |= F_FORCEHOST;
913 break;
914 case K_REJECT:
915 flags |= RTF_REJECT;
916 break;
917 case K_BLACKHOLE:
918 flags |= RTF_BLACKHOLE;
919 break;
920 case K_PROTO1:
921 flags |= RTF_PROTO1;
922 break;
923 case K_PROTO2:
924 flags |= RTF_PROTO2;
925 break;
926 case K_PROXY:
927 nrflags |= F_PROXY;
928 break;
929 case K_XRESOLVE:
930 flags |= RTF_XRESOLVE;
931 break;
932 case K_STATIC:
933 flags |= RTF_STATIC;
934 break;
935 case K_STICKY:
936 flags |= RTF_STICKY;
937 break;
938 case K_NOSTICK:
939 flags &= ~RTF_STICKY;
940 break;
941 case K_FIB:
942 if (!--argc)
943 usage(NULL);
944 error = fiboptlist_csv(*++argv, &fibl_head);
945 if (error)
946 errx(EX_USAGE,
947 "invalid fib number: %s", *argv);
948 break;
949 case K_IFA:
950 if (!--argc)
951 usage(NULL);
952 getaddr(RTAX_IFA, *++argv, nrflags);
953 break;
954 case K_IFP:
955 if (!--argc)
956 usage(NULL);
957 getaddr(RTAX_IFP, *++argv, nrflags);
958 break;
959 case K_GENMASK:
960 if (!--argc)
961 usage(NULL);
962 getaddr(RTAX_GENMASK, *++argv, nrflags);
963 break;
964 case K_GATEWAY:
965 if (!--argc)
966 usage(NULL);
967 getaddr(RTAX_GATEWAY, *++argv, nrflags);
968 gateway = *argv;
969 break;
970 case K_DST:
971 if (!--argc)
972 usage(NULL);
973 if (getaddr(RTAX_DST, *++argv, nrflags))
974 nrflags |= F_ISHOST;
975 dest = *argv;
976 break;
977 case K_NETMASK:
978 if (!--argc)
979 usage(NULL);
980 getaddr(RTAX_NETMASK, *++argv, nrflags);
981 /* FALLTHROUGH */
982 case K_NET:
983 nrflags |= F_FORCENET;
984 break;
985 case K_PREFIXLEN:
986 if (!--argc)
987 usage(NULL);
988 if (prefixlen(*++argv) == -1) {
989 nrflags &= ~F_FORCENET;
990 nrflags |= F_ISHOST;
991 } else {
992 nrflags |= F_FORCENET;
993 nrflags &= ~F_ISHOST;
994 }
995 break;
996 case K_MTU:
997 case K_HOPCOUNT:
998 case K_EXPIRE:
999 case K_RECVPIPE:
1000 case K_SENDPIPE:
1001 case K_SSTHRESH:
1002 case K_RTT:
1003 case K_RTTVAR:
1004 case K_WEIGHT:
1005 case K_METRIC:
1006 if (!--argc)
1007 usage(NULL);
1008 set_metric(*++argv, key);
1009 break;
1010 default:
1011 usage(1+*argv);
1012 }
1013 } else {
1014 if ((rtm_addrs & RTA_DST) == 0) {
1015 dest = *argv;
1016 if (getaddr(RTAX_DST, *argv, nrflags))
1017 nrflags |= F_ISHOST;
1018 } else if ((rtm_addrs & RTA_GATEWAY) == 0) {
1019 gateway = *argv;
1020 getaddr(RTAX_GATEWAY, *argv, nrflags);
1021 } else {
1022 getaddr(RTAX_NETMASK, *argv, nrflags);
1023 nrflags |= F_FORCENET;
1024 }
1025 }
1026 }
1027
1028 /* Do some sanity checks on resulting request */
1029 if (so[RTAX_DST].ss_len == 0) {
1030 warnx("destination parameter required");
1031 usage(NULL);
1032 }
1033
1034 if (so[RTAX_NETMASK].ss_len != 0 &&
1035 so[RTAX_DST].ss_family != so[RTAX_NETMASK].ss_family) {
1036 warnx("destination and netmask family need to be the same");
1037 usage(NULL);
1038 }
1039
1040 if (nrflags & F_FORCEHOST) {
1041 nrflags |= F_ISHOST;
1042 #ifdef INET6
1043 if (af == AF_INET6) {
1044 rtm_addrs &= ~RTA_NETMASK;
1045 memset(&so[RTAX_NETMASK], 0, sizeof(so[RTAX_NETMASK]));
1046 }
1047 #endif
1048 }
1049 if (nrflags & F_FORCENET)
1050 nrflags &= ~F_ISHOST;
1051 flags |= RTF_UP;
1052 if (nrflags & F_ISHOST)
1053 flags |= RTF_HOST;
1054 if ((nrflags & F_INTERFACE) == 0)
1055 flags |= RTF_GATEWAY;
1056 if (nrflags & F_PROXY)
1057 flags |= RTF_ANNOUNCE;
1058 if (dest == NULL)
1059 dest = "";
1060 if (gateway == NULL)
1061 gateway = "";
1062
1063 if (TAILQ_EMPTY(&fibl_head)) {
1064 error = fiboptlist_csv("default", &fibl_head);
1065 if (error)
1066 errx(EX_OSERR, "fiboptlist_csv failed.");
1067 }
1068 error = 0;
1069 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1070 fl->fl_error = newroute_fib(fl->fl_num, cmd, flags);
1071 if (fl->fl_error)
1072 fl->fl_errno = errno;
1073 error += fl->fl_error;
1074 }
1075 if (*cmd == 'g' || *cmd == 's')
1076 exit(error);
1077
1078 error = 0;
1079 if (!qflag) {
1080 fibnum = 0;
1081 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1082 if (fl->fl_error == 0)
1083 fibnum++;
1084 }
1085 if (fibnum > 0) {
1086 int firstfib = 1;
1087
1088 printf("%s %s %s", cmd,
1089 (nrflags & F_ISHOST) ? "host" : "net", dest);
1090 if (*gateway)
1091 printf(": gateway %s", gateway);
1092
1093 if (numfibs > 1) {
1094 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1095 if (fl->fl_error == 0
1096 && fl->fl_num >= 0) {
1097 if (firstfib) {
1098 printf(" fib ");
1099 firstfib = 0;
1100 }
1101 printf("%d", fl->fl_num);
1102 if (fibnum-- > 1)
1103 printf(",");
1104 }
1105 }
1106 }
1107 printf("\n");
1108 }
1109 }
1110
1111 fibnum = 0;
1112 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1113 if (fl->fl_error != 0) {
1114 error = 1;
1115 if (!qflag) {
1116 printf("%s %s %s", cmd, (nrflags & F_ISHOST)
1117 ? "host" : "net", dest);
1118 if (*gateway)
1119 printf(": gateway %s", gateway);
1120
1121 if (fl->fl_num >= 0)
1122 printf(" fib %d", fl->fl_num);
1123
1124 switch (fl->fl_errno) {
1125 case ESRCH:
1126 errmsg = "not in table";
1127 break;
1128 case EBUSY:
1129 errmsg = "entry in use";
1130 break;
1131 case ENOBUFS:
1132 errmsg = "not enough memory";
1133 break;
1134 case EADDRINUSE:
1135 /*
1136 * handle recursion avoidance
1137 * in rt_setgate()
1138 */
1139 errmsg = "gateway uses the same route";
1140 break;
1141 case EEXIST:
1142 errmsg = "route already in table";
1143 break;
1144 default:
1145 errmsg = strerror(fl->fl_errno);
1146 break;
1147 }
1148 printf(": %s\n", errmsg);
1149 }
1150 }
1151 }
1152 exit(error);
1153 }
1154
1155 static int
newroute_fib(int fib,char * cmd,int flags)1156 newroute_fib(int fib, char *cmd, int flags)
1157 {
1158 int error;
1159
1160 error = set_sofib(fib);
1161 if (error) {
1162 warn("fib number %d is ignored", fib);
1163 return (error);
1164 }
1165
1166 error = rtmsg(*cmd, flags, fib);
1167 return (error);
1168 }
1169
1170 #ifdef INET
1171 static void
inet_makemask(struct sockaddr_in * sin_mask,u_long bits)1172 inet_makemask(struct sockaddr_in *sin_mask, u_long bits)
1173 {
1174 u_long mask = 0;
1175
1176 rtm_addrs |= RTA_NETMASK;
1177
1178 if (bits != 0)
1179 mask = 0xffffffff << (32 - bits);
1180
1181 sin_mask->sin_addr.s_addr = htonl(mask);
1182 sin_mask->sin_len = sizeof(struct sockaddr_in);
1183 sin_mask->sin_family = AF_INET;
1184 }
1185 #endif
1186
1187 #ifdef INET6
1188 /*
1189 * XXX the function may need more improvement...
1190 */
1191 static int
inet6_makenetandmask(struct sockaddr_in6 * sin6,const char * plen)1192 inet6_makenetandmask(struct sockaddr_in6 *sin6, const char *plen)
1193 {
1194
1195 if (plen == NULL) {
1196 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
1197 sin6->sin6_scope_id == 0)
1198 plen = "0";
1199 }
1200
1201 if (plen == NULL || strcmp(plen, "128") == 0)
1202 return (1);
1203 rtm_addrs |= RTA_NETMASK;
1204 prefixlen(plen);
1205 return (0);
1206 }
1207 #endif
1208
1209 /*
1210 * Interpret an argument as a network address of some kind,
1211 * returning 1 if a host address, 0 if a network address.
1212 */
1213 static int
getaddr(int idx,char * str,int nrflags)1214 getaddr(int idx, char *str, int nrflags)
1215 {
1216 struct sockaddr *sa;
1217 #if defined(INET)
1218 struct sockaddr_in *sin;
1219 struct hostent *hp;
1220 char *q;
1221 #elif defined(INET6)
1222 char *q;
1223 #endif
1224
1225 if (idx < 0 || idx >= RTAX_MAX)
1226 usage("internal error");
1227 if (af == 0) {
1228 #if defined(INET)
1229 af = AF_INET;
1230 aflen = sizeof(struct sockaddr_in);
1231 #elif defined(INET6)
1232 af = AF_INET6;
1233 aflen = sizeof(struct sockaddr_in6);
1234 #else
1235 af = AF_LINK;
1236 aflen = sizeof(struct sockaddr_dl);
1237 #endif
1238 }
1239 rtm_addrs |= (1 << idx);
1240 sa = (struct sockaddr *)&so[idx];
1241 sa->sa_family = af;
1242 sa->sa_len = aflen;
1243
1244 switch (idx) {
1245 case RTAX_GATEWAY:
1246 if (nrflags & F_INTERFACE) {
1247 struct ifaddrs *ifap, *ifa;
1248 struct sockaddr_dl *sdl0 = (struct sockaddr_dl *)(void *)sa;
1249 struct sockaddr_dl *sdl = NULL;
1250
1251 if (getifaddrs(&ifap))
1252 err(EX_OSERR, "getifaddrs");
1253
1254 for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
1255 if (ifa->ifa_addr->sa_family != AF_LINK)
1256 continue;
1257
1258 if (strcmp(str, ifa->ifa_name) != 0)
1259 continue;
1260
1261 sdl = (struct sockaddr_dl *)(void *)ifa->ifa_addr;
1262 }
1263 /* If we found it, then use it */
1264 if (sdl != NULL) {
1265 /*
1266 * Note that we need to copy before calling
1267 * freeifaddrs().
1268 */
1269 memcpy(sdl0, sdl, sdl->sdl_len);
1270 }
1271 freeifaddrs(ifap);
1272 if (sdl != NULL)
1273 return(1);
1274 else
1275 errx(EX_DATAERR,
1276 "interface '%s' does not exist", str);
1277 }
1278 break;
1279 case RTAX_IFP:
1280 sa->sa_family = AF_LINK;
1281 break;
1282 }
1283 if (strcmp(str, "default") == 0) {
1284 /*
1285 * Default is net 0.0.0.0/0
1286 */
1287 switch (idx) {
1288 case RTAX_DST:
1289 nrflags |= F_FORCENET;
1290 getaddr(RTAX_NETMASK, str, nrflags);
1291 break;
1292 }
1293 return (0);
1294 }
1295 switch (sa->sa_family) {
1296 #ifdef INET6
1297 case AF_INET6:
1298 {
1299 struct addrinfo hints, *res;
1300 int ecode;
1301
1302 q = NULL;
1303 if (idx == RTAX_DST && (q = strchr(str, '/')) != NULL)
1304 *q = '\0';
1305 memset(&hints, 0, sizeof(hints));
1306 hints.ai_family = sa->sa_family;
1307 hints.ai_socktype = SOCK_DGRAM;
1308 ecode = getaddrinfo(str, NULL, &hints, &res);
1309 if (ecode != 0 || res->ai_family != AF_INET6 ||
1310 res->ai_addrlen != sizeof(struct sockaddr_in6))
1311 errx(EX_OSERR, "%s: %s", str, gai_strerror(ecode));
1312 memcpy(sa, res->ai_addr, res->ai_addrlen);
1313 freeaddrinfo(res);
1314 if (q != NULL)
1315 *q++ = '/';
1316 if (idx == RTAX_DST)
1317 return (inet6_makenetandmask((struct sockaddr_in6 *)(void *)sa, q));
1318 return (0);
1319 }
1320 #endif /* INET6 */
1321 case AF_LINK:
1322 link_addr(str, (struct sockaddr_dl *)(void *)sa);
1323 return (1);
1324
1325 case PF_ROUTE:
1326 sockaddr(str, sa, sizeof(struct sockaddr_storage));
1327 return (1);
1328 #ifdef INET
1329 case AF_INET:
1330 #endif
1331 default:
1332 break;
1333 }
1334
1335 #ifdef INET
1336 sin = (struct sockaddr_in *)(void *)sa;
1337
1338 q = strchr(str,'/');
1339 if (q != NULL && idx == RTAX_DST) {
1340 /* A.B.C.D/NUM */
1341 struct sockaddr_in *mask;
1342 uint32_t mask_bits;
1343
1344 *q = '\0';
1345 if (inet_aton(str, &sin->sin_addr) == 0)
1346 errx(EX_NOHOST, "bad address: %s", str);
1347
1348 int masklen = strtol(q + 1, NULL, 10);
1349 if (masklen < 0 || masklen > 32)
1350 errx(EX_NOHOST, "bad mask length: %s", q + 1);
1351
1352 inet_makemask((struct sockaddr_in *)&so[RTAX_NETMASK],masklen);
1353
1354 /*
1355 * Check for bogus destination such as "10/8"; heuristic is
1356 * that there are bits set in the host part, and no dot
1357 * is present.
1358 */
1359 mask = ((struct sockaddr_in *) &so[RTAX_NETMASK]);
1360 mask_bits = ntohl(mask->sin_addr.s_addr);
1361 if ((ntohl(sin->sin_addr.s_addr) & ~mask_bits) != 0 &&
1362 strchr(str, '.') == NULL)
1363 errx(EX_NOHOST,
1364 "malformed address, bits set after mask;"
1365 " %s means %s",
1366 str, inet_ntoa(sin->sin_addr));
1367 return (0);
1368 }
1369 if (inet_aton(str, &sin->sin_addr) != 0)
1370 return (1);
1371
1372 hp = gethostbyname(str);
1373 if (hp != NULL) {
1374 sin->sin_family = hp->h_addrtype;
1375 memmove((char *)&sin->sin_addr, hp->h_addr,
1376 MIN((size_t)hp->h_length, sizeof(sin->sin_addr)));
1377 return (1);
1378 }
1379 #endif
1380 errx(EX_NOHOST, "bad address: %s", str);
1381 }
1382
1383 static int
prefixlen(const char * str)1384 prefixlen(const char *str)
1385 {
1386 int len = atoi(str), q, r;
1387 int max;
1388 char *p;
1389
1390 rtm_addrs |= RTA_NETMASK;
1391 switch (af) {
1392 #ifdef INET6
1393 case AF_INET6:
1394 {
1395 struct sockaddr_in6 *sin6 =
1396 (struct sockaddr_in6 *)&so[RTAX_NETMASK];
1397
1398 max = 128;
1399 p = (char *)&sin6->sin6_addr;
1400 sin6->sin6_family = AF_INET6;
1401 sin6->sin6_len = sizeof(*sin6);
1402 break;
1403 }
1404 #endif
1405 #ifdef INET
1406 case AF_INET:
1407 {
1408 struct sockaddr_in *sin =
1409 (struct sockaddr_in *)&so[RTAX_NETMASK];
1410
1411 max = 32;
1412 p = (char *)&sin->sin_addr;
1413 sin->sin_family = AF_INET;
1414 sin->sin_len = sizeof(*sin);
1415 break;
1416 }
1417 #endif
1418 default:
1419 errx(EX_OSERR, "prefixlen not supported in this af");
1420 }
1421
1422 if (len < 0 || max < len)
1423 errx(EX_USAGE, "%s: invalid prefixlen", str);
1424
1425 q = len >> 3;
1426 r = len & 7;
1427 memset((void *)p, 0, max / 8);
1428 if (q > 0)
1429 memset((void *)p, 0xff, q);
1430 if (r > 0)
1431 *((u_char *)p + q) = (0xff00 >> r) & 0xff;
1432 if (len == max)
1433 return (-1);
1434 else
1435 return (len);
1436 }
1437
1438 static void
interfaces(void)1439 interfaces(void)
1440 {
1441 size_t needed;
1442 int mib[6];
1443 char *buf, *lim, *next, count = 0;
1444 struct rt_msghdr *rtm;
1445
1446 retry2:
1447 mib[0] = CTL_NET;
1448 mib[1] = PF_ROUTE;
1449 mib[2] = 0; /* protocol */
1450 mib[3] = AF_UNSPEC;
1451 mib[4] = NET_RT_IFLIST;
1452 mib[5] = 0; /* no flags */
1453 if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0)
1454 err(EX_OSERR, "route-sysctl-estimate");
1455 if ((buf = malloc(needed)) == NULL)
1456 errx(EX_OSERR, "malloc failed");
1457 if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0) {
1458 if (errno == ENOMEM && count++ < 10) {
1459 warnx("Routing table grew, retrying");
1460 sleep(1);
1461 free(buf);
1462 goto retry2;
1463 }
1464 err(EX_OSERR, "actual retrieval of interface table");
1465 }
1466 lim = buf + needed;
1467 for (next = buf; next < lim; next += rtm->rtm_msglen) {
1468 rtm = (struct rt_msghdr *)(void *)next;
1469 print_rtmsg(rtm, rtm->rtm_msglen);
1470 }
1471 free(buf);
1472 }
1473
1474 static void
monitor(int argc,char * argv[])1475 monitor(int argc, char *argv[])
1476 {
1477 int fib, error;
1478 char *endptr;
1479
1480 fib = defaultfib;
1481 while (argc > 1) {
1482 argc--;
1483 argv++;
1484 if (**argv != '-')
1485 usage(*argv);
1486 switch (keyword(*argv + 1)) {
1487 case K_FIB:
1488 if (!--argc)
1489 usage(*argv);
1490 errno = 0;
1491 fib = strtol(*++argv, &endptr, 0);
1492 if (errno == 0) {
1493 if (*endptr != '\0' ||
1494 fib < 0 ||
1495 (numfibs != -1 && fib > numfibs - 1))
1496 errno = EINVAL;
1497 }
1498 if (errno)
1499 errx(EX_USAGE, "invalid fib number: %s", *argv);
1500 break;
1501 default:
1502 usage(*argv);
1503 }
1504 }
1505 error = set_sofib(fib);
1506 if (error)
1507 errx(EX_USAGE, "invalid fib number: %d", fib);
1508
1509 verbose = 1;
1510 if (debugonly) {
1511 interfaces();
1512 exit(0);
1513 }
1514 #ifdef WITHOUT_NETLINK
1515 monitor_rtsock();
1516 #else
1517 monitor_nl(fib);
1518 #endif
1519 }
1520
1521 #ifdef WITHOUT_NETLINK
1522 static void
monitor_rtsock(void)1523 monitor_rtsock(void)
1524 {
1525 char msg[2048];
1526 int n;
1527
1528 #ifdef SO_RERROR
1529 n = 1;
1530 if (setsockopt(s, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) == -1)
1531 warn("SO_RERROR");
1532 #endif
1533
1534 for (;;) {
1535 time_t now;
1536 n = read(s, msg, sizeof(msg));
1537 if (n == -1) {
1538 warn("read");
1539 continue;
1540 }
1541 now = time(NULL);
1542 (void)printf("\ngot message of size %d on %s", n, ctime(&now));
1543 print_rtmsg((struct rt_msghdr *)(void *)msg, n);
1544 }
1545 }
1546 #endif
1547
1548 static int
rtmsg(int cmd,int flags,int fib)1549 rtmsg(int cmd, int flags, int fib)
1550 {
1551 errno = 0;
1552 if (cmd == 'a')
1553 cmd = RTM_ADD;
1554 else if (cmd == 'c')
1555 cmd = RTM_CHANGE;
1556 else if (cmd == 'g' || cmd == 's') {
1557 cmd = RTM_GET;
1558 if (so[RTAX_IFP].ss_family == 0) {
1559 so[RTAX_IFP].ss_family = AF_LINK;
1560 so[RTAX_IFP].ss_len = sizeof(struct sockaddr_dl);
1561 rtm_addrs |= RTA_IFP;
1562 }
1563 } else {
1564 cmd = RTM_DELETE;
1565 flags |= RTF_PINNED;
1566 }
1567 #ifdef WITHOUT_NETLINK
1568 return (rtmsg_rtsock(cmd, flags, fib));
1569 #else
1570 errno = rtmsg_nl(cmd, flags, fib, rtm_addrs, so, &rt_metrics);
1571 return (errno == 0 ? 0 : -1);
1572 #endif
1573 }
1574
1575 #ifdef WITHOUT_NETLINK
1576 static int
rtmsg_rtsock(int cmd,int flags,int fib)1577 rtmsg_rtsock(int cmd, int flags, int fib)
1578 {
1579 int rlen;
1580 char *cp = m_rtmsg.m_space;
1581 int l;
1582
1583 memset(&m_rtmsg, 0, sizeof(m_rtmsg));
1584
1585 #define NEXTADDR(w, u) \
1586 if (rtm_addrs & (w)) { \
1587 l = SA_SIZE(&(u)); \
1588 memmove(cp, (char *)&(u), l); \
1589 cp += l; \
1590 if (verbose) \
1591 sodump((struct sockaddr *)&(u), #w); \
1592 }
1593
1594 #define rtm m_rtmsg.m_rtm
1595 rtm.rtm_type = cmd;
1596 rtm.rtm_flags = flags;
1597 rtm.rtm_version = RTM_VERSION;
1598 rtm.rtm_seq = ++rtm_seq;
1599 rtm.rtm_addrs = rtm_addrs;
1600 rtm.rtm_rmx = rt_metrics;
1601 rtm.rtm_inits = rtm_inits;
1602
1603 NEXTADDR(RTA_DST, so[RTAX_DST]);
1604 NEXTADDR(RTA_GATEWAY, so[RTAX_GATEWAY]);
1605 NEXTADDR(RTA_NETMASK, so[RTAX_NETMASK]);
1606 NEXTADDR(RTA_GENMASK, so[RTAX_GENMASK]);
1607 NEXTADDR(RTA_IFP, so[RTAX_IFP]);
1608 NEXTADDR(RTA_IFA, so[RTAX_IFA]);
1609 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
1610 if (verbose)
1611 print_rtmsg(&rtm, l);
1612 if (debugonly)
1613 return (0);
1614 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
1615 switch (errno) {
1616 case EPERM:
1617 err(1, "writing to routing socket");
1618 break;
1619 case ESRCH:
1620 warnx("route has not been found");
1621 break;
1622 case EEXIST:
1623 /* Handled by newroute() */
1624 break;
1625 default:
1626 warn("writing to routing socket");
1627 }
1628 return (-1);
1629 }
1630 if (cmd == RTM_GET) {
1631 stop_read = 0;
1632 alarm(READ_TIMEOUT);
1633 do {
1634 l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
1635 } while (l > 0 && stop_read == 0 &&
1636 (rtm.rtm_type != RTM_GET || rtm.rtm_seq != rtm_seq ||
1637 rtm.rtm_pid != pid));
1638 if (stop_read != 0) {
1639 warnx("read from routing socket timed out");
1640 return (-1);
1641 } else
1642 alarm(0);
1643 if (l < 0)
1644 warn("read from routing socket");
1645 else
1646 print_getmsg(&rtm, l, fib);
1647 }
1648 #undef rtm
1649 return (0);
1650 }
1651 #endif
1652
1653 static const char *const msgtypes[] = {
1654 "",
1655 "RTM_ADD: Add Route",
1656 "RTM_DELETE: Delete Route",
1657 "RTM_CHANGE: Change Metrics or flags",
1658 "RTM_GET: Report Metrics",
1659 "RTM_LOSING: Kernel Suspects Partitioning",
1660 "RTM_REDIRECT: Told to use different route",
1661 "RTM_MISS: Lookup failed on this address",
1662 "RTM_LOCK: fix specified metrics",
1663 "RTM_OLDADD: caused by SIOCADDRT",
1664 "RTM_OLDDEL: caused by SIOCDELRT",
1665 "RTM_RESOLVE: Route created by cloning",
1666 "RTM_NEWADDR: address being added to iface",
1667 "RTM_DELADDR: address being removed from iface",
1668 "RTM_IFINFO: iface status change",
1669 "RTM_NEWMADDR: new multicast group membership on iface",
1670 "RTM_DELMADDR: multicast group membership removed from iface",
1671 "RTM_IFANNOUNCE: interface arrival/departure",
1672 "RTM_IEEE80211: IEEE 802.11 wireless event",
1673 "RTM_IPFWLOG: IPFW log",
1674 };
1675
1676 static const char metricnames[] =
1677 "\011weight\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire"
1678 "\1mtu";
1679 const char routeflags[] =
1680 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE"
1681 "\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE"
1682 "\017PROTO2\020PROTO1\021PRCLONING\022WASCLONED\023PROTO3"
1683 "\024FIXEDMTU\025PINNED\026LOCAL\027BROADCAST\030MULTICAST\035STICKY";
1684 static const char ifnetflags[] =
1685 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6b6\7RUNNING\010NOARP"
1686 "\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1"
1687 "\017LINK2\020MULTICAST";
1688 static const char addrnames[] =
1689 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD";
1690
1691 static const char errfmt[] =
1692 "\n%s: truncated route message, only %zu bytes left\n";
1693
1694 static void
print_rtmsg(struct rt_msghdr * rtm,size_t msglen)1695 print_rtmsg(struct rt_msghdr *rtm, size_t msglen)
1696 {
1697 struct if_msghdr *ifm;
1698 struct ifa_msghdr *ifam;
1699 #ifdef RTM_NEWMADDR
1700 struct ifma_msghdr *ifmam;
1701 #endif
1702 struct if_announcemsghdr *ifan;
1703 const char *state;
1704
1705 if (verbose == 0)
1706 return;
1707 if (rtm->rtm_version != RTM_VERSION) {
1708 (void)printf("routing message version %d not understood\n",
1709 rtm->rtm_version);
1710 return;
1711 }
1712 if (rtm->rtm_type < nitems(msgtypes))
1713 (void)printf("%s: ", msgtypes[rtm->rtm_type]);
1714 else
1715 (void)printf("unknown type %d: ", rtm->rtm_type);
1716 (void)printf("len %d, ", rtm->rtm_msglen);
1717
1718 #define REQUIRE(x) do { \
1719 if (msglen < sizeof(x)) \
1720 goto badlen; \
1721 else \
1722 msglen -= sizeof(x); \
1723 } while (0)
1724
1725 switch (rtm->rtm_type) {
1726 case RTM_IFINFO:
1727 REQUIRE(struct if_msghdr);
1728 ifm = (struct if_msghdr *)rtm;
1729 (void)printf("if# %d, ", ifm->ifm_index);
1730 switch (ifm->ifm_data.ifi_link_state) {
1731 case LINK_STATE_DOWN:
1732 state = "down";
1733 break;
1734 case LINK_STATE_UP:
1735 state = "up";
1736 break;
1737 default:
1738 state = "unknown";
1739 break;
1740 }
1741 (void)printf("link: %s, flags:", state);
1742 printb(ifm->ifm_flags, ifnetflags);
1743 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs, msglen);
1744 break;
1745 case RTM_NEWADDR:
1746 case RTM_DELADDR:
1747 REQUIRE(struct ifa_msghdr);
1748 ifam = (struct ifa_msghdr *)rtm;
1749 (void)printf("metric %d, flags:", ifam->ifam_metric);
1750 printb(ifam->ifam_flags, routeflags);
1751 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs, msglen);
1752 break;
1753 #ifdef RTM_NEWMADDR
1754 case RTM_NEWMADDR:
1755 case RTM_DELMADDR:
1756 REQUIRE(struct ifma_msghdr);
1757 ifmam = (struct ifma_msghdr *)rtm;
1758 pmsg_addrs((char *)(ifmam + 1), ifmam->ifmam_addrs, msglen);
1759 break;
1760 #endif
1761 case RTM_IFANNOUNCE:
1762 REQUIRE(struct if_announcemsghdr);
1763 ifan = (struct if_announcemsghdr *)rtm;
1764 (void)printf("if# %d, what: ", ifan->ifan_index);
1765 switch (ifan->ifan_what) {
1766 case IFAN_ARRIVAL:
1767 (void)printf("arrival");
1768 break;
1769 case IFAN_DEPARTURE:
1770 printf("departure");
1771 break;
1772 default:
1773 printf("#%d", ifan->ifan_what);
1774 break;
1775 }
1776 printf("\n");
1777 fflush(stdout);
1778 break;
1779
1780 default:
1781 if (rtm->rtm_type <= RTM_RESOLVE) {
1782 printf("pid: %ld, seq %d, errno %d, flags:",
1783 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1784 printb(rtm->rtm_flags, routeflags);
1785 pmsg_common(rtm, msglen);
1786 } else
1787 printf("type: %u, len: %zu\n", rtm->rtm_type, msglen);
1788 }
1789
1790 return;
1791
1792 badlen:
1793 (void)printf(errfmt, __func__, msglen);
1794 #undef REQUIRE
1795 }
1796
1797 static void
print_getmsg(struct rt_msghdr * rtm,int msglen,int fib)1798 print_getmsg(struct rt_msghdr *rtm, int msglen, int fib)
1799 {
1800 struct sockaddr *sp[RTAX_MAX];
1801 struct timespec ts;
1802 char *cp;
1803 int i;
1804
1805 memset(sp, 0, sizeof(sp));
1806 (void)printf(" route to: %s\n",
1807 routename((struct sockaddr *)&so[RTAX_DST]));
1808 if (rtm->rtm_version != RTM_VERSION) {
1809 warnx("routing message version %d not understood",
1810 rtm->rtm_version);
1811 return;
1812 }
1813 if (rtm->rtm_msglen > msglen) {
1814 warnx("message length mismatch, in packet %d, returned %d",
1815 rtm->rtm_msglen, msglen);
1816 return;
1817 }
1818 if (rtm->rtm_errno) {
1819 errno = rtm->rtm_errno;
1820 warn("message indicates error %d", errno);
1821 return;
1822 }
1823 cp = ((char *)(rtm + 1));
1824 for (i = 0; i < RTAX_MAX; i++)
1825 if (rtm->rtm_addrs & (1 << i)) {
1826 sp[i] = (struct sockaddr *)cp;
1827 cp += SA_SIZE((struct sockaddr *)cp);
1828 }
1829 if ((rtm->rtm_addrs & RTA_IFP) &&
1830 (sp[RTAX_IFP]->sa_family != AF_LINK ||
1831 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_nlen == 0))
1832 sp[RTAX_IFP] = NULL;
1833 if (sp[RTAX_DST])
1834 (void)printf("destination: %s\n", routename(sp[RTAX_DST]));
1835 if (sp[RTAX_NETMASK])
1836 (void)printf(" mask: %s\n", routename(sp[RTAX_NETMASK]));
1837 if (sp[RTAX_GATEWAY] && (rtm->rtm_flags & RTF_GATEWAY))
1838 (void)printf(" gateway: %s\n", routename(sp[RTAX_GATEWAY]));
1839 if (fib >= 0)
1840 (void)printf(" fib: %u\n", (unsigned int)fib);
1841 if (sp[RTAX_IFP])
1842 (void)printf(" interface: %.*s\n",
1843 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_nlen,
1844 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_data);
1845 (void)printf(" flags: ");
1846 printb(rtm->rtm_flags, routeflags);
1847
1848 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1849 #define msec(u) (((u) + 500) / 1000) /* usec to msec */
1850 printf("\n%9s %9s %9s %9s %9s %10s %9s\n", "recvpipe",
1851 "sendpipe", "ssthresh", "rtt,msec", "mtu ", "weight", "expire");
1852 printf("%8lu%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE));
1853 printf("%8lu%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE));
1854 printf("%8lu%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH));
1855 printf("%8lu%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT));
1856 printf("%8lu%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU));
1857 printf("%8lu%c ", rtm->rtm_rmx.rmx_weight, lock(WEIGHT));
1858 if (rtm->rtm_rmx.rmx_expire > 0)
1859 clock_gettime(CLOCK_REALTIME_FAST, &ts);
1860 else
1861 ts.tv_sec = 0;
1862 printf("%8ld%c\n", (long)(rtm->rtm_rmx.rmx_expire - ts.tv_sec),
1863 lock(EXPIRE));
1864 #undef lock
1865 #undef msec
1866 #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD)
1867 if (verbose)
1868 pmsg_common(rtm, msglen);
1869 else if (rtm->rtm_addrs &~ RTA_IGN) {
1870 (void)printf("sockaddrs: ");
1871 printb(rtm->rtm_addrs, addrnames);
1872 putchar('\n');
1873 }
1874 #undef RTA_IGN
1875 }
1876
1877 static void
pmsg_common(struct rt_msghdr * rtm,size_t msglen)1878 pmsg_common(struct rt_msghdr *rtm, size_t msglen)
1879 {
1880
1881 (void)printf("\nlocks: ");
1882 printb(rtm->rtm_rmx.rmx_locks, metricnames);
1883 (void)printf(" inits: ");
1884 printb(rtm->rtm_inits, metricnames);
1885 if (msglen > sizeof(struct rt_msghdr))
1886 pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs,
1887 msglen - sizeof(struct rt_msghdr));
1888 else
1889 (void)fflush(stdout);
1890 }
1891
1892 static void
pmsg_addrs(char * cp,int addrs,size_t len)1893 pmsg_addrs(char *cp, int addrs, size_t len)
1894 {
1895 struct sockaddr *sa;
1896 int i;
1897
1898 if (addrs == 0) {
1899 (void)putchar('\n');
1900 return;
1901 }
1902 (void)printf("\nsockaddrs: ");
1903 printb(addrs, addrnames);
1904 putchar('\n');
1905 for (i = 0; i < RTAX_MAX; i++)
1906 if (addrs & (1 << i)) {
1907 sa = (struct sockaddr *)cp;
1908 if (len == 0 || len < SA_SIZE(sa)) {
1909 (void)printf(errfmt, __func__, len);
1910 break;
1911 }
1912 (void)printf(" %s", routename(sa));
1913 len -= SA_SIZE(sa);
1914 cp += SA_SIZE(sa);
1915 }
1916 (void)putchar('\n');
1917 (void)fflush(stdout);
1918 }
1919
1920 void
printb(int b,const char * str)1921 printb(int b, const char *str)
1922 {
1923 int i;
1924 int gotsome = 0;
1925
1926 if (b == 0)
1927 return;
1928 while ((i = *str++) != 0) {
1929 if (b & (1 << (i-1))) {
1930 if (gotsome == 0)
1931 i = '<';
1932 else
1933 i = ',';
1934 putchar(i);
1935 gotsome = 1;
1936 for (; (i = *str) > 32; str++)
1937 putchar(i);
1938 } else
1939 while (*str > 32)
1940 str++;
1941 }
1942 if (gotsome)
1943 putchar('>');
1944 }
1945
1946 int
keyword(const char * cp)1947 keyword(const char *cp)
1948 {
1949 const struct keytab *kt = keywords;
1950
1951 while (kt->kt_cp != NULL && strcmp(kt->kt_cp, cp) != 0)
1952 kt++;
1953 return (kt->kt_i);
1954 }
1955
1956 static void
sodump(struct sockaddr * sa,const char * which)1957 sodump(struct sockaddr *sa, const char *which)
1958 {
1959 #ifdef INET6
1960 char nbuf[INET6_ADDRSTRLEN];
1961 #endif
1962
1963 switch (sa->sa_family) {
1964 case AF_LINK:
1965 (void)printf("%s: link %s; ", which,
1966 link_ntoa((struct sockaddr_dl *)(void *)sa));
1967 break;
1968 #ifdef INET
1969 case AF_INET:
1970 (void)printf("%s: inet %s; ", which,
1971 inet_ntoa(((struct sockaddr_in *)(void *)sa)->sin_addr));
1972 break;
1973 #endif
1974 #ifdef INET6
1975 case AF_INET6:
1976 (void)printf("%s: inet6 %s; ", which, inet_ntop(sa->sa_family,
1977 &((struct sockaddr_in6 *)(void *)sa)->sin6_addr, nbuf,
1978 sizeof(nbuf)));
1979 break;
1980 #endif
1981 }
1982 (void)fflush(stdout);
1983 }
1984
1985 /* States*/
1986 #define VIRGIN 0
1987 #define GOTONE 1
1988 #define GOTTWO 2
1989 /* Inputs */
1990 #define DIGIT (4*0)
1991 #define END (4*1)
1992 #define DELIM (4*2)
1993
1994 static void
sockaddr(char * addr,struct sockaddr * sa,size_t size)1995 sockaddr(char *addr, struct sockaddr *sa, size_t size)
1996 {
1997 char *cp = (char *)sa;
1998 char *cplim = cp + size;
1999 int byte = 0, state = VIRGIN, new = 0 /* foil gcc */;
2000
2001 memset(cp, 0, size);
2002 cp++;
2003 do {
2004 if ((*addr >= '0') && (*addr <= '9')) {
2005 new = *addr - '0';
2006 } else if ((*addr >= 'a') && (*addr <= 'f')) {
2007 new = *addr - 'a' + 10;
2008 } else if ((*addr >= 'A') && (*addr <= 'F')) {
2009 new = *addr - 'A' + 10;
2010 } else if (*addr == '\0')
2011 state |= END;
2012 else
2013 state |= DELIM;
2014 addr++;
2015 switch (state /* | INPUT */) {
2016 case GOTTWO | DIGIT:
2017 *cp++ = byte; /*FALLTHROUGH*/
2018 case VIRGIN | DIGIT:
2019 state = GOTONE; byte = new; continue;
2020 case GOTONE | DIGIT:
2021 state = GOTTWO; byte = new + (byte << 4); continue;
2022 default: /* | DELIM */
2023 state = VIRGIN; *cp++ = byte; byte = 0; continue;
2024 case GOTONE | END:
2025 case GOTTWO | END:
2026 *cp++ = byte; /* FALLTHROUGH */
2027 case VIRGIN | END:
2028 break;
2029 }
2030 break;
2031 } while (cp < cplim);
2032 sa->sa_len = cp - (char *)sa;
2033 }
2034