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