/*
* Allocate space for primary (outside) content
*/
- if ((ct = (CT) mh_xcalloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
/*
* Allocate structure for handling decoded content
fclose(in);
free (ct);
return NULL;
- } else {
- adios (NULL, "draft shouldn't contain %s: field", name);
}
+ adios (NULL, "draft shouldn't contain %s: field", name);
}
/* ignore any Content-Type fields in the header */
goto finish_field;
}
- entry = mh_xmalloc(sizeof(*entry));
- entry->filename = getcpy(s);
+ NEW(entry);
+ entry->filename = mh_xstrdup(s);
entry->next = NULL;
free(vp);
adios (NULL, "Multiple %s headers with different files"
" not allowed", type);
} else {
- convert->filename = getcpy (filename);
+ convert->filename = mh_xstrdup(filename);
}
} else {
- convert = mh_xcalloc (sizeof *convert, 1);
- convert->filename = getcpy (filename);
- convert->type = getcpy (type);
+ NEW0(convert);
+ convert->filename = mh_xstrdup(filename);
+ convert->type = mh_xstrdup(type);
if (convert_tail) {
convert_tail->next = convert;
adios (NULL, "Multiple %s headers with different "
"argstrings not allowed", type);
} else {
- convert->argstring = getcpy (argstring);
+ convert->argstring = mh_xstrdup(argstring);
}
} else {
- convert = mh_xcalloc (sizeof *convert, 1);
- convert->type = getcpy (type);
- convert->argstring = getcpy (argstring);
+ NEW0(convert);
+ convert->type = mh_xstrdup(type);
+ convert->argstring = mh_xstrdup(argstring);
if (convert_tail) {
convert_tail->next = convert;
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_MIXED;
- if ((m = (struct multipart *) mh_xcalloc (1, sizeof(*m))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(m);
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
if (!p)
continue;
- if ((part = (struct part *) mh_xcalloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
adios("reading", "Unable to open %s for", at_entry->filename);
}
- if ((p = (CT) mh_xcalloc (1, sizeof(*p))) == NULL)
- adios(NULL, "out of memory");
-
+ NEW0(p);
init_decoded_content(p, infile);
/*
setup_attach_content(p, at_entry->filename);
- if ((part = (struct part *) mh_xcalloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
free (cts);
/* Extract the type part (as a CT) from filename. */
- if (! (cts = (CT *) mh_xcalloc ((size_t) 2, sizeof *cts))) {
- adios (NULL, "out of memory");
- } else if (! (cts[0] = parse_mime (convert_head->filename))) {
+ cts = mh_xcalloc(2, sizeof *cts);
+ if (! (cts[0] = parse_mime (convert_head->filename))) {
adios (NULL, "failed to parse %s", convert_head->filename);
}
struct part *part;
struct text *t;
- if ((p = (CT) mh_xcalloc (1, sizeof(*p))) == NULL)
- adios(NULL, "out of memory");
-
+ NEW0(p);
init_decoded_content(p, infile);
if (get_ctinfo ("text/plain", p, 0) == NOTOK)
* So this seems like the best option available since we're going
* to call scan_content() on this.
*/
- p->c_cefile.ce_file = getcpy("/dev/null");
+ p->c_cefile.ce_file = mh_xstrdup("/dev/null");
p->c_begin = ftell(in);
p->c_end = ftell(in);
- if ((t = (struct text *) mh_xcalloc (1, sizeof (*t))) == NULL)
- adios (NULL, "out of memory");
-
+ NEW0(t);
t->tx_charset = CHARSET_SPECIFIED;
p->c_ctparams = t;
- if ((part = (struct part *) mh_xcalloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
part->mp_part = p;
}
if ((cp = strchr(prefix, 'a')) == NULL)
adios (NULL, "internal error(4)");
+ /*
+ * If using EAI, force 8-bit charset.
+ */
+ if (header_encoding == CE_8BIT) {
+ set_charset (ct, 1);
+ }
+
/*
* Scan the contents. Choose a transfer encoding, and
* check if prefix for multipart boundary clashes with
}
/* allocate basic Content structure */
- if ((ct = (CT) mh_xcalloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
*ctp = ct;
/* allocate basic structure for handling decoded content */
strncpy (content, buf + 2, sizeof(content));
inlineD = 1;
goto rock_and_roll;
- } else {
- inlineD = 0;
}
+ inlineD = 0;
/* the directive is implicit */
strncpy (content, "text/plain", sizeof(content));
* reference, we need to create another Content structure
* for the message/external-body to wrap it in.
*/
- if ((ct = (CT) mh_xcalloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
init_decoded_content(ct, infilename);
*ctp = ct;
if (get_ctinfo (buffer, ct, 0) == NOTOK)
ct->c_type = CT_MESSAGE;
ct->c_subtype = MESSAGE_EXTERNAL;
- if ((e = (struct exbody *) mh_xcalloc (1, sizeof(*e))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(e);
ct->c_ctparams = (void *) e;
e->eb_parent = ct;
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_DIGEST;
- if ((m = (struct multipart *) mh_xcalloc (1, sizeof(*m))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(m);
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
CT p;
CE pe;
- if ((p = (CT) mh_xcalloc (1, sizeof(*p))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(p);
init_decoded_content (p, infilename);
pe = &p->c_cefile;
if (get_ctinfo ("message/rfc822", p, 0) == NOTOK)
if (listsw && stat (pe->ce_file, &st) != NOTOK)
p->c_end = (long) st.st_size;
- if ((part = (struct part *) mh_xcalloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
ct->c_type = CT_MULTIPART;
ct->c_subtype = vrsn;
- if ((m = (struct multipart *) mh_xcalloc (1, sizeof(*m))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(m);
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
if (!p)
continue;
- if ((part = (struct part *) mh_xcalloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
time (&clock);
snprintf (contentid, sizeof(contentid), "%s\n", message_id (clock, 1));
partno = 0;
- msgfmt = getcpy(contentid);
+ msgfmt = mh_xstrdup(contentid);
}
snprintf (contentid, sizeof(contentid), msgfmt, top ? 0 : ++partno);
- ct->c_id = getcpy (contentid);
+ ct->c_id = mh_xstrdup(contentid);
}
* Decide what to check while scanning this content. Note that
* for text content we always check for 8bit characters if the
* charset is unspecified, because that controls whether or not the
- * character set is us-ascii or retrieved from the locale.
+ * character set is us-ascii or retrieved from the locale. And
+ * we check even if the charset is specified, to allow setting
+ * the proper Content-Transfer-Encoding.
*/
if (ct->c_type == CT_TEXT) {
t = (struct text *) ct->c_ctparams;
if (t->tx_charset == CHARSET_UNSPECIFIED) {
- check8bit = 1;
checknul = 1;
}
+ check8bit = 1;
}
switch (ct->c_reqencoding) {
np = output_params(len, ct->c_dispo_first, NULL, 0);
vp = add(np, vp);
vp = add("\n", vp);
- if (np)
- free(np);
- add_header (ct, getcpy(DISPO_FIELD), vp);
+ mh_xfree(np);
+ add_header (ct, mh_xstrdup(DISPO_FIELD), vp);
}
skip_headers:
/*
* output the Content-Transfer-Encoding
+ * If using EAI and message body is 7-bit, force 8-bit C-T-E.
*/
+ if (header_encoding == CE_8BIT && ct->c_encoding == CE_7BIT) {
+ ct->c_encoding = CE_8BIT;
+ }
+
switch (ct->c_encoding) {
case CE_7BIT:
/* Nothing to output */
for (pm = ct->c_ctinfo.ci_first_pm; pm; pm = pm->pm_next) {
if (strcasecmp(pm->pm_name, "name") == 0) {
- if (pm->pm_value)
- free(pm->pm_value);
- pm->pm_value = getcpy(simplename);
+ mh_xfree(pm->pm_value);
+ pm->pm_value = mh_xstrdup(simplename);
break;
}
}
add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
"name", simplename, 0);
- ct->c_descr = getcpy(simplename);
+ ct->c_descr = mh_xstrdup(simplename);
ct->c_descr = add("\n", ct->c_descr);
- ct->c_cefile.ce_file = getcpy(filename);
+ ct->c_cefile.ce_file = mh_xstrdup(filename);
set_disposition (ct);
cp);
}
- ct->c_dispo_type = cp ? getcpy (cp) : getcpy ("attachment");
+ if (!cp)
+ cp = "attachment";
+ ct->c_dispo_type = mh_xstrdup(cp);
}
}
struct text *t;
if (ct->c_ctparams == NULL) {
- if ((t = ct->c_ctparams =
- (struct text *) mh_xcalloc (1, sizeof (struct text))) ==
- NULL) {
- adios (NULL, "out of memory");
- }
+ NEW0(t);
+ ct->c_ctparams = t;
t->tx_charset = CHARSET_UNSPECIFIED;
} else {
t = (struct text *) ct->c_ctparams;
struct str2init *s2i;
CT reply_ct;
struct part *part;
+ int eightbit = 0;
int status;
type_p = getcpy (type);
NULL);
/* Convert here . . . */
- ct->c_storeproc = getcpy (convert_command);
+ ct->c_storeproc = mh_xstrdup(convert_command);
ct->c_umask = ~m_gmprot ();
if ((status = show_content_aux (ct, 0, convert_command, NULL, NULL)) !=
free (convert_command);
/* Fill out the the new ct, reply_ct. */
- reply_ct = (CT) mh_xcalloc (1, sizeof *reply_ct);
+ NEW0(reply_ct);
init_decoded_content (reply_ct, infile);
if (extract_headers (reply_ct, reply_file, &reply_fp) == NOTOK) {
return;
}
+ /* For text content only, see if it is 8-bit text. */
+ if (reply_ct->c_type == CT_TEXT) {
+ int fd;
+
+ if ((fd = open (reply_file, O_RDONLY)) == NOTOK ||
+ scan_input (fd, &eightbit) == NOTOK) {
+ free (reply_file);
+ admonish (NULL, "failed to read %s", reply_file);
+ return;
+ }
+ (void) close (fd);
+ }
+
/* This sets reply_ct->c_ctparams, and reply_ct->c_termproc if the
charset can't be handled natively. */
for (s2i = str2cts; s2i->si_key; s2i++) {
} else {
set_charset (reply_ct, -1);
charset = get_param (reply_ct->c_ctinfo.ci_first_pm, "charset", '?', 1);
- if (reply_ct->c_reqencoding == CE_UNKNOWN) {
- /* Assume that 8bit is sufficient (for text). */
- reply_ct->c_reqencoding =
- strcasecmp (charset, "US-ASCII") ? CE_8BIT : CE_7BIT;
+ if (reply_ct->c_reqencoding == CE_UNKNOWN &&
+ reply_ct->c_type == CT_TEXT) {
+ /* Assume that 8bit is sufficient (for text). In other words,
+ don't allow it to be encoded as quoted printable if lines
+ are too long. This also sidesteps the check for whether
+ it needs to be encoded as binary; instead, it relies on
+ the applicable mhbuild-convert-text directive to ensure
+ that the resultant text is not binary. */
+ reply_ct->c_reqencoding = eightbit ? CE_8BIT : CE_7BIT;
}
}
part. */
set_charset (*text_plain_ct, -1);
if ((*text_plain_ct)->c_reqencoding == CE_UNKNOWN) {
- /* Assume that 8bit is sufficient (for text). */
+ /* Assume that 8bit is sufficient (for text). In other words,
+ don't allow it to be encoded as quoted printable if lines
+ are too long. This also sidesteps the check for whether
+ it needs to be encoded as binary; instead, it relies on
+ the applicable mhbuild-convert-text directive to ensure
+ that the resultant text is not binary. */
(*text_plain_ct)->c_reqencoding =
- strcasecmp (charset, "US-ASCII") ? CE_8BIT : CE_7BIT;
+ eightbit ? CE_8BIT : CE_7BIT;
}
}
reply_file);
if (close (text_plain_reply) == OK &&
close (addl_reply) == OK) {
+ /* If appended text needed 8-bit but first text didn't,
+ propagate the 8-bit indication. */
+ if ((*text_plain_ct)->c_reqencoding == CE_7BIT &&
+ reply_ct->c_reqencoding == CE_8BIT) {
+ (*text_plain_ct)->c_reqencoding = CE_8BIT;
+ }
+
if (reply_fp) { fclose (reply_fp); }
free (reply_file);
free_content (reply_ct);
reply_ct->c_cefile.ce_fp = reply_fp;
reply_ct->c_cefile.ce_unlink = 1;
- /* Attach the new part to the parent mulitpart/mixed, "m". */
- part = (struct part *) mh_xcalloc (1, sizeof *part);
+ /* Attach the new part to the parent multipart/mixed, "m". */
+ NEW0(part);
part->mp_part = reply_ct;
if (m->mp_parts) {
struct part *p;
projects / nmh / blobdiff