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