![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deliver.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 deliver.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[] = "@(#)deliver.c 5.10 (Berkeley) 3/2/86"; ! 13: #endif not lint ! 14: ! 15: # include <signal.h> ! 16: # include <errno.h> ! 17: # include "sendmail.h" ! 18: # include <sys/stat.h> ! 19: # include <netdb.h> ! 20: ! 21: /* ! 22: ** DELIVER -- Deliver a message to a list of addresses. ! 23: ** ! 24: ** This routine delivers to everyone on the same host as the ! 25: ** user on the head of the list. It is clever about mailers ! 26: ** that don't handle multiple users. It is NOT guaranteed ! 27: ** that it will deliver to all these addresses however -- so ! 28: ** deliver should be called once for each address on the ! 29: ** list. ! 30: ** ! 31: ** Parameters: ! 32: ** e -- the envelope to deliver. ! 33: ** firstto -- head of the address list to deliver to. ! 34: ** ! 35: ** Returns: ! 36: ** zero -- successfully delivered. ! 37: ** else -- some failure, see ExitStat for more info. ! 38: ** ! 39: ** Side Effects: ! 40: ** The standard input is passed off to someone. ! 41: */ ! 42: ! 43: deliver(e, firstto) ! 44: register ENVELOPE *e; ! 45: ADDRESS *firstto; ! 46: { ! 47: char *host; /* host being sent to */ ! 48: char *user; /* user being sent to */ ! 49: char **pvp; ! 50: register char **mvp; ! 51: register char *p; ! 52: register MAILER *m; /* mailer for this recipient */ ! 53: ADDRESS *ctladdr; ! 54: register ADDRESS *to = firstto; ! 55: bool clever = FALSE; /* running user smtp to this mailer */ ! 56: ADDRESS *tochain = NULL; /* chain of users in this mailer call */ ! 57: register int rcode; /* response code */ ! 58: char *pv[MAXPV+1]; ! 59: char tobuf[MAXLINE-50]; /* text line of to people */ ! 60: char buf[MAXNAME]; ! 61: char tfrombuf[MAXNAME]; /* translated from person */ ! 62: extern bool checkcompat(); ! 63: extern ADDRESS *getctladdr(); ! 64: extern char *remotename(); ! 65: ! 66: errno = 0; ! 67: if (bitset(QDONTSEND, to->q_flags)) ! 68: return (0); ! 69: ! 70: m = to->q_mailer; ! 71: host = to->q_host; ! 72: ! 73: # ifdef DEBUG ! 74: if (tTd(10, 1)) ! 75: printf("\n--deliver, mailer=%d, host=`%s', first user=`%s'\n", ! 76: m->m_mno, host, to->q_user); ! 77: # endif DEBUG ! 78: ! 79: /* ! 80: ** If this mailer is expensive, and if we don't want to make ! 81: ** connections now, just mark these addresses and return. ! 82: ** This is useful if we want to batch connections to ! 83: ** reduce load. This will cause the messages to be ! 84: ** queued up, and a daemon will come along to send the ! 85: ** messages later. ! 86: ** This should be on a per-mailer basis. ! 87: */ ! 88: ! 89: if (NoConnect && !QueueRun && bitnset(M_EXPENSIVE, m->m_flags) && ! 90: !Verbose) ! 91: { ! 92: for (; to != NULL; to = to->q_next) ! 93: { ! 94: if (bitset(QDONTSEND, to->q_flags) || to->q_mailer != m) ! 95: continue; ! 96: to->q_flags |= QQUEUEUP|QDONTSEND; ! 97: e->e_to = to->q_paddr; ! 98: message(Arpa_Info, "queued"); ! 99: if (LogLevel > 4) ! 100: logdelivery("queued"); ! 101: } ! 102: e->e_to = NULL; ! 103: return (0); ! 104: } ! 105: ! 106: /* ! 107: ** Do initial argv setup. ! 108: ** Insert the mailer name. Notice that $x expansion is ! 109: ** NOT done on the mailer name. Then, if the mailer has ! 110: ** a picky -f flag, we insert it as appropriate. This ! 111: ** code does not check for 'pv' overflow; this places a ! 112: ** manifest lower limit of 4 for MAXPV. ! 113: ** The from address rewrite is expected to make ! 114: ** the address relative to the other end. ! 115: */ ! 116: ! 117: /* rewrite from address, using rewriting rules */ ! 118: expand("\001f", buf, &buf[sizeof buf - 1], e); ! 119: (void) strcpy(tfrombuf, remotename(buf, m, TRUE, TRUE)); ! 120: ! 121: define('g', tfrombuf, e); /* translated sender address */ ! 122: define('h', host, e); /* to host */ ! 123: Errors = 0; ! 124: pvp = pv; ! 125: *pvp++ = m->m_argv[0]; ! 126: ! 127: /* insert -f or -r flag as appropriate */ ! 128: if (FromFlag && (bitnset(M_FOPT, m->m_flags) || bitnset(M_ROPT, m->m_flags))) ! 129: { ! 130: if (bitnset(M_FOPT, m->m_flags)) ! 131: *pvp++ = "-f"; ! 132: else ! 133: *pvp++ = "-r"; ! 134: expand("\001g", buf, &buf[sizeof buf - 1], e); ! 135: *pvp++ = newstr(buf); ! 136: } ! 137: ! 138: /* ! 139: ** Append the other fixed parts of the argv. These run ! 140: ** up to the first entry containing "$u". There can only ! 141: ** be one of these, and there are only a few more slots ! 142: ** in the pv after it. ! 143: */ ! 144: ! 145: for (mvp = m->m_argv; (p = *++mvp) != NULL; ) ! 146: { ! 147: while ((p = index(p, '\001')) != NULL) ! 148: if (*++p == 'u') ! 149: break; ! 150: if (p != NULL) ! 151: break; ! 152: ! 153: /* this entry is safe -- go ahead and process it */ ! 154: expand(*mvp, buf, &buf[sizeof buf - 1], e); ! 155: *pvp++ = newstr(buf); ! 156: if (pvp >= &pv[MAXPV - 3]) ! 157: { ! 158: syserr("Too many parameters to %s before $u", pv[0]); ! 159: return (-1); ! 160: } ! 161: } ! 162: ! 163: /* ! 164: ** If we have no substitution for the user name in the argument ! 165: ** list, we know that we must supply the names otherwise -- and ! 166: ** SMTP is the answer!! ! 167: */ ! 168: ! 169: if (*mvp == NULL) ! 170: { ! 171: /* running SMTP */ ! 172: # ifdef SMTP ! 173: clever = TRUE; ! 174: *pvp = NULL; ! 175: # else SMTP ! 176: /* oops! we don't implement SMTP */ ! 177: syserr("SMTP style mailer"); ! 178: return (EX_SOFTWARE); ! 179: # endif SMTP ! 180: } ! 181: ! 182: /* ! 183: ** At this point *mvp points to the argument with $u. We ! 184: ** run through our address list and append all the addresses ! 185: ** we can. If we run out of space, do not fret! We can ! 186: ** always send another copy later. ! 187: */ ! 188: ! 189: tobuf[0] = '\0'; ! 190: e->e_to = tobuf; ! 191: ctladdr = NULL; ! 192: for (; to != NULL; to = to->q_next) ! 193: { ! 194: /* avoid sending multiple recipients to dumb mailers */ ! 195: if (tobuf[0] != '\0' && !bitnset(M_MUSER, m->m_flags)) ! 196: break; ! 197: ! 198: /* if already sent or not for this host, don't send */ ! 199: if (bitset(QDONTSEND, to->q_flags) || ! 200: strcmp(to->q_host, host) != 0 || ! 201: to->q_mailer != firstto->q_mailer) ! 202: continue; ! 203: ! 204: /* avoid overflowing tobuf */ ! 205: if (sizeof tobuf - (strlen(to->q_paddr) + strlen(tobuf) + 2) < 0) ! 206: break; ! 207: ! 208: # ifdef DEBUG ! 209: if (tTd(10, 1)) ! 210: { ! 211: printf("\nsend to "); ! 212: printaddr(to, FALSE); ! 213: } ! 214: # endif DEBUG ! 215: ! 216: /* compute effective uid/gid when sending */ ! 217: if (to->q_mailer == ProgMailer) ! 218: ctladdr = getctladdr(to); ! 219: ! 220: user = to->q_user; ! 221: e->e_to = to->q_paddr; ! 222: to->q_flags |= QDONTSEND; ! 223: ! 224: /* ! 225: ** Check to see that these people are allowed to ! 226: ** talk to each other. ! 227: */ ! 228: ! 229: if (m->m_maxsize != 0 && e->e_msgsize > m->m_maxsize) ! 230: { ! 231: usrerr("Message is too large; %ld bytes max", m->m_maxsize); ! 232: NoReturn = TRUE; ! 233: giveresponse(EX_UNAVAILABLE, m, e); ! 234: continue; ! 235: } ! 236: if (!checkcompat(to)) ! 237: { ! 238: giveresponse(EX_UNAVAILABLE, m, e); ! 239: continue; ! 240: } ! 241: ! 242: /* ! 243: ** Strip quote bits from names if the mailer is dumb ! 244: ** about them. ! 245: */ ! 246: ! 247: if (bitnset(M_STRIPQ, m->m_flags)) ! 248: { ! 249: stripquotes(user, TRUE); ! 250: stripquotes(host, TRUE); ! 251: } ! 252: else ! 253: { ! 254: stripquotes(user, FALSE); ! 255: stripquotes(host, FALSE); ! 256: } ! 257: ! 258: /* hack attack -- delivermail compatibility */ ! 259: if (m == ProgMailer && *user == '|') ! 260: user++; ! 261: ! 262: /* ! 263: ** If an error message has already been given, don't ! 264: ** bother to send to this address. ! 265: ** ! 266: ** >>>>>>>>>> This clause assumes that the local mailer ! 267: ** >> NOTE >> cannot do any further aliasing; that ! 268: ** >>>>>>>>>> function is subsumed by sendmail. ! 269: */ ! 270: ! 271: if (bitset(QBADADDR|QQUEUEUP, to->q_flags)) ! 272: continue; ! 273: ! 274: /* save statistics.... */ ! 275: markstats(e, to); ! 276: ! 277: /* ! 278: ** See if this user name is "special". ! 279: ** If the user name has a slash in it, assume that this ! 280: ** is a file -- send it off without further ado. Note ! 281: ** that this type of addresses is not processed along ! 282: ** with the others, so we fudge on the To person. ! 283: */ ! 284: ! 285: if (m == LocalMailer) ! 286: { ! 287: if (user[0] == '/') ! 288: { ! 289: rcode = mailfile(user, getctladdr(to)); ! 290: giveresponse(rcode, m, e); ! 291: continue; ! 292: } ! 293: } ! 294: ! 295: /* ! 296: ** Address is verified -- add this user to mailer ! 297: ** argv, and add it to the print list of recipients. ! 298: */ ! 299: ! 300: /* link together the chain of recipients */ ! 301: to->q_tchain = tochain; ! 302: tochain = to; ! 303: ! 304: /* create list of users for error messages */ ! 305: (void) strcat(tobuf, ","); ! 306: (void) strcat(tobuf, to->q_paddr); ! 307: define('u', user, e); /* to user */ ! 308: define('z', to->q_home, e); /* user's home */ ! 309: ! 310: /* ! 311: ** Expand out this user into argument list. ! 312: */ ! 313: ! 314: if (!clever) ! 315: { ! 316: expand(*mvp, buf, &buf[sizeof buf - 1], e); ! 317: *pvp++ = newstr(buf); ! 318: if (pvp >= &pv[MAXPV - 2]) ! 319: { ! 320: /* allow some space for trailing parms */ ! 321: break; ! 322: } ! 323: } ! 324: } ! 325: ! 326: /* see if any addresses still exist */ ! 327: if (tobuf[0] == '\0') ! 328: { ! 329: define('g', (char *) NULL, e); ! 330: return (0); ! 331: } ! 332: ! 333: /* print out messages as full list */ ! 334: e->e_to = tobuf + 1; ! 335: ! 336: /* ! 337: ** Fill out any parameters after the $u parameter. ! 338: */ ! 339: ! 340: while (!clever && *++mvp != NULL) ! 341: { ! 342: expand(*mvp, buf, &buf[sizeof buf - 1], e); ! 343: *pvp++ = newstr(buf); ! 344: if (pvp >= &pv[MAXPV]) ! 345: syserr("deliver: pv overflow after $u for %s", pv[0]); ! 346: } ! 347: *pvp++ = NULL; ! 348: ! 349: /* ! 350: ** Call the mailer. ! 351: ** The argument vector gets built, pipes ! 352: ** are created as necessary, and we fork & exec as ! 353: ** appropriate. ! 354: ** If we are running SMTP, we just need to clean up. ! 355: */ ! 356: ! 357: message(Arpa_Info, "Connecting to %s.%s...", host, m->m_name); ! 358: ! 359: if (ctladdr == NULL) ! 360: ctladdr = &e->e_from; ! 361: # ifdef SMTP ! 362: if (clever) ! 363: { ! 364: /* send the initial SMTP protocol */ ! 365: rcode = smtpinit(m, pv); ! 366: ! 367: if (rcode == EX_OK) ! 368: { ! 369: /* send the recipient list */ ! 370: tobuf[0] = '\0'; ! 371: for (to = tochain; to != NULL; to = to->q_tchain) ! 372: { ! 373: int i; ! 374: ! 375: e->e_to = to->q_paddr; ! 376: i = smtprcpt(to, m); ! 377: if (i != EX_OK) ! 378: { ! 379: markfailure(e, to, i); ! 380: giveresponse(i, m, e); ! 381: } ! 382: else ! 383: { ! 384: (void) strcat(tobuf, ","); ! 385: (void) strcat(tobuf, to->q_paddr); ! 386: } ! 387: } ! 388: ! 389: /* now send the data */ ! 390: if (tobuf[0] == '\0') ! 391: e->e_to = NULL; ! 392: else ! 393: { ! 394: e->e_to = tobuf + 1; ! 395: rcode = smtpdata(m, e); ! 396: } ! 397: ! 398: /* now close the connection */ ! 399: smtpquit(m); ! 400: } ! 401: } ! 402: else ! 403: # endif SMTP ! 404: rcode = sendoff(e, m, pv, ctladdr); ! 405: ! 406: /* ! 407: ** Do final status disposal. ! 408: ** We check for something in tobuf for the SMTP case. ! 409: ** If we got a temporary failure, arrange to queue the ! 410: ** addressees. ! 411: */ ! 412: ! 413: if (tobuf[0] != '\0') ! 414: giveresponse(rcode, m, e); ! 415: if (rcode != EX_OK) ! 416: { ! 417: for (to = tochain; to != NULL; to = to->q_tchain) ! 418: markfailure(e, to, rcode); ! 419: } ! 420: ! 421: errno = 0; ! 422: define('g', (char *) NULL, e); ! 423: return (rcode); ! 424: } ! 425: /* ! 426: ** MARKFAILURE -- mark a failure on a specific address. ! 427: ** ! 428: ** Parameters: ! 429: ** e -- the envelope we are sending. ! 430: ** q -- the address to mark. ! 431: ** rcode -- the code signifying the particular failure. ! 432: ** ! 433: ** Returns: ! 434: ** none. ! 435: ** ! 436: ** Side Effects: ! 437: ** marks the address (and possibly the envelope) with the ! 438: ** failure so that an error will be returned or ! 439: ** the message will be queued, as appropriate. ! 440: */ ! 441: ! 442: markfailure(e, q, rcode) ! 443: register ENVELOPE *e; ! 444: register ADDRESS *q; ! 445: int rcode; ! 446: { ! 447: if (rcode == EX_OK) ! 448: return; ! 449: else if (rcode != EX_TEMPFAIL) ! 450: q->q_flags |= QBADADDR; ! 451: else if (curtime() > e->e_ctime + TimeOut) ! 452: { ! 453: extern char *pintvl(); ! 454: char buf[MAXLINE]; ! 455: ! 456: if (!bitset(EF_TIMEOUT, e->e_flags)) ! 457: { ! 458: (void) sprintf(buf, "Cannot send message for %s", ! 459: pintvl(TimeOut, FALSE)); ! 460: if (e->e_message != NULL) ! 461: free(e->e_message); ! 462: e->e_message = newstr(buf); ! 463: message(Arpa_Info, buf); ! 464: } ! 465: q->q_flags |= QBADADDR; ! 466: e->e_flags |= EF_TIMEOUT; ! 467: } ! 468: else ! 469: q->q_flags |= QQUEUEUP; ! 470: } ! 471: /* ! 472: ** DOFORK -- do a fork, retrying a couple of times on failure. ! 473: ** ! 474: ** This MUST be a macro, since after a vfork we are running ! 475: ** two processes on the same stack!!! ! 476: ** ! 477: ** Parameters: ! 478: ** none. ! 479: ** ! 480: ** Returns: ! 481: ** From a macro??? You've got to be kidding! ! 482: ** ! 483: ** Side Effects: ! 484: ** Modifies the ==> LOCAL <== variable 'pid', leaving: ! 485: ** pid of child in parent, zero in child. ! 486: ** -1 on unrecoverable error. ! 487: ** ! 488: ** Notes: ! 489: ** I'm awfully sorry this looks so awful. That's ! 490: ** vfork for you..... ! 491: */ ! 492: ! 493: # define NFORKTRIES 5 ! 494: # ifdef VMUNIX ! 495: # define XFORK vfork ! 496: # else VMUNIX ! 497: # define XFORK fork ! 498: # endif VMUNIX ! 499: ! 500: # define DOFORK(fORKfN) \ ! 501: {\ ! 502: register int i;\ ! 503: \ ! 504: for (i = NFORKTRIES; --i >= 0; )\ ! 505: {\ ! 506: pid = fORKfN();\ ! 507: if (pid >= 0)\ ! 508: break;\ ! 509: if (i > 0)\ ! 510: sleep((unsigned) NFORKTRIES - i);\ ! 511: }\ ! 512: } ! 513: /* ! 514: ** DOFORK -- simple fork interface to DOFORK. ! 515: ** ! 516: ** Parameters: ! 517: ** none. ! 518: ** ! 519: ** Returns: ! 520: ** pid of child in parent. ! 521: ** zero in child. ! 522: ** -1 on error. ! 523: ** ! 524: ** Side Effects: ! 525: ** returns twice, once in parent and once in child. ! 526: */ ! 527: ! 528: dofork() ! 529: { ! 530: register int pid; ! 531: ! 532: DOFORK(fork); ! 533: return (pid); ! 534: } ! 535: /* ! 536: ** SENDOFF -- send off call to mailer & collect response. ! 537: ** ! 538: ** Parameters: ! 539: ** e -- the envelope to mail. ! 540: ** m -- mailer descriptor. ! 541: ** pvp -- parameter vector to send to it. ! 542: ** ctladdr -- an address pointer controlling the ! 543: ** user/groupid etc. of the mailer. ! 544: ** ! 545: ** Returns: ! 546: ** exit status of mailer. ! 547: ** ! 548: ** Side Effects: ! 549: ** none. ! 550: */ ! 551: ! 552: sendoff(e, m, pvp, ctladdr) ! 553: register ENVELOPE *e; ! 554: MAILER *m; ! 555: char **pvp; ! 556: ADDRESS *ctladdr; ! 557: { ! 558: auto FILE *mfile; ! 559: auto FILE *rfile; ! 560: register int i; ! 561: int pid; ! 562: ! 563: /* ! 564: ** Create connection to mailer. ! 565: */ ! 566: ! 567: pid = openmailer(m, pvp, ctladdr, FALSE, &mfile, &rfile); ! 568: if (pid < 0) ! 569: return (-1); ! 570: ! 571: /* ! 572: ** Format and send message. ! 573: */ ! 574: ! 575: putfromline(mfile, m); ! 576: (*e->e_puthdr)(mfile, m, e); ! 577: putline("\n", mfile, m); ! 578: (*e->e_putbody)(mfile, m, e); ! 579: (void) fclose(mfile); ! 580: ! 581: i = endmailer(pid, pvp[0]); ! 582: ! 583: /* arrange a return receipt if requested */ ! 584: if (e->e_receiptto != NULL && bitnset(M_LOCAL, m->m_flags)) ! 585: { ! 586: e->e_flags |= EF_SENDRECEIPT; ! 587: /* do we want to send back more info? */ ! 588: } ! 589: ! 590: return (i); ! 591: } ! 592: /* ! 593: ** ENDMAILER -- Wait for mailer to terminate. ! 594: ** ! 595: ** We should never get fatal errors (e.g., segmentation ! 596: ** violation), so we report those specially. For other ! 597: ** errors, we choose a status message (into statmsg), ! 598: ** and if it represents an error, we print it. ! 599: ** ! 600: ** Parameters: ! 601: ** pid -- pid of mailer. ! 602: ** name -- name of mailer (for error messages). ! 603: ** ! 604: ** Returns: ! 605: ** exit code of mailer. ! 606: ** ! 607: ** Side Effects: ! 608: ** none. ! 609: */ ! 610: ! 611: endmailer(pid, name) ! 612: int pid; ! 613: char *name; ! 614: { ! 615: int st; ! 616: ! 617: /* in the IPC case there is nothing to wait for */ ! 618: if (pid == 0) ! 619: return (EX_OK); ! 620: ! 621: /* wait for the mailer process to die and collect status */ ! 622: st = waitfor(pid); ! 623: if (st == -1) ! 624: { ! 625: syserr("endmailer %s: wait", name); ! 626: return (EX_SOFTWARE); ! 627: } ! 628: ! 629: /* see if it died a horrid death */ ! 630: if ((st & 0377) != 0) ! 631: { ! 632: syserr("mailer %s died with signal %o", name, st); ! 633: ExitStat = EX_TEMPFAIL; ! 634: return (EX_TEMPFAIL); ! 635: } ! 636: ! 637: /* normal death -- return status */ ! 638: st = (st >> 8) & 0377; ! 639: return (st); ! 640: } ! 641: /* ! 642: ** OPENMAILER -- open connection to mailer. ! 643: ** ! 644: ** Parameters: ! 645: ** m -- mailer descriptor. ! 646: ** pvp -- parameter vector to pass to mailer. ! 647: ** ctladdr -- controlling address for user. ! 648: ** clever -- create a full duplex connection. ! 649: ** pmfile -- pointer to mfile (to mailer) connection. ! 650: ** prfile -- pointer to rfile (from mailer) connection. ! 651: ** ! 652: ** Returns: ! 653: ** pid of mailer ( > 0 ). ! 654: ** -1 on error. ! 655: ** zero on an IPC connection. ! 656: ** ! 657: ** Side Effects: ! 658: ** creates a mailer in a subprocess. ! 659: */ ! 660: ! 661: openmailer(m, pvp, ctladdr, clever, pmfile, prfile) ! 662: MAILER *m; ! 663: char **pvp; ! 664: ADDRESS *ctladdr; ! 665: bool clever; ! 666: FILE **pmfile; ! 667: FILE **prfile; ! 668: { ! 669: int pid; ! 670: int mpvect[2]; ! 671: int rpvect[2]; ! 672: FILE *mfile; ! 673: FILE *rfile; ! 674: extern FILE *fdopen(); ! 675: ! 676: # ifdef DEBUG ! 677: if (tTd(11, 1)) ! 678: { ! 679: printf("openmailer:"); ! 680: printav(pvp); ! 681: } ! 682: # endif DEBUG ! 683: errno = 0; ! 684: ! 685: CurHostName = m->m_mailer; ! 686: ! 687: /* ! 688: ** Deal with the special case of mail handled through an IPC ! 689: ** connection. ! 690: ** In this case we don't actually fork. We must be ! 691: ** running SMTP for this to work. We will return a ! 692: ** zero pid to indicate that we are running IPC. ! 693: ** We also handle a debug version that just talks to stdin/out. ! 694: */ ! 695: ! 696: #ifdef DEBUG ! 697: /* check for Local Person Communication -- not for mortals!!! */ ! 698: if (strcmp(m->m_mailer, "[LPC]") == 0) ! 699: { ! 700: *pmfile = stdout; ! 701: *prfile = stdin; ! 702: return (0); ! 703: } ! 704: #endif DEBUG ! 705: ! 706: if (strcmp(m->m_mailer, "[IPC]") == 0) ! 707: { ! 708: #ifdef HOSTINFO ! 709: register STAB *st; ! 710: extern STAB *stab(); ! 711: #endif HOSTINFO ! 712: #ifdef DAEMON ! 713: register int i; ! 714: register u_short port; ! 715: ! 716: CurHostName = pvp[1]; ! 717: if (!clever) ! 718: syserr("non-clever IPC"); ! 719: if (pvp[2] != NULL) ! 720: port = atoi(pvp[2]); ! 721: else ! 722: port = 0; ! 723: #ifdef HOSTINFO ! 724: /* see if we have already determined that this host is fried */ ! 725: st = stab(pvp[1], ST_HOST, ST_FIND); ! 726: if (st == NULL || st->s_host.ho_exitstat == EX_OK) ! 727: i = makeconnection(pvp[1], port, pmfile, prfile); ! 728: else ! 729: { ! 730: i = st->s_host.ho_exitstat; ! 731: errno = st->s_host.ho_errno; ! 732: } ! 733: #else HOSTINFO ! 734: i = makeconnection(pvp[1], port, pmfile, prfile); ! 735: #endif HOSTINFO ! 736: if (i != EX_OK) ! 737: { ! 738: #ifdef HOSTINFO ! 739: /* enter status of this host */ ! 740: if (st == NULL) ! 741: st = stab(pvp[1], ST_HOST, ST_ENTER); ! 742: st->s_host.ho_exitstat = i; ! 743: st->s_host.ho_errno = errno; ! 744: #endif HOSTINFO ! 745: ExitStat = i; ! 746: return (-1); ! 747: } ! 748: else ! 749: return (0); ! 750: #else DAEMON ! 751: syserr("openmailer: no IPC"); ! 752: return (-1); ! 753: #endif DAEMON ! 754: } ! 755: ! 756: /* create a pipe to shove the mail through */ ! 757: if (pipe(mpvect) < 0) ! 758: { ! 759: syserr("openmailer: pipe (to mailer)"); ! 760: return (-1); ! 761: } ! 762: ! 763: #ifdef SMTP ! 764: /* if this mailer speaks smtp, create a return pipe */ ! 765: if (clever && pipe(rpvect) < 0) ! 766: { ! 767: syserr("openmailer: pipe (from mailer)"); ! 768: (void) close(mpvect[0]); ! 769: (void) close(mpvect[1]); ! 770: return (-1); ! 771: } ! 772: #endif SMTP ! 773: ! 774: /* ! 775: ** Actually fork the mailer process. ! 776: ** DOFORK is clever about retrying. ! 777: ** ! 778: ** Dispose of SIGCHLD signal catchers that may be laying ! 779: ** around so that endmail will get it. ! 780: */ ! 781: ! 782: if (CurEnv->e_xfp != NULL) ! 783: (void) fflush(CurEnv->e_xfp); /* for debugging */ ! 784: (void) fflush(stdout); ! 785: # ifdef SIGCHLD ! 786: (void) signal(SIGCHLD, SIG_DFL); ! 787: # endif SIGCHLD ! 788: DOFORK(XFORK); ! 789: /* pid is set by DOFORK */ ! 790: if (pid < 0) ! 791: { ! 792: /* failure */ ! 793: syserr("openmailer: cannot fork"); ! 794: (void) close(mpvect[0]); ! 795: (void) close(mpvect[1]); ! 796: #ifdef SMTP ! 797: if (clever) ! 798: { ! 799: (void) close(rpvect[0]); ! 800: (void) close(rpvect[1]); ! 801: } ! 802: #endif SMTP ! 803: return (-1); ! 804: } ! 805: else if (pid == 0) ! 806: { ! 807: int i; ! 808: extern int DtableSize; ! 809: ! 810: /* child -- set up input & exec mailer */ ! 811: /* make diagnostic output be standard output */ ! 812: (void) signal(SIGINT, SIG_IGN); ! 813: (void) signal(SIGHUP, SIG_IGN); ! 814: (void) signal(SIGTERM, SIG_DFL); ! 815: ! 816: /* arrange to filter standard & diag output of command */ ! 817: if (clever) ! 818: { ! 819: (void) close(rpvect[0]); ! 820: (void) close(1); ! 821: (void) dup(rpvect[1]); ! 822: (void) close(rpvect[1]); ! 823: } ! 824: else if (OpMode == MD_SMTP || HoldErrs) ! 825: { ! 826: /* put mailer output in transcript */ ! 827: (void) close(1); ! 828: (void) dup(fileno(CurEnv->e_xfp)); ! 829: } ! 830: (void) close(2); ! 831: (void) dup(1); ! 832: ! 833: /* arrange to get standard input */ ! 834: (void) close(mpvect[1]); ! 835: (void) close(0); ! 836: if (dup(mpvect[0]) < 0) ! 837: { ! 838: syserr("Cannot dup to zero!"); ! 839: _exit(EX_OSERR); ! 840: } ! 841: (void) close(mpvect[0]); ! 842: if (!bitnset(M_RESTR, m->m_flags)) ! 843: { ! 844: if (ctladdr == NULL || ctladdr->q_uid == 0) ! 845: { ! 846: (void) setgid(DefGid); ! 847: (void) setuid(DefUid); ! 848: } ! 849: else ! 850: { ! 851: (void) setgid(ctladdr->q_gid); ! 852: (void) setuid(ctladdr->q_uid); ! 853: } ! 854: } ! 855: ! 856: /* arrange for all the files to be closed */ ! 857: for (i = 3; i < DtableSize; i++) ! 858: #ifdef FIOCLEX ! 859: (void) ioctl(i, FIOCLEX, 0); ! 860: #else FIOCLEX ! 861: (void) close(i); ! 862: #endif FIOCLEX ! 863: ! 864: /* try to execute the mailer */ ! 865: execve(m->m_mailer, pvp, UserEnviron); ! 866: ! 867: #ifdef FIOCLEX ! 868: syserr("Cannot exec %s", m->m_mailer); ! 869: #else FIOCLEX ! 870: printf("Cannot exec '%s' errno=%d\n", m->m_mailer, errno); ! 871: (void) fflush(stdout); ! 872: #endif FIOCLEX ! 873: if (m == LocalMailer || errno == EIO || errno == EAGAIN || ! 874: errno == ENOMEM || errno == EPROCLIM) ! 875: _exit(EX_TEMPFAIL); ! 876: else ! 877: _exit(EX_UNAVAILABLE); ! 878: } ! 879: ! 880: /* ! 881: ** Set up return value. ! 882: */ ! 883: ! 884: (void) close(mpvect[0]); ! 885: mfile = fdopen(mpvect[1], "w"); ! 886: if (clever) ! 887: { ! 888: (void) close(rpvect[1]); ! 889: rfile = fdopen(rpvect[0], "r"); ! 890: } ! 891: ! 892: *pmfile = mfile; ! 893: *prfile = rfile; ! 894: ! 895: return (pid); ! 896: } ! 897: /* ! 898: ** GIVERESPONSE -- Interpret an error response from a mailer ! 899: ** ! 900: ** Parameters: ! 901: ** stat -- the status code from the mailer (high byte ! 902: ** only; core dumps must have been taken care of ! 903: ** already). ! 904: ** m -- the mailer descriptor for this mailer. ! 905: ** ! 906: ** Returns: ! 907: ** none. ! 908: ** ! 909: ** Side Effects: ! 910: ** Errors may be incremented. ! 911: ** ExitStat may be set. ! 912: */ ! 913: ! 914: giveresponse(stat, m, e) ! 915: int stat; ! 916: register MAILER *m; ! 917: ENVELOPE *e; ! 918: { ! 919: register char *statmsg; ! 920: extern char *SysExMsg[]; ! 921: register int i; ! 922: extern int N_SysEx; ! 923: char buf[MAXLINE]; ! 924: ! 925: #ifdef lint ! 926: if (m == NULL) ! 927: return; ! 928: #endif lint ! 929: ! 930: /* ! 931: ** Compute status message from code. ! 932: */ ! 933: ! 934: i = stat - EX__BASE; ! 935: if (stat == 0) ! 936: statmsg = "250 Sent"; ! 937: else if (i < 0 || i > N_SysEx) ! 938: { ! 939: (void) sprintf(buf, "554 unknown mailer error %d", stat); ! 940: stat = EX_UNAVAILABLE; ! 941: statmsg = buf; ! 942: } ! 943: else if (stat == EX_TEMPFAIL) ! 944: { ! 945: (void) strcpy(buf, SysExMsg[i]); ! 946: if (h_errno == TRY_AGAIN) ! 947: { ! 948: extern char *errstring(); ! 949: ! 950: statmsg = errstring(h_errno+MAX_ERRNO); ! 951: } ! 952: else ! 953: { ! 954: if (errno != 0) ! 955: { ! 956: extern char *errstring(); ! 957: ! 958: statmsg = errstring(errno); ! 959: } ! 960: else ! 961: { ! 962: #ifdef SMTP ! 963: extern char SmtpError[]; ! 964: ! 965: statmsg = SmtpError; ! 966: #else SMTP ! 967: statmsg = NULL; ! 968: #endif SMTP ! 969: } ! 970: } ! 971: if (statmsg != NULL && statmsg[0] != '\0') ! 972: { ! 973: (void) strcat(buf, ": "); ! 974: (void) strcat(buf, statmsg); ! 975: } ! 976: statmsg = buf; ! 977: } ! 978: else ! 979: { ! 980: statmsg = SysExMsg[i]; ! 981: } ! 982: ! 983: /* ! 984: ** Print the message as appropriate ! 985: */ ! 986: ! 987: if (stat == EX_OK || stat == EX_TEMPFAIL) ! 988: message(Arpa_Info, &statmsg[4]); ! 989: else ! 990: { ! 991: Errors++; ! 992: usrerr(statmsg); ! 993: } ! 994: ! 995: /* ! 996: ** Final cleanup. ! 997: ** Log a record of the transaction. Compute the new ! 998: ** ExitStat -- if we already had an error, stick with ! 999: ** that. ! 1000: */ ! 1001: ! 1002: if (LogLevel > ((stat == 0 || stat == EX_TEMPFAIL) ? 3 : 2)) ! 1003: logdelivery(&statmsg[4]); ! 1004: ! 1005: if (stat != EX_TEMPFAIL) ! 1006: setstat(stat); ! 1007: if (stat != EX_OK) ! 1008: { ! 1009: if (e->e_message != NULL) ! 1010: free(e->e_message); ! 1011: e->e_message = newstr(&statmsg[4]); ! 1012: } ! 1013: errno = 0; ! 1014: h_errno = 0; ! 1015: } ! 1016: /* ! 1017: ** LOGDELIVERY -- log the delivery in the system log ! 1018: ** ! 1019: ** Parameters: ! 1020: ** stat -- the message to print for the status ! 1021: ** ! 1022: ** Returns: ! 1023: ** none ! 1024: ** ! 1025: ** Side Effects: ! 1026: ** none ! 1027: */ ! 1028: ! 1029: logdelivery(stat) ! 1030: char *stat; ! 1031: { ! 1032: extern char *pintvl(); ! 1033: ! 1034: # ifdef LOG ! 1035: syslog(LOG_INFO, "%s: to=%s, delay=%s, stat=%s", CurEnv->e_id, ! 1036: CurEnv->e_to, pintvl(curtime() - CurEnv->e_ctime, TRUE), stat); ! 1037: # endif LOG ! 1038: } ! 1039: /* ! 1040: ** PUTFROMLINE -- output a UNIX-style from line (or whatever) ! 1041: ** ! 1042: ** This can be made an arbitrary message separator by changing $l ! 1043: ** ! 1044: ** One of the ugliest hacks seen by human eyes is contained herein: ! 1045: ** UUCP wants those stupid "remote from <host>" lines. Why oh why ! 1046: ** does a well-meaning programmer such as myself have to deal with ! 1047: ** this kind of antique garbage???? ! 1048: ** ! 1049: ** Parameters: ! 1050: ** fp -- the file to output to. ! 1051: ** m -- the mailer describing this entry. ! 1052: ** ! 1053: ** Returns: ! 1054: ** none ! 1055: ** ! 1056: ** Side Effects: ! 1057: ** outputs some text to fp. ! 1058: */ ! 1059: ! 1060: putfromline(fp, m) ! 1061: register FILE *fp; ! 1062: register MAILER *m; ! 1063: { ! 1064: char *template = "\001l\n"; ! 1065: char buf[MAXLINE]; ! 1066: ! 1067: if (bitnset(M_NHDR, m->m_flags)) ! 1068: return; ! 1069: ! 1070: # ifdef UGLYUUCP ! 1071: if (bitnset(M_UGLYUUCP, m->m_flags)) ! 1072: { ! 1073: char *bang; ! 1074: char xbuf[MAXLINE]; ! 1075: ! 1076: expand("\001g", buf, &buf[sizeof buf - 1], CurEnv); ! 1077: bang = index(buf, '!'); ! 1078: if (bang == NULL) ! 1079: syserr("No ! in UUCP! (%s)", buf); ! 1080: else ! 1081: { ! 1082: *bang++ = '\0'; ! 1083: (void) sprintf(xbuf, "From %s \001d remote from %s\n", bang, buf); ! 1084: template = xbuf; ! 1085: } ! 1086: } ! 1087: # endif UGLYUUCP ! 1088: expand(template, buf, &buf[sizeof buf - 1], CurEnv); ! 1089: putline(buf, fp, m); ! 1090: } ! 1091: /* ! 1092: ** PUTBODY -- put the body of a message. ! 1093: ** ! 1094: ** Parameters: ! 1095: ** fp -- file to output onto. ! 1096: ** m -- a mailer descriptor to control output format. ! 1097: ** e -- the envelope to put out. ! 1098: ** ! 1099: ** Returns: ! 1100: ** none. ! 1101: ** ! 1102: ** Side Effects: ! 1103: ** The message is written onto fp. ! 1104: */ ! 1105: ! 1106: putbody(fp, m, e) ! 1107: FILE *fp; ! 1108: MAILER *m; ! 1109: register ENVELOPE *e; ! 1110: { ! 1111: char buf[MAXLINE]; ! 1112: ! 1113: /* ! 1114: ** Output the body of the message ! 1115: */ ! 1116: ! 1117: if (e->e_dfp == NULL) ! 1118: { ! 1119: if (e->e_df != NULL) ! 1120: { ! 1121: e->e_dfp = fopen(e->e_df, "r"); ! 1122: if (e->e_dfp == NULL) ! 1123: syserr("Cannot open %s", e->e_df); ! 1124: } ! 1125: else ! 1126: putline("<<< No Message Collected >>>", fp, m); ! 1127: } ! 1128: if (e->e_dfp != NULL) ! 1129: { ! 1130: rewind(e->e_dfp); ! 1131: while (!ferror(fp) && fgets(buf, sizeof buf, e->e_dfp) != NULL) ! 1132: { ! 1133: if (buf[0] == 'F' && bitnset(M_ESCFROM, m->m_flags) && ! 1134: strncmp(buf, "From", 4) == 0) ! 1135: (void) putc('>', fp); ! 1136: putline(buf, fp, m); ! 1137: } ! 1138: ! 1139: if (ferror(e->e_dfp)) ! 1140: { ! 1141: syserr("putbody: read error"); ! 1142: ExitStat = EX_IOERR; ! 1143: } ! 1144: } ! 1145: ! 1146: (void) fflush(fp); ! 1147: if (ferror(fp) && errno != EPIPE) ! 1148: { ! 1149: syserr("putbody: write error"); ! 1150: ExitStat = EX_IOERR; ! 1151: } ! 1152: errno = 0; ! 1153: } ! 1154: /* ! 1155: ** MAILFILE -- Send a message to a file. ! 1156: ** ! 1157: ** If the file has the setuid/setgid bits set, but NO execute ! 1158: ** bits, sendmail will try to become the owner of that file ! 1159: ** rather than the real user. Obviously, this only works if ! 1160: ** sendmail runs as root. ! 1161: ** ! 1162: ** This could be done as a subordinate mailer, except that it ! 1163: ** is used implicitly to save messages in ~/dead.letter. We ! 1164: ** view this as being sufficiently important as to include it ! 1165: ** here. For example, if the system is dying, we shouldn't have ! 1166: ** to create another process plus some pipes to save the message. ! 1167: ** ! 1168: ** Parameters: ! 1169: ** filename -- the name of the file to send to. ! 1170: ** ctladdr -- the controlling address header -- includes ! 1171: ** the userid/groupid to be when sending. ! 1172: ** ! 1173: ** Returns: ! 1174: ** The exit code associated with the operation. ! 1175: ** ! 1176: ** Side Effects: ! 1177: ** none. ! 1178: */ ! 1179: ! 1180: mailfile(filename, ctladdr) ! 1181: char *filename; ! 1182: ADDRESS *ctladdr; ! 1183: { ! 1184: register FILE *f; ! 1185: register int pid; ! 1186: ! 1187: /* ! 1188: ** Fork so we can change permissions here. ! 1189: ** Note that we MUST use fork, not vfork, because of ! 1190: ** the complications of calling subroutines, etc. ! 1191: */ ! 1192: ! 1193: DOFORK(fork); ! 1194: ! 1195: if (pid < 0) ! 1196: return (EX_OSERR); ! 1197: else if (pid == 0) ! 1198: { ! 1199: /* child -- actually write to file */ ! 1200: struct stat stb; ! 1201: ! 1202: (void) signal(SIGINT, SIG_DFL); ! 1203: (void) signal(SIGHUP, SIG_DFL); ! 1204: (void) signal(SIGTERM, SIG_DFL); ! 1205: (void) umask(OldUmask); ! 1206: if (stat(filename, &stb) < 0) ! 1207: { ! 1208: errno = 0; ! 1209: stb.st_mode = 0666; ! 1210: } ! 1211: if (bitset(0111, stb.st_mode)) ! 1212: exit(EX_CANTCREAT); ! 1213: if (ctladdr == NULL) ! 1214: ctladdr = &CurEnv->e_from; ! 1215: if (!bitset(S_ISGID, stb.st_mode) || setgid(stb.st_gid) < 0) ! 1216: { ! 1217: if (ctladdr->q_uid == 0) ! 1218: (void) setgid(DefGid); ! 1219: else ! 1220: (void) setgid(ctladdr->q_gid); ! 1221: } ! 1222: if (!bitset(S_ISUID, stb.st_mode) || setuid(stb.st_uid) < 0) ! 1223: { ! 1224: if (ctladdr->q_uid == 0) ! 1225: (void) setuid(DefUid); ! 1226: else ! 1227: (void) setuid(ctladdr->q_uid); ! 1228: } ! 1229: f = dfopen(filename, "a"); ! 1230: if (f == NULL) ! 1231: exit(EX_CANTCREAT); ! 1232: ! 1233: putfromline(f, ProgMailer); ! 1234: (*CurEnv->e_puthdr)(f, ProgMailer, CurEnv); ! 1235: putline("\n", f, ProgMailer); ! 1236: (*CurEnv->e_putbody)(f, ProgMailer, CurEnv); ! 1237: putline("\n", f, ProgMailer); ! 1238: (void) fclose(f); ! 1239: (void) fflush(stdout); ! 1240: ! 1241: /* reset ISUID & ISGID bits for paranoid systems */ ! 1242: (void) chmod(filename, (int) stb.st_mode); ! 1243: exit(EX_OK); ! 1244: /*NOTREACHED*/ ! 1245: } ! 1246: else ! 1247: { ! 1248: /* parent -- wait for exit status */ ! 1249: int st; ! 1250: ! 1251: st = waitfor(pid); ! 1252: if ((st & 0377) != 0) ! 1253: return (EX_UNAVAILABLE); ! 1254: else ! 1255: return ((st >> 8) & 0377); ! 1256: } ! 1257: } ! 1258: /* ! 1259: ** SENDALL -- actually send all the messages. ! 1260: ** ! 1261: ** Parameters: ! 1262: ** e -- the envelope to send. ! 1263: ** mode -- the delivery mode to use. If SM_DEFAULT, use ! 1264: ** the current SendMode. ! 1265: ** ! 1266: ** Returns: ! 1267: ** none. ! 1268: ** ! 1269: ** Side Effects: ! 1270: ** Scans the send lists and sends everything it finds. ! 1271: ** Delivers any appropriate error messages. ! 1272: ** If we are running in a non-interactive mode, takes the ! 1273: ** appropriate action. ! 1274: */ ! 1275: ! 1276: sendall(e, mode) ! 1277: ENVELOPE *e; ! 1278: char mode; ! 1279: { ! 1280: register ADDRESS *q; ! 1281: bool oldverbose; ! 1282: int pid; ! 1283: ! 1284: /* determine actual delivery mode */ ! 1285: if (mode == SM_DEFAULT) ! 1286: { ! 1287: extern bool shouldqueue(); ! 1288: ! 1289: if (shouldqueue(e->e_msgpriority)) ! 1290: mode = SM_QUEUE; ! 1291: else ! 1292: mode = SendMode; ! 1293: } ! 1294: ! 1295: #ifdef DEBUG ! 1296: if (tTd(13, 1)) ! 1297: { ! 1298: printf("\nSENDALL: mode %c, sendqueue:\n", mode); ! 1299: printaddr(e->e_sendqueue, TRUE); ! 1300: } ! 1301: #endif DEBUG ! 1302: ! 1303: /* ! 1304: ** Do any preprocessing necessary for the mode we are running. ! 1305: ** Check to make sure the hop count is reasonable. ! 1306: ** Delete sends to the sender in mailing lists. ! 1307: */ ! 1308: ! 1309: CurEnv = e; ! 1310: ! 1311: if (e->e_hopcount > MAXHOP) ! 1312: { ! 1313: syserr("sendall: too many hops (%d max)", MAXHOP); ! 1314: return; ! 1315: } ! 1316: ! 1317: if (!MeToo) ! 1318: { ! 1319: extern ADDRESS *recipient(); ! 1320: ! 1321: e->e_from.q_flags |= QDONTSEND; ! 1322: (void) recipient(&e->e_from, &e->e_sendqueue); ! 1323: } ! 1324: ! 1325: # ifdef QUEUE ! 1326: if ((mode == SM_QUEUE || mode == SM_FORK || ! 1327: (mode != SM_VERIFY && SuperSafe)) && ! 1328: !bitset(EF_INQUEUE, e->e_flags)) ! 1329: queueup(e, TRUE, mode == SM_QUEUE); ! 1330: #endif QUEUE ! 1331: ! 1332: oldverbose = Verbose; ! 1333: switch (mode) ! 1334: { ! 1335: case SM_VERIFY: ! 1336: Verbose = TRUE; ! 1337: break; ! 1338: ! 1339: case SM_QUEUE: ! 1340: e->e_flags |= EF_INQUEUE|EF_KEEPQUEUE; ! 1341: return; ! 1342: ! 1343: case SM_FORK: ! 1344: if (e->e_xfp != NULL) ! 1345: (void) fflush(e->e_xfp); ! 1346: pid = fork(); ! 1347: if (pid < 0) ! 1348: { ! 1349: mode = SM_DELIVER; ! 1350: break; ! 1351: } ! 1352: else if (pid > 0) ! 1353: { ! 1354: /* be sure we leave the temp files to our child */ ! 1355: e->e_id = e->e_df = NULL; ! 1356: return; ! 1357: } ! 1358: ! 1359: /* double fork to avoid zombies */ ! 1360: if (fork() > 0) ! 1361: exit(EX_OK); ! 1362: ! 1363: /* be sure we are immune from the terminal */ ! 1364: disconnect(FALSE); ! 1365: ! 1366: break; ! 1367: } ! 1368: ! 1369: /* ! 1370: ** Run through the list and send everything. ! 1371: */ ! 1372: ! 1373: for (q = e->e_sendqueue; q != NULL; q = q->q_next) ! 1374: { ! 1375: if (mode == SM_VERIFY) ! 1376: { ! 1377: e->e_to = q->q_paddr; ! 1378: if (!bitset(QDONTSEND|QBADADDR, q->q_flags)) ! 1379: message(Arpa_Info, "deliverable"); ! 1380: } ! 1381: else ! 1382: (void) deliver(e, q); ! 1383: } ! 1384: Verbose = oldverbose; ! 1385: ! 1386: /* ! 1387: ** Now run through and check for errors. ! 1388: */ ! 1389: ! 1390: if (mode == SM_VERIFY) ! 1391: return; ! 1392: ! 1393: for (q = e->e_sendqueue; q != NULL; q = q->q_next) ! 1394: { ! 1395: register ADDRESS *qq; ! 1396: ! 1397: # ifdef DEBUG ! 1398: if (tTd(13, 3)) ! 1399: { ! 1400: printf("Checking "); ! 1401: printaddr(q, FALSE); ! 1402: } ! 1403: # endif DEBUG ! 1404: ! 1405: /* only send errors if the message failed */ ! 1406: if (!bitset(QBADADDR, q->q_flags)) ! 1407: continue; ! 1408: ! 1409: /* we have an address that failed -- find the parent */ ! 1410: for (qq = q; qq != NULL; qq = qq->q_alias) ! 1411: { ! 1412: char obuf[MAXNAME + 6]; ! 1413: extern char *aliaslookup(); ! 1414: ! 1415: /* we can only have owners for local addresses */ ! 1416: if (!bitnset(M_LOCAL, qq->q_mailer->m_flags)) ! 1417: continue; ! 1418: ! 1419: /* see if the owner list exists */ ! 1420: (void) strcpy(obuf, "owner-"); ! 1421: if (strncmp(qq->q_user, "owner-", 6) == 0) ! 1422: (void) strcat(obuf, "owner"); ! 1423: else ! 1424: (void) strcat(obuf, qq->q_user); ! 1425: if (aliaslookup(obuf) == NULL) ! 1426: continue; ! 1427: ! 1428: # ifdef DEBUG ! 1429: if (tTd(13, 4)) ! 1430: printf("Errors to %s\n", obuf); ! 1431: # endif DEBUG ! 1432: ! 1433: /* owner list exists -- add it to the error queue */ ! 1434: sendtolist(obuf, (ADDRESS *) NULL, &e->e_errorqueue); ! 1435: ErrorMode = EM_MAIL; ! 1436: break; ! 1437: } ! 1438: ! 1439: /* if we did not find an owner, send to the sender */ ! 1440: if (qq == NULL && bitset(QBADADDR, q->q_flags)) ! 1441: sendtolist(e->e_from.q_paddr, qq, &e->e_errorqueue); ! 1442: } ! 1443: ! 1444: if (mode == SM_FORK) ! 1445: finis(); ! 1446: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.