* distribution for complete copyright information.
*/
-#include <h/mh.h>
-#include <h/fmt_scan.h>
-#include <h/mime.h>
-#include <h/mhparse.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 "h/utils.h"
+#include "h/signals.h"
#include "sbr/m_maildir.h"
#include "sbr/m_mktemp.h"
#include "sbr/mime_type.h"
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;
rmmproc = NULL;
continue;
case CHGSW:
- chgflag = 1;
+ chgflag = true;
continue;
case NCHGSW:
- chgflag = 0;
+ chgflag = false;
continue;
case VERBSW:
verbosw = 1;
int fd;
char *cp;
- using_stdin = 1;
+ using_stdin = true;
if ((cp = m_mktemp2 (NULL, invo_name, &fd, NULL)) == NULL) {
die("unable to create temporary file in %s",
*/
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;
*/
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;
* 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)
* 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];
* 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) {
* 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 between the parameter name and the "=", or
between the "=" and the parameter value. */
* 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) {
* 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) {
*/
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;
* 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;
* 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;
* 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=";
* 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;
* 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;
* 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;
* 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;
}
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;
}
}
}
* 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 {
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;
*/
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) {
* 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;
projects / nmh / blobdiff