-/*
- * mhfixmsg.c -- rewrite a message with various transformations
+/* mhfixmsg.c -- rewrite a message with various transformations
*
* This code is Copyright (c) 2002 and 2013, by the authors of nmh.
* See the COPYRIGHT file in the root directory of the nmh
* distribution for complete copyright information.
*/
-#include <h/mh.h>
-#include <h/mime.h>
-#include <h/mhparse.h>
-#include <h/utils.h>
-#include <h/signals.h>
+#include "h/mh.h"
+#include "sbr/path.h"
+#include "sbr/print_version.h"
+#include "sbr/print_help.h"
+#include "sbr/error.h"
+#include "h/fmt_scan.h"
+#include "h/mime.h"
+#include "h/mhparse.h"
+#include "h/done.h"
+#include "h/utils.h"
+#include "h/signals.h"
+#include "sbr/m_maildir.h"
+#include "sbr/m_mktemp.h"
+#include "sbr/mime_type.h"
+#include "mhmisc.h"
+#include "mhfree.h"
+#include "mhoutsbr.h"
+#include "mhshowsbr.h"
#include <fcntl.h>
#define MHFIXMSG_SWITCHES \
#define quitser pipeser
-/* mhparse.c */
-extern int skip_mp_cte_check; /* flag to InitMultiPart */
-extern int suppress_bogus_mp_content_warning; /* flag to InitMultiPart */
-extern int bogus_mp_content; /* flag from InitMultiPart */
-/* flags to/from parse_header_attrs */
-extern int suppress_extraneous_trailing_semicolon_warning;
-
-/* mhoutsbr.c */
-int output_message_fp (CT, FILE *, char *);
-
-/* mhmisc.c */
-void flush_errors (void);
-
-/* mhfree.c */
-extern CT *cts;
-
/*
* static prototypes
*/
char *textcharset;
} fix_transformations;
-int mhfixmsgsbr (CT *, char *, const fix_transformations *, FILE **, char *,
- FILE **);
+static int mhfixmsgsbr (CT *, char *, const fix_transformations *,
+ FILE **, char *, FILE **);
static int fix_boundary (CT *, int *);
static int copy_input_to_output (const char *, FILE *, const char *, FILE *);
static int get_multipart_boundary (CT, char **);
static int content_encoding (CT, const char **);
static int strip_crs (CT, int *);
static void update_cte (CT);
-static int least_restrictive_encoding (CT);
+static int least_restrictive_encoding (CT) PURE;
static int less_restrictive (int, int);
static int convert_charsets (CT, char *, int *);
static int fix_always (CT, int *);
static int write_content (CT, const char *, char *, FILE *, int, int);
static void set_text_ctparams(CT, char *, int);
static int remove_file (const char *);
-static void report (char *, char *, char *, char *, ...);
+static void report (char *, char *, char *, char *, ...)
+ CHECK_PRINTF(4, 5);
static void pipeser (int);
int
-main (int argc, char **argv) {
+main (int argc, char **argv)
+{
int msgnum;
char *cp, *file = NULL, *folder = NULL;
char *maildir = NULL, buf[100], *outfile = NULL;
struct msgs *mp = NULL;
CT *ctp;
FILE *fp, *infp = NULL, *outfp = NULL;
- int using_stdin = 0;
- int chgflag = 1;
+ bool using_stdin = false;
+ bool chgflag = true;
int status = OK;
fix_transformations fx;
fx.reformat = fx.fixcompositecte = fx.fixboundary = 1;
fx.lf_line_endings = 0;
fx.textcharset = NULL;
- if (nmh_init(argv[0], 2)) { return 1; }
+ if (nmh_init(argv[0], true, false)) { return 1; }
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
ambigsw (cp, switches);
done (1);
case UNKWNSW:
- adios (NULL, "-%s unknown", cp);
+ die("-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof buf, "%s [+folder] [msgs] [switches]",
case DECODETEXTSW:
if (! (cp = *argp++) || *cp == '-') {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
if (! strcasecmp (cp, "8bit")) {
fx.decodetext = CE_8BIT;
} else if (! strcasecmp (cp, "binary")) {
fx.decodetext = CE_BINARY;
} else {
- adios (NULL, "invalid argument to %s", argp[-2]);
+ die("invalid argument to %s", argp[-2]);
}
continue;
case NDECODETEXTSW:
continue;
case DECODETYPESW:
if (! (cp = *argp++) || *cp == '-') {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
fx.decodetypes = cp;
continue;
continue;
case TEXTCHARSETSW:
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
fx.textcharset = cp;
continue;
continue;
case FIXTYPESW:
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
if (! strncasecmp (cp, "multipart/", 10) ||
- ! strncasecmp (cp, "message/", 8)) {
- adios (NULL, "-fixtype %s not allowed", cp);
- } else if (! strchr (cp, '/')) {
- adios (NULL, "-fixtype requires type/subtype");
- }
+ ! strncasecmp (cp, "message/", 8))
+ die("-fixtype %s not allowed", cp);
+ if (! strchr (cp, '/'))
+ die("-fixtype requires type/subtype");
if (fx.fixtypes == NULL) { fx.fixtypes = svector_create (10); }
svector_push_back (fx.fixtypes, cp);
continue;
continue;
case FILESW:
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
file = *cp == '-' ? mh_xstrdup (cp) : path (cp, TFILE);
continue;
case OUTFILESW:
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
outfile = *cp == '-' ? mh_xstrdup (cp) : path (cp, TFILE);
continue;
case RPROCSW:
if (!(rmmproc = *argp++) || *rmmproc == '-') {
- adios (NULL, "missing argument to %s", argp[-2]);
+ die("missing argument to %s", argp[-2]);
}
continue;
case NRPRCSW:
rmmproc = NULL;
continue;
case CHGSW:
- chgflag = 1;
+ chgflag = true;
continue;
case NCHGSW:
- chgflag = 0;
+ chgflag = false;
continue;
case VERBSW:
verbosw = 1;
}
}
if (*cp == '+' || *cp == '@') {
- if (folder) {
- adios (NULL, "only one folder at a time!");
- } else {
- folder = pluspath (cp);
- }
+ if (folder)
+ die("only one folder at a time!");
+ folder = pluspath (cp);
} else {
if (*cp == '/') {
/* Interpret a full path as a filename, not a message. */
* Read the standard profile setup
*/
if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
- readconfig ((struct node **) 0, fp, cp, 0);
+ readconfig(NULL, fp, cp, 0);
fclose (fp);
}
- suppress_bogus_mp_content_warning = skip_mp_cte_check = 1;
- suppress_extraneous_trailing_semicolon_warning = 1;
+ suppress_bogus_mp_content_warning = skip_mp_cte_check = true;
+ suppress_extraneous_trailing_semicolon_warning = true;
if (! context_find ("path")) {
free (path ("./", TFOLDER));
}
if (file && msgs.size) {
- adios (NULL, "cannot specify msg and file at same time!");
+ die("cannot specify msg and file at same time!");
}
if (outfile) {
int fd;
char *cp;
- using_stdin = 1;
+ using_stdin = true;
if ((cp = m_mktemp2 (NULL, invo_name, &fd, NULL)) == NULL) {
- adios (NULL, "unable to create temporary file in %s",
+ die("unable to create temporary file in %s",
get_temp_dir());
} else {
free (file);
if (close (fd)) {
(void) m_unlink (file);
- adios (NULL, "failed to write temporary file");
+ die("failed to write temporary file");
}
}
set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
*ctp++ = ct;
} else {
- advise (NULL, "unable to parse message from file %s", file);
+ inform("unable to parse message from file %s", file);
status = NOTOK;
/* If there's an outfile, pass the input message unchanged, so the
}
if (copy_input_to_output (file, infp, outfile, outfp) != OK) {
- advise (NULL, "unable to copy message to %s, "
+ inform("unable to copy message to %s, "
"it might be lost\n", outfile);
}
/* read folder and create message structure */
if (! (mp = folder_read (folder, 1))) {
- adios (NULL, "unable to read folder %s", folder);
+ die("unable to read folder %s", folder);
}
/* check for empty folder */
if (mp->nummsg == 0) {
- adios (NULL, "no messages in %s", folder);
+ die("no messages in %s", folder);
}
/* parse all the message ranges/sequences and set SELECTED */
set_text_ctparams(ct, fx.decodetypes, fx.lf_line_endings);
*ctp++ = ct;
} else {
- advise (NULL, "unable to parse message %s", msgnam);
+ inform("unable to parse message %s", msgnam);
status = NOTOK;
/* If there's an outfile, pass the input message
if (copy_input_to_output (input_filename, infp,
outfile, outfp) != OK) {
- advise (NULL,
- "unable to copy message to %s, "
- "it might be lost\n",
- outfile);
+ inform("unable to copy message to %s, "
+ "it might be lost\n", outfile);
}
fclose (infp);
if (*cts) {
for (ctp = cts; *ctp; ++ctp) {
- status += mhfixmsgsbr (ctp, maildir, &fx, &infp, outfile, &outfp);
+ status =
+ mhfixmsgsbr (ctp, maildir, &fx, &infp, outfile, &outfp) == OK
+ ? 0
+ : 1;
free_content (*ctp);
if (using_stdin) {
status = 1;
}
- mh_xfree(maildir);
+ free(maildir);
free (cts);
if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); }
free (folder);
free (arguments);
- done (status);
+ done (status == OK ? 0 : 1);
return NOTOK;
}
/*
* Apply transformations to one message.
*/
-int
+static int
mhfixmsgsbr (CT *ctp, char *maildir, const fix_transformations *fx,
- FILE **infp, char *outfile, FILE **outfp) {
+ FILE **infp, char *outfile, FILE **outfp)
+{
/* Store input filename in case one of the transformations, i.e.,
fix_boundary(), rewrites to a tmp file. */
char *input_filename = maildir
? concat (maildir, "/", (*ctp)->c_file, NULL)
: mh_xstrdup ((*ctp)->c_file);
- int modify_inplace = 0;
+ bool modify_inplace = false;
int message_mods = 0;
int status = OK;
}
if (outfile == NULL) {
- modify_inplace = 1;
+ modify_inplace = true;
if ((*ctp)->c_file) {
char *tempfile;
/* outfp will be closed by the caller */
if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, outfp)) ==
NULL) {
- adios (NULL, "unable to create temporary file in %s",
+ die("unable to create temporary file in %s",
get_temp_dir());
}
outfile = mh_xstrdup (tempfile);
} else {
- adios (NULL, "missing both input and output filenames\n");
+ die("missing both input and output filenames\n");
}
} /* else *outfp was defined by caller */
to the output. */
if (copy_input_to_output (input_filename, *infp, outfile,
*outfp) != OK) {
- advise (NULL, "unable to copy message to %s, it might be lost\n",
+ inform("unable to copy message to %s, it might be lost\n",
outfile);
}
}
*/
static int
copy_input_to_output (const char *input_filename, FILE *infp,
- const char *output_filename, FILE *outfp) {
+ const char *output_filename, FILE *outfp)
+{
int in = fileno (infp);
int out = fileno (outfp);
int status = OK;
* Fix mismatched outer level boundary.
*/
static int
-fix_boundary (CT *ct, int *message_mods) {
+fix_boundary (CT *ct, int *message_mods)
+{
struct multipart *mp;
int status = OK;
}
} else {
*ct = NULL;
- advise (NULL, "unable to parse fixed part");
+ inform("unable to parse fixed part");
status = NOTOK;
}
free (filename);
} else {
- advise (NULL, "unable to replace broken boundary");
+ inform("unable to replace broken boundary");
status = NOTOK;
}
} else {
- advise (NULL, "unable to create temporary file in %s",
+ inform("unable to create temporary file in %s",
get_temp_dir());
status = NOTOK;
}
* Find boundary at end of multipart.
*/
static int
-get_multipart_boundary (CT ct, char **part_boundary) {
+get_multipart_boundary (CT ct, char **part_boundary)
+{
char buffer[NMH_BUFSIZ];
char *end_boundary = NULL;
off_t begin = (off_t) ct->c_end > (off_t) (ct->c_begin + sizeof buffer)
}
}
- if (! end_boundary && begin > (off_t) (ct->c_begin + sizeof buffer)) {
- begin -= sizeof buffer;
- } else {
+ if (end_boundary || begin <= (off_t) (ct->c_begin + sizeof buffer))
break;
- }
+ begin -= sizeof buffer;
}
/* Get boundary at beginning of multipart. */
* Open and copy ct->c_file to file, replacing the multipart boundary.
*/
static int
-replace_boundary (CT ct, char *file, char *boundary) {
+replace_boundary (CT ct, char *file, char *boundary)
+{
FILE *fpin, *fpout;
int compnum, state;
char buf[NMH_BUFSIZ], name[NAMESZ];
char *np, *vp;
- m_getfld_state_t gstate = 0;
+ m_getfld_state_t gstate;
int status = OK;
if (ct->c_file == NULL) {
- advise (NULL, "missing input filename");
+ inform("missing input filename");
return NOTOK;
}
return NOTOK;
}
+ gstate = m_getfld_state_init(fpin);
for (compnum = 1;;) {
int bufsz = (int) sizeof buf;
- switch (state = m_getfld (&gstate, name, buf, &bufsz, fpin)) {
+ switch (state = m_getfld2(&gstate, name, buf, &bufsz)) {
case FLD:
case FLDPLUS:
compnum++;
/* if necessary, get rest of field */
while (state == FLDPLUS) {
bufsz = sizeof buf;
- state = m_getfld (&gstate, name, buf, &bufsz, fpin);
+ state = m_getfld2(&gstate, name, buf, &bufsz);
vp = add (buf, vp); /* add to previous value */
}
new_ctline = concat(" ", ct->c_ctinfo.ci_type, "/",
ct->c_ctinfo.ci_subtype, NULL);
- new_params = output_params(strlen(TYPE_FIELD) +
+ new_params = output_params(LEN(TYPE_FIELD) +
strlen(new_ctline) + 1,
ct->c_ctinfo.ci_first_pm, NULL, 0);
fprintf (fpout, "%s:%s%s\n", np, new_ctline,
- new_params ? new_params : "");
+ FENDNULL(new_params));
free(new_ctline);
- mh_xfree(new_params);
+ free(new_params);
}
free (vp);
case LENERR:
case FMTERR:
- advise (NULL, "message format error in component #%d", compnum);
+ inform("message format error in component #%d", compnum);
status = NOTOK;
break;
default:
- advise (NULL, "getfld() returned %d", state);
+ inform("getfld() returned %d", state);
status = NOTOK;
break;
}
* Fix Content-Type header to reflect the content of its part.
*/
static int
-fix_types (CT ct, svector_t fixtypes, int *message_mods) {
+fix_types (CT ct, svector_t fixtypes, int *message_mods)
+{
int status = OK;
switch (ct->c_type) {
*cp = '\0';
ct_subtype = mh_xstrdup(++cp);
} else {
- advise (NULL, "missing / in MIME type of %s %s",
+ inform("missing / in MIME type of %s %s",
ct->c_file, ct->c_partno);
free (ct_type);
return NOTOK;
ct->c_ctinfo.ci_subtype = ct_subtype;
if (! replace_substring (&ct->c_ctline, type,
ct_type_subtype)) {
- advise (NULL, "did not find %s in %s",
+ inform("did not find %s in %s",
type, ct->c_ctline);
}
type, ct_type_subtype);
}
break;
- } else {
- advise (NULL, "did not find %s in %s",
- type, hf->value);
}
+ inform("did not find %s in %s", type, hf->value);
}
}
}
* Replace a substring, allocating space to hold the new one.
*/
char *
-replace_substring (char **str, const char *old, const char *new) {
+replace_substring (char **str, const char *old, const char *new)
+{
char *cp;
if ((cp = strstr (*str, old))) {
* Remove a name=value parameter, given just its name, from a header value.
*/
char *
-remove_parameter (char *str, const char *name) {
+remove_parameter (char *str, const char *name)
+{
/* It looks to me, based on the BNF in RFC 2045, than there can't
- be whitespace betwwen the parameter name and the "=", or
+ be whitespace between the parameter name and the "=", or
between the "=" and the parameter value. */
char *param_name = concat (name, "=", NULL);
char *cp;
* 8 bit.
*/
static int
-fix_composite_cte (CT ct, int *message_mods) {
+fix_composite_cte (CT ct, int *message_mods)
+{
int status = OK;
if (ct->c_type == CT_MESSAGE || ct->c_type == CT_MULTIPART) {
for (hf = ct->c_first_hf; hf; hf = hf->next) {
char *name = hf->name;
- for (; *name && isspace ((unsigned char) *name); ++name) {
+ for (; isspace((unsigned char)*name); ++name) {
continue;
}
if (! strncasecmp (name, ENCODING_FIELD,
- strlen (ENCODING_FIELD))) {
+ LEN(ENCODING_FIELD))) {
char *prefix = "Nmh-REPLACED-INVALID-";
HF h;
* Set content encoding.
*/
static int
-set_ce (CT ct, int encoding) {
+set_ce (CT ct, int encoding)
+{
const char *ce = ce_str (encoding);
const struct str2init *ctinit = get_ce_method (ce);
if (ctinit) {
char *cte = concat (" ", ce, "\n", NULL);
- int found_cte = 0;
+ bool found_cte = false;
HF hf;
/* Decoded contents might be in ct->c_cefile.ce_file, if the
caller is decode_text_parts (). Save because we'll
/* Update/add Content-Transfer-Encoding header field. */
for (hf = ct->c_first_hf; hf; hf = hf->next) {
if (! strcasecmp (ENCODING_FIELD, hf->name)) {
- found_cte = 1;
+ found_cte = true;
free (hf->value);
hf->value = cte;
}
* Make sure each text part has a corresponding text/plain part.
*/
static int
-ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain) {
+ensure_text_plain (CT *ct, CT parent, int *message_mods, int replacetextplain)
+{
int status = OK;
switch ((*ct)->c_type) {
parent->c_ctinfo.ci_subtype = mh_xstrdup("alternative");
if (! replace_substring (&parent->c_ctline, "/related",
"/alternative")) {
- advise (NULL,
- "did not find multipart/related in %s",
- parent->c_ctline);
+ inform("did not find multipart/related in %s",
+ parent->c_ctline);
}
/* Update Content-Type header field. */
multipart/alternative. */
remove_parameter (hf->value, "type");
break;
- } else {
- advise (NULL, "did not find multipart/"
- "related in header %s",
- hf->value);
}
+ inform("did not find multipart/"
+ "related in header %s", hf->value);
}
}
} else {
*/
static int
find_textplain_sibling (CT parent, int replacetextplain,
- int *new_subpart_number) {
+ int *new_subpart_number)
+{
struct multipart *mp = (struct multipart *) parent->c_ctparams;
struct part *part, *prev;
- int has_text_plain = 0;
+ bool has_text_plain = false;
for (prev = part = mp->mp_parts; part; part = part->mp_next) {
++*new_subpart_number;
free_content (old_part->mp_part);
free (old_part);
} else {
- has_text_plain = 1;
+ has_text_plain = true;
}
break;
}
* Insert a new text/plain part.
*/
static int
-insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent) {
+insert_new_text_plain_part (CT ct, int new_subpart_number, CT parent)
+{
struct multipart *mp = (struct multipart *) parent->c_ctparams;
struct part *new_part;
* Create a text/plain part to go along with non-plain sibling part.
*/
static CT
-build_text_plain_part (CT encoded_part) {
+build_text_plain_part (CT encoded_part)
+{
CT tp_part = divide_part (encoded_part);
char *tmp_plain_file = NULL;
/* This m_mktemp2() call closes the temp file. */
if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
- advise (NULL, "unable to create temporary file in %s",
+ inform("unable to create temporary file in %s",
get_temp_dir());
} else {
tmp_plain_file = mh_xstrdup (tempfile);
* Slip new text/plain part into a new multipart/alternative.
*/
static int
-insert_into_new_mp_alt (CT *ct, int *message_mods) {
+insert_into_new_mp_alt (CT *ct, int *message_mods)
+{
CT tp_part = build_text_plain_part (*ct);
int status = OK;
* Clone a MIME part.
*/
static CT
-divide_part (CT ct) {
+divide_part (CT ct)
+{
CT new_part;
NEW0(new_part);
* Copy the content info from one part to another.
*/
static void
-copy_ctinfo (CI dest, CI src) {
+copy_ctinfo (CI dest, CI src)
+{
PM s_pm, d_pm;
dest->ci_type = src->ci_type ? mh_xstrdup (src->ci_type) : NULL;
* Decode content.
*/
static int
-decode_part (CT ct) {
+decode_part (CT ct)
+{
char *tmp_decoded;
int status;
FILE *file;
char *tempfile;
if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, &file)) == NULL) {
- adios (NULL, "unable to create temporary file in %s", get_temp_dir());
+ die("unable to create temporary file in %s", get_temp_dir());
}
tmp_decoded = mh_xstrdup (tempfile);
/* The following call will load ct->c_cefile.ce_file with the tmp
(void) m_unlink (tmp_decoded);
free (tmp_decoded);
if (fclose (file)) {
- admonish (NULL, "unable to close temporary file %s", tempfile);
+ inform("unable to close temporary file %s, continuing...", tempfile);
}
return status;
* be in the future for other than text types.
*/
static int
-reformat_part (CT ct, char *file, char *type, char *subtype, int c_type) {
+reformat_part (CT ct, char *file, char *type, char *subtype, int c_type)
+{
int output_subtype, output_encoding;
const char *reason = NULL;
char *cp, *cf;
/* Check for invo_name-format-type/subtype. */
if ((cf = context_find_by_type ("format", type, subtype)) == NULL) {
if (verbosw) {
- advise (NULL, "Don't know how to convert %s, there is no "
+ inform("Don't know how to convert %s, there is no "
"%s-format-%s/%s profile entry",
ct->c_file, invo_name, type, subtype);
}
return NOTOK;
}
if (strchr (cf, '>')) {
- advise (NULL, "'>' prohibited in \"%s\",\nplease fix your "
+ inform("'>' prohibited in \"%s\",\nplease fix your "
"%s-format-%s/%s profile entry", cf, invo_name, type,
- subtype ? subtype : "");
+ FENDNULL(subtype));
return NOTOK;
}
* Fill in a multipart/alternative part.
*/
static CT
-build_multipart_alt (CT first_alt, CT new_part, int type, int subtype) {
+build_multipart_alt (CT first_alt, CT new_part, int type, int subtype)
+{
char *boundary_prefix = "----=_nmh-multipart";
char *boundary = concat (boundary_prefix, first_alt->c_partno, NULL);
char *boundary_indicator = "; boundary=";
boundary_in_content (&new_part->c_cefile.ce_fp,
new_part->c_cefile.ce_file,
boundary)) == NOTOK) {
- free_content (ct);
- return NULL;
+ goto return_null;
}
}
boundary_in_content (&new_part->c_fp,
new_part->c_file,
boundary)) == NOTOK) {
- free_content (ct);
- return NULL;
+ goto return_null;
}
}
snprintf (buffer2, sizeof buffer2, "%d", serial);
boundary =
concat (boundary_prefix,
- first_alt->c_partno ? first_alt->c_partno : "",
+ FENDNULL(first_alt->c_partno),
"-", buffer2, NULL);
}
}
if (found_boundary) {
- advise (NULL, "giving up trying to find a unique boundary");
- free_content (ct);
- return NULL;
+ inform("giving up trying to find a unique boundary");
+ goto return_null;
}
}
free (boundary);
return ct;
+
+return_null:
+ free_content(ct);
+ free(boundary);
+ return NULL;
}
* Check that the boundary does not appear in the content.
*/
static int
-boundary_in_content (FILE **fp, char *file, const char *boundary) {
+boundary_in_content (FILE **fp, char *file, const char *boundary)
+{
char buffer[NMH_BUFSIZ];
size_t bytes_read;
- int found_boundary = 0;
+ bool found_boundary = false;
/* free_content() will close *fp if we fopen it here. */
if (! *fp && (*fp = fopen (file, "r")) == NULL) {
fseeko (*fp, 0L, SEEK_SET);
while ((bytes_read = fread (buffer, 1, sizeof buffer, *fp)) > 0) {
if (find_str (buffer, bytes_read, boundary)) {
- found_boundary = 1;
+ found_boundary = true;
break;
}
}
* Remove all non-Content headers.
*/
static void
-transfer_noncontent_headers (CT old, CT new) {
+transfer_noncontent_headers (CT old, CT new)
+{
HF hp, hp_prev;
hp_prev = hp = old->c_first_hf;
while (hp) {
HF next = hp->next;
- if (strncasecmp (XXX_FIELD_PRF, hp->name, strlen (XXX_FIELD_PRF))) {
+ if (strncasecmp (XXX_FIELD_PRF, hp->name, LEN(XXX_FIELD_PRF))) {
if (hp == old->c_last_hf) {
if (hp == old->c_first_hf) {
old->c_last_hf = old->c_first_hf = NULL;
* Set content type.
*/
static int
-set_ct_type (CT ct, int type, int subtype, int encoding) {
+set_ct_type (CT ct, int type, int subtype, int encoding)
+{
char *typename = ct_type_str (type);
char *subtypename = ct_subtype_str (type, subtype);
/* E.g, " text/plain" */
char *type_subtypename = concat (" ", typename, "/", subtypename, NULL);
/* E.g, " text/plain\n" */
char *name_plus_nl = concat (type_subtypename, "\n", NULL);
- int found_content_type = 0;
+ bool found_content_type = false;
HF hf;
const char *cp = NULL;
char *ctline;
/* Update/add Content-Type header field. */
for (hf = ct->c_first_hf; hf; hf = hf->next) {
if (! strcasecmp (TYPE_FIELD, hf->name)) {
- found_content_type = 1;
+ found_content_type = true;
free (hf->value);
hf->value = (cp = strchr (ct->c_ctline, ';'))
? concat (type_subtypename, cp, "\n", NULL)
*/
static int
decode_text_parts (CT ct, int encoding, const char *decodetypes,
- int *message_mods) {
+ int *message_mods)
+{
int status = OK;
int lf_line_endings = 0;
report (NULL, ct->c_partno, ct->c_file,
"will not decode%s because it is binary (%s)",
ct->c_partno ? ""
- : ct->c_ctline ? ct->c_ctline
- : "",
+ : (FENDNULL(ct->c_ctline)),
reason);
}
(void) m_unlink (ct->c_cefile.ce_file);
report (NULL, ct->c_partno, ct->c_file,
"will not decode%s because it is 8bit",
ct->c_partno ? ""
- : ct->c_ctline ? ct->c_ctline
- : "");
+ : (FENDNULL(ct->c_ctline)));
}
(void) m_unlink (ct->c_cefile.ce_file);
free (ct->c_cefile.ce_file);
++*message_mods;
if (verbosw) {
report (NULL, ct->c_partno, ct->c_file, "decode%s",
- ct->c_ctline ? ct->c_ctline : "");
+ FENDNULL(ct->c_ctline));
}
if (lf_line_endings) {
strip_crs (ct, message_mods);
* decodetypes (which came from the -decodetypes switch).
*/
static int
-should_decode(const char *decodetypes, const char *type, const char *subtype) {
+should_decode(const char *decodetypes, const char *type, const char *subtype)
+{
/* Quick search for matching type[/subtype] in decodetypes: bracket
decodetypes with commas, then search for ,type, and ,type/subtype, in
it. */
- int found_match = 0;
+ bool found_match = false;
char *delimited_decodetypes = concat(",", decodetypes, ",", NULL);
char *delimited_type = concat(",", type, ",", NULL);
if (nmh_strcasestr(delimited_decodetypes, delimited_type)) {
- found_match = 1;
+ found_match = true;
} else if (subtype != NULL) {
char *delimited_type_subtype =
concat(",", type, "/", subtype, ",", NULL);
if (nmh_strcasestr(delimited_decodetypes, delimited_type_subtype)) {
- found_match = 1;
+ found_match = true;
}
free(delimited_type_subtype);
}
* to a string explaining why.
*/
static int
-content_encoding (CT ct, const char **reason) {
+content_encoding (CT ct, const char **reason)
+{
CE ce = &ct->c_cefile;
int encoding = CE_7BIT;
*reason = "";
}
break;
- } else if (*cp == '\n') {
+ }
+ if (*cp == '\n') {
line_len = 0;
} else if (! isascii ((unsigned char) *cp)) {
encoding = CE_8BIT;
}
- last_char_was_cr = *cp == '\r' ? 1 : 0;
+ last_char_was_cr = *cp == '\r';
}
}
* Strip carriage returns from content.
*/
static int
-strip_crs (CT ct, int *message_mods) {
+strip_crs (CT ct, int *message_mods)
+{
char *charset = content_charset (ct);
int status = OK;
FILE **fp = NULL;
size_t begin;
size_t end;
- int has_crs = 0;
- int opened_input_file = 0;
+ bool has_crs = false;
+ bool opened_input_file = false;
if (ct->c_cefile.ce_file) {
file = &ct->c_cefile.ce_file;
advise (*file, "unable to open for reading");
status = NOTOK;
} else {
- opened_input_file = 1;
+ opened_input_file = true;
}
}
}
modify the content. */
char *cp;
size_t i;
- int last_char_was_cr = 0;
+ bool last_char_was_cr = false;
if (end > 0) { bytes_to_read -= bytes_read; }
for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
if (*cp == '\n' && last_char_was_cr) {
- has_crs = 1;
+ has_crs = true;
break;
}
- last_char_was_cr = *cp == '\r' ? 1 : 0;
+ last_char_was_cr = *cp == '\r';
}
}
char *tempfile = m_mktemp2 (NULL, invo_name, &fd, NULL);
if (tempfile == NULL) {
- adios (NULL, "unable to create temporary file in %s",
+ die("unable to create temporary file in %s",
get_temp_dir());
}
stripped_content_file = mh_xstrdup (tempfile);
0) {
char *cp;
size_t i;
- int last_char_was_cr = 0;
+ bool last_char_was_cr = false;
for (i = 0, cp = buffer; i < bytes_read; ++i, ++cp) {
if (*cp == '\r') {
- last_char_was_cr = 1;
+ last_char_was_cr = true;
} else if (last_char_was_cr) {
if (*cp != '\n') {
if (write (fd, "\r", 1) < 0) {
if (write (fd, cp, 1) < 0) {
advise (tempfile, "write");
}
- last_char_was_cr = 0;
+ last_char_was_cr = false;
} else {
if (write (fd, cp, 1) < 0) {
advise (tempfile, "write");
}
- last_char_was_cr = 0;
+ last_char_was_cr = false;
}
}
}
if (close (fd)) {
- admonish (NULL, "unable to write temporary file %s",
+ inform("unable to write temporary file %s, continuing...",
stripped_content_file);
(void) m_unlink (stripped_content_file);
+ free(stripped_content_file);
status = NOTOK;
} else {
/* Replace the decoded file with the converted one. */
if (ct->c_cefile.ce_file && ct->c_cefile.ce_unlink)
(void) m_unlink (ct->c_cefile.ce_file);
- mh_xfree(ct->c_cefile.ce_file);
+ free(ct->c_cefile.ce_file);
ct->c_cefile.ce_file = stripped_content_file;
ct->c_cefile.ce_unlink = 1;
* of the part C-T-E's.
*/
static void
-update_cte (CT ct) {
+update_cte (CT ct)
+{
const int least_restrictive_enc = least_restrictive_encoding (ct);
if (least_restrictive_enc != CE_UNKNOWN &&
least_restrictive_enc != CE_7BIT) {
char *cte = concat (" ", ce_str (least_restrictive_enc), "\n", NULL);
HF hf;
- int found_cte = 0;
+ bool found_cte = false;
/* Update/add Content-Transfer-Encoding header field. */
for (hf = ct->c_first_hf; hf; hf = hf->next) {
if (! strcasecmp (ENCODING_FIELD, hf->name)) {
- found_cte = 1;
+ found_cte = true;
free (hf->value);
hf->value = cte;
}
* within a message.
*/
static int
-least_restrictive_encoding (CT ct) {
+least_restrictive_encoding (CT ct)
+{
int encoding = CE_UNKNOWN;
switch (ct->c_type) {
* CE_8BIT is less restrictive than CE_7BIT.
*/
static int
-less_restrictive (int encoding, int second_encoding) {
+less_restrictive (int encoding, int second_encoding)
+{
switch (second_encoding) {
case CE_BINARY:
return encoding != CE_BINARY;
* Convert character set of each part.
*/
static int
-convert_charsets (CT ct, char *dest_charset, int *message_mods) {
+convert_charsets (CT ct, char *dest_charset, int *message_mods)
+{
int status = OK;
switch (ct->c_type) {
* headers, respectively.
*/
static int
-fix_always (CT ct, int *message_mods) {
+fix_always (CT ct, int *message_mods)
+{
int status = OK;
switch (ct->c_type) {
* Factor out common code for loops in fix_filename_encoding().
*/
static int
-fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm) {
- int fixed = 0;
+fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm)
+{
+ bool fixed = false;
if (has_prefix(value, "=?") && has_suffix(value, "?=")) {
/* Looks like an RFC 2047 encoded parameter. */
if (decode_rfc2047 (value, decoded, sizeof decoded)) {
/* Encode using RFC 2231. */
replace_param (first_pm, last_pm, name, decoded, 0);
- fixed = 1;
+ fixed = true;
} else {
- advise (NULL, "failed to decode %s parameter %s", name, value);
+ inform("failed to decode %s parameter %s", name, value);
}
}
* headers, respectively.
*/
static int
-fix_filename_encoding (CT ct) {
+fix_filename_encoding (CT ct)
+{
PM pm;
HF hf;
int fixed = 0;
free((void *)new_params); /* Cast away const. Sigh. */
free((void *)params);
} else {
- advise (NULL, "did not find semicolon in %s:%s\n",
+ inform("did not find semicolon in %s:%s\n",
hf->name, hf->value);
}
}
*/
static int
write_content (CT ct, const char *input_filename, char *outfile, FILE *outfp,
- int modify_inplace, int message_mods) {
+ int modify_inplace, int message_mods)
+{
int status = OK;
if (modify_inplace) {
expand filename to absolute path. */
int file = ct->c_file && ct->c_file[0] == '/';
- admonish (NULL, "unable to rename %s %s to %s",
+ inform("unable to rename %s %s to %s, continuing...",
file ? "file" : "message", outfile,
infile);
status = NOTOK;
}
}
} else {
- admonish (NULL, "unable to remove input file %s, "
- "not modifying it", infile);
+ inform("unable to remove input file %s, "
+ "not modifying it, continuing...", infile);
(void) m_unlink (outfile);
status = NOTOK;
}
* function to do it. It touches the parts the decodetypes identifies.
*/
static void
-set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings) {
+set_text_ctparams(CT ct, char *decodetypes, int lf_line_endings)
+{
switch (ct->c_type) {
case CT_MULTIPART: {
struct multipart *m = (struct multipart *) ct->c_ctparams;
* use the standard MH backup file.
*/
static int
-remove_file (const char *file) {
+remove_file (const char *file)
+{
if (rmmproc) {
char *rmm_command = concat (rmmproc, " ", file, NULL);
int status = system (rmm_command);
* Output formatted message to user.
*/
static void
-report (char *what, char *partno, char *filename, char *message, ...) {
+report (char *what, char *partno, char *filename, char *message, ...)
+{
va_list args;
char *fmt;
if (verbosw) {
va_start (args, message);
fmt = concat (filename, partno ? " part " : ", ",
- partno ? partno : "", partno ? ", " : "", message, NULL);
+ FENDNULL(partno), partno ? ", " : "", message, NULL);
advertise (what, NULL, fmt, args);
projects / nmh / blobdiff