![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parseaddr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src|
Return to parseaddr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src |
1.1 ! root 1: /* ! 2: ** Sendmail ! 3: ** Copyright (c) 1983 Eric P. Allman ! 4: ** Berkeley, California ! 5: ** ! 6: ** Copyright (c) 1983 Regents of the University of California. ! 7: ** All rights reserved. The Berkeley software License Agreement ! 8: ** specifies the terms and conditions for redistribution. ! 9: */ ! 10: ! 11: #ifndef lint ! 12: static char SccsId[] = "@(#)parseaddr.c 5.6 (Berkeley) 4/2/86"; ! 13: #endif not lint ! 14: ! 15: # include "sendmail.h" ! 16: ! 17: /* ! 18: ** PARSEADDR -- Parse an address ! 19: ** ! 20: ** Parses an address and breaks it up into three parts: a ! 21: ** net to transmit the message on, the host to transmit it ! 22: ** to, and a user on that host. These are loaded into an ! 23: ** ADDRESS header with the values squirreled away if necessary. ! 24: ** The "user" part may not be a real user; the process may ! 25: ** just reoccur on that machine. For example, on a machine ! 26: ** with an arpanet connection, the address ! 27: ** csvax.bill@berkeley ! 28: ** will break up to a "user" of 'csvax.bill' and a host ! 29: ** of 'berkeley' -- to be transmitted over the arpanet. ! 30: ** ! 31: ** Parameters: ! 32: ** addr -- the address to parse. ! 33: ** a -- a pointer to the address descriptor buffer. ! 34: ** If NULL, a header will be created. ! 35: ** copyf -- determines what shall be copied: ! 36: ** -1 -- don't copy anything. The printname ! 37: ** (q_paddr) is just addr, and the ! 38: ** user & host are allocated internally ! 39: ** to parse. ! 40: ** 0 -- copy out the parsed user & host, but ! 41: ** don't copy the printname. ! 42: ** +1 -- copy everything. ! 43: ** delim -- the character to terminate the address, passed ! 44: ** to prescan. ! 45: ** ! 46: ** Returns: ! 47: ** A pointer to the address descriptor header (`a' if ! 48: ** `a' is non-NULL). ! 49: ** NULL on error. ! 50: ** ! 51: ** Side Effects: ! 52: ** none ! 53: */ ! 54: ! 55: /* following delimiters are inherent to the internal algorithms */ ! 56: # define DELIMCHARS "\001()<>,;\\\"\r\n" /* word delimiters */ ! 57: ! 58: ADDRESS * ! 59: parseaddr(addr, a, copyf, delim) ! 60: char *addr; ! 61: register ADDRESS *a; ! 62: int copyf; ! 63: char delim; ! 64: { ! 65: register char **pvp; ! 66: register struct mailer *m; ! 67: char pvpbuf[PSBUFSIZE]; ! 68: extern char **prescan(); ! 69: extern ADDRESS *buildaddr(); ! 70: ! 71: /* ! 72: ** Initialize and prescan address. ! 73: */ ! 74: ! 75: CurEnv->e_to = addr; ! 76: # ifdef DEBUG ! 77: if (tTd(20, 1)) ! 78: printf("\n--parseaddr(%s)\n", addr); ! 79: # endif DEBUG ! 80: ! 81: pvp = prescan(addr, delim, pvpbuf); ! 82: if (pvp == NULL) ! 83: return (NULL); ! 84: ! 85: /* ! 86: ** Apply rewriting rules. ! 87: ** Ruleset 0 does basic parsing. It must resolve. ! 88: */ ! 89: ! 90: rewrite(pvp, 3); ! 91: rewrite(pvp, 0); ! 92: ! 93: /* ! 94: ** See if we resolved to a real mailer. ! 95: */ ! 96: ! 97: if (pvp[0][0] != CANONNET) ! 98: { ! 99: setstat(EX_USAGE); ! 100: usrerr("cannot resolve name"); ! 101: return (NULL); ! 102: } ! 103: ! 104: /* ! 105: ** Build canonical address from pvp. ! 106: */ ! 107: ! 108: a = buildaddr(pvp, a); ! 109: if (a == NULL) ! 110: return (NULL); ! 111: m = a->q_mailer; ! 112: ! 113: /* ! 114: ** Make local copies of the host & user and then ! 115: ** transport them out. ! 116: */ ! 117: ! 118: if (copyf > 0) ! 119: { ! 120: extern char *DelimChar; ! 121: char savec = *DelimChar; ! 122: ! 123: *DelimChar = '\0'; ! 124: a->q_paddr = newstr(addr); ! 125: *DelimChar = savec; ! 126: } ! 127: else ! 128: a->q_paddr = addr; ! 129: ! 130: if (a->q_user == NULL) ! 131: a->q_user = ""; ! 132: if (a->q_host == NULL) ! 133: a->q_host = ""; ! 134: ! 135: if (copyf >= 0) ! 136: { ! 137: a->q_host = newstr(a->q_host); ! 138: if (a->q_user != a->q_paddr) ! 139: a->q_user = newstr(a->q_user); ! 140: } ! 141: ! 142: /* ! 143: ** Convert host name to lower case if requested. ! 144: ** User name will be done later. ! 145: */ ! 146: ! 147: if (!bitnset(M_HST_UPPER, m->m_flags)) ! 148: makelower(a->q_host); ! 149: ! 150: /* ! 151: ** Compute return value. ! 152: */ ! 153: ! 154: # ifdef DEBUG ! 155: if (tTd(20, 1)) ! 156: { ! 157: printf("parseaddr-->"); ! 158: printaddr(a, FALSE); ! 159: } ! 160: # endif DEBUG ! 161: ! 162: return (a); ! 163: } ! 164: /* ! 165: ** LOWERADDR -- map UPPER->lower case on addresses as requested. ! 166: ** ! 167: ** Parameters: ! 168: ** a -- address to be mapped. ! 169: ** ! 170: ** Returns: ! 171: ** none. ! 172: ** ! 173: ** Side Effects: ! 174: ** none. ! 175: */ ! 176: ! 177: loweraddr(a) ! 178: register ADDRESS *a; ! 179: { ! 180: register MAILER *m = a->q_mailer; ! 181: ! 182: if (!bitnset(M_USR_UPPER, m->m_flags)) ! 183: makelower(a->q_user); ! 184: } ! 185: /* ! 186: ** PRESCAN -- Prescan name and make it canonical ! 187: ** ! 188: ** Scans a name and turns it into a set of tokens. This process ! 189: ** deletes blanks and comments (in parentheses). ! 190: ** ! 191: ** This routine knows about quoted strings and angle brackets. ! 192: ** ! 193: ** There are certain subtleties to this routine. The one that ! 194: ** comes to mind now is that backslashes on the ends of names ! 195: ** are silently stripped off; this is intentional. The problem ! 196: ** is that some versions of sndmsg (like at LBL) set the kill ! 197: ** character to something other than @ when reading addresses; ! 198: ** so people type "csvax.eric\@berkeley" -- which screws up the ! 199: ** berknet mailer. ! 200: ** ! 201: ** Parameters: ! 202: ** addr -- the name to chomp. ! 203: ** delim -- the delimiter for the address, normally ! 204: ** '\0' or ','; \0 is accepted in any case. ! 205: ** If '\t' then we are reading the .cf file. ! 206: ** pvpbuf -- place to put the saved text -- note that ! 207: ** the pointers are static. ! 208: ** ! 209: ** Returns: ! 210: ** A pointer to a vector of tokens. ! 211: ** NULL on error. ! 212: ** ! 213: ** Side Effects: ! 214: ** sets DelimChar to point to the character matching 'delim'. ! 215: */ ! 216: ! 217: /* states and character types */ ! 218: # define OPR 0 /* operator */ ! 219: # define ATM 1 /* atom */ ! 220: # define QST 2 /* in quoted string */ ! 221: # define SPC 3 /* chewing up spaces */ ! 222: # define ONE 4 /* pick up one character */ ! 223: ! 224: # define NSTATES 5 /* number of states */ ! 225: # define TYPE 017 /* mask to select state type */ ! 226: ! 227: /* meta bits for table */ ! 228: # define M 020 /* meta character; don't pass through */ ! 229: # define B 040 /* cause a break */ ! 230: # define MB M|B /* meta-break */ ! 231: ! 232: static short StateTab[NSTATES][NSTATES] = ! 233: { ! 234: /* oldst chtype> OPR ATM QST SPC ONE */ ! 235: /*OPR*/ OPR|B, ATM|B, QST|B, SPC|MB, ONE|B, ! 236: /*ATM*/ OPR|B, ATM, QST|B, SPC|MB, ONE|B, ! 237: /*QST*/ QST, QST, OPR, QST, QST, ! 238: /*SPC*/ OPR, ATM, QST, SPC|M, ONE, ! 239: /*ONE*/ OPR, OPR, OPR, OPR, OPR, ! 240: }; ! 241: ! 242: # define NOCHAR -1 /* signal nothing in lookahead token */ ! 243: ! 244: char *DelimChar; /* set to point to the delimiter */ ! 245: ! 246: char ** ! 247: prescan(addr, delim, pvpbuf) ! 248: char *addr; ! 249: char delim; ! 250: char pvpbuf[]; ! 251: { ! 252: register char *p; ! 253: register char *q; ! 254: register int c; ! 255: char **avp; ! 256: bool bslashmode; ! 257: int cmntcnt; ! 258: int anglecnt; ! 259: char *tok; ! 260: int state; ! 261: int newstate; ! 262: static char *av[MAXATOM+1]; ! 263: extern int errno; ! 264: ! 265: /* make sure error messages don't have garbage on them */ ! 266: errno = 0; ! 267: ! 268: q = pvpbuf; ! 269: bslashmode = FALSE; ! 270: cmntcnt = 0; ! 271: anglecnt = 0; ! 272: avp = av; ! 273: state = OPR; ! 274: c = NOCHAR; ! 275: p = addr; ! 276: # ifdef DEBUG ! 277: if (tTd(22, 45)) ! 278: { ! 279: printf("prescan: "); ! 280: xputs(p); ! 281: (void) putchar('\n'); ! 282: } ! 283: # endif DEBUG ! 284: ! 285: do ! 286: { ! 287: /* read a token */ ! 288: tok = q; ! 289: for (;;) ! 290: { ! 291: /* store away any old lookahead character */ ! 292: if (c != NOCHAR) ! 293: { ! 294: /* see if there is room */ ! 295: if (q >= &pvpbuf[PSBUFSIZE - 5]) ! 296: { ! 297: usrerr("Address too long"); ! 298: DelimChar = p; ! 299: return (NULL); ! 300: } ! 301: ! 302: /* squirrel it away */ ! 303: *q++ = c; ! 304: } ! 305: ! 306: /* read a new input character */ ! 307: c = *p++; ! 308: if (c == '\0') ! 309: break; ! 310: c &= ~0200; ! 311: ! 312: # ifdef DEBUG ! 313: if (tTd(22, 101)) ! 314: printf("c=%c, s=%d; ", c, state); ! 315: # endif DEBUG ! 316: ! 317: /* chew up special characters */ ! 318: *q = '\0'; ! 319: if (bslashmode) ! 320: { ! 321: /* kludge \! for naive users */ ! 322: if (c != '!') ! 323: c |= 0200; ! 324: bslashmode = FALSE; ! 325: } ! 326: else if (c == '\\') ! 327: { ! 328: bslashmode = TRUE; ! 329: c = NOCHAR; ! 330: } ! 331: else if (state == QST) ! 332: { ! 333: /* do nothing, just avoid next clauses */ ! 334: } ! 335: else if (c == '(') ! 336: { ! 337: cmntcnt++; ! 338: c = NOCHAR; ! 339: } ! 340: else if (c == ')') ! 341: { ! 342: if (cmntcnt <= 0) ! 343: { ! 344: usrerr("Unbalanced ')'"); ! 345: DelimChar = p; ! 346: return (NULL); ! 347: } ! 348: else ! 349: cmntcnt--; ! 350: } ! 351: else if (cmntcnt > 0) ! 352: c = NOCHAR; ! 353: else if (c == '<') ! 354: anglecnt++; ! 355: else if (c == '>') ! 356: { ! 357: if (anglecnt <= 0) ! 358: { ! 359: usrerr("Unbalanced '>'"); ! 360: DelimChar = p; ! 361: return (NULL); ! 362: } ! 363: anglecnt--; ! 364: } ! 365: else if (delim == ' ' && isspace(c)) ! 366: c = ' '; ! 367: ! 368: if (c == NOCHAR) ! 369: continue; ! 370: ! 371: /* see if this is end of input */ ! 372: if (c == delim && anglecnt <= 0 && state != QST) ! 373: break; ! 374: ! 375: newstate = StateTab[state][toktype(c)]; ! 376: # ifdef DEBUG ! 377: if (tTd(22, 101)) ! 378: printf("ns=%02o\n", newstate); ! 379: # endif DEBUG ! 380: state = newstate & TYPE; ! 381: if (bitset(M, newstate)) ! 382: c = NOCHAR; ! 383: if (bitset(B, newstate)) ! 384: break; ! 385: } ! 386: ! 387: /* new token */ ! 388: if (tok != q) ! 389: { ! 390: *q++ = '\0'; ! 391: # ifdef DEBUG ! 392: if (tTd(22, 36)) ! 393: { ! 394: printf("tok="); ! 395: xputs(tok); ! 396: (void) putchar('\n'); ! 397: } ! 398: # endif DEBUG ! 399: if (avp >= &av[MAXATOM]) ! 400: { ! 401: syserr("prescan: too many tokens"); ! 402: DelimChar = p; ! 403: return (NULL); ! 404: } ! 405: *avp++ = tok; ! 406: } ! 407: } while (c != '\0' && (c != delim || anglecnt > 0)); ! 408: *avp = NULL; ! 409: DelimChar = --p; ! 410: if (cmntcnt > 0) ! 411: usrerr("Unbalanced '('"); ! 412: else if (anglecnt > 0) ! 413: usrerr("Unbalanced '<'"); ! 414: else if (state == QST) ! 415: usrerr("Unbalanced '\"'"); ! 416: else if (av[0] != NULL) ! 417: return (av); ! 418: return (NULL); ! 419: } ! 420: /* ! 421: ** TOKTYPE -- return token type ! 422: ** ! 423: ** Parameters: ! 424: ** c -- the character in question. ! 425: ** ! 426: ** Returns: ! 427: ** Its type. ! 428: ** ! 429: ** Side Effects: ! 430: ** none. ! 431: */ ! 432: ! 433: toktype(c) ! 434: register char c; ! 435: { ! 436: static char buf[50]; ! 437: static bool firstime = TRUE; ! 438: ! 439: if (firstime) ! 440: { ! 441: firstime = FALSE; ! 442: expand("\001o", buf, &buf[sizeof buf - 1], CurEnv); ! 443: (void) strcat(buf, DELIMCHARS); ! 444: } ! 445: if (c == MATCHCLASS || c == MATCHREPL || c == MATCHNCLASS) ! 446: return (ONE); ! 447: if (c == '"') ! 448: return (QST); ! 449: if (!isascii(c)) ! 450: return (ATM); ! 451: if (isspace(c) || c == ')') ! 452: return (SPC); ! 453: if (iscntrl(c) || index(buf, c) != NULL) ! 454: return (OPR); ! 455: return (ATM); ! 456: } ! 457: /* ! 458: ** REWRITE -- apply rewrite rules to token vector. ! 459: ** ! 460: ** This routine is an ordered production system. Each rewrite ! 461: ** rule has a LHS (called the pattern) and a RHS (called the ! 462: ** rewrite); 'rwr' points the the current rewrite rule. ! 463: ** ! 464: ** For each rewrite rule, 'avp' points the address vector we ! 465: ** are trying to match against, and 'pvp' points to the pattern. ! 466: ** If pvp points to a special match value (MATCHZANY, MATCHANY, ! 467: ** MATCHONE, MATCHCLASS, MATCHNCLASS) then the address in avp ! 468: ** matched is saved away in the match vector (pointed to by 'mvp'). ! 469: ** ! 470: ** When a match between avp & pvp does not match, we try to ! 471: ** back out. If we back up over MATCHONE, MATCHCLASS, or MATCHNCLASS ! 472: ** we must also back out the match in mvp. If we reach a ! 473: ** MATCHANY or MATCHZANY we just extend the match and start ! 474: ** over again. ! 475: ** ! 476: ** When we finally match, we rewrite the address vector ! 477: ** and try over again. ! 478: ** ! 479: ** Parameters: ! 480: ** pvp -- pointer to token vector. ! 481: ** ! 482: ** Returns: ! 483: ** none. ! 484: ** ! 485: ** Side Effects: ! 486: ** pvp is modified. ! 487: */ ! 488: ! 489: struct match ! 490: { ! 491: char **first; /* first token matched */ ! 492: char **last; /* last token matched */ ! 493: }; ! 494: ! 495: # define MAXMATCH 9 /* max params per rewrite */ ! 496: ! 497: ! 498: rewrite(pvp, ruleset) ! 499: char **pvp; ! 500: int ruleset; ! 501: { ! 502: register char *ap; /* address pointer */ ! 503: register char *rp; /* rewrite pointer */ ! 504: register char **avp; /* address vector pointer */ ! 505: register char **rvp; /* rewrite vector pointer */ ! 506: register struct match *mlp; /* cur ptr into mlist */ ! 507: register struct rewrite *rwr; /* pointer to current rewrite rule */ ! 508: struct match mlist[MAXMATCH]; /* stores match on LHS */ ! 509: char *npvp[MAXATOM+1]; /* temporary space for rebuild */ ! 510: extern bool sameword(); ! 511: ! 512: if (OpMode == MD_TEST || tTd(21, 2)) ! 513: { ! 514: printf("rewrite: ruleset %2d input:", ruleset); ! 515: printav(pvp); ! 516: } ! 517: if (pvp == NULL) ! 518: return; ! 519: ! 520: /* ! 521: ** Run through the list of rewrite rules, applying ! 522: ** any that match. ! 523: */ ! 524: ! 525: for (rwr = RewriteRules[ruleset]; rwr != NULL; ) ! 526: { ! 527: # ifdef DEBUG ! 528: if (tTd(21, 12)) ! 529: { ! 530: printf("-----trying rule:"); ! 531: printav(rwr->r_lhs); ! 532: } ! 533: # endif DEBUG ! 534: ! 535: /* try to match on this rule */ ! 536: mlp = mlist; ! 537: rvp = rwr->r_lhs; ! 538: avp = pvp; ! 539: while ((ap = *avp) != NULL || *rvp != NULL) ! 540: { ! 541: rp = *rvp; ! 542: # ifdef DEBUG ! 543: if (tTd(21, 35)) ! 544: { ! 545: printf("ap="); ! 546: xputs(ap); ! 547: printf(", rp="); ! 548: xputs(rp); ! 549: printf("\n"); ! 550: } ! 551: # endif DEBUG ! 552: if (rp == NULL) ! 553: { ! 554: /* end-of-pattern before end-of-address */ ! 555: goto backup; ! 556: } ! 557: if (ap == NULL && *rp != MATCHZANY) ! 558: { ! 559: /* end-of-input */ ! 560: break; ! 561: } ! 562: ! 563: switch (*rp) ! 564: { ! 565: register STAB *s; ! 566: ! 567: case MATCHCLASS: ! 568: case MATCHNCLASS: ! 569: /* match any token in (not in) a class */ ! 570: s = stab(ap, ST_CLASS, ST_FIND); ! 571: if (s == NULL || !bitnset(rp[1], s->s_class)) ! 572: { ! 573: if (*rp == MATCHCLASS) ! 574: goto backup; ! 575: } ! 576: else if (*rp == MATCHNCLASS) ! 577: goto backup; ! 578: ! 579: /* explicit fall-through */ ! 580: ! 581: case MATCHONE: ! 582: case MATCHANY: ! 583: /* match exactly one token */ ! 584: mlp->first = avp; ! 585: mlp->last = avp++; ! 586: mlp++; ! 587: break; ! 588: ! 589: case MATCHZANY: ! 590: /* match zero or more tokens */ ! 591: mlp->first = avp; ! 592: mlp->last = avp - 1; ! 593: mlp++; ! 594: break; ! 595: ! 596: default: ! 597: /* must have exact match */ ! 598: if (!sameword(rp, ap)) ! 599: goto backup; ! 600: avp++; ! 601: break; ! 602: } ! 603: ! 604: /* successful match on this token */ ! 605: rvp++; ! 606: continue; ! 607: ! 608: backup: ! 609: /* match failed -- back up */ ! 610: while (--rvp >= rwr->r_lhs) ! 611: { ! 612: rp = *rvp; ! 613: if (*rp == MATCHANY || *rp == MATCHZANY) ! 614: { ! 615: /* extend binding and continue */ ! 616: avp = ++mlp[-1].last; ! 617: avp++; ! 618: rvp++; ! 619: break; ! 620: } ! 621: avp--; ! 622: if (*rp == MATCHONE || *rp == MATCHCLASS || ! 623: *rp == MATCHNCLASS) ! 624: { ! 625: /* back out binding */ ! 626: mlp--; ! 627: } ! 628: } ! 629: ! 630: if (rvp < rwr->r_lhs) ! 631: { ! 632: /* total failure to match */ ! 633: break; ! 634: } ! 635: } ! 636: ! 637: /* ! 638: ** See if we successfully matched ! 639: */ ! 640: ! 641: if (rvp < rwr->r_lhs || *rvp != NULL) ! 642: { ! 643: # ifdef DEBUG ! 644: if (tTd(21, 10)) ! 645: printf("----- rule fails\n"); ! 646: # endif DEBUG ! 647: rwr = rwr->r_next; ! 648: continue; ! 649: } ! 650: ! 651: rvp = rwr->r_rhs; ! 652: # ifdef DEBUG ! 653: if (tTd(21, 12)) ! 654: { ! 655: printf("-----rule matches:"); ! 656: printav(rvp); ! 657: } ! 658: # endif DEBUG ! 659: ! 660: rp = *rvp; ! 661: if (*rp == CANONUSER) ! 662: { ! 663: rvp++; ! 664: rwr = rwr->r_next; ! 665: } ! 666: else if (*rp == CANONHOST) ! 667: { ! 668: rvp++; ! 669: rwr = NULL; ! 670: } ! 671: else if (*rp == CANONNET) ! 672: rwr = NULL; ! 673: ! 674: /* substitute */ ! 675: for (avp = npvp; *rvp != NULL; rvp++) ! 676: { ! 677: register struct match *m; ! 678: register char **pp; ! 679: ! 680: rp = *rvp; ! 681: if (*rp == MATCHREPL) ! 682: { ! 683: /* substitute from LHS */ ! 684: m = &mlist[rp[1] - '1']; ! 685: if (m >= mlp) ! 686: { ! 687: syserr("rewrite: ruleset %d: replacement out of bounds", ruleset); ! 688: return; ! 689: } ! 690: # ifdef DEBUG ! 691: if (tTd(21, 15)) ! 692: { ! 693: printf("$%c:", rp[1]); ! 694: pp = m->first; ! 695: while (pp <= m->last) ! 696: { ! 697: printf(" %x=\"", *pp); ! 698: (void) fflush(stdout); ! 699: printf("%s\"", *pp++); ! 700: } ! 701: printf("\n"); ! 702: } ! 703: # endif DEBUG ! 704: pp = m->first; ! 705: while (pp <= m->last) ! 706: { ! 707: if (avp >= &npvp[MAXATOM]) ! 708: { ! 709: syserr("rewrite: expansion too long"); ! 710: return; ! 711: } ! 712: *avp++ = *pp++; ! 713: } ! 714: } ! 715: else ! 716: { ! 717: /* vanilla replacement */ ! 718: if (avp >= &npvp[MAXATOM]) ! 719: { ! 720: toolong: ! 721: syserr("rewrite: expansion too long"); ! 722: return; ! 723: } ! 724: *avp++ = rp; ! 725: } ! 726: } ! 727: *avp++ = NULL; ! 728: ! 729: /* ! 730: ** Check for any hostname lookups. ! 731: */ ! 732: ! 733: for (rvp = npvp; *rvp != NULL; rvp++) ! 734: { ! 735: char **hbrvp; ! 736: char **xpvp; ! 737: int trsize; ! 738: char *olddelimchar; ! 739: char buf[MAXNAME + 1]; ! 740: char *pvpb1[MAXATOM + 1]; ! 741: char pvpbuf[PSBUFSIZE]; ! 742: extern char *DelimChar; ! 743: ! 744: if (**rvp != HOSTBEGIN) ! 745: continue; ! 746: ! 747: /* ! 748: ** Got a hostname lookup. ! 749: ** ! 750: ** This could be optimized fairly easily. ! 751: */ ! 752: ! 753: hbrvp = rvp; ! 754: ! 755: /* extract the match part */ ! 756: while (*++rvp != NULL && **rvp != HOSTEND) ! 757: continue; ! 758: if (*rvp != NULL) ! 759: *rvp++ = NULL; ! 760: ! 761: /* save the remainder of the input string */ ! 762: trsize = (int) (avp - rvp + 1) * sizeof *rvp; ! 763: bcopy((char *) rvp, (char *) pvpb1, trsize); ! 764: ! 765: /* look it up */ ! 766: cataddr(++hbrvp, buf, sizeof buf); ! 767: maphostname(buf, sizeof buf); ! 768: ! 769: /* scan the new host name */ ! 770: olddelimchar = DelimChar; ! 771: xpvp = prescan(buf, '\0', pvpbuf); ! 772: DelimChar = olddelimchar; ! 773: if (xpvp == NULL) ! 774: { ! 775: syserr("rewrite: cannot prescan canonical hostname: %s", buf); ! 776: return; ! 777: } ! 778: ! 779: /* append it to the token list */ ! 780: for (avp = --hbrvp; *xpvp != NULL; xpvp++) ! 781: { ! 782: *avp++ = newstr(*xpvp); ! 783: if (avp >= &npvp[MAXATOM]) ! 784: goto toolong; ! 785: } ! 786: ! 787: /* restore the old trailing information */ ! 788: for (xpvp = pvpb1; (*avp++ = *xpvp++) != NULL; ) ! 789: if (avp >= &npvp[MAXATOM]) ! 790: goto toolong; ! 791: ! 792: break; ! 793: } ! 794: ! 795: /* ! 796: ** Check for subroutine calls. ! 797: */ ! 798: ! 799: if (*npvp != NULL && **npvp == CALLSUBR) ! 800: { ! 801: bcopy((char *) &npvp[2], (char *) pvp, ! 802: (int) (avp - npvp - 2) * sizeof *avp); ! 803: # ifdef DEBUG ! 804: if (tTd(21, 3)) ! 805: printf("-----callsubr %s\n", npvp[1]); ! 806: # endif DEBUG ! 807: rewrite(pvp, atoi(npvp[1])); ! 808: } ! 809: else ! 810: { ! 811: bcopy((char *) npvp, (char *) pvp, ! 812: (int) (avp - npvp) * sizeof *avp); ! 813: } ! 814: # ifdef DEBUG ! 815: if (tTd(21, 4)) ! 816: { ! 817: printf("rewritten as:"); ! 818: printav(pvp); ! 819: } ! 820: # endif DEBUG ! 821: } ! 822: ! 823: if (OpMode == MD_TEST || tTd(21, 2)) ! 824: { ! 825: printf("rewrite: ruleset %2d returns:", ruleset); ! 826: printav(pvp); ! 827: } ! 828: } ! 829: /* ! 830: ** BUILDADDR -- build address from token vector. ! 831: ** ! 832: ** Parameters: ! 833: ** tv -- token vector. ! 834: ** a -- pointer to address descriptor to fill. ! 835: ** If NULL, one will be allocated. ! 836: ** ! 837: ** Returns: ! 838: ** NULL if there was an error. ! 839: ** 'a' otherwise. ! 840: ** ! 841: ** Side Effects: ! 842: ** fills in 'a' ! 843: */ ! 844: ! 845: ADDRESS * ! 846: buildaddr(tv, a) ! 847: register char **tv; ! 848: register ADDRESS *a; ! 849: { ! 850: static char buf[MAXNAME]; ! 851: struct mailer **mp; ! 852: register struct mailer *m; ! 853: extern bool sameword(); ! 854: ! 855: if (a == NULL) ! 856: a = (ADDRESS *) xalloc(sizeof *a); ! 857: bzero((char *) a, sizeof *a); ! 858: ! 859: /* figure out what net/mailer to use */ ! 860: if (**tv != CANONNET) ! 861: { ! 862: syserr("buildaddr: no net"); ! 863: return (NULL); ! 864: } ! 865: tv++; ! 866: if (sameword(*tv, "error")) ! 867: { ! 868: if (**++tv == CANONHOST) ! 869: { ! 870: setstat(atoi(*++tv)); ! 871: tv++; ! 872: } ! 873: if (**tv != CANONUSER) ! 874: syserr("buildaddr: error: no user"); ! 875: buf[0] = '\0'; ! 876: while (*++tv != NULL) ! 877: { ! 878: if (buf[0] != '\0') ! 879: (void) strcat(buf, " "); ! 880: (void) strcat(buf, *tv); ! 881: } ! 882: usrerr(buf); ! 883: return (NULL); ! 884: } ! 885: for (mp = Mailer; (m = *mp++) != NULL; ) ! 886: { ! 887: if (sameword(m->m_name, *tv)) ! 888: break; ! 889: } ! 890: if (m == NULL) ! 891: { ! 892: syserr("buildaddr: unknown mailer %s", *tv); ! 893: return (NULL); ! 894: } ! 895: a->q_mailer = m; ! 896: ! 897: /* figure out what host (if any) */ ! 898: tv++; ! 899: if (!bitnset(M_LOCAL, m->m_flags)) ! 900: { ! 901: if (**tv++ != CANONHOST) ! 902: { ! 903: syserr("buildaddr: no host"); ! 904: return (NULL); ! 905: } ! 906: buf[0] = '\0'; ! 907: while (*tv != NULL && **tv != CANONUSER) ! 908: (void) strcat(buf, *tv++); ! 909: a->q_host = newstr(buf); ! 910: } ! 911: else ! 912: a->q_host = NULL; ! 913: ! 914: /* figure out the user */ ! 915: if (**tv != CANONUSER) ! 916: { ! 917: syserr("buildaddr: no user"); ! 918: return (NULL); ! 919: } ! 920: ! 921: /* rewrite according recipient mailer rewriting rules */ ! 922: rewrite(++tv, 2); ! 923: if (m->m_r_rwset > 0) ! 924: rewrite(tv, m->m_r_rwset); ! 925: rewrite(tv, 4); ! 926: ! 927: /* save the result for the command line/RCPT argument */ ! 928: cataddr(tv, buf, sizeof buf); ! 929: a->q_user = buf; ! 930: ! 931: return (a); ! 932: } ! 933: /* ! 934: ** CATADDR -- concatenate pieces of addresses (putting in <LWSP> subs) ! 935: ** ! 936: ** Parameters: ! 937: ** pvp -- parameter vector to rebuild. ! 938: ** buf -- buffer to build the string into. ! 939: ** sz -- size of buf. ! 940: ** ! 941: ** Returns: ! 942: ** none. ! 943: ** ! 944: ** Side Effects: ! 945: ** Destroys buf. ! 946: */ ! 947: ! 948: cataddr(pvp, buf, sz) ! 949: char **pvp; ! 950: char *buf; ! 951: register int sz; ! 952: { ! 953: bool oatomtok = FALSE; ! 954: bool natomtok = FALSE; ! 955: register int i; ! 956: register char *p; ! 957: ! 958: if (pvp == NULL) ! 959: { ! 960: (void) strcpy(buf, ""); ! 961: return; ! 962: } ! 963: p = buf; ! 964: sz -= 2; ! 965: while (*pvp != NULL && (i = strlen(*pvp)) < sz) ! 966: { ! 967: natomtok = (toktype(**pvp) == ATM); ! 968: if (oatomtok && natomtok) ! 969: *p++ = SpaceSub; ! 970: (void) strcpy(p, *pvp); ! 971: oatomtok = natomtok; ! 972: p += i; ! 973: sz -= i + 1; ! 974: pvp++; ! 975: } ! 976: *p = '\0'; ! 977: } ! 978: /* ! 979: ** SAMEADDR -- Determine if two addresses are the same ! 980: ** ! 981: ** This is not just a straight comparison -- if the mailer doesn't ! 982: ** care about the host we just ignore it, etc. ! 983: ** ! 984: ** Parameters: ! 985: ** a, b -- pointers to the internal forms to compare. ! 986: ** ! 987: ** Returns: ! 988: ** TRUE -- they represent the same mailbox. ! 989: ** FALSE -- they don't. ! 990: ** ! 991: ** Side Effects: ! 992: ** none. ! 993: */ ! 994: ! 995: bool ! 996: sameaddr(a, b) ! 997: register ADDRESS *a; ! 998: register ADDRESS *b; ! 999: { ! 1000: /* if they don't have the same mailer, forget it */ ! 1001: if (a->q_mailer != b->q_mailer) ! 1002: return (FALSE); ! 1003: ! 1004: /* if the user isn't the same, we can drop out */ ! 1005: if (strcmp(a->q_user, b->q_user) != 0) ! 1006: return (FALSE); ! 1007: ! 1008: /* if the mailer ignores hosts, we have succeeded! */ ! 1009: if (bitnset(M_LOCAL, a->q_mailer->m_flags)) ! 1010: return (TRUE); ! 1011: ! 1012: /* otherwise compare hosts (but be careful for NULL ptrs) */ ! 1013: if (a->q_host == NULL || b->q_host == NULL) ! 1014: return (FALSE); ! 1015: if (strcmp(a->q_host, b->q_host) != 0) ! 1016: return (FALSE); ! 1017: ! 1018: return (TRUE); ! 1019: } ! 1020: /* ! 1021: ** PRINTADDR -- print address (for debugging) ! 1022: ** ! 1023: ** Parameters: ! 1024: ** a -- the address to print ! 1025: ** follow -- follow the q_next chain. ! 1026: ** ! 1027: ** Returns: ! 1028: ** none. ! 1029: ** ! 1030: ** Side Effects: ! 1031: ** none. ! 1032: */ ! 1033: ! 1034: # ifdef DEBUG ! 1035: ! 1036: printaddr(a, follow) ! 1037: register ADDRESS *a; ! 1038: bool follow; ! 1039: { ! 1040: bool first = TRUE; ! 1041: ! 1042: while (a != NULL) ! 1043: { ! 1044: first = FALSE; ! 1045: printf("%x=", a); ! 1046: (void) fflush(stdout); ! 1047: printf("%s: mailer %d (%s), host `%s', user `%s'\n", a->q_paddr, ! 1048: a->q_mailer->m_mno, a->q_mailer->m_name, a->q_host, ! 1049: a->q_user); ! 1050: printf("\tnext=%x, flags=%o, alias %x\n", a->q_next, a->q_flags, ! 1051: a->q_alias); ! 1052: printf("\thome=\"%s\", fullname=\"%s\"\n", a->q_home, ! 1053: a->q_fullname); ! 1054: ! 1055: if (!follow) ! 1056: return; ! 1057: a = a->q_next; ! 1058: } ! 1059: if (first) ! 1060: printf("[NULL]\n"); ! 1061: } ! 1062: ! 1063: # endif DEBUG ! 1064: /* ! 1065: ** REMOTENAME -- return the name relative to the current mailer ! 1066: ** ! 1067: ** Parameters: ! 1068: ** name -- the name to translate. ! 1069: ** m -- the mailer that we want to do rewriting relative ! 1070: ** to. ! 1071: ** senderaddress -- if set, uses the sender rewriting rules ! 1072: ** rather than the recipient rewriting rules. ! 1073: ** canonical -- if set, strip out any comment information, ! 1074: ** etc. ! 1075: ** ! 1076: ** Returns: ! 1077: ** the text string representing this address relative to ! 1078: ** the receiving mailer. ! 1079: ** ! 1080: ** Side Effects: ! 1081: ** none. ! 1082: ** ! 1083: ** Warnings: ! 1084: ** The text string returned is tucked away locally; ! 1085: ** copy it if you intend to save it. ! 1086: */ ! 1087: ! 1088: char * ! 1089: remotename(name, m, senderaddress, canonical) ! 1090: char *name; ! 1091: struct mailer *m; ! 1092: bool senderaddress; ! 1093: bool canonical; ! 1094: { ! 1095: register char **pvp; ! 1096: char *fancy; ! 1097: extern char *macvalue(); ! 1098: char *oldg = macvalue('g', CurEnv); ! 1099: static char buf[MAXNAME]; ! 1100: char lbuf[MAXNAME]; ! 1101: char pvpbuf[PSBUFSIZE]; ! 1102: extern char **prescan(); ! 1103: extern char *crackaddr(); ! 1104: ! 1105: # ifdef DEBUG ! 1106: if (tTd(12, 1)) ! 1107: printf("remotename(%s)\n", name); ! 1108: # endif DEBUG ! 1109: ! 1110: /* don't do anything if we are tagging it as special */ ! 1111: if ((senderaddress ? m->m_s_rwset : m->m_r_rwset) < 0) ! 1112: return (name); ! 1113: ! 1114: /* ! 1115: ** Do a heuristic crack of this name to extract any comment info. ! 1116: ** This will leave the name as a comment and a $g macro. ! 1117: */ ! 1118: ! 1119: if (canonical) ! 1120: fancy = "\001g"; ! 1121: else ! 1122: fancy = crackaddr(name); ! 1123: ! 1124: /* ! 1125: ** Turn the name into canonical form. ! 1126: ** Normally this will be RFC 822 style, i.e., "user@domain". ! 1127: ** If this only resolves to "user", and the "C" flag is ! 1128: ** specified in the sending mailer, then the sender's ! 1129: ** domain will be appended. ! 1130: */ ! 1131: ! 1132: pvp = prescan(name, '\0', pvpbuf); ! 1133: if (pvp == NULL) ! 1134: return (name); ! 1135: rewrite(pvp, 3); ! 1136: if (CurEnv->e_fromdomain != NULL) ! 1137: { ! 1138: /* append from domain to this address */ ! 1139: register char **pxp = pvp; ! 1140: ! 1141: /* see if there is an "@domain" in the current name */ ! 1142: while (*pxp != NULL && strcmp(*pxp, "@") != 0) ! 1143: pxp++; ! 1144: if (*pxp == NULL) ! 1145: { ! 1146: /* no.... append the "@domain" from the sender */ ! 1147: register char **qxq = CurEnv->e_fromdomain; ! 1148: ! 1149: while ((*pxp++ = *qxq++) != NULL) ! 1150: continue; ! 1151: rewrite(pvp, 3); ! 1152: } ! 1153: } ! 1154: ! 1155: /* ! 1156: ** Do more specific rewriting. ! 1157: ** Rewrite using ruleset 1 or 2 depending on whether this is ! 1158: ** a sender address or not. ! 1159: ** Then run it through any receiving-mailer-specific rulesets. ! 1160: */ ! 1161: ! 1162: if (senderaddress) ! 1163: { ! 1164: rewrite(pvp, 1); ! 1165: if (m->m_s_rwset > 0) ! 1166: rewrite(pvp, m->m_s_rwset); ! 1167: } ! 1168: else ! 1169: { ! 1170: rewrite(pvp, 2); ! 1171: if (m->m_r_rwset > 0) ! 1172: rewrite(pvp, m->m_r_rwset); ! 1173: } ! 1174: ! 1175: /* ! 1176: ** Do any final sanitation the address may require. ! 1177: ** This will normally be used to turn internal forms ! 1178: ** (e.g., [email protected]) into external form. This ! 1179: ** may be used as a default to the above rules. ! 1180: */ ! 1181: ! 1182: rewrite(pvp, 4); ! 1183: ! 1184: /* ! 1185: ** Now restore the comment information we had at the beginning. ! 1186: */ ! 1187: ! 1188: cataddr(pvp, lbuf, sizeof lbuf); ! 1189: define('g', lbuf, CurEnv); ! 1190: expand(fancy, buf, &buf[sizeof buf - 1], CurEnv); ! 1191: define('g', oldg, CurEnv); ! 1192: ! 1193: # ifdef DEBUG ! 1194: if (tTd(12, 1)) ! 1195: printf("remotename => `%s'\n", buf); ! 1196: # endif DEBUG ! 1197: return (buf); ! 1198: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.