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