handler.h File Reference

Decide how to display email content. More...

#include <iconv.h>
#include <stdbool.h>

Include dependency graph for handler.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	mutt_body_handler (struct Body *b, struct State *state)
	Handler for the Body of an email. 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 *state)
	Decode an email's attachment. More...
void	mutt_decode_base64 (struct State *state, size_t len, bool istext, iconv_t cd)
	Decode base64-encoded text. More...
bool	mutt_prefer_as_attachment (struct Body *b)
	Do we want this part as an 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.h.

Function Documentation

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 1619 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))
    {
      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 ((state->flags & STATE_REPLYING) && (state->flags & STATE_FIRSTDONE) &&
        encrypted_handler && !c_include_encrypted)
    {
      goto cleanup;
    }
 
    rc = run_decode_and_handler(b, state, handler, plaintext);
  }
  /* print hint to use attachment menu for disposition == attachment
   * if we're not already being called from there */
  else if (state->flags & STATE_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(state);
    state_printf(state, "%s", mutt_buffer_string(&msg));
    mutt_buffer_dealloc(&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", TYPE(b),
               NONULL(b->subtype));
  }
 
  return rc;
}

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 1849 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 *	state
	)

Decode an email's attachment.

Parameters

b	Body of the email
state	State of text being processed

Definition at line 1889 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(state->fp_in, b->offset, SEEK_SET))
  {
    return;
  }
 
  if (istext && (b->charset || (state->flags & STATE_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(c_assumed_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(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;
  }
 
  if (cd != (iconv_t) (-1))
    iconv_close(cd);
}

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

{
  char buf[5] = { 0 };
  int ch, 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]);
    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, 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_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 1833 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: