X("nofixboundary", 0, NFIXBOUNDARYSW) \
X("fixcte", 0, FIXCTESW) \
X("nofixcte", 0, NFIXCTESW) \
+ 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) \
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 */
-CT parse_mime (char *);
-void reverse_parts (CT);
+/* 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 *);
-/* mhshowsbr.c */
-int show_content_aux (CT, int, char *, char *);
-
/* mhmisc.c */
void flush_errors (void);
typedef struct fix_transformations {
int fixboundary;
int fixcte;
+ svector_t fixtypes;
int reformat;
int replacetextplain;
int decodetext;
} fix_transformations;
int mhfixmsgsbr (CT *, const fix_transformations *, char *);
-static void reverse_alternative_parts (CT);
static int fix_boundary (CT *, int *);
static int get_multipart_boundary (CT, char **);
static int replace_boundary (CT, char *, char *);
+static int fix_types (CT, svector_t, int *);
+static char *replace_substring (char **, const char *, const 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 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 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 *, ...);
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.fixtypes = NULL;
fx.replacetextplain = 0;
fx.decodetext = CE_8BIT;
fx.textcharset = NULL;
case NFIXCTESW:
fx.fixcte = 0;
continue;
+ 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;
continue;
case NRPRCSW:
rmmproc = NULL;
continue;
+ case CHGSW:
+ chgflag = 1;
+ continue;
+ case NCHGSW:
+ chgflag = 0;
+ continue;
case VERBSW:
verbosw = 1;
continue;
}
suppress_bogus_mp_content_warning = skip_mp_cte_check = 1;
+ suppress_extraneous_trailing_semicolon_warning = 1;
if (! context_find ("path"))
free (path ("./", TFOLDER));
}
}
- 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))) { *ctp++ = ct; }
} else {
/*
* message(s) are coming from a folder
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;
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
char *msgnam;
msgnam = m_name (msgnum);
- if ((ct = parse_mime (msgnam))) *ctp++ = ct;
+ if ((ct = parse_mime (msgnam))) { *ctp++ = ct; }
}
}
- 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 */
status = 1;
}
+ if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); }
free (outfile);
free (file);
}
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->fixtypes != NULL) {
+ status = fix_types (*ctp, fx->fixtypes, &message_mods);
+ }
if (status == OK && fx->fixcte) {
status = fix_multipart_cte (*ctp, &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;
}
if (modify_inplace) {
- if (status != OK) (void) m_unlink (outfile);
+ if (status != OK) { (void) m_unlink (outfile); }
free (outfile);
outfile = NULL;
}
}
-/* parse_mime() arranges alternates in reverse (priority) order, so
- reverse them back. This will put a text/plain part at the front of
- a multipart/alternative part, for example, where it belongs. */
-static void
-reverse_alternative_parts (CT ct) {
- if (ct->c_type == CT_MULTIPART) {
- struct multipart *m = (struct multipart *) ct->c_ctparams;
- struct part *part;
-
- if (ct->c_subtype == MULTI_ALTERNATE) {
- reverse_parts (ct);
- }
-
- /* And call recursively on each part of a multipart. */
- for (part = m->mp_parts; part; part = part->mp_next) {
- reverse_alternative_parts (part->mp_part);
- }
- }
-}
-
-
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;
/*
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;
report (NULL, NULL, filename,
"fix multipart boundary");
}
+ } else {
+ *ct = NULL;
+ advise (NULL, "unable to parse fixed part");
+ status = NOTOK;
}
free (filename);
} else {
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:
}
+static int
+fix_types (CT ct, svector_t fixtypes, 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_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;
+}
+
+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;
+ }
+}
+
+
static int
fix_multipart_cte (CT ct, int *message_mods) {
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 ((*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 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. */
- 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;
}
}
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);
}
}
+/* 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);
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;
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
Could show_multi() in mhshowsbr.c avoid this? */
/* Check for invo_name-format-type/subtype. */
- cp = concat (invo_name, "-format-", type, "/", subtype, NULL);
- if ((cf = context_find (cp)) && *cf != '\0') {
+ if ((cf = context_find_by_type ("format", type, subtype)) == NULL) {
+ if (verbosw) {
+ advise (NULL, "Don't know how to convert %s, there is no "
+ "%s-format-%s/%s profile entry",
+ ct->c_file, invo_name, type, subtype);
+ }
+ return NOTOK;
+ } else {
if (strchr (cf, '>')) {
- free (cp);
advise (NULL, "'>' prohibited in \"%s\",\nplease fix your "
"%s-format-%s/%s profile entry", cf, invo_name, type,
- subtype);
- return NOTOK;
- }
- } else {
- free (cp);
-
- /* Check for invo_name-format-type. */
- cp = concat (invo_name, "-format-", type, NULL);
- if (! (cf = context_find (cp)) || *cf == '\0') {
- free (cp);
- if (verbosw) {
- advise (NULL, "Don't know how to convert %s, there is no "
- "%s-format-%s/%s profile entry",
- ct->c_file, invo_name, type, subtype);
- }
- return NOTOK;
- }
+ subtype ? subtype : "");
- if (strchr (cf, '>')) {
- free (cp);
- advise (NULL, "'>' prohibited in \"%s\"", cf);
return NOTOK;
}
}
- free (cp);
cp = concat (cf, " >", file, NULL);
- status = show_content_aux (ct, 0, cp, NULL);
+ status = show_content_aux (ct, 0, cp, NULL, NULL);
free (cp);
/* Unlink decoded content tmp file and free its filename to avoid
/* 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;
+ char *ct_charset = content_charset (ct);
+ int encoding = strcasecmp (ct_charset, "US-ASCII") ? CE_8BIT : CE_7BIT;
+
+ free (ct_charset);
return encoding;
}
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,
}
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);
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 = decode_text_parts (e->eb_content, encoding, message_mods);
}
break;
static int
strip_crs (CT ct, int *message_mods) {
- /* norm_charmap() is case sensitive. */
char *charset = content_charset (ct);
int status = OK;
size_t i;
int last_char_was_cr = 0;
- if (end > 0) bytes_to_read -= bytes_read;
+ if (end > 0) { bytes_to_read -= bytes_read; }
for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
if (*cp == '\n' && last_char_was_cr) {
if (*cp == '\r') {
last_char_was_cr = 1;
} else if (last_char_was_cr) {
- if (*cp != '\n') write (fd, "\r", 1);
- write (fd, cp, 1);
+ if (*cp != '\n') {
+ if (write (fd, "\r", 1) < 0) {
+ advise (tempfile, "CR write");
+ }
+ }
+ if (write (fd, cp, 1) < 0) {
+ advise (tempfile, "write");
+ }
last_char_was_cr = 0;
} else {
- write (fd, cp, 1);
+ if (write (fd, cp, 1) < 0) {
+ advise (tempfile, "write");
+ }
last_char_was_cr = 0;
}
}
}
}
+ free (charset);
+
return status;
}
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;
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);
}
}
+/*
+ * 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) {
}
}
}
- if (new != -1) close (new);
- if (old != -1) close (old);
+ if (new != -1) { close (new); }
+ if (old != -1) { close (old); }
(void) m_unlink (outfile);
if (i < 0) {
projects / nmh / blobdiff