#include <h/mh.h>
#include <fcntl.h>
-#include <h/signals.h>
#include <h/md5.h>
-#include <errno.h>
-#include <signal.h>
#include <h/mts.h>
#include <h/tws.h>
#include <h/mime.h>
extern int debugsw;
-extern int verbosw;
extern int listsw;
extern int rfc934sw;
extern int rcachesw; /* mhcachesbr.c */
extern int wcachesw; /* mhcachesbr.c */
-/*
- * Directory to place tmp files. This must
- * be set before these routines are called.
- */
-char *tmp;
+static char prefix[] = "----- =_aaaaaaaaaa";
-pid_t xpid = 0;
+struct attach_list {
+ char *filename;
+ struct attach_list *next;
+};
-static char prefix[] = "----- =_aaaaaaaaaa";
+typedef struct convert_list {
+ char *type;
+ char *filename;
+ char *argstring;
+ struct convert_list *next;
+} convert_list;
/*
* Maximum size of URL token in message/external-body
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);
-/*
- * prototypes
- */
-CT build_mime (char *, int);
-
/*
* static prototypes
*/
-static int init_decoded_content (CT);
+static int init_decoded_content (CT, const char *);
+static void setup_attach_content(CT, char *);
+static void set_disposition (CT);
+static void set_charset (CT, int);
+static void expand_pseudoheaders (CT, struct multipart *, const char *,
+ const convert_list *);
+static void expand_pseudoheader (CT, CT *, struct multipart *, const char *,
+ const char *, const char *);
static char *fgetstr (char *, int, FILE *);
-static int user_content (FILE *, char *, char *, CT *);
+static int user_content (FILE *, char *, CT *, const char *infilename);
static void set_id (CT, int);
-static int compose_content (CT);
-static int scan_content (CT);
-static int build_headers (CT);
+static int compose_content (CT, int);
+static int scan_content (CT, size_t);
+static int build_headers (CT, int);
static char *calculate_digest (CT, int);
+static int extract_headers (CT, char *, FILE **);
static unsigned char directives_stack[32];
*/
CT
-build_mime (char *infile, int directives)
+build_mime (char *infile, int autobuild, int dist, int directives,
+ int header_encoding, size_t maxunencoded, int verbose)
{
int compnum, state;
char buf[BUFSIZ], name[NAMESZ];
struct part **pp;
CT ct;
FILE *in;
+ HF hp;
m_getfld_state_t gstate = 0;
+ struct attach_list *attach_head = NULL, *attach_tail = NULL, *at_entry;
+ convert_list *convert_head = NULL, *convert_tail = NULL, *convert;
directive_init(directives);
/*
* Allocate space for primary (outside) content
*/
- if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
/*
* Allocate structure for handling decoded content
* for this part. We don't really need this, but
* allocate it to remain consistent.
*/
- init_decoded_content (ct);
+ init_decoded_content (ct, infile);
/*
* Parse some of the header fields in the composition
case FLDPLUS:
compnum++;
- /* abort if draft has Mime-Version header field */
- if (!mh_strcasecmp (name, VRSN_FIELD))
- adios (NULL, "draft shouldn't contain %s: field", VRSN_FIELD);
-
- /* abort if draft has Content-Transfer-Encoding header field */
- if (!mh_strcasecmp (name, ENCODING_FIELD))
- adios (NULL, "draft shouldn't contain %s: field", ENCODING_FIELD);
+ /* abort if draft has Mime-Version or C-T-E header field */
+ if (strcasecmp (name, VRSN_FIELD) == 0 ||
+ strcasecmp (name, ENCODING_FIELD) == 0) {
+ if (autobuild) {
+ fclose(in);
+ free (ct);
+ return NULL;
+ }
+ adios (NULL, "draft shouldn't contain %s: field", name);
+ }
/* ignore any Content-Type fields in the header */
- if (!mh_strcasecmp (name, TYPE_FIELD)) {
+ if (!strcasecmp (name, TYPE_FIELD)) {
while (state == FLDPLUS) {
bufsz = sizeof buf;
state = m_getfld (&gstate, name, buf, &bufsz, in);
vp = add (buf, vp); /* add to previous value */
}
- /* Now add the header data to the list */
- add_header (ct, np, vp);
+ /*
+ * Now add the header data to the list, unless it's an attach
+ * header; in that case, add it to our attach list
+ */
+
+ if (strcasecmp(ATTACH_FIELD, np) == 0 ||
+ strcasecmp(ATTACH_FIELD_ALT, np) == 0) {
+ struct attach_list *entry;
+ char *s = vp, *e = vp + strlen(vp) - 1;
+ free(np);
+
+ /*
+ * Make sure we can find the start of this filename.
+ * If it's blank, we skip completely. Otherwise, strip
+ * off any leading spaces and trailing newlines.
+ */
+
+ while (isspace((unsigned char) *s))
+ s++;
+
+ while (e > s && *e == '\n')
+ *e-- = '\0';
+
+ if (*s == '\0') {
+ free(vp);
+ goto finish_field;
+ }
+
+ NEW(entry);
+ entry->filename = mh_xstrdup(s);
+ entry->next = NULL;
+ free(vp);
+
+ if (attach_tail) {
+ attach_tail->next = entry;
+ attach_tail = entry;
+ } else {
+ attach_head = attach_tail = entry;
+ }
+ } else if (strncasecmp(MHBUILD_FILE_PSEUDOHEADER, np,
+ strlen (MHBUILD_FILE_PSEUDOHEADER)) == 0) {
+ /* E.g.,
+ * Nmh-mhbuild-file-text/calendar: /home/user/Mail/inbox/9
+ */
+ char *type = np + strlen (MHBUILD_FILE_PSEUDOHEADER);
+ char *filename = vp;
+
+ /* vp should begin with a space because m_getfld()
+ includes the space after the colon in buf. */
+ while (isspace((unsigned char) *filename)) { ++filename; }
+ /* Trim trailing newline and any other whitespace. */
+ rtrim (filename);
+
+ for (convert = convert_head; convert; convert = convert->next) {
+ if (strcasecmp (convert->type, type) == 0) { break; }
+ }
+ if (convert) {
+ if (convert->filename &&
+ strcasecmp (convert->filename, filename)) {
+ adios (NULL, "Multiple %s headers with different files"
+ " not allowed", type);
+ } else {
+ convert->filename = mh_xstrdup(filename);
+ }
+ } else {
+ NEW0(convert);
+ convert->filename = mh_xstrdup(filename);
+ convert->type = mh_xstrdup(type);
+
+ if (convert_tail) {
+ convert_tail->next = convert;
+ } else {
+ convert_head = convert;
+ }
+ convert_tail = convert;
+ }
+
+ free (vp);
+ free (np);
+ } else if (strncasecmp(MHBUILD_ARGS_PSEUDOHEADER, np,
+ strlen (MHBUILD_ARGS_PSEUDOHEADER)) == 0) {
+ /* E.g.,
+ * Nmh-mhbuild-args-text/calendar: -reply accept
+ */
+ char *type = np + strlen (MHBUILD_ARGS_PSEUDOHEADER);
+ char *argstring = vp;
+
+ /* vp should begin with a space because m_getfld()
+ includes the space after the colon in buf. */
+ while (isspace((unsigned char) *argstring)) { ++argstring; }
+ /* Trim trailing newline and any other whitespace. */
+ rtrim (argstring);
+
+ for (convert = convert_head; convert; convert = convert->next) {
+ if (strcasecmp (convert->type, type) == 0) { break; }
+ }
+ if (convert) {
+ if (convert->argstring &&
+ strcasecmp (convert->argstring, argstring)) {
+ adios (NULL, "Multiple %s headers with different "
+ "argstrings not allowed", type);
+ } else {
+ convert->argstring = mh_xstrdup(argstring);
+ }
+ } else {
+ NEW0(convert);
+ convert->type = mh_xstrdup(type);
+ convert->argstring = mh_xstrdup(argstring);
+
+ if (convert_tail) {
+ convert_tail->next = convert;
+ } else {
+ convert_head = convert;
+ }
+ convert_tail = convert;
+ }
+
+ free (vp);
+ free (np);
+ } else {
+ add_header (ct, np, vp);
+ }
finish_field:
/* if this wasn't the last header field, then continue */
continue;
- case FILEEOF:
- adios (NULL, "draft has empty body -- no directives!");
- /* NOTREACHED */
-
case BODY:
fseek (in, (long) (-strlen (buf)), SEEK_CUR);
+ /* fall through */
+ case FILEEOF:
break;
case LENERR:
}
m_getfld_state_destroy (&gstate);
+ if (header_encoding != CE_8BIT) {
+ /*
+ * Iterate through the list of headers and call the function to MIME-ify
+ * them if required.
+ */
+
+ 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);
+ }
+ }
+ }
+
/*
* Now add the MIME-Version header field
* to the list of header fields.
*/
- np = add (VRSN_FIELD, NULL);
- vp = concat (" ", VRSN_VALUE, "\n", NULL);
- add_header (ct, np, vp);
+
+ if (! dist) {
+ np = add (VRSN_FIELD, NULL);
+ vp = concat (" ", VRSN_VALUE, "\n", NULL);
+ add_header (ct, np, vp);
+ }
/*
* We initally assume we will find multiple contents in the
done (1);
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_MIXED;
- ct->c_file = add (infile, NULL);
- if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(m);
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
struct part *part;
CT p;
- if (user_content (in, infile, buf, &p) == DONE) {
+ if (user_content (in, buf, &p, infile) == DONE) {
admonish (NULL, "ignoring spurious #end");
continue;
}
if (!p)
continue;
- if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
+ *pp = part;
+ pp = &part->mp_next;
+ part->mp_part = p;
+ }
+
+ /*
+ * Add any Attach headers to the list of MIME parts at the end of the
+ * message.
+ */
+
+ for (at_entry = attach_head; at_entry; ) {
+ struct attach_list *at_prev = at_entry;
+ struct part *part;
+ CT p;
+
+ if (access(at_entry->filename, R_OK) != 0) {
+ adios("reading", "Unable to open %s for", at_entry->filename);
+ }
+
+ NEW0(p);
+ init_decoded_content(p, infile);
+
+ /*
+ * Initialize our content structure based on the filename,
+ * and fill in all of the relevant fields. Also place MIME
+ * parameters in the attributes array.
+ */
+
+ setup_attach_content(p, at_entry->filename);
+
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
+
+ at_entry = at_entry->next;
+ free(at_prev->filename);
+ free(at_prev);
+ }
+
+ /*
+ * Handle the mhbuild pseudoheaders, which deal with specific
+ * content types.
+ */
+ if (convert_head) {
+ CT *ctp;
+ convert_list *next;
+
+ 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. */
+ cts = mh_xcalloc(2, sizeof *cts);
+ if (! (cts[0] = parse_mime (convert_head->filename))) {
+ adios (NULL, "failed to parse %s", convert_head->filename);
+ }
+
+ expand_pseudoheaders (cts[0], m, infile, convert_head);
+
+ /* Free the convert list. */
+ for (convert = convert_head; convert; convert = next) {
+ next = convert->next;
+ free (convert->type);
+ free (convert->filename);
+ free (convert->argstring);
+ free (convert);
+ }
+ convert_head = NULL;
+ }
+
+ /*
+ * To allow for empty message bodies, if we've found NO content at all
+ * yet cook up an empty text/plain part.
+ */
+
+ if (!m->mp_parts) {
+ CT p;
+ struct part *part;
+ struct text *t;
+
+ NEW0(p);
+ init_decoded_content(p, infile);
+
+ if (get_ctinfo ("text/plain", p, 0) == NOTOK)
+ done (1);
+
+ p->c_type = CT_TEXT;
+ p->c_subtype = TEXT_PLAIN;
+ p->c_encoding = CE_7BIT;
+ /*
+ * Sigh. ce_file contains the "decoded" contents of this part.
+ * So this seems like the best option available since we're going
+ * to call scan_content() on this.
+ */
+ p->c_cefile.ce_file = mh_xstrdup("/dev/null");
+ p->c_begin = ftell(in);
+ p->c_end = ftell(in);
+
+ NEW0(t);
+ t->tx_charset = CHARSET_SPECIFIED;
+ p->c_ctparams = t;
+
+ NEW0(part);
+ *pp = part;
+ part->mp_part = p;
}
/*
*/
fclose (in);
- /* check if any contents were found */
- if (!m->mp_parts)
- adios (NULL, "no content directives found");
-
/*
* If only one content was found, then remove and
* free the outer multipart content.
* Fill out, or expand directives. Parse and execute
* commands specified by profile composition strings.
*/
- compose_content (ct);
+ compose_content (ct, verbose);
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
* any of the contents.
*/
- while (scan_content (ct) == NOTOK) {
+ while (scan_content (ct, maxunencoded) == NOTOK) {
if (*cp < 'z') {
(*cp)++;
} else {
if (*++cp == 0)
adios (NULL, "giving up trying to find a unique delimiter string");
- else
+ else
(*cp)++;
}
}
/* Build the rest of the header field structures */
- build_headers (ct);
+ if (! dist)
+ build_headers (ct, header_encoding);
return ct;
}
*/
static int
-init_decoded_content (CT ct)
+init_decoded_content (CT ct, const char *filename)
{
ct->c_ceopenfnx = open7Bit; /* since unencoded */
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);
return OK;
}
*/
static int
-user_content (FILE *in, char *file, char *buf, CT *ctp)
+user_content (FILE *in, char *buf, CT *ctp, const char *infilename)
{
int extrnal, vrsn;
char *cp, **ap;
}
/* allocate basic Content structure */
- if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
*ctp = ct;
/* allocate basic structure for handling decoded content */
- init_decoded_content (ct);
+ init_decoded_content (ct, infilename);
ce = &ct->c_cefile;
ci = &ct->c_ctinfo;
FILE *out;
char *cp;
- cp = m_mktemp2(NULL, invo_name, NULL, &out);
- if (cp == NULL) adios("mhbuildsbr", "unable to create temporary file");
+ if ((cp = m_mktemp2(NULL, invo_name, NULL, &out)) == NULL) {
+ adios("mhbuildsbr", "unable to create temporary file in %s",
+ get_temp_dir());
+ }
/* use a temp file to collect the plain text lines */
ce->ce_file = add (cp, NULL);
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));
done (1);
for (s2i = str2cts; s2i->si_key; s2i++)
- if (!mh_strcasecmp (ci->ci_type, s2i->si_key))
+ if (!strcasecmp (ci->ci_type, s2i->si_key))
break;
if (!s2i->si_key && !uprf (ci->ci_type, "X-"))
s2i++;
*/
switch (ct->c_type = s2i->si_val) {
case CT_MESSAGE:
- if (!mh_strcasecmp (ci->ci_subtype, "rfc822")) {
+ if (!strcasecmp (ci->ci_subtype, "rfc822")) {
ct->c_encoding = CE_7BIT;
goto call_init;
}
/* check directive against the list of MIME types */
for (s2i = str2cts; s2i->si_key; s2i++)
- if (!mh_strcasecmp (ci->ci_type, s2i->si_key))
+ if (!strcasecmp (ci->ci_type, s2i->si_key))
break;
/*
/* NOTREACHED */
case CT_MESSAGE:
- if (!mh_strcasecmp (ci->ci_subtype, "partial"))
+ if (!strcasecmp (ci->ci_subtype, "partial"))
adios (NULL, "sorry, \"#%s/%s\" isn't supported",
ci->ci_type, ci->ci_subtype);
- if (!mh_strcasecmp (ci->ci_subtype, "external-body"))
+ if (!strcasecmp (ci->ci_subtype, "external-body"))
adios (NULL, "use \"#@type/subtype ... [] ...\" instead of \"#%s/%s\"",
ci->ci_type, ci->ci_subtype);
use_forw:
* reference, we need to create another Content structure
* for the message/external-body to wrap it in.
*/
- if ((ct = (CT) calloc (1, sizeof(*ct))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(ct);
+ init_decoded_content(ct, infilename);
*ctp = ct;
- ci = &ct->c_ctinfo;
if (get_ctinfo (buffer, ct, 0) == NOTOK)
done (1);
ct->c_type = CT_MESSAGE;
ct->c_subtype = MESSAGE_EXTERNAL;
- if ((e = (struct exbody *) calloc (1, sizeof(*e))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(e);
ct->c_ctparams = (void *) e;
e->eb_parent = ct;
* No [file] argument, so check profile for
* method to compose content.
*/
- snprintf (buffer, sizeof(buffer), "%s-compose-%s/%s",
- invo_name, ci->ci_type, ci->ci_subtype);
- if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
- snprintf (buffer, sizeof(buffer), "%s-compose-%s", invo_name, ci->ci_type);
- if ((cp = context_find (buffer)) == NULL || *cp == '\0') {
- content_error (NULL, ct, "don't know how to compose content");
- done (1);
- }
+ cp = context_find_by_type ("compose", ci->ci_type, ci->ci_subtype);
+ if (cp == NULL) {
+ content_error (NULL, ct, "don't know how to compose content");
+ done (1);
}
ci->ci_magic = add (cp, NULL);
return OK;
* Message directive
* #forw [+folder] [msgs]
*/
- if (!mh_strcasecmp (ci->ci_type, "forw")) {
+ if (!strcasecmp (ci->ci_type, "forw")) {
int msgnum;
char *folder, *arguments[MAXARGS];
struct msgs *mp;
if (!folder)
folder = add (getfolder (1), NULL);
- if (!(mp = folder_read (folder)))
+ if (!(mp = folder_read (folder, 0)))
adios (NULL, "unable to read folder %s", folder);
for (ap = arguments; *ap; ap++) {
cp = *ap;
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_DIGEST;
- if ((m = (struct multipart *) calloc (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) calloc (1, sizeof(*p))) == NULL)
- adios (NULL, "out of memory");
- init_decoded_content (p);
+ NEW0(p);
+ init_decoded_content (p, infilename);
pe = &p->c_cefile;
if (get_ctinfo ("message/rfc822", p, 0) == NOTOK)
done (1);
if (listsw && stat (pe->ce_file, &st) != NOTOK)
p->c_end = (long) st.st_size;
- if ((part = (struct part *) calloc (1, sizeof(*part))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(part);
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
/*
* #end
*/
- if (!mh_strcasecmp (ci->ci_type, "end")) {
+ if (!strcasecmp (ci->ci_type, "end")) {
free_content (ct);
*ctp = NULL;
return DONE;
/*
* #begin [ alternative | parallel ]
*/
- if (!mh_strcasecmp (ci->ci_type, "begin")) {
+ if (!strcasecmp (ci->ci_type, "begin")) {
if (!ci->ci_magic) {
vrsn = MULTI_MIXED;
cp = SubMultiPart[vrsn - 1].kv_key;
- } else if (!mh_strcasecmp (ci->ci_magic, "alternative")) {
+ } else if (!strcasecmp (ci->ci_magic, "alternative")) {
vrsn = MULTI_ALTERNATE;
cp = SubMultiPart[vrsn - 1].kv_key;
- } else if (!mh_strcasecmp (ci->ci_magic, "parallel")) {
+ } else if (!strcasecmp (ci->ci_magic, "parallel")) {
vrsn = MULTI_PARALLEL;
cp = SubMultiPart[vrsn - 1].kv_key;
} else if (uprf (ci->ci_magic, "digest")) {
ct->c_type = CT_MULTIPART;
ct->c_subtype = vrsn;
- if ((m = (struct multipart *) calloc (1, sizeof(*m))) == NULL)
- adios (NULL, "out of memory");
+ NEW0(m);
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
struct part *part;
CT p;
- if (user_content (in, file, buffer, &p) == DONE) {
+ if (user_content (in, buffer, &p, infilename) == DONE) {
if (!m->mp_parts)
adios (NULL, "empty \"#begin ... #end\" sequence");
return OK;
if (!p)
continue;
- if ((part = (struct part *) calloc (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);
}
*/
static int
-compose_content (CT ct)
+compose_content (CT ct, int verbose)
{
CE ce = &ct->c_cefile;
sprintf (pp, "%d", partnum);
p->c_partno = add (partnam, NULL);
- if (compose_content (p) == NOTOK)
+ if (compose_content (p, verbose) == NOTOK)
return NOTOK;
}
if (!ce->ce_file) {
pid_t child_id;
int i, xstdout, len, buflen;
- char *bp, **ap, *cp;
+ char *bp, *cp;
char *vec[4], buffer[BUFSIZ];
FILE *out;
CI ci = &ct->c_ctinfo;
if (!(cp = ci->ci_magic))
adios (NULL, "internal error(5)");
- tfile = m_mktemp2(NULL, invo_name, NULL, NULL);
- if (tfile == NULL) {
- adios("mhbuildsbr", "unable to create temporary file");
- }
+ 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_unlink = 1;
case 'a':
{
/* insert parameters from directive */
- char **ep;
char *s = "";
+ PM pm;
- for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
- snprintf (bp, buflen, "%s%s=\"%s\"", s, *ap, *ep);
+ for (pm = ci->ci_first_pm; pm; pm = pm->pm_next) {
+ snprintf (bp, buflen, "%s%s=\"%s\"", s,
+ pm->pm_name, get_param_value(pm, '?'));
len = strlen (bp);
bp += len;
buflen -= len;
}
}
- if (verbosw)
+ if (verbose)
printf ("composing content %s/%s from command\n\t%s\n",
ci->ci_type, ci->ci_subtype, buffer);
*/
static int
-scan_content (CT ct)
+scan_content (CT ct, size_t maxunencoded)
{
- int len;
- int check8bit = 0, contains8bit = 0; /* check if contains 8bit data */
- int checklinelen = 0, linelen = 0; /* check for long lines */
+ 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 */
- char *cp = NULL, buffer[BUFSIZ];
+ char *cp = NULL;
+ char *bufp = NULL;
+ size_t buflen;
+ ssize_t gotlen;
struct text *t = NULL;
FILE *in = NULL;
CE ce = &ct->c_cefile;
for (part = m->mp_parts; part; part = part->mp_next) {
CT p = part->mp_part;
- if (scan_content (p) == NOTOK) /* choose encoding for subpart */
+ if (scan_content (p, maxunencoded) == NOTOK) /* choose encoding for subpart */
return NOTOK;
/* if necessary, enlarge encoding for enclosing multipart */
}
/*
- * Decide what to check while scanning this content.
+ * 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. And
+ * we check even if the charset is specified, to allow setting
+ * the proper Content-Transfer-Encoding.
*/
- switch (ct->c_type) {
- case CT_TEXT:
+
+ if (ct->c_type == CT_TEXT) {
+ t = (struct text *) ct->c_ctparams;
+ if (t->tx_charset == CHARSET_UNSPECIFIED) {
+ checknul = 1;
+ }
check8bit = 1;
+ }
+
+ switch (ct->c_reqencoding) {
+ case CE_8BIT:
+ checkllinelen = 1;
checkboundary = 1;
- if (ct->c_subtype == TEXT_PLAIN) {
- checklinelen = 0;
- checklinespace = 0;
- } else {
- checklinelen = 1;
- checklinespace = 1;
- }
break;
-
- case CT_APPLICATION:
- check8bit = 1;
- checklinelen = 1;
- checklinespace = 1;
+ case CE_QUOTED:
checkboundary = 1;
break;
-
- case CT_MESSAGE:
- check8bit = 0;
- checklinelen = 0;
- checklinespace = 0;
-
- /* don't check anything for message/external */
- if (ct->c_subtype == MESSAGE_EXTERNAL)
- checkboundary = 0;
- else
+ case CE_BASE64:
+ break;
+ case CE_UNKNOWN:
+ /* Use the default rules based on content-type */
+ switch (ct->c_type) {
+ case CT_TEXT:
checkboundary = 1;
+ checklinelen = 1;
+ if (ct->c_subtype == TEXT_PLAIN) {
+ checklinespace = 0;
+ } else {
+ checklinespace = 1;
+ }
break;
- case CT_AUDIO:
- case CT_IMAGE:
- case CT_VIDEO:
- /*
- * Don't check anything for these types,
- * since we are forcing use of base64.
- */
- check8bit = 0;
- checklinelen = 0;
- checklinespace = 0;
- checkboundary = 0;
+ case CT_APPLICATION:
+ check8bit = 1;
+ checknul = 1;
+ checklinelen = 1;
+ checklinespace = 1;
+ checkboundary = 1;
break;
+
+ case CT_MESSAGE:
+ checklinelen = 0;
+ checklinespace = 0;
+
+ /* don't check anything for message/external */
+ if (ct->c_subtype == MESSAGE_EXTERNAL) {
+ checkboundary = 0;
+ check8bit = 0;
+ } else {
+ checkboundary = 1;
+ check8bit = 1;
+ }
+ break;
+
+ case CT_AUDIO:
+ case CT_IMAGE:
+ case CT_VIDEO:
+ /*
+ * Don't check anything for these types,
+ * 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;
+ break;
+ }
}
/*
* Scan the unencoded content
*/
- if (check8bit || checklinelen || checklinespace || checkboundary) {
+ if (check8bit || checklinelen || checklinespace || checkboundary ||
+ checkllinelen || checknul) {
if ((in = fopen (ce->ce_file, "r")) == NULL)
adios (ce->ce_file, "unable to open for reading");
- len = strlen (prefix);
+ prefix_len = strlen (prefix);
- while (fgets (buffer, sizeof(buffer) - 1, in)) {
+ while ((gotlen = getline(&bufp, &buflen, in)) != -1) {
/*
- * Check for 8bit data.
+ * Check for 8bit and NUL data.
*/
- if (check8bit) {
- for (cp = buffer; *cp; cp++) {
- if (!isascii ((unsigned char) *cp)) {
- contains8bit = 1;
- check8bit = 0; /* no need to keep checking */
- }
+ for (cp = bufp; (check8bit || checknul) &&
+ cp < bufp + gotlen; cp++) {
+ if (!isascii ((unsigned char) *cp)) {
+ contains8bit = 1;
+ check8bit = 0; /* no need to keep checking */
+ }
+ if (!*cp) {
+ containsnul = 1;
+ checknul = 0; /* no need to keep checking */
}
}
/*
* Check line length.
*/
- if (checklinelen && (strlen (buffer) > CPERLIN + 1)) {
+ if (checklinelen && ((size_t)gotlen > maxunencoded + 1)) {
linelen = 1;
checklinelen = 0; /* no need to keep checking */
}
+ /*
+ * RFC 5322 specifies that a message cannot contain a line
+ * greater than 998 characters (excluding the CRLF). If we
+ * get one of those lines and linelen is NOT set, then abort.
+ */
+
+ if (checkllinelen && !linelen &&
+ (gotlen > MAXLONGLINE + 1)) {
+ adios(NULL, "Line in content exceeds maximum line limit (%d)",
+ MAXLONGLINE);
+ }
+
/*
* Check if line ends with a space.
*/
- if (checklinespace && (cp = buffer + strlen (buffer) - 2) > buffer && isspace ((unsigned char) *cp)) {
+ if (checklinespace && (cp = bufp + gotlen - 2) > bufp &&
+ isspace ((unsigned char) *cp)) {
linespace = 1;
checklinespace = 0; /* no need to keep checking */
}
* Check if content contains a line that clashes
* with our standard boundary for multipart messages.
*/
- if (checkboundary && buffer[0] == '-' && buffer[1] == '-') {
- for (cp = buffer + strlen (buffer) - 1; cp >= buffer; cp--)
+ if (checkboundary && bufp[0] == '-' && bufp[1] == '-') {
+ for (cp = bufp + gotlen - 1; cp >= bufp; cp--)
if (!isspace ((unsigned char) *cp))
break;
*++cp = '\0';
- if (!strncmp(buffer + 2, prefix, len) && isdigit((unsigned char) buffer[2 + len])) {
+ if (!strncmp(bufp + 2, prefix, prefix_len) &&
+ isdigit((unsigned char) bufp[2 + prefix_len])) {
boundaryclash = 1;
checkboundary = 0; /* no need to keep checking */
}
}
}
fclose (in);
+ free(bufp);
}
/*
- * Decide which transfer encoding to use.
+ * If the content is text and didn't specify a character set,
+ * we need to figure out which one was used.
*/
- switch (ct->c_type) {
- case CT_TEXT:
- /*
- * If the text content didn't specify a character
- * set, we need to figure out which one was used.
- */
- t = (struct text *) ct->c_ctparams;
- if (t->tx_charset == CHARSET_UNSPECIFIED) {
- CI ci = &ct->c_ctinfo;
- char **ap, **ep;
+ set_charset (ct, contains8bit);
- for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++)
- continue;
+ /*
+ * Decide which transfer encoding to use.
+ */
- if (contains8bit) {
- *ap = concat ("charset=", write_charset_8bit(), NULL);
- } else {
- *ap = add ("charset=us-ascii", NULL);
- }
- t->tx_charset = CHARSET_SPECIFIED;
+ if (ct->c_reqencoding != CE_UNKNOWN)
+ ct->c_encoding = ct->c_reqencoding;
+ else {
+ int wants_q_p = (containsnul || linelen || linespace || checksw);
- cp = strchr(*ap++, '=');
- *ap = NULL;
- *cp++ = '\0';
- *ep = cp;
- }
+ switch (ct->c_type) {
+ case CT_TEXT:
+ if (wants_q_p)
+ ct->c_encoding = CE_QUOTED;
+ else if (contains8bit)
+ ct->c_encoding = CE_8BIT;
+ else
+ ct->c_encoding = CE_7BIT;
- if (contains8bit || linelen || linespace || checksw)
- ct->c_encoding = CE_QUOTED;
- else
- ct->c_encoding = CE_7BIT;
- break;
+ break;
- case CT_APPLICATION:
- /* For application type, use base64, except when postscript */
- if (contains8bit || linelen || linespace || checksw)
- ct->c_encoding = (ct->c_subtype == APPLICATION_POSTSCRIPT)
- ? CE_QUOTED : CE_BASE64;
- else
- ct->c_encoding = CE_7BIT;
- break;
+ case CT_APPLICATION:
+ /* For application type, use base64, except when postscript */
+ if (wants_q_p || contains8bit) {
+ if (ct->c_subtype == APPLICATION_POSTSCRIPT)
+ ct->c_encoding = CE_QUOTED; /* historical */
+ else
+ ct->c_encoding = CE_BASE64;
+ } else {
+ ct->c_encoding = CE_7BIT;
+ }
+ break;
- case CT_MESSAGE:
- ct->c_encoding = CE_7BIT;
- break;
+ case CT_MESSAGE:
+ ct->c_encoding = contains8bit ? CE_8BIT : CE_7BIT;
+ break;
- case CT_AUDIO:
- case CT_IMAGE:
- case CT_VIDEO:
- /* For audio, image, and video contents, just use base64 */
- ct->c_encoding = CE_BASE64;
- break;
+ case CT_AUDIO:
+ case CT_IMAGE:
+ case CT_VIDEO:
+ /* For audio, image, and video contents, just use base64 */
+ ct->c_encoding = CE_BASE64;
+ break;
+ }
}
return (boundaryclash ? NOTOK : OK);
*/
static int
-build_headers (CT ct)
+build_headers (CT ct, int header_encoding)
{
int cc, mailbody, extbody, len;
- char **ap, **ep;
char *np, *vp, buffer[BUFSIZ];
CI ci = &ct->c_ctinfo;
* boundary to the list of attribute/value pairs.
*/
if (ct->c_type == CT_MULTIPART) {
- char *cp;
static int level = 0; /* store nesting level */
- ap = ci->ci_attrs;
- ep = ci->ci_values;
- snprintf (buffer, sizeof(buffer), "boundary=%s%d", prefix, level++);
- cp = strchr(*ap++ = add (buffer, NULL), '=');
- *ap = NULL;
- *cp++ = '\0';
- *ep = cp;
+ snprintf (buffer, sizeof(buffer), "%s%d", prefix, level++);
+ add_param(&ci->ci_first_pm, &ci->ci_last_pm, "boundary", buffer, 0);
}
/*
* Append the attribute/value pairs to
* the end of the Content-Type line.
*/
- for (ap = ci->ci_attrs, ep = ci->ci_values; *ap; ap++, ep++) {
- if (mailbody && !mh_strcasecmp (*ap, "body"))
- continue;
-
- vp = add (";", vp);
- len++;
-
- /*
- * According to RFC 2017, if we have a URL longer than 40 characters
- * we have to break it across multiple lines
- */
-
- if (extbody && mh_strcasecmp (*ap, "url") == 0) {
- char *value = *ep;
-
- /* 7 here refers to " url=\"\"" */
- if (len + 1 + (cc = (min(MAXURLTOKEN, strlen(value)) + 7)) >=
- CPERLIN) {
- vp = add ("\n\t", vp);
- len = 8;
- } else {
- vp = add (" ", vp);
- len++;
- }
-
- vp = add ("url=\"", vp);
- len += 5;
- while (strlen(value) > MAXURLTOKEN) {
- strncpy(buffer, value, MAXURLTOKEN);
- buffer[MAXURLTOKEN] = '\0';
- vp = add (buffer, vp);
- vp = add ("\n\t", vp);
- value += MAXURLTOKEN;
- len = 8;
- }
+ if (ci->ci_first_pm) {
+ char *s = output_params(len, ci->ci_first_pm, &len, mailbody);
- vp = add (value, vp);
- vp = add ("\"", vp);
- len += strlen(value) + 1;
- continue;
- }
+ if (!s)
+ adios(NULL, "Internal error: failed outputting Content-Type "
+ "parameters");
- snprintf (buffer, sizeof(buffer), "%s=\"%s\"", *ap, *ep);
- if (len + 1 + (cc = strlen (buffer)) >= CPERLIN) {
- vp = add ("\n\t", vp);
- len = 8;
- } else {
- vp = add (" ", vp);
- len++;
- }
- vp = add (buffer, vp);
- len += cc;
+ vp = add (s, vp);
+ free(s);
}
/*
vp = concat (" ", ct->c_id, NULL);
add_header (ct, np, vp);
}
-
/*
* output the Content-Description
*/
if (ct->c_descr) {
np = add (DESCR_FIELD, NULL);
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);
+ }
+ }
add_header (ct, np, vp);
}
/*
- * output the Content-Disposition
+ * output the Content-Disposition. If it's NULL but c_dispo_type is
+ * set, then we need to build it.
*/
if (ct->c_dispo) {
np = add (DISPO_FIELD, NULL);
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;
+ np = output_params(len, ct->c_dispo_first, NULL, 0);
+ vp = add(np, vp);
+ vp = add("\n", 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 */
break;
case CE_8BIT:
- if (ct->c_type == CT_MESSAGE)
- adios (NULL, "internal error, invalid encoding");
-
np = add (ENCODING_FIELD, NULL);
vp = concat (" ", "8bit", "\n", NULL);
add_header (ct, np, vp);
CT p;
p = part->mp_part;
- build_headers (p);
+ build_headers (p, header_encoding);
}
}
break;
struct exbody *e;
e = (struct exbody *) ct->c_ctparams;
- build_headers (e->eb_content);
+ build_headers (e->eb_content, header_encoding);
}
break;
calculate_digest (CT ct, int asciiP)
{
int cc;
- char buffer[BUFSIZ], *vp, *op;
+ char *vp, *op;
unsigned char *dp;
unsigned char digest[16];
unsigned char outbuf[25];
/* calculate md5 message digest */
if (asciiP) {
- while (fgets (buffer, sizeof(buffer) - 1, in)) {
+ char *bufp = NULL;
+ size_t buflen;
+ ssize_t gotlen;
+ while ((gotlen = getline(&bufp, &buflen, in)) != -1) {
char c, *cp;
- cp = buffer + strlen (buffer) - 1;
+ cp = bufp + gotlen - 1;
if ((c = *cp) == '\n')
- *cp = '\0';
+ gotlen--;
- MD5Update (&mdContext, (unsigned char *) buffer,
- (unsigned int) strlen (buffer));
+ MD5Update (&mdContext, (unsigned char *) bufp,
+ (unsigned int) gotlen);
if (c == '\n')
MD5Update (&mdContext, (unsigned char *) "\r\n", 2);
}
} else {
+ char buffer[BUFSIZ];
while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), in)) > 0)
MD5Update (&mdContext, (unsigned char *) buffer, (unsigned int) cc);
}
/* encode the digest using base64 */
for (dp = digest, op = (char *) outbuf,
- cc = sizeof(digest) / sizeof(digest[0]);
+ cc = sizeof(digest) / sizeof(digest[0]);
cc > 0; cc -= 3, op += 4) {
unsigned long bits;
char *bp;
vp = concat (" ", outbuf, "\n", NULL);
return vp;
}
+
+/*
+ * Set things up for the content structure for file "filename" that
+ * we want to attach
+ */
+
+static void
+setup_attach_content(CT ct, char *filename)
+{
+ char *type, *simplename = r1bindex(filename, '/');
+ struct str2init *s2i;
+ PM pm;
+
+ if (! (type = mime_type(filename))) {
+ adios(NULL, "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.
+ * Map that to a valid content-type label and call any initialization
+ * function.
+ */
+
+ if (get_ctinfo(type, ct, 0) == NOTOK)
+ done(1);
+
+ free(type);
+
+ for (s2i = str2cts; s2i->si_key; s2i++)
+ if (strcasecmp(ct->c_ctinfo.ci_type, s2i->si_key) == 0)
+ break;
+ if (!s2i->si_key && !uprf(ct->c_ctinfo.ci_type, "X-"))
+ s2i++;
+
+ /*
+ * Make sure the type isn't incompatible with what we can handle
+ */
+
+ switch (ct->c_type = s2i->si_val) {
+ case CT_MULTIPART:
+ adios (NULL, "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,
+ ct->c_ctinfo.ci_subtype);
+ if (strcasecmp(ct->c_ctinfo.ci_subtype, "external-body") == 0)
+ adios(NULL, "external-body messages must be specified "
+ "by mhbuild directives");
+ /* Fall through */
+
+ default:
+ /*
+ * This sets the subtype, if it's significant
+ */
+ if ((ct->c_ctinitfnx = s2i->si_init))
+ (*ct->c_ctinitfnx)(ct);
+ break;
+ }
+
+ /*
+ * Feed in a few attributes; specifically, the name attribute, the
+ * content-description, and the content-disposition.
+ */
+
+ for (pm = ct->c_ctinfo.ci_first_pm; pm; pm = pm->pm_next) {
+ if (strcasecmp(pm->pm_name, "name") == 0) {
+ mh_xfree(pm->pm_value);
+ pm->pm_value = mh_xstrdup(simplename);
+ break;
+ }
+ }
+
+ if (pm == NULL)
+ add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
+ "name", simplename, 0);
+
+ ct->c_descr = mh_xstrdup(simplename);
+ ct->c_descr = add("\n", ct->c_descr);
+ ct->c_cefile.ce_file = mh_xstrdup(filename);
+
+ set_disposition (ct);
+
+ add_param(&ct->c_dispo_first, &ct->c_dispo_last, "filename", simplename, 0);
+}
+
+/*
+ * If disposition type hasn't already been set in ct:
+ * Look for mhbuild-disposition-<type>/<subtype> entry
+ * that specifies Content-Disposition type. Only
+ * 'attachment' and 'inline' are allowed. Default to
+ * 'attachment'.
+ */
+void
+set_disposition (CT ct) {
+ if (ct->c_dispo_type == NULL) {
+ char *cp = context_find_by_type ("disposition", ct->c_ctinfo.ci_type,
+ ct->c_ctinfo.ci_subtype);
+
+ 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);
+ }
+
+ if (!cp)
+ cp = "attachment";
+ ct->c_dispo_type = mh_xstrdup(cp);
+ }
+}
+
+/*
+ * Set text content charset if it was unspecified. contains8bit
+ * selctions:
+ * 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
+ */
+void
+set_charset (CT ct, int contains8bit) {
+ if (ct->c_type == CT_TEXT) {
+ struct text *t;
+
+ if (ct->c_ctparams == NULL) {
+ NEW0(t);
+ ct->c_ctparams = t;
+ t->tx_charset = CHARSET_UNSPECIFIED;
+ } else {
+ t = (struct text *) ct->c_ctparams;
+ }
+
+ if (t->tx_charset == CHARSET_UNSPECIFIED) {
+ CI ci = &ct->c_ctinfo;
+ char *eightbitcharset = write_charset_8bit();
+ char *charset = contains8bit ? eightbitcharset : "us-ascii";
+
+ if (contains8bit == 1 &&
+ strcasecmp (eightbitcharset, "US-ASCII") == 0) {
+ adios (NULL, "Text content contains 8 bit characters, but "
+ "character set is US-ASCII");
+ }
+
+ add_param (&ci->ci_first_pm, &ci->ci_last_pm, "charset", charset,
+ 0);
+
+ t->tx_charset = CHARSET_SPECIFIED;
+ }
+ }
+}
+
+
+/*
+ * Look at all of the replied-to message parts and expand any that
+ * are matched by a pseudoheader. Except don't descend into
+ * message parts.
+ */
+void
+expand_pseudoheaders (CT ct, struct multipart *m, const char *infile,
+ const convert_list *convert_head) {
+ /* text_plain_ct is used to concatenate all of the text/plain
+ replies into one part, instead of having each one in a separate
+ part. */
+ CT text_plain_ct = NULL;
+
+ switch (ct->c_type) {
+ case CT_MULTIPART: {
+ struct multipart *mp = (struct multipart *) ct->c_ctparams;
+ struct part *part;
+
+ if (ct->c_subtype == MULTI_ALTERNATE) {
+ int matched = 0;
+
+ /* The parts are in descending priority order (defined by
+ RFC 2046 Sec. 5.1.4) because they were reversed by
+ parse_mime (). So, stop looking for matches with
+ immediate subparts after the first match of an
+ alternative. */
+ for (part = mp->mp_parts; ! matched && part; part = part->mp_next) {
+ char *type_subtype =
+ concat (part->mp_part->c_ctinfo.ci_type, "/",
+ part->mp_part->c_ctinfo.ci_subtype, NULL);
+
+ if (part->mp_part->c_type == CT_MULTIPART) {
+ expand_pseudoheaders (part->mp_part, m, infile,
+ convert_head);
+ } else {
+ const convert_list *c;
+
+ for (c = convert_head; c; c = c->next) {
+ if (! strcasecmp (type_subtype, c->type)) {
+ expand_pseudoheader (part->mp_part, &text_plain_ct,
+ m, infile,
+ c->type, c->argstring);
+ matched = 1;
+ break;
+ }
+ }
+ }
+ free (type_subtype);
+ }
+ } else {
+ for (part = mp->mp_parts; part; part = part->mp_next) {
+ expand_pseudoheaders (part->mp_part, m, infile, convert_head);
+ }
+ }
+ break;
+ }
+
+ default: {
+ char *type_subtype =
+ concat (ct->c_ctinfo.ci_type, "/", ct->c_ctinfo.ci_subtype,
+ NULL);
+ const convert_list *c;
+
+ for (c = convert_head; c; c = c->next) {
+ if (! strcasecmp (type_subtype, c->type)) {
+ expand_pseudoheader (ct, &text_plain_ct, m, infile, c->type,
+ c->argstring);
+ break;
+ }
+ }
+ free (type_subtype);
+ break;
+ }
+ }
+}
+
+
+/*
+ * Expand a single pseudoheader. It's for the specified type.
+ */
+void
+expand_pseudoheader (CT ct, CT *text_plain_ct, struct multipart *m,
+ const char *infile, const char *type,
+ const char *argstring) {
+ char *reply_file;
+ FILE *reply_fp = NULL;
+ char *convert, *type_p, *subtype_p;
+ char *convert_command;
+ char *charset = NULL;
+ char *cp;
+ struct str2init *s2i;
+ CT reply_ct;
+ struct part *part;
+ int eightbit = 0;
+ int status;
+
+ type_p = getcpy (type);
+ if ((subtype_p = strchr (type_p, '/'))) {
+ *subtype_p++ = '\0';
+ convert = context_find_by_type ("convert", type_p, subtype_p);
+ } else {
+ free (type_p);
+ type_p = concat ("mhbuild-convert-", type, NULL);
+ convert = context_find (type_p);
+ }
+ free (type_p);
+
+ if (! (convert)) {
+ /* 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);
+
+ /* Convert here . . . */
+ 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);
+ }
+ free (convert_command);
+
+ /* Fill out the the new ct, 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);
+ 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++) {
+ if (strcasecmp(reply_ct->c_ctinfo.ci_type, s2i->si_key) == 0) {
+ break;
+ }
+ }
+
+ if ((reply_ct->c_ctinitfnx = s2i->si_init)) {
+ (*reply_ct->c_ctinitfnx)(reply_ct);
+ }
+
+ 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 &&
+ 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;
+ }
+ }
+
+ /* Concatenate text/plain parts. */
+ 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. */
+ set_charset (*text_plain_ct, -1);
+ if ((*text_plain_ct)->c_reqencoding == CE_UNKNOWN) {
+ /* 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 =
+ eightbit ? CE_8BIT : CE_7BIT;
+ }
+ }
+
+ if (*text_plain_ct) {
+ /* Only concatenate if the charsets are identical. */
+ char *text_plain_ct_charset =
+ get_param ((*text_plain_ct)->c_ctinfo.ci_first_pm, "charset",
+ '?', 1);
+
+ if (strcasecmp (text_plain_ct_charset, charset) == 0) {
+ /* Append this text/plain reply to the first one.
+ If there's a problem anywhere along the way,
+ instead attach it is a separate part. */
+ int text_plain_reply =
+ open ((*text_plain_ct)->c_cefile.ce_file,
+ O_WRONLY | O_APPEND);
+ int addl_reply = open (reply_file, O_RDONLY);
+
+ if (text_plain_reply != NOTOK && addl_reply != NOTOK) {
+ /* Insert blank line before each addl part. */
+ /* It would be nice not to do this for the first one. */
+ if (write (text_plain_reply, "\n", 1) == 1) {
+ /* Copy the text from the new reply and
+ then free its Content struct. */
+ cpydata (addl_reply, text_plain_reply,
+ (*text_plain_ct)->c_cefile.ce_file,
+ 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);
+ return;
+ }
+ }
+ }
+ }
+ } else {
+ *text_plain_ct = reply_ct;
+ }
+ }
+
+ reply_ct->c_cefile.ce_file = reply_file;
+ reply_ct->c_cefile.ce_fp = reply_fp;
+ reply_ct->c_cefile.ce_unlink = 1;
+
+ /* Attach the new part to the parent multipart/mixed, "m". */
+ NEW0(part);
+ part->mp_part = reply_ct;
+ if (m->mp_parts) {
+ struct part *p;
+
+ for (p = m->mp_parts; p && p->mp_next; p = p->mp_next) { continue; }
+ p->mp_next = part;
+ } else {
+ m->mp_parts = part;
+ }
+}
+
+
+/* Extract any Content-Type header from beginning of convert output. */
+int
+extract_headers (CT ct, char *reply_file, FILE **reply_fp) {
+ char *buffer = NULL, *cp, *end_of_header;
+ int found_header = 0;
+ struct stat statbuf;
+
+ /* Read the convert reply from the file to memory. */
+ if (stat (reply_file, &statbuf) == NOTOK) {
+ admonish (reply_file, "failed to stat");
+ goto failed_to_extract_ct;
+ }
+
+ buffer = mh_xmalloc (statbuf.st_size + 1);
+
+ if ((*reply_fp = fopen (reply_file, "r+")) == NULL ||
+ fread (buffer, 1, (size_t) statbuf.st_size, *reply_fp) <
+ (size_t) statbuf.st_size) {
+ admonish (reply_file, "failed to read");
+ goto failed_to_extract_ct;
+ }
+ 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 ((end_of_header = strstr (buffer, "\r\n\r\n"))) {
+ end_of_header += 2;
+ found_header = 1;
+ } else if ((end_of_header = strstr (buffer, "\n\n"))) {
+ ++end_of_header;
+ found_header = 1;
+ }
+ }
+
+ if (found_header) {
+ CT tmp_ct;
+ char *tmp_file;
+ FILE *tmp_f;
+ size_t n;
+
+ /* 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");
+ 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 {
+ goto failed_to_extract_ct;
+ }
+ tmp_ct = parse_mime (tmp_file);
+
+ if (tmp_ct) {
+ /* The type and subtype were detected from the reply
+ using parse_mime() above. */
+ ct->c_type = tmp_ct->c_type;
+ ct->c_subtype = tmp_ct->c_subtype;
+ free_content (tmp_ct);
+ }
+
+ free (tmp_file);
+
+ /* Rewrite the content without the header. */
+ cp = end_of_header + 1;
+ rewind (*reply_fp);
+
+ if (fwrite (cp, 1, statbuf.st_size - (cp - buffer), *reply_fp) <
+ (size_t) (statbuf.st_size - (cp - buffer))) {
+ admonish (reply_file, "failed to write");
+ goto failed_to_extract_ct;
+ }
+
+ if (ftruncate (fileno (*reply_fp), statbuf.st_size - (cp - buffer)) !=
+ 0) {
+ advise (reply_file, "ftruncate");
+ goto failed_to_extract_ct;
+ }
+ } else {
+ /* No header section, assume the reply is text/plain. */
+ ct->c_type = CT_TEXT;
+ 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");
+ }
+ }
+
+ /* free_encoding() will close reply_fp, which is passed through
+ ct->c_cefile.ce_fp. */
+ free (buffer);
+ return OK;
+
+failed_to_extract_ct:
+ if (*reply_fp) { fclose (*reply_fp); }
+ free (buffer);
+ return NOTOK;
+}
projects / nmh / blobdiff