Changed remaining uses of MAXPATHLEN to PATH_MAX.
[mmh] / uip / whatnowsbr.c
1
2 /*
3  * whatnowsbr.c -- the WhatNow shell
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  *  Several options have been added to ease the inclusion of attachments
10  *  using the header field name mechanism added to anno and send.  The
11  *  -attach option is used to specify the header field name for attachments.
12  *
13  *  Several commands have been added at the whatnow prompt:
14  *
15  *      cd [ directory ]        This option works just like the shell's
16  *                              cd command and lets the user change the
17  *                              directory from which attachments are
18  *                              taken so that long path names are not
19  *                              needed with every file.
20  *
21  *      ls [ ls-options ]       This option works just like the normal
22  *                              ls command and exists to allow the user
23  *                              to verify file names in the directory.
24  *
25  *      pwd                     This option works just like the normal
26  *                              pwd command and exists to allow the user
27  *                              to verify the directory.
28  *
29  *      attach files            This option attaches the named files to
30  *                              the draft.
31  *
32  *      alist [-ln]             This option lists the attachments on the
33  *                              draft.  -l gets long listings, -n gets
34  *                              numbered listings.
35  *
36  *      detach files            This option removes attachments from the
37  *      detach -n numbers       draft.  This can be done by file name or
38  *                              by attachment number.
39  */
40
41 #include <h/mh.h>
42 #include <fcntl.h>
43 #include <signal.h>
44 #include <h/mime.h>
45 #include <h/utils.h>
46
47 static struct swit whatnowswitches[] = {
48 #define DFOLDSW                 0
49     { "draftfolder +folder", 0 },
50 #define DMSGSW                  1
51     { "draftmessage msg", 0 },
52 #define NDFLDSW                 2
53     { "nodraftfolder", 0 },
54 #define EDITRSW                 3
55     { "editor editor", 0 },
56 #define NEDITSW                 4
57     { "noedit", 0 },
58 #define PRMPTSW                 5
59     { "prompt string", 4 },
60 #define VERSIONSW               6
61     { "version", 0 },
62 #define HELPSW                  7
63     { "help", 0 },
64 #define ATTACHSW                8
65     { "attach header-field-name", 0 },
66 #define NOATTACHSW              9
67     { "noattach", 0 },
68     { NULL, 0 }
69 };
70
71 /*
72  * Options at the "whatnow" prompt
73  */
74 static struct swit aleqs[] = {
75 #define EDITSW                         0
76     { "edit [<editor> <switches>]", 0 },
77 #define REFILEOPT                      1
78     { "refile [<switches>] +folder", 0 },
79 #define BUILDMIMESW                    2
80     { "mime [<switches>]", 0 },
81 #define DISPSW                         3
82     { "display [<switches>]", 0 },
83 #define LISTSW                         4
84     { "list [<switches>]", 0 },
85 #define SENDSW                         5
86     { "send [<switches>]", 0 },
87 #define PUSHSW                         6
88     { "push [<switches>]", 0 },
89 #define WHOMSW                         7
90     { "whom [<switches>]", 0 },
91 #define QUITSW                         8
92     { "quit [-delete]", 0 },
93 #define DELETESW                       9
94     { "delete", 0 },
95 #define CDCMDSW                       10
96     { "cd [directory]", 0 },
97 #define PWDCMDSW                      11
98     { "pwd", 0 },
99 #define LSCMDSW                       12
100     { "ls", 0 },
101 #define ATTACHCMDSW                   13
102     { "attach", 0 },
103 #define DETACHCMDSW                   14
104     { "detach [-n]", 2 },
105 #define ALISTCMDSW                    15
106     { "alist [-ln] ", 2 },
107     { NULL, 0 }
108 };
109
110 static char *myprompt = "\nWhat now? ";
111
112 /*
113  * static prototypes
114  */
115 static int editfile (char **, char **, char *, int, struct msgs *,
116         char *, char *, int, int);
117 static int sendfile (char **, char *, int);
118 static void sendit (char *, char **, char *, int);
119 static int buildfile (char **, char *);
120 static int check_draft (char *);
121 static int whomfile (char **, char *);
122 static int removefile (char *);
123 static void writelscmd(char *, int, char **);
124 static void writesomecmd(char *buf, int bufsz, char *cmd, char *trailcmd, char **argp);
125 static FILE* popen_in_dir(const char *dir, const char *cmd, const char *type);
126 static int system_in_dir(const char *dir, const char *cmd);
127
128
129 #ifdef HAVE_LSTAT
130 static int copyf (char *, char *);
131 #endif
132
133
134 int
135 WhatNow (int argc, char **argv)
136 {
137     int isdf = 0, nedit = 0, use = 0, atfile = 1;
138     char *cp, *dfolder = NULL, *dmsg = NULL;
139     char *ed = NULL, *drft = NULL, *msgnam = NULL;
140     char buf[BUFSIZ], prompt[BUFSIZ];
141     char **argp, **arguments;
142     struct stat st;
143     char        *attach = NMH_ATTACH_HEADER;/* attachment header field name */
144     char        cwd[PATH_MAX + 1];      /* current working directory */
145     char        file[PATH_MAX + 1];     /* file name buffer */
146     char        shell[PATH_MAX + 1];    /* shell response buffer */
147     FILE        *f;                     /* read pointer for bgnd proc */
148     char        *l;                     /* set on -l to alist  command */
149     int         n;                      /* set on -n to alist command */
150
151     invo_name = r1bindex (argv[0], '/');
152
153     /* read user profile/context */
154     context_read();
155
156     arguments = getarguments (invo_name, argc, argv, 1);
157     argp = arguments;
158
159     /*
160      *  Get the initial current working directory.
161      */
162
163     if (getcwd(cwd, sizeof (cwd)) == (char *)0) {
164         adios("getcwd", "could not get working directory");
165     }
166
167     while ((cp = *argp++)) {
168         if (*cp == '-') {
169             switch (smatch (++cp, whatnowswitches)) {
170             case AMBIGSW:
171                 ambigsw (cp, whatnowswitches);
172                 done (1);
173             case UNKWNSW:
174                 adios (NULL, "-%s unknown", cp);
175
176             case HELPSW:
177                 snprintf (buf, sizeof(buf), "%s [switches] [file]", invo_name);
178                 print_help (buf, whatnowswitches, 1);
179                 done (0);
180             case VERSIONSW:
181                 print_version(invo_name);
182                 done (0);
183
184             case DFOLDSW:
185                 if (dfolder)
186                     adios (NULL, "only one draft folder at a time!");
187                 if (!(cp = *argp++) || *cp == '-')
188                     adios (NULL, "missing argument to %s", argp[-2]);
189                 dfolder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
190                                 *cp != '@' ? TFOLDER : TSUBCWF);
191                 continue;
192             case DMSGSW:
193                 if (dmsg)
194                     adios (NULL, "only one draft message at a time!");
195                 if (!(dmsg = *argp++) || *dmsg == '-')
196                     adios (NULL, "missing argument to %s", argp[-2]);
197                 continue;
198             case NDFLDSW:
199                 dfolder = NULL;
200                 isdf = NOTOK;
201                 continue;
202
203             case EDITRSW:
204                 if (!(ed = *argp++) || *ed == '-')
205                     adios (NULL, "missing argument to %s", argp[-2]);
206                 nedit = 0;
207                 continue;
208             case NEDITSW:
209                 nedit++;
210                 continue;
211
212             case PRMPTSW:
213                 if (!(myprompt = *argp++) || *myprompt == '-')
214                     adios (NULL, "missing argument to %s", argp[-2]);
215                 continue;
216
217             case ATTACHSW:
218                 if (!(attach = *argp++) || *attach == '-')
219                     adios (NULL, "missing argument to %s", argp[-2]);
220                 continue;
221
222             case NOATTACHSW:
223                 attach = NULL;
224                 continue;
225             }
226         }
227         if (drft)
228             adios (NULL, "only one draft at a time!");
229         else
230             drft = cp;
231     }
232
233     if ((drft == NULL && (drft = getenv ("mhdraft")) == NULL) || *drft == 0)
234         drft = getcpy (m_draft (dfolder, dmsg, 1, &isdf));
235
236     msgnam = (cp = getenv ("mhaltmsg")) && *cp ? getcpy (cp) : NULL;
237
238     if ((cp = getenv ("mhatfile")) && *cp)
239         atfile = atoi(cp);
240
241     if ((cp = getenv ("mhuse")) && *cp)
242         use = atoi (cp);
243
244     if (ed == NULL && ((ed = getenv ("mheditor")) == NULL || *ed == 0)) {
245         ed = NULL;
246         nedit++;
247     }
248
249     /* start editing the draft, unless -noedit was given */
250     if (!nedit && editfile (&ed, NULL, drft, use, NULL, msgnam,
251                             NULL, 1, atfile) < 0)
252         done (1);
253
254     snprintf (prompt, sizeof(prompt), myprompt, invo_name);
255     for (;;) {
256 #ifdef READLINE_SUPPORT
257         if (!(argp = getans_via_readline (prompt, aleqs))) {
258 #else /* ! READLINE_SUPPORT */
259         if (!(argp = getans (prompt, aleqs))) {
260 #endif /* READLINE_SUPPORT */
261             unlink (LINK);
262             done (1);
263         }
264         switch (smatch (*argp, aleqs)) {
265         case DISPSW:
266             /* display the message being replied to, or distributed */
267             if (msgnam)
268                 showfile (++argp, msgnam);
269             else
270                 advise (NULL, "no alternate message to display");
271             break;
272
273         case BUILDMIMESW:
274             /* Translate MIME composition file */
275             buildfile (++argp, drft);
276             break;
277
278         case EDITSW:
279             /* Call an editor on the draft file */
280             if (*++argp)
281                 ed = *argp++;
282             if (editfile (&ed, argp, drft, NOUSE, NULL, msgnam,
283                           NULL, 1, atfile) == NOTOK)
284                 done (1);
285             break;
286
287         case LISTSW:
288             /* display the draft file */
289             showfile (++argp, drft);
290             break;
291
292         case WHOMSW:
293             /* Check to whom the draft would be sent */
294             whomfile (++argp, drft);
295             break;
296
297         case QUITSW:
298             /* Quit, and possibly delete the draft */
299             if (*++argp && (*argp[0] == 'd' ||
300                 ((*argp)[0] == '-' && (*argp)[1] == 'd'))) {
301                 removefile (drft);
302             } else {
303                 if (stat (drft, &st) != NOTOK)
304                     advise (NULL, "draft left on %s", drft);
305             }
306             done (1);
307
308         case DELETESW:
309             /* Delete draft and exit */
310             removefile (drft);
311             done (1);
312
313         case PUSHSW:
314             /* Send draft in background */
315             if (sendfile (++argp, drft, 1))
316                 done (1);
317             break;
318
319         case SENDSW:
320             /* Send draft */
321             sendfile (++argp, drft, 0);
322             break;
323
324         case REFILEOPT:
325             /* Refile the draft */
326             if (refile (++argp, drft) == 0)
327                 done (0);
328             break;
329
330         case CDCMDSW:
331             /* Change the working directory for attachments
332              *
333              *  Run the directory through the user's shell so that
334              *  we can take advantage of any syntax that the user
335              *  is accustomed to.  Read back the absolute path.
336              */
337
338             if (*(argp+1) == (char *)0) {
339                 (void)sprintf(buf, "$SHELL -c \"cd;pwd\"");
340             }
341             else {
342                 writesomecmd(buf, BUFSIZ, "cd", "pwd", argp);
343             }
344             if ((f = popen_in_dir(cwd, buf, "r")) != (FILE *)0) {
345                 fgets(cwd, sizeof (cwd), f);
346
347                 if (strchr(cwd, '\n') != (char *)0)
348                         *strchr(cwd, '\n') = '\0';
349
350                 pclose(f);
351             }
352             else {
353                 advise("popen", "could not get directory");
354             }
355
356             break;
357
358         case PWDCMDSW:
359             /* Print the working directory for attachments */
360             printf("%s\n", cwd);
361             break;
362
363         case LSCMDSW:
364             /* List files in the current attachment working directory
365              *
366              *  Use the user's shell so that we can take advantage of any
367              *  syntax that the user is accustomed to.
368              */
369             writelscmd(buf, sizeof(buf), argp);
370             (void)system_in_dir(cwd, buf);
371             break;
372
373         case ALISTCMDSW:
374             /*
375              *  List attachments on current draft.  Options are:
376              *
377              *   -l     long listing (full path names)
378              *   -n     numbers listing
379              */
380
381             if (attach == (char *)0) {
382                 advise((char *)0, "can't list because no header field name was given.");
383                 break;
384             }
385
386             l = (char *)0;
387             n = 0;
388
389             while (*++argp != (char *)0) {
390                 if (strcmp(*argp, "-l") == 0)
391                     l = "/";
392
393                 else if (strcmp(*argp, "-n") == 0)
394                     n = 1;
395
396                 else if (strcmp(*argp, "-ln") == 0 || strcmp(*argp, "-nl") == 0) {
397                     l = "/";
398                     n = 1;
399                 }
400
401                 else {
402                     n = -1;
403                     break;
404                 }
405             }
406
407             if (n == -1)
408                 advise((char *)0, "usage is alist [-ln].");
409
410             else
411                 annolist(drft, attach, l, n);
412
413             break;
414
415         case ATTACHCMDSW:
416             /*
417              *  Attach files to current draft.
418              */
419
420             if (attach == (char *)0) {
421                 advise((char *)0, "can't attach because no header field name was given.");
422                 break;
423             }
424
425             if (*(argp+1) == (char *)0) {
426                 advise((char *)0, "attach command requires file argument(s).");
427                 break;
428             }
429
430             /*
431              *  Build a command line that causes the user's shell to list the file name
432              *  arguments.  This handles and wildcard expansion, tilde expansion, etc.
433              */
434             writelscmd(buf, sizeof(buf), argp);
435
436             /*
437              *  Read back the response from the shell, which contains a number of lines
438              *  with one file name per line.  Remove off the newline.  Determine whether
439              *  we have an absolute or relative path name.  Prepend the current working
440              *  directory to relative path names.  Add the attachment annotation to the
441              *  draft.
442              */
443
444             if ((f = popen_in_dir(cwd, buf, "r")) != (FILE *)0) {
445                 while (fgets(shell, sizeof (shell), f) != (char *)0) {
446                     *(strchr(shell, '\n')) = '\0';
447
448                     if (*shell == '/')
449                         (void)annotate(drft, attach, shell, 1, 0, -2, 1);
450                     else {
451                         (void)sprintf(file, "%s/%s", cwd, shell);
452                         (void)annotate(drft, attach, file, 1, 0, -2, 1);
453                     }
454                 }
455
456                 pclose(f);
457             }
458             else {
459                 advise("popen", "could not get file from shell");
460             }
461
462             break;
463
464         case DETACHCMDSW:
465             /*
466              *  Detach files from current draft.
467              */
468
469             if (attach == (char *)0) {
470                 advise((char *)0, "can't detach because no header field name was given.");
471                 break;
472             }
473
474             /*
475              *  Scan the arguments for a -n.  Mixed file names and numbers aren't allowed,
476              *  so this catches a -n anywhere in the argument list.
477              */
478
479             for (n = 0, arguments = argp + 1; *arguments != (char *)0; arguments++) {
480                 if (strcmp(*arguments, "-n") == 0) {
481                         n = 1;
482                         break;
483                 }
484             }
485
486             /*
487              *  A -n was found so interpret the arguments as attachment numbers.
488              *  Decrement any remaining argument number that is greater than the one
489              *  just processed after processing each one so that the numbering stays
490              *  correct.
491              */
492
493             if (n == 1) {
494                 for (arguments = argp + 1; *arguments != (char *)0; arguments++) {
495                     if (strcmp(*arguments, "-n") == 0)
496                         continue;
497
498                     if (**arguments != '\0') {
499                         n = atoi(*arguments);
500                         (void)annotate(drft, attach, (char *)0, 1, 0, n, 1);
501
502                         for (argp = arguments + 1; *argp != (char *)0; argp++) {
503                             if (atoi(*argp) > n) {
504                                 if (atoi(*argp) == 1)
505                                     *argp = "";
506                                 else
507                                     (void)sprintf(*argp, "%d", atoi(*argp) - 1);
508                             }
509                         }
510                     }
511                 }
512             }
513
514             /*
515              *  The arguments are interpreted as file names.  Run them through the
516              *  user's shell for wildcard expansion and other goodies.  Do this from
517              *  the current working directory if the argument is not an absolute path
518              *  name (does not begin with a /).
519              *
520              * We feed all the file names to the shell at once, otherwise you can't
521              * provide a file name with a space in it.
522              */
523             writelscmd(buf, sizeof(buf), argp);
524             if ((f = popen_in_dir(cwd, buf, "r")) != (FILE *)0) {
525                 while (fgets(shell, sizeof (shell), f) != (char *)0) {
526                     *(strchr(shell, '\n')) = '\0';
527                     (void)annotate(drft, attach, shell, 1, 0, 0, 1);
528                 }
529                 pclose(f);
530             } else {
531                 advise("popen", "could not get file from shell");
532             }
533
534             break;
535
536         default:
537             /* Unknown command */
538             advise (NULL, "say what?");
539             break;
540         }
541     }
542     /*NOTREACHED*/
543 }
544
545
546
547 /* Build a command line of the form $SHELL -c "cd 'cwd'; cmd argp ... ; trailcmd". */
548 static void
549 writesomecmd(char *buf, int bufsz, char *cmd, char *trailcmd, char **argp)
550 {
551     char *cp;
552     /* Note that we do not quote -- the argp from the user
553      * is assumed to be quoted as they desire. (We can't treat
554      * it as pure literal as that would prevent them using ~,
555      * wildcards, etc.) The buffer produced by this function
556      * should be given to popen_in_dir() or system_in_dir() so
557      * that the current working directory is set correctly.
558      */
559     int ln = snprintf(buf, bufsz, "$SHELL -c \"%s", cmd);
560     /* NB that some snprintf() return -1 on overflow rather than the
561      * new C99 mandated 'number of chars that would have been written'
562      */
563     /* length checks here and inside the loop allow for the
564      * trailing ';', trailcmd, '"' and NUL
565      */
566     int trailln = strlen(trailcmd) + 3;
567     if (ln < 0 || ln + trailln > bufsz)
568         adios((char *)0, "arguments too long");
569     
570     cp = buf + ln;
571     
572     while (*++argp != (char *)0) {
573         ln = strlen(*argp);
574         /* +1 for leading space */
575         if (ln + trailln + 1 > bufsz - (cp-buf))
576             adios((char *)0, "arguments too long");
577         *cp++ = ' ';
578         memcpy(cp, *argp, ln+1);
579         cp += ln;
580     }
581     if (*trailcmd) {
582         *cp++ = ';';
583         strcpy(cp, trailcmd);
584         cp += trailln - 3;
585     }
586     *cp++ = '"';
587     *cp = 0;
588 }
589
590 /*
591  * Build a command line that causes the user's shell to list the file name
592  * arguments.  This handles and wildcard expansion, tilde expansion, etc.
593  */
594 static void
595 writelscmd(char *buf, int bufsz, char **argp)
596 {
597     writesomecmd(buf, bufsz, "ls", "", argp);
598 }
599
600 /* Like system(), but run the command in directory dir.
601  * This assumes the program is single-threaded!
602  */
603 static int
604 system_in_dir(const char *dir, const char *cmd)
605 {
606     char olddir[BUFSIZ];
607     int r;
608     if (getcwd(olddir, sizeof(olddir)) == 0)
609         adios("getcwd", "could not get working directory");
610     if (chdir(dir) != 0)
611         adios("chdir", "could not change working directory");
612     r = system(cmd);
613     if (chdir(olddir) != 0)
614         adios("chdir", "could not change working directory");
615     return r;
616 }
617
618 /* ditto for popen() */
619 static FILE*
620 popen_in_dir(const char *dir, const char *cmd, const char *type)
621 {
622     char olddir[BUFSIZ];
623     FILE *f;
624     if (getcwd(olddir, sizeof(olddir)) == 0)
625         adios("getcwd", "could not get working directory");
626     if (chdir(dir) != 0)
627         adios("chdir", "could not change working directory");
628     f = popen(cmd, type);
629     if (chdir(olddir) != 0)
630         adios("chdir", "could not change working directory");
631     return f;
632 }
633
634
635 /*
636  * EDIT
637  */
638
639 static int  reedit = 0;         /* have we been here before?     */
640 static char *edsave = NULL;     /* the editor we used previously */
641
642
643 static int
644 editfile (char **ed, char **arg, char *file, int use, struct msgs *mp,
645           char *altmsg, char *cwd, int save_editor, int atfile)
646 {
647     int pid, status, vecp;
648     char altpath[BUFSIZ], linkpath[BUFSIZ];
649     char *cp, *vec[MAXARGS];
650     struct stat st;
651
652 #ifdef HAVE_LSTAT
653     int slinked = 0;
654 #endif /* HAVE_LSTAT */
655
656     /* Was there a previous edit session? */
657     if (reedit) {
658         if (!*ed) {             /* no explicit editor      */
659             *ed = edsave;       /* so use the previous one */
660             if ((cp = r1bindex (*ed, '/')) == NULL)
661                 cp = *ed;
662
663             /* unless we've specified it via "editor-next" */
664             cp = concat (cp, "-next", NULL);
665             if ((cp = context_find (cp)) != NULL)
666                 *ed = cp;
667         }
668     } else {
669         /* set initial editor */
670         if (*ed == NULL && (*ed = context_find ("editor")) == NULL)
671             *ed = defaulteditor;
672     }
673
674     if (altmsg && atfile) {
675         if (mp == NULL || *altmsg == '/' || cwd == NULL)
676             strncpy (altpath, altmsg, sizeof(altpath));
677         else
678             snprintf (altpath, sizeof(altpath), "%s/%s", mp->foldpath, altmsg);
679         if (cwd == NULL)
680             strncpy (linkpath, LINK, sizeof(linkpath));
681         else
682             snprintf (linkpath, sizeof(linkpath), "%s/%s", cwd, LINK);
683
684         unlink (linkpath);
685 #ifdef HAVE_LSTAT
686         if (link (altpath, linkpath) == NOTOK) {
687             symlink (altpath, linkpath);
688             slinked = 1;
689         } else {
690             slinked = 0;
691         }
692 #else /* not HAVE_LSTAT */
693         link (altpath, linkpath);
694 #endif /* not HAVE_LSTAT */
695     }
696
697     context_save ();    /* save the context file */
698     fflush (stdout);
699
700     switch (pid = vfork()) {
701         case NOTOK:
702             advise ("fork", "unable to");
703             status = NOTOK;
704             break;
705
706         case OK:
707             if (cwd)
708                 chdir (cwd);
709             if (altmsg) {
710                 if (mp)
711                     m_putenv ("mhfolder", mp->foldpath);
712                 m_putenv ("editalt", altpath);
713             }
714
715             vecp = 0;
716             vec[vecp++] = r1bindex (*ed, '/');
717             if (arg)
718                 while (*arg)
719                     vec[vecp++] = *arg++;
720             vec[vecp++] = file;
721             vec[vecp] = NULL;
722
723             execvp (*ed, vec);
724             fprintf (stderr, "unable to exec ");
725             perror (*ed);
726             _exit (-1);
727
728         default:
729             if ((status = pidwait (pid, NOTOK))) {
730                 if (((status & 0xff00) != 0xff00)
731                     && (!reedit || (status & 0x00ff))) {
732                     if (!use && (status & 0xff00) &&
733                             (rename (file, cp = m_backup (file)) != NOTOK)) {
734                         advise (NULL, "problems with edit--draft left in %s", cp);
735                     } else {
736                         advise (NULL, "problems with edit--%s preserved", file);
737                     }
738                 }
739                 status = -2;    /* maybe "reedit ? -2 : -1"? */
740                 break;
741             }
742
743             reedit++;
744 #ifdef HAVE_LSTAT
745             if (altmsg
746                     && mp
747                     && !is_readonly(mp)
748                     && (slinked
749                            ? lstat (linkpath, &st) != NOTOK
750                                 && S_ISREG(st.st_mode)
751                                 && copyf (linkpath, altpath) == NOTOK
752                            : stat (linkpath, &st) != NOTOK
753                                 && st.st_nlink == 1
754                                 && (unlink (altpath) == NOTOK
755                                         || link (linkpath, altpath) == NOTOK)))
756                 advise (linkpath, "unable to update %s from", altmsg);
757 #else /* HAVE_LSTAT */
758             if (altmsg
759                     && mp
760                     && !is_readonly(mp)
761                     && stat (linkpath, &st) != NOTOK
762                     && st.st_nlink == 1
763                     && (unlink (altpath) == NOTOK
764                         || link (linkpath, altpath) == NOTOK))
765                 advise (linkpath, "unable to update %s from", altmsg);
766 #endif /* HAVE_LSTAT */
767     }
768
769     /* normally, we remember which editor we used */
770     if (save_editor)
771         edsave = getcpy (*ed);
772
773     *ed = NULL;
774     if (altmsg && atfile)
775         unlink (linkpath);
776
777     return status;
778 }
779
780
781 #ifdef HAVE_LSTAT
782 static int
783 copyf (char *ifile, char *ofile)
784 {
785     int i, in, out;
786     char buffer[BUFSIZ];
787
788     if ((in = open (ifile, O_RDONLY)) == NOTOK)
789         return NOTOK;
790     if ((out = open (ofile, O_WRONLY | O_TRUNC)) == NOTOK) {
791         admonish (ofile, "unable to open and truncate");
792         close (in);
793         return NOTOK;
794     }
795
796     while ((i = read (in, buffer, sizeof(buffer))) > OK)
797         if (write (out, buffer, i) != i) {
798             advise (ofile, "may have damaged");
799             i = NOTOK;
800             break;
801         }
802
803     close (in);
804     close (out);
805     return i;
806 }
807 #endif /* HAVE_LSTAT */
808
809
810 /*
811  * SEND
812  */
813
814 static int
815 sendfile (char **arg, char *file, int pushsw)
816 {
817     pid_t child_id;
818     int i, vecp;
819     char *cp, *sp, *vec[MAXARGS];
820
821     /* Translate MIME composition file, if necessary */
822     if ((cp = context_find ("automimeproc"))
823             && (!strcmp (cp, "1"))
824             && check_draft (file)
825             && (buildfile (NULL, file) == NOTOK))
826         return 0;
827
828     /* For backwards compatibility */
829     if ((cp = context_find ("automhnproc"))
830             && check_draft (file)
831             && (i = editfile (&cp, NULL, file, NOUSE, NULL, NULL, NULL, 0, 0)))
832         return 0;
833
834     /*
835      * If the sendproc is the nmh command `send', then we call
836      * those routines directly rather than exec'ing the command.
837      */
838     if (strcmp (sp = r1bindex (sendproc, '/'), "send") == 0) {
839         cp = invo_name;
840         sendit (invo_name = sp, arg, file, pushsw);
841         invo_name = cp;
842         return 1;
843     }
844
845     context_save ();    /* save the context file */
846     fflush (stdout);
847
848     for (i = 0; (child_id = vfork()) == NOTOK && i < 5; i++)
849         sleep (5);
850     switch (child_id) {
851         case NOTOK:
852             advise (NULL, "unable to fork, so sending directly...");
853         case OK:
854             vecp = 0;
855             vec[vecp++] = invo_name;
856             if (pushsw)
857                 vec[vecp++] = "-push";
858             if (arg)
859                 while (*arg)
860                     vec[vecp++] = *arg++;
861             vec[vecp++] = file;
862             vec[vecp] = NULL;
863
864             execvp (sendproc, vec);
865             fprintf (stderr, "unable to exec ");
866             perror (sendproc);
867             _exit (-1);
868
869         default:
870             if (pidwait(child_id, OK) == 0)
871                 done (0);
872             return 1;
873     }
874 }
875
876
877 /*
878  * Translate MIME composition file (call buildmimeproc)
879  */
880
881 static int
882 buildfile (char **argp, char *file)
883 {
884     int i;
885     char **args, *ed;
886
887     ed = buildmimeproc;
888
889     /* allocate space for arguments */
890     i = 0;
891     if (argp) {
892         while (argp[i])
893             i++;
894     }
895     args = (char **) mh_xmalloc((i + 2) * sizeof(char *));
896
897     /*
898      * For backward compatibility, we need to add -build
899      * if we are using mhn as buildmimeproc
900      */
901     i = 0;
902     if (strcmp (r1bindex (ed, '/'), "mhn") == 0)
903         args[i++] = "-build";
904
905     /* copy any other arguments */
906     while (argp && *argp)
907         args[i++] = *argp++;
908     args[i] = NULL;
909
910     i = editfile (&ed, args, file, NOUSE, NULL, NULL, NULL, 0, 0);
911     free (args);
912
913     return (i ? NOTOK : OK);
914 }
915
916
917 /*
918  *  Check if draft is a mhbuild composition file
919  */
920
921 static int
922 check_draft (char *msgnam)
923 {
924     int state;
925     char buf[BUFSIZ], name[NAMESZ];
926     FILE *fp;
927
928     if ((fp = fopen (msgnam, "r")) == NULL)
929         return 0;
930     for (state = FLD;;)
931         switch (state = m_getfld (state, name, buf, sizeof(buf), fp)) {
932             case FLD:
933             case FLDPLUS:
934             case FLDEOF:
935                 /*
936                  * If draft already contains any of the
937                  * Content-XXX fields, then assume it already
938                  * been converted.
939                  */
940                 if (uprf (name, XXX_FIELD_PRF)) {
941                     fclose (fp);
942                     return 0;
943                 }
944                 while (state == FLDPLUS)
945                     state = m_getfld (state, name, buf, sizeof(buf), fp);
946                 break;
947
948             case BODY:
949                 do {
950                     char *bp;
951
952                     for (bp = buf; *bp; bp++)
953                         if (*bp != ' ' && *bp != '\t' && *bp != '\n') {
954                             fclose (fp);
955                             return 1;
956                         }
957
958                     state = m_getfld (state, name, buf, sizeof(buf), fp);
959                 } while (state == BODY);
960                 /* and fall... */
961
962             default:
963                 fclose (fp);
964                 return 0;
965         }
966 }
967
968
969 #ifndef CYRUS_SASL
970 # define SASLminc(a) (a)
971 #else /* CYRUS_SASL */
972 # define SASLminc(a)  0
973 #endif /* CYRUS_SASL */
974
975 #ifndef TLS_SUPPORT
976 # define TLSminc(a)  (a)
977 #else /* TLS_SUPPORT */
978 # define TLSminc(a)   0
979 #endif /* TLS_SUPPORT */
980
981 static struct swit  sendswitches[] = {
982 #define ALIASW            0
983     { "alias aliasfile", 0 },
984 #define DEBUGSW           1
985     { "debug", -5 },
986 #define FILTSW            2
987     { "filter filterfile", 0 },
988 #define NFILTSW           3
989     { "nofilter", 0 },
990 #define FRMTSW            4
991     { "format", 0 },
992 #define NFRMTSW           5
993     { "noformat", 0 },
994 #define FORWSW            6
995     { "forward", 0 },
996 #define NFORWSW           7
997     { "noforward", 0 },
998 #define MIMESW            8
999     { "mime", 0 },
1000 #define NMIMESW           9
1001     { "nomime", 0 },
1002 #define MSGDSW           10
1003     { "msgid", 0 },
1004 #define NMSGDSW          11
1005     { "nomsgid", 0 },
1006 #define SPSHSW           12
1007     { "push", 0 },
1008 #define NSPSHSW          13
1009     { "nopush", 0 },
1010 #define SPLITSW          14
1011     { "split seconds", 0 },
1012 #define UNIQSW           15
1013     { "unique", -6 },
1014 #define NUNIQSW          16
1015     { "nounique", -8 },
1016 #define VERBSW           17
1017     { "verbose", 0 },
1018 #define NVERBSW          18
1019     { "noverbose", 0 },
1020 #define WATCSW           19
1021     { "watch", 0 },
1022 #define NWATCSW          20
1023     { "nowatch", 0 },
1024 #define WIDTHSW          21
1025     { "width columns", 0 },
1026 #define SVERSIONSW       22
1027     { "version", 0 },
1028 #define SHELPSW          23
1029     { "help", 0 },
1030 #define BITSTUFFSW       24
1031     { "dashstuffing", -12 },
1032 #define NBITSTUFFSW      25
1033     { "nodashstuffing", -14 },
1034 #define MAILSW           26
1035     { "mail", -4 },
1036 #define SAMLSW           27
1037     { "saml", -4 },
1038 #define SSNDSW           28
1039     { "send", -4 },
1040 #define SOMLSW           29
1041     { "soml", -4 },
1042 #define CLIESW           30
1043     { "client host", -6 },
1044 #define SERVSW           31
1045     { "server host", 6 },
1046 #define SNOOPSW          32
1047     { "snoop", -5 },
1048 #define SDRFSW           33
1049     { "draftfolder +folder", -6 },
1050 #define SDRMSW           34
1051     { "draftmessage msg", -6 },
1052 #define SNDRFSW          35
1053     { "nodraftfolder", -3 },
1054 #define SASLSW           36
1055     { "sasl", SASLminc(-4) },
1056 #define NOSASLSW         37
1057     { "nosasl", SASLminc(-6) },
1058 #define SASLMXSSFSW      38
1059     { "saslmaxssf", SASLminc(-10) },
1060 #define SASLMECHSW       39
1061     { "saslmech", SASLminc(-5) },
1062 #define USERSW           40
1063     { "user", SASLminc(-4) },
1064 #define SNDATTACHSW       41
1065     { "attach file", 6 },
1066 #define SNDNOATTACHSW     42
1067     { "noattach", 0 },
1068 #define SNDATTACHFORMAT   43
1069     { "attachformat", 7 },
1070 #define PORTSW            44
1071     { "port server-port-name/number", 4 },
1072 #define TLSSW             45
1073     { "tls", TLSminc(-3) },
1074 #define NTLSSW            46
1075     { "notls", TLSminc(-5) },
1076     { NULL, 0 }
1077 };
1078
1079
1080 extern int debugsw;             /* from sendsbr.c */
1081 extern int forwsw;
1082 extern int inplace;
1083 extern int pushsw;
1084 extern int splitsw;
1085 extern int unique;
1086 extern int verbsw;
1087
1088 extern char *altmsg;            /*  .. */
1089 extern char *annotext;
1090 extern char *distfile;
1091
1092
1093 static void
1094 sendit (char *sp, char **arg, char *file, int pushed)
1095 {
1096     int vecp, n = 1;
1097     char *cp, buf[BUFSIZ], **argp;
1098     char **arguments, *vec[MAXARGS];
1099     struct stat st;
1100     char        *attach = NMH_ATTACH_HEADER;/* attachment header field name */
1101     int         attachformat = 1;       /* mhbuild format specifier for
1102                                            attachments */
1103
1104 #ifndef lint
1105     int distsw = 0;
1106 #endif
1107
1108     /*
1109      * Make sure these are defined.  In particular, we need
1110      * vec[1] to be NULL, in case "arg" is NULL below.  It
1111      * doesn't matter what is the value of vec[0], but we
1112      * set it to NULL, to help catch "off-by-one" errors.
1113      */
1114     vec[0] = NULL;
1115     vec[1] = NULL;
1116
1117     /*
1118      * Temporarily copy arg to vec, since the brkstring() call in
1119      * getarguments() will wipe it out before it is merged in.
1120      * Also, we skip the first element of vec, since getarguments()
1121      * skips it.  Then we count the number of arguments
1122      * copied.  The value of "n" will be one greater than
1123      * this in order to simulate the standard argc/argv.
1124      */
1125     if (arg) {
1126         char **bp;
1127
1128         copyip (arg, vec+1, MAXARGS-1);
1129         bp = vec+1;
1130         while (*bp++)
1131             n++;
1132     }
1133
1134     /*
1135      * Merge any arguments from command line (now in vec)
1136      * and arguments from profile.
1137      */
1138     arguments = getarguments (sp, n, vec, 1);
1139     argp = arguments;
1140
1141     debugsw = 0;
1142     forwsw = 1;
1143     inplace = 1;
1144     unique = 0;
1145
1146     altmsg = NULL;
1147     annotext = NULL;
1148     distfile = NULL;
1149
1150     vecp = 1;                   /* we'll get the zero'th element later */
1151     vec[vecp++] = "-library";
1152     vec[vecp++] = getcpy (m_maildir (""));
1153
1154     if ((cp = context_find ("fileproc"))) {
1155       vec[vecp++] = "-fileproc";
1156       vec[vecp++] = cp;
1157     }
1158
1159     if ((cp = context_find ("mhlproc"))) {
1160       vec[vecp++] = "-mhlproc";
1161       vec[vecp++] = cp;
1162     }
1163
1164     while ((cp = *argp++)) {
1165         if (*cp == '-') {
1166             switch (smatch (++cp, sendswitches)) {
1167                 case AMBIGSW:
1168                     ambigsw (cp, sendswitches);
1169                     return;
1170                 case UNKWNSW:
1171                     advise (NULL, "-%s unknown\n", cp);
1172                     return;
1173
1174                 case SHELPSW:
1175                     snprintf (buf, sizeof(buf), "%s [switches]", sp);
1176                     print_help (buf, sendswitches, 1);
1177                     return;
1178                 case SVERSIONSW:
1179                     print_version (invo_name);
1180                     return;
1181
1182                 case SPSHSW:
1183                     pushed++;
1184                     continue;
1185                 case NSPSHSW:
1186                     pushed = 0;
1187                     continue;
1188
1189                 case SPLITSW:
1190                     if (!(cp = *argp++) || sscanf (cp, "%d", &splitsw) != 1) {
1191                         advise (NULL, "missing argument to %s", argp[-2]);
1192                         return;
1193                     }
1194                     continue;
1195
1196                 case UNIQSW:
1197                     unique++;
1198                     continue;
1199                 case NUNIQSW:
1200                     unique = 0;
1201                     continue;
1202                 case FORWSW:
1203                     forwsw++;
1204                     continue;
1205                 case NFORWSW:
1206                     forwsw = 0;
1207                     continue;
1208
1209                 case VERBSW:
1210                     verbsw++;
1211                     vec[vecp++] = --cp;
1212                     continue;
1213                 case NVERBSW:
1214                     verbsw = 0;
1215                     vec[vecp++] = --cp;
1216                     continue;
1217
1218                 case DEBUGSW:
1219                     debugsw++;  /* fall */
1220                 case NFILTSW:
1221                 case FRMTSW:
1222                 case NFRMTSW:
1223                 case BITSTUFFSW:
1224                 case NBITSTUFFSW:
1225                 case MIMESW:
1226                 case NMIMESW:
1227                 case MSGDSW:
1228                 case NMSGDSW:
1229                 case WATCSW:
1230                 case NWATCSW:
1231                 case MAILSW:
1232                 case SAMLSW:
1233                 case SSNDSW:
1234                 case SOMLSW:
1235                 case SNOOPSW:
1236                 case SASLSW:
1237                 case NOSASLSW:
1238                 case TLSSW:
1239                 case NTLSSW:
1240                     vec[vecp++] = --cp;
1241                     continue;
1242
1243                 case ALIASW:
1244                 case FILTSW:
1245                 case WIDTHSW:
1246                 case CLIESW:
1247                 case SERVSW:
1248                 case SASLMXSSFSW:
1249                 case SASLMECHSW:
1250                 case USERSW:
1251                 case PORTSW:
1252                     vec[vecp++] = --cp;
1253                     if (!(cp = *argp++) || *cp == '-') {
1254                         advise (NULL, "missing argument to %s", argp[-2]);
1255                         return;
1256                     }
1257                     vec[vecp++] = cp;
1258                     continue;
1259
1260                 case SDRFSW:
1261                 case SDRMSW:
1262                     if (!(cp = *argp++) || *cp == '-') {
1263                         advise (NULL, "missing argument to %s", argp[-2]);
1264                         return;
1265                     }
1266                 case SNDRFSW:
1267                     continue;
1268
1269                 case SNDATTACHSW:
1270                     if (!(attach = *argp++) || *attach == '-') {
1271                         advise (NULL, "missing argument to %s", argp[-2]);
1272                         return;
1273                     }
1274                     continue;
1275                 case SNDNOATTACHSW:
1276                     attach = NULL;
1277                     continue;
1278
1279                 case SNDATTACHFORMAT:
1280                     if (! *argp || **argp == '-')
1281                         adios (NULL, "missing argument to %s", argp[-1]);
1282                     else {
1283                         attachformat = atoi (*argp);
1284                         if (attachformat < 0 ||
1285                             attachformat > ATTACHFORMATS - 1) {
1286                             advise (NULL, "unsupported attachformat %d",
1287                                     attachformat);
1288                             continue;
1289                         }
1290                     }
1291                     ++argp;
1292                     continue;
1293             }
1294         }
1295         advise (NULL, "usage: %s [switches]", sp);
1296         return;
1297     }
1298
1299     /* allow Aliasfile: profile entry */
1300     if ((cp = context_find ("Aliasfile"))) {
1301         char **ap, *dp;
1302
1303         dp = getcpy (cp);
1304         for (ap = brkstring (dp, " ", "\n"); ap && *ap; ap++) {
1305             vec[vecp++] = "-alias";
1306             vec[vecp++] = *ap;
1307         }
1308     }
1309
1310     if ((cp = getenv ("SIGNATURE")) == NULL || *cp == 0)
1311         if ((cp = context_find ("signature")) && *cp)
1312             m_putenv ("SIGNATURE", cp);
1313
1314     if ((annotext = getenv ("mhannotate")) == NULL || *annotext == 0)
1315         annotext = NULL;
1316     if ((altmsg = getenv ("mhaltmsg")) == NULL || *altmsg == 0)
1317         altmsg = NULL;
1318     if (annotext && ((cp = getenv ("mhinplace")) != NULL && *cp != 0))
1319         inplace = atoi (cp);
1320
1321     if ((cp = getenv ("mhdist"))
1322             && *cp
1323 #ifndef lint
1324             && (distsw = atoi (cp))
1325 #endif /* not lint */
1326             && altmsg) {
1327         vec[vecp++] = "-dist";
1328         distfile = getcpy (m_mktemp2(altmsg, invo_name, NULL, NULL));
1329         unlink(distfile);
1330         if (link (altmsg, distfile) == NOTOK)
1331             adios (distfile, "unable to link %s to", altmsg);
1332     } else {
1333         distfile = NULL;
1334     }
1335
1336     if (altmsg == NULL || stat (altmsg, &st) == NOTOK) {
1337         st.st_mtime = 0;
1338         st.st_dev = 0;
1339         st.st_ino = 0;
1340     }
1341     if ((pushsw = pushed))
1342         push ();
1343
1344     vec[0] = r1bindex (postproc, '/');
1345     closefds (3);
1346
1347     if (sendsbr (vec, vecp, file, &st, 1, attach, attachformat) == OK)
1348         done (0);
1349 }
1350
1351 /*
1352  * WHOM
1353  */
1354
1355 static int
1356 whomfile (char **arg, char *file)
1357 {
1358     pid_t pid;
1359     int vecp;
1360     char *vec[MAXARGS];
1361
1362     context_save ();    /* save the context file */
1363     fflush (stdout);
1364
1365     switch (pid = vfork()) {
1366         case NOTOK:
1367             advise ("fork", "unable to");
1368             return 1;
1369
1370         case OK:
1371             vecp = 0;
1372             vec[vecp++] = r1bindex (whomproc, '/');
1373             vec[vecp++] = file;
1374             if (arg)
1375                 while (*arg)
1376                     vec[vecp++] = *arg++;
1377             vec[vecp] = NULL;
1378
1379             execvp (whomproc, vec);
1380             fprintf (stderr, "unable to exec ");
1381             perror (whomproc);
1382             _exit (-1);         /* NOTREACHED */
1383
1384         default:
1385             return (pidwait (pid, NOTOK) & 0377 ? 1 : 0);
1386     }
1387 }
1388
1389
1390 /*
1391  * Remove the draft file
1392  */
1393
1394 static int
1395 removefile (char *drft)
1396 {
1397     if (unlink (drft) == NOTOK)
1398         adios (drft, "unable to unlink");
1399
1400     return OK;
1401 }