![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to htable.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / htable|
Return to htable.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / htable |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: char copyright[] =
20: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
21: All rights reserved.\n";
22: #endif /* not lint */
23:
24: #ifndef lint
25: static char sccsid[] = "@(#)htable.c 5.8 (Berkeley) 6/18/88";
26: #endif /* not lint */
27:
28: /*
29: * htable - convert NIC host table into a UNIX format.
30: * NIC format is described in RFC 810, 1 March 1982.
31: */
32: #include <stdio.h>
33: #include <ctype.h>
34: #include <errno.h>
35: #include <netdb.h>
36:
37: #include "htable.h" /* includes <sys/types.h> */
38:
39: #include <sys/socket.h>
40: #include <arpa/inet.h>
41:
42: #define DATELINES 3 /* these lines usually contain the date */
43: #define MAXNETS 30 /* array size for local, connected nets */
44:
45: FILE *hf; /* hosts file */
46: FILE *gf; /* gateways file */
47: FILE *nf; /* networks file */
48: struct gateway *savegateway(), *gatewayto();
49:
50: int connected_nets[MAXNETS];
51: int nconnected;
52: int local_nets[MAXNETS];
53: int nlocal;
54: char *myname;
55:
56: main(argc, argv)
57: int argc;
58: char *argv[];
59: {
60: int errs;
61:
62: infile = "(stdin)";
63: myname = argv[0];
64: argc--;
65: argv++;
66: while (argc--) {
67: if (*argv[0] == '-') {
68: switch (argv[0][1]) {
69: case 'c':
70: nconnected = addlocal(argv[1], connected_nets);
71: argv++;
72: argc--;
73: break;
74: case 'l':
75: nlocal = addlocal(argv[1], local_nets);
76: argv++;
77: argc--;
78: break;
79: default:
80: usage();
81: /*NOTREACHED*/
82: }
83: } else {
84: infile = argv[0];
85: if (freopen(infile, "r", stdin) == NULL) {
86: perror(infile);
87: exit(1);
88: }
89: }
90: argv++;
91: }
92: hf = fopen("hosts", "w");
93: if (hf == NULL) {
94: perror("hosts");
95: exit(1);
96: }
97: copylocal(hf, "localhosts");
98: gf = fopen("gateways", "w");
99: if (gf == NULL) {
100: perror("gateways");
101: exit(1);
102: }
103: copygateways("localgateways");
104: nf = fopen("networks", "w");
105: if (nf == NULL) {
106: perror("networks");
107: exit(1);
108: }
109: copylocal(nf, "localnetworks");
110: copycomments(stdin, hf, DATELINES);
111: errs = yyparse();
112: dogateways();
113: exit(errs);
114: }
115:
116: usage()
117: {
118: fprintf(stderr,
119: "usage: %s [ -c connected-nets ] [-l local-nets ] [ input-file ]\n",
120: myname);
121: exit(1);
122: }
123:
124: /*
125: * Turn a comma-separated list of network names or numbers in dot notation
126: * (e.g. "arpanet, 128.32") into an array of net numbers.
127: */
128: addlocal(arg, nets)
129: char *arg;
130: int *nets;
131: {
132: register char *p, c;
133: register int nfound = 0;
134:
135: do {
136: p = arg;
137: while (*p && *p != ',' && !isspace(*p))
138: p++;
139: c = *p;
140: *p = 0;
141: while (*arg && isspace(*arg))
142: arg++;
143: if (*arg == 0)
144: continue;
145: if (nfound == MAXNETS) {
146: fprintf(stderr, "%s: Too many networks in list\n",
147: myname);
148: return (nfound);
149: }
150: if (getnetaddr(arg, &nets[nfound]))
151: nfound++;
152: else {
153: fprintf(stderr, "%s: %s: unknown network\n",
154: myname, arg);
155: exit(1);
156: }
157: arg = p + 1;
158: } while (c);
159: return (nfound);
160: }
161:
162: struct name *
163: newname(str)
164: char *str;
165: {
166: char *p;
167: struct name *nm;
168:
169: p = malloc(strlen(str) + 1);
170: strcpy(p, str);
171: nm = (struct name *)malloc(sizeof (struct name));
172: nm->name_val = p;
173: nm->name_link = NONAME;
174: return (nm);
175: }
176:
177: char *
178: lower(str)
179: char *str;
180: {
181: register char *cp = str;
182:
183: while (*cp) {
184: if (isupper(*cp))
185: *cp = tolower(*cp);
186: cp++;
187: }
188: return (str);
189: }
190:
191: do_entry(keyword, addrlist, namelist, cputype, opsys, protos)
192: int keyword;
193: struct addr *addrlist;
194: struct name *namelist, *cputype, *opsys, *protos;
195: {
196: register struct addr *al, *al2;
197: register struct name *nl;
198: struct addr *connect_addr;
199: char *cp;
200:
201: switch (keyword) {
202:
203: case KW_NET:
204: nl = namelist;
205: if (nl == NONAME) {
206: fprintf(stderr, "htable: net");
207: putnet(stderr, inet_netof(addrlist->addr_val));
208: fprintf(stderr, " missing names.\n");
209: break;
210: }
211: fprintf(nf, "%-16.16s", lower(nl->name_val));
212: al2 = addrlist;
213: while (al = al2) {
214: char *cp;
215:
216: putnet(nf, inet_netof(al->addr_val));
217: cp = "\t%s";
218: while (nl = nl->name_link) {
219: fprintf(nf, cp, lower(nl->name_val));
220: cp = " %s";
221: }
222: putc('\n', nf);
223: al2 = al->addr_link;
224: free((char *)al);
225: }
226: break;
227:
228: case KW_GATEWAY:
229: /* locate locally connected address, if one */
230: for (al = addrlist; al; al = al->addr_link)
231: if (connectedto(inet_netof(al->addr_val)))
232: break;
233: if (al == NULL) {
234: /*
235: * Not connected to known networks. Save for later.
236: */
237: struct gateway *gw, *firstgw = (struct gateway *) NULL;
238:
239: for (al = addrlist; al; al = al->addr_link) {
240: register int net;
241:
242: net = inet_netof(al->addr_val);
243: gw = savegateway(namelist, net,
244: al->addr_val, 0);
245: if (firstgw == (struct gateway *) NULL)
246: firstgw = gw;
247: gw->g_firstent = firstgw;
248: }
249: freeaddrs(addrlist);
250: goto dontfree;
251: }
252: /*
253: * Connected to a known network.
254: * Mark this as the gateway to all other networks
255: * that are on the addrlist (unless we already have
256: * gateways to them).
257: */
258: connect_addr = al;
259: for (al = addrlist; al; al = al->addr_link) {
260: register int net;
261:
262: /* suppress duplicates -- not optimal */
263: net = inet_netof(al->addr_val);
264: if (connectedto(net) || gatewayto(net))
265: continue;
266: printgateway(net, namelist->name_val, 1);
267: (void) savegateway(namelist, net, al->addr_val, 1);
268: }
269: /*
270: * Put the gateway in the hosts file.
271: */
272: putaddr(hf, connect_addr->addr_val);
273: cp = "%s";
274: for (nl = namelist; nl; nl = nl->name_link) {
275: fprintf(hf, cp, lower(nl->name_val));
276: cp = " %s";
277: }
278: fprintf(hf, "\t# gateway\n");
279: freeaddrs(addrlist);
280: goto dontfree;
281:
282: case KW_HOST:
283: al2 = addrlist;
284: while (al = al2) {
285: if (!local(inet_netof(al->addr_val))) {
286: char *cp;
287:
288: putaddr(hf, al->addr_val);
289: cp = "%s";
290: for (nl = namelist; nl; nl = nl->name_link) {
291: fprintf(hf, cp, lower(nl->name_val));
292: cp = " %s";
293: }
294: putc('\n', hf);
295: }
296: al2 = al->addr_link;
297: free((char *)al);
298: }
299: break;
300:
301: default:
302: fprintf(stderr, "Unknown keyword: %d.\n", keyword);
303: }
304: freenames(namelist);
305: dontfree:
306: freenames(protos);
307: }
308:
309: printgateway(net, name, metric)
310: int net;
311: char *name;
312: int metric;
313: {
314: struct netent *np;
315:
316: fprintf(gf, "net ");
317: np = getnetbyaddr(net, AF_INET);
318: if (np)
319: fprintf(gf, "%s", np->n_name);
320: else
321: putnet(gf, net);
322: fprintf(gf, " gateway %s metric %d passive\n",
323: lower(name), metric);
324: }
325:
326: copylocal(f, filename)
327: FILE *f;
328: char *filename;
329: {
330: register FILE *lhf;
331: register cc;
332: char buf[BUFSIZ];
333: extern int errno;
334:
335: lhf = fopen(filename, "r");
336: if (lhf == NULL) {
337: if (errno != ENOENT) {
338: perror(filename);
339: exit(1);
340: }
341: fprintf(stderr, "Warning, no %s file.\n", filename);
342: return;
343: }
344: while (cc = fread(buf, 1, sizeof(buf), lhf))
345: fwrite(buf, 1, cc, f);
346: fclose(lhf);
347: }
348:
349: copygateways(filename)
350: char *filename;
351: {
352: register FILE *lhf;
353: struct name *nl;
354: char type[80];
355: char dname[80];
356: char gname[80];
357: char junk[80];
358: char buf[500];
359: struct in_addr addr;
360: int net, metric;
361: extern int errno;
362:
363: lhf = fopen(filename, "r");
364: if (lhf == NULL) {
365: if (errno != ENOENT) {
366: perror(filename);
367: exit(1);
368: }
369: fprintf(stderr, "Warning, no %s file.\n", filename);
370: return;
371: }
372: /* format: {net | host} XX gateway XX metric DD [passive]\n */
373: for (;;) {
374: junk[0] = 0;
375: if (fgets(buf, sizeof(buf), lhf) == (char *)NULL)
376: break;
377: fputs(buf, gf);
378: if (buf[0] == '#' ||
379: sscanf(buf, "%s %s gateway %s metric %d %s",
380: type, dname, gname, &metric, junk) < 5)
381: continue;
382: if (strcmp(type, "net"))
383: continue;
384: if (!getnetaddr(dname, &net))
385: continue;
386: if (!gethostaddr(gname, &addr.s_addr))
387: continue;
388: nl = newname(gname);
389: (void) savegateway(nl, net, addr, metric);
390: }
391: fclose(lhf);
392: }
393:
394: getnetaddr(name, addr)
395: char *name;
396: int *addr;
397: {
398: struct netent *np = getnetbyname(name);
399:
400: if (np == 0) {
401: *addr = inet_network(name);
402: return (*addr != -1);
403: } else {
404: if (np->n_addrtype != AF_INET)
405: return (0);
406: *addr = np->n_net;
407: return (1);
408: }
409: }
410:
411: gethostaddr(name, addr)
412: char *name;
413: u_long *addr;
414: {
415: struct hostent *hp;
416:
417: hp = gethostbyname(name);
418: if (hp) {
419: *addr = *(u_long *)(hp->h_addr);
420: return (1);
421: }
422: *addr = inet_addr(name);
423: return (*addr != -1);
424: }
425:
426: copycomments(in, out, ccount)
427: FILE *in, *out;
428: int ccount;
429: {
430: int count;
431: char buf[BUFSIZ], *fgets();
432:
433: for (count=0; count < ccount; count++) {
434: if ((fgets(buf, sizeof(buf), in) == NULL) || (buf[0] != ';'))
435: return;
436: buf[0] = '#';
437: fputs(buf, out);
438: }
439: return;
440: }
441: #define UC(b) (((int)(b))&0xff)
442:
443: /*
444: * Print network number in internet-standard dot notation;
445: * v is in host byte order.
446: */
447: putnet(f, v)
448: FILE *f;
449: register int v;
450: {
451: if (v < 128)
452: fprintf(f, "%d", v);
453: else if (v < 65536)
454: fprintf(f, "%d.%d", UC(v >> 8), UC(v));
455: else
456: fprintf(f, "%d.%d.%d", UC(v >> 16), UC(v >> 8), UC(v));
457: }
458:
459: putaddr(f, v)
460: FILE *f;
461: struct in_addr v;
462: {
463: fprintf(f, "%-16.16s", inet_ntoa(v));
464: }
465:
466: freenames(list)
467: struct name *list;
468: {
469: register struct name *nl, *nl2;
470:
471: nl2 = list;
472: while (nl = nl2) {
473: nl2 = nl->name_link;
474: free(nl->name_val);
475: free((char *)nl);
476: }
477: }
478:
479: freeaddrs(list)
480: struct addr *list;
481: {
482: register struct addr *al, *al2;
483:
484: al2 = list;
485: while (al = al2)
486: al2 = al->addr_link, free((char *)al);
487: }
488:
489: struct gateway *gateways = 0;
490: struct gateway *lastgateway = 0;
491:
492: struct gateway *
493: gatewayto(net)
494: register int net;
495: {
496: register struct gateway *gp;
497:
498: for (gp = gateways; gp; gp = gp->g_link)
499: if ((gp->g_net == net) && (gp->g_metric > 0))
500: return (gp);
501: return ((struct gateway *) NULL);
502: }
503:
504: struct gateway *
505: savegateway(namelist, net, addr, metric)
506: struct name *namelist;
507: struct in_addr addr;
508: int net, metric;
509: {
510: register struct gateway *gp;
511:
512: gp = (struct gateway *)malloc(sizeof (struct gateway));
513: if (gp == 0) {
514: fprintf(stderr, "htable: out of memory\n");
515: exit(1);
516: }
517: gp->g_link = (struct gateway *) NULL;
518: if (lastgateway)
519: lastgateway->g_link = gp;
520: else
521: gateways = gp;
522: lastgateway = gp;
523: gp->g_name = namelist;
524: gp->g_net = net;
525: gp->g_addr = addr;
526: gp->g_metric = metric;
527: if (metric == 1)
528: gp->g_dst = gp;
529: return (gp);
530: }
531:
532: connectedto(net)
533: u_long net;
534: {
535: register i;
536:
537: for (i = 0; i < nconnected; i++)
538: if (connected_nets[i] == net)
539: return(1);
540: return(0);
541: }
542:
543: local(net)
544: u_long net;
545: {
546: register i;
547:
548: for (i = 0; i < nlocal; i++)
549: if (local_nets[i] == net)
550: return(1);
551: return(0);
552: }
553:
554: #define MAXHOPS 10
555:
556: /*
557: * Go through list of gateways, finding connections for gateways
558: * that are not yet connected.
559: */
560: dogateways()
561: {
562: register struct gateway *gp, *gw, *ggp;
563: register int hops, changed = 1;
564: struct name *nl;
565: char *cp;
566:
567: for (hops = 0; hops < MAXHOPS && changed; hops++, changed = 0) {
568: for (gp = gateways; gp; gp = gp->g_link)
569: if ((gp->g_metric == 0) && (gw = gatewayto(gp->g_net))) {
570: /*
571: * Found a new connection.
572: * For each other network that this gateway is on,
573: * add a new gateway to that network.
574: */
575: changed = 1;
576: gp->g_dst = gw->g_dst;
577: gp->g_metric = gw->g_metric + 1;
578: for (ggp = gp->g_firstent; ggp->g_name == gp->g_name;
579: ggp = ggp->g_link) {
580: if (ggp == gp)
581: continue;
582: if (gatewayto(ggp->g_net))
583: continue;
584: ggp->g_dst = gp->g_dst;
585: ggp->g_metric = gp->g_metric;
586: printgateway(ggp->g_net,
587: gw->g_dst->g_name->name_val, gp->g_metric);
588: }
589: /*
590: * Put the gateway in the hosts file,
591: * using the address for the connected net.
592: */
593: putaddr(hf, gp->g_addr);
594: cp = "%s";
595: for (nl = gp->g_name; nl; nl = nl->name_link) {
596: fprintf(hf, cp, lower(nl->name_val));
597: cp = " %s";
598: }
599: fprintf(hf, "\t# gateway\n");
600: }
601: }
602: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.