handler.c File Reference

Decide how to display email content. More...

#include "config.h"
#include <stddef.h>
#include <ctype.h>
#include <iconv.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "handler.h"
#include "attach/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "pager/lib.h"
#include "copy.h"
#include "enriched.h"
#include "keymap.h"
#include "mailcap.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "opcodes.h"
#include "options.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
#define	BUFO_SIZE   2000
#define	TXT_HTML   1
#define	TXT_PLAIN   2
#define	TXT_ENRICHED   3

Typedefs
typedef int(*	handler_t) (struct Body *b, struct State *s)

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

Detailed Description

Decide how to display email content.

Authors

• Michael R. Elkins

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

Definition at line 63 of file handler.c.

BUFO_SIZE

#define BUFO_SIZE   2000

Definition at line 64 of file handler.c.

TXT_HTML

#define TXT_HTML   1

Definition at line 66 of file handler.c.

TXT_PLAIN

#define TXT_PLAIN   2

Definition at line 67 of file handler.c.

TXT_ENRICHED

#define TXT_ENRICHED   3

Definition at line 68 of file handler.c.

Typedef Documentation

handler_t

typedef int(* handler_t) (struct Body *b, struct State *s)

Definition at line 80 of file handler.c.

Function Documentation

print_part_line()

static void print_part_line ( struct State *  s, struct Body *  b, int  n  )

static

Print a separator for the Mime part.

Parameters

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

Definition at line 88 of file handler.c.

{
  char length[5];
  mutt_str_pretty_size(length, sizeof(length), b->length);
  state_mark_attach(s);
  char *charset = mutt_param_get(&b->parameter, "charset");
  if (n == 0)
  {
    state_printf(s, _("[-- Type: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
                 TYPE(b), b->subtype, charset ? "; charset=" : "",
                 charset ? charset : "", ENCODING(b->encoding), length);
  }
  else
  {
    state_printf(s, _("[-- Alternative Type #%d: %s/%s%s%s, Encoding: %s, Size: %s --]\n"),
                 n, TYPE(b), b->subtype, charset ? "; charset=" : "",
                 charset ? charset : "", ENCODING(b->encoding), length);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_state()

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

static

Convert text and write it to a file.

Parameters

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

Definition at line 115 of file handler.c.

{
  char bufo[BUFO_SIZE];
  const char *ib = NULL;
  char *ob = NULL;
  size_t ibl, obl;
 
  if (!bufi)
  {
    if (cd != (iconv_t) (-1))
    {
      ob = bufo;
      obl = sizeof(bufo);
      iconv(cd, NULL, NULL, &ob, &obl);
      if (ob != bufo)
        state_prefix_put(s, bufo, ob - bufo);
    }
    return;
  }
 
  if (cd == (iconv_t) (-1))
  {
    state_prefix_put(s, 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(s, 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()

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

static

Decode xbit-encoded text.

Parameters

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

Definition at line 164 of file handler.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

qp_decode_triple()

static 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 209 of file handler.c.

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

Here is the caller graph for this function:

qp_decode_line()

static 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 233 of file handler.c.

{
  char *d = NULL, *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 */
    }
  }
 
  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()

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

static

Decode an attachment encoded with quoted-printable.

Parameters

s	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 301 of file handler.c.

{
  char line[256];
  char decline[512];
  size_t l = 0;
  size_t l3;
 
  if (istext)
    state_set_prefix(s);
 
  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), s->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) && IS_SPACE(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, s);
  }
 
  convert_to_state(cd, 0, 0, s);
  state_reset_prefix(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_byte()

static unsigned char decode_byte ( char  ch )

static

Decode a uuencoded byte.

Parameters

ch	Character to decode

Return values

num	Decoded value

Definition at line 351 of file handler.c.

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

Here is the caller graph for this function:

decode_uuencoded()

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

static

Decode uuencoded text.

Parameters

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

Definition at line 365 of file handler.c.

{
  char tmps[128];
  char *pt = NULL;
  char bufi[BUFI_SIZE];
  size_t k = 0;
 
  if (istext)
    state_set_prefix(s);
 
  while (len > 0)
  {
    if (!fgets(tmps, sizeof(tmps), s->fp_in))
      goto cleanup;
    len -= mutt_str_len(tmps);
    if (mutt_str_startswith(tmps, "begin "))
      break;
  }
  while (len > 0)
  {
    if (!fgets(tmps, sizeof(tmps), s->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, s);
      pt++;
    }
  }
 
cleanup:
  convert_to_state(cd, bufi, &k, s);
  convert_to_state(cd, 0, 0, s);
 
  state_reset_prefix(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_mmnoask()

static 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 427 of file handler.c.

{
  const char *val = mutt_str_getenv("MM_NOASK");
  if (!val)
    return false;
 
  char *p = NULL;
  char tmp[1024];
  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()

static 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 478 of file handler.c.

{
  char type[256];
  bool is_av = false;
 
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
 
  const bool c_implicit_autoview = cs_subset_bool(NeoMutt->sub, "implicit_autoview");
  if (c_implicit_autoview)
  {
    /* $implicit_autoview 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, &AutoViewList, entries)
    {
      int i = mutt_str_len(np->data) - 1;
      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()

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

static

Run an appropriate decoder for an email.

Parameters

b	Body of the email
s	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 1294 of file handler.c.

{
  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(s->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)
    {
      /* decode to a tempfile, saving the original destination */
      fp = s->fp_out;
#ifdef USE_FMEMOPEN
      s->fp_out = open_memstream(&temp, &tempsize);
      if (!s->fp_out)
      {
        mutt_error(_("Unable to open 'memory stream'"));
        mutt_debug(LL_DEBUG1, "Can't open 'memory stream'\n");
        return -1;
      }
#else
      tempfile = mutt_buffer_pool_get();
      mutt_buffer_mktemp(tempfile);
      s->fp_out = mutt_file_fopen(mutt_buffer_string(tempfile), "w");
      if (!s->fp_out)
      {
        mutt_error(_("Unable to open temporary file"));
        mutt_debug(LL_DEBUG1, "Can't open %s\n", mutt_buffer_string(tempfile));
        mutt_buffer_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 = s->prefix;
      s->prefix = NULL;
 
      decode = 1;
    }
    else
      b->type = TYPE_TEXT;
 
    mutt_decode_attachment(b, s);
 
    if (decode)
    {
      b->length = ftello(s->fp_out);
      b->offset = 0;
#ifdef USE_FMEMOPEN
      /* When running under torify, mutt_file_fclose(&s->fp_out) does not seem to
       * update tempsize. On the other hand, fflush does.  See
       * https://github.com/neomutt/neomutt/issues/440 */
      fflush(s->fp_out);
#endif
      mutt_file_fclose(&s->fp_out);
 
      /* restore final destination and substitute the tempfile for input */
      s->fp_out = fp;
      fp = s->fp_in;
#ifdef USE_FMEMOPEN
      if (tempsize)
      {
        s->fp_in = fmemopen(temp, tempsize, "r");
      }
      else
      { /* fmemopen can't handle zero-length buffers */
        s->fp_in = mutt_file_fopen("/dev/null", "r");
      }
      if (!s->fp_in)
      {
        mutt_perror(_("failed to re-open 'memory stream'"));
        FREE(&temp);
        return -1;
      }
#else
      s->fp_in = fopen(mutt_buffer_string(tempfile), "r");
      unlink(mutt_buffer_string(tempfile));
      mutt_buffer_pool_release(&tempfile);
#endif
      /* restore the prefix */
      s->prefix = save_prefix;
    }
 
    b->type = orig_type;
  }
 
  /* process the (decoded) body part */
  if (handler)
  {
    rc = handler(b, s);
    if (rc != 0)
    {
      mutt_debug(LL_DEBUG1, "Failed on attachment of type %s/%s\n", TYPE(b),
                 NONULL(b->subtype));
    }
 
    if (decode)
    {
      b->length = tmplength;
      b->offset = tmpoffset;
 
      /* restore the original source stream */
      mutt_file_fclose(&s->fp_in);
      s->fp_in = fp;
    }
  }
  s->flags |= MUTT_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 *	s,
		size_t	len,
		bool	istext,
		iconv_t	cd
	)

Decode base64-encoded text.

Parameters

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

Definition at line 1498 of file handler.c.

{
  char buf[5];
  int ch, i;
  bool cr = false;
  char bufi[BUFI_SIZE];
  size_t l = 0;
 
  buf[4] = '\0';
 
  if (istext)
    state_set_prefix(s);
 
  while (len > 0)
  {
    for (i = 0; (i < 4) && (len > 0); len--)
    {
      ch = fgetc(s->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]);
    const int c2 = base64val(buf[1]);
 
    /* 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, s);
  }
 
  if (cr)
    bufi[l++] = '\r';
 
  convert_to_state(cd, bufi, &l, s);
  convert_to_state(cd, 0, 0, s);
 
  state_reset_prefix(s);
}

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 *	s
	)

Handler for the Body of an email.

Parameters

b	Body of the email
s	State to work with

Return values

0	Success
-1	Error

Definition at line 1597 of file handler.c.

{
  if (!b || !s)
    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 = s->flags;
  const bool is_attachment_display = (oflags & MUTT_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;
    s->flags &= ~MUTT_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 (s->flags & MUTT_VERIFY)
        handler = mutt_signed_handler;
    }
    else if (mutt_is_valid_multipart_pgp_encrypted(b))
    {
      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;
    }
  }
 
  /* only respect disposition == attachment if we're not
   * displaying from the attachment menu (i.e. pager) */
  if ((plaintext || handler) && (is_attachment_display || !mutt_prefer_as_attachment(b)))
  {
    /* 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 ((s->flags & MUTT_REPLYING) && (s->flags & MUTT_FIRSTDONE) &&
        encrypted_handler && !c_include_encrypted)
    {
      goto cleanup;
    }
 
    rc = run_decode_and_handler(b, s, handler, plaintext);
  }
  /* print hint to use attachment menu for disposition == attachment
   * if we're not already being called from there */
  else if (s->flags & MUTT_DISPLAY)
  {
    const bool c_honor_disposition = cs_subset_bool(NeoMutt->sub, "honor_disposition");
    struct Buffer msg = mutt_buffer_make(256);
 
    if (!is_attachment_display)
    {
      char keystroke[128] = { 0 };
      if (km_expand_key(keystroke, sizeof(keystroke),
                        km_find_func(MENU_PAGER, OP_VIEW_ATTACHMENTS)))
      {
        if (c_honor_disposition && (b->disposition == DISP_ATTACH))
        {
          /* L10N: %s expands to a keystroke/key binding, e.g. 'v'.  */
          mutt_buffer_printf(&msg, _("[-- This is an attachment (use '%s' to view this part) --]\n"),
                             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'. */
          mutt_buffer_printf(&msg, _("[-- %s/%s is unsupported (use '%s' to view this part) --]\n"),
                             TYPE(b), b->subtype, keystroke);
        }
      }
      else
      {
        if (c_honor_disposition && (b->disposition == DISP_ATTACH))
        {
          mutt_buffer_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". */
          mutt_buffer_printf(&msg, _("[-- %s/%s is unsupported (need 'view-attachments' bound to key) --]\n"),
                             TYPE(b), b->subtype);
        }
      }
    }
    else
    {
      if (c_honor_disposition && (b->disposition == DISP_ATTACH))
      {
        mutt_buffer_strcpy(&msg, _("[-- This is an attachment --]\n"));
      }
      else
      {
        /* L10N: %s/%s is a MIME type, e.g. "text/plain". */
        mutt_buffer_printf(&msg, _("[-- %s/%s is unsupported --]\n"), TYPE(b), b->subtype);
      }
    }
    state_mark_attach(s);
    state_printf(s, "%s", mutt_buffer_string(&msg));
    mutt_buffer_dealloc(&msg);
  }
 
cleanup:
  recurse_level--;
  s->flags = oflags | (s->flags & MUTT_FIRSTDONE);
  if (rc != 0)
  {
    mutt_debug(LL_DEBUG1, "Bailing on attachment of type %s/%s\n", 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 1811 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 1827 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	(	struct Body *	b,
		struct State *	s
	)

Decode an email's attachment.

Parameters

b	Body of the email
s	State of text being processed

Definition at line 1867 of file handler.c.

{
  int istext = mutt_is_text_part(b) && (b->disposition == DISP_INLINE);
  iconv_t cd = (iconv_t) (-1);
 
  if (!mutt_file_seek(s->fp_in, b->offset, SEEK_SET))
  {
    return;
  }
 
  if (istext && (b->charset || (s->flags & MUTT_CHARCONV)))
  {
    const char *charset = b->charset;
    if (!charset)
    {
      const struct Slist *const c_assumed_charset = cs_subset_slist(NeoMutt->sub, "assumed_charset");
      charset = mutt_param_get(&b->parameter, "charset");
      if (!charset && c_assumed_charset)
        charset = mutt_ch_get_default_charset();
    }
    const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
    if (charset && c_charset)
      cd = mutt_ch_iconv_open(c_charset, charset, MUTT_ICONV_HOOK_FROM);
  }
 
  switch (b->encoding)
  {
    case ENC_QUOTED_PRINTABLE:
      decode_quoted(s, b->length,
                    istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                               mutt_is_application_pgp(b)),
                    cd);
      break;
    case ENC_BASE64:
      mutt_decode_base64(s, b->length,
                         istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                                    mutt_is_application_pgp(b)),
                         cd);
      break;
    case ENC_UUENCODED:
      decode_uuencoded(s, b->length,
                       istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                                  mutt_is_application_pgp(b)),
                       cd);
      break;
    default:
      decode_xbit(s, b->length,
                  istext || (((WithCrypto & APPLICATION_PGP) != 0) &&
                             mutt_is_application_pgp(b)),
                  cd);
      break;
  }
 
  if (cd != (iconv_t) (-1))
    iconv_close(cd);
}

Here is the call graph for this function:

Here is the caller graph for this function: