]> diplodocus.org Git - nmh/blobdiff - uip/mhfixmsg.c
Alter HasSuffixC()'s char * to be const.
[nmh] / uip / mhfixmsg.c
index 55db2c0b0f55de587bd93d60460d8874c963f186..ee25624c8ee13ea51edf2ddc237fcc624c576b9b 100644 (file)
@@ -108,7 +108,6 @@ 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 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 CT build_multipart_alt (CT, CT, int, int);
 static int boundary_in_content (FILE **, char *, const char *);
 static void transfer_noncontent_headers (CT, CT);
@@ -117,6 +116,9 @@ 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 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 fix_always (CT, int *);
 static int fix_filename_param (char *, char *, PM *, PM *);
 static int convert_charsets (CT, char *, int *);
 static int fix_always (CT, int *);
 static int fix_filename_param (char *, char *, PM *, PM *);
@@ -150,7 +152,7 @@ main (int argc, char **argv) {
     fx.lf_line_endings = 0;
     fx.textcharset = NULL;
 
     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;
 
 
     done = freects_done;
 
@@ -356,9 +358,7 @@ main (int argc, char **argv) {
             }
         }
 
             }
         }
 
-        if (! (cts = (CT *) mh_xcalloc ((size_t) 2, sizeof *cts))) {
-            adios (NULL, "out of memory");
-        }
+        cts = mh_xcalloc(2, sizeof *cts);
         ctp = cts;
 
         if ((ct = parse_mime (file))) {
         ctp = cts;
 
         if ((ct = parse_mime (file))) {
@@ -413,10 +413,7 @@ main (int argc, char **argv) {
             }
         seq_setprev (mp);       /* set the previous-sequence */
 
             }
         seq_setprev (mp);       /* set the previous-sequence */
 
-        if (! (cts =
-               (CT *) mh_xcalloc ((size_t) (mp->numsel + 1), sizeof *cts))) {
-            adios (NULL, "out of memory");
-        }
+        cts = mh_xcalloc(mp->numsel + 1, sizeof *cts);
         ctp = cts;
 
         for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
         ctp = cts;
 
         for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
@@ -526,7 +523,9 @@ mhfixmsgsbr (CT *ctp, const fix_transformations *fx, char *outfile) {
             ensure_text_plain (ctp, NULL, &message_mods, fx->replacetextplain);
     }
     if (status == OK  &&  fx->decodetext) {
             ensure_text_plain (ctp, NULL, &message_mods, fx->replacetextplain);
     }
     if (status == OK  &&  fx->decodetext) {
-        status = decode_text_parts (*ctp, fx->decodetext, fx->decodetypes, &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 (status == OK  &&  fx->textcharset != NULL) {
         status = convert_charsets (*ctp, fx->textcharset, &message_mods);
@@ -820,9 +819,7 @@ replace_boundary (CT ct, char *file, char *boundary) {
                 fprintf (fpout, "%s:%s%s\n", np, new_ctline,
                         new_params ? new_params : "");
                free(new_ctline);
                 fprintf (fpout, "%s:%s%s\n", np, new_ctline,
                         new_params ? new_params : "");
                free(new_ctline);
-               if (new_params) {
-                   free(new_params);
-                }
+                mh_xfree(new_params);
             }
 
             free (vp);
             }
 
             free (vp);
@@ -831,7 +828,7 @@ replace_boundary (CT ct, char *file, char *boundary) {
             continue;
 
         case BODY:
             continue;
 
         case BODY:
-            fputs ("\n", fpout);
+            putc('\n', fpout);
             /* buf will have a terminating NULL, skip it. */
             if ((int) fwrite (buf, 1, bufsz-1, fpout) < bufsz-1) {
                 advise (file, "fwrite");
             /* buf will have a terminating NULL, skip it. */
             if ((int) fwrite (buf, 1, bufsz-1, fpout) < bufsz-1) {
                 advise (file, "fwrite");
@@ -925,10 +922,10 @@ fix_types (CT ct, svector_t fixtypes, int *message_mods) {
                            * c_ctline
                            */
                         /* Extract type and subtype from type/subtype. */
                            * c_ctline
                            */
                         /* Extract type and subtype from type/subtype. */
-                        ct_type = getcpy (ct_type_subtype);
+                        ct_type = mh_xstrdup(ct_type_subtype);
                         if ((cp = strchr (ct_type, '/'))) {
                             *cp = '\0';
                         if ((cp = strchr (ct_type, '/'))) {
                             *cp = '\0';
-                            ct_subtype = getcpy (++cp);
+                            ct_subtype = mh_xstrdup(++cp);
                         } else {
                             advise (NULL, "missing / in MIME type of %s %s",
                                     ct->c_file, ct->c_partno);
                         } else {
                             advise (NULL, "missing / in MIME type of %s %s",
                                     ct->c_file, ct->c_partno);
@@ -992,7 +989,7 @@ replace_substring (char **str, const char *old, const char *new) {
         char *prefix, *new_str;
 
         if (cp - *str) {
         char *prefix, *new_str;
 
         if (cp - *str) {
-            prefix = getcpy (*str);
+            prefix = mh_xstrdup(*str);
             *(prefix + (cp - *str)) = '\0';
             new_str = concat (prefix, new, remainder, NULL);
             free (prefix);
             *(prefix + (cp - *str)) = '\0';
             new_str = concat (prefix, new, remainder, NULL);
             free (prefix);
@@ -1003,9 +1000,9 @@ replace_substring (char **str, const char *old, const char *new) {
         free (*str);
 
         return *str = new_str;
         free (*str);
 
         return *str = new_str;
-    } else {
-        return NULL;
     }
     }
+
+    return NULL;
 }
 
 
 }
 
 
@@ -1079,8 +1076,9 @@ fix_composite_cte (CT ct, int *message_mods) {
                 if (! strncasecmp (name, ENCODING_FIELD,
                                    strlen (ENCODING_FIELD))) {
                     char *prefix = "Nmh-REPLACED-INVALID-";
                 if (! strncasecmp (name, ENCODING_FIELD,
                                    strlen (ENCODING_FIELD))) {
                     char *prefix = "Nmh-REPLACED-INVALID-";
-                    HF h = mh_xmalloc (sizeof *h);
+                    HF h;
 
 
+                    NEW(h);
                     h->name = add (hf->name, NULL);
                     h->hf_encoding = hf->hf_encoding;
                     h->next = hf->next;
                     h->name = add (hf->name, NULL);
                     h->hf_encoding = hf->hf_encoding;
                     h->next = hf->next;
@@ -1156,6 +1154,10 @@ set_ce (CT ct, int encoding) {
            ct->c_cefile.ce_file to the name of the file containing
            the contents. */
 
            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;
 
         /* Restore the cefile. */
         ct->c_cefile = decoded_content_info;
 
@@ -1176,9 +1178,9 @@ set_ce (CT ct, int encoding) {
         ct->c_celine = add (cte, NULL);
 
         return OK;
         ct->c_celine = add (cte, NULL);
 
         return OK;
-    } else {
-        return NOTOK;
     }
     }
+
+    return NOTOK;
 }
 
 
 }
 
 
@@ -1273,7 +1275,7 @@ ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
                         HF hf;
 
                         parent->c_subtype = MULTI_ALTERNATE;
                         HF hf;
 
                         parent->c_subtype = MULTI_ALTERNATE;
-                        parent->c_ctinfo.ci_subtype = getcpy ("alternative");
+                        parent->c_ctinfo.ci_subtype = mh_xstrdup("alternative");
                         if (! replace_substring (&parent->c_ctline, "/related",
                                                  "/alternative")) {
                             advise (NULL,
                         if (! replace_substring (&parent->c_ctline, "/related",
                                                  "/alternative")) {
                             advise (NULL,
@@ -1392,8 +1394,9 @@ find_textplain_sibling (CT parent, int replacetextplain,
 static int
 insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) {
     struct multipart *mp = (struct multipart *) parent->c_ctparams;
 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);
+    struct part *new_part;
 
 
+    NEW(new_part);
     if ((new_part->mp_part = build_text_plain_part (ct))) {
         char buffer[16];
         snprintf (buffer, sizeof buffer, "%d", new_subpart_number);
     if ((new_part->mp_part = build_text_plain_part (ct))) {
         char buffer[16];
         snprintf (buffer, sizeof buffer, "%d", new_subpart_number);
@@ -1405,12 +1408,12 @@ insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) {
                     buffer, NULL);
 
         return 1;
                     buffer, NULL);
 
         return 1;
-    } else {
-        free_content (new_part->mp_part);
-        free (new_part);
-
-        return 0;
     }
     }
+
+    free_content (new_part->mp_part);
+    free (new_part);
+
+    return 0;
 }
 
 
 }
 
 
@@ -1498,9 +1501,7 @@ static CT
 divide_part (CT ct) {
     CT new_part;
 
 divide_part (CT ct) {
     CT new_part;
 
-    if ((new_part = (CT) mh_xcalloc (1, sizeof *new_part)) == NULL)
-        adios (NULL, "out of memory");
-
+    NEW0(new_part);
     /* Just copy over what is needed for decoding.  c_vrsn and
        c_celine aren't necessary. */
     new_part->c_file = add (ct->c_file, NULL);
     /* Just copy over what is needed for decoding.  c_vrsn and
        c_celine aren't necessary. */
     new_part->c_file = add (ct->c_file, NULL);
@@ -1537,10 +1538,10 @@ copy_ctinfo (CI dest, CI src) {
        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) {
        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) {
-           d_pm->pm_charset = getcpy(s_pm->pm_charset);
+           d_pm->pm_charset = mh_xstrdup(s_pm->pm_charset);
         }
        if (s_pm->pm_lang) {
         }
        if (s_pm->pm_lang) {
-           d_pm->pm_lang = getcpy(s_pm->pm_lang);
+           d_pm->pm_lang = mh_xstrdup(s_pm->pm_lang);
         }
     }
 
         }
     }
 
@@ -1581,6 +1582,7 @@ decode_part (CT ct) {
 static int
 reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
     int output_subtype, output_encoding;
 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;
 
     char *cp, *cf;
     int status;
 
@@ -1597,14 +1599,13 @@ reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
                     ct->c_file, invo_name, type, subtype);
         }
         return NOTOK;
                     ct->c_file, invo_name, type, subtype);
         }
         return NOTOK;
-    } else {
-        if (strchr (cf, '>')) {
-            advise (NULL, "'>' prohibited in \"%s\",\nplease fix your "
-                    "%s-format-%s/%s profile entry", cf, invo_name, type,
-                    subtype ? subtype : "");
+    }
+    if (strchr (cf, '>')) {
+        advise (NULL, "'>' prohibited in \"%s\",\nplease fix your "
+                "%s-format-%s/%s profile entry", cf, invo_name, type,
+                subtype ? subtype : "");
 
 
-            return NOTOK;
-        }
+        return NOTOK;
     }
 
     cp = concat (cf, " >", file, NULL);
     }
 
     cp = concat (cf, " >", file, NULL);
@@ -1626,8 +1627,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;
     }
         /* 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;
     if (set_ct_type (ct, c_type, output_subtype, output_encoding) == OK) {
         ct->c_cefile.ce_file = file;
         ct->c_cefile.ce_unlink = 1;
@@ -1640,20 +1641,6 @@ 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) {
-    char *ct_charset = content_charset (ct);
-    int encoding = strcasecmp (ct_charset, "US-ASCII")  ?  CE_8BIT  :  CE_7BIT;
-
-    free (ct_charset);
-
-    return encoding;
-}
-
-
 /*
  * Fill in a multipart/alternative part.
  */
 /*
  * Fill in a multipart/alternative part.
  */
@@ -1668,8 +1655,7 @@ build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
     struct multipart *m;
     const struct str2init *ctinit;
 
     struct multipart *m;
     const struct str2init *ctinit;
 
-    if ((ct = (CT) mh_xcalloc (1, sizeof *ct)) == NULL)
-        adios (NULL, "out of memory");
+    NEW0(ct);
 
     /* Set up the multipart/alternative part.  These fields of *ct were
        initialized to 0 by mh_xcalloc():
 
     /* Set up the multipart/alternative part.  These fields of *ct were
        initialized to 0 by mh_xcalloc():
@@ -1771,14 +1757,12 @@ 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);
 
     add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
               "boundary", boundary, 0);
 
-    p = (struct part *) mh_xmalloc (sizeof *p);
-    p->mp_next = (struct part *) mh_xmalloc (sizeof *p->mp_next);
+    NEW(p);
+    NEW(p->mp_next);
     p->mp_next->mp_next = NULL;
     p->mp_next->mp_part = first_alt;
 
     p->mp_next->mp_next = NULL;
     p->mp_next->mp_part = first_alt;
 
-    if ((m = (struct multipart *) mh_xcalloc (1, sizeof (struct multipart))) ==
-        NULL)
-        adios (NULL, "out of memory");
+    NEW0(m);
     m->mp_start = concat (boundary, "\n", NULL);
     m->mp_stop = concat (boundary, "--\n", NULL);
     m->mp_parts = p;
     m->mp_start = concat (boundary, "\n", NULL);
     m->mp_stop = concat (boundary, "--\n", NULL);
     m->mp_parts = p;
@@ -1925,7 +1909,8 @@ set_ct_type (CT ct, int type, int subtype, int encoding) {
  * that character set again after decoding."
  */
 static int
  * that character set again after decoding."
  */
 static int
-decode_text_parts (CT ct, int encoding, const char *decodetypes, int *message_mods) {
+decode_text_parts (CT ct, int encoding, const char *decodetypes,
+                   int *message_mods) {
     int status = OK;
     int lf_line_endings = 0;
 
     int status = OK;
     int lf_line_endings = 0;
 
@@ -1937,7 +1922,8 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes, int *message_mo
         /* 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) {
         /* 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);
+            status = decode_text_parts (part->mp_part, encoding, decodetypes,
+                                        message_mods);
         }
         break;
     }
         }
         break;
     }
@@ -1946,7 +1932,8 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes, int *message_mo
         if (ct->c_subtype == MESSAGE_EXTERNAL) {
             struct exbody *e = (struct exbody *) ct->c_ctparams;
 
         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);
+            status = decode_text_parts (e->eb_content, encoding, decodetypes,
+                                        message_mods);
         }
         break;
 
         }
         break;
 
@@ -1997,12 +1984,13 @@ decode_text_parts (CT ct, int encoding, const char *decodetypes, int *message_mo
                     ct->c_cefile.ce_file = NULL;
                 } else {
                     int enc;
                     ct->c_cefile.ce_file = NULL;
                 } else {
                     int enc;
+
                     if (ct_encoding == CE_BINARY) {
                         enc = CE_BINARY;
                     } else if (ct_encoding == CE_8BIT  &&  encoding == CE_7BIT) {
                         enc = CE_QUOTED;
                     } else {
                     if (ct_encoding == CE_BINARY) {
                         enc = CE_BINARY;
                     } else if (ct_encoding == CE_8BIT  &&  encoding == CE_7BIT) {
                         enc = CE_QUOTED;
                     } else {
-                        enc = charset_encoding (ct);
+                        enc = ct_encoding;
                     }
                     if (set_ce (ct, enc) == OK) {
                         ++*message_mods;
                     }
                     if (set_ce (ct, enc) == OK) {
                         ++*message_mods;
@@ -2256,12 +2244,10 @@ strip_crs (CT ct, int *message_mods) {
                     status = NOTOK;
                 } else {
                     /* Replace the decoded file with the converted one. */
                     status = NOTOK;
                 } else {
                     /* Replace the decoded file with the converted one. */
-                    if (ct->c_cefile.ce_file) {
-                        if (ct->c_cefile.ce_unlink) {
-                            (void) m_unlink (ct->c_cefile.ce_file);
-                        }
-                        free (ct->c_cefile.ce_file);
-                    }
+                    if (ct->c_cefile.ce_file && ct->c_cefile.ce_unlink)
+                        (void) m_unlink (ct->c_cefile.ce_file);
+
+                    mh_xfree(ct->c_cefile.ce_file);
                     ct->c_cefile.ce_file = stripped_content_file;
                     ct->c_cefile.ce_unlink = 1;
 
                     ct->c_cefile.ce_file = stripped_content_file;
                     ct->c_cefile.ce_unlink = 1;
 
@@ -2287,6 +2273,103 @@ strip_crs (CT ct, int *message_mods) {
 }
 
 
 }
 
 
+/*
+ * 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.
  */
 /*
  * Convert character set of each part.
  */
@@ -2515,8 +2598,8 @@ fix_filename_encoding (CT ct) {
                 const char *const new_params = concat (params, "\n", NULL);
 
                 replace_substring (&hf->value, semicolon_loc, new_params);
                 const char *const new_params = concat (params, "\n", NULL);
 
                 replace_substring (&hf->value, semicolon_loc, new_params);
-                free ((char *) new_params);
-                free ((char *) params);
+                free((void *)new_params); /* Cast away const.  Sigh. */
+                free((void *)params);
             } else {
                 advise (NULL, "did not find semicolon in %s:%s\n",
                         hf->name, hf->value);
             } else {
                 advise (NULL, "did not find semicolon in %s:%s\n",
                         hf->name, hf->value);
@@ -2633,9 +2716,7 @@ set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings) {
     default:
         if (should_decode(decodetypes, ct->c_ctinfo.ci_type, ct->c_ctinfo.ci_subtype)) {
             if (ct->c_ctparams == NULL) {
     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");
-                }
+                ct->c_ctparams = mh_xcalloc(1, sizeof (struct text));
             }
             ((struct text *) ct->c_ctparams)->lf_line_endings = lf_line_endings;
         }
             }
             ((struct text *) ct->c_ctparams)->lf_line_endings = lf_line_endings;
         }
@@ -2655,12 +2736,11 @@ remove_file (const char *file) {
 
         free (rmm_command);
         return WIFEXITED (status)  ?  WEXITSTATUS (status)  :  NOTOK;
 
         free (rmm_command);
         return WIFEXITED (status)  ?  WEXITSTATUS (status)  :  NOTOK;
-    } else {
-        /* This is OK for a non-message file, it still uses the
-           BACKUP_PREFIX form.  The backup file will be in the same
-           directory as file. */
-        return rename (file, m_backup (file));
     }
     }
+    /* This is OK for a non-message file, it still uses the
+       BACKUP_PREFIX form.  The backup file will be in the same
+       directory as file. */
+    return rename (file, m_backup (file));
 }
 
 
 }