-
-/*
- * mhshowsbr.c -- routines to display the contents of MIME messages
+/* mhshowsbr.c -- routines to display the contents of MIME messages
*
* This code is Copyright (c) 2002, by the authors of nmh. See the
* COPYRIGHT file in the root directory of the nmh distribution for
#include <fcntl.h>
#include <h/signals.h>
#include <h/md5.h>
-#include <setjmp.h>
#include <h/mts.h>
#include <h/tws.h>
#include <h/mime.h>
#include <h/mhparse.h>
#include <h/fmt_scan.h>
#include <h/utils.h>
+#include "mhmisc.h"
+#include "mhshowsbr.h"
+#include "sbr/m_mktemp.h"
#ifdef HAVE_ICONV
# include <iconv.h>
#endif /* ! HAVE_ICONV */
int nomore = 0;
char *formsw = NULL;
+/* for output markers and headers */
+char *folder = NULL;
+char *markerform;
+char *headerform;
+int headersw = -1;
-/* mhmisc.c */
-int part_ok (CT, int);
-int type_ok (CT, int);
-void content_error (char *, CT, char *, ...);
-void flush_errors (void);
/*
* static prototypes
static int parse_display_string (CT, char *, int *, int *, char *, char *,
size_t, int multipart);
static int convert_content_charset (CT, char **);
+static struct format *compile_header(char *);
static struct format *compile_marker(char *);
+static void output_header (CT, struct format *);
static void output_marker (CT, struct format *, int);
static void free_markercomps (void);
static int pidcheck(int);
* content marker display.
*/
+static struct comp *folder_comp = NULL;
static struct comp *part_comp = NULL;
static struct comp *ctype_comp = NULL;
static struct comp *description_comp = NULL;
*/
void
-show_all_messages (CT *cts, int concatsw, int textonly, int inlineonly,
- char *markerform)
+show_all_messages(CT *cts, int concat, int textonly, int inlineonly)
{
CT ct, *ctp;
- struct format *fmt;
+ struct format *hfmt, *mfmt;
/*
* If form is not specified, then get default form
formsw = getcpy (etcpath ("mhl.headers"));
/*
- * Compile the content marker format line
+ * Compile the content marker and header format lines
*/
- fmt = compile_marker(markerform);
+ mfmt = compile_marker(markerform);
+ hfmt = compile_header(headerform);
/*
* If form is "mhl.null", suppress display of header.
ct = *ctp;
/* if top-level type is ok, then display message */
- if (type_ok (ct, 1))
- show_single_message (ct, formsw, concatsw, textonly, inlineonly,
- fmt);
+ if (type_ok (ct, 1)) {
+ if (headersw) output_header(ct, hfmt);
+
+ show_single_message (ct, formsw, concat, textonly, inlineonly,
+ mfmt);
+ }
}
free_markercomps();
- fmt_free(fmt, 1);
+ fmt_free(hfmt, 1);
+ fmt_free(mfmt, 1);
}
DisplayMsgHeader (CT ct, char *form, int concatsw)
{
pid_t child_id;
- int i, vecp;
+ int vecp;
char **vec;
char *file;
vec = argsplit(mhlproc, &file, &vecp);
- vec[vecp++] = getcpy("-form");
- vec[vecp++] = getcpy(form);
- vec[vecp++] = getcpy("-nobody");
+ vec[vecp++] = mh_xstrdup("-form");
+ vec[vecp++] = mh_xstrdup(form);
+ vec[vecp++] = mh_xstrdup("-nobody");
vec[vecp++] = getcpy(ct->c_file);
/*
* then just pass that along.
*/
if (nomore || concatsw) {
- vec[vecp++] = getcpy("-nomoreproc");
+ vec[vecp++] = mh_xstrdup("-nomoreproc");
} else if (progsw) {
- vec[vecp++] = getcpy("-moreproc");
- vec[vecp++] = getcpy(progsw);
+ vec[vecp++] = mh_xstrdup("-moreproc");
+ vec[vecp++] = mh_xstrdup(progsw);
}
vec[vecp] = NULL;
fflush (stdout);
- for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
- sleep (5);
-
+ child_id = fork();
switch (child_id) {
case NOTOK:
adios ("fork", "unable to");
{
int fd;
int xstdin = 0, xlist = 0;
- char *file = NULL, buffer[BUFSIZ];
+ char *file = NULL, buffer[NMH_BUFSIZ];
if (!ct->c_ceopenfnx) {
if (!alternate)
if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
return NOTOK;
if (ct->c_showproc && !strcmp (ct->c_showproc, "true"))
- return (alternate ? DONE : OK);
+ return OK;
if (! strcmp(invo_name, "mhshow") &&
ct->c_type == CT_TEXT && ct->c_subtype == TEXT_PLAIN) {
if ((fd = (*ct->c_ceopenfnx) (ct, &file)) == NOTOK)
return NOTOK;
} else {
- admonish (NULL, "unable to convert character set%s%s to %s",
+ char *charset = content_charset (ct);
+ inform("unable to convert character set%s%s from %s, continuing...",
ct->c_partno ? " of part " : "",
- ct->c_partno ? ct->c_partno : "",
- content_charset (ct));
+ FENDNULL(ct->c_partno),
+ charset);
+ free (charset);
}
}
if (parse_display_string (ct, cp, &xstdin, &xlist, file, buffer,
sizeof(buffer) - 1, 0)) {
- admonish (NULL, "Buffer overflow constructing show command!\n");
+ inform("Buffer overflow constructing show command, continuing...");
return NOTOK;
}
int fd, int xlist, int xstdin, struct format *fmt)
{
pid_t child_id;
- int i, vecp;
+ int vecp;
char **vec, *file;
if (debugsw || cracked) {
char lastchar = '\n';
if (fd == NOTOK) {
- advise(NULL, "Cannot use NULL command to display content-type "
+ inform("Cannot use NULL command to display content-type "
"%s/%s", ct->c_ctinfo.ci_type, ct->c_ctinfo.ci_subtype);
return NOTOK;
}
while ((cc = read(fd, readbuf, sizeof(readbuf))) > 0) {
- fwrite(readbuf, sizeof(char), cc, stdout);
+ if ((ssize_t) fwrite(readbuf, sizeof(char), cc, stdout) < cc) {
+ advise ("putline", "fwrite");
+ }
lastchar = readbuf[cc - 1];
}
if (strcmp(invo_name, "mhshow") == 0 && ct->c_type == CT_TEXT &&
ct->c_subtype == TEXT_PLAIN && lastchar != '\n') {
- putc('\n', stdout);
+ putchar('\n');
}
fflush(stdout);
fflush (stdout);
- for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
- sleep (5);
+ child_id = fork();
switch (child_id) {
case NOTOK:
advise ("fork", "unable to");
_exit (-1);
/* NOTREACHED */
- default:
- arglist_free(file, vec);
+ default: {
+ int status;
+ char *display_prog = vecp > 2 && vec[2][0] != '\0'
+ /* Copy the real display program name. This relies on the
+ specific construction of vec[] by argsplit(). */
+ ? vec[2]
+ : NULL;
- pidcheck (pidXwait (child_id, NULL));
+ pidcheck ((status = pidXwait (child_id, display_prog)));
+ arglist_free(file, vec);
if (fd != NOTOK)
(*ct->c_ceclosefnx) (ct);
- return (alternate ? DONE : OK);
+ return (alternate ? OK : status);
+ }
}
}
} else
snprintf (buffer, sizeof(buffer), "%%l%s %%F", progsw ? progsw :
moreproc && *moreproc ? moreproc : DEFAULT_PAGER);
- cp = (ct->c_showproc = add (buffer, NULL));
+ cp = (ct->c_showproc = mh_xstrdup(buffer));
return show_content_aux (ct, alternate, cp, NULL, fmt);
}
if ((cp = context_find_by_type ("show", ci->ci_type, ci->ci_subtype)))
return show_multi_aux (ct, alternate, cp, fmt);
- if ((cp = ct->c_showproc))
+ if ((cp = ct->c_showproc)) {
return show_multi_aux (ct, alternate, cp, fmt);
+ }
/*
* Use default method to display this multipart content. Even
int alternating, nowalternate, result;
struct multipart *m = (struct multipart *) ct->c_ctparams;
struct part *part;
- int any_part_ok;
+ int request_matched;
+ int display_success;
+ int mult_alt_done;
+ int ret;
CT p;
alternating = 0;
alternating = 1;
}
-/*
- * alternate -> we are a part inside an multipart/alternative
- * alternating -> we are a multipart/alternative
- */
+ /*
+ * alternate -> we are a part inside a multipart/alternative
+ * alternating -> we are a multipart/alternative
+ */
- result = alternate ? NOTOK : OK;
- any_part_ok = 0;
+ result = NOTOK;
+ request_matched = 0;
+ display_success = 0;
+ mult_alt_done = 0;
for (part = m->mp_parts; part; part = part->mp_next) {
p = part->mp_part;
- if (part_ok (p, 1) && type_ok (p, 1)) {
- int inneresult;
+ /* while looking for the right displayable alternative, we
+ * use a looser search criterion than we do after finding it.
+ * specifically, while still looking, part_ok() will match
+ * "parent" parts (e.g. "-part 2" where 2 is a high-level
+ * multipart). after finding it, we use part_exact() to only
+ * choose a part that was requested explicitly.
+ */
+ if ((part_exact(p) && type_ok(p, 1)) ||
+ (!mult_alt_done && part_ok (p) && type_ok (p, 1))) {
- any_part_ok = 1;
+ int inneresult;
inneresult = show_switch (p, nowalternate, concatsw, textonly,
inlineonly, fmt);
switch (inneresult) {
- case NOTOK:
+ case NOTOK: /* hard display error */
+ request_matched = 1;
if (alternate && !alternating) {
result = NOTOK;
goto out;
}
continue;
- case OK:
- case DONE:
+ case DONE: /* found no match on content type */
+ continue;
+
+ case OK: /* display successful */
+ request_matched = 1;
+ display_success = 1;
+ result = OK;
+
+ /* if we got success on a sub-part of
+ * multipart/alternative, we're done, unless
+ * there's a chance an explicit part should be
+ * matched later in the alternatives. */
if (alternating) {
- result = DONE;
- break;
- }
- if (alternate) {
+ mult_alt_done = 1;
+ } else if (alternate) {
alternate = nowalternate = 0;
- if (result == NOTOK)
- result = inneresult;
}
continue;
}
}
}
- if (alternating && !part && any_part_ok) {
+ /* we're supposed to be displaying at least something from a
+ * multipart/alternative. if we've had parts to consider, and
+ * we've had no success, then we should complain. we shouldn't
+ * complain if none of the parts matched any -part or -type option.
+ */
+ if (alternating && request_matched && !display_success) {
+ /* if we're ourselves an alternate. don't complain yet. */
if (!alternate)
content_error (NULL, ct, "don't know how to display any of the contents");
result = NOTOK;
- goto out;
}
out:
- return result;
+ /* if no parts matched what was requested, there can't have been
+ * any display errors. we report DONE rather than OK. */
+ ret = request_matched ? result : DONE;
+ return ret;
}
if ((*p->c_ceopenfnx) (p, &file) == NOTOK)
return NOTOK;
- p->c_storage = add (file, NULL);
+ p->c_storage = mh_xstrdup(FENDNULL(file));
if (p->c_showproc && !strcmp (p->c_showproc, "true"))
- return (alternate ? DONE : OK);
+ return OK;
(*p->c_ceclosefnx) (p);
}
}
if (parse_display_string (ct, cp, &xstdin, &xlist, file,
buffer, sizeof(buffer) - 1, 1)) {
- admonish (NULL, "Buffer overflow constructing show command!\n");
+ inform("Buffer overflow constructing show command, continuing...");
return NOTOK;
}
/* default method for message/rfc822 */
if (ct->c_subtype == MESSAGE_RFC822) {
- cp = (ct->c_showproc = add ("%pshow -file %F", NULL));
+ cp = (ct->c_showproc = mh_xstrdup("%pshow -file %F"));
return show_content_aux (ct, alternate, cp, NULL, fmt);
}
case 'F':
/* %f, and stdin is terminal not content */
*xstdin = 1;
- /* and fall... */
+ /* FALLTHRU */
case 'f':
if (multipart) {
case 'p':
/* No longer supported */
- /* and fall... */
+ /* FALLTHRU */
case 'l':
/* display listing prior to displaying content */
/* This will get confused if there are multiple %{}'s,
but its real purpose is to avoid doing bad things
above if a closing brace wasn't found. */
- admonish(NULL,
- "no closing brace for display string escape %s",
+ inform("no closing brace for display string escape %s, continuing...",
cp);
}
break;
quote. */
memmove (pp, pp-1, len+1);
*(pp++-1) = '\\';
- buflen -= 1;
- bp += 1;
+ buflen--;
+ bp++;
}
}
/* If pp is still set, that means we ran out of space. */
char *dest_buffer = mh_xmalloc(dest_buffer_size);
HF hf;
char *tempfile;
+ int fromutf8 = !strcasecmp(src_charset, "UTF-8");
if ((conv_desc = iconv_open (dest_charset, src_charset)) ==
(iconv_t) -1) {
- advise (NULL, "Can't convert %s to %s", src_charset, dest_charset);
+ inform("Can't convert %s to %s", src_charset, dest_charset);
+ free (src_charset);
return NOTOK;
}
adios (NULL, "unable to create temporary file in %s",
get_temp_dir());
}
- dest = add (tempfile, NULL);
+ dest = mh_xstrdup(tempfile);
if (ct->c_cefile.ce_file) {
file = &ct->c_cefile.ce_file;
outbytes_before += bumpup;
goto iconv_start;
}
+ if (errno == EINVAL) {
+ /* middle of multi-byte sequence */
+ if (write (fd, dest_buffer, outbytes_before - outbytes) < 0) {
+ advise (dest, "write");
+ }
+ fseeko (*fp, -inbytes, SEEK_CUR);
+ if (end > 0) bytes_to_read += inbytes;
+ /* inform("convert_charset: EINVAL"); */
+ continue;
+ }
+ if (errno == EILSEQ) {
+ /* invalid multi-byte sequence */
+ if (fromutf8) {
+ for (++ib, --inbytes;
+ inbytes > 0 &&
+ (((unsigned char) *ib) & 0xc0) == 0x80;
+ ++ib, --inbytes)
+ continue;
+ } else {
+ ib++; inbytes--; /* skip it */
+ }
+ (*ob++) = '?'; outbytes --;
+ /* inform("convert_charset: EILSEQ"); */
+ goto iconv_start;
+ }
+ inform("convert_charset: errno = %d", errno);
status = NOTOK;
break;
- } else {
- if (write (fd, dest_buffer, outbytes_before - outbytes)
- < 0) {
- advise (dest, "write");
- }
+ }
+
+ if (write (fd, dest_buffer, outbytes_before - outbytes) < 0) {
+ advise (dest, "write");
}
}
replace_param(&ct->c_ctinfo.ci_first_pm,
&ct->c_ctinfo.ci_last_pm, "charset",
dest_charset, 0);
- outline = output_params(strlen(TYPE_FIELD) + 1 + strlen(ctline),
+ outline = output_params(LEN(TYPE_FIELD) + 1 + strlen(ctline),
ct->c_ctinfo.ci_first_pm, NULL, 0);
if (outline) {
ctline = add(outline, ctline);
#else /* ! HAVE_ICONV */
NMH_UNUSED (message_mods);
- advise (NULL, "Can't convert %s to %s without iconv", src_charset,
+ inform("Can't convert %s to %s without iconv", src_charset,
dest_charset);
errno = ENOSYS;
status = NOTOK;
#endif /* ! HAVE_ICONV */
}
+ free (src_charset);
return status;
}
/* Using current locale, see if the content needs to be converted. */
/* content_charset() cannot return NULL. */
- char *charset = content_charset (ct);
+ char *src_charset = content_charset (ct);
- if (! check_charset (charset, strlen (charset))) {
+ if (! check_charset (src_charset, strlen (src_charset))) {
int unused = 0;
- char *charset = getcpy (get_charset ());
+ char *dest_charset = getcpy (get_charset ());
- if (convert_charset (ct, charset, &unused) == 0) {
+ if (convert_charset (ct, dest_charset, &unused) == 0) {
*file = ct->c_cefile.ce_file;
} else {
status = NOTOK;
}
- free (charset);
+ free (dest_charset);
}
+ free (src_charset);
#else /* ! HAVE_ICONV */
NMH_UNUSED (ct);
NMH_UNUSED (file);
* Compile our format string and save any parameters we care about.
*/
+#define DEFAULT_HEADER "[ Message %{folder}%<{folder}:%>%(msg) ]"
#define DEFAULT_MARKER "[ part %{part} - %{content-type} - " \
"%<{description}%{description}" \
"%?{cdispo-filename}%{cdispo-filename}" \
"%(kilo(size))B %<(unseen)\\(suppressed\\)%> ]"
static struct format *
-compile_marker(char *markerform)
+compile_header(char *form)
+{
+ struct format *fmt;
+ char *fmtstring;
+ struct comp *comp = NULL;
+ unsigned int bucket;
+
+ fmtstring = new_fs(form, NULL, DEFAULT_HEADER);
+
+ (void) fmt_compile(fmtstring, &fmt, 1);
+ free_fs();
+
+ while ((comp = fmt_nextcomp(comp, &bucket)) != NULL) {
+ if (strcasecmp(comp->c_name, "folder") == 0) {
+ folder_comp = comp;
+ }
+ }
+
+ return fmt;
+}
+
+static struct format *
+compile_marker(char *form)
{
struct format *fmt;
char *fmtstring;
unsigned int bucket;
struct param_comp_list *pc_entry;
- fmtstring = new_fs(markerform, NULL, DEFAULT_MARKER);
+ fmtstring = new_fs(form, NULL, DEFAULT_MARKER);
(void) fmt_compile(fmtstring, &fmt, 1);
- free(fmtstring);
+ free_fs();
/*
* Things we care about:
dispo_comp = comp;
} else if (strncasecmp(comp->c_name, "ctype-", 6) == 0 &&
strlen(comp->c_name) > 6) {
- pc_entry = mh_xmalloc(sizeof(*pc_entry));
- pc_entry->param = getcpy(comp->c_name + 6);
+ NEW(pc_entry);
+ pc_entry->param = mh_xstrdup(comp->c_name + 6);
pc_entry->comp = comp;
pc_entry->next = ctype_pc_list;
ctype_pc_list = pc_entry;
} else if (strncasecmp(comp->c_name, "cdispo-", 7) == 0 &&
strlen(comp->c_name) > 7) {
- pc_entry = mh_xmalloc(sizeof(*pc_entry));
- pc_entry->param = getcpy(comp->c_name + 7);
+ NEW(pc_entry);
+ pc_entry->param = mh_xstrdup(comp->c_name + 7);
pc_entry->comp = comp;
pc_entry->next = dispo_pc_list;
dispo_pc_list = pc_entry;
* Output on stdout an appropriate marker for this content, using mh-format
*/
+static void
+output_header(CT ct, struct format *fmt)
+{
+ charstring_t outbuf = charstring_create (BUFSIZ);
+ int dat[5] = { 0 };
+ char *endp;
+ int message = 0;
+
+ if (folder_comp)
+ folder_comp->c_text = getcpy(folder);
+
+ if (ct->c_file && *ct->c_file) {
+ message = strtol(ct->c_file, &endp, 10);
+ if (*endp) message = 0;
+ dat[0] = message;
+ }
+
+ /* it would be nice to populate dat[2], for %(size) here,
+ * but it's not available. it might also be nice to know
+ * if the message originally had any mime parts or not -- but
+ * there's also no record of that. (except for MIME-version:)
+ */
+
+ fmt_scan(fmt, outbuf, BUFSIZ, dat, NULL);
+
+ fputs(charstring_buffer (outbuf), stdout);
+ charstring_free (outbuf);
+
+ fmt_freecomptext();
+}
+
static void
output_marker(CT ct, struct format *fmt, int hidden)
{
charstring_t outbuf = charstring_create (BUFSIZ);
struct param_comp_list *pcentry;
int partsize;
- int dat[5];
+ int message = 0;
+ char *endp;
+ int dat[5] = { 0 };
/*
* Grab any items we care about.
}
if (part_comp && ct->c_partno) {
- part_comp->c_text = getcpy(ct->c_partno);
+ part_comp->c_text = mh_xstrdup(ct->c_partno);
}
if (description_comp && ct->c_descr) {
- description_comp->c_text = getcpy(ct->c_descr);
+ description_comp->c_text = mh_xstrdup(ct->c_descr);
}
if (dispo_comp && ct->c_dispo_type) {
- dispo_comp->c_text = getcpy(ct->c_dispo_type);
+ dispo_comp->c_text = mh_xstrdup(ct->c_dispo_type);
}
for (pcentry = ctype_pc_list; pcentry != NULL; pcentry = pcentry->next) {
else
partsize = ct->c_end - ct->c_begin;
+ if (ct->c_file && *ct->c_file) {
+ message = strtol(ct->c_file, &endp, 10);
+ if (*endp) message = 0;
+ dat[0] = message;
+ }
+ dat[2] = partsize;
+
/* make the part's hidden aspect available by overloading the
* %(unseen) function. make the part's size available via %(size).
* see comments in h/fmt_scan.h.
*/
- dat[2] = partsize;
dat[4] = hidden;
- dat[0] = dat[1] = dat[3] = 0;
fmt_scan(fmt, outbuf, BUFSIZ, dat, NULL);
{
struct param_comp_list *pc_entry, *pc2;
+ folder_comp = NULL;
part_comp = NULL;
ctype_comp = NULL;
description_comp = NULL;
projects / nmh / blobdiff