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