Always initialize those two variables made static in commit

[nmh] / uip / mhfixmsg.c

diff --git a/uip/mhfixmsg.c b/uip/mhfixmsg.c
index ffe97acdb7e6b4d421dfa71983c61d2c4d8ae4f7..f80ff9be156bb87d71048e89f40eac571ca7da2c 100644 (file)
--- a/uip/mhfixmsg.c
+++ b/uip/mhfixmsg.c
@@ -55,6 +55,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 */
 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 *);
 
 /* mhoutsbr.c */
 int output_message (CT, char *);


@@ -85,6 +88,8 @@ static int replace_boundary (CT, char *, char *);
 static int fix_multipart_cte (CT, int *);
 static int set_ce (CT, int);
 static int ensure_text_plain (CT *, CT, int *, int);
 static int fix_multipart_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 CT divide_part (CT);
 static void copy_ctinfo (CI, CI);
 static CT build_text_plain_part (CT);
 static CT divide_part (CT);
 static void copy_ctinfo (CI, CI);


@@ -99,6 +104,7 @@ static int decode_text_parts (CT, int, int *);
 static int content_encoding (CT, const char **);
 static int strip_crs (CT, int *);
 static int convert_charsets (CT, char *, int *);
 static int content_encoding (CT, const char **);
 static int strip_crs (CT, int *);
 static int convert_charsets (CT, char *, int *);

+static int fix_always (CT, int *);

 static int write_content (CT, char *, char *, int, int);
 static int remove_file (char *);
 static void report (char *, char *, char *, char *, ...);
 static int write_content (CT, char *, char *, int, int);
 static int remove_file (char *);
 static void report (char *, char *, char *, char *, ...);


@@ -215,12 +221,12 @@ main (int argc, char **argv) {
             case NRPRCSW:
                 rmmproc = NULL;
                 continue;
             case NRPRCSW:
                 rmmproc = NULL;
                 continue;

-           case CHGSW:
-               chgflag = 1;
-               continue;
-           case NCHGSW:
-               chgflag = 0;
-               continue;
+            case CHGSW:
+                chgflag = 1;
+                continue;
+            case NCHGSW:
+                chgflag = 0;
+                continue;

             case VERBSW:
                 verbosw = 1;
                 continue;
             case VERBSW:
                 verbosw = 1;
                 continue;


@@ -256,6 +262,7 @@ main (int argc, char **argv) {
     }
 
     suppress_bogus_mp_content_warning = skip_mp_cte_check = 1;
     }
 
     suppress_bogus_mp_content_warning = skip_mp_cte_check = 1;

+    suppress_extraneous_trailing_semicolon_warning = 1;

 
     if (! context_find ("path"))
         free (path ("./", TFOLDER));
 
     if (! context_find ("path"))
         free (path ("./", TFOLDER));


@@ -403,6 +410,7 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
     }
 
     reverse_alternative_parts (*ctp);
     }
 
     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->fixboundary) {
         status = fix_boundary (ctp, &message_mods);
     }


@@ -420,7 +428,7 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
         status = convert_charsets (*ctp, fx->textcharset, &message_mods);
     }
 
         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;
         /* Set the umask for the contents file.  This currently
            isn't used but just in case it is in the future. */
         struct stat st;


@@ -474,7 +482,7 @@ fix_boundary (CT *ct, int *message_mods) {
     struct multipart *mp;
     int status = OK;
 
     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;
 
         /*
         mp = (struct multipart *) (*ct)->c_ctparams;
 
         /*


@@ -509,6 +517,7 @@ fix_boundary (CT *ct, int *message_mods) {
                                         "fix multipart boundary");
                             }
                         } else {
                                         "fix multipart boundary");
                             }
                         } else {

+                            *ct = NULL;

                             advise (NULL, "unable to parse fixed part");
                             status = NOTOK;
                         }
                             advise (NULL, "unable to parse fixed part");
                             status = NOTOK;
                         }


@@ -841,69 +850,72 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
 
     switch ((*ct)->c_type) {
     case CT_TEXT: {
 
     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) {
         /* 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;
             int new_subpart_number = 1;

+            int has_text_plain =
+                find_textplain_sibling (parent, replacetextplain,
+                                        &new_subpart_number);

 
 

-            /* 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;
+            if (! has_text_plain) {
+                /* Parent is a multipart/alternative.  Insert a new
+                   text/plain subpart. */
+                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");

                     }
                     }

-                    break;
+                } else {
+                    status = NOTOK;

                 }
                 }

-                prev = part;

             }
             }

+        } 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);
+            }
+
+            free (type_subtype);

 
             if (! has_text_plain) {
                 /* Parent is a multipart/alternative.  Insert a new
                    text/plain subpart. */
 
             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 {
                     ++*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;
                 }
             }
                     status = NOTOK;
                 }
             }


@@ -970,6 +982,71 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
 }
 
 
 }
 
 

+/* See if there is a sibling text/plain. */
+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;
+}
+
+
+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;
+    }
+}
+
+

 static CT
 build_text_plain_part (CT encoded_part) {
     CT tp_part = divide_part (encoded_part);
 static CT
 build_text_plain_part (CT encoded_part) {
     CT tp_part = divide_part (encoded_part);


@@ -996,7 +1073,7 @@ build_text_plain_part (CT encoded_part) {
     }
 
     free_content (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;
     free (tmp_plain_file);
 
     return NULL;


@@ -1262,7 +1339,7 @@ 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,
     }
 
     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 = (struct part *) mh_xmalloc (sizeof *p);
     p->mp_next = (struct part *) mh_xmalloc (sizeof *p->mp_next);


@@ -1775,6 +1852,87 @@ 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" is just one:  an extraneous
+ * semicolon at the end of a header parameter list.)
+ */
+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;
+
+        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;
+}
+
+

 static int
 write_content (CT ct, char *input_filename, char *outfile, int modify_inplace,
                int message_mods) {
 static int
 write_content (CT ct, char *input_filename, char *outfile, int modify_inplace,
                int message_mods) {