![[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.