Mime Handler API

Prototype for a function to handle MIME parts. More...

Functions
int	text_enriched_handler (struct Body *b_email, struct State *state)
	Handler for enriched text - Implements handler_t -.
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	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 -.
int	rfc3676_handler (struct Body *b_email, struct State *state)
	Handler for format=flowed - Implements handler_t -.
int	mutt_protected_headers_handler (struct Body *b_email, struct State *state)
	Handler for protected headers - Implements handler_t -.
int	mutt_signed_handler (struct Body *b_email, struct State *state)
	Handler for "multipart/signed" - Implements handler_t -.
int	crypt_pgp_application_handler (struct Body *b_email, struct State *state)
	Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.
int	crypt_pgp_encrypted_handler (struct Body *b_email, struct State *state)
	Wrapper for CryptModuleSpecs::encrypted_handler() - Implements handler_t -.
int	crypt_smime_application_handler (struct Body *b_email, struct State *state)
	Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.

Detailed Description

Prototype for a function to handle MIME parts.

Parameters

b_email	Body of the email
state	State of text being processed

Return values

0	Success
-1	Error

Function Documentation

text_enriched_handler()

int text_enriched_handler	(	struct Body *	b_email,
		struct State *	state )

Handler for enriched text - Implements handler_t -.

Return values

0

Always

Definition at line 473 of file enriched.c.

{
  enum
  {
    TEXT,
    LANGLE,
    TAG,
    BOGUS_TAG,
    NEWLINE,
    ST_EOF,
    DONE
  } text_state = TEXT;
 
  long bytes = b_email->length;
  struct EnrichedState enriched = { 0 };
  wint_t wc = 0;
  int tag_len = 0;
  wchar_t tag[1024 + 1];
 
  enriched.state = state;
  enriched.wrap_margin = ((state->wraplen > 4) &&
                          ((state->flags & STATE_DISPLAY) || (state->wraplen < 76))) ?
                             state->wraplen - 4 :
                             72;
  enriched.line_max = enriched.wrap_margin * 4;
  enriched.line = MUTT_MEM_CALLOC(enriched.line_max + 1, wchar_t);
  enriched.param = MUTT_MEM_CALLOC(256, wchar_t);
 
  enriched.param_len = 256;
  enriched.param_used = 0;
 
  if (state->prefix)
  {
    state_puts(state, state->prefix);
    enriched.indent_len += mutt_str_len(state->prefix);
  }
 
  while (text_state != DONE)
  {
    if (text_state != ST_EOF)
    {
      if (!bytes || ((wc = fgetwc(state->fp_in)) == WEOF))
        text_state = ST_EOF;
      else
        bytes--;
    }
 
    switch (text_state)
    {
      case TEXT:
        switch (wc)
        {
          case '<':
            text_state = LANGLE;
            break;
 
          case '\n':
            if (enriched.tag_level[RICH_NOFILL])
            {
              enriched_flush(&enriched, true);
            }
            else
            {
              enriched_putwc((wchar_t) ' ', &enriched);
              text_state = NEWLINE;
            }
            break;
 
          default:
            enriched_putwc(wc, &enriched);
        }
        break;
 
      case LANGLE:
        if (wc == (wchar_t) '<')
        {
          enriched_putwc(wc, &enriched);
          text_state = TEXT;
          break;
        }
        else
        {
          tag_len = 0;
          text_state = TAG;
        }
        /* Yes, (it wasn't a <<, so this char is first in TAG) */
        FALLTHROUGH;
 
      case TAG:
        if (wc == (wchar_t) '>')
        {
          tag[tag_len] = (wchar_t) '\0';
          enriched_set_flags(tag, &enriched);
          text_state = TEXT;
        }
        else if (tag_len < 1024) /* ignore overly long tags */
        {
          tag[tag_len++] = wc;
        }
        else
        {
          text_state = BOGUS_TAG;
        }
        break;
 
      case BOGUS_TAG:
        if (wc == (wchar_t) '>')
          text_state = TEXT;
        break;
 
      case NEWLINE:
        if (wc == (wchar_t) '\n')
        {
          enriched_flush(&enriched, true);
        }
        else
        {
          ungetwc(wc, state->fp_in);
          bytes++;
          text_state = TEXT;
        }
        break;
 
      case ST_EOF:
        enriched_putwc((wchar_t) '\0', &enriched);
        enriched_flush(&enriched, true);
        text_state = DONE;
        break;
 
      default:
        /* not reached */
        break;
    }
  }
 
  state_putc(state, '\n'); /* add a final newline */
 
  FREE(&(enriched.buffer));
  FREE(&(enriched.line));
  FREE(&(enriched.param));
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

autoview_handler()

static int autoview_handler ( struct Body * b_email, struct State * state )

static

Handler for autoviewable attachments - Implements handler_t -.

Definition at line 541 of file handler.c.

{
  struct MailcapEntry *entry = mailcap_entry_new();
  char buf[1024] = { 0 };
  char type[256] = { 0 };
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *tempfile = buf_pool_get();
  char *fname = NULL;
  FILE *fp_in = NULL;
  FILE *fp_out = NULL;
  FILE *fp_err = NULL;
  pid_t pid;
  int rc = 0;
 
  snprintf(type, sizeof(type), "%s/%s", BODY_TYPE(b_email), b_email->subtype);
  mailcap_lookup(b_email, type, sizeof(type), entry, MUTT_MC_AUTOVIEW);
 
  fname = mutt_str_dup(b_email->filename);
  mutt_file_sanitize_filename(fname, true);
  mailcap_expand_filename(entry->nametemplate, fname, tempfile);
  FREE(&fname);
 
  if (entry->command)
  {
    buf_strcpy(cmd, entry->command);
 
    /* mailcap_expand_command returns 0 if the file is required */
    bool piped = mailcap_expand_command(b_email, buf_string(tempfile), type, cmd);
 
    if (state->flags & STATE_DISPLAY)
    {
      state_mark_attach(state);
      state_printf(state, _("[-- Autoview using %s --]\n"), buf_string(cmd));
      mutt_message(_("Invoking autoview command: %s"), buf_string(cmd));
    }
 
    fp_in = mutt_file_fopen(buf_string(tempfile), "w+");
    if (!fp_in)
    {
      mutt_perror("fopen");
      mailcap_entry_free(&entry);
      rc = -1;
      goto cleanup;
    }
 
    mutt_file_copy_bytes(state->fp_in, fp_in, b_email->length);
 
    if (piped)
    {
      unlink(buf_string(tempfile));
      fflush(fp_in);
      rewind(fp_in);
      pid = filter_create_fd(buf_string(cmd), NULL, &fp_out, &fp_err,
                             fileno(fp_in), -1, -1, NeoMutt->env);
    }
    else
    {
      mutt_file_fclose(&fp_in);
      pid = filter_create(buf_string(cmd), NULL, &fp_out, &fp_err, NeoMutt->env);
    }
 
    if (pid < 0)
    {
      mutt_perror(_("Can't create filter"));
      if (state->flags & STATE_DISPLAY)
      {
        state_mark_attach(state);
        state_printf(state, _("[-- Can't run %s --]\n"), buf_string(cmd));
      }
      rc = -1;
      goto bail;
    }
 
    if (state->prefix)
    {
      /* Remove ansi and formatting from autoview output in replies only.  The
       * user may want to see the formatting in the pager, but it shouldn't be
       * in their quoted reply text too.  */
      struct Buffer *stripped = buf_pool_get();
      while (fgets(buf, sizeof(buf), fp_out))
      {
        buf_strip_formatting(stripped, buf, false);
        state_puts(state, state->prefix);
        state_puts(state, buf_string(stripped));
      }
      buf_pool_release(&stripped);
 
      /* check for data on stderr */
      if (fgets(buf, sizeof(buf), fp_err))
      {
        if (state->flags & STATE_DISPLAY)
        {
          state_mark_attach(state);
          state_printf(state, _("[-- Autoview stderr of %s --]\n"), buf_string(cmd));
        }
 
        state_puts(state, state->prefix);
        state_puts(state, buf);
        while (fgets(buf, sizeof(buf), fp_err))
        {
          state_puts(state, state->prefix);
          state_puts(state, buf);
        }
      }
    }
    else
    {
      mutt_file_copy_stream(fp_out, state->fp_out);
      /* Check for stderr messages */
      if (fgets(buf, sizeof(buf), fp_err))
      {
        if (state->flags & STATE_DISPLAY)
        {
          state_mark_attach(state);
          state_printf(state, _("[-- Autoview stderr of %s --]\n"), buf_string(cmd));
        }
 
        state_puts(state, buf);
        mutt_file_copy_stream(fp_err, state->fp_out);
      }
    }
 
  bail:
    mutt_file_fclose(&fp_out);
    mutt_file_fclose(&fp_err);
 
    filter_wait(pid);
    if (piped)
      mutt_file_fclose(&fp_in);
    else
      mutt_file_unlink(buf_string(tempfile));
 
    if (state->flags & STATE_DISPLAY)
      mutt_clear_error();
  }
 
cleanup:
  mailcap_entry_free(&entry);
 
  buf_pool_release(&cmd);
  buf_pool_release(&tempfile);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

text_plain_handler()

static int text_plain_handler ( struct Body * b_email, struct State * state )

static

Handler for plain text - Implements handler_t -.

Return values

0

Always

When generating format=flowed ($text_flowed is set) from format=fixed, strip all trailing spaces to improve interoperability; if $text_flowed is unset, simply verbatim copy input.

Definition at line 694 of file handler.c.

{
  char *buf = NULL;
  size_t sz = 0;
 
  const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
  while ((buf = mutt_file_read_line(buf, &sz, state->fp_in, NULL, MUTT_RL_NO_FLAGS)))
  {
    if (!mutt_str_equal(buf, "-- ") && c_text_flowed)
    {
      size_t len = mutt_str_len(buf);
      while ((len > 0) && (buf[len - 1] == ' '))
        buf[--len] = '\0';
    }
    if (state->prefix)
      state_puts(state, state->prefix);
    state_puts(state, buf);
    state_putc(state, '\n');
  }
 
  FREE(&buf);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

message_handler()

static int message_handler ( struct Body * b_email, struct State * state )

static

Handler for message/rfc822 body parts - Implements handler_t -.

Definition at line 721 of file handler.c.

{
  struct Body *b = NULL;
  LOFF_T off_start;
  int rc = 0;
 
  off_start = ftello(state->fp_in);
  if (off_start < 0)
    return -1;
 
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    b = mutt_body_new();
    b->length = mutt_file_get_size_fp(state->fp_in);
    b->parts = mutt_rfc822_parse_message(state->fp_in, b);
  }
  else
  {
    b = b_email;
  }
 
  if (b->parts)
  {
    CopyHeaderFlags chflags = CH_DECODE | CH_FROM;
    const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
    if ((state->flags & STATE_WEED) ||
        ((state->flags & (STATE_DISPLAY | STATE_PRINTING)) && c_weed))
    {
      chflags |= CH_WEED | CH_REORDER;
    }
    if (state->prefix)
      chflags |= CH_PREFIX;
    if (state->flags & STATE_DISPLAY)
      chflags |= CH_DISPLAY;
 
    mutt_copy_hdr(state->fp_in, state->fp_out, off_start, b->parts->offset,
                  chflags, state->prefix, 0);
 
    if (state->prefix)
      state_puts(state, state->prefix);
    state_putc(state, '\n');
 
    rc = mutt_body_handler(b->parts, state);
  }
 
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    mutt_body_free(&b);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

external_body_handler()

static int external_body_handler ( struct Body * b_email, struct State * state )

static

Handler for external-body emails - Implements handler_t -.

Definition at line 779 of file handler.c.

{
  const char *access_type = mutt_param_get(&b_email->parameter, "access-type");
  if (!access_type)
  {
    if (state->flags & STATE_DISPLAY)
    {
      state_mark_attach(state);
      state_puts(state, _("[-- Error: message/external-body has no access-type parameter --]\n"));
      return 0;
    }
    else
    {
      return -1;
    }
  }
 
  const char *fmt = NULL;
  struct Buffer *banner = buf_pool_get();
 
  const char *expiration = mutt_param_get(&b_email->parameter, "expiration");
  time_t expire;
  if (expiration)
    expire = mutt_date_parse_date(expiration, NULL);
  else
    expire = -1;
 
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  if (mutt_istr_equal(access_type, "x-mutt-deleted"))
  {
    if (state->flags & (STATE_DISPLAY | STATE_PRINTING))
    {
      struct Buffer *pretty_size = buf_pool_get();
      char *length = mutt_param_get(&b_email->parameter, "length");
      if (length)
      {
        const long size = strtol(length, NULL, 10);
        mutt_str_pretty_size(pretty_size, size);
        if (expire != -1)
        {
          fmt = ngettext(
              /* L10N: If the translation of this string is a multi line string, then
                 each line should start with "[-- " and end with " --]".
                 The first "%s/%s" is a MIME type, e.g. "text/plain". The last %s
                 expands to a date as returned by `mutt_date_parse_date()`.
 
                 Note: The size argument printed is not the actual number as passed
                 to gettext but the prettified version, e.g. size = 2048 will be
                 printed as 2K.  Your language might be sensitive to that: For
                 example although '1K' and '1024' represent the same number your
                 language might inflect the noun 'byte' differently.
 
                 Sadly, we can't do anything about that at the moment besides
                 passing the precise size in bytes. If you are interested the
                 function responsible for the prettification is
                 mutt_str_pretty_size() in muttlib.c */
              "[-- This %s/%s attachment (size %s byte) has been deleted --]\n"
              "[-- on %s --]\n",
              "[-- This %s/%s attachment (size %s bytes) has been deleted --]\n"
              "[-- on %s --]\n",
              size);
        }
        else
        {
          fmt = ngettext(
              /* L10N: If the translation of this string is a multi line string, then
                 each line should start with "[-- " and end with " --]".
                 The first "%s/%s" is a MIME type, e.g. "text/plain".
 
                 Note: The size argument printed is not the actual number as passed
                 to gettext but the prettified version, e.g. size = 2048 will be
                 printed as 2K.  Your language might be sensitive to that: For
                 example although '1K' and '1024' represent the same number your
                 language might inflect the noun 'byte' differently.
 
                 Sadly, we can't do anything about that at the moment besides
                 passing the precise size in bytes. If you are interested the
                 function responsible for the prettification is
                 mutt_str_pretty_size() in muttlib.c  */
              "[-- This %s/%s attachment (size %s byte) has been deleted --]\n",
              "[-- This %s/%s attachment (size %s bytes) has been deleted --]\n", size);
        }
      }
      else
      {
        if (expire != -1)
        {
          /* L10N: If the translation of this string is a multi line string, then
             each line should start with "[-- " and end with " --]".
             The first "%s/%s" is a MIME type, e.g. "text/plain". The last %s
             expands to a date as returned by `mutt_date_parse_date()`.
 
             Caution: Argument three %3$ is also defined but should not be used
             in this translation!  */
          fmt = _("[-- This %s/%s attachment has been deleted --]\n[-- on %4$s --]\n");
        }
        else
        {
          /* L10N: If the translation of this string is a multi line string, then
             each line should start with "[-- " and end with " --]".
             The first "%s/%s" is a MIME type, e.g. "text/plain". */
          fmt = _("[-- This %s/%s attachment has been deleted --]\n");
        }
      }
 
      buf_printf(banner, fmt, BODY_TYPE(b_email->parts),
                 b_email->parts->subtype, buf_string(pretty_size), expiration);
      state_attach_puts(state, buf_string(banner));
      if (b_email->parts->filename)
      {
        state_mark_attach(state);
        state_printf(state, _("[-- name: %s --]\n"), b_email->parts->filename);
      }
 
      CopyHeaderFlags chflags = CH_DECODE;
      if (c_weed)
        chflags |= CH_WEED | CH_REORDER;
 
      mutt_copy_hdr(state->fp_in, state->fp_out, ftello(state->fp_in),
                    b_email->parts->offset, chflags, NULL, 0);
      buf_pool_release(&pretty_size);
    }
  }
  else if (expiration && (expire < mutt_date_now()))
  {
    if (state->flags & STATE_DISPLAY)
    {
      /* L10N: If the translation of this string is a multi line string, then
         each line should start with "[-- " and end with " --]".
         The "%s/%s" is a MIME type, e.g. "text/plain". */
      buf_printf(banner, _("[-- This %s/%s attachment is not included, --]\n[-- and the indicated external source has expired --]\n"),
                 BODY_TYPE(b_email->parts), b_email->parts->subtype);
      state_attach_puts(state, buf_string(banner));
 
      CopyHeaderFlags chflags = CH_DECODE | CH_DISPLAY;
      if (c_weed)
        chflags |= CH_WEED | CH_REORDER;
 
      mutt_copy_hdr(state->fp_in, state->fp_out, ftello(state->fp_in),
                    b_email->parts->offset, chflags, NULL, 0);
    }
  }
  else
  {
    if (state->flags & STATE_DISPLAY)
    {
      /* L10N: If the translation of this string is a multi line string, then
         each line should start with "[-- " and end with " --]".
         The "%s/%s" is a MIME type, e.g. "text/plain".  The %s after
         access-type is an access-type as defined by the MIME RFCs, e.g. "FTP",
         "LOCAL-FILE", "MAIL-SERVER". */
      buf_printf(banner, _("[-- This %s/%s attachment is not included, --]\n[-- and the indicated access-type %s is unsupported --]\n"),
                 BODY_TYPE(b_email->parts), b_email->parts->subtype, access_type);
      state_attach_puts(state, buf_string(banner));
 
      CopyHeaderFlags chflags = CH_DECODE | CH_DISPLAY;
      if (c_weed)
        chflags |= CH_WEED | CH_REORDER;
 
      mutt_copy_hdr(state->fp_in, state->fp_out, ftello(state->fp_in),
                    b_email->parts->offset, chflags, NULL, 0);
    }
  }
  buf_pool_release(&banner);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alternative_handler()

static int alternative_handler ( struct Body * b_email, struct State * state )

static

Handler for multipart alternative emails - Implements handler_t -.

Definition at line 950 of file handler.c.

{
  struct Body *const head = b_email;
  struct Body *choice = NULL;
  struct Body *b = NULL;
  bool mustfree = false;
  int rc = 0;
 
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    mustfree = true;
    b = mutt_body_new();
    b->length = mutt_file_get_size_fp(state->fp_in);
    b->parts = mutt_parse_multipart(state->fp_in,
                                    mutt_param_get(&b_email->parameter, "boundary"),
                                    b->length,
                                    mutt_istr_equal("digest", b_email->subtype));
  }
  else
  {
    b = b_email;
  }
 
  b_email = b;
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  /* First, search list of preferred types */
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &mod_data->alternative_order, entries)
  {
    int btlen; /* length of basetype */
    bool wild; /* do we have a wildcard to match all subtypes? */
 
    char *c = strchr(np->data, '/');
    if (c)
    {
      wild = ((c[1] == '*') && (c[2] == '\0'));
      btlen = c - np->data;
    }
    else
    {
      wild = true;
      btlen = mutt_str_len(np->data);
    }
 
    if (b_email->parts)
      b = b_email->parts;
    else
      b = b_email;
    while (b)
    {
      const char *bt = BODY_TYPE(b);
      if (mutt_istrn_equal(bt, np->data, btlen) && (bt[btlen] == 0))
      {
        /* the basetype matches */
        if (wild || mutt_istr_equal(np->data + btlen + 1, b->subtype))
        {
          choice = b;
        }
      }
      b = b->next;
    }
 
    if (choice)
      break;
  }
 
  /* Next, look for an autoviewable type */
  if (!choice)
  {
    if (b_email->parts)
      b = b_email->parts;
    else
      b = b_email;
    while (b)
    {
      if (is_autoview(b))
        choice = b;
      b = b->next;
    }
  }
 
  /* Then, look for a text entry */
  if (!choice)
  {
    if (b_email->parts)
      b = b_email->parts;
    else
      b = b_email;
    int type = 0;
    while (b)
    {
      if (b->type == TYPE_TEXT)
      {
        if (mutt_istr_equal("plain", b->subtype) && (type <= TXT_PLAIN))
        {
          choice = b;
          type = TXT_PLAIN;
        }
        else if (mutt_istr_equal("enriched", b->subtype) && (type <= TXT_ENRICHED))
        {
          choice = b;
          type = TXT_ENRICHED;
        }
        else if (mutt_istr_equal("html", b->subtype) && (type <= TXT_HTML))
        {
          choice = b;
          type = TXT_HTML;
        }
      }
      b = b->next;
    }
  }
 
  /* Finally, look for other possibilities */
  if (!choice)
  {
    if (b_email->parts)
      b = b_email->parts;
    else
      b = b_email;
    while (b)
    {
      if (mutt_can_decode(b))
        choice = b;
      b = b->next;
    }
  }
 
  if (choice)
  {
    const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
    if (state->flags & STATE_DISPLAY && !c_weed &&
        mutt_file_seek(state->fp_in, choice->hdr_offset, SEEK_SET))
    {
      mutt_file_copy_bytes(state->fp_in, state->fp_out, choice->offset - choice->hdr_offset);
    }
 
    const char *const c_show_multipart_alternative = cs_subset_string(NeoMutt->sub, "show_multipart_alternative");
    if (mutt_str_equal("info", c_show_multipart_alternative))
    {
      print_part_line(state, choice, 0);
    }
    mutt_body_handler(choice, state);
 
    /* Let it flow back to the main part */
    head->nowrap = choice->nowrap;
    choice->nowrap = false;
 
    if (mutt_str_equal("info", c_show_multipart_alternative))
    {
      if (b_email->parts)
        b = b_email->parts;
      else
        b = b_email;
      int count = 0;
      while (b)
      {
        if (choice != b)
        {
          count += 1;
          if (count == 1)
            state_putc(state, '\n');
 
          print_part_line(state, b, count);
        }
        b = b->next;
      }
    }
  }
  else if (state->flags & STATE_DISPLAY)
  {
    /* didn't find anything that we could display! */
    state_mark_attach(state);
    state_puts(state, _("[-- Error: Could not display any parts of Multipart/Alternative --]\n"));
    rc = -1;
  }
 
  if (mustfree)
    mutt_body_free(&b_email);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multilingual_handler()

static int multilingual_handler ( struct Body * b_email, struct State * state )

static

Handler for multi-lingual emails - Implements handler_t -.

Return values

0

Always

Definition at line 1141 of file handler.c.

{
  struct Body *b = NULL;
  bool mustfree = false;
  int rc = 0;
 
  mutt_debug(LL_DEBUG2, "RFC8255 >> entering in handler multilingual handler\n");
  /* If the body is transfer-encoded, decode it and re-parse the MIME parts */
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    mustfree = true;
    b = mutt_body_new();
    b->length = mutt_file_get_size_fp(state->fp_in);
    b->parts = mutt_parse_multipart(state->fp_in,
                                    mutt_param_get(&b_email->parameter, "boundary"),
                                    b->length,
                                    mutt_istr_equal("digest", b_email->subtype));
  }
  else
  {
    b = b_email;
  }
 
  b_email = b;
 
  if (b_email->parts)
    b = b_email->parts;
  else
    b = b_email;
 
  struct Body *choice = NULL;
  struct Body *first_part = NULL;
  struct Body *zxx_part = NULL;
  struct ListNode *np = NULL;
 
  /* Find the first decodable part as a fallback */
  while (b)
  {
    if (mutt_can_decode(b))
    {
      first_part = b;
      break;
    }
    b = b->next;
  }
 
  /* Search for a part matching the user's preferred languages (RFC 8255).
   * Also track any "zxx" (no linguistic content) part as a secondary fallback. */
  const struct Slist *c_preferred_languages = cs_subset_slist(NeoMutt->sub, "preferred_languages");
  if (c_preferred_languages)
  {
    struct Buffer *langs = buf_pool_get();
    cs_subset_str_string_get(NeoMutt->sub, "preferred_languages", langs);
    mutt_debug(LL_DEBUG2, "RFC8255 >> preferred_languages set in config to '%s'\n",
               buf_string(langs));
    buf_pool_release(&langs);
 
    STAILQ_FOREACH(np, &c_preferred_languages->head, entries)
    {
      while (b)
      {
        if (mutt_can_decode(b))
        {
          if (b->language && mutt_str_equal("zxx", b->language))
            zxx_part = b;
 
          mutt_debug(LL_DEBUG2, "RFC8255 >> comparing configuration preferred_language='%s' to mail part content-language='%s'\n",
                     np->data, b->language);
          if (b->language && mutt_str_equal(np->data, b->language))
          {
            mutt_debug(LL_DEBUG2, "RFC8255 >> preferred_language='%s' matches content-language='%s' >> part selected to be displayed\n",
                       np->data, b->language);
            choice = b;
            break;
          }
        }
 
        b = b->next;
      }
 
      if (choice)
        break;
 
      if (b_email->parts)
        b = b_email->parts;
      else
        b = b_email;
    }
  }
 
  /* Display the best match: preferred language > zxx > first decodable part */
  if (choice)
  {
    mutt_body_handler(choice, state);
  }
  else
  {
    if (zxx_part)
      mutt_body_handler(zxx_part, state);
    else if (first_part)
      mutt_body_handler(first_part, state);
  }
 
  if (mustfree)
    mutt_body_free(&b_email);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multipart_handler()

static int multipart_handler ( struct Body * b_email, struct State * state )

static

Handler for multipart emails - Implements handler_t -.

Definition at line 1254 of file handler.c.

{
  struct Body *b = NULL, *p = NULL;
  int count;
  int rc = 0;
 
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    b = mutt_body_new();
    b->length = mutt_file_get_size_fp(state->fp_in);
    b->parts = mutt_parse_multipart(state->fp_in,
                                    mutt_param_get(&b_email->parameter, "boundary"),
                                    b->length,
                                    mutt_istr_equal("digest", b_email->subtype));
  }
  else
  {
    b = b_email;
  }
 
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  const bool c_include_only_first = cs_subset_bool(NeoMutt->sub, "include_only_first");
 
  for (p = b->parts, count = 1; p; p = p->next, count++)
  {
    if (state->flags & STATE_DISPLAY)
    {
      state_mark_attach(state);
      if (p->description || p->filename || p->form_name)
      {
        /* L10N: %s is the attachment description, filename or form_name. */
        state_printf(state, _("[-- Attachment #%d: %s --]\n"), count,
                     p->description ? p->description :
                     p->filename    ? p->filename :
                                      p->form_name);
      }
      else
      {
        state_printf(state, _("[-- Attachment #%d --]\n"), count);
      }
      print_part_line(state, p, 0);
      if (c_weed)
      {
        state_putc(state, '\n');
      }
      else if (mutt_file_seek(state->fp_in, p->hdr_offset, SEEK_SET))
      {
        mutt_file_copy_bytes(state->fp_in, state->fp_out, p->offset - p->hdr_offset);
      }
    }
 
    rc = mutt_body_handler(p, state);
    state_putc(state, '\n');
 
    if (rc != 0)
    {
      mutt_error(_("One or more parts of this message could not be displayed"));
      mutt_debug(LL_DEBUG1, "Failed on attachment #%d, type %s/%s\n", count,
                 BODY_TYPE(p), NONULL(p->subtype));
    }
 
    if ((state->flags & STATE_REPLYING) && c_include_only_first && (state->flags & STATE_FIRSTDONE))
    {
      break;
    }
  }
 
  if ((b_email->encoding == ENC_BASE64) || (b_email->encoding == ENC_QUOTED_PRINTABLE) ||
      (b_email->encoding == ENC_UUENCODED))
  {
    mutt_body_free(&b);
  }
 
  /* make failure of a single part non-fatal */
  if (rc < 0)
    rc = 1;
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

valid_pgp_encrypted_handler()

static int valid_pgp_encrypted_handler ( struct Body * b_email, struct State * state )

static

Handler for valid pgp-encrypted emails - Implements handler_t -.

Definition at line 1501 of file handler.c.

{
  struct Body *octetstream = b_email->parts->next;
 
  /* clear out any mime headers before the handler, so they can't be spoofed. */
  mutt_env_free(&b_email->mime_headers);
  mutt_env_free(&octetstream->mime_headers);
 
  int rc;
  /* Some clients improperly encode the octetstream part. */
  if (octetstream->encoding != ENC_7BIT)
    rc = run_decode_and_handler(octetstream, state, crypt_pgp_encrypted_handler, 0);
  else
    rc = crypt_pgp_encrypted_handler(octetstream, state);
  b_email->goodsig |= octetstream->goodsig;
 
  /* Relocate protected headers onto the multipart/encrypted part */
  if (!rc && octetstream->mime_headers)
  {
    b_email->mime_headers = octetstream->mime_headers;
    octetstream->mime_headers = NULL;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

malformed_pgp_encrypted_handler()

static int malformed_pgp_encrypted_handler ( struct Body * b_email, struct State * state )

static

Handler for invalid pgp-encrypted emails - Implements handler_t -.

Definition at line 1530 of file handler.c.

{
  if (!b_email->parts || !b_email->parts->next || !b_email->parts->next->next)
    return -1;
 
  struct Body *octetstream = b_email->parts->next->next;
 
  /* clear out any mime headers before the handler, so they can't be spoofed. */
  mutt_env_free(&b_email->mime_headers);
  mutt_env_free(&octetstream->mime_headers);
 
  /* exchange encodes the octet-stream, so re-run it through the decoder */
  int rc = run_decode_and_handler(octetstream, state, crypt_pgp_encrypted_handler, false);
  b_email->goodsig |= octetstream->goodsig;
#ifdef USE_AUTOCRYPT
  b_email->is_autocrypt |= octetstream->is_autocrypt;
#endif
 
  /* Relocate protected headers onto the multipart/encrypted part */
  if (!rc && octetstream->mime_headers)
  {
    b_email->mime_headers = octetstream->mime_headers;
    octetstream->mime_headers = NULL;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfc3676_handler()

int rfc3676_handler	(	struct Body *	b_email,
		struct State *	state )

Handler for format=flowed - Implements handler_t -.

Return values

0

Always

Definition at line 327 of file rfc3676.c.

{
  char *buf = NULL;
  unsigned int quotelevel = 0;
  bool delsp = false;
  size_t sz = 0;
  struct FlowedState fst = { 0 };
 
  /* respect DelSp of RFC3676 only with f=f parts */
  char *t = mutt_param_get(&b_email->parameter, "delsp");
  if (t)
  {
    delsp = mutt_istr_equal(t, "yes");
    t = NULL;
    fst.delsp = true;
  }
 
  mutt_debug(LL_DEBUG3, "f=f: DelSp: %s\n", delsp ? "yes" : "no");
 
  while ((buf = mutt_file_read_line(buf, &sz, state->fp_in, NULL, MUTT_RL_NO_FLAGS)))
  {
    const size_t buflen = mutt_str_len(buf);
    const unsigned int newql = get_quote_level(buf);
 
    /* end flowed paragraph (if we're within one) if quoting level
     * changes (should not but can happen, see RFC3676, sec. 4.5.) */
    if (newql != quotelevel)
      flush_par(state, &fst);
 
    quotelevel = newql;
    int buf_off = newql;
 
    /* respect sender's space-stuffing by removing one leading space */
    if (buf[buf_off] == ' ')
      buf_off++;
 
    /* test for signature separator */
    const unsigned int sigsep = mutt_str_equal(buf + buf_off, "-- ");
 
    /* a fixed line either has no trailing space or is the
     * signature separator */
    const bool fixed = (buflen == buf_off) || (buf[buflen - 1] != ' ') || sigsep;
 
    /* print fixed-and-standalone, fixed-and-empty and sigsep lines as
     * fixed lines */
    if ((fixed && ((fst.width == 0) || (buflen == 0))) || sigsep)
    {
      /* if we're within a flowed paragraph, terminate it */
      flush_par(state, &fst);
      print_fixed_line(buf + buf_off, state, quotelevel, &fst);
      continue;
    }
 
    /* for DelSp=yes, we need to strip one SP prior to CRLF on flowed lines */
    if (delsp && !fixed)
      buf[buflen - 1] = '\0';
 
    print_flowed_line(buf + buf_off, state, quotelevel, &fst, fixed);
  }
 
  flush_par(state, &fst);
 
  FREE(&buf);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_protected_headers_handler()

int mutt_protected_headers_handler	(	struct Body *	b_email,
		struct State *	state )

Handler for protected headers - Implements handler_t -.

Definition at line 1122 of file crypt.c.

{
  if (!cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read"))
    return 0;
 
  state_mark_protected_header(state);
 
  if (!b_email->mime_headers)
    goto blank;
 
  /* Load display preferences: weeding, wrapping, and security debug flags */
  const bool c_devel_security = cs_subset_bool(NeoMutt->sub, "devel_security");
  const bool display = (state->flags & STATE_DISPLAY);
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  const bool c_crypt_protected_headers_weed = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_weed");
  const short c_wrap = cs_subset_number(NeoMutt->sub, "wrap");
  const int wraplen = display ? mutt_window_wrap_cols(state->wraplen, c_wrap) : 0;
  const CopyHeaderFlags chflags = display ? CH_DISPLAY : CH_NO_FLAGS;
  struct Buffer *buf = buf_pool_get();
  bool weed = (display && c_weed && c_crypt_protected_headers_weed);
 
  /* When devel_security is enabled, output all protected envelope headers
   * (Date, From, To, Cc, etc.) subject to weed rules */
  if (c_devel_security)
  {
    if (b_email->mime_headers->date && (!display || !c_weed || !mutt_matches_ignore("date")))
    {
      mutt_write_one_header(state->fp_out, "Date", b_email->mime_headers->date,
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
 
    if (!weed || !mutt_matches_ignore("return-path"))
    {
      mutt_addrlist_write(&b_email->mime_headers->return_path, buf, display);
      mutt_write_one_header(state->fp_out, "Return-Path", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("from"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->from, buf, display);
      mutt_write_one_header(state->fp_out, "From", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("to"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->to, buf, display);
      mutt_write_one_header(state->fp_out, "To", buf_string(buf), state->prefix,
                            wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("cc"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->cc, buf, display);
      mutt_write_one_header(state->fp_out, "Cc", buf_string(buf), state->prefix,
                            wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("sender"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->sender, buf, display);
      mutt_write_one_header(state->fp_out, "Sender", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("reply-to"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->reply_to, buf, display);
      mutt_write_one_header(state->fp_out, "Reply-To", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("mail-followup-to"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->mail_followup_to, buf, display);
      mutt_write_one_header(state->fp_out, "Mail-Followup-To", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("x-original-to"))
    {
      buf_reset(buf);
      mutt_addrlist_write(&b_email->mime_headers->x_original_to, buf, display);
      mutt_write_one_header(state->fp_out, "X-Original-To", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
  }
 
  if (b_email->mime_headers->subject && (!weed || !mutt_matches_ignore("subject")))
  {
    mutt_write_one_header(state->fp_out, "Subject", b_email->mime_headers->subject,
                          state->prefix, wraplen, chflags, NeoMutt->sub);
  }
 
  if (c_devel_security)
  {
    if (b_email->mime_headers->message_id && (!weed || !mutt_matches_ignore("message-id")))
    {
      mutt_write_one_header(state->fp_out, "Message-ID", b_email->mime_headers->message_id,
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("references"))
    {
      buf_reset(buf);
      mutt_list_write(&b_email->mime_headers->references, buf);
      mutt_write_one_header(state->fp_out, "References", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
    if (!weed || !mutt_matches_ignore("in-reply-to"))
    {
      buf_reset(buf);
      mutt_list_write(&b_email->mime_headers->in_reply_to, buf);
      mutt_write_one_header(state->fp_out, "In-Reply-To", buf_string(buf),
                            state->prefix, wraplen, chflags, NeoMutt->sub);
    }
  }
 
  buf_pool_release(&buf);
 
blank:
  state_puts(state, "\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_signed_handler()

int mutt_signed_handler	(	struct Body *	b_email,
		struct State *	state )

Handler for "multipart/signed" - Implements handler_t -.

Definition at line 1249 of file crypt.c.

{
  if (!WithCrypto)
    return -1;
 
  bool inconsistent = false;
  struct Body *top = b_email;
  struct Body **signatures = NULL;
  int sigcnt = 0;
  int rc = 0;
  struct Buffer *tempfile = NULL;
 
  /* Identify the signature type from the multipart/signed protocol parameter */
  b_email = b_email->parts;
  SecurityFlags signed_type = mutt_is_multipart_signed(top);
  if (signed_type == SEC_NO_FLAGS)
  {
    /* A null protocol value is already checked for in mutt_body_handler() */
    state_printf(state, _("[-- Error: Unknown multipart/signed protocol %s --]\n\n"),
                 mutt_param_get(&top->parameter, "protocol"));
    return mutt_body_handler(b_email, state);
  }
 
  /* Validate that the second MIME part matches the expected signature type */
  if (!(b_email && b_email->next))
  {
    inconsistent = true;
  }
  else
  {
    switch (signed_type)
    {
      case SEC_SIGN:
        if ((b_email->next->type != TYPE_MULTIPART) ||
            !mutt_istr_equal(b_email->next->subtype, "mixed"))
        {
          inconsistent = true;
        }
        break;
      case PGP_SIGN:
        if ((b_email->next->type != TYPE_APPLICATION) ||
            !mutt_istr_equal(b_email->next->subtype, "pgp-signature"))
        {
          inconsistent = true;
        }
        break;
      case SMIME_SIGN:
        if ((b_email->next->type != TYPE_APPLICATION) ||
            (!mutt_istr_equal(b_email->next->subtype, "x-pkcs7-signature") &&
             !mutt_istr_equal(b_email->next->subtype, "pkcs7-signature")))
        {
          inconsistent = true;
        }
        break;
      default:
        inconsistent = true;
    }
  }
  if (inconsistent)
  {
    state_attach_puts(state, _("[-- Error: Missing or bad-format multipart/signed signature --]\n\n"));
    return mutt_body_handler(b_email, state);
  }
 
  if (state->flags & STATE_DISPLAY)
  {
    /* Verify each signature part (PGP or S/MIME) against the signed body
     * written to a temporary file */
    crypt_fetch_signatures(&signatures, b_email->next, &sigcnt);
 
    if (sigcnt != 0)
    {
      tempfile = buf_pool_get();
      buf_mktemp(tempfile);
      bool goodsig = true;
      if (crypt_write_signed(b_email, state, buf_string(tempfile)) == 0)
      {
        for (int i = 0; i < sigcnt; i++)
        {
          if (((WithCrypto & APPLICATION_PGP) != 0) &&
              (signatures[i]->type == TYPE_APPLICATION) &&
              mutt_istr_equal(signatures[i]->subtype, "pgp-signature"))
          {
            if (crypt_pgp_verify_one(signatures[i], state, buf_string(tempfile)) != 0)
              goodsig = false;
 
            continue;
          }
 
          if (((WithCrypto & APPLICATION_SMIME) != 0) &&
              (signatures[i]->type == TYPE_APPLICATION) &&
              (mutt_istr_equal(signatures[i]->subtype, "x-pkcs7-signature") ||
               mutt_istr_equal(signatures[i]->subtype, "pkcs7-signature")))
          {
            if (crypt_smime_verify_one(signatures[i], state, buf_string(tempfile)) != 0)
              goodsig = false;
 
            continue;
          }
 
          state_printf(state, _("[-- Warning: We can't verify %s/%s signatures --]\n\n"),
                       BODY_TYPE(signatures[i]), signatures[i]->subtype);
        }
      }
 
      mutt_file_unlink(buf_string(tempfile));
      buf_pool_release(&tempfile);
 
      top->goodsig = goodsig;
      top->badsig = !goodsig;
 
      /* Now display the signed body */
      state_attach_puts(state, _("[-- The following data is signed --]\n"));
 
      mutt_protected_headers_handler(b_email, state);
 
      FREE(&signatures);
    }
    else
    {
      state_attach_puts(state, _("[-- Warning: Can't find any signatures --]\n\n"));
    }
  }
 
  rc = mutt_body_handler(b_email, state);
 
  if ((state->flags & STATE_DISPLAY) && (sigcnt != 0))
    state_attach_puts(state, _("[-- End of signed data --]\n"));
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_pgp_application_handler()

int crypt_pgp_application_handler	(	struct Body *	b_email,
		struct State *	state )

Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.

Definition at line 249 of file cryptglue.c.

{
  if (CRYPT_MOD_CALL_CHECK(PGP, application_handler))
    return CRYPT_MOD_CALL(PGP, application_handler)(b_email, state);
 
  return -1;
}

Here is the caller graph for this function:

crypt_pgp_encrypted_handler()

int crypt_pgp_encrypted_handler	(	struct Body *	b_email,
		struct State *	state )

Wrapper for CryptModuleSpecs::encrypted_handler() - Implements handler_t -.

Definition at line 260 of file cryptglue.c.

{
#ifdef USE_AUTOCRYPT
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (c_autocrypt)
  {
    OptAutocryptGpgme = true;
    int result = pgp_gpgme_encrypted_handler(b_email, state);
    OptAutocryptGpgme = false;
    if (result == 0)
    {
      b_email->is_autocrypt = true;
      return result;
    }
  }
#endif
 
  if (CRYPT_MOD_CALL_CHECK(PGP, encrypted_handler))
    return CRYPT_MOD_CALL(PGP, encrypted_handler)(b_email, state);
 
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_smime_application_handler()

int crypt_smime_application_handler	(	struct Body *	b_email,
		struct State *	state )

Wrapper for CryptModuleSpecs::application_handler() - Implements handler_t -.

Definition at line 456 of file cryptglue.c.

{
  if (CRYPT_MOD_CALL_CHECK(SMIME, application_handler))
    return CRYPT_MOD_CALL(SMIME, application_handler)(b_email, state);
 
  return -1;
}

Here is the caller graph for this function: