-
-/*
- * mhbuildsbr.c -- routines to expand/translate MIME composition files
+/* mhbuildsbr.c -- routines to expand/translate MIME composition files
*
* This code is Copyright (c) 2002, by the authors of nmh. See the
* COPYRIGHT file in the root directory of the nmh distribution for
#include <h/md5.h>
#include <h/mts.h>
#include <h/tws.h>
+#include <h/fmt_scan.h>
#include <h/mime.h>
#include <h/mhparse.h>
+#include "h/done.h"
#include <h/utils.h>
+#include "h/mhcachesbr.h"
+#include "mhmisc.h"
+#include "sbr/m_mktemp.h"
+#include "sbr/message_id.h"
+#include "sbr/mime_type.h"
+#include "mhfree.h"
+#include "mhshowsbr.h"
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
extern int debugsw;
-extern int listsw;
-extern int rfc934sw;
-extern int contentidsw;
-
-/* cache policies */
-extern int rcachesw; /* mhcachesbr.c */
-extern int wcachesw; /* mhcachesbr.c */
+extern bool listsw;
+extern bool rfc934sw;
+extern bool contentidsw;
static char prefix[] = "----- =_aaaaaaaaaa";
struct convert_list *next;
} convert_list;
-/*
- * Maximum size of URL token in message/external-body
- */
-
-#define MAXURLTOKEN 40
-
-
-/* mhmisc.c */
-void content_error (char *, CT, char *, ...);
-
-/* mhcachesbr.c */
-int find_cache (CT, int, int *, char *, char *, int);
-
-/* mhfree.c */
-extern CT *cts;
-void freects_done (int) NORETURN;
-void free_ctinfo (CT);
-void free_encoding (CT, int);
/*
* static prototypes
int header_encoding, size_t maxunencoded, int verbose)
{
int compnum, state;
- char buf[BUFSIZ], name[NAMESZ];
+ char buf[NMH_BUFSIZ], name[NAMESZ];
char *cp, *np, *vp;
struct multipart *m;
struct part **pp;
CT ct;
FILE *in;
HF hp;
- m_getfld_state_t gstate = 0;
+ m_getfld_state_t gstate;
struct attach_list *attach_head = NULL, *attach_tail = NULL, *at_entry;
convert_list *convert_head = NULL, *convert_tail = NULL, *convert;
/*
* 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
* draft into the linked list of header fields for
* the new MIME message.
*/
- m_getfld_track_filepos (&gstate, in);
+ gstate = m_getfld_state_init(in);
+ m_getfld_track_filepos2(&gstate);
for (compnum = 1;;) {
int bufsz = sizeof buf;
- switch (state = m_getfld (&gstate, name, buf, &bufsz, in)) {
+ switch (state = m_getfld2(&gstate, name, buf, &bufsz)) {
case FLD:
case FLDPLUS:
compnum++;
fclose(in);
free (ct);
return NULL;
- } else {
- adios (NULL, "draft shouldn't contain %s: field", name);
}
+ die("draft shouldn't contain %s: field", name);
}
/* ignore any Content-Type fields in the header */
if (!strcasecmp (name, TYPE_FIELD)) {
while (state == FLDPLUS) {
bufsz = sizeof buf;
- state = m_getfld (&gstate, name, buf, &bufsz, in);
+ state = m_getfld2(&gstate, name, buf, &bufsz);
}
goto finish_field;
}
/* get copies of the buffers */
- np = add (name, NULL);
- vp = add (buf, NULL);
+ np = mh_xstrdup(name);
+ vp = mh_xstrdup(buf);
/* if necessary, get rest of field */
while (state == FLDPLUS) {
bufsz = sizeof buf;
- state = m_getfld (&gstate, name, buf, &bufsz, in);
+ state = m_getfld2(&gstate, name, buf, &bufsz);
vp = add (buf, vp); /* add to previous value */
}
goto finish_field;
}
- entry = mh_xmalloc(sizeof(*entry));
- entry->filename = getcpy(s);
+ NEW(entry);
+ entry->filename = mh_xstrdup(s);
entry->next = NULL;
free(vp);
attach_head = attach_tail = entry;
}
} else if (strncasecmp(MHBUILD_FILE_PSEUDOHEADER, np,
- strlen (MHBUILD_FILE_PSEUDOHEADER)) == 0) {
+ LEN(MHBUILD_FILE_PSEUDOHEADER)) == 0) {
/* E.g.,
* Nmh-mhbuild-file-text/calendar: /home/user/Mail/inbox/9
*/
- char *type = np + strlen (MHBUILD_FILE_PSEUDOHEADER);
+ char *type = np + LEN(MHBUILD_FILE_PSEUDOHEADER);
char *filename = vp;
- /* vp should begin with a space because m_getfld()
+ /* vp should begin with a space because m_getfld2()
includes the space after the colon in buf. */
while (isspace((unsigned char) *filename)) { ++filename; }
/* Trim trailing newline and any other whitespace. */
if (convert) {
if (convert->filename &&
strcasecmp (convert->filename, filename)) {
- adios (NULL, "Multiple %s headers with different files"
+ die("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;
free (vp);
free (np);
} else if (strncasecmp(MHBUILD_ARGS_PSEUDOHEADER, np,
- strlen (MHBUILD_ARGS_PSEUDOHEADER)) == 0) {
+ LEN(MHBUILD_ARGS_PSEUDOHEADER)) == 0) {
/* E.g.,
* Nmh-mhbuild-args-text/calendar: -reply accept
*/
- char *type = np + strlen (MHBUILD_ARGS_PSEUDOHEADER);
+ char *type = np + LEN(MHBUILD_ARGS_PSEUDOHEADER);
char *argstring = vp;
- /* vp should begin with a space because m_getfld()
+ /* vp should begin with a space because m_getfld2()
includes the space after the colon in buf. */
while (isspace((unsigned char) *argstring)) { ++argstring; }
/* Trim trailing newline and any other whitespace. */
if (convert) {
if (convert->argstring &&
strcasecmp (convert->argstring, argstring)) {
- adios (NULL, "Multiple %s headers with different "
+ die("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;
case BODY:
fseek (in, (long) (-strlen (buf)), SEEK_CUR);
- /* fall through */
+ break;
case FILEEOF:
break;
case LENERR:
case FMTERR:
- adios (NULL, "message format error in component #%d", compnum);
+ die("message format error in component #%d", compnum);
default:
- adios (NULL, "getfld() returned %d", state);
+ die("getfld() returned %d", state);
}
break;
}
for (hp = ct->c_first_hf; hp != NULL; hp = hp->next) {
if (encode_rfc2047(hp->name, &hp->value, header_encoding, NULL)) {
- adios(NULL, "Unable to encode header \"%s\"", hp->name);
+ die("Unable to encode header \"%s\"", hp->name);
}
}
}
*/
if (! dist) {
- np = add (VRSN_FIELD, NULL);
+ np = mh_xstrdup(VRSN_FIELD);
vp = concat (" ", VRSN_VALUE, "\n", NULL);
add_header (ct, np, vp);
}
/*
- * We initally assume we will find multiple contents in the
+ * We initially assume we will find multiple contents in the
* draft. So create a multipart/mixed content to hold everything.
* We can remove this later, if it is not needed.
*/
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;
CT p;
if (user_content (in, buf, &p, infile) == DONE) {
- admonish (NULL, "ignoring spurious #end");
+ inform("ignoring spurious #end, continuing...");
continue;
}
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;
CT *ctp;
convert_list *next;
- done = freects_done;
+ set_done(freects_done);
/* In case there are multiple calls that land here, prevent leak. */
for (ctp = cts; ctp && *ctp; ++ctp) { free_content (*ctp); }
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))) {
- adios (NULL, "failed to parse %s", convert_head->filename);
+ cts = mh_xcalloc(2, sizeof *cts);
+ if (! (cts[0] = parse_mime (convert_head->filename))) {
+ die("failed to parse %s", convert_head->filename);
}
expand_pseudoheaders (cts[0], m, infile, convert_head);
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;
}
compose_content (ct, verbose);
if ((cp = strchr(prefix, 'a')) == NULL)
- adios (NULL, "internal error(4)");
+ die("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
(*cp)++;
} else {
if (*++cp == 0)
- adios (NULL, "giving up trying to find a unique delimiter string");
- else
- (*cp)++;
+ die("giving up trying to find a unique delimiter string");
+ (*cp)++;
}
}
ct->c_ceclosefnx = close_encoding;
ct->c_cesizefnx = NULL; /* since unencoded */
ct->c_encoding = CE_7BIT; /* Seems like a reasonable default */
- ct->c_file = add(filename, NULL);
+ ct->c_file = mh_xstrdup(FENDNULL(filename));
return OK;
}
fgetstr (char *s, int n, FILE *stream)
{
char *cp, *ep;
- int o_n = n;
+ ep = s + n;
while(1) {
- for (ep = (cp = s) + o_n; cp < ep; ) {
- int i;
+ for (cp = s; cp < ep;) {
+ int len;
if (!fgets (cp, n, stream))
- return (cp != s ? s : NULL);
+ return cp == s ? NULL : s; /* "\\\nEOF" ignored. */
- if (cp == s && *cp != '#')
- return s;
+ if (! do_direct() || (cp == s && *cp != '#'))
+ return s; /* Plaintext line. */
- cp += (i = strlen (cp)) - 1;
- if (i <= 1 || *cp-- != '\n' || *cp != '\\')
+ len = strlen(cp);
+ if (len <= 1)
+ break; /* Can't contain "\\\n". */
+ cp += len - 1; /* Just before NUL. */
+ if (*cp-- != '\n' || *cp != '\\')
break;
- *cp = '\0';
- n -= (i - 2);
+ *cp = '\0'; /* Erase the trailing "\\\n". */
+ n -= (len - 2);
}
if (strcmp(s, "#on\n") == 0) {
} else if (strcmp(s, "#pop\n") == 0) {
directive_pop();
} else {
- break;
+ return s;
}
}
-
- return s;
}
{
int extrnal, vrsn;
char *cp, **ap;
- char buffer[BUFSIZ];
+ char buffer[NMH_BUFSIZ];
struct multipart *m;
struct part **pp;
struct stat st;
}
/* 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 */
*/
if (!do_direct() || buf[0] != '#' || buf[1] == '#' || buf[1] == '<') {
int headers;
- int inlineD;
+ bool inlineD;
long pos;
char content[BUFSIZ];
FILE *out;
}
/* use a temp file to collect the plain text lines */
- ce->ce_file = add (cp, NULL);
+ ce->ce_file = mh_xstrdup(cp);
ce->ce_unlink = 1;
if (do_direct() && (buf[0] == '#' && buf[1] == '<')) {
strncpy (content, buf + 2, sizeof(content));
- inlineD = 1;
+ inlineD = true;
goto rock_and_roll;
- } else {
- inlineD = 0;
}
+ inlineD = false;
/* the directive is implicit */
strncpy (content, "text/plain", sizeof(content));
int i;
if (headers >= 0 && do_direct() && uprf (buffer, DESCR_FIELD)
- && buffer[i = strlen (DESCR_FIELD)] == ':') {
+ && buffer[i = LEN(DESCR_FIELD)] == ':') {
headers = 1;
again_descr:
ct->c_descr = add (buffer + i + 1, ct->c_descr);
if (!fgetstr (buffer, sizeof(buffer) - 1, in))
- adios (NULL, "end-of-file after %s: field in plaintext", DESCR_FIELD);
+ die("end-of-file after %s: field in plaintext", DESCR_FIELD);
switch (buffer[0]) {
case ' ':
case '\t':
goto again_descr;
case '#':
- adios (NULL, "#-directive after %s: field in plaintext", DESCR_FIELD);
+ die("#-directive after %s: field in plaintext", DESCR_FIELD);
/* NOTREACHED */
default:
}
if (headers >= 0 && do_direct() && uprf (buffer, DISPO_FIELD)
- && buffer[i = strlen (DISPO_FIELD)] == ':') {
+ && buffer[i = LEN(DISPO_FIELD)] == ':') {
headers = 1;
again_dispo:
ct->c_dispo = add (buffer + i + 1, ct->c_dispo);
if (!fgetstr (buffer, sizeof(buffer) - 1, in))
- adios (NULL, "end-of-file after %s: field in plaintext", DISPO_FIELD);
+ die("end-of-file after %s: field in plaintext", DISPO_FIELD);
switch (buffer[0]) {
case ' ':
case '\t':
goto again_dispo;
case '#':
- adios (NULL, "#-directive after %s: field in plaintext", DISPO_FIELD);
+ die("#-directive after %s: field in plaintext", DISPO_FIELD);
/* NOTREACHED */
default:
ct->c_encoding = CE_7BIT;
goto call_init;
}
- /* else fall... */
+ /* FALLTHRU */
case CT_MULTIPART:
- adios (NULL, "it doesn't make sense to define an in-line %s content",
+ die("it doesn't make sense to define an in-line %s content",
ct->c_type == CT_MESSAGE ? "message" : "multipart");
/* NOTREACHED */
*/
if (s2i->si_key) {
if (!ci->ci_subtype)
- adios (NULL, "missing subtype in \"#%s\"", ci->ci_type);
+ die("missing subtype in \"#%s\"", ci->ci_type);
switch (ct->c_type = s2i->si_val) {
case CT_MULTIPART:
- adios (NULL, "use \"#begin ... #end\" instead of \"#%s/%s\"",
+ die("use \"#begin ... #end\" instead of \"#%s/%s\"",
ci->ci_type, ci->ci_subtype);
/* NOTREACHED */
case CT_MESSAGE:
if (!strcasecmp (ci->ci_subtype, "partial"))
- adios (NULL, "sorry, \"#%s/%s\" isn't supported",
+ die("sorry, \"#%s/%s\" isn't supported",
ci->ci_type, ci->ci_subtype);
if (!strcasecmp (ci->ci_subtype, "external-body"))
- adios (NULL, "use \"#@type/subtype ... [] ...\" instead of \"#%s/%s\"",
+ die("use \"#@type/subtype ... [] ...\" instead of \"#%s/%s\"",
ci->ci_type, ci->ci_subtype);
use_forw:
- adios (NULL,
- "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"",
+ die( "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"",
ci->ci_type, ci->ci_subtype);
/* NOTREACHED */
CT p;
if (!ci->ci_magic)
- adios (NULL, "need external information for \"#@%s/%s\"",
+ die("need external information for \"#@%s/%s\"",
ci->ci_type, ci->ci_subtype);
p = ct;
* 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;
for (cp = ci->ci_magic + 1; isspace ((unsigned char) *cp); cp++)
continue;
if (!*cp)
- adios (NULL, "empty pipe command for #%s directive", ci->ci_type);
- cp = add (cp, NULL);
+ die("empty pipe command for #%s directive", ci->ci_type);
+ cp = mh_xstrdup(cp);
free (ci->ci_magic);
ci->ci_magic = cp;
} else {
content_error (NULL, ct, "don't know how to compose content");
done (1);
}
- ci->ci_magic = add (cp, NULL);
+ ci->ci_magic = mh_xstrdup(cp);
return OK;
}
if (extrnal)
- adios (NULL, "external definition not allowed for \"#%s\"", ci->ci_type);
+ die("external definition not allowed for \"#%s\"", ci->ci_type);
/*
* Message directive
cp = *ap;
if (*cp == '+' || *cp == '@') {
if (folder)
- adios (NULL, "only one folder per #forw directive");
- else
- folder = pluspath (cp);
+ die("only one folder per #forw directive");
+ folder = pluspath (cp);
}
}
/* else, use the current folder */
if (!folder)
- folder = add (getfolder (1), NULL);
+ folder = mh_xstrdup(getfolder(1));
if (!(mp = folder_read (folder, 0)))
- adios (NULL, "unable to read folder %s", folder);
+ die("unable to read folder %s", folder);
for (ap = arguments; *ap; ap++) {
cp = *ap;
if (*cp != '+' && *cp != '@')
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)
p->c_subtype = MESSAGE_RFC822;
snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
- pe->ce_file = add (buffer, NULL);
+ pe->ce_file = mh_xstrdup(buffer);
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;
msgnum = mp->lowsel;
snprintf (buffer, sizeof(buffer), "%s/%d", mp->foldpath, msgnum);
- ce->ce_file = add (buffer, NULL);
+ ce->ce_file = mh_xstrdup(buffer);
if (listsw && stat (ce->ce_file, &st) != NOTOK)
ct->c_end = (long) st.st_size;
}
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 (user_content (in, buffer, &p, infilename) == DONE) {
if (!m->mp_parts)
- adios (NULL, "empty \"#begin ... #end\" sequence");
+ die("empty \"#begin ... #end\" sequence");
return OK;
}
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;
}
- admonish (NULL, "premature end-of-file, missing #end");
+ inform("premature end-of-file, missing #end, continuing...");
return OK;
}
/*
* Unknown directive
*/
- adios (NULL, "unknown directive \"#%s\"", ci->ci_type);
+ die("unknown directive \"#%s\"", ci->ci_type);
return NOTOK; /* NOT REACHED */
}
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);
}
CT p = part->mp_part;
sprintf (pp, "%d", partnum);
- p->c_partno = add (partnam, NULL);
+ p->c_partno = mh_xstrdup(partnam);
if (compose_content (p, verbose) == NOTOK)
return NOTOK;
}
* subparts with the rfc934 compatibility mode flag.
*/
if (rfc934sw && ct->c_subtype == MULTI_DIGEST) {
- int is934 = 1;
+ bool is934 = true;
for (part = m->mp_parts; part; part = part->mp_next) {
CT p = part->mp_part;
if (p->c_subtype != MESSAGE_RFC822) {
- is934 = 0;
+ is934 = false;
break;
}
}
if (listsw) {
ct->c_end = (partnum = strlen (prefix) + 2) + 2;
if (ct->c_rfc934)
- ct->c_end += 1;
+ ct->c_end++;
for (part = m->mp_parts; part; part = part->mp_next)
ct->c_end += part->mp_part->c_end + partnum;
default:
if (!ce->ce_file) {
pid_t child_id;
- int i, xstdout, len, buflen;
+ bool xstdout;
+ int len, buflen;
char *bp, *cp;
char *vec[4], buffer[BUFSIZ];
FILE *out;
char *tfile = NULL;
if (!(cp = ci->ci_magic))
- adios (NULL, "internal error(5)");
+ die("internal error(5)");
if ((tfile = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
adios("mhbuildsbr", "unable to create temporary file in %s",
get_temp_dir());
}
- ce->ce_file = add (tfile, NULL);
+ ce->ce_file = mh_xstrdup(tfile);
ce->ce_unlink = 1;
- xstdout = 0;
+ xstdout = false;
/* Get buffer ready to go */
bp = buffer;
case 'F':
/* %f, and stdout is not-redirected */
- xstdout = 1;
- /* and fall... */
+ xstdout = true;
+ /* FALLTHRU */
case 'f':
/*
if ((out = fopen (ce->ce_file, "w")) == NULL)
adios (ce->ce_file, "unable to open for writing");
- for (i = 0; (child_id = fork()) == NOTOK && i > 5; i++)
- sleep (5);
+ child_id = fork();
switch (child_id) {
case NOTOK:
adios ("fork", "unable to fork");
execvp ("/bin/sh", vec);
fprintf (stderr, "unable to exec ");
perror ("/bin/sh");
- _exit (-1);
+ _exit(1);
/* NOTREACHED */
default:
scan_content (CT ct, size_t maxunencoded)
{
int prefix_len;
- int check8bit = 0, contains8bit = 0; /* check if contains 8bit data */
- int checknul = 0, containsnul = 0; /* check if contains NULs */
- int checklinelen = 0, linelen = 0; /* check for long lines */
- int checkllinelen = 0; /* check for extra-long lines */
- int checkboundary = 0, boundaryclash = 0; /* check if clashes with multipart boundary */
- int checklinespace = 0, linespace = 0; /* check if any line ends with space */
+ bool check8bit = false, contains8bit = false; /* check if contains 8bit data */
+ bool checknul = false, containsnul = false; /* check if contains NULs */
+ bool checklinelen = false, linelen = false; /* check for long lines */
+ bool checkllinelen = false; /* check for extra-long lines */
+ bool checkboundary = false, boundaryclash = false; /* check if clashes with multipart boundary */
+ bool checklinespace = false, linespace = false; /* check if any line ends with space */
char *cp = NULL;
char *bufp = NULL;
size_t buflen;
* 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;
+ checknul = true;
}
+ check8bit = true;
}
switch (ct->c_reqencoding) {
case CE_8BIT:
- checkllinelen = 1;
- checkboundary = 1;
+ checkllinelen = true;
+ checkboundary = true;
break;
case CE_QUOTED:
- checkboundary = 1;
+ checkboundary = true;
break;
case CE_BASE64:
break;
/* Use the default rules based on content-type */
switch (ct->c_type) {
case CT_TEXT:
- checkboundary = 1;
- checklinelen = 1;
+ checkboundary = true;
+ checklinelen = true;
if (ct->c_subtype == TEXT_PLAIN) {
- checklinespace = 0;
+ checklinespace = false;
} else {
- checklinespace = 1;
+ checklinespace = true;
}
break;
case CT_APPLICATION:
- check8bit = 1;
- checknul = 1;
- checklinelen = 1;
- checklinespace = 1;
- checkboundary = 1;
+ check8bit = true;
+ checknul = true;
+ checklinelen = true;
+ checklinespace = true;
+ checkboundary = true;
break;
case CT_MESSAGE:
- checklinelen = 0;
- checklinespace = 0;
+ checklinelen = false;
+ checklinespace = false;
/* don't check anything for message/external */
if (ct->c_subtype == MESSAGE_EXTERNAL) {
- checkboundary = 0;
- check8bit = 0;
+ checkboundary = false;
+ check8bit = false;
} else {
- checkboundary = 1;
- check8bit = 1;
+ checkboundary = true;
+ check8bit = true;
}
break;
* since we are forcing use of base64, unless
* the content-type was specified by a mhbuild directive.
*/
- check8bit = 0;
- checklinelen = 0;
- checklinespace = 0;
- checkboundary = 0;
+ check8bit = false;
+ checklinelen = false;
+ checklinespace = false;
+ checkboundary = false;
break;
}
}
for (cp = bufp; (check8bit || checknul) &&
cp < bufp + gotlen; cp++) {
if (!isascii ((unsigned char) *cp)) {
- contains8bit = 1;
- check8bit = 0; /* no need to keep checking */
+ contains8bit = true;
+ check8bit = false; /* no need to keep checking */
}
if (!*cp) {
- containsnul = 1;
- checknul = 0; /* no need to keep checking */
+ containsnul = true;
+ checknul = false; /* no need to keep checking */
}
}
* Check line length.
*/
if (checklinelen && ((size_t)gotlen > maxunencoded + 1)) {
- linelen = 1;
- checklinelen = 0; /* no need to keep checking */
+ linelen = true;
+ checklinelen = false; /* no need to keep checking */
}
/*
if (checkllinelen && !linelen &&
(gotlen > MAXLONGLINE + 1)) {
- adios(NULL, "Line in content exceeds maximum line limit (%d)",
+ die("Line in content exceeds maximum line limit (%d)",
MAXLONGLINE);
}
*/
if (checklinespace && (cp = bufp + gotlen - 2) > bufp &&
isspace ((unsigned char) *cp)) {
- linespace = 1;
- checklinespace = 0; /* no need to keep checking */
+ linespace = true;
+ checklinespace = false; /* no need to keep checking */
}
/*
*++cp = '\0';
if (!strncmp(bufp + 2, prefix, prefix_len) &&
isdigit((unsigned char) bufp[2 + prefix_len])) {
- boundaryclash = 1;
- checkboundary = 0; /* no need to keep checking */
+ boundaryclash = true;
+ checkboundary = false; /* no need to keep checking */
}
}
}
}
}
- return (boundaryclash ? NOTOK : OK);
+ return boundaryclash ? NOTOK : OK;
}
/*
* output the content type and subtype
*/
- np = add (TYPE_FIELD, NULL);
+ np = mh_xstrdup(TYPE_FIELD);
vp = concat (" ", ci->ci_type, "/", ci->ci_subtype, NULL);
/* keep track of length of line */
- len = strlen (TYPE_FIELD) + strlen (ci->ci_type)
+ len = LEN(TYPE_FIELD) + strlen (ci->ci_type)
+ strlen (ci->ci_subtype) + 3;
extbody = ct->c_type == CT_MESSAGE && ct->c_subtype == MESSAGE_EXTERNAL;
char *s = output_params(len, ci->ci_first_pm, &len, mailbody);
if (!s)
- adios(NULL, "Internal error: failed outputting Content-Type "
+ die("Internal error: failed outputting Content-Type "
"parameters");
vp = add (s, vp);
add_header (ct, np, vp);
/*
- * output the Content-ID, unless disabled by -nocontentid
+ * output the Content-ID, unless disabled by -nocontentid. Note that
+ * RFC 2045 always requires a Content-ID header for message/external-body
+ * entities.
*/
- if (contentidsw && ct->c_id) {
- np = add (ID_FIELD, NULL);
+ if ((contentidsw || ct->c_ctexbody) && ct->c_id) {
+ np = mh_xstrdup(ID_FIELD);
vp = concat (" ", ct->c_id, NULL);
add_header (ct, np, vp);
}
* output the Content-Description
*/
if (ct->c_descr) {
- np = add (DESCR_FIELD, NULL);
+ np = mh_xstrdup(DESCR_FIELD);
vp = concat (" ", ct->c_descr, NULL);
if (header_encoding != CE_8BIT) {
if (encode_rfc2047(DESCR_FIELD, &vp, header_encoding, NULL)) {
- adios(NULL, "Unable to encode %s header", DESCR_FIELD);
+ die("Unable to encode %s header", DESCR_FIELD);
}
}
add_header (ct, np, vp);
* set, then we need to build it.
*/
if (ct->c_dispo) {
- np = add (DISPO_FIELD, NULL);
+ np = mh_xstrdup(DISPO_FIELD);
vp = concat (" ", ct->c_dispo, NULL);
add_header (ct, np, vp);
} else if (ct->c_dispo_type) {
vp = concat (" ", ct->c_dispo_type, NULL);
- len = strlen(DISPO_FIELD) + strlen(vp) + 1;
+ len = LEN(DISPO_FIELD) + strlen(vp) + 1;
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);
+ free(np);
+ add_header (ct, mh_xstrdup(DISPO_FIELD), vp);
}
skip_headers:
* output the Content-MD5
*/
if (checksw) {
- np = add (MD5_FIELD, NULL);
- vp = calculate_digest (ct, (ct->c_encoding == CE_QUOTED) ? 1 : 0);
+ np = mh_xstrdup(MD5_FIELD);
+ vp = calculate_digest (ct, ct->c_encoding == CE_QUOTED);
add_header (ct, np, vp);
}
/*
* 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 */
break;
case CE_8BIT:
- np = add (ENCODING_FIELD, NULL);
+ np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "8bit", "\n", NULL);
add_header (ct, np, vp);
break;
case CE_QUOTED:
if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
- adios (NULL, "internal error, invalid encoding");
+ die("internal error, invalid encoding");
- np = add (ENCODING_FIELD, NULL);
+ np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "quoted-printable", "\n", NULL);
add_header (ct, np, vp);
break;
case CE_BASE64:
if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART)
- adios (NULL, "internal error, invalid encoding");
+ die("internal error, invalid encoding");
- np = add (ENCODING_FIELD, NULL);
+ np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "base64", "\n", NULL);
add_header (ct, np, vp);
break;
case CE_BINARY:
if (ct->c_type == CT_MESSAGE)
- adios (NULL, "internal error, invalid encoding");
+ die("internal error, invalid encoding");
- np = add (ENCODING_FIELD, NULL);
+ np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "binary", "\n", NULL);
add_header (ct, np, vp);
break;
default:
- adios (NULL, "unknown transfer encoding in content");
+ die("unknown transfer encoding in content");
break;
}
unsigned char *ep;
fprintf (stderr, "MD5 digest=");
- for (ep = (dp = digest) + sizeof(digest) / sizeof(digest[0]);
+ for (ep = (dp = digest) + sizeof digest;
dp < ep; dp++)
fprintf (stderr, "%02x", *dp & 0xff);
fprintf (stderr, "\n");
/* encode the digest using base64 */
for (dp = digest, op = (char *) outbuf,
- cc = sizeof(digest) / sizeof(digest[0]);
+ cc = sizeof digest;
cc > 0; cc -= 3, op += 4) {
unsigned long bits;
char *bp;
PM pm;
if (! (type = mime_type(filename))) {
- adios(NULL, "Unable to determine MIME type of \"%s\"", filename);
+ die("Unable to determine MIME type of \"%s\"", filename);
}
/*
* Parse the Content-Type. get_ctinfo() parses MIME parameters, but
- * since we're just feeding it a MIME type we have to add those ourself.
+ * since we're just feeding it a MIME type we have to add those ourselves.
* Map that to a valid content-type label and call any initialization
* function.
*/
switch (ct->c_type = s2i->si_val) {
case CT_MULTIPART:
- adios (NULL, "multipart types must be specified by mhbuild directives");
+ die("multipart types must be specified by mhbuild directives");
/* NOTREACHED */
case CT_MESSAGE:
if (strcasecmp(ct->c_ctinfo.ci_subtype, "partial") == 0)
- adios(NULL, "Sorry, %s/%s isn't supported", ct->c_ctinfo.ci_type,
+ die("Sorry, %s/%s isn't supported", ct->c_ctinfo.ci_type,
ct->c_ctinfo.ci_subtype);
if (strcasecmp(ct->c_ctinfo.ci_subtype, "external-body") == 0)
- adios(NULL, "external-body messages must be specified "
+ die("external-body messages must be specified "
"by mhbuild directives");
- /* Fall through */
+ /* FALLTHRU */
default:
/*
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);
+ free(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);
if (cp && strcasecmp (cp, "attachment") &&
strcasecmp (cp, "inline")) {
- admonish (NULL, "configuration problem: %s-disposition-%s%s%s "
- "specifies '%s' but only 'attachment' and 'inline' are "
- "allowed", invo_name,
- ct->c_ctinfo.ci_type,
- ct->c_ctinfo.ci_subtype ? "/" : "",
- ct->c_ctinfo.ci_subtype ? ct->c_ctinfo.ci_subtype : "",
- cp);
+ inform("configuration problem: %s-disposition-%s%s%s specifies "
+ "'%s' but only 'attachment' and 'inline' are allowed, "
+ "continuing...", invo_name,
+ ct->c_ctinfo.ci_type,
+ ct->c_ctinfo.ci_subtype ? "/" : "",
+ FENDNULL(ct->c_ctinfo.ci_subtype),
+ cp);
}
- ct->c_dispo_type = cp ? getcpy (cp) : getcpy ("attachment");
+ if (!cp)
+ cp = "attachment";
+ ct->c_dispo_type = mh_xstrdup(cp);
}
}
/*
* Set text content charset if it was unspecified. contains8bit
- * selctions:
+ * selections:
* 0: content does not contain 8-bit characters
* 1: content contains 8-bit characters
* -1: ignore content and use user's locale to determine charset
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;
if (contains8bit == 1 &&
strcasecmp (eightbitcharset, "US-ASCII") == 0) {
- adios (NULL, "Text content contains 8 bit characters, but "
+ die("Text content contains 8 bit characters, but "
"character set is US-ASCII");
}
struct part *part;
if (ct->c_subtype == MULTI_ALTERNATE) {
- int matched = 0;
+ bool matched = false;
/* The parts are in descending priority order (defined by
RFC 2046 Sec. 5.1.4) because they were reversed by
expand_pseudoheader (part->mp_part, &text_plain_ct,
m, infile,
c->type, c->argstring);
- matched = 1;
+ matched = true;
break;
}
}
free (type_p);
if (! (convert)) {
- /* No mhbuild-convert- entry in mhn.defaults or profile
- for type. */
+ /* No mhbuild-convert- entry in mhn.defaults or profile for type. */
return;
}
/* reply_file is used to pass the output of the convert. */
reply_file = getcpy (m_mktemp2 (NULL, invo_name, NULL, NULL));
convert_command =
- concat (convert, " ", argstring ? argstring : "", " >", reply_file,
- NULL);
+ concat (convert, " ", FENDNULL(argstring), " >", reply_file, 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)) !=
OK) {
- admonish (NULL, "store of %s content failed", type);
+ inform("store of %s content failed, continuing...", type);
}
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) {
- free (reply_file);
- admonish (NULL,
- "failed to extract headers from convert output in %s",
- reply_file);
+ inform("failed to extract headers from convert output in %s, "
+ "continuing...", reply_file);
+ free(reply_file);
return;
}
(*reply_ct->c_ctinitfnx)(reply_ct);
}
- if ((cp =
- get_param (reply_ct->c_ctinfo.ci_first_pm, "charset", '?', 1))) {
+ if ((cp = get_param (reply_ct->c_ctinfo.ci_first_pm, "charset", '?', 1))) {
/* The reply Content-Type had the charset. */
charset = cp;
} 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;
- }
}
/* Concatenate text/plain parts. */
- if (reply_ct->c_type == CT_TEXT &&
- reply_ct->c_subtype == TEXT_PLAIN) {
+ if (reply_ct->c_type == CT_TEXT && reply_ct->c_subtype == TEXT_PLAIN) {
if (! *text_plain_ct && m->mp_parts && m->mp_parts->mp_part &&
m->mp_parts->mp_part->c_type == CT_TEXT &&
m->mp_parts->mp_part->c_subtype == TEXT_PLAIN) {
*text_plain_ct = m->mp_parts->mp_part;
- /* Make sure that the charset is set in the text/plain
- part. */
+ /* Make sure that the charset is set in the text/plain part. */
set_charset (*text_plain_ct, -1);
- if ((*text_plain_ct)->c_reqencoding == CE_UNKNOWN) {
- /* Assume that 8bit is sufficient (for text). */
- (*text_plain_ct)->c_reqencoding =
- strcasecmp (charset, "US-ASCII") ? CE_8BIT : CE_7BIT;
- }
}
if (*text_plain_ct) {
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;
int
extract_headers (CT ct, char *reply_file, FILE **reply_fp) {
char *buffer = NULL, *cp, *end_of_header;
- int found_header = 0;
+ bool found_header = false;
struct stat statbuf;
/* Read the convert reply from the file to memory. */
buffer[statbuf.st_size] = '\0';
/* Look for a header in the convert reply. */
- if (strncasecmp (buffer, TYPE_FIELD, strlen (TYPE_FIELD)) == 0 &&
- buffer[strlen (TYPE_FIELD)] == ':') {
+ if (strncasecmp (buffer, TYPE_FIELD, LEN(TYPE_FIELD)) == 0 &&
+ buffer[LEN(TYPE_FIELD)] == ':') {
if ((end_of_header = strstr (buffer, "\r\n\r\n"))) {
end_of_header += 2;
- found_header = 1;
+ found_header = true;
} else if ((end_of_header = strstr (buffer, "\n\n"))) {
++end_of_header;
- found_header = 1;
+ found_header = true;
}
}
CT tmp_ct;
char *tmp_file;
FILE *tmp_f;
- size_t n;
+ size_t n, written;
/* Truncate buffer to just the C-T. */
*end_of_header = '\0';
n = strlen (buffer);
if (get_ctinfo (buffer + 14, ct, 0) != OK) {
- admonish (NULL, "unable to get content info for reply");
+ inform("unable to get content info for reply, continuing...");
goto failed_to_extract_ct;
}
/* Hack. Use parse_mime() to detect the type/subtype of the
reply, which we'll use below. */
tmp_file = getcpy (m_mktemp2 (NULL, invo_name, NULL, NULL));
- if ((tmp_f = fopen (tmp_file, "w")) &&
- fwrite (buffer, 1, n, tmp_f) == n) {
- fclose (tmp_f);
- } else {
+ tmp_f = fopen(tmp_file, "w");
+ if (!tmp_f)
+ goto failed_to_extract_ct;
+ written = fwrite(buffer, 1, n, tmp_f);
+ fclose(tmp_f);
+ if (written != n)
goto failed_to_extract_ct;
- }
- tmp_ct = parse_mime (tmp_file);
+ tmp_ct = parse_mime (tmp_file);
if (tmp_ct) {
/* The type and subtype were detected from the reply
using parse_mime() above. */
ct->c_subtype = TEXT_PLAIN;
if (get_ctinfo ("text/plain", ct, 0) == NOTOK) {
/* This never should fail, but just in case. */
- adios (NULL, "unable to get content info for reply");
+ die("unable to get content info for reply");
}
}
projects / nmh / blobdiff