-/*
- * 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
*/
#include <h/mh.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 (CT, 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 *, char *);
+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 *, const char *);
+static int copy_input_to_output (const char *, FILE *, const char *, FILE *);
static int get_multipart_boundary (CT, char **);
static int replace_boundary (CT, char *, char *);
static int fix_types (CT, svector_t, int *);
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 fix_filename_param (char *, char *, PM *, PM *);
static int fix_filename_encoding (CT);
-static int write_content (CT, const char *, char *, int, 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);
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp = NULL;
CT *ctp;
- FILE *fp;
+ FILE *fp, *infp = NULL, *outfp = NULL;
int using_stdin = 0;
int chgflag = 1;
int status = OK;
adios (NULL, "missing argument to %s", argp[-2]);
}
if (! strncasecmp (cp, "multipart/", 10) ||
- ! strncasecmp (cp, "message/", 8)) {
+ ! strncasecmp (cp, "message/", 8))
adios (NULL, "-fixtype %s not allowed", cp);
- } else if (! strchr (cp, '/')) {
+ if (! strchr (cp, '/'))
adios (NULL, "-fixtype requires type/subtype");
- }
if (fx.fixtypes == NULL) { fx.fixtypes = svector_create (10); }
svector_push_back (fx.fixtypes, cp);
continue;
if (! (cp = *argp++) || (*cp == '-' && cp[1])) {
adios (NULL, "missing argument to %s", argp[-2]);
}
- file = *cp == '-' ? add (cp, NULL) : path (cp, TFILE);
+ 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]);
}
- outfile = *cp == '-' ? add (cp, NULL) : path (cp, TFILE);
+ outfile = *cp == '-' ? mh_xstrdup (cp) : path (cp, TFILE);
continue;
case RPROCSW:
if (!(rmmproc = *argp++) || *rmmproc == '-') {
}
}
if (*cp == '+' || *cp == '@') {
- if (folder) {
+ if (folder)
adios (NULL, "only one folder at a time!");
- } else {
- folder = pluspath (cp);
- }
+ folder = pluspath (cp);
} else {
if (*cp == '/') {
/* Interpret a full path as a filename, not a message. */
- file = add (cp, NULL);
+ file = mh_xstrdup (cp);
} else {
app_msgarg (&msgs, cp);
}
* 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));
adios (NULL, "cannot specify msg and file at same time!");
}
+ if (outfile) {
+ /* Open the outfile now, so we don't have to risk opening it
+ after running out of fds. */
+ if (strcmp (outfile, "-") == 0) {
+ outfp = stdout;
+ } else if ((outfp = fopen (outfile, "w")) == NULL) {
+ adios (outfile, "unable to open for writing");
+ }
+ }
+
/*
* check if message is coming from file
*/
get_temp_dir());
} else {
free (file);
- file = add (cp, NULL);
+ file = mh_xstrdup (cp);
cpydata (STDIN_FILENO, fd, "-", 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 message won't
- get dropped from a pipeline. */
+ /* If there's an outfile, pass the input message unchanged, so the
+ message won't get dropped from a pipeline. */
if (outfile) {
- /* Something went wrong. Output might be expected, such as if this were run
- as a filter. Just copy the input to the output. */
- if (copy_input_to_output (file, outfile) != OK) {
- advise (NULL, "unable to copy message to %s, it might be lost\n", outfile);
+ /* Something went wrong. Output might be expected, such as if
+ this were run as a filter. Just copy the input to the
+ output. */
+ if ((infp = fopen (file, "r")) == NULL) {
+ adios (file, "unable to open for reading");
}
+
+ if (copy_input_to_output (file, infp, outfile, outfp) != OK) {
+ inform("unable to copy message to %s, "
+ "it might be lost\n", outfile);
+ }
+
+ fclose (infp);
+ infp = NULL;
}
}
} else {
if (! folder) {
folder = getfolder (1);
}
- maildir = m_maildir (folder);
+ maildir = mh_xstrdup(m_maildir (folder));
/* chdir so that error messages, esp. from MIME parser, just
refer to the message and not its path. */
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
char *input_filename =
concat (maildir, "/", msgnam, NULL);
- if (copy_input_to_output (input_filename, outfile) != OK) {
- advise (NULL,
- "unable to copy message to %s, it might be lost\n",
- outfile);
+ if ((infp = fopen (input_filename, "r")) == NULL) {
+ adios (input_filename,
+ "unable to open for reading");
+ }
+
+ if (copy_input_to_output (input_filename, infp,
+ outfile, outfp) != OK) {
+ inform("unable to copy message to %s, "
+ "it might be lost\n", outfile);
}
+
+ fclose (infp);
+ infp = NULL;
free (input_filename);
}
}
if (*cts) {
for (ctp = cts; *ctp; ++ctp) {
- status += mhfixmsgsbr (ctp, maildir, &fx, outfile);
+ status =
+ mhfixmsgsbr (ctp, maildir, &fx, &infp, outfile, &outfp) == OK
+ ? 0
+ : 1;
free_content (*ctp);
if (using_stdin) {
status = 1;
}
+ free(maildir);
free (cts);
if (fx.fixtypes != NULL) { svector_free (fx.fixtypes); }
+ if (infp) { fclose (infp); } /* even if stdin */
+ if (outfp) { fclose (outfp); } /* even if stdout */
free (outfile);
free (file);
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,
- char *outfile) {
+ 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)
- : add ((*ctp)->c_file, NULL);
+ : mh_xstrdup ((*ctp)->c_file);
int modify_inplace = 0;
int message_mods = 0;
int status = OK;
+ /* Though the input file won't need to be opened if everything goes
+ well, do it here just in case there's a failure, and that failure is
+ running out of file descriptors. */
+ if ((*infp = fopen (input_filename, "r")) == NULL) {
+ adios (input_filename, "unable to open for reading");
+ }
+
if (outfile == NULL) {
modify_inplace = 1;
if ((*ctp)->c_file) {
char *tempfile;
- if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
+ /* 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",
get_temp_dir());
}
- outfile = add (tempfile, NULL);
+ outfile = mh_xstrdup (tempfile);
} else {
adios (NULL, "missing both input and output filenames\n");
}
- }
+ } /* else *outfp was defined by caller */
reverse_alternative_parts (*ctp);
status = fix_always (*ctp, &message_mods);
* Write the content to a file
*/
if (status == OK) {
- status = write_content (*ctp, input_filename, outfile, modify_inplace,
- message_mods);
+ status = write_content (*ctp, input_filename, outfile, *outfp,
+ modify_inplace, message_mods);
} else if (! modify_inplace) {
/* Something went wrong. Output might be expected, such
as if this were run as a filter. Just copy the input
to the output. */
- if (copy_input_to_output (input_filename, outfile) != OK) {
- advise (NULL, "unable to copy message to %s, it might be lost\n", outfile);
+ if (copy_input_to_output (input_filename, *infp, outfile,
+ *outfp) != OK) {
+ inform("unable to copy message to %s, it might be lost\n",
+ outfile);
}
}
outfile = NULL;
}
+ fclose (*infp);
+ *infp = NULL;
free (input_filename);
return status;
* might be running as part of a pipeline.
*/
static int
-copy_input_to_output (const char *input_filename, const char *output_filename) {
- int in = open (input_filename, O_RDONLY);
- int out = strcmp (output_filename, "-")
- ? open (output_filename, O_WRONLY | O_CREAT, m_gmprot ())
- : STDOUT_FILENO;
+copy_input_to_output (const char *input_filename, FILE *infp,
+ const char *output_filename, FILE *outfp) {
+ int in = fileno (infp);
+ int out = fileno (outfp);
int status = OK;
if (in != -1 && out != -1) {
status = NOTOK;
}
- close (out);
- close (in);
-
return status;
}
if ((fixed = m_mktemp2 (NULL, invo_name, NULL, &(*ct)->c_fp))) {
if (replace_boundary (*ct, fixed, part_boundary) == OK) {
- char *filename = add ((*ct)->c_file, NULL);
+ char *filename = mh_xstrdup ((*ct)->c_file);
CT fixed_ct;
free_content (*ct);
}
} 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;
}
if ((end = rfind_str (buffer, cp - buffer, "\n"))) {
if (strlen (end) > 3 && *end++ == '\n' &&
*end++ == '-' && *end++ == '-') {
- end_boundary = add (end, NULL);
+ end_boundary = mh_xstrdup (end);
break;
}
}
}
}
- 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. */
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++;
/* get copies of the buffers */
- np = add (name, NULL);
- vp = add (buf, NULL);
+ np = mh_xstrdup (name);
+ vp = mh_xstrdup (buf);
/* 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;
}
*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);
}
}
}
char *
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;
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;
NEW(h);
- h->name = add (hf->name, NULL);
+ h->name = mh_xstrdup (hf->name);
h->hf_encoding = hf->hf_encoding;
h->next = hf->next;
hf->next = h;
free (encoding);
}
- h->value = add (" 8bit\n", NULL);
+ h->value = mh_xstrdup (" 8bit\n");
/* Don't need to warn for multiple C-T-E header
fields, parse_mime() already does that. But
}
}
if (! found_cte) {
- add_header (ct, add (ENCODING_FIELD, NULL), cte);
+ add_header (ct, mh_xstrdup (ENCODING_FIELD), cte);
}
/* Update c_celine. It's used only by mhlist -debug. */
free (ct->c_celine);
- ct->c_celine = add (cte, NULL);
+ ct->c_celine = mh_xstrdup (cte);
return OK;
}
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 {
be unlinked by free_content (). */
char *tempfile;
+ /* 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 = add (tempfile, NULL);
+ tmp_plain_file = mh_xstrdup (tempfile);
if (reformat_part (tp_part, tmp_plain_file,
tp_part->c_ctinfo.ci_type,
tp_part->c_ctinfo.ci_subtype,
NEW0(new_part);
/* Just copy over what is needed for decoding. c_vrsn and
c_celine aren't necessary. */
- new_part->c_file = add (ct->c_file, NULL);
+ new_part->c_file = mh_xstrdup (ct->c_file);
new_part->c_begin = ct->c_begin;
new_part->c_end = ct->c_end;
copy_ctinfo (&new_part->c_ctinfo, &ct->c_ctinfo);
/* c_ctline is used by reformat__part(), so it can preserve
anything after the type/subtype. */
- new_part->c_ctline = add (ct->c_ctline, NULL);
+ new_part->c_ctline = mh_xstrdup (ct->c_ctline);
return new_part;
}
copy_ctinfo (CI dest, CI src) {
PM s_pm, d_pm;
- dest->ci_type = src->ci_type ? add (src->ci_type, NULL) : NULL;
- dest->ci_subtype = src->ci_subtype ? add (src->ci_subtype, NULL) : NULL;
+ dest->ci_type = src->ci_type ? mh_xstrdup (src->ci_type) : NULL;
+ dest->ci_subtype = src->ci_subtype ? mh_xstrdup (src->ci_subtype) : NULL;
for (s_pm = src->ci_first_pm; s_pm; s_pm = s_pm->pm_next) {
d_pm = add_param(&dest->ci_first_pm, &dest->ci_last_pm, s_pm->pm_name,
}
}
- dest->ci_comment = src->ci_comment ? add (src->ci_comment, NULL) : NULL;
- dest->ci_magic = src->ci_magic ? add (src->ci_magic, NULL) : NULL;
+ dest->ci_comment = src->ci_comment ? mh_xstrdup (src->ci_comment) : NULL;
+ dest->ci_magic = src->ci_magic ? mh_xstrdup (src->ci_magic) : NULL;
}
decode_part (CT ct) {
char *tmp_decoded;
int status;
+ FILE *file;
char *tempfile;
- if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, NULL)) == NULL) {
+ if ((tempfile = m_mktemp2 (NULL, invo_name, NULL, &file)) == NULL) {
adios (NULL, "unable to create temporary file in %s", get_temp_dir());
}
- tmp_decoded = add (tempfile, NULL);
+ tmp_decoded = mh_xstrdup (tempfile);
/* The following call will load ct->c_cefile.ce_file with the tmp
filename of the decoded content. tmp_decoded will contain the
encoded output, get rid of that. */
- status = output_message (ct, tmp_decoded);
+ status = output_message_fp (ct, file, tmp_decoded);
(void) m_unlink (tmp_decoded);
free (tmp_decoded);
+ if (fclose (file)) {
+ inform("unable to close temporary file %s, continuing...", tempfile);
+ }
return status;
}
/* 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;
}
c_showproc, c_termproc, c_storeproc, c_storage, c_folder
*/
- ct->c_file = add (first_alt->c_file, NULL);
+ ct->c_file = mh_xstrdup (first_alt->c_file);
ct->c_type = type;
ct->c_subtype = subtype;
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;
}
}
/* Load c_first_hf and c_last_hf. */
transfer_noncontent_headers (first_alt, ct);
- add_header (ct, add (TYPE_FIELD, NULL), concat (name, "\n", NULL));
+ add_header (ct, mh_xstrdup (TYPE_FIELD), concat (name, "\n", NULL));
free (name);
/* Load c_partno. */
if (first_alt->c_partno) {
- ct->c_partno = add (first_alt->c_partno, NULL);
+ ct->c_partno = mh_xstrdup (first_alt->c_partno);
free (first_alt->c_partno);
first_alt->c_partno = concat (ct->c_partno, ".1", NULL);
new_part->c_partno = concat (ct->c_partno, ".2", NULL);
} else {
- first_alt->c_partno = add ("1", NULL);
- new_part->c_partno = add ("2", NULL);
+ first_alt->c_partno = mh_xstrdup ("1");
+ new_part->c_partno = mh_xstrdup ("2");
}
if (ctinit) {
- ct->c_ctinfo.ci_type = add (typename, NULL);
- ct->c_ctinfo.ci_subtype = add (subtypename, NULL);
+ ct->c_ctinfo.ci_type = mh_xstrdup (typename);
+ ct->c_ctinfo.ci_subtype = mh_xstrdup (subtypename);
}
add_param(&ct->c_ctinfo.ci_first_pm, &ct->c_ctinfo.ci_last_pm,
free (boundary);
return ct;
+
+return_null:
+ free_content(ct);
+ free(boundary);
+ return NULL;
}
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;
free (hf->value);
hf->value = (cp = strchr (ct->c_ctline, ';'))
? concat (type_subtypename, cp, "\n", NULL)
- : add (name_plus_nl, NULL);
+ : mh_xstrdup (name_plus_nl);
}
}
if (! found_content_type) {
- add_header (ct, add (TYPE_FIELD, NULL),
+ add_header (ct, mh_xstrdup (TYPE_FIELD),
(cp = strchr (ct->c_ctline, ';'))
? concat (type_subtypename, cp, "\n", NULL)
- : add (name_plus_nl, NULL));
+ : mh_xstrdup (name_plus_nl));
}
/* Some of these might not be used, but set them anyway. */
ct->c_ctline = ctline;
/* Leave other ctinfo members as they were. */
free (ct->c_ctinfo.ci_type);
- ct->c_ctinfo.ci_type = add (typename, NULL);
+ ct->c_ctinfo.ci_type = mh_xstrdup (typename);
free (ct->c_ctinfo.ci_subtype);
- ct->c_ctinfo.ci_subtype = add (subtypename, NULL);
+ ct->c_ctinfo.ci_subtype = mh_xstrdup (subtypename);
ct->c_type = type;
ct->c_subtype = subtype;
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);
*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';
}
}
break;
}
- last_char_was_cr = *cp == '\r' ? 1 : 0;
+ last_char_was_cr = *cp == '\r';
}
}
adios (NULL, "unable to create temporary file in %s",
get_temp_dir());
}
- stripped_content_file = add (tempfile, NULL);
+ stripped_content_file = mh_xstrdup (tempfile);
/* Strip each CR before a LF from the content. */
fseeko (*fp, begin, SEEK_SET);
}
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;
}
}
if (! found_cte) {
- add_header (ct, add (ENCODING_FIELD, NULL), cte);
+ add_header (ct, mh_xstrdup (ENCODING_FIELD), cte);
}
}
}
fix_filename_param (char *name, char *value, PM *first_pm, PM *last_pm) {
int fixed = 0;
- if (HasPrefix(value, "=?") && HasSuffix(value, "?=")) {
+ if (has_prefix(value, "=?") && has_suffix(value, "?=")) {
/* Looks like an RFC 2047 encoded parameter. */
char decoded[PATH_MAX + 1];
replace_param (first_pm, last_pm, name, decoded, 0);
fixed = 1;
} else {
- advise (NULL, "failed to decode %s parameter %s", name, value);
+ inform("failed to decode %s parameter %s", name, value);
}
}
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);
}
}
* Output content in input file to output file.
*/
static int
-write_content (CT ct, const char *input_filename, char *outfile, int modify_inplace,
- int message_mods) {
+write_content (CT ct, const char *input_filename, char *outfile, FILE *outfp,
+ int modify_inplace, int message_mods) {
int status = OK;
if (modify_inplace) {
if (message_mods > 0) {
- if ((status = output_message (ct, outfile)) == OK) {
+ if ((status = output_message_fp (ct, outfp, outfile)) == OK) {
char *infile = input_filename
- ? add (input_filename, NULL)
- : add (ct->c_file ? ct->c_file : "-", NULL);
+ ? mh_xstrdup (input_filename)
+ : mh_xstrdup (ct->c_file ? ct->c_file : "-");
if (remove_file (infile) == OK) {
if (rename (outfile, infile)) {
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;
}
} else {
/* Output is going to some file. Produce it whether or not
there were modifications. */
- status = output_message (ct, outfile);
+ status = output_message_fp (ct, outfp, outfile);
}
flush_errors ();
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