![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to routed.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / ipc / internet|
Return to routed.c CVS log | Up to [Research Unix] / researchv10dc / ipc / internet |
1.1 root 1: #include <sys/param.h>
2: #include <fio.h>
3: #include <signal.h>
4: #include <errno.h>
5: #include <sys/filio.h>
6: #include <sys/inet/in.h>
7: #include <sys/inet/ip_var.h>
8: #include <sys/inet/udp_user.h>
9: #include "config.h"
10:
11: #define IPDEVICE "/dev/ip16" /* device for getting ip info from */
12: #define RPORT 520
13:
14: int udpfd, ipfd, verbose, trace, quiet, traceinput, hopoffset;
15: extern errno;
16: extern int buf_ld;
17: extern char *in_ntoa();
18: extern u_short cksum();
19:
20: struct udppacket {
21: struct udpaddr addr;
22: char buf[4096];
23: };
24:
25: main(argc, argv)
26: char *argv[];
27: {
28: int n, i;
29: struct udppacket packet;
30: char *cp;
31:
32: for(i = 1; i < argc; i++){
33: if(argv[i][0] == '-'){
34: for(cp = argv[i]+1; *cp; cp++){
35: switch(*cp){
36: case 'v':
37: verbose++;
38: break;
39: case 'q':
40: quiet++;
41: break;
42: case 't':
43: trace++;
44: break;
45: case 'T':
46: traceinput++;
47: break;
48: default:
49: if((*cp >= '0' && *cp <= '9') || *cp == '-') {
50: hopoffset = atoi(cp);
51: while(*cp >= '0' && *cp <= '9')
52: cp++;
53: cp--;
54: } else {
55: fprint(2, "usage: routed [-qtvT#]\n"); exit(1);
56: }
57: break;
58: }
59: }
60: } else
61: recsafe(argv[i]);
62: }
63:
64: if(verbose || traceinput || trace) {
65: if(hopoffset)
66: fprint(2, "%s: adding %d to each metric\n", argv[0], hopoffset);
67: }
68:
69: if((udpfd = udp_datagram(RPORT)) < 0) {
70: perror("udp route daemon: no connection");
71: exit(1);
72: }
73:
74: /*
75: * try pushing bufld, complain but don't exit if unable
76: */
77: /*
78: if(ioctl(udpfd, FIOPUSHLD, &buf_ld)<0){
79: perror("pushing buf_ld");
80: }
81: if(ioctl(udpfd, FIOPUSHLD, &buf_ld)<0){
82: perror("pushing buf_ld");
83: }
84: if(ioctl(udpfd, FIOPUSHLD, &buf_ld)<0){
85: perror("pushing buf_ld");
86: }
87: */
88:
89: if((ipfd = open(IPDEVICE, 2)) < 0) {
90: perror(IPDEVICE);
91: exit(1);
92: }
93:
94: readgateways();
95: if(!(verbose || traceinput || trace)) {
96: detach("routed");
97: nice(-20);
98: }
99: timer();
100:
101: again:
102: while((n = read(udpfd, &packet, sizeof(struct udppacket))) > 0) {
103: routed(&packet, n - sizeof(struct udpaddr));
104: }
105: if(n < 0 && errno == EINTR)
106: goto again;
107: }
108:
109:
110: /* protocol.h 4.10 83/08/11 */
111: /*
112: * Routing Information Protocol
113: *
114: * Derived from Xerox NS Routing Information Protocol
115: * by changing 32-bit net numbers to sockaddr's and
116: * padding stuff to 32-bit boundaries.
117: */
118: #define RIPVERSION 1
119: #define AF_INET 2
120: #define AF_UNSPEC 0
121:
122: struct sockaddr{
123: short sin_family;
124: u_short sin_port;
125: u_long sin_addr;
126: char sin_zero[8];
127: };
128: struct netinfo {
129: struct sockaddr rip_dst; /* destination net/host */
130: int rip_metric; /* cost of route */
131: };
132:
133: struct rip {
134: u_char rip_cmd; /* request/response */
135: u_char rip_vers; /* protocol version # */
136: u_char rip_res1[2]; /* pad to 32-bit boundary */
137: union {
138: struct netinfo ru_nets[1]; /* variable length... */
139: char ru_tracefile[1]; /* ditto ... */
140: } ripun;
141: #define rip_nets ripun.ru_nets
142: #define rip_tracefile ripun.ru_tracefile
143: };
144:
145: /*
146: * Packet types.
147: */
148: #define RIPCMD_REQUEST 1 /* want info */
149: #define RIPCMD_RESPONSE 2 /* responding to request */
150: #define RIPCMD_TRACEON 3 /* turn tracing on */
151: #define RIPCMD_TRACEOFF 4 /* turn it off */
152:
153: #define RIPCMD_MAX 5
154: #ifdef RIPCMDS
155: char *ripcmds[RIPCMD_MAX] =
156: { "#0", "REQUEST", "RESPONSE", "TRACEON", "TRACEOFF" };
157: #endif
158:
159: #define HOPCNT_INFINITY 16 /* per Xerox NS */
160: #define MAXPACKETSIZE 488 /* max broadcast size */
161: #define MAXROUTESPERPACKET (MAXPACKETSIZE-4)/sizeof(struct netinfo)
162:
163: /*
164: * Timer values used in managing the routing table.
165: * Every update forces an entry's timer to be reset. After
166: * EXPIRE_TIME without updates, the entry is marked invalid,
167: * but held onto until GARBAGE_TIME so that others may
168: * see it "be deleted".
169: */
170: #define TIMER_RATE 60 /* interval in seconds over which we bcast to all
171: * directly connected interfaces */
172:
173: #define EXPIRE_TIME 180 /* time to mark entry invalid */
174: #define GARBAGE_TIME 240 /* time to garbage collect */
175:
176: #define NIFS TIMER_RATE
177: struct ipif ifs[NIFS];
178: int nextifs; /* next interface to broadcast to */
179: int nifs; /* number of functioning interfaces */
180:
181: routed(up, len)
182: struct udppacket *up;
183: u_int len;
184: {
185: struct rip *rip;
186:
187: if(traceinput)
188: logevent("from %s\n", in_ntoa(up->addr.host));
189: rip = (struct rip *)(up->buf);
190: if(rip->rip_vers != RIPVERSION)
191: return;
192: switch(rip->rip_cmd){
193: case RIPCMD_RESPONSE:
194: if(up->addr.port != RPORT)
195: logevent("routed: %s %d masquerading as routed\n",
196: in_host(up->addr.host), up->addr.port);
197: else
198: response(up, len);
199: break;
200: case RIPCMD_REQUEST:
201: request(up, len);
202: break;
203: default:
204: logevent("routed: %s %d sent strange command %d\n",
205: in_host(up->addr.host), up->addr.port, rip->rip_cmd);
206: return;
207: }
208: }
209:
210: /*
211: * don't believe responses from this host. no use infinitely
212: * recursing.
213: */
214: response(up, len)
215: struct udppacket *up;
216: u_int len;
217: {
218: struct rip *rip;
219: struct sockaddr *sin;
220: struct netinfo *np;
221:
222: rip = (struct rip *)(up->buf);
223: if(myaddr(up->addr.host))
224: return;
225: np = rip->rip_nets;
226: while(np < (struct netinfo *)(&(up->buf[len]))){
227: sin = &(np->rip_dst);
228: np->rip_metric = ntohl(np->rip_metric);
229: sin->sin_port = ntohs(sin->sin_port);
230: sin->sin_addr = ntohl(sin->sin_addr);
231: if(traceinput) {
232: logevent(" %s %d\n", in_ntoa(sin->sin_addr), np->rip_metric);
233: }
234: if (np->rip_metric > 0 && saferoute(sin->sin_addr) == 0)
235: rtinstall(sin->sin_addr, up->addr.host, np->rip_metric, 0, -1);
236: np++;
237: }
238: }
239:
240: /*
241: * Only accept requests for all routes or for internet routes.
242: * In all cases send back everything.
243: */
244: request(up, len)
245: struct udppacket *up;
246: u_int len;
247: {
248: struct rip *rip;
249: struct sockaddr *sin;
250: struct netinfo *np;
251:
252: rip = (struct rip *)(up->buf);
253: np = rip->rip_nets;
254: if(traceinput)
255: logevent("request from %s\n", in_ntoa(up->addr.host));
256:
257: sin = &(np->rip_dst);
258: np->rip_metric = ntohl(np->rip_metric);
259: sin->sin_family = ntohs(sin->sin_family);
260: if((sin->sin_family == AF_UNSPEC && np->rip_metric == HOPCNT_INFINITY)
261: || sin->sin_family == AF_INET)
262: send(up);
263: }
264:
265: struct route{
266: u_long dst;
267: u_long gate;
268: int metric;
269: int age;
270: int nif;
271: };
272: #define NROUTES 360
273: struct route routes[NROUTES];
274:
275: rtinstall(dst, gate, metric, age, nif)
276: u_long dst, gate;
277: {
278: struct route *rp, *save = 0;
279: char hname[128];
280:
281: /*
282: * don't let a default route get set unless we are quiet
283: */
284: if(dst==0 && !quiet)
285: return;
286:
287: /*
288: * ignore any route with inifinite hop counts
289: */
290: if(metric >= HOPCNT_INFINITY)
291: return;
292:
293: /*
294: * look up the route in our local tables (not the kernel's)
295: */
296: for(rp = routes; rp < &routes[NROUTES]; rp++){
297: if(rp->dst == dst)
298: break;
299: if(rp->dst == 0 && save == 0)
300: save = rp;
301: }
302: if(rp >= &routes[NROUTES] && (rp = save) == 0){
303: logevent("routed: out of routes?\n");
304: return;
305: }
306:
307: /*
308: * if this is a new route, make sure the new count is smaller
309: */
310: if(rp->dst == 0)
311: rp->metric = HOPCNT_INFINITY + 1;
312:
313: /*
314: * if new route is closer than the old route
315: * or the gate is the same but the distance has changed
316: * or the gate is the same but the age has changed,
317: * then use the new gate
318: */
319: if(metric < rp->metric
320: || (gate == rp->gate && metric != rp->metric)
321: || (gate == rp->gate && age != rp->age)){
322: rp->metric = metric;
323: rp->age = age;
324: if(rp->dst != dst || rp->gate != gate){
325: if(verbose){
326: strcpy(hname, in_host(gate));
327: logevent("%s installing as route to %s, metric %d\n",
328: hname, in_host(dst), metric);
329: }
330: rp->dst = dst;
331: rp->gate = gate;
332: rp->nif = nif;
333: if(ioctl(ipfd, IPIOROUTE, rp) < 0)
334: logevent("can't install routed %s\n", in_ntoa(rp->gate));
335: } else {
336: if(verbose > 1){
337: strcpy(hname, in_host(gate));
338: logevent("%s confirmed as route to %s, metric %d\n",
339: hname, in_host(dst), metric);
340: }
341: rp->dst = dst;
342: rp->gate = gate;
343: }
344: }
345: }
346:
347: /*
348: * keep a list of routes
349: * that belong to us;
350: * don't let anyone claim them
351: */
352:
353: #define NSAFE 20
354:
355: u_long safer[NSAFE];
356: int nsafe = 0;
357:
358: recsafe(s)
359: char *s;
360: {
361: if (nsafe < NSAFE)
362: safer[nsafe++] = in_address(s);
363: }
364:
365: saferoute(dst)
366: u_long dst;
367: {
368: register int i;
369:
370: for (i = 0; i < nsafe; i++)
371: if (dst == safer[i])
372: return (1);
373: return (0);
374: }
375:
376: readgateways()
377: {
378: int fd;
379: char *cp;
380: char net[32], gateway[32], which[32];
381: u_long dst, gate;
382: int metric;
383:
384: if((fd = open(GATEWAYS, 0)) == 0)
385: return;
386: Finit(fd, 0);
387: while(cp=Frdline(fd)){
388: if(sscanf(cp, "%s %s gateway %s metric %d",
389: which, net, gateway, &metric) != 4)
390: continue;
391: dst = in_address(net);
392: gate = in_address(gateway);
393: rtinstall(dst, gate, metric, -1, -1);
394: }
395: }
396:
397: timer()
398: {
399: int i;
400: struct route *rp;
401: struct ipif ipif;
402: u_long net;
403: char haddr1[32], haddr2[322];
404:
405: if(nextifs == 0){
406: /*
407: * get interfaces from kernel. ignore interfaces that are down,
408: * interfaces that are loop place holders (this==that), and the
409: * loop-back network
410: */
411: for(i = nifs = 0; nifs < NIFS; i++){
412: *(int *)&ipif = i;
413: if(ioctl(ipfd, IPIOGETIFS, &ipif) < 0)
414: break;
415: if((ipif.flags&IFF_UP) && ipif.thishost != ipif.that &&
416: ipif.that != 0x7f000000) {
417: if(ipif.bcast[0] == 0)
418: ipif.bcast[0] = ipif.that;
419: ifs[nifs++] = ipif;
420: if(trace){
421: strcpy(haddr1, in_ntoa(ipif.that));
422: strcpy(haddr2, in_ntoa(ipif.thishost));
423: logevent("ifs[%d] %s %s %s\n", nifs, haddr1,
424: haddr2, in_ntoa(ipif.bcast[0]));
425: }
426: rtinstall(ipif.that, ipif.that, 0, 0, nifs - 1);
427: }
428: }
429: }
430:
431: if(!quiet)
432: broadcast();
433:
434: /*
435: * age routes && get rid of too old routes
436: */
437: if(nextifs == 0)
438: for(rp = routes; rp < &routes[NROUTES]; rp++){
439: if(rp->dst == 0)
440: continue;
441: if(rp->age > 10){
442: rtdelete(rp);
443: } else if(rp->age >= 0){
444: rp->age++;
445: }
446: }
447:
448: /*
449: * post alarm for broadcast to next interface
450: */
451: signal(SIGALRM, timer);
452: i = nifs>0 ? TIMER_RATE/nifs : TIMER_RATE;
453: alarm(i+1);
454: }
455:
456: /*
457: * Send a broadcast to the next interface. This happens once every TIMER_RATE/nifs
458: * seconds so that n TIMER_RATE seconds we shoulc hit every interface.
459: */
460: broadcast()
461: {
462: static long last;
463: long now;
464: int reps;
465: struct udppacket p;
466:
467: /*
468: * broadcast to interfaces. approximate one broadcast every
469: * TIMER_RATE/nifs seconds.
470: */
471: now = time((long *)0);
472: reps = nifs ? (now-last)/(TIMER_RATE/nifs) : 0;
473: if(reps > nifs)
474: reps = nifs;
475: for(; reps>0; reps--){
476: if(++nextifs >= nifs)
477: nextifs = 0;
478:
479: p.addr.host = ifs[nextifs].bcast[0];
480: p.addr.port = RPORT;
481: send(&p);
482: }
483: last = now;
484: }
485:
486: /*
487: * put an entry into the bradcast message
488: */
489: struct netinfo *
490: insert(rp, up, np, rip)
491: struct udppacket *up;
492: struct route *rp;
493: struct netinfo *np;
494: struct rip *rip;
495: {
496: struct sockaddr *sin;
497: char haddr[32];
498:
499: /*
500: * don't send routes back onto the network from which they
501: * came
502: */
503: if((rp->gate & ifs[nextifs].mask) == ifs[nextifs].that)
504: return np;
505:
506: /*
507: * put the routing entry into the message.
508: */
509: bzero(np, sizeof(struct netinfo));
510: sin = &(np->rip_dst);
511: np->rip_metric = htonl(rp->metric + 1 + hopoffset);
512: sin->sin_port = 0;
513:
514: /*
515: * don't send information about one network's subnets to other networks
516: */
517: if(in_netof(rp->dst) == in_netof(ifs[nextifs].that))
518: sin->sin_addr = htonl(rp->dst);
519: else
520: sin->sin_addr = htonl(in_netof(rp->dst));
521:
522: sin->sin_family = htons((u_short)AF_INET);
523: if(trace){
524: strcpy(haddr, in_ntoa(ntohl(sin->sin_addr)));
525: logevent(" %s %s %d\n",
526: haddr,
527: in_ntoa(rp->dst),
528: ntohl(np->rip_metric));
529: }
530: np++;
531:
532: /*
533: * if the message is at maximum size, send it and start a new one
534: */
535: if (np-rip->rip_nets == MAXROUTESPERPACKET) {
536: psend(up, (char *)np);
537: np = rip->rip_nets;
538: }
539: return np;
540: }
541:
542: /*
543: * send info about all routes
544: */
545: send(up)
546: struct udppacket *up;
547: {
548: struct route *rp;
549: struct rip *rip;
550: struct netinfo *np;
551: long net;
552:
553: net = in_netof(ifs[nextifs].bcast[0]);
554: rip = (struct rip *)up->buf;
555: rip->rip_cmd = RIPCMD_RESPONSE;
556: rip->rip_vers = RIPVERSION;
557: np = rip->rip_nets;
558: if(trace)
559: logevent("BROADCAST:\n");
560:
561: /*
562: * first send info about directly connected networks
563: */
564: for(rp = routes; rp < &routes[NROUTES]; rp++){
565: if(rp->dst == 0 || rp->metric > 0)
566: continue;
567: if(rp->metric + hopoffset + 1 >= HOPCNT_INFINITY)
568: continue;
569: np = insert(rp, up, np, rip);
570: }
571:
572: /*
573: * now send info about the rest
574: */
575: for(rp = routes; rp < &routes[NROUTES]; rp++){
576: if(rp->dst==0 || rp->metric<=0)
577: continue;
578: if(rp->metric + hopoffset + 1 >= HOPCNT_INFINITY)
579: continue;
580: np = insert(rp, up, np, rip);
581: }
582: if (np > rip->rip_nets)
583: psend(up, (char *)np);
584: }
585:
586: /* send one routing packet to one network */
587: psend(pp, cp)
588: struct udppacket *pp;
589: char *cp;
590: {
591: int len=cp-(char *)pp;
592: int i;
593:
594: if(trace)
595: logevent("to %s %d\n", in_ntoa(pp->addr.host), len);
596: if (write(udpfd, pp, len) !=len)
597: logevent("udp write error\n");
598: }
599:
600: myaddr(x)
601: u_long x;
602: {
603: int i;
604:
605: for(i = 0; i < nifs; i ++)
606: if(ifs[i].thishost == x)
607: return(1);
608: return(0);
609: }
610:
611: rtdelete(rp)
612: struct route *rp;
613: {
614: if(verbose) {
615: logevent("deleting %s %d\n", in_ntoa(rp->dst), rp->metric);
616: }
617: if(rp->gate != rp->dst){
618: rp->gate = 0;
619: if(ioctl(ipfd, IPIOROUTE, rp) < 0)
620: logevent("can't remove route %s\n", in_ntoa(rp->gate));
621: }
622: rp->gate = rp->dst = 0;
623: rp->age = rp->metric = 0;
624: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.