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) \
*/
typedef struct fix_transformations {
int fixboundary;
- int fixcte;
+ int fixcompositecte;
svector_t fixtypes;
int reformat;
int replacetextplain;
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_multipart_cte (CT, int *);
+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 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 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 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 *);
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.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;
case NFIXBOUNDARYSW:
fx.fixboundary = 0;
continue;
- case FIXCTESW:
- fx.fixcte = 1;
+ case FIXCOMPOSITECTESW:
+ fx.fixcompositecte = 1;
continue;
- case NFIXCTESW:
- fx.fixcte = 0;
+ case NFIXCOMPOSITECTESW:
+ fx.fixcompositecte = 0;
continue;
case FIXTYPESW:
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
}
}
- 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))) {
}
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++) {
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);
+ 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, 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);
/*
- * Fix Content-Transfer-Encoding.
+ * 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_multipart_cte (CT ct, int *message_mods) {
+fix_composite_cte (CT ct, int *message_mods) {
int status = OK;
- if (ct->c_type == CT_MULTIPART) {
- struct multipart *m;
- struct part *part;
-
+ 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;
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;
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;
+ }
}
}
}
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;
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,
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);
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);
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;
/* 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;
}
-/*
- * 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.
*/
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():
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;
- 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;
* 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;
/* 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;
}
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;
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 {
- enc = charset_encoding (ct);
+ enc = ct_encoding;
}
if (set_ce (ct, enc) == OK) {
++*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.
*/
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);
}
+/*
+ * 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.
*/
/*
- * 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.
+ * 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) {
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;
}
projects / nmh / blobdiff