git.marmaro.de Git - mmh/blob - uip/mhparse.c

   1
   2 /*
   3  * mhparse.c -- routines to parse 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 extern int debugsw;
  24
  25 extern int endian;      /* mhmisc.c     */
  26
  27 extern pid_t xpid;      /* mhshowsbr.c  */
  28
  29 /* cache policies */
  30 extern int rcachesw;    /* mhcachesbr.c */
  31 extern int wcachesw;    /* mhcachesbr.c */
  32
  33 int checksw = 0;        /* check Content-MD5 field */
  34
  35 /*
  36  * Directory to place temp files.  This must
  37  * be set before these routines are called.
  38  */
  39 char *tmp;
  40
  41 /*
  42  * Structures for TEXT messages
  43  */
  44 struct k2v SubText[] = {
  45     { "plain",    TEXT_PLAIN },
  46     { "richtext", TEXT_RICHTEXT },  /* defined in RFC-1341    */
  47     { "enriched", TEXT_ENRICHED },  /* defined in RFC-1896    */
  48     { NULL,       TEXT_UNKNOWN }    /* this one must be last! */
  49 };
  50
  51 struct k2v Charset[] = {
  52     { "us-ascii",   CHARSET_USASCII },
  53     { "iso-8859-1", CHARSET_LATIN },
  54     { NULL,         CHARSET_UNKNOWN }  /* this one must be last! */
  55 };
  56
  57 /*
  58  * Structures for MULTIPART messages
  59  */
  60 struct k2v SubMultiPart[] = {
  61     { "mixed",       MULTI_MIXED },
  62     { "alternative", MULTI_ALTERNATE },
  63     { "digest",      MULTI_DIGEST },
  64     { "parallel",    MULTI_PARALLEL },
  65     { NULL,          MULTI_UNKNOWN }    /* this one must be last! */
  66 };
  67
  68 /*
  69  * Structures for MESSAGE messages
  70  */
  71 struct k2v SubMessage[] = {
  72     { "rfc822",        MESSAGE_RFC822 },
  73     { "partial",       MESSAGE_PARTIAL },
  74     { "external-body", MESSAGE_EXTERNAL },
  75     { NULL,            MESSAGE_UNKNOWN }        /* this one must be last! */
  76 };
  77
  78 /*
  79  * Structure for APPLICATION messages
  80  */
  81 struct k2v SubApplication[] = {
  82     { "octet-stream", APPLICATION_OCTETS },
  83     { "postscript",   APPLICATION_POSTSCRIPT },
  84     { NULL,           APPLICATION_UNKNOWN }     /* this one must be last! */
  85 };
  86
  87
  88 /* mhcachesbr.c */
  89 int find_cache (CT, int, int *, char *, char *, int);
  90
  91 /* mhmisc.c */
  92 int part_ok (CT, int);
  93 int type_ok (CT, int);
  94 void content_error (char *, CT, char *, ...);
  95
  96 /* mhfree.c */
  97 void free_content (CT);
  98 void free_encoding (CT, int);
  99
 100 /*
 101  * static prototypes
 102  */
 103 static CT get_content (FILE *, char *, int);
 104 static int get_comment (CT, unsigned char **, int);
 105
 106 static int InitGeneric (CT);
 107 static int InitText (CT);
 108 static int InitMultiPart (CT);
 109 static void reverse_parts (CT);
 110 static int InitMessage (CT);
 111 static int InitApplication (CT);
 112 static int init_encoding (CT, OpenCEFunc);
 113 static unsigned long size_encoding (CT);
 114 static int InitBase64 (CT);
 115 static int openBase64 (CT, char **);
 116 static int InitQuoted (CT);
 117 static int openQuoted (CT, char **);
 118 static int Init7Bit (CT);
 119 static int openExternal (CT, CT, CE, char **, int *);
 120 static int InitFile (CT);
 121 static int openFile (CT, char **);
 122 static int InitFTP (CT);
 123 static int openFTP (CT, char **);
 124 static int InitMail (CT);
 125 static int openMail (CT, char **);
 126 static int readDigest (CT, char *);
 127
 128 struct str2init str2cts[] = {
 129     { "application", CT_APPLICATION, InitApplication },
 130     { "audio",       CT_AUDIO,       InitGeneric },
 131     { "image",       CT_IMAGE,       InitGeneric },
 132     { "message",     CT_MESSAGE,     InitMessage },
 133     { "multipart",   CT_MULTIPART,   InitMultiPart },
 134     { "text",        CT_TEXT,        InitText },
 135     { "video",       CT_VIDEO,       InitGeneric },
 136     { NULL,          CT_EXTENSION,   NULL },  /* these two must be last! */
 137     { NULL,          CT_UNKNOWN,     NULL },
 138 };
 139
 140 struct str2init str2ces[] = {
 141     { "base64",           CE_BASE64,    InitBase64 },
 142     { "quoted-printable", CE_QUOTED,    InitQuoted },
 143     { "8bit",             CE_8BIT,      Init7Bit },
 144     { "7bit",             CE_7BIT,      Init7Bit },
 145     { "binary",           CE_BINARY,    Init7Bit },
 146     { NULL,               CE_EXTENSION, NULL },  /* these two must be last! */
 147     { NULL,               CE_UNKNOWN,   NULL },
 148 };
 149
 150 /*
 151  * NOTE WELL: si_key MUST NOT have value of NOTOK
 152  *
 153  * si_key is 1 if access method is anonymous.
 154  */
 155 struct str2init str2methods[] = {
 156     { "afs",         1, InitFile },
 157     { "anon-ftp",    1, InitFTP },
 158     { "ftp",         0, InitFTP },
 159     { "local-file",  0, InitFile },
 160     { "mail-server", 0, InitMail },
 161     { NULL,          0, NULL }
 162 };
 163
 164
 165 int
 166 pidcheck (int status)
 167 {
 168     if ((status & 0xff00) == 0xff00 || (status & 0x007f) != SIGQUIT)
 169         return status;
 170
 171     fflush (stdout);
 172     fflush (stderr);
 173     done (1);
 174     return 1;
 175 }
 176
 177
 178 /*
 179  * Main entry point for parsing a MIME message or file.
 180  * It returns the Content structure for the top level
 181  * entity in the file.
 182  */
 183
 184 CT
 185 parse_mime (char *file)
 186 {
 187     int is_stdin;
 188     char buffer[BUFSIZ];
 189     FILE *fp;
 190     CT ct;
 191
 192     /*
 193      * Check if file is actually standard input
 194      */
 195     if ((is_stdin = !(strcmp (file, "-")))) {
 196         char *tfile = m_mktemp2(NULL, invo_name, NULL, &fp);
 197         if (tfile == NULL) {
 198             advise("mhparse", "unable to create temporary file");
 199             return NULL;
 200         }
 201         file = add (tfile, NULL);
 202         chmod (file, 0600);
 203
 204         while (fgets (buffer, sizeof(buffer), stdin))
 205             fputs (buffer, fp);
 206         fflush (fp);
 207
 208         if (ferror (stdin)) {
 209             unlink (file);
 210             advise ("stdin", "error reading");
 211             return NULL;
 212         }
 213         if (ferror (fp)) {
 214             unlink (file);
 215             advise (file, "error writing");
 216             return NULL;
 217         }
 218         fseek (fp, 0L, SEEK_SET);
 219     } else if ((fp = fopen (file, "r")) == NULL) {
 220         advise (file, "unable to read");
 221         return NULL;
 222     }
 223
 224     if (!(ct = get_content (fp, file, 1))) {
 225         if (is_stdin)
 226             unlink (file);
 227         advise (NULL, "unable to decode %s", file);
 228         return NULL;
 229     }
 230
 231     if (is_stdin)
 232         ct->c_unlink = 1;       /* temp file to remove */
 233
 234     ct->c_fp = NULL;
 235
 236     if (ct->c_end == 0L) {
 237         fseek (fp, 0L, SEEK_END);
 238         ct->c_end = ftell (fp);
 239     }
 240
 241     if (ct->c_ctinitfnx && (*ct->c_ctinitfnx) (ct) == NOTOK) {
 242         fclose (fp);
 243         free_content (ct);
 244         return NULL;
 245     }
 246
 247     fclose (fp);
 248     return ct;
 249 }
 250
 251
 252 /*
 253  * Main routine for reading/parsing the headers
 254  * of a message content.
 255  *
 256  * toplevel =  1   # we are at the top level of the message
 257  * toplevel =  0   # we are inside message type or multipart type
 258  *                 # other than multipart/digest
 259  * toplevel = -1   # we are inside multipart/digest
 260  * NB: on failure we will fclose(in)!
 261  */
 262
 263 static CT
 264 get_content (FILE *in, char *file, int toplevel)
 265 {
 266     int compnum, state;
 267     char buf[BUFSIZ], name[NAMESZ];
 268     char *np, *vp;
 269     CT ct;
 270     HF hp;
 271
 272     /* allocate the content structure */
 273     if (!(ct = (CT) calloc (1, sizeof(*ct))))
 274         adios (NULL, "out of memory");
 275
 276     ct->c_fp = in;
 277     ct->c_file = add (file, NULL);
 278     ct->c_begin = ftell (ct->c_fp) + 1;
 279
 280     /*
 281      * Parse the header fields for this
 282      * content into a linked list.
 283      */
 284     for (compnum = 1, state = FLD;;) {
 285         switch (state = m_getfld (state, name, buf, sizeof(buf), in)) {
 286         case FLD:
 287         case FLDPLUS:
 288         case FLDEOF:
 289             compnum++;
 290
 291             /* get copies of the buffers */
 292             np = add (name, NULL);
 293             vp = add (buf, NULL);
 294
 295             /* if necessary, get rest of field */
 296             while (state == FLDPLUS) {
 297                 state = m_getfld (state, name, buf, sizeof(buf), in);
 298                 vp = add (buf, vp);     /* add to previous value */
 299             }
 300
 301             /* Now add the header data to the list */
 302             add_header (ct, np, vp);
 303
 304             /* continue, if this isn't the last header field */
 305             if (state != FLDEOF) {
 306                 ct->c_begin = ftell (in) + 1;
 307                 continue;
 308             }
 309             /* else fall... */
 310
 311         case BODY:
 312         case BODYEOF:
 313             ct->c_begin = ftell (in) - strlen (buf);
 314             break;
 315
 316         case FILEEOF:
 317             ct->c_begin = ftell (in);
 318             break;
 319
 320         case LENERR:
 321         case FMTERR:
 322             adios (NULL, "message format error in component #%d", compnum);
 323
 324         default:
 325             adios (NULL, "getfld() returned %d", state);
 326         }
 327
 328         /* break out of the loop */
 329         break;
 330     }
 331
 332     /*
 333      * Read the content headers.  We will parse the
 334      * MIME related header fields into their various
 335      * structures and set internal flags related to
 336      * content type/subtype, etc.
 337      */
 338
 339     hp = ct->c_first_hf;        /* start at first header field */
 340     while (hp) {
 341         /* Get MIME-Version field */
 342         if (!mh_strcasecmp (hp->name, VRSN_FIELD)) {
 343             int ucmp;
 344             char c;
 345             unsigned char *cp, *dp;
 346
 347             if (ct->c_vrsn) {
 348                 advise (NULL, "message %s has multiple %s: fields",
 349                         ct->c_file, VRSN_FIELD);
 350                 goto next_header;
 351             }
 352             ct->c_vrsn = add (hp->value, NULL);
 353
 354             /* Now, cleanup this field */
 355             cp = ct->c_vrsn;
 356
 357             while (isspace (*cp))
 358                 cp++;
 359             for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 360                 *dp++ = ' ';
 361             for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 362                 if (!isspace (*dp))
 363                     break;
 364             *++dp = '\0';
 365             if (debugsw)
 366                 fprintf (stderr, "%s: %s\n", VRSN_FIELD, cp);
 367
 368             if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK)
 369                 goto out;
 370
 371             for (dp = cp; istoken (*dp); dp++)
 372                 continue;
 373             c = *dp;
 374             *dp = '\0';
 375             ucmp = !mh_strcasecmp (cp, VRSN_VALUE);
 376             *dp = c;
 377             if (!ucmp) {
 378                 admonish (NULL, "message %s has unknown value for %s: field (%s)",
 379                 ct->c_file, VRSN_FIELD, cp);
 380             }
 381         }
 382         else if (!mh_strcasecmp (hp->name, TYPE_FIELD)) {
 383         /* Get Content-Type field */
 384             struct str2init *s2i;
 385             CI ci = &ct->c_ctinfo;
 386
 387             /* Check if we've already seen a Content-Type header */
 388             if (ct->c_ctline) {
 389                 advise (NULL, "message %s has multiple %s: fields",
 390                         ct->c_file, TYPE_FIELD);
 391                 goto next_header;
 392             }
 393
 394             /* Parse the Content-Type field */
 395             if (get_ctinfo (hp->value, ct, 0) == NOTOK)
 396                 goto out;
 397
 398             /*
 399              * Set the Init function and the internal
 400              * flag for this content type.
 401              */
 402             for (s2i = str2cts; s2i->si_key; s2i++)
 403                 if (!mh_strcasecmp (ci->ci_type, s2i->si_key))
 404                     break;
 405             if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
 406                 s2i++;
 407             ct->c_type = s2i->si_val;
 408             ct->c_ctinitfnx = s2i->si_init;
 409         }
 410         else if (!mh_strcasecmp (hp->name, ENCODING_FIELD)) {
 411         /* Get Content-Transfer-Encoding field */
 412             char c;
 413             unsigned char *cp, *dp;
 414             struct str2init *s2i;
 415
 416             /*
 417              * Check if we've already seen the
 418              * Content-Transfer-Encoding field
 419              */
 420             if (ct->c_celine) {
 421                 advise (NULL, "message %s has multiple %s: fields",
 422                         ct->c_file, ENCODING_FIELD);
 423                 goto next_header;
 424             }
 425
 426             /* get copy of this field */
 427             ct->c_celine = cp = add (hp->value, NULL);
 428
 429             while (isspace (*cp))
 430                 cp++;
 431             for (dp = cp; istoken (*dp); dp++)
 432                 continue;
 433             c = *dp;
 434             *dp = '\0';
 435
 436             /*
 437              * Find the internal flag and Init function
 438              * for this transfer encoding.
 439              */
 440             for (s2i = str2ces; s2i->si_key; s2i++)
 441                 if (!mh_strcasecmp (cp, s2i->si_key))
 442                     break;
 443             if (!s2i->si_key && !uprf (cp, "X-"))
 444                 s2i++;
 445             *dp = c;
 446             ct->c_encoding = s2i->si_val;
 447
 448             /* Call the Init function for this encoding */
 449             if (s2i->si_init && (*s2i->si_init) (ct) == NOTOK)
 450                 goto out;
 451         }
 452         else if (!mh_strcasecmp (hp->name, MD5_FIELD)) {
 453         /* Get Content-MD5 field */
 454             unsigned char *cp, *dp;
 455             char *ep;
 456
 457             if (!checksw)
 458                 goto next_header;
 459
 460             if (ct->c_digested) {
 461                 advise (NULL, "message %s has multiple %s: fields",
 462                         ct->c_file, MD5_FIELD);
 463                 goto next_header;
 464             }
 465
 466             ep = cp = add (hp->value, NULL);    /* get a copy */
 467
 468             while (isspace (*cp))
 469                 cp++;
 470             for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 471                 *dp++ = ' ';
 472             for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 473                 if (!isspace (*dp))
 474                     break;
 475             *++dp = '\0';
 476             if (debugsw)
 477                 fprintf (stderr, "%s: %s\n", MD5_FIELD, cp);
 478
 479             if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK) {
 480                 free (ep);
 481                 goto out;
 482             }
 483
 484             for (dp = cp; *dp && !isspace (*dp); dp++)
 485                 continue;
 486             *dp = '\0';
 487
 488             readDigest (ct, cp);
 489             free (ep);
 490             ct->c_digested++;
 491         }
 492         else if (!mh_strcasecmp (hp->name, ID_FIELD)) {
 493         /* Get Content-ID field */
 494             ct->c_id = add (hp->value, ct->c_id);
 495         }
 496         else if (!mh_strcasecmp (hp->name, DESCR_FIELD)) {
 497         /* Get Content-Description field */
 498             ct->c_descr = add (hp->value, ct->c_descr);
 499         }
 500         else if (!mh_strcasecmp (hp->name, DISPO_FIELD)) {
 501         /* Get Content-Disposition field */
 502             ct->c_dispo = add (hp->value, ct->c_dispo);
 503         }
 504
 505 next_header:
 506         hp = hp->next;  /* next header field */
 507     }
 508
 509     /*
 510      * Check if we saw a Content-Type field.
 511      * If not, then assign a default value for
 512      * it, and the Init function.
 513      */
 514     if (!ct->c_ctline) {
 515         /*
 516          * If we are inside a multipart/digest message,
 517          * so default type is message/rfc822
 518          */
 519         if (toplevel < 0) {
 520             if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
 521                 goto out;
 522             ct->c_type = CT_MESSAGE;
 523             ct->c_ctinitfnx = InitMessage;
 524         } else {
 525             /*
 526              * Else default type is text/plain
 527              */
 528             if (get_ctinfo ("text/plain", ct, 0) == NOTOK)
 529                 goto out;
 530             ct->c_type = CT_TEXT;
 531             ct->c_ctinitfnx = InitText;
 532         }
 533     }
 534
 535     /* Use default Transfer-Encoding, if necessary */
 536     if (!ct->c_celine) {
 537         ct->c_encoding = CE_7BIT;
 538         Init7Bit (ct);
 539     }
 540
 541     return ct;
 542
 543 out:
 544     free_content (ct);
 545     return NULL;
 546 }
 547
 548
 549 /*
 550  * small routine to add header field to list
 551  */
 552
 553 int
 554 add_header (CT ct, char *name, char *value)
 555 {
 556     HF hp;
 557
 558     /* allocate header field structure */
 559     hp = mh_xmalloc (sizeof(*hp));
 560
 561     /* link data into header structure */
 562     hp->name = name;
 563     hp->value = value;
 564     hp->next = NULL;
 565
 566     /* link header structure into the list */
 567     if (ct->c_first_hf == NULL) {
 568         ct->c_first_hf = hp;            /* this is the first */
 569         ct->c_last_hf = hp;
 570     } else {
 571         ct->c_last_hf->next = hp;       /* add it to the end */
 572         ct->c_last_hf = hp;
 573     }
 574
 575     return 0;
 576 }
 577
 578
 579 /* Make sure that buf contains at least one appearance of name,
 580    followed by =.  If not, insert both name and value, just after
 581    first semicolon, if any.  Note that name should not contain a
 582    trailing =.  And quotes will be added around the value.  Typical
 583    usage:  make sure that a Content-Disposition header contains
 584    filename="foo".  If it doesn't and value does, use value from
 585    that. */
 586 static char *
 587 incl_name_value (unsigned char *buf, char *name, char *value) {
 588     char *newbuf = buf;
 589
 590     /* Assume that name is non-null. */
 591     if (buf && value) {
 592         char *name_plus_equal = concat (name, "=", NULL);
 593
 594         if (! strstr (buf, name_plus_equal)) {
 595             char *insertion;
 596             unsigned char *cp;
 597             char *prefix, *suffix;
 598
 599             /* Trim trailing space, esp. newline. */
 600             for (cp = &buf[strlen (buf) - 1];
 601                  cp >= buf && isspace (*cp);
 602                  --cp) {
 603                 *cp = '\0';
 604             }
 605
 606             insertion = concat ("; ", name, "=", "\"", value, "\"", NULL);
 607
 608             /* Insert at first semicolon, if any.  If none, append to
 609                end. */
 610             prefix = add (buf, NULL);
 611             if ((cp = strchr (prefix, ';'))) {
 612                 suffix = concat (cp, NULL);
 613                 *cp = '\0';
 614                 newbuf = concat (prefix, insertion, suffix, "\n", NULL);
 615                 free (suffix);
 616             } else {
 617                 /* Append to end. */
 618                 newbuf = concat (buf, insertion, "\n", NULL);
 619             }
 620
 621             free (prefix);
 622             free (insertion);
 623             free (buf);
 624         }
 625
 626         free (name_plus_equal);
 627     }
 628
 629     return newbuf;
 630 }
 631
 632 /* Extract just name_suffix="foo", if any, from value.  If there isn't
 633    one, return the entire value.  Note that, for example, a name_suffix
 634    of name will match filename="foo", and return foo. */
 635 static char *
 636 extract_name_value (char *name_suffix, char *value) {
 637     char *extracted_name_value = value;
 638     char *name_suffix_plus_quote = concat (name_suffix, "=\"", NULL);
 639     char *name_suffix_equals = strstr (value, name_suffix_plus_quote);
 640     char *cp;
 641
 642     free (name_suffix_plus_quote);
 643     if (name_suffix_equals) {
 644         char *name_suffix_begin;
 645
 646         /* Find first \". */
 647         for (cp = name_suffix_equals; *cp != '"'; ++cp) /* empty */;
 648         name_suffix_begin = ++cp;
 649         /* Find second \". */
 650         for (; *cp != '"'; ++cp) /* empty */;
 651
 652         extracted_name_value = mh_xmalloc (cp - name_suffix_begin + 1);
 653         memcpy (extracted_name_value,
 654                 name_suffix_begin,
 655                 cp - name_suffix_begin);
 656         extracted_name_value[cp - name_suffix_begin] = '\0';
 657     }
 658
 659     return extracted_name_value;
 660 }
 661
 662 /*
 663  * Parse Content-Type line and (if `magic' is non-zero) mhbuild composition
 664  * directives.  Fills in the information of the CTinfo structure.
 665  */
 666 int
 667 get_ctinfo (unsigned char *cp, CT ct, int magic)
 668 {
 669     int i;
 670     unsigned char *dp;
 671     char **ap, **ep;
 672     char c;
 673     CI ci;
 674
 675     ci = &ct->c_ctinfo;
 676     i = strlen (invo_name) + 2;
 677
 678     /* store copy of Content-Type line */
 679     cp = ct->c_ctline = add (cp, NULL);
 680
 681     while (isspace (*cp))       /* trim leading spaces */
 682         cp++;
 683
 684     /* change newlines to spaces */
 685     for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 686         *dp++ = ' ';
 687
 688     /* trim trailing spaces */
 689     for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 690         if (!isspace (*dp))
 691             break;
 692     *++dp = '\0';
 693
 694     if (debugsw)
 695         fprintf (stderr, "%s: %s\n", TYPE_FIELD, cp);
 696
 697     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 698         return NOTOK;
 699
 700     for (dp = cp; istoken (*dp); dp++)
 701         continue;
 702     c = *dp, *dp = '\0';
 703     ci->ci_type = add (cp, NULL);       /* store content type */
 704     *dp = c, cp = dp;
 705
 706     if (!*ci->ci_type) {
 707         advise (NULL, "invalid %s: field in message %s (empty type)",
 708                 TYPE_FIELD, ct->c_file);
 709         return NOTOK;
 710     }
 711
 712     /* down case the content type string */
 713     for (dp = ci->ci_type; *dp; dp++)
 714         if (isalpha(*dp) && isupper (*dp))
 715             *dp = tolower (*dp);
 716
 717     while (isspace (*cp))
 718         cp++;
 719
 720     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 721         return NOTOK;
 722
 723     if (*cp != '/') {
 724         if (!magic)
 725             ci->ci_subtype = add ("", NULL);
 726         goto magic_skip;
 727     }
 728
 729     cp++;
 730     while (isspace (*cp))
 731         cp++;
 732
 733     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 734         return NOTOK;
 735
 736     for (dp = cp; istoken (*dp); dp++)
 737         continue;
 738     c = *dp, *dp = '\0';
 739     ci->ci_subtype = add (cp, NULL);    /* store the content subtype */
 740     *dp = c, cp = dp;
 741
 742     if (!*ci->ci_subtype) {
 743         advise (NULL,
 744                 "invalid %s: field in message %s (empty subtype for \"%s\")",
 745                 TYPE_FIELD, ct->c_file, ci->ci_type);
 746         return NOTOK;
 747     }
 748
 749     /* down case the content subtype string */
 750     for (dp = ci->ci_subtype; *dp; dp++)
 751         if (isalpha(*dp) && isupper (*dp))
 752             *dp = tolower (*dp);
 753
 754 magic_skip:
 755     while (isspace (*cp))
 756         cp++;
 757
 758     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 759         return NOTOK;
 760
 761     /*
 762      * Parse attribute/value pairs given with Content-Type
 763      */
 764     ep = (ap = ci->ci_attrs) + NPARMS;
 765     while (*cp == ';') {
 766         char *vp;
 767         unsigned char *up;
 768
 769         if (ap >= ep) {
 770             advise (NULL,
 771                     "too many parameters in message %s's %s: field (%d max)",
 772                     ct->c_file, TYPE_FIELD, NPARMS);
 773             return NOTOK;
 774         }
 775
 776         cp++;
 777         while (isspace (*cp))
 778             cp++;
 779
 780         if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 781             return NOTOK;
 782
 783         if (*cp == 0) {
 784             advise (NULL,
 785                     "extraneous trailing ';' in message %s's %s: parameter list",
 786                     ct->c_file, TYPE_FIELD);
 787             return OK;
 788         }
 789
 790         /* down case the attribute name */
 791         for (dp = cp; istoken (*dp); dp++)
 792             if (isalpha(*dp) && isupper (*dp))
 793                 *dp = tolower (*dp);
 794
 795         for (up = dp; isspace (*dp);)
 796             dp++;
 797         if (dp == cp || *dp != '=') {
 798             advise (NULL,
 799                     "invalid parameter in message %s's %s: field\n%*.*sparameter %s (error detected at offset %d)",
 800                     ct->c_file, TYPE_FIELD, i, i, "", cp, dp - cp);
 801             return NOTOK;
 802         }
 803
 804         vp = (*ap = add (cp, NULL)) + (up - cp);
 805         *vp = '\0';
 806         for (dp++; isspace (*dp);)
 807             dp++;
 808
 809         /* now add the attribute value */
 810         ci->ci_values[ap - ci->ci_attrs] = vp = *ap + (dp - cp);
 811
 812         if (*dp == '"') {
 813             for (cp = ++dp, dp = vp;;) {
 814                 switch (c = *cp++) {
 815                     case '\0':
 816 bad_quote:
 817                         advise (NULL,
 818                                 "invalid quoted-string in message %s's %s: field\n%*.*s(parameter %s)",
 819                                 ct->c_file, TYPE_FIELD, i, i, "", *ap);
 820                         return NOTOK;
 821
 822                     case '\\':
 823                         *dp++ = c;
 824                         if ((c = *cp++) == '\0')
 825                             goto bad_quote;
 826                         /* else fall... */
 827
 828                     default:
 829                         *dp++ = c;
 830                         continue;
 831
 832                     case '"':
 833                         *dp = '\0';
 834                         break;
 835                 }
 836                 break;
 837             }
 838         } else {
 839             for (cp = dp, dp = vp; istoken (*cp); cp++, dp++)
 840                 continue;
 841             *dp = '\0';
 842         }
 843         if (!*vp) {
 844             advise (NULL,
 845                     "invalid parameter in message %s's %s: field\n%*.*s(parameter %s)",
 846                     ct->c_file, TYPE_FIELD, i, i, "", *ap);
 847             return NOTOK;
 848         }
 849         ap++;
 850
 851         while (isspace (*cp))
 852             cp++;
 853
 854         if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 855             return NOTOK;
 856     }
 857
 858     /*
 859      * Get any <Content-Id> given in buffer
 860      */
 861     if (magic && *cp == '<') {
 862         if (ct->c_id) {
 863             free (ct->c_id);
 864             ct->c_id = NULL;
 865         }
 866         if (!(dp = strchr(ct->c_id = ++cp, '>'))) {
 867             advise (NULL, "invalid ID in message %s", ct->c_file);
 868             return NOTOK;
 869         }
 870         c = *dp;
 871         *dp = '\0';
 872         if (*ct->c_id)
 873             ct->c_id = concat ("<", ct->c_id, ">\n", NULL);
 874         else
 875             ct->c_id = NULL;
 876         *dp++ = c;
 877         cp = dp;
 878
 879         while (isspace (*cp))
 880             cp++;
 881     }
 882
 883     /*
 884      * Get any [Content-Description] given in buffer.
 885      */
 886     if (magic && *cp == '[') {
 887         ct->c_descr = ++cp;
 888         for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 889             if (*dp == ']')
 890                 break;
 891         if (dp < cp) {
 892             advise (NULL, "invalid description in message %s", ct->c_file);
 893             ct->c_descr = NULL;
 894             return NOTOK;
 895         }
 896
 897         c = *dp;
 898         *dp = '\0';
 899         if (*ct->c_descr)
 900             ct->c_descr = concat (ct->c_descr, "\n", NULL);
 901         else
 902             ct->c_descr = NULL;
 903         *dp++ = c;
 904         cp = dp;
 905
 906         while (isspace (*cp))
 907             cp++;
 908     }
 909
 910     /*
 911      * Get any {Content-Disposition} given in buffer.
 912      */
 913     if (magic && *cp == '{') {
 914         ct->c_dispo = ++cp;
 915         for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 916             if (*dp == '}')
 917                 break;
 918         if (dp < cp) {
 919             advise (NULL, "invalid disposition in message %s", ct->c_file);
 920             ct->c_dispo = NULL;
 921             return NOTOK;
 922         }
 923
 924         c = *dp;
 925         *dp = '\0';
 926         if (*ct->c_dispo)
 927             ct->c_dispo = concat (ct->c_dispo, "\n", NULL);
 928         else
 929             ct->c_dispo = NULL;
 930         *dp++ = c;
 931         cp = dp;
 932
 933         while (isspace (*cp))
 934             cp++;
 935     }
 936
 937     /*
 938      * Check if anything is left over
 939      */
 940     if (*cp) {
 941         if (magic) {
 942             ci->ci_magic = add (cp, NULL);
 943
 944             /* If there is a Content-Disposition header and it doesn't
 945                have a *filename=, extract it from the magic contents.
 946                The r1bindex call skips any leading directory
 947                components. */
 948             if (ct->c_dispo)
 949                 ct->c_dispo =
 950                     incl_name_value (ct->c_dispo,
 951                                      "filename",
 952                                      r1bindex (extract_name_value ("name",
 953                                                                    ci->
 954                                                                    ci_magic),
 955                                                '/'));
 956         }
 957         else
 958             advise (NULL,
 959                     "extraneous information in message %s's %s: field\n%*.*s(%s)",
 960                     ct->c_file, TYPE_FIELD, i, i, "", cp);
 961     }
 962
 963     return OK;
 964 }
 965
 966
 967 static int
 968 get_comment (CT ct, unsigned char **ap, int istype)
 969 {
 970     int i;
 971     char *bp;
 972     unsigned char *cp;
 973     char c, buffer[BUFSIZ], *dp;
 974     CI ci;
 975
 976     ci = &ct->c_ctinfo;
 977     cp = *ap;
 978     bp = buffer;
 979     cp++;
 980
 981     for (i = 0;;) {
 982         switch (c = *cp++) {
 983         case '\0':
 984 invalid:
 985         advise (NULL, "invalid comment in message %s's %s: field",
 986                 ct->c_file, istype ? TYPE_FIELD : VRSN_FIELD);
 987         return NOTOK;
 988
 989         case '\\':
 990             *bp++ = c;
 991             if ((c = *cp++) == '\0')
 992                 goto invalid;
 993             *bp++ = c;
 994             continue;
 995
 996         case '(':
 997             i++;
 998             /* and fall... */
 999         default:
1000             *bp++ = c;
1001             continue;
1002
1003         case ')':
1004             if (--i < 0)
1005                 break;
1006             *bp++ = c;
1007             continue;
1008         }
1009         break;
1010     }
1011     *bp = '\0';
1012
1013     if (istype) {
1014         if ((dp = ci->ci_comment)) {
1015             ci->ci_comment = concat (dp, " ", buffer, NULL);
1016             free (dp);
1017         } else {
1018             ci->ci_comment = add (buffer, NULL);
1019         }
1020     }
1021
1022     while (isspace (*cp))
1023         cp++;
1024
1025     *ap = cp;
1026     return OK;
1027 }
1028
1029
1030 /*
1031  * CONTENTS
1032  *
1033  * Handles content types audio, image, and video.
1034  * There's not much to do right here.
1035  */
1036
1037 static int
1038 InitGeneric (CT ct)
1039 {
1040     NMH_UNUSED (ct);
1041
1042     return OK;          /* not much to do here */
1043 }
1044
1045
1046 /*
1047  * TEXT
1048  */
1049
1050 static int
1051 InitText (CT ct)
1052 {
1053     char buffer[BUFSIZ];
1054     char *chset = NULL;
1055     char **ap, **ep, *cp;
1056     struct k2v *kv;
1057     struct text *t;
1058     CI ci = &ct->c_ctinfo;
1059
1060     /* check for missing subtype */
1061     if (!*ci->ci_subtype)
1062         ci->ci_subtype = add ("plain", ci->ci_subtype);
1063
1064     /* match subtype */
1065     for (kv = SubText; kv->kv_key; kv++)
1066         if (!mh_strcasecmp (ci->ci_subtype, kv->kv_key))
1067             break;
1068     ct->c_subtype = kv->kv_value;
1069
1070     /* allocate text character set structure */
1071     if ((t = (struct text *) calloc (1, sizeof(*t))) == NULL)
1072         adios (NULL, "out of memory");
1073     ct->c_ctparams = (void *) t;
1074
1075     /* scan for charset parameter */
1076     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
1077         if (!mh_strcasecmp (*ap, "charset"))
1078             break;
1079
1080     /* check if content specified a character set */
1081     if (*ap) {
1082         /* match character set or set to CHARSET_UNKNOWN */
1083         for (kv = Charset; kv->kv_key; kv++) {
1084             if (!mh_strcasecmp (*ep, kv->kv_key)) {
1085                 chset = *ep;
1086                 break;
1087             }
1088         }
1089         t->tx_charset = kv->kv_value;
1090     } else {
1091         t->tx_charset = CHARSET_UNSPECIFIED;
1092     }
1093
1094     /*
1095      * If we can not handle character set natively,
1096      * then check profile for string to modify the
1097      * terminal or display method.
1098      *
1099      * termproc is for mhshow, though mhlist -debug prints it, too.
1100      */
1101     if (chset != NULL && !check_charset (chset, strlen (chset))) {
1102         snprintf (buffer, sizeof(buffer), "%s-charset-%s", invo_name, chset);
1103         if ((cp = context_find (buffer)))
1104             ct->c_termproc = getcpy (cp);
1105     }
1106
1107     return OK;
1108 }
1109
1110
1111 /*
1112  * MULTIPART
1113  */
1114
1115 static int
1116 InitMultiPart (CT ct)
1117 {
1118     int inout;
1119     long last, pos;
1120     unsigned char *cp, *dp;
1121     char **ap, **ep;
1122     char *bp, buffer[BUFSIZ];
1123     struct multipart *m;
1124     struct k2v *kv;
1125     struct part *part, **next;
1126     CI ci = &ct->c_ctinfo;
1127     CT p;
1128     FILE *fp;
1129
1130     /*
1131      * The encoding for multipart messages must be either
1132      * 7bit, 8bit, or binary (per RFC2045).
1133      */
1134     if (ct->c_encoding != CE_7BIT && ct->c_encoding != CE_8BIT
1135         && ct->c_encoding != CE_BINARY) {
1136         admonish (NULL,
1137                   "\"%s/%s\" type in message %s must be encoded in 7bit, 8bit, or binary",
1138                   ci->ci_type, ci->ci_subtype, ct->c_file);
1139         return NOTOK;
1140     }
1141
1142     /* match subtype */
1143     for (kv = SubMultiPart; kv->kv_key; kv++)
1144         if (!mh_strcasecmp (ci->ci_subtype, kv->kv_key))
1145             break;
1146     ct->c_subtype = kv->kv_value;
1147
1148     /*
1149      * Check for "boundary" parameter, which is
1150      * required for multipart messages.
1151      */
1152     bp = 0;
1153     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1154         if (!mh_strcasecmp (*ap, "boundary")) {
1155             bp = *ep;
1156             break;
1157         }
1158     }
1159
1160     /* complain if boundary parameter is missing */
1161     if (!*ap) {
1162         advise (NULL,
1163                 "a \"boundary\" parameter is mandatory for \"%s/%s\" type in message %s's %s: field",
1164                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1165         return NOTOK;
1166     }
1167
1168     /* allocate primary structure for multipart info */
1169     if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
1170         adios (NULL, "out of memory");
1171     ct->c_ctparams = (void *) m;
1172
1173     /* check if boundary parameter contains only whitespace characters */
1174     for (cp = bp; isspace (*cp); cp++)
1175         continue;
1176     if (!*cp) {
1177         advise (NULL, "invalid \"boundary\" parameter for \"%s/%s\" type in message %s's %s: field",
1178                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1179         return NOTOK;
1180     }
1181
1182     /* remove trailing whitespace from boundary parameter */
1183     for (cp = bp, dp = cp + strlen (cp) - 1; dp > cp; dp--)
1184         if (!isspace (*dp))
1185             break;
1186     *++dp = '\0';
1187
1188     /* record boundary separators */
1189     m->mp_start = concat (bp, "\n", NULL);
1190     m->mp_stop = concat (bp, "--\n", NULL);
1191
1192     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1193         advise (ct->c_file, "unable to open for reading");
1194         return NOTOK;
1195     }
1196
1197     fseek (fp = ct->c_fp, pos = ct->c_begin, SEEK_SET);
1198     last = ct->c_end;
1199     next = &m->mp_parts;
1200     part = NULL;
1201     inout = 1;
1202
1203     while (fgets (buffer, sizeof(buffer) - 1, fp)) {
1204         if (pos > last)
1205             break;
1206
1207         pos += strlen (buffer);
1208         if (buffer[0] != '-' || buffer[1] != '-')
1209             continue;
1210         if (inout) {
1211             if (strcmp (buffer + 2, m->mp_start))
1212                 continue;
1213 next_part:
1214             if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
1215                 adios (NULL, "out of memory");
1216             *next = part;
1217             next = &part->mp_next;
1218
1219             if (!(p = get_content (fp, ct->c_file,
1220                         ct->c_subtype == MULTI_DIGEST ? -1 : 0))) {
1221                 ct->c_fp = NULL;
1222                 return NOTOK;
1223             }
1224             p->c_fp = NULL;
1225             part->mp_part = p;
1226             pos = p->c_begin;
1227             fseek (fp, pos, SEEK_SET);
1228             inout = 0;
1229         } else {
1230             if (strcmp (buffer + 2, m->mp_start) == 0) {
1231                 inout = 1;
1232 end_part:
1233                 p = part->mp_part;
1234                 p->c_end = ftell(fp) - (strlen(buffer) + 1);
1235                 if (p->c_end < p->c_begin)
1236                     p->c_begin = p->c_end;
1237                 if (inout)
1238                     goto next_part;
1239                 goto last_part;
1240             } else {
1241                 if (strcmp (buffer + 2, m->mp_stop) == 0)
1242                     goto end_part;
1243             }
1244         }
1245     }
1246
1247     advise (NULL, "bogus multipart content in message %s", ct->c_file);
1248     if (!inout && part) {
1249         p = part->mp_part;
1250         p->c_end = ct->c_end;
1251
1252         if (p->c_begin >= p->c_end) {
1253             for (next = &m->mp_parts; *next != part;
1254                      next = &((*next)->mp_next))
1255                 continue;
1256             *next = NULL;
1257             free_content (p);
1258             free ((char *) part);
1259         }
1260     }
1261
1262 last_part:
1263     /* reverse the order of the parts for multipart/alternative */
1264     if (ct->c_subtype == MULTI_ALTERNATE)
1265         reverse_parts (ct);
1266
1267     /*
1268      * label all subparts with part number, and
1269      * then initialize the content of the subpart.
1270      */
1271     {
1272         int partnum;
1273         char *pp;
1274         char partnam[BUFSIZ];
1275
1276         if (ct->c_partno) {
1277             snprintf (partnam, sizeof(partnam), "%s.", ct->c_partno);
1278             pp = partnam + strlen (partnam);
1279         } else {
1280             pp = partnam;
1281         }
1282
1283         for (part = m->mp_parts, partnum = 1; part;
1284                  part = part->mp_next, partnum++) {
1285             p = part->mp_part;
1286
1287             sprintf (pp, "%d", partnum);
1288             p->c_partno = add (partnam, NULL);
1289
1290             /* initialize the content of the subparts */
1291             if (p->c_ctinitfnx && (*p->c_ctinitfnx) (p) == NOTOK) {
1292                 fclose (ct->c_fp);
1293                 ct->c_fp = NULL;
1294                 return NOTOK;
1295             }
1296         }
1297     }
1298
1299     fclose (ct->c_fp);
1300     ct->c_fp = NULL;
1301     return OK;
1302 }
1303
1304
1305 /*
1306  * reverse the order of the parts of a multipart
1307  */
1308
1309 static void
1310 reverse_parts (CT ct)
1311 {
1312     int i;
1313     struct multipart *m;
1314     struct part **base, **bmp, **next, *part;
1315
1316     m = (struct multipart *) ct->c_ctparams;
1317
1318     /* if only one part, just return */
1319     if (!m->mp_parts || !m->mp_parts->mp_next)
1320         return;
1321
1322     /* count number of parts */
1323     i = 0;
1324     for (part = m->mp_parts; part; part = part->mp_next)
1325         i++;
1326
1327     /* allocate array of pointers to the parts */
1328     if (!(base = (struct part **) calloc ((size_t) (i + 1), sizeof(*base))))
1329         adios (NULL, "out of memory");
1330     bmp = base;
1331
1332     /* point at all the parts */
1333     for (part = m->mp_parts; part; part = part->mp_next)
1334         *bmp++ = part;
1335     *bmp = NULL;
1336
1337     /* reverse the order of the parts */
1338     next = &m->mp_parts;
1339     for (bmp--; bmp >= base; bmp--) {
1340         part = *bmp;
1341         *next = part;
1342         next = &part->mp_next;
1343     }
1344     *next = NULL;
1345
1346     /* free array of pointers */
1347     free ((char *) base);
1348 }
1349
1350
1351 /*
1352  * MESSAGE
1353  */
1354
1355 static int
1356 InitMessage (CT ct)
1357 {
1358     struct k2v *kv;
1359     CI ci = &ct->c_ctinfo;
1360
1361     if ((ct->c_encoding != CE_7BIT) && (ct->c_encoding != CE_8BIT)) {
1362         admonish (NULL,
1363                   "\"%s/%s\" type in message %s should be encoded in 7bit or 8bit",
1364                   ci->ci_type, ci->ci_subtype, ct->c_file);
1365         return NOTOK;
1366     }
1367
1368     /* check for missing subtype */
1369     if (!*ci->ci_subtype)
1370         ci->ci_subtype = add ("rfc822", ci->ci_subtype);
1371
1372     /* match subtype */
1373     for (kv = SubMessage; kv->kv_key; kv++)
1374         if (!mh_strcasecmp (ci->ci_subtype, kv->kv_key))
1375             break;
1376     ct->c_subtype = kv->kv_value;
1377
1378     switch (ct->c_subtype) {
1379         case MESSAGE_RFC822:
1380             break;
1381
1382         case MESSAGE_PARTIAL:
1383             {
1384                 char **ap, **ep;
1385                 struct partial *p;
1386
1387                 if ((p = (struct partial *) calloc (1, sizeof(*p))) == NULL)
1388                     adios (NULL, "out of memory");
1389                 ct->c_ctparams = (void *) p;
1390
1391                 /* scan for parameters "id", "number", and "total" */
1392                 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1393                     if (!mh_strcasecmp (*ap, "id")) {
1394                         p->pm_partid = add (*ep, NULL);
1395                         continue;
1396                     }
1397                     if (!mh_strcasecmp (*ap, "number")) {
1398                         if (sscanf (*ep, "%d", &p->pm_partno) != 1
1399                                 || p->pm_partno < 1) {
1400 invalid_param:
1401                             advise (NULL,
1402                                     "invalid %s parameter for \"%s/%s\" type in message %s's %s field",
1403                                     *ap, ci->ci_type, ci->ci_subtype,
1404                                     ct->c_file, TYPE_FIELD);
1405                             return NOTOK;
1406                         }
1407                         continue;
1408                     }
1409                     if (!mh_strcasecmp (*ap, "total")) {
1410                         if (sscanf (*ep, "%d", &p->pm_maxno) != 1
1411                                 || p->pm_maxno < 1)
1412                             goto invalid_param;
1413                         continue;
1414                     }
1415                 }
1416
1417                 if (!p->pm_partid
1418                         || !p->pm_partno
1419                         || (p->pm_maxno && p->pm_partno > p->pm_maxno)) {
1420                     advise (NULL,
1421                             "invalid parameters for \"%s/%s\" type in message %s's %s field",
1422                             ci->ci_type, ci->ci_subtype,
1423                             ct->c_file, TYPE_FIELD);
1424                     return NOTOK;
1425                 }
1426             }
1427             break;
1428
1429         case MESSAGE_EXTERNAL:
1430             {
1431                 int exresult;
1432                 struct exbody *e;
1433                 CT p;
1434                 FILE *fp;
1435
1436                 if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
1437                     adios (NULL, "out of memory");
1438                 ct->c_ctparams = (void *) e;
1439
1440                 if (!ct->c_fp
1441                         && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1442                     advise (ct->c_file, "unable to open for reading");
1443                     return NOTOK;
1444                 }
1445
1446                 fseek (fp = ct->c_fp, ct->c_begin, SEEK_SET);
1447
1448                 if (!(p = get_content (fp, ct->c_file, 0))) {
1449                     ct->c_fp = NULL;
1450                     return NOTOK;
1451                 }
1452
1453                 e->eb_parent = ct;
1454                 e->eb_content = p;
1455                 p->c_ctexbody = e;
1456                 if ((exresult = params_external (ct, 0)) != NOTOK
1457                         && p->c_ceopenfnx == openMail) {
1458                     int cc, size;
1459                     char *bp;
1460
1461                     if ((size = ct->c_end - p->c_begin) <= 0) {
1462                         if (!e->eb_subject)
1463                             content_error (NULL, ct,
1464                                            "empty body for access-type=mail-server");
1465                         goto no_body;
1466                     }
1467
1468                     e->eb_body = bp = mh_xmalloc ((unsigned) size);
1469                     fseek (p->c_fp, p->c_begin, SEEK_SET);
1470                     while (size > 0)
1471                         switch (cc = fread (bp, sizeof(*bp), size, p->c_fp)) {
1472                             case NOTOK:
1473                                 adios ("failed", "fread");
1474
1475                             case OK:
1476                                 adios (NULL, "unexpected EOF from fread");
1477
1478                             default:
1479                                 bp += cc, size -= cc;
1480                                 break;
1481                         }
1482                     *bp = 0;
1483                 }
1484 no_body:
1485                 p->c_fp = NULL;
1486                 p->c_end = p->c_begin;
1487
1488                 fclose (ct->c_fp);
1489                 ct->c_fp = NULL;
1490
1491                 if (exresult == NOTOK)
1492                     return NOTOK;
1493                 if (e->eb_flags == NOTOK)
1494                     return OK;
1495
1496                 switch (p->c_type) {
1497                     case CT_MULTIPART:
1498                         break;
1499
1500                     case CT_MESSAGE:
1501                         if (p->c_subtype != MESSAGE_RFC822)
1502                             break;
1503                         /* else fall... */
1504                     default:
1505                         e->eb_partno = ct->c_partno;
1506                         if (p->c_ctinitfnx)
1507                             (*p->c_ctinitfnx) (p);
1508                         break;
1509                 }
1510             }
1511             break;
1512
1513         default:
1514             break;
1515     }
1516
1517     return OK;
1518 }
1519
1520
1521 int
1522 params_external (CT ct, int composing)
1523 {
1524     char **ap, **ep;
1525     struct exbody *e = (struct exbody *) ct->c_ctparams;
1526     CI ci = &ct->c_ctinfo;
1527
1528     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1529         if (!mh_strcasecmp (*ap, "access-type")) {
1530             struct str2init *s2i;
1531             CT p = e->eb_content;
1532
1533             for (s2i = str2methods; s2i->si_key; s2i++)
1534                 if (!mh_strcasecmp (*ep, s2i->si_key))
1535                     break;
1536             if (!s2i->si_key) {
1537                 e->eb_access = *ep;
1538                 e->eb_flags = NOTOK;
1539                 p->c_encoding = CE_EXTERNAL;
1540                 continue;
1541             }
1542             e->eb_access = s2i->si_key;
1543             e->eb_flags = s2i->si_val;
1544             p->c_encoding = CE_EXTERNAL;
1545
1546             /* Call the Init function for this external type */
1547             if ((*s2i->si_init)(p) == NOTOK)
1548                 return NOTOK;
1549             continue;
1550         }
1551         if (!mh_strcasecmp (*ap, "name")) {
1552             e->eb_name = *ep;
1553             continue;
1554         }
1555         if (!mh_strcasecmp (*ap, "permission")) {
1556             e->eb_permission = *ep;
1557             continue;
1558         }
1559         if (!mh_strcasecmp (*ap, "site")) {
1560             e->eb_site = *ep;
1561             continue;
1562         }
1563         if (!mh_strcasecmp (*ap, "directory")) {
1564             e->eb_dir = *ep;
1565             continue;
1566         }
1567         if (!mh_strcasecmp (*ap, "mode")) {
1568             e->eb_mode = *ep;
1569             continue;
1570         }
1571         if (!mh_strcasecmp (*ap, "size")) {
1572             sscanf (*ep, "%lu", &e->eb_size);
1573             continue;
1574         }
1575         if (!mh_strcasecmp (*ap, "server")) {
1576             e->eb_server = *ep;
1577             continue;
1578         }
1579         if (!mh_strcasecmp (*ap, "subject")) {
1580             e->eb_subject = *ep;
1581             continue;
1582         }
1583         if (composing && !mh_strcasecmp (*ap, "body")) {
1584             e->eb_body = getcpy (*ep);
1585             continue;
1586         }
1587     }
1588
1589     if (!e->eb_access) {
1590         advise (NULL,
1591                 "invalid parameters for \"%s/%s\" type in message %s's %s field",
1592                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1593         return NOTOK;
1594     }
1595
1596     return OK;
1597 }
1598
1599
1600 /*
1601  * APPLICATION
1602  */
1603
1604 static int
1605 InitApplication (CT ct)
1606 {
1607     struct k2v *kv;
1608     CI ci = &ct->c_ctinfo;
1609
1610     /* match subtype */
1611     for (kv = SubApplication; kv->kv_key; kv++)
1612         if (!mh_strcasecmp (ci->ci_subtype, kv->kv_key))
1613             break;
1614     ct->c_subtype = kv->kv_value;
1615
1616     return OK;
1617 }
1618
1619
1620 /*
1621  * TRANSFER ENCODINGS
1622  */
1623
1624 static int
1625 init_encoding (CT ct, OpenCEFunc openfnx)
1626 {
1627     CE ce;
1628
1629     if ((ce = (CE) calloc (1, sizeof(*ce))) == NULL)
1630         adios (NULL, "out of memory");
1631
1632     ct->c_cefile     = ce;
1633     ct->c_ceopenfnx  = openfnx;
1634     ct->c_ceclosefnx = close_encoding;
1635     ct->c_cesizefnx  = size_encoding;
1636
1637     return OK;
1638 }
1639
1640
1641 void
1642 close_encoding (CT ct)
1643 {
1644     CE ce;
1645
1646     if (!(ce = ct->c_cefile))
1647         return;
1648
1649     if (ce->ce_fp) {
1650         fclose (ce->ce_fp);
1651         ce->ce_fp = NULL;
1652     }
1653 }
1654
1655
1656 static unsigned long
1657 size_encoding (CT ct)
1658 {
1659     int fd;
1660     unsigned long size;
1661     char *file;
1662     CE ce;
1663     struct stat st;
1664
1665     if (!(ce = ct->c_cefile))
1666         return (ct->c_end - ct->c_begin);
1667
1668     if (ce->ce_fp && fstat (fileno (ce->ce_fp), &st) != NOTOK)
1669         return (long) st.st_size;
1670
1671     if (ce->ce_file) {
1672         if (stat (ce->ce_file, &st) != NOTOK)
1673             return (long) st.st_size;
1674         else
1675             return 0L;
1676     }
1677
1678     if (ct->c_encoding == CE_EXTERNAL)
1679         return (ct->c_end - ct->c_begin);
1680
1681     file = NULL;
1682     if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
1683         return (ct->c_end - ct->c_begin);
1684
1685     if (fstat (fd, &st) != NOTOK)
1686         size = (long) st.st_size;
1687     else
1688         size = 0L;
1689
1690     (*ct->c_ceclosefnx) (ct);
1691     return size;
1692 }
1693
1694
1695 /*
1696  * BASE64
1697  */
1698
1699 static unsigned char b642nib[0x80] = {
1700     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1701     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1702     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1703     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1704     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1705     0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
1706     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
1707     0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1708     0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
1709     0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
1710     0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
1711     0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
1712     0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1713     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
1714     0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
1715     0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
1716 };
1717
1718
1719 static int
1720 InitBase64 (CT ct)
1721 {
1722     return init_encoding (ct, openBase64);
1723 }
1724
1725
1726 static int
1727 openBase64 (CT ct, char **file)
1728 {
1729     int bitno, cc, digested;
1730     int fd, len, skip, own_ct_fp = 0;
1731     unsigned long bits;
1732     unsigned char value, *b, *b1, *b2, *b3;
1733     unsigned char *cp, *ep;
1734     char buffer[BUFSIZ];
1735     /* sbeck -- handle suffixes */
1736     CI ci;
1737     CE ce;
1738     MD5_CTX mdContext;
1739
1740     b  = (unsigned char *) &bits;
1741     b1 = &b[endian > 0 ? 1 : 2];
1742     b2 = &b[endian > 0 ? 2 : 1];
1743     b3 = &b[endian > 0 ? 3 : 0];
1744
1745     ce = ct->c_cefile;
1746     if (ce->ce_fp) {
1747         fseek (ce->ce_fp, 0L, SEEK_SET);
1748         goto ready_to_go;
1749     }
1750
1751     if (ce->ce_file) {
1752         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1753             content_error (ce->ce_file, ct, "unable to fopen for reading");
1754             return NOTOK;
1755         }
1756         goto ready_to_go;
1757     }
1758
1759     if (*file == NULL) {
1760         ce->ce_file = add (m_mktemp(tmp, NULL, NULL), NULL);
1761         ce->ce_unlink = 1;
1762     } else {
1763         ce->ce_file = add (*file, NULL);
1764         ce->ce_unlink = 0;
1765     }
1766
1767     /* sbeck@cise.ufl.edu -- handle suffixes */
1768     ci = &ct->c_ctinfo;
1769     snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
1770               invo_name, ci->ci_type, ci->ci_subtype);
1771     cp = context_find (buffer);
1772     if (cp == NULL || *cp == '\0') {
1773         snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
1774                   ci->ci_type);
1775         cp = context_find (buffer);
1776     }
1777     if (cp != NULL && *cp != '\0') {
1778         if (ce->ce_unlink) {
1779             // Temporary file already exists, so we rename to
1780             // version with extension.
1781             char *file_org = strdup(ce->ce_file);
1782             ce->ce_file = add (cp, ce->ce_file);
1783             if (rename(file_org, ce->ce_file)) {
1784                 adios (ce->ce_file, "unable to rename %s to ", file_org);
1785             }
1786             free(file_org);
1787
1788         } else {
1789             ce->ce_file = add (cp, ce->ce_file);
1790         }
1791     }
1792
1793     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1794         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1795         return NOTOK;
1796     }
1797
1798     if ((len = ct->c_end - ct->c_begin) < 0)
1799         adios (NULL, "internal error(1)");
1800
1801     if (! ct->c_fp) {
1802         if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1803             content_error (ct->c_file, ct, "unable to open for reading");
1804             return NOTOK;
1805         }
1806         own_ct_fp = 1;
1807     }
1808
1809     if ((digested = ct->c_digested))
1810         MD5Init (&mdContext);
1811
1812     bitno = 18;
1813     bits = 0L;
1814     skip = 0;
1815
1816     lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
1817     while (len > 0) {
1818         switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
1819         case NOTOK:
1820             content_error (ct->c_file, ct, "error reading from");
1821             goto clean_up;
1822
1823         case OK:
1824             content_error (NULL, ct, "premature eof");
1825             goto clean_up;
1826
1827         default:
1828             if (cc > len)
1829                 cc = len;
1830             len -= cc;
1831
1832             for (ep = (cp = buffer) + cc; cp < ep; cp++) {
1833                 switch (*cp) {
1834                 default:
1835                     if (isspace (*cp))
1836                         break;
1837                     if (skip || (*cp & 0x80)
1838                         || (value = b642nib[*cp & 0x7f]) > 0x3f) {
1839                         if (debugsw) {
1840                             fprintf (stderr, "*cp=0x%x pos=%ld skip=%d\n",
1841                                 *cp,
1842                                 (long) (lseek (fd, (off_t) 0, SEEK_CUR) - (ep - cp)),
1843                                 skip);
1844                         }
1845                         content_error (NULL, ct,
1846                                        "invalid BASE64 encoding -- continuing");
1847                         continue;
1848                     }
1849
1850                     bits |= value << bitno;
1851 test_end:
1852                     if ((bitno -= 6) < 0) {
1853                         putc ((char) *b1, ce->ce_fp);
1854                         if (digested)
1855                             MD5Update (&mdContext, b1, 1);
1856                         if (skip < 2) {
1857                             putc ((char) *b2, ce->ce_fp);
1858                             if (digested)
1859                                 MD5Update (&mdContext, b2, 1);
1860                             if (skip < 1) {
1861                                 putc ((char) *b3, ce->ce_fp);
1862                                 if (digested)
1863                                     MD5Update (&mdContext, b3, 1);
1864                             }
1865                         }
1866
1867                         if (ferror (ce->ce_fp)) {
1868                             content_error (ce->ce_file, ct,
1869                                            "error writing to");
1870                             goto clean_up;
1871                         }
1872                         bitno = 18, bits = 0L, skip = 0;
1873                     }
1874                     break;
1875
1876                 case '=':
1877                     if (++skip > 3)
1878                         goto self_delimiting;
1879                     goto test_end;
1880                 }
1881             }
1882         }
1883     }
1884
1885     if (bitno != 18) {
1886         if (debugsw)
1887             fprintf (stderr, "premature ending (bitno %d)\n", bitno);
1888
1889         content_error (NULL, ct, "invalid BASE64 encoding");
1890         goto clean_up;
1891     }
1892
1893 self_delimiting:
1894     fseek (ct->c_fp, 0L, SEEK_SET);
1895
1896     if (fflush (ce->ce_fp)) {
1897         content_error (ce->ce_file, ct, "error writing to");
1898         goto clean_up;
1899     }
1900
1901     if (digested) {
1902         unsigned char digest[16];
1903
1904         MD5Final (digest, &mdContext);
1905         if (memcmp((char *) digest, (char *) ct->c_digest,
1906                    sizeof(digest) / sizeof(digest[0])))
1907             content_error (NULL, ct,
1908                            "content integrity suspect (digest mismatch) -- continuing");
1909         else
1910             if (debugsw)
1911                 fprintf (stderr, "content integrity confirmed\n");
1912     }
1913
1914     fseek (ce->ce_fp, 0L, SEEK_SET);
1915
1916 ready_to_go:
1917     *file = ce->ce_file;
1918     if (own_ct_fp) {
1919       fclose (ct->c_fp);
1920       ct->c_fp = NULL;
1921     }
1922     return fileno (ce->ce_fp);
1923
1924 clean_up:
1925     if (own_ct_fp) {
1926       fclose (ct->c_fp);
1927       ct->c_fp = NULL;
1928     }
1929     free_encoding (ct, 0);
1930     return NOTOK;
1931 }
1932
1933
1934 /*
1935  * QUOTED PRINTABLE
1936  */
1937
1938 static char hex2nib[0x80] = {
1939     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1940     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1941     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1942     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1943     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1944     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1945     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1946     0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1947     0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
1948     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1949     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1950     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1951     0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
1952     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1953     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1954     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1955 };
1956
1957
1958 static int
1959 InitQuoted (CT ct)
1960 {
1961     return init_encoding (ct, openQuoted);
1962 }
1963
1964
1965 static int
1966 openQuoted (CT ct, char **file)
1967 {
1968     int cc, digested, len, quoted, own_ct_fp = 0;
1969     unsigned char *cp, *ep;
1970     char buffer[BUFSIZ];
1971     unsigned char mask;
1972     CE ce;
1973     /* sbeck -- handle suffixes */
1974     CI ci;
1975     MD5_CTX mdContext;
1976
1977     ce = ct->c_cefile;
1978     if (ce->ce_fp) {
1979         fseek (ce->ce_fp, 0L, SEEK_SET);
1980         goto ready_to_go;
1981     }
1982
1983     if (ce->ce_file) {
1984         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1985             content_error (ce->ce_file, ct, "unable to fopen for reading");
1986             return NOTOK;
1987         }
1988         goto ready_to_go;
1989     }
1990
1991     if (*file == NULL) {
1992         ce->ce_file = add (m_mktemp(tmp, NULL, NULL), NULL);
1993         ce->ce_unlink = 1;
1994     } else {
1995         ce->ce_file = add (*file, NULL);
1996         ce->ce_unlink = 0;
1997     }
1998
1999     /* sbeck@cise.ufl.edu -- handle suffixes */
2000     ci = &ct->c_ctinfo;
2001     snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
2002               invo_name, ci->ci_type, ci->ci_subtype);
2003     cp = context_find (buffer);
2004     if (cp == NULL || *cp == '\0') {
2005         snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
2006                   ci->ci_type);
2007         cp = context_find (buffer);
2008     }
2009     if (cp != NULL && *cp != '\0') {
2010         if (ce->ce_unlink) {
2011             // Temporary file already exists, so we rename to
2012             // version with extension.
2013             char *file_org = strdup(ce->ce_file);
2014             ce->ce_file = add (cp, ce->ce_file);
2015             if (rename(file_org, ce->ce_file)) {
2016                 adios (ce->ce_file, "unable to rename %s to ", file_org);
2017             }
2018             free(file_org);
2019
2020         } else {
2021             ce->ce_file = add (cp, ce->ce_file);
2022         }
2023     }
2024
2025     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2026         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2027         return NOTOK;
2028     }
2029
2030     if ((len = ct->c_end - ct->c_begin) < 0)
2031         adios (NULL, "internal error(2)");
2032
2033     if (! ct->c_fp) {
2034         if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2035             content_error (ct->c_file, ct, "unable to open for reading");
2036             return NOTOK;
2037         }
2038         own_ct_fp = 1;
2039     }
2040
2041     if ((digested = ct->c_digested))
2042         MD5Init (&mdContext);
2043
2044     quoted = 0;
2045 #ifdef lint
2046     mask = 0;
2047 #endif
2048
2049     fseek (ct->c_fp, ct->c_begin, SEEK_SET);
2050     while (len > 0) {
2051         if (fgets (buffer, sizeof(buffer) - 1, ct->c_fp) == NULL) {
2052             content_error (NULL, ct, "premature eof");
2053             goto clean_up;
2054         }
2055
2056         if ((cc = strlen (buffer)) > len)
2057             cc = len;
2058         len -= cc;
2059
2060         for (ep = (cp = buffer) + cc - 1; cp <= ep; ep--)
2061             if (!isspace (*ep))
2062                 break;
2063         *++ep = '\n', ep++;
2064
2065         for (; cp < ep; cp++) {
2066             if (quoted > 0) {
2067                 /* in an escape sequence */
2068                 if (quoted == 1) {
2069                     /* at byte 1 of an escape sequence */
2070                     mask = hex2nib[*cp & 0x7f];
2071                     /* next is byte 2 */
2072                     quoted = 2;
2073                 } else {
2074                     /* at byte 2 of an escape sequence */
2075                     mask <<= 4;
2076                     mask |= hex2nib[*cp & 0x7f];
2077                     putc (mask, ce->ce_fp);
2078                     if (digested)
2079                         MD5Update (&mdContext, &mask, 1);
2080                     if (ferror (ce->ce_fp)) {
2081                         content_error (ce->ce_file, ct, "error writing to");
2082                         goto clean_up;
2083                     }
2084                     /* finished escape sequence; next may be literal or a new
2085                      * escape sequence */
2086                     quoted = 0;
2087                 }
2088                 /* on to next byte */
2089                 continue;
2090             }
2091
2092             /* not in an escape sequence */
2093             if (*cp == '=') {
2094                 /* starting an escape sequence, or invalid '='? */
2095                 if (cp + 1 < ep && cp[1] == '\n') {
2096                     /* "=\n" soft line break, eat the \n */
2097                     cp++;
2098                     continue;
2099                 }
2100                 if (cp + 1 >= ep || cp + 2 >= ep) {
2101                     /* We don't have 2 bytes left, so this is an invalid
2102                      * escape sequence; just show the raw bytes (below). */
2103                 } else if (isxdigit (cp[1]) && isxdigit (cp[2])) {
2104                     /* Next 2 bytes are hex digits, making this a valid escape
2105                      * sequence; let's decode it (above). */
2106                     quoted = 1;
2107                     continue;
2108                 } else {
2109                     /* One or both of the next 2 is out of range, making this
2110                      * an invalid escape sequence; just show the raw bytes
2111                      * (below). */
2112                 }
2113             }
2114
2115             /* Just show the raw byte. */
2116             putc (*cp, ce->ce_fp);
2117             if (digested) {
2118                 if (*cp == '\n') {
2119                     MD5Update (&mdContext, (unsigned char *) "\r\n",2);
2120                 } else {
2121                     MD5Update (&mdContext, (unsigned char *) cp, 1);
2122                 }
2123             }
2124             if (ferror (ce->ce_fp)) {
2125                 content_error (ce->ce_file, ct, "error writing to");
2126                 goto clean_up;
2127             }
2128         }
2129     }
2130     if (quoted) {
2131         content_error (NULL, ct,
2132                        "invalid QUOTED-PRINTABLE encoding -- end-of-content while still quoting");
2133         goto clean_up;
2134     }
2135
2136     fseek (ct->c_fp, 0L, SEEK_SET);
2137
2138     if (fflush (ce->ce_fp)) {
2139         content_error (ce->ce_file, ct, "error writing to");
2140         goto clean_up;
2141     }
2142
2143     if (digested) {
2144         unsigned char digest[16];
2145
2146         MD5Final (digest, &mdContext);
2147         if (memcmp((char *) digest, (char *) ct->c_digest,
2148                    sizeof(digest) / sizeof(digest[0])))
2149             content_error (NULL, ct,
2150                            "content integrity suspect (digest mismatch) -- continuing");
2151         else
2152             if (debugsw)
2153                 fprintf (stderr, "content integrity confirmed\n");
2154     }
2155
2156     fseek (ce->ce_fp, 0L, SEEK_SET);
2157
2158 ready_to_go:
2159     *file = ce->ce_file;
2160     if (own_ct_fp) {
2161       fclose (ct->c_fp);
2162       ct->c_fp = NULL;
2163     }
2164     return fileno (ce->ce_fp);
2165
2166 clean_up:
2167     free_encoding (ct, 0);
2168     if (own_ct_fp) {
2169       fclose (ct->c_fp);
2170       ct->c_fp = NULL;
2171     }
2172     return NOTOK;
2173 }
2174
2175
2176 /*
2177  * 7BIT
2178  */
2179
2180 static int
2181 Init7Bit (CT ct)
2182 {
2183     if (init_encoding (ct, open7Bit) == NOTOK)
2184         return NOTOK;
2185
2186     ct->c_cesizefnx = NULL;     /* no need to decode for real size */
2187     return OK;
2188 }
2189
2190
2191 int
2192 open7Bit (CT ct, char **file)
2193 {
2194     int cc, fd, len, own_ct_fp = 0;
2195     char buffer[BUFSIZ];
2196     /* sbeck -- handle suffixes */
2197     char *cp;
2198     CI ci;
2199     CE ce;
2200
2201     ce = ct->c_cefile;
2202     if (ce->ce_fp) {
2203         fseek (ce->ce_fp, 0L, SEEK_SET);
2204         goto ready_to_go;
2205     }
2206
2207     if (ce->ce_file) {
2208         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2209             content_error (ce->ce_file, ct, "unable to fopen for reading");
2210             return NOTOK;
2211         }
2212         goto ready_to_go;
2213     }
2214
2215     if (*file == NULL) {
2216         ce->ce_file = add (m_mktemp(tmp, NULL, NULL), NULL);
2217         ce->ce_unlink = 1;
2218     } else {
2219         ce->ce_file = add (*file, NULL);
2220         ce->ce_unlink = 0;
2221     }
2222
2223     /* sbeck@cise.ufl.edu -- handle suffixes */
2224     ci = &ct->c_ctinfo;
2225     snprintf (buffer, sizeof(buffer), "%s-suffix-%s/%s",
2226               invo_name, ci->ci_type, ci->ci_subtype);
2227     cp = context_find (buffer);
2228     if (cp == NULL || *cp == '\0') {
2229         snprintf (buffer, sizeof(buffer), "%s-suffix-%s", invo_name,
2230                   ci->ci_type);
2231         cp = context_find (buffer);
2232     }
2233     if (cp != NULL && *cp != '\0') {
2234         if (ce->ce_unlink) {
2235             // Temporary file already exists, so we rename to
2236             // version with extension.
2237             char *file_org = strdup(ce->ce_file);
2238             ce->ce_file = add (cp, ce->ce_file);
2239             if (rename(file_org, ce->ce_file)) {
2240                 adios (ce->ce_file, "unable to rename %s to ", file_org);
2241             }
2242             free(file_org);
2243
2244         } else {
2245             ce->ce_file = add (cp, ce->ce_file);
2246         }
2247     }
2248
2249     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2250         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2251         return NOTOK;
2252     }
2253
2254     if (ct->c_type == CT_MULTIPART) {
2255         char **ap, **ep;
2256         CI ci = &ct->c_ctinfo;
2257
2258         len = 0;
2259         fprintf (ce->ce_fp, "%s: %s/%s", TYPE_FIELD, ci->ci_type, ci->ci_subtype);
2260         len += strlen (TYPE_FIELD) + 2 + strlen (ci->ci_type)
2261             + 1 + strlen (ci->ci_subtype);
2262         for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
2263             putc (';', ce->ce_fp);
2264             len++;
2265
2266             snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
2267
2268             if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
2269                 fputs ("\n\t", ce->ce_fp);
2270                 len = 8;
2271             } else {
2272                 putc (' ', ce->ce_fp);
2273                 len++;
2274             }
2275             fprintf (ce->ce_fp, "%s", buffer);
2276             len += cc;
2277         }
2278
2279         if (ci->ci_comment) {
2280             if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
2281                 fputs ("\n\t", ce->ce_fp);
2282                 len = 8;
2283             }
2284             else {
2285                 putc (' ', ce->ce_fp);
2286                 len++;
2287             }
2288             fprintf (ce->ce_fp, "(%s)", ci->ci_comment);
2289             len += cc;
2290         }
2291         fprintf (ce->ce_fp, "\n");
2292         if (ct->c_id)
2293             fprintf (ce->ce_fp, "%s:%s", ID_FIELD, ct->c_id);
2294         if (ct->c_descr)
2295             fprintf (ce->ce_fp, "%s:%s", DESCR_FIELD, ct->c_descr);
2296         if (ct->c_dispo)
2297             fprintf (ce->ce_fp, "%s:%s", DISPO_FIELD, ct->c_dispo);
2298         fprintf (ce->ce_fp, "\n");
2299     }
2300
2301     if ((len = ct->c_end - ct->c_begin) < 0)
2302         adios (NULL, "internal error(3)");
2303
2304     if (! ct->c_fp) {
2305         if ((ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2306             content_error (ct->c_file, ct, "unable to open for reading");
2307             return NOTOK;
2308         }
2309         own_ct_fp = 1;
2310     }
2311
2312     lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
2313     while (len > 0)
2314         switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
2315         case NOTOK:
2316             content_error (ct->c_file, ct, "error reading from");
2317             goto clean_up;
2318
2319         case OK:
2320             content_error (NULL, ct, "premature eof");
2321             goto clean_up;
2322
2323         default:
2324             if (cc > len)
2325                 cc = len;
2326             len -= cc;
2327
2328             fwrite (buffer, sizeof(*buffer), cc, ce->ce_fp);
2329             if (ferror (ce->ce_fp)) {
2330                 content_error (ce->ce_file, ct, "error writing to");
2331                 goto clean_up;
2332             }
2333         }
2334
2335     fseek (ct->c_fp, 0L, SEEK_SET);
2336
2337     if (fflush (ce->ce_fp)) {
2338         content_error (ce->ce_file, ct, "error writing to");
2339         goto clean_up;
2340     }
2341
2342     fseek (ce->ce_fp, 0L, SEEK_SET);
2343
2344 ready_to_go:
2345     *file = ce->ce_file;
2346     if (own_ct_fp) {
2347       fclose (ct->c_fp);
2348       ct->c_fp = NULL;
2349     }
2350     return fileno (ce->ce_fp);
2351
2352 clean_up:
2353     free_encoding (ct, 0);
2354     if (own_ct_fp) {
2355       fclose (ct->c_fp);
2356       ct->c_fp = NULL;
2357     }
2358     return NOTOK;
2359 }
2360
2361
2362 /*
2363  * External
2364  */
2365
2366 static int
2367 openExternal (CT ct, CT cb, CE ce, char **file, int *fd)
2368 {
2369     char cachefile[BUFSIZ];
2370
2371     if (ce->ce_fp) {
2372         fseek (ce->ce_fp, 0L, SEEK_SET);
2373         goto ready_already;
2374     }
2375
2376     if (ce->ce_file) {
2377         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2378             content_error (ce->ce_file, ct, "unable to fopen for reading");
2379             return NOTOK;
2380         }
2381         goto ready_already;
2382     }
2383
2384     if (find_cache (ct, rcachesw, (int *) 0, cb->c_id,
2385                 cachefile, sizeof(cachefile)) != NOTOK) {
2386         if ((ce->ce_fp = fopen (cachefile, "r"))) {
2387             ce->ce_file = getcpy (cachefile);
2388             ce->ce_unlink = 0;
2389             goto ready_already;
2390         } else {
2391             admonish (cachefile, "unable to fopen for reading");
2392         }
2393     }
2394
2395     return OK;
2396
2397 ready_already:
2398     *file = ce->ce_file;
2399     *fd = fileno (ce->ce_fp);
2400     return DONE;
2401 }
2402
2403 /*
2404  * File
2405  */
2406
2407 static int
2408 InitFile (CT ct)
2409 {
2410     return init_encoding (ct, openFile);
2411 }
2412
2413
2414 static int
2415 openFile (CT ct, char **file)
2416 {
2417     int fd, cachetype;
2418     char cachefile[BUFSIZ];
2419     struct exbody *e = ct->c_ctexbody;
2420     CE ce = ct->c_cefile;
2421
2422     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2423         case NOTOK:
2424             return NOTOK;
2425
2426         case OK:
2427             break;
2428
2429         case DONE:
2430             return fd;
2431     }
2432
2433     if (!e->eb_name) {
2434         content_error (NULL, ct, "missing name parameter");
2435         return NOTOK;
2436     }
2437
2438     ce->ce_file = getcpy (e->eb_name);
2439     ce->ce_unlink = 0;
2440
2441     if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2442         content_error (ce->ce_file, ct, "unable to fopen for reading");
2443         return NOTOK;
2444     }
2445
2446     if ((!e->eb_permission || mh_strcasecmp (e->eb_permission, "read-write"))
2447             && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2448                 cachefile, sizeof(cachefile)) != NOTOK) {
2449         int mask;
2450         FILE *fp;
2451
2452         mask = umask (cachetype ? ~m_gmprot () : 0222);
2453         if ((fp = fopen (cachefile, "w"))) {
2454             int cc;
2455             char buffer[BUFSIZ];
2456             FILE *gp = ce->ce_fp;
2457
2458             fseek (gp, 0L, SEEK_SET);
2459
2460             while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2461                        > 0)
2462                 fwrite (buffer, sizeof(*buffer), cc, fp);
2463             fflush (fp);
2464
2465             if (ferror (gp)) {
2466                 admonish (ce->ce_file, "error reading");
2467                 unlink (cachefile);
2468             }
2469             else
2470                 if (ferror (fp)) {
2471                     admonish (cachefile, "error writing");
2472                     unlink (cachefile);
2473                 }
2474             fclose (fp);
2475         }
2476         umask (mask);
2477     }
2478
2479     fseek (ce->ce_fp, 0L, SEEK_SET);
2480     *file = ce->ce_file;
2481     return fileno (ce->ce_fp);
2482 }
2483
2484 /*
2485  * FTP
2486  */
2487
2488 static int
2489 InitFTP (CT ct)
2490 {
2491     return init_encoding (ct, openFTP);
2492 }
2493
2494
2495 static int
2496 openFTP (CT ct, char **file)
2497 {
2498     int cachetype, caching, fd;
2499     int len, buflen;
2500     char *bp, *ftp, *user, *pass;
2501     char buffer[BUFSIZ], cachefile[BUFSIZ];
2502     struct exbody *e;
2503     CE ce;
2504     static char *username = NULL;
2505     static char *password = NULL;
2506
2507     e  = ct->c_ctexbody;
2508     ce = ct->c_cefile;
2509
2510     if ((ftp = context_find (nmhaccessftp)) && !*ftp)
2511         ftp = NULL;
2512
2513     if (!ftp)
2514         return NOTOK;
2515
2516     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2517         case NOTOK:
2518             return NOTOK;
2519
2520         case OK:
2521             break;
2522
2523         case DONE:
2524             return fd;
2525     }
2526
2527     if (!e->eb_name || !e->eb_site) {
2528         content_error (NULL, ct, "missing %s parameter",
2529                        e->eb_name ? "site": "name");
2530         return NOTOK;
2531     }
2532
2533     if (xpid) {
2534         if (xpid < 0)
2535             xpid = -xpid;
2536         pidcheck (pidwait (xpid, NOTOK));
2537         xpid = 0;
2538     }
2539
2540     /* Get the buffer ready to go */
2541     bp = buffer;
2542     buflen = sizeof(buffer);
2543
2544     /*
2545      * Construct the query message for user
2546      */
2547     snprintf (bp, buflen, "Retrieve %s", e->eb_name);
2548     len = strlen (bp);
2549     bp += len;
2550     buflen -= len;
2551
2552     if (e->eb_partno) {
2553         snprintf (bp, buflen, " (content %s)", e->eb_partno);
2554         len = strlen (bp);
2555         bp += len;
2556         buflen -= len;
2557     }
2558
2559     snprintf (bp, buflen, "\n    using %sFTP from site %s",
2560                     e->eb_flags ? "anonymous " : "", e->eb_site);
2561     len = strlen (bp);
2562     bp += len;
2563     buflen -= len;
2564
2565     if (e->eb_size > 0) {
2566         snprintf (bp, buflen, " (%lu octets)", e->eb_size);
2567         len = strlen (bp);
2568         bp += len;
2569         buflen -= len;
2570     }
2571     snprintf (bp, buflen, "? ");
2572
2573     /*
2574      * Now, check the answer
2575      */
2576     if (!getanswer (buffer))
2577         return NOTOK;
2578
2579     if (e->eb_flags) {
2580         user = "anonymous";
2581         snprintf (buffer, sizeof(buffer), "%s@%s", getusername (),
2582                   LocalName (1));
2583         pass = buffer;
2584     } else {
2585         ruserpass (e->eb_site, &username, &password);
2586         user = username;
2587         pass = password;
2588     }
2589
2590     ce->ce_unlink = (*file == NULL);
2591     caching = 0;
2592     cachefile[0] = '\0';
2593     if ((!e->eb_permission || mh_strcasecmp (e->eb_permission, "read-write"))
2594             && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2595                 cachefile, sizeof(cachefile)) != NOTOK) {
2596         if (*file == NULL) {
2597             ce->ce_unlink = 0;
2598             caching = 1;
2599         }
2600     }
2601
2602     if (*file)
2603         ce->ce_file = add (*file, NULL);
2604     else if (caching)
2605         ce->ce_file = add (cachefile, NULL);
2606     else
2607         ce->ce_file = add (m_mktemp(tmp, NULL, NULL), NULL);
2608
2609     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2610         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2611         return NOTOK;
2612     }
2613
2614     {
2615         int child_id, i, vecp;
2616         char *vec[9];
2617
2618         vecp = 0;
2619         vec[vecp++] = r1bindex (ftp, '/');
2620         vec[vecp++] = e->eb_site;
2621         vec[vecp++] = user;
2622         vec[vecp++] = pass;
2623         vec[vecp++] = e->eb_dir;
2624         vec[vecp++] = e->eb_name;
2625         vec[vecp++] = ce->ce_file,
2626         vec[vecp++] = e->eb_mode && !mh_strcasecmp (e->eb_mode, "ascii")
2627                         ? "ascii" : "binary";
2628         vec[vecp] = NULL;
2629
2630         fflush (stdout);
2631
2632         for (i = 0; (child_id = vfork()) == NOTOK && i < 5; i++)
2633             sleep (5);
2634         switch (child_id) {
2635             case NOTOK:
2636                 adios ("fork", "unable to");
2637                 /* NOTREACHED */
2638
2639             case OK:
2640                 close (fileno (ce->ce_fp));
2641                 execvp (ftp, vec);
2642                 fprintf (stderr, "unable to exec ");
2643                 perror (ftp);
2644                 _exit (-1);
2645                 /* NOTREACHED */
2646
2647             default:
2648                 if (pidXwait (child_id, NULL)) {
2649                     username = password = NULL;
2650                     ce->ce_unlink = 1;
2651                     return NOTOK;
2652                 }
2653                 break;
2654         }
2655     }
2656
2657     if (cachefile[0]) {
2658         if (caching)
2659             chmod (cachefile, cachetype ? m_gmprot () : 0444);
2660         else {
2661             int mask;
2662             FILE *fp;
2663
2664             mask = umask (cachetype ? ~m_gmprot () : 0222);
2665             if ((fp = fopen (cachefile, "w"))) {
2666                 int cc;
2667                 FILE *gp = ce->ce_fp;
2668
2669                 fseek (gp, 0L, SEEK_SET);
2670
2671                 while ((cc= fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2672                            > 0)
2673                     fwrite (buffer, sizeof(*buffer), cc, fp);
2674                 fflush (fp);
2675
2676                 if (ferror (gp)) {
2677                     admonish (ce->ce_file, "error reading");
2678                     unlink (cachefile);
2679                 }
2680                 else
2681                     if (ferror (fp)) {
2682                         admonish (cachefile, "error writing");
2683                         unlink (cachefile);
2684                     }
2685                 fclose (fp);
2686             }
2687             umask (mask);
2688         }
2689     }
2690
2691     fseek (ce->ce_fp, 0L, SEEK_SET);
2692     *file = ce->ce_file;
2693     return fileno (ce->ce_fp);
2694 }
2695
2696
2697 /*
2698  * Mail
2699  */
2700
2701 static int
2702 InitMail (CT ct)
2703 {
2704     return init_encoding (ct, openMail);
2705 }
2706
2707
2708 static int
2709 openMail (CT ct, char **file)
2710 {
2711     int child_id, fd, i, vecp;
2712     int len, buflen;
2713     char *bp, buffer[BUFSIZ], *vec[7];
2714     struct exbody *e = ct->c_ctexbody;
2715     CE ce = ct->c_cefile;
2716
2717     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2718         case NOTOK:
2719             return NOTOK;
2720
2721         case OK:
2722             break;
2723
2724         case DONE:
2725             return fd;
2726     }
2727
2728     if (!e->eb_server) {
2729         content_error (NULL, ct, "missing server parameter");
2730         return NOTOK;
2731     }
2732
2733     if (xpid) {
2734         if (xpid < 0)
2735             xpid = -xpid;
2736         pidcheck (pidwait (xpid, NOTOK));
2737         xpid = 0;
2738     }
2739
2740     /* Get buffer ready to go */
2741     bp = buffer;
2742     buflen = sizeof(buffer);
2743
2744     /* Now, construct query message */
2745     snprintf (bp, buflen, "Retrieve content");
2746     len = strlen (bp);
2747     bp += len;
2748     buflen -= len;
2749
2750     if (e->eb_partno) {
2751         snprintf (bp, buflen, " %s", e->eb_partno);
2752         len = strlen (bp);
2753         bp += len;
2754         buflen -= len;
2755     }
2756
2757     snprintf (bp, buflen, " by asking %s\n\n%s\n? ",
2758                     e->eb_server,
2759                     e->eb_subject ? e->eb_subject : e->eb_body);
2760
2761     /* Now, check answer */
2762     if (!getanswer (buffer))
2763         return NOTOK;
2764
2765     vecp = 0;
2766     vec[vecp++] = r1bindex (mailproc, '/');
2767     vec[vecp++] = e->eb_server;
2768     vec[vecp++] = "-subject";
2769     vec[vecp++] = e->eb_subject ? e->eb_subject : "mail-server request";
2770     vec[vecp++] = "-body";
2771     vec[vecp++] = e->eb_body;
2772     vec[vecp] = NULL;
2773
2774     for (i = 0; (child_id = vfork()) == NOTOK && i < 5; i++)
2775         sleep (5);
2776     switch (child_id) {
2777         case NOTOK:
2778             advise ("fork", "unable to");
2779             return NOTOK;
2780
2781         case OK:
2782             execvp (mailproc, vec);
2783             fprintf (stderr, "unable to exec ");
2784             perror (mailproc);
2785             _exit (-1);
2786             /* NOTREACHED */
2787
2788         default:
2789             if (pidXwait (child_id, NULL) == OK)
2790                 advise (NULL, "request sent");
2791             break;
2792     }
2793
2794     if (*file == NULL) {
2795         ce->ce_file = add (m_mktemp(tmp, NULL, NULL), NULL);
2796         ce->ce_unlink = 1;
2797     } else {
2798         ce->ce_file = add (*file, NULL);
2799         ce->ce_unlink = 0;
2800     }
2801
2802     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2803         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2804         return NOTOK;
2805     }
2806
2807     /* showproc is for mhshow and mhstore, though mhlist -debug
2808      * prints it, too. */
2809     if (ct->c_showproc)
2810         free (ct->c_showproc);
2811     ct->c_showproc = add ("true", NULL);
2812
2813     fseek (ce->ce_fp, 0L, SEEK_SET);
2814     *file = ce->ce_file;
2815     return fileno (ce->ce_fp);
2816 }
2817
2818
2819 static int
2820 readDigest (CT ct, char *cp)
2821 {
2822     int bitno, skip;
2823     unsigned long bits;
2824     char *bp = cp;
2825     unsigned char *dp, value, *ep;
2826     unsigned char *b, *b1, *b2, *b3;
2827
2828     b  = (unsigned char *) &bits,
2829     b1 = &b[endian > 0 ? 1 : 2],
2830     b2 = &b[endian > 0 ? 2 : 1],
2831     b3 = &b[endian > 0 ? 3 : 0];
2832     bitno = 18;
2833     bits = 0L;
2834     skip = 0;
2835
2836     for (ep = (dp = ct->c_digest)
2837                  + sizeof(ct->c_digest) / sizeof(ct->c_digest[0]); *cp; cp++)
2838         switch (*cp) {
2839             default:
2840                 if (skip
2841                         || (*cp & 0x80)
2842                         || (value = b642nib[*cp & 0x7f]) > 0x3f) {
2843                     if (debugsw)
2844                         fprintf (stderr, "invalid BASE64 encoding\n");
2845                     return NOTOK;
2846                 }
2847
2848                 bits |= value << bitno;
2849 test_end:
2850                 if ((bitno -= 6) < 0) {
2851                     if (dp + (3 - skip) > ep)
2852                         goto invalid_digest;
2853                     *dp++ = *b1;
2854                     if (skip < 2) {
2855                         *dp++ = *b2;
2856                         if (skip < 1)
2857                             *dp++ = *b3;
2858                     }
2859                     bitno = 18;
2860                     bits = 0L;
2861                     skip = 0;
2862                 }
2863                 break;
2864
2865             case '=':
2866                 if (++skip > 3)
2867                     goto self_delimiting;
2868                 goto test_end;
2869         }
2870     if (bitno != 18) {
2871         if (debugsw)
2872             fprintf (stderr, "premature ending (bitno %d)\n", bitno);
2873
2874         return NOTOK;
2875     }
2876 self_delimiting:
2877     if (dp != ep) {
2878 invalid_digest:
2879         if (debugsw) {
2880             while (*cp)
2881                 cp++;
2882             fprintf (stderr, "invalid MD5 digest (got %d octets)\n",
2883                      (int)(cp - bp));
2884         }
2885
2886         return NOTOK;
2887     }
2888
2889     if (debugsw) {
2890         fprintf (stderr, "MD5 digest=");
2891         for (dp = ct->c_digest; dp < ep; dp++)
2892             fprintf (stderr, "%02x", *dp & 0xff);
2893         fprintf (stderr, "\n");
2894     }
2895
2896     return OK;
2897 }