SMTPMTS has been the default for over a decade, so it's time to get rid of
[mmh] / uip / post.c
1
2 /*
3  * post.c -- enter messages into the mail transport system
4  *
5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
6  * COPYRIGHT file in the root directory of the nmh distribution for
7  * complete copyright information.
8  */
9
10 #include <h/mh.h>
11 #include <fcntl.h>
12 #include <h/signals.h>
13 #include <h/addrsbr.h>
14 #include <h/aliasbr.h>
15 #include <h/dropsbr.h>
16 #include <h/mime.h>
17 #include <h/utils.h>
18
19 #include <h/tws.h>
20 #include <h/mts.h>
21
22 #include <errno.h>
23 #include <signal.h>
24
25 #ifdef HAVE_SYS_TIME_H
26 # include <sys/time.h>
27 #endif
28 #include <time.h>
29
30 #include <mts/smtp/smtp.h>
31
32 #ifndef CYRUS_SASL
33 # define SASLminc(a) (a)
34 #else /* CYRUS_SASL */
35 # define SASLminc(a)  0
36 #endif /* CYRUS_SASL */
37
38 #ifndef TLS_SUPPORT
39 # define TLSminc(a)  (a)
40 #else /* TLS_SUPPORT */
41 # define TLSminc(a)   0
42 #endif /* TLS_SUPPORT */
43
44 #define FCCS            10      /* max number of fccs allowed */
45
46 #define uptolow(c)      ((isalpha(c) && isupper (c)) ? tolower (c) : c)
47
48 /* In the following array of structures, the numeric second field of the
49    structures (minchars) is apparently used like this:
50
51    -# : Switch can be abbreviated to # characters; switch hidden in -help.
52    0  : Switch can't be abbreviated;               switch shown in -help.
53    #  : Switch can be abbreviated to # characters; switch shown in -help. */
54
55 static struct swit switches[] = {
56 #define ALIASW                    0
57     { "alias aliasfile", 0 },
58 #define CHKSW                     1
59     { "check", -5 },                    /* interface from whom */
60 #define NCHKSW                    2
61     { "nocheck", -7 },                  /* interface from whom */
62 #define DEBUGSW                   3
63     { "debug", -5 },
64 #define DISTSW                    4
65     { "dist", -4 },                     /* interface from dist */
66 #define FILTSW                    5
67     { "filter filterfile", 0 },
68 #define NFILTSW                   6
69     { "nofilter", 0 },
70 #define FRMTSW                    7
71     { "format", 0 },
72 #define NFRMTSW                   8
73     { "noformat", 0 },
74 #define LIBSW                     9
75     { "library directory", -7 },        /* interface from send, whom */
76 #define MIMESW                   10
77     { "mime", 0 },
78 #define NMIMESW                  11
79     { "nomime", 0 },
80 #define MSGDSW                   12
81     { "msgid", 0 },
82 #define NMSGDSW                  13
83     { "nomsgid", 0 },
84 #define VERBSW                   14
85     { "verbose", 0 },
86 #define NVERBSW                  15
87     { "noverbose", 0 },
88 #define WATCSW                   16
89     { "watch", 0 },
90 #define NWATCSW                  17
91     { "nowatch", 0 },
92 #define WHOMSW                   18
93     { "whom", -4 },                     /* interface from whom */
94 #define WIDTHSW                  19
95     { "width columns", 0 },
96 #define VERSIONSW                20
97     { "version", 0 },
98 #define HELPSW                   21
99     { "help", 0 },
100 #define BITSTUFFSW               22
101     { "dashstuffing", -12 },            /* should we dashstuff BCC messages? */
102 #define NBITSTUFFSW              23
103     { "nodashstuffing", -14 },
104 #define MAILSW                   24
105     { "mail", -4 },                     /* specify MAIL smtp mode */
106 #define SAMLSW                   25
107     { "saml", -4 },                     /* specify SAML smtp mode */
108 #define SENDSW                   26
109     { "send", -4 },                     /* specify SEND smtp mode */
110 #define SOMLSW                   27
111     { "soml", -4 },                     /* specify SOML smtp mode */
112 #define ANNOSW                   28
113     { "idanno number", -6 },            /* interface from send    */
114 #define DLVRSW                   29
115     { "deliver address-list", -7 },
116 #define CLIESW                   30
117     { "client host", -6 },
118 #define SERVSW                   31
119     { "server host", -6 },              /* specify alternate SMTP server */
120 #define SNOOPSW                  32
121     { "snoop", -5 },                    /* snoop the SMTP transaction */
122 #define FILLSW                   33
123     { "fill-in file", -7 },
124 #define FILLUSW                  34
125     { "fill-up", -7 },
126 #define PARTSW                   35
127     { "partno", -6 },
128 #define QUEUESW                  36
129     { "queued", -6 },
130 #define SASLSW                   37
131     { "sasl", SASLminc(-4) },
132 #define NOSASLSW                 38
133     { "nosasl", SASLminc(-6) },
134 #define SASLMXSSFSW              39
135     { "saslmaxssf", SASLminc(-10) },
136 #define SASLMECHSW               40
137     { "saslmech", SASLminc(-5) },
138 #define USERSW                   41
139     { "user", SASLminc(-4) },
140 #define PORTSW                   42
141     { "port server port name/number", 4 },
142 #define TLSSW                    43
143     { "tls", TLSminc(-3) },
144 #define FILEPROCSW               44
145     { "fileproc", -4 },
146 #define MHLPROCSW                45
147     { "mhlproc", -3 },
148     { NULL, 0 }
149 };
150
151
152 struct headers {
153     char *value;
154     unsigned int flags;
155     unsigned int set;
156 };
157
158 /*
159  * flags for headers->flags
160  */
161 #define HNOP  0x0000            /* just used to keep .set around          */
162 #define HBAD  0x0001            /* bad header - don't let it through      */
163 #define HADR  0x0002            /* header has an address field            */
164 #define HSUB  0x0004            /* Subject: header                        */
165 #define HTRY  0x0008            /* try to send to addrs on header         */
166 #define HBCC  0x0010            /* don't output this header               */
167 #define HMNG  0x0020            /* munge this header                      */
168 #define HNGR  0x0040            /* no groups allowed in this header       */
169 #define HFCC  0x0080            /* FCC: type header                       */
170 #define HNIL  0x0100            /* okay for this header not to have addrs */
171 #define HIGN  0x0200            /* ignore this header                     */
172 #define HDCC  0x0400            /* another undocumented feature           */
173
174 /*
175  * flags for headers->set
176  */
177 #define MFRM  0x0001            /* we've seen a From:        */
178 #define MDAT  0x0002            /* we've seen a Date:        */
179 #define MRFM  0x0004            /* we've seen a Resent-From: */
180 #define MVIS  0x0008            /* we've seen sighted addrs  */
181 #define MINV  0x0010            /* we've seen blind addrs    */
182
183
184 static struct headers NHeaders[] = {
185     { "Return-Path", HBAD,                0 },
186     { "Received",    HBAD,                0 },
187     { "Reply-To",    HADR|HNGR,           0 },
188     { "From",        HADR|HNGR,           MFRM },
189     { "Sender",      HADR|HBAD,           0 },
190     { "Date",        HBAD,                0 },
191     { "Subject",     HSUB,                0 },
192     { "To",          HADR|HTRY,           MVIS },
193     { "cc",          HADR|HTRY,           MVIS },
194     { "Bcc",         HADR|HTRY|HBCC|HNIL, MINV },
195     { "Dcc",         HADR|HTRY|HDCC|HNIL, MVIS },       /* sorta cc & bcc combined */
196     { "Message-ID",  HBAD,                0 },
197     { "Fcc",         HFCC,                0 },
198     { NULL,          0,                   0 }
199 };
200
201 static struct headers RHeaders[] = {
202     { "Resent-Reply-To",   HADR|HNGR,           0 },
203     { "Resent-From",       HADR|HNGR,           MRFM },
204     { "Resent-Sender",     HADR|HBAD,           0 },
205     { "Resent-Date",       HBAD,                0 },
206     { "Resent-Subject",    HSUB,                0 },
207     { "Resent-To",         HADR|HTRY,           MVIS },
208     { "Resent-cc",         HADR|HTRY,           MVIS },
209     { "Resent-Bcc",        HADR|HTRY|HBCC,      MINV },
210     { "Resent-Message-ID", HBAD,                0 },
211     { "Resent-Fcc",        HFCC,                0 },
212     { "Reply-To",          HADR,                0 },
213     { "From",              HADR|HNGR,           MFRM },
214     { "Sender",            HADR|HNGR,           0 },
215     { "Date",              HNOP,                MDAT },
216     { "To",                HADR|HNIL,           0 },
217     { "cc",                HADR|HNIL,           0 },
218     { "Bcc",               HADR|HTRY|HBCC|HNIL, 0 },
219     { "Fcc",               HIGN,                0 },
220     { NULL,                0,                   0 }
221 };
222
223 static short fccind = 0;        /* index into fccfold[] */
224 static short outputlinelen = OUTPUTLINELEN;
225
226 static int pfd = NOTOK;         /* fd to write annotation list to        */
227 static uid_t myuid= -1;         /* my user id                            */
228 static gid_t mygid= -1;         /* my group id                           */
229 static int recipients = 0;      /* how many people will get a copy       */
230 static int unkadr = 0;          /* how many of those were unknown        */
231 static int badadr = 0;          /* number of bad addrs                   */
232 static int badmsg = 0;          /* message has bad semantics             */
233 static int verbose = 0;         /* spell it out                          */
234 static int format = 1;          /* format addresses                      */
235 static int mime = 0;            /* use MIME-style encapsulations for Bcc */
236 static int msgid = 0;           /* add msgid                             */
237 static int debug = 0;           /* debugging post                        */
238 static int watch = 0;           /* watch the delivery process            */
239 static int whomsw = 0;          /* we are whom not post                  */
240 static int checksw = 0;         /* whom -check                           */
241 static int linepos=0;           /* putadr()'s position on the line       */
242 static int nameoutput=0;        /* putadr() has output header name       */
243 static int sasl=0;              /* Use SASL auth for SMTP                */
244 static int saslssf=-1;          /* Our maximum SSF for SASL              */
245 static char *saslmech=NULL;     /* Force use of particular SASL mech     */
246 static char *user=NULL;         /* Authenticate as this user             */
247 static char *port="smtp";       /* Name of server port for SMTP          */
248 static int tls=0;               /* Use TLS for encryption                */
249
250 static unsigned msgflags = 0;   /* what we've seen */
251
252 #define NORMAL 0
253 #define RESENT 1
254 static int msgstate = NORMAL;
255
256 static time_t tclock = 0;       /* the time we started (more or less) */
257
258 static SIGNAL_HANDLER hstat, istat, qstat, tstat;
259
260 static char tmpfil[BUFSIZ];
261 static char bccfil[BUFSIZ];
262
263 static char from[BUFSIZ];       /* my network address            */
264 static char signature[BUFSIZ];  /* my signature                  */
265 static char *filter = NULL;     /* the filter for BCC'ing        */
266 static char *subject = NULL;    /* the subject field for BCC'ing */
267 static char *fccfold[FCCS];     /* foldernames for FCC'ing       */
268
269 static struct headers  *hdrtab; /* table for the message we're doing */
270
271 static struct mailname localaddrs;              /* local addrs     */
272 static struct mailname netaddrs;                /* network addrs   */
273 static struct mailname uuaddrs;                 /* uucp addrs      */
274 static struct mailname tmpaddrs;                /* temporary queue */
275
276 static int snoop      = 0;
277 static int smtpmode   = S_MAIL;
278 static char *clientsw = NULL;
279 static char *serversw = NULL;
280
281 extern struct smtp sm_reply;
282
283 static char prefix[] = "----- =_aaaaaaaaaa";
284
285 static int fill_up = 0;
286 static char *fill_in = NULL;
287 static char *partno = NULL;
288 static int queued = 0;
289
290 extern boolean  draft_from_masquerading;  /* defined in mts.c */
291
292 /*
293  * static prototypes
294  */
295 static void putfmt (char *, char *, FILE *);
296 static void start_headers (void);
297 static void finish_headers (FILE *);
298 static int get_header (char *, struct headers *);
299 static int putadr (char *, char *, struct mailname *, FILE *, unsigned int);
300 static void putgrp (char *, char *, FILE *, unsigned int);
301 static int insert (struct mailname *);
302 static void pl (void);
303 static void anno (void);
304 static int annoaux (struct mailname *);
305 static void insert_fcc (struct headers *, unsigned char *);
306 static void make_bcc_file (int);
307 static void verify_all_addresses (int);
308 static void chkadr (void);
309 static void sigon (void);
310 static void sigoff (void);
311 static void p_refile (char *);
312 static void fcc (char *, char *);
313 static void die (char *, char *, ...);
314 static void post (char *, int, int);
315 static void do_text (char *file, int fd);
316 static void do_an_address (struct mailname *, int);
317 static void do_addresses (int, int);
318 static int find_prefix (void);
319
320
321 int
322 main (int argc, char **argv)
323 {
324     int state, compnum, dashstuff = 0;
325     char *cp, *msg = NULL, **argp, **arguments;
326     char buf[BUFSIZ], name[NAMESZ];
327     FILE *in, *out;
328
329 #ifdef LOCALE
330     setlocale(LC_ALL, "");
331 #endif
332     invo_name = r1bindex (argv[0], '/');
333
334     /* foil search of user profile/context */
335     if (context_foil (NULL) == -1)
336         done (1);
337
338     mts_init (invo_name);
339     arguments = getarguments (invo_name, argc, argv, 0);
340     argp = arguments;
341
342     while ((cp = *argp++)) {
343         if (*cp == '-') {
344             switch (smatch (++cp, switches)) {
345                 case AMBIGSW: 
346                     ambigsw (cp, switches);
347                     done (1);
348                 case UNKWNSW: 
349                     adios (NULL, "-%s unknown", cp);
350
351                 case HELPSW: 
352                     snprintf (buf, sizeof(buf), "%s [switches] file", invo_name);
353                     print_help (buf, switches, 0);
354                     done (1);
355                 case VERSIONSW:
356                     print_version(invo_name);
357                     done (1);
358
359                 case LIBSW:
360                     if (!(cp = *argp++) || *cp == '-')
361                         adios (NULL, "missing argument to %s", argp[-2]);
362                     /* create a minimal context */
363                     if (context_foil (cp) == -1)
364                         done (1);
365                     continue;
366
367                 case ALIASW: 
368                     if (!(cp = *argp++) || *cp == '-')
369                         adios (NULL, "missing argument to %s", argp[-2]);
370                     if ((state = alias (cp)) != AK_OK)
371                         adios (NULL, "aliasing error in %s - %s",
372                                 cp, akerror (state));
373                     continue;
374
375                 case CHKSW: 
376                     checksw++;
377                     continue;
378                 case NCHKSW: 
379                     checksw = 0;
380                     continue;
381
382                 case DEBUGSW: 
383                     debug++;
384                     continue;
385
386                 case DISTSW:
387                     msgstate = RESENT;
388                     continue;
389
390                 case FILTSW:
391                     if (!(filter = *argp++) || *filter == '-')
392                         adios (NULL, "missing argument to %s", argp[-2]);
393                     mime = 0;
394                     continue;
395                 case NFILTSW:
396                     filter = NULL;
397                     continue;
398                 
399                 case FRMTSW: 
400                     format++;
401                     continue;
402                 case NFRMTSW: 
403                     format = 0;
404                     continue;
405
406                 case BITSTUFFSW:
407                     dashstuff = 1;
408                     continue;
409                 case NBITSTUFFSW:
410                     dashstuff = -1;
411                     continue;
412
413                 case MIMESW:
414                     mime++;
415                     filter = NULL;
416                     continue;
417                 case NMIMESW: 
418                     mime = 0;
419                     continue;
420
421                 case MSGDSW: 
422                     msgid++;
423                     continue;
424                 case NMSGDSW: 
425                     msgid = 0;
426                     continue;
427
428                 case VERBSW: 
429                     verbose++;
430                     continue;
431                 case NVERBSW: 
432                     verbose = 0;
433                     continue;
434
435                 case WATCSW: 
436                     watch++;
437                     continue;
438                 case NWATCSW: 
439                     watch = 0;
440                     continue;
441
442                 case WHOMSW: 
443                     whomsw++;
444                     continue;
445
446                 case WIDTHSW: 
447                     if (!(cp = *argp++) || *cp == '-')
448                         adios (NULL, "missing argument to %s", argp[-2]);
449                     if ((outputlinelen = atoi (cp)) < 10)
450                         adios (NULL, "impossible width %d", outputlinelen);
451                     continue;
452
453                 case ANNOSW: 
454                     if (!(cp = *argp++) || *cp == '-')
455                         adios (NULL, "missing argument to %s", argp[-2]);
456                     if ((pfd = atoi (cp)) <= 2)
457                         adios (NULL, "bad argument %s %s", argp[-2], cp);
458                     continue;
459
460                 case DLVRSW:
461                     if (!(cp = *argp++) || *cp == '-')
462                         adios (NULL, "missing argument to %s", argp[-2]);
463                     continue;
464
465                 case MAILSW:
466                     smtpmode = S_MAIL;
467                     continue;
468                 case SAMLSW:
469                     smtpmode = S_SAML;
470                     continue;
471                 case SOMLSW:
472                     smtpmode = S_SOML;
473                     continue;
474                 case SENDSW:
475                     smtpmode = S_SEND;
476                     continue;
477                 case CLIESW:
478                     if (!(clientsw = *argp++) || *clientsw == '-')
479                         adios (NULL, "missing argument to %s", argp[-2]);
480                     continue;
481                 case SERVSW:
482                     if (!(serversw = *argp++) || *serversw == '-')
483                         adios (NULL, "missing argument to %s", argp[-2]);
484                     continue;
485                 case SNOOPSW:
486                     snoop++;
487                     continue;
488
489                 case FILLSW:
490                     if (!(fill_in = *argp++) || *fill_in == '-')
491                         adios (NULL, "missing argument to %s", argp[-2]);
492                     continue;
493                 case FILLUSW:
494                     fill_up++;
495                     continue;
496                 case PARTSW:
497                     if (!(partno = *argp++) || *partno == '-')
498                         adios (NULL, "missing argument to %s", argp[-2]);
499                     continue;
500
501                 case QUEUESW:
502                     queued++;
503                     continue;
504                 
505                 case SASLSW:
506                     sasl++;
507                     continue;
508
509                 case NOSASLSW:
510                     sasl = 0;
511                     continue;
512
513                 case SASLMXSSFSW:
514                     if (!(cp = *argp++) || *cp == '-')
515                         adios (NULL, "missing argument to %s", argp[-2]);
516                     saslssf = atoi(cp);
517                     continue;
518                 
519                 case SASLMECHSW:
520                     if (!(saslmech = *argp++) || *saslmech == '-')
521                         adios (NULL, "missing argument to %s", argp[-2]);
522                     continue;
523                 
524                 case USERSW:
525                     if (!(user = *argp++) || *user == '-')
526                         adios (NULL, "missing argument to %s", argp[-2]);
527                     continue;
528
529                 case PORTSW:
530                     if (!(port = *argp++) || *port == '-')
531                         adios (NULL, "missing argument to %s", argp[-2]);
532                     continue;
533
534                 case TLSSW:
535                     tls++;
536                     continue;
537
538                 case FILEPROCSW:
539                     if (!(cp = *argp++) || *cp == '-')
540                         adios (NULL, "missing argument to %s", argp[-2]);
541                     fileproc = cp;
542                     continue;
543
544                 case MHLPROCSW:
545                     if (!(cp = *argp++) || *cp == '-')
546                         adios (NULL, "missing argument to %s", argp[-2]);
547                     mhlproc = cp;
548                     continue;
549             }
550         }
551         if (msg)
552             adios (NULL, "only one message at a time!");
553         else
554             msg = cp;
555     }
556
557     alias (AliasFile);
558
559     if (!msg)
560         adios (NULL, "usage: %s [switches] file", invo_name);
561
562     if (outputlinelen < 10)
563         adios (NULL, "impossible width %d", outputlinelen);
564
565     if ((in = fopen (msg, "r")) == NULL)
566         adios (msg, "unable to open");
567
568     start_headers ();
569     if (debug) {
570         verbose++;
571         discard (out = stdout); /* XXX: reference discard() to help loader */
572     } else {
573         if (whomsw) {
574             if ((out = fopen (fill_in ? fill_in : "/dev/null", "w")) == NULL)
575                 adios ("/dev/null", "unable to open");
576         } else {
577             char *cp = m_mktemp(m_maildir(invo_name), NULL, &out);
578             if (cp == NULL) {
579                 cp = m_mktemp2(NULL, invo_name, NULL, &out);
580                 if (cp == NULL) {
581                     adios ("post", "unable to create temporary file");
582                 }
583             }
584             strncpy(tmpfil, cp, sizeof(tmpfil));
585             chmod (tmpfil, 0600);
586         }
587     }
588
589     hdrtab = msgstate == NORMAL ? NHeaders : RHeaders;
590
591     for (compnum = 1, state = FLD;;) {
592         switch (state = m_getfld (state, name, buf, sizeof(buf), in)) {
593             case FLD: 
594             case FLDEOF: 
595             case FLDPLUS: 
596                 compnum++;
597                 cp = add (buf, NULL);
598                 while (state == FLDPLUS) {
599                     state = m_getfld (state, name, buf, sizeof(buf), in);
600                     cp = add (buf, cp);
601                 }
602                 putfmt (name, cp, out);
603                 free (cp);
604                 if (state != FLDEOF)
605                     continue;
606                 finish_headers (out);
607                 break;
608
609             case BODY: 
610             case BODYEOF: 
611                 finish_headers (out);
612                 if (whomsw && !fill_in)
613                     break;
614                 fprintf (out, "\n%s", buf);
615                 while (state == BODY) {
616                     state = m_getfld (state, name, buf, sizeof(buf), in);
617                     fputs (buf, out);
618                 }
619                 break;
620
621             case FILEEOF: 
622                 finish_headers (out);
623                 break;
624
625             case LENERR: 
626             case FMTERR: 
627                 adios (NULL, "message format error in component #%d", compnum);
628
629             default: 
630                 adios (NULL, "getfld() returned %d", state);
631         }
632         break;
633     }
634
635     if (pfd != NOTOK)
636         anno ();
637     fclose (in);
638
639     if (debug) {
640         pl ();
641         done (0);
642     } else {
643         fclose (out);
644     }
645
646     /* If we are doing a "whom" check */
647     if (whomsw) {
648         if (!fill_up)
649             verify_all_addresses (1);
650         done (0);
651     }
652
653     if (msgflags & MINV) {
654         make_bcc_file (dashstuff);
655         if (msgflags & MVIS) {
656             verify_all_addresses (verbose);
657             post (tmpfil, 0, verbose);
658         }
659         post (bccfil, 1, verbose);
660         unlink (bccfil);
661     } else {
662         post (tmpfil, 0, isatty (1));
663     }
664
665     p_refile (tmpfil);
666     unlink (tmpfil);
667
668     if (verbose)
669         printf (partno ? "Partial Message #%s Processed\n" : "Message Processed\n",
670                 partno);
671     done (0);
672     return 1;
673 }
674
675
676 /*
677  * DRAFT GENERATION
678  */
679
680 static void
681 putfmt (char *name, char *str, FILE *out)
682 {
683     int count, grp, i, keep;
684     char *cp, *pp, *qp;
685     char namep[BUFSIZ];
686     struct mailname *mp = NULL, *np = NULL;
687     struct headers *hdr;
688
689     while (*str == ' ' || *str == '\t')
690         str++;
691
692     if (msgstate == NORMAL && uprf (name, "resent")) {
693         advise (NULL, "illegal header line -- %s:", name);
694         badmsg++;
695         return;
696     }
697
698     if ((i = get_header (name, hdrtab)) == NOTOK) {
699         fprintf (out, "%s: %s", name, str);
700         return;
701     }
702
703     hdr = &hdrtab[i];
704     if (hdr->flags & HIGN) {
705         if (fill_in)
706             fprintf (out, "%s: %s", name, str);
707         return;
708     }
709     if (hdr->flags & HBAD) {
710         if (fill_in)
711             fprintf (out, "%s: %s", name, str);
712         else {
713             advise (NULL, "illegal header line -- %s:", name);
714             badmsg++;
715         }
716         return;
717     }
718     msgflags |= (hdr->set & ~(MVIS | MINV));
719
720     if (hdr->flags & HSUB)
721         subject = subject ? add (str, add ("\t", subject)) : getcpy (str);
722     if (hdr->flags & HFCC) {
723         if (fill_in) {
724             fprintf (out, "%s: %s", name, str);
725             return;
726         }
727
728         if ((cp = strrchr(str, '\n')))
729             *cp = 0;
730         for (cp = pp = str; (cp = strchr(pp, ',')); pp = cp) {
731             *cp++ = 0;
732             insert_fcc (hdr, pp);
733         }
734         insert_fcc (hdr, pp);
735         return;
736     }
737
738     if (!(hdr->flags & HADR)) {
739         fprintf (out, "%s: %s", name, str);
740         return;
741     }
742
743     tmpaddrs.m_next = NULL;
744     for (count = 0; (cp = getname (str)); count++)
745         if ((mp = getm (cp, NULL, 0, AD_HOST, NULL))) {
746             if (tmpaddrs.m_next)
747                 np->m_next = mp;
748             else
749                 tmpaddrs.m_next = mp;
750             np = mp;
751         }
752         else
753             if (hdr->flags & HTRY)
754                 badadr++;
755             else
756                 badmsg++;
757
758     if (count < 1) {
759         if (hdr->flags & HNIL)
760             fprintf (out, "%s: %s", name, str);
761         else {
762 #ifdef notdef
763             advise (NULL, "%s: field requires at least one address", name);
764             badmsg++;
765 #endif /* notdef */
766         }
767         return;
768     }
769
770     nameoutput = linepos = 0;
771     snprintf (namep, sizeof(namep), "%s%s",
772                 !fill_in && (hdr->flags & HMNG) ? "Original-" : "", name);
773
774     for (grp = 0, mp = tmpaddrs.m_next; mp; mp = np)
775         if (mp->m_nohost) {     /* also used to test (hdr->flags & HTRY) */
776             /* The address doesn't include a host, so it might be an alias. */
777             pp = akvalue (mp->m_mbox);  /* do mh alias substitution */
778             qp = akvisible () ? mp->m_mbox : "";
779             np = mp;
780             if (np->m_gname)
781                 putgrp (namep, np->m_gname, out, hdr->flags);
782             while ((cp = getname (pp))) {
783                 if (!(mp = getm (cp, NULL, 0, AD_HOST, NULL))) {
784                     badadr++;
785                     continue;
786                 }
787
788                 if (draft_from_masquerading && ((msgstate == RESENT)
789                                                 ? (hdr->set & MRFM)
790                                                 : (hdr->set & MFRM)))
791                     /* The user manually specified a [Resent-]From: address in
792                        their draft and the "masquerade:" line in mts.conf
793                        doesn't contain "draft_from", so we'll set things up to
794                        use the actual email address embedded in the draft
795                        [Resent-]From: (after alias substitution, and without the
796                        GECOS full name or angle brackets) as the envelope
797                        From:. */
798                     strncpy(from, auxformat(mp, 0), sizeof(from) - 1);
799
800                 if (hdr->flags & HBCC)
801                     mp->m_bcc++;
802                 if (np->m_ingrp)
803                     mp->m_ingrp = np->m_ingrp;
804                 else
805                     if (mp->m_gname)
806                         putgrp (namep, mp->m_gname, out, hdr->flags);
807                 if (mp->m_ingrp)
808                     grp++;
809                 if (putadr (namep, qp, mp, out, hdr->flags))
810                     msgflags |= (hdr->set & (MVIS | MINV));
811                 else
812                     mnfree (mp);
813             }
814             mp = np;
815             np = np->m_next;
816             mnfree (mp);
817         }
818         else {
819             /* Address includes a host, so no alias substitution is needed. */
820             if (draft_from_masquerading && ((msgstate == RESENT)
821                                             ? (hdr->set & MRFM)
822                                             : (hdr->set & MFRM)))
823                 /* The user manually specified a [Resent-]From: address in
824                    their draft and the "masquerade:" line in mts.conf
825                    doesn't contain "draft_from", so we'll set things up to
826                    use the actual email address embedded in the draft
827                    [Resent-]From: (after alias substitution, and without the
828                    GECOS full name or angle brackets) as the envelope
829                    From:. */
830                 strncpy(from, auxformat(mp, 0), sizeof(from) - 1);
831
832             if (hdr->flags & HBCC)
833                 mp->m_bcc++;
834             if (mp->m_gname)
835                 putgrp (namep, mp->m_gname, out, hdr->flags);
836             if (mp->m_ingrp)
837                 grp++;
838             keep = putadr (namep, "", mp, out, hdr->flags);
839             np = mp->m_next;
840             if (keep) {
841                 mp->m_next = NULL;
842                 msgflags |= (hdr->set & (MVIS | MINV));
843             }
844             else
845                 mnfree (mp);
846         }
847
848     if (grp > 0 && (hdr->flags & HNGR)) {
849         advise (NULL, "%s: field does not allow groups", name);
850         badmsg++;
851     }
852     if (linepos) {
853         if (fill_in && grp > 0)
854             putc (';', out);
855         putc ('\n', out);
856     }
857 }
858
859
860 static void
861 start_headers (void)
862 {
863     unsigned char  *cp;
864     char myhost[BUFSIZ], sigbuf[BUFSIZ];
865     struct mailname *mp;
866
867     myuid = getuid ();
868     mygid = getgid ();
869     time (&tclock);
870
871     strncpy (from, getlocaladdr(), sizeof(from));
872     strncpy (myhost, LocalName (0), sizeof(myhost));
873
874     for (cp = myhost; *cp; cp++)
875         *cp = uptolow (*cp);
876
877     if ((cp = getfullname ()) && *cp) {
878         strncpy (sigbuf, cp, sizeof(sigbuf));
879         snprintf (signature, sizeof(signature), "%s <%s>",
880                 sigbuf, getlocaladdr());
881         if ((cp = getname (signature)) == NULL)
882             adios (NULL, "getname () failed -- you lose extraordinarily big");
883         if ((mp = getm (cp, NULL, 0, AD_HOST, NULL)) == NULL)
884             adios (NULL, "bad signature '%s'", sigbuf);
885         mnfree (mp);
886         while (getname (""))
887             continue;
888     } else {
889         strncpy (signature, getlocaladdr(), sizeof(signature));
890     }
891 }
892
893
894 /*
895  * Now that we've outputted the header fields in the draft
896  * message, we will now output any remaining header fields
897  * that we need to add/create.
898  */
899
900 static void
901 finish_headers (FILE *out)
902 {
903     switch (msgstate) {
904         case NORMAL: 
905             if (whomsw && !fill_up)
906                 break;
907
908             fprintf (out, "Date: %s\n", dtime (&tclock, 0));
909             if (msgid)
910                 fprintf (out, "Message-ID: <%d.%ld@%s>\n",
911                         (int) getpid (), (long) tclock, LocalName (1));
912             if (msgflags & MFRM) {
913                 /* There was already a From: in the draft.  Don't add one. */
914                 if (!draft_from_masquerading)
915                     /* mts.conf didn't contain "masquerade:[...]draft_from[...]"
916                        so we'll reveal the user's actual account@thismachine
917                        address in a Sender: header (and use it as the envelope
918                        From: later). */
919                     fprintf (out, "Sender: %s\n", from);
920             }
921             else
922                 /* Construct a From: header. */
923                 fprintf (out, "From: %s\n", signature);
924             if (whomsw)
925                 break;
926
927             if (!(msgflags & MVIS))
928                 fprintf (out, "Bcc: Blind Distribution List: ;\n");
929             break;
930
931         case RESENT: 
932             if (!(msgflags & MDAT)) {
933                 advise (NULL, "message has no Date: header");
934                 badmsg++;
935             }
936             if (!(msgflags & MFRM)) {
937                 advise (NULL, "message has no From: header");
938                 badmsg++;
939             }
940             if (whomsw && !fill_up)
941                 break;
942
943             fprintf (out, "Resent-Date: %s\n", dtime (&tclock, 0));
944             if (msgid)
945                 fprintf (out, "Resent-Message-ID: <%d.%ld@%s>\n",
946                         (int) getpid (), (long) tclock, LocalName (1));
947             if (msgflags & MRFM) {
948                 /* There was already a Resent-From: in draft.  Don't add one. */
949                 if (!draft_from_masquerading)
950                     /* mts.conf didn't contain "masquerade:[...]draft_from[...]"
951                        so we'll reveal the user's actual account@thismachine
952                        address in a Sender: header (and use it as the envelope
953                        From: later). */
954                     fprintf (out, "Resent-Sender: %s\n", from);
955             }
956             else
957                 /* Construct a Resent-From: header. */
958                 fprintf (out, "Resent-From: %s\n", signature);
959             if (whomsw)
960                 break;
961             if (!(msgflags & MVIS))
962                 fprintf (out, "Resent-Bcc: Blind Re-Distribution List: ;\n");
963             break;
964     }
965
966     if (badmsg)
967         adios (NULL, "re-format message and try again");
968     if (!recipients)
969         adios (NULL, "no addressees");
970 }
971
972
973 static int
974 get_header (char *header, struct headers *table)
975 {
976     struct headers *h;
977
978     for (h = table; h->value; h++)
979         if (!mh_strcasecmp (header, h->value))
980             return (h - table);
981
982     return NOTOK;
983 }
984
985
986 static int
987 putadr (char *name, char *aka, struct mailname *mp, FILE *out, unsigned int flags)
988 {
989     int len;
990     char *cp;
991     char buffer[BUFSIZ];
992
993     if (mp->m_mbox == NULL || ((flags & HTRY) && !insert (mp)))
994         return 0;
995     if ((!fill_in && (flags & (HBCC | HDCC))) || mp->m_ingrp)
996         return 1;
997
998     if (!nameoutput) {
999         fprintf (out, "%s: ", name);
1000         linepos += (nameoutput = strlen (name) + 2);
1001     }
1002
1003     if (*aka && mp->m_type != UUCPHOST && !mp->m_pers)
1004         mp->m_pers = getcpy (aka);
1005     if (format) {
1006         if (mp->m_gname && !fill_in) {
1007             snprintf (buffer, sizeof(buffer), "%s;", mp->m_gname);
1008             cp = buffer;
1009         } else {
1010             cp = adrformat (mp);
1011         }
1012     } else {
1013         cp = mp->m_text;
1014     }
1015     len = strlen (cp);
1016
1017     if (linepos != nameoutput) {
1018         if (len + linepos + 2 > outputlinelen)
1019             fprintf (out, ",\n%*s", linepos = nameoutput, "");
1020         else {
1021             fputs (", ", out);
1022             linepos += 2;
1023         }
1024     }
1025
1026     fputs (cp, out);
1027     linepos += len;
1028
1029     return (flags & HTRY);
1030 }
1031
1032
1033 static void
1034 putgrp (char *name, char *group, FILE *out, unsigned int flags)
1035 {
1036     int len;
1037     char *cp;
1038
1039     if (!fill_in && (flags & HBCC))
1040         return;
1041
1042     if (!nameoutput) {
1043         fprintf (out, "%s: ", name);
1044         linepos += (nameoutput = strlen (name) + 2);
1045         if (fill_in)
1046             linepos -= strlen (group);
1047     }
1048
1049     cp = fill_in ? group : concat (group, ";", NULL);
1050     len = strlen (cp);
1051
1052     if (linepos > nameoutput) {
1053         if (len + linepos + 2 > outputlinelen) {
1054             fprintf (out, ",\n%*s", nameoutput, "");
1055             linepos = nameoutput;
1056         }
1057         else {
1058             fputs (", ", out);
1059             linepos += 2;
1060         }
1061     }
1062
1063     fputs (cp, out);
1064     linepos += len;
1065 }
1066
1067
1068 static int
1069 insert (struct mailname *np)
1070 {
1071     struct mailname *mp;
1072
1073     if (np->m_mbox == NULL)
1074         return 0;
1075
1076     for (mp = np->m_type == LOCALHOST ? &localaddrs
1077             : np->m_type == UUCPHOST ? &uuaddrs
1078             : &netaddrs;
1079             mp->m_next;
1080             mp = mp->m_next)
1081         if (!mh_strcasecmp (np->m_host, mp->m_next->m_host)
1082                 && !mh_strcasecmp (np->m_mbox, mp->m_next->m_mbox)
1083                 && np->m_bcc == mp->m_next->m_bcc)
1084             return 0;
1085
1086     mp->m_next = np;
1087     recipients++;
1088     return 1;
1089 }
1090
1091
1092 static void
1093 pl (void)
1094 {
1095     int i;
1096     struct mailname *mp;
1097
1098     printf ("-------\n\t-- Addresses --\nlocal:\t");
1099     for (mp = localaddrs.m_next; mp; mp = mp->m_next)
1100         printf ("%s%s%s", mp->m_mbox,
1101                 mp->m_bcc ? "[BCC]" : "",
1102                 mp->m_next ? ",\n\t" : "");
1103
1104     printf ("\nnet:\t");
1105     for (mp = netaddrs.m_next; mp; mp = mp->m_next)
1106         printf ("%s%s@%s%s%s", mp->m_path ? mp->m_path : "",
1107                 mp->m_mbox, mp->m_host,
1108                 mp->m_bcc ? "[BCC]" : "",
1109                 mp->m_next ? ",\n\t" : "");
1110
1111     printf ("\nuucp:\t");
1112     for (mp = uuaddrs.m_next; mp; mp = mp->m_next)
1113         printf ("%s!%s%s%s", mp->m_host, mp->m_mbox,
1114                 mp->m_bcc ? "[BCC]" : "",
1115                 mp->m_next ? ",\n\t" : "");
1116
1117     printf ("\n\t-- Folder Copies --\nfcc:\t");
1118     for (i = 0; i < fccind; i++)
1119         printf ("%s%s", fccfold[i], i + 1 < fccind ? ",\n\t" : "");
1120     printf ("\n");
1121 }
1122
1123
1124 static void
1125 anno (void)
1126 {
1127     struct mailname *mp;
1128
1129     for (mp = localaddrs.m_next; mp; mp = mp->m_next)
1130         if (annoaux (mp) == NOTOK)
1131             goto oops;
1132
1133     for (mp = netaddrs.m_next; mp; mp = mp->m_next)
1134         if (annoaux (mp) == NOTOK)
1135             goto oops;
1136
1137     for (mp = uuaddrs.m_next; mp; mp = mp->m_next)
1138         if (annoaux (mp) == NOTOK)
1139             break;
1140
1141 oops: ;
1142     close (pfd);
1143     pfd = NOTOK;
1144 }
1145
1146
1147 static int
1148 annoaux (struct mailname *mp)
1149 {
1150     int i;
1151     char buffer[BUFSIZ];
1152
1153     snprintf (buffer, sizeof(buffer), "%s\n", adrformat (mp));
1154     i = strlen (buffer);
1155
1156     return (write (pfd, buffer, i) == i ? OK : NOTOK);
1157 }
1158
1159
1160 static void
1161 insert_fcc (struct headers *hdr, unsigned char *pp)
1162 {
1163     unsigned char *cp;
1164
1165     for (cp = pp; isspace (*cp); cp++)
1166         continue;
1167     for (pp += strlen (pp) - 1; pp > cp && isspace (*pp); pp--)
1168         continue;
1169     if (pp >= cp)
1170         *++pp = 0;
1171     if (*cp == 0)
1172         return;
1173
1174     if (fccind >= FCCS)
1175         adios (NULL, "too many %ss", hdr->value);
1176     fccfold[fccind++] = getcpy (cp);
1177 }
1178
1179 /*
1180  * BCC GENERATION
1181  */
1182
1183 static void
1184 make_bcc_file (int dashstuff)
1185 {
1186     int fd, i;
1187     pid_t child_id;
1188     char *vec[6];
1189     FILE *out;
1190     char *tfile = NULL;
1191
1192     tfile = m_mktemp2(NULL, "bccs", NULL, &out);
1193     if (tfile == NULL) adios("bcc", "unable to create temporary file");
1194     chmod (bccfil, 0600);
1195     strncpy (bccfil, tfile, sizeof(bccfil));
1196
1197     fprintf (out, "Date: %s\n", dtime (&tclock, 0));
1198     if (msgid)
1199         fprintf (out, "Message-ID: <%d.%ld@%s>\n",
1200                 (int) getpid (), (long) tclock, LocalName (1));
1201     if (msgflags & MFRM) {
1202       /* There was already a From: in the draft.  Don't add one. */
1203       if (!draft_from_masquerading)
1204         /* mts.conf didn't contain "masquerade:[...]draft_from[...]"
1205            so we'll reveal the user's actual account@thismachine
1206            address in a Sender: header (and use it as the envelope
1207            From: later). */
1208         fprintf (out, "Sender: %s\n", from);
1209     }
1210     else
1211       /* Construct a From: header. */
1212       fprintf (out, "From: %s\n", signature);
1213     if (subject)
1214         fprintf (out, "Subject: %s", subject);
1215     fprintf (out, "BCC:\n");
1216
1217     /*
1218      * Use MIME encapsulation for Bcc messages
1219      */
1220     if (mime) {
1221         char *cp;
1222
1223         /*
1224          * Check if any lines in the message clash with the
1225          * prefix for the MIME multipart separator.  If there
1226          * is a clash, increment one of the letters in the
1227          * prefix and check again.
1228          */
1229         if ((cp = strchr(prefix, 'a')) == NULL)
1230             adios (NULL, "lost prefix start");
1231         while (find_prefix () == NOTOK) {
1232             if (*cp < 'z')
1233                 (*cp)++;
1234             else
1235                 if (*++cp == 0)
1236                     adios (NULL, "can't find a unique delimiter string");
1237                 else
1238                     (*cp)++;
1239         }
1240
1241         fprintf (out, "%s: %s\n%s: multipart/digest; boundary=\"",
1242                  VRSN_FIELD, VRSN_VALUE, TYPE_FIELD);
1243         fprintf (out, "%s\"\n\n--%s\n\n", prefix, prefix);
1244     } else {
1245         fprintf (out, "\n------- Blind-Carbon-Copy\n\n");
1246     }
1247
1248     fflush (out);
1249
1250     /*
1251      * Do mhl filtering of Bcc messages instead
1252      * of MIME encapsulation.
1253      */
1254     if (filter != NULL) {
1255         vec[0] = r1bindex (mhlproc, '/');
1256
1257         for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
1258             sleep (5);
1259         switch (child_id) {
1260             case NOTOK: 
1261                 adios ("fork", "unable to");
1262
1263             case OK: 
1264                 dup2 (fileno (out), 1);
1265
1266                 i = 1;
1267                 vec[i++] = "-forward";
1268                 vec[i++] = "-form";
1269                 vec[i++] = filter;
1270                 vec[i++] = tmpfil;
1271
1272                 /* was the flag -[no]dashstuffing specified? */
1273                 if (dashstuff > 0)
1274                     vec[i++] = "-dashstuffing";
1275                 else if (dashstuff < 0)
1276                     vec[i++] = "-nodashstuffing";
1277                 vec[i] = NULL;
1278
1279                 execvp (mhlproc, vec);
1280                 fprintf (stderr, "unable to exec ");
1281                 perror (mhlproc);
1282                 _exit (-1);
1283
1284             default: 
1285                 pidXwait (child_id, mhlproc);
1286                 break;
1287         }
1288     } else {
1289         if ((fd = open (tmpfil, O_RDONLY)) == NOTOK)
1290             adios (tmpfil, "unable to re-open");
1291
1292         /*
1293          * If using MIME encapsulation, or if the -nodashstuffing
1294          * flag was given, then just copy message.  Else do
1295          * RFC934 quoting (dashstuffing).
1296          */
1297         if (mime || dashstuff < 0)
1298             cpydata (fd, fileno (out), tmpfil, bccfil);
1299         else
1300             cpydgst (fd, fileno (out), tmpfil, bccfil);
1301         close (fd);
1302     }
1303
1304     fseek (out, 0L, SEEK_END);
1305     if (mime)
1306         fprintf (out, "\n--%s--\n", prefix);
1307     else
1308         fprintf (out, "\n------- End of Blind-Carbon-Copy\n");
1309     fclose (out);
1310 }
1311
1312
1313 /*
1314  * Scan message to check if any lines clash with
1315  * the prefix of the MIME multipart separator.
1316  */
1317
1318 static int
1319 find_prefix (void)
1320 {
1321     int result = OK;
1322     unsigned char buffer[BUFSIZ];
1323     FILE *in;
1324
1325     if ((in = fopen (tmpfil, "r")) == NULL)
1326         adios (tmpfil, "unable to re-open");
1327
1328     while (fgets (buffer, sizeof(buffer) - 1, in))
1329         if (buffer[0] == '-' && buffer[1] == '-') {
1330             unsigned char *cp;
1331
1332             for (cp = buffer + strlen (buffer) - 1; cp >= buffer; cp--)
1333                 if (!isspace (*cp))
1334                     break;
1335             *++cp = '\0';
1336             if (strcmp (buffer + 2, prefix) == 0) {
1337                 result = NOTOK;
1338                 break;
1339             }
1340         }
1341
1342     fclose (in);
1343     return result;
1344 }
1345
1346
1347 #define plural(x) (x == 1 ? "" : "s")
1348
1349 static void
1350 chkadr (void)
1351 {
1352     if (badadr && unkadr)
1353         die (NULL, "%d address%s unparsable, %d addressee%s undeliverable",
1354                 badadr, plural (badadr), unkadr, plural (badadr));
1355     if (badadr)
1356         die (NULL, "%d address%s unparsable", badadr, plural (badadr));
1357     if (unkadr)
1358         die (NULL, "%d addressee%s undeliverable", unkadr, plural (unkadr));
1359 }
1360
1361
1362 static void
1363 do_addresses (int bccque, int talk)
1364 {
1365     int retval;
1366     int state;
1367     struct mailname *lp;
1368
1369     state = 0;
1370     for (lp = localaddrs.m_next; lp; lp = lp->m_next)
1371         if (lp->m_bcc ? bccque : !bccque) {
1372             if (talk && !state)
1373                 printf ("  -- Local Recipients --\n");
1374             do_an_address (lp, talk);
1375             state++;
1376         }
1377
1378     state = 0;
1379     for (lp = uuaddrs.m_next; lp; lp = lp->m_next)
1380         if (lp->m_bcc ? bccque : !bccque) {
1381             if (talk && !state)
1382                 printf ("  -- UUCP Recipients --\n");
1383             do_an_address (lp, talk);
1384             state++;
1385         }
1386
1387     state = 0;
1388     for (lp = netaddrs.m_next; lp; lp = lp->m_next)
1389         if (lp->m_bcc ? bccque : !bccque) {
1390             if (talk && !state)
1391                 printf ("  -- Network Recipients --\n");
1392             do_an_address (lp, talk);
1393             state++;
1394         }
1395
1396     chkadr ();
1397
1398     if (rp_isbad (retval = sm_waend ()))
1399         die (NULL, "problem ending addresses; %s", rp_string (retval));
1400 }
1401
1402
1403 /*
1404  * MTS-SPECIFIC INTERACTION
1405  */
1406
1407
1408 /*
1409  * SENDMAIL/SMTP routines
1410  */
1411
1412 static void
1413 post (char *file, int bccque, int talk)
1414 {
1415     int fd, onex;
1416     int retval;
1417
1418     onex = !(msgflags & MINV) || bccque;
1419     if (verbose) {
1420         if (msgflags & MINV)
1421             printf (" -- Posting for %s Recipients --\n",
1422                     bccque ? "Blind" : "Sighted");
1423         else
1424             printf (" -- Posting for All Recipients --\n");
1425     }
1426
1427     sigon ();
1428
1429     if (rp_isbad (retval = sm_init (clientsw, serversw, port, watch, verbose,
1430                                     snoop, onex, queued, sasl, saslssf,
1431                                     saslmech, user, tls))
1432             || rp_isbad (retval = sm_winit (smtpmode, from)))
1433         die (NULL, "problem initializing server; %s", rp_string (retval));
1434
1435     do_addresses (bccque, talk && verbose);
1436     if ((fd = open (file, O_RDONLY)) == NOTOK)
1437         die (file, "unable to re-open");
1438     do_text (file, fd);
1439     close (fd);
1440     fflush (stdout);
1441
1442     sm_end (onex ? OK : DONE);
1443     sigoff ();
1444
1445     if (verbose) {
1446         if (msgflags & MINV)
1447             printf (" -- %s Recipient Copies Posted --\n",
1448                     bccque ? "Blind" : "Sighted");
1449         else
1450             printf (" -- Recipient Copies Posted --\n");
1451     }
1452
1453     fflush (stdout);
1454 }
1455
1456
1457 /* Address Verification */
1458
1459 static void
1460 verify_all_addresses (int talk)
1461 {
1462     int retval;
1463     struct mailname *lp;
1464
1465     sigon ();
1466
1467     if (!whomsw || checksw)
1468         if (rp_isbad (retval = sm_init (clientsw, serversw, port, watch,
1469                                         verbose, snoop, 0, queued, sasl,
1470                                         saslssf, saslmech, user, tls))
1471                 || rp_isbad (retval = sm_winit (smtpmode, from)))
1472             die (NULL, "problem initializing server; %s", rp_string (retval));
1473
1474     if (talk && !whomsw)
1475         printf (" -- Address Verification --\n");
1476     if (talk && localaddrs.m_next)
1477         printf ("  -- Local Recipients --\n");
1478     for (lp = localaddrs.m_next; lp; lp = lp->m_next)
1479         do_an_address (lp, talk);
1480
1481     if (talk && uuaddrs.m_next)
1482         printf ("  -- UUCP Recipients --\n");
1483     for (lp = uuaddrs.m_next; lp; lp = lp->m_next)
1484         do_an_address (lp, talk);
1485
1486     if (talk && netaddrs.m_next)
1487         printf ("  -- Network Recipients --\n");
1488     for (lp = netaddrs.m_next; lp; lp = lp->m_next)
1489         do_an_address (lp, talk);
1490
1491     chkadr ();
1492     if (talk && !whomsw)
1493         printf (" -- Address Verification Successful --\n");
1494
1495     if (!whomsw || checksw)
1496         sm_end (DONE);
1497
1498     fflush (stdout);
1499     sigoff ();
1500 }
1501
1502
1503 static void
1504 do_an_address (struct mailname *lp, int talk)
1505 {
1506     int retval;
1507     char *mbox, *host;
1508     char addr[BUFSIZ];
1509
1510     switch (lp->m_type) {
1511         case LOCALHOST: 
1512             mbox = lp->m_mbox;
1513             host = lp->m_host;
1514             strncpy (addr, mbox, sizeof(addr));
1515             break;
1516
1517         case UUCPHOST: 
1518             mbox = auxformat (lp, 0);
1519             host = NULL;
1520             snprintf (addr, sizeof(addr), "%s!%s", lp->m_host, lp->m_mbox);
1521             break;
1522
1523         default:                /* let SendMail decide if the host is bad  */
1524             mbox = lp->m_mbox;
1525             host = lp->m_host;
1526             snprintf (addr, sizeof(addr), "%s at %s", mbox, host);
1527             break;
1528     }
1529
1530     if (talk)
1531         printf ("  %s%s", addr, whomsw && lp->m_bcc ? "[BCC]" : "");
1532
1533     if (whomsw && !checksw) {
1534         putchar ('\n');
1535         return;
1536     }
1537     if (talk)
1538         printf (": ");
1539     fflush (stdout);
1540
1541     switch (retval = sm_wadr (mbox, host,
1542                          lp->m_type != UUCPHOST ? lp->m_path : NULL)) {
1543         case RP_OK: 
1544             if (talk)
1545                 printf ("address ok\n");
1546             break;
1547
1548         case RP_NO: 
1549         case RP_USER: 
1550             if (!talk)
1551                 fprintf (stderr, "  %s: ", addr);
1552             fprintf (talk ? stdout : stderr, "loses; %s\n",
1553                         rp_string (retval));
1554             unkadr++;
1555             break;
1556
1557         default: 
1558             if (!talk)
1559                 fprintf (stderr, "  %s: ", addr);
1560             die (NULL, "unexpected response; %s", rp_string (retval));
1561     }
1562
1563     fflush (stdout);
1564 }
1565
1566
1567 static void
1568 do_text (char *file, int fd)
1569 {
1570     int retval, state;
1571     char buf[BUFSIZ];
1572
1573     lseek (fd, (off_t) 0, SEEK_SET);
1574
1575     while ((state = read (fd, buf, sizeof(buf))) > 0) {
1576         if (rp_isbad (retval = sm_wtxt (buf, state)))
1577             die (NULL, "problem writing text; %s\n", rp_string (retval));
1578     }
1579
1580     if (state == NOTOK)
1581         die (file, "problem reading from");
1582
1583     switch (retval = sm_wtend ()) {
1584         case RP_OK: 
1585             break;
1586
1587         case RP_NO: 
1588         case RP_NDEL: 
1589             die (NULL, "posting failed; %s", rp_string (retval));
1590
1591         default: 
1592             die (NULL, "unexpected response; %s", rp_string (retval));
1593     }
1594 }
1595
1596
1597 /*
1598  * SIGNAL HANDLING
1599  */
1600
1601 static void
1602 sigser (int i)
1603 {
1604     NMH_UNUSED (i);
1605
1606     unlink (tmpfil);
1607     if (msgflags & MINV)
1608         unlink (bccfil);
1609
1610     if (!whomsw || checksw)
1611         sm_end (NOTOK);
1612
1613     done (1);
1614 }
1615
1616
1617 static void
1618 sigon (void)
1619 {
1620     if (debug)
1621         return;
1622
1623     hstat = SIGNAL2 (SIGHUP, sigser);
1624     istat = SIGNAL2 (SIGINT, sigser);
1625     qstat = SIGNAL2 (SIGQUIT, sigser);
1626     tstat = SIGNAL2 (SIGTERM, sigser);
1627 }
1628
1629
1630 static void
1631 sigoff (void)
1632 {
1633     if (debug)
1634         return;
1635
1636     SIGNAL (SIGHUP, hstat);
1637     SIGNAL (SIGINT, istat);
1638     SIGNAL (SIGQUIT, qstat);
1639     SIGNAL (SIGTERM, tstat);
1640 }
1641
1642 /*
1643  * FCC INTERACTION
1644  */
1645
1646 static void
1647 p_refile (char *file)
1648 {
1649     int i;
1650
1651     if (fccind == 0)
1652         return;
1653
1654     if (verbose)
1655         printf (" -- Filing Folder Copies --\n");
1656     for (i = 0; i < fccind; i++)
1657         fcc (file, fccfold[i]);
1658     if (verbose)
1659         printf (" -- Folder Copies Filed --\n");
1660 }
1661
1662
1663 /*
1664  * Call the `fileproc' to add the file to the folder.
1665  */
1666
1667 static void
1668 fcc (char *file, char *folder)
1669 {
1670     pid_t child_id;
1671     int i, status;
1672     char fold[BUFSIZ];
1673
1674     if (verbose)
1675         printf ("  %sFcc %s: ", msgstate == RESENT ? "Resent-" : "", folder);
1676     fflush (stdout);
1677
1678     for (i = 0; (child_id = fork ()) == NOTOK && i < 5; i++)
1679         sleep (5);
1680
1681     switch (child_id) {
1682         case NOTOK: 
1683             if (!verbose)
1684                 fprintf (stderr, "  %sFcc %s: ",
1685                         msgstate == RESENT ? "Resent-" : "", folder);
1686             fprintf (verbose ? stdout : stderr, "no forks, so not ok\n");
1687             break;
1688
1689         case OK: 
1690             /* see if we need to add `+' */
1691             snprintf (fold, sizeof(fold), "%s%s",
1692                     *folder == '+' || *folder == '@' ? "" : "+", folder);
1693
1694             /* now exec the fileproc */
1695             execlp (fileproc, r1bindex (fileproc, '/'),
1696                     "-link", "-file", file, fold, NULL);
1697             _exit (-1);
1698
1699         default: 
1700             if ((status = pidwait (child_id, OK))) {
1701                 if (!verbose)
1702                     fprintf (stderr, "  %sFcc %s: ",
1703                             msgstate == RESENT ? "Resent-" : "", folder);
1704                 pidstatus (status, verbose ? stdout : stderr, NULL);
1705             } else {
1706                 if (verbose)
1707                     printf ("folder ok\n");
1708             }
1709     }
1710
1711     fflush (stdout);
1712 }
1713
1714 /*
1715  * TERMINATION
1716  */
1717
1718 static void
1719 die (char *what, char *fmt, ...)
1720 {
1721     va_list ap;
1722
1723     unlink (tmpfil);
1724     if (msgflags & MINV)
1725         unlink (bccfil);
1726
1727     if (!whomsw || checksw)
1728         sm_end (NOTOK);
1729
1730     va_start(ap, fmt);
1731     advertise (what, NULL, fmt, ap);
1732     va_end(ap);
1733     done (1);
1734 }