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