* patch #3968: Move the add() function from its own file (add.c) and
[mmh] / uip / mhstoresbr.c
1
2 /*
3  * mhstoresbr.c -- routines to save/store the contents of MIME messages
4  *
5  * $Id$
6  *
7  * This code is Copyright (c) 2002, by the authors of nmh.  See the
8  * COPYRIGHT file in the root directory of the nmh distribution for
9  * complete copyright information.
10  */
11
12 #include <h/mh.h>
13 #include <fcntl.h>
14 #include <h/signals.h>
15 #include <h/md5.h>
16 #include <errno.h>
17 #include <setjmp.h>
18 #include <signal.h>
19 #include <h/mts.h>
20 #include <h/tws.h>
21 #include <h/mime.h>
22 #include <h/mhparse.h>
23 #include <h/utils.h>
24
25
26 /*
27  * The list of top-level contents to display
28  */
29 extern CT *cts;
30
31 int autosw = 0;
32
33 /*
34  * Cache of current directory.  This must be
35  * set before these routines are called.
36  */
37 char *cwd;
38
39 /*
40  * The directory in which to store the contents.
41  */
42 static char *dir;
43
44 /*
45  * Type for a compare function for qsort.  This keeps
46  * the compiler happy.
47  */
48 typedef int (*qsort_comp) (const void *, const void *);
49
50
51 /* mhmisc.c */
52 int part_ok (CT, int);
53 int type_ok (CT, int);
54 int make_intermediates (char *);
55 void flush_errors (void);
56
57 /* mhshowsbr.c */
58 int show_content_aux (CT, int, int, char *, char *);
59
60 /*
61  * prototypes
62  */
63 void store_all_messages (CT *);
64
65 /*
66  * static prototypes
67  */
68 static void store_single_message (CT);
69 static int store_switch (CT);
70 static int store_generic (CT);
71 static int store_application (CT);
72 static int store_multi (CT);
73 static int store_partial (CT);
74 static int store_external (CT);
75 static int ct_compar (CT *, CT *);
76 static int store_content (CT, CT);
77 static int output_content_file (CT, int);
78 static int check_folder (char *);
79 static int output_content_folder (char *, char *);
80 static int parse_format_string (CT, char *, char *, int, char *);
81 static void get_storeproc (CT);
82 static int copy_some_headers (FILE *, CT);
83
84
85 /*
86  * Main entry point to store content
87  * from a collection of messages.
88  */
89
90 void
91 store_all_messages (CT *cts)
92 {
93     CT ct, *ctp;
94     char *cp;
95
96     /*
97      * Check for the directory in which to
98      * store any contents.
99      */
100     if (autosw)
101         dir = getcpy (cwd);
102     else if ((cp = context_find (nmhstorage)) && *cp)
103         dir = getcpy (cp);
104     else
105         dir = getcpy (cwd);
106
107     for (ctp = cts; *ctp; ctp++) {
108         ct = *ctp;
109         store_single_message (ct);
110     }
111
112     flush_errors ();
113 }
114
115
116 /*
117  * Entry point to store the content
118  * in a (single) message
119  */
120
121 static void
122 store_single_message (CT ct)
123 {
124     if (type_ok (ct, 1)) {
125         umask (ct->c_umask);
126         store_switch (ct);
127         if (ct->c_fp) {
128             fclose (ct->c_fp);
129             ct->c_fp = NULL;
130         }
131         if (ct->c_ceclosefnx)
132             (*ct->c_ceclosefnx) (ct);
133     }
134 }
135
136
137 /*
138  * Switching routine to store different content types
139  */
140
141 static int
142 store_switch (CT ct)
143 {
144     switch (ct->c_type) {
145         case CT_MULTIPART:
146             return store_multi (ct);
147             break;
148
149         case CT_MESSAGE:
150             switch (ct->c_subtype) {
151                 case MESSAGE_PARTIAL:
152                     return store_partial (ct);
153                     break;
154
155                 case MESSAGE_EXTERNAL:
156                     return store_external (ct);
157
158                 case MESSAGE_RFC822:
159                 default:
160                     return store_generic (ct);
161                     break;
162             }
163             break;
164
165         case CT_APPLICATION:
166             return store_application (ct);
167             break;
168
169         case CT_TEXT:
170         case CT_AUDIO:
171         case CT_IMAGE:
172         case CT_VIDEO:
173             return store_generic (ct);
174             break;
175
176         default:
177             adios (NULL, "unknown content type %d", ct->c_type);
178             break;
179     }
180
181     return OK;  /* NOT REACHED */
182 }
183
184
185 /*
186  * Generic routine to store a MIME content.
187  * (audio, video, image, text, message/rfc922)
188  */
189
190 static int
191 store_generic (CT ct)
192 {
193     /*
194      * Check if the content specifies a filename.
195      * Don't bother with this for type "message"
196      * (only "message/rfc822" will use store_generic).
197      */
198     if (autosw && ct->c_type != CT_MESSAGE)
199         get_storeproc (ct);
200
201     return store_content (ct, NULL);
202 }
203
204
205 /*
206  * Store content of type "application"
207  */
208
209 static int
210 store_application (CT ct)
211 {
212     char **ap, **ep;
213     CI ci = &ct->c_ctinfo;
214
215     /* Check if the content specifies a filename */
216     if (autosw)
217         get_storeproc (ct);
218
219     /*
220      * If storeproc is not defined, and the content is type
221      * "application/octet-stream", we also check for various
222      * attribute/value pairs which specify if this a tar file.
223      */
224     if (!ct->c_storeproc && ct->c_subtype == APPLICATION_OCTETS) {
225         int tarP = 0, zP = 0, gzP = 0;
226
227         for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
228             /* check for "type=tar" attribute */
229             if (!strcasecmp (*ap, "type")) {
230                 if (strcasecmp (*ep, "tar"))
231                     break;
232
233                 tarP = 1;
234                 continue;
235             }
236
237             /* check for "conversions=compress" attribute */
238             if ((!strcasecmp (*ap, "conversions") || !strcasecmp (*ap, "x-conversions"))
239                 && (!strcasecmp (*ep, "compress") || !strcasecmp (*ep, "x-compress"))) {
240                 zP = 1;
241                 continue;
242             }
243             /* check for "conversions=gzip" attribute */
244             if ((!strcasecmp (*ap, "conversions") || !strcasecmp (*ap, "x-conversions"))
245                 && (!strcasecmp (*ep, "gzip") || !strcasecmp (*ep, "x-gzip"))) {
246                 gzP = 1;
247                 continue;
248             }
249         }
250
251         if (tarP) {
252             ct->c_showproc = add (zP ? "%euncompress | tar tvf -"
253                                   : (gzP ? "%egzip -dc | tar tvf -"
254                                      : "%etar tvf -"), NULL);
255             if (!ct->c_storeproc) {
256                 if (autosw) {
257                     ct->c_storeproc = add (zP ? "| uncompress | tar xvpf -"
258                                            : (gzP ? "| gzip -dc | tar xvpf -"
259                                               : "| tar xvpf -"), NULL);
260                     ct->c_umask = 0022;
261                 } else {
262                     ct->c_storeproc= add (zP ? "%m%P.tar.Z"
263                                           : (gzP ? "%m%P.tar.gz"
264                                              : "%m%P.tar"), NULL);
265                 }
266             }
267         }
268     }
269
270     return store_content (ct, NULL);
271 }
272
273
274 /*
275  * Store the content of a multipart message
276  */
277
278 static int
279 store_multi (CT ct)
280 {
281     int result;
282     struct multipart *m = (struct multipart *) ct->c_ctparams;
283     struct part *part;
284
285     result = NOTOK;
286     for (part = m->mp_parts; part; part = part->mp_next) {
287         CT  p = part->mp_part;
288
289         if (part_ok (p, 1) && type_ok (p, 1)) {
290             result = store_switch (p);
291             if (result == OK && ct->c_subtype == MULTI_ALTERNATE)
292                 break;
293         }
294     }
295
296     return result;
297 }
298
299
300 /*
301  * Reassemble and store the contents of a collection
302  * of messages of type "message/partial".
303  */
304
305 static int
306 store_partial (CT ct)
307 {
308     int cur, hi, i;
309     CT p, *ctp, *ctq;
310     CT *base;
311     struct partial *pm, *qm;
312
313     qm = (struct partial *) ct->c_ctparams;
314     if (qm->pm_stored)
315         return OK;
316
317     hi = i = 0;
318     for (ctp = cts; *ctp; ctp++) {
319         p = *ctp;
320         if (p->c_type == CT_MESSAGE && p->c_subtype == ct->c_subtype) {
321             pm = (struct partial *) p->c_ctparams;
322             if (!pm->pm_stored
323                     && strcmp (qm->pm_partid, pm->pm_partid) == 0) {
324                 pm->pm_marked = pm->pm_partno;
325                 if (pm->pm_maxno)
326                     hi = pm->pm_maxno;
327                 pm->pm_stored = 1;
328                 i++;
329             }
330             else
331                 pm->pm_marked = 0;
332         }
333     }
334
335     if (hi == 0) {
336         advise (NULL, "missing (at least) last part of multipart message");
337         return NOTOK;
338     }
339
340     if ((base = (CT *) calloc ((size_t) (i + 1), sizeof(*base))) == NULL)
341         adios (NULL, "out of memory");
342
343     ctq = base;
344     for (ctp = cts; *ctp; ctp++) {
345         p = *ctp;
346         if (p->c_type == CT_MESSAGE && p->c_subtype == ct->c_subtype) {
347             pm = (struct partial *) p->c_ctparams;
348             if (pm->pm_marked)
349                 *ctq++ = p;
350         }
351     }
352     *ctq = NULL;
353
354     if (i > 1)
355         qsort ((char *) base, i, sizeof(*base), (qsort_comp) ct_compar);
356
357     cur = 1;
358     for (ctq = base; *ctq; ctq++) {
359         p = *ctq;
360         pm = (struct partial *) p->c_ctparams;
361         if (pm->pm_marked != cur) {
362             if (pm->pm_marked == cur - 1) {
363                 admonish (NULL,
364                           "duplicate part %d of %d part multipart message",
365                           pm->pm_marked, hi);
366                 continue;
367             }
368
369 missing_part:
370             advise (NULL,
371                     "missing %spart %d of %d part multipart message",
372                     cur != hi ? "(at least) " : "", cur, hi);
373             goto losing;
374         }
375         else
376             cur++;
377     }
378     if (hi != --cur) {
379         cur = hi;
380         goto missing_part;
381     }
382
383     /*
384      * Now cycle through the sorted list of messages of type
385      * "message/partial" and save/append them to a file.
386      */
387
388     ctq = base;
389     ct = *ctq++;
390     if (store_content (ct, NULL) == NOTOK) {
391 losing:
392         free ((char *) base);
393         return NOTOK;
394     }
395
396     for (; *ctq; ctq++) {
397         p = *ctq;
398         if (store_content (p, ct) == NOTOK)
399             goto losing;
400     }
401
402     free ((char *) base);
403     return OK;
404 }
405
406
407 /*
408  * Store content from a message of type "message/external".
409  */
410
411 static int
412 store_external (CT ct)
413 {
414     int result = NOTOK;
415     struct exbody *e = (struct exbody *) ct->c_ctparams;
416     CT p = e->eb_content;
417
418     if (!type_ok (p, 1))
419         return OK;
420
421     /*
422      * Check if the parameters for the external body
423      * specified a filename.
424      */
425     if (autosw) {
426         char *cp;
427
428         if ((cp = e->eb_name)
429             && *cp != '/'
430             && *cp != '.'
431             && *cp != '|'
432             && *cp != '!'
433             && !strchr (cp, '%')) {
434             if (!ct->c_storeproc)
435                 ct->c_storeproc = add (cp, NULL);
436             if (!p->c_storeproc)
437                 p->c_storeproc = add (cp, NULL);
438         }
439     }
440
441     /*
442      * Since we will let the Content structure for the
443      * external body substitute for the current content,
444      * we temporarily change its partno (number inside
445      * multipart), so everything looks right.
446      */
447     p->c_partno = ct->c_partno;
448
449     /* we probably need to check if content is really there */
450     result = store_switch (p);
451
452     p->c_partno = NULL;
453     return result;
454 }
455
456
457 /*
458  * Compare the numbering from two different
459  * message/partials (needed for sorting).
460  */
461
462 static int
463 ct_compar (CT *a, CT *b)
464 {
465     struct partial *am = (struct partial *) ((*a)->c_ctparams);
466     struct partial *bm = (struct partial *) ((*b)->c_ctparams);
467
468     return (am->pm_marked - bm->pm_marked);
469 }
470
471
472 /*
473  * Store contents of a message or message part to
474  * a folder, a file, the standard output, or pass
475  * the contents to a command.
476  *
477  * If the current content to be saved is a followup part
478  * to a collection of messages of type "message/partial",
479  * then field "p" is a pointer to the Content structure
480  * to the first message/partial in the group.
481  */
482
483 static int
484 store_content (CT ct, CT p)
485 {
486     int appending = 0, msgnum;
487     int is_partial = 0, first_partial = 0;
488     int last_partial = 0;
489     char *cp, buffer[BUFSIZ];
490
491     /*
492      * Do special processing for messages of
493      * type "message/partial".
494      *
495      * We first check if this content is of type
496      * "message/partial".  If it is, then we need to check
497      * whether it is the first and/or last in the group.
498      *
499      * Then if "p" is a valid pointer, it points to the Content
500      * structure of the first partial in the group.  So we copy
501      * the file name and/or folder name from that message.  In
502      * this case, we also note that we will be appending.
503      */
504     if (ct->c_type == CT_MESSAGE && ct->c_subtype == MESSAGE_PARTIAL) {
505         struct partial *pm = (struct partial *) ct->c_ctparams;
506
507         /* Yep, it's a message/partial */
508         is_partial = 1;
509
510         /* But is it the first and/or last in the collection? */
511         if (pm->pm_partno == 1)
512             first_partial = 1;
513         if (pm->pm_maxno && pm->pm_partno == pm->pm_maxno)
514             last_partial = 1;
515
516         /*
517          * If "p" is a valid pointer, then it points to the
518          * Content structure for the first message in the group.
519          * So we just copy the filename or foldername information
520          * from the previous iteration of this function.
521          */
522         if (p) {
523             appending = 1;
524             ct->c_storage = add (p->c_storage, NULL);
525
526             /* record the folder name */
527             if (p->c_folder) {
528                 ct->c_folder = add (p->c_folder, NULL);
529             }
530             goto got_filename;
531         }
532     }
533
534     /*
535      * Get storage formatting string.
536      *
537      * 1) If we have storeproc defined, then use that
538      * 2) Else check for a mhn-store-<type>/<subtype> entry
539      * 3) Else check for a mhn-store-<type> entry
540      * 4) Else if content is "message", use "+" (current folder)
541      * 5) Else use string "%m%P.%s".
542      */
543     if ((cp = ct->c_storeproc) == NULL || *cp == '\0') {
544         CI ci = &ct->c_ctinfo;
545
546         snprintf (buffer, sizeof(buffer), "%s-store-%s/%s",
547                 invo_name, ci->ci_type, ci->ci_subtype);
548         if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
549             snprintf (buffer, sizeof(buffer), "%s-store-%s", invo_name, ci->ci_type);
550             if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
551                 cp = ct->c_type == CT_MESSAGE ? "+" : "%m%P.%s";
552             }
553         }
554     }
555
556     /*
557      * Check the beginning of storage formatting string
558      * to see if we are saving content to a folder.
559      */
560     if (*cp == '+' || *cp == '@') {
561         char *tmpfilenam, *folder;
562
563         /* Store content in temporary file for now */
564         tmpfilenam = m_scratch ("", invo_name);
565         ct->c_storage = add (tmpfilenam, NULL);
566
567         /* Get the folder name */
568         if (cp[1])
569             folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
570         else
571             folder = getfolder (1);
572
573         /* Check if folder exists */
574         if (check_folder (folder) == NOTOK)
575             return NOTOK;
576
577         /* Record the folder name */
578         ct->c_folder = add (folder, NULL);
579
580         if (cp[1])
581             free (folder);
582
583         goto got_filename;
584     }
585
586     /*
587      * Parse and expand the storage formatting string
588      * in `cp' into `buffer'.
589      */
590     parse_format_string (ct, cp, buffer, sizeof(buffer), dir);
591
592     /*
593      * If formatting begins with '|' or '!', then pass
594      * content to standard input of a command and return.
595      */
596     if (buffer[0] == '|' || buffer[0] == '!')
597         return show_content_aux (ct, 1, 0, buffer + 1, dir);
598
599     /* record the filename */
600     ct->c_storage = add (buffer, NULL);
601
602 got_filename:
603     /* flush the output stream */
604     fflush (stdout);
605
606     /* Now save or append the content to a file */
607     if (output_content_file (ct, appending) == NOTOK)
608         return NOTOK;
609
610     /*
611      * If necessary, link the file into a folder and remove
612      * the temporary file.  If this message is a partial,
613      * then only do this if it is the last one in the group.
614      */
615     if (ct->c_folder && (!is_partial || last_partial)) {
616         msgnum = output_content_folder (ct->c_folder, ct->c_storage);
617         unlink (ct->c_storage);
618         if (msgnum == NOTOK)
619             return NOTOK;
620     }
621
622     /*
623      * Now print out the name/number of the message
624      * that we are storing.
625      */
626     if (is_partial) {
627         if (first_partial)
628             fprintf (stderr, "reassembling partials ");
629         if (last_partial)
630             fprintf (stderr, "%s", ct->c_file);
631         else
632             fprintf (stderr, "%s,", ct->c_file);
633     } else {
634         fprintf (stderr, "storing message %s", ct->c_file);
635         if (ct->c_partno)
636             fprintf (stderr, " part %s", ct->c_partno);
637     }
638
639     /*
640      * Unless we are in the "middle" of group of message/partials,
641      * we now print the name of the file, folder, and/or message
642      * to which we are storing the content.
643      */
644     if (!is_partial || last_partial) {
645         if (ct->c_folder) {
646             fprintf (stderr, " to folder %s as message %d\n", ct->c_folder, msgnum);
647         } else if (!strcmp(ct->c_storage, "-")) {
648             fprintf (stderr, " to stdout\n");
649         } else {
650             int cwdlen;
651
652             cwdlen = strlen (cwd);
653             fprintf (stderr, " as file %s\n",
654                 strncmp (ct->c_storage, cwd, cwdlen)
655                 || ct->c_storage[cwdlen] != '/'
656                 ? ct->c_storage : ct->c_storage + cwdlen + 1);
657         }
658     }
659
660     return OK;
661 }
662
663
664 /*
665  * Output content to a file
666  */
667
668 static int
669 output_content_file (CT ct, int appending)
670 {
671     int filterstate;
672     char *file, buffer[BUFSIZ];
673     long pos, last;
674     FILE *fp;
675
676     /*
677      * If the pathname is absolute, make sure
678      * all the relevant directories exist.
679      */
680     if (strchr(ct->c_storage, '/')
681             && make_intermediates (ct->c_storage) == NOTOK)
682         return NOTOK;
683
684     if (ct->c_encoding != CE_7BIT) {
685         int cc, fd;
686
687         if (!ct->c_ceopenfnx) {
688             advise (NULL, "don't know how to decode part %s of message %s",
689                     ct->c_partno, ct->c_file);
690             return NOTOK;
691         }
692
693         file = appending || !strcmp (ct->c_storage, "-") ? NULL
694                                                            : ct->c_storage;
695         if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
696             return NOTOK;
697         if (!strcmp (file, ct->c_storage)) {
698             (*ct->c_ceclosefnx) (ct);
699             return OK;
700         }
701
702         /*
703          * Send to standard output
704          */
705         if (!strcmp (ct->c_storage, "-")) {
706             int gd;
707
708             if ((gd = dup (fileno (stdout))) == NOTOK) {
709                 advise ("stdout", "unable to dup");
710 losing:
711                 (*ct->c_ceclosefnx) (ct);
712                 return NOTOK;
713             }
714             if ((fp = fdopen (gd, appending ? "a" : "w")) == NULL) {
715                 advise ("stdout", "unable to fdopen (%d, \"%s\") from", gd,
716                         appending ? "a" : "w");
717                 close (gd);
718                 goto losing;
719             }
720         } else {
721             /*
722              * Open output file
723              */
724             if ((fp = fopen (ct->c_storage, appending ? "a" : "w")) == NULL) {
725                 advise (ct->c_storage, "unable to fopen for %s",
726                         appending ? "appending" : "writing");
727                 goto losing;
728             }
729         }
730
731         /*
732          * Filter the header fields of the initial enclosing
733          * message/partial into the file.
734          */
735         if (ct->c_type == CT_MESSAGE && ct->c_subtype == MESSAGE_PARTIAL) {
736             struct partial *pm = (struct partial *) ct->c_ctparams;
737
738             if (pm->pm_partno == 1)
739                 copy_some_headers (fp, ct);
740         }
741
742         for (;;) {
743             switch (cc = read (fd, buffer, sizeof(buffer))) {
744                 case NOTOK:
745                     advise (file, "error reading content from");
746                     break;
747
748                 case OK:
749                     break;
750
751                 default:
752                     fwrite (buffer, sizeof(*buffer), cc, fp);
753                     continue;
754             }
755             break;
756         }
757
758         (*ct->c_ceclosefnx) (ct);
759
760         if (cc != NOTOK && fflush (fp))
761             advise (ct->c_storage, "error writing to");
762
763         fclose (fp);
764
765         return (cc != NOTOK ? OK : NOTOK);
766     }
767
768     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
769         advise (ct->c_file, "unable to open for reading");
770         return NOTOK;
771     }
772
773     pos = ct->c_begin;
774     last = ct->c_end;
775     fseek (ct->c_fp, pos, SEEK_SET);
776
777     if (!strcmp (ct->c_storage, "-")) {
778         int gd;
779
780         if ((gd = dup (fileno (stdout))) == NOTOK) {
781             advise ("stdout", "unable to dup");
782             return NOTOK;
783         }
784         if ((fp = fdopen (gd, appending ? "a" : "w")) == NULL) {
785             advise ("stdout", "unable to fdopen (%d, \"%s\") from", gd,
786                     appending ? "a" : "w");
787             close (gd);
788             return NOTOK;
789         }
790     } else {
791         if ((fp = fopen (ct->c_storage, appending ? "a" : "w")) == NULL) {
792             advise (ct->c_storage, "unable to fopen for %s",
793                     appending ? "appending" : "writing");
794             return NOTOK;
795         }
796     }
797
798     /*
799      * Copy a few of the header fields of the initial
800      * enclosing message/partial into the file.
801      */
802     filterstate = 0;
803     if (ct->c_type == CT_MESSAGE && ct->c_subtype == MESSAGE_PARTIAL) {
804         struct partial *pm = (struct partial *) ct->c_ctparams;
805
806         if (pm->pm_partno == 1) {
807             copy_some_headers (fp, ct);
808             filterstate = 1;
809         }
810     }
811
812     while (fgets (buffer, sizeof(buffer) - 1, ct->c_fp)) {
813         if ((pos += strlen (buffer)) > last) {
814             int diff;
815
816             diff = strlen (buffer) - (pos - last);
817             if (diff >= 0)
818                 buffer[diff] = '\0';
819         }
820         /*
821          * If this is the first content of a group of
822          * message/partial contents, then we only copy a few
823          * of the header fields of the enclosed message.
824          */
825         if (filterstate) {
826             switch (buffer[0]) {
827                 case ' ':
828                 case '\t':
829                     if (filterstate < 0)
830                         buffer[0] = 0;
831                     break;
832
833                 case '\n':
834                     filterstate = 0;
835                     break;
836
837                 default:
838                     if (!uprf (buffer, XXX_FIELD_PRF)
839                             && !uprf (buffer, VRSN_FIELD)
840                             && !uprf (buffer, "Subject:")
841                             && !uprf (buffer, "Encrypted:")
842                             && !uprf (buffer, "Message-ID:")) {
843                         filterstate = -1;
844                         buffer[0] = 0;
845                         break;
846                     }
847                     filterstate = 1;
848                     break;
849             }
850         }
851         fputs (buffer, fp);
852         if (pos >= last)
853             break;
854     }
855
856     if (fflush (fp))
857         advise (ct->c_storage, "error writing to");
858
859     fclose (fp);
860     fclose (ct->c_fp);
861     ct->c_fp = NULL;
862     return OK;
863 }
864
865
866 /*
867  * Check if folder exists, and create
868  * if necessary.
869  */
870
871 static int
872 check_folder (char *folder)
873 {
874     char *folderdir;
875     struct stat st;
876
877     /* expand path to the folder */
878     folderdir = m_mailpath (folder);
879
880     /* Check if folder exists */
881     if (stat (folderdir, &st) == NOTOK) {
882         int answer;
883         char *ep;
884
885         if (errno != ENOENT) {
886             advise (folderdir, "error on folder");
887             return NOTOK;
888         }
889
890         ep = concat ("Create folder \"", folderdir, "\"? ", NULL);
891         answer = getanswer (ep);
892         free (ep);
893
894         if (!answer)
895             return NOTOK;
896
897         if (!makedir (folderdir)) {
898             advise (NULL, "unable to create folder %s", folderdir);
899             return NOTOK;
900         }
901     }
902
903     return OK;
904 }
905
906
907 /*
908  * Add a file to a folder.
909  *
910  * Return the new message number of the file
911  * when added to the folder.  Return -1, if
912  * there is an error.
913  */
914
915 static int
916 output_content_folder (char *folder, char *filename)
917 {
918     int msgnum;
919     struct msgs *mp;
920
921     /* Read the folder. */
922     if ((mp = folder_read (folder))) {
923         /* Link file into folder */
924         msgnum = folder_addmsg (&mp, filename, 0, 0, 0, 0, (char *)0);
925     } else {
926         advise (NULL, "unable to read folder %s", folder);
927         return NOTOK;
928     }
929
930     /* free folder structure */
931     folder_free (mp);
932
933     /*
934      * Return msgnum.  We are relying on the fact that
935      * msgnum will be -1, if folder_addmsg() had an error.
936      */
937     return msgnum;
938 }
939
940
941 /*
942  * Parse and expand the storage formatting string
943  * pointed to by "cp" into "buffer".
944  */
945
946 static int
947 parse_format_string (CT ct, char *cp, char *buffer, int buflen, char *dir)
948 {
949     int len;
950     char *bp;
951     CI ci = &ct->c_ctinfo;
952
953     /*
954      * If storage string is "-", just copy it, and
955      * return (send content to standard output).
956      */
957     if (cp[0] == '-' && cp[1] == '\0') {
958         strncpy (buffer, cp, buflen);
959         return 0;
960     }
961
962     bp = buffer;
963     bp[0] = '\0';
964
965     /*
966      * If formatting string is a pathname that doesn't
967      * begin with '/', then preface the path with the
968      * appropriate directory.
969      */
970     if (*cp != '/' && *cp != '|' && *cp != '!') {
971         snprintf (bp, buflen, "%s/", dir[1] ? dir : "");
972         len = strlen (bp);
973         bp += len;
974         buflen -= len;
975     }
976
977     for (; *cp; cp++) {
978
979         /* We are processing a storage escape */
980         if (*cp == '%') {
981             switch (*++cp) {
982                 case 'a':
983                     /*
984                      * Insert parameters from Content-Type.
985                      * This is only valid for '|' commands.
986                      */
987                     if (buffer[0] != '|' && buffer[0] != '!') {
988                         *bp++ = *--cp;
989                         *bp = '\0';
990                         buflen--;
991                         continue;
992                     } else {
993                         char **ap, **ep;
994                         char *s = "";
995
996                         for (ap = ci->ci_attrs, ep = ci->ci_values;
997                                  *ap; ap++, ep++) {
998                             snprintf (bp, buflen, "%s%s=\"%s\"", s, *ap, *ep);
999                             len = strlen (bp);
1000                             bp += len;
1001                             buflen -= len;
1002                             s = " ";
1003                         }
1004                     }
1005                     break;
1006
1007                 case 'm':
1008                     /* insert message number */
1009                     snprintf (bp, buflen, "%s", r1bindex (ct->c_file, '/'));
1010                     break;
1011
1012                 case 'P':
1013                     /* insert part number with leading dot */
1014                     if (ct->c_partno)
1015                         snprintf (bp, buflen, ".%s", ct->c_partno);
1016                     break;
1017
1018                 case 'p':
1019                     /* insert part number withouth leading dot */
1020                     if (ct->c_partno)
1021                         strncpy (bp, ct->c_partno, buflen);
1022                     break;
1023
1024                 case 't':
1025                     /* insert content type */
1026                     strncpy (bp, ci->ci_type, buflen);
1027                     break;
1028
1029                 case 's':
1030                     /* insert content subtype */
1031                     strncpy (bp, ci->ci_subtype, buflen);
1032                     break;
1033
1034                 case '%':
1035                     /* insert the character % */
1036                     goto raw;
1037
1038                 default:
1039                     *bp++ = *--cp;
1040                     *bp = '\0';
1041                     buflen--;
1042                     continue;
1043             }
1044
1045             /* Advance bp and decrement buflen */
1046             len = strlen (bp);
1047             bp += len;
1048             buflen -= len;
1049
1050         } else {
1051 raw:
1052             *bp++ = *cp;
1053             *bp = '\0';
1054             buflen--;
1055         }
1056     }
1057
1058     return 0;
1059 }
1060
1061
1062 /*
1063  * Check if the content specifies a filename
1064  * in its MIME parameters.
1065  */
1066
1067 static void
1068 get_storeproc (CT ct)
1069 {
1070     char **ap, **ep, *cp;
1071     CI ci = &ct->c_ctinfo;
1072
1073     /*
1074      * If the storeproc has already been defined,
1075      * we just return (for instance, if this content
1076      * is part of a "message/external".
1077      */
1078     if (ct->c_storeproc)
1079         return;
1080
1081     /*
1082      * Check the attribute/value pairs, for the attribute "name".
1083      * If found, do a few sanity checks and copy the value into
1084      * the storeproc.
1085      */
1086     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1087         if (!strcasecmp (*ap, "name")
1088             && *(cp = *ep) != '/'
1089             && *cp != '.'
1090             && *cp != '|'
1091             && *cp != '!'
1092             && !strchr (cp, '%')) {
1093             ct->c_storeproc = add (cp, NULL);
1094             return;
1095         }
1096     }
1097 }
1098
1099
1100 /*
1101  * Copy some of the header fields of the initial message/partial
1102  * message into the header of the reassembled message.
1103  */
1104
1105 static int
1106 copy_some_headers (FILE *out, CT ct)
1107 {
1108     HF hp;
1109
1110     hp = ct->c_first_hf;        /* start at first header field */
1111
1112     while (hp) {
1113         /*
1114          * A few of the header fields of the enclosing
1115          * messages are not copied.
1116          */
1117         if (!uprf (hp->name, XXX_FIELD_PRF)
1118                 && strcasecmp (hp->name, VRSN_FIELD)
1119                 && strcasecmp (hp->name, "Subject")
1120                 && strcasecmp (hp->name, "Encrypted")
1121                 && strcasecmp (hp->name, "Message-ID"))
1122             fprintf (out, "%s:%s", hp->name, hp->value);
1123         hp = hp->next;  /* next header field */
1124     }
1125
1126     return OK;
1127 }