* streamlining and removal of unneeded code.
*/
-#include <h/mh.h>
+#include "h/mh.h"
+#include "sbr/m_gmprot.h"
+#include "sbr/m_getfld.h"
+#include "sbr/concat.h"
+#include "sbr/r1bindex.h"
+#include "sbr/encode_rfc2047.h"
+#include "sbr/copyip.h"
+#include "sbr/cpydata.h"
+#include "sbr/trimcpy.h"
+#include "sbr/uprf.h"
+#include "sbr/check_charset.h"
+#include "sbr/getcpy.h"
+#include "sbr/m_convert.h"
+#include "sbr/getfolder.h"
+#include "sbr/folder_read.h"
+#include "sbr/folder_free.h"
+#include "sbr/context_find.h"
+#include "sbr/brkstring.h"
+#include "sbr/pidstatus.h"
+#include "sbr/path.h"
+#include "sbr/error.h"
#include <fcntl.h>
-#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/utils.h>
+#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 "sbr/m_mktemp.h"
+#include "sbr/message_id.h"
+#include "sbr/mime_type.h"
#include "mhfree.h"
#include "mhshowsbr.h"
extern int debugsw;
-extern int listsw;
-extern int rfc934sw;
-extern int contentidsw;
+extern bool listsw;
+extern bool rfc934sw;
+extern bool contentidsw;
static char prefix[] = "----- =_aaaaaaaaaa";
static unsigned char directives_stack[32];
static unsigned int directives_index;
-static int do_direct(void)
+static int
+do_direct(void)
{
return directives_stack[directives_index];
}
-static void directive_onoff(int onoff)
+static void
+directive_onoff(int onoff)
{
if (directives_index >= sizeof(directives_stack) - 1) {
fprintf(stderr, "mhbuild: #on/off overflow, continuing\n");
directives_stack[++directives_index] = onoff;
}
-static void directive_init(int onoff)
+static void
+directive_init(int onoff)
{
directives_index = 0;
directives_stack[0] = onoff;
}
-static void directive_pop(void)
+static void
+directive_pop(void)
{
if (directives_index > 0)
directives_index--;
free (ct);
return NULL;
}
- 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 (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 = mh_xstrdup(filename);
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 = mh_xstrdup(argstring);
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);
}
}
}
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); }
/* 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);
+ die("failed to parse %s", convert_head->filename);
}
expand_pseudoheaders (cts[0], m, infile, convert_head);
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.
(*cp)++;
} else {
if (*++cp == 0)
- adios (NULL, "giving up trying to find a unique delimiter string");
+ die("giving up trying to find a unique delimiter string");
(*cp)++;
}
}
*/
if (!do_direct() || buf[0] != '#' || buf[1] == '#' || buf[1] == '<') {
int headers;
- int inlineD;
+ bool inlineD;
long pos;
char content[BUFSIZ];
FILE *out;
if (do_direct() && (buf[0] == '#' && buf[1] == '<')) {
strncpy (content, buf + 2, sizeof(content));
- inlineD = 1;
+ inlineD = true;
goto rock_and_roll;
}
- inlineD = 0;
+ inlineD = false;
/* the directive is implicit */
strncpy (content, "text/plain", sizeof(content));
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:
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:
}
/* 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;
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);
+ die("empty pipe command for #%s directive", ci->ci_type);
cp = mh_xstrdup(cp);
free (ci->ci_magic);
ci->ci_magic = cp;
}
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");
+ die("only one folder per #forw directive");
folder = pluspath (cp);
}
}
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 != '@')
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)
/*
* Unknown directive
*/
- adios (NULL, "unknown directive \"#%s\"", ci->ci_type);
+ die("unknown directive \"#%s\"", ci->ci_type);
return NOTOK; /* NOT REACHED */
}
* 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;
}
}
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",
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;
+ 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;
if (ct->c_type == CT_TEXT) {
t = (struct text *) ct->c_ctparams;
if (t->tx_charset == CHARSET_UNSPECIFIED) {
- checknul = 1;
+ checknul = true;
}
- check8bit = 1;
+ 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;
}
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);
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);
np = output_params(len, ct->c_dispo_first, NULL, 0);
vp = add(np, vp);
vp = add("\n", vp);
- mh_xfree(np);
+ free(np);
add_header (ct, mh_xstrdup(DISPO_FIELD), vp);
}
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 = mh_xstrdup(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");
+ die("internal error, invalid encoding");
np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "base64", "\n", NULL);
case CE_BINARY:
if (ct->c_type == CT_MESSAGE)
- adios (NULL, "internal error, invalid encoding");
+ die("internal error, invalid encoding");
np = mh_xstrdup(ENCODING_FIELD);
vp = concat (" ", "binary", "\n", NULL);
break;
default:
- adios (NULL, "unknown transfer encoding in content");
+ die("unknown transfer encoding in content");
break;
}
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);
}
/*
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");
/* FALLTHRU */
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);
+ free(pm->pm_value);
pm->pm_value = mh_xstrdup(simplename);
break;
}
* 'attachment'.
*/
void
-set_disposition (CT ct) {
+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);
* -1: ignore content and use user's locale to determine charset
*/
void
-set_charset (CT ct, int contains8bit) {
+set_charset (CT ct, int contains8bit)
+{
if (ct->c_type == CT_TEXT) {
struct text *t;
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");
}
*/
void
expand_pseudoheaders (CT ct, struct multipart *m, const char *infile,
- const convert_list *convert_head) {
+ 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. */
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;
}
}
void
expand_pseudoheader (CT ct, CT *text_plain_ct, struct multipart *m,
const char *infile, const char *type,
- const char *argstring) {
+ const char *argstring)
+{
char *reply_file;
FILE *reply_fp = NULL;
char *convert, *type_p, *subtype_p;
/* Extract any Content-Type header from beginning of convert output. */
int
-extract_headers (CT ct, char *reply_file, FILE **reply_fp) {
+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[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->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