#include <h/mh.h>
#include <fcntl.h>
-#include <h/signals.h>
#include <errno.h>
-#include <signal.h>
#include <h/tws.h>
#include <h/mime.h>
#include <h/mhparse.h>
#include <h/utils.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <locale.h>
+#include <sysexits.h>
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
{ NULL, 0 }
};
+char *version=VERSION;
/*
** Directory to place tmp files. This must
static char outfile[BUFSIZ];
static int unlink_outfile = 0;
-static void unlink_done(int) NORETURN;
+void unlink_done();
/* mhoutsbr.c */
int output_message(CT, char *);
char *cp, buf[BUFSIZ];
char buffer[BUFSIZ], *compfile = NULL;
char **argp, **arguments;
- CT ct, cts[2];
+ CT ct;
FILE *fp = NULL;
FILE *fp_out = NULL;
- done = unlink_done;
+ if (atexit(unlink_done) != 0) {
+ adios(EX_OSERR, NULL, "atexit failed");
+ }
-#ifdef LOCALE
setlocale(LC_ALL, "");
-#endif
invo_name = mhbasename(argv[0]);
/* read user profile/context */
while ((cp = *argp++)) {
if (cp[0] == '-' && cp[1] == '\0') {
if (compfile)
- adios(NULL, "cannot specify both standard input and a file");
+ adios(EX_USAGE, NULL, "cannot specify both standard input and a file");
else
compfile = cp;
verbosw = 0; /* turn off -verbose listings */
switch (smatch(++cp, switches)) {
case AMBIGSW:
ambigsw(cp, switches);
- done(1);
+ exit(EX_USAGE);
case UNKWNSW:
- adios(NULL, "-%s unknown", cp);
+ adios(EX_USAGE, NULL, "-%s unknown", cp);
case HELPSW:
snprintf(buf, sizeof(buf), "%s [switches] file", invo_name);
print_help(buf, switches, 1);
- done(1);
+ exit(argc == 2 ? EX_OK : EX_USAGE);
case VERSIONSW:
print_version(invo_name);
- done(1);
+ exit(argc == 2 ? EX_OK : EX_USAGE);
case VERBSW:
verbosw++;
}
}
if (compfile)
- adios(NULL, "only one composition file allowed");
+ adios(EX_USAGE, NULL, "only one composition file allowed");
else
compfile = cp;
}
if ((cp = context_find(nmhstorage)) && *cp)
tmp = concat(cp, "/", invo_name, NULL);
else
- tmp = getcpy(toabsdir(invo_name));
+ tmp = mh_xstrdup(toabsdir(invo_name));
/* Check if we have a file to process */
if (!compfile)
- adios(NULL, "need to specify a %s composition file",
+ adios(EX_USAGE, NULL, "need to specify a %s composition file",
invo_name);
/*
/* build the content structures for MIME message */
ct = build_mime(infile);
- cts[0] = ct;
- cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy(outfile, m_mktemp(invo_name, NULL, &fp_out),
/* output the temp file to standard output */
if ((fp = fopen(outfile, "r")) == NULL)
- adios(outfile, "unable to open");
+ adios(EX_IOERR, outfile, "unable to open");
while (fgets(buffer, BUFSIZ, fp))
fputs(buffer, stdout);
fclose(fp);
unlink_outfile = 0;
free_content(ct);
- done(0);
+ exit(EX_OK);
}
/*
/* build the content structures for MIME message */
ct = build_mime(compfile);
- cts[0] = ct;
- cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy(outfile, m_mktemp2(compfile, invo_name, NULL, &fp_out),
fclose(fp_out);
/* Rename composition draft */
- snprintf(buffer, sizeof(buffer), "%s.orig", m_backup(compfile));
+ snprintf(buffer, sizeof(buffer), "%s.orig", compfile);
if (rename(compfile, buffer) == NOTOK) {
- adios(compfile, "unable to rename comp draft %s to", buffer);
+ adios(EX_IOERR, buffer, "unable to rename draft %s to", compfile);
}
/* Rename output file to take its place */
if (rename(outfile, compfile) == NOTOK) {
- advise(outfile, "unable to rename output %s to", compfile);
+ advise(compfile, "unable to rename output %s to", outfile);
rename(buffer, compfile);
- done(1);
+ exit(EX_IOERR);
}
unlink_outfile = 0;
free_content(ct);
- done(0);
- return 1;
+ return 0;
}
-static void
-unlink_done(int status)
+void
+unlink_done()
{
/*
** Check if we need to remove stray temporary files.
*/
- if (unlink_infile)
+ if (unlink_infile) {
unlink(infile);
- if (unlink_outfile)
+ }
+ if (unlink_outfile) {
unlink(outfile);
-
- exit(status);
+ }
}
/*
static CT
build_mime(char *infile)
{
- int compnum, state;
- char buf[BUFSIZ], name[NAMESZ];
+ enum state state;
+ struct field f = {{0}};
+ int compnum;
+ char buf[BUFSIZ];
char *cp, *np, *vp;
struct multipart *m;
struct part **pp;
CT ct;
FILE *in;
+ HF hp;
umask(~m_gmprot());
/* open the composition draft */
- if ((in = fopen(infile, "r")) == NULL)
- adios(infile, "unable to open for reading");
+ if ((in = fopen(infile, "r")) == NULL) {
+ adios(EX_IOERR, infile, "unable to open for reading");
+ }
/*
** Allocate space for primary (outside) content
*/
- if ((ct = (CT) calloc(1, sizeof(*ct))) == NULL)
- adios(NULL, "out of memory");
+ ct = mh_xcalloc(1, sizeof(*ct));
/*
** Allocate structure for handling decoded content
** draft into the linked list of header fields for
** the new MIME message.
*/
- for (compnum = 1, state = FLD;;) {
- switch (state = m_getfld(state, name, buf, sizeof(buf), in)) {
- case FLD:
- case FLDPLUS:
- case FLDEOF:
+ for (compnum = 1, state = FLD2;;) {
+ switch (state = m_getfld2(state, &f, in)) {
+ case FLD2:
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);
+ if (!mh_strcasecmp(f.name, VRSN_FIELD)) {
+ adios(EX_CONFIG, 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);
+ if (!mh_strcasecmp(f.name, ENCODING_FIELD)) {
+ adios(EX_CONFIG, NULL, "draft shouldn't contain %s: field", ENCODING_FIELD);
+ }
/* ignore any Content-Type fields in the header */
- if (!mh_strcasecmp(name, TYPE_FIELD)) {
- while (state == FLDPLUS)
- state = m_getfld(state, name, buf,
- sizeof(buf), in);
- goto finish_field;
+ if (!mh_strcasecmp(f.name, TYPE_FIELD)) {
+ continue;
}
- /* get copies of the buffers */
- np = getcpy(name);
- vp = getcpy(buf);
-
- /* if necessary, get rest of field */
- while (state == FLDPLUS) {
- state = m_getfld(state, name, buf,
- sizeof(buf), in);
- vp = add(buf, vp); /* add to prev value */
- }
+ /* add the header data to the list */
+ add_header(ct, mh_xstrdup(f.name), mh_xstrdup(f.value));
- /* Now add the header data to the list */
- add_header(ct, np, vp);
+ continue;
-finish_field:
- /* if this wasn't the last hdr field, then continue */
- if (state != FLDEOF)
- continue;
- /* else fall... */
+ case BODY2:
+ fseek(in, (long) (-strlen(f.value)), SEEK_CUR);
+ break;
- case FILEEOF:
- adios(NULL, "draft has empty body -- no directives!");
+ case FILEEOF2:
+ adios(EX_CONFIG, NULL, "draft has empty body -- no directives!");
/* NOTREACHED */
- case BODY:
- case BODYEOF:
- fseek(in, (long) (-strlen(buf)), SEEK_CUR);
- break;
-
- case LENERR:
- case FMTERR:
- adios(NULL, "message format error in component #%d",
+ case LENERR2:
+ case FMTERR2:
+ case IOERR2:
+ adios(EX_CONFIG, NULL, "message format error in component #%d",
compnum);
default:
- adios(NULL, "getfld() returned %d", state);
+ adios(EX_SOFTWARE, NULL, "getfld() returned %d", state);
}
break;
}
/*
+ ** 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, NULL)) {
+ adios(EX_DATAERR, NULL, "Unable to encode header \"%s\"", hp->name);
+ }
+ }
+
+ /*
** Now add the MIME-Version header field
** to the list of header fields.
*/
- np = getcpy(VRSN_FIELD);
+ 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.
*/
- if (get_ctinfo("multipart/mixed", ct, 0) == NOTOK)
- done(1);
+ if (get_ctinfo("multipart/mixed", ct, 0) == NOTOK) {
+ exit(EX_DATAERR);
+ }
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_MIXED;
- ct->c_file = getcpy(infile);
+ ct->c_file = mh_xstrdup(infile);
- if ((m = (struct multipart *) calloc(1, sizeof(*m))) == NULL)
- adios(NULL, "out of memory");
+ m = (struct multipart *) mh_xcalloc(1, sizeof(*m));
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
if (!p)
continue;
- if ((part = (struct part *) calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ part = mh_xcalloc(1, sizeof(*part));
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
/* check if any contents were found */
if (!m->mp_parts)
- adios(NULL, "no content directives found");
+ adios(EX_OSERR, NULL, "no content directives found");
/*
** If only one content was found, then remove and
compose_content(ct);
if ((cp = strchr(prefix, 'a')) == NULL)
- adios(NULL, "internal error(4)");
+ adios(EX_SOFTWARE, NULL, "internal error(4)");
/*
** Scan the contents. Choose a transfer encoding, and
(*cp)++;
} else {
if (*++cp == 0)
- adios(NULL, "giving up trying to find a unique delimiter string");
+ adios(EX_SOFTWARE, NULL, "giving up trying to find a unique delimiter string");
else
(*cp)++;
}
{
CE ce;
- if ((ce = (CE) calloc(1, sizeof(*ce))) == NULL)
- adios(NULL, "out of memory");
+ ce = mh_xcalloc(1, sizeof(*ce));
ct->c_cefile = ce;
ct->c_ceopenfnx = open7Bit; /* since unencoded */
}
/* allocate basic Content structure */
- if ((ct = (CT) calloc(1, sizeof(*ct))) == NULL)
- adios(NULL, "out of memory");
+ ct = mh_xcalloc(1, sizeof(*ct));
*ctp = ct;
/* allocate basic structure for handling decoded content */
cp = m_mktemp2(NULL, invo_name, NULL, &out);
if (cp == NULL)
- adios("mhbuild", "unable to create temporary file");
+ adios(EX_CANTCREAT, "mhbuild", "unable to create temporary file");
/* use a temp file to collect the plain text lines */
- ce->ce_file = getcpy(cp);
+ ce->ce_file = mh_xstrdup(cp);
ce->ce_unlink = 1;
if (buf[0] == '#' && buf[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);
+ adios(EX_DATAERR, NULL, "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);
+ adios(EX_DATAERR, NULL, "#-directive after %s: field in plaintext", DESCR_FIELD);
/* NOTREACHED */
default:
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);
+ adios(EX_DATAERR, NULL, "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);
+ adios(EX_DATAERR, NULL, "#-directive after %s: field in plaintext", DISPO_FIELD);
/* NOTREACHED */
default:
/* parse content type */
if (get_ctinfo(content, ct, inlineD) == NOTOK)
- done(1);
+ exit(EX_DATAERR);
for (s2i = str2cts; s2i->si_key; s2i++)
if (!mh_strcasecmp(ci->ci_type, s2i->si_key))
}
/* else fall... */
case CT_MULTIPART:
- adios(NULL, "it doesn't make sense to define an in-line %s content",
+ adios(EX_DATAERR, NULL, "it doesn't make sense to define an in-line %s content",
ct->c_type == CT_MESSAGE ? "message" :
"multipart");
/* NOTREACHED */
*/
if (buf[1] == '@') {
- adios(NULL, "The #@ directive i.e. message/external-body "
+ adios(EX_DATAERR, NULL, "The #@ directive i.e. message/external-body "
"is not supported anymore.");
}
/* parse directive */
if (get_ctinfo(buf+1, ct, 1) == NOTOK)
- done(1);
+ exit(EX_DATAERR);
/* check directive against the list of MIME types */
for (s2i = str2cts; s2i->si_key; s2i++)
*/
if (s2i->si_key) {
if (!ci->ci_subtype)
- adios(NULL, "missing subtype in \"#%s\"", ci->ci_type);
+ adios(EX_DATAERR, NULL, "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\"", ci->ci_type, ci->ci_subtype);
+ adios(EX_DATAERR, NULL, "use \"#begin ... #end\" instead of \"#%s/%s\"", ci->ci_type, ci->ci_subtype);
/* NOTREACHED */
case CT_MESSAGE:
if (!mh_strcasecmp(ci->ci_subtype, "partial") ||
!mh_strcasecmp(ci->ci_subtype,
"external-body")) {
- adios(NULL, "sorry, \"#%s/%s\" isn't supported", ci->ci_type, ci->ci_subtype);
+ adios(EX_DATAERR, NULL, "sorry, \"#%s/%s\" isn't supported", ci->ci_type, ci->ci_subtype);
}
use_forw:
- adios(NULL, "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"", ci->ci_type, ci->ci_subtype);
- /* NOTREACHED */
+ admonish(NULL, "use \"#forw [+folder] [msgs]\" instead of \"#%s/%s\"", ci->ci_type, ci->ci_subtype);
+ /* FALL */
default:
if ((ct->c_ctinitfnx = s2i->si_init))
for (cp = ci->ci_magic + 1; isspace(*cp); cp++)
continue;
if (!*cp)
- adios(NULL, "empty pipe command for #%s directive", ci->ci_type);
- cp = getcpy(cp);
- free(ci->ci_magic);
+ adios(EX_DATAERR, NULL, "empty pipe command for #%s directive", ci->ci_type);
+ cp = mh_xstrdup(cp);
+ mh_free0(&(ci->ci_magic));
ci->ci_magic = cp;
} else {
/* record filename of decoded contents */
ce->ce_file = ci->ci_magic;
if (access(ce->ce_file, R_OK) == NOTOK)
- adios("reading", "unable to access %s for", ce->ce_file);
+ adios(EX_IOERR, "reading", "unable to access %s for", ce->ce_file);
ci->ci_magic = NULL;
}
return OK;
if ((cp = context_find(buffer)) == NULL ||
*cp == '\0') {
content_error(NULL, ct, "don't know how to compose content");
- done(1);
+ exit(EX_CONFIG);
}
}
- ci->ci_magic = getcpy(cp);
+ ci->ci_magic = mh_xstrdup(cp);
return OK;
}
cp = *ap;
if (*cp == '+' || *cp == '@') {
if (folder)
- adios(NULL, "only one folder per #forw directive");
+ adios(EX_USAGE, NULL, "only one folder per #forw directive");
else
- folder = getcpy(expandfol(cp));
+ folder = mh_xstrdup(expandfol(cp));
}
}
/* else, use the current folder */
if (!folder)
- folder = getcpy(getcurfol());
+ folder = mh_xstrdup(getcurfol());
if (!(mp = folder_read(folder)))
- adios(NULL, "unable to read folder %s", folder);
+ adios(EX_IOERR, NULL, "unable to read folder %s", folder);
for (ap = arguments; *ap; ap++) {
cp = *ap;
if (*cp != '+' && *cp != '@')
if (!m_convert(mp, cp))
- done(1);
+ exit(EX_USAGE);
}
- free(folder);
+ mh_free0(&folder);
free_ctinfo(ct);
/*
if (mp->numsel > 1) {
/* we are forwarding multiple messages */
if (get_ctinfo("multipart/digest", ct, 0) == NOTOK)
- done(1);
+ exit(EX_DATAERR);
ct->c_type = CT_MULTIPART;
ct->c_subtype = MULTI_DIGEST;
- if ((m = (struct multipart *)
- calloc(1, sizeof(*m))) == NULL)
- adios(NULL, "out of memory");
+ m = mh_xcalloc(1, sizeof(*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");
+ p = mh_xcalloc(1, sizeof(*p));
init_decoded_content(p);
pe = p->c_cefile;
if (get_ctinfo("message/rfc822", p, 0)
== NOTOK)
- done(1);
+ exit(EX_DATAERR);
p->c_type = CT_MESSAGE;
p->c_subtype = MESSAGE_RFC822;
snprintf(buffer, sizeof(buffer),
"%s/%d", mp->foldpath,
msgnum);
- pe->ce_file = getcpy(buffer);
+ pe->ce_file = mh_xstrdup(buffer);
- if ((part = (struct part *) calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ part = mh_xcalloc(1, sizeof(*part));
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
} else {
/* we are forwarding one message */
if (get_ctinfo("message/rfc822", ct, 0) == NOTOK)
- done(1);
+ exit(EX_DATAERR);
ct->c_type = CT_MESSAGE;
ct->c_subtype = MESSAGE_RFC822;
msgnum = mp->lowsel;
snprintf(buffer, sizeof(buffer), "%s/%d",
mp->foldpath, msgnum);
- ce->ce_file = getcpy(buffer);
+ ce->ce_file = mh_xstrdup(buffer);
}
folder_free(mp); /* free folder/message structure */
free_ctinfo(ct);
snprintf(buffer, sizeof(buffer), "multipart/%s", cp);
if (get_ctinfo(buffer, ct, 0) == NOTOK)
- done(1);
+ exit(EX_DATAERR);
ct->c_type = CT_MULTIPART;
ct->c_subtype = vrsn;
- if ((m = (struct multipart *) calloc(1, sizeof(*m))) == NULL)
- adios(NULL, "out of memory");
+ m = mh_xcalloc(1, sizeof(*m));
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
if (user_content(in, file, buffer, &p) == DONE) {
if (!m->mp_parts)
- adios(NULL, "empty \"#begin ... #end\" sequence");
+ adios(EX_DATAERR, NULL, "empty \"#begin ... #end\" sequence");
return OK;
}
if (!p)
continue;
- if ((part = (struct part *)
- calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ part = mh_xcalloc(1, sizeof(*part));
*pp = part;
pp = &part->mp_next;
part->mp_part = p;
/*
** Unknown directive
*/
- adios(NULL, "unknown directive \"#%s\"", ci->ci_type);
+ adios(EX_DATAERR, NULL, "unknown directive \"#%s\"", ci->ci_type);
return NOTOK; /* NOT REACHED */
}
snprintf(msgid, sizeof(msgid), "<%d.%ld.%%d@%s>\n",
(int) getpid(), (long) clock, LocalName());
partno = 0;
- msgfmt = getcpy(msgid);
+ msgfmt = mh_xstrdup(msgid);
}
snprintf(msgid, sizeof(msgid), msgfmt, top ? 0 : ++partno);
- ct->c_id = getcpy(msgid);
+ ct->c_id = mh_xstrdup(msgid);
}
CT p = part->mp_part;
sprintf(pp, "%d", partnum);
- p->c_partno = getcpy(partnam);
+ p->c_partno = mh_xstrdup(partnam);
if (compose_content(p) == NOTOK)
return NOTOK;
}
char *tfile = NULL;
if (!(cp = ci->ci_magic))
- adios(NULL, "internal error(5)");
+ adios(EX_SOFTWARE, NULL, "internal error(5)");
tfile = m_mktemp2(NULL, invo_name, NULL, NULL);
if (tfile == NULL) {
- adios("mhbuild", "unable to create temporary file");
+ adios(EX_CANTCREAT, "mhbuild", "unable to create temporary file");
}
- ce->ce_file = getcpy(tfile);
+ ce->ce_file = mh_xstrdup(tfile);
ce->ce_unlink = 1;
xstdout = 0;
vec[3] = NULL;
if ((out = fopen(ce->ce_file, "w")) == NULL)
- adios(ce->ce_file, "unable to open for writing");
+ adios(EX_IOERR, ce->ce_file, "unable to open for writing");
switch (child_id = fork()) {
case NOTOK:
- adios("fork", "unable to fork");
+ adios(EX_OSERR, "fork", "unable to fork");
/* NOTREACHED */
case OK:
execvp("/bin/sh", vec);
fprintf(stderr, "unable to exec ");
perror("/bin/sh");
- _exit(-1);
+ _exit(EX_OSERR);
/* NOTREACHED */
default:
fclose(out);
if (pidXwait(child_id, NULL))
- done(1);
+ exit(EX_SOFTWARE);
break;
}
}
scan_content(CT ct)
{
int len;
- int check8bit = 0, contains8bit = 0; /* check if contains 8bit data */
- int checklinelen = 0, linelen = 0; /* check for 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 */
+ int check8bit = 0, contains8bit = 0;
+ int checklinelen = 0, linelen = 0;
+ int checkboundary = 0, boundaryclash = 0;
+ int checklinespace = 0, linespace = 0; /* trailing whitespace */
unsigned char *cp = NULL, buffer[BUFSIZ];
struct text *t = NULL;
FILE *in = NULL;
case CT_TEXT:
check8bit = 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;
- checkboundary = 1;
break;
case CT_MESSAGE:
checkboundary = 1;
break;
+ case CT_APPLICATION:
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;
*/
if (check8bit || checklinelen || checklinespace || checkboundary) {
if ((in = fopen(ce->ce_file, "r")) == NULL)
- adios(ce->ce_file, "unable to open for reading");
+ adios(EX_IOERR, ce->ce_file, "unable to open for reading");
len = strlen(prefix);
while (fgets(buffer, sizeof(buffer) - 1, in)) {
- /*
- ** Check for 8bit data.
- */
if (check8bit) {
for (cp = buffer; *cp; cp++) {
if (!isascii(*cp)) {
}
}
- /*
- ** Check line length.
- */
if (checklinelen && (strlen(buffer) > CPERLIN + 1)) {
linelen = 1;
checklinelen = 0; /* no need to keep checking */
}
- /*
- ** Check if line ends with a space.
- */
if (checklinespace &&
(cp = buffer + strlen(buffer) - 2) >
buffer && isspace(*cp)) {
NULL);
} else {
t->tx_charset = CHARSET_USASCII;
- *ap = getcpy("charset=us-ascii");
+ *ap = mh_xstrdup("charset=us-ascii");
}
cp = strchr(*ap++, '=');
ct->c_encoding = CE_7BIT;
break;
- case CT_APPLICATION:
- /* For application type, use base64, except when postscript */
- if (contains8bit || linelen || linespace)
- ct->c_encoding = (ct->c_subtype ==
- APPLICATION_POSTSCRIPT) ?
- CE_QUOTED : CE_BASE64;
- else
- ct->c_encoding = CE_7BIT;
- break;
-
case CT_MESSAGE:
ct->c_encoding = CE_7BIT;
break;
+ case CT_APPLICATION:
case CT_AUDIO:
case CT_IMAGE:
case CT_VIDEO:
- /* For audio, image, and video contents, just use base64 */
+ /*
+ ** Forcing use of base64, because these types likely
+ ** contain binary data and NUL bytes. Don't care about
+ ** files that would be clean.
+ */
ct->c_encoding = CE_BASE64;
break;
}
ep = ci->ci_values;
snprintf(buffer, sizeof(buffer), "boundary=%s%d",
prefix, level++);
- cp = strchr(*ap++ = getcpy(buffer), '=');
+ cp = strchr(*ap++ = mh_xstrdup(buffer), '=');
*ap = NULL;
*cp++ = '\0';
*ep = cp;
/*
** output the content type and subtype
*/
- np = getcpy(TYPE_FIELD);
+ np = mh_xstrdup(TYPE_FIELD);
vp = concat(" ", ci->ci_type, "/", ci->ci_subtype, NULL);
/* keep track of length of line */
** output the Content-ID
*/
if (ct->c_id) {
- np = getcpy(ID_FIELD);
+ 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 = getcpy(DESCR_FIELD);
+ np = mh_xstrdup(DESCR_FIELD);
vp = concat(" ", ct->c_descr, NULL);
+ if (encode_rfc2047(DESCR_FIELD, &vp, NULL)) {
+ adios(EX_DATAERR, NULL, "Unable to encode %s header", DESCR_FIELD);
+ }
add_header(ct, np, vp);
}
** output the Content-Disposition
*/
if (ct->c_dispo) {
- np = getcpy(DISPO_FIELD);
+ np = mh_xstrdup(DISPO_FIELD);
vp = concat(" ", ct->c_dispo, NULL);
add_header(ct, np, vp);
}
case CE_8BIT:
if (ct->c_type == CT_MESSAGE)
- adios(NULL, "internal error, invalid encoding");
+ adios(EX_DATAERR, NULL, "internal error, invalid encoding");
- np = getcpy(ENCODING_FIELD);
+ 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");
+ adios(EX_DATAERR, NULL, "internal error, invalid encoding");
- np = getcpy(ENCODING_FIELD);
+ 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");
+ adios(EX_DATAERR, NULL, "internal error, invalid encoding");
- np = getcpy(ENCODING_FIELD);
+ 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");
+ adios(EX_DATAERR, NULL, "internal error, invalid encoding");
- np = getcpy(ENCODING_FIELD);
+ np = mh_xstrdup(ENCODING_FIELD);
vp = concat(" ", "binary", "\n", NULL);
add_header(ct, np, vp);
break;
default:
- adios(NULL, "unknown transfer encoding in content");
+ adios(EX_DATAERR, NULL, "unknown transfer encoding in content");
break;
}
projects / mmh / blobdiff