#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>
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;
}
/* 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);
+ }
}
/*
/* open the composition draft */
if ((in = fopen(infile, "r")) == NULL)
- adios(infile, "unable to open for reading");
+ 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");
+ adios(EX_OSERR, NULL, "out of memory");
/*
** Allocate structure for handling decoded content
/* abort if draft has Mime-Version header field */
if (!mh_strcasecmp(name, VRSN_FIELD))
- adios(NULL, "draft shouldn't contain %s: field", 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);
+ 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)) {
/* else fall... */
case FILEEOF:
- adios(NULL, "draft has empty body -- no directives!");
+ adios(EX_CONFIG, NULL, "draft has empty body -- no directives!");
/* NOTREACHED */
case BODY:
case LENERR:
case FMTERR:
- adios(NULL, "message format error in component #%d",
+ 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;
}
** 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);
if ((m = (struct multipart *) calloc(1, sizeof(*m))) == NULL)
- adios(NULL, "out of memory");
+ adios(EX_OSERR, NULL, "out of memory");
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
continue;
if ((part = (struct part *) calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ adios(EX_OSERR, NULL, "out of memory");
*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");
+ adios(EX_OSERR, NULL, "out of memory");
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");
+ adios(EX_OSERR, NULL, "out of memory");
*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);
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);
+ adios(EX_DATAERR, NULL, "empty pipe command for #%s directive", ci->ci_type);
cp = getcpy(cp);
free(ci->ci_magic);
ci->ci_magic = cp;
/* 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);
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 = getcpy(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);
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");
+ adios(EX_OSERR, NULL, "out of memory");
ct->c_ctparams = (void *) m;
pp = &m->mp_parts;
if ((p = (CT) calloc(1, sizeof(*p)))
== NULL)
- adios(NULL, "out of memory");
+ adios(EX_OSERR, NULL, "out of memory");
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;
pe->ce_file = getcpy(buffer);
if ((part = (struct part *) calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ adios(EX_OSERR, NULL, "out of memory");
*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;
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");
+ adios(EX_OSERR, NULL, "out of memory");
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)
if ((part = (struct part *)
calloc(1, sizeof(*part))) == NULL)
- adios(NULL, "out of memory");
+ adios(EX_OSERR, NULL, "out of memory");
*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 */
}
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_unlink = 1;
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;
}
break;
- case CT_APPLICATION:
- check8bit = 1;
- checklinelen = 1;
- checklinespace = 1;
- checkboundary = 1;
- break;
-
case CT_MESSAGE:
check8bit = 0;
checklinelen = 0;
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)) {
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;
}
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);
vp = concat(" ", "8bit", "\n", NULL);
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);
vp = concat(" ", "quoted-printable", "\n", NULL);
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);
vp = concat(" ", "base64", "\n", NULL);
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);
vp = concat(" ", "binary", "\n", NULL);
break;
default:
- adios(NULL, "unknown transfer encoding in content");
+ adios(EX_DATAERR, NULL, "unknown transfer encoding in content");
break;
}