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

   1
   2 /*
   3  * mhbuildsbr.c -- routines to expand/translate MIME composition files
   4  *
   5  * $Id$
   6  *
   7  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   8  * COPYRIGHT file in the root directory of the nmh distribution for
   9  * complete copyright information.
  10  */
  11
  12 /*
  13  * This code was originally part of mhn.c.  I split it into
  14  * a separate program (mhbuild.c) and then later split it
  15  * again (mhbuildsbr.c).  But the code still has some of
  16  * the mhn.c code in it.  This program needs additional
  17  * streamlining and removal of unneeded code.
  18  */
  19
  20 #include <h/mh.h>
  21 #include <fcntl.h>
  22 #include <h/signals.h>
  23 #include <h/md5.h>
  24 #include <errno.h>
  25 #include <signal.h>
  26 #include <h/mts.h>
  27 #include <h/tws.h>
  28 #include <h/mime.h>
  29 #include <h/mhparse.h>
  30
  31 #ifdef TIME_WITH_SYS_TIME
  32 # include <sys/time.h>
  33 # include <time.h>
  34 #else
  35 # ifdef TM_IN_SYS_TIME
  36 #  include <sys/time.h>
  37 # else
  38 #  include <time.h>
  39 # endif
  40 #endif
  41
  42 #ifdef HAVE_SYS_WAIT_H
  43 # include <sys/wait.h>
  44 #endif
  45
  46
  47 extern int debugsw;
  48 extern int verbosw;
  49
  50 extern int ebcdicsw;
  51 extern int listsw;
  52 extern int rfc934sw;
  53
  54 extern int endian;      /* mhmisc.c */
  55
  56 /* cache policies */
  57 extern int rcachesw;    /* mhcachesbr.c */
  58 extern int wcachesw;    /* mhcachesbr.c */
  59
  60 int checksw = 0;        /* Add Content-MD5 field */
  61
  62 /*
  63  * Directory to place tmp files.  This must
  64  * be set before these routines are called.
  65  */
  66 char *tmp;
  67
  68 pid_t xpid = 0;
  69
  70 static char prefix[] = "----- =_aaaaaaaaaa";
  71
  72 /*
  73  * Structure for mapping types to their internal flags
  74  */
  75 struct k2v {
  76     char *kv_key;
  77     int   kv_value;
  78 };
  79
  80 /*
  81  * Structures for TEXT messages
  82  */
  83 static struct k2v SubText[] = {
  84     { "plain",    TEXT_PLAIN },
  85     { "richtext", TEXT_RICHTEXT },  /* defined in RFC-1341    */
  86     { "enriched", TEXT_ENRICHED },  /* defined in RFC-1896    */
  87     { NULL,       TEXT_UNKNOWN }    /* this one must be last! */
  88 };
  89
  90 static struct k2v Charset[] = {
  91     { "us-ascii",   CHARSET_USASCII },
  92     { "iso-8859-1", CHARSET_LATIN },
  93     { NULL,         CHARSET_UNKNOWN }  /* this one must be last! */
  94 };
  95
  96 /*
  97  * Structures for MULTIPART messages
  98  */
  99 static struct k2v SubMultiPart[] = {
 100     { "mixed",       MULTI_MIXED },
 101     { "alternative", MULTI_ALTERNATE },
 102     { "digest",      MULTI_DIGEST },
 103     { "parallel",    MULTI_PARALLEL },
 104     { NULL,          MULTI_UNKNOWN }    /* this one must be last! */
 105 };
 106
 107 /*
 108  * Structures for MESSAGE messages
 109  */
 110 static struct k2v SubMessage[] = {
 111     { "rfc822",        MESSAGE_RFC822 },
 112     { "partial",       MESSAGE_PARTIAL },
 113     { "external-body", MESSAGE_EXTERNAL },
 114     { NULL,            MESSAGE_UNKNOWN }        /* this one must be last! */
 115 };
 116
 117 /*
 118  * Structure for APPLICATION messages
 119  */
 120 static struct k2v SubApplication[] = {
 121     { "octet-stream", APPLICATION_OCTETS },
 122     { "postscript",   APPLICATION_POSTSCRIPT },
 123     { NULL,           APPLICATION_UNKNOWN }     /* this one must be last! */
 124 };
 125
 126
 127 /* mhmisc.c */
 128 int make_intermediates (char *);
 129 void content_error (char *, CT, char *, ...);
 130
 131 /* mhcachesbr.c */
 132 int find_cache (CT, int, int *, char *, char *, int);
 133
 134 /* ftpsbr.c */
 135 int ftp_get (char *, char *, char *, char *, char *, char *, int, int);
 136
 137 /* mhfree.c */
 138 void free_content (CT);
 139 void free_ctinfo (CT);
 140 void free_encoding (CT, int);
 141
 142 /*
 143  * prototypes
 144  */
 145 CT build_mime (char *);
 146 int pidcheck (int);
 147
 148 /*
 149  * static prototypes
 150  */
 151 static CT get_content (FILE *, char *, int);
 152 static int add_header (CT, char *, char *);
 153 static int get_ctinfo (char *, CT, int);
 154 static int get_comment (CT, char **, int);
 155 static int InitGeneric (CT);
 156 static int InitText (CT);
 157 static int InitMultiPart (CT);
 158 static void reverse_parts (CT);
 159 static int InitMessage (CT);
 160 static int params_external (CT, int);
 161 static int InitApplication (CT);
 162 static int init_decoded_content (CT);
 163 static int init_encoding (CT, OpenCEFunc);
 164 static void close_encoding (CT);
 165 static unsigned long size_encoding (CT);
 166 static int InitBase64 (CT);
 167 static int openBase64 (CT, char **);
 168 static int InitQuoted (CT);
 169 static int openQuoted (CT, char **);
 170 static int Init7Bit (CT);
 171 static int open7Bit (CT, char **);
 172 static int openExternal (CT, CT, CE, char **, int *);
 173 static int InitFile (CT);
 174 static int openFile (CT, char **);
 175 static int InitFTP (CT);
 176 static int openFTP (CT, char **);
 177 static int InitMail (CT);
 178 static int openMail (CT, char **);
 179 static char *fgetstr (char *, int, FILE *);
 180 static int user_content (FILE *, char *, char *, CT *);
 181 static void set_id (CT, int);
 182 static int compose_content (CT);
 183 static int scan_content (CT);
 184 static int build_headers (CT);
 185 static char *calculate_digest (CT, int);
 186 static int readDigest (CT, char *);
 187
 188 /*
 189  * Structures for mapping (content) types to
 190  * the functions to handle them.
 191  */
 192 struct str2init {
 193     char *si_key;
 194     int   si_val;
 195     InitFunc si_init;
 196 };
 197
 198 static struct str2init str2cts[] = {
 199     { "application", CT_APPLICATION, InitApplication },
 200     { "audio",       CT_AUDIO,       InitGeneric },
 201     { "image",       CT_IMAGE,       InitGeneric },
 202     { "message",     CT_MESSAGE,     InitMessage },
 203     { "multipart",   CT_MULTIPART,   InitMultiPart },
 204     { "text",        CT_TEXT,        InitText },
 205     { "video",       CT_VIDEO,       InitGeneric },
 206     { NULL,          CT_EXTENSION,   NULL },  /* these two must be last! */
 207     { NULL,          CT_UNKNOWN,     NULL },
 208 };
 209
 210 static struct str2init str2ces[] = {
 211     { "base64",           CE_BASE64,    InitBase64 },
 212     { "quoted-printable", CE_QUOTED,    InitQuoted },
 213     { "8bit",             CE_8BIT,      Init7Bit },
 214     { "7bit",             CE_7BIT,      Init7Bit },
 215     { "binary",           CE_BINARY,    NULL },
 216     { NULL,               CE_EXTENSION, NULL },  /* these two must be last! */
 217     { NULL,               CE_UNKNOWN,   NULL },
 218 };
 219
 220 /*
 221  * NOTE WELL: si_key MUST NOT have value of NOTOK
 222  *
 223  * si_key is 1 if access method is anonymous.
 224  */
 225 static struct str2init str2methods[] = {
 226     { "afs",         1, InitFile },
 227     { "anon-ftp",    1, InitFTP },
 228     { "ftp",         0, InitFTP },
 229     { "local-file",  0, InitFile },
 230     { "mail-server", 0, InitMail },
 231     { NULL,          0, NULL }
 232 };
 233
 234
 235 int
 236 pidcheck (int status)
 237 {
 238     if ((status & 0xff00) == 0xff00 || (status & 0x007f) != SIGQUIT)
 239         return status;
 240
 241     fflush (stdout);
 242     fflush (stderr);
 243     return done (1);
 244 }
 245
 246
 247 /*
 248  * Main routine for translating composition file
 249  * into valid MIME message.  It translates the draft
 250  * into a content structure (actually a tree of content
 251  * structures).  This message then can be manipulated
 252  * in various ways, including being output via
 253  * output_message().
 254  */
 255
 256 CT
 257 build_mime (char *infile)
 258 {
 259     int compnum, state;
 260     char buf[BUFSIZ], name[NAMESZ];
 261     char *cp, *np, *vp;
 262     struct multipart *m;
 263     struct part **pp;
 264     CT ct;
 265     FILE *in;
 266
 267     umask (~m_gmprot ());
 268
 269     /* open the composition draft */
 270     if ((in = fopen (infile, "r")) == NULL)
 271         adios (infile, "unable to open for reading");
 272
 273     /*
 274      * Allocate space for primary (outside) content
 275      */
 276     if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
 277         adios (NULL, "out of memory");
 278
 279     /*
 280      * Allocate structure for handling decoded content
 281      * for this part.  We don't really need this, but
 282      * allocate it to remain consistent.
 283      */
 284     init_decoded_content (ct);
 285
 286     /*
 287      * Parse some of the header fields in the composition
 288      * draft into the linked list of header fields for
 289      * the new MIME message.
 290      */
 291     for (compnum = 1, state = FLD;;) {
 292         switch (state = m_getfld (state, name, buf, sizeof(buf), in)) {
 293         case FLD:
 294         case FLDPLUS:
 295         case FLDEOF:
 296             compnum++;
 297
 298             /* abort if draft has Mime-Version header field */
 299             if (!strcasecmp (name, VRSN_FIELD))
 300                 adios (NULL, "draft shouldn't contain %s: field", VRSN_FIELD);
 301
 302             /* abort if draft has Content-Transfer-Encoding header field */
 303             if (!strcasecmp (name, ENCODING_FIELD))
 304                 adios (NULL, "draft shouldn't contain %s: field", ENCODING_FIELD);
 305
 306             /* ignore any Content-Type fields in the header */
 307             if (!strcasecmp (name, TYPE_FIELD)) {
 308                 while (state == FLDPLUS)
 309                     state = m_getfld (state, name, buf, sizeof(buf), in);
 310                 goto finish_field;
 311             }
 312
 313             /* get copies of the buffers */
 314             np = add (name, NULL);
 315             vp = add (buf, NULL);
 316
 317             /* if necessary, get rest of field */
 318             while (state == FLDPLUS) {
 319                 state = m_getfld (state, name, buf, sizeof(buf), in);
 320                 vp = add (buf, vp);     /* add to previous value */
 321             }
 322
 323             /* Now add the header data to the list */
 324             add_header (ct, np, vp);
 325
 326 finish_field:
 327             /* if this wasn't the last header field, then continue */
 328             if (state != FLDEOF)
 329                 continue;
 330             /* else fall... */
 331
 332         case FILEEOF:
 333             adios (NULL, "draft has empty body -- no directives!");
 334             /* NOTREACHED */
 335
 336         case BODY:
 337         case BODYEOF:
 338             fseek (in, (long) (-strlen (buf)), SEEK_CUR);
 339             break;
 340
 341         case LENERR:
 342         case FMTERR:
 343             adios (NULL, "message format error in component #%d", compnum);
 344
 345         default:
 346             adios (NULL, "getfld() returned %d", state);
 347         }
 348         break;
 349     }
 350
 351     /*
 352      * Now add the MIME-Version header field
 353      * to the list of header fields.
 354      */
 355     np = add (VRSN_FIELD, NULL);
 356     vp = concat (" ", VRSN_VALUE, "\n", NULL);
 357     add_header (ct, np, vp);
 358
 359     /*
 360      * We initally assume we will find multiple contents in the
 361      * draft.  So create a multipart/mixed content to hold everything.
 362      * We can remove this later, if it is not needed.
 363      */
 364     if (get_ctinfo ("multipart/mixed", ct, 0) == NOTOK)
 365         done (1);
 366     ct->c_type = CT_MULTIPART;
 367     ct->c_subtype = MULTI_MIXED;
 368     ct->c_file = add (infile, NULL);
 369
 370     if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
 371         adios (NULL, "out of memory");
 372     ct->c_ctparams = (void *) m;
 373     pp = &m->mp_parts;
 374
 375     /*
 376      * read and parse the composition file
 377      * and the directives it contains.
 378      */
 379     while (fgetstr (buf, sizeof(buf) - 1, in)) {
 380         struct part *part;
 381         CT p;
 382
 383         if (user_content (in, infile, buf, &p) == DONE) {
 384             admonish (NULL, "ignoring spurious #end");
 385             continue;
 386         }
 387         if (!p)
 388             continue;
 389
 390         if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
 391             adios (NULL, "out of memory");
 392         *pp = part;
 393         pp = &part->mp_next;
 394         part->mp_part = p;
 395     }
 396
 397     /*
 398      * close the composition draft since
 399      * it's not needed any longer.
 400      */
 401     fclose (in);
 402
 403     /* check if any contents were found */
 404     if (!m->mp_parts)
 405         adios (NULL, "no content directives found");
 406
 407     /*
 408      * If only one content was found, then remove and
 409      * free the outer multipart content.
 410      */
 411     if (!m->mp_parts->mp_next) {
 412         CT p;
 413
 414         p = m->mp_parts->mp_part;
 415         m->mp_parts->mp_part = NULL;
 416
 417         /* move header fields */
 418         p->c_first_hf = ct->c_first_hf;
 419         p->c_last_hf = ct->c_last_hf;
 420         ct->c_first_hf = NULL;
 421         ct->c_last_hf = NULL;
 422
 423         free_content (ct);
 424         ct = p;
 425     } else {
 426         set_id (ct, 1);
 427     }
 428
 429     /*
 430      * Fill out, or expand directives.  Parse and execute
 431      * commands specified by profile composition strings.
 432      */
 433     compose_content (ct);
 434
 435     if ((cp = strchr(prefix, 'a')) == NULL)
 436         adios (NULL, "internal error(4)");
 437
 438     /*
 439      * Scan the contents.  Choose a transfer encoding, and
 440      * check if prefix for multipart boundary clashes with
 441      * any of the contents.
 442      */
 443     while (scan_content (ct) == NOTOK) {
 444         if (*cp < 'z') {
 445             (*cp)++;
 446         } else {
 447             if (*++cp == 0)
 448                 adios (NULL, "giving up trying to find a unique delimiter string");
 449             else
 450                 (*cp)++;
 451         }
 452     }
 453
 454     /* Build the rest of the header field structures */
 455     build_headers (ct);
 456
 457     return ct;
 458 }
 459
 460
 461 /*
 462  * Main routine for reading/parsing the headers
 463  * of a message content.
 464  *
 465  * toplevel =  1   # we are at the top level of the message
 466  * toplevel =  0   # we are inside message type or multipart type
 467  *                 # other than multipart/digest
 468  * toplevel = -1   # we are inside multipart/digest
 469  */
 470
 471 static CT
 472 get_content (FILE *in, char *file, int toplevel)
 473 {
 474     int compnum, state;
 475     char buf[BUFSIZ], name[NAMESZ];
 476     CT ct;
 477
 478     if (!(ct = (CT) calloc (1, sizeof(*ct))))
 479         adios (NULL, "out of memory");
 480
 481     ct->c_fp = in;
 482     ct->c_file = add (file, NULL);
 483     ct->c_begin = ftell (ct->c_fp) + 1;
 484
 485     /*
 486      * Read the content headers
 487      */
 488     for (compnum = 1, state = FLD;;) {
 489         switch (state = m_getfld (state, name, buf, sizeof(buf), in)) {
 490         case FLD:
 491         case FLDPLUS:
 492         case FLDEOF:
 493             compnum++;
 494
 495             /* Get MIME-Version field */
 496             if (!strcasecmp (name, VRSN_FIELD)) {
 497                 int ucmp;
 498                 char c, *cp, *dp;
 499
 500                 cp = add (buf, NULL);
 501                 while (state == FLDPLUS) {
 502                     state = m_getfld (state, name, buf, sizeof(buf), in);
 503                     cp = add (buf, cp);
 504                 }
 505
 506                 if (ct->c_vrsn) {
 507                     advise (NULL, "message %s has multiple %s: fields (%s)",
 508                             ct->c_file, VRSN_FIELD, dp = trimcpy (cp));
 509                     free (dp);
 510                     free (cp);
 511                     goto out;
 512                 }
 513
 514                 ct->c_vrsn = cp;
 515                 while (isspace (*cp))
 516                     cp++;
 517                 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 518                     *dp++ = ' ';
 519                 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 520                     if (!isspace (*dp))
 521                         break;
 522                 *++dp = '\0';
 523                 if (debugsw)
 524                     fprintf (stderr, "%s: %s\n", VRSN_FIELD, cp);
 525
 526                 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK)
 527                     goto out;
 528
 529                 for (dp = cp; istoken (*dp); dp++)
 530                     continue;
 531                 c = *dp, *dp = '\0';
 532                 ucmp = !strcasecmp (cp, VRSN_VALUE);
 533                 *dp = c;
 534                 if (!ucmp)
 535                     admonish (NULL,
 536                               "message %s has unknown value for %s: field (%s)",
 537                               ct->c_file, VRSN_FIELD, cp);
 538                 goto got_header;
 539             }
 540
 541             /* Get Content-Type field */
 542             if (!strcasecmp (name, TYPE_FIELD)) {
 543                 char *cp;
 544                 struct str2init *s2i;
 545                 CI ci = &ct->c_ctinfo;
 546
 547                 cp = add (buf, NULL);
 548                 while (state == FLDPLUS) {
 549                     state = m_getfld (state, name, buf, sizeof(buf), in);
 550                     cp = add (buf, cp);
 551                 }
 552
 553                 /* Check if we've already seen a Content-Type header */
 554                 if (ct->c_ctline) {
 555                     char *dp = trimcpy (cp);
 556
 557                     advise (NULL, "message %s has multiple %s: fields (%s)",
 558                             ct->c_file, TYPE_FIELD, dp);
 559                     free (dp);
 560                     free (cp);
 561                     goto out;
 562                 }
 563
 564                 /* Parse the Content-Type field */
 565                 if (get_ctinfo (cp, ct, 0) == NOTOK)
 566                     goto out;
 567
 568                 /*
 569                  * Set the Init function and the internal
 570                  * flag for this content type.
 571                  */
 572                 for (s2i = str2cts; s2i->si_key; s2i++)
 573                     if (!strcasecmp (ci->ci_type, s2i->si_key))
 574                         break;
 575                 if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
 576                     s2i++;
 577                 ct->c_type = s2i->si_val;
 578                 ct->c_ctinitfnx = s2i->si_init;
 579                 goto got_header;
 580             }
 581
 582             /* Get Content-Transfer-Encoding field */
 583             if (!strcasecmp (name, ENCODING_FIELD)) {
 584                 char *cp, *dp;
 585                 char c;
 586                 struct str2init *s2i;
 587
 588                 cp = add (buf, NULL);
 589                 while (state == FLDPLUS) {
 590                     state = m_getfld (state, name, buf, sizeof(buf), in);
 591                     cp = add (buf, cp);
 592                 }
 593
 594                 /*
 595                  * Check if we've already seen the
 596                  * Content-Transfer-Encoding field
 597                  */
 598                 if (ct->c_celine) {
 599                     advise (NULL, "message %s has multiple %s: fields (%s)",
 600                             ct->c_file, ENCODING_FIELD, dp = trimcpy (cp));
 601                     free (dp);
 602                     free (cp);
 603                     goto out;
 604                 }
 605
 606                 ct->c_celine = cp;      /* Save copy of this field */
 607                 while (isspace (*cp))
 608                     cp++;
 609                 for (dp = cp; istoken (*dp); dp++)
 610                     continue;
 611                 c = *dp;
 612                 *dp = '\0';
 613
 614                 /*
 615                  * Find the internal flag and Init function
 616                  * for this transfer encoding.
 617                  */
 618                 for (s2i = str2ces; s2i->si_key; s2i++)
 619                     if (!strcasecmp (cp, s2i->si_key))
 620                         break;
 621                 if (!s2i->si_key && !uprf (cp, "X-"))
 622                     s2i++;
 623                 *dp = c;
 624                 ct->c_encoding = s2i->si_val;
 625
 626                 /* Call the Init function for this encoding */
 627                 if (s2i->si_init && (*s2i->si_init) (ct) == NOTOK)
 628                     goto out;
 629                 goto got_header;
 630             }
 631
 632             /* Get Content-ID field */
 633             if (!strcasecmp (name, ID_FIELD)) {
 634                 ct->c_id = add (buf, ct->c_id);
 635                 while (state == FLDPLUS) {
 636                     state = m_getfld (state, name, buf, sizeof(buf), in);
 637                     ct->c_id = add (buf, ct->c_id);
 638                 }
 639                 goto got_header;
 640             }
 641
 642             /* Get Content-Description field */
 643             if (!strcasecmp (name, DESCR_FIELD)) {
 644                 ct->c_descr = add (buf, ct->c_descr);
 645                 while (state == FLDPLUS) {
 646                     state = m_getfld (state, name, buf, sizeof(buf), in);
 647                     ct->c_descr = add (buf, ct->c_descr);
 648                 }
 649                 goto got_header;
 650             }
 651
 652             /* Get Content-MD5 field */
 653             if (!strcasecmp (name, MD5_FIELD)) {
 654                 char *cp, *dp, *ep;
 655
 656                 cp = add (buf, NULL);
 657                 while (state == FLDPLUS) {
 658                     state = m_getfld (state, name, buf, sizeof(buf), in);
 659                     cp = add (buf, cp);
 660                 }
 661
 662                 if (!checksw) {
 663                     free (cp);
 664                     goto got_header;
 665                 }
 666
 667                 if (ct->c_digested) {
 668                     advise (NULL, "message %s has multiple %s: fields (%s)",
 669                             ct->c_file, MD5_FIELD, dp = trimcpy (cp));
 670                     free (dp);
 671                     free (cp);
 672                     goto out;
 673                 }
 674
 675                 ep = cp;
 676                 while (isspace (*cp))
 677                     cp++;
 678                 for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 679                     *dp++ = ' ';
 680                 for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 681                     if (!isspace (*dp))
 682                         break;
 683                 *++dp = '\0';
 684                 if (debugsw)
 685                     fprintf (stderr, "%s: %s\n", MD5_FIELD, cp);
 686
 687                 if (*cp == '(' && get_comment (ct, &cp, 0) == NOTOK) {
 688                     free (ep);
 689                     goto out;
 690                 }
 691
 692                 for (dp = cp; *dp && !isspace (*dp); dp++)
 693                     continue;
 694                 *dp = '\0';
 695
 696                 readDigest (ct, cp);
 697                 free (ep);
 698                 ct->c_digested++;
 699                 goto got_header;
 700             }
 701
 702 #if 0
 703             if (uprf (name, XXX_FIELD_PRF))
 704                 advise (NULL, "unknown field (%s) in message %s",
 705                         name, ct->c_file);
 706             /* and fall... */
 707 #endif
 708
 709             while (state == FLDPLUS)
 710                 state = m_getfld (state, name, buf, sizeof(buf), in);
 711
 712 got_header:
 713             if (state != FLDEOF) {
 714                 ct->c_begin = ftell (in) + 1;
 715                 continue;
 716             }
 717             /* else fall... */
 718
 719         case BODY:
 720         case BODYEOF:
 721             ct->c_begin = ftell (in) - strlen (buf);
 722             break;
 723
 724         case FILEEOF:
 725             ct->c_begin = ftell (in);
 726             break;
 727
 728         case LENERR:
 729         case FMTERR:
 730             adios (NULL, "message format error in component #%d", compnum);
 731
 732         default:
 733             adios (NULL, "getfld() returned %d", state);
 734         }
 735         break;
 736     }
 737
 738     /*
 739      * Check if we saw a Content-Type field.
 740      * If not, then assign a default value for
 741      * it, and the Init function.
 742      */
 743     if (!ct->c_ctline) {
 744         /*
 745          * If we are inside a multipart/digest message,
 746          * so default type is message/rfc822
 747          */
 748         if (toplevel < 0) {
 749             if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
 750                 goto out;
 751             ct->c_type = CT_MESSAGE;
 752             ct->c_ctinitfnx = InitMessage;
 753         } else {
 754             /*
 755              * Else default type is text/plain
 756              */
 757             if (get_ctinfo ("text/plain", ct, 0) == NOTOK)
 758                 goto out;
 759             ct->c_type = CT_TEXT;
 760             ct->c_ctinitfnx = InitText;
 761         }
 762     }
 763
 764     /* Use default Transfer-Encoding, if necessary */
 765     if (!ct->c_celine) {
 766         ct->c_encoding = CE_7BIT;
 767         Init7Bit (ct);
 768     }
 769
 770     return ct;
 771
 772 out:
 773     free_content (ct);
 774     return NULL;
 775 }
 776
 777
 778 /*
 779  * small routine to add header field to list
 780  */
 781
 782 static int
 783 add_header (CT ct, char *name, char *value)
 784 {
 785     HF hp;
 786
 787     /* allocate header field structure */
 788     if (!(hp = malloc (sizeof(*hp))))
 789         adios (NULL, "out of memory");
 790
 791     /* link data into header structure */
 792     hp->name = name;
 793     hp->value = value;
 794     hp->next = NULL;
 795
 796     /* link header structure into the list */
 797     if (ct->c_first_hf == NULL) {
 798         ct->c_first_hf = hp;            /* this is the first */
 799         ct->c_last_hf = hp;
 800     } else {
 801         ct->c_last_hf->next = hp;       /* add it to the end */
 802         ct->c_last_hf = hp;
 803     }
 804
 805     return 0;
 806 }
 807
 808
 809 /*
 810  * Used to parse both:
 811  *   1) Content-Type line
 812  *   2) composition directives
 813  *
 814  * and fills in the information of the CTinfo structure.
 815  */
 816
 817 static int
 818 get_ctinfo (char *cp, CT ct, int magic)
 819 {
 820     int i;
 821     char *dp, **ap, **ep;
 822     char c;
 823     CI ci;
 824
 825     ci = &ct->c_ctinfo;
 826     i = strlen (invo_name) + 2;
 827
 828     /* store copy of Content-Type line */
 829     cp = ct->c_ctline = add (cp, NULL);
 830
 831     while (isspace (*cp))       /* trim leading spaces */
 832         cp++;
 833
 834     /* change newlines to spaces */
 835     for (dp = strchr(cp, '\n'); dp; dp = strchr(dp, '\n'))
 836         *dp++ = ' ';
 837
 838     /* trim trailing spaces */
 839     for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
 840         if (!isspace (*dp))
 841             break;
 842     *++dp = '\0';
 843
 844     if (debugsw)
 845         fprintf (stderr, "%s: %s\n", TYPE_FIELD, cp);
 846
 847     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 848         return NOTOK;
 849
 850     for (dp = cp; istoken (*dp); dp++)
 851         continue;
 852     c = *dp, *dp = '\0';
 853     ci->ci_type = add (cp, NULL);       /* store content type */
 854     *dp = c, cp = dp;
 855
 856     if (!*ci->ci_type) {
 857         advise (NULL, "invalid %s: field in message %s (empty type)",
 858                 TYPE_FIELD, ct->c_file);
 859         return NOTOK;
 860     }
 861
 862     /* down case the content type string */
 863     for (dp = ci->ci_type; *dp; dp++)
 864         if (isalpha(*dp) && isupper (*dp))
 865             *dp = tolower (*dp);
 866
 867     while (isspace (*cp))
 868         cp++;
 869
 870     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 871         return NOTOK;
 872
 873     if (*cp != '/') {
 874         if (!magic)
 875             ci->ci_subtype = add ("", NULL);
 876         goto magic_skip;
 877     }
 878
 879     cp++;
 880     while (isspace (*cp))
 881         cp++;
 882
 883     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 884         return NOTOK;
 885
 886     for (dp = cp; istoken (*dp); dp++)
 887         continue;
 888     c = *dp, *dp = '\0';
 889     ci->ci_subtype = add (cp, NULL);    /* store the content subtype */
 890     *dp = c, cp = dp;
 891
 892     if (!*ci->ci_subtype) {
 893         advise (NULL,
 894                 "invalid %s: field in message %s (empty subtype for \"%s\")",
 895                 TYPE_FIELD, ct->c_file, ci->ci_type);
 896         return NOTOK;
 897     }
 898
 899     /* down case the content subtype string */
 900     for (dp = ci->ci_subtype; *dp; dp++)
 901         if (isalpha(*dp) && isupper (*dp))
 902             *dp = tolower (*dp);
 903
 904 magic_skip:
 905     while (isspace (*cp))
 906         cp++;
 907
 908     if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 909         return NOTOK;
 910
 911     /*
 912      * Parse attribute/value pairs given with Content-Type
 913      */
 914     ep = (ap = ci->ci_attrs) + NPARMS;
 915     while (*cp == ';') {
 916         char *vp, *up;
 917
 918         if (ap >= ep) {
 919             advise (NULL,
 920                     "too many parameters in message %s's %s: field (%d max)",
 921                     ct->c_file, TYPE_FIELD, NPARMS);
 922             return NOTOK;
 923         }
 924
 925         cp++;
 926         while (isspace (*cp))
 927             cp++;
 928
 929         if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
 930             return NOTOK;
 931
 932         if (*cp == 0) {
 933             advise (NULL,
 934                     "extraneous trailing ';' in message %s's %s: parameter list",
 935                     ct->c_file, TYPE_FIELD);
 936             return OK;
 937         }
 938
 939         /* down case the attribute name */
 940         for (dp = cp; istoken (*dp); dp++)
 941             if (isalpha(*dp) && isupper (*dp))
 942                 *dp = tolower (*dp);
 943
 944         for (up = dp; isspace (*dp); )
 945             dp++;
 946         if (dp == cp || *dp != '=') {
 947             advise (NULL,
 948                     "invalid parameter in message %s's %s: field\n%*.*sparameter %s (error detected at offset %d)",
 949                     ct->c_file, TYPE_FIELD, i, i, "", cp, dp - cp);
 950             return NOTOK;
 951         }
 952
 953         vp = (*ap = add (cp, NULL)) + (up - cp);
 954         *vp = '\0';
 955         for (dp++; isspace (*dp); )
 956             dp++;
 957
 958         /* now add the attribute value */
 959         ci->ci_values[ap - ci->ci_attrs] = vp = *ap + (dp - cp);
 960
 961         if (*dp == '"') {
 962             for (cp = ++dp, dp = vp;;) {
 963                 switch (c = *cp++) {
 964                     case '\0':
 965 bad_quote:
 966                         advise (NULL,
 967                                 "invalid quoted-string in message %s's %s: field\n%*.*s(parameter %s)",
 968                                 ct->c_file, TYPE_FIELD, i, i, "", *ap);
 969                         return NOTOK;
 970
 971                     case '\\':
 972                         *dp++ = c;
 973                         if ((c = *cp++) == '\0')
 974                             goto bad_quote;
 975                         /* else fall... */
 976
 977                     default:
 978                         *dp++ = c;
 979                         continue;
 980
 981                     case '"':
 982                         *dp = '\0';
 983                         break;
 984                 }
 985                 break;
 986             }
 987         } else {
 988             for (cp = dp, dp = vp; istoken (*cp); cp++, dp++)
 989                 continue;
 990             *dp = '\0';
 991         }
 992         if (!*vp) {
 993             advise (NULL,
 994                     "invalid parameter in message %s's %s: field\n%*.*s(parameter %s)",
 995                     ct->c_file, TYPE_FIELD, i, i, "", *ap);
 996             return NOTOK;
 997         }
 998         ap++;
 999
1000         while (isspace (*cp))
1001             cp++;
1002
1003         if (*cp == '(' && get_comment (ct, &cp, 1) == NOTOK)
1004             return NOTOK;
1005     }
1006
1007     /*
1008      * Get any <Content-Id> given in buffer
1009      */
1010     if (magic && *cp == '<') {
1011         if (ct->c_id) {
1012             free (ct->c_id);
1013             ct->c_id = NULL;
1014         }
1015         if (!(dp = strchr(ct->c_id = ++cp, '>'))) {
1016             advise (NULL, "invalid ID in message %s", ct->c_file);
1017             return NOTOK;
1018         }
1019         c = *dp;
1020         *dp = '\0';
1021         if (*ct->c_id)
1022             ct->c_id = concat ("<", ct->c_id, ">\n", NULL);
1023         else
1024             ct->c_id = NULL;
1025         *dp++ = c;
1026         cp = dp;
1027
1028         while (isspace (*cp))
1029             cp++;
1030     }
1031
1032     /*
1033      * Get any [Content-Description] given in buffer.
1034      */
1035     if (magic && *cp == '[') {
1036         ct->c_descr = ++cp;
1037         for (dp = cp + strlen (cp) - 1; dp >= cp; dp--)
1038             if (*dp == ']')
1039                 break;
1040         if (dp < cp) {
1041             advise (NULL, "invalid description in message %s", ct->c_file);
1042             ct->c_descr = NULL;
1043             return NOTOK;
1044         }
1045
1046         c = *dp;
1047         *dp = '\0';
1048         if (*ct->c_descr)
1049             ct->c_descr = concat (ct->c_descr, "\n", NULL);
1050         else
1051             ct->c_descr = NULL;
1052         *dp++ = c;
1053         cp = dp;
1054
1055         while (isspace (*cp))
1056             cp++;
1057     }
1058
1059     /*
1060      * Check if anything is left over
1061      */
1062     if (*cp) {
1063         if (magic)
1064             ci->ci_magic = add (cp, NULL);
1065         else
1066             advise (NULL,
1067                     "extraneous information in message %s's %s: field\n%*.*s(%s)",
1068                 ct->c_file, TYPE_FIELD, i, i, "", cp);
1069     }
1070
1071     return OK;
1072 }
1073
1074
1075 static int
1076 get_comment (CT ct, char **ap, int istype)
1077 {
1078     int i;
1079     char *bp, *cp;
1080     char c, buffer[BUFSIZ], *dp;
1081     CI ci;
1082
1083     ci = &ct->c_ctinfo;
1084     cp = *ap;
1085     bp = buffer;
1086     cp++;
1087
1088     for (i = 0;;) {
1089         switch (c = *cp++) {
1090         case '\0':
1091 invalid:
1092         advise (NULL, "invalid comment in message %s's %s: field",
1093                 ct->c_file, istype ? TYPE_FIELD : VRSN_FIELD);
1094         return NOTOK;
1095
1096         case '\\':
1097             *bp++ = c;
1098             if ((c = *cp++) == '\0')
1099                 goto invalid;
1100             *bp++ = c;
1101             continue;
1102
1103         case '(':
1104             i++;
1105             /* and fall... */
1106         default:
1107             *bp++ = c;
1108             continue;
1109
1110         case ')':
1111             if (--i < 0)
1112                 break;
1113             *bp++ = c;
1114             continue;
1115         }
1116         break;
1117     }
1118     *bp = '\0';
1119
1120     if (istype) {
1121         if ((dp = ci->ci_comment)) {
1122             ci->ci_comment = concat (dp, " ", buffer, NULL);
1123             free (dp);
1124         } else {
1125             ci->ci_comment = add (buffer, NULL);
1126         }
1127     }
1128
1129     while (isspace (*cp))
1130         cp++;
1131
1132     *ap = cp;
1133     return OK;
1134 }
1135
1136
1137 /*
1138  * CONTENTS
1139  *
1140  * Handles content types audio, image, and video.
1141  * There's not much to do right here.
1142  */
1143
1144 static int
1145 InitGeneric (CT ct)
1146 {
1147     return OK;          /* not much to do here */
1148 }
1149
1150
1151 /*
1152  * TEXT
1153  */
1154
1155 static int
1156 InitText (CT ct)
1157 {
1158     char **ap, **ep;
1159     struct k2v *kv;
1160     struct text *t;
1161     CI ci = &ct->c_ctinfo;
1162
1163     /* check for missing subtype */
1164     if (!*ci->ci_subtype)
1165         ci->ci_subtype = add ("plain", ci->ci_subtype);
1166
1167     /* match subtype */
1168     for (kv = SubText; kv->kv_key; kv++)
1169         if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1170             break;
1171     ct->c_subtype = kv->kv_value;
1172
1173     /* allocate text character set structure */
1174     if ((t = (struct text *) calloc (1, sizeof(*t))) == NULL)
1175         adios (NULL, "out of memory");
1176     ct->c_ctparams = (void *) t;
1177
1178     /* initially mark character set as unspecified */
1179     t->tx_charset = CHARSET_UNSPECIFIED;
1180
1181     /* scan for charset parameter */
1182     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
1183         if (!strcasecmp (*ap, "charset"))
1184             break;
1185
1186     /* check if content specified a character set */
1187     if (*ap) {
1188         /* match character set or set to CHARSET_UNKNOWN */
1189         for (kv = Charset; kv->kv_key; kv++)
1190             if (!strcasecmp (*ep, kv->kv_key))
1191                 break;
1192         t->tx_charset = kv->kv_value;
1193     }
1194
1195     return OK;
1196 }
1197
1198
1199 /*
1200  * MULTIPART
1201  */
1202
1203 static int
1204 InitMultiPart (CT ct)
1205 {
1206     int inout;
1207     long last, pos;
1208     char *cp, *dp, **ap, **ep;
1209     char *bp, buffer[BUFSIZ];
1210     struct multipart *m;
1211     struct k2v *kv;
1212     struct part *part, **next;
1213     CI ci = &ct->c_ctinfo;
1214     CT p;
1215     FILE *fp;
1216
1217     /*
1218      * The encoding for multipart messages must be either
1219      * 7bit, 8bit, or binary (per RFC2045).
1220      */
1221     if (ct->c_encoding != CE_7BIT && ct->c_encoding != CE_8BIT
1222         && ct->c_encoding != CE_BINARY) {
1223         admonish (NULL,
1224                   "\"%s/%s\" type in message %s must be encoded in 7bit, 8bit, or binary",
1225                   ci->ci_type, ci->ci_subtype, ct->c_file);
1226         return NOTOK;
1227     }
1228
1229     /* match subtype */
1230     for (kv = SubMultiPart; kv->kv_key; kv++)
1231         if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1232             break;
1233     ct->c_subtype = kv->kv_value;
1234
1235     /*
1236      * Check for "boundary" parameter, which is
1237      * required for multipart messages.
1238      */
1239     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1240         if (!strcasecmp (*ap, "boundary")) {
1241             bp = *ep;
1242             break;
1243         }
1244     }
1245
1246     /* complain if boundary parameter is missing */
1247     if (!*ap) {
1248         advise (NULL,
1249                 "a \"boundary\" parameter is mandatory for \"%s/%s\" type in message %s's %s: field",
1250                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1251         return NOTOK;
1252     }
1253
1254     /* allocate primary structure for multipart info */
1255     if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
1256         adios (NULL, "out of memory");
1257     ct->c_ctparams = (void *) m;
1258
1259     /* check if boundary parameter contains only whitespace characters */
1260     for (cp = bp; isspace (*cp); cp++)
1261         continue;
1262     if (!*cp) {
1263         advise (NULL, "invalid \"boundary\" parameter for \"%s/%s\" type in message %s's %s: field",
1264                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1265         return NOTOK;
1266     }
1267
1268     /* remove trailing whitespace from boundary parameter */
1269     for (cp = bp, dp = cp + strlen (cp) - 1; dp > cp; dp--)
1270         if (!isspace (*dp))
1271             break;
1272     *++dp = '\0';
1273
1274     /* record boundary separators */
1275     m->mp_start = concat (bp, "\n", NULL);
1276     m->mp_stop = concat (bp, "--\n", NULL);
1277
1278     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1279         advise (ct->c_file, "unable to open for reading");
1280         return NOTOK;
1281     }
1282
1283     fseek (fp = ct->c_fp, pos = ct->c_begin, SEEK_SET);
1284     last = ct->c_end;
1285     next = &m->mp_parts;
1286     part = NULL;
1287     inout = 1;
1288
1289     while (fgets (buffer, sizeof(buffer) - 1, fp)) {
1290         if (pos > last)
1291             break;
1292
1293         pos += strlen (buffer);
1294         if (buffer[0] != '-' || buffer[1] != '-')
1295             continue;
1296         if (inout) {
1297             if (strcmp (buffer + 2, m->mp_start))
1298                 continue;
1299 next_part:
1300             if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
1301                 adios (NULL, "out of memory");
1302             *next = part;
1303             next = &part->mp_next;
1304
1305             if (!(p = get_content (fp, ct->c_file,
1306                 rfc934sw && ct->c_subtype == MULTI_DIGEST ? -1 : 0))) {
1307                 fclose (ct->c_fp);
1308                 ct->c_fp = NULL;
1309                 return NOTOK;
1310             }
1311             p->c_fp = NULL;
1312             part->mp_part = p;
1313             pos = p->c_begin;
1314             fseek (fp, pos, SEEK_SET);
1315             inout = 0;
1316         } else {
1317             if (strcmp (buffer + 2, m->mp_start) == 0) {
1318                 inout = 1;
1319 end_part:
1320                 p = part->mp_part;
1321                 p->c_end = ftell(fp) - (strlen(buffer) + 1);
1322                 if (p->c_end < p->c_begin)
1323                     p->c_begin = p->c_end;
1324                 if (inout)
1325                     goto next_part;
1326                 goto last_part;
1327             } else {
1328                 if (strcmp (buffer + 2, m->mp_stop) == 0)
1329                     goto end_part;
1330             }
1331         }
1332     }
1333
1334     advise (NULL, "bogus multipart content in message %s", ct->c_file);
1335     if (!inout && part) {
1336         p = part->mp_part;
1337         p->c_end = ct->c_end;
1338
1339         if (p->c_begin >= p->c_end) {
1340             for (next = &m->mp_parts; *next != part;
1341                      next = &((*next)->mp_next))
1342                 continue;
1343             *next = NULL;
1344             free_content (p);
1345             free ((char *) part);
1346         }
1347     }
1348
1349 last_part:
1350     /* reverse the order of the parts for multipart/alternative */
1351     if (ct->c_subtype == MULTI_ALTERNATE)
1352         reverse_parts (ct);
1353
1354     /*
1355      * label all subparts with part number, and
1356      * then initialize the content of the subpart.
1357      */
1358     {
1359         int partnum;
1360         char *pp;
1361         char partnam[BUFSIZ];
1362
1363         if (ct->c_partno) {
1364             snprintf (partnam, sizeof(partnam), "%s.", ct->c_partno);
1365             pp = partnam + strlen (partnam);
1366         } else {
1367             pp = partnam;
1368         }
1369
1370         for (part = m->mp_parts, partnum = 1; part;
1371                  part = part->mp_next, partnum++) {
1372             p = part->mp_part;
1373
1374             sprintf (pp, "%d", partnum);
1375             p->c_partno = add (partnam, NULL);
1376
1377             /* initialize the content of the subparts */
1378             if (p->c_ctinitfnx && (*p->c_ctinitfnx) (p) == NOTOK) {
1379                 fclose (ct->c_fp);
1380                 ct->c_fp = NULL;
1381                 return NOTOK;
1382             }
1383         }
1384     }
1385
1386     fclose (ct->c_fp);
1387     ct->c_fp = NULL;
1388     return OK;
1389 }
1390
1391
1392 /*
1393  * reverse the order of the parts of a multipart
1394  */
1395
1396 static void
1397 reverse_parts (CT ct)
1398 {
1399     int i;
1400     struct multipart *m;
1401     struct part **base, **bmp, **next, *part;
1402
1403     m = (struct multipart *) ct->c_ctparams;
1404
1405     /* if only one part, just return */
1406     if (!m->mp_parts || !m->mp_parts->mp_next)
1407         return;
1408
1409     /* count number of parts */
1410     i = 0;
1411     for (part = m->mp_parts; part; part = part->mp_next)
1412         i++;
1413
1414     /* allocate array of pointers to the parts */
1415     if (!(base = (struct part **) calloc ((size_t) (i + 1), sizeof(*base))))
1416         adios (NULL, "out of memory");
1417     bmp = base;
1418
1419     /* point at all the parts */
1420     for (part = m->mp_parts; part; part = part->mp_next)
1421         *bmp++ = part;
1422     *bmp = NULL;
1423
1424     /* reverse the order of the parts */
1425     next = &m->mp_parts;
1426     for (bmp--; bmp >= base; bmp--) {
1427         part = *bmp;
1428         *next = part;
1429         next = &part->mp_next;
1430     }
1431     *next = NULL;
1432
1433     /* free array of pointers */
1434     free ((char *) base);
1435 }
1436
1437
1438 /*
1439  * MESSAGE
1440  */
1441
1442 static int
1443 InitMessage (CT ct)
1444 {
1445     struct k2v *kv;
1446     CI ci = &ct->c_ctinfo;
1447
1448     if ((ct->c_encoding != CE_7BIT) && (ct->c_encoding != CE_8BIT)) {
1449         admonish (NULL,
1450                   "\"%s/%s\" type in message %s should be encoded in 7bit or 8bit",
1451                   ci->ci_type, ci->ci_subtype, ct->c_file);
1452         return NOTOK;
1453     }
1454
1455     /* check for missing subtype */
1456     if (!*ci->ci_subtype)
1457         ci->ci_subtype = add ("rfc822", ci->ci_subtype);
1458
1459     /* match subtype */
1460     for (kv = SubMessage; kv->kv_key; kv++)
1461         if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1462             break;
1463     ct->c_subtype = kv->kv_value;
1464
1465     switch (ct->c_subtype) {
1466         case MESSAGE_RFC822:
1467             break;
1468
1469         case MESSAGE_PARTIAL:
1470             {
1471                 char **ap, **ep;
1472                 struct partial *p;
1473
1474                 if ((p = (struct partial *) calloc (1, sizeof(*p))) == NULL)
1475                     adios (NULL, "out of memory");
1476                 ct->c_ctparams = (void *) p;
1477
1478                 /* scan for parameters "id", "number", and "total" */
1479                 for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1480                     if (!strcasecmp (*ap, "id")) {
1481                         p->pm_partid = add (*ep, NULL);
1482                         continue;
1483                     }
1484                     if (!strcasecmp (*ap, "number")) {
1485                         if (sscanf (*ep, "%d", &p->pm_partno) != 1
1486                                 || p->pm_partno < 1) {
1487 invalid_param:
1488                             advise (NULL,
1489                                     "invalid %s parameter for \"%s/%s\" type in message %s's %s field",
1490                                     *ap, ci->ci_type, ci->ci_subtype,
1491                                     ct->c_file, TYPE_FIELD);
1492                             return NOTOK;
1493                         }
1494                         continue;
1495                     }
1496                     if (!strcasecmp (*ap, "total")) {
1497                         if (sscanf (*ep, "%d", &p->pm_maxno) != 1
1498                                 || p->pm_maxno < 1)
1499                             goto invalid_param;
1500                         continue;
1501                     }
1502                 }
1503
1504                 if (!p->pm_partid
1505                         || !p->pm_partno
1506                         || (p->pm_maxno && p->pm_partno > p->pm_maxno)) {
1507                     advise (NULL,
1508                             "invalid parameters for \"%s/%s\" type in message %s's %s field",
1509                             ci->ci_type, ci->ci_subtype,
1510                             ct->c_file, TYPE_FIELD);
1511                     return NOTOK;
1512                 }
1513             }
1514             break;
1515
1516         case MESSAGE_EXTERNAL:
1517             {
1518                 int exresult;
1519                 struct exbody *e;
1520                 CT p;
1521                 FILE *fp;
1522
1523                 if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
1524                     adios (NULL, "out of memory");
1525                 ct->c_ctparams = (void *) e;
1526
1527                 if (!ct->c_fp
1528                         && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1529                     advise (ct->c_file, "unable to open for reading");
1530                     return NOTOK;
1531                 }
1532
1533                 fseek (fp = ct->c_fp, ct->c_begin, SEEK_SET);
1534
1535                 if (!(p = get_content (fp, ct->c_file, 0))) {
1536                     fclose (ct->c_fp);
1537                     ct->c_fp = NULL;
1538                     return NOTOK;
1539                 }
1540
1541                 e->eb_parent = ct;
1542                 e->eb_content = p;
1543                 p->c_ctexbody = e;
1544                 if ((exresult = params_external (ct, 0)) != NOTOK
1545                         && p->c_ceopenfnx == openMail) {
1546                     int cc, size;
1547                     char *bp;
1548
1549                     if ((size = ct->c_end - p->c_begin) <= 0) {
1550                         if (!e->eb_subject)
1551                             content_error (NULL, ct,
1552                                            "empty body for access-type=mail-server");
1553                         goto no_body;
1554                     }
1555
1556                     if ((e->eb_body = bp = malloc ((unsigned) size)) == NULL)
1557                         adios (NULL, "out of memory");
1558                     fseek (p->c_fp, p->c_begin, SEEK_SET);
1559                     while (size > 0)
1560                         switch (cc = fread (bp, sizeof(*bp), size, p->c_fp)) {
1561                             case NOTOK:
1562                                 adios ("failed", "fread");
1563
1564                             case OK:
1565                                 adios (NULL, "unexpected EOF from fread");
1566
1567                             default:
1568                                 bp += cc, size -= cc;
1569                                 break;
1570                         }
1571                     *bp = 0;
1572                 }
1573 no_body:
1574                 p->c_fp = NULL;
1575                 p->c_end = p->c_begin;
1576
1577                 fclose (ct->c_fp);
1578                 ct->c_fp = NULL;
1579
1580                 if (exresult == NOTOK)
1581                     return NOTOK;
1582                 if (e->eb_flags == NOTOK)
1583                     return OK;
1584
1585                 switch (p->c_type) {
1586                     case CT_MULTIPART:
1587                         break;
1588
1589                     case CT_MESSAGE:
1590                         if (p->c_subtype != MESSAGE_RFC822)
1591                             break;
1592                         /* else fall... */
1593                     default:
1594                         e->eb_partno = ct->c_partno;
1595                         if (p->c_ctinitfnx)
1596                             (*p->c_ctinitfnx) (p);
1597                         break;
1598                 }
1599             }
1600             break;
1601
1602         default:
1603             break;
1604     }
1605
1606     return OK;
1607 }
1608
1609
1610 static int
1611 params_external (CT ct, int composing)
1612 {
1613     char **ap, **ep;
1614     struct exbody *e = (struct exbody *) ct->c_ctparams;
1615     CI ci = &ct->c_ctinfo;
1616
1617     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
1618         if (!strcasecmp (*ap, "access-type")) {
1619             struct str2init *s2i;
1620             CT p = e->eb_content;
1621
1622             for (s2i = str2methods; s2i->si_key; s2i++)
1623                 if (!strcasecmp (*ep, s2i->si_key))
1624                     break;
1625
1626             if (!s2i->si_key) {
1627                 e->eb_access = *ep;
1628                 e->eb_flags = NOTOK;
1629                 p->c_encoding = CE_EXTERNAL;
1630                 continue;
1631             }
1632             e->eb_access = s2i->si_key;
1633             e->eb_flags = s2i->si_val;
1634             p->c_encoding = CE_EXTERNAL;
1635
1636             /* Call the Init function for this external type */
1637             if ((*s2i->si_init)(p) == NOTOK)
1638                 return NOTOK;
1639             continue;
1640         }
1641         if (!strcasecmp (*ap, "name")) {
1642             e->eb_name = *ep;
1643             continue;
1644         }
1645         if (!strcasecmp (*ap, "permission")) {
1646             e->eb_permission = *ep;
1647             continue;
1648         }
1649         if (!strcasecmp (*ap, "site")) {
1650             e->eb_site = *ep;
1651             continue;
1652         }
1653         if (!strcasecmp (*ap, "directory")) {
1654             e->eb_dir = *ep;
1655             continue;
1656         }
1657         if (!strcasecmp (*ap, "mode")) {
1658             e->eb_mode = *ep;
1659             continue;
1660         }
1661         if (!strcasecmp (*ap, "size")) {
1662             sscanf (*ep, "%lu", &e->eb_size);
1663             continue;
1664         }
1665         if (!strcasecmp (*ap, "server")) {
1666             e->eb_server = *ep;
1667             continue;
1668         }
1669         if (!strcasecmp (*ap, "subject")) {
1670             e->eb_subject = *ep;
1671             continue;
1672         }
1673         if (composing && !strcasecmp (*ap, "body")) {
1674             e->eb_body = getcpy (*ep);
1675             continue;
1676         }
1677     }
1678
1679     if (!e->eb_access) {
1680         advise (NULL,
1681                 "invalid parameters for \"%s/%s\" type in message %s's %s field",
1682                 ci->ci_type, ci->ci_subtype, ct->c_file, TYPE_FIELD);
1683         return NOTOK;
1684     }
1685
1686     return OK;
1687 }
1688
1689
1690 /*
1691  * APPLICATION
1692  */
1693
1694 static int
1695 InitApplication (CT ct)
1696 {
1697     struct k2v *kv;
1698     CI ci = &ct->c_ctinfo;
1699
1700     /* match subtype */
1701     for (kv = SubApplication; kv->kv_key; kv++)
1702         if (!strcasecmp (ci->ci_subtype, kv->kv_key))
1703             break;
1704     ct->c_subtype = kv->kv_value;
1705
1706     return OK;
1707 }
1708
1709
1710 /*
1711  * Set up structures for placing unencoded
1712  * content when building parts.
1713  */
1714
1715 static int
1716 init_decoded_content (CT ct)
1717 {
1718     CE ce;
1719
1720     if ((ce = (CE) calloc (1, sizeof(*ce))) == NULL)
1721         adios (NULL, "out of memory");
1722
1723     ct->c_cefile     = ce;
1724     ct->c_ceopenfnx  = open7Bit;        /* since unencoded */
1725     ct->c_ceclosefnx = close_encoding;
1726     ct->c_cesizefnx  = NULL;            /* since unencoded */
1727
1728     return OK;
1729 }
1730
1731
1732 /*
1733  * TRANSFER ENCODINGS
1734  */
1735
1736 static int
1737 init_encoding (CT ct, OpenCEFunc openfnx)
1738 {
1739     CE ce;
1740
1741     if ((ce = (CE) calloc (1, sizeof(*ce))) == NULL)
1742         adios (NULL, "out of memory");
1743
1744     ct->c_cefile     = ce;
1745     ct->c_ceopenfnx  = openfnx;
1746     ct->c_ceclosefnx = close_encoding;
1747     ct->c_cesizefnx  = size_encoding;
1748
1749     return OK;
1750 }
1751
1752
1753 static void
1754 close_encoding (CT ct)
1755 {
1756     CE ce;
1757
1758     if (!(ce = ct->c_cefile))
1759         return;
1760
1761     if (ce->ce_fp) {
1762         fclose (ce->ce_fp);
1763         ce->ce_fp = NULL;
1764     }
1765 }
1766
1767
1768 static unsigned long
1769 size_encoding (CT ct)
1770 {
1771     int fd;
1772     unsigned long size;
1773     char *file;
1774     CE ce;
1775     struct stat st;
1776
1777     if (!(ce = ct->c_cefile))
1778         return (ct->c_end - ct->c_begin);
1779
1780     if (ce->ce_fp && fstat (fileno (ce->ce_fp), &st) != NOTOK)
1781         return (long) st.st_size;
1782
1783     if (ce->ce_file) {
1784         if (stat (ce->ce_file, &st) != NOTOK)
1785             return (long) st.st_size;
1786         else
1787             return 0L;
1788     }
1789
1790     if (ct->c_encoding == CE_EXTERNAL)
1791         return (ct->c_end - ct->c_begin);
1792
1793     file = NULL;
1794     if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
1795         return (ct->c_end - ct->c_begin);
1796
1797     if (fstat (fd, &st) != NOTOK)
1798         size = (long) st.st_size;
1799     else
1800         size = 0L;
1801
1802     (*ct->c_ceclosefnx) (ct);
1803     return size;
1804 }
1805
1806
1807 /*
1808  * BASE64
1809  */
1810
1811 static unsigned char b642nib[0x80] = {
1812     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1813     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1814     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1815     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1816     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1817     0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
1818     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
1819     0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1820     0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
1821     0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
1822     0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
1823     0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
1824     0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1825     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
1826     0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
1827     0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
1828 };
1829
1830
1831 static int
1832 InitBase64 (CT ct)
1833 {
1834     return init_encoding (ct, openBase64);
1835 }
1836
1837
1838 static int
1839 openBase64 (CT ct, char **file)
1840 {
1841     int bitno, cc, digested;
1842     int fd, len, skip;
1843     unsigned long bits;
1844     unsigned char value, *b, *b1, *b2, *b3;
1845     char *cp, *ep, buffer[BUFSIZ];
1846     CE ce;
1847     MD5_CTX mdContext;
1848
1849     b  = (unsigned char *) &bits;
1850     b1 = &b[endian > 0 ? 1 : 2];
1851     b2 = &b[endian > 0 ? 2 : 1];
1852     b3 = &b[endian > 0 ? 3 : 0];
1853
1854     ce = ct->c_cefile;
1855     if (ce->ce_fp) {
1856         fseek (ce->ce_fp, 0L, SEEK_SET);
1857         goto ready_to_go;
1858     }
1859
1860     if (ce->ce_file) {
1861         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
1862             content_error (ce->ce_file, ct, "unable to fopen for reading");
1863             return NOTOK;
1864         }
1865         goto ready_to_go;
1866     }
1867
1868     if (*file == NULL) {
1869         ce->ce_file = add (m_scratch ("", tmp), NULL);
1870         ce->ce_unlink = 1;
1871     } else {
1872         ce->ce_file = add (*file, NULL);
1873         ce->ce_unlink = 0;
1874     }
1875
1876     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
1877         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
1878         return NOTOK;
1879     }
1880
1881     if ((len = ct->c_end - ct->c_begin) < 0)
1882         adios (NULL, "internal error(1)");
1883
1884     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
1885         content_error (ct->c_file, ct, "unable to open for reading");
1886         return NOTOK;
1887     }
1888
1889     if ((digested = ct->c_digested))
1890         MD5Init (&mdContext);
1891
1892     bitno = 18;
1893     bits = 0L;
1894     skip = 0;
1895
1896     lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
1897     while (len > 0) {
1898         switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
1899         case NOTOK:
1900             content_error (ct->c_file, ct, "error reading from");
1901             goto clean_up;
1902
1903         case OK:
1904             content_error (NULL, ct, "premature eof");
1905             goto clean_up;
1906
1907         default:
1908             if (cc > len)
1909                 cc = len;
1910             len -= cc;
1911
1912             for (ep = (cp = buffer) + cc; cp < ep; cp++) {
1913                 switch (*cp) {
1914                 default:
1915                     if (isspace (*cp))
1916                         break;
1917                     if (skip || (*cp & 0x80)
1918                         || (value = b642nib[*cp & 0x7f]) > 0x3f) {
1919                         if (debugsw) {
1920                             fprintf (stderr, "*cp=0x%x pos=%ld skip=%d\n",
1921                                 *cp,
1922                                 (long) (lseek (fd, (off_t) 0, SEEK_CUR) - (ep - cp)),
1923                                 skip);
1924                         }
1925                         content_error (NULL, ct,
1926                                        "invalid BASE64 encoding -- continuing");
1927                         continue;
1928                     }
1929
1930                     bits |= value << bitno;
1931 test_end:
1932                     if ((bitno -= 6) < 0) {
1933                         putc ((char) *b1, ce->ce_fp);
1934                         if (digested)
1935                             MD5Update (&mdContext, b1, 1);
1936                         if (skip < 2) {
1937                             putc ((char) *b2, ce->ce_fp);
1938                             if (digested)
1939                                 MD5Update (&mdContext, b2, 1);
1940                             if (skip < 1) {
1941                                 putc ((char) *b3, ce->ce_fp);
1942                                 if (digested)
1943                                     MD5Update (&mdContext, b3, 1);
1944                             }
1945                         }
1946
1947                         if (ferror (ce->ce_fp)) {
1948                             content_error (ce->ce_file, ct,
1949                                            "error writing to");
1950                             goto clean_up;
1951                         }
1952                         bitno = 18, bits = 0L, skip = 0;
1953                     }
1954                     break;
1955
1956                 case '=':
1957                     if (++skip > 3)
1958                         goto self_delimiting;
1959                     goto test_end;
1960                 }
1961             }
1962         }
1963     }
1964
1965     if (bitno != 18) {
1966         if (debugsw)
1967             fprintf (stderr, "premature ending (bitno %d)\n", bitno);
1968
1969         content_error (NULL, ct, "invalid BASE64 encoding");
1970         goto clean_up;
1971     }
1972
1973 self_delimiting:
1974     fseek (ct->c_fp, 0L, SEEK_SET);
1975
1976     if (fflush (ce->ce_fp)) {
1977         content_error (ce->ce_file, ct, "error writing to");
1978         goto clean_up;
1979     }
1980
1981     if (digested) {
1982         unsigned char digest[16];
1983
1984         MD5Final (digest, &mdContext);
1985         if (memcmp((char *) digest, (char *) ct->c_digest,
1986                    sizeof(digest) / sizeof(digest[0])))
1987             content_error (NULL, ct,
1988                            "content integrity suspect (digest mismatch) -- continuing");
1989         else
1990             if (debugsw)
1991                 fprintf (stderr, "content integrity confirmed\n");
1992     }
1993
1994     fseek (ce->ce_fp, 0L, SEEK_SET);
1995
1996 ready_to_go:
1997     *file = ce->ce_file;
1998     return fileno (ce->ce_fp);
1999
2000 clean_up:
2001     free_encoding (ct, 0);
2002     return NOTOK;
2003 }
2004
2005
2006 /*
2007  * QUOTED PRINTABLE
2008  */
2009
2010 static char hex2nib[0x80] = {
2011     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2012     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2013     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2014     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2015     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2016     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2017     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2018     0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2019     0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
2020     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2021     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2022     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2023     0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
2024     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2025     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2026     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2027 };
2028
2029
2030 static int
2031 InitQuoted (CT ct)
2032 {
2033     return init_encoding (ct, openQuoted);
2034 }
2035
2036
2037 static int
2038 openQuoted (CT ct, char **file)
2039 {
2040     int cc, digested, len, quoted;
2041     char *cp, *ep;
2042     char buffer[BUFSIZ];
2043     unsigned char mask;
2044     CE ce;
2045     MD5_CTX mdContext;
2046
2047     ce = ct->c_cefile;
2048     if (ce->ce_fp) {
2049         fseek (ce->ce_fp, 0L, SEEK_SET);
2050         goto ready_to_go;
2051     }
2052
2053     if (ce->ce_file) {
2054         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2055             content_error (ce->ce_file, ct, "unable to fopen for reading");
2056             return NOTOK;
2057         }
2058         goto ready_to_go;
2059     }
2060
2061     if (*file == NULL) {
2062         ce->ce_file = add (m_scratch ("", tmp), NULL);
2063         ce->ce_unlink = 1;
2064     } else {
2065         ce->ce_file = add (*file, NULL);
2066         ce->ce_unlink = 0;
2067     }
2068
2069     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2070         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2071         return NOTOK;
2072     }
2073
2074     if ((len = ct->c_end - ct->c_begin) < 0)
2075         adios (NULL, "internal error(2)");
2076
2077     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2078         content_error (ct->c_file, ct, "unable to open for reading");
2079         return NOTOK;
2080     }
2081
2082     if ((digested = ct->c_digested))
2083         MD5Init (&mdContext);
2084
2085     quoted = 0;
2086 #ifdef lint
2087     mask = 0;
2088 #endif
2089
2090     fseek (ct->c_fp, ct->c_begin, SEEK_SET);
2091     while (len > 0) {
2092         char *dp;
2093
2094         if (fgets (buffer, sizeof(buffer) - 1, ct->c_fp) == NULL) {
2095             content_error (NULL, ct, "premature eof");
2096             goto clean_up;
2097         }
2098
2099         if ((cc = strlen (buffer)) > len)
2100             cc = len;
2101         len -= cc;
2102
2103         for (ep = (cp = buffer) + cc - 1; cp <= ep; ep--)
2104             if (!isspace (*ep))
2105                 break;
2106         *++ep = '\n', ep++;
2107
2108         for (; cp < ep; cp++) {
2109             if (quoted) {
2110                 if (quoted > 1) {
2111                     if (!isxdigit (*cp)) {
2112 invalid_hex:
2113                         dp = "expecting hexidecimal-digit";
2114                         goto invalid_encoding;
2115                     }
2116                     mask <<= 4;
2117                     mask |= hex2nib[*cp & 0x7f];
2118                     putc (mask, ce->ce_fp);
2119                     if (digested)
2120                         MD5Update (&mdContext, &mask, 1);
2121                 } else {
2122                     switch (*cp) {
2123                     case ':':
2124                         putc (*cp, ce->ce_fp);
2125                         if (digested)
2126                             MD5Update (&mdContext, (unsigned char *) ":", 1);
2127                         break;
2128
2129                     default:
2130                         if (!isxdigit (*cp))
2131                             goto invalid_hex;
2132                         mask = hex2nib[*cp & 0x7f];
2133                         quoted = 2;
2134                         continue;
2135                     }
2136                 }
2137
2138                 if (ferror (ce->ce_fp)) {
2139                     content_error (ce->ce_file, ct, "error writing to");
2140                     goto clean_up;
2141                 }
2142                 quoted = 0;
2143                 continue;
2144             }
2145
2146             switch (*cp) {
2147             default:
2148                 if (*cp < '!' || *cp > '~') {
2149                     int i;
2150                     dp = "expecting character in range [!..~]";
2151
2152 invalid_encoding:
2153                     i = strlen (invo_name) + 2;
2154                     content_error (NULL, ct,
2155                                    "invalid QUOTED-PRINTABLE encoding -- %s,\n%*.*sbut got char 0x%x",
2156                                    dp, i, i, "", *cp);
2157                     goto clean_up;
2158                 }
2159                 /* and fall...*/
2160             case ' ':
2161             case '\t':
2162             case '\n':
2163                 putc (*cp, ce->ce_fp);
2164                 if (digested) {
2165                     if (*cp == '\n')
2166                         MD5Update (&mdContext, (unsigned char *) "\r\n",2);
2167                     else
2168                         MD5Update (&mdContext, (unsigned char *) cp, 1);
2169                 }
2170                 if (ferror (ce->ce_fp)) {
2171                     content_error (ce->ce_file, ct, "error writing to");
2172                     goto clean_up;
2173                 }
2174                 break;
2175
2176             case '=':
2177                 if (*++cp != '\n') {
2178                     quoted = 1;
2179                     cp--;
2180                 }
2181                 break;
2182             }
2183         }
2184     }
2185     if (quoted) {
2186         content_error (NULL, ct,
2187                        "invalid QUOTED-PRINTABLE encoding -- end-of-content while still quoting");
2188         goto clean_up;
2189     }
2190
2191     fseek (ct->c_fp, 0L, SEEK_SET);
2192
2193     if (fflush (ce->ce_fp)) {
2194         content_error (ce->ce_file, ct, "error writing to");
2195         goto clean_up;
2196     }
2197
2198     if (digested) {
2199         unsigned char digest[16];
2200
2201         MD5Final (digest, &mdContext);
2202         if (memcmp((char *) digest, (char *) ct->c_digest,
2203                    sizeof(digest) / sizeof(digest[0])))
2204             content_error (NULL, ct,
2205                            "content integrity suspect (digest mismatch) -- continuing");
2206         else
2207             if (debugsw)
2208                 fprintf (stderr, "content integrity confirmed\n");
2209     }
2210
2211     fseek (ce->ce_fp, 0L, SEEK_SET);
2212
2213 ready_to_go:
2214     *file = ce->ce_file;
2215     return fileno (ce->ce_fp);
2216
2217 clean_up:
2218     free_encoding (ct, 0);
2219     return NOTOK;
2220 }
2221
2222
2223 /*
2224  * 7BIT
2225  */
2226
2227 static int
2228 Init7Bit (CT ct)
2229 {
2230     if (init_encoding (ct, open7Bit) == NOTOK)
2231         return NOTOK;
2232
2233     ct->c_cesizefnx = NULL;     /* no need to decode for real size */
2234     return OK;
2235 }
2236
2237
2238 static int
2239 open7Bit (CT ct, char **file)
2240 {
2241     int cc, fd, len;
2242     char buffer[BUFSIZ];
2243     CE ce;
2244
2245     ce = ct->c_cefile;
2246     if (ce->ce_fp) {
2247         fseek (ce->ce_fp, 0L, SEEK_SET);
2248         goto ready_to_go;
2249     }
2250
2251     if (ce->ce_file) {
2252         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2253             content_error (ce->ce_file, ct, "unable to fopen for reading");
2254             return NOTOK;
2255         }
2256         goto ready_to_go;
2257     }
2258
2259     if (*file == NULL) {
2260         ce->ce_file = add (m_scratch ("", tmp), NULL);
2261         ce->ce_unlink = 1;
2262     } else {
2263         ce->ce_file = add (*file, NULL);
2264         ce->ce_unlink = 0;
2265     }
2266
2267     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2268         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2269         return NOTOK;
2270     }
2271
2272     if (ct->c_type == CT_MULTIPART) {
2273         char **ap, **ep;
2274         CI ci = &ct->c_ctinfo;
2275
2276         len = 0;
2277         fprintf (ce->ce_fp, "%s: %s/%s", TYPE_FIELD, ci->ci_type, ci->ci_subtype);
2278         len += strlen (TYPE_FIELD) + 2 + strlen (ci->ci_type)
2279             + 1 + strlen (ci->ci_subtype);
2280         for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
2281             putc (';', ce->ce_fp);
2282             len++;
2283
2284             snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
2285
2286             if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
2287                 fputs ("\n\t", ce->ce_fp);
2288                 len = 8;
2289             } else {
2290                 putc (' ', ce->ce_fp);
2291                 len++;
2292             }
2293             fprintf (ce->ce_fp, "%s", buffer);
2294             len += cc;
2295         }
2296
2297         if (ci->ci_comment) {
2298             if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
2299                 fputs ("\n\t", ce->ce_fp);
2300                 len = 8;
2301             }
2302             else {
2303                 putc (' ', ce->ce_fp);
2304                 len++;
2305             }
2306             fprintf (ce->ce_fp, "(%s)", ci->ci_comment);
2307             len += cc;
2308         }
2309         fprintf (ce->ce_fp, "\n");
2310         if (ct->c_id)
2311             fprintf (ce->ce_fp, "%s:%s", ID_FIELD, ct->c_id);
2312         if (ct->c_descr)
2313             fprintf (ce->ce_fp, "%s:%s", DESCR_FIELD, ct->c_descr);
2314         fprintf (ce->ce_fp, "\n");
2315     }
2316
2317     if ((len = ct->c_end - ct->c_begin) < 0)
2318         adios (NULL, "internal error(3)");
2319
2320     if (!ct->c_fp && (ct->c_fp = fopen (ct->c_file, "r")) == NULL) {
2321         content_error (ct->c_file, ct, "unable to open for reading");
2322         return NOTOK;
2323     }
2324
2325     lseek (fd = fileno (ct->c_fp), (off_t) ct->c_begin, SEEK_SET);
2326     while (len > 0)
2327         switch (cc = read (fd, buffer, sizeof(buffer) - 1)) {
2328         case NOTOK:
2329             content_error (ct->c_file, ct, "error reading from");
2330             goto clean_up;
2331
2332         case OK:
2333             content_error (NULL, ct, "premature eof");
2334             goto clean_up;
2335
2336         default:
2337             if (cc > len)
2338                 cc = len;
2339             len -= cc;
2340
2341             fwrite (buffer, sizeof(*buffer), cc, ce->ce_fp);
2342             if (ferror (ce->ce_fp)) {
2343                 content_error (ce->ce_file, ct, "error writing to");
2344                 goto clean_up;
2345             }
2346         }
2347
2348     fseek (ct->c_fp, 0L, SEEK_SET);
2349
2350     if (fflush (ce->ce_fp)) {
2351         content_error (ce->ce_file, ct, "error writing to");
2352         goto clean_up;
2353     }
2354
2355     fseek (ce->ce_fp, 0L, SEEK_SET);
2356
2357 ready_to_go:
2358     *file = ce->ce_file;
2359     return fileno (ce->ce_fp);
2360
2361 clean_up:
2362     free_encoding (ct, 0);
2363     return NOTOK;
2364 }
2365
2366
2367 /*
2368  * External
2369  */
2370
2371 static int
2372 openExternal (CT ct, CT cb, CE ce, char **file, int *fd)
2373 {
2374     char cachefile[BUFSIZ];
2375
2376     if (ce->ce_fp) {
2377         fseek (ce->ce_fp, 0L, SEEK_SET);
2378         goto ready_already;
2379     }
2380
2381     if (ce->ce_file) {
2382         if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2383             content_error (ce->ce_file, ct, "unable to fopen for reading");
2384             return NOTOK;
2385         }
2386         goto ready_already;
2387     }
2388
2389     if (find_cache (ct, rcachesw, (int *) 0, cb->c_id,
2390                 cachefile, sizeof(cachefile)) != NOTOK) {
2391         if ((ce->ce_fp = fopen (cachefile, "r"))) {
2392             ce->ce_file = getcpy (cachefile);
2393             ce->ce_unlink = 0;
2394             goto ready_already;
2395         } else {
2396             admonish (cachefile, "unable to fopen for reading");
2397         }
2398     }
2399
2400     return OK;
2401
2402 ready_already:
2403     *file = ce->ce_file;
2404     *fd = fileno (ce->ce_fp);
2405     return DONE;
2406 }
2407
2408 /*
2409  * File
2410  */
2411
2412 static int
2413 InitFile (CT ct)
2414 {
2415     return init_encoding (ct, openFile);
2416 }
2417
2418
2419 static int
2420 openFile (CT ct, char **file)
2421 {
2422     int fd, cachetype;
2423     char cachefile[BUFSIZ];
2424     struct exbody *e = ct->c_ctexbody;
2425     CE ce = ct->c_cefile;
2426
2427     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2428         case NOTOK:
2429             return NOTOK;
2430
2431         case OK:
2432             break;
2433
2434         case DONE:
2435             return fd;
2436     }
2437
2438     if (!e->eb_name) {
2439         content_error (NULL, ct, "missing name parameter");
2440         return NOTOK;
2441     }
2442
2443     ce->ce_file = getcpy (e->eb_name);
2444     ce->ce_unlink = 0;
2445
2446     if ((ce->ce_fp = fopen (ce->ce_file, "r")) == NULL) {
2447         content_error (ce->ce_file, ct, "unable to fopen for reading");
2448         return NOTOK;
2449     }
2450
2451     if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2452             && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2453                 cachefile, sizeof(cachefile)) != NOTOK) {
2454         int mask;
2455         FILE *fp;
2456
2457         mask = umask (cachetype ? ~m_gmprot () : 0222);
2458         if ((fp = fopen (cachefile, "w"))) {
2459             int cc;
2460             char buffer[BUFSIZ];
2461             FILE *gp = ce->ce_fp;
2462
2463             fseek (gp, 0L, SEEK_SET);
2464
2465             while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2466                        > 0)
2467                 fwrite (buffer, sizeof(*buffer), cc, fp);
2468             fflush (fp);
2469
2470             if (ferror (gp)) {
2471                 admonish (ce->ce_file, "error reading");
2472                 unlink (cachefile);
2473             }
2474             else
2475                 if (ferror (fp)) {
2476                     admonish (cachefile, "error writing");
2477                     unlink (cachefile);
2478                 }
2479             fclose (fp);
2480         }
2481         umask (mask);
2482     }
2483
2484     fseek (ce->ce_fp, 0L, SEEK_SET);
2485     *file = ce->ce_file;
2486     return fileno (ce->ce_fp);
2487 }
2488
2489 /*
2490  * FTP
2491  */
2492
2493 static int
2494 InitFTP (CT ct)
2495 {
2496     return init_encoding (ct, openFTP);
2497 }
2498
2499
2500 static int
2501 openFTP (CT ct, char **file)
2502 {
2503     int cachetype, caching, fd;
2504     int len, buflen;
2505     char *bp, *ftp, *user, *pass;
2506     char buffer[BUFSIZ], cachefile[BUFSIZ];
2507     struct exbody *e;
2508     CE ce;
2509     static char *username = NULL;
2510     static char *password = NULL;
2511
2512     e  = ct->c_ctexbody;
2513     ce = ct->c_cefile;
2514
2515     if ((ftp = context_find (nmhaccessftp)) && !*ftp)
2516         ftp = NULL;
2517
2518 #ifndef BUILTIN_FTP
2519     if (!ftp)
2520         return NOTOK;
2521 #endif
2522
2523     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2524         case NOTOK:
2525             return NOTOK;
2526
2527         case OK:
2528             break;
2529
2530         case DONE:
2531             return fd;
2532     }
2533
2534     if (!e->eb_name || !e->eb_site) {
2535         content_error (NULL, ct, "missing %s parameter",
2536                        e->eb_name ? "site": "name");
2537         return NOTOK;
2538     }
2539
2540     if (xpid) {
2541         if (xpid < 0)
2542             xpid = -xpid;
2543         pidcheck (pidwait (xpid, NOTOK));
2544         xpid = 0;
2545     }
2546
2547     /* Get the buffer ready to go */
2548     bp = buffer;
2549     buflen = sizeof(buffer);
2550
2551     /*
2552      * Construct the query message for user
2553      */
2554     snprintf (bp, buflen, "Retrieve %s", e->eb_name);
2555     len = strlen (bp);
2556     bp += len;
2557     buflen -= len;
2558
2559     if (e->eb_partno) {
2560         snprintf (bp, buflen, " (content %s)", e->eb_partno);
2561         len = strlen (bp);
2562         bp += len;
2563         buflen -= len;
2564     }
2565
2566     snprintf (bp, buflen, "\n    using %sFTP from site %s",
2567                     e->eb_flags ? "anonymous " : "", e->eb_site);
2568     len = strlen (bp);
2569     bp += len;
2570     buflen -= len;
2571
2572     if (e->eb_size > 0) {
2573         snprintf (bp, buflen, " (%lu octets)", e->eb_size);
2574         len = strlen (bp);
2575         bp += len;
2576         buflen -= len;
2577     }
2578     snprintf (bp, buflen, "? ");
2579
2580     /*
2581      * Now, check the answer
2582      */
2583     if (!getanswer (buffer))
2584         return NOTOK;
2585
2586     if (e->eb_flags) {
2587         user = "anonymous";
2588         snprintf (buffer, sizeof(buffer), "%s@%s", getusername (), LocalName ());
2589         pass = buffer;
2590     } else {
2591         ruserpass (e->eb_site, &username, &password);
2592         user = username;
2593         pass = password;
2594     }
2595
2596     ce->ce_unlink = (*file == NULL);
2597     caching = 0;
2598     cachefile[0] = '\0';
2599     if ((!e->eb_permission || strcasecmp (e->eb_permission, "read-write"))
2600             && find_cache (NULL, wcachesw, &cachetype, e->eb_content->c_id,
2601                 cachefile, sizeof(cachefile)) != NOTOK) {
2602         if (*file == NULL) {
2603             ce->ce_unlink = 0;
2604             caching = 1;
2605         }
2606     }
2607
2608     if (*file)
2609         ce->ce_file = add (*file, NULL);
2610     else if (caching)
2611         ce->ce_file = add (cachefile, NULL);
2612     else
2613         ce->ce_file = add (m_scratch ("", tmp), NULL);
2614
2615     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2616         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2617         return NOTOK;
2618     }
2619
2620 #ifdef BUILTIN_FTP
2621     if (ftp)
2622 #endif
2623     {
2624         int child_id, i, vecp;
2625         char *vec[9];
2626
2627         vecp = 0;
2628         vec[vecp++] = r1bindex (ftp, '/');
2629         vec[vecp++] = e->eb_site;
2630         vec[vecp++] = user;
2631         vec[vecp++] = pass;
2632         vec[vecp++] = e->eb_dir;
2633         vec[vecp++] = e->eb_name;
2634         vec[vecp++] = ce->ce_file,
2635         vec[vecp++] = e->eb_mode && !strcasecmp (e->eb_mode, "ascii")
2636                         ? "ascii" : "binary";
2637         vec[vecp] = NULL;
2638
2639         fflush (stdout);
2640
2641         for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
2642             sleep (5);
2643         switch (child_id) {
2644             case NOTOK:
2645                 adios ("fork", "unable to");
2646                 /* NOTREACHED */
2647
2648             case OK:
2649                 close (fileno (ce->ce_fp));
2650                 execvp (ftp, vec);
2651                 fprintf (stderr, "unable to exec ");
2652                 perror (ftp);
2653                 _exit (-1);
2654                 /* NOTREACHED */
2655
2656             default:
2657                 if (pidXwait (child_id, NULL)) {
2658 #ifdef BUILTIN_FTP
2659 losing_ftp:
2660 #endif
2661                     username = password = NULL;
2662                     ce->ce_unlink = 1;
2663                     return NOTOK;
2664                 }
2665                 break;
2666         }
2667     }
2668 #ifdef BUILTIN_FTP
2669     else
2670         if (ftp_get (e->eb_site, user, pass, e->eb_dir, e->eb_name,
2671                      ce->ce_file,
2672                      e->eb_mode && !strcasecmp (e->eb_mode, "ascii"), 0)
2673                 == NOTOK)
2674             goto losing_ftp;
2675 #endif
2676
2677     if (cachefile[0]) {
2678         if (caching)
2679             chmod (cachefile, cachetype ? m_gmprot () : 0444);
2680         else {
2681             int mask;
2682             FILE *fp;
2683
2684             mask = umask (cachetype ? ~m_gmprot () : 0222);
2685             if ((fp = fopen (cachefile, "w"))) {
2686                 int cc;
2687                 FILE *gp = ce->ce_fp;
2688
2689                 fseek (gp, 0L, SEEK_SET);
2690
2691                 while ((cc= fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
2692                            > 0)
2693                     fwrite (buffer, sizeof(*buffer), cc, fp);
2694                 fflush (fp);
2695
2696                 if (ferror (gp)) {
2697                     admonish (ce->ce_file, "error reading");
2698                     unlink (cachefile);
2699                 }
2700                 else
2701                     if (ferror (fp)) {
2702                         admonish (cachefile, "error writing");
2703                         unlink (cachefile);
2704                     }
2705                 fclose (fp);
2706             }
2707             umask (mask);
2708         }
2709     }
2710
2711     fseek (ce->ce_fp, 0L, SEEK_SET);
2712     *file = ce->ce_file;
2713     return fileno (ce->ce_fp);
2714 }
2715
2716
2717 /*
2718  * Mail
2719  */
2720
2721 static int
2722 InitMail (CT ct)
2723 {
2724     return init_encoding (ct, openMail);
2725 }
2726
2727
2728 static int
2729 openMail (CT ct, char **file)
2730 {
2731     int child_id, fd, i, vecp;
2732     int len, buflen;
2733     char *bp, buffer[BUFSIZ], *vec[7];
2734     struct exbody *e = ct->c_ctexbody;
2735     CE ce = ct->c_cefile;
2736
2737     switch (openExternal (e->eb_parent, e->eb_content, ce, file, &fd)) {
2738         case NOTOK:
2739             return NOTOK;
2740
2741         case OK:
2742             break;
2743
2744         case DONE:
2745             return fd;
2746     }
2747
2748     if (!e->eb_server) {
2749         content_error (NULL, ct, "missing server parameter");
2750         return NOTOK;
2751     }
2752
2753     if (xpid) {
2754         if (xpid < 0)
2755             xpid = -xpid;
2756         pidcheck (pidwait (xpid, NOTOK));
2757         xpid = 0;
2758     }
2759
2760     /* Get buffer ready to go */
2761     bp = buffer;
2762     buflen = sizeof(buffer);
2763
2764     /* Now construct query message */
2765     snprintf (bp, buflen, "Retrieve content");
2766     len = strlen (bp);
2767     bp += len;
2768     buflen -= len;
2769
2770     if (e->eb_partno) {
2771         snprintf (bp, buflen, " %s", e->eb_partno);
2772         len = strlen (bp);
2773         bp += len;
2774         buflen -= len;
2775     }
2776
2777     snprintf (bp, buflen, " by asking %s\n\n%s\n? ",
2778                     e->eb_server,
2779                     e->eb_subject ? e->eb_subject : e->eb_body);
2780
2781     /* Now, check answer */
2782     if (!getanswer (buffer))
2783         return NOTOK;
2784
2785     vecp = 0;
2786     vec[vecp++] = r1bindex (mailproc, '/');
2787     vec[vecp++] = e->eb_server;
2788     vec[vecp++] = "-subject";
2789     vec[vecp++] = e->eb_subject ? e->eb_subject : "mail-server request";
2790     vec[vecp++] = "-body";
2791     vec[vecp++] = e->eb_body;
2792     vec[vecp] = NULL;
2793
2794     for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
2795         sleep (5);
2796     switch (child_id) {
2797         case NOTOK:
2798             advise ("fork", "unable to");
2799             return NOTOK;
2800
2801         case OK:
2802             execvp (mailproc, vec);
2803             fprintf (stderr, "unable to exec ");
2804             perror (mailproc);
2805             _exit (-1);
2806             /* NOTREACHED */
2807
2808         default:
2809             if (pidXwait (child_id, NULL) == OK)
2810                 advise (NULL, "request sent");
2811             break;
2812     }
2813
2814     if (*file == NULL) {
2815         ce->ce_file = add (m_scratch ("", tmp), NULL);
2816         ce->ce_unlink = 1;
2817     } else {
2818         ce->ce_file = add (*file, NULL);
2819         ce->ce_unlink = 0;
2820     }
2821
2822     if ((ce->ce_fp = fopen (ce->ce_file, "w+")) == NULL) {
2823         content_error (ce->ce_file, ct, "unable to fopen for reading/writing");
2824         return NOTOK;
2825     }
2826
2827     fseek (ce->ce_fp, 0L, SEEK_SET);
2828     *file = ce->ce_file;
2829     return fileno (ce->ce_fp);
2830 }
2831
2832
2833 static char *
2834 fgetstr (char *s, int n, FILE *stream)
2835 {
2836     char *cp, *ep;
2837
2838     for (ep = (cp = s) + n; cp < ep; ) {
2839         int i;
2840
2841         if (!fgets (cp, n, stream))
2842             return (cp != s ? s : NULL);
2843         if (cp == s && *cp != '#')
2844             return s;
2845
2846         cp += (i = strlen (cp)) - 1;
2847         if (i <= 1 || *cp-- != '\n' || *cp != '\\')
2848             break;
2849         *cp = '\0';
2850         n -= (i - 2);
2851     }
2852
2853     return s;
2854 }
2855
2856
2857 /*
2858  * Parse the composition draft for text and directives.
2859  * Do initial setup of Content structure.
2860  */
2861
2862 static int
2863 user_content (FILE *in, char *file, char *buf, CT *ctp)
2864 {
2865     int extrnal, vrsn;
2866     char *cp, **ap;
2867     char buffer[BUFSIZ];
2868     struct multipart *m;
2869     struct part **pp;
2870     struct stat st;
2871     struct str2init *s2i;
2872     CI ci;
2873     CT ct;
2874     CE ce;
2875
2876     if (buf[0] == '\n' || strcmp (buf, "#\n") == 0) {
2877         *ctp = NULL;
2878         return OK;
2879     }
2880
2881     /* allocate basic Content structure */
2882     if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
2883         adios (NULL, "out of memory");
2884     *ctp = ct;
2885
2886     /* allocate basic structure for handling decoded content */
2887     init_decoded_content (ct);
2888     ce = ct->c_cefile;
2889
2890     ci = &ct->c_ctinfo;
2891     set_id (ct, 0);
2892
2893     /*
2894      * Handle inline text.  Check if line
2895      * is one of the following forms:
2896      *
2897      * 1) doesn't begin with '#'        (implicit directive)
2898      * 2) begins with "##"              (implicit directive)
2899      * 3) begins with "#<"
2900      */
2901     if (buf[0] != '#' || buf[1] == '#' || buf[1] == '<') {
2902         int headers;
2903         int inlineD;
2904         long pos;
2905         char content[BUFSIZ];
2906         FILE *out;
2907
2908         /* use a temp file to collect the plain text lines */
2909         ce->ce_file = add (m_tmpfil (invo_name), NULL);
2910         ce->ce_unlink = 1;
2911
2912         if ((out = fopen (ce->ce_file, "w")) == NULL)
2913             adios (ce->ce_file, "unable to open for writing");
2914
2915         if (buf[0] == '#' && buf[1] == '<') {
2916             strncpy (content, buf + 2, sizeof(content));
2917             inlineD = 1;
2918             goto rock_and_roll;
2919         } else {
2920             inlineD = 0;
2921         }
2922
2923         /* the directive is implicit */
2924         strncpy (content, "text/plain", sizeof(content));
2925         headers = 0;
2926         strncpy (buffer, buf[0] != '#' ? buf : buf + 1, sizeof(buffer));
2927         for (;;) {
2928             int i;
2929
2930             if (headers >= 0 && uprf (buffer, DESCR_FIELD)
2931                 && buffer[i = strlen (DESCR_FIELD)] == ':') {
2932                 headers = 1;
2933
2934 again_descr:
2935                 ct->c_descr = add (buffer + i + 1, ct->c_descr);
2936                 if (!fgetstr (buffer, sizeof(buffer) - 1, in))
2937                     adios (NULL, "end-of-file after %s: field in plaintext", DESCR_FIELD);
2938                 switch (buffer[0]) {
2939                 case ' ':
2940                 case '\t':
2941                     i = -1;
2942                     goto again_descr;
2943
2944                 case '#':
2945                     adios (NULL, "#-directive after %s: field in plaintext", DESCR_FIELD);
2946                     /* NOTREACHED */
2947
2948                 default:
2949                     break;
2950                 }
2951             }
2952
2953             if (headers != 1 || buffer[0] != '\n')
2954                 fputs (buffer, out);
2955
2956 rock_and_roll:
2957             headers = -1;
2958             pos = ftell (in);
2959             if ((cp = fgetstr (buffer, sizeof(buffer) - 1, in)) == NULL)
2960                 break;
2961             if (buffer[0] == '#') {
2962                 char *bp;
2963
2964                 if (buffer[1] != '#')
2965                     break;
2966                 for (cp = (bp = buffer) + 1; *cp; cp++)
2967                     *bp++ = *cp;
2968                 *bp = '\0';
2969             }
2970         }
2971
2972         if (listsw)
2973             ct->c_end = ftell (out);
2974         fclose (out);
2975
2976         /* parse content type */
2977         if (get_ctinfo (content, ct, inlineD) == NOTOK)
2978             done (1);
2979
2980         for (s2i = str2cts; s2i->si_key; s2i++)
2981             if (!strcasecmp (ci->ci_type, s2i->si_key))
2982                 break;
2983         if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
2984             s2i++;
2985
2986         /*
2987          * check type specified (possibly implicitly)
2988          */
2989         switch (ct->c_type = s2i->si_val) {
2990         case CT_MESSAGE:
2991             if (!strcasecmp (ci->ci_subtype, "rfc822")) {
2992                 ct->c_encoding = CE_7BIT;
2993                 goto call_init;
2994             }
2995             /* else fall... */
2996         case CT_MULTIPART:
2997             adios (NULL, "it doesn't make sense to define an in-line %s content",
2998                    ct->c_type == CT_MESSAGE ? "message" : "multipart");
2999             /* NOTREACHED */
3000
3001         default:
3002 call_init:
3003             if ((ct->c_ctinitfnx = s2i->si_init))
3004                 (*ct->c_ctinitfnx) (ct);
3005             break;
3006         }
3007
3008         if (cp)
3009             fseek (in, pos, SEEK_SET);
3010         return OK;
3011     }
3012
3013     /*
3014      * If we've reached this point, the next line
3015      * must be some type of explicit directive.
3016      */
3017
3018     /* check if directive is external-type */
3019     extrnal = (buf[1] == '@');
3020
3021     /* parse directive */
3022     if (get_ctinfo (buf + (extrnal ? 2 : 1), ct, 1) == NOTOK)
3023         done (1);
3024
3025     /* check directive against the list of MIME types */
3026     for (s2i = str2cts; s2i->si_key; s2i++)
3027         if (!strcasecmp (ci->ci_type, s2i->si_key))
3028             break;
3029
3030     /*
3031      * Check if the directive specified a valid type.
3032      * This will happen if it was one of the following forms:
3033      *
3034      *    #type/subtype  (or)
3035      *    #@type/subtype
3036      */
3037     if (s2i->si_key) {
3038         if (!ci->ci_subtype)
3039             adios (NULL, "missing subtype in \"#%s\"", ci->ci_type);
3040
3041         switch (ct->c_type = s2i->si_val) {
3042         case CT_MULTIPART:
3043             adios (NULL, "use \"#begin ... #end\" instead of \"#%s/%s\"",
3044                    ci->ci_type, ci->ci_subtype);
3045             /* NOTREACHED */
3046
3047         case CT_MESSAGE:
3048             if (!strcasecmp (ci->ci_subtype, "partial"))
3049                 adios (NULL, "sorry, \"#%s/%s\" isn't supported",
3050                        ci->ci_type, ci->ci_subtype);
3051             if (!strcasecmp (ci->ci_subtype, "external-body"))
3052                 adios (NULL, "use \"#@type/subtype ... [] ...\" instead of \"#%s/%s\"",
3053                        ci->ci_type, ci->ci_subtype);
3054 use_forw:
3055             adios (NULL,
3056                    "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"",
3057                    ci->ci_type, ci->ci_subtype);
3058             /* NOTREACHED */
3059
3060         default:
3061             if ((ct->c_ctinitfnx = s2i->si_init))
3062                 (*ct->c_ctinitfnx) (ct);
3063             break;
3064         }
3065
3066         /*
3067          * #@type/subtype (external types directive)
3068          */
3069         if (extrnal) {
3070             struct exbody *e;
3071             CT p;
3072
3073             if (!ci->ci_magic)
3074                 adios (NULL, "need external information for \"#@%s/%s\"",
3075                        ci->ci_type, ci->ci_subtype);
3076             p = ct;
3077
3078             snprintf (buffer, sizeof(buffer), "message/external-body; %s", ci->ci_magic);
3079             free (ci->ci_magic);
3080             ci->ci_magic = NULL;
3081
3082             /*
3083              * Since we are using the current Content structure to
3084              * hold information about the type of the external
3085              * reference, we need to create another Content structure
3086              * for the message/external-body to wrap it in.
3087              */
3088             if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
3089                 adios (NULL, "out of memory");
3090             *ctp = ct;
3091             ci = &ct->c_ctinfo;
3092             if (get_ctinfo (buffer, ct, 0) == NOTOK)
3093                 done (1);
3094             ct->c_type = CT_MESSAGE;
3095             ct->c_subtype = MESSAGE_EXTERNAL;
3096
3097             if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
3098                 adios (NULL, "out of memory");
3099             ct->c_ctparams = (void *) e;
3100
3101             e->eb_parent = ct;
3102             e->eb_content = p;
3103             p->c_ctexbody = e;
3104
3105             if (params_external (ct, 1) == NOTOK)
3106                 done (1);
3107
3108             return OK;
3109         }
3110
3111         /* Handle [file] argument */
3112         if (ci->ci_magic) {
3113             /* check if specifies command to execute */
3114             if (*ci->ci_magic == '|' || *ci->ci_magic == '!') {
3115                 for (cp = ci->ci_magic + 1; isspace (*cp); cp++)
3116                     continue;
3117                 if (!*cp)
3118                     adios (NULL, "empty pipe command for #%s directive", ci->ci_type);
3119                 cp = add (cp, NULL);
3120                 free (ci->ci_magic);
3121                 ci->ci_magic = cp;
3122             } else {
3123                 /* record filename of decoded contents */
3124                 ce->ce_file = ci->ci_magic;
3125                 if (access (ce->ce_file, R_OK) == NOTOK)
3126                     adios ("reading", "unable to access %s for", ce->ce_file);
3127                 if (listsw && stat (ce->ce_file, &st) != NOTOK)
3128                     ct->c_end = (long) st.st_size;
3129                 ci->ci_magic = NULL;
3130             }
3131             return OK;
3132         }
3133
3134         /*
3135          * No [file] argument, so check profile for
3136          * method to compose content.
3137          */
3138         snprintf (buffer, sizeof(buffer), "%s-compose-%s/%s",
3139                 invo_name, ci->ci_type, ci->ci_subtype);
3140         if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
3141             snprintf (buffer, sizeof(buffer), "%s-compose-%s", invo_name, ci->ci_type);
3142             if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
3143                 content_error (NULL, ct, "don't know how to compose content");
3144                 done (1);
3145             }
3146         }
3147         ci->ci_magic = add (cp, NULL);
3148         return OK;
3149     }
3150
3151     if (extrnal)
3152         adios (NULL, "external definition not allowed for \"#%s\"", ci->ci_type);
3153
3154     /*
3155      * Message directive
3156      * #forw [+folder] [msgs]
3157      */
3158     if (!strcasecmp (ci->ci_type, "forw")) {
3159         int msgnum;
3160         char *folder, *arguments[MAXARGS];
3161         struct msgs *mp;
3162
3163         if (ci->ci_magic) {
3164             ap = brkstring (ci->ci_magic, " ", "\n");
3165             copyip (ap, arguments, MAXARGS);
3166         } else {
3167             arguments[0] = "cur";
3168             arguments[1] = NULL;
3169         }
3170         folder = NULL;
3171
3172         /* search the arguments for a folder name */
3173         for (ap = arguments; *ap; ap++) {
3174             cp = *ap;
3175             if (*cp == '+' || *cp == '@') {
3176                 if (folder)
3177                     adios (NULL, "only one folder per #forw directive");
3178                 else
3179                     folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
3180             }
3181         }
3182
3183         /* else, use the current folder */
3184         if (!folder)
3185             folder = add (getfolder (1), NULL);
3186
3187         if (!(mp = folder_read (folder)))
3188             adios (NULL, "unable to read folder %s", folder);
3189         for (ap = arguments; *ap; ap++) {
3190             cp = *ap;
3191             if (*cp != '+' && *cp != '@')
3192                 if (!m_convert (mp, cp))
3193                     done (1);
3194         }
3195         free (folder);
3196         free_ctinfo (ct);
3197
3198         /*
3199          * If there is more than one message to include, make this
3200          * a content of type "multipart/digest" and insert each message
3201          * as a subpart.  If there is only one message, then make this
3202          * a content of type "message/rfc822".
3203          */
3204         if (mp->numsel > 1) {
3205             /* we are forwarding multiple messages */
3206             if (get_ctinfo ("multipart/digest", ct, 0) == NOTOK)
3207                 done (1);
3208             ct->c_type = CT_MULTIPART;
3209             ct->c_subtype = MULTI_DIGEST;
3210
3211             if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
3212                 adios (NULL, "out of memory");
3213             ct->c_ctparams = (void *) m;
3214             pp = &m->mp_parts;
3215
3216             for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
3217                 if (is_selected(mp, msgnum)) {
3218                     struct part *part;
3219                     CT p;
3220                     CE pe;
3221
3222                     if ((p = (CT) calloc (1, sizeof(*p))) == NULL)
3223                         adios (NULL, "out of memory");
3224                     init_decoded_content (p);
3225                     pe = p->c_cefile;
3226                     if (get_ctinfo ("message/rfc822", p, 0) == NOTOK)
3227                         done (1);
3228                     p->c_type = CT_MESSAGE;
3229                     p->c_subtype = MESSAGE_RFC822;
3230
3231                     snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
3232                     pe->ce_file = add (buffer, NULL);
3233                     if (listsw && stat (pe->ce_file, &st) != NOTOK)
3234                         p->c_end = (long) st.st_size;
3235
3236                     if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
3237                         adios (NULL, "out of memory");
3238                     *pp = part;
3239                     pp = &part->mp_next;
3240                     part->mp_part = p;
3241                 }
3242             }
3243         } else {
3244             /* we are forwarding one message */
3245             if (get_ctinfo ("message/rfc822", ct, 0) == NOTOK)
3246                 done (1);
3247             ct->c_type = CT_MESSAGE;
3248             ct->c_subtype = MESSAGE_RFC822;
3249
3250             msgnum = mp->lowsel;
3251             snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
3252             ce->ce_file = add (buffer, NULL);
3253             if (listsw && stat (ce->ce_file, &st) != NOTOK)
3254                 ct->c_end = (long) st.st_size;
3255         }
3256
3257         folder_free (mp);       /* free folder/message structure */
3258         return OK;
3259     }
3260
3261     /*
3262      * #end
3263      */
3264     if (!strcasecmp (ci->ci_type, "end")) {
3265         free_content (ct);
3266         *ctp = NULL;
3267         return DONE;
3268     }
3269
3270     /*
3271      * #begin [ alternative | parallel ]
3272      */
3273     if (!strcasecmp (ci->ci_type, "begin")) {
3274         if (!ci->ci_magic) {
3275             vrsn = MULTI_MIXED;
3276             cp = SubMultiPart[vrsn - 1].kv_key;
3277         } else if (!strcasecmp (ci->ci_magic, "alternative")) {
3278             vrsn = MULTI_ALTERNATE;
3279             cp = SubMultiPart[vrsn - 1].kv_key;
3280         } else if (!strcasecmp (ci->ci_magic, "parallel")) {
3281             vrsn = MULTI_PARALLEL;
3282             cp = SubMultiPart[vrsn - 1].kv_key;
3283         } else if (uprf (ci->ci_magic, "digest")) {
3284             goto use_forw;
3285         } else {
3286             vrsn = MULTI_UNKNOWN;
3287             cp = ci->ci_magic;
3288         }
3289
3290         free_ctinfo (ct);
3291         snprintf (buffer, sizeof(buffer), "multipart/%s", cp);
3292         if (get_ctinfo (buffer, ct, 0) == NOTOK)
3293             done (1);
3294         ct->c_type = CT_MULTIPART;
3295         ct->c_subtype = vrsn;
3296
3297         if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
3298             adios (NULL, "out of memory");
3299         ct->c_ctparams = (void *) m;
3300
3301         pp = &m->mp_parts;
3302         while (fgetstr (buffer, sizeof(buffer) - 1, in)) {
3303             struct part *part;
3304             CT p;
3305
3306             if (user_content (in, file, buffer, &p) == DONE) {
3307                 if (!m->mp_parts)
3308                     adios (NULL, "empty \"#begin ... #end\" sequence");
3309                 return OK;
3310             }
3311             if (!p)
3312                 continue;
3313
3314             if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
3315                 adios (NULL, "out of memory");
3316             *pp = part;
3317             pp = &part->mp_next;
3318             part->mp_part = p;
3319         }
3320         admonish (NULL, "premature end-of-file, missing #end");
3321         return OK;
3322     }
3323
3324     /*
3325      * Unknown directive
3326      */
3327     adios (NULL, "unknown directive \"#%s\"", ci->ci_type);
3328     return NOTOK;       /* NOT REACHED */
3329 }
3330
3331
3332 static void
3333 set_id (CT ct, int top)
3334 {
3335     char msgid[BUFSIZ];
3336     static int partno;
3337     static time_t clock = 0;
3338     static char *msgfmt;
3339
3340     if (clock == 0) {
3341         time (&clock);
3342         snprintf (msgid, sizeof(msgid), "<%d.%ld.%%d@%s>\n",
3343                 (int) getpid(), (long) clock, LocalName());
3344         partno = 0;
3345         msgfmt = getcpy(msgid);
3346     }
3347     snprintf (msgid, sizeof(msgid), msgfmt, top ? 0 : ++partno);
3348     ct->c_id = getcpy (msgid);
3349 }
3350
3351
3352 static char ebcdicsafe[0x100] = {
3353     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3354     0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
3355     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3356     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3357     0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
3358     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3359     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3360     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3361     0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3362     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3363     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3364     0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
3365     0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3366     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3367     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
3368     0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
3369     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3370     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3371     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3372     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3373     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3374     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3375     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3376     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3377     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3378     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3379     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3380     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3381     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3382     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3383     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3384     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3385 };
3386
3387
3388 /*
3389  * Fill out, or expand the various contents in the composition
3390  * draft.  Read-in any necessary files.  Parse and execute any
3391  * commands specified by profile composition strings.
3392  */
3393
3394 static int
3395 compose_content (CT ct)
3396 {
3397     CE ce = ct->c_cefile;
3398
3399     switch (ct->c_type) {
3400     case CT_MULTIPART:
3401     {
3402         int partnum;
3403         char *pp;
3404         char partnam[BUFSIZ];
3405         struct multipart *m = (struct multipart *) ct->c_ctparams;
3406         struct part *part;
3407
3408         if (ct->c_partno) {
3409             snprintf (partnam, sizeof(partnam), "%s.", ct->c_partno);
3410             pp = partnam + strlen (partnam);
3411         } else {
3412             pp = partnam;
3413         }
3414
3415         /* first, we call compose_content on all the subparts */
3416         for (part = m->mp_parts, partnum = 1; part; part = part->mp_next, partnum++) {
3417             CT p = part->mp_part;
3418
3419             sprintf (pp, "%d", partnum);
3420             p->c_partno = add (partnam, NULL);
3421             if (compose_content (p) == NOTOK)
3422                 return NOTOK;
3423         }
3424
3425         /*
3426          * If the -rfc934mode switch is given, then check all
3427          * the subparts of a multipart/digest.  If they are all
3428          * message/rfc822, then mark this content and all
3429          * subparts with the rfc934 compatibility mode flag.
3430          */
3431         if (rfc934sw && ct->c_subtype == MULTI_DIGEST) {
3432             int is934 = 1;
3433
3434             for (part = m->mp_parts; part; part = part->mp_next) {
3435                 CT p = part->mp_part;
3436
3437                 if (p->c_subtype != MESSAGE_RFC822) {
3438                     is934 = 0;
3439                     break;
3440                 }
3441             }
3442             ct->c_rfc934 = is934;
3443             for (part = m->mp_parts; part; part = part->mp_next) {
3444                 CT p = part->mp_part;
3445
3446                 if ((p->c_rfc934 = is934))
3447                     p->c_end++;
3448             }
3449         }
3450
3451         if (listsw) {
3452             ct->c_end = (partnum = strlen (prefix) + 2) + 2;
3453             if (ct->c_rfc934)
3454                 ct->c_end += 1;
3455
3456             for (part = m->mp_parts; part; part = part->mp_next)
3457                 ct->c_end += part->mp_part->c_end + partnum;
3458         }
3459     }
3460     break;
3461
3462     case CT_MESSAGE:
3463         /* Nothing to do for type message */
3464         break;
3465
3466     /*
3467      * Discrete types (text/application/audio/image/video)
3468      */
3469     default:
3470         if (!ce->ce_file) {
3471             pid_t child_id;
3472             int i, xstdout, len, buflen;
3473             char *bp, **ap, *cp;
3474             char *vec[4], buffer[BUFSIZ];
3475             FILE *out;
3476             CI ci = &ct->c_ctinfo;
3477
3478             if (!(cp = ci->ci_magic))
3479                 adios (NULL, "internal error(5)");
3480
3481             ce->ce_file = add (m_tmpfil (invo_name), NULL);
3482             ce->ce_unlink = 1;
3483
3484             xstdout = 0;
3485
3486             /* Get buffer ready to go */
3487             bp = buffer;
3488             bp[0] = '\0';
3489             buflen = sizeof(buffer);
3490
3491             /*
3492              * Parse composition string into buffer
3493              */
3494             for ( ; *cp; cp++) {
3495                 if (*cp == '%') {
3496                     switch (*++cp) {
3497                     case 'a':
3498                     {
3499                         /* insert parameters from directive */
3500                         char **ep;
3501                         char *s = "";
3502
3503                         for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
3504                             snprintf (bp, buflen, "%s%s=\"%s\"", s, *ap, *ep);
3505                             len = strlen (bp);
3506                             bp += len;
3507                             buflen -= len;
3508                             s = " ";
3509                         }
3510                     }
3511                     break;
3512
3513                     case 'F':
3514                         /* %f, and stdout is not-redirected */
3515                         xstdout = 1;
3516                         /* and fall... */
3517
3518                     case 'f':
3519                         /*
3520                          * insert temporary filename where
3521                          * content should be written
3522                          */
3523                         snprintf (bp, buflen, "%s", ce->ce_file);
3524                         break;
3525
3526                     case 's':
3527                         /* insert content subtype */
3528                         strncpy (bp, ci->ci_subtype, buflen);
3529                         break;
3530
3531                     case '%':
3532                         /* insert character % */
3533                         goto raw;
3534
3535                     default:
3536                         *bp++ = *--cp;
3537                         *bp = '\0';
3538                         buflen--;
3539                         continue;
3540                     }
3541                     len = strlen (bp);
3542                     bp += len;
3543                     buflen -= len;
3544                 } else {
3545 raw:
3546                 *bp++ = *cp;
3547                 *bp = '\0';
3548                 buflen--;
3549                 }
3550             }
3551
3552             if (verbosw)
3553                 printf ("composing content %s/%s from command\n\t%s\n",
3554                         ci->ci_type, ci->ci_subtype, buffer);
3555
3556             fflush (stdout);    /* not sure if need for -noverbose */
3557
3558             vec[0] = "/bin/sh";
3559             vec[1] = "-c";
3560             vec[2] = buffer;
3561             vec[3] = NULL;
3562
3563             if ((out = fopen (ce->ce_file, "w")) == NULL)
3564                 adios (ce->ce_file, "unable to open for writing");
3565
3566             for (i = 0; (child_id = vfork()) == NOTOK && i > 5; i++)
3567                 sleep (5);
3568             switch (child_id) {
3569             case NOTOK:
3570                 adios ("fork", "unable to fork");
3571                 /* NOTREACHED */
3572
3573             case OK:
3574                 if (!xstdout)
3575                     dup2 (fileno (out), 1);
3576                 close (fileno (out));
3577                 execvp ("/bin/sh", vec);
3578                 fprintf (stderr, "unable to exec ");
3579                 perror ("/bin/sh");
3580                 _exit (-1);
3581                 /* NOTREACHED */
3582
3583             default:
3584                 fclose (out);
3585                 if (pidXwait(child_id, NULL))
3586                     done (1);
3587                 break;
3588             }
3589         }
3590
3591         /* Check size of file */
3592         if (listsw && ct->c_end == 0L) {
3593             struct stat st;
3594
3595             if (stat (ce->ce_file, &st) != NOTOK)
3596                 ct->c_end = (long) st.st_size;
3597         }
3598         break;
3599     }
3600
3601     return OK;
3602 }
3603
3604
3605 /*
3606  * Scan the content.
3607  *
3608  *    1) choose a transfer encoding.
3609  *    2) check for clashes with multipart boundary string.
3610  *    3) for text content, figure out which character set is being used.
3611  *
3612  * If there is a clash with one of the contents and the multipart boundary,
3613  * this function will exit with NOTOK.  This will cause the scanning process
3614  * to be repeated with a different multipart boundary.  It is possible
3615  * (although highly unlikely) that this scan will be repeated multiple times.
3616  */
3617
3618 static int
3619 scan_content (CT ct)
3620 {
3621     int len;
3622     int check8bit, contains8bit = 0;      /* check if contains 8bit data                */
3623     int checklinelen, linelen = 0;        /* check for long lines                       */
3624     int checkboundary, boundaryclash = 0; /* check if clashes with multipart boundary   */
3625     int checklinespace, linespace = 0;    /* check if any line ends with space          */
3626     int checkebcdic, ebcdicunsafe = 0;    /* check if contains ebcdic unsafe characters */
3627     char *cp, buffer[BUFSIZ];
3628     struct text *t;
3629     FILE *in;
3630     CE ce = ct->c_cefile;
3631
3632     /*
3633      * handle multipart by scanning all subparts
3634      * and then checking their encoding.
3635      */
3636     if (ct->c_type == CT_MULTIPART) {
3637         struct multipart *m = (struct multipart *) ct->c_ctparams;
3638         struct part *part;
3639
3640         /* initially mark the domain of enclosing multipart as 7bit */
3641         ct->c_encoding = CE_7BIT;
3642
3643         for (part = m->mp_parts; part; part = part->mp_next) {
3644             CT p = part->mp_part;
3645
3646             if (scan_content (p) == NOTOK)      /* choose encoding for subpart */
3647                 return NOTOK;
3648
3649             /* if necessary, enlarge encoding for enclosing multipart */
3650             if (p->c_encoding == CE_BINARY)
3651                 ct->c_encoding = CE_BINARY;
3652             if (p->c_encoding == CE_8BIT && ct->c_encoding != CE_BINARY)
3653                 ct->c_encoding = CE_8BIT;
3654         }
3655
3656         return OK;
3657     }
3658
3659     /*
3660      * Decide what to check while scanning this content.
3661      */
3662     switch (ct->c_type) {
3663     case CT_TEXT:
3664         check8bit = 1;
3665         checkboundary = 1;
3666         if (ct->c_subtype == TEXT_PLAIN) {
3667             checkebcdic = 0;
3668             checklinelen = 0;
3669             checklinespace = 0;
3670         } else {
3671             checkebcdic = ebcdicsw;
3672             checklinelen = 1;
3673             checklinespace = 1;
3674         }
3675         break;
3676
3677     case CT_APPLICATION:
3678         check8bit = 1;
3679         checkebcdic = ebcdicsw;
3680         checklinelen = 1;
3681         checklinespace = 1;
3682         checkboundary = 1;
3683         break;
3684
3685     case CT_MESSAGE:
3686         check8bit = 0;
3687         checkebcdic = 0;
3688         checklinelen = 0;
3689         checklinespace = 0;
3690
3691         /* don't check anything for message/external */
3692         if (ct->c_subtype == MESSAGE_EXTERNAL)
3693             checkboundary = 0;
3694         else
3695             checkboundary = 1;
3696         break;
3697
3698     case CT_AUDIO:
3699     case CT_IMAGE:
3700     case CT_VIDEO:
3701         /*
3702          * Don't check anything for these types,
3703          * since we are forcing use of base64.
3704          */
3705         check8bit = 0;
3706         checkebcdic = 0;
3707         checklinelen = 0;
3708         checklinespace = 0;
3709         checkboundary = 0;
3710         break;
3711     }
3712
3713     /*
3714      * Scan the unencoded content
3715      */
3716     if (check8bit || checklinelen || checklinespace || checkboundary) {
3717         if ((in = fopen (ce->ce_file, "r")) == NULL)
3718             adios (ce->ce_file, "unable to open for reading");
3719         len = strlen (prefix);
3720
3721         while (fgets (buffer, sizeof(buffer) - 1, in)) {
3722             /*
3723              * Check for 8bit data.
3724              */
3725             if (check8bit) {
3726                 for (cp = buffer; *cp; cp++) {
3727                     if (!isascii (*cp)) {
3728                         contains8bit = 1;
3729                         check8bit = 0;  /* no need to keep checking */
3730                     }
3731                     /*
3732                      * Check if character is ebcdic-safe.  We only check
3733                      * this if also checking for 8bit data.
3734                      */
3735                     if (checkebcdic && !ebcdicsafe[*cp & 0xff]) {
3736                         ebcdicunsafe = 1;
3737                         checkebcdic = 0; /* no need to keep checking */
3738                     }
3739                 }
3740             }
3741
3742             /*
3743              * Check line length.
3744              */
3745             if (checklinelen && (strlen (buffer) > CPERLIN + 1)) {
3746                 linelen = 1;
3747                 checklinelen = 0;       /* no need to keep checking */
3748             }
3749
3750             /*
3751              * Check if line ends with a space.
3752              */
3753             if (checklinespace && (cp = buffer + strlen (buffer) - 2) > buffer && isspace (*cp)) {
3754                 linespace = 1;
3755                 checklinespace = 0;     /* no need to keep checking */
3756             }
3757
3758             /*
3759              * Check if content contains a line that clashes
3760              * with our standard boundary for multipart messages.
3761              */
3762             if (checkboundary && buffer[0] == '-' && buffer[1] == '-') {
3763                 for (cp = buffer + strlen (buffer) - 1; cp >= buffer; cp--)
3764                     if (!isspace (*cp))
3765                         break;
3766                 *++cp = '\0';
3767                 if (!strncmp(buffer + 2, prefix, len) && isdigit(buffer[2 + len])) {
3768                     boundaryclash = 1;
3769                     checkboundary = 0;  /* no need to keep checking */
3770                 }
3771             }
3772         }
3773         fclose (in);
3774     }
3775
3776     /*
3777      * Decide which transfer encoding to use.
3778      */
3779     switch (ct->c_type) {
3780     case CT_TEXT:
3781         /*
3782          * If the text content didn't specify a character
3783          * set, we need to figure out which one was used.
3784          */
3785         t = (struct text *) ct->c_ctparams;
3786         if (t->tx_charset == CHARSET_UNSPECIFIED) {
3787             CI ci = &ct->c_ctinfo;
3788             char **ap, **ep;
3789
3790             for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
3791                 continue;
3792
3793             if (contains8bit) {
3794                 t->tx_charset = CHARSET_UNKNOWN;
3795                 *ap = concat ("charset=", write_charset_8bit(), NULL);
3796             } else {
3797                 t->tx_charset = CHARSET_USASCII;
3798                 *ap = add ("charset=us-ascii", NULL);
3799             }
3800
3801             cp = strchr(*ap++, '=');
3802             *ap = NULL;
3803             *cp++ = '\0';
3804             *ep = cp;
3805         }
3806
3807         if (contains8bit || ebcdicunsafe || linelen || linespace || checksw)
3808             ct->c_encoding = CE_QUOTED;
3809         else
3810             ct->c_encoding = CE_7BIT;
3811         break;
3812
3813     case CT_APPLICATION:
3814         /* For application type, use base64, except when postscript */
3815         if (contains8bit || ebcdicunsafe || linelen || linespace || checksw)
3816             ct->c_encoding = (ct->c_subtype == APPLICATION_POSTSCRIPT)
3817                 ? CE_QUOTED : CE_BASE64;
3818         else
3819             ct->c_encoding = CE_7BIT;
3820         break;
3821
3822     case CT_MESSAGE:
3823         ct->c_encoding = CE_7BIT;
3824         break;
3825
3826     case CT_AUDIO:
3827     case CT_IMAGE:
3828     case CT_VIDEO:
3829         /* For audio, image, and video contents, just use base64 */
3830         ct->c_encoding = CE_BASE64;
3831         break;
3832     }
3833
3834     return (boundaryclash ? NOTOK : OK);
3835 }
3836
3837
3838 /*
3839  * Scan the content structures, and build header
3840  * fields that will need to be output into the
3841  * message.
3842  */
3843
3844 static int
3845 build_headers (CT ct)
3846 {
3847     int cc, mailbody, len;
3848     char **ap, **ep;
3849     char *np, *vp, buffer[BUFSIZ];
3850     CI ci = &ct->c_ctinfo;
3851
3852     /*
3853      * If message is type multipart, then add the multipart
3854      * boundary to the list of attribute/value pairs.
3855      */
3856     if (ct->c_type == CT_MULTIPART) {
3857         char *cp;
3858         static int level = 0;   /* store nesting level */
3859
3860         ap = ci->ci_attrs;
3861         ep = ci->ci_values;
3862         snprintf (buffer, sizeof(buffer), "boundary=%s%d", prefix, level++);
3863         cp = strchr(*ap++ = add (buffer, NULL), '=');
3864         *ap = NULL;
3865         *cp++ = '\0';
3866         *ep = cp;
3867     }
3868
3869     /*
3870      * Skip the output of Content-Type, parameters, content
3871      * description, and Content-ID if the content is of type
3872      * "message" and the rfc934 compatibility flag is set
3873      * (which means we are inside multipart/digest and the
3874      * switch -rfc934mode was given).
3875      */
3876     if (ct->c_type == CT_MESSAGE && ct->c_rfc934)
3877         goto skip_headers;
3878
3879     /*
3880      * output the content type and subtype
3881      */
3882     np = add (TYPE_FIELD, NULL);
3883     vp = concat (" ", ci->ci_type, "/", ci->ci_subtype, NULL);
3884
3885     /* keep track of length of line */
3886     len = strlen (TYPE_FIELD) + strlen (ci->ci_type)
3887                 + strlen (ci->ci_subtype) + 3;
3888
3889     mailbody = ct->c_type == CT_MESSAGE
3890         && ct->c_subtype == MESSAGE_EXTERNAL
3891         && ((struct exbody *) ct->c_ctparams)->eb_body;
3892
3893     /*
3894      * Append the attribute/value pairs to
3895      * the end of the Content-Type line.
3896      */
3897     for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
3898         if (mailbody && !strcasecmp (*ap, "body"))
3899             continue;
3900
3901         vp = add (";", vp);
3902         len++;
3903
3904         snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
3905         if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
3906             vp = add ("\n\t", vp);
3907             len = 8;
3908         } else {
3909             vp = add (" ", vp);
3910             len++;
3911         }
3912         vp = add (buffer, vp);
3913         len += cc;
3914     }
3915
3916     /*
3917      * Append any RFC-822 comment to the end of
3918      * the Content-Type line.
3919      */
3920     if (ci->ci_comment) {
3921         snprintf (buffer, sizeof(buffer), "(%s)", ci->ci_comment);
3922         if (len + 1 + (cc = 2 + strlen (ci->ci_comment)) >= CPERLIN) {
3923             vp = add ("\n\t", vp);
3924             len = 8;
3925         } else {
3926             vp = add (" ", vp);
3927             len++;
3928         }
3929         vp = add (buffer, vp);
3930         len += cc;
3931     }
3932     vp = add ("\n", vp);
3933     add_header (ct, np, vp);
3934
3935     /*
3936      * output the Content-ID
3937      */
3938     if (ct->c_id) {
3939         np = add (ID_FIELD, NULL);
3940         vp = concat (" ", ct->c_id, NULL);
3941         add_header (ct, np, vp);
3942     }
3943
3944     /*
3945      * output the Content-Description
3946      */
3947     if (ct->c_descr) {
3948         np = add (DESCR_FIELD, NULL);
3949         vp = concat (" ", ct->c_descr, NULL);
3950         add_header (ct, np, vp);
3951     }
3952
3953 skip_headers:
3954     /*
3955      * If this is the internal content structure for a
3956      * "message/external", then we are done with the
3957      * headers (since it has no body).
3958      */
3959     if (ct->c_ctexbody)
3960         return OK;
3961
3962     /*
3963      * output the Content-MD5
3964      */
3965     if (checksw) {
3966         np = add (MD5_FIELD, NULL);
3967         vp = calculate_digest (ct, (ct->c_encoding == CE_QUOTED) ? 1 : 0);
3968         add_header (ct, np, vp);
3969     }
3970
3971     /*
3972      * output the Content-Transfer-Encoding
3973      */
3974     switch (ct->c_encoding) {
3975     case CE_7BIT:
3976         /* Nothing to output */
3977 #if 0
3978         np = add (ENCODING_FIELD, NULL);
3979         vp = concat (" ", "7bit", "\n", NULL);
3980         add_header (ct, np, vp);
3981 #endif
3982         break;
3983
3984     case CE_8BIT:
3985         if (ct->c_type == CT_MESSAGE)
3986             adios (NULL, "internal error, invalid encoding");
3987
3988         np = add (ENCODING_FIELD, NULL);
3989         vp = concat (" ", "8bit", "\n", NULL);
3990         add_header (ct, np, vp);
3991         break;
3992
3993     case CE_QUOTED:
3994         if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
3995             adios (NULL, "internal error, invalid encoding");
3996
3997         np = add (ENCODING_FIELD, NULL);
3998         vp = concat (" ", "quoted-printable", "\n", NULL);
3999         add_header (ct, np, vp);
4000         break;
4001
4002     case CE_BASE64:
4003         if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
4004             adios (NULL, "internal error, invalid encoding");
4005
4006         np = add (ENCODING_FIELD, NULL);
4007         vp = concat (" ", "base64", "\n", NULL);
4008         add_header (ct, np, vp);
4009         break;
4010
4011     case CE_BINARY:
4012         if (ct->c_type == CT_MESSAGE)
4013             adios (NULL, "internal error, invalid encoding");
4014
4015         np = add (ENCODING_FIELD, NULL);
4016         vp = concat (" ", "binary", "\n", NULL);
4017         add_header (ct, np, vp);
4018         break;
4019
4020     default:
4021         adios (NULL, "unknown transfer encoding in content");
4022         break;
4023     }
4024
4025     /*
4026      * Additional content specific header processing
4027      */
4028     switch (ct->c_type) {
4029     case CT_MULTIPART:
4030     {
4031         struct multipart *m;
4032         struct part *part;
4033
4034         m = (struct multipart *) ct->c_ctparams;
4035         for (part = m->mp_parts; part; part = part->mp_next) {
4036             CT p;
4037
4038             p = part->mp_part;
4039             build_headers (p);
4040         }
4041     }
4042         break;
4043
4044     case CT_MESSAGE:
4045         if (ct->c_subtype == MESSAGE_EXTERNAL) {
4046             struct exbody *e;
4047
4048             e = (struct exbody *) ct->c_ctparams;
4049             build_headers (e->eb_content);
4050         }
4051         break;
4052
4053     default:
4054         /* Nothing to do */
4055         break;
4056     }
4057
4058     return OK;
4059 }
4060
4061
4062 static char nib2b64[0x40+1] =
4063         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4064
4065 static char *
4066 calculate_digest (CT ct, int asciiP)
4067 {
4068     int cc;
4069     char buffer[BUFSIZ], *vp, *op;
4070     unsigned char *dp;
4071     unsigned char digest[16];
4072     unsigned char outbuf[25];
4073     FILE *in;
4074     MD5_CTX mdContext;
4075     CE ce = ct->c_cefile;
4076
4077     /* open content */
4078     if ((in = fopen (ce->ce_file, "r")) == NULL)
4079         adios (ce->ce_file, "unable to open for reading");
4080
4081     /* Initialize md5 context */
4082     MD5Init (&mdContext);
4083
4084     /* calculate md5 message digest */
4085     if (asciiP) {
4086         while (fgets (buffer, sizeof(buffer) - 1, in)) {
4087             char c, *cp;
4088
4089             cp = buffer + strlen (buffer) - 1;
4090             if ((c = *cp) == '\n')
4091                 *cp = '\0';
4092
4093             MD5Update (&mdContext, (unsigned char *) buffer,
4094                        (unsigned int) strlen (buffer));
4095
4096             if (c == '\n')
4097                 MD5Update (&mdContext, (unsigned char *) "\r\n", 2);
4098         }
4099     } else {
4100         while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), in)) > 0)
4101             MD5Update (&mdContext, (unsigned char *) buffer, (unsigned int) cc);
4102     }
4103
4104     /* md5 finalization.  Write digest and zero md5 context */
4105     MD5Final (digest, &mdContext);
4106
4107     /* close content */
4108     fclose (in);
4109
4110     /* print debugging info */
4111     if (debugsw) {
4112         unsigned char *ep;
4113
4114         fprintf (stderr, "MD5 digest=");
4115         for (ep = (dp = digest) + sizeof(digest) / sizeof(digest[0]);
4116                  dp < ep; dp++)
4117             fprintf (stderr, "%02x", *dp & 0xff);
4118         fprintf (stderr, "\n");
4119     }
4120
4121     /* encode the digest using base64 */
4122     for (dp = digest, op = outbuf, cc = sizeof(digest) / sizeof(digest[0]);
4123                 cc > 0; cc -= 3, op += 4) {
4124         unsigned long bits;
4125         char *bp;
4126
4127         bits = (*dp++ & 0xff) << 16;
4128         if (cc > 1) {
4129             bits |= (*dp++ & 0xff) << 8;
4130             if (cc > 2)
4131                 bits |= *dp++ & 0xff;
4132         }
4133
4134         for (bp = op + 4; bp > op; bits >>= 6)
4135             *--bp = nib2b64[bits & 0x3f];
4136         if (cc < 3) {
4137             *(op + 3) = '=';
4138             if (cc < 2)
4139                 *(op + 2) = '=';
4140         }
4141     }
4142
4143     /* null terminate string */
4144     outbuf[24] = '\0';
4145
4146     /* now make copy and return string */
4147     vp = concat (" ", outbuf, "\n", NULL);
4148     return vp;
4149 }
4150
4151
4152 static int
4153 readDigest (CT ct, char *cp)
4154 {
4155     int bitno, skip;
4156     unsigned long bits;
4157     char *bp = cp;
4158     unsigned char *dp, value, *ep;
4159     unsigned char *b, *b1, *b2, *b3;
4160
4161     b  = (unsigned char *) &bits,
4162     b1 = &b[endian > 0 ? 1 : 2],
4163     b2 = &b[endian > 0 ? 2 : 1],
4164     b3 = &b[endian > 0 ? 3 : 0];
4165     bitno = 18;
4166     bits = 0L;
4167     skip = 0;
4168
4169     for (ep = (dp = ct->c_digest)
4170                  + sizeof(ct->c_digest) / sizeof(ct->c_digest[0]); *cp; cp++)
4171         switch (*cp) {
4172             default:
4173                 if (skip
4174                         || (*cp & 0x80)
4175                         || (value = b642nib[*cp & 0x7f]) > 0x3f) {
4176                     if (debugsw)
4177                         fprintf (stderr, "invalid BASE64 encoding\n");
4178                     return NOTOK;
4179                 }
4180
4181                 bits |= value << bitno;
4182 test_end:
4183                 if ((bitno -= 6) < 0) {
4184                     if (dp + (3 - skip) > ep)
4185                         goto invalid_digest;
4186                     *dp++ = *b1;
4187                     if (skip < 2) {
4188                         *dp++ = *b2;
4189                         if (skip < 1)
4190                             *dp++ = *b3;
4191                     }
4192                     bitno = 18;
4193                     bits = 0L;
4194                     skip = 0;
4195                 }
4196                 break;
4197
4198             case '=':
4199                 if (++skip > 3)
4200                     goto self_delimiting;
4201                 goto test_end;
4202         }
4203     if (bitno != 18) {
4204         if (debugsw)
4205             fprintf (stderr, "premature ending (bitno %d)\n", bitno);
4206
4207         return NOTOK;
4208     }
4209 self_delimiting:
4210     if (dp != ep) {
4211 invalid_digest:
4212         if (debugsw) {
4213             while (*cp)
4214                 cp++;
4215             fprintf (stderr, "invalid MD5 digest (got %d octets)\n",
4216                      cp - bp);
4217         }
4218
4219         return NOTOK;
4220     }
4221
4222     if (debugsw) {
4223         fprintf (stderr, "MD5 digest=");
4224         for (dp = ct->c_digest; dp < ep; dp++)
4225             fprintf (stderr, "%02x", *dp & 0xff);
4226         fprintf (stderr, "\n");
4227     }
4228
4229     return OK;
4230 }