![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to addrsbr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / sbr|
Return to addrsbr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / sbr |
1.1 ! root 1: /* addrsbr.c - parse addresses 822-style */ ! 2: ! 3: #include "../h/mh.h" ! 4: #include "../h/addrsbr.h" ! 5: #include "../zotnet/mf.h" ! 6: #include <stdio.h> ! 7: #ifdef BERK ! 8: #include <ctype.h> ! 9: #endif BERK ! 10: ! 11: /* High level parsing of addresses: ! 12: ! 13: The routines in zotnet/mf/mf.c parse the syntactic representations of ! 14: addresses. The routines in uip/addrsbr.c associate semantics with those ! 15: addresses. ! 16: ! 17: If #ifdef BERK is in effect, the routines in mf.c aren't called and only ! 18: the most rudimentary syntax parse is done. The parse is not 822-conformant. ! 19: This causes problems as there is no semantics associated with the address ! 20: at all--it's just a string. (the author of the BERK code disagrees with ! 21: the preceding, of course. BERK solves problems for incoming mail ! 22: because it will accept damn near any address. BERK was intended to be ! 23: used when spost is the interface to the mail delivery system which means ! 24: all outgoing address interpretation is left to sendmail. It is possible, ! 25: though unlikely, for BERK address parsing to interact poorly with ! 26: "post". - [email protected]). ! 27: ! 28: Instead, if #ifdef DUMB is in effect, a full 822-style parser is called ! 29: for syntax recongition. This breaks each address into its components. ! 30: Note however that no semantics are assumed about the parts or their ! 31: totality. This means that implicit hostnames aren't made explicit, ! 32: and explicit hostnames aren't expanded to their "official" represenations. ! 33: ! 34: If neither BERK nor DUMB is in effect, then this module does some ! 35: high-level thinking about what the addresses are. If #ifdef MF is in ! 36: effect, then MH will deduce UUCP-style addressing masquerading as ! 37: 822-style addresses. ! 38: ! 39: 1. for MMDF systems: ! 40: ! 41: string%<uucp>@<local> -> string ! 42: ! 43: 2. for non-MMDF systems: ! 44: ! 45: string@host.<uucp> -> host!string ! 46: ! 47: 3. for any system, an address interpreted relative to the local host: ! 48: ! 49: string@<uucp> -> string ! 50: ! 51: For cases (1) and (3) above, the leftmost host is extracted. If it's not ! 52: present, the local host is used. If #ifdef MF is not in effect or the ! 53: tests above fail, the address is considered to be a real 822-style address. ! 54: ! 55: If an explicit host is not present, then MH checks for a bang to indicate ! 56: an explicit UUCP-style address. If so, this is noted. If not, the host is ! 57: defaulted, typically to the local host. The lack of an explict host is ! 58: also noted. ! 59: ! 60: If an explicit 822-style host is present, then MH checks to see if it ! 61: can expand this to the official name for the host. If the hostname is ! 62: unknown, the address is so typed. ! 63: ! 64: To summarize, when we're all done, here's what MH knows about the address: ! 65: ! 66: BERK - type: local ! 67: nohost: set if no '@' or '!' in mailbox ! 68: text: exact copy of address ! 69: mbox: lowercase version of mailbox ! 70: ! 71: DUMB - type: local, uucp, or network ! 72: host: not locally defaulted, not explicitly expanded ! 73: everything else ! 74: ! 75: other - type: local, uucp, network, unknown ! 76: everything else ! 77: */ ! 78: ! 79: /* */ ! 80: ! 81: #if !defined(DUMB) && defined(SENDMTS) && !defined(BANG) ! 82: #define MF ! 83: #define UucpChan() "UUCP" ! 84: #endif MF ! 85: ! 86: #ifdef BERK ! 87: static char *err = NULL; ! 88: static char adrtext[BUFSIZ]; ! 89: #else not BERK ! 90: static int ingrp = 0; ! 91: ! 92: static char *pers = NULL; ! 93: static char *mbox = NULL; ! 94: static char *host = NULL; ! 95: static char *route = NULL; ! 96: static char *grp = NULL; ! 97: static char *note = NULL; ! 98: ! 99: static char err[BUFSIZ]; ! 100: #endif not BERK ! 101: static char adr[BUFSIZ]; ! 102: ! 103: ! 104: char *getusr (); ! 105: ! 106: /* */ ! 107: ! 108: char *getname (addrs) ! 109: register char *addrs; ! 110: { ! 111: #ifdef BERK ! 112: /* ! 113: * Berkeley uses a very simple parser since Sendmail does all the work. ! 114: * The only thing that does address parsing if BERK is defined is the ! 115: * routine "ismybox" used by "scan" & "repl" to identify the current ! 116: * users maildrop. ! 117: * ! 118: * This routine does essentially the same address interpretation as the ! 119: * routine "prescan" in "sendmail". The intent is that MH should ! 120: * make minimum assumptions about address forms since it doesn't ! 121: * have access to the information in the sendmail config file ! 122: * (God forbid that anything but sendmail has to deal with a sendmail ! 123: * config file) and, therefore, hasn't the faintest idea of what will ! 124: * or won't be a legal address. ! 125: * ! 126: * Since this parse is only used by "ismybox" and repl, it just does ! 127: * two things: split multiple addr on a line into separate addresses and ! 128: * locate the "mailbox" portion of an address. The parse uses rfc-822 ! 129: * metacharacters and quoting but is much less restrictive that rfc-822. ! 130: * In detail, `,' or eos terminate addresses. "Empty" addresses ! 131: * (e.g., `,,') are ignored. Double quote ("), backslash, left & right ! 132: * paren and left and right angle brackets are metacharacters. Left & ! 133: * right parens must balance as must left & right angle brackets. Any ! 134: * metacharacter may be escaped by preceding it with a backslash. ! 135: * Any text between parens is considered a comment and ignored (i.e., ! 136: * only `(', `)' and `\' are metacharacters following a `('). Text ! 137: * between double quotes is considered escaped (i.e., only `"' and ! 138: * `\' are metacharacters following a `"'). The `mailbox' portion ! 139: * of an address is the non-comment text between angle-brackets if ! 140: * the address contains any angle brackets. Otherwise, it is all the ! 141: * non-comment text. Blanks, tabs & newlines will not be included ! 142: * in the mailbox portion of an address unless they are escaped. ! 143: */ ! 144: ! 145: /* Scanner states */ ! 146: #define NORMAL (0<<8) ! 147: #define QS (1<<8) /* in quoted string */ ! 148: #define COM (2<<8) /* in comment (...) */ ! 149: #define ERR (3<<8) /* found an error */ ! 150: #define EOA (4<<8) /* end of address */ ! 151: ! 152: static char *saved_addr = NULL; /* saved address line ptr */ ! 153: static char *adr_ptr = NULL; /* where to start looking for ! 154: next address on line */ ! 155: register char *nxtout = adr; /* where to put next character of ! 156: `mailbox' part of address */ ! 157: register char c; ! 158: register int state = NORMAL; ! 159: register char *adrcopy = adrtext; /* where to put next character of ! 160: address */ ! 161: register int lbcnt = 0; /* number of unmatched "(" */ ! 162: register int lpcnt = 0; /* number of unmatched "<" */ ! 163: ! 164: err = NULL; ! 165: if (! addrs) { ! 166: adr_ptr = NULL; ! 167: return NULL; ! 168: } ! 169: if (adr_ptr) ! 170: addrs = adr_ptr; ! 171: else ! 172: addrs = saved_addr = getcpy(addrs); ! 173: ! 174: /* skip any leading whitespace or commas. */ ! 175: while ( (c = *addrs++) == ',' || isspace(c)) ! 176: ; ! 177: ! 178: *nxtout = *adrcopy = '\0'; ! 179: while (state != EOA) { ! 180: *adrcopy++ = c; ! 181: if (state != COM) ! 182: *nxtout++ = isupper (c) ? tolower (c) : c; ! 183: switch (state+c) { ! 184: ! 185: case NORMAL+'\n': /* discard newlines */ ! 186: case QS+'\n': ! 187: case COM+'\n': ! 188: case ERR+'\n': ! 189: --nxtout; ! 190: --adrcopy; ! 191: break; ! 192: ! 193: case NORMAL+' ': /* skip unquoted whitespace */ ! 194: case NORMAL+'\t': ! 195: --nxtout; ! 196: break; ! 197: ! 198: case NORMAL+'"': /* start quoted string */ ! 199: state = QS; ! 200: break; ! 201: ! 202: case QS+'"': /* end quoted string */ ! 203: state = NORMAL; ! 204: break; ! 205: ! 206: case NORMAL+'<': ! 207: nxtout = adr; /* start over accumulating address */ ! 208: lbcnt++; ! 209: break; ! 210: ! 211: case NORMAL+'>': ! 212: --lbcnt; ! 213: if (lbcnt < 0) { ! 214: state = ERR; ! 215: err = "extra >"; ! 216: } else ! 217: *(nxtout-1) = '\0'; ! 218: break; ! 219: ! 220: case NORMAL+'(': ! 221: state = COM; ! 222: --nxtout; ! 223: case COM+'(': ! 224: lpcnt++; ! 225: break; ! 226: ! 227: case COM+')': ! 228: --lpcnt; ! 229: if (lpcnt < 0) { ! 230: state = ERR; ! 231: err = "extra )"; ! 232: } else if (lpcnt == 0) ! 233: state = NORMAL; ! 234: break; ! 235: ! 236: case NORMAL+'\\': ! 237: case QS+'\\': ! 238: case COM+'\\': ! 239: if ((c = *addrs++) == '\n' || c == '\0') { ! 240: state = EOA; ! 241: err = "illegal \\"; ! 242: } ! 243: *adrcopy++ = c; ! 244: *nxtout++ = isupper (c) ? tolower (c) : c; ! 245: break; ! 246: ! 247: case NORMAL+',': ! 248: case ERR+',': ! 249: case NORMAL+'\0': ! 250: case ERR+'\0': ! 251: state = EOA; ! 252: if (lbcnt) ! 253: err = "missing >"; ! 254: break; ! 255: ! 256: case COM+'\0': ! 257: state = EOA; ! 258: err = "missing )"; ! 259: if (nxtout == adr) ! 260: nxtout++; ! 261: break; ! 262: ! 263: case QS+'\0': ! 264: state = EOA; ! 265: err = "missing \""; ! 266: break; ! 267: } ! 268: if (c != '\0') ! 269: c = *addrs++; ! 270: } ! 271: /* ! 272: * at this point adr contains the `mailbox' part of the address ! 273: * in lower case & minus any comment or unquoted whitespace. ! 274: * adrtext contains an exact copy of the address and ! 275: * addr points to where we should start scanning next time. ! 276: */ ! 277: *(nxtout-1) = *(adrcopy-1) = '\0'; ! 278: if (*adr && !err) { ! 279: adr_ptr = addrs-1; ! 280: return adrtext; ! 281: } else { ! 282: free (saved_addr); ! 283: adr_ptr = NULL; ! 284: return NULL; ! 285: } ! 286: #else not BERK ! 287: register struct adrx *ap; ! 288: ! 289: pers = mbox = host = route = grp = note = NULL; ! 290: err[0] = NULL; ! 291: ! 292: if ((ap = getadrx (addrs)) == NULL) ! 293: return NULL; ! 294: ! 295: (void) strcpy (adr, ap -> text); ! 296: pers = ap -> pers; ! 297: mbox = ap -> mbox; ! 298: host = ap -> host; ! 299: route = ap -> path; ! 300: grp = ap -> grp; ! 301: ingrp = ap -> ingrp; ! 302: note = ap -> note; ! 303: if (ap -> err && *ap -> err) ! 304: (void) strcpy (err, ap -> err); ! 305: ! 306: return adr; ! 307: #endif not BERK ! 308: } ! 309: ! 310: /* */ ! 311: ! 312: #ifdef BERK ! 313: /* ARGSUSED */ ! 314: #endif BERK ! 315: ! 316: struct mailname *getm (str, dfhost, dftype, wanthost, eresult) ! 317: register char *str, ! 318: *eresult; ! 319: char *dfhost; ! 320: int dftype, ! 321: wanthost; ! 322: { ! 323: #ifndef BERK ! 324: register char *pp; ! 325: #ifndef DUMB ! 326: register char *dp; ! 327: #endif not DUMB ! 328: #ifdef MF ! 329: char *up = UucpChan (); ! 330: #endif MF ! 331: #endif not BERK ! 332: register struct mailname *mp; ! 333: ! 334: if (err && err[0]) { ! 335: if (eresult) ! 336: (void) strcpy (eresult, err); ! 337: else ! 338: if (wanthost == AD_HOST) ! 339: admonish (NULLCP, "bad address '%s' - %s", str, err); ! 340: return NULL; ! 341: } ! 342: #ifdef BERK ! 343: if (str == NULL || *str == '\0') { ! 344: #else not BERK ! 345: if (pers == NULL ! 346: && mbox == NULL && host == NULL && route == NULL ! 347: && grp == NULL) { ! 348: #endif not BERK ! 349: if (eresult) ! 350: (void) strcpy (eresult, "null address"); ! 351: else ! 352: if (wanthost == AD_HOST) ! 353: admonish (NULLCP, "null address '%s'", str); ! 354: return NULL; ! 355: } ! 356: #ifndef BERK ! 357: if (mbox == NULL && grp == NULL) { ! 358: if (eresult) ! 359: (void) strcpy (eresult, "no mailbox in address"); ! 360: else ! 361: if (wanthost == AD_HOST) ! 362: admonish (NULLCP, "no mailbox in address '%s'", str); ! 363: return NULL; ! 364: } ! 365: ! 366: if (dfhost == NULL) { ! 367: dfhost = LocalName (); ! 368: dftype = LOCALHOST; ! 369: } ! 370: #endif not BERK ! 371: ! 372: mp = (struct mailname *) calloc ((unsigned) 1, sizeof *mp); ! 373: if (mp == NULL) { ! 374: if (eresult) ! 375: (void) strcpy (eresult, "insufficient memory to represent address"); ! 376: else ! 377: if (wanthost == AD_HOST) ! 378: adios (NULLCP, "insufficient memory to represent address"); ! 379: return NULL; ! 380: } ! 381: ! 382: mp -> m_text = getcpy (str); ! 383: #ifdef BERK ! 384: mp -> m_type = LOCALHOST; ! 385: mp -> m_mbox = getcpy (adr); ! 386: if (!index (adr, '@') && !index (adr, '!')) ! 387: mp -> m_nohost = 1; ! 388: #else not BERK ! 389: if (pers) ! 390: mp -> m_pers = getcpy (pers); ! 391: ! 392: if (mbox == NULL) { ! 393: mp -> m_type = BADHOST; ! 394: mp -> m_nohost = 1; ! 395: mp -> m_ingrp = ingrp; ! 396: mp -> m_gname = getcpy (grp); ! 397: if (note) ! 398: mp -> m_note = getcpy (note); ! 399: return mp; ! 400: } ! 401: ! 402: /* */ ! 403: ! 404: if (host) { ! 405: #ifdef MF ! 406: #ifdef MMDFMTS ! 407: if (up && uleq (host, LocalName ()) ! 408: && (pp = rindex (mbox, '%')) ! 409: && uleq (up, pp + 1)) {/* uucpaddr%<uucp>@<local> */ ! 410: *pp = NULL; ! 411: goto get_uucp; ! 412: } ! 413: #else not MMDFMTS ! 414: if (up && (pp = index (host, '.')) ! 415: && uleq (up, pp + 1)) {/* uucpaddr@host.<uucp> */ ! 416: *pp = NULL; ! 417: mp -> m_host = getcpy (host); ! 418: mp -> m_mbox = getcpy (mbox); ! 419: mp -> m_type = UUCPHOST; ! 420: goto got_host; ! 421: } ! 422: #endif not MMDFMTS ! 423: if (up && uleq (dfhost, LocalName ()) ! 424: && uleq (up, host)) {/* uucpaddr@<uucp> [local] */ ! 425: if (pp = index (mbox, '!')) { ! 426: *pp++ = NULL; ! 427: mp -> m_host = getcpy (mbox); ! 428: mp -> m_mbox = getcpy (pp); ! 429: } ! 430: else { ! 431: mp -> m_host = getcpy (SystemName ()); ! 432: mp -> m_mbox = getcpy (mbox); ! 433: } ! 434: mp -> m_type = UUCPHOST; ! 435: goto got_host; ! 436: } ! 437: #endif MF ! 438: mp -> m_mbox = getcpy (mbox); ! 439: mp -> m_host = getcpy (host); ! 440: } ! 441: else { ! 442: if (pp = index (mbox, '!')) { ! 443: *pp++ = NULL; ! 444: mp -> m_mbox = getcpy (pp); ! 445: mp -> m_host = getcpy (mbox); ! 446: mp -> m_type = UUCPHOST; ! 447: } ! 448: else { ! 449: mp -> m_nohost = 1; ! 450: mp -> m_mbox = getcpy (mbox); ! 451: #ifdef DUMB ! 452: if (route == NULL && dftype == LOCALHOST) { ! 453: mp -> m_host = NULLCP; ! 454: mp -> m_type = dftype; ! 455: } ! 456: else ! 457: #endif DUMB ! 458: { ! 459: mp -> m_host = route ? NULLCP : getcpy (dfhost); ! 460: mp -> m_type = route ? NETHOST : dftype; ! 461: } ! 462: } ! 463: goto got_host; ! 464: } ! 465: ! 466: /* */ ! 467: ! 468: if (wanthost == AD_NHST) ! 469: mp -> m_type = uleq (LocalName (), mp -> m_host) ! 470: ? LOCALHOST : NETHOST; ! 471: #ifdef DUMB ! 472: else ! 473: mp -> m_type = uleq (LocalName (), mp -> m_host) ? LOCALHOST ! 474: : NETHOST; ! 475: #else not DUMB ! 476: else ! 477: if (pp = OfficialName (mp -> m_host)) { ! 478: got_real_host: ; ! 479: free (mp -> m_host); ! 480: mp -> m_host = getcpy (pp); ! 481: mp -> m_type = uleq (LocalName (), mp -> m_host) ? LOCALHOST ! 482: : NETHOST; ! 483: } ! 484: else { ! 485: if (dp = index (mp -> m_host, '.')) { ! 486: *dp = NULL; ! 487: if (pp = OfficialName (mp -> m_host)) ! 488: goto got_real_host; ! 489: *dp = '.'; ! 490: } ! 491: mp -> m_type = BADHOST; ! 492: } ! 493: #endif not DUMB ! 494: ! 495: got_host: ; ! 496: if (route) ! 497: mp -> m_path = getcpy (route); ! 498: mp -> m_ingrp = ingrp; ! 499: if (grp) ! 500: mp -> m_gname = getcpy (grp); ! 501: if (note) ! 502: mp -> m_note = getcpy (note); ! 503: #endif not BERK ! 504: ! 505: return mp; ! 506: } ! 507: ! 508: /* */ ! 509: ! 510: void mnfree (mp) ! 511: register struct mailname *mp; ! 512: { ! 513: if (!mp) ! 514: return; ! 515: ! 516: if (mp -> m_text) ! 517: free (mp -> m_text); ! 518: if (mp -> m_pers) ! 519: free (mp -> m_pers); ! 520: if (mp -> m_mbox) ! 521: free (mp -> m_mbox); ! 522: if (mp -> m_host) ! 523: free (mp -> m_host); ! 524: if (mp -> m_path) ! 525: free (mp -> m_path); ! 526: if (mp -> m_gname) ! 527: free (mp -> m_gname); ! 528: if (mp -> m_note) ! 529: free (mp -> m_note); ! 530: #ifdef MHMTS ! 531: if (mp -> m_aka) ! 532: free (mp -> m_aka); ! 533: #endif MHMTS ! 534: ! 535: free ((char *) mp); ! 536: } ! 537: ! 538: /* */ ! 539: ! 540: char *auxformat (mp, extras) ! 541: register struct mailname *mp; ! 542: int extras; ! 543: { ! 544: #ifndef BERK ! 545: #ifdef MF ! 546: char *up = UucpChan (); ! 547: #endif MF ! 548: static char addr[BUFSIZ]; ! 549: #endif not BERK ! 550: static char buffer[BUFSIZ]; ! 551: ! 552: #ifdef BERK ! 553: /* this "if" is a crufty hack to handle "visible" aliases */ ! 554: if (mp->m_pers && !extras) ! 555: (void) sprintf (buffer, "%s <%s>", mp->m_pers, mp->m_mbox); ! 556: else ! 557: (void) strcpy (buffer, mp -> m_text); ! 558: #else not BERK ! 559: ! 560: #ifdef MF ! 561: if (up && mp -> m_type == UUCPHOST) ! 562: #ifdef MMDFMTS ! 563: (void) sprintf (addr, "%s!%s%%%s@%s", mp -> m_host, mp -> m_mbox, ! 564: up, LocalName ()); ! 565: #else not MMDFMTS ! 566: (void) sprintf (addr, "%s@%s.%s", mp -> m_mbox, mp -> m_host, up); ! 567: #endif not MMDFMTS ! 568: else ! 569: #endif MF ! 570: ! 571: #ifdef DUMB ! 572: if (mp -> m_nohost) ! 573: (void) strcpy (addr, mp -> m_mbox ? mp -> m_mbox : ""); ! 574: else ! 575: #endif DUMB ! 576: ! 577: #ifndef BANG ! 578: if (mp -> m_type != UUCPHOST) ! 579: (void) sprintf (addr, mp -> m_host ? "%s%s@%s" : "%s%s", ! 580: mp -> m_path ? mp -> m_path : "", mp -> m_mbox, mp -> m_host); ! 581: else ! 582: #endif not BANG ! 583: (void) sprintf (addr, "%s!%s", mp -> m_host, mp -> m_mbox); ! 584: ! 585: if (!extras) ! 586: return addr; ! 587: ! 588: if (mp -> m_pers || mp -> m_path) ! 589: if (mp -> m_note) ! 590: (void) sprintf (buffer, "%s %s <%s>", ! 591: legal_person (mp -> m_pers ? mp -> m_pers : mp -> m_mbox), ! 592: mp -> m_note, addr); ! 593: else ! 594: (void) sprintf (buffer, "%s <%s>", ! 595: legal_person (mp -> m_pers ? mp -> m_pers : mp -> m_mbox), ! 596: addr); ! 597: else ! 598: if (mp -> m_note) ! 599: (void) sprintf (buffer, "%s %s", addr, mp -> m_note); ! 600: else ! 601: (void) strcpy (buffer, addr); ! 602: #endif not BERK ! 603: ! 604: return buffer; ! 605: } ! 606: ! 607: /* */ ! 608: ! 609: #if defined(BERK) || (defined(DUMB) && !defined(MMDFMTS) && !defined(SMTP)) ! 610: #define REALLYDUMB ! 611: #else ! 612: #undef REALLYDUMB ! 613: #endif ! 614: ! 615: char *adrsprintf (local, domain) ! 616: char *local, ! 617: *domain; ! 618: { ! 619: static char addr[BUFSIZ]; ! 620: ! 621: if (local == NULL) ! 622: #ifdef REALLYDUMB ! 623: return getusr (); ! 624: else ! 625: #endif REALLYDUMB ! 626: local = getusr (); ! 627: ! 628: if (domain == NULL) ! 629: #ifdef REALLYDUMB ! 630: return local; ! 631: else ! 632: #endif REALLYDUMB ! 633: domain = LocalName (); ! 634: ! 635: #ifndef BANG ! 636: (void) sprintf (addr, "%s@%s", local, domain); ! 637: #else BANG ! 638: (void) sprintf (addr, "%s!%s", domain, local); ! 639: #endif BANG ! 640: ! 641: return addr; ! 642: } ! 643: ! 644: /* */ ! 645: ! 646: #define W_NIL 0x0000 ! 647: #define W_MBEG 0x0001 ! 648: #define W_MEND 0x0002 ! 649: #define W_MBOX (W_MBEG | W_MEND) ! 650: #define W_HBEG 0x0004 ! 651: #define W_HEND 0x0008 ! 652: #define W_HOST (W_HBEG | W_HEND) ! 653: #define WBITS "\020\01MBEG\02MEND\03HBEG\04HEND" ! 654: ! 655: ! 656: int ismymbox (np) ! 657: register struct mailname *np; ! 658: { ! 659: int oops; ! 660: register int len, ! 661: i; ! 662: register char *cp; ! 663: #ifndef BERK ! 664: register char *pp; ! 665: char buffer[BUFSIZ]; ! 666: #endif not BERK ! 667: register struct mailname *mp; ! 668: static char *am = NULL; ! 669: static struct mailname mq; ! 670: ! 671: /* if this is the first call, init. alternate mailboxes list */ ! 672: if (am == NULL) { ! 673: mq.m_next = NULL; ! 674: mq.m_mbox = getusr (); ! 675: if ((am = m_find ("alternate-mailboxes")) == NULL) ! 676: am = getusr (); ! 677: else { ! 678: mp = &mq; ! 679: oops = 0; ! 680: while (cp = getname (am)) ! 681: if ((mp -> m_next = getm (cp, NULLCP, 0, AD_NAME, NULLCP)) ! 682: == NULL) ! 683: admonish (NULLCP, "illegal address: %s", cp), oops++; ! 684: else { ! 685: mp = mp -> m_next; ! 686: mp -> m_type = W_NIL; ! 687: #ifdef BERK ! 688: /* check for wildcards on the mailbox name and ! 689: set m_type accordingly. */ ! 690: mp -> m_ingrp = strlen (mp -> m_mbox); ! 691: if (*(mp -> m_mbox) == '*') { ! 692: mp -> m_type |= W_MBEG; ! 693: mp -> m_mbox++; ! 694: --mp -> m_ingrp; ! 695: } ! 696: if (mp -> m_mbox[mp -> m_ingrp - 1] == '*') { ! 697: mp -> m_type |= W_MEND; ! 698: mp -> m_ingrp--; ! 699: mp -> m_mbox[mp -> m_ingrp] = NULL; ! 700: } ! 701: #else not BERK ! 702: /* owing to screwy munging, wildcarding is a great idea ! 703: even under #ifndef BERK, so... */ ! 704: mp -> m_type = W_NIL; ! 705: if (*mp -> m_mbox == '*') ! 706: mp -> m_type |= W_MBEG, mp -> m_mbox++; ! 707: if (*(cp = mp -> m_mbox + strlen (mp -> m_mbox) - 1) ! 708: == '*') ! 709: mp -> m_type |= W_MEND, *cp = NULL; ! 710: if (mp -> m_host) { ! 711: if (*mp -> m_host == '*') ! 712: mp -> m_type |= W_HBEG, mp -> m_host++; ! 713: if (*(cp = mp -> m_host + strlen (mp -> m_host) - 1) ! 714: == '*') ! 715: mp -> m_type |= W_HEND, *cp = NULL; ! 716: } ! 717: if ((cp = getenv ("MHWDEBUG")) && *cp) ! 718: fprintf (stderr, "mbox=\"%s\" host=\"%s\" %s\n", ! 719: mp -> m_mbox, mp -> m_host, ! 720: sprintb (buffer, (unsigned) mp -> m_type, WBITS)); ! 721: #endif not BERK ! 722: } ! 723: if (oops) ! 724: advise (NULLCP, "please fix the %s: entry in your %s file", ! 725: "alternate-mailboxes", mh_profile); ! 726: } ! 727: } ! 728: if (np == NULL) /* XXX */ ! 729: return 0; ! 730: ! 731: #ifdef BERK ! 732: cp = np -> m_mbox; ! 733: if (strcmp (cp, mq.m_mbox) == 0) ! 734: return 1; ! 735: #else not BERK ! 736: switch (np -> m_type) { ! 737: case NETHOST: ! 738: len = strlen (cp = LocalName ()); ! 739: if (uprf (np -> m_host, cp) || np -> m_host[len] != '.') ! 740: break; ! 741: goto local_test; ! 742: ! 743: case UUCPHOST: ! 744: if (!uleq (np -> m_host, SystemName ())) ! 745: break; /* fall */ ! 746: case LOCALHOST: ! 747: local_test: ; ! 748: if (uleq (np -> m_mbox, mq.m_text)) ! 749: return 1; ! 750: break; ! 751: ! 752: default: ! 753: break; ! 754: } ! 755: #endif not BERK ! 756: ! 757: #ifdef BERK ! 758: len = strlen (cp); ! 759: for (mp = &mq; mp = mp -> m_next;) ! 760: if (len >= mp -> m_ingrp) ! 761: switch (mp -> m_type) { ! 762: case W_NIL: /* no wildcards */ ! 763: if (strcmp (cp, mp -> m_mbox) == 0) ! 764: return 1; ! 765: break; ! 766: ! 767: case W_MBEG: /* wildcard at beginning */ ! 768: if (strcmp (&cp[len - mp -> m_ingrp], mp -> m_mbox) == 0) ! 769: return 1; ! 770: break; ! 771: ! 772: case W_MEND: /* wildcard at end */ ! 773: if (strncmp (cp, mp -> m_mbox, mp -> m_ingrp) == 0) ! 774: return 1; ! 775: break; ! 776: ! 777: case W_MBEG | W_MEND: /* wildcard at beginning & end */ ! 778: for (i = 0; i <= len - mp -> m_ingrp; i++) ! 779: if (strncmp (&cp[i], mp -> m_mbox, mp -> m_ingrp) == 0) ! 780: return 1; ! 781: } ! 782: #else not BERK ! 783: for (mp = &mq; mp = mp -> m_next;) { ! 784: if ((len = strlen (cp = np -> m_mbox)) ! 785: < (i = strlen (pp = mp -> m_mbox))) ! 786: continue; ! 787: switch (mp -> m_type & W_MBOX) { ! 788: case W_NIL: ! 789: if (!uleq (cp, pp)) ! 790: continue; ! 791: break; ! 792: case W_MBEG: ! 793: if (!uleq (cp + len - i, pp)) ! 794: continue; ! 795: break; ! 796: case W_MEND: ! 797: if (!uprf (cp, pp)) ! 798: continue; ! 799: break; ! 800: case W_MBEG | W_MEND: ! 801: if (stringdex (pp, cp) < 0) ! 802: continue; ! 803: break; ! 804: } ! 805: ! 806: if (mp -> m_nohost) ! 807: return 1; ! 808: if ((len = strlen (cp = np -> m_host)) ! 809: < (i = strlen (pp = mp -> m_host))) ! 810: continue; ! 811: switch (mp -> m_type & W_HOST) { ! 812: case W_NIL: ! 813: if (!uleq (cp, pp)) ! 814: continue; ! 815: break; ! 816: case W_HBEG: ! 817: if (!uleq (cp + len - i, pp)) ! 818: continue; ! 819: break; ! 820: case W_HEND: ! 821: if (!uprf (cp, pp)) ! 822: continue; ! 823: break; ! 824: case W_HBEG | W_HEND: ! 825: if (stringdex (pp, cp) < 0) ! 826: continue; ! 827: break; ! 828: } ! 829: return 1; ! 830: } ! 831: #endif not BERK ! 832: ! 833: return 0; ! 834: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.