handler.c File Reference

Decide how to display email content. More...

#include "config.h"
#include <iconv.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "handler.h"
#include "attach/lib.h"
#include "key/lib.h"
#include "ncrypt/lib.h"
#include "pager/lib.h"
#include "body.h"
#include "copy_email.h"
#include "enriched.h"
#include "envelope.h"
#include "globals.h"
#include "mailcap.h"
#include "mime.h"
#include "module_data.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "parameter.h"
#include "parse.h"
#include "rfc3676.h"
#include <libintl.h>

Include dependency graph for handler.c:

Go to the source code of this file.

Macros
#define	BUFI_SIZE   1000
	Input buffer size for handler operations.
#define	BUFO_SIZE   2000
	Output buffer size for handler operations.
#define	TXT_HTML   1
	HTML text format.
#define	TXT_PLAIN   2
	Plain text format.
#define	TXT_ENRICHED   3
	Enriched text format.

Typedefs
typedef int(*	handler_t) (struct Body *b_email, struct State *state)

Functions
static void	print_part_line (struct State *state, struct Body *b_email, int n)
	Print a separator for the Mime part.
static void	convert_to_state (iconv_t cd, char *bufi, size_t *l, struct State *state)
	Convert text and write it to a file.
static void	decode_xbit (struct State *state, long len, bool istext, iconv_t cd)
	Decode xbit-encoded text.
static int	qp_decode_triple (char *s, char *d)
	Decode a quoted-printable triplet.
static void	qp_decode_line (char *dest, char *src, size_t *l, int last)
	Decode a line of quoted-printable text.
static void	decode_quoted (struct State *state, long len, bool istext, iconv_t cd)
	Decode an attachment encoded with quoted-printable.
static unsigned char	decode_byte (char ch)
	Decode a uuencoded byte.
static void	decode_uuencoded (struct State *state, long len, bool istext, iconv_t cd)
	Decode uuencoded text.
static bool	is_mmnoask (const char *buf)
	Metamail compatibility: should the attachment be autoviewed?
static bool	is_autoview (struct Body *b)
	Should email body be filtered by mailcap.
static int	autoview_handler (struct Body *b_email, struct State *state)
	Handler for autoviewable attachments - Implements handler_t -.
static int	text_plain_handler (struct Body *b_email, struct State *state)
	Handler for plain text - Implements handler_t -.
static int	message_handler (struct Body *b_email, struct State *state)
	Handler for message/rfc822 body parts - Implements handler_t -.
static int	external_body_handler (struct Body *b_email, struct State *state)
	Handler for external-body emails - Implements handler_t -.
static int	alternative_handler (struct Body *b_email, struct State *state)
	Handler for multipart alternative emails - Implements handler_t -.
static int	multilingual_handler (struct Body *b_email, struct State *state)
	Handler for multi-lingual emails - Implements handler_t -.
static int	multipart_handler (struct Body *b_email, struct State *state)
	Handler for multipart emails - Implements handler_t -.
static int	run_decode_and_handler (struct Body *b, struct State *state, handler_t handler, bool plaintext)
	Run an appropriate decoder for an email.
static int	valid_pgp_encrypted_handler (struct Body *b_email, struct State *state)
	Handler for valid pgp-encrypted emails - Implements handler_t -.
static int	malformed_pgp_encrypted_handler (struct Body *b_email, struct State *state)
	Handler for invalid pgp-encrypted emails - Implements handler_t -.
void	mutt_decode_base64 (struct State *state, size_t len, bool istext, iconv_t cd)
	Decode base64-encoded text.
int	mutt_body_handler (struct Body *b, struct State *state)
	Handler for the Body of an email.
bool	mutt_prefer_as_attachment (struct Body *b)
	Do we want this part as an attachment?
bool	mutt_can_decode (struct Body *b)
	Will decoding the attachment produce any output.
void	mutt_decode_attachment (const struct Body *b, struct State *state)
	Decode an email's attachment.

Detailed Description

Decide how to display email content.

Authors

• Michael R. Elkins
• Pietro Cerutti
• Richard Russon
• Federico Kircheis
• Reis Radomil
• Ian Zimmerman
• David Purton
• Dennis Schön
• Thomas Klausner

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file handler.c.

Macro Definition Documentation

BUFI_SIZE

#define BUFI_SIZE   1000

Input buffer size for handler operations.

Definition at line 72 of file handler.c.

BUFO_SIZE

#define BUFO_SIZE   2000

Output buffer size for handler operations.

Definition at line 73 of file handler.c.

TXT_HTML

#define TXT_HTML   1

HTML text format.

Definition at line 75 of file handler.c.

TXT_PLAIN

#define TXT_PLAIN   2

Plain text format.

Definition at line 76 of file handler.c.

TXT_ENRICHED

#define TXT_ENRICHED   3

Enriched text format.

Definition at line 77 of file handler.c.

Typedef Documentation

handler_t

typedef int(* handler_t) (struct Body *b_email, struct State *state)

Definition at line 89 of file handler.c.

Function Documentation

print_part_line()

void print_part_line ( struct State * state, struct Body * b_email, int n )

static

Print a separator for the Mime part.

Parameters

state	State of text being processed
b_email	Body of the email
n	Part number for multipart emails (0 otherwise)

Definition at line 97 of file handler.c.

{
  struct Buffer *length = buf_pool_get();
  mutt_str_pretty_size(length, b_email->length);
  state_mark_attach(state);
  char *charset = mutt_param_get(&b_email->parameter, "charset");
  if (n == 0)
  {
    state_printf(state, _("[-- Type: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
                 BODY_TYPE(b_email), b_email->subtype, charset ? "; charset=" : "",
                 charset ? charset : "", ENCODING(b_email->encoding), buf_string(length));
  }
  else
  {
    state_printf(state, _("[-- Alternative Type #%d: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
                 n, BODY_TYPE(b_email), b_email->subtype,
                 charset ? "; charset=" : "", charset ? charset : "",
                 ENCODING(b_email->encoding), buf_string(length));
  }
  buf_pool_release(&length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_state()

void convert_to_state ( iconv_t cd, char * bufi, size_t * l, struct State * state )

static

Convert text and write it to a file.

Parameters

cd	Iconv conversion descriptor
bufi	Buffer with text to convert
l	Length of buffer
state	State to write to

Definition at line 126 of file handler.c.

{
  char bufo[BUFO_SIZE] = { 0 };
  const char *ib = NULL;
  char *ob = NULL;
  size_t ibl = 0;
  size_t obl = 0;
 
  if (!bufi)
  {
    if (iconv_t_valid(cd))
    {
      ob = bufo;
      obl = sizeof(bufo);
      iconv(cd, NULL, NULL, &ob, &obl);
      if (ob != bufo)
        state_prefix_put(state, bufo, ob - bufo);
    }
    return;
  }
 
  if (!iconv_t_valid(cd))
  {
    state_prefix_put(state, bufi, *l);
    *l = 0;
    return;
  }
 
  ib = bufi;
  ibl = *l;
  while (true)
  {
    ob = bufo;
    obl = sizeof(bufo);
    mutt_ch_iconv(cd, &ib, &ibl, &ob, &obl, 0, "?", NULL);
    if (ob == bufo)
      break;
    state_prefix_put(state, bufo, ob - bufo);
  }
  memmove(bufi, ib, ibl);
  *l = ibl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_xbit()

void decode_xbit ( struct State * state, long len, bool istext, iconv_t cd )

static

Decode xbit-encoded text.

Parameters

state	State to work with
len	Length of text to decode
istext	Mime part is plain text
cd	Iconv conversion descriptor

Definition at line 176 of file handler.c.

{
  if (!istext)
  {
    mutt_file_copy_bytes(state->fp_in, state->fp_out, len);
    return;
  }
 
  state_set_prefix(state);
 
  int c;
  char bufi[BUFI_SIZE] = { 0 };
  size_t l = 0;
  while (((c = fgetc(state->fp_in)) != EOF) && len--)
  {
    if ((c == '\r') && len)
    {
      const int ch = fgetc(state->fp_in);
      if (ch == '\n')
      {
        c = ch;
        len--;
      }
      else
      {
        ungetc(ch, state->fp_in);
      }
    }
 
    bufi[l++] = c;
    if (l == sizeof(bufi))
      convert_to_state(cd, bufi, &l, state);
  }
 
  convert_to_state(cd, bufi, &l, state);
  convert_to_state(cd, 0, 0, state);
 
  state_reset_prefix(state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

qp_decode_triple()

int qp_decode_triple ( char * s, char * d )

static

Decode a quoted-printable triplet.

Parameters

s	State to work with
d	Decoded character

Return values

0	Success
-1	Error

Definition at line 223 of file handler.c.

{
  /* soft line break */
  if ((s[0] == '=') && (s[1] == '\0'))
    return 1;
 
  /* quoted-printable triple */
  if ((s[0] == '=') && mutt_isxdigit(s[1]) && mutt_isxdigit(s[2]))
  {
    *d = (hexval(s[1]) << 4) | hexval(s[2]);
    return 0;
  }
 
  /* something else */
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

qp_decode_line()

void qp_decode_line ( char * dest, char * src, size_t * l, int last )

static

Decode a line of quoted-printable text.

Parameters

dest	Buffer for result
src	Text to decode
l	Bytes written to buffer
last	Last character of the line

Definition at line 247 of file handler.c.

{
  char *d = NULL;
  char *s = NULL;
  char c = 0;
 
  int kind = -1;
  bool soft = false;
 
  /* decode the line */
 
  for (d = dest, s = src; *s;)
  {
    switch ((kind = qp_decode_triple(s, &c)))
    {
      case 0:
        *d++ = c;
        s += 3;
        break; /* qp triple */
      case -1:
        *d++ = *s++;
        break; /* single character */
      case 1:
        soft = true;
        s++;
        break; /* soft line break */
      default:
        break;
    }
  }
 
  if (!soft && (last == '\n'))
  {
    /* neither \r nor \n as part of line-terminating CRLF
     * may be qp-encoded, so remove \r and \n-terminate;
     * see RFC2045, sect. 6.7, (1): General 8bit representation */
    if ((kind == 0) && (c == '\r'))
      *(d - 1) = '\n';
    else
      *d++ = '\n';
  }
 
  *d = '\0';
  *l = d - dest;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_quoted()

void decode_quoted ( struct State * state, long len, bool istext, iconv_t cd )

static

Decode an attachment encoded with quoted-printable.

Parameters

state	State to work with
len	Length of text to decode
istext	Mime part is plain text
cd	Iconv conversion descriptor

Why doesn't this overflow any buffers? First, it's guaranteed that the length of a line grows when you en-code it to quoted-printable. That means that we always can store the result in a buffer of at most the same size.

Now, we don't special-case if the line we read with fgets() isn't terminated. We don't care about this, since 256 > 78, so corrupted input will just be corrupted a bit more. That implies that 256+1 bytes are always sufficient to store the result of qp_decode_line.

Finally, at soft line breaks, some part of a multibyte character may have been left over by convert_to_state(). This shouldn't be more than 6 characters, so 256+7 should be sufficient memory to store the decoded data.

Just to make sure that I didn't make some off-by-one error above, we just use 512 for the target buffer's size.

Definition at line 318 of file handler.c.

{
  char line[256] = { 0 };
  char decline[512] = { 0 };
  size_t l = 0;
  size_t l3 = 0;
 
  if (istext)
    state_set_prefix(state);
 
  while (len > 0)
  {
    /* It's ok to use a fixed size buffer for input, even if the line turns
     * out to be longer than this.  Just process the line in chunks.  This
     * really shouldn't happen according the MIME spec, since Q-P encoded
     * lines are at most 76 characters, but we should be liberal about what
     * we accept.  */
    if (!fgets(line, MIN((ssize_t) sizeof(line), len + 1), state->fp_in))
      break;
 
    size_t linelen = strlen(line);
    len -= linelen;
 
    /* inspect the last character we read so we can tell if we got the
     * entire line.  */
    const int last = (linelen != 0) ? line[linelen - 1] : 0;
 
    /* chop trailing whitespace if we got the full line */
    if (last == '\n')
    {
      while ((linelen > 0) && mutt_isspace(line[linelen - 1]))
        linelen--;
      line[linelen] = '\0';
    }
 
    /* decode and do character set conversion */
    qp_decode_line(decline + l, line, &l3, last);
    l += l3;
    convert_to_state(cd, decline, &l, state);
  }
 
  convert_to_state(cd, 0, 0, state);
  state_reset_prefix(state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_byte()

unsigned char decode_byte ( char ch )

static

Decode a uuencoded byte.

Parameters

ch	Character to decode

Return values

num	Decoded value

Definition at line 368 of file handler.c.

{
  if ((ch < 32) || (ch > 95))
    return 0;
  return ch - 32;
}

Here is the caller graph for this function:

decode_uuencoded()

void decode_uuencoded ( struct State * state, long len, bool istext, iconv_t cd )

static

Decode uuencoded text.

Parameters

state	State to work with
len	Length of text to decode
istext	Mime part is plain text
cd	Iconv conversion descriptor

Definition at line 382 of file handler.c.

{
  char tmps[128] = { 0 };
  char *pt = NULL;
  char bufi[BUFI_SIZE] = { 0 };
  size_t k = 0;
 
  if (istext)
    state_set_prefix(state);
 
  while (len > 0)
  {
    if (!fgets(tmps, sizeof(tmps), state->fp_in))
      goto cleanup;
    len -= mutt_str_len(tmps);
    if (mutt_str_startswith(tmps, "begin "))
      break;
  }
  while (len > 0)
  {
    if (!fgets(tmps, sizeof(tmps), state->fp_in))
      goto cleanup;
    len -= mutt_str_len(tmps);
    if (mutt_str_startswith(tmps, "end"))
      break;
    pt = tmps;
    const unsigned char linelen = decode_byte(*pt);
    pt++;
    for (unsigned char c = 0; (c < linelen) && *pt;)
    {
      for (char l = 2; (l <= 6) && pt[0] && pt[1]; l += 2)
      {
        char out = decode_byte(*pt) << l;
        pt++;
        out |= (decode_byte(*pt) >> (6 - l));
        bufi[k++] = out;
        c++;
        if (c == linelen)
          break;
      }
      convert_to_state(cd, bufi, &k, state);
      pt++;
    }
  }
 
cleanup:
  convert_to_state(cd, bufi, &k, state);
  convert_to_state(cd, 0, 0, state);
 
  state_reset_prefix(state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_mmnoask()

bool is_mmnoask ( const char * buf )

static

Metamail compatibility: should the attachment be autoviewed?

Parameters

buf	Mime type, e.g. 'text/plain'

Return values

true	Metamail "no ask" is true

Test if the MM_NOASK environment variable should allow autoviewing of the attachment.

Note

If MM_NOASK=1 then the function will automatically return true.

Definition at line 444 of file handler.c.

{
  const char *val = mutt_str_getenv("MM_NOASK");
  if (!val)
    return false;
 
  char *p = NULL;
  char tmp[1024] = { 0 };
  char *q = NULL;
 
  if (mutt_str_equal(val, "1"))
    return true;
 
  mutt_str_copy(tmp, val, sizeof(tmp));
  p = tmp;
 
  while ((p = strtok(p, ",")))
  {
    q = strrchr(p, '/');
    if (q)
    {
      if (q[1] == '*')
      {
        if (mutt_istrn_equal(buf, p, q - p))
          return true;
      }
      else
      {
        if (mutt_istr_equal(buf, p))
          return true;
      }
    }
    else
    {
      const size_t plen = mutt_istr_startswith(buf, p);
      if ((plen != 0) && (buf[plen] == '/'))
        return true;
    }
 
    p = NULL;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_autoview()

bool is_autoview ( struct Body * b )

static

Should email body be filtered by mailcap.

Parameters

b	Body of the email

Return values

1	body part should be filtered by a mailcap entry prior to viewing inline
0	otherwise

Definition at line 495 of file handler.c.

{
  char type[256] = { 0 };
  bool is_av = false;
 
  snprintf(type, sizeof(type), "%s/%s", BODY_TYPE(b), b->subtype);
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  const bool c_implicit_auto_view = cs_subset_bool(NeoMutt->sub, "implicit_auto_view");
  if (c_implicit_auto_view)
  {
    /* $implicit_auto_view is essentially the same as "auto-view *" */
    is_av = true;
  }
  else
  {
    /* determine if this type is on the user's auto-view list */
    mutt_check_lookup_list(b, type, sizeof(type));
    struct ListNode *np = NULL;
    STAILQ_FOREACH(np, &mod_data->auto_view, entries)
    {
      int i = mutt_str_len(np->data);
      i--;
      if (((i > 0) && (np->data[i - 1] == '/') && (np->data[i] == '*') &&
           mutt_istrn_equal(type, np->data, i)) ||
          mutt_istr_equal(type, np->data))
      {
        is_av = true;
        break;
      }
    }
 
    if (is_mmnoask(type))
      is_av = true;
  }
 
  /* determine if there is a mailcap entry suitable for auto-view
   *
   * @warning type is altered by this call as a result of 'mime-lookup' support */
  if (is_av)
    return mailcap_lookup(b, type, sizeof(type), NULL, MUTT_MC_AUTOVIEW);
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_decode_and_handler()

int run_decode_and_handler ( struct Body * b, struct State * state, handler_t handler, bool plaintext )

static

Run an appropriate decoder for an email.

Parameters

b	Body of the email
state	State to work with
handler	Callback function to process the content - Implements handler_t
plaintext	Is the content in plain text

Return values

0	Success
-1	Error

Definition at line 1349 of file handler.c.

{
  const char *save_prefix = NULL;
  FILE *fp = NULL;
  size_t tmplength = 0;
  LOFF_T tmpoffset = 0;
  int decode = 0;
  int rc = 0;
#ifndef USE_FMEMOPEN
  struct Buffer *tempfile = NULL;
#endif
 
  if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
  {
    return -1;
  }
 
#ifdef USE_FMEMOPEN
  char *temp = NULL;
  size_t tempsize = 0;
#endif
 
  /* see if we need to decode this part before processing it */
  if ((b->encoding == ENC_BASE64) || (b->encoding == ENC_QUOTED_PRINTABLE) ||
      (b->encoding == ENC_UUENCODED) || (plaintext || mutt_is_text_part(b)))
  /* text subtypes may require character set conversion even with 8bit encoding */
  {
    const int orig_type = b->type;
    if (plaintext)
    {
      b->type = TYPE_TEXT;
    }
    else
    {
      /* decode to a tempfile, saving the original destination */
      fp = state->fp_out;
#ifdef USE_FMEMOPEN
      state->fp_out = open_memstream(&temp, &tempsize);
      if (!state->fp_out)
      {
        mutt_error(_("Unable to open 'memory stream'"));
        mutt_debug(LL_DEBUG1, "Can't open 'memory stream'\n");
        return -1;
      }
#else
      tempfile = buf_pool_get();
      buf_mktemp(tempfile);
      state->fp_out = mutt_file_fopen(buf_string(tempfile), "w");
      if (!state->fp_out)
      {
        mutt_error(_("Unable to open temporary file"));
        mutt_debug(LL_DEBUG1, "Can't open %s\n", buf_string(tempfile));
        buf_pool_release(&tempfile);
        return -1;
      }
#endif
      /* decoding the attachment changes the size and offset, so save a copy
       * of the "real" values now, and restore them after processing */
      tmplength = b->length;
      tmpoffset = b->offset;
 
      /* if we are decoding binary bodies, we don't want to prefix each
       * line with the prefix or else the data will get corrupted.  */
      save_prefix = state->prefix;
      state->prefix = NULL;
 
      decode = 1;
    }
 
    mutt_decode_attachment(b, state);
 
    if (decode)
    {
      b->length = ftello(state->fp_out);
      b->offset = 0;
#ifdef USE_FMEMOPEN
      /* When running under torify, mutt_file_fclose(&state->fp_out) does not seem to
       * update tempsize. On the other hand, fflush does.  See
       * https://github.com/neomutt/neomutt/issues/440 */
      fflush(state->fp_out);
#endif
      mutt_file_fclose(&state->fp_out);
 
      /* restore final destination and substitute the tempfile for input */
      state->fp_out = fp;
      fp = state->fp_in;
#ifdef USE_FMEMOPEN
      if (tempsize)
      {
        state->fp_in = fmemopen(temp, tempsize, "r");
      }
      else
      { /* fmemopen can't handle zero-length buffers */
        state->fp_in = mutt_file_fopen("/dev/null", "r");
      }
      if (!state->fp_in)
      {
        mutt_perror(_("failed to re-open 'memory stream'"));
        FREE(&temp);
        state->fp_in = fp;
        state->prefix = save_prefix;
        b->length = tmplength;
        b->offset = tmpoffset;
        return -1;
      }
#else
      state->fp_in = mutt_file_fopen(buf_string(tempfile), "r");
      unlink(buf_string(tempfile));
      buf_pool_release(&tempfile);
      if (!state->fp_in)
      {
        mutt_perror(_("failed to re-open temporary file"));
        state->fp_in = fp;
        state->prefix = save_prefix;
        b->length = tmplength;
        b->offset = tmpoffset;
        return -1;
      }
#endif
      /* restore the prefix */
      state->prefix = save_prefix;
    }
 
    b->type = orig_type;
  }
 
  /* process the (decoded) body part */
  if (handler)
  {
    rc = handler(b, state);
    if (rc != 0)
    {
      mutt_debug(LL_DEBUG1, "Failed on attachment of type %s/%s\n",
                 BODY_TYPE(b), NONULL(b->subtype));
    }
 
    if (decode)
    {
      b->length = tmplength;
      b->offset = tmpoffset;
 
      /* restore the original source stream */
      mutt_file_fclose(&state->fp_in);
      state->fp_in = fp;
    }
  }
  state->flags |= STATE_FIRSTDONE;
#ifdef USE_FMEMOPEN
  FREE(&temp);
#endif
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_decode_base64()

void mutt_decode_base64	(	struct State *	state,
		size_t	len,
		bool	istext,
		iconv_t	cd )

Decode base64-encoded text.

Parameters

state	State to work with
len	Length of text to decode
istext	Mime part is plain text
cd	Iconv conversion descriptor

Definition at line 1571 of file handler.c.

{
  char buf[5] = { 0 };
  int ch;
  int i;
  bool cr = false;
  char bufi[BUFI_SIZE] = { 0 };
  size_t l = 0;
 
  buf[4] = '\0';
 
  if (istext)
    state_set_prefix(state);
 
  while (len > 0)
  {
    for (i = 0; (i < 4) && (len > 0); len--)
    {
      ch = fgetc(state->fp_in);
      if (ch == EOF)
        break;
      if ((ch >= 0) && (ch < 128) && ((base64val(ch) != -1) || (ch == '=')))
        buf[i++] = ch;
    }
    if (i != 4)
    {
      /* "i" may be zero if there is trailing whitespace, which is not an error */
      if (i != 0)
        mutt_debug(LL_DEBUG2, "didn't get a multiple of 4 chars\n");
      break;
    }
 
    const int c1 = base64val(buf[0]);
    if (c1 == -1) /* '=' (or any non-base64 char) at slot 0: stop */
      break;
    const int c2 = base64val(buf[1]);
    if (c2 == -1) /* '=' at slot 1: invalid padding, stop */
      break;
 
    /* first char */
    ch = (c1 << 2) | (c2 >> 4);
 
    if (cr && (ch != '\n'))
      bufi[l++] = '\r';
 
    cr = false;
 
    if (istext && (ch == '\r'))
      cr = true;
    else
      bufi[l++] = ch;
 
    /* second char */
    if (buf[2] == '=')
      break;
    const int c3 = base64val(buf[2]);
    ch = ((c2 & 0xf) << 4) | (c3 >> 2);
 
    if (cr && (ch != '\n'))
      bufi[l++] = '\r';
 
    cr = false;
 
    if (istext && (ch == '\r'))
      cr = true;
    else
      bufi[l++] = ch;
 
    /* third char */
    if (buf[3] == '=')
      break;
    const int c4 = base64val(buf[3]);
    ch = ((c3 & 0x3) << 6) | c4;
 
    if (cr && (ch != '\n'))
      bufi[l++] = '\r';
 
    cr = false;
 
    if (istext && (ch == '\r'))
      cr = true;
    else
      bufi[l++] = ch;
 
    if ((l + 8) >= sizeof(bufi))
      convert_to_state(cd, bufi, &l, state);
  }
 
  if (cr)
    bufi[l++] = '\r';
 
  convert_to_state(cd, bufi, &l, state);
  convert_to_state(cd, 0, 0, state);
 
  state_reset_prefix(state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_body_handler()

int mutt_body_handler	(	struct Body *	b,
		struct State *	state )

Handler for the Body of an email.

Parameters

b	Body of the email
state	State to work with

Return values

0	Success
-1	Error

Definition at line 1675 of file handler.c.

{
  if (!b || !state)
    return -1;
 
  bool plaintext = false;
  handler_t handler = NULL;
  handler_t encrypted_handler = NULL;
  int rc = 0;
  static unsigned short recurse_level = 0;
 
  const int oflags = state->flags;
  const bool is_attachment_display = (oflags & STATE_DISPLAY_ATTACH);
 
  if (recurse_level >= MUTT_MIME_MAX_DEPTH)
  {
    mutt_debug(LL_DEBUG1, "recurse level too deep. giving up\n");
    return 1;
  }
  recurse_level++;
 
  /* first determine which handler to use to process this part */
 
  if (is_autoview(b))
  {
    handler = autoview_handler;
    state->flags &= ~STATE_CHARCONV;
  }
  else if (b->type == TYPE_TEXT)
  {
    if (mutt_istr_equal("plain", b->subtype))
    {
      const bool c_reflow_text = cs_subset_bool(NeoMutt->sub, "reflow_text");
      /* avoid copying this part twice since removing the transfer-encoding is
       * the only operation needed.  */
      if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
      {
        encrypted_handler = crypt_pgp_application_handler;
        handler = encrypted_handler;
      }
      else if (c_reflow_text &&
               mutt_istr_equal("flowed", mutt_param_get(&b->parameter, "format")))
      {
        handler = rfc3676_handler;
      }
      else
      {
        handler = text_plain_handler;
      }
    }
    else if (mutt_istr_equal("enriched", b->subtype))
    {
      handler = text_enriched_handler;
    }
    else /* text body type without a handler */
    {
      plaintext = false;
    }
  }
  else if (b->type == TYPE_MESSAGE)
  {
    if (mutt_is_message_type(b->type, b->subtype))
      handler = message_handler;
    else if (mutt_istr_equal("delivery-status", b->subtype))
      plaintext = true;
    else if (mutt_istr_equal("external-body", b->subtype))
      handler = external_body_handler;
  }
  else if (b->type == TYPE_MULTIPART)
  {
    const char *const c_show_multipart_alternative = cs_subset_string(NeoMutt->sub, "show_multipart_alternative");
    if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
        mutt_istr_equal("alternative", b->subtype))
    {
      handler = alternative_handler;
    }
    else if (!mutt_str_equal("inline", c_show_multipart_alternative) &&
             mutt_istr_equal("multilingual", b->subtype))
    {
      handler = multilingual_handler;
    }
    else if ((WithCrypto != 0) && mutt_istr_equal("signed", b->subtype))
    {
      if (!mutt_param_get(&b->parameter, "protocol"))
        mutt_error(_("Error: multipart/signed has no protocol"));
      else if (state->flags & STATE_VERIFY)
        handler = mutt_signed_handler;
    }
    else if (mutt_is_valid_multipart_pgp_encrypted(b) == PGP_ENCRYPT)
    {
      encrypted_handler = valid_pgp_encrypted_handler;
      handler = encrypted_handler;
    }
    else if (mutt_is_malformed_multipart_pgp_encrypted(b))
    {
      encrypted_handler = malformed_pgp_encrypted_handler;
      handler = encrypted_handler;
    }
 
    if (!handler)
      handler = multipart_handler;
 
    if ((b->encoding != ENC_7BIT) && (b->encoding != ENC_8BIT) && (b->encoding != ENC_BINARY))
    {
      mutt_debug(LL_DEBUG1, "Bad encoding type %d for multipart entity, assuming 7 bit\n",
                 b->encoding);
      b->encoding = ENC_7BIT;
    }
  }
  else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
  {
    if (OptDontHandlePgpKeys && mutt_istr_equal("pgp-keys", b->subtype))
    {
      /* pass raw part through for key extraction */
      plaintext = true;
    }
    else if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
    {
      encrypted_handler = crypt_pgp_application_handler;
      handler = encrypted_handler;
    }
    else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(b))
    {
      encrypted_handler = crypt_smime_application_handler;
      handler = encrypted_handler;
    }
  }
 
  if ((plaintext || handler) && (is_attachment_display || !mutt_prefer_as_attachment(b)))
  {
    /* only respect disposition == attachment if we're not
     * displaying from the attachment menu (i.e. pager) */
    /* Prevent encrypted attachments from being included in replies
     * unless $include_encrypted is set. */
    const bool c_include_encrypted = cs_subset_bool(NeoMutt->sub, "include_encrypted");
    if ((state->flags & STATE_REPLYING) && (state->flags & STATE_FIRSTDONE) &&
        encrypted_handler && !c_include_encrypted)
    {
      goto cleanup;
    }
 
    rc = run_decode_and_handler(b, state, handler, plaintext);
  }
  else if (state->flags & STATE_DISPLAY)
  {
    /* print hint to use attachment menu for disposition == attachment
     * if we're not already being called from there */
    const bool c_honor_disposition = cs_subset_bool(NeoMutt->sub, "honor_disposition");
    struct Buffer *msg = buf_pool_get();
 
    if (is_attachment_display)
    {
      if (c_honor_disposition && (b->disposition == DISP_ATTACH))
      {
        buf_strcpy(msg, _("[-- This is an attachment --]\n"));
      }
      else
      {
        /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
        buf_printf(msg, _("[-- %s/%s is unsupported --]\n"), BODY_TYPE(b), b->subtype);
      }
    }
    else
    {
      struct Buffer *keystroke = buf_pool_get();
      const struct MenuDefinition *md_pager = pager_get_menu_definition();
      if (keymap_expand_key(km_find_func(md_pager, OP_VIEW_ATTACHMENTS), keystroke))
      {
        if (c_honor_disposition && (b->disposition == DISP_ATTACH))
        {
          /* L10N: %s expands to a keystroke/key binding, e.g. 'v'.  */
          buf_printf(msg, _("[-- This is an attachment (use '%s' to view this part) --]\n"),
                     buf_string(keystroke));
        }
        else
        {
          /* L10N: %s/%s is a MIME type, e.g. "text/plain".
             The last %s expands to a keystroke/key binding, e.g. 'v'. */
          buf_printf(msg, _("[-- %s/%s is unsupported (use '%s' to view this part) --]\n"),
                     BODY_TYPE(b), b->subtype, buf_string(keystroke));
        }
      }
      else
      {
        if (c_honor_disposition && (b->disposition == DISP_ATTACH))
        {
          buf_strcpy(msg, _("[-- This is an attachment (need 'view-attachments' bound to key) --]\n"));
        }
        else
        {
          /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
          buf_printf(msg, _("[-- %s/%s is unsupported (need 'view-attachments' bound to key) --]\n"),
                     BODY_TYPE(b), b->subtype);
        }
      }
      buf_pool_release(&keystroke);
    }
    state_mark_attach(state);
    state_printf(state, "%s", buf_string(msg));
    buf_pool_release(&msg);
  }
 
cleanup:
  recurse_level--;
  state->flags = oflags | (state->flags & STATE_FIRSTDONE);
  if (rc != 0)
  {
    mutt_debug(LL_DEBUG1, "Bailing on attachment of type %s/%s\n", BODY_TYPE(b),
               NONULL(b->subtype));
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_prefer_as_attachment()

bool mutt_prefer_as_attachment

(

struct Body *

b

)

Do we want this part as an attachment?

Parameters

b	Body of email to test

Return values

true	We want this part as an attachment

Definition at line 1894 of file handler.c.

{
  if (!mutt_can_decode(b))
    return true;
 
  if (b->disposition != DISP_ATTACH)
    return false;
 
  return cs_subset_bool(NeoMutt->sub, "honor_disposition");
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_can_decode()

bool mutt_can_decode

(

struct Body *

b

)

Will decoding the attachment produce any output.

Parameters

b	Body of email to test

Return values

true	Decoding the attachment will produce output

Definition at line 1910 of file handler.c.

{
  if (is_autoview(b))
    return true;
  if (b->type == TYPE_TEXT)
    return true;
  if (b->type == TYPE_MESSAGE)
    return true;
  if (b->type == TYPE_MULTIPART)
  {
    if (WithCrypto)
    {
      if (mutt_istr_equal(b->subtype, "signed") || mutt_istr_equal(b->subtype, "encrypted"))
      {
        return true;
      }
    }
 
    for (struct Body *part = b->parts; part; part = part->next)
    {
      if (mutt_can_decode(part))
        return true;
    }
  }
  else if ((WithCrypto != 0) && (b->type == TYPE_APPLICATION))
  {
    if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
      return true;
    if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(b))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_decode_attachment()

void mutt_decode_attachment	(	const struct Body *	b,
		struct State *	state )

Decode an email's attachment.

Parameters

b	Body of the email
state	State of text being processed

Definition at line 1950 of file handler.c.

{
  int istext = mutt_is_text_part(b) && (b->disposition == DISP_INLINE);
  iconv_t cd = ICONV_T_INVALID;
 
  if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
  {
    return;
  }
 
  if (istext && (b->charset || (state->flags & STATE_CHARCONV)))
  {
    const char *charset = b->charset;
    if (!charset)
    {
      charset = mutt_param_get(&b->parameter, "charset");
      if (!charset && !slist_is_empty(cc_assumed_charset()))
        charset = mutt_ch_get_default_charset(cc_assumed_charset());
    }
    if (charset && cc_charset())
      cd = mutt_ch_iconv_open(cc_charset(), charset, MUTT_ICONV_HOOK_FROM);
  }
 
  switch (b->encoding)
  {
    case ENC_QUOTED_PRINTABLE:
      decode_quoted(state, b->length,
                    istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                               mutt_is_application_pgp(b)),
                    cd);
      break;
    case ENC_BASE64:
      mutt_decode_base64(state, b->length,
                         istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                                    mutt_is_application_pgp(b)),
                         cd);
      break;
    case ENC_UUENCODED:
      decode_uuencoded(state, b->length,
                       istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                                  mutt_is_application_pgp(b)),
                       cd);
      break;
    default:
      decode_xbit(state, b->length,
                  istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                             mutt_is_application_pgp(b)),
                  cd);
      break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: