![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / Mail|
Return to optim.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / Mail |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)optim.c 2.9 (Berkeley) 8/11/83";
3: #endif
4:
5: /*
6: * Mail -- a program for sending and receiving mail.
7: *
8: * Network name modification routines.
9: */
10:
11: #include "rcv.h"
12: #include "configdefs.h"
13: #include <ctype.h>
14:
15: /*
16: * Map a name into the correct network "view" of the
17: * name. This is done by prepending the name with the
18: * network address of the sender, then optimizing away
19: * nonsense.
20: */
21:
22: char *
23: netmap(name, from)
24: char name[], from[];
25: {
26: char nbuf[BUFSIZ], ret[BUFSIZ];
27: register char *cp;
28:
29: if (strlen(from) == 0)
30: return(name);
31: if (any('@', name) || any('%', name))
32: return(savestr(arpafix(name, from)));
33: cp = revarpa(from);
34: if (cp == NOSTR)
35: return(name);
36: strcpy(nbuf, cp);
37: cp = &nbuf[strlen(nbuf) - 1];
38: while (!any(*cp, metanet) && cp > nbuf)
39: cp--;
40: if (cp == nbuf)
41: return(name);
42: *++cp = 0;
43: strcat(nbuf, revarpa(name));
44: optim(nbuf, ret);
45: cp = revarpa(ret);
46: if (!icequal(name, cp))
47: return(savestr(cp));
48: return(name);
49: }
50:
51: /*
52: * Rename the given network path to use
53: * the kinds of names that we would right here.
54: */
55:
56: char *
57: rename(str)
58: char str[];
59: {
60: register char *cp, *cp2;
61: char buf[BUFSIZ], path[BUFSIZ];
62: register int c, host;
63:
64: strcpy(path, "");
65: for (;;) {
66: if ((c = *cp++) == 0)
67: break;
68: cp2 = buf;
69: while (!any(c, metanet) && c != 0) {
70: *cp2++ = c;
71: c = *cp++;
72: }
73: *cp2 = 0;
74: if (c == 0) {
75: strcat(path, buf);
76: break;
77: }
78: host = netlook(buf, ntype(c));
79: strcat(path, netname(host));
80: stradd(path, c);
81: }
82: if (strcmp(str, path) != 0)
83: return(savestr(path));
84: return(str);
85: }
86:
87: /*
88: * Turn a network machine name into a unique character
89: */
90: netlook(machine, attnet)
91: char machine[];
92: {
93: register struct netmach *np;
94: register char *cp, *cp2;
95: char nbuf[20];
96:
97: /*
98: * Make into lower case.
99: */
100:
101: for (cp = machine, cp2 = nbuf; *cp; *cp2++ = little(*cp++))
102: ;
103: *cp2 = 0;
104:
105: /*
106: * If a single letter machine, look through those first.
107: */
108:
109: if (strlen(nbuf) == 1)
110: for (np = netmach; np->nt_mid != 0; np++)
111: if (np->nt_mid == nbuf[0])
112: return(nbuf[0]);
113:
114: /*
115: * Look for usual name
116: */
117:
118: for (np = netmach; np->nt_mid != 0; np++)
119: if (strcmp(np->nt_machine, nbuf) == 0)
120: return(np->nt_mid);
121:
122: /*
123: * Look in side hash table.
124: */
125:
126: return(mstash(nbuf, attnet));
127: }
128:
129: /*
130: * Make a little character.
131: */
132:
133: little(c)
134: register int c;
135: {
136:
137: if (c >= 'A' && c <= 'Z')
138: c += 'a' - 'A';
139: return(c);
140: }
141:
142: /*
143: * Turn a network unique character identifier into a network name.
144: */
145:
146: char *
147: netname(mid)
148: {
149: register struct netmach *np;
150: char *mlook();
151:
152: if (mid & 0200)
153: return(mlook(mid));
154: for (np = netmach; np->nt_mid != 0; np++)
155: if (np->nt_mid == mid)
156: return(np->nt_machine);
157: return(NOSTR);
158: }
159:
160: /*
161: * Deal with arpa net addresses. The way this is done is strange.
162: * In particular, if the destination arpa net host is not Berkeley,
163: * then the address is correct as stands. Otherwise, we strip off
164: * the trailing @Berkeley, then cook up a phony person for it to
165: * be from and optimize the result.
166: */
167: char *
168: arpafix(name, from)
169: char name[];
170: char from[];
171: {
172: register char *cp;
173: register int arpamach;
174: char newname[BUFSIZ];
175: char fake[5];
176: char fakepath[20];
177:
178: if (debug) {
179: fprintf(stderr, "arpafix(%s, %s)\n", name, from);
180: }
181: cp = rindex(name, '@');
182: if (cp == NOSTR)
183: cp = rindex(name, '%');
184: if (cp == NOSTR) {
185: fprintf(stderr, "Somethings amiss -- no @ or % in arpafix\n");
186: return(name);
187: }
188: cp++;
189: arpamach = netlook(cp, '@');
190: if (arpamach == 0) {
191: if (debug)
192: fprintf(stderr, "machine %s unknown, uses: %s\n", cp, name);
193: return(name);
194: }
195: if (((nettype(arpamach) & nettype(LOCAL)) & ~AN) == 0) {
196: if (debug)
197: fprintf(stderr, "machine %s known but remote, uses: %s\n",
198: cp, name);
199: return(name);
200: }
201: strcpy(newname, name);
202: cp = rindex(newname, '@');
203: if (cp == NOSTR)
204: cp = rindex(newname, '%');
205: *cp = 0;
206: fake[0] = arpamach;
207: fake[1] = ':';
208: fake[2] = LOCAL;
209: fake[3] = ':';
210: fake[4] = 0;
211: prefer(fake);
212: strcpy(fakepath, netname(fake[0]));
213: stradd(fakepath, fake[1]);
214: strcat(fakepath, "daemon");
215: if (debug)
216: fprintf(stderr, "machine local, call netmap(%s, %s)\n",
217: newname, fakepath);
218: return(netmap(newname, fakepath));
219: }
220:
221: /*
222: * Take a network machine descriptor and find the types of connected
223: * nets and return it.
224: */
225:
226: nettype(mid)
227: {
228: register struct netmach *np;
229:
230: if (mid & 0200)
231: return(mtype(mid));
232: for (np = netmach; np->nt_mid != 0; np++)
233: if (np->nt_mid == mid)
234: return(np->nt_type);
235: return(0);
236: }
237:
238: /*
239: * Hashing routines to salt away machines seen scanning
240: * networks paths that we don't know about.
241: */
242:
243: #define XHSIZE 19 /* Size of extra hash table */
244: #define NXMID (XHSIZE*3/4) /* Max extra machines */
245:
246: struct xtrahash {
247: char *xh_name; /* Name of machine */
248: short xh_mid; /* Machine ID */
249: short xh_attnet; /* Attached networks */
250: } xtrahash[XHSIZE];
251:
252: struct xtrahash *xtab[XHSIZE]; /* F: mid-->machine name */
253:
254: short midfree; /* Next free machine id */
255:
256: /*
257: * Initialize the extra host hash table.
258: * Called by sreset.
259: */
260:
261: minit()
262: {
263: register struct xtrahash *xp, **tp;
264: register int i;
265:
266: midfree = 0;
267: tp = &xtab[0];
268: for (xp = &xtrahash[0]; xp < &xtrahash[XHSIZE]; xp++) {
269: xp->xh_name = NOSTR;
270: xp->xh_mid = 0;
271: xp->xh_attnet = 0;
272: *tp++ = (struct xtrahash *) 0;
273: }
274: }
275:
276: /*
277: * Stash a net name in the extra host hash table.
278: * If a new entry is put in the hash table, deduce what
279: * net the machine is attached to from the net character.
280: *
281: * If the machine is already known, add the given attached
282: * net to those already known.
283: */
284:
285: mstash(name, attnet)
286: char name[];
287: {
288: register struct xtrahash *xp;
289: struct xtrahash *xlocate();
290: int x;
291:
292: xp = xlocate(name);
293: if (xp == (struct xtrahash *) 0) {
294: printf("Ran out of machine id spots\n");
295: return(0);
296: }
297: if (xp->xh_name == NOSTR) {
298: if (midfree >= XHSIZE) {
299: printf("Out of machine ids\n");
300: return(0);
301: }
302: xtab[midfree] = xp;
303: xp->xh_name = savestr(name);
304: xp->xh_mid = 0200 + midfree++;
305: }
306: x = ntype(attnet);
307: if (x == 0)
308: xp->xh_attnet |= SN;
309: else
310: xp->xh_attnet |= x;
311: return(xp->xh_mid);
312: }
313:
314: /*
315: * Search for the given name in the hash table
316: * and return the pointer to it if found, or to the first
317: * empty slot if not found.
318: *
319: * If no free slots can be found, return 0.
320: */
321:
322: struct xtrahash *
323: xlocate(name)
324: char name[];
325: {
326: register int h, q, i;
327: register char *cp;
328: register struct xtrahash *xp;
329:
330: for (h = 0, cp = name; *cp; h = (h << 2) + *cp++)
331: ;
332: if (h < 0 && (h = -h) < 0)
333: h = 0;
334: h = h % XHSIZE;
335: cp = name;
336: for (i = 0, q = 0; q < XHSIZE; i++, q = i * i) {
337: xp = &xtrahash[(h + q) % XHSIZE];
338: if (xp->xh_name == NOSTR)
339: return(xp);
340: if (strcmp(cp, xp->xh_name) == 0)
341: return(xp);
342: if (h - q < 0)
343: q += XHSIZE;
344: xp = &xtrahash[(h - q) % XHSIZE];
345: if (xp->xh_name == NOSTR)
346: return(xp);
347: if (strcmp(cp, xp->xh_name) == 0)
348: return(xp);
349: }
350: return((struct xtrahash *) 0);
351: }
352:
353: /*
354: * Return the name from the extra host hash table corresponding
355: * to the passed machine id.
356: */
357:
358: char *
359: mlook(mid)
360: {
361: register int m;
362:
363: if ((mid & 0200) == 0)
364: return(NOSTR);
365: m = mid & 0177;
366: if (m >= midfree) {
367: printf("Use made of undefined machine id\n");
368: return(NOSTR);
369: }
370: return(xtab[m]->xh_name);
371: }
372:
373: /*
374: * Return the bit mask of net's that the given extra host machine
375: * id has so far.
376: */
377:
378: mtype(mid)
379: {
380: register int m;
381:
382: if ((mid & 0200) == 0)
383: return(0);
384: m = mid & 0177;
385: if (m >= midfree) {
386: printf("Use made of undefined machine id\n");
387: return(0);
388: }
389: return(xtab[m]->xh_attnet);
390: }
391:
392: /*
393: * Take a network name and optimize it. This gloriously messy
394: * operation takes place as follows: the name with machine names
395: * in it is tokenized by mapping each machine name into a single
396: * character machine id (netlook). The separator characters (network
397: * metacharacters) are left intact. The last component of the network
398: * name is stripped off and assumed to be the destination user name --
399: * it does not participate in the optimization. As an example, the
400: * name "research!vax135!research!ucbvax!bill" becomes, tokenized,
401: * "r!x!r!v!" and "bill" A low level routine, optim1, fixes up the
402: * network part (eg, "r!x!r!v!"), then we convert back to network
403: * machine names and tack the user name on the end.
404: *
405: * The result of this is copied into the parameter "name"
406: */
407:
408: optim(net, name)
409: char net[], name[];
410: {
411: char netcomp[BUFSIZ], netstr[40], xfstr[40];
412: register char *cp, *cp2;
413: register int c;
414:
415: strcpy(netstr, "");
416: cp = net;
417: for (;;) {
418: /*
419: * Rip off next path component into netcomp
420: */
421: cp2 = netcomp;
422: while (*cp && !any(*cp, metanet))
423: *cp2++ = *cp++;
424: *cp2 = 0;
425: /*
426: * If we hit null byte, then we just scanned
427: * the destination user name. Go off and optimize
428: * if its so.
429: */
430: if (*cp == 0)
431: break;
432: if ((c = netlook(netcomp, *cp)) == 0) {
433: printf("No host named \"%s\"\n", netcomp);
434: err:
435: strcpy(name, net);
436: return;
437: }
438: stradd(netstr, c);
439: stradd(netstr, *cp++);
440: /*
441: * If multiple network separators given,
442: * throw away the extras.
443: */
444: while (any(*cp, metanet))
445: cp++;
446: }
447: if (strlen(netcomp) == 0) {
448: printf("net name syntax\n");
449: goto err;
450: }
451: optim1(netstr, xfstr);
452:
453: /*
454: * Convert back to machine names.
455: */
456:
457: cp = xfstr;
458: strcpy(name, "");
459: while (*cp) {
460: if ((cp2 = netname(*cp++)) == NOSTR) {
461: printf("Made up bad net name\n");
462: printf("Machine code %c (0%o)\n", cp[-1], cp[-1]);
463: printf("Sorry -- dumping now. Alert K. Shoens\n");
464: core(0);
465: goto err;
466: }
467: strcat(name, cp2);
468: stradd(name, *cp++);
469: }
470: strcat(name, netcomp);
471: }
472:
473: /*
474: * Take a string of network machine id's and separators and
475: * optimize them. We process these by pulling off maximal
476: * leading strings of the same type, passing these to the appropriate
477: * optimizer and concatenating the results.
478: */
479:
480: optim1(netstr, name)
481: char netstr[], name[];
482: {
483: char path[40], rpath[40];
484: register char *cp, *cp2;
485: register int tp, nc;
486:
487: cp = netstr;
488: prefer(cp);
489: strcpy(name, "");
490: /*
491: * If the address ultimately points back to us,
492: * just return a null network path.
493: */
494: if (strlen(cp) > 1 && cp[strlen(cp) - 2] == LOCAL)
495: return;
496: while (*cp != 0) {
497: strcpy(path, "");
498: tp = ntype(cp[1]);
499: nc = cp[1];
500: while (*cp && tp == ntype(cp[1])) {
501: stradd(path, *cp++);
502: cp++;
503: }
504: switch (netkind(tp)) {
505: default:
506: strcpy(rpath, path);
507: break;
508:
509: case IMPLICIT:
510: optimimp(path, rpath);
511: break;
512:
513: case EXPLICIT:
514: optimex(path, rpath);
515: break;
516: }
517: for (cp2 = rpath; *cp2 != 0; cp2++) {
518: stradd(name, *cp2);
519: stradd(name, nc);
520: }
521: }
522: optiboth(name);
523: prefer(name);
524: }
525:
526: /*
527: * Return the network of the separator --
528: * AN for arpa net
529: * BN for Bell labs net
530: * SN for Schmidt (berkeley net)
531: * 0 if we don't know.
532: */
533:
534: ntype(nc)
535: register int nc;
536: {
537: register struct ntypetab *np;
538:
539: for (np = ntypetab; np->nt_char != 0; np++)
540: if (np->nt_char == nc)
541: return(np->nt_bcode);
542: return(0);
543: }
544:
545: /*
546: * Return the kind of routing used for the particular net
547: * EXPLICIT means explicitly routed
548: * IMPLICIT means implicitly routed
549: * 0 means don't know
550: */
551:
552: netkind(nt)
553: register int nt;
554: {
555: register struct nkindtab *np;
556:
557: for (np = nkindtab; np->nk_type != 0; np++)
558: if (np->nk_type == nt)
559: return(np->nk_kind);
560: return(0);
561: }
562:
563: /*
564: * Do name optimization for an explicitly routed network (eg BTL network).
565: */
566:
567: optimex(net, name)
568: char net[], name[];
569: {
570: register char *cp, *rp;
571: register int m;
572: char *rindex();
573:
574: strcpy(name, net);
575: cp = name;
576: if (strlen(cp) == 0)
577: return(-1);
578: if (cp[strlen(cp)-1] == LOCAL) {
579: name[0] = 0;
580: return(0);
581: }
582: for (cp = name; *cp; cp++) {
583: m = *cp;
584: rp = rindex(cp+1, m);
585: if (rp != NOSTR)
586: strcpy(cp, rp);
587: }
588: return(0);
589: }
590:
591: /*
592: * Do name optimization for implicitly routed network (eg, arpanet,
593: * Berkeley network)
594: */
595:
596: optimimp(net, name)
597: char net[], name[];
598: {
599: register char *cp;
600: register int m;
601:
602: cp = net;
603: if (strlen(cp) == 0)
604: return(-1);
605: m = cp[strlen(cp) - 1];
606: if (m == LOCAL) {
607: strcpy(name, "");
608: return(0);
609: }
610: name[0] = m;
611: name[1] = 0;
612: return(0);
613: }
614:
615: /*
616: * Perform global optimization on the given network path.
617: * The trick here is to look ahead to see if there are any loops
618: * in the path and remove them. The interpretation of loops is
619: * more strict here than in optimex since both the machine and net
620: * type must match.
621: */
622:
623: optiboth(net)
624: char net[];
625: {
626: register char *cp, *cp2;
627: char *rpair();
628:
629: cp = net;
630: if (strlen(cp) == 0)
631: return;
632: if ((strlen(cp) % 2) != 0) {
633: printf("Strange arg to optiboth\n");
634: return;
635: }
636: while (*cp) {
637: cp2 = rpair(cp+2, *cp);
638: if (cp2 != NOSTR)
639: strcpy(cp, cp2);
640: cp += 2;
641: }
642: }
643:
644: /*
645: * Find the rightmost instance of the given (machine, type) pair.
646: */
647:
648: char *
649: rpair(str, mach)
650: char str[];
651: {
652: register char *cp, *last;
653:
654: last = NOSTR;
655: while (*cp) {
656: if (*cp == mach)
657: last = cp;
658: cp += 2;
659: }
660: return(last);
661: }
662:
663: /*
664: * Change the network separators in the given network path
665: * to the preferred network transmission means.
666: */
667:
668: prefer(name)
669: char name[];
670: {
671: register char *cp;
672: register int state, n;
673:
674: state = LOCAL;
675: for (cp = name; *cp; cp += 2) {
676: n = best(state, *cp);
677: if (n)
678: cp[1] = n;
679: state = *cp;
680: }
681: }
682:
683: /*
684: * Return the best network separator for the given machine pair.
685: */
686:
687: best(src, dest)
688: {
689: register int dtype, stype;
690: register struct netorder *np;
691:
692: stype = nettype(src);
693: dtype = nettype(dest);
694: fflush(stdout);
695: if (stype == 0 || dtype == 0) {
696: printf("ERROR: unknown internal machine id\n");
697: return(0);
698: }
699: if ((stype & dtype) == 0)
700: return(0);
701: np = &netorder[0];
702: while ((np->no_stat & stype & dtype) == 0)
703: np++;
704: return(np->no_char);
705: }
706:
707: #ifdef GETHOST
708: /*
709: * Initialize the network name of the current host.
710: */
711: inithost()
712: {
713: register struct netmach *np;
714: static char host[64];
715:
716: gethostname(host, sizeof host);
717: for (np = netmach; np->nt_machine != 0; np++)
718: if (strcmp(np->nt_machine, EMPTY) == 0)
719: break;
720: if (np->nt_machine == 0) {
721: printf("Cannot find empty slot for dynamic host entry\n");
722: exit(1);
723: }
724: np->nt_machine = host;
725: }
726: #endif GETHOST
727:
728: /*
729: * Code to twist around arpa net names.
730: */
731:
732: #define WORD 257 /* Token for a string */
733:
734: static char netbuf[256];
735: static char *yylval;
736:
737: /*
738: * Reverse all of the arpa net addresses in the given name to
739: * be of the form "host @ user" instead of "user @ host"
740: * This function is its own inverse.
741: */
742:
743: char *
744: revarpa(str)
745: char str[];
746: {
747:
748: if (yyinit(str) < 0)
749: return(NOSTR);
750: if (name())
751: return(NOSTR);
752: if (strcmp(str, netbuf) == 0)
753: return(str);
754: return(savestr(netbuf));
755: }
756:
757: /*
758: * Parse (by recursive descent) network names, using the following grammar:
759: * name:
760: * term {':' term}
761: * term {'^' term}
762: * term {'!' term}
763: * term '@' name
764: * term '%' name
765: *
766: * term:
767: * string of characters.
768: */
769:
770: name()
771: {
772: register int t;
773: register char *cp;
774:
775: for (;;) {
776: t = yylex();
777: if (t != WORD)
778: return(-1);
779: cp = yylval;
780: t = yylex();
781: switch (t) {
782: case 0:
783: strcat(netbuf, cp);
784: return(0);
785:
786: case '@':
787: case '%':
788: if (name())
789: return(-1);
790: stradd(netbuf, '@');
791: strcat(netbuf, cp);
792: return(0);
793:
794: case WORD:
795: return(-1);
796:
797: default:
798: strcat(netbuf, cp);
799: stradd(netbuf, t);
800: }
801: }
802: }
803:
804: /*
805: * Scanner for network names.
806: */
807:
808: static char *charp; /* Current input pointer */
809: static int nexttok; /* Salted away next token */
810:
811: /*
812: * Initialize the network name scanner.
813: */
814:
815: yyinit(str)
816: char str[];
817: {
818: static char lexbuf[BUFSIZ];
819:
820: netbuf[0] = 0;
821: if (strlen(str) >= sizeof lexbuf - 1)
822: return(-1);
823: nexttok = 0;
824: strcpy(lexbuf, str);
825: charp = lexbuf;
826: return(0);
827: }
828:
829: /*
830: * Scan and return a single token.
831: * yylval is set to point to a scanned string.
832: */
833:
834: yylex()
835: {
836: register char *cp, *dot;
837: register int s;
838:
839: if (nexttok) {
840: s = nexttok;
841: nexttok = 0;
842: return(s);
843: }
844: cp = charp;
845: while (*cp && isspace(*cp))
846: cp++;
847: if (*cp == 0)
848: return(0);
849: if (any(*cp, metanet)) {
850: charp = cp+1;
851: return(*cp);
852: }
853: dot = cp;
854: while (*cp && !any(*cp, metanet) && !any(*cp, " \t"))
855: cp++;
856: if (any(*cp, metanet))
857: nexttok = *cp;
858: if (*cp == 0)
859: charp = cp;
860: else
861: charp = cp+1;
862: *cp = 0;
863: yylval = dot;
864: return(WORD);
865: }
866:
867: /*
868: * Add a single character onto a string.
869: */
870:
871: stradd(str, c)
872: register char *str;
873: register int c;
874: {
875:
876: str += strlen(str);
877: *str++ = c;
878: *str = 0;
879: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.