![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to route.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / route|
Return to route.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / route |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983, 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: char copyright[] = ! 22: "@(#) Copyright (c) 1983 The Regents of the University of California.\n\ ! 23: All rights reserved.\n"; ! 24: #endif /* not lint */ ! 25: ! 26: #ifndef lint ! 27: static char sccsid[] = "@(#)route.c 5.27 (Berkeley) 6/22/90"; ! 28: #endif /* not lint */ ! 29: ! 30: #include <sys/param.h> ! 31: #include <sys/socket.h> ! 32: #include <sys/ioctl.h> ! 33: #include <sys/file.h> ! 34: #include <sys/mbuf.h> ! 35: #include <sys/kinfo.h> ! 36: ! 37: #include <net/route.h> ! 38: #include <net/if_dl.h> ! 39: #include <netinet/in.h> ! 40: #include <netns/ns.h> ! 41: #include <netiso/iso.h> ! 42: ! 43: #include <netdb.h> ! 44: #include <stdio.h> ! 45: #include <errno.h> ! 46: #include <ctype.h> ! 47: #include <paths.h> ! 48: ! 49: struct keytab { ! 50: char *kt_cp; ! 51: int kt_i; ! 52: } keywords[] = { ! 53: #include "keywords.h" ! 54: {0, 0} ! 55: }; ! 56: ! 57: struct ortentry route; ! 58: union sockunion { ! 59: struct sockaddr sa; ! 60: struct sockaddr_in sin; ! 61: struct sockaddr_ns sns; ! 62: struct sockaddr_iso siso; ! 63: struct sockaddr_dl sdl; ! 64: } so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp, *so_addrs[] = ! 65: { &so_dst, &so_gate, &so_mask, &so_genmask, &so_ifa, &so_ifp, 0}; ! 66: typedef union sockunion *sup; ! 67: int pid, rtm_addrs; ! 68: int s; ! 69: int forcehost, forcenet, doflush, nflag, af, qflag, Cflag, keyword(); ! 70: int iflag, verbose, aflen = sizeof (struct sockaddr_in); ! 71: int locking, lockrest, debugonly; ! 72: struct sockaddr_in sin = { sizeof(sin), AF_INET }; ! 73: struct rt_metrics rt_metrics; ! 74: u_long rtm_inits; ! 75: struct in_addr inet_makeaddr(); ! 76: char *malloc(), *routename(), *netname(); ! 77: extern char *iso_ntoa(), *link_ntoa(); ! 78: #define kget(p, d) \ ! 79: (lseek(kmem, (off_t)(p), 0), read(kmem, (char *)&(d), sizeof (d))) ! 80: ! 81: usage(cp) ! 82: char *cp; ! 83: { ! 84: fprintf(stderr, ! 85: "usage: route [ -nqCv ] cmd [[ -<qualifers> ] args ]\n"); ! 86: if (cp) fprintf(stderr, "(botched keyword: %s)\n", cp); ! 87: ! 88: exit(1); ! 89: } ! 90: ! 91: main(argc, argv) ! 92: int argc; ! 93: char *argv[]; ! 94: { ! 95: ! 96: char *argvp; ! 97: if (argc < 2) ! 98: usage((char *)0); ! 99: argc--, argv++; ! 100: for (; argc > 0 && argv[0][0] == '-'; argc--, argv++) { ! 101: for (argvp = argv[0]++; *argvp; argvp++) ! 102: switch (*argv[0]) { ! 103: case 'n': ! 104: nflag++; ! 105: break; ! 106: case 'q': ! 107: qflag++; ! 108: break; ! 109: case 'C': ! 110: Cflag++; /* Use old ioctls */ ! 111: break; ! 112: case 'v': ! 113: verbose++; ! 114: } ! 115: } ! 116: pid = getpid(); ! 117: if (Cflag) ! 118: s = socket(AF_INET, SOCK_RAW, 0); ! 119: else ! 120: s = socket(PF_ROUTE, SOCK_RAW, 0); ! 121: if (s < 0) { ! 122: perror("route: socket"); ! 123: exit(1); ! 124: } ! 125: if (argc > 0) switch (keyword(*argv)) { ! 126: case K_ADD: ! 127: case K_CHANGE: ! 128: case K_DELETE: ! 129: newroute(argc, argv); ! 130: case K_MONITOR: ! 131: monitor(); ! 132: case K_FLUSH: ! 133: flushroutes(argc, argv); ! 134: } ! 135: usage(*argv); ! 136: } ! 137: ! 138: /* ! 139: * Purge all entries in the routing tables not ! 140: * associated with network interfaces. ! 141: */ ! 142: flushroutes(argc, argv) ! 143: char *argv[]; ! 144: { ! 145: int bufsize, needed, seqno, rlen; ! 146: char *buf, *next, *lim; ! 147: register struct rt_msghdr *rtm; ! 148: struct { ! 149: struct rt_msghdr m_rtm; ! 150: union { ! 151: char u_saddrs[200]; ! 152: struct sockaddr u_sa; ! 153: } m_u; ! 154: } m; ! 155: ! 156: shutdown(s, 0); /* Don't want to read back our messages */ ! 157: if (argc > 1) { ! 158: argv++; ! 159: if (argc == 2 && **argv == '-') switch (keyword(1 + *argv)) { ! 160: case K_INET: af = AF_INET; break; ! 161: case K_XNS: af = AF_NS; break; ! 162: case K_LINK: af = AF_LINK; break; ! 163: case K_ISO: case K_OSI: af = AF_ISO; break; ! 164: default: goto bad; ! 165: } else ! 166: bad: usage(*argv); ! 167: } ! 168: if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0) ! 169: { perror("route-getkerninfo-estimate"); exit(1);} ! 170: if ((buf = malloc(needed)) == 0) ! 171: { printf("out of space\n");; exit(1);} ! 172: if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0) ! 173: { perror("actual retrieval of routing table"); exit(1);} ! 174: lim = buf + rlen; ! 175: for (next = buf; next < lim; next += rtm->rtm_msglen) { ! 176: rtm = (struct rt_msghdr *)next; ! 177: if ((rtm->rtm_flags & RTF_GATEWAY) == 0) ! 178: continue; ! 179: if (af) { ! 180: struct sockaddr *sa = (struct sockaddr *)(rtm + 1); ! 181: if (sa->sa_family != af) ! 182: continue; ! 183: } ! 184: rtm->rtm_type = RTM_DELETE; ! 185: rtm->rtm_seq = seqno; ! 186: if ((rlen = write(s, next, rtm->rtm_msglen)) < 0) { ! 187: perror("writing to routing socket"); ! 188: printf("got only %d for rlen\n", rlen); ! 189: break; ! 190: } ! 191: seqno++; ! 192: if (qflag) ! 193: continue; ! 194: if (verbose) { ! 195: print_rtmsg(rtm, rlen); ! 196: } else { ! 197: struct sockaddr *sa = &m.m_u.u_sa; ! 198: printf("%-20.20s ", (rtm->rtm_flags & RTF_HOST) ? ! 199: routename(sa) : netname(sa)); ! 200: sa = (struct sockaddr *)(sa->sa_len + (char *)sa); ! 201: printf("%-20.20s ", routename(sa)); ! 202: printf("done\n"); ! 203: } ! 204: } ! 205: exit(0); ! 206: } ! 207: ! 208: char * ! 209: routename(sa) ! 210: struct sockaddr *sa; ! 211: { ! 212: register char *cp; ! 213: static char line[50]; ! 214: struct hostent *hp; ! 215: static char domain[MAXHOSTNAMELEN + 1]; ! 216: static int first = 1; ! 217: char *index(); ! 218: char *ns_print(); ! 219: ! 220: if (first) { ! 221: first = 0; ! 222: if (gethostname(domain, MAXHOSTNAMELEN) == 0 && ! 223: (cp = index(domain, '.'))) ! 224: (void) strcpy(domain, cp + 1); ! 225: else ! 226: domain[0] = 0; ! 227: } ! 228: switch (sa->sa_family) { ! 229: ! 230: case AF_INET: ! 231: { struct in_addr in; ! 232: in = ((struct sockaddr_in *)sa)->sin_addr; ! 233: ! 234: cp = 0; ! 235: if (in.s_addr == INADDR_ANY) ! 236: cp = "default"; ! 237: if (cp == 0 && !nflag) { ! 238: hp = gethostbyaddr(&in, sizeof (struct in_addr), ! 239: AF_INET); ! 240: if (hp) { ! 241: if ((cp = index(hp->h_name, '.')) && ! 242: !strcmp(cp + 1, domain)) ! 243: *cp = 0; ! 244: cp = hp->h_name; ! 245: } ! 246: } ! 247: if (cp) ! 248: strcpy(line, cp); ! 249: else { ! 250: #define C(x) ((x) & 0xff) ! 251: in.s_addr = ntohl(in.s_addr); ! 252: (void)sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), ! 253: C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr)); ! 254: } ! 255: break; ! 256: } ! 257: ! 258: case AF_NS: ! 259: return (ns_print((struct sockaddr_ns *)sa)); ! 260: ! 261: case AF_LINK: ! 262: return (link_ntoa((struct sockaddr_dl *)sa)); ! 263: ! 264: case AF_ISO: ! 265: (void) sprintf(line, "iso %s", ! 266: iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); ! 267: break; ! 268: ! 269: default: ! 270: { u_short *s = (u_short *)sa->sa_data; ! 271: u_short *slim = s + ((sa->sa_len + 1)>>1); ! 272: char *cp = line + sprintf(line, "(%d)", sa->sa_family); ! 273: int n; ! 274: ! 275: while (s < slim) { ! 276: n = sprintf(cp, " %x", *s); ! 277: s++; cp += n; ! 278: } ! 279: break; ! 280: } ! 281: } ! 282: return (line); ! 283: } ! 284: ! 285: /* ! 286: * Return the name of the network whose address is given. ! 287: * The address is assumed to be that of a net or subnet, not a host. ! 288: */ ! 289: char * ! 290: netname(sa) ! 291: struct sockaddr *sa; ! 292: { ! 293: char *cp = 0; ! 294: static char line[50]; ! 295: struct netent *np = 0; ! 296: u_long net, mask; ! 297: register u_long i; ! 298: int subnetshift; ! 299: char *ns_print(); ! 300: ! 301: switch (sa->sa_family) { ! 302: ! 303: case AF_INET: ! 304: { struct in_addr in; ! 305: in = ((struct sockaddr_in *)sa)->sin_addr; ! 306: ! 307: i = in.s_addr = ntohl(in.s_addr); ! 308: if (in.s_addr == 0) ! 309: cp = "default"; ! 310: else if (!nflag) { ! 311: if (IN_CLASSA(i)) { ! 312: mask = IN_CLASSA_NET; ! 313: subnetshift = 8; ! 314: } else if (IN_CLASSB(i)) { ! 315: mask = IN_CLASSB_NET; ! 316: subnetshift = 8; ! 317: } else { ! 318: mask = IN_CLASSC_NET; ! 319: subnetshift = 4; ! 320: } ! 321: /* ! 322: * If there are more bits than the standard mask ! 323: * would suggest, subnets must be in use. ! 324: * Guess at the subnet mask, assuming reasonable ! 325: * width subnet fields. ! 326: */ ! 327: while (in.s_addr &~ mask) ! 328: mask = (long)mask >> subnetshift; ! 329: net = in.s_addr & mask; ! 330: while ((mask & 1) == 0) ! 331: mask >>= 1, net >>= 1; ! 332: np = getnetbyaddr(net, AF_INET); ! 333: if (np) ! 334: cp = np->n_name; ! 335: } ! 336: if (cp) ! 337: strcpy(line, cp); ! 338: else if ((in.s_addr & 0xffffff) == 0) ! 339: (void)sprintf(line, "%u", C(in.s_addr >> 24)); ! 340: else if ((in.s_addr & 0xffff) == 0) ! 341: (void)sprintf(line, "%u.%u", C(in.s_addr >> 24), ! 342: C(in.s_addr >> 16)); ! 343: else if ((in.s_addr & 0xff) == 0) ! 344: (void)sprintf(line, "%u.%u.%u", C(in.s_addr >> 24), ! 345: C(in.s_addr >> 16), C(in.s_addr >> 8)); ! 346: else ! 347: (void)sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), ! 348: C(in.s_addr >> 16), C(in.s_addr >> 8), ! 349: C(in.s_addr)); ! 350: break; ! 351: } ! 352: ! 353: case AF_NS: ! 354: return (ns_print((struct sockaddr_ns *)sa)); ! 355: break; ! 356: ! 357: case AF_LINK: ! 358: return (link_ntoa((struct sockaddr_dl *)sa)); ! 359: ! 360: case AF_ISO: ! 361: (void) sprintf(line, "iso %s", ! 362: iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); ! 363: break; ! 364: ! 365: default: ! 366: { u_short *s = (u_short *)sa->sa_data; ! 367: u_short *slim = s + ((sa->sa_len + 1)>>1); ! 368: char *cp = line + sprintf(line, "af %d:", sa->sa_family); ! 369: int n; ! 370: ! 371: while (s < slim) { ! 372: n = sprintf(cp, " %x", *s); ! 373: s++; cp += n; ! 374: } ! 375: break; ! 376: } ! 377: } ! 378: return (line); ! 379: } ! 380: ! 381: set_metric(value, key) ! 382: char *value; ! 383: { ! 384: int flag = 0; ! 385: u_long noval, *valp = &noval; ! 386: ! 387: switch (key) { ! 388: #define caseof(x, y, z) case x: valp = &rt_metrics.z; flag = y; break ! 389: caseof(K_MTU, RTV_MTU, rmx_mtu); ! 390: caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount); ! 391: caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire); ! 392: caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe); ! 393: caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe); ! 394: caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh); ! 395: caseof(K_RTT, RTV_RTT, rmx_rtt); ! 396: caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar); ! 397: } ! 398: rtm_inits |= flag; ! 399: if (lockrest || locking) ! 400: rt_metrics.rmx_locks |= flag; ! 401: if (locking) ! 402: locking = 0; ! 403: *valp = atoi(value); ! 404: } ! 405: ! 406: newroute(argc, argv) ! 407: int argc; ! 408: register char **argv; ! 409: { ! 410: struct sockaddr_in *sin; ! 411: char *cmd, *dest, *gateway, *mask; ! 412: int ishost, metric = 0, ret, attempts, oerrno, flags = 0, next; ! 413: int key; ! 414: struct hostent *hp = 0; ! 415: extern int errno; ! 416: ! 417: shutdown(s, 0); /* Don't want to read back our messages */ ! 418: cmd = argv[0]; ! 419: while (--argc > 0) { ! 420: if (**(++argv)== '-') { ! 421: switch(key = keyword(1 + *argv)) { ! 422: case K_LINK: ! 423: af = AF_LINK; ! 424: aflen = sizeof(struct sockaddr_dl); ! 425: break; ! 426: case K_OSI: ! 427: case K_ISO: ! 428: af = AF_ISO; ! 429: aflen = sizeof(struct sockaddr_iso); ! 430: break; ! 431: case K_INET: ! 432: af = AF_INET; ! 433: aflen = sizeof(struct sockaddr_in); ! 434: break; ! 435: case K_XNS: ! 436: af = AF_NS; ! 437: aflen = sizeof(struct sockaddr_ns); ! 438: break; ! 439: case K_IFACE: ! 440: case K_INTERFACE: ! 441: iflag++; ! 442: break; ! 443: case K_LOCK: ! 444: locking = 1; ! 445: break; ! 446: case K_LOCKREST: ! 447: lockrest = 1; ! 448: break; ! 449: case K_HOST: ! 450: forcehost++; ! 451: break; ! 452: case K_NETMASK: ! 453: argc--; ! 454: (void) getaddr(RTA_NETMASK, *++argv, 0); ! 455: /* FALLTHROUGH */ ! 456: case K_NET: ! 457: forcenet++; ! 458: break; ! 459: case K_CLONING: ! 460: flags |= RTF_CLONING; ! 461: break; ! 462: case K_XRESOLVE: ! 463: flags |= RTF_XRESOLVE; ! 464: break; ! 465: case K_GENMASK: ! 466: argc--; ! 467: (void) getaddr(RTA_GENMASK, *++argv, 0); ! 468: break; ! 469: case K_MTU: ! 470: case K_HOPCOUNT: ! 471: case K_EXPIRE: ! 472: case K_RECVPIPE: ! 473: case K_SENDPIPE: ! 474: case K_SSTHRESH: ! 475: case K_RTT: ! 476: case K_RTTVAR: ! 477: argc--; ! 478: set_metric(*++argv, key); ! 479: break; ! 480: default: ! 481: usage(1+*argv); ! 482: } ! 483: } else { ! 484: if ((rtm_addrs & RTA_DST) == 0) { ! 485: dest = *argv; ! 486: ishost = getaddr(RTA_DST, *argv, &hp); ! 487: } else if ((rtm_addrs & RTA_GATEWAY) == 0) { ! 488: gateway = *argv; ! 489: (void) getaddr(RTA_GATEWAY, *argv, &hp); ! 490: } else { ! 491: int ret = atoi(*argv); ! 492: if (ret == 0) { ! 493: printf("%s,%s", "old usage of trailing 0", ! 494: "assuming route to if\n"); ! 495: iflag = 1; ! 496: continue; ! 497: } else if (ret > 0 && ret < 10) { ! 498: printf("old usage of trailing digit, "); ! 499: printf("assuming route via gateway\n"); ! 500: iflag = 0; ! 501: continue; ! 502: } ! 503: (void) getaddr(RTA_NETMASK, *argv, 0); ! 504: } ! 505: } ! 506: } ! 507: if (forcehost) ! 508: ishost = 1; ! 509: if (forcenet) ! 510: ishost = 0; ! 511: flags |= RTF_UP; ! 512: if (ishost) ! 513: flags |= RTF_HOST; ! 514: if (iflag == 0) ! 515: flags |= RTF_GATEWAY; ! 516: for (attempts = 1; ; attempts++) { ! 517: errno = 0; ! 518: if (Cflag && (af == AF_INET || af == AF_NS)) { ! 519: route.rt_flags = flags; ! 520: route.rt_dst = so_dst.sa; ! 521: route.rt_gateway = so_gate.sa; ! 522: if ((ret = ioctl(s, *cmd == 'a' ? SIOCADDRT : SIOCDELRT, ! 523: (caddr_t)&route)) == 0) ! 524: break; ! 525: } else { ! 526: if ((ret = rtmsg(*cmd, flags)) == 0); ! 527: break; ! 528: } ! 529: if (errno != ENETUNREACH && errno != ESRCH) ! 530: break; ! 531: if (hp && hp->h_addr_list[1]) { ! 532: hp->h_addr_list++; ! 533: bcopy(hp->h_addr_list[0], (caddr_t)&so_dst.sin.sin_addr, ! 534: hp->h_length); ! 535: } else ! 536: break; ! 537: } ! 538: oerrno = errno; ! 539: printf("%s %s %s: gateway %s", cmd, ishost? "host" : "net", ! 540: dest, gateway); ! 541: if (attempts > 1 && ret == 0) ! 542: printf(" (%s)", ! 543: inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr)); ! 544: if (ret == 0) ! 545: printf("\n"); ! 546: else { ! 547: printf(": "); ! 548: fflush(stdout); ! 549: errno = oerrno; ! 550: error(""); ! 551: } ! 552: exit(0); ! 553: } ! 554: ! 555: error(cmd) ! 556: char *cmd; ! 557: { ! 558: extern int errno; ! 559: ! 560: switch(errno) { ! 561: case ESRCH: ! 562: printf("not in table\n"); ! 563: break; ! 564: case EBUSY: ! 565: printf("entry in use\n"); ! 566: break; ! 567: case ENOBUFS: ! 568: printf("routing table overflow\n"); ! 569: break; ! 570: default: ! 571: printf("ioctl returns %d\n", errno); ! 572: perror(cmd); ! 573: } ! 574: fflush(stdout); ! 575: errno = 0; ! 576: } ! 577: ! 578: char * ! 579: savestr(s) ! 580: char *s; ! 581: { ! 582: char *sav; ! 583: ! 584: sav = malloc(strlen(s) + 1); ! 585: if (sav == NULL) { ! 586: fprintf("route: out of memory\n"); ! 587: exit(1); ! 588: } ! 589: strcpy(sav, s); ! 590: return (sav); ! 591: } ! 592: ! 593: inet_makenetandmask(net, sin) ! 594: u_long net; ! 595: register struct sockaddr_in *sin; ! 596: { ! 597: u_long addr; ! 598: u_long mask = 0; ! 599: register char *cp; ! 600: ! 601: rtm_addrs |= RTA_NETMASK; ! 602: if (net == 0) ! 603: mask = addr = 0; ! 604: else if (net < 128) { ! 605: addr = net << IN_CLASSA_NSHIFT; ! 606: mask = IN_CLASSA_NET; ! 607: } else if (net < 65536) { ! 608: addr = net << IN_CLASSB_NSHIFT; ! 609: mask = IN_CLASSB_NET; ! 610: } else if (net < 16777216L) { ! 611: addr = net << IN_CLASSC_NSHIFT; ! 612: mask = IN_CLASSC_NET; ! 613: } else { ! 614: addr = net; ! 615: if ((addr & IN_CLASSA_HOST) == 0) ! 616: mask = IN_CLASSA_NET; ! 617: else if ((addr & IN_CLASSB_HOST) == 0) ! 618: mask = IN_CLASSB_NET; ! 619: else if ((addr & IN_CLASSC_HOST) == 0) ! 620: mask = IN_CLASSC_NET; ! 621: else ! 622: mask = -1; ! 623: } ! 624: sin->sin_addr.s_addr = htonl(addr); ! 625: sin = &so_mask.sin; ! 626: sin->sin_addr.s_addr = htonl(mask); ! 627: sin->sin_len = 0; ! 628: sin->sin_family = 0; ! 629: cp = (char *)(1 + &(sin->sin_addr)); ! 630: while (*--cp == 0 && cp > (char *)sin) ! 631: ; ! 632: sin->sin_len = 1 + cp - (char *)sin; ! 633: } ! 634: ! 635: /* ! 636: * Interpret an argument as a network address of some kind, ! 637: * returning 1 if a host address, 0 if a network address. ! 638: */ ! 639: getaddr(which, s, hpp) ! 640: char *s; ! 641: struct hostent **hpp; ! 642: { ! 643: register union sockunion *su; ! 644: struct ns_addr ns_addr(); ! 645: struct iso_addr *iso_addr(); ! 646: struct hostent *hp; ! 647: struct netent *np; ! 648: u_long val; ! 649: ! 650: if (af == 0) { ! 651: af = AF_INET; ! 652: aflen = sizeof(struct sockaddr_in); ! 653: } ! 654: rtm_addrs |= which; ! 655: switch (which) { ! 656: case RTA_DST: su = so_addrs[0]; su->sa.sa_family = af; break; ! 657: case RTA_GATEWAY: su = so_addrs[1]; su->sa.sa_family = af; break; ! 658: case RTA_NETMASK: su = so_addrs[2]; break; ! 659: case RTA_GENMASK: su = so_addrs[3]; break; ! 660: default: usage("Internal Error"); /*NOTREACHED*/ ! 661: } ! 662: su->sa.sa_len = aflen; ! 663: if (strcmp(s, "default") == 0) { ! 664: switch (which) { ! 665: case RTA_DST: ! 666: forcenet++; ! 667: getaddr(RTA_NETMASK, s, 0); ! 668: break; ! 669: case RTA_NETMASK: ! 670: case RTA_GENMASK: ! 671: su->sa.sa_len = 0; ! 672: } ! 673: return 0; ! 674: } ! 675: if (af == AF_NS) ! 676: goto do_xns; ! 677: if (af == AF_OSI) ! 678: goto do_osi; ! 679: if (af == AF_LINK) ! 680: goto do_link; ! 681: if (hpp == 0) hpp = &hp; ! 682: *hpp = 0; ! 683: if (((val = inet_addr(s)) != -1) && ! 684: (which != RTA_DST || forcenet == 0)) { ! 685: su->sin.sin_addr.s_addr = val; ! 686: if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY) ! 687: return (1); ! 688: else { ! 689: val = ntohl(val); ! 690: out: if (which == RTA_DST) ! 691: inet_makenetandmask(val, &su->sin); ! 692: return (0); ! 693: } ! 694: } ! 695: val = inet_network(s); ! 696: if (val != -1) { ! 697: goto out; ! 698: } ! 699: np = getnetbyname(s); ! 700: if (np) { ! 701: val = np->n_net; ! 702: goto out; ! 703: } ! 704: hp = gethostbyname(s); ! 705: if (hp) { ! 706: *hpp = hp; ! 707: su->sin.sin_family = hp->h_addrtype; ! 708: bcopy(hp->h_addr, &su->sin.sin_addr, hp->h_length); ! 709: return (1); ! 710: } ! 711: fprintf(stderr, "%s: bad value\n", s); ! 712: exit(1); ! 713: do_xns: ! 714: if (val == 0) ! 715: return(0); ! 716: if (which == RTA_DST) { ! 717: extern short ns_bh[3]; ! 718: struct sockaddr_ns *sms = &(so_mask.sns); ! 719: bzero((char *)sms, sizeof(*sms)); ! 720: sms->sns_family = 0; ! 721: sms->sns_len = 6; ! 722: sms->sns_addr.x_net = *(union ns_net *)ns_bh; ! 723: rtm_addrs |= RTA_NETMASK; ! 724: } ! 725: su->sns.sns_addr = ns_addr(s); ! 726: return (!ns_nullhost(su->sns.sns_addr)); ! 727: do_osi: ! 728: su->siso.siso_addr = *iso_addr(s); ! 729: if (which == RTA_NETMASK || which == RTA_GENMASK) { ! 730: register char *cp = (char *)TSEL(&su->siso); ! 731: su->siso.siso_nlen = 0; ! 732: do {--cp ;} while ((cp > (char *)su) && (*cp == 0)); ! 733: su->siso.siso_len = 1 + cp - (char *)su; ! 734: } ! 735: return (1); ! 736: do_link: ! 737: link_addr(s, &su->sdl); ! 738: return (1); ! 739: } ! 740: ! 741: short ns_nullh[] = {0,0,0}; ! 742: short ns_bh[] = {-1,-1,-1}; ! 743: ! 744: char * ! 745: ns_print(sns) ! 746: struct sockaddr_ns *sns; ! 747: { ! 748: struct ns_addr work; ! 749: union { union ns_net net_e; u_long long_e; } net; ! 750: u_short port; ! 751: static char mybuf[50], cport[10], chost[25]; ! 752: char *host = ""; ! 753: register char *p; register u_char *q; u_char *q_lim; ! 754: ! 755: work = sns->sns_addr; ! 756: port = ntohs(work.x_port); ! 757: work.x_port = 0; ! 758: net.net_e = work.x_net; ! 759: if (ns_nullhost(work) && net.long_e == 0) { ! 760: if (port ) { ! 761: (void)sprintf(mybuf, "*.%xH", port); ! 762: upHex(mybuf); ! 763: } else ! 764: (void)sprintf(mybuf, "*.*"); ! 765: return (mybuf); ! 766: } ! 767: ! 768: if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) { ! 769: host = "any"; ! 770: } else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) { ! 771: host = "*"; ! 772: } else { ! 773: q = work.x_host.c_host; ! 774: (void)sprintf(chost, "%02x%02x%02x%02x%02x%02xH", ! 775: q[0], q[1], q[2], q[3], q[4], q[5]); ! 776: for (p = chost; *p == '0' && p < chost + 12; p++); ! 777: host = p; ! 778: } ! 779: if (port) ! 780: (void)sprintf(cport, ".%xH", htons(port)); ! 781: else ! 782: *cport = 0; ! 783: ! 784: (void)sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport); ! 785: upHex(mybuf); ! 786: return(mybuf); ! 787: } ! 788: ! 789: upHex(p0) ! 790: char *p0; ! 791: { ! 792: register char *p = p0; ! 793: for (; *p; p++) switch (*p) { ! 794: ! 795: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': ! 796: *p += ('A' - 'a'); ! 797: } ! 798: } ! 799: ! 800: monitor() ! 801: { ! 802: int n; ! 803: char msg[2048]; ! 804: verbose = 1; ! 805: for(;;) { ! 806: n = read(s, msg, 2048); ! 807: printf("got message of size %d\n", n); ! 808: print_rtmsg((struct rt_msghdr *)msg); ! 809: } ! 810: } ! 811: ! 812: struct { ! 813: struct rt_msghdr m_rtm; ! 814: char m_space[512]; ! 815: } m_rtmsg; ! 816: ! 817: rtmsg(cmd, flags) ! 818: { ! 819: static int seq; ! 820: int rlen; ! 821: extern int errno; ! 822: register char *cp = m_rtmsg.m_space; ! 823: register int l; ! 824: ! 825: errno = 0; ! 826: bzero((char *)&m_rtmsg, sizeof(m_rtmsg)); ! 827: if (cmd == 'a') ! 828: cmd = RTM_ADD; ! 829: else if (cmd == 'c') ! 830: cmd = RTM_CHANGE; ! 831: else ! 832: cmd = RTM_DELETE; ! 833: m_rtmsg.m_rtm.rtm_flags = flags; ! 834: m_rtmsg.m_rtm.rtm_version = RTM_VERSION; ! 835: m_rtmsg.m_rtm.rtm_seq = ++seq; ! 836: m_rtmsg.m_rtm.rtm_addrs = rtm_addrs; ! 837: m_rtmsg.m_rtm.rtm_rmx = rt_metrics; ! 838: m_rtmsg.m_rtm.rtm_inits = rtm_inits; ! 839: ! 840: #define ROUND(a) (1 + (((a) - 1) | (sizeof(long) - 1))) ! 841: #define NEXTADDR(w, u) { if (rtm_addrs & (w)) {l = (u).sa.sa_len;\ ! 842: if(verbose)sodump(&(u),"u");if(l == 0) l = sizeof(int); l = ROUND(l);\ ! 843: bcopy((char *)&(u), cp, l); cp += l;}} ! 844: ! 845: NEXTADDR(RTA_DST, so_dst); ! 846: NEXTADDR(RTA_GATEWAY, so_gate); ! 847: NEXTADDR(RTA_NETMASK, so_mask); ! 848: NEXTADDR(RTA_GENMASK, so_genmask); ! 849: m_rtmsg.m_rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; ! 850: m_rtmsg.m_rtm.rtm_type = cmd; ! 851: if (verbose) ! 852: print_rtmsg(&m_rtmsg.m_rtm, l); ! 853: if (debugonly) ! 854: return 0; ! 855: if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) { ! 856: perror("writing to routing socket"); ! 857: printf("got only %d for rlen\n", rlen); ! 858: return (-1); ! 859: } ! 860: return (0); ! 861: } ! 862: ! 863: char *msgtypes[] = { ! 864: "", ! 865: "RTM_ADD: Add Route", ! 866: "RTM_DELETE: Delete Route", ! 867: "RTM_CHANGE: Change Metrics or flags", ! 868: "RTM_GET: Report Metrics", ! 869: "RTM_LOSING: Kernel Suspects Partitioning", ! 870: "RTM_REDIRECT: Told to use different route", ! 871: "RTM_MISS: Lookup failed on this address", ! 872: "RTM_LOCK: fix specified metrics", ! 873: "RTM_OLDADD: caused by SIOCADDRT", ! 874: "RTM_OLDDEL: caused by SIOCDELRT", ! 875: 0, }; ! 876: ! 877: char metricnames[] = ! 878: "\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu"; ! 879: char routeflags[] = ! 880: "\1UP\2GATEWAY\3HOST\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE"; ! 881: ! 882: #define ROUNDUP(a) ((char *)(1 + (((((int)a)) - 1) | (sizeof(long) - 1)))) ! 883: ! 884: print_rtmsg(rtm, n) ! 885: register struct rt_msghdr *rtm; ! 886: { ! 887: char *cp; ! 888: register struct sockaddr *sa; ! 889: int i; ! 890: ! 891: if (verbose == 0) ! 892: return; ! 893: if (rtm->rtm_version != RTM_VERSION) { ! 894: printf("routing message version %d not understood\n", ! 895: rtm->rtm_version); ! 896: } else { ! 897: printf("%s\npid: %d, len %d, seq %d, errno %d, flags:", ! 898: msgtypes[rtm->rtm_type], rtm->rtm_pid, rtm->rtm_msglen, ! 899: rtm->rtm_seq, rtm->rtm_errno); ! 900: bprintf(stdout, rtm->rtm_flags, routeflags); ! 901: printf("\nlocks: "); bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames); ! 902: printf(" inits: "); bprintf(stdout, rtm->rtm_inits, metricnames); ! 903: printf("\nsockaddrs: "); ! 904: bprintf(stdout, rtm->rtm_addrs, ! 905: "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR"); ! 906: putchar('\n'); ! 907: cp = ((char *)(rtm + 1)); ! 908: if (rtm->rtm_addrs) ! 909: for (i = 1; i; i <<= 1) ! 910: if (i & rtm->rtm_addrs) { ! 911: sa = (struct sockaddr *)cp; ! 912: printf(" %s", routename(sa)); ! 913: cp = ROUNDUP(cp + sa->sa_len); ! 914: } ! 915: putchar('\n'); ! 916: } ! 917: fflush(stdout); ! 918: } ! 919: ! 920: bprintf(fp, b, s) ! 921: register FILE *fp; ! 922: register int b; ! 923: register u_char *s; ! 924: { ! 925: register int i; ! 926: int gotsome = 0; ! 927: ! 928: if (b == 0) ! 929: return; ! 930: while (i = *s++) { ! 931: if (b & (1 << (i-1))) { ! 932: if (gotsome == 0) i = '<'; else i = ','; ! 933: putc(i, fp); ! 934: gotsome = 1; ! 935: for (; (i = *s) > 32; s++) ! 936: putc(i, fp); ! 937: } else ! 938: while (*s > 32) ! 939: s++; ! 940: } ! 941: if (gotsome) ! 942: putc('>', fp); ! 943: } ! 944: int ! 945: keyword(cp) ! 946: char *cp; ! 947: { ! 948: register struct keytab *kt = keywords; ! 949: while (kt->kt_cp && strcmp(kt->kt_cp, cp)) ! 950: kt++; ! 951: return kt->kt_i; ! 952: } ! 953: ! 954: sodump(su, which) ! 955: register union sockunion *su; ! 956: char *which; ! 957: { ! 958: switch (su->sa.sa_family) { ! 959: case AF_LINK: ! 960: printf("%s: link %s; ", which, link_ntoa(&su->sdl)); ! 961: break; ! 962: case AF_ISO: ! 963: printf("%s: iso %s; ", which, iso_ntoa(&su->siso.siso_addr)); ! 964: break; ! 965: case AF_INET: ! 966: printf("%s: inet %s; ", which, inet_ntoa(su->sin.sin_addr)); ! 967: break; ! 968: case AF_NS: ! 969: printf("%s: xns %s; ", which, ns_ntoa(&su->sns.sns_addr)); ! 970: break; ! 971: } ! 972: fflush(stdout); ! 973: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.