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