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_PREFSRC:
950 case K_IFA:
951 if (!--argc)
952 usage(NULL);
953 getaddr(RTAX_IFA, *++argv, nrflags);
954 break;
955 case K_IFP:
956 if (!--argc)
957 usage(NULL);
958 getaddr(RTAX_IFP, *++argv, nrflags);
959 break;
960 case K_GENMASK:
961 if (!--argc)
962 usage(NULL);
963 getaddr(RTAX_GENMASK, *++argv, nrflags);
964 break;
965 case K_GATEWAY:
966 if (!--argc)
967 usage(NULL);
968 getaddr(RTAX_GATEWAY, *++argv, nrflags);
969 gateway = *argv;
970 break;
971 case K_DST:
972 if (!--argc)
973 usage(NULL);
974 if (getaddr(RTAX_DST, *++argv, nrflags))
975 nrflags |= F_ISHOST;
976 dest = *argv;
977 break;
978 case K_NETMASK:
979 if (!--argc)
980 usage(NULL);
981 getaddr(RTAX_NETMASK, *++argv, nrflags);
982 /* FALLTHROUGH */
983 case K_NET:
984 nrflags |= F_FORCENET;
985 break;
986 case K_PREFIXLEN:
987 if (!--argc)
988 usage(NULL);
989 if (prefixlen(*++argv) == -1) {
990 nrflags &= ~F_FORCENET;
991 nrflags |= F_ISHOST;
992 } else {
993 nrflags |= F_FORCENET;
994 nrflags &= ~F_ISHOST;
995 }
996 break;
997 case K_MTU:
998 case K_HOPCOUNT:
999 case K_EXPIRE:
1000 case K_RECVPIPE:
1001 case K_SENDPIPE:
1002 case K_SSTHRESH:
1003 case K_RTT:
1004 case K_RTTVAR:
1005 case K_WEIGHT:
1006 case K_METRIC:
1007 if (!--argc)
1008 usage(NULL);
1009 set_metric(*++argv, key);
1010 break;
1011 default:
1012 usage(1+*argv);
1013 }
1014 } else {
1015 if ((rtm_addrs & RTA_DST) == 0) {
1016 dest = *argv;
1017 if (getaddr(RTAX_DST, *argv, nrflags))
1018 nrflags |= F_ISHOST;
1019 } else if ((rtm_addrs & RTA_GATEWAY) == 0) {
1020 gateway = *argv;
1021 getaddr(RTAX_GATEWAY, *argv, nrflags);
1022 } else {
1023 getaddr(RTAX_NETMASK, *argv, nrflags);
1024 nrflags |= F_FORCENET;
1025 }
1026 }
1027 }
1028
1029 /* Do some sanity checks on resulting request */
1030 if (so[RTAX_DST].ss_len == 0) {
1031 warnx("destination parameter required");
1032 usage(NULL);
1033 }
1034
1035 if (so[RTAX_NETMASK].ss_len != 0 &&
1036 so[RTAX_DST].ss_family != so[RTAX_NETMASK].ss_family) {
1037 warnx("destination and netmask family need to be the same");
1038 usage(NULL);
1039 }
1040
1041 if (nrflags & F_FORCEHOST) {
1042 nrflags |= F_ISHOST;
1043 #ifdef INET6
1044 if (af == AF_INET6) {
1045 rtm_addrs &= ~RTA_NETMASK;
1046 memset(&so[RTAX_NETMASK], 0, sizeof(so[RTAX_NETMASK]));
1047 }
1048 #endif
1049 }
1050 if (nrflags & F_FORCENET)
1051 nrflags &= ~F_ISHOST;
1052 flags |= RTF_UP;
1053 if (nrflags & F_ISHOST)
1054 flags |= RTF_HOST;
1055 if ((nrflags & F_INTERFACE) == 0)
1056 flags |= RTF_GATEWAY;
1057 if (nrflags & F_PROXY)
1058 flags |= RTF_ANNOUNCE;
1059 if (dest == NULL)
1060 dest = "";
1061 if (gateway == NULL)
1062 gateway = "";
1063
1064 if (TAILQ_EMPTY(&fibl_head)) {
1065 error = fiboptlist_csv("default", &fibl_head);
1066 if (error)
1067 errx(EX_OSERR, "fiboptlist_csv failed.");
1068 }
1069 error = 0;
1070 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1071 fl->fl_error = newroute_fib(fl->fl_num, cmd, flags);
1072 if (fl->fl_error)
1073 fl->fl_errno = errno;
1074 error += fl->fl_error;
1075 }
1076 if (*cmd == 'g' || *cmd == 's')
1077 exit(error);
1078
1079 error = 0;
1080 if (!qflag) {
1081 fibnum = 0;
1082 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1083 if (fl->fl_error == 0)
1084 fibnum++;
1085 }
1086 if (fibnum > 0) {
1087 int firstfib = 1;
1088
1089 printf("%s %s %s", cmd,
1090 (nrflags & F_ISHOST) ? "host" : "net", dest);
1091 if (*gateway)
1092 printf(": gateway %s", gateway);
1093
1094 if (numfibs > 1) {
1095 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1096 if (fl->fl_error == 0
1097 && fl->fl_num >= 0) {
1098 if (firstfib) {
1099 printf(" fib ");
1100 firstfib = 0;
1101 }
1102 printf("%d", fl->fl_num);
1103 if (fibnum-- > 1)
1104 printf(",");
1105 }
1106 }
1107 }
1108 printf("\n");
1109 }
1110 }
1111
1112 fibnum = 0;
1113 TAILQ_FOREACH(fl, &fibl_head, fl_next) {
1114 if (fl->fl_error != 0) {
1115 error = 1;
1116 if (!qflag) {
1117 printf("%s %s %s", cmd, (nrflags & F_ISHOST)
1118 ? "host" : "net", dest);
1119 if (*gateway)
1120 printf(": gateway %s", gateway);
1121
1122 if (fl->fl_num >= 0)
1123 printf(" fib %d", fl->fl_num);
1124
1125 switch (fl->fl_errno) {
1126 case ESRCH:
1127 errmsg = "not in table";
1128 break;
1129 case EBUSY:
1130 errmsg = "entry in use";
1131 break;
1132 case ENOBUFS:
1133 errmsg = "not enough memory";
1134 break;
1135 case EADDRINUSE:
1136 /*
1137 * handle recursion avoidance
1138 * in rt_setgate()
1139 */
1140 errmsg = "gateway uses the same route";
1141 break;
1142 case EEXIST:
1143 errmsg = "route already in table";
1144 break;
1145 default:
1146 errmsg = strerror(fl->fl_errno);
1147 break;
1148 }
1149 printf(": %s\n", errmsg);
1150 }
1151 }
1152 }
1153 exit(error);
1154 }
1155
1156 static int
newroute_fib(int fib,char * cmd,int flags)1157 newroute_fib(int fib, char *cmd, int flags)
1158 {
1159 int error;
1160
1161 error = set_sofib(fib);
1162 if (error) {
1163 warn("fib number %d is ignored", fib);
1164 return (error);
1165 }
1166
1167 error = rtmsg(*cmd, flags, fib);
1168 return (error);
1169 }
1170
1171 #ifdef INET
1172 static void
inet_makemask(struct sockaddr_in * sin_mask,u_long bits)1173 inet_makemask(struct sockaddr_in *sin_mask, u_long bits)
1174 {
1175 u_long mask = 0;
1176
1177 rtm_addrs |= RTA_NETMASK;
1178
1179 if (bits != 0)
1180 mask = 0xffffffff << (32 - bits);
1181
1182 sin_mask->sin_addr.s_addr = htonl(mask);
1183 sin_mask->sin_len = sizeof(struct sockaddr_in);
1184 sin_mask->sin_family = AF_INET;
1185 }
1186 #endif
1187
1188 #ifdef INET6
1189 /*
1190 * XXX the function may need more improvement...
1191 */
1192 static int
inet6_makenetandmask(struct sockaddr_in6 * sin6,const char * plen)1193 inet6_makenetandmask(struct sockaddr_in6 *sin6, const char *plen)
1194 {
1195
1196 if (plen == NULL) {
1197 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
1198 sin6->sin6_scope_id == 0)
1199 plen = "0";
1200 }
1201
1202 if (plen == NULL || strcmp(plen, "128") == 0)
1203 return (1);
1204 rtm_addrs |= RTA_NETMASK;
1205 prefixlen(plen);
1206 return (0);
1207 }
1208 #endif
1209
1210 /*
1211 * Interpret an argument as a network address of some kind,
1212 * returning 1 if a host address, 0 if a network address.
1213 */
1214 static int
getaddr(int idx,char * str,int nrflags)1215 getaddr(int idx, char *str, int nrflags)
1216 {
1217 struct sockaddr *sa;
1218 #if defined(INET)
1219 struct sockaddr_in *sin;
1220 struct hostent *hp;
1221 char *q;
1222 #elif defined(INET6)
1223 char *q;
1224 #endif
1225
1226 if (idx < 0 || idx >= RTAX_MAX)
1227 usage("internal error");
1228 if (af == 0) {
1229 #if defined(INET)
1230 af = AF_INET;
1231 aflen = sizeof(struct sockaddr_in);
1232 #elif defined(INET6)
1233 af = AF_INET6;
1234 aflen = sizeof(struct sockaddr_in6);
1235 #else
1236 af = AF_LINK;
1237 aflen = sizeof(struct sockaddr_dl);
1238 #endif
1239 }
1240 rtm_addrs |= (1 << idx);
1241 sa = (struct sockaddr *)&so[idx];
1242 sa->sa_family = af;
1243 sa->sa_len = aflen;
1244
1245 switch (idx) {
1246 case RTAX_GATEWAY:
1247 if (nrflags & F_INTERFACE) {
1248 struct ifaddrs *ifap, *ifa;
1249 struct sockaddr_dl *sdl0 = (struct sockaddr_dl *)(void *)sa;
1250 struct sockaddr_dl *sdl = NULL;
1251
1252 if (getifaddrs(&ifap))
1253 err(EX_OSERR, "getifaddrs");
1254
1255 for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
1256 if (ifa->ifa_addr->sa_family != AF_LINK)
1257 continue;
1258
1259 if (strcmp(str, ifa->ifa_name) != 0)
1260 continue;
1261
1262 sdl = (struct sockaddr_dl *)(void *)ifa->ifa_addr;
1263 }
1264 /* If we found it, then use it */
1265 if (sdl != NULL) {
1266 /*
1267 * Note that we need to copy before calling
1268 * freeifaddrs().
1269 */
1270 memcpy(sdl0, sdl, sdl->sdl_len);
1271 }
1272 freeifaddrs(ifap);
1273 if (sdl != NULL)
1274 return(1);
1275 else
1276 errx(EX_DATAERR,
1277 "interface '%s' does not exist", str);
1278 }
1279 break;
1280 case RTAX_IFP:
1281 sa->sa_family = AF_LINK;
1282 break;
1283 }
1284 if (strcmp(str, "default") == 0) {
1285 /*
1286 * Default is net 0.0.0.0/0
1287 */
1288 switch (idx) {
1289 case RTAX_DST:
1290 nrflags |= F_FORCENET;
1291 getaddr(RTAX_NETMASK, str, nrflags);
1292 break;
1293 }
1294 return (0);
1295 }
1296 switch (sa->sa_family) {
1297 #ifdef INET6
1298 case AF_INET6:
1299 {
1300 struct addrinfo hints, *res;
1301 int ecode;
1302
1303 q = NULL;
1304 if (idx == RTAX_DST && (q = strchr(str, '/')) != NULL)
1305 *q = '\0';
1306 memset(&hints, 0, sizeof(hints));
1307 hints.ai_family = sa->sa_family;
1308 hints.ai_socktype = SOCK_DGRAM;
1309 ecode = getaddrinfo(str, NULL, &hints, &res);
1310 if (ecode != 0 || res->ai_family != AF_INET6 ||
1311 res->ai_addrlen != sizeof(struct sockaddr_in6))
1312 errx(EX_OSERR, "%s: %s", str, gai_strerror(ecode));
1313 memcpy(sa, res->ai_addr, res->ai_addrlen);
1314 freeaddrinfo(res);
1315 if (q != NULL)
1316 *q++ = '/';
1317 if (idx == RTAX_DST)
1318 return (inet6_makenetandmask((struct sockaddr_in6 *)(void *)sa, q));
1319 return (0);
1320 }
1321 #endif /* INET6 */
1322 case AF_LINK:
1323 link_addr(str, (struct sockaddr_dl *)(void *)sa);
1324 return (1);
1325
1326 case PF_ROUTE:
1327 sockaddr(str, sa, sizeof(struct sockaddr_storage));
1328 return (1);
1329 #ifdef INET
1330 case AF_INET:
1331 #endif
1332 default:
1333 break;
1334 }
1335
1336 #ifdef INET
1337 sin = (struct sockaddr_in *)(void *)sa;
1338
1339 q = strchr(str,'/');
1340 if (q != NULL && idx == RTAX_DST) {
1341 /* A.B.C.D/NUM */
1342 struct sockaddr_in *mask;
1343 uint32_t mask_bits;
1344
1345 *q = '\0';
1346 if (inet_aton(str, &sin->sin_addr) == 0)
1347 errx(EX_NOHOST, "bad address: %s", str);
1348
1349 int masklen = strtol(q + 1, NULL, 10);
1350 if (masklen < 0 || masklen > 32)
1351 errx(EX_NOHOST, "bad mask length: %s", q + 1);
1352
1353 inet_makemask((struct sockaddr_in *)&so[RTAX_NETMASK],masklen);
1354
1355 /*
1356 * Check for bogus destination such as "10/8"; heuristic is
1357 * that there are bits set in the host part, and no dot
1358 * is present.
1359 */
1360 mask = ((struct sockaddr_in *) &so[RTAX_NETMASK]);
1361 mask_bits = ntohl(mask->sin_addr.s_addr);
1362 if ((ntohl(sin->sin_addr.s_addr) & ~mask_bits) != 0 &&
1363 strchr(str, '.') == NULL)
1364 errx(EX_NOHOST,
1365 "malformed address, bits set after mask;"
1366 " %s means %s",
1367 str, inet_ntoa(sin->sin_addr));
1368 return (0);
1369 }
1370 if (inet_aton(str, &sin->sin_addr) != 0)
1371 return (1);
1372
1373 hp = gethostbyname(str);
1374 if (hp != NULL) {
1375 sin->sin_family = hp->h_addrtype;
1376 memmove((char *)&sin->sin_addr, hp->h_addr,
1377 MIN((size_t)hp->h_length, sizeof(sin->sin_addr)));
1378 return (1);
1379 }
1380 #endif
1381 errx(EX_NOHOST, "bad address: %s", str);
1382 }
1383
1384 static int
prefixlen(const char * str)1385 prefixlen(const char *str)
1386 {
1387 int len = atoi(str), q, r;
1388 int max;
1389 char *p;
1390
1391 rtm_addrs |= RTA_NETMASK;
1392 switch (af) {
1393 #ifdef INET6
1394 case AF_INET6:
1395 {
1396 struct sockaddr_in6 *sin6 =
1397 (struct sockaddr_in6 *)&so[RTAX_NETMASK];
1398
1399 max = 128;
1400 p = (char *)&sin6->sin6_addr;
1401 sin6->sin6_family = AF_INET6;
1402 sin6->sin6_len = sizeof(*sin6);
1403 break;
1404 }
1405 #endif
1406 #ifdef INET
1407 case AF_INET:
1408 {
1409 struct sockaddr_in *sin =
1410 (struct sockaddr_in *)&so[RTAX_NETMASK];
1411
1412 max = 32;
1413 p = (char *)&sin->sin_addr;
1414 sin->sin_family = AF_INET;
1415 sin->sin_len = sizeof(*sin);
1416 break;
1417 }
1418 #endif
1419 default:
1420 errx(EX_OSERR, "prefixlen not supported in this af");
1421 }
1422
1423 if (len < 0 || max < len)
1424 errx(EX_USAGE, "%s: invalid prefixlen", str);
1425
1426 q = len >> 3;
1427 r = len & 7;
1428 memset((void *)p, 0, max / 8);
1429 if (q > 0)
1430 memset((void *)p, 0xff, q);
1431 if (r > 0)
1432 *((u_char *)p + q) = (0xff00 >> r) & 0xff;
1433 if (len == max)
1434 return (-1);
1435 else
1436 return (len);
1437 }
1438
1439 static void
interfaces(void)1440 interfaces(void)
1441 {
1442 size_t needed;
1443 int mib[6];
1444 char *buf, *lim, *next, count = 0;
1445 struct rt_msghdr *rtm;
1446
1447 retry2:
1448 mib[0] = CTL_NET;
1449 mib[1] = PF_ROUTE;
1450 mib[2] = 0; /* protocol */
1451 mib[3] = AF_UNSPEC;
1452 mib[4] = NET_RT_IFLIST;
1453 mib[5] = 0; /* no flags */
1454 if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0)
1455 err(EX_OSERR, "route-sysctl-estimate");
1456 if ((buf = malloc(needed)) == NULL)
1457 errx(EX_OSERR, "malloc failed");
1458 if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0) {
1459 if (errno == ENOMEM && count++ < 10) {
1460 warnx("Routing table grew, retrying");
1461 sleep(1);
1462 free(buf);
1463 goto retry2;
1464 }
1465 err(EX_OSERR, "actual retrieval of interface table");
1466 }
1467 lim = buf + needed;
1468 for (next = buf; next < lim; next += rtm->rtm_msglen) {
1469 rtm = (struct rt_msghdr *)(void *)next;
1470 print_rtmsg(rtm, rtm->rtm_msglen);
1471 }
1472 free(buf);
1473 }
1474
1475 static void
monitor(int argc,char * argv[])1476 monitor(int argc, char *argv[])
1477 {
1478 int fib, error;
1479 char *endptr;
1480
1481 fib = defaultfib;
1482 while (argc > 1) {
1483 argc--;
1484 argv++;
1485 if (**argv != '-')
1486 usage(*argv);
1487 switch (keyword(*argv + 1)) {
1488 case K_FIB:
1489 if (!--argc)
1490 usage(*argv);
1491 errno = 0;
1492 fib = strtol(*++argv, &endptr, 0);
1493 if (errno == 0) {
1494 if (*endptr != '\0' ||
1495 fib < 0 ||
1496 (numfibs != -1 && fib > numfibs - 1))
1497 errno = EINVAL;
1498 }
1499 if (errno)
1500 errx(EX_USAGE, "invalid fib number: %s", *argv);
1501 break;
1502 default:
1503 usage(*argv);
1504 }
1505 }
1506 error = set_sofib(fib);
1507 if (error)
1508 errx(EX_USAGE, "invalid fib number: %d", fib);
1509
1510 verbose = 1;
1511 if (debugonly) {
1512 interfaces();
1513 exit(0);
1514 }
1515 #ifdef WITHOUT_NETLINK
1516 monitor_rtsock();
1517 #else
1518 monitor_nl(fib);
1519 #endif
1520 }
1521
1522 #ifdef WITHOUT_NETLINK
1523 static void
monitor_rtsock(void)1524 monitor_rtsock(void)
1525 {
1526 char msg[2048];
1527 int n;
1528
1529 #ifdef SO_RERROR
1530 n = 1;
1531 if (setsockopt(s, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) == -1)
1532 warn("SO_RERROR");
1533 #endif
1534
1535 for (;;) {
1536 time_t now;
1537 n = read(s, msg, sizeof(msg));
1538 if (n == -1) {
1539 warn("read");
1540 continue;
1541 }
1542 now = time(NULL);
1543 (void)printf("\ngot message of size %d on %s", n, ctime(&now));
1544 print_rtmsg((struct rt_msghdr *)(void *)msg, n);
1545 }
1546 }
1547 #endif
1548
1549 static int
rtmsg(int cmd,int flags,int fib)1550 rtmsg(int cmd, int flags, int fib)
1551 {
1552 errno = 0;
1553 if (cmd == 'a')
1554 cmd = RTM_ADD;
1555 else if (cmd == 'c')
1556 cmd = RTM_CHANGE;
1557 else if (cmd == 'g' || cmd == 's') {
1558 cmd = RTM_GET;
1559 if (so[RTAX_IFP].ss_family == 0) {
1560 so[RTAX_IFP].ss_family = AF_LINK;
1561 so[RTAX_IFP].ss_len = sizeof(struct sockaddr_dl);
1562 rtm_addrs |= RTA_IFP;
1563 }
1564 } else {
1565 cmd = RTM_DELETE;
1566 flags |= RTF_PINNED;
1567 }
1568 #ifdef WITHOUT_NETLINK
1569 return (rtmsg_rtsock(cmd, flags, fib));
1570 #else
1571 errno = rtmsg_nl(cmd, flags, fib, rtm_addrs, so, &rt_metrics);
1572 return (errno == 0 ? 0 : -1);
1573 #endif
1574 }
1575
1576 #ifdef WITHOUT_NETLINK
1577 static int
rtmsg_rtsock(int cmd,int flags,int fib)1578 rtmsg_rtsock(int cmd, int flags, int fib)
1579 {
1580 int rlen;
1581 char *cp = m_rtmsg.m_space;
1582 int l;
1583
1584 memset(&m_rtmsg, 0, sizeof(m_rtmsg));
1585
1586 #define NEXTADDR(w, u) \
1587 if (rtm_addrs & (w)) { \
1588 l = SA_SIZE(&(u)); \
1589 memmove(cp, (char *)&(u), l); \
1590 cp += l; \
1591 if (verbose) \
1592 sodump((struct sockaddr *)&(u), #w); \
1593 }
1594
1595 #define rtm m_rtmsg.m_rtm
1596 rtm.rtm_type = cmd;
1597 rtm.rtm_flags = flags;
1598 rtm.rtm_version = RTM_VERSION;
1599 rtm.rtm_seq = ++rtm_seq;
1600 rtm.rtm_addrs = rtm_addrs;
1601 rtm.rtm_rmx = rt_metrics;
1602 rtm.rtm_inits = rtm_inits;
1603
1604 NEXTADDR(RTA_DST, so[RTAX_DST]);
1605 NEXTADDR(RTA_GATEWAY, so[RTAX_GATEWAY]);
1606 NEXTADDR(RTA_NETMASK, so[RTAX_NETMASK]);
1607 NEXTADDR(RTA_GENMASK, so[RTAX_GENMASK]);
1608 NEXTADDR(RTA_IFP, so[RTAX_IFP]);
1609 NEXTADDR(RTA_IFA, so[RTAX_IFA]);
1610 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
1611 if (verbose)
1612 print_rtmsg(&rtm, l);
1613 if (debugonly)
1614 return (0);
1615 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
1616 switch (errno) {
1617 case EPERM:
1618 err(1, "writing to routing socket");
1619 break;
1620 case ESRCH:
1621 warnx("route has not been found");
1622 break;
1623 case EEXIST:
1624 /* Handled by newroute() */
1625 break;
1626 default:
1627 warn("writing to routing socket");
1628 }
1629 return (-1);
1630 }
1631 if (cmd == RTM_GET) {
1632 stop_read = 0;
1633 alarm(READ_TIMEOUT);
1634 do {
1635 l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
1636 } while (l > 0 && stop_read == 0 &&
1637 (rtm.rtm_type != RTM_GET || rtm.rtm_seq != rtm_seq ||
1638 rtm.rtm_pid != pid));
1639 if (stop_read != 0) {
1640 warnx("read from routing socket timed out");
1641 return (-1);
1642 } else
1643 alarm(0);
1644 if (l < 0)
1645 warn("read from routing socket");
1646 else
1647 print_getmsg(&rtm, l, fib);
1648 }
1649 #undef rtm
1650 return (0);
1651 }
1652 #endif
1653
1654 static const char *const msgtypes[] = {
1655 "",
1656 "RTM_ADD: Add Route",
1657 "RTM_DELETE: Delete Route",
1658 "RTM_CHANGE: Change Metrics or flags",
1659 "RTM_GET: Report Metrics",
1660 "RTM_LOSING: Kernel Suspects Partitioning",
1661 "RTM_REDIRECT: Told to use different route",
1662 "RTM_MISS: Lookup failed on this address",
1663 "RTM_LOCK: fix specified metrics",
1664 "RTM_OLDADD: caused by SIOCADDRT",
1665 "RTM_OLDDEL: caused by SIOCDELRT",
1666 "RTM_RESOLVE: Route created by cloning",
1667 "RTM_NEWADDR: address being added to iface",
1668 "RTM_DELADDR: address being removed from iface",
1669 "RTM_IFINFO: iface status change",
1670 "RTM_NEWMADDR: new multicast group membership on iface",
1671 "RTM_DELMADDR: multicast group membership removed from iface",
1672 "RTM_IFANNOUNCE: interface arrival/departure",
1673 "RTM_IEEE80211: IEEE 802.11 wireless event",
1674 "RTM_IPFWLOG: IPFW log",
1675 };
1676
1677 static const char metricnames[] =
1678 "\011weight\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire"
1679 "\1mtu";
1680 const char routeflags[] =
1681 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE"
1682 "\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE"
1683 "\017PROTO2\020PROTO1\021PRCLONING\022WASCLONED\023PROTO3"
1684 "\024FIXEDMTU\025PINNED\026LOCAL\027BROADCAST\030MULTICAST\035STICKY";
1685 static const char ifnetflags[] =
1686 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6b6\7RUNNING\010NOARP"
1687 "\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1"
1688 "\017LINK2\020MULTICAST";
1689 static const char addrnames[] =
1690 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD";
1691
1692 static const char errfmt[] =
1693 "\n%s: truncated route message, only %zu bytes left\n";
1694
1695 static void
print_rtmsg(struct rt_msghdr * rtm,size_t msglen)1696 print_rtmsg(struct rt_msghdr *rtm, size_t msglen)
1697 {
1698 struct if_msghdr *ifm;
1699 struct ifa_msghdr *ifam;
1700 #ifdef RTM_NEWMADDR
1701 struct ifma_msghdr *ifmam;
1702 #endif
1703 struct if_announcemsghdr *ifan;
1704 const char *state;
1705
1706 if (verbose == 0)
1707 return;
1708 if (rtm->rtm_version != RTM_VERSION) {
1709 (void)printf("routing message version %d not understood\n",
1710 rtm->rtm_version);
1711 return;
1712 }
1713 if (rtm->rtm_type < nitems(msgtypes))
1714 (void)printf("%s: ", msgtypes[rtm->rtm_type]);
1715 else
1716 (void)printf("unknown type %d: ", rtm->rtm_type);
1717 (void)printf("len %d, ", rtm->rtm_msglen);
1718
1719 #define REQUIRE(x) do { \
1720 if (msglen < sizeof(x)) \
1721 goto badlen; \
1722 else \
1723 msglen -= sizeof(x); \
1724 } while (0)
1725
1726 switch (rtm->rtm_type) {
1727 case RTM_IFINFO:
1728 REQUIRE(struct if_msghdr);
1729 ifm = (struct if_msghdr *)rtm;
1730 (void)printf("if# %d, ", ifm->ifm_index);
1731 switch (ifm->ifm_data.ifi_link_state) {
1732 case LINK_STATE_DOWN:
1733 state = "down";
1734 break;
1735 case LINK_STATE_UP:
1736 state = "up";
1737 break;
1738 default:
1739 state = "unknown";
1740 break;
1741 }
1742 (void)printf("link: %s, flags:", state);
1743 printb(ifm->ifm_flags, ifnetflags);
1744 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs, msglen);
1745 break;
1746 case RTM_NEWADDR:
1747 case RTM_DELADDR:
1748 REQUIRE(struct ifa_msghdr);
1749 ifam = (struct ifa_msghdr *)rtm;
1750 (void)printf("metric %d, flags:", ifam->ifam_metric);
1751 printb(ifam->ifam_flags, routeflags);
1752 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs, msglen);
1753 break;
1754 #ifdef RTM_NEWMADDR
1755 case RTM_NEWMADDR:
1756 case RTM_DELMADDR:
1757 REQUIRE(struct ifma_msghdr);
1758 ifmam = (struct ifma_msghdr *)rtm;
1759 pmsg_addrs((char *)(ifmam + 1), ifmam->ifmam_addrs, msglen);
1760 break;
1761 #endif
1762 case RTM_IFANNOUNCE:
1763 REQUIRE(struct if_announcemsghdr);
1764 ifan = (struct if_announcemsghdr *)rtm;
1765 (void)printf("if# %d, what: ", ifan->ifan_index);
1766 switch (ifan->ifan_what) {
1767 case IFAN_ARRIVAL:
1768 (void)printf("arrival");
1769 break;
1770 case IFAN_DEPARTURE:
1771 printf("departure");
1772 break;
1773 default:
1774 printf("#%d", ifan->ifan_what);
1775 break;
1776 }
1777 printf("\n");
1778 fflush(stdout);
1779 break;
1780
1781 default:
1782 if (rtm->rtm_type <= RTM_RESOLVE) {
1783 printf("pid: %ld, seq %d, errno %d, flags:",
1784 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1785 printb(rtm->rtm_flags, routeflags);
1786 pmsg_common(rtm, msglen);
1787 } else
1788 printf("type: %u, len: %zu\n", rtm->rtm_type, msglen);
1789 }
1790
1791 return;
1792
1793 badlen:
1794 (void)printf(errfmt, __func__, msglen);
1795 #undef REQUIRE
1796 }
1797
1798 static void
print_getmsg(struct rt_msghdr * rtm,int msglen,int fib)1799 print_getmsg(struct rt_msghdr *rtm, int msglen, int fib)
1800 {
1801 struct sockaddr *sp[RTAX_MAX];
1802 struct timespec ts;
1803 char *cp;
1804 int i;
1805
1806 memset(sp, 0, sizeof(sp));
1807 (void)printf(" route to: %s\n",
1808 routename((struct sockaddr *)&so[RTAX_DST]));
1809 if (rtm->rtm_version != RTM_VERSION) {
1810 warnx("routing message version %d not understood",
1811 rtm->rtm_version);
1812 return;
1813 }
1814 if (rtm->rtm_msglen > msglen) {
1815 warnx("message length mismatch, in packet %d, returned %d",
1816 rtm->rtm_msglen, msglen);
1817 return;
1818 }
1819 if (rtm->rtm_errno) {
1820 errno = rtm->rtm_errno;
1821 warn("message indicates error %d", errno);
1822 return;
1823 }
1824 cp = ((char *)(rtm + 1));
1825 for (i = 0; i < RTAX_MAX; i++)
1826 if (rtm->rtm_addrs & (1 << i)) {
1827 sp[i] = (struct sockaddr *)cp;
1828 cp += SA_SIZE((struct sockaddr *)cp);
1829 }
1830 if ((rtm->rtm_addrs & RTA_IFP) &&
1831 (sp[RTAX_IFP]->sa_family != AF_LINK ||
1832 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_nlen == 0))
1833 sp[RTAX_IFP] = NULL;
1834 if (sp[RTAX_DST])
1835 (void)printf("destination: %s\n", routename(sp[RTAX_DST]));
1836 if (sp[RTAX_NETMASK])
1837 (void)printf(" mask: %s\n", routename(sp[RTAX_NETMASK]));
1838 if (sp[RTAX_GATEWAY] && (rtm->rtm_flags & RTF_GATEWAY))
1839 (void)printf(" gateway: %s\n", routename(sp[RTAX_GATEWAY]));
1840 if (fib >= 0)
1841 (void)printf(" fib: %u\n", (unsigned int)fib);
1842 if (sp[RTAX_IFP])
1843 (void)printf(" interface: %.*s\n",
1844 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_nlen,
1845 ((struct sockaddr_dl *)(void *)sp[RTAX_IFP])->sdl_data);
1846 (void)printf(" flags: ");
1847 printb(rtm->rtm_flags, routeflags);
1848
1849 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1850 #define msec(u) (((u) + 500) / 1000) /* usec to msec */
1851 printf("\n%9s %9s %9s %9s %9s %10s %9s\n", "recvpipe",
1852 "sendpipe", "ssthresh", "rtt,msec", "mtu ", "weight", "expire");
1853 printf("%8lu%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE));
1854 printf("%8lu%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE));
1855 printf("%8lu%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH));
1856 printf("%8lu%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT));
1857 printf("%8lu%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU));
1858 printf("%8lu%c ", rtm->rtm_rmx.rmx_weight, lock(WEIGHT));
1859 if (rtm->rtm_rmx.rmx_expire > 0)
1860 clock_gettime(CLOCK_REALTIME_FAST, &ts);
1861 else
1862 ts.tv_sec = 0;
1863 printf("%8ld%c\n", (long)(rtm->rtm_rmx.rmx_expire - ts.tv_sec),
1864 lock(EXPIRE));
1865 #undef lock
1866 #undef msec
1867 #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD)
1868 if (verbose)
1869 pmsg_common(rtm, msglen);
1870 else if (rtm->rtm_addrs &~ RTA_IGN) {
1871 (void)printf("sockaddrs: ");
1872 printb(rtm->rtm_addrs, addrnames);
1873 putchar('\n');
1874 }
1875 #undef RTA_IGN
1876 }
1877
1878 static void
pmsg_common(struct rt_msghdr * rtm,size_t msglen)1879 pmsg_common(struct rt_msghdr *rtm, size_t msglen)
1880 {
1881
1882 (void)printf("\nlocks: ");
1883 printb(rtm->rtm_rmx.rmx_locks, metricnames);
1884 (void)printf(" inits: ");
1885 printb(rtm->rtm_inits, metricnames);
1886 if (msglen > sizeof(struct rt_msghdr))
1887 pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs,
1888 msglen - sizeof(struct rt_msghdr));
1889 else
1890 (void)fflush(stdout);
1891 }
1892
1893 static void
pmsg_addrs(char * cp,int addrs,size_t len)1894 pmsg_addrs(char *cp, int addrs, size_t len)
1895 {
1896 struct sockaddr *sa;
1897 int i;
1898
1899 if (addrs == 0) {
1900 (void)putchar('\n');
1901 return;
1902 }
1903 (void)printf("\nsockaddrs: ");
1904 printb(addrs, addrnames);
1905 putchar('\n');
1906 for (i = 0; i < RTAX_MAX; i++)
1907 if (addrs & (1 << i)) {
1908 sa = (struct sockaddr *)cp;
1909 if (len == 0 || len < SA_SIZE(sa)) {
1910 (void)printf(errfmt, __func__, len);
1911 break;
1912 }
1913 (void)printf(" %s", routename(sa));
1914 len -= SA_SIZE(sa);
1915 cp += SA_SIZE(sa);
1916 }
1917 (void)putchar('\n');
1918 (void)fflush(stdout);
1919 }
1920
1921 void
printb(int b,const char * str)1922 printb(int b, const char *str)
1923 {
1924 int i;
1925 int gotsome = 0;
1926
1927 if (b == 0)
1928 return;
1929 while ((i = *str++) != 0) {
1930 if (b & (1 << (i-1))) {
1931 if (gotsome == 0)
1932 i = '<';
1933 else
1934 i = ',';
1935 putchar(i);
1936 gotsome = 1;
1937 for (; (i = *str) > 32; str++)
1938 putchar(i);
1939 } else
1940 while (*str > 32)
1941 str++;
1942 }
1943 if (gotsome)
1944 putchar('>');
1945 }
1946
1947 int
keyword(const char * cp)1948 keyword(const char *cp)
1949 {
1950 const struct keytab *kt = keywords;
1951
1952 while (kt->kt_cp != NULL && strcmp(kt->kt_cp, cp) != 0)
1953 kt++;
1954 return (kt->kt_i);
1955 }
1956
1957 static void
sodump(struct sockaddr * sa,const char * which)1958 sodump(struct sockaddr *sa, const char *which)
1959 {
1960 #ifdef INET6
1961 char nbuf[INET6_ADDRSTRLEN];
1962 #endif
1963
1964 switch (sa->sa_family) {
1965 case AF_LINK:
1966 (void)printf("%s: link %s; ", which,
1967 link_ntoa((struct sockaddr_dl *)(void *)sa));
1968 break;
1969 #ifdef INET
1970 case AF_INET:
1971 (void)printf("%s: inet %s; ", which,
1972 inet_ntoa(((struct sockaddr_in *)(void *)sa)->sin_addr));
1973 break;
1974 #endif
1975 #ifdef INET6
1976 case AF_INET6:
1977 (void)printf("%s: inet6 %s; ", which, inet_ntop(sa->sa_family,
1978 &((struct sockaddr_in6 *)(void *)sa)->sin6_addr, nbuf,
1979 sizeof(nbuf)));
1980 break;
1981 #endif
1982 }
1983 (void)fflush(stdout);
1984 }
1985
1986 /* States*/
1987 #define VIRGIN 0
1988 #define GOTONE 1
1989 #define GOTTWO 2
1990 /* Inputs */
1991 #define DIGIT (4*0)
1992 #define END (4*1)
1993 #define DELIM (4*2)
1994
1995 static void
sockaddr(char * addr,struct sockaddr * sa,size_t size)1996 sockaddr(char *addr, struct sockaddr *sa, size_t size)
1997 {
1998 char *cp = (char *)sa;
1999 char *cplim = cp + size;
2000 int byte = 0, state = VIRGIN, new = 0 /* foil gcc */;
2001
2002 memset(cp, 0, size);
2003 cp++;
2004 do {
2005 if ((*addr >= '0') && (*addr <= '9')) {
2006 new = *addr - '0';
2007 } else if ((*addr >= 'a') && (*addr <= 'f')) {
2008 new = *addr - 'a' + 10;
2009 } else if ((*addr >= 'A') && (*addr <= 'F')) {
2010 new = *addr - 'A' + 10;
2011 } else if (*addr == '\0')
2012 state |= END;
2013 else
2014 state |= DELIM;
2015 addr++;
2016 switch (state /* | INPUT */) {
2017 case GOTTWO | DIGIT:
2018 *cp++ = byte; /*FALLTHROUGH*/
2019 case VIRGIN | DIGIT:
2020 state = GOTONE; byte = new; continue;
2021 case GOTONE | DIGIT:
2022 state = GOTTWO; byte = new + (byte << 4); continue;
2023 default: /* | DELIM */
2024 state = VIRGIN; *cp++ = byte; byte = 0; continue;
2025 case GOTONE | END:
2026 case GOTTWO | END:
2027 *cp++ = byte; /* FALLTHROUGH */
2028 case VIRGIN | END:
2029 break;
2030 }
2031 break;
2032 } while (cp < cplim);
2033 sa->sa_len = cp - (char *)sa;
2034 }
2035