X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/b02a191a4c725fb987c56dc41b2a81fbd6bff44c..c36ae8a76cf2ab8065fa996bb182e286880d63c0:/uip/mhfixmsg.c?ds=inline diff --git a/uip/mhfixmsg.c b/uip/mhfixmsg.c index 5385b9ec..6195b316 100644 --- a/uip/mhfixmsg.c +++ b/uip/mhfixmsg.c @@ -1,5 +1,5 @@ /* - * mhfixmsg.c -- rewrite a message with various tranformations + * mhfixmsg.c -- rewrite a message with various transformations * * This code is Copyright (c) 2002 and 2013, by the authors of nmh. * See the COPYRIGHT file in the root directory of the nmh @@ -14,8 +14,11 @@ #include #define MHFIXMSG_SWITCHES \ - X("decodetext 8bit|7bit", 0, DECODETEXTSW) \ + X("decodetext 8bit|7bit|binary", 0, DECODETEXTSW) \ X("nodecodetext", 0, NDECODETEXTSW) \ + X("decodetypes", 0, DECODETYPESW) \ + X("crlflinebreaks", 0, CRLFLINEBREAKSSW) \ + X("nocrlflinebreaks", 0, NCRLFLINEBREAKSSW) \ X("textcharset", 0, TEXTCHARSETSW) \ X("notextcharset", 0, NTEXTCHARSETSW) \ X("reformat", 0, REFORMATSW) \ @@ -24,12 +27,15 @@ X("noreplacetextplain", 0, NREPLACETEXTPLAINSW) \ X("fixboundary", 0, FIXBOUNDARYSW) \ X("nofixboundary", 0, NFIXBOUNDARYSW) \ - X("fixcte", 0, FIXCTESW) \ - X("nofixcte", 0, NFIXCTESW) \ + X("fixcte", 0, FIXCOMPOSITECTESW) \ + X("nofixcte", 0, NFIXCOMPOSITECTESW) \ + X("fixtype mimetype", 0, FIXTYPESW) \ X("file file", 0, FILESW) \ X("outfile file", 0, OUTFILESW) \ X("rmmproc program", 0, RPROCSW) \ X("normmproc", 0, NRPRCSW) \ + X("changecur", 0, CHGSW) \ + X("nochangecur", 0, NCHGSW) \ X("verbose", 0, VERBSW) \ X("noverbose", 0, NVERBSW) \ X("version", 0, VERSIONSW) \ @@ -53,6 +59,9 @@ int debugsw; /* Needed by mhparse.c. */ extern int skip_mp_cte_check; /* flag to InitMultiPart */ extern int suppress_bogus_mp_content_warning; /* flag to InitMultiPart */ extern int bogus_mp_content; /* flag from InitMultiPart */ +/* flags to/from parse_header_attrs */ +extern int suppress_extraneous_trailing_semicolon_warning; +extern int extraneous_trailing_semicolon; /* mhoutsbr.c */ int output_message (CT, char *); @@ -69,36 +78,54 @@ void freects_done (int) NORETURN; */ typedef struct fix_transformations { int fixboundary; - int fixcte; + int fixcompositecte; + svector_t fixtypes; int reformat; int replacetextplain; int decodetext; + char *decodetypes; + /* Whether to use CRLF linebreaks, per RFC 2046 Sec. 4.1.1, par.1. */ + int lf_line_endings; char *textcharset; } fix_transformations; int mhfixmsgsbr (CT *, const fix_transformations *, char *); static int fix_boundary (CT *, int *); +static int copy_input_to_output (const char *, const char *); static int get_multipart_boundary (CT, char **); static int replace_boundary (CT, char *, char *); -static int fix_multipart_cte (CT, int *); +static int fix_types (CT, svector_t, int *); +static char *replace_substring (char **, const char *, const char *); +static char *remove_parameter (char *, const char *); +static int fix_composite_cte (CT, int *); static int set_ce (CT, int); static int ensure_text_plain (CT *, CT, int *, int); +static int find_textplain_sibling (CT, int, int *); +static int insert_new_text_plain_part (CT, int, CT); static CT build_text_plain_part (CT); +static int insert_into_new_mp_alt (CT *, int *); static CT divide_part (CT); static void copy_ctinfo (CI, CI); static int decode_part (CT); static int reformat_part (CT, char *, char *, char *, int); -static int charset_encoding (CT); static CT build_multipart_alt (CT, CT, int, int); static int boundary_in_content (FILE **, char *, const char *); static void transfer_noncontent_headers (CT, CT); static int set_ct_type (CT, int type, int subtype, int encoding); -static int decode_text_parts (CT, int, int *); +static int decode_text_parts (CT, int, const char *, int *); +static int should_decode(const char *, const char *, const char *); static int content_encoding (CT, const char **); static int strip_crs (CT, int *); +static void update_cte (CT); +static int least_restrictive_encoding (CT); +static int less_restrictive (int, int); static int convert_charsets (CT, char *, int *); -static int write_content (CT, char *, char *, int, int); -static int remove_file (char *); +static int fix_always (CT, int *); +static int fix_filename_param (char *, char *, PM *, PM *); +static int fix_filename_encoding (CT); +static int write_content (CT, const char *, char *, int, int); +static void set_text_ctparams(CT, char *, int); +static int remove_file (const char *); static void report (char *, char *, char *, char *, ...); static void pipeser (int); @@ -114,14 +141,18 @@ main (int argc, char **argv) { CT *ctp; FILE *fp; int using_stdin = 0; + int chgflag = 1; int status = OK; fix_transformations fx; - fx.reformat = fx.fixcte = fx.fixboundary = 1; + fx.reformat = fx.fixcompositecte = fx.fixboundary = 1; + fx.fixtypes = NULL; fx.replacetextplain = 0; fx.decodetext = CE_8BIT; + fx.decodetypes = "text,application/ics"; /* Default, per man page. */ + fx.lf_line_endings = 0; fx.textcharset = NULL; - if (nmh_init(argv[0], 1)) { return 1; } + if (nmh_init(argv[0], 2)) { return 1; } done = freects_done; @@ -150,12 +181,15 @@ main (int argc, char **argv) { done (0); case DECODETEXTSW: - if (! (cp = *argp++) || *cp == '-') + if (! (cp = *argp++) || *cp == '-') { adios (NULL, "missing argument to %s", argp[-2]); + } if (! strcasecmp (cp, "8bit")) { fx.decodetext = CE_8BIT; } else if (! strcasecmp (cp, "7bit")) { fx.decodetext = CE_7BIT; + } else if (! strcasecmp (cp, "binary")) { + fx.decodetext = CE_BINARY; } else { adios (NULL, "invalid argument to %s", argp[-2]); } @@ -163,9 +197,22 @@ main (int argc, char **argv) { case NDECODETEXTSW: fx.decodetext = 0; continue; + case DECODETYPESW: + if (! (cp = *argp++) || *cp == '-') { + adios (NULL, "missing argument to %s", argp[-2]); + } + fx.decodetypes = cp; + continue; + case CRLFLINEBREAKSSW: + fx.lf_line_endings = 0; + continue; + case NCRLFLINEBREAKSSW: + fx.lf_line_endings = 1; + continue; case TEXTCHARSETSW: - if (! (cp = *argp++) || (*cp == '-' && cp[1])) + if (! (cp = *argp++) || (*cp == '-' && cp[1])) { adios (NULL, "missing argument to %s", argp[-2]); + } fx.textcharset = cp; continue; case NTEXTCHARSETSW: @@ -177,11 +224,24 @@ main (int argc, char **argv) { case NFIXBOUNDARYSW: fx.fixboundary = 0; continue; - case FIXCTESW: - fx.fixcte = 1; + case FIXCOMPOSITECTESW: + fx.fixcompositecte = 1; + continue; + case NFIXCOMPOSITECTESW: + fx.fixcompositecte = 0; continue; - case NFIXCTESW: - fx.fixcte = 0; + case FIXTYPESW: + if (! (cp = *argp++) || (*cp == '-' && cp[1])) { + adios (NULL, "missing argument to %s", argp[-2]); + } + if (! strncasecmp (cp, "multipart/", 10) || + ! strncasecmp (cp, "message/", 8)) { + adios (NULL, "-fixtype %s not allowed", cp); + } else if (! strchr (cp, '/')) { + adios (NULL, "-fixtype requires type/subtype"); + } + if (fx.fixtypes == NULL) { fx.fixtypes = svector_create (10); } + svector_push_back (fx.fixtypes, cp); continue; case REFORMATSW: fx.reformat = 1; @@ -196,22 +256,31 @@ main (int argc, char **argv) { fx.replacetextplain = 0; continue; case FILESW: - if (! (cp = *argp++) || (*cp == '-' && cp[1])) + if (! (cp = *argp++) || (*cp == '-' && cp[1])) { adios (NULL, "missing argument to %s", argp[-2]); + } file = *cp == '-' ? add (cp, NULL) : path (cp, TFILE); continue; case OUTFILESW: - if (! (cp = *argp++) || (*cp == '-' && cp[1])) + if (! (cp = *argp++) || (*cp == '-' && cp[1])) { adios (NULL, "missing argument to %s", argp[-2]); + } outfile = *cp == '-' ? add (cp, NULL) : path (cp, TFILE); continue; case RPROCSW: - if (!(rmmproc = *argp++) || *rmmproc == '-') + if (!(rmmproc = *argp++) || *rmmproc == '-') { adios (NULL, "missing argument to %s", argp[-2]); + } continue; case NRPRCSW: rmmproc = NULL; continue; + case CHGSW: + chgflag = 1; + continue; + case NCHGSW: + chgflag = 0; + continue; case VERBSW: verbosw = 1; continue; @@ -221,10 +290,11 @@ main (int argc, char **argv) { } } if (*cp == '+' || *cp == '@') { - if (folder) + if (folder) { adios (NULL, "only one folder at a time!"); - else + } else { folder = pluspath (cp); + } } else { if (*cp == '/') { /* Interpret a full path as a filename, not a message. */ @@ -247,12 +317,15 @@ main (int argc, char **argv) { } suppress_bogus_mp_content_warning = skip_mp_cte_check = 1; + suppress_extraneous_trailing_semicolon_warning = 1; - if (! context_find ("path")) + if (! context_find ("path")) { free (path ("./", TFOLDER)); + } - if (file && msgs.size) + if (file && msgs.size) { adios (NULL, "cannot specify msg and file at same time!"); + } /* * check if message is coming from file @@ -285,42 +358,65 @@ main (int argc, char **argv) { } } - if (! (cts = (CT *) calloc ((size_t) 2, sizeof *cts))) { + if (! (cts = (CT *) mh_xcalloc ((size_t) 2, sizeof *cts))) { adios (NULL, "out of memory"); } ctp = cts; - if ((ct = parse_mime (file))) { *ctp++ = ct; } + if ((ct = parse_mime (file))) { + set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings); + *ctp++ = ct; + } else { + advise (NULL, "unable to parse message from file %s", file); + status = NOTOK; + + /* If there's an outfile, pass the input message unchanged, so the message won't + get dropped from a pipeline. */ + if (outfile) { + /* Something went wrong. Output might be expected, such as if this were run + as a filter. Just copy the input to the output. */ + if (copy_input_to_output (file, outfile) != OK) { + advise (NULL, "unable to copy message to %s, it might be lost\n", outfile); + } + } + } } else { /* * message(s) are coming from a folder */ CT ct; - if (! msgs.size) + if (! msgs.size) { app_msgarg(&msgs, "cur"); - if (! folder) + } + if (! folder) { folder = getfolder (1); + } maildir = m_maildir (folder); - if (chdir (maildir) == NOTOK) + if (chdir (maildir) == NOTOK) { adios (maildir, "unable to change directory to"); + } /* read folder and create message structure */ - if (! (mp = folder_read (folder, 1))) + if (! (mp = folder_read (folder, 1))) { adios (NULL, "unable to read folder %s", folder); + } /* check for empty folder */ - if (mp->nummsg == 0) + if (mp->nummsg == 0) { adios (NULL, "no messages in %s", folder); + } /* parse all the message ranges/sequences and set SELECTED */ for (msgnum = 0; msgnum < msgs.size; msgnum++) - if (! m_convert (mp, msgs.msgs[msgnum])) + if (! m_convert (mp, msgs.msgs[msgnum])) { done (1); + } seq_setprev (mp); /* set the previous-sequence */ - if (! (cts = (CT *) calloc ((size_t) (mp->numsel + 1), sizeof *cts))) { + if (! (cts = + (CT *) mh_xcalloc ((size_t) (mp->numsel + 1), sizeof *cts))) { adios (NULL, "out of memory"); } ctp = cts; @@ -330,11 +426,31 @@ main (int argc, char **argv) { char *msgnam; msgnam = m_name (msgnum); - if ((ct = parse_mime (msgnam))) { *ctp++ = ct; } + if ((ct = parse_mime (msgnam))) { + set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings); + *ctp++ = ct; + } else { + advise (NULL, "unable to parse message %s", msgnam); + status = NOTOK; + + /* If there's an outfile, pass the input message unchanged, so the message won't + get dropped from a pipeline. */ + if (outfile) { + /* Something went wrong. Output might be expected, such as if this were run + as a filter. Just copy the input to the output. */ + const char *input_filename = path (msgnam, TFILE); + + if (copy_input_to_output (input_filename, outfile) != OK) { + advise (NULL, "unable to copy message to %s, it might be lost\n", outfile); + } + } + } } } - seq_setcur (mp, mp->hghsel); /* update current message */ + if (chgflag) { + seq_setcur (mp, mp->hghsel); /* update current message */ + } seq_save (mp); /* synchronize sequences */ context_replace (pfolder, folder);/* update current folder */ context_save (); /* save the context file */ @@ -357,8 +473,11 @@ main (int argc, char **argv) { status = 1; } + if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); } free (outfile); free (file); + free (folder); + free (arguments); /* done is freects_done, which will clean up all of cts. */ done (status); @@ -366,6 +485,9 @@ main (int argc, char **argv) { } +/* + * Apply transformations to one message. + */ int mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) { /* Store input filename in case one of the transformations, i.e., @@ -391,24 +513,30 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) { } reverse_alternative_parts (*ctp); + status = fix_always (*ctp, &message_mods); if (status == OK && fx->fixboundary) { status = fix_boundary (ctp, &message_mods); } - if (status == OK && fx->fixcte) { - status = fix_multipart_cte (*ctp, &message_mods); + if (status == OK && fx->fixtypes != NULL) { + status = fix_types (*ctp, fx->fixtypes, &message_mods); + } + if (status == OK && fx->fixcompositecte) { + status = fix_composite_cte (*ctp, &message_mods); } if (status == OK && fx->reformat) { status = ensure_text_plain (ctp, NULL, &message_mods, fx->replacetextplain); } if (status == OK && fx->decodetext) { - status = decode_text_parts (*ctp, fx->decodetext, &message_mods); + status = decode_text_parts (*ctp, fx->decodetext, fx->decodetypes, + &message_mods); + update_cte (*ctp); } if (status == OK && fx->textcharset != NULL) { status = convert_charsets (*ctp, fx->textcharset, &message_mods); } - if (! (*ctp)->c_umask) { + if (status == OK && ! (*ctp)->c_umask) { /* Set the umask for the contents file. This currently isn't used but just in case it is in the future. */ struct stat st; @@ -430,19 +558,9 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) { /* Something went wrong. Output might be expected, such as if this were run as a filter. Just copy the input to the output. */ - int in = open (input_filename, O_RDONLY); - int out = strcmp (outfile, "-") - ? open (outfile, O_WRONLY | O_CREAT, m_gmprot ()) - : STDOUT_FILENO; - - if (in != -1 && out != -1) { - cpydata (in, out, input_filename, outfile); - } else { - status = NOTOK; + if (copy_input_to_output (input_filename, outfile) != OK) { + advise (NULL, "unable to copy message to %s, it might be lost\n", outfile); } - - close (out); - close (in); } if (modify_inplace) { @@ -457,12 +575,40 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) { } +/* + * Copy input message to output. Assumes not modifying in place, so this + * might be running as part of a pipeline. + */ +static int +copy_input_to_output (const char *input_filename, const char *output_filename) { + int in = open (input_filename, O_RDONLY); + int out = strcmp (output_filename, "-") + ? open (output_filename, O_WRONLY | O_CREAT, m_gmprot ()) + : STDOUT_FILENO; + int status = OK; + + if (in != -1 && out != -1) { + cpydata (in, out, input_filename, output_filename); + } else { + status = NOTOK; + } + + close (out); + close (in); + + return status; +} + + +/* + * Fix mismatched outer level boundary. + */ static int fix_boundary (CT *ct, int *message_mods) { struct multipart *mp; int status = OK; - if (bogus_mp_content) { + if (ct && (*ct)->c_type == CT_MULTIPART && bogus_mp_content) { mp = (struct multipart *) (*ct)->c_ctparams; /* @@ -484,9 +630,11 @@ fix_boundary (CT *ct, int *message_mods) { if ((fixed = m_mktemp2 (NULL, invo_name, NULL, &(*ct)->c_fp))) { if (replace_boundary (*ct, fixed, part_boundary) == OK) { char *filename = add ((*ct)->c_file, NULL); + CT fixed_ct; free_content (*ct); - if ((*ct = parse_mime (fixed))) { + if ((fixed_ct = parse_mime (fixed))) { + *ct = fixed_ct; (*ct)->c_unlink = 1; ++*message_mods; @@ -494,6 +642,10 @@ fix_boundary (CT *ct, int *message_mods) { report (NULL, NULL, filename, "fix multipart boundary"); } + } else { + *ct = NULL; + advise (NULL, "unable to parse fixed part"); + status = NOTOK; } free (filename); } else { @@ -507,7 +659,16 @@ fix_boundary (CT *ct, int *message_mods) { } free (part_boundary); + } else { + /* Couldn't fix the boundary. Report failure so that mhfixmsg + doesn't modify the message. */ + status = NOTOK; } + } else { + /* No multipart struct, even though the content type is + CT_MULTIPART. Report failure so that mhfixmsg doesn't modify + the message. */ + status = NOTOK; } } @@ -515,6 +676,9 @@ fix_boundary (CT *ct, int *message_mods) { } +/* + * Find boundary at end of multipart. + */ static int get_multipart_boundary (CT ct, char **part_boundary) { char buffer[BUFSIZ]; @@ -596,7 +760,9 @@ get_multipart_boundary (CT ct, char **part_boundary) { } -/* Open and copy ct->c_file to file, replacing the multipart boundary. */ +/* + * Open and copy ct->c_file to file, replacing the multipart boundary. + */ static int replace_boundary (CT ct, char *file, char *boundary) { FILE *fpin, *fpout; @@ -658,8 +824,9 @@ replace_boundary (CT ct, char *file, char *boundary) { fprintf (fpout, "%s:%s%s\n", np, new_ctline, new_params ? new_params : ""); free(new_ctline); - if (new_params) + if (new_params) { free(new_params); + } } free (vp); @@ -670,7 +837,9 @@ replace_boundary (CT ct, char *file, char *boundary) { case BODY: fputs ("\n", fpout); /* buf will have a terminating NULL, skip it. */ - fwrite (buf, 1, bufsz-1, fpout); + if ((int) fwrite (buf, 1, bufsz-1, fpout) < bufsz-1) { + advise (file, "fwrite"); + } continue; case FILEEOF: @@ -699,14 +868,208 @@ replace_boundary (CT ct, char *file, char *boundary) { } +/* + * Fix Content-Type header to reflect the content of its part. + */ static int -fix_multipart_cte (CT ct, int *message_mods) { +fix_types (CT ct, svector_t fixtypes, int *message_mods) { int status = OK; - if (ct->c_type == CT_MULTIPART) { - struct multipart *m; + switch (ct->c_type) { + case CT_MULTIPART: { + struct multipart *m = (struct multipart *) ct->c_ctparams; struct part *part; + for (part = m->mp_parts; status == OK && part; part = part->mp_next) { + status = fix_types (part->mp_part, fixtypes, message_mods); + } + break; + } + + case CT_MESSAGE: + if (ct->c_subtype == MESSAGE_EXTERNAL) { + struct exbody *e = (struct exbody *) ct->c_ctparams; + + status = fix_types (e->eb_content, fixtypes, message_mods); + } + break; + + default: { + char **typep, *type; + + if (ct->c_ctinfo.ci_type && ct->c_ctinfo.ci_subtype) { + for (typep = svector_strs (fixtypes); + typep && (type = *typep); + ++typep) { + char *type_subtype = + concat (ct->c_ctinfo.ci_type, "/", ct->c_ctinfo.ci_subtype, + NULL); + + if (! strcasecmp (type, type_subtype) && + decode_part (ct) == OK && + ct->c_cefile.ce_file != NULL) { + char *ct_type_subtype = mime_type (ct->c_cefile.ce_file); + char *cp; + + if ((cp = strchr (ct_type_subtype, ';'))) { + /* Truncate to remove any parameter list from + mime_type () result. */ + *cp = '\0'; + } + + if (strcasecmp (type, ct_type_subtype)) { + char *ct_type, *ct_subtype; + HF hf; + + /* The Content-Type header does not match the + content, so update these struct Content + fields to match: + * c_type, c_subtype + * c_ctinfo.ci_type, c_ctinfo.ci_subtype + * c_ctline + */ + /* Extract type and subtype from type/subtype. */ + ct_type = getcpy (ct_type_subtype); + if ((cp = strchr (ct_type, '/'))) { + *cp = '\0'; + ct_subtype = getcpy (++cp); + } else { + advise (NULL, "missing / in MIME type of %s %s", + ct->c_file, ct->c_partno); + free (ct_type); + return NOTOK; + } + + ct->c_type = ct_str_type (ct_type); + ct->c_subtype = ct_str_subtype (ct->c_type, ct_subtype); + + free (ct->c_ctinfo.ci_type); + ct->c_ctinfo.ci_type = ct_type; + free (ct->c_ctinfo.ci_subtype); + ct->c_ctinfo.ci_subtype = ct_subtype; + if (! replace_substring (&ct->c_ctline, type, + ct_type_subtype)) { + advise (NULL, "did not find %s in %s", + type, ct->c_ctline); + } + + /* Update Content-Type header field. */ + for (hf = ct->c_first_hf; hf; hf = hf->next) { + if (! strcasecmp (TYPE_FIELD, hf->name)) { + if (replace_substring (&hf->value, type, + ct_type_subtype)) { + ++*message_mods; + if (verbosw) { + report (NULL, ct->c_partno, ct->c_file, + "change Content-Type in header " + "from %s to %s", + type, ct_type_subtype); + } + break; + } else { + advise (NULL, "did not find %s in %s", + type, hf->value); + } + } + } + } + free (ct_type_subtype); + } + free (type_subtype); + } + } + }} + + return status; +} + + +/* + * Replace a substring, allocating space to hold the new one. + */ +char * +replace_substring (char **str, const char *old, const char *new) { + char *cp; + + if ((cp = strstr (*str, old))) { + char *remainder = cp + strlen (old); + char *prefix, *new_str; + + if (cp - *str) { + prefix = getcpy (*str); + *(prefix + (cp - *str)) = '\0'; + new_str = concat (prefix, new, remainder, NULL); + free (prefix); + } else { + new_str = concat (new, remainder, NULL); + } + + free (*str); + + return *str = new_str; + } else { + return NULL; + } +} + + +/* + * Remove a name=value parameter, given just its name, from a header value. + */ +char * +remove_parameter (char *str, const char *name) { + /* It looks to me, based on the BNF in RFC 2045, than there can't + be whitespace betwwen the parameter name and the "=", or + between the "=" and the parameter value. */ + char *param_name = concat (name, "=", NULL); + char *cp; + + if ((cp = strstr (str, param_name))) { + char *start, *end; + size_t count = 1; + + /* Remove any leading spaces, before the parameter name. */ + for (start = cp; + start > str && isspace ((unsigned char) *(start-1)); + --start) { + continue; + } + /* Remove a leading semicolon. */ + if (start > str && *(start-1) == ';') { --start; } + + end = cp + strlen (name) + 1; + if (*end == '"') { + /* Skip past the quoted value, and then the final quote. */ + for (++end ; *end && *end != '"'; ++end) { continue; } + ++end; + } else { + /* Skip past the value. */ + for (++end ; *end && ! isspace ((unsigned char) *end); ++end) {} + } + + /* Count how many characters need to be moved. Include + trailing null, which is accounted for by the + initialization of count to 1. */ + for (cp = end; *cp; ++cp) { ++count; } + (void) memmove (start, end, count); + } + + free (param_name); + + return str; +} + + +/* + * Fix Content-Transfer-Encoding of composite,, e.g., message or multipart, part. + * According to RFC 2045 Sec. 6.4, it must be 7bit, 8bit, or binary. Set it to + * 8 bit. + */ +static int +fix_composite_cte (CT ct, int *message_mods) { + int status = OK; + + if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART) { if (ct->c_encoding != CE_7BIT && ct->c_encoding != CE_8BIT && ct->c_encoding != CE_BINARY) { HF hf; @@ -752,11 +1115,16 @@ fix_multipart_cte (CT ct, int *message_mods) { set_ce (ct, CE_8BIT); } - m = (struct multipart *) ct->c_ctparams; - for (part = m->mp_parts; part; part = part->mp_next) { - if (fix_multipart_cte (part->mp_part, message_mods) != OK) { - status = NOTOK; - break; + if (ct->c_type == CT_MULTIPART) { + struct multipart *m; + struct part *part; + + m = (struct multipart *) ct->c_ctparams; + for (part = m->mp_parts; part; part = part->mp_next) { + if (fix_composite_cte (part->mp_part, message_mods) != OK) { + status = NOTOK; + break; + } } } } @@ -765,6 +1133,9 @@ fix_multipart_cte (CT ct, int *message_mods) { } +/* + * Set content encoding. + */ static int set_ce (CT ct, int encoding) { const char *ce = ce_str (encoding); @@ -789,6 +1160,10 @@ set_ce (CT ct, int encoding) { ct->c_cefile.ce_file to the name of the file containing the contents. */ + if (ct->c_ceclosefnx) { + (*ct->c_ceclosefnx) (ct); + } + /* Restore the cefile. */ ct->c_cefile = decoded_content_info; @@ -815,109 +1190,135 @@ set_ce (CT ct, int encoding) { } -/* Make sure each text part has a corresponding text/plain part. */ +/* + * Make sure each text part has a corresponding text/plain part. + */ static int ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) { int status = OK; switch ((*ct)->c_type) { case CT_TEXT: { - int has_text_plain = 0; - /* Nothing to do for text/plain. */ if ((*ct)->c_subtype == TEXT_PLAIN) { return OK; } if (parent && parent->c_type == CT_MULTIPART && parent->c_subtype == MULTI_ALTERNATE) { - struct multipart *mp = (struct multipart *) parent->c_ctparams; - struct part *part, *prev; int new_subpart_number = 1; - - /* See if there is a sibling text/plain. */ - for (prev = part = mp->mp_parts; part; part = part->mp_next) { - ++new_subpart_number; - if (part->mp_part->c_type == CT_TEXT && - part->mp_part->c_subtype == TEXT_PLAIN) { - if (replacetextplain) { - struct part *old_part; - if (part == mp->mp_parts) { - old_part = mp->mp_parts; - mp->mp_parts = part->mp_next; - } else { - old_part = prev->mp_next; - prev->mp_next = part->mp_next; - } - if (verbosw) { - report (NULL, parent->c_partno, parent->c_file, - "remove text/plain part %s", - old_part->mp_part->c_partno); - } - free_content (old_part->mp_part); - free (old_part); - } else { - has_text_plain = 1; - } - break; - } - prev = part; - } + int has_text_plain = + find_textplain_sibling (parent, replacetextplain, + &new_subpart_number); if (! has_text_plain) { /* Parent is a multipart/alternative. Insert a new text/plain subpart. */ - struct part *new_part = mh_xmalloc (sizeof *new_part); - - if ((new_part->mp_part = build_text_plain_part (*ct))) { - char buffer[16]; - snprintf (buffer, sizeof buffer, "%d", new_subpart_number); - - new_part->mp_next = mp->mp_parts; - mp->mp_parts = new_part; - new_part->mp_part->c_partno = - concat (parent->c_partno ? parent->c_partno : "1", ".", - buffer, NULL); - + const int inserted = + insert_new_text_plain_part (*ct, new_subpart_number, + parent); + if (inserted) { ++*message_mods; if (verbosw) { report (NULL, parent->c_partno, parent->c_file, "insert text/plain part"); } } else { - free_content (new_part->mp_part); - free (new_part); status = NOTOK; } } - } else { - /* Slip new text/plain part into a new multipart/alternative. */ - CT tp_part = build_text_plain_part (*ct); + } else if (parent && parent->c_type == CT_MULTIPART && + parent->c_subtype == MULTI_RELATED) { + char *type_subtype = + concat ((*ct)->c_ctinfo.ci_type, "/", + (*ct)->c_ctinfo.ci_subtype, NULL); + const char *parent_type = + get_param (parent->c_ctinfo.ci_first_pm, "type", '?', 1); + int new_subpart_number = 1; + int has_text_plain = 0; + + /* Have to do string comparison on the subtype because we + don't enumerate all of them in c_subtype values. + parent_type will be NULL if the multipart/related part + doesn't have a type parameter. The type parameter must + be specified according to RFC 2387 Sec. 3.1 but not all + messages comply. */ + if (parent_type && strcasecmp (type_subtype, parent_type) == 0) { + /* The type of this part matches the root type of the + parent multipart/related. Look to see if there's + text/plain sibling. */ + has_text_plain = + find_textplain_sibling (parent, replacetextplain, + &new_subpart_number); + } - if (tp_part) { - CT mp_alt = build_multipart_alt (*ct, tp_part, CT_MULTIPART, - MULTI_ALTERNATE); - if (mp_alt) { - struct multipart *mp = - (struct multipart *) mp_alt->c_ctparams; + free (type_subtype); - if (mp && mp->mp_parts) { - mp->mp_parts->mp_part = tp_part; - /* Make the new multipart/alternative the parent. */ - *ct = mp_alt; + if (! has_text_plain) { + struct multipart *mp = (struct multipart *) parent->c_ctparams; + struct part *part; + int siblings = 0; - ++*message_mods; - if (verbosw) { - report (NULL, (*ct)->c_partno, (*ct)->c_file, - "insert text/plain part"); + for (part = mp->mp_parts; part; part = part->mp_next) { + if (*ct != part->mp_part) { + ++siblings; + } + } + + if (siblings) { + /* Parent is a multipart/related. Insert a new + text/plain subpart in a new multipart/alternative. */ + if (insert_into_new_mp_alt (ct, message_mods)) { + /* Not an error if text/plain couldn't be added. */ + } + } else { + /* There are no siblings, so insert a new text/plain + subpart, and change the parent type from + multipart/related to multipart/alternative. */ + const int inserted = + insert_new_text_plain_part (*ct, new_subpart_number, + parent); + + if (inserted) { + HF hf; + + parent->c_subtype = MULTI_ALTERNATE; + parent->c_ctinfo.ci_subtype = getcpy ("alternative"); + if (! replace_substring (&parent->c_ctline, "/related", + "/alternative")) { + advise (NULL, + "did not find multipart/related in %s", + parent->c_ctline); + } + + /* Update Content-Type header field. */ + for (hf = parent->c_first_hf; hf; hf = hf->next) { + if (! strcasecmp (TYPE_FIELD, hf->name)) { + if (replace_substring (&hf->value, "/related", + "/alternative")) { + ++*message_mods; + if (verbosw) { + report (NULL, parent->c_partno, + parent->c_file, + "insert text/plain part"); + } + + /* Remove, e.g., type="text/html" from + multipart/alternative. */ + remove_parameter (hf->value, "type"); + break; + } else { + advise (NULL, "did not find multipart/" + "related in header %s", + hf->value); + } + } } } else { - free_content (tp_part); - free_content (mp_alt); - status = NOTOK; + /* Not an error if text/plain couldn't be inserted. */ } - } else { - status = NOTOK; } - } else { + } + } else { + if (insert_into_new_mp_alt (ct, message_mods)) { status = NOTOK; } } @@ -939,9 +1340,8 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) { case CT_MESSAGE: if ((*ct)->c_subtype == MESSAGE_EXTERNAL) { - struct exbody *e; + struct exbody *e = (struct exbody *) (*ct)->c_ctparams; - e = (struct exbody *) (*ct)->c_ctparams; status = ensure_text_plain (&e->eb_content, *ct, message_mods, replacetextplain); } @@ -952,6 +1352,79 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) { } +/* + * See if there is a sibling text/plain, and return its subpart number. + */ +static int +find_textplain_sibling (CT parent, int replacetextplain, + int *new_subpart_number) { + struct multipart *mp = (struct multipart *) parent->c_ctparams; + struct part *part, *prev; + int has_text_plain = 0; + + for (prev = part = mp->mp_parts; part; part = part->mp_next) { + ++*new_subpart_number; + if (part->mp_part->c_type == CT_TEXT && + part->mp_part->c_subtype == TEXT_PLAIN) { + if (replacetextplain) { + struct part *old_part; + if (part == mp->mp_parts) { + old_part = mp->mp_parts; + mp->mp_parts = part->mp_next; + } else { + old_part = prev->mp_next; + prev->mp_next = part->mp_next; + } + if (verbosw) { + report (NULL, parent->c_partno, parent->c_file, + "remove text/plain part %s", + old_part->mp_part->c_partno); + } + free_content (old_part->mp_part); + free (old_part); + } else { + has_text_plain = 1; + } + break; + } + prev = part; + } + + return has_text_plain; +} + + +/* + * Insert a new text/plain part. + */ +static int +insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) { + struct multipart *mp = (struct multipart *) parent->c_ctparams; + struct part *new_part = mh_xmalloc (sizeof *new_part); + + if ((new_part->mp_part = build_text_plain_part (ct))) { + char buffer[16]; + snprintf (buffer, sizeof buffer, "%d", new_subpart_number); + + new_part->mp_next = mp->mp_parts; + mp->mp_parts = new_part; + new_part->mp_part->c_partno = + concat (parent->c_partno ? parent->c_partno : "1", ".", + buffer, NULL); + + return 1; + } else { + free_content (new_part->mp_part); + free (new_part); + + return 0; + } +} + + +/* + * Create a text/plain part to go along with non-plain sibling part. + */ static CT build_text_plain_part (CT encoded_part) { CT tp_part = divide_part (encoded_part); @@ -967,29 +1440,73 @@ build_text_plain_part (CT encoded_part) { if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) { advise (NULL, "unable to create temporary file in %s", get_temp_dir()); - } - tmp_plain_file = add (tempfile, NULL); - if (reformat_part (tp_part, tmp_plain_file, - tp_part->c_ctinfo.ci_type, - tp_part->c_ctinfo.ci_subtype, - tp_part->c_type) == OK) { - return tp_part; + } else { + tmp_plain_file = add (tempfile, NULL); + if (reformat_part (tp_part, tmp_plain_file, + tp_part->c_ctinfo.ci_type, + tp_part->c_ctinfo.ci_subtype, + tp_part->c_type) == OK) { + return tp_part; + } } } free_content (tp_part); - (void) m_unlink (tmp_plain_file); + if (tmp_plain_file) { (void) m_unlink (tmp_plain_file); } free (tmp_plain_file); return NULL; } +/* + * Slip new text/plain part into a new multipart/alternative. + */ +static int +insert_into_new_mp_alt (CT *ct, int *message_mods) { + CT tp_part = build_text_plain_part (*ct); + int status = OK; + + if (tp_part) { + CT mp_alt = build_multipart_alt (*ct, tp_part, CT_MULTIPART, + MULTI_ALTERNATE); + if (mp_alt) { + struct multipart *mp = (struct multipart *) mp_alt->c_ctparams; + + if (mp && mp->mp_parts) { + mp->mp_parts->mp_part = tp_part; + /* Make the new multipart/alternative the parent. */ + *ct = mp_alt; + + ++*message_mods; + if (verbosw) { + report (NULL, (*ct)->c_partno, (*ct)->c_file, + "insert text/plain part"); + } + } else { + free_content (tp_part); + free_content (mp_alt); + status = NOTOK; + } + } else { + status = NOTOK; + } + } else { + /* Not an error if text/plain couldn't be built. */ + } + + return status; +} + + +/* + * Clone a MIME part. + */ static CT divide_part (CT ct) { CT new_part; - if ((new_part = (CT) calloc (1, sizeof *new_part)) == NULL) + if ((new_part = (CT) mh_xcalloc (1, sizeof *new_part)) == NULL) adios (NULL, "out of memory"); /* Just copy over what is needed for decoding. c_vrsn and @@ -1014,6 +1531,9 @@ divide_part (CT ct) { } +/* + * Copy the content info from one part to another. + */ static void copy_ctinfo (CI dest, CI src) { PM s_pm, d_pm; @@ -1024,10 +1544,12 @@ copy_ctinfo (CI dest, CI src) { for (s_pm = src->ci_first_pm; s_pm; s_pm = s_pm->pm_next) { d_pm = add_param(&dest->ci_first_pm, &dest->ci_last_pm, s_pm->pm_name, s_pm->pm_value, 0); - if (s_pm->pm_charset) + if (s_pm->pm_charset) { d_pm->pm_charset = getcpy(s_pm->pm_charset); - if (s_pm->pm_lang) + } + if (s_pm->pm_lang) { d_pm->pm_lang = getcpy(s_pm->pm_lang); + } } dest->ci_comment = src->ci_comment ? add (src->ci_comment, NULL) : NULL; @@ -1035,6 +1557,9 @@ copy_ctinfo (CI dest, CI src) { } +/* + * Decode content. + */ static int decode_part (CT ct) { char *tmp_decoded; @@ -1056,11 +1581,15 @@ decode_part (CT ct) { } -/* Some of the arguments aren't really needed now, but maybe will - be in the future for other than text types. */ +/* + * Reformat content as plain text. + * Some of the arguments aren't really needed now, but maybe will + * be in the future for other than text types. + */ static int reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) { int output_subtype, output_encoding; + const char *reason = NULL; char *cp, *cf; int status; @@ -1106,8 +1635,8 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) { /* Set subtype to 0, which is always an UNKNOWN subtype. */ output_subtype = 0; } - output_encoding = charset_encoding (ct); + output_encoding = content_encoding (ct, &reason); if (set_ct_type (ct, c_type, output_subtype, output_encoding) == OK) { ct->c_cefile.ce_file = file; ct->c_cefile.ce_unlink = 1; @@ -1120,16 +1649,9 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) { } -/* Identifies 7bit or 8bit content based on charset. */ -static int -charset_encoding (CT ct) { - int encoding = - strcasecmp (content_charset (ct), "US-ASCII") ? CE_8BIT : CE_7BIT; - - return encoding; -} - - +/* + * Fill in a multipart/alternative part. + */ static CT build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) { char *boundary_prefix = "----=_nmh-multipart"; @@ -1141,11 +1663,11 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) { struct multipart *m; const struct str2init *ctinit; - if ((ct = (CT) calloc (1, sizeof *ct)) == NULL) + if ((ct = (CT) mh_xcalloc (1, sizeof *ct)) == NULL) adios (NULL, "out of memory"); /* Set up the multipart/alternative part. These fields of *ct were - initialized to 0 by calloc(): + initialized to 0 by mh_xcalloc(): c_fp, c_unlink, c_begin, c_end, c_vrsn, c_ctline, c_celine, c_id, c_descr, c_dispo, c_partno, @@ -1242,20 +1764,20 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) { } add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm, - "boundary", boundary, 0); + "boundary", boundary, 0); p = (struct part *) mh_xmalloc (sizeof *p); p->mp_next = (struct part *) mh_xmalloc (sizeof *p->mp_next); p->mp_next->mp_next = NULL; p->mp_next->mp_part = first_alt; - if ((m = (struct multipart *) calloc (1, sizeof (struct multipart))) == + if ((m = (struct multipart *) mh_xcalloc (1, sizeof (struct multipart))) == NULL) adios (NULL, "out of memory"); m->mp_start = concat (boundary, "\n", NULL); m->mp_stop = concat (boundary, "--\n", NULL); m->mp_parts = p; - ct->c_ctparams = (void *) m; + ct->c_ctparams = m; free (boundary); @@ -1263,7 +1785,9 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) { } -/* Check that the boundary does not appear in the content. */ +/* + * Check that the boundary does not appear in the content. + */ static int boundary_in_content (FILE **fp, char *file, const char *boundary) { char buffer[BUFSIZ]; @@ -1288,7 +1812,9 @@ boundary_in_content (FILE **fp, char *file, const char *boundary) { } -/* Remove all non-Content headers. */ +/* + * Remove all non-Content headers. + */ static void transfer_noncontent_headers (CT old, CT new) { HF hp, hp_prev; @@ -1330,6 +1856,9 @@ transfer_noncontent_headers (CT old, CT new) { } +/* + * Set content type. + */ static int set_ct_type (CT ct, int type, int subtype, int encoding) { char *typename = ct_type_str (type); @@ -1384,12 +1913,49 @@ set_ct_type (CT ct, int type, int subtype, int encoding) { } +/* + * It's not necessary to update the charset parameter of a Content-Type + * header for a text part. According to RFC 2045 Sec. 6.4, the body + * (content) was originally in the specified charset, "and will be in + * that character set again after decoding." + */ static int -decode_text_parts (CT ct, int encoding, int *message_mods) { +decode_text_parts (CT ct, int encoding, const char *decodetypes, + int *message_mods) { int status = OK; + int lf_line_endings = 0; switch (ct->c_type) { - case CT_TEXT: + case CT_MULTIPART: { + struct multipart *m = (struct multipart *) ct->c_ctparams; + struct part *part; + + /* Should check to see if the body for this part is encoded? + For now, it gets passed along as-is by InitMultiPart(). */ + for (part = m->mp_parts; status == OK && part; part = part->mp_next) { + status = decode_text_parts (part->mp_part, encoding, decodetypes, + message_mods); + } + break; + } + + case CT_MESSAGE: + if (ct->c_subtype == MESSAGE_EXTERNAL) { + struct exbody *e = (struct exbody *) ct->c_ctparams; + + status = decode_text_parts (e->eb_content, encoding, decodetypes, + message_mods); + } + break; + + default: + if (! should_decode(decodetypes, ct->c_ctinfo.ci_type, ct->c_ctinfo.ci_subtype)) { + break; + } + + lf_line_endings = + ct->c_ctparams && ((struct text *) ct->c_ctparams)->lf_line_endings; + switch (ct->c_encoding) { case CE_BASE64: case CE_QUOTED: { @@ -1429,19 +1995,23 @@ decode_text_parts (CT ct, int encoding, int *message_mods) { ct->c_cefile.ce_file = NULL; } else { int enc; - if (ct_encoding == CE_BINARY) + + if (ct_encoding == CE_BINARY) { enc = CE_BINARY; - else if (ct_encoding == CE_8BIT && encoding == CE_7BIT) + } else if (ct_encoding == CE_8BIT && encoding == CE_7BIT) { enc = CE_QUOTED; - else - enc = charset_encoding (ct); + } else { + enc = ct_encoding; + } if (set_ce (ct, enc) == OK) { ++*message_mods; if (verbosw) { report (NULL, ct->c_partno, ct->c_file, "decode%s", ct->c_ctline ? ct->c_ctline : ""); } - strip_crs (ct, message_mods); + if (lf_line_endings) { + strip_crs (ct, message_mods); + } } else { status = NOTOK; } @@ -1453,47 +2023,60 @@ decode_text_parts (CT ct, int encoding, int *message_mods) { } case CE_8BIT: case CE_7BIT: - strip_crs (ct, message_mods); + if (lf_line_endings) { + strip_crs (ct, message_mods); + } break; default: break; } break; - - case CT_MULTIPART: { - struct multipart *m = (struct multipart *) ct->c_ctparams; - struct part *part; - - /* Should check to see if the body for this part is encoded? - For now, it gets passed along as-is by InitMultiPart(). */ - for (part = m->mp_parts; status == OK && part; part = part->mp_next) { - status = decode_text_parts (part->mp_part, encoding, message_mods); - } - break; } - case CT_MESSAGE: - if (ct->c_subtype == MESSAGE_EXTERNAL) { - struct exbody *e; + return status; +} - e = (struct exbody *) ct->c_ctparams; - status = decode_text_parts (e->eb_content, encoding, message_mods); - } - break; - default: - break; +/* + * Determine if the part with type[/subtype] should be decoded, according to + * decodetypes (which came from the -decodetypes switch). + */ +static int +should_decode(const char *decodetypes, const char *type, const char *subtype) { + /* Quick search for matching type[/subtype] in decodetypes: bracket + decodetypes with commas, then search for ,type, and ,type/subtype, in + it. */ + + int found_match = 0; + char *delimited_decodetypes = concat(",", decodetypes, ",", NULL); + char *delimited_type = concat(",", type, ",", NULL); + + if (nmh_strcasestr(delimited_decodetypes, delimited_type)) { + found_match = 1; + } else if (subtype != NULL) { + char *delimited_type_subtype = + concat(",", type, "/", subtype, ",", NULL); + + if (nmh_strcasestr(delimited_decodetypes, delimited_type_subtype)) { + found_match = 1; + } + free(delimited_type_subtype); } - return status; + free(delimited_type); + free(delimited_decodetypes); + + return found_match; } -/* See if the decoded content is 7bit, 8bit, or binary. It's binary - if it has any NUL characters, a CR not followed by a LF, or lines - greater than 998 characters in length. If binary, reason is set - to a string explaining why. */ +/* + * See if the decoded content is 7bit, 8bit, or binary. It's binary + * if it has any NUL characters, a CR not followed by a LF, or lines + * greater than 998 characters in length. If binary, reason is set + * to a string explaining why. + */ static int content_encoding (CT ct, const char **reason) { CE ce = &ct->c_cefile; @@ -1549,6 +2132,9 @@ content_encoding (CT ct, const char **reason) { } +/* + * Strip carriage returns from content. + */ static int strip_crs (CT ct, int *message_mods) { char *charset = content_charset (ct); @@ -1694,10 +2280,112 @@ strip_crs (CT ct, int *message_mods) { } } + free (charset); + return status; } +/* + * Add/update, if necessary, the message C-T-E, based on the least restrictive + * of the part C-T-E's. + */ +static void +update_cte (CT ct) { + const int least_restrictive_enc = least_restrictive_encoding (ct); + + if (least_restrictive_enc != CE_UNKNOWN && + least_restrictive_enc != CE_7BIT) { + char *cte = concat (" ", ce_str (least_restrictive_enc), "\n", NULL); + HF hf; + int found_cte = 0; + + /* Update/add Content-Transfer-Encoding header field. */ + for (hf = ct->c_first_hf; hf; hf = hf->next) { + if (! strcasecmp (ENCODING_FIELD, hf->name)) { + found_cte = 1; + free (hf->value); + hf->value = cte; + } + } + if (! found_cte) { + add_header (ct, add (ENCODING_FIELD, NULL), cte); + } + } +} + + +/* + * Find the least restrictive encoding (7bit, 8bit, binary) of the parts + * within a message. + */ +static int +least_restrictive_encoding (CT ct) { + int encoding = CE_UNKNOWN; + + switch (ct->c_type) { + case CT_MULTIPART: { + struct multipart *m = (struct multipart *) ct->c_ctparams; + struct part *part; + + for (part = m->mp_parts; part; part = part->mp_next) { + const int part_encoding = + least_restrictive_encoding (part->mp_part); + + if (less_restrictive (encoding, part_encoding)) { + encoding = part_encoding; + } + } + break; + } + + case CT_MESSAGE: + if (ct->c_subtype == MESSAGE_EXTERNAL) { + struct exbody *e = (struct exbody *) ct->c_ctparams; + const int part_encoding = + least_restrictive_encoding (e->eb_content); + + if (less_restrictive (encoding, part_encoding)) { + encoding = part_encoding; + } + } + break; + + default: { + if (less_restrictive (encoding, ct->c_encoding)) { + encoding = ct->c_encoding; + } + }} + + return encoding; +} + + +/* + * Return whether the second encoding is less restrictive than the first, where + * "less restrictive" is in the sense used by RFC 2045 Secs. 6.1 and 6.4. So, + * CE_BINARY is less restrictive than CE_8BIT and + * CE_8BIT is less restrictive than CE_7BIT. + */ +static int +less_restrictive (int encoding, int second_encoding) { + switch (second_encoding) { + case CE_BINARY: + return encoding != CE_BINARY; + case CE_8BIT: + return encoding != CE_BINARY && encoding != CE_8BIT; + case CE_7BIT: + return encoding != CE_BINARY && encoding != CE_8BIT && + encoding != CE_7BIT; + default : + return 0; + } +} + + +/* + * Convert character set of each part. + */ static int convert_charsets (CT ct, char *dest_charset, int *message_mods) { int status = OK; @@ -1708,14 +2396,18 @@ convert_charsets (CT ct, char *dest_charset, int *message_mods) { status = convert_charset (ct, dest_charset, message_mods); if (status == OK) { if (verbosw) { + char *ct_charset = content_charset (ct); + report (NULL, ct->c_partno, ct->c_file, - "convert %s to %s", - content_charset(ct), dest_charset); + "convert %s to %s", ct_charset, dest_charset); + free (ct_charset); } } else { + char *ct_charset = content_charset (ct); + report ("iconv", ct->c_partno, ct->c_file, - "failed to convert %s to %s", - content_charset(ct), dest_charset); + "failed to convert %s to %s", ct_charset, dest_charset); + free (ct_charset); } } break; @@ -1735,9 +2427,8 @@ convert_charsets (CT ct, char *dest_charset, int *message_mods) { case CT_MESSAGE: if (ct->c_subtype == MESSAGE_EXTERNAL) { - struct exbody *e; + struct exbody *e = (struct exbody *) ct->c_ctparams; - e = (struct exbody *) ct->c_ctparams; status = convert_charsets (e->eb_content, dest_charset, message_mods); } @@ -1751,8 +2442,193 @@ convert_charsets (CT ct, char *dest_charset, int *message_mods) { } +/* + * Fix various problems that aren't handled elsewhere. These + * are fixed unconditionally: there are no switches to disable + * them. Currently, "problems" are these: + * 1) remove extraneous semicolon at the end of a header parameter list + * 2) replace RFC 2047 encoding with RFC 2231 encoding of name and + * filename parameters in Content-Type and Content-Disposition + * headers, respectively. + */ +static int +fix_always (CT ct, int *message_mods) { + int status = OK; + + switch (ct->c_type) { + case CT_MULTIPART: { + struct multipart *m = (struct multipart *) ct->c_ctparams; + struct part *part; + + for (part = m->mp_parts; status == OK && part; part = part->mp_next) { + status = fix_always (part->mp_part, message_mods); + } + break; + } + + case CT_MESSAGE: + if (ct->c_subtype == MESSAGE_EXTERNAL) { + struct exbody *e = (struct exbody *) ct->c_ctparams; + + status = fix_always (e->eb_content, message_mods); + } + break; + + default: { + HF hf; + + if (ct->c_first_hf) { + fix_filename_encoding (ct); + } + + for (hf = ct->c_first_hf; hf; hf = hf->next) { + size_t len = strlen (hf->value); + + if (strcasecmp (hf->name, TYPE_FIELD) != 0 && + strcasecmp (hf->name, DISPO_FIELD) != 0) { + /* Only do this for Content-Type and + Content-Disposition fields because those are the + only headers that parse_mime() warns about. */ + continue; + } + + /* whitespace following a trailing ';' will be nuked as well */ + if (hf->value[len - 1] == '\n') { + while (isspace((unsigned char)(hf->value[len - 2]))) { + if (len-- == 0) { break; } + } + } + + if (hf->value[len - 2] == ';') { + /* Remove trailing ';' from parameter value. */ + hf->value[len - 2] = '\n'; + hf->value[len - 1] = '\0'; + + /* Also, if Content-Type parameter, remove trailing ';' + from ct->c_ctline. This probably isn't necessary + but can't hurt. */ + if (strcasecmp(hf->name, TYPE_FIELD) == 0 && ct->c_ctline) { + size_t l = strlen(ct->c_ctline) - 1; + while (isspace((unsigned char)(ct->c_ctline[l])) || + ct->c_ctline[l] == ';') { + ct->c_ctline[l--] = '\0'; + if (l == 0) { break; } + } + } + + ++*message_mods; + if (verbosw) { + report (NULL, ct->c_partno, ct->c_file, + "remove trailing ; from %s parameter value", + hf->name); + } + } + } + }} + + return status; +} + + +/* + * Factor out common code for loops in fix_filename_encoding(). + */ +static int +fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm) { + size_t value_len; + int fixed = 0; + + if (((value_len = strlen (value)) > 0) && + strncmp (value, "=?", 2) == 0 && + strncmp (&value[value_len - 2], "?=", 2) == 0) { + /* Looks like an RFC 2047 encoded parameter. */ + char decoded[PATH_MAX + 1]; + + if (decode_rfc2047 (value, decoded, sizeof decoded)) { + /* Encode using RFC 2231. */ + replace_param (first_pm, last_pm, name, decoded, 0); + fixed = 1; + } else { + advise (NULL, "failed to decode %s parameter %s", name, value); + } + } + + return fixed; +} + + +/* + * Replace RFC 2047 encoding with RFC 2231 encoding of name and + * filename parameters in Content-Type and Content-Disposition + * headers, respectively. + */ +static int +fix_filename_encoding (CT ct) { + PM pm; + HF hf; + int fixed = 0; + + for (pm = ct->c_ctinfo.ci_first_pm; pm; pm = pm->pm_next) { + if (pm->pm_name && pm->pm_value && + strcasecmp (pm->pm_name, "name") == 0) { + fixed = fix_filename_param (pm->pm_name, pm->pm_value, + &ct->c_ctinfo.ci_first_pm, + &ct->c_ctinfo.ci_last_pm); + } + } + + for (pm = ct->c_dispo_first; pm; pm = pm->pm_next) { + if (pm->pm_name && pm->pm_value && + strcasecmp (pm->pm_name, "filename") == 0) { + fixed = fix_filename_param (pm->pm_name, pm->pm_value, + &ct->c_dispo_first, + &ct->c_dispo_last); + } + } + + /* Fix hf values to correspond. */ + for (hf = ct->c_first_hf; fixed && hf; hf = hf->next) { + enum { OTHER, TYPE_HEADER, DISPO_HEADER } field = OTHER; + + if (strcasecmp (hf->name, TYPE_FIELD) == 0) { + field = TYPE_HEADER; + } else if (strcasecmp (hf->name, DISPO_FIELD) == 0) { + field = DISPO_HEADER; + } + + if (field != OTHER) { + const char *const semicolon_loc = strchr (hf->value, ';'); + + if (semicolon_loc) { + const size_t len = + strlen (hf->name) + 1 + semicolon_loc - hf->value; + const char *const params = + output_params (len, + field == TYPE_HEADER + ? ct->c_ctinfo.ci_first_pm + : ct->c_dispo_first, + NULL, 0); + const char *const new_params = concat (params, "\n", NULL); + + replace_substring (&hf->value, semicolon_loc, new_params); + free ((char *) new_params); + free ((char *) params); + } else { + advise (NULL, "did not find semicolon in %s:%s\n", + hf->name, hf->value); + } + } + } + + return OK; +} + + +/* + * Output content in input file to output file. + */ static int -write_content (CT ct, char *input_filename, char *outfile, int modify_inplace, +write_content (CT ct, const char *input_filename, char *outfile, int modify_inplace, int message_mods) { int status = OK; @@ -1825,12 +2701,50 @@ write_content (CT ct, char *input_filename, char *outfile, int modify_inplace, } +/* + * parse_mime() does not set lf_line_endings in struct text, so use this + * function to do it. It touches the parts the decodetypes identifies. + */ +static void +set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings) { + switch (ct->c_type) { + case CT_MULTIPART: { + struct multipart *m = (struct multipart *) ct->c_ctparams; + struct part *part; + + for (part = m->mp_parts; part; part = part->mp_next) { + set_text_ctparams(part->mp_part, decodetypes, lf_line_endings); + } + break; + } + + case CT_MESSAGE: + if (ct->c_subtype == MESSAGE_EXTERNAL) { + struct exbody *e = (struct exbody *) ct->c_ctparams; + + set_text_ctparams(e->eb_content, decodetypes, lf_line_endings); + } + break; + + default: + if (should_decode(decodetypes, ct->c_ctinfo.ci_type, ct->c_ctinfo.ci_subtype)) { + if (ct->c_ctparams == NULL) { + if ((ct->c_ctparams = (struct text *) mh_xcalloc (1, sizeof (struct text))) == NULL) { + adios (NULL, "out of memory"); + } + } + ((struct text *) ct->c_ctparams)->lf_line_endings = lf_line_endings; + } + } +} + + /* * If "rmmproc" is defined, call that to remove the file. Otherwise, * use the standard MH backup file. */ static int -remove_file (char *file) { +remove_file (const char *file) { if (rmmproc) { char *rmm_command = concat (rmmproc, " ", file, NULL); int status = system (rmm_command); @@ -1846,6 +2760,9 @@ remove_file (char *file) { } +/* + * Output formatted message to user. + */ static void report (char *what, char *partno, char *filename, char *message, ...) { va_list args;