![[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] / 43BSD / etc|
Return to route.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)route.c 5.6 (Berkeley) 6/5/86";
15: #endif not lint
16:
17: #include <sys/param.h>
18: #include <sys/socket.h>
19: #include <sys/ioctl.h>
20: #include <sys/mbuf.h>
21:
22: #include <net/route.h>
23: #include <netinet/in.h>
24: #include <netns/ns.h>
25:
26: #include <stdio.h>
27: #include <errno.h>
28: #include <ctype.h>
29: #include <netdb.h>
30:
31: struct rtentry route;
32: int s;
33: int forcehost, forcenet, doflush, nflag;
34: struct sockaddr_in sin = { AF_INET };
35: struct in_addr inet_makeaddr();
36: char *malloc();
37:
38: main(argc, argv)
39: int argc;
40: char *argv[];
41: {
42:
43: if (argc < 2)
44: printf("usage: route [ -n ] [ -f ] [ cmd [ net | host ] args ]\n"),
45: exit(1);
46: s = socket(AF_INET, SOCK_RAW, 0);
47: if (s < 0) {
48: perror("route: socket");
49: exit(1);
50: }
51: argc--, argv++;
52: for (; argc > 0 && argv[0][0] == '-'; argc--, argv++) {
53: for (argv[0]++; *argv[0]; argv[0]++)
54: switch (*argv[0]) {
55: case 'f':
56: doflush++;
57: break;
58: case 'n':
59: nflag++;
60: break;
61: }
62: }
63: if (doflush)
64: flushroutes();
65: if (argc > 0) {
66: if (strcmp(*argv, "add") == 0)
67: newroute(argc, argv);
68: else if (strcmp(*argv, "delete") == 0)
69: newroute(argc, argv);
70: else if (strcmp(*argv, "change") == 0)
71: changeroute(argc-1, argv+1);
72: else
73: printf("%s: huh?\n", *argv);
74: }
75: }
76:
77: /*
78: * Purge all entries in the routing tables not
79: * associated with network interfaces.
80: */
81: #include <nlist.h>
82:
83: struct nlist nl[] = {
84: #define N_RTHOST 0
85: { "_rthost" },
86: #define N_RTNET 1
87: { "_rtnet" },
88: #define N_RTHASHSIZE 2
89: { "_rthashsize" },
90: "",
91: };
92:
93: flushroutes()
94: {
95: struct mbuf mb;
96: register struct rtentry *rt;
97: register struct mbuf *m;
98: struct mbuf **routehash;
99: int rthashsize, i, doinghost = 1, kmem;
100: char *routename(), *netname();
101:
102: nlist("/vmunix", nl);
103: if (nl[N_RTHOST].n_value == 0) {
104: printf("route: \"rthost\", symbol not in namelist\n");
105: exit(1);
106: }
107: if (nl[N_RTNET].n_value == 0) {
108: printf("route: \"rtnet\", symbol not in namelist\n");
109: exit(1);
110: }
111: if (nl[N_RTHASHSIZE].n_value == 0) {
112: printf("route: \"rthashsize\", symbol not in namelist\n");
113: exit(1);
114: }
115: kmem = open("/dev/kmem", 0);
116: if (kmem < 0) {
117: perror("route: /dev/kmem");
118: exit(1);
119: }
120: lseek(kmem, nl[N_RTHASHSIZE].n_value, 0);
121: read(kmem, &rthashsize, sizeof (rthashsize));
122: routehash = (struct mbuf **)malloc(rthashsize*sizeof (struct mbuf *));
123:
124: lseek(kmem, nl[N_RTHOST].n_value, 0);
125: read(kmem, routehash, rthashsize*sizeof (struct mbuf *));
126: printf("Flushing routing tables:\n");
127: again:
128: for (i = 0; i < rthashsize; i++) {
129: if (routehash[i] == 0)
130: continue;
131: m = routehash[i];
132: while (m) {
133: lseek(kmem, m, 0);
134: read(kmem, &mb, sizeof (mb));
135: rt = mtod(&mb, struct rtentry *);
136: if (rt->rt_flags & RTF_GATEWAY) {
137: printf("%-20.20s ", doinghost ?
138: routename(&rt->rt_dst) :
139: netname(&rt->rt_dst));
140: printf("%-20.20s ", routename(&rt->rt_gateway));
141: if (ioctl(s, SIOCDELRT, (caddr_t)rt) < 0)
142: error("delete");
143: else
144: printf("done\n");
145: }
146: m = mb.m_next;
147: }
148: }
149: if (doinghost) {
150: lseek(kmem, nl[N_RTNET].n_value, 0);
151: read(kmem, routehash, rthashsize*sizeof (struct mbuf *));
152: doinghost = 0;
153: goto again;
154: }
155: close(kmem);
156: free(routehash);
157: }
158:
159: char *
160: routename(sa)
161: struct sockaddr *sa;
162: {
163: register char *cp;
164: static char line[50];
165: struct hostent *hp;
166: static char domain[MAXHOSTNAMELEN + 1];
167: static int first = 1;
168: char *index();
169: char *ns_print();
170:
171: if (first) {
172: first = 0;
173: if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
174: (cp = index(domain, '.')))
175: (void) strcpy(domain, cp + 1);
176: else
177: domain[0] = 0;
178: }
179: switch (sa->sa_family) {
180:
181: case AF_INET:
182: { struct in_addr in;
183: in = ((struct sockaddr_in *)sa)->sin_addr;
184:
185: cp = 0;
186: if (in.s_addr == INADDR_ANY)
187: cp = "default";
188: if (cp == 0 && !nflag) {
189: hp = gethostbyaddr(&in, sizeof (struct in_addr),
190: AF_INET);
191: if (hp) {
192: if ((cp = index(hp->h_name, '.')) &&
193: !strcmp(cp + 1, domain))
194: *cp = 0;
195: cp = hp->h_name;
196: }
197: }
198: if (cp)
199: strcpy(line, cp);
200: else {
201: #define C(x) ((x) & 0xff)
202: in.s_addr = ntohl(in.s_addr);
203: sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
204: C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
205: }
206: break;
207: }
208:
209: case AF_NS:
210: return (ns_print((struct sockaddr_ns *)sa));
211:
212: default:
213: { u_short *s = (u_short *)sa->sa_data;
214:
215: sprintf(line, "af %d: %x %x %x %x %x %x %x", sa->sa_family,
216: s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
217: break;
218: }
219: }
220: return (line);
221: }
222:
223: /*
224: * Return the name of the network whose address is given.
225: * The address is assumed to be that of a net or subnet, not a host.
226: */
227: char *
228: netname(sa)
229: struct sockaddr *sa;
230: {
231: char *cp = 0;
232: static char line[50];
233: struct netent *np = 0;
234: u_long net, mask;
235: register i;
236: int subnetshift;
237:
238: switch (sa->sa_family) {
239:
240: case AF_INET:
241: { struct in_addr in;
242: in = ((struct sockaddr_in *)sa)->sin_addr;
243:
244: in.s_addr = ntohl(in.s_addr);
245: if (in.s_addr == 0)
246: cp = "default";
247: else if (!nflag) {
248: if (IN_CLASSA(i)) {
249: mask = IN_CLASSA_NET;
250: subnetshift = 8;
251: } else if (IN_CLASSB(i)) {
252: mask = IN_CLASSB_NET;
253: subnetshift = 8;
254: } else {
255: mask = IN_CLASSC_NET;
256: subnetshift = 4;
257: }
258: /*
259: * If there are more bits than the standard mask
260: * would suggest, subnets must be in use.
261: * Guess at the subnet mask, assuming reasonable
262: * width subnet fields.
263: */
264: while (in.s_addr &~ mask)
265: mask = (long)mask >> subnetshift;
266: net = in.s_addr & mask;
267: while ((mask & 1) == 0)
268: mask >>= 1, net >>= 1;
269: np = getnetbyaddr(net, AF_INET);
270: if (np)
271: cp = np->n_name;
272: }
273: if (cp)
274: strcpy(line, cp);
275: else if ((in.s_addr & 0xffffff) == 0)
276: sprintf(line, "%u", C(in.s_addr >> 24));
277: else if ((in.s_addr & 0xffff) == 0)
278: sprintf(line, "%u.%u", C(in.s_addr >> 24),
279: C(in.s_addr >> 16));
280: else if ((in.s_addr & 0xff) == 0)
281: sprintf(line, "%u.%u.%u", C(in.s_addr >> 24),
282: C(in.s_addr >> 16), C(in.s_addr >> 8));
283: else
284: sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
285: C(in.s_addr >> 16), C(in.s_addr >> 8),
286: C(in.s_addr));
287: break;
288: }
289:
290: case AF_NS:
291: return (ns_print((struct sockaddr_ns *)sa));
292: break;
293:
294: default:
295: { u_short *s = (u_short *)sa->sa_data;
296:
297: sprintf(line, "af %d: %x %x %x %x %x %x %x", sa->sa_family,
298: s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
299: break;
300: }
301: }
302: return (line);
303: }
304:
305: newroute(argc, argv)
306: int argc;
307: char *argv[];
308: {
309: struct sockaddr_in *sin;
310: char *cmd, *dest, *gateway;
311: int ishost, metric = 0, ret, attempts, oerrno;
312: struct hostent *hp;
313: extern int errno;
314:
315: cmd = argv[0];
316: if ((strcmp(argv[1], "host")) == 0) {
317: forcehost++;
318: argc--, argv++;
319: } else if ((strcmp(argv[1], "net")) == 0) {
320: forcenet++;
321: argc--, argv++;
322: }
323: if (*cmd == 'a') {
324: if (argc != 4) {
325: printf("usage: %s destination gateway metric\n", cmd);
326: printf("(metric of 0 if gateway is this host)\n");
327: return;
328: }
329: metric = atoi(argv[3]);
330: } else {
331: if (argc < 3) {
332: printf("usage: %s destination gateway\n", cmd);
333: return;
334: }
335: }
336: sin = (struct sockaddr_in *)&route.rt_dst;
337: ishost = getaddr(argv[1], &route.rt_dst, &hp, &dest, forcenet);
338: if (forcehost)
339: ishost = 1;
340: if (forcenet)
341: ishost = 0;
342: sin = (struct sockaddr_in *)&route.rt_gateway;
343: (void) getaddr(argv[2], &route.rt_gateway, &hp, &gateway, 0);
344: route.rt_flags = RTF_UP;
345: if (ishost)
346: route.rt_flags |= RTF_HOST;
347: if (metric > 0)
348: route.rt_flags |= RTF_GATEWAY;
349: for (attempts = 1; ; attempts++) {
350: errno = 0;
351: if ((ret = ioctl(s, *cmd == 'a' ? SIOCADDRT : SIOCDELRT,
352: (caddr_t)&route)) == 0)
353: break;
354: if (errno != ENETUNREACH && errno != ESRCH)
355: break;
356: if (hp && hp->h_addr_list[1]) {
357: hp->h_addr_list++;
358: bcopy(hp->h_addr_list[0], (caddr_t)&sin->sin_addr,
359: hp->h_length);
360: } else
361: break;
362: }
363: oerrno = errno;
364: printf("%s %s %s: gateway %s", cmd, ishost? "host" : "net",
365: dest, gateway);
366: if (attempts > 1 && ret == 0)
367: printf(" (%s)",
368: inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr));
369: if (ret == 0)
370: printf("\n");
371: else {
372: printf(": ");
373: fflush(stdout);
374: errno = oerrno;
375: error(0);
376: }
377: }
378:
379: changeroute(argc, argv)
380: int argc;
381: char *argv[];
382: {
383: printf("not supported\n");
384: }
385:
386: error(cmd)
387: char *cmd;
388: {
389:
390: if (errno == ESRCH)
391: fprintf(stderr, "not in table\n");
392: else if (errno == EBUSY)
393: fprintf(stderr, "entry in use\n");
394: else if (errno == ENOBUFS)
395: fprintf(stderr, "routing table overflow\n");
396: else
397: perror(cmd);
398: }
399:
400: char *
401: savestr(s)
402: char *s;
403: {
404: char *sav;
405:
406: sav = malloc(strlen(s) + 1);
407: if (sav == NULL) {
408: fprintf("route: out of memory\n");
409: exit(1);
410: }
411: strcpy(sav, s);
412: return (sav);
413: }
414:
415: /*
416: * Interpret an argument as a network address of some kind,
417: * returning 1 if a host address, 0 if a network address.
418: */
419: getaddr(s, sin, hpp, name, isnet)
420: char *s;
421: struct sockaddr_in *sin;
422: struct hostent **hpp;
423: char **name;
424: int isnet;
425: {
426: struct hostent *hp;
427: struct netent *np;
428: u_long val;
429:
430: *hpp = 0;
431: if (strcmp(s, "default") == 0) {
432: sin->sin_family = AF_INET;
433: sin->sin_addr = inet_makeaddr(0, INADDR_ANY);
434: *name = "default";
435: return(0);
436: }
437: sin->sin_family = AF_INET;
438: if (isnet == 0) {
439: val = inet_addr(s);
440: if (val != -1) {
441: sin->sin_addr.s_addr = val;
442: *name = s;
443: return(inet_lnaof(sin->sin_addr) != INADDR_ANY);
444: }
445: }
446: val = inet_network(s);
447: if (val != -1) {
448: sin->sin_addr = inet_makeaddr(val, INADDR_ANY);
449: *name = s;
450: return(0);
451: }
452: np = getnetbyname(s);
453: if (np) {
454: sin->sin_family = np->n_addrtype;
455: sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
456: *name = savestr(np->n_name);
457: return(0);
458: }
459: hp = gethostbyname(s);
460: if (hp) {
461: *hpp = hp;
462: sin->sin_family = hp->h_addrtype;
463: bcopy(hp->h_addr, &sin->sin_addr, hp->h_length);
464: *name = savestr(hp->h_name);
465: return(1);
466: }
467: fprintf(stderr, "%s: bad value\n", s);
468: exit(1);
469: }
470:
471: short ns_nullh[] = {0,0,0};
472: short ns_bh[] = {-1,-1,-1};
473:
474: char *
475: ns_print(sns)
476: struct sockaddr_ns *sns;
477: {
478: struct ns_addr work;
479: union { union ns_net net_e; u_long long_e; } net;
480: u_short port;
481: static char mybuf[50], cport[10], chost[25];
482: char *host = "";
483: register char *p; register u_char *q; u_char *q_lim;
484:
485: work = sns->sns_addr;
486: port = ntohs(work.x_port);
487: work.x_port = 0;
488: net.net_e = work.x_net;
489: if (ns_nullhost(work) && net.long_e == 0) {
490: if (port ) {
491: sprintf(mybuf, "*.%xH", port);
492: upHex(mybuf);
493: } else
494: sprintf(mybuf, "*.*");
495: return (mybuf);
496: }
497:
498: if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) {
499: host = "any";
500: } else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
501: host = "*";
502: } else {
503: q = work.x_host.c_host;
504: sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
505: q[0], q[1], q[2], q[3], q[4], q[5]);
506: for (p = chost; *p == '0' && p < chost + 12; p++);
507: host = p;
508: }
509: if (port)
510: sprintf(cport, ".%xH", htons(port));
511: else
512: *cport = 0;
513:
514: sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
515: upHex(mybuf);
516: return(mybuf);
517: }
518:
519: upHex(p0)
520: char *p0;
521: {
522: register char *p = p0;
523: for (; *p; p++) switch (*p) {
524:
525: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
526: *p += ('A' - 'a');
527: }
528: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.