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