![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to post.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip|
Return to post.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip |
1.1 root 1: /* post.c - enter messages into the transport system */
2:
3: #include "../h/mh.h"
4: #include "../h/addrsbr.h"
5: #include "../h/aliasbr.h"
6: #include "../h/dropsbr.h"
7: #include "../zotnet/tws.h"
8: #ifndef MMDFMTS
9: #include <ctype.h>
10: #include <errno.h>
11: #include <setjmp.h>
12: #include <stdio.h>
13: #include <sys/types.h>
14: #else MMDFMTS
15: #include "../mts/mmdf/util.h"
16: #include "../mts/mmdf/mmdf.h"
17: #endif MMDFMTS
18: #include "../zotnet/mts.h"
19: #ifdef MHMTS
20: #ifndef V7
21: #include <sys/ioctl.h>
22: #endif not V7
23: #include <sys/stat.h>
24: #endif MHMTS
25: #ifdef SENDMTS
26: #include "../mts/sendmail/smail.h"
27: #undef MF
28: #endif SENDMTS
29: #include <signal.h>
30:
31:
32: #ifndef MMDFMTS
33: #define uptolow(c) (isupper (c) ? tolower (c) : (c))
34: #endif not MMDFMTS
35:
36: #define FCCS 10 /* max number of fccs allowed */
37:
38: /* */
39:
40: static struct swit switches[] = {
41: #define ALIASW 0
42: "alias aliasfile", 0,
43:
44: #define CHKSW 1
45: "check", -5, /* interface from whom */
46: #define NCHKSW 2
47: "nocheck", -7, /* interface from whom */
48:
49: #define DEBUGSW 3
50: "debug", -5,
51:
52: #define DISTSW 4
53: "dist", -4, /* interface from dist */
54:
55: #define ENCRSW 5
56: "encrypt",
57: #ifndef TMA
58: -7,
59: #else TMA
60: 0,
61: #endif TMA
62: #define NENCRSW 6
63: "noencrypt",
64: #ifndef TMA
65: -9,
66: #else TMA
67: 0,
68: #endif TMA
69:
70: #define FILTSW 7
71: "filter filterfile", 0,
72: #define NFILTSW 8
73: "nofilter", 0,
74:
75: #define FRMTSW 9
76: "format", 0,
77: #define NFRMTSW 10
78: "noformat", 0,
79:
80: #define LIBSW 11 /* interface from send, whom */
81: "library directory", -7,
82:
83: #define MSGDSW 12
84: "msgid", 0,
85: #define NMSGDSW 13
86: "nomsgid", 0,
87:
88: #define VERBSW 14
89: "verbose", 0,
90: #define NVERBSW 15
91: "noverbose", 0,
92:
93: #define WATCSW 16
94: "watch", 0,
95: #define NWATCSW 17
96: "nowatch", 0,
97:
98: #define WHOMSW 18 /* interface from whom */
99: "whom", -4,
100:
101: #define WIDTHSW 19
102: "width columns", 0,
103:
104: #define HELPSW 20
105: "help", 4,
106:
107: #define MAILSW 21
108: "mail", -4,
109: #define SAMLSW 22
110: "saml", -4,
111: #define SENDSW 23
112: "send", -4,
113: #define SOMLSW 24
114: "soml", -4,
115:
116: #define ANNOSW 25 /* interface from send */
117: "idanno number", -6,
118:
119: #define DLVRSW 26
120: "deliver address-list", -7,
121:
122: #define CLIESW 27
123: "client host", -6,
124: #define SERVSW 28
125: "server host", -6,
126: #define SNOOPSW 29
127: "snoop", -5,
128:
129: NULL, NULL
130: };
131:
132: /* */
133:
134: struct headers {
135: char *value;
136:
137: unsigned int flags;
138: #define HNOP 0x0000 /* just used to keep .set around */
139: #define HBAD 0x0001 /* bad header - don't let it through */
140: #define HADR 0x0002 /* header has an address field */
141: #define HSUB 0x0004 /* Subject: header */
142: #define HTRY 0x0008 /* try to send to addrs on header */
143: #define HBCC 0x0010 /* don't output this header */
144: #define HMNG 0x0020 /* munge this header */
145: #define HNGR 0x0040 /* no groups allowed in this header */
146: #define HFCC 0x0080 /* FCC: type header */
147: #define HNIL 0x0100 /* okay for this header not to have addrs */
148: #define HIGN 0x0200 /* ignore this header */
149:
150: unsigned int set;
151: #define MFRM 0x0001 /* we've seen a From: */
152: #define MDAT 0x0002 /* we've seen a Date: */
153: #define MRFM 0x0004 /* we've seen a Resent-From: */
154: #define MVIS 0x0008 /* we've seen sighted addrs */
155: #define MINV 0x0010 /* we've seen blind addrs */
156: };
157:
158: /* */
159:
160: static struct headers NHeaders[] = {
161: "Return-Path", HBAD, NULL,
162: "Received", HBAD, NULL,
163: "Reply-To", HADR | HNGR, NULL,
164: "From", HADR | HNGR, MFRM,
165: "Sender", HADR | HBAD, NULL,
166: "Date", HBAD, NULL,
167: "Subject", HSUB, NULL,
168: "To", HADR | HTRY, MVIS,
169: "cc", HADR | HTRY, MVIS,
170: "Bcc", HADR | HTRY | HBCC | HNIL, MINV,
171: "Message-ID", HBAD, NULL,
172: "Fcc", HFCC, NULL,
173:
174: NULL
175: };
176:
177: static struct headers RHeaders[] = {
178: "Resent-Reply-To", HADR | HNGR, NULL,
179: "Resent-From", HADR | HNGR, MRFM,
180: "Resent-Sender", HADR | HBAD, NULL,
181: "Resent-Date", HBAD, NULL,
182: "Resent-Subject", HSUB, NULL,
183: "Resent-To", HADR | HTRY, MVIS,
184: "Resent-cc", HADR | HTRY, MVIS,
185: "Resent-Bcc", HADR | HTRY | HBCC, MINV,
186: "Resent-Message-ID", HBAD, NULL,
187: "Resent-Fcc", HFCC, NULL,
188: "Reply-To", HADR, NULL,
189: "From", HADR | HNGR, MFRM,
190: #ifdef MMDFI
191: "Sender", HADR | HMNG | HNGR, NULL,
192: #else not MMFDI
193: "Sender", HADR | HNGR, NULL,
194: #endif not MMDFI
195: "Date", HNOP, MDAT,
196: "To", HADR | HNIL, NULL,
197: "cc", HADR | HNIL, NULL,
198: "Bcc", HADR | HTRY | HBCC | HNIL, NULL,
199: "Fcc", HIGN, NULL,
200:
201: NULL
202: };
203:
204: /* */
205:
206:
207: static short fccind = 0; /* index into fccfold[] */
208: static short outputlinelen = OUTPUTLINELEN;
209:
210: static int pfd = NOTOK; /* fd to write annotation list to */
211: static int myuid; /* my user id */
212: static int mygid; /* my group id */
213: static int recipients = 0; /* how many people will get a copy */
214: static int unkadr = 0; /* how many of those were unknown */
215: static int badadr = 0; /* number of bad addrs */
216: static int badmsg = 0; /* message has bad semantics */
217: static int verbose = 0; /* spell it out */
218: static int format = 1; /* format addresses */
219: static int msgid = 0; /* add msgid */
220: static int debug = 0; /* debugging post */
221: static int watch = 0; /* watch the delivery process */
222: static int whomsw = 0; /* we are whom not post */
223: static int checksw = 0; /* whom -check */
224: static int linepos; /* putadr()'s position on the line */
225: static int nameoutput; /* putadr() has output header name */
226:
227: static unsigned msgflags = 0; /* what we've seen */
228:
229: #define NORMAL 0
230: #define RESENT 1
231: static int msgstate = NORMAL;
232:
233: static long clock = 0L; /* the time we started (more or less) */
234:
235: static SIGDECL (*hstat)(), (*istat)(), (*qstat)(), (*tstat)();
236:
237: static char tmpfil[BUFSIZ];
238: static char bccfil[BUFSIZ];
239:
240: static char from[BUFSIZ]; /* my network address */
241: static char signature[BUFSIZ]; /* my signature */
242: static char *filter = NULL; /* the filter for BCC'ing */
243: static char *subject = NULL; /* the subject field for BCC'ing */
244: static char *fccfold[FCCS]; /* foldernames for FCC'ing */
245:
246: static struct headers *hdrtab; /* table for the message we're doing */
247:
248: static struct mailname localaddrs; /* local addrs */
249: static struct mailname netaddrs; /* network addrs */
250: static struct mailname uuaddrs; /* uucp addrs */
251: static struct mailname tmpaddrs; /* temporary queue */
252:
253: /* */
254:
255: #ifdef MMDFMTS
256: static char *submitmode = "m"; /* deliver to mailbox only */
257: #ifndef RP_DOK
258: static char submitopts[6] = "vl";/* initial options for submit */
259: #else RP_DOK
260: static char submitopts[7] = "vlk";/* initial options for submit */
261: #endif RP_DOK
262: #endif MMDFMTS
263:
264: #ifdef MHMTS
265: static char *deliver = NULL;
266:
267: extern char **environ;
268:
269: int sigser ();
270: #endif MHMTS
271:
272: #ifdef SENDMTS
273: static int smtpmode = S_MAIL;
274: static int snoop = 0;
275: static char *clientsw = NULL;
276: static char *serversw = NULL;
277:
278: extern struct smtp sm_reply;
279: #endif SENDMTS
280:
281: #ifdef TMA
282: #define post(a,b,c) \
283: if (encryptsw) postcipher ((a), (b), (c)); else postplain ((a), (b), (c))
284:
285: #ifndef SENDMTS
286: #define tmasnoop 0
287: #else SENDMTS
288: #define tmasnoop snoop
289: #endif SENDMTS
290: #endif TMA
291:
292: static int encryptsw = 0; /* encrypt it */
293:
294:
295: long lseek ();
296:
297:
298:
299: static int get_header(), putadr(), insert(), annoaux(), sigser(),
300: usr_hook(), copyfile(), make_uucp_file();
301: static void putfmt(), start_headers(), finish_headers(), putgrp(),
302: pl(), anno(), insert_fcc(), make_bcc_file(), verify_all_addresses(),
303: chkadr(), postplain(), postcipher(), do_a_cipher(), post(),
304: do_addresses(), do_text(), do_an_address(), sigon(), sigoff(),
305: postrefile(), fcc(), die(), localmail(), uucpmail(), netmail();
306:
307: /* MAIN */
308:
309: /* ARGSUSED */
310:
311: main(argc, argv)
312: int argc;
313: char *argv[];
314: {
315: int state,
316: compnum;
317: char *cp,
318: *msg = NULL,
319: **argp = argv + 1,
320: buf[BUFSIZ],
321: name[NAMESZ];
322: FILE *in,
323: *out;
324:
325: invo_name = r1bindex (argv[0], '/');
326: m_foil (NULLCP);
327: mts_init (invo_name);
328: #ifdef MMDFMTS
329: #ifdef MMDFII
330: mmdf_init (invo_name);
331: #endif MMDFII
332: #endif MMDFMTS
333:
334: /* */
335:
336: while (cp = *argp++) {
337: if (*cp == '-')
338: switch (smatch (++cp, switches)) {
339: case AMBIGSW:
340: ambigsw (cp, switches);
341: done (1);
342: case UNKWNSW:
343: adios (NULLCP, "-%s unknown", cp);
344: case HELPSW:
345: (void) sprintf (buf, "%s [switches] file", invo_name);
346: help (buf, switches);
347: done (1);
348:
349: case LIBSW:
350: if (!(cp = *argp++) || *cp == '-')
351: adios (NULLCP, "missing argument to %s", argp[-2]);
352: m_foil (cp);
353: continue;
354:
355: case ALIASW:
356: if (!(cp = *argp++) || *cp == '-')
357: adios (NULLCP, "missing argument to %s", argp[-2]);
358: #ifdef MHMTS
359: if (access (libpath (cp), 04) == NOTOK)
360: adios (cp, "unable to read");
361: #endif MHMTS
362: if ((state = alias (cp)) != AK_OK)
363: adios (NULLCP, "aliasing error in %s - %s",
364: cp, akerror (state));
365: continue;
366:
367: case CHKSW:
368: checksw++;
369: continue;
370: case NCHKSW:
371: checksw = 0;
372: continue;
373:
374: case DEBUGSW:
375: debug++;
376: continue;
377:
378: case DISTSW:
379: msgstate = RESENT;
380: continue;
381:
382: case FILTSW:
383: if (!(filter = *argp++) || *filter == '-')
384: adios (NULLCP, "missing argument to %s", argp[-2]);
385: continue;
386: case NFILTSW:
387: filter = NULL;
388: continue;
389:
390: case FRMTSW:
391: format++;
392: continue;
393: case NFRMTSW:
394: format = 0;
395: continue;
396:
397: case MSGDSW:
398: msgid++;
399: continue;
400: case NMSGDSW:
401: msgid = 0;
402: continue;
403:
404: case VERBSW:
405: verbose++;
406: continue;
407: case NVERBSW:
408: verbose = 0;
409: continue;
410:
411: case WATCSW:
412: watch++;
413: continue;
414: case NWATCSW:
415: watch = 0;
416: continue;
417:
418: case WHOMSW:
419: whomsw++;
420: continue;
421:
422: case WIDTHSW:
423: if (!(cp = *argp++) || *cp == '-')
424: adios (NULLCP, "missing argument to %s", argp[-2]);
425: if ((outputlinelen = atoi (cp)) < 10)
426: adios (NULLCP, "impossible width %d", outputlinelen);
427: continue;
428:
429: case ENCRSW:
430: encryptsw++;
431: continue;
432: case NENCRSW:
433: encryptsw = 0;
434: continue;
435:
436: case ANNOSW:
437: if (!(cp = *argp++) || *cp == '-')
438: adios (NULLCP, "missing argument to %s", argp[-2]);
439: if ((pfd = atoi (cp)) <= 2)
440: adios (NULLCP, "bad argument %s %s", argp[-2], cp);
441: continue;
442:
443: #ifdef MMDFMTS
444: case MAILSW:
445: submitmode = "m";
446: continue;
447: case SOMLSW: /* for right now, sigh... */
448: case SAMLSW:
449: submitmode = "b";
450: continue;
451: case SENDSW:
452: submitmode = "y";
453: continue;
454: #endif MMDFMTS
455:
456: #ifndef MHMTS
457: case DLVRSW:
458: if (!(cp = *argp++) || *cp == '-')
459: adios (NULLCP, "missing argument to %s", argp[-2]);
460: continue;
461: #else MHMTS
462: case MAILSW:
463: case SAMLSW:
464: case SOMLSW:
465: case SENDSW:
466: continue;
467: case DLVRSW:
468: if (!(deliver = *argp++) || *deliver == '-')
469: adios (NULLCP, "missing argument to %s", argp[-2]);
470: continue;
471: #endif MHMTS
472:
473: #ifndef SENDMTS
474: case CLIESW:
475: case SERVSW:
476: if (!(cp = *argp++) || *cp == '-')
477: adios (NULLCP, "missing argument to %s", argp[-2]);
478: continue;
479:
480: case SNOOPSW:
481: continue;
482: #else SENDMTS
483: case MAILSW:
484: smtpmode = S_MAIL;
485: continue;
486: case SAMLSW:
487: smtpmode = S_SAML;
488: continue;
489: case SOMLSW:
490: smtpmode = S_SOML;
491: continue;
492: case SENDSW:
493: smtpmode = S_SEND;
494: continue;
495: case CLIESW:
496: if (!(clientsw = *argp++) || *clientsw == '-')
497: adios (NULLCP, "missing argument to %s", argp[-2]);
498: continue;
499: case SERVSW:
500: if (!(serversw = *argp++) || *serversw == '-')
501: adios (NULLCP, "missing argument to %s", argp[-2]);
502: continue;
503: case SNOOPSW:
504: snoop++;
505: continue;
506: #endif SENDMTS
507: }
508: if (msg)
509: adios (NULLCP, "only one message at a time!");
510: else
511: msg = cp;
512: }
513:
514: (void) alias (AliasFile);
515:
516: /* */
517:
518: if (!msg)
519: adios (NULLCP, "usage: %s [switches] file", invo_name);
520:
521: if (outputlinelen < 10)
522: adios (NULLCP, "impossible width %d", outputlinelen);
523:
524: #ifdef MHMTS
525: if (access (msg, 04) == NOTOK)
526: adios (msg, "unable to read");
527: #endif MHMTS
528: if ((in = fopen (msg, "r")) == NULL)
529: adios (msg, "unable to open");
530:
531: start_headers ();
532: if (debug) {
533: verbose++;
534: out = stdout;
535: #ifdef MHMTS
536: if (deliver) {
537: (void) strcpy (tmpfil, msg);
538: putfmt ("To", deliver, out);
539: goto daemon;
540: }
541: #endif MHMTS
542: }
543: else
544: #ifdef MHMTS
545: if (deliver) {
546: if ((out = fopen ("/dev/null", "r")) == NULL)
547: adios ("/dev/null", "unable to write");
548: (void) strcpy (tmpfil, msg);
549: putfmt ("To", deliver, out);
550: goto daemon;
551: }
552: else
553: #endif MHMTS
554: if (whomsw) {
555: if ((out = fopen ("/dev/null", "w")) == NULL)
556: adios ("/dev/null", "unable to open");
557: }
558: else {
559: (void) strcpy (tmpfil, m_scratch (m_maildir (invo_name)));
560: if ((out = fopen (tmpfil, "w")) == NULL) {
561: (void) strcpy (tmpfil, m_tmpfil (invo_name));
562: if ((out = fopen (tmpfil, "w")) == NULL)
563: adios (tmpfil, "unable to create");
564: }
565: #ifdef MHMTS
566: (void) chown (tmpfil, myuid, mygid);
567: #endif MHMTS
568: (void) chmod (tmpfil, 0600);
569: }
570:
571: /* */
572:
573: hdrtab = msgstate == NORMAL ? NHeaders : RHeaders;
574:
575: for (compnum = 1, state = FLD;;) {
576: switch (state = m_getfld (state, name, buf, sizeof buf, in)) {
577: case FLD:
578: case FLDEOF:
579: case FLDPLUS:
580: compnum++;
581: cp = add (buf, NULLCP);
582: while (state == FLDPLUS) {
583: state = m_getfld (state, name, buf, sizeof buf, in);
584: cp = add (buf, cp);
585: }
586: putfmt (name, cp, out);
587: free (cp);
588: if (state != FLDEOF)
589: continue;
590: finish_headers (out);
591: break;
592:
593: case BODY:
594: case BODYEOF:
595: finish_headers (out);
596: if (whomsw)
597: break;
598: fprintf (out, "\n%s", buf);
599: while (state == BODY) {
600: state = m_getfld (state, name, buf, sizeof buf, in);
601: fputs (buf, out);
602: }
603: break;
604:
605: case FILEEOF:
606: finish_headers (out);
607: break;
608:
609: case LENERR:
610: case FMTERR:
611: adios (NULLCP, "message format error in component #%d",
612: compnum);
613:
614: default:
615: adios (NULLCP, "getfld() returned %d", state);
616: }
617: break;
618: }
619:
620: /* */
621:
622: #ifdef MHMTS
623: daemon: ;
624: #endif MHMTS
625: if (pfd != NOTOK)
626: anno ();
627: (void) fclose (in);
628: if (debug) {
629: pl ();
630: done (0);
631: }
632: else
633: (void) fclose (out);
634:
635: #ifdef TMA
636: if (encryptsw)
637: tmastart (tmasnoop);
638: #endif TMA
639: if (whomsw) {
640: verify_all_addresses (1);
641: done (0);
642: }
643:
644: #ifdef MMDFMTS
645: (void) strcat (submitopts, submitmode);
646: if (watch)
647: (void) strcat (submitopts, "nw");
648: #endif MMDFMTS
649: #ifdef MHMTS
650: verify_all_addresses (0);
651: #endif MHMTS
652: if (encryptsw)
653: verify_all_addresses (verbose);
654: if (msgflags & MINV) {
655: make_bcc_file ();
656: if (msgflags & MVIS) {
657: #ifndef MHMTS
658: if (!encryptsw)
659: verify_all_addresses (verbose);
660: #endif not MHMTS
661: post (tmpfil, 0, verbose);
662: }
663: post (bccfil, 1, verbose);
664: (void) unlink (bccfil);
665: }
666: else
667: post (tmpfil, 0, isatty (1));
668: #ifdef TMA
669: if (encryptsw)
670: tmastop ();
671: #endif TMA
672:
673: postrefile (tmpfil);
674:
675: #ifdef MHMTS
676: if (!deliver)
677: #endif MHMTS
678: (void) unlink (tmpfil);
679:
680: if (verbose)
681: printf ("Message Processed\n");
682:
683: done (0);
684: }
685:
686: /* DRAFT GENERATION */
687:
688: static void
689: putfmt(name, str, out)
690: register char *name, *str;
691: register FILE *out;
692: {
693: int count,
694: grp,
695: i,
696: keep;
697: register char *cp,
698: *pp,
699: *qp;
700: char namep[BUFSIZ];
701: register struct mailname *mp,
702: *np;
703: register struct headers *hdr;
704:
705: while (*str == ' ' || *str == '\t')
706: str++;
707:
708: if (msgstate == NORMAL && uprf (name, "resent")) {
709: advise (NULLCP, "illegal header line -- %s:", name);
710: badmsg++;
711: return;
712: }
713:
714: if ((i = get_header (name, hdrtab)) == NOTOK) {
715: fprintf (out, "%s: %s", name, str);
716: return;
717: }
718:
719: hdr = &hdrtab[i];
720: if (hdr -> flags & HIGN)
721: return;
722: if (hdr -> flags & HBAD) {
723: advise (NULLCP, "illegal header line -- %s:", name);
724: badmsg++;
725: return;
726: }
727: msgflags |= (hdr -> set & ~(MVIS | MINV));
728:
729: if (hdr -> flags & HSUB)
730: subject = subject ? add (str, add ("\t", subject)) : getcpy (str);
731: if (hdr -> flags & HFCC) {
732: if (cp = rindex (str, '\n'))
733: *cp = NULL;
734: for (cp = pp = str; cp = index (pp, ','); pp = cp) {
735: *cp++ = NULL;
736: insert_fcc (hdr, pp);
737: }
738: insert_fcc (hdr, pp);
739: return;
740: }
741:
742: /* */
743:
744: if (!(hdr -> flags & HADR)) {
745: fprintf (out, "%s: %s", name, str);
746: return;
747: }
748:
749: tmpaddrs.m_next = NULL;
750: for (count = 0; cp = getname (str); count++)
751: if (mp = getm (cp, NULLCP, 0, AD_HOST, NULLCP)) {
752: if (tmpaddrs.m_next)
753: np -> m_next = mp;
754: else
755: tmpaddrs.m_next = mp;
756: np = mp;
757: }
758: else
759: if (hdr -> flags & HTRY)
760: badadr++;
761: else
762: badmsg++;
763:
764: if (count < 1) {
765: if (hdr -> flags & HNIL)
766: fprintf (out, "%s: %s", name, str);
767: else {
768: #ifdef notdef
769: advise (NULLCP, "%s: field requires at least one address", name);
770: badmsg++;
771: #endif notdef
772: }
773: return;
774: }
775:
776: /* */
777:
778: nameoutput = linepos = 0;
779: (void) sprintf (namep, "%s%s",
780: (hdr -> flags & HMNG) ? "Original-" : "", name);
781:
782: for (grp = 0, mp = tmpaddrs.m_next; mp; mp = np)
783: if (mp -> m_nohost) { /* also used to test (hdr -> flags & HTRY) */
784: pp = akvalue (mp -> m_mbox);
785: qp = akvisible () ? mp -> m_mbox : "";
786: np = mp;
787: if (np -> m_gname)
788: putgrp (namep, np -> m_gname, out, hdr -> flags);
789: while (cp = getname (pp)) {
790: if (!(mp = getm (cp, NULLCP, 0, AD_HOST, NULLCP))) {
791: badadr++;
792: continue;
793: }
794: if (hdr -> flags & HBCC)
795: mp -> m_bcc++;
796: if (mp -> m_ingrp = np -> m_ingrp)
797: grp++;
798: #ifdef MHMTS
799: mp -> m_aka = getcpy (np -> m_mbox);
800: #endif MHMTS
801: if (putadr (namep, qp, mp, out, hdr -> flags))
802: msgflags |= (hdr -> set & (MVIS | MINV));
803: else
804: mnfree (mp);
805: }
806: mp = np;
807: np = np -> m_next;
808: mnfree (mp);
809: }
810: else {
811: if (hdr -> flags & HBCC)
812: mp -> m_bcc++;
813: if (mp -> m_gname)
814: putgrp (namep, mp -> m_gname, out, hdr -> flags);
815: if (mp -> m_ingrp)
816: grp++;
817: keep = putadr (namep, "", mp, out, hdr -> flags);
818: np = mp -> m_next;
819: if (keep) {
820: mp -> m_next = NULL;
821: msgflags |= (hdr -> set & (MVIS | MINV));
822: }
823: else
824: mnfree (mp);
825: }
826:
827: if (grp > 0 && (hdr -> flags & HNGR)) {
828: advise (NULLCP, "%s: field does not allow groups", name);
829: badmsg++;
830: }
831: if (linepos)
832: (void) putc ('\n', out);
833: }
834:
835: /* */
836:
837: static void
838: start_headers()
839: {
840: register char *cp;
841: char myhost[BUFSIZ],
842: sigbuf[BUFSIZ];
843: register struct mailname *mp;
844:
845: myuid = getuid ();
846: mygid = getgid ();
847: (void) time (&clock);
848:
849: (void) strcpy (from, adrsprintf (NULLCP, NULLCP));
850:
851: (void) strcpy (myhost, LocalName ());
852: for (cp = myhost; *cp; cp++)
853: *cp = uptolow (*cp);
854:
855: #ifdef MHMTS
856: if (deliver) {
857: if (geteuid () == 0 && myuid != 0 && myuid != 1 && mygid != 1)
858: adios (NULLCP, "-deliver unknown");
859: (void) strcpy (signature, from);
860: }
861: #endif MHMTS
862:
863: if ((cp = getfullname ()) && *cp) {
864: (void) strcpy (sigbuf, cp);
865: (void) sprintf (signature, "%s <%s>", sigbuf, adrsprintf (NULLCP, NULLCP));
866: if ((cp = getname (signature)) == NULL)
867: adios (NULLCP, "getname () failed -- you lose extraordinarily big");
868: if ((mp = getm (cp, NULLCP, 0, AD_HOST, NULLCP)) == NULL)
869: adios (NULLCP, "bad signature '%s'", sigbuf);
870: mnfree (mp);
871: while (getname (""))
872: continue;
873: }
874: else
875: (void) strcpy (signature, adrsprintf (NULLCP, NULLCP));
876: }
877:
878: /* */
879:
880: static void
881: finish_headers(out)
882: register FILE *out;
883: {
884: switch (msgstate) {
885: case NORMAL:
886: if (whomsw)
887: break;
888:
889: fprintf (out, "Date: %s\n", dtime (&clock));
890: if (msgid)
891: fprintf (out, "Message-ID: <%d.%ld@%s>\n",
892: getpid (), clock, LocalName ());
893: if (msgflags & MFRM)
894: fprintf (out, "Sender: %s\n", from);
895: else
896: fprintf (out, "From: %s\n", signature);
897: if (!(msgflags & MVIS))
898: fprintf (out, "Bcc: Blind Distribution List: ;\n");
899: break;
900:
901: case RESENT:
902: if (!(msgflags & MDAT)) {
903: advise (NULLCP, "message has no Date: header");
904: badmsg++;
905: }
906: if (!(msgflags & MFRM)) {
907: advise (NULLCP, "message has no From: header");
908: badmsg++;
909: }
910: if (whomsw)
911: break;
912:
913: #ifdef MMDFI /* sigh */
914: fprintf (out, "Sender: %s\n", from);
915: #endif MMDFI
916:
917: fprintf (out, "Resent-Date: %s\n", dtime (&clock));
918: if (msgid)
919: fprintf (out, "Resent-Message-ID: <%d.%ld@%s>\n",
920: getpid (), clock, LocalName ());
921: if (msgflags & MRFM)
922: fprintf (out, "Resent-Sender: %s\n", from);
923: else
924: fprintf (out, "Resent-From: %s\n", signature);
925: if (!(msgflags & MVIS))
926: fprintf (out, "Resent-Bcc: Blind Re-Distribution List: ;\n");
927: break;
928: }
929:
930: if (badmsg)
931: adios (NULLCP, "re-format message and try again");
932: if (!recipients)
933: adios (NULLCP, "no addressees");
934: }
935:
936: /* */
937:
938: static int
939: get_header(header, table)
940: register char *header;
941: register struct headers *table;
942: {
943: register struct headers *h;
944:
945: for (h = table; h -> value; h++)
946: if (uleq (header, h -> value))
947: return (h - table);
948:
949: return NOTOK;
950: }
951:
952: /* */
953:
954: static int
955: putadr(name, aka, mp, out, flags)
956: register char *name, *aka;
957: register struct mailname *mp;
958: register FILE *out;
959: unsigned int flags;
960: {
961: int len;
962: register char *cp;
963: char buffer[BUFSIZ];
964:
965: if (mp -> m_mbox == NULL || ((flags & HTRY) && !insert (mp)))
966: return 0;
967: if ((flags & HBCC) || mp -> m_ingrp)
968: return 1;
969:
970: if (!nameoutput) {
971: fprintf (out, "%s: ", name);
972: linepos += (nameoutput = strlen (name) + 2);
973: }
974:
975: if (*aka && mp -> m_type != UUCPHOST && !mp -> m_pers)
976: mp -> m_pers = getcpy (aka);
977: if (format) {
978: if (mp -> m_gname)
979: (void) sprintf (cp = buffer, "%s;", mp -> m_gname);
980: else
981: cp = adrformat (mp);
982: }
983: else
984: cp = mp -> m_text;
985: len = strlen (cp);
986:
987: if (linepos != nameoutput)
988: if (len + linepos + 2 > outputlinelen)
989: fprintf (out, ",\n%*s", linepos = nameoutput, "");
990: else {
991: fputs (", ", out);
992: linepos += 2;
993: }
994:
995: fputs (cp, out);
996: linepos += len;
997:
998: return (flags & HTRY);
999: }
1000:
1001: /* */
1002:
1003: static void
1004: putgrp(name, group, out, flags)
1005: register char *name, *group;
1006: register FILE *out;
1007: unsigned int flags;
1008: {
1009: int len;
1010: char *cp;
1011:
1012: if (flags & HBCC)
1013: return;
1014:
1015: if (!nameoutput) {
1016: fprintf (out, "%s: ", name);
1017: linepos += (nameoutput = strlen (name) + 2);
1018: }
1019:
1020: cp = concat (group, ";", NULLCP);
1021: len = strlen (cp);
1022:
1023: if (linepos != nameoutput)
1024: if (len + linepos + 2 > outputlinelen) {
1025: fprintf (out, ",\n%*s", nameoutput, "");
1026: linepos = nameoutput;
1027: }
1028: else {
1029: fputs (", ", out);
1030: linepos += 2;
1031: }
1032:
1033: fputs (cp, out);
1034: linepos += len;
1035: }
1036:
1037: /* */
1038:
1039: static int
1040: insert(np)
1041: register struct mailname *np;
1042: {
1043: register struct mailname *mp;
1044:
1045: if (np -> m_mbox == NULL)
1046: return 0;
1047:
1048: for (mp = np -> m_type == LOCALHOST ? &localaddrs
1049: : np -> m_type == UUCPHOST ? &uuaddrs
1050: : &netaddrs;
1051: mp -> m_next;
1052: mp = mp -> m_next)
1053: if (uleq (np -> m_host, mp -> m_next -> m_host)
1054: && uleq (np -> m_mbox, mp -> m_next -> m_mbox)
1055: && np -> m_bcc == mp -> m_next -> m_bcc)
1056: return 0;
1057:
1058: mp -> m_next = np;
1059: recipients++;
1060: return 1;
1061: }
1062:
1063:
1064: static void
1065: pl()
1066: {
1067: register int i;
1068: register struct mailname *mp;
1069:
1070: printf ("-------\n\t-- Addresses --\nlocal:\t");
1071: for (mp = localaddrs.m_next; mp; mp = mp -> m_next)
1072: printf ("%s%s%s", mp -> m_mbox,
1073: mp -> m_bcc ? "[BCC]" : "",
1074: mp -> m_next ? ",\n\t" : "");
1075:
1076: printf ("\nnet:\t");
1077: for (mp = netaddrs.m_next; mp; mp = mp -> m_next)
1078: printf ("%s%s@%s%s%s", mp -> m_path ? mp -> m_path : "",
1079: mp -> m_mbox, mp -> m_host,
1080: mp -> m_bcc ? "[BCC]" : "",
1081: mp -> m_next ? ",\n\t" : "");
1082:
1083: printf ("\nuucp:\t");
1084: for (mp = uuaddrs.m_next; mp; mp = mp -> m_next)
1085: printf ("%s!%s%s", mp -> m_host, mp -> m_mbox,
1086: mp -> m_bcc ? "[BCC]" : "",
1087: mp -> m_next ? ",\n\t" : "");
1088:
1089: printf ("\n\t-- Folder Copies --\nfcc:\t");
1090: for (i = 0; i < fccind; i++)
1091: printf ("%s%s", fccfold[i], i + 1 < fccind ? ",\n\t" : "");
1092: printf ("\n");
1093: }
1094:
1095: /* */
1096:
1097: static void
1098: anno()
1099: {
1100: register struct mailname *mp;
1101:
1102: for (mp = localaddrs.m_next; mp; mp = mp -> m_next)
1103: if (annoaux (mp) == NOTOK)
1104: goto oops;
1105:
1106: for (mp = netaddrs.m_next; mp; mp = mp -> m_next)
1107: if (annoaux (mp) == NOTOK)
1108: goto oops;
1109:
1110: for (mp = uuaddrs.m_next; mp; mp = mp -> m_next)
1111: if (annoaux (mp) == NOTOK)
1112: break;
1113:
1114: oops: ;
1115: (void) close (pfd);
1116: pfd = NOTOK;
1117: }
1118:
1119: static int
1120: annoaux(mp)
1121: register struct mailname *mp;
1122: {
1123: int i;
1124: char buffer[BUFSIZ];
1125:
1126: (void) sprintf (buffer, "%s\n", adrformat (mp));
1127: i = strlen (buffer);
1128:
1129: return (write (pfd, buffer, i) == i ? OK : NOTOK);
1130: }
1131:
1132: /* */
1133:
1134: static void
1135: insert_fcc(hdr, pp)
1136: register struct headers *hdr;
1137: register char *pp;
1138: {
1139: register char *cp;
1140:
1141: for (cp = pp; isspace (*cp); cp++)
1142: continue;
1143: for (pp += strlen (pp) - 1; pp > cp && isspace (*pp); pp--)
1144: continue;
1145: if (pp >= cp)
1146: *++pp = NULL;
1147: if (*cp == NULL)
1148: return;
1149:
1150: if (fccind >= FCCS)
1151: adios (NULLCP, "too many %ss", hdr -> value);
1152: fccfold[fccind++] = getcpy (cp);
1153: }
1154:
1155: /* BCC GENERATION */
1156:
1157: static void
1158: make_bcc_file()
1159: {
1160: int fd,
1161: i,
1162: child_id;
1163: char *vec[6];
1164: register FILE *out;
1165:
1166: (void) strcpy (bccfil, m_tmpfil ("bccs"));
1167: if ((out = fopen (bccfil, "w")) == NULL)
1168: adios (bccfil, "unable to create");
1169: (void) chmod (bccfil, 0600);
1170:
1171: fprintf (out, "Date: %s\n", dtime (&clock));
1172: if (msgid)
1173: fprintf (out, "Message-ID: <%d.%ld@%s>\n",
1174: getpid (), clock, LocalName ());
1175: fprintf (out, "From: %s\n", signature);
1176: if (subject)
1177: fprintf (out, "Subject: %s", subject);
1178: fprintf (out, "BCC:\n\n------- Blind-Carbon-Copy\n\n");
1179: (void) fflush (out);
1180:
1181: if (filter == NULL) {
1182: if ((fd = open (tmpfil, 0)) == NOTOK)
1183: adios (NULLCP, "unable to re-open");
1184: cpydgst (fd, fileno (out), tmpfil, bccfil);
1185: (void) close (fd);
1186: }
1187: else {
1188: vec[0] = r1bindex (mhlproc, '/');
1189:
1190: for (i = 0; (child_id = fork ()) == NOTOK && i < 5; i++)
1191: sleep (5);
1192: switch (child_id) {
1193: case NOTOK:
1194: adios ("fork", "unable to");
1195:
1196: case OK:
1197: (void) dup2 (fileno (out), 1);
1198:
1199: i = 1;
1200: vec[i++] = "-forward";
1201: vec[i++] = "-form";
1202: vec[i++] = filter;
1203: vec[i++] = tmpfil;
1204: vec[i] = NULL;
1205:
1206: execvp (mhlproc, vec);
1207: fprintf (stderr, "unable to exec ");
1208: perror (mhlproc);
1209: _exit (-1);
1210:
1211: default:
1212: (void) pidXwait (child_id, mhlproc);
1213: break;
1214: }
1215: }
1216:
1217: (void) fseek (out, 0L, 2);
1218: fprintf (out, "\n------- End of Blind-Carbon-Copy\n");
1219: (void) fclose (out);
1220: }
1221:
1222: /* ADDRESS VERIFICATION */
1223:
1224: static void
1225: verify_all_addresses(talk)
1226: int talk;
1227: {
1228: #ifndef MHMTS
1229: int retval;
1230: #endif not MHMTS
1231: #ifdef MMDFMTS
1232: #ifdef RP_NS
1233: int len;
1234: struct rp_bufstruct reply;
1235: #endif RP_NS
1236: #endif MMDFMTS
1237: register struct mailname *lp;
1238:
1239: #ifndef MHMTS
1240: sigon ();
1241: #endif not MHMTS
1242:
1243: #ifdef MMDFMTS
1244: if (!whomsw || checksw) {
1245: if (rp_isbad (retval = mm_init ())
1246: || rp_isbad (retval = mm_sbinit ())
1247: || rp_isbad (retval = mm_winit (NULLCP, submitopts, from)))
1248: die (NULLCP, "problem initializing MMDF system [%s]",
1249: rp_valstr (retval));
1250: #ifdef RP_NS
1251: if (rp_isbad (retval = mm_rrply (&reply, &len)))
1252: die (NULLCP, "problem with sender address [%s]",
1253: rp_valstr (retval));
1254: #endif RP_NS
1255: }
1256: #endif MMDFMTS
1257: #ifdef SENDMTS
1258: if (!whomsw || checksw)
1259: if (rp_isbad (retval = sm_init (clientsw, serversw, 0, 0, snoop))
1260: || rp_isbad (retval = sm_winit (smtpmode, from)))
1261: die (NULLCP, "problem initializing server; %s",
1262: rp_string (retval));
1263: #endif SENDMTS
1264:
1265: if (talk && !whomsw)
1266: printf (" -- Address Verification --\n");
1267: #ifndef BERK
1268: if (talk && localaddrs.m_next)
1269: printf (" -- Local Recipients --\n");
1270: #endif BERK
1271: for (lp = localaddrs.m_next; lp; lp = lp -> m_next)
1272: do_an_address (lp, talk, encryptsw);
1273:
1274: #ifndef BERK
1275: if (talk && uuaddrs.m_next)
1276: printf (" -- UUCP Recipients --\n");
1277: #endif BERK
1278: for (lp = uuaddrs.m_next; lp; lp = lp -> m_next)
1279: do_an_address (lp, talk, encryptsw);
1280:
1281: #ifndef BERK
1282: if (talk && netaddrs.m_next)
1283: printf (" -- Network Recipients --\n");
1284: #endif BERK
1285: for (lp = netaddrs.m_next; lp; lp = lp -> m_next)
1286: do_an_address (lp, talk, encryptsw);
1287:
1288: chkadr ();
1289: if (talk && !whomsw)
1290: printf (" -- Address Verification Successful --\n");
1291:
1292: #ifdef MMDFMTS
1293: if (!whomsw || checksw)
1294: (void) mm_end (NOTOK);
1295: #endif MMDFMTS
1296: #ifdef SENDMTS
1297: if (!whomsw || checksw)
1298: (void) sm_end (DONE);
1299: #endif SENDMTS
1300: (void) fflush (stdout);
1301:
1302: #ifndef MHMTS
1303: sigoff ();
1304: #endif not MHMTS
1305: }
1306:
1307: /* */
1308:
1309: static void
1310: chkadr()
1311: {
1312: #define plural(x) (x == 1 ? "" : "s")
1313:
1314: if (badadr && unkadr)
1315: die (NULLCP, "%d address%s unparsable, %d addressee%s undeliverable",
1316: badadr, plural (badadr), unkadr, plural (badadr));
1317: if (badadr)
1318: die (NULLCP, "%d address%s unparsable", badadr, plural (badadr));
1319: if (unkadr)
1320: die (NULLCP, "%d addressee%s undeliverable", unkadr, plural (unkadr));
1321: }
1322:
1323: /* MTS INTERACTION */
1324:
1325: #ifdef TMA
1326: static void
1327: postplain(file, bccque, talk)
1328: #else TMA
1329: static void
1330: post(file, bccque, talk)
1331: #endif TMA
1332: register char *file;
1333: int bccque, talk;
1334: {
1335: int fd;
1336: #ifndef MHMTS
1337: int retval;
1338: #ifdef MMDFMTS
1339: #ifdef RP_NS
1340: int len;
1341: struct rp_bufstruct reply;
1342: #endif RP_NS
1343: #endif MMDFMTS
1344: #else MHMTS
1345: int ud;
1346: #endif MHMTS
1347:
1348: if (verbose)
1349: if (msgflags & MINV)
1350: printf (" -- Posting for %s Recipients --\n",
1351: bccque ? "Blind" : "Sighted");
1352: else
1353: printf (" -- Posting for All Recipients --\n");
1354:
1355: sigon ();
1356:
1357: #ifdef MMDFMTS
1358: if (rp_isbad (retval = mm_init ())
1359: || rp_isbad (retval = mm_sbinit ())
1360: || rp_isbad (retval = mm_winit (NULLCP, submitopts, from)))
1361: die (NULLCP, "problem initializing MMDF system [%s]",
1362: rp_valstr (retval));
1363: #ifdef RP_NS
1364: if (rp_isbad (retval = mm_rrply (&reply, &len)))
1365: die (NULLCP, "problem with sender address [%s]",
1366: rp_valstr (retval));
1367: #endif RP_NS
1368: #endif MMDFMTS
1369: #ifdef SENDMTS
1370: if (rp_isbad (retval = sm_init (clientsw, serversw, watch, verbose, snoop))
1371: || rp_isbad (retval = sm_winit (smtpmode, from)))
1372: die (NULLCP, "problem initializing server; %s", rp_string (retval));
1373: #endif SENDMTS
1374:
1375: #ifndef MHMTS
1376: do_addresses (bccque, talk && verbose);
1377: if ((fd = open (file, 0)) == NOTOK)
1378: die (file, "unable to re-open");
1379: do_text (file, fd);
1380: #else MHMTS
1381: if ((fd = open (file, 0)) == NULL)
1382: adios (file, "unable to re-open");
1383: #ifdef MF
1384: ud = UucpChan () && uuaddrs.m_next ? make_uucp_file (fd) : NOTOK;
1385: #else not MF
1386: ud = NOTOK;
1387: #endif not MF
1388: do_addresses (file, fd, ud, bccque, talk && verbose);
1389: if (ud != NOTOK)
1390: (void) close (ud);
1391: #endif MHMTS
1392: (void) close (fd);
1393: (void) fflush (stdout);
1394:
1395: #ifdef MMDFMTS
1396: (void) mm_sbend ();
1397: (void) mm_end (OK);
1398: #endif MMDFMTS
1399: #ifdef SENDMTS
1400: (void) sm_end (!(msgflags & MINV) || bccque ? OK : DONE);
1401: #endif SENDMTS
1402:
1403: sigoff ();
1404:
1405: if (verbose)
1406: if (msgflags & MINV)
1407: printf (" -- %s Recipient Copies Posted --\n",
1408: bccque ? "Blind" : "Sighted");
1409: else
1410: printf (" -- Recipient Copies Posted --\n");
1411: (void) fflush (stdout);
1412: }
1413:
1414: /* */
1415:
1416: #ifdef TMA
1417: static void
1418: postcipher(file, bccque, talk)
1419: register char *file;
1420: int bccque, talk;
1421: {
1422: int fdP,
1423: state;
1424: char reason[BUFSIZ];
1425: struct mailname *lp;
1426:
1427: if (verbose)
1428: if (msgflags & MINV)
1429: printf (" -- Posting for %s Recipients --\n",
1430: bccque ? "Blind" : "Sighted");
1431: else
1432: printf (" -- Posting for All Recipients --\n");
1433:
1434: if ((fdP = open (file, 0)) == NOTOK)
1435: adios (file, "unable to re-open");
1436: if (ciphinit (fdP, reason) == NOTOK)
1437: adios (NULLCP, "%s", reason);
1438: (void) close (fdP);
1439:
1440: for (state = 0, lp = localaddrs.m_next; lp; lp = lp -> m_next)
1441: if (lp -> m_bcc ? bccque : !bccque) {
1442: #ifndef BERK
1443: if (talk && !state)
1444: printf (" -- Local Recipients --\n");
1445: #endif BERK
1446: do_a_cipher (lp, talk);
1447: #ifndef BERK
1448: state++;
1449: #endif BERK
1450: }
1451:
1452: for (state = 0, lp = uuaddrs.m_next; lp; lp = lp -> m_next)
1453: if (lp -> m_bcc ? bccque : !bccque) {
1454: #ifndef BERK
1455: if (talk && !state)
1456: printf (" -- UUCP Recipients --\n");
1457: #endif BERK
1458: do_a_cipher (lp, talk);
1459: #ifndef BERK
1460: state++;
1461: #endif BERK
1462: }
1463:
1464: for (state = 0, lp = netaddrs.m_next; lp; lp = lp -> m_next)
1465: if (lp -> m_bcc ? bccque : !bccque) {
1466: #ifndef BERK
1467: if (talk && !state)
1468: printf (" -- Network Recipients --\n");
1469: #endif BERK
1470: do_a_cipher (lp, talk);
1471: #ifndef BERK
1472: state++;
1473: #endif BERK
1474: }
1475:
1476: if (ciphdone (reason) == NOTOK)
1477: admonish (NULLCP, "%s", reason);
1478: #ifdef SENDMTS
1479: if (!(msgflags & MINV) || bccque)
1480: (void) sm_end (OK);
1481: #endif SENDMTS
1482:
1483: if (verbose)
1484: if (msgflags & MINV)
1485: printf (" -- %s Recipient Copies Posted --\n",
1486: bccque ? "Blind" : "Sighted");
1487: else
1488: printf (" -- Recipient Copies Posted --\n");
1489: (void) fflush (stdout);
1490: }
1491:
1492: /* */
1493:
1494: static void
1495: do_a_cipher(lp, talk)
1496: register struct mailname *lp;
1497: int talk;
1498: {
1499: int fd,
1500: retval;
1501: register char *mbox,
1502: *host;
1503: char addr[BUFSIZ],
1504: reason[BUFSIZ];
1505: #ifdef MMDFMTS
1506: #ifdef RP_NS
1507: int len;
1508: struct rp_bufstruct reply;
1509: #endif RP_NS
1510: #endif MMDFMTS
1511:
1512: sigon ();
1513:
1514: #ifdef MMDFMTS
1515: if (rp_isbad (retval = mm_init ())
1516: || rp_isbad (retval = mm_sbinit ())
1517: || rp_isbad (retval = mm_winit (NULL, submitopts, from)))
1518: die (NULLCP, "problem initializing MMDF system [%s]",
1519: rp_valstr (retval));
1520: #ifdef RP_NS
1521: if (rp_isbad (retval = mm_rrply (&reply, &len)))
1522: die (NULLCP, "problem with sender address [%s]",
1523: rp_valstr (retval));
1524: #endif RP_NS
1525: #endif MMDFMTS
1526: #ifdef SENDMTS
1527: if (rp_isbad (retval = sm_init (clientsw, serversw, watch, verbose, snoop))
1528: || rp_isbad (retval = sm_winit (smtpmode, from)))
1529: die (NULLCP, "problem initializing server; %s", rp_string (retval));
1530: #endif SENDMTS
1531:
1532: do_an_address (lp, talk, 0);
1533:
1534: switch (lp -> m_type) {
1535: case LOCALHOST:
1536: mbox = lp -> m_mbox;
1537: host = LocalName ();
1538: (void) strcpy (addr, mbox);
1539: break;
1540:
1541: case UUCPHOST:
1542: #ifdef MMDFMTS
1543: mbox = concat (lp -> m_host, "!", lp -> m_mbox, NULLCP);
1544: host = UucpChan ();
1545: #endif MMDFMTS
1546: #ifdef SENDMTS
1547: mbox = auxformat (lp, 0);
1548: host = NULL;
1549: #endif SENDMTS
1550: (void) sprintf (addr, "%s!%s", lp -> m_host, lp -> m_mbox);
1551: break;
1552:
1553: default:
1554: mbox = lp -> m_mbox;
1555: host = lp -> m_host;
1556: (void) sprintf (addr, "%s at %s", lp -> m_mbox, lp -> m_host);
1557: break;
1558: }
1559: chkadr (); /* XXX */
1560:
1561: #ifdef MMDFMTS
1562: if (rp_isbad (retval = mm_waend ()))
1563: die (NULLCP, "problem ending addresses [%s]\n",
1564: rp_valstr (retval));
1565: #endif MMDFMTS
1566: #ifdef SENDMTS
1567: if (rp_isbad (retval = sm_waend ()))
1568: die (NULLCP, "problem ending addresses; %s", rp_string (retval));
1569: #endif SENDMTS
1570:
1571: if ((fd = encipher (mbox, host, reason)) == NOTOK)
1572: die (NULLCP, "%s: %s", addr, reason);
1573: do_text ("temporary file", fd);
1574: (void) close (fd);
1575: (void) fflush (stdout);
1576:
1577: #ifdef MMDFMTS
1578: (void) mm_sbend ();
1579: (void) mm_end (OK);
1580: #endif MMDFMTS
1581: #ifdef SENDMTS
1582: (void) sm_end (DONE);
1583: #endif SENDMTS
1584:
1585: sigoff ();
1586: }
1587: #endif TMA
1588:
1589: /* */
1590:
1591: #ifndef MHMTS
1592: static void
1593: do_addresses(bccque, talk)
1594: #else MHMTS
1595: static void
1596: do_addresses(file, fd, ud, bccque, talk)
1597: register char *file;
1598: int fd, ud;
1599: #endif MHMTS
1600: int bccque, talk;
1601: {
1602: int retval;
1603: #ifndef BERK
1604: int state;
1605: #endif not BERK
1606: register struct mailname *lp;
1607:
1608: #ifndef BERK
1609: state = 0;
1610: #endif not BERK
1611: for (lp = localaddrs.m_next; lp; lp = lp -> m_next)
1612: if (lp -> m_bcc ? bccque : !bccque) {
1613: #ifndef BERK
1614: if (talk && !state)
1615: printf (" -- Local Recipients --\n");
1616: #endif not BERK
1617: #ifndef MHMTS
1618: do_an_address (lp, talk, 0);
1619: #else MHMTS
1620: localmail (lp, talk, fd);
1621: #endif MHMTS
1622: #ifndef BERK
1623: state++;
1624: #endif not BERK
1625: }
1626:
1627: #ifndef BERK
1628: state = 0;
1629: #endif not BERK
1630: for (lp = uuaddrs.m_next; lp; lp = lp -> m_next)
1631: if (lp -> m_bcc ? bccque : !bccque) {
1632: #ifndef BERK
1633: if (talk && !state)
1634: printf (" -- UUCP Recipients --\n");
1635: #endif not BERK
1636: #ifndef MHMTS
1637: do_an_address (lp, talk, 0);
1638: #else MHMTS
1639: uucpmail (lp, talk, ud != NOTOK ? ud : fd, ud == NOTOK);
1640: #endif MHMTS
1641: #ifndef BERK
1642: state++;
1643: #endif not BERK
1644: }
1645:
1646: #ifndef BERK
1647: state = 0;
1648: #endif not BERK
1649: for (lp = netaddrs.m_next; lp; lp = lp -> m_next)
1650: if (lp -> m_bcc ? bccque : !bccque) {
1651: #ifndef BERK
1652: if (talk && !state)
1653: printf (" -- Network Recipients --\n");
1654: #endif not BERK
1655: #ifndef MHMTS
1656: do_an_address (lp, talk, 0);
1657: #else MHMTS
1658: netmail (talk, fd, bccque);
1659: #endif MHMTS
1660: #ifndef BERK
1661: state++;
1662: #endif not BERK
1663: }
1664:
1665: /* */
1666:
1667: chkadr ();
1668:
1669: #ifdef MMDFMTS
1670: if (rp_isbad (retval = mm_waend ()))
1671: die (NULLCP, "problem ending addresses [%s]\n",
1672: rp_valstr (retval));
1673: #endif MMDFMTS
1674: #ifdef SENDMTS
1675: if (rp_isbad (retval = sm_waend ()))
1676: die (NULLCP, "problem ending addresses; %s", rp_string (retval));
1677: #endif SENDMTS
1678: }
1679:
1680: /* */
1681:
1682: #ifndef MHMTS
1683: static void
1684: do_text(file, fd)
1685: register char *file;
1686: int fd;
1687: {
1688: int retval,
1689: state;
1690: char buf[BUFSIZ];
1691: #ifdef MMDFMTS
1692: struct rp_bufstruct reply;
1693: #endif MMDFMTS
1694:
1695: (void) lseek (fd, 0L, 0);
1696: while ((state = read (fd, buf, sizeof buf)) > 0)
1697: #ifdef MMDFMTS
1698: if (rp_isbad (mm_wtxt (buf, state)))
1699: die (NULLCP, "problem writing text [%s]\n", rp_valstr (retval));
1700: #endif MMDFMTS
1701: #ifdef SENDMTS
1702: if (rp_isbad (retval = sm_wtxt (buf, state)))
1703: die (NULLCP, "problem writing text; %s\n", rp_string (retval));
1704: #endif SENDMTS
1705:
1706: if (state == NOTOK)
1707: die (file, "problem reading from");
1708:
1709: #ifdef MMDFMTS
1710: if (rp_isbad (retval = mm_wtend ()))
1711: die (NULLCP, "problem ending text [%s]\n", rp_valstr (retval));
1712:
1713: if (rp_isbad (retval = mm_rrply (&reply, &state)))
1714: die (NULLCP, "problem getting submission status [%s]\n",
1715: rp_valstr (retval));
1716:
1717: switch (rp_gval (reply.rp_val)) {
1718: case RP_OK:
1719: case RP_MOK:
1720: break;
1721:
1722: case RP_NO:
1723: die (NULLCP, "you lose; %s", reply.rp_line);
1724:
1725: case RP_NDEL:
1726: die (NULLCP, "no delivery occurred; %s", reply.rp_line);
1727:
1728: case RP_AGN:
1729: die (NULLCP, "try again later; %s", reply.rp_line);
1730:
1731: case RP_NOOP:
1732: die (NULLCP, "nothing done; %s", reply.rp_line);
1733:
1734: default:
1735: die (NULLCP, "unexpected response;\n\t[%s] -- %s",
1736: rp_valstr (reply.rp_val), reply.rp_line);
1737: }
1738: #endif MMDFMTS
1739: #ifdef SENDMTS
1740: switch (retval = sm_wtend ()) {
1741: case RP_OK:
1742: break;
1743:
1744: case RP_NO:
1745: case RP_NDEL:
1746: die (NULLCP, "posting failed; %s", rp_string (retval));
1747:
1748: default:
1749: die (NULLCP, "unexpected response; %s", rp_string (retval));
1750: }
1751: #endif SENDMTS
1752: }
1753: #endif not MHMTS
1754:
1755: /* MTS-SPECIFIC INTERACTION */
1756:
1757: #ifdef MMDFMTS
1758:
1759: #ifndef TMA
1760: /* ARGSUSED */
1761: #endif TMA
1762:
1763: static void
1764: do_an_address(lp, talk, tma)
1765: register struct mailname *lp;
1766: int talk, tma;
1767: {
1768: int len,
1769: retval;
1770: register char *mbox,
1771: *host,
1772: *text,
1773: *path;
1774: char addr[BUFSIZ];
1775: #ifdef TMA
1776: char reason[BUFSIZ];
1777: #endif TMA
1778: struct rp_bufstruct reply;
1779:
1780: switch (lp -> m_type) {
1781: case LOCALHOST:
1782: mbox = lp -> m_mbox;
1783: host = LocalName ();
1784: (void) strcpy (addr, mbox);
1785: break;
1786:
1787: case UUCPHOST:
1788: #ifdef MF
1789: mbox = concat (lp -> m_host, "!", lp -> m_mbox, NULLCP);
1790: host = UucpChan ();
1791: (void) strcpy (addr, mbox);
1792: break;
1793: #else MF
1794: fprintf (talk ? stdout : stderr, " %s!%s: %s\n",
1795: lp -> m_host, lp -> m_mbox, "not supported; UUCP address");
1796: unkadr++;
1797: (void) fflush (stdout);
1798: return;
1799: #endif MF
1800:
1801: default: /* let MMDF decide if the host is bad */
1802: mbox = lp -> m_mbox;
1803: host = lp -> m_host;
1804: (void) sprintf (addr, "%s at %s", mbox, host);
1805: break;
1806: }
1807: #ifdef TMA
1808: if ((!whomsw || checksw)
1809: && tma
1810: && seekaddr (mbox, host, reason) == NOTOK) {
1811: fprintf (talk ? stdout : stderr, " %s%s: %s\n",
1812: addr, "[TMA]", reason);
1813: unkadr++;
1814: }
1815: #endif TMA
1816:
1817: if (talk)
1818: printf (" %s%s", addr, whomsw && lp -> m_bcc ? "[BCC]" : "");
1819:
1820: if (whomsw && !checksw) {
1821: (void) putchar ('\n');
1822: return;
1823: }
1824: if (talk)
1825: printf (": ");
1826: (void) fflush (stdout);
1827:
1828: /* */
1829:
1830: #ifdef MMDFII
1831: if (lp -> m_path)
1832: path = concat (lp -> m_path, mbox, "@", host, NULLCP);
1833: else
1834: #endif MMDFII
1835: path = NULLCP;
1836: if (rp_isbad (retval = mm_wadr (path ? NULLCP : host, path ? path : mbox))
1837: || rp_isbad (retval = mm_rrply (&reply, &len)))
1838: die (NULLCP, "problem submitting address [%s]", rp_valstr (retval));
1839:
1840: switch (rp_gval (reply.rp_val)) {
1841: case RP_AOK:
1842: if (talk)
1843: printf ("address ok\n");
1844: (void) fflush (stdout);
1845: return;
1846:
1847: #ifdef RP_DOK
1848: case RP_DOK:
1849: if (talk)
1850: printf ("nameserver timeout - queued for checking\n");
1851: (void) fflush (stdout);
1852: return;
1853: #endif RP_DOK
1854:
1855: case RP_NO:
1856: text = "you lose";
1857: break;
1858:
1859: #ifdef RP_NS
1860: case RP_NS:
1861: text = "temporary nameserver failure";
1862: break;
1863:
1864: #endif RP_NS
1865:
1866: case RP_USER:
1867: case RP_NDEL:
1868: text = "not deliverable";
1869: break;
1870:
1871: case RP_AGN:
1872: text = "try again later";
1873: break;
1874:
1875: case RP_NOOP:
1876: text = "nothing done";
1877: break;
1878:
1879: default:
1880: if (!talk)
1881: fprintf (stderr, " %s: ", addr);
1882: text = "unexpected response";
1883: die (NULLCP, "%s;\n [%s] -- %s", text,
1884: rp_valstr (reply.rp_val), reply.rp_line);
1885: }
1886:
1887: if (!talk)
1888: fprintf (stderr, " %s: ", addr);
1889: fprintf (talk ? stdout : stderr, "%s;\n %s\n", text, reply.rp_line);
1890: unkadr++;
1891:
1892: (void) fflush (stdout);
1893: }
1894: #endif MMDFMTS
1895:
1896: /* */
1897:
1898: #ifdef MHMTS
1899: /* ARGSUSED */
1900:
1901: static void
1902: do_an_address(lp, talk, tma)
1903: register struct mailname *lp;
1904: int talk, tma;
1905: {
1906: register char *mbox;
1907: char addr[BUFSIZ];
1908:
1909: switch (lp -> m_type) {
1910: case LOCALHOST:
1911: (void) strcpy (addr, lp -> m_mbox);
1912: break;
1913:
1914: case UUCPHOST:
1915: (void) sprintf (addr, "%s!%s", lp -> m_host, lp -> m_mbox);
1916: break;
1917:
1918: default:
1919: (void) sprintf (addr, "%s at %s", lp -> m_mbox, lp -> m_host);
1920: break;
1921: }
1922: if (talk)
1923: printf (" %s%s", addr, whomsw && lp -> m_bcc ? "[BCC]" : "");
1924:
1925: if (whomsw && !checksw) {
1926: (void) putchar ('\n');
1927: return;
1928: }
1929: if (talk)
1930: printf (": ");
1931: (void) fflush (stdout);
1932:
1933: /* */
1934:
1935: switch (lp -> m_type) {
1936: case LOCALHOST:
1937: mbox = lp -> m_mbox;
1938: if (*mbox == '~')
1939: mbox++;
1940: if (seek_home (mbox)) {
1941: lp -> m_mbox = mbox;
1942: if (talk)
1943: printf ("address ok\n");
1944: }
1945: else {
1946: if (!talk)
1947: fprintf (stderr, " %s: ", addr);
1948: fprintf (talk ? stdout : stderr,
1949: "not deliverable; unknown user\n");
1950: unkadr++;
1951: }
1952: break;
1953:
1954: case UUCPHOST:
1955: if (uucpsite (lp -> m_host) == OK) {
1956: if (talk)
1957: printf ("address ok\n");
1958: }
1959: else {
1960: if (!talk)
1961: fprintf (stderr, " %s: ", addr);
1962: fprintf (talk ? stdout : stderr,
1963: "not deliverable; unknown system\n");
1964: unkadr++;
1965: }
1966: break;
1967:
1968: case NETHOST:
1969: if (talk)
1970: printf ("address ok\n");
1971: break;
1972:
1973: default:
1974: if (!talk)
1975: fprintf (stderr, " %s: ", addr);
1976: fprintf (talk ? stdout : stderr,
1977: "not deliverable; unknown host\n");
1978: unkadr++;
1979: break;
1980: }
1981:
1982: (void) fflush (stdout);
1983: }
1984: #endif MHMTS
1985:
1986: /* */
1987:
1988: #ifdef SENDMTS
1989:
1990: #ifndef TMA
1991: /* ARGSUSED */
1992: #endif TMA
1993:
1994: static void
1995: do_an_address(lp, talk, tma)
1996: register struct mailname *lp;
1997: int talk, tma;
1998: {
1999: int retval;
2000: register char *mbox,
2001: *host;
2002: char addr[BUFSIZ];
2003: #ifdef TMA
2004: char reason[BUFSIZ];
2005: #endif TMA
2006:
2007: switch (lp -> m_type) {
2008: case LOCALHOST:
2009: mbox = lp -> m_mbox;
2010: host = lp -> m_host;
2011: (void) strcpy (addr, mbox);
2012: break;
2013:
2014: case UUCPHOST:
2015: mbox = auxformat (lp, 0);
2016: host = NULL;
2017: (void) sprintf (addr, "%s!%s", lp -> m_host, lp -> m_mbox);
2018: break;
2019:
2020: default: /* let SendMail decide if the host is bad */
2021: mbox = lp -> m_mbox;
2022: host = lp -> m_host;
2023: (void) sprintf (addr, "%s at %s", mbox, host);
2024: break;
2025: }
2026:
2027: #ifdef TMA
2028: if ((!whomsw || checksw)
2029: && tma
2030: && seekaddr (mbox, host, reason) == NOTOK) {
2031: fprintf (talk ? stdout : stderr, " %s%s: %s\n",
2032: addr, "[TMA]", reason);
2033: unkadr++;
2034: }
2035: #endif TMA
2036:
2037: if (talk)
2038: printf (" %s%s", addr, whomsw && lp -> m_bcc ? "[BCC]" : "");
2039:
2040: if (whomsw && !checksw) {
2041: (void) putchar ('\n');
2042: return;
2043: }
2044: if (talk)
2045: printf (": ");
2046: (void) fflush (stdout);
2047:
2048: /* */
2049:
2050: switch (retval = sm_wadr (mbox, host,
2051: lp -> m_type != UUCPHOST ? lp -> m_path : NULLCP)) {
2052: case RP_OK:
2053: if (talk)
2054: printf ("address ok\n");
2055: break;
2056:
2057: case RP_NO:
2058: case RP_USER:
2059: if (!talk)
2060: fprintf (stderr, " %s: ", addr);
2061: fprintf (talk ? stdout : stderr, "loses; %s\n",
2062: rp_string (retval));
2063: unkadr++;
2064: break;
2065:
2066: default:
2067: if (!talk)
2068: fprintf (stderr, " %s: ", addr);
2069: die (NULLCP, "unexpected response; %s", rp_string (retval));
2070: }
2071:
2072: (void) fflush (stdout);
2073: }
2074: #endif SENDMTS
2075:
2076: /* SIGNAL HANDLING */
2077:
2078: #ifndef MHMTS
2079:
2080: /* ARGSUSED */
2081:
2082: static int
2083: sigser(i)
2084: int i;
2085: {
2086: #ifndef BSD42
2087: (void) signal (i, SIG_IGN);
2088: #endif not BSD42
2089: (void) unlink (tmpfil);
2090: if (msgflags & MINV)
2091: (void) unlink (bccfil);
2092: #ifdef MMDFMTS
2093: if (!whomsw || checksw)
2094: (void) mm_end (NOTOK);
2095: #endif MMDFMTS
2096: #ifdef SENDMTS
2097: if (!whomsw || checksw)
2098: (void) sm_end (NOTOK);
2099: #endif SENDMTS
2100: done (1);
2101: }
2102: #endif not MHMTS
2103:
2104:
2105: static void
2106: sigon()
2107: {
2108: if (debug)
2109: return;
2110:
2111: #ifndef MHMTS
2112: setsigx (hstat, SIGHUP, sigser);
2113: setsigx (istat, SIGINT, sigser);
2114: setsigx (qstat, SIGQUIT, sigser);
2115: setsigx (tstat, SIGTERM, sigser);
2116: #else MHMTS
2117: setsigx (hstat, SIGHUP, SIG_IGN);
2118: setsigx (istat, SIGINT, SIG_IGN);
2119: setsigx (qstat, SIGQUIT, SIG_IGN);
2120: setsigx (tstat, SIGTERM, SIG_IGN);
2121: #endif MHMTS
2122: }
2123:
2124:
2125: static void
2126: sigoff()
2127: {
2128: if (debug)
2129: return;
2130:
2131: (void) signal (SIGHUP, hstat);
2132: (void) signal (SIGINT, istat);
2133: (void) signal (SIGQUIT, qstat);
2134: (void) signal (SIGTERM, tstat);
2135: }
2136:
2137: /* FCC INTERACTION */
2138:
2139: static void
2140: postrefile(file)
2141: register char *file;
2142: {
2143: register int i;
2144:
2145: if (fccind == 0)
2146: return;
2147:
2148: #ifdef MHMTS
2149: (void) setuid (myuid);
2150: #endif MHMTS
2151: if (verbose)
2152: printf (" -- Filing Folder Copies --\n");
2153: for (i = 0; i < fccind; i++)
2154: fcc (file, fccfold[i]);
2155: if (verbose)
2156: printf (" -- Folder Copies Filed --\n");
2157: }
2158:
2159:
2160: static void
2161: fcc(file, folder)
2162: register char *file, *folder;
2163: {
2164: int i,
2165: child_id,
2166: status;
2167: char fold[BUFSIZ];
2168:
2169: if (verbose)
2170: printf (" %sFcc %s: ", msgstate == RESENT ? "Resent-" : "", folder);
2171: (void) fflush (stdout);
2172:
2173: for (i = 0; (child_id = fork ()) == NOTOK && i < 5; i++)
2174: sleep (5);
2175: switch (child_id) {
2176: case NOTOK:
2177: if (!verbose)
2178: fprintf (stderr, " %sFcc %s: ",
2179: msgstate == RESENT ? "Resent-" : "", folder);
2180: fprintf (verbose ? stdout : stderr, "no forks, so not ok\n");
2181: break;
2182:
2183: case OK:
2184: (void) sprintf (fold, "%s%s",
2185: *folder == '+' || *folder == '@' ? "" : "+", folder);
2186: execlp (fileproc, r1bindex (fileproc, '/'),
2187: "-link", "-file", file, fold, NULLCP);
2188: _exit (-1);
2189:
2190: default:
2191: if (status = pidwait (child_id, OK)) {
2192: if (!verbose)
2193: fprintf (stderr, " %sFcc %s: ",
2194: msgstate == RESENT ? "Resent-" : "", folder);
2195: (void) pidstatus (status, verbose ? stdout : stderr, NULLCP);
2196: }
2197: else
2198: if (verbose)
2199: printf ("folder ok\n");
2200: }
2201:
2202: (void) fflush (stdout);
2203: }
2204:
2205: /* TERMINATION */
2206:
2207: /* VARARGS2 */
2208:
2209: static void
2210: die(what, fmt, a, b, c, d)
2211: char *what, *fmt, *a, *b, *c, *d;
2212: {
2213: #ifndef MHMTS
2214: (void) unlink (tmpfil);
2215: if (msgflags & MINV)
2216: (void) unlink (bccfil);
2217: #endif MHMTS
2218: #ifdef MMDFMTS
2219: if (!whomsw || checksw)
2220: (void) mm_end (NOTOK);
2221: #endif MMDFMTS
2222: #ifdef SENDMTS
2223: if (!whomsw || checksw)
2224: (void) sm_end (NOTOK);
2225: #endif SENDMTS
2226:
2227: adios (what, fmt, a, b, c, d);
2228: }
2229:
2230:
2231: #ifdef MMDFMTS
2232: /*
2233: * err_abrt() is used by the mm_ routines
2234: * do not, under *ANY* circumstances, remove it from post,
2235: * or you will lose *BIG*
2236: */
2237:
2238: err_abrt(code, fmt, a, b, c)
2239: int code;
2240: char *fmt, *a, *b, *c;
2241: {
2242: char buffer[BUFSIZ];
2243:
2244: (void) sprintf (buffer, "[%s]", rp_valstr (code));
2245:
2246: adios (buffer, fmt, a, b, c);
2247: }
2248: #endif MMDFMTS
2249:
2250: /* STAND-ALONE DELIVERY */
2251:
2252: #ifdef MHMTS
2253:
2254: /* BUG: MHMTS ignores 822-style route addresses... */
2255:
2256: static void
2257: localmail(lp, talk, fd)
2258: register struct mailname *lp;
2259: int talk, fd;
2260: {
2261: int md;
2262: char mailbox[BUFSIZ],
2263: ddate[BUFSIZ];
2264: register struct home *hp;
2265:
2266: if (talk)
2267: printf (" %s: ", lp -> m_mbox);
2268: (void) fflush (stdout);
2269:
2270: if ((hp = seek_home (lp -> m_mbox)) == NULL) {
2271: if (!talk)
2272: fprintf (stderr, " %s: ", lp -> m_mbox);
2273: fprintf (talk ? stdout : stderr,
2274: "not deliverable; unknown address\n");
2275: unkadr++;
2276: return;
2277: }
2278:
2279: (void) sprintf (mailbox, "%s/%s",
2280: mmdfldir[0] ? mmdfldir : hp -> h_home,
2281: mmdflfil[0] ? mmdflfil : hp -> h_name);
2282:
2283: /* */
2284:
2285: switch (access (slocalproc, 01)) {
2286: default:
2287: if (talk)
2288: printf ("(invoking hook)\n\t");
2289: (void) fflush (stdout);
2290:
2291: if (usr_hook (lp, talk, fd, hp, mailbox) != NOTOK)
2292: return;
2293: if (talk)
2294: printf (" %s: ", lp -> m_mbox);
2295: (void) fflush (stdout);
2296:
2297: case NOTOK:
2298: (void) lseek (fd, 0L, 0);
2299: if ((md = mbx_open (mailbox, hp -> h_uid, hp -> h_gid, m_gmprot ()))
2300: == NOTOK) {
2301: if (!talk)
2302: fprintf (stderr, " %s: ", lp -> m_mbox);
2303: fprintf (talk ? stdout : stderr,
2304: "error in transmission; unable to open maildrop\n");
2305: unkadr++;
2306: return;
2307: }
2308: (void) sprintf (ddate, "Delivery-Date: %s\n", dtimenow ());
2309: if (mbx_copy (mailbox, md, fd, 0, ddate, 0) == NOTOK) {
2310: if (!talk)
2311: fprintf (stderr, " %s: ", lp -> m_mbox);
2312: fprintf (talk ? stdout : stderr,
2313: "error in transmission; write to maildrop failed\n");
2314: unkadr++;
2315: (void) close (md);
2316: return;
2317: }
2318: mbx_close (mailbox, md);
2319:
2320: if (talk)
2321: printf ("sent\n");
2322: break;
2323: }
2324:
2325: (void) fflush (stdout);
2326: }
2327:
2328: /* */
2329:
2330: static int
2331: usr_hook(lp, talk, fd, hp, mailbox)
2332: register struct mailname *lp;
2333: int talk, fd;
2334: register struct home *hp;
2335: register char *mailbox;
2336: {
2337: int i,
2338: child_id,
2339: status;
2340: char tmpfil[BUFSIZ];
2341:
2342: if ((fd = copyfile (fd, tmpfil)) == NOTOK) {
2343: if (!talk)
2344: fprintf (stderr, " %s: ", lp -> m_mbox);
2345: fprintf (talk ? stdout : stderr,
2346: "unable to copy message; skipping hook\n");
2347: return NOTOK;
2348: }
2349: (void) chown (tmpfil, hp -> h_uid, hp -> h_gid);
2350:
2351: (void) fflush (stdout);
2352:
2353: for (i = 0; (child_id = fork ()) == NOTOK && i < 5; i++)
2354: sleep (5);
2355: switch (child_id) {
2356: case NOTOK:
2357: if (!talk)
2358: fprintf (stderr, " %s: ", lp -> m_mbox);
2359: fprintf (talk ? stdout : stderr,
2360: "unable to invoke hook; fork() failed\n");
2361: return NOTOK;
2362:
2363: case OK:
2364: if (fd != 0)
2365: (void) dup2 (fd, 0);
2366: (void) freopen ("/dev/null", "w", stdout);
2367: (void) freopen ("/dev/null", "w", stderr);
2368: if (fd != 3) /* backwards compatible... */
2369: (void) dup2 (fd, 3);
2370: closefds (4);
2371: #ifdef TIOCNOTTY
2372: if ((fd = open ("/dev/tty", 2)) != NOTOK) {
2373: (void) ioctl (fd, TIOCNOTTY, NULLCP);
2374: (void) close (fd);
2375: }
2376: #endif TIOCNOTTY
2377: #ifdef BSD42
2378: (void) setpgrp (0, getpid ());
2379: #endif BSD42
2380:
2381: *environ = NULL;
2382: (void) putenv ("USER", hp -> h_name);
2383: (void) putenv ("HOME", hp -> h_home);
2384: (void) putenv ("SHELL", hp -> h_shell);
2385: if (chdir (hp -> h_home) == NOTOK)
2386: (void) chdir ("/");
2387: (void) umask (0077);
2388: #ifdef BSD41A
2389: (void) inigrp (hp -> h_name, hp -> h_gid);
2390: #endif BSD41A
2391: (void) setgid (hp -> h_gid);
2392: #ifdef BSD42
2393: (void) initgroups (hp -> h_name, hp -> h_gid);
2394: #endif BSD42
2395: (void) setuid (hp -> h_uid);
2396:
2397: execlp (slocalproc, r1bindex (slocalproc, '/'),
2398: "-file", tmpfil, "-mailbox", mailbox,
2399: "-home", hp -> h_home, "-addr", lp -> m_aka,
2400: "-user", hp -> h_name, "-sender", from,
2401: talk ? "-verbose" : NULLCP, NULLCP);
2402: _exit (-1);
2403:
2404: /* */
2405:
2406: default:
2407: (void) close (fd);
2408:
2409: status = pidwait (child_id, OK);
2410:
2411: (void) unlink (tmpfil);
2412: if (status == 0) {
2413: if (talk)
2414: printf ("accepted\n");
2415: return OK;
2416: }
2417: if (!talk)
2418: fprintf (stderr, " %s: ", lp -> m_mbox);
2419: fprintf (talk ? stdout : stderr,
2420: "%s error on hook; status=0%o\n",
2421: status & 0x00ff ? "system" : "user",
2422: status & 0x00ff ? status & 0xff
2423: : (status & 0xff00) >> 8);
2424: return NOTOK;
2425: }
2426: }
2427:
2428: /* */
2429:
2430: static int
2431: copyfile(qd, tmpfil)
2432: int qd;
2433: register char *tmpfil;
2434: {
2435: int i,
2436: fd;
2437: char buffer[BUFSIZ];
2438:
2439: (void) strcpy (tmpfil, m_tmpfil ("hook"));
2440: if ((fd = creat (tmpfil, 0600)) == NOTOK)
2441: return NOTOK;
2442: (void) close (fd);
2443: if ((fd = open (tmpfil, 2)) == NOTOK)
2444: return NOTOK;
2445:
2446: (void) lseek (qd, 0L, 0);
2447: while ((i = read (qd, buffer, sizeof buffer)) > 0)
2448: if (write (fd, buffer, i) != i) {
2449: (void) close (fd);
2450: return NOTOK;
2451: }
2452: if (i == NOTOK) {
2453: (void) close (fd);
2454: return NOTOK;
2455: }
2456:
2457: (void) lseek (fd, 0L, 0);
2458:
2459: return fd;
2460: }
2461:
2462: /* */
2463:
2464: static void
2465: uucpmail(lp, talk, fd, from)
2466: register struct mailname *lp;
2467: int talk, fd, from;
2468: {
2469: int i;
2470: SIGDECL (*pstat)();
2471: char addr[BUFSIZ],
2472: buffer[BUFSIZ];
2473: register FILE *fp;
2474:
2475: (void) sprintf (addr, "%s!%s", lp -> m_host, lp -> m_mbox);
2476: if (talk)
2477: printf (" %s: ", addr);
2478: (void) fflush (stdout);
2479:
2480: #ifndef UCI
2481: (void) sprintf (buffer, "uux -r -p %s!rmail \\(%s\\)",
2482: lp -> m_host, lp -> m_mbox);
2483: #else UCI
2484: (void) sprintf (buffer, "uux -p %s!rmail \\(%s\\)", lp -> m_host,
2485: lp -> m_mbox);
2486: #endif UCI
2487: if ((fp = popen (buffer, "w")) == NULL) {
2488: if (!talk)
2489: fprintf (stderr, " %s: ", addr);
2490: fprintf (talk ? stdout : stderr,
2491: "unable to start uux; popen() failed\n");
2492: unkadr++;
2493: return;
2494: }
2495:
2496: pstat = signal (SIGPIPE, SIG_IGN);
2497: if (from) { /* no mail filtering, so... */
2498: (void) sprintf (buffer, "From %s %.24s remote from %s\n",
2499: getusr (), ctime (&clock), SystemName ());
2500: i = strlen (buffer);
2501: if (fwrite (buffer, sizeof *buffer, i, fp) != i)
2502: goto oops;
2503: }
2504:
2505: (void) lseek (fd, 0L, 0);
2506: while ((i = read (fd, buffer, sizeof buffer)) > 0)
2507: if (fwrite (buffer, sizeof *buffer, i, fp) != i) {
2508: oops: ;
2509: if (!talk)
2510: fprintf (stderr, " %s: ", addr);
2511: fprintf (talk ? stdout : stderr,
2512: "error in transmission; write to uux failed\n");
2513: unkadr++;
2514: (void) pclose (fp);
2515: return;
2516: }
2517: if (pclose (fp))
2518: goto oops;
2519: (void) signal (SIGPIPE, pstat);
2520:
2521: if (i < 0) {
2522: if (!talk)
2523: fprintf (stderr, " %s: ", addr);
2524: fprintf (talk ? stdout : stderr,
2525: "error in transmission; read failed\n");
2526: unkadr++;
2527: return;
2528: }
2529:
2530: if (talk)
2531: printf ("queued (via uux)\n");
2532: (void) fflush (stdout);
2533: }
2534:
2535: /* */
2536:
2537: #ifdef MF
2538: static int
2539: make_uucp_file(td)
2540: int td;
2541: {
2542: int i,
2543: qd,
2544: fd;
2545: char tmpfil[BUFSIZ];
2546:
2547: (void) lseek (td, 0L, 0);
2548: if ((qd = dup (td)) == NOTOK)
2549: adios ("fd", "unable to dup");
2550:
2551: (void) strcpy (tmpfil, m_tmpfil ("uumf"));
2552: if ((fd = creat (tmpfil, 0600)) == NOTOK)
2553: adios (tmpfil, "unable to create");
2554: (void) close (fd);
2555: if ((fd = open (tmpfil, 2)) == NOTOK)
2556: adios (tmpfil, "unable to re-open");
2557:
2558: switch (i = mmdf2uucp (qd, fd, 1)) {
2559: case OK:
2560: if (!debug)
2561: (void) unlink (tmpfil);
2562: break;
2563:
2564: default:
2565: adios (NULLCP, "unable to filter mail(%d), examine %s", i, tmpfil);
2566: }
2567: (void) close (qd);
2568:
2569: return fd;
2570: }
2571: #endif MF
2572:
2573: /* */
2574:
2575: static void
2576: netmail(talk, fd, bccque)
2577: int talk, fd, bccque;
2578: {
2579: int i,
2580: naddrs;
2581: char buffer[BUFSIZ];
2582: register struct mailname *lp;
2583:
2584: naddrs = 0;
2585: if (nm_init (getusr (), &clock) == NOTOK) {
2586: for (lp = netaddrs.m_next; lp; lp = lp -> m_next)
2587: if (lp -> m_bcc ? bccque : !bccque)
2588: fprintf (stderr, " %s at %s: unable to get queue file\n",
2589: lp -> m_mbox, lp -> m_host);
2590: return;
2591: }
2592:
2593: for (lp = netaddrs.m_next; lp; lp = lp -> m_next)
2594: if (lp -> m_bcc ? bccque : !bccque) {
2595: (void) nm_wadr (lp -> m_mbox, lp -> m_host);
2596: naddrs++;
2597: if (talk)
2598: printf (" %s at %s: queued\n", lp -> m_mbox, lp -> m_host);
2599: (void) fflush (stdout);
2600: }
2601: nm_waend ();
2602:
2603: (void) lseek (fd, 0L, 0);
2604: while ((i = read (fd, buffer, sizeof buffer)) > 0)
2605: if (nm_wtxt (buffer, i) == NOTOK) {
2606: fprintf (stderr,
2607: "error in transmission; write to temporary failed");
2608: unkadr += naddrs;
2609: return;
2610: }
2611:
2612: if (i < 0) {
2613: fprintf (stderr, "error in transmission; read failed\n");
2614: unkadr += naddrs;
2615: return;
2616: }
2617:
2618: if (nm_wtend () == NOTOK) {
2619: fprintf (stderr, "error in transmission; unable to queue message\n");
2620: unkadr += naddrs;
2621: return;
2622: }
2623: }
2624: #endif MHMTS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.