![[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] / 40BSD / cmd / delivermail|
Return to deliver.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / delivermail |
1.1 root 1: # include <stdio.h>
2: # include <pwd.h>
3: # include <signal.h>
4: # include "dlvrmail.h"
5: # ifdef LOG
6: # include <log.h>
7: # endif LOG
8:
9: static char SccsId[] = "@(#)deliver.c 1.11 10/27/80";
10:
11: /*
12: ** DELIVER -- Deliver a message to a particular address.
13: **
14: ** Algorithm:
15: ** Compute receiving network (i.e., mailer), host, & user.
16: ** If local, see if this is really a program name.
17: ** Build argument for the mailer.
18: ** Create pipe through edit fcn if appropriate.
19: ** Fork.
20: ** Child: call mailer
21: ** Parent: call editfcn if specified.
22: ** Wait for mailer to finish.
23: ** Interpret exit status.
24: **
25: ** Parameters:
26: ** to -- the address to deliver the message to.
27: ** editfcn -- if non-NULL, we want to call this function
28: ** to output the letter (instead of just out-
29: ** putting it raw).
30: **
31: ** Returns:
32: ** zero -- successfully delivered.
33: ** else -- some failure, see ExitStat for more info.
34: **
35: ** Side Effects:
36: ** The standard input is passed off to someone.
37: **
38: ** WARNING:
39: ** The standard input is shared amongst all children,
40: ** including the file pointer. It is critical that the
41: ** parent waits for the child to finish before forking
42: ** another child.
43: **
44: ** Called By:
45: ** main
46: ** savemail
47: **
48: ** Files:
49: ** standard input -- must be opened to the message to
50: ** deliver.
51: */
52:
53: deliver(to, editfcn)
54: addrq *to;
55: int (*editfcn)();
56: {
57: register struct mailer *m;
58: char *host;
59: char *user;
60: extern struct passwd *getpwnam();
61: char **pvp;
62: extern char **buildargv();
63: auto int st;
64: register int i;
65: register char *p;
66: int pid;
67: int pvect[2];
68: extern FILE *fdopen();
69: extern int errno;
70: FILE *mfile;
71: extern putheader();
72: extern pipesig();
73:
74: /*
75: ** Compute receiving mailer, host, and to addreses.
76: ** Do some initialization first. To is the to address
77: ** for error messages.
78: */
79:
80: To = to->q_paddr;
81: m = to->q_mailer;
82: user = to->q_user;
83: host = to->q_host;
84: Errors = 0;
85: errno = 0;
86: # ifdef DEBUG
87: if (Debug)
88: printf("deliver(%s [%d, `%s', `%s'])\n", To, m, host, user);
89: # endif DEBUG
90:
91: /*
92: ** Remove quote bits from user/host.
93: */
94:
95: for (p = user; (*p++ &= 0177) != '\0'; )
96: continue;
97: if (host != NULL)
98: for (p = host; (*p++ &= 0177) != '\0'; )
99: continue;
100:
101: /*
102: ** Strip quote bits from names if the mailer wants it.
103: */
104:
105: if (flagset(M_STRIPQ, m->m_flags))
106: {
107: stripquotes(user);
108: stripquotes(host);
109: }
110:
111: /*
112: ** See if this user name is "special".
113: ** If the user is a program, diddle with the mailer spec.
114: ** If the user name has a slash in it, assume that this
115: ** is a file -- send it off without further ado.
116: ** Note that this means that editfcn's will not
117: ** be applied to the message.
118: */
119:
120: if (m == &Mailer[0])
121: {
122: if (*user == '|')
123: {
124: user++;
125: m = &Mailer[1];
126: }
127: else
128: {
129: if (index(user, '/') != NULL)
130: {
131: i = mailfile(user);
132: giveresponse(i, TRUE, m);
133: return (i);
134: }
135: }
136: }
137:
138: /*
139: ** See if the user exists.
140: ** Strictly, this is only needed to print a pretty
141: ** error message.
142: **
143: ** >>>>>>>>>> This clause assumes that the local mailer
144: ** >> NOTE >> cannot do any further aliasing; that
145: ** >>>>>>>>>> function is subsumed by delivermail.
146: */
147:
148: if (m == &Mailer[0])
149: {
150: if (getpwnam(user) == NULL)
151: {
152: giveresponse(EX_NOUSER, TRUE, m);
153: return (EX_NOUSER);
154: }
155: }
156:
157: /*
158: ** If the mailer wants a From line, insert a new editfcn.
159: */
160:
161: if (flagset(M_HDR, m->m_flags) && editfcn == NULL)
162: editfcn = putheader;
163:
164: /*
165: ** Call the mailer.
166: ** The argument vector gets built, pipes through 'editfcn'
167: ** are created as necessary, and we fork & exec as
168: ** appropriate. In the parent, we call 'editfcn'.
169: */
170:
171: pvp = buildargv(m->m_argv, m->m_flags, host, user, From.q_paddr);
172: if (pvp == NULL)
173: {
174: usrerr("name too long");
175: return (-1);
176: }
177: rewind(stdin);
178:
179: /* create a pipe if we will need one */
180: if (editfcn != NULL && pipe(pvect) < 0)
181: {
182: syserr("pipe");
183: return (-1);
184: }
185: # ifdef VFORK
186: pid = vfork();
187: # else
188: pid = fork();
189: # endif
190: if (pid < 0)
191: {
192: syserr("Cannot fork");
193: if (editfcn != NULL)
194: {
195: close(pvect[0]);
196: close(pvect[1]);
197: }
198: return (-1);
199: }
200: else if (pid == 0)
201: {
202: /* child -- set up input & exec mailer */
203: /* make diagnostic output be standard output */
204: close(2);
205: dup(1);
206: signal(SIGINT, SIG_IGN);
207: if (editfcn != NULL)
208: {
209: close(0);
210: if (dup(pvect[0]) < 0)
211: {
212: syserr("Cannot dup to zero!");
213: _exit(EX_OSERR);
214: }
215: close(pvect[0]);
216: close(pvect[1]);
217: }
218: if (!flagset(M_RESTR, m->m_flags))
219: setuid(getuid());
220: # ifdef LOG
221: initlog(NULL, 0, LOG_CLOSE);
222: # endif LOG
223: # ifndef VFORK
224: /*
225: * We have to be careful with vfork - we can't mung up the
226: * memory but we don't want the mailer to inherit any extra
227: * open files. Chances are the mailer won't
228: * care about an extra file, but then again you never know.
229: * Actually, we would like to close(fileno(pwf)), but it's
230: * declared static so we can't. But if we fclose(pwf), which
231: * is what endpwent does, it closes it in the parent too and
232: * the next getpwnam will be slower. If you have a weird mailer
233: * that chokes on the extra file you should do the endpwent().
234: */
235: endpwent();
236: # endif
237: execv(m->m_mailer, pvp);
238: /* syserr fails because log is closed */
239: /* syserr("Cannot exec %s", m->m_mailer); */
240: _exit(EX_UNAVAILABLE);
241: }
242:
243: /* arrange to write out header message if error */
244: if (editfcn != NULL)
245: {
246: close(pvect[0]);
247: signal(SIGPIPE, pipesig);
248: mfile = fdopen(pvect[1], "w");
249: (*editfcn)(mfile);
250: fclose(mfile);
251: }
252:
253: /*
254: ** Wait for child to die and report status.
255: ** We should never get fatal errors (e.g., segmentation
256: ** violation), so we report those specially. For other
257: ** errors, we choose a status message (into statmsg),
258: ** and if it represents an error, we print it.
259: */
260:
261: while ((i = wait(&st)) > 0 && i != pid)
262: continue;
263: if (i < 0)
264: {
265: syserr("wait");
266: return (-1);
267: }
268: if ((st & 0377) != 0)
269: {
270: syserr("%s: stat %o", pvp[0], st);
271: ExitStat = EX_UNAVAILABLE;
272: return (-1);
273: }
274: i = (st >> 8) & 0377;
275: giveresponse(i, FALSE, m);
276: return (i);
277: }
278: /*
279: ** GIVERESPONSE -- Interpret an error response from a mailer
280: **
281: ** Parameters:
282: ** stat -- the status code from the mailer (high byte
283: ** only; core dumps must have been taken care of
284: ** already).
285: ** force -- if set, force an error message output, even
286: ** if the mailer seems to like to print its own
287: ** messages.
288: ** m -- the mailer descriptor for this mailer.
289: **
290: ** Returns:
291: ** none.
292: **
293: ** Side Effects:
294: ** Errors may be incremented.
295: ** ExitStat may be set.
296: **
297: ** Called By:
298: ** deliver
299: */
300:
301: giveresponse(stat, force, m)
302: int stat;
303: int force;
304: register struct mailer *m;
305: {
306: register char *statmsg;
307: extern char *SysExMsg[];
308: register int i;
309: extern int N_SysEx;
310: extern long MsgSize;
311: char buf[30];
312:
313: i = stat - EX__BASE;
314: if (i < 0 || i > N_SysEx)
315: statmsg = NULL;
316: else
317: statmsg = SysExMsg[i];
318: if (stat == 0)
319: statmsg = "ok";
320: else
321: {
322: Errors++;
323: if (statmsg == NULL && m->m_badstat != 0)
324: {
325: stat = m->m_badstat;
326: i = stat - EX__BASE;
327: # ifdef DEBUG
328: if (i < 0 || i >= N_SysEx)
329: syserr("Bad m_badstat %d", stat);
330: else
331: # endif DEBUG
332: statmsg = SysExMsg[i];
333: }
334: if (statmsg == NULL)
335: usrerr("unknown mailer response %d", stat);
336: else if (force || !flagset(M_QUIET, m->m_flags))
337: usrerr("%s", statmsg);
338: }
339:
340: /*
341: ** Final cleanup.
342: ** Log a record of the transaction. Compute the new
343: ** ExitStat -- if we already had an error, stick with
344: ** that.
345: */
346:
347: if (statmsg == NULL)
348: {
349: sprintf(buf, "error %d", stat);
350: statmsg = buf;
351: }
352:
353: # ifdef LOG
354: logmsg(LOG_INFO, "%s->%s: %ld: %s", From.q_paddr, To, MsgSize, statmsg);
355: # endif LOG
356: setstat(stat);
357: return (stat);
358: }
359: /*
360: ** PUTHEADER -- insert the From header into some mail
361: **
362: ** For mailers such as 'msgs' that want the header inserted
363: ** into the mail, this edit filter inserts the From line and
364: ** then passes the rest of the message through.
365: **
366: ** Parameters:
367: ** fp -- the file pointer for the output.
368: **
369: ** Returns:
370: ** none
371: **
372: ** Side Effects:
373: ** Puts a "From" line in UNIX format, and then
374: ** outputs the rest of the message.
375: **
376: ** Called By:
377: ** deliver
378: */
379:
380: putheader(fp)
381: register FILE *fp;
382: {
383: char buf[MAXLINE + 1];
384: long tim;
385: extern char *ctime();
386:
387: time(&tim);
388: fprintf(fp, "From %s %s", From.q_paddr, ctime(&tim));
389: while (fgets(buf, sizeof buf, stdin) != NULL && !ferror(fp))
390: fputs(buf, fp);
391: if (ferror(fp))
392: {
393: syserr("putheader: write error");
394: setstat(EX_IOERR);
395: }
396: }
397: /*
398: ** PIPESIG -- Handle broken pipe signals
399: **
400: ** This just logs an error.
401: **
402: ** Parameters:
403: ** none
404: **
405: ** Returns:
406: ** none
407: **
408: ** Side Effects:
409: ** logs an error message.
410: */
411:
412: pipesig()
413: {
414: syserr("Broken pipe");
415: signal(SIGPIPE, SIG_IGN);
416: }
417: /*
418: ** SENDTO -- Designate a send list.
419: **
420: ** The parameter is a comma-separated list of people to send to.
421: ** This routine arranges to send to all of them.
422: **
423: ** Parameters:
424: ** list -- the send list.
425: ** copyf -- the copy flag; passed to parse.
426: **
427: ** Returns:
428: ** none
429: **
430: ** Side Effects:
431: ** none.
432: **
433: ** Called By:
434: ** main
435: ** alias
436: */
437:
438: sendto(list, copyf)
439: char *list;
440: int copyf;
441: {
442: register char *p;
443: register char *q;
444: register char c;
445: addrq *a;
446: extern addrq *parse();
447: bool more;
448:
449: /* more keeps track of what the previous delimiter was */
450: more = TRUE;
451: for (p = list; more; )
452: {
453: /* find the end of this address */
454: q = p;
455: while ((c = *p++) != '\0' && c != ',' && c != '\n')
456: continue;
457: more = c != '\0';
458: *--p = '\0';
459: if (more)
460: p++;
461:
462: /* parse the address */
463: if ((a = parse(q, (addrq *) NULL, copyf)) == NULL)
464: continue;
465:
466: /* arrange to send to this person */
467: recipient(a, &SendQ);
468: }
469: To = NULL;
470: }
471: /*
472: ** RECIPIENT -- Designate a message recipient
473: **
474: ** Saves the named person for future mailing.
475: **
476: ** Designates a person as a recipient. This routine
477: ** does the initial parsing, and checks to see if
478: ** this person has already received the mail.
479: ** It also supresses local network names and turns them into
480: ** local names.
481: **
482: ** Parameters:
483: ** a -- the (preparsed) address header for the recipient.
484: ** targetq -- the queue to add the name to.
485: **
486: ** Returns:
487: ** none.
488: **
489: ** Side Effects:
490: ** none.
491: **
492: ** Called By:
493: ** sendto
494: ** main
495: */
496:
497: recipient(a, targetq)
498: register addrq *a;
499: addrq *targetq;
500: {
501: register addrq *q;
502: register struct mailer *m;
503: register char **pvp;
504: extern char *xalloc();
505: extern bool forward();
506: extern int errno;
507: extern bool sameaddr();
508:
509: To = a->q_paddr;
510: m = a->q_mailer;
511: errno = 0;
512: # ifdef DEBUG
513: if (Debug)
514: printf("recipient(%s)\n", To);
515: # endif DEBUG
516:
517: /*
518: ** Look up this person in the recipient list. If they
519: ** are there already, return, otherwise continue.
520: */
521:
522: if (!ForceMail)
523: {
524: for (q = &SendQ; (q = nxtinq(q)) != NULL; )
525: if (sameaddr(q, a, FALSE))
526: {
527: # ifdef DEBUG
528: if (Debug)
529: printf("(%s in SendQ)\n", a->q_paddr);
530: # endif DEBUG
531: return;
532: }
533: for (q = &AliasQ; (q = nxtinq(q)) != NULL; )
534: if (sameaddr(q, a, FALSE))
535: {
536: # ifdef DEBUG
537: if (Debug)
538: printf("(%s in AliasQ)\n", a->q_paddr);
539: # endif DEBUG
540: return;
541: }
542: }
543:
544: /*
545: ** See if the user wants hir mail forwarded.
546: ** `Forward' must do the forwarding recursively.
547: */
548:
549: if (m == &Mailer[0] && !NoAlias && targetq == &SendQ && forward(a))
550: return;
551:
552: /*
553: ** Put the user onto the target queue.
554: */
555:
556: if (targetq != NULL)
557: {
558: putonq(a, targetq);
559: }
560:
561: return;
562: }
563: /*
564: ** BUILDARGV -- Build an argument vector for a mail server.
565: **
566: ** Using a template defined in config.c, an argv is built.
567: ** The format of the template is already a vector. The
568: ** items of this vector are copied, unless a dollar sign
569: ** is encountered. In this case, the next character
570: ** specifies something else to copy in. These can be
571: ** $f The from address.
572: ** $h The host.
573: ** $u The user.
574: ** $c The hop count.
575: ** The vector is built in a local buffer. A pointer to
576: ** the static argv is returned.
577: **
578: ** Parameters:
579: ** tmplt -- a template for an argument vector.
580: ** flags -- the flags for this server.
581: ** host -- the host name to send to.
582: ** user -- the user name to send to.
583: ** from -- the person this mail is from.
584: **
585: ** Returns:
586: ** A pointer to an argv.
587: **
588: ** Side Effects:
589: ** none
590: **
591: ** WARNING:
592: ** Since the argv is staticly allocated, any subsequent
593: ** calls will clobber the old argv.
594: **
595: ** Called By:
596: ** deliver
597: */
598:
599: char **
600: buildargv(tmplt, flags, host, user, from)
601: char **tmplt;
602: int flags;
603: char *host;
604: char *user;
605: char *from;
606: {
607: register char *p;
608: register char *q;
609: static char *pv[MAXPV+1];
610: char **pvp;
611: char **mvp;
612: static char buf[512];
613: register char *bp;
614: char pbuf[30];
615:
616: /*
617: ** Do initial argv setup.
618: ** Insert the mailer name. Notice that $x expansion is
619: ** NOT done on the mailer name. Then, if the mailer has
620: ** a picky -f flag, we insert it as appropriate. This
621: ** code does not check for 'pv' overflow; this places a
622: ** manifest lower limit of 4 for MAXPV.
623: */
624:
625: pvp = pv;
626: bp = buf;
627:
628: *pvp++ = tmplt[0];
629:
630: /* insert -f or -r flag as appropriate */
631: if (flagset(M_FOPT|M_ROPT, flags) && FromFlag)
632: {
633: if (flagset(M_FOPT, flags))
634: *pvp++ = "-f";
635: else
636: *pvp++ = "-r";
637: *pvp++ = From.q_paddr;
638: }
639:
640: /*
641: ** Build the rest of argv.
642: ** For each prototype parameter, the prototype is
643: ** scanned character at a time. If a dollar-sign is
644: ** found, 'q' is set to the appropriate expansion,
645: ** otherwise it is null. Then either the string
646: ** pointed to by q, or the original character, is
647: ** interpolated into the buffer. Buffer overflow is
648: ** checked.
649: */
650:
651: for (mvp = tmplt; (p = *++mvp) != NULL; )
652: {
653: if (pvp >= &pv[MAXPV])
654: {
655: syserr("Too many parameters to %s", pv[0]);
656: return (NULL);
657: }
658: *pvp++ = bp;
659: for (; *p != '\0'; p++)
660: {
661: /* q will be the interpolated quantity */
662: q = NULL;
663: if (*p == '$')
664: {
665: switch (*++p)
666: {
667: case 'f': /* from person */
668: q = from;
669: break;
670:
671: case 'u': /* user */
672: q = user;
673: break;
674:
675: case 'h': /* host */
676: q = host;
677: break;
678:
679: case 'c': /* hop count */
680: sprintf(pbuf, "%d", HopCount);
681: q = pbuf;
682: break;
683: }
684: }
685:
686: /*
687: ** Interpolate q or output one character
688: ** Strip quote bits as we proceed.....
689: */
690:
691: if (q != NULL)
692: {
693: while (bp < &buf[sizeof buf - 1] && (*bp++ = *q++) != '\0')
694: continue;
695: bp--;
696: }
697: else if (bp < &buf[sizeof buf - 1])
698: *bp++ = *p;
699: }
700: *bp++ = '\0';
701: if (bp >= &buf[sizeof buf - 1])
702: return (NULL);
703: }
704: *pvp = NULL;
705:
706: # ifdef DEBUG
707: if (Debug)
708: {
709: printf("Interpolated argv is:\n");
710: for (mvp = pv; *mvp != NULL; mvp++)
711: printf("\t%s\n", *mvp);
712: }
713: # endif DEBUG
714:
715: return (pv);
716: }
717: /*
718: ** MAILFILE -- Send a message to a file.
719: **
720: ** Parameters:
721: ** filename -- the name of the file to send to.
722: **
723: ** Returns:
724: ** The exit code associated with the operation.
725: **
726: ** Side Effects:
727: ** none.
728: **
729: ** Called By:
730: ** deliver
731: */
732:
733: mailfile(filename)
734: char *filename;
735: {
736: char buf[MAXLINE];
737: register FILE *f;
738: auto long tim;
739: extern char *ctime();
740:
741: f = fopen(filename, "a");
742: if (f == NULL)
743: return (EX_CANTCREAT);
744:
745: /* output the timestamp */
746: time(&tim);
747: fprintf(f, "From %s %s", From.q_paddr, ctime(&tim));
748: rewind(stdin);
749: while (fgets(buf, sizeof buf, stdin) != NULL)
750: {
751: fputs(buf, f);
752: if (ferror(f))
753: {
754: fclose(f);
755: return (EX_IOERR);
756: }
757: }
758: fputs("\n", f);
759: fclose(f);
760: return (EX_OK);
761: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.