route.c (251581) | route.c (253427) |
---|---|
1/* 2 * Copyright (c) 1983, 1989, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 26 unchanged lines hidden (view full) --- 35 36#ifndef lint 37#if 0 38static char sccsid[] = "@(#)route.c 8.6 (Berkeley) 4/28/95"; 39#endif 40#endif /* not lint */ 41 42#include <sys/cdefs.h> | 1/* 2 * Copyright (c) 1983, 1989, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 26 unchanged lines hidden (view full) --- 35 36#ifndef lint 37#if 0 38static char sccsid[] = "@(#)route.c 8.6 (Berkeley) 4/28/95"; 39#endif 40#endif /* not lint */ 41 42#include <sys/cdefs.h> |
43__FBSDID("$FreeBSD: head/sbin/route/route.c 251581 2013-06-09 17:40:06Z hrs $"); | 43__FBSDID("$FreeBSD: head/sbin/route/route.c 253427 2013-07-17 14:05:20Z hrs $"); |
44 45#include <sys/param.h> 46#include <sys/file.h> 47#include <sys/socket.h> 48#include <sys/ioctl.h> 49#include <sys/sysctl.h> 50#include <sys/types.h> 51#include <sys/queue.h> --- 13 unchanged lines hidden (view full) --- 65#include <paths.h> 66#include <stdio.h> 67#include <stdlib.h> 68#include <string.h> 69#include <sysexits.h> 70#include <unistd.h> 71#include <ifaddrs.h> 72 | 44 45#include <sys/param.h> 46#include <sys/file.h> 47#include <sys/socket.h> 48#include <sys/ioctl.h> 49#include <sys/sysctl.h> 50#include <sys/types.h> 51#include <sys/queue.h> --- 13 unchanged lines hidden (view full) --- 65#include <paths.h> 66#include <stdio.h> 67#include <stdlib.h> 68#include <string.h> 69#include <sysexits.h> 70#include <unistd.h> 71#include <ifaddrs.h> 72 |
73struct keytab { | 73static struct keytab { |
74 const char *kt_cp; 75 int kt_i; 76} keywords[] = { 77#include "keywords.h" 78 {0, 0} 79}; 80 | 74 const char *kt_cp; 75 int kt_i; 76} keywords[] = { 77#include "keywords.h" 78 {0, 0} 79}; 80 |
81union sockunion { 82 struct sockaddr sa; 83 struct sockaddr_in sin; 84#ifdef INET6 85 struct sockaddr_in6 sin6; 86#endif 87 struct sockaddr_at sat; 88 struct sockaddr_dl sdl; 89 struct sockaddr_storage ss; /* added to avoid memory overrun */ 90} so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp; 91 92typedef union sockunion *sup; 93int pid, rtm_addrs; 94int s; 95int forcehost, forcenet, doflush, nflag, af, qflag, tflag; 96int verbose, aflen = sizeof (struct sockaddr_in); 97int locking, lockrest, debugonly; 98struct rt_metrics rt_metrics; 99u_long rtm_inits; 100uid_t uid; | 81static struct sockaddr_storage so[RTAX_MAX]; 82static int pid, rtm_addrs; 83static int s; 84static int forcehost, forcenet, nflag, af, qflag, tflag; 85static int verbose, aflen; 86static int locking, lockrest, debugonly; 87static struct rt_metrics rt_metrics; 88static u_long rtm_inits; 89static uid_t uid; |
101static int defaultfib; 102static int numfibs; 103 104static int atalk_aton(const char *, struct at_addr *); 105static char *atalk_ntoa(struct at_addr); | 90static int defaultfib; 91static int numfibs; 92 93static int atalk_aton(const char *, struct at_addr *); 94static char *atalk_ntoa(struct at_addr); |
106static void bprintf(FILE *, int, u_char *); | 95static void printb(int, const char *); |
107static void flushroutes(int argc, char *argv[]); 108static int flushroutes_fib(int); 109static int getaddr(int, char *, struct hostent **, int); 110static int keyword(const char *); | 96static void flushroutes(int argc, char *argv[]); 97static int flushroutes_fib(int); 98static int getaddr(int, char *, struct hostent **, int); 99static int keyword(const char *); |
111static void inet_makenetandmask(u_long, struct sockaddr_in *, u_long); | 100#ifdef INET 101static void inet_makenetandmask(u_long, struct sockaddr_in *, 102 struct sockaddr_in *, u_long); 103#endif |
112#ifdef INET6 | 104#ifdef INET6 |
113static int inet6_makenetandmask(struct sockaddr_in6 *, const char *); | 105static int inet6_makenetandmask(struct sockaddr_in6 *, const char *); |
114#endif 115static void interfaces(void); | 106#endif 107static void interfaces(void); |
116static void mask_addr(void); | |
117static void monitor(int, char*[]); 118static const char *netname(struct sockaddr *); 119static void newroute(int, char **); 120static int newroute_fib(int, char *, int); 121static void pmsg_addrs(char *, int, size_t); 122static void pmsg_common(struct rt_msghdr *, size_t); 123static int prefixlen(const char *); 124static void print_getmsg(struct rt_msghdr *, int, int); 125static void print_rtmsg(struct rt_msghdr *, size_t); 126static const char *routename(struct sockaddr *); 127static int rtmsg(int, int, int); 128static void set_metric(char *, int); 129static int set_sofib(int); 130static int set_procfib(int); | 108static void monitor(int, char*[]); 109static const char *netname(struct sockaddr *); 110static void newroute(int, char **); 111static int newroute_fib(int, char *, int); 112static void pmsg_addrs(char *, int, size_t); 113static void pmsg_common(struct rt_msghdr *, size_t); 114static int prefixlen(const char *); 115static void print_getmsg(struct rt_msghdr *, int, int); 116static void print_rtmsg(struct rt_msghdr *, size_t); 117static const char *routename(struct sockaddr *); 118static int rtmsg(int, int, int); 119static void set_metric(char *, int); 120static int set_sofib(int); 121static int set_procfib(int); |
131static void sockaddr(char *, struct sockaddr *); 132static void sodump(sup, const char *); | 122static void sockaddr(char *, struct sockaddr *, size_t); 123static void sodump(struct sockaddr *, const char *); |
133extern char *iso_ntoa(void); 134 135struct fibl { 136 TAILQ_ENTRY(fibl) fl_next; 137 138 int fl_num; 139 int fl_error; 140 int fl_errno; 141}; | 124extern char *iso_ntoa(void); 125 126struct fibl { 127 TAILQ_ENTRY(fibl) fl_next; 128 129 int fl_num; 130 int fl_error; 131 int fl_errno; 132}; |
142TAILQ_HEAD(fibl_head_t, fibl) fibl_head; | 133static TAILQ_HEAD(fibl_head_t, fibl) fibl_head; |
143 144static int fiboptlist_csv(const char *, struct fibl_head_t *); 145static int fiboptlist_range(const char *, struct fibl_head_t *); 146 147static void usage(const char *) __dead2; 148 149void 150usage(const char *cp) 151{ 152 if (cp != NULL) 153 warnx("bad keyword: %s", cp); | 134 135static int fiboptlist_csv(const char *, struct fibl_head_t *); 136static int fiboptlist_range(const char *, struct fibl_head_t *); 137 138static void usage(const char *) __dead2; 139 140void 141usage(const char *cp) 142{ 143 if (cp != NULL) 144 warnx("bad keyword: %s", cp); |
154 (void) fprintf(stderr, 155 "usage: route [-dnqtv] command [[modifiers] args]\n"); 156 exit(EX_USAGE); | 145 errx(EX_USAGE, "usage: route [-dnqtv] command [[modifiers] args]"); |
157 /* NOTREACHED */ 158} 159 160int 161main(int argc, char **argv) 162{ 163 int ch; 164 size_t len; --- 143 unchanged lines hidden (view full) --- 308#define ALLSTRLEN 64 309static int 310fiboptlist_csv(const char *arg, struct fibl_head_t *flh) 311{ 312 struct fibl *fl; 313 char *str0, *str, *token, *endptr; 314 int fib, error; 315 | 146 /* NOTREACHED */ 147} 148 149int 150main(int argc, char **argv) 151{ 152 int ch; 153 size_t len; --- 143 unchanged lines hidden (view full) --- 297#define ALLSTRLEN 64 298static int 299fiboptlist_csv(const char *arg, struct fibl_head_t *flh) 300{ 301 struct fibl *fl; 302 char *str0, *str, *token, *endptr; 303 int fib, error; 304 |
305 str0 = str = NULL; |
|
316 if (strcmp("all", arg) == 0) { 317 str = calloc(1, ALLSTRLEN); 318 if (str == NULL) { 319 error = 1; 320 goto fiboptlist_csv_ret; 321 } 322 if (numfibs > 1) 323 snprintf(str, ALLSTRLEN - 1, "%d-%d", 0, numfibs - 1); --- 33 unchanged lines hidden (view full) --- 357 error = 1; 358 goto fiboptlist_csv_ret; 359 } 360 fl->fl_num = fib; 361 TAILQ_INSERT_TAIL(flh, fl, fl_next); 362 } 363 } 364fiboptlist_csv_ret: | 306 if (strcmp("all", arg) == 0) { 307 str = calloc(1, ALLSTRLEN); 308 if (str == NULL) { 309 error = 1; 310 goto fiboptlist_csv_ret; 311 } 312 if (numfibs > 1) 313 snprintf(str, ALLSTRLEN - 1, "%d-%d", 0, numfibs - 1); --- 33 unchanged lines hidden (view full) --- 347 error = 1; 348 goto fiboptlist_csv_ret; 349 } 350 fl->fl_num = fib; 351 TAILQ_INSERT_TAIL(flh, fl, fl_next); 352 } 353 } 354fiboptlist_csv_ret: |
365 free(str0); | 355 if (str0 != NULL) 356 free(str0); |
366 return (error); 367} 368 369/* 370 * Purge all entries in the routing tables not 371 * associated with network interfaces. 372 */ 373static void 374flushroutes(int argc, char *argv[]) 375{ 376 struct fibl *fl; 377 int error; 378 | 357 return (error); 358} 359 360/* 361 * Purge all entries in the routing tables not 362 * associated with network interfaces. 363 */ 364static void 365flushroutes(int argc, char *argv[]) 366{ 367 struct fibl *fl; 368 int error; 369 |
379 if (uid != 0 && !debugonly && !tflag) { | 370 if (uid != 0 && !debugonly && !tflag) |
380 errx(EX_NOPERM, "must be root to alter routing table"); | 371 errx(EX_NOPERM, "must be root to alter routing table"); |
381 } | |
382 shutdown(s, SHUT_RD); /* Don't want to read back our messages */ 383 384 TAILQ_INIT(&fibl_head); 385 while (argc > 1) { 386 argc--; 387 argv++; 388 if (**argv != '-') 389 usage(*argv); 390 switch (keyword(*argv + 1)) { | 372 shutdown(s, SHUT_RD); /* Don't want to read back our messages */ 373 374 TAILQ_INIT(&fibl_head); 375 while (argc > 1) { 376 argc--; 377 argv++; 378 if (**argv != '-') 379 usage(*argv); 380 switch (keyword(*argv + 1)) { |
381#ifdef INET |
|
391 case K_INET: 392 af = AF_INET; 393 break; | 382 case K_INET: 383 af = AF_INET; 384 break; |
385#endif |
|
394#ifdef INET6 395 case K_INET6: 396 af = AF_INET6; 397 break; 398#endif 399 case K_ATALK: 400 af = AF_APPLETALK; 401 break; --- 35 unchanged lines hidden (view full) --- 437 warn("fib number %d is ignored", fib); 438 return (error); 439 } 440 441retry: 442 mib[0] = CTL_NET; 443 mib[1] = PF_ROUTE; 444 mib[2] = 0; /* protocol */ | 386#ifdef INET6 387 case K_INET6: 388 af = AF_INET6; 389 break; 390#endif 391 case K_ATALK: 392 af = AF_APPLETALK; 393 break; --- 35 unchanged lines hidden (view full) --- 429 warn("fib number %d is ignored", fib); 430 return (error); 431 } 432 433retry: 434 mib[0] = CTL_NET; 435 mib[1] = PF_ROUTE; 436 mib[2] = 0; /* protocol */ |
445 mib[3] = 0; /* wildcard address family */ | 437 mib[3] = AF_UNSPEC; |
446 mib[4] = NET_RT_DUMP; 447 mib[5] = 0; /* no flags */ | 438 mib[4] = NET_RT_DUMP; 439 mib[5] = 0; /* no flags */ |
448 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) | 440 if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0) |
449 err(EX_OSERR, "route-sysctl-estimate"); 450 if ((buf = malloc(needed)) == NULL) 451 errx(EX_OSERR, "malloc failed"); | 441 err(EX_OSERR, "route-sysctl-estimate"); 442 if ((buf = malloc(needed)) == NULL) 443 errx(EX_OSERR, "malloc failed"); |
452 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) { | 444 if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0) { |
453 if (errno == ENOMEM && count++ < 10) { 454 warnx("Routing table grew, retrying"); 455 sleep(1); 456 free(buf); 457 goto retry; 458 } 459 err(EX_OSERR, "route-sysctl-get"); 460 } 461 lim = buf + needed; 462 if (verbose) | 445 if (errno == ENOMEM && count++ < 10) { 446 warnx("Routing table grew, retrying"); 447 sleep(1); 448 free(buf); 449 goto retry; 450 } 451 err(EX_OSERR, "route-sysctl-get"); 452 } 453 lim = buf + needed; 454 if (verbose) |
463 (void) printf("Examining routing table from sysctl\n"); | 455 (void)printf("Examining routing table from sysctl\n"); |
464 seqno = 0; /* ??? */ 465 for (next = buf; next < lim; next += rtm->rtm_msglen) { 466 rtm = (struct rt_msghdr *)next; 467 if (verbose) 468 print_rtmsg(rtm, rtm->rtm_msglen); 469 if ((rtm->rtm_flags & RTF_GATEWAY) == 0) 470 continue; 471 if (af != 0) { --- 6 unchanged lines hidden (view full) --- 478 continue; 479 rtm->rtm_type = RTM_DELETE; 480 rtm->rtm_seq = seqno; 481 rlen = write(s, next, rtm->rtm_msglen); 482 if (rlen < 0 && errno == EPERM) 483 err(1, "write to routing socket"); 484 if (rlen < (int)rtm->rtm_msglen) { 485 warn("write to routing socket"); | 456 seqno = 0; /* ??? */ 457 for (next = buf; next < lim; next += rtm->rtm_msglen) { 458 rtm = (struct rt_msghdr *)next; 459 if (verbose) 460 print_rtmsg(rtm, rtm->rtm_msglen); 461 if ((rtm->rtm_flags & RTF_GATEWAY) == 0) 462 continue; 463 if (af != 0) { --- 6 unchanged lines hidden (view full) --- 470 continue; 471 rtm->rtm_type = RTM_DELETE; 472 rtm->rtm_seq = seqno; 473 rlen = write(s, next, rtm->rtm_msglen); 474 if (rlen < 0 && errno == EPERM) 475 err(1, "write to routing socket"); 476 if (rlen < (int)rtm->rtm_msglen) { 477 warn("write to routing socket"); |
486 (void) printf("got only %d for rlen\n", rlen); | 478 (void)printf("got only %d for rlen\n", rlen); |
487 free(buf); 488 goto retry; 489 break; 490 } 491 seqno++; 492 if (qflag) 493 continue; 494 if (verbose) --- 13 unchanged lines hidden (view full) --- 508 return (error); 509} 510 511const char * 512routename(struct sockaddr *sa) 513{ 514 const char *cp; 515 static char line[MAXHOSTNAMELEN + 1]; | 479 free(buf); 480 goto retry; 481 break; 482 } 483 seqno++; 484 if (qflag) 485 continue; 486 if (verbose) --- 13 unchanged lines hidden (view full) --- 500 return (error); 501} 502 503const char * 504routename(struct sockaddr *sa) 505{ 506 const char *cp; 507 static char line[MAXHOSTNAMELEN + 1]; |
508#ifdef INET |
|
516 struct hostent *hp; | 509 struct hostent *hp; |
510#endif |
|
517 static char domain[MAXHOSTNAMELEN + 1]; 518 static int first = 1, n; 519 520 if (first) { 521 first = 0; 522 if (gethostname(domain, MAXHOSTNAMELEN) == 0 && 523 (cp = strchr(domain, '.'))) { 524 domain[MAXHOSTNAMELEN] = '\0'; | 511 static char domain[MAXHOSTNAMELEN + 1]; 512 static int first = 1, n; 513 514 if (first) { 515 first = 0; 516 if (gethostname(domain, MAXHOSTNAMELEN) == 0 && 517 (cp = strchr(domain, '.'))) { 518 domain[MAXHOSTNAMELEN] = '\0'; |
525 (void) strcpy(domain, cp + 1); | 519 (void)strcpy(domain, cp + 1); |
526 } else | 520 } else |
527 domain[0] = 0; | 521 domain[0] = '\0'; |
528 } 529 | 522 } 523 |
530 if (sa->sa_len == 0) | 524 if (sa->sa_len == 0) { |
531 strcpy(line, "default"); | 525 strcpy(line, "default"); |
532 else switch (sa->sa_family) { 533 | 526 return (line); 527 } 528 switch (sa->sa_family) { 529#ifdef INET |
534 case AF_INET: | 530 case AF_INET: |
535 { struct in_addr in; 536 in = ((struct sockaddr_in *)sa)->sin_addr; | 531 { 532 struct in_addr in; |
537 | 533 |
534 in = ((struct sockaddr_in *)sa)->sin_addr; |
|
538 cp = NULL; 539 if (in.s_addr == INADDR_ANY || sa->sa_len < 4) 540 cp = "default"; 541 if (cp == NULL && !nflag) { 542 hp = gethostbyaddr((char *)&in, sizeof (struct in_addr), 543 AF_INET); 544 if (hp != NULL) { 545 char *cptr; 546 cptr = strchr(hp->h_name, '.'); 547 if (cptr != NULL && 548 strcmp(cptr + 1, domain) == 0) 549 *cptr = '\0'; 550 cp = hp->h_name; 551 } 552 } 553 if (cp != NULL) { 554 strncpy(line, cp, sizeof(line) - 1); 555 line[sizeof(line) - 1] = '\0'; 556 } else | 535 cp = NULL; 536 if (in.s_addr == INADDR_ANY || sa->sa_len < 4) 537 cp = "default"; 538 if (cp == NULL && !nflag) { 539 hp = gethostbyaddr((char *)&in, sizeof (struct in_addr), 540 AF_INET); 541 if (hp != NULL) { 542 char *cptr; 543 cptr = strchr(hp->h_name, '.'); 544 if (cptr != NULL && 545 strcmp(cptr + 1, domain) == 0) 546 *cptr = '\0'; 547 cp = hp->h_name; 548 } 549 } 550 if (cp != NULL) { 551 strncpy(line, cp, sizeof(line) - 1); 552 line[sizeof(line) - 1] = '\0'; 553 } else |
557 (void) sprintf(line, "%s", inet_ntoa(in)); | 554 (void)sprintf(line, "%s", inet_ntoa(in)); |
558 break; | 555 break; |
559 } | 556 } |
560 | 557 |
558#endif |
|
561#ifdef INET6 562 case AF_INET6: 563 { 564 struct sockaddr_in6 sin6; /* use static var for safety */ 565 int niflags = 0; 566 567 memset(&sin6, 0, sizeof(sin6)); 568 memcpy(&sin6, sa, sa->sa_len); 569 sin6.sin6_len = sizeof(struct sockaddr_in6); 570 sin6.sin6_family = AF_INET6; 571 if (nflag) 572 niflags |= NI_NUMERICHOST; 573 if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, 574 line, sizeof(line), NULL, 0, niflags) != 0) 575 strncpy(line, "invalid", sizeof(line)); 576 | 559#ifdef INET6 560 case AF_INET6: 561 { 562 struct sockaddr_in6 sin6; /* use static var for safety */ 563 int niflags = 0; 564 565 memset(&sin6, 0, sizeof(sin6)); 566 memcpy(&sin6, sa, sa->sa_len); 567 sin6.sin6_len = sizeof(struct sockaddr_in6); 568 sin6.sin6_family = AF_INET6; 569 if (nflag) 570 niflags |= NI_NUMERICHOST; 571 if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, 572 line, sizeof(line), NULL, 0, niflags) != 0) 573 strncpy(line, "invalid", sizeof(line)); 574 |
577 return(line); | 575 return (line); |
578 } 579#endif 580 581 case AF_APPLETALK: | 576 } 577#endif 578 579 case AF_APPLETALK: |
582 (void) snprintf(line, sizeof(line), "atalk %s", 583 atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr)); | 580 (void)snprintf(line, sizeof(line), "atalk %s", 581 atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr)); |
584 break; 585 586 case AF_LINK: 587 return (link_ntoa((struct sockaddr_dl *)sa)); | 582 break; 583 584 case AF_LINK: 585 return (link_ntoa((struct sockaddr_dl *)sa)); |
586 break; |
|
588 589 default: 590 { 591 u_short *sp = (u_short *)sa; 592 u_short *splim = sp + ((sa->sa_len + 1) >> 1); 593 char *cps = line + sprintf(line, "(%d)", sa->sa_family); 594 char *cpe = line + sizeof(line); 595 --- 10 unchanged lines hidden (view full) --- 606 607/* 608 * Return the name of the network whose address is given. 609 * The address is assumed to be that of a net, not a host. 610 */ 611const char * 612netname(struct sockaddr *sa) 613{ | 587 588 default: 589 { 590 u_short *sp = (u_short *)sa; 591 u_short *splim = sp + ((sa->sa_len + 1) >> 1); 592 char *cps = line + sprintf(line, "(%d)", sa->sa_family); 593 char *cpe = line + sizeof(line); 594 --- 10 unchanged lines hidden (view full) --- 605 606/* 607 * Return the name of the network whose address is given. 608 * The address is assumed to be that of a net, not a host. 609 */ 610const char * 611netname(struct sockaddr *sa) 612{ |
614 const char *cp = NULL; | |
615 static char line[MAXHOSTNAMELEN + 1]; | 613 static char line[MAXHOSTNAMELEN + 1]; |
614 int n; 615#ifdef INET |
|
616 struct netent *np = NULL; | 616 struct netent *np = NULL; |
617 const char *cp = NULL; |
|
617 u_long i; | 618 u_long i; |
618 int n; | 619#endif |
619 620 switch (sa->sa_family) { | 620 621 switch (sa->sa_family) { |
621 | 622#ifdef INET |
622 case AF_INET: | 623 case AF_INET: |
623 { struct in_addr in; 624 in = ((struct sockaddr_in *)sa)->sin_addr; | 624 { 625 struct in_addr in; |
625 | 626 |
627 in = ((struct sockaddr_in *)sa)->sin_addr; |
|
626 i = in.s_addr = ntohl(in.s_addr); 627 if (in.s_addr == 0) 628 cp = "default"; 629 else if (!nflag) { 630 np = getnetbyaddr(i, AF_INET); 631 if (np != NULL) 632 cp = np->n_name; 633 } 634#define C(x) (unsigned)((x) & 0xff) 635 if (cp != NULL) 636 strncpy(line, cp, sizeof(line)); 637 else if ((in.s_addr & 0xffffff) == 0) | 628 i = in.s_addr = ntohl(in.s_addr); 629 if (in.s_addr == 0) 630 cp = "default"; 631 else if (!nflag) { 632 np = getnetbyaddr(i, AF_INET); 633 if (np != NULL) 634 cp = np->n_name; 635 } 636#define C(x) (unsigned)((x) & 0xff) 637 if (cp != NULL) 638 strncpy(line, cp, sizeof(line)); 639 else if ((in.s_addr & 0xffffff) == 0) |
638 (void) sprintf(line, "%u", C(in.s_addr >> 24)); | 640 (void)sprintf(line, "%u", C(in.s_addr >> 24)); |
639 else if ((in.s_addr & 0xffff) == 0) | 641 else if ((in.s_addr & 0xffff) == 0) |
640 (void) sprintf(line, "%u.%u", C(in.s_addr >> 24), | 642 (void)sprintf(line, "%u.%u", C(in.s_addr >> 24), |
641 C(in.s_addr >> 16)); 642 else if ((in.s_addr & 0xff) == 0) | 643 C(in.s_addr >> 16)); 644 else if ((in.s_addr & 0xff) == 0) |
643 (void) sprintf(line, "%u.%u.%u", C(in.s_addr >> 24), | 645 (void)sprintf(line, "%u.%u.%u", C(in.s_addr >> 24), |
644 C(in.s_addr >> 16), C(in.s_addr >> 8)); 645 else | 646 C(in.s_addr >> 16), C(in.s_addr >> 8)); 647 else |
646 (void) sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), | 648 (void)sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), |
647 C(in.s_addr >> 16), C(in.s_addr >> 8), 648 C(in.s_addr)); 649#undef C 650 break; | 649 C(in.s_addr >> 16), C(in.s_addr >> 8), 650 C(in.s_addr)); 651#undef C 652 break; |
651 } 652 | 653 } 654#endif |
653#ifdef INET6 654 case AF_INET6: 655 { | 655#ifdef INET6 656 case AF_INET6: 657 { |
656 struct sockaddr_in6 sin6; /* use static var for safety */ | 658 struct sockaddr_in6 sin6; |
657 int niflags = 0; 658 659 memset(&sin6, 0, sizeof(sin6)); 660 memcpy(&sin6, sa, sa->sa_len); | 659 int niflags = 0; 660 661 memset(&sin6, 0, sizeof(sin6)); 662 memcpy(&sin6, sa, sa->sa_len); |
661 sin6.sin6_len = sizeof(struct sockaddr_in6); | 663 sin6.sin6_len = sizeof(sin6); |
662 sin6.sin6_family = AF_INET6; 663 if (nflag) 664 niflags |= NI_NUMERICHOST; 665 if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, 666 line, sizeof(line), NULL, 0, niflags) != 0) 667 strncpy(line, "invalid", sizeof(line)); 668 669 return(line); 670 } 671#endif 672 673 case AF_APPLETALK: | 664 sin6.sin6_family = AF_INET6; 665 if (nflag) 666 niflags |= NI_NUMERICHOST; 667 if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, 668 line, sizeof(line), NULL, 0, niflags) != 0) 669 strncpy(line, "invalid", sizeof(line)); 670 671 return(line); 672 } 673#endif 674 675 case AF_APPLETALK: |
674 (void) snprintf(line, sizeof(line), "atalk %s", 675 atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr)); | 676 (void)snprintf(line, sizeof(line), "atalk %s", 677 atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr)); |
676 break; 677 678 case AF_LINK: 679 return (link_ntoa((struct sockaddr_dl *)sa)); | 678 break; 679 680 case AF_LINK: 681 return (link_ntoa((struct sockaddr_dl *)sa)); |
682 break; |
|
680 | 683 |
681 | |
682 default: 683 { 684 u_short *sp = (u_short *)sa->sa_data; 685 u_short *splim = sp + ((sa->sa_len + 1)>>1); 686 char *cps = line + sprintf(line, "af %d:", sa->sa_family); 687 char *cpe = line + sizeof(line); 688 689 while (sp < splim && cps < cpe) --- 43 unchanged lines hidden (view full) --- 733newroute(int argc, char **argv) 734{ 735 struct hostent *hp; 736 struct fibl *fl; 737 char *cmd; 738 const char *dest, *gateway, *errmsg; 739 int key, error, flags, nrflags, fibnum; 740 | 684 default: 685 { 686 u_short *sp = (u_short *)sa->sa_data; 687 u_short *splim = sp + ((sa->sa_len + 1)>>1); 688 char *cps = line + sprintf(line, "af %d:", sa->sa_family); 689 char *cpe = line + sizeof(line); 690 691 while (sp < splim && cps < cpe) --- 43 unchanged lines hidden (view full) --- 735newroute(int argc, char **argv) 736{ 737 struct hostent *hp; 738 struct fibl *fl; 739 char *cmd; 740 const char *dest, *gateway, *errmsg; 741 int key, error, flags, nrflags, fibnum; 742 |
741 if (uid != 0 && !debugonly && !tflag) { | 743 if (uid != 0 && !debugonly && !tflag) |
742 errx(EX_NOPERM, "must be root to alter routing table"); | 744 errx(EX_NOPERM, "must be root to alter routing table"); |
743 } 744 | |
745 dest = NULL; 746 gateway = NULL; 747 flags = RTF_STATIC; 748 nrflags = 0; 749 hp = NULL; 750 TAILQ_INIT(&fibl_head); 751 752 cmd = argv[0]; 753 if (*cmd != 'g' && *cmd != 's') 754 shutdown(s, SHUT_RD); /* Don't want to read back our messages */ | 745 dest = NULL; 746 gateway = NULL; 747 flags = RTF_STATIC; 748 nrflags = 0; 749 hp = NULL; 750 TAILQ_INIT(&fibl_head); 751 752 cmd = argv[0]; 753 if (*cmd != 'g' && *cmd != 's') 754 shutdown(s, SHUT_RD); /* Don't want to read back our messages */ |
755 | |
756 while (--argc > 0) { 757 if (**(++argv)== '-') { 758 switch (key = keyword(1 + *argv)) { 759 case K_LINK: 760 af = AF_LINK; 761 aflen = sizeof(struct sockaddr_dl); 762 break; | 755 while (--argc > 0) { 756 if (**(++argv)== '-') { 757 switch (key = keyword(1 + *argv)) { 758 case K_LINK: 759 af = AF_LINK; 760 aflen = sizeof(struct sockaddr_dl); 761 break; |
762#ifdef INET |
|
763 case K_INET: 764 af = AF_INET; 765 aflen = sizeof(struct sockaddr_in); 766 break; | 763 case K_INET: 764 af = AF_INET; 765 aflen = sizeof(struct sockaddr_in); 766 break; |
767#endif |
|
767#ifdef INET6 768 case K_INET6: 769 af = AF_INET6; 770 aflen = sizeof(struct sockaddr_in6); 771 break; 772#endif 773 case K_ATALK: 774 af = AF_APPLETALK; 775 aflen = sizeof(struct sockaddr_at); 776 break; 777 case K_SA: 778 af = PF_ROUTE; | 768#ifdef INET6 769 case K_INET6: 770 af = AF_INET6; 771 aflen = sizeof(struct sockaddr_in6); 772 break; 773#endif 774 case K_ATALK: 775 af = AF_APPLETALK; 776 aflen = sizeof(struct sockaddr_at); 777 break; 778 case K_SA: 779 af = PF_ROUTE; |
779 aflen = sizeof(union sockunion); | 780 aflen = sizeof(struct sockaddr_storage); |
780 break; 781 case K_IFACE: 782 case K_INTERFACE: 783 nrflags |= F_INTERFACE; 784 break; 785 case K_NOSTATIC: 786 flags &= ~RTF_STATIC; 787 break; --- 119 unchanged lines hidden (view full) --- 907 } 908 } 909 910 if (nrflags & F_FORCEHOST) { 911 nrflags |= F_ISHOST; 912#ifdef INET6 913 if (af == AF_INET6) { 914 rtm_addrs &= ~RTA_NETMASK; | 781 break; 782 case K_IFACE: 783 case K_INTERFACE: 784 nrflags |= F_INTERFACE; 785 break; 786 case K_NOSTATIC: 787 flags &= ~RTF_STATIC; 788 break; --- 119 unchanged lines hidden (view full) --- 908 } 909 } 910 911 if (nrflags & F_FORCEHOST) { 912 nrflags |= F_ISHOST; 913#ifdef INET6 914 if (af == AF_INET6) { 915 rtm_addrs &= ~RTA_NETMASK; |
915 memset((void *)&so_mask, 0, sizeof(so_mask)); | 916 memset(&so[RTAX_NETMASK], 0, sizeof(so[RTAX_NETMASK])); |
916 } 917#endif 918 } 919 if (nrflags & F_FORCENET) 920 nrflags &= ~F_ISHOST; 921 flags |= RTF_UP; 922 if (nrflags & F_ISHOST) 923 flags |= RTF_HOST; --- 106 unchanged lines hidden (view full) --- 1030 warn("fib number %d is ignored", fib); 1031 return (error); 1032 } 1033 1034 error = rtmsg(*cmd, flags, fib); 1035 return (error); 1036} 1037 | 917 } 918#endif 919 } 920 if (nrflags & F_FORCENET) 921 nrflags &= ~F_ISHOST; 922 flags |= RTF_UP; 923 if (nrflags & F_ISHOST) 924 flags |= RTF_HOST; --- 106 unchanged lines hidden (view full) --- 1031 warn("fib number %d is ignored", fib); 1032 return (error); 1033 } 1034 1035 error = rtmsg(*cmd, flags, fib); 1036 return (error); 1037} 1038 |
1039#ifdef INET |
|
1038static void | 1040static void |
1039inet_makenetandmask(u_long net, struct sockaddr_in *sin, u_long bits) | 1041inet_makenetandmask(u_long net, struct sockaddr_in *sin, 1042 struct sockaddr_in *sin_mask, u_long bits) |
1040{ 1041 u_long mask = 0; | 1043{ 1044 u_long mask = 0; |
1042 char *cp; | |
1043 1044 rtm_addrs |= RTA_NETMASK; 1045 1046 /* 1047 * MSB of net should be meaningful. 0/0 is exception. 1048 */ 1049 if (net > 0) 1050 while ((net & 0xff000000) == 0) 1051 net <<= 8; 1052 1053 /* 1054 * If no /xx was specified we must calculate the 1055 * CIDR address. 1056 */ 1057 if ((bits == 0) && (net != 0)) { 1058 u_long i, j; | 1045 1046 rtm_addrs |= RTA_NETMASK; 1047 1048 /* 1049 * MSB of net should be meaningful. 0/0 is exception. 1050 */ 1051 if (net > 0) 1052 while ((net & 0xff000000) == 0) 1053 net <<= 8; 1054 1055 /* 1056 * If no /xx was specified we must calculate the 1057 * CIDR address. 1058 */ 1059 if ((bits == 0) && (net != 0)) { 1060 u_long i, j; |
1059 for(i=0,j=0xff; i<4; i++) { | 1061 1062 for(i = 0, j = 0xff; i < 4; i++) { |
1060 if (net & j) { 1061 break; 1062 } 1063 j <<= 8; 1064 } 1065 /* i holds the first non zero bit */ 1066 bits = 32 - (i*8); 1067 } 1068 if (bits != 0) 1069 mask = 0xffffffff << (32 - bits); 1070 1071 sin->sin_addr.s_addr = htonl(net); | 1063 if (net & j) { 1064 break; 1065 } 1066 j <<= 8; 1067 } 1068 /* i holds the first non zero bit */ 1069 bits = 32 - (i*8); 1070 } 1071 if (bits != 0) 1072 mask = 0xffffffff << (32 - bits); 1073 1074 sin->sin_addr.s_addr = htonl(net); |
1072 sin = &so_mask.sin; 1073 sin->sin_addr.s_addr = htonl(mask); 1074 sin->sin_len = 0; 1075 sin->sin_family = 0; 1076 cp = (char *)(&sin->sin_addr + 1); 1077 while (*--cp == 0 && cp > (char *)sin) 1078 ; 1079 sin->sin_len = 1 + cp - (char *)sin; | 1075 sin_mask->sin_addr.s_addr = htonl(mask); 1076 sin_mask->sin_len = sizeof(struct sockaddr_in); 1077 sin_mask->sin_family = AF_INET; |
1080} | 1078} |
1079#endif |
|
1081 1082#ifdef INET6 1083/* 1084 * XXX the function may need more improvement... 1085 */ 1086static int 1087inet6_makenetandmask(struct sockaddr_in6 *sin6, const char *plen) 1088{ --- 22 unchanged lines hidden (view full) --- 1111 1112/* 1113 * Interpret an argument as a network address of some kind, 1114 * returning 1 if a host address, 0 if a network address. 1115 */ 1116static int 1117getaddr(int which, char *str, struct hostent **hpp, int nrflags) 1118{ | 1080 1081#ifdef INET6 1082/* 1083 * XXX the function may need more improvement... 1084 */ 1085static int 1086inet6_makenetandmask(struct sockaddr_in6 *sin6, const char *plen) 1087{ --- 22 unchanged lines hidden (view full) --- 1110 1111/* 1112 * Interpret an argument as a network address of some kind, 1113 * returning 1 if a host address, 0 if a network address. 1114 */ 1115static int 1116getaddr(int which, char *str, struct hostent **hpp, int nrflags) 1117{ |
1119 sup su; | 1118 struct sockaddr *sa; 1119#if defined(INET) 1120 struct sockaddr_in *sin; |
1120 struct hostent *hp; 1121 struct netent *np; 1122 u_long val; 1123 char *q; | 1121 struct hostent *hp; 1122 struct netent *np; 1123 u_long val; 1124 char *q; |
1124 int afamily; /* local copy of af so we can change it */ | 1125#elif defined(INET6) 1126 char *q; 1127#endif |
1125 1126 if (af == 0) { | 1128 1129 if (af == 0) { |
1130#if defined(INET) |
|
1127 af = AF_INET; 1128 aflen = sizeof(struct sockaddr_in); | 1131 af = AF_INET; 1132 aflen = sizeof(struct sockaddr_in); |
1133#elif defined(INET6) 1134 af = AF_INET6; 1135 aflen = sizeof(struct sockaddr_in6); 1136#else 1137 af = AF_LINK; 1138 aflen = sizeof(struct sockaddr_dl); 1139#endif |
|
1129 } | 1140 } |
1130 afamily = af; | |
1131 rtm_addrs |= which; | 1141 rtm_addrs |= which; |
1142 |
|
1132 switch (which) { 1133 case RTA_DST: | 1143 switch (which) { 1144 case RTA_DST: |
1134 su = &so_dst; | 1145 sa = (struct sockaddr *)&so[RTAX_DST]; |
1135 break; 1136 case RTA_GATEWAY: | 1146 break; 1147 case RTA_GATEWAY: |
1137 su = &so_gate; | 1148 sa = (struct sockaddr *)&so[RTAX_GATEWAY]; 1149 break; 1150 case RTA_NETMASK: 1151 sa = (struct sockaddr *)&so[RTAX_NETMASK]; 1152 break; 1153 case RTA_GENMASK: 1154 sa = (struct sockaddr *)&so[RTAX_GENMASK]; 1155 break; 1156 case RTA_IFA: 1157 sa = (struct sockaddr *)&so[RTAX_IFA]; 1158 break; 1159 case RTA_IFP: 1160 sa = (struct sockaddr *)&so[RTAX_IFP]; 1161 break; 1162 default: 1163 usage("internal error"); 1164 /*NOTREACHED*/ 1165 } 1166 sa->sa_family = af; 1167 sa->sa_len = aflen; 1168 1169 switch (which) { 1170 case RTA_GATEWAY: |
1138 if (nrflags & F_INTERFACE) { 1139 struct ifaddrs *ifap, *ifa; | 1171 if (nrflags & F_INTERFACE) { 1172 struct ifaddrs *ifap, *ifa; |
1173 struct sockaddr_dl *sdl0 = (struct sockaddr_dl *)sa; |
|
1140 struct sockaddr_dl *sdl = NULL; 1141 1142 if (getifaddrs(&ifap)) | 1174 struct sockaddr_dl *sdl = NULL; 1175 1176 if (getifaddrs(&ifap)) |
1143 err(1, "getifaddrs"); | 1177 err(EX_OSERR, "getifaddrs"); |
1144 1145 for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) { 1146 if (ifa->ifa_addr->sa_family != AF_LINK) 1147 continue; 1148 1149 if (strcmp(str, ifa->ifa_name) != 0) 1150 continue; 1151 1152 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 1153 } 1154 /* If we found it, then use it */ 1155 if (sdl != NULL) { 1156 /* | 1178 1179 for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) { 1180 if (ifa->ifa_addr->sa_family != AF_LINK) 1181 continue; 1182 1183 if (strcmp(str, ifa->ifa_name) != 0) 1184 continue; 1185 1186 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 1187 } 1188 /* If we found it, then use it */ 1189 if (sdl != NULL) { 1190 /* |
1157 * Copy is safe since we have a 1158 * sockaddr_storage member in sockunion{}. | |
1159 * Note that we need to copy before calling 1160 * freeifaddrs(). 1161 */ | 1191 * Note that we need to copy before calling 1192 * freeifaddrs(). 1193 */ |
1162 memcpy(&su->sdl, sdl, sdl->sdl_len); | 1194 memcpy(sdl0, sdl, sdl->sdl_len); |
1163 } 1164 freeifaddrs(ifap); 1165 if (sdl != NULL) 1166 return(1); 1167 } 1168 break; | 1195 } 1196 freeifaddrs(ifap); 1197 if (sdl != NULL) 1198 return(1); 1199 } 1200 break; |
1169 case RTA_NETMASK: 1170 su = &so_mask; 1171 break; 1172 case RTA_GENMASK: 1173 su = &so_genmask; 1174 break; | |
1175 case RTA_IFP: | 1201 case RTA_IFP: |
1176 su = &so_ifp; 1177 afamily = AF_LINK; | 1202 sa->sa_family = AF_LINK; |
1178 break; | 1203 break; |
1179 case RTA_IFA: 1180 su = &so_ifa; 1181 break; 1182 default: 1183 usage("internal error"); 1184 /*NOTREACHED*/ | |
1185 } | 1204 } |
1186 su->sa.sa_len = aflen; 1187 su->sa.sa_family = afamily; /* cases that don't want it have left already */ | |
1188 if (strcmp(str, "default") == 0) { 1189 /* 1190 * Default is net 0.0.0.0/0 1191 */ 1192 switch (which) { 1193 case RTA_DST: 1194 forcenet++; | 1205 if (strcmp(str, "default") == 0) { 1206 /* 1207 * Default is net 0.0.0.0/0 1208 */ 1209 switch (which) { 1210 case RTA_DST: 1211 forcenet++; |
1195#if 0 1196 bzero(su, sizeof(*su)); /* for readability */ 1197#endif | |
1198 getaddr(RTA_NETMASK, str, 0, nrflags); 1199 break; | 1212 getaddr(RTA_NETMASK, str, 0, nrflags); 1213 break; |
1200#if 0 1201 case RTA_NETMASK: 1202 case RTA_GENMASK: 1203 bzero(su, sizeof(*su)); /* for readability */ 1204#endif | |
1205 } 1206 return (0); 1207 } | 1214 } 1215 return (0); 1216 } |
1208 switch (afamily) { | 1217 switch (sa->sa_family) { |
1209#ifdef INET6 1210 case AF_INET6: 1211 { 1212 struct addrinfo hints, *res; 1213 int ecode; 1214 1215 q = NULL; 1216 if (which == RTA_DST && (q = strchr(str, '/')) != NULL) 1217 *q = '\0'; 1218 memset(&hints, 0, sizeof(hints)); | 1218#ifdef INET6 1219 case AF_INET6: 1220 { 1221 struct addrinfo hints, *res; 1222 int ecode; 1223 1224 q = NULL; 1225 if (which == RTA_DST && (q = strchr(str, '/')) != NULL) 1226 *q = '\0'; 1227 memset(&hints, 0, sizeof(hints)); |
1219 hints.ai_family = afamily; /*AF_INET6*/ 1220 hints.ai_socktype = SOCK_DGRAM; /*dummy*/ | 1228 hints.ai_family = sa->sa_family; 1229 hints.ai_socktype = SOCK_DGRAM; |
1221 ecode = getaddrinfo(str, NULL, &hints, &res); 1222 if (ecode != 0 || res->ai_family != AF_INET6 || | 1230 ecode = getaddrinfo(str, NULL, &hints, &res); 1231 if (ecode != 0 || res->ai_family != AF_INET6 || |
1223 res->ai_addrlen != sizeof(su->sin6)) { 1224 (void) fprintf(stderr, "%s: %s\n", str, 1225 gai_strerror(ecode)); 1226 exit(1); 1227 } 1228 memcpy(&su->sin6, res->ai_addr, sizeof(su->sin6)); | 1232 res->ai_addrlen != sizeof(struct sockaddr_in6)) 1233 errx(EX_OSERR, "%s: %s", str, gai_strerror(ecode)); 1234 memcpy(sa, res->ai_addr, res->ai_addrlen); |
1229 freeaddrinfo(res); 1230 if (q != NULL) 1231 *q++ = '/'; 1232 if (which == RTA_DST) | 1235 freeaddrinfo(res); 1236 if (q != NULL) 1237 *q++ = '/'; 1238 if (which == RTA_DST) |
1233 return (inet6_makenetandmask(&su->sin6, q)); | 1239 return (inet6_makenetandmask((struct sockaddr_in6 *)sa, 1240 q)); |
1234 return (0); 1235 } 1236#endif /* INET6 */ 1237 1238 case AF_APPLETALK: | 1241 return (0); 1242 } 1243#endif /* INET6 */ 1244 1245 case AF_APPLETALK: |
1239 if (!atalk_aton(str, &su->sat.sat_addr)) | 1246 { 1247 struct sockaddr_at *sat = (struct sockaddr_at *)sa; 1248 1249 if (!atalk_aton(str, &sat->sat_addr)) |
1240 errx(EX_NOHOST, "bad address: %s", str); 1241 rtm_addrs |= RTA_NETMASK; | 1250 errx(EX_NOHOST, "bad address: %s", str); 1251 rtm_addrs |= RTA_NETMASK; |
1242 return(forcehost || su->sat.sat_addr.s_node != 0); 1243 | 1252 return(forcehost || sat->sat_addr.s_node != 0); 1253 } |
1244 case AF_LINK: | 1254 case AF_LINK: |
1245 link_addr(str, &su->sdl); | 1255 link_addr(str, (struct sockaddr_dl *)sa); |
1246 return (1); 1247 | 1256 return (1); 1257 |
1248 | |
1249 case PF_ROUTE: | 1258 case PF_ROUTE: |
1250 su->sa.sa_len = sizeof(*su); 1251 sockaddr(str, &su->sa); | 1259 sockaddr(str, sa, sizeof(struct sockaddr_storage)); |
1252 return (1); | 1260 return (1); |
1253 | 1261#ifdef INET |
1254 case AF_INET: | 1262 case AF_INET: |
1263#endif |
|
1255 default: 1256 break; 1257 } 1258 | 1264 default: 1265 break; 1266 } 1267 |
1268#ifdef INET 1269 sin = (struct sockaddr_in *)sa; |
|
1259 if (hpp == NULL) 1260 hpp = &hp; 1261 *hpp = NULL; 1262 1263 q = strchr(str,'/'); 1264 if (q != NULL && which == RTA_DST) { 1265 *q = '\0'; 1266 if ((val = inet_network(str)) != INADDR_NONE) { | 1270 if (hpp == NULL) 1271 hpp = &hp; 1272 *hpp = NULL; 1273 1274 q = strchr(str,'/'); 1275 if (q != NULL && which == RTA_DST) { 1276 *q = '\0'; 1277 if ((val = inet_network(str)) != INADDR_NONE) { |
1267 inet_makenetandmask( 1268 val, &su->sin, strtoul(q+1, 0, 0)); | 1278 inet_makenetandmask(val, sin, 1279 (struct sockaddr_in *)&so[RTAX_NETMASK], 1280 strtoul(q+1, 0, 0)); |
1269 return (0); 1270 } 1271 *q = '/'; 1272 } 1273 if ((which != RTA_DST || forcenet == 0) && | 1281 return (0); 1282 } 1283 *q = '/'; 1284 } 1285 if ((which != RTA_DST || forcenet == 0) && |
1274 inet_aton(str, &su->sin.sin_addr)) { 1275 val = su->sin.sin_addr.s_addr; | 1286 inet_aton(str, &sin->sin_addr)) { 1287 val = sin->sin_addr.s_addr; |
1276 if (which != RTA_DST || forcehost || | 1288 if (which != RTA_DST || forcehost || |
1277 inet_lnaof(su->sin.sin_addr) != INADDR_ANY) | 1289 inet_lnaof(sin->sin_addr) != INADDR_ANY) |
1278 return (1); 1279 else { 1280 val = ntohl(val); 1281 goto netdone; 1282 } 1283 } 1284 if (which == RTA_DST && forcehost == 0 && 1285 ((val = inet_network(str)) != INADDR_NONE || 1286 ((np = getnetbyname(str)) != NULL && (val = np->n_net) != 0))) { 1287netdone: | 1290 return (1); 1291 else { 1292 val = ntohl(val); 1293 goto netdone; 1294 } 1295 } 1296 if (which == RTA_DST && forcehost == 0 && 1297 ((val = inet_network(str)) != INADDR_NONE || 1298 ((np = getnetbyname(str)) != NULL && (val = np->n_net) != 0))) { 1299netdone: |
1288 inet_makenetandmask(val, &su->sin, 0); | 1300 inet_makenetandmask(val, sin, 1301 (struct sockaddr_in *)&so[RTAX_NETMASK], 0); |
1289 return (0); 1290 } 1291 hp = gethostbyname(str); 1292 if (hp != NULL) { 1293 *hpp = hp; | 1302 return (0); 1303 } 1304 hp = gethostbyname(str); 1305 if (hp != NULL) { 1306 *hpp = hp; |
1294 su->sin.sin_family = hp->h_addrtype; 1295 memmove((char *)&su->sin.sin_addr, hp->h_addr, 1296 MIN((size_t)hp->h_length, sizeof(su->sin.sin_addr))); | 1307 sin->sin_family = hp->h_addrtype; 1308 memmove((char *)&sin->sin_addr, hp->h_addr, 1309 MIN((size_t)hp->h_length, sizeof(sin->sin_addr))); |
1297 return (1); 1298 } | 1310 return (1); 1311 } |
1312#endif |
|
1299 errx(EX_NOHOST, "bad address: %s", str); 1300} 1301 1302static int 1303prefixlen(const char *str) 1304{ 1305 int len = atoi(str), q, r; 1306 int max; 1307 char *p; 1308 1309 rtm_addrs |= RTA_NETMASK; 1310 switch (af) { 1311#ifdef INET6 1312 case AF_INET6: | 1313 errx(EX_NOHOST, "bad address: %s", str); 1314} 1315 1316static int 1317prefixlen(const char *str) 1318{ 1319 int len = atoi(str), q, r; 1320 int max; 1321 char *p; 1322 1323 rtm_addrs |= RTA_NETMASK; 1324 switch (af) { 1325#ifdef INET6 1326 case AF_INET6: |
1327 { 1328 struct sockaddr_in6 *sin6 = 1329 (struct sockaddr_in6 *)&so[RTAX_NETMASK]; 1330 |
|
1313 max = 128; | 1331 max = 128; |
1314 p = (char *)&so_mask.sin6.sin6_addr; | 1332 p = (char *)&sin6->sin6_addr; 1333 sin6->sin6_family = AF_INET6; 1334 sin6->sin6_len = sizeof(*sin6); |
1315 break; | 1335 break; |
1336 } |
|
1316#endif | 1337#endif |
1338#ifdef INET |
|
1317 case AF_INET: | 1339 case AF_INET: |
1340 { 1341 struct sockaddr_in *sin = 1342 (struct sockaddr_in *)&so[RTAX_NETMASK]; 1343 |
|
1318 max = 32; | 1344 max = 32; |
1319 p = (char *)&so_mask.sin.sin_addr; | 1345 p = (char *)&sin->sin_addr; 1346 sin->sin_family = AF_INET; 1347 sin->sin_len = sizeof(*sin); |
1320 break; | 1348 break; |
1349 } 1350#endif |
|
1321 default: | 1351 default: |
1322 fprintf(stderr, "prefixlen not supported in this af\n"); 1323 exit(1); | 1352 errx(EX_OSERR, "prefixlen not supported in this af"); |
1324 } 1325 | 1353 } 1354 |
1326 if (len < 0 || max < len) { 1327 fprintf(stderr, "%s: bad value\n", str); 1328 exit(1); 1329 } | 1355 if (len < 0 || max < len) 1356 errx(EX_USAGE, "%s: invalid prefixlen", str); |
1330 1331 q = len >> 3; 1332 r = len & 7; | 1357 1358 q = len >> 3; 1359 r = len & 7; |
1333 so_mask.sa.sa_family = af; 1334 so_mask.sa.sa_len = aflen; | |
1335 memset((void *)p, 0, max / 8); 1336 if (q > 0) 1337 memset((void *)p, 0xff, q); 1338 if (r > 0) 1339 *((u_char *)p + q) = (0xff00 >> r) & 0xff; 1340 if (len == max) 1341 return (-1); 1342 else --- 7 unchanged lines hidden (view full) --- 1350 int mib[6]; 1351 char *buf, *lim, *next, count = 0; 1352 struct rt_msghdr *rtm; 1353 1354retry2: 1355 mib[0] = CTL_NET; 1356 mib[1] = PF_ROUTE; 1357 mib[2] = 0; /* protocol */ | 1360 memset((void *)p, 0, max / 8); 1361 if (q > 0) 1362 memset((void *)p, 0xff, q); 1363 if (r > 0) 1364 *((u_char *)p + q) = (0xff00 >> r) & 0xff; 1365 if (len == max) 1366 return (-1); 1367 else --- 7 unchanged lines hidden (view full) --- 1375 int mib[6]; 1376 char *buf, *lim, *next, count = 0; 1377 struct rt_msghdr *rtm; 1378 1379retry2: 1380 mib[0] = CTL_NET; 1381 mib[1] = PF_ROUTE; 1382 mib[2] = 0; /* protocol */ |
1358 mib[3] = 0; /* wildcard address family */ | 1383 mib[3] = AF_UNSPEC; |
1359 mib[4] = NET_RT_IFLIST; 1360 mib[5] = 0; /* no flags */ | 1384 mib[4] = NET_RT_IFLIST; 1385 mib[5] = 0; /* no flags */ |
1361 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) | 1386 if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0) |
1362 err(EX_OSERR, "route-sysctl-estimate"); 1363 if ((buf = malloc(needed)) == NULL) 1364 errx(EX_OSERR, "malloc failed"); | 1387 err(EX_OSERR, "route-sysctl-estimate"); 1388 if ((buf = malloc(needed)) == NULL) 1389 errx(EX_OSERR, "malloc failed"); |
1365 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) { | 1390 if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0) { |
1366 if (errno == ENOMEM && count++ < 10) { 1367 warnx("Routing table grew, retrying"); 1368 sleep(1); 1369 free(buf); 1370 goto retry2; 1371 } 1372 err(EX_OSERR, "actual retrieval of interface table"); 1373 } --- 43 unchanged lines hidden (view full) --- 1417 if (debugonly) { 1418 interfaces(); 1419 exit(0); 1420 } 1421 for (;;) { 1422 time_t now; 1423 n = read(s, msg, 2048); 1424 now = time(NULL); | 1391 if (errno == ENOMEM && count++ < 10) { 1392 warnx("Routing table grew, retrying"); 1393 sleep(1); 1394 free(buf); 1395 goto retry2; 1396 } 1397 err(EX_OSERR, "actual retrieval of interface table"); 1398 } --- 43 unchanged lines hidden (view full) --- 1442 if (debugonly) { 1443 interfaces(); 1444 exit(0); 1445 } 1446 for (;;) { 1447 time_t now; 1448 n = read(s, msg, 2048); 1449 now = time(NULL); |
1425 (void) printf("\ngot message of size %d on %s", n, ctime(&now)); | 1450 (void)printf("\ngot message of size %d on %s", n, ctime(&now)); |
1426 print_rtmsg((struct rt_msghdr *)msg, n); 1427 } 1428} 1429 | 1451 print_rtmsg((struct rt_msghdr *)msg, n); 1452 } 1453} 1454 |
1430struct { | 1455static struct { |
1431 struct rt_msghdr m_rtm; 1432 char m_space[512]; 1433} m_rtmsg; 1434 1435static int 1436rtmsg(int cmd, int flags, int fib) 1437{ 1438 static int seq; 1439 int rlen; 1440 char *cp = m_rtmsg.m_space; 1441 int l; 1442 | 1456 struct rt_msghdr m_rtm; 1457 char m_space[512]; 1458} m_rtmsg; 1459 1460static int 1461rtmsg(int cmd, int flags, int fib) 1462{ 1463 static int seq; 1464 int rlen; 1465 char *cp = m_rtmsg.m_space; 1466 int l; 1467 |
1443#define NEXTADDR(w, u) \ 1444 if (rtm_addrs & (w)) {\ 1445 l = SA_SIZE(&(u.sa)); memmove(cp, &(u), l); cp += l;\ 1446 if (verbose) sodump(&(u),#u);\ | 1468#define NEXTADDR(w, u) \ 1469 if (rtm_addrs & (w)) { \ 1470 l = SA_SIZE((struct sockaddr *)&(u)); \ 1471 memmove(cp, (char *)&(u), l); \ 1472 cp += l; \ 1473 if (verbose) \ 1474 sodump((struct sockaddr *)&(u), #w); \ |
1447 } 1448 1449 errno = 0; 1450 memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 1451 if (cmd == 'a') 1452 cmd = RTM_ADD; 1453 else if (cmd == 'c') 1454 cmd = RTM_CHANGE; 1455 else if (cmd == 'g' || cmd == 's') { 1456 cmd = RTM_GET; | 1475 } 1476 1477 errno = 0; 1478 memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 1479 if (cmd == 'a') 1480 cmd = RTM_ADD; 1481 else if (cmd == 'c') 1482 cmd = RTM_CHANGE; 1483 else if (cmd == 'g' || cmd == 's') { 1484 cmd = RTM_GET; |
1457 if (so_ifp.sa.sa_family == 0) { 1458 so_ifp.sa.sa_family = AF_LINK; 1459 so_ifp.sa.sa_len = sizeof(struct sockaddr_dl); | 1485 if (so[RTAX_IFP].ss_family == 0) { 1486 so[RTAX_IFP].ss_family = AF_LINK; 1487 so[RTAX_IFP].ss_len = sizeof(struct sockaddr_dl); |
1460 rtm_addrs |= RTA_IFP; 1461 } 1462 } else 1463 cmd = RTM_DELETE; 1464#define rtm m_rtmsg.m_rtm 1465 rtm.rtm_type = cmd; 1466 rtm.rtm_flags = flags; 1467 rtm.rtm_version = RTM_VERSION; 1468 rtm.rtm_seq = ++seq; 1469 rtm.rtm_addrs = rtm_addrs; 1470 rtm.rtm_rmx = rt_metrics; 1471 rtm.rtm_inits = rtm_inits; 1472 | 1488 rtm_addrs |= RTA_IFP; 1489 } 1490 } else 1491 cmd = RTM_DELETE; 1492#define rtm m_rtmsg.m_rtm 1493 rtm.rtm_type = cmd; 1494 rtm.rtm_flags = flags; 1495 rtm.rtm_version = RTM_VERSION; 1496 rtm.rtm_seq = ++seq; 1497 rtm.rtm_addrs = rtm_addrs; 1498 rtm.rtm_rmx = rt_metrics; 1499 rtm.rtm_inits = rtm_inits; 1500 |
1473 if (rtm_addrs & RTA_NETMASK) 1474 mask_addr(); 1475 NEXTADDR(RTA_DST, so_dst); 1476 NEXTADDR(RTA_GATEWAY, so_gate); 1477 NEXTADDR(RTA_NETMASK, so_mask); 1478 NEXTADDR(RTA_GENMASK, so_genmask); 1479 NEXTADDR(RTA_IFP, so_ifp); 1480 NEXTADDR(RTA_IFA, so_ifa); | 1501 NEXTADDR(RTA_DST, so[RTAX_DST]); 1502 NEXTADDR(RTA_GATEWAY, so[RTAX_GATEWAY]); 1503 NEXTADDR(RTA_NETMASK, so[RTAX_NETMASK]); 1504 NEXTADDR(RTA_GENMASK, so[RTAX_GENMASK]); 1505 NEXTADDR(RTA_IFP, so[RTAX_IFP]); 1506 NEXTADDR(RTA_IFA, so[RTAX_IFA]); |
1481 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; 1482 if (verbose) 1483 print_rtmsg(&rtm, l); 1484 if (debugonly) 1485 return (0); 1486 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) { 1487 if (errno == EPERM) 1488 err(1, "writing to routing socket"); --- 8 unchanged lines hidden (view full) --- 1497 warn("read from routing socket"); 1498 else 1499 print_getmsg(&rtm, l, fib); 1500 } 1501#undef rtm 1502 return (0); 1503} 1504 | 1507 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; 1508 if (verbose) 1509 print_rtmsg(&rtm, l); 1510 if (debugonly) 1511 return (0); 1512 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) { 1513 if (errno == EPERM) 1514 err(1, "writing to routing socket"); --- 8 unchanged lines hidden (view full) --- 1523 warn("read from routing socket"); 1524 else 1525 print_getmsg(&rtm, l, fib); 1526 } 1527#undef rtm 1528 return (0); 1529} 1530 |
1505static void 1506mask_addr(void) 1507{ 1508 int olen = so_mask.sa.sa_len; 1509 char *cp1 = olen + (char *)&so_mask, *cp2; 1510 1511 for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; ) 1512 if (*--cp1 != 0) { 1513 so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask; 1514 break; 1515 } 1516 if ((rtm_addrs & RTA_DST) == 0) 1517 return; 1518 switch (so_dst.sa.sa_family) { 1519 case AF_INET: 1520#ifdef INET6 1521 case AF_INET6: 1522#endif 1523 case AF_APPLETALK: 1524 case 0: 1525 return; 1526 } 1527 cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst; 1528 cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst; 1529 while (cp2 > cp1) 1530 *--cp2 = 0; 1531 cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask; 1532 while (cp1 > so_dst.sa.sa_data) 1533 *--cp1 &= *--cp2; 1534} 1535 1536const char *msgtypes[] = { | 1531static const char *msgtypes[] = { |
1537 "", 1538 "RTM_ADD: Add Route", 1539 "RTM_DELETE: Delete Route", 1540 "RTM_CHANGE: Change Metrics or flags", 1541 "RTM_GET: Report Metrics", 1542 "RTM_LOSING: Kernel Suspects Partitioning", 1543 "RTM_REDIRECT: Told to use different route", 1544 "RTM_MISS: Lookup failed on this address", --- 5 unchanged lines hidden (view full) --- 1550 "RTM_DELADDR: address being removed from iface", 1551 "RTM_IFINFO: iface status change", 1552 "RTM_NEWMADDR: new multicast group membership on iface", 1553 "RTM_DELMADDR: multicast group membership removed from iface", 1554 "RTM_IFANNOUNCE: interface arrival/departure", 1555 "RTM_IEEE80211: IEEE 802.11 wireless event", 1556}; 1557 | 1532 "", 1533 "RTM_ADD: Add Route", 1534 "RTM_DELETE: Delete Route", 1535 "RTM_CHANGE: Change Metrics or flags", 1536 "RTM_GET: Report Metrics", 1537 "RTM_LOSING: Kernel Suspects Partitioning", 1538 "RTM_REDIRECT: Told to use different route", 1539 "RTM_MISS: Lookup failed on this address", --- 5 unchanged lines hidden (view full) --- 1545 "RTM_DELADDR: address being removed from iface", 1546 "RTM_IFINFO: iface status change", 1547 "RTM_NEWMADDR: new multicast group membership on iface", 1548 "RTM_DELMADDR: multicast group membership removed from iface", 1549 "RTM_IFANNOUNCE: interface arrival/departure", 1550 "RTM_IEEE80211: IEEE 802.11 wireless event", 1551}; 1552 |
1558char metricnames[] = 1559"\011weight\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire" 1560"\1mtu"; 1561char routeflags[] = 1562"\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE" 1563"\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE" 1564"\017PROTO2\020PROTO1\021PRCLONING\022WASCLONED\023PROTO3" 1565"\025PINNED\026LOCAL\027BROADCAST\030MULTICAST\035STICKY"; 1566char ifnetflags[] = 1567"\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6b6\7RUNNING\010NOARP" 1568"\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1" 1569"\017LINK2\020MULTICAST"; 1570char addrnames[] = 1571"\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD"; | 1553static const char metricnames[] = 1554 "\011weight\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire" 1555 "\1mtu"; 1556static const char routeflags[] = 1557 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE" 1558 "\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE" 1559 "\017PROTO2\020PROTO1\021PRCLONING\022WASCLONED\023PROTO3" 1560 "\025PINNED\026LOCAL\027BROADCAST\030MULTICAST\035STICKY"; 1561static const char ifnetflags[] = 1562 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6b6\7RUNNING\010NOARP" 1563 "\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1" 1564 "\017LINK2\020MULTICAST"; 1565static const char addrnames[] = 1566 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD"; |
1572 1573static const char errfmt[] = | 1567 1568static const char errfmt[] = |
1574"\n%s: truncated route message, only %zu bytes left\n"; | 1569 "\n%s: truncated route message, only %zu bytes left\n"; |
1575 1576static void 1577print_rtmsg(struct rt_msghdr *rtm, size_t msglen) 1578{ 1579 struct if_msghdr *ifm; 1580 struct ifa_msghdr *ifam; 1581#ifdef RTM_NEWMADDR 1582 struct ifma_msghdr *ifmam; 1583#endif 1584 struct if_announcemsghdr *ifan; 1585 const char *state; 1586 1587 if (verbose == 0) 1588 return; 1589 if (rtm->rtm_version != RTM_VERSION) { | 1570 1571static void 1572print_rtmsg(struct rt_msghdr *rtm, size_t msglen) 1573{ 1574 struct if_msghdr *ifm; 1575 struct ifa_msghdr *ifam; 1576#ifdef RTM_NEWMADDR 1577 struct ifma_msghdr *ifmam; 1578#endif 1579 struct if_announcemsghdr *ifan; 1580 const char *state; 1581 1582 if (verbose == 0) 1583 return; 1584 if (rtm->rtm_version != RTM_VERSION) { |
1590 (void) printf("routing message version %d not understood\n", | 1585 (void)printf("routing message version %d not understood\n", |
1591 rtm->rtm_version); 1592 return; 1593 } 1594 if (rtm->rtm_type < sizeof(msgtypes) / sizeof(msgtypes[0])) 1595 (void)printf("%s: ", msgtypes[rtm->rtm_type]); 1596 else 1597 (void)printf("unknown type %d: ", rtm->rtm_type); 1598 (void)printf("len %d, ", rtm->rtm_msglen); --- 4 unchanged lines hidden (view full) --- 1603 else \ 1604 msglen -= sizeof(x); \ 1605 } while (0) 1606 1607 switch (rtm->rtm_type) { 1608 case RTM_IFINFO: 1609 REQUIRE(struct if_msghdr); 1610 ifm = (struct if_msghdr *)rtm; | 1586 rtm->rtm_version); 1587 return; 1588 } 1589 if (rtm->rtm_type < sizeof(msgtypes) / sizeof(msgtypes[0])) 1590 (void)printf("%s: ", msgtypes[rtm->rtm_type]); 1591 else 1592 (void)printf("unknown type %d: ", rtm->rtm_type); 1593 (void)printf("len %d, ", rtm->rtm_msglen); --- 4 unchanged lines hidden (view full) --- 1598 else \ 1599 msglen -= sizeof(x); \ 1600 } while (0) 1601 1602 switch (rtm->rtm_type) { 1603 case RTM_IFINFO: 1604 REQUIRE(struct if_msghdr); 1605 ifm = (struct if_msghdr *)rtm; |
1611 (void) printf("if# %d, ", ifm->ifm_index); | 1606 (void)printf("if# %d, ", ifm->ifm_index); |
1612 switch (ifm->ifm_data.ifi_link_state) { 1613 case LINK_STATE_DOWN: 1614 state = "down"; 1615 break; 1616 case LINK_STATE_UP: 1617 state = "up"; 1618 break; 1619 default: 1620 state = "unknown"; 1621 break; 1622 } | 1607 switch (ifm->ifm_data.ifi_link_state) { 1608 case LINK_STATE_DOWN: 1609 state = "down"; 1610 break; 1611 case LINK_STATE_UP: 1612 state = "up"; 1613 break; 1614 default: 1615 state = "unknown"; 1616 break; 1617 } |
1623 (void) printf("link: %s, flags:", state); 1624 bprintf(stdout, ifm->ifm_flags, ifnetflags); | 1618 (void)printf("link: %s, flags:", state); 1619 printb(ifm->ifm_flags, ifnetflags); |
1625 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs, msglen); 1626 break; 1627 case RTM_NEWADDR: 1628 case RTM_DELADDR: 1629 REQUIRE(struct ifa_msghdr); 1630 ifam = (struct ifa_msghdr *)rtm; | 1620 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs, msglen); 1621 break; 1622 case RTM_NEWADDR: 1623 case RTM_DELADDR: 1624 REQUIRE(struct ifa_msghdr); 1625 ifam = (struct ifa_msghdr *)rtm; |
1631 (void) printf("metric %d, flags:", ifam->ifam_metric); 1632 bprintf(stdout, ifam->ifam_flags, routeflags); | 1626 (void)printf("metric %d, flags:", ifam->ifam_metric); 1627 printb(ifam->ifam_flags, routeflags); |
1633 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs, msglen); 1634 break; 1635#ifdef RTM_NEWMADDR 1636 case RTM_NEWMADDR: 1637 case RTM_DELMADDR: 1638 REQUIRE(struct ifma_msghdr); 1639 ifmam = (struct ifma_msghdr *)rtm; 1640 pmsg_addrs((char *)(ifmam + 1), ifmam->ifmam_addrs, msglen); 1641 break; 1642#endif 1643 case RTM_IFANNOUNCE: 1644 REQUIRE(struct if_announcemsghdr); 1645 ifan = (struct if_announcemsghdr *)rtm; | 1628 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs, msglen); 1629 break; 1630#ifdef RTM_NEWMADDR 1631 case RTM_NEWMADDR: 1632 case RTM_DELMADDR: 1633 REQUIRE(struct ifma_msghdr); 1634 ifmam = (struct ifma_msghdr *)rtm; 1635 pmsg_addrs((char *)(ifmam + 1), ifmam->ifmam_addrs, msglen); 1636 break; 1637#endif 1638 case RTM_IFANNOUNCE: 1639 REQUIRE(struct if_announcemsghdr); 1640 ifan = (struct if_announcemsghdr *)rtm; |
1646 (void) printf("if# %d, what: ", ifan->ifan_index); | 1641 (void)printf("if# %d, what: ", ifan->ifan_index); |
1647 switch (ifan->ifan_what) { 1648 case IFAN_ARRIVAL: | 1642 switch (ifan->ifan_what) { 1643 case IFAN_ARRIVAL: |
1649 printf("arrival"); | 1644 (void)printf("arrival"); |
1650 break; 1651 case IFAN_DEPARTURE: 1652 printf("departure"); 1653 break; 1654 default: 1655 printf("#%d", ifan->ifan_what); 1656 break; 1657 } 1658 printf("\n"); 1659 fflush(stdout); 1660 break; 1661 1662 default: | 1645 break; 1646 case IFAN_DEPARTURE: 1647 printf("departure"); 1648 break; 1649 default: 1650 printf("#%d", ifan->ifan_what); 1651 break; 1652 } 1653 printf("\n"); 1654 fflush(stdout); 1655 break; 1656 1657 default: |
1663 (void) printf("pid: %ld, seq %d, errno %d, flags:", | 1658 printf("pid: %ld, seq %d, errno %d, flags:", |
1664 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno); | 1659 (long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno); |
1665 bprintf(stdout, rtm->rtm_flags, routeflags); | 1660 printb(rtm->rtm_flags, routeflags); |
1666 pmsg_common(rtm, msglen); 1667 } 1668 1669 return; 1670 1671badlen: 1672 (void)printf(errfmt, __func__, msglen); 1673#undef REQUIRE 1674} 1675 1676static void 1677print_getmsg(struct rt_msghdr *rtm, int msglen, int fib) 1678{ 1679 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL; 1680 struct sockaddr_dl *ifp = NULL; 1681 struct sockaddr *sa; 1682 char *cp; 1683 int i; 1684 | 1661 pmsg_common(rtm, msglen); 1662 } 1663 1664 return; 1665 1666badlen: 1667 (void)printf(errfmt, __func__, msglen); 1668#undef REQUIRE 1669} 1670 1671static void 1672print_getmsg(struct rt_msghdr *rtm, int msglen, int fib) 1673{ 1674 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL; 1675 struct sockaddr_dl *ifp = NULL; 1676 struct sockaddr *sa; 1677 char *cp; 1678 int i; 1679 |
1685 (void) printf(" route to: %s\n", 1686 routename((struct sockaddr *)&so_dst)); | 1680 (void)printf(" route to: %s\n", 1681 routename((struct sockaddr *)&so[RTAX_DST])); |
1687 if (rtm->rtm_version != RTM_VERSION) { 1688 warnx("routing message version %d not understood", 1689 rtm->rtm_version); 1690 return; 1691 } 1692 if (rtm->rtm_msglen > msglen) { 1693 warnx("message length mismatch, in packet %d, returned %d", 1694 rtm->rtm_msglen, msglen); --- 40 unchanged lines hidden (view full) --- 1735 if (gate && rtm->rtm_flags & RTF_GATEWAY) 1736 (void)printf(" gateway: %s\n", routename(gate)); 1737 if (fib >= 0) 1738 (void)printf(" fib: %u\n", (unsigned int)fib); 1739 if (ifp) 1740 (void)printf(" interface: %.*s\n", 1741 ifp->sdl_nlen, ifp->sdl_data); 1742 (void)printf(" flags: "); | 1682 if (rtm->rtm_version != RTM_VERSION) { 1683 warnx("routing message version %d not understood", 1684 rtm->rtm_version); 1685 return; 1686 } 1687 if (rtm->rtm_msglen > msglen) { 1688 warnx("message length mismatch, in packet %d, returned %d", 1689 rtm->rtm_msglen, msglen); --- 40 unchanged lines hidden (view full) --- 1730 if (gate && rtm->rtm_flags & RTF_GATEWAY) 1731 (void)printf(" gateway: %s\n", routename(gate)); 1732 if (fib >= 0) 1733 (void)printf(" fib: %u\n", (unsigned int)fib); 1734 if (ifp) 1735 (void)printf(" interface: %.*s\n", 1736 ifp->sdl_nlen, ifp->sdl_data); 1737 (void)printf(" flags: "); |
1743 bprintf(stdout, rtm->rtm_flags, routeflags); | 1738 printb(rtm->rtm_flags, routeflags); |
1744 1745#define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ') 1746#define msec(u) (((u) + 500) / 1000) /* usec to msec */ 1747 | 1739 1740#define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ') 1741#define msec(u) (((u) + 500) / 1000) /* usec to msec */ 1742 |
1748 (void) printf("\n%s\n", "\ | 1743 printf("\n%s\n", "\ |
1749 recvpipe sendpipe ssthresh rtt,msec mtu weight expire"); 1750 printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE)); 1751 printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE)); 1752 printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH)); 1753 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT)); 1754 printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU)); 1755 printf("%8ld%c ", rtm->rtm_rmx.rmx_weight, lock(WEIGHT)); 1756 if (rtm->rtm_rmx.rmx_expire) 1757 rtm->rtm_rmx.rmx_expire -= time(0); 1758 printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE)); 1759#undef lock 1760#undef msec 1761#define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD) 1762 if (verbose) 1763 pmsg_common(rtm, msglen); 1764 else if (rtm->rtm_addrs &~ RTA_IGN) { | 1744 recvpipe sendpipe ssthresh rtt,msec mtu weight expire"); 1745 printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE)); 1746 printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE)); 1747 printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH)); 1748 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT)); 1749 printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU)); 1750 printf("%8ld%c ", rtm->rtm_rmx.rmx_weight, lock(WEIGHT)); 1751 if (rtm->rtm_rmx.rmx_expire) 1752 rtm->rtm_rmx.rmx_expire -= time(0); 1753 printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE)); 1754#undef lock 1755#undef msec 1756#define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD) 1757 if (verbose) 1758 pmsg_common(rtm, msglen); 1759 else if (rtm->rtm_addrs &~ RTA_IGN) { |
1765 (void) printf("sockaddrs: "); 1766 bprintf(stdout, rtm->rtm_addrs, addrnames); | 1760 (void)printf("sockaddrs: "); 1761 printb(rtm->rtm_addrs, addrnames); |
1767 putchar('\n'); 1768 } 1769#undef RTA_IGN 1770} 1771 1772static void 1773pmsg_common(struct rt_msghdr *rtm, size_t msglen) 1774{ | 1762 putchar('\n'); 1763 } 1764#undef RTA_IGN 1765} 1766 1767static void 1768pmsg_common(struct rt_msghdr *rtm, size_t msglen) 1769{ |
1775 (void) printf("\nlocks: "); 1776 bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames); 1777 (void) printf(" inits: "); 1778 bprintf(stdout, rtm->rtm_inits, metricnames); | 1770 1771 (void)printf("\nlocks: "); 1772 printb(rtm->rtm_rmx.rmx_locks, metricnames); 1773 (void)printf(" inits: "); 1774 printb(rtm->rtm_inits, metricnames); |
1779 if (msglen > sizeof(struct rt_msghdr)) 1780 pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs, 1781 msglen - sizeof(struct rt_msghdr)); 1782 else | 1775 if (msglen > sizeof(struct rt_msghdr)) 1776 pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs, 1777 msglen - sizeof(struct rt_msghdr)); 1778 else |
1783 (void) fflush(stdout); | 1779 (void)fflush(stdout); |
1784} 1785 1786static void 1787pmsg_addrs(char *cp, int addrs, size_t len) 1788{ 1789 struct sockaddr *sa; 1790 int i; 1791 1792 if (addrs == 0) { | 1780} 1781 1782static void 1783pmsg_addrs(char *cp, int addrs, size_t len) 1784{ 1785 struct sockaddr *sa; 1786 int i; 1787 1788 if (addrs == 0) { |
1793 (void) putchar('\n'); | 1789 (void)putchar('\n'); |
1794 return; 1795 } | 1790 return; 1791 } |
1796 (void) printf("\nsockaddrs: "); 1797 bprintf(stdout, addrs, addrnames); 1798 (void) putchar('\n'); | 1792 (void)printf("\nsockaddrs: "); 1793 printb(addrs, addrnames); 1794 putchar('\n'); |
1799 for (i = 1; i != 0; i <<= 1) 1800 if (i & addrs) { 1801 sa = (struct sockaddr *)cp; 1802 if (len == 0 || len < SA_SIZE(sa)) { | 1795 for (i = 1; i != 0; i <<= 1) 1796 if (i & addrs) { 1797 sa = (struct sockaddr *)cp; 1798 if (len == 0 || len < SA_SIZE(sa)) { |
1803 (void) printf(errfmt, __func__, len); | 1799 (void)printf(errfmt, __func__, len); |
1804 break; 1805 } | 1800 break; 1801 } |
1806 (void) printf(" %s", routename(sa)); | 1802 (void)printf(" %s", routename(sa)); |
1807 len -= SA_SIZE(sa); 1808 cp += SA_SIZE(sa); 1809 } | 1803 len -= SA_SIZE(sa); 1804 cp += SA_SIZE(sa); 1805 } |
1810 (void) putchar('\n'); 1811 (void) fflush(stdout); | 1806 (void)putchar('\n'); 1807 (void)fflush(stdout); |
1812} 1813 1814static void | 1808} 1809 1810static void |
1815bprintf(FILE *fp, int b, u_char *str) | 1811printb(int b, const char *str) |
1816{ 1817 int i; 1818 int gotsome = 0; 1819 1820 if (b == 0) 1821 return; 1822 while ((i = *str++) != 0) { 1823 if (b & (1 << (i-1))) { 1824 if (gotsome == 0) 1825 i = '<'; 1826 else 1827 i = ','; | 1812{ 1813 int i; 1814 int gotsome = 0; 1815 1816 if (b == 0) 1817 return; 1818 while ((i = *str++) != 0) { 1819 if (b & (1 << (i-1))) { 1820 if (gotsome == 0) 1821 i = '<'; 1822 else 1823 i = ','; |
1828 (void) putc(i, fp); | 1824 putchar(i); |
1829 gotsome = 1; 1830 for (; (i = *str) > 32; str++) | 1825 gotsome = 1; 1826 for (; (i = *str) > 32; str++) |
1831 (void) putc(i, fp); | 1827 putchar(i); |
1832 } else 1833 while (*str > 32) 1834 str++; 1835 } 1836 if (gotsome) | 1828 } else 1829 while (*str > 32) 1830 str++; 1831 } 1832 if (gotsome) |
1837 (void) putc('>', fp); | 1833 putchar('>'); |
1838} 1839 1840int 1841keyword(const char *cp) 1842{ 1843 struct keytab *kt = keywords; 1844 1845 while (kt->kt_cp != NULL && strcmp(kt->kt_cp, cp) != 0) 1846 kt++; 1847 return (kt->kt_i); 1848} 1849 1850static void | 1834} 1835 1836int 1837keyword(const char *cp) 1838{ 1839 struct keytab *kt = keywords; 1840 1841 while (kt->kt_cp != NULL && strcmp(kt->kt_cp, cp) != 0) 1842 kt++; 1843 return (kt->kt_i); 1844} 1845 1846static void |
1851sodump(sup su, const char *which) | 1847sodump(struct sockaddr *sa, const char *which) |
1852{ | 1848{ |
1853 switch (su->sa.sa_family) { | 1849#ifdef INET6 1850 char nbuf[INET6_ADDRSTRLEN]; 1851#endif 1852 1853 switch (sa->sa_family) { |
1854 case AF_LINK: | 1854 case AF_LINK: |
1855 (void) printf("%s: link %s; ", 1856 which, link_ntoa(&su->sdl)); | 1855 (void)printf("%s: link %s; ", which, 1856 link_ntoa((struct sockaddr_dl *)sa)); |
1857 break; | 1857 break; |
1858#ifdef INET |
|
1858 case AF_INET: | 1859 case AF_INET: |
1859 (void) printf("%s: inet %s; ", 1860 which, inet_ntoa(su->sin.sin_addr)); | 1860 (void)printf("%s: inet %s; ", which, 1861 inet_ntoa(((struct sockaddr_in *)sa)->sin_addr)); |
1861 break; | 1862 break; |
1863#endif 1864#ifdef INET6 1865 case AF_INET6: 1866 (void)printf("%s: inet6 %s; ", which, inet_ntop(sa->sa_family, 1867 &((struct sockaddr_in6 *)sa)->sin6_addr, nbuf, 1868 sizeof(nbuf))); 1869 break; 1870#endif |
|
1862 case AF_APPLETALK: | 1871 case AF_APPLETALK: |
1863 (void) printf("%s: atalk %s; ", 1864 which, atalk_ntoa(su->sat.sat_addr)); | 1872 (void)printf("%s: atalk %s; ", which, 1873 atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr)); |
1865 break; 1866 } | 1874 break; 1875 } |
1867 (void) fflush(stdout); | 1876 (void)fflush(stdout); |
1868} 1869 1870/* States*/ 1871#define VIRGIN 0 1872#define GOTONE 1 1873#define GOTTWO 2 1874/* Inputs */ 1875#define DIGIT (4*0) 1876#define END (4*1) 1877#define DELIM (4*2) 1878 1879static void | 1877} 1878 1879/* States*/ 1880#define VIRGIN 0 1881#define GOTONE 1 1882#define GOTTWO 2 1883/* Inputs */ 1884#define DIGIT (4*0) 1885#define END (4*1) 1886#define DELIM (4*2) 1887 1888static void |
1880sockaddr(char *addr, struct sockaddr *sa) | 1889sockaddr(char *addr, struct sockaddr *sa, size_t size) |
1881{ 1882 char *cp = (char *)sa; | 1890{ 1891 char *cp = (char *)sa; |
1883 int size = sa->sa_len; | |
1884 char *cplim = cp + size; 1885 int byte = 0, state = VIRGIN, new = 0 /* foil gcc */; 1886 1887 memset(cp, 0, size); 1888 cp++; 1889 do { 1890 if ((*addr >= '0') && (*addr <= '9')) { 1891 new = *addr - '0'; --- 39 unchanged lines hidden (view full) --- 1931 return(1); 1932} 1933 1934static char * 1935atalk_ntoa(struct at_addr at) 1936{ 1937 static char buf[20]; 1938 | 1892 char *cplim = cp + size; 1893 int byte = 0, state = VIRGIN, new = 0 /* foil gcc */; 1894 1895 memset(cp, 0, size); 1896 cp++; 1897 do { 1898 if ((*addr >= '0') && (*addr <= '9')) { 1899 new = *addr - '0'; --- 39 unchanged lines hidden (view full) --- 1939 return(1); 1940} 1941 1942static char * 1943atalk_ntoa(struct at_addr at) 1944{ 1945 static char buf[20]; 1946 |
1939 (void) snprintf(buf, sizeof(buf), "%u.%u", ntohs(at.s_net), at.s_node); | 1947 (void)snprintf(buf, sizeof(buf), "%u.%u", ntohs(at.s_net), at.s_node); 1948 buf[sizeof(buf) - 1] = '\0'; |
1940 return(buf); 1941} | 1949 return(buf); 1950} |