![[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 [Research Unix] / researchv10no / lbin / mailx|
Return to optim.c CVS log | Up to [Research Unix] / researchv10no / lbin / mailx |
1.1 ! root 1: #ident "@(#)optim.c 1.4 'attmail mail(1) command'" ! 2: #ident "@(#)mailx:optim.c 1.5.2.1" ! 3: /* Copyright (c) 1984 AT&T */ ! 4: /* All Rights Reserved */ ! 5: ! 6: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */ ! 7: /* The copyright notice above does not evidence any */ ! 8: /* actual or intended publication of such source code. */ ! 9: ! 10: #ident "@(#)mailx:optim.c 1.5" ! 11: ! 12: /* ! 13: * mailx -- a modified version of a University of California at Berkeley ! 14: * mail program ! 15: * ! 16: * Network name modification routines. ! 17: */ ! 18: ! 19: #include "rcv.h" ! 20: #include "configdefs.h" ! 21: ! 22: static char *arpafix(); ! 23: static char *lasthost(); ! 24: static char *makeremote(); ! 25: static int mstash(); ! 26: static int mtype(); ! 27: static int netlook(); ! 28: static int nettype(); ! 29: static int ntype(); ! 30: static char *revarpa(); ! 31: static char *tackon(); ! 32: static struct xtrahash *xlocate(); ! 33: static int yyinit(); ! 34: static int yylex(); ! 35: ! 36: /* ! 37: * Map a name into the correct network "view" of the ! 38: * name. This is done by prepending the name with the ! 39: * network address of the sender, then optimizing away ! 40: * nonsense. ! 41: */ ! 42: ! 43: char * ! 44: netmap(name, from) ! 45: char name[], from[]; ! 46: { ! 47: char nbuf[BUFSIZ], ret[BUFSIZ]; ! 48: register char *cp, *oname; ! 49: ! 50: if (debug) fprintf(stderr, "netmap(name '%s', from '%s')\n", name, from); ! 51: if (strlen(from) == 0) ! 52: return(name); ! 53: if (any('@', name) || any('%', name)) ! 54: return(arpafix(name, from)); ! 55: if (any('@', from) || any('%', from)) ! 56: return(unuucp(makeremote(name, from))); ! 57: if (value("onehop") && (cp = strchr(name, '!')) && cp > name) ! 58: strcpy(nbuf, name); ! 59: else { ! 60: from = tackon(host, from); ! 61: *strrchr(from, '!') = 0; ! 62: name = tackon(lasthost(from), name); ! 63: while (((cp = lasthost(from)) != 0) && ishost(cp, name)) { ! 64: oname = name; ! 65: name = strchr(name, '!') + 1; ! 66: if (cp == from) { ! 67: from[strlen(from)] = '!'; ! 68: if (value("mustbang") && !strchr(name, '!')) ! 69: name = oname; ! 70: return(unuucp(name)); ! 71: } ! 72: *--cp = 0; ! 73: } ! 74: from[strlen(from)] = '!'; ! 75: from = strchr(from, '!') + 1; ! 76: sprintf(nbuf, "%s!%s", from, name); ! 77: } ! 78: strcpy(ret, nbuf); ! 79: cp = revarpa(ret); ! 80: if (debug) fprintf(stderr, "wind up with '%s'\n", name); ! 81: if (!icequal(name, cp)) ! 82: return(unuucp(savestr(cp))); ! 83: return(unuucp(name)); ! 84: } ! 85: ! 86: /* ! 87: * Stick a host on the beginning of a uucp ! 88: * address if it isn't there already. ! 89: */ ! 90: static char * ! 91: tackon(sys, rest) ! 92: char *sys, *rest; ! 93: { ! 94: while (*rest == '!') ! 95: rest++; ! 96: if (!ishost(sys, rest)) { ! 97: char *r = salloc(strlen(sys) + strlen(rest) + 2); ! 98: sprintf(r, "%s!%s", sys, rest); ! 99: rest = r; ! 100: } ! 101: return rest; ! 102: } ! 103: ! 104: /* ! 105: * Check equality of the first host in a uucp address. ! 106: */ ! 107: ishost(sys, rest) ! 108: char *sys, *rest; ! 109: { ! 110: while (*sys && *sys == *rest) ! 111: sys++, rest++; ! 112: return(*sys == 0 && *rest == '!'); ! 113: } ! 114: ! 115: /* ! 116: * Return last host in a uucp address. ! 117: */ ! 118: static char * ! 119: lasthost(addr) ! 120: char *addr; ! 121: { ! 122: char *r = strrchr(addr, '!'); ! 123: return r ? ++r : addr; ! 124: } ! 125: ! 126: /* ! 127: * Optionally translate an old format uucp name into a new one, e.g. ! 128: * "mach1!mach2!user" becomes "[email protected]". This optional because ! 129: * some information is necessarily lost (e.g. the route it got here ! 130: * via) and if we don't have the host in our routing tables, we lose. ! 131: */ ! 132: char * ! 133: unuucp(name) ! 134: char *name; ! 135: { ! 136: register char *np, *hp, *cp; ! 137: char result[100]; ! 138: char tname[300]; ! 139: ! 140: if (UnUUCP==0 && ! 141: ((cp = value("conv"))==NOSTR || strcmp(cp, "internet"))) ! 142: return name; ! 143: if (debug) fprintf(stderr, "unuucp(%s)\n", name); ! 144: strcpy(tname, name); ! 145: np = strrchr(tname, '!'); ! 146: if (np == NOSTR) ! 147: return name; ! 148: *np++ = 0; ! 149: hp = strrchr(tname, '!'); ! 150: if (hp == NOSTR) ! 151: hp = tname; ! 152: else ! 153: *hp++ = 0; ! 154: cp = strchr(np, '@'); ! 155: if (cp == NOSTR) ! 156: cp = strchr(np, '%'); ! 157: if (cp) ! 158: *cp = 0; ! 159: if (debug) fprintf(stderr, "host %s, name %s\n", hp, np); ! 160: sprintf(result, "%s@%s.UUCP", np, hp); ! 161: if (debug) fprintf(stderr, "unuucp returns %s\n", result); ! 162: return savestr(result); ! 163: } ! 164: ! 165: /* ! 166: * Turn a network machine name into a unique character ! 167: */ ! 168: static int ! 169: netlook(machine, attnet) ! 170: char machine[]; ! 171: { ! 172: register struct netmach *np; ! 173: register char *cp, *cp2; ! 174: char nbuf[BUFSIZ]; ! 175: ! 176: /* ! 177: * Make into lower case. ! 178: */ ! 179: for (cp = machine, cp2 = nbuf; ! 180: *cp && cp2 < &nbuf[BUFSIZ-1]; ! 181: *cp2++ = tolower(*cp++)) ! 182: /*nothing*/; ! 183: *cp2 = 0; ! 184: ! 185: /* ! 186: * If a single letter machine, look through those first. ! 187: */ ! 188: ! 189: if (strlen(nbuf) == 1) ! 190: for (np = netmach; np->nt_mid != 0; np++) ! 191: if (np->nt_mid == nbuf[0]) ! 192: return(nbuf[0]); ! 193: ! 194: /* ! 195: * Look for usual name ! 196: */ ! 197: ! 198: for (np = netmach; np->nt_mid != 0; np++) ! 199: if (strcmp(np->nt_machine, nbuf) == 0) ! 200: return(np->nt_mid); ! 201: ! 202: /* ! 203: * Look in side hash table. ! 204: */ ! 205: ! 206: return(mstash(nbuf, attnet)); ! 207: } ! 208: ! 209: /* ! 210: * Deal with arpa net addresses. The way this is done is strange. ! 211: * In particular, if the destination arpa net host is not Berkeley, ! 212: * then the address is correct as stands. Otherwise, we strip off ! 213: * the trailing @Berkeley, then cook up a phony person for it to ! 214: * be from and optimize the result. ! 215: */ ! 216: static char * ! 217: arpafix(name, from) ! 218: char name[]; ! 219: char from[]; ! 220: { ! 221: register char *cp; ! 222: register int arpamach; ! 223: char newname[BUFSIZ]; ! 224: ! 225: if (debug) { ! 226: fprintf(stderr, "arpafix(%s, %s)\n", name, from); ! 227: } ! 228: cp = strrchr(name, '@'); ! 229: if (cp == NOSTR) ! 230: cp = strrchr(name, '%'); ! 231: if (cp == NOSTR) { ! 232: fprintf(stderr, "Somethings amiss -- no @ or %% in arpafix\n"); ! 233: return(name); ! 234: } ! 235: cp++; ! 236: arpamach = netlook(cp, '@'); ! 237: if (debug) fprintf(stderr, "cp '%s', arpamach %o, nettypes arpamach %o LOCAL %o\n", cp, arpamach, nettype(arpamach), nettype(LOCAL)); ! 238: if (arpamach == 0) { ! 239: if (debug) ! 240: fprintf(stderr, "machine %s unknown, uses: %s\n", cp, name); ! 241: return(name); ! 242: } ! 243: if (((nettype(arpamach) & nettype(LOCAL)) & ~AN) == 0) { ! 244: if (debug) ! 245: fprintf(stderr, "machine %s known but remote, uses: %s\n", ! 246: cp, name); ! 247: return(name); ! 248: } ! 249: strcpy(newname, name); ! 250: cp = strrchr(newname, '@'); ! 251: if (cp == NOSTR) ! 252: cp = strrchr(newname, '%'); ! 253: *cp = 0; ! 254: if (debug) fprintf(stderr, "local address, return '%s'\n", newname); ! 255: return(savestr(newname)); ! 256: } ! 257: ! 258: /* ! 259: * We have name with no @'s in it, and from with @'s. ! 260: * Assume that name is meaningful only on the site in from. ! 261: */ ! 262: static char * ! 263: makeremote(name, from) ! 264: char name[]; ! 265: char from[]; ! 266: { ! 267: register char *cp; ! 268: static char rbuf[200]; ! 269: ! 270: if (debug) fprintf(stderr, "makeremote(%s, %s) returns ", name, from); ! 271: strcpy(rbuf, name); ! 272: cp = strrchr(from, '@'); ! 273: if (cp == NOSTR) ! 274: cp = strrchr(from, '%'); ! 275: strcat(rbuf, cp); ! 276: if (debug) fprintf(stderr, "%s\n", rbuf); ! 277: return rbuf; ! 278: } ! 279: ! 280: /* ! 281: * Take a network machine descriptor and find the types of connected ! 282: * nets and return it. ! 283: */ ! 284: static int ! 285: nettype(mid) ! 286: { ! 287: register struct netmach *np; ! 288: ! 289: if (mid & 0200) ! 290: return(mtype(mid)); ! 291: for (np = netmach; np->nt_mid != 0; np++) ! 292: if (np->nt_mid == mid) ! 293: return(np->nt_type); ! 294: return(0); ! 295: } ! 296: ! 297: /* ! 298: * Hashing routines to salt away machines seen scanning ! 299: * networks paths that we don't know about. ! 300: */ ! 301: ! 302: #define XHSIZE 19 /* Size of extra hash table */ ! 303: #define NXMID (XHSIZE*3/4) /* Max extra machines */ ! 304: ! 305: struct xtrahash { ! 306: char *xh_name; /* Name of machine */ ! 307: short xh_mid; /* Machine ID */ ! 308: short xh_attnet; /* Attached networks */ ! 309: } xtrahash[XHSIZE]; ! 310: ! 311: static struct xtrahash *xtab[XHSIZE]; /* F: mid-->machine name */ ! 312: ! 313: static short midfree; /* Next free machine id */ ! 314: ! 315: /* ! 316: * Initialize the extra host hash table. ! 317: * Called by sreset. ! 318: */ ! 319: void ! 320: minit() ! 321: { ! 322: register struct xtrahash *xp, **tp; ! 323: ! 324: midfree = 0; ! 325: tp = &xtab[0]; ! 326: for (xp = &xtrahash[0]; xp < &xtrahash[XHSIZE]; xp++) { ! 327: xp->xh_name = NOSTR; ! 328: xp->xh_mid = 0; ! 329: xp->xh_attnet = 0; ! 330: *tp++ = (struct xtrahash *) 0; ! 331: } ! 332: } ! 333: ! 334: /* ! 335: * Stash a net name in the extra host hash table. ! 336: * If a new entry is put in the hash table, deduce what ! 337: * net the machine is attached to from the net character. ! 338: * ! 339: * If the machine is already known, add the given attached ! 340: * net to those already known. ! 341: */ ! 342: static int ! 343: mstash(name, attnet) ! 344: char name[]; ! 345: { ! 346: register struct xtrahash *xp; ! 347: int x; ! 348: ! 349: xp = xlocate(name); ! 350: if (xp == (struct xtrahash *) 0) { ! 351: printf("Ran out of machine id spots\n"); ! 352: return(0); ! 353: } ! 354: if (xp->xh_name == NOSTR) { ! 355: if (midfree >= XHSIZE) { ! 356: printf("Out of machine ids\n"); ! 357: return(0); ! 358: } ! 359: xtab[midfree] = xp; ! 360: xp->xh_name = savestr(name); ! 361: xp->xh_mid = 0200 + midfree++; ! 362: } ! 363: x = ntype(attnet); ! 364: if (x == 0) ! 365: xp->xh_attnet |= AN; ! 366: else ! 367: xp->xh_attnet |= x; ! 368: return(xp->xh_mid); ! 369: } ! 370: ! 371: /* ! 372: * Search for the given name in the hash table ! 373: * and return the pointer to it if found, or to the first ! 374: * empty slot if not found. ! 375: * ! 376: * If no free slots can be found, return 0. ! 377: */ ! 378: ! 379: static struct xtrahash * ! 380: xlocate(name) ! 381: char name[]; ! 382: { ! 383: register int h, q, i; ! 384: register char *cp; ! 385: register struct xtrahash *xp; ! 386: ! 387: for (h = 0, cp = name; *cp; h = (h << 2) + *cp++) ! 388: ; ! 389: if (h < 0 && (h = -h) < 0) ! 390: h = 0; ! 391: h = h % XHSIZE; ! 392: cp = name; ! 393: for (i = 0, q = 0; q < XHSIZE; i++, q = i * i) { ! 394: xp = &xtrahash[(h + q) % XHSIZE]; ! 395: if (xp->xh_name == NOSTR) ! 396: return(xp); ! 397: if (strcmp(cp, xp->xh_name) == 0) ! 398: return(xp); ! 399: if (h - q < 0) ! 400: q += XHSIZE; ! 401: xp = &xtrahash[(h - q) % XHSIZE]; ! 402: if (xp->xh_name == NOSTR) ! 403: return(xp); ! 404: if (strcmp(cp, xp->xh_name) == 0) ! 405: return(xp); ! 406: } ! 407: return((struct xtrahash *) 0); ! 408: } ! 409: ! 410: /* ! 411: * Return the bit mask of net's that the given extra host machine ! 412: * id has so far. ! 413: */ ! 414: static int ! 415: mtype(mid) ! 416: { ! 417: register int m; ! 418: ! 419: if ((mid & 0200) == 0) ! 420: return(0); ! 421: m = mid & 0177; ! 422: if (m >= midfree) { ! 423: printf("Use made of undefined machine id\n"); ! 424: return(0); ! 425: } ! 426: return(xtab[m]->xh_attnet); ! 427: } ! 428: ! 429: /* ! 430: * Return the network of the separator -- ! 431: * AN for arpa net ! 432: * BN for Bell labs net (e.g. UUCP, NOT Berknet) ! 433: * SN for Schmidt net (Berknet) ! 434: * 0 if we don't know. ! 435: */ ! 436: static int ! 437: ntype(nc) ! 438: register int nc; ! 439: { ! 440: register struct ntypetab *np; ! 441: ! 442: for (np = ntypetab; np->nt_char != 0; np++) ! 443: if (np->nt_char == nc) ! 444: return(np->nt_bcode); ! 445: return(0); ! 446: } ! 447: ! 448: ! 449: /* ! 450: * Code to twist around arpa net names. ! 451: */ ! 452: ! 453: #define WORD 257 /* Token for a string */ ! 454: ! 455: static char netbuf[256]; ! 456: static char *yylval; ! 457: ! 458: /* ! 459: * Reverse all of the arpa net addresses in the given name to ! 460: * be of the form "host @ user" instead of "user @ host" ! 461: * This function is its own inverse. ! 462: */ ! 463: ! 464: static char * ! 465: revarpa(str) ! 466: char str[]; ! 467: { ! 468: ! 469: if (yyinit(str) < 0) ! 470: return(NOSTR); ! 471: if (name()) ! 472: return(NOSTR); ! 473: if (strcmp(str, netbuf) == 0) ! 474: return(str); ! 475: return(savestr(netbuf)); ! 476: } ! 477: ! 478: /* ! 479: * Parse (by recursive descent) network names, using the following grammar: ! 480: * name: ! 481: * term {':' term} ! 482: * term {'^' term} ! 483: * term {'!' term} ! 484: * term '@' name ! 485: * term '%' name ! 486: * ! 487: * term: ! 488: * string of characters. ! 489: */ ! 490: ! 491: name() ! 492: { ! 493: register int t; ! 494: register char *cp; ! 495: ! 496: for (;;) { ! 497: t = yylex(); ! 498: if (t != WORD) ! 499: return(-1); ! 500: cp = yylval; ! 501: t = yylex(); ! 502: switch (t) { ! 503: case 0: ! 504: strcat(netbuf, cp); ! 505: return(0); ! 506: ! 507: case '@': ! 508: case '%': ! 509: if (name()) ! 510: return(-1); ! 511: strcat(netbuf, "@"); ! 512: strcat(netbuf, cp); ! 513: return(0); ! 514: ! 515: case WORD: ! 516: return(-1); ! 517: ! 518: default: ! 519: strcat(netbuf, cp); ! 520: stradd(netbuf, t); ! 521: } ! 522: } ! 523: } ! 524: ! 525: /* ! 526: * Scanner for network names. ! 527: */ ! 528: ! 529: static char *charp; /* Current input pointer */ ! 530: static int nexttok; /* Salted away next token */ ! 531: ! 532: /* ! 533: * Initialize the network name scanner. ! 534: */ ! 535: static int ! 536: yyinit(str) ! 537: char str[]; ! 538: { ! 539: static char lexbuf[BUFSIZ]; ! 540: ! 541: netbuf[0] = 0; ! 542: if (strlen(str) >= sizeof lexbuf - 1) ! 543: return(-1); ! 544: nexttok = 0; ! 545: strcpy(lexbuf, str); ! 546: charp = lexbuf; ! 547: return(0); ! 548: } ! 549: ! 550: /* ! 551: * Scan and return a single token. ! 552: * yylval is set to point to a scanned string. ! 553: */ ! 554: static int ! 555: yylex() ! 556: { ! 557: register char *cp, *dot; ! 558: register int s; ! 559: ! 560: if (nexttok) { ! 561: s = nexttok; ! 562: nexttok = 0; ! 563: return(s); ! 564: } ! 565: cp = charp; ! 566: while (*cp && isspace(*cp)) ! 567: cp++; ! 568: if (*cp == 0) ! 569: return(0); ! 570: if (any(*cp, metanet)) { ! 571: charp = cp+1; ! 572: return(*cp); ! 573: } ! 574: dot = cp; ! 575: while (*cp && !any(*cp, metanet) && !any(*cp, " \t")) ! 576: cp++; ! 577: if (any(*cp, metanet)) ! 578: nexttok = *cp; ! 579: if (*cp == 0) ! 580: charp = cp; ! 581: else ! 582: charp = cp+1; ! 583: *cp = 0; ! 584: yylval = dot; ! 585: return(WORD); ! 586: } ! 587: ! 588: /* ! 589: * Add a single character onto a string. ! 590: */ ! 591: ! 592: void ! 593: stradd(str, c) ! 594: register char *str; ! 595: register int c; ! 596: { ! 597: while (*str) ! 598: str++; ! 599: *str++ = (char)c; ! 600: *str = '\0'; ! 601: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.