application_handler()

Manage the MIME type "application/pgp" or "application/smime". More...

Collaboration diagram for application_handler():

Functions
int	pgp_gpgme_application_handler (struct Body *b, struct State *state)
	Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.
int	smime_gpgme_application_handler (struct Body *b, struct State *state)
	Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.
int	pgp_class_application_handler (struct Body *b, struct State *state)
	Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.
int	smime_class_application_handler (struct Body *b, struct State *state)
	Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.

Detailed Description

Manage the MIME type "application/pgp" or "application/smime".

Parameters

b	Body of the email
state	State of text being processed

Return values

0	Success
-1	Error

Function Documentation

pgp_gpgme_application_handler()

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

Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.

Definition at line 2470 of file crypt_gpgme.c.

{
  int needpass = -1;
  bool pgp_keyblock = false;
  bool clearsign = false;
  long bytes;
  LOFF_T last_pos;
  LOFF_T block_begin;
  LOFF_T block_end;
  char buf[8192] = { 0 };
  FILE *fp_out = NULL;
 
  gpgme_error_t err = GPG_ERR_NO_ERROR;
  gpgme_data_t armored_data = NULL;
 
  bool maybe_goodsig = true;
  bool have_any_sigs = false;
 
  char body_charset[256] = { 0 }; /* Only used for clearsigned messages. */
  char *gpgcharset = NULL;
 
  mutt_debug(LL_DEBUG2, "Entering handler\n");
 
  /* For clearsigned messages we won't be able to get a character set
   * but we know that this may only be text thus we assume Latin-1 here. */
  if (!mutt_body_get_charset(b, body_charset, sizeof(body_charset)))
    mutt_str_copy(body_charset, "iso-8859-1", sizeof(body_charset));
 
  if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
  {
    return -1;
  }
  last_pos = b->offset;
 
  for (bytes = b->length; bytes > 0;)
  {
    // record before the fgets in case it is a BEGIN block
    block_begin = last_pos;
 
    if (!fgets(buf, sizeof(buf), state->fp_in))
      break;
 
    LOFF_T offset = ftello(state->fp_in);
    if (offset < 0)
    {
      mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
      offset = 0;
    }
    bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
    last_pos = offset;
 
    size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
    if (plen != 0)
    {
      needpass = 0;
      clearsign = false;
      pgp_keyblock = false;
 
      if (MESSAGE(buf + plen))
      {
        needpass = 1;
      }
      else if (SIGNED_MESSAGE(buf + plen))
      {
        clearsign = true;
      }
      else if (PUBLIC_KEY_BLOCK(buf + plen))
      {
        pgp_keyblock = true;
      }
      else
      {
        /* XXX we may wish to recode here */
        if (state->prefix)
          state_puts(state, state->prefix);
        state_puts(state, buf);
        continue;
      }
 
      /* Find the end of armored block. */
      while ((bytes > 0) && (fgets(buf, sizeof(buf) - 1, state->fp_in) != NULL))
      {
        offset = ftello(state->fp_in);
        if (offset < 0)
        {
          mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
          offset = 0;
        }
        bytes -= (offset - last_pos); /* don't rely on mutt_strlen(buf) */
        last_pos = offset;
 
        if (needpass && mutt_str_equal("-----END PGP MESSAGE-----\n", buf))
        {
          break;
        }
 
        if (!needpass && (mutt_str_equal("-----END PGP SIGNATURE-----\n", buf) ||
                          mutt_str_equal("-----END PGP PUBLIC KEY BLOCK-----\n", buf)))
        {
          break;
        }
 
        // remember optional Charset: armor header as defined by rfc4880
        if (mutt_strn_equal("Charset: ", buf, 9))
        {
          size_t l = 0;
          FREE(&gpgcharset);
          gpgcharset = mutt_str_dup(buf + 9);
          if ((l = mutt_str_len(gpgcharset)) > 0 && gpgcharset[l - 1] == '\n')
            gpgcharset[l - 1] = 0;
          if (!mutt_ch_check_charset(gpgcharset, 0))
            mutt_str_replace(&gpgcharset, "UTF-8");
        }
      }
      block_end = ftello(state->fp_in);
      if (block_end < 0)
      {
        mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
        block_end = 0;
      }
 
      have_any_sigs = (have_any_sigs || (clearsign && (state->flags & STATE_VERIFY)));
 
      /* Copy PGP material to an data container */
      armored_data = file_to_data_object(state->fp_in, block_begin, block_end - block_begin);
      fseeko(state->fp_in, block_end, 0);
 
      /* Invoke PGP if needed */
      if (pgp_keyblock)
      {
        pgp_gpgme_extract_keys(armored_data, &fp_out);
      }
      else if (!clearsign || (state->flags & STATE_VERIFY))
      {
        gpgme_data_t plaintext = create_gpgme_data();
        gpgme_ctx_t ctx = create_gpgme_context(false);
 
        if (clearsign)
        {
          err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
        }
        else
        {
          err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
          if (gpg_err_code(err) == GPG_ERR_NO_DATA)
          {
            /* Decrypt verify can't handle signed only messages. */
            gpgme_data_seek(armored_data, 0, SEEK_SET);
            /* Must release plaintext so that we supply an uninitialized object. */
            gpgme_data_release(plaintext);
            plaintext = create_gpgme_data();
            err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
          }
        }
        redraw_if_needed(ctx);
 
        const bool c_devel_security = cs_subset_bool(NeoMutt->sub, "devel_security");
        gpgme_decrypt_result_t result = gpgme_op_decrypt_result(ctx);
        if (c_devel_security && result && (state->flags & STATE_DISPLAY))
          show_encryption_info(state, result);
 
        if (err != GPG_ERR_NO_ERROR)
        {
          char errbuf[200] = { 0 };
 
          snprintf(errbuf, sizeof(errbuf) - 1,
                   _("Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
          state_puts(state, errbuf);
        }
        else
        {
          /* Decryption/Verification succeeded */
 
          mutt_message(_("PGP message successfully decrypted"));
 
          bool sig_stat = false;
          char *tmpfname = NULL;
 
          /* Check whether signatures have been verified.  */
          gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
          if (verify_result->signatures)
            sig_stat = true;
 
          have_any_sigs = false;
          maybe_goodsig = false;
          if ((state->flags & STATE_DISPLAY) && sig_stat)
          {
            int res, idx;
            bool anybad = false;
 
            state_attach_puts(state, _("[-- Begin signature information --]\n"));
            have_any_sigs = true;
            for (idx = 0; (res = show_one_sig_status(ctx, idx, state)) != -1; idx++)
            {
              if (res == 1)
                anybad = true;
            }
            if (!anybad && idx)
              maybe_goodsig = true;
 
            state_attach_puts(state, _("[-- End signature information --]\n\n"));
          }
 
          tmpfname = data_object_to_tempfile(plaintext, &fp_out);
          if (tmpfname)
          {
            unlink(tmpfname);
            FREE(&tmpfname);
          }
          else
          {
            mutt_file_fclose(&fp_out);
            state_puts(state, _("Error: copy data failed\n"));
          }
        }
        gpgme_data_release(plaintext);
        gpgme_release(ctx);
      }
 
      /* Now, copy cleartext to the screen.  NOTE - we expect that PGP
       * outputs utf-8 cleartext.  This may not always be true, but it
       * seems to be a reasonable guess.  */
      if (state->flags & STATE_DISPLAY)
      {
        if (needpass)
          state_attach_puts(state, _("[-- BEGIN PGP MESSAGE --]\n\n"));
        else if (pgp_keyblock)
          state_attach_puts(state, _("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"));
        else
          state_attach_puts(state, _("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"));
      }
 
      if (clearsign)
      {
        copy_clearsigned(armored_data, state, body_charset);
      }
      else if (fp_out)
      {
        int c;
        char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
        rewind(fp_out);
        struct FgetConv *fc = mutt_ch_fgetconv_open(fp_out, expected_charset,
                                                    cc_charset(), MUTT_ICONV_HOOK_FROM);
        while ((c = mutt_ch_fgetconv(fc)) != EOF)
        {
          state_putc(state, c);
          if ((c == '\n') && state->prefix)
            state_puts(state, state->prefix);
        }
        mutt_ch_fgetconv_close(&fc);
      }
 
      if (state->flags & STATE_DISPLAY)
      {
        state_putc(state, '\n');
        if (needpass)
          state_attach_puts(state, _("[-- END PGP MESSAGE --]\n"));
        else if (pgp_keyblock)
          state_attach_puts(state, _("[-- END PGP PUBLIC KEY BLOCK --]\n"));
        else
          state_attach_puts(state, _("[-- END PGP SIGNED MESSAGE --]\n"));
      }
 
      // Multiple PGP blocks can exist, so clean these up in each loop
      gpgme_data_release(armored_data);
      mutt_file_fclose(&fp_out);
    }
    else
    {
      /* A traditional PGP part may mix signed and unsigned content */
      /* XXX we may wish to recode here */
      if (state->prefix)
        state_puts(state, state->prefix);
      state_puts(state, buf);
    }
  }
  FREE(&gpgcharset);
 
  b->goodsig = (maybe_goodsig && have_any_sigs);
 
  if (needpass == -1)
  {
    state_attach_puts(state, _("[-- Error: could not find beginning of PGP message --]\n\n"));
    return 1;
  }
  mutt_debug(LL_DEBUG2, "Leaving handler\n");
 
  return err;
}

Here is the call graph for this function:

smime_gpgme_application_handler()

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

Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.

Definition at line 2856 of file crypt_gpgme.c.

{
  int is_signed = 0;
  int rc = 0;
 
  mutt_debug(LL_DEBUG2, "Entering handler\n");
 
  /* clear out any mime headers before the handler, so they can't be spoofed. */
  mutt_env_free(&b->mime_headers);
  b->warnsig = false;
  FILE *fp_out = mutt_file_mkstemp();
  if (!fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, _("[-- Error: could not create temporary file --]\n"));
    }
    return -1;
  }
 
  struct Body *tattach = decrypt_part(b, state, fp_out, true, &is_signed);
  if (tattach)
  {
    tattach->goodsig = is_signed > 0;
 
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, is_signed ?
                                   _("[-- The following data is S/MIME signed --]\n") :
                                   _("[-- The following data is S/MIME encrypted --]\n"));
      mutt_protected_headers_handler(tattach, state);
    }
 
    /* Store any protected headers in the parent so they can be
     * accessed for index updates after the handler recursion is done.
     * This is done before the handler to prevent a nested encrypted
     * handler from freeing the headers. */
    mutt_env_free(&b->mime_headers);
    b->mime_headers = tattach->mime_headers;
    tattach->mime_headers = NULL;
 
    FILE *fp_save = state->fp_in;
    state->fp_in = fp_out;
    rc = mutt_body_handler(tattach, state);
    state->fp_in = fp_save;
 
    /* Embedded multipart signed protected headers override the
     * encrypted headers.  We need to do this after the handler so
     * they can be printed in the pager. */
    if (mutt_is_multipart_signed(tattach) && tattach->parts && tattach->parts->mime_headers)
    {
      mutt_env_free(&b->mime_headers);
      b->mime_headers = tattach->parts->mime_headers;
      tattach->parts->mime_headers = NULL;
    }
 
    /* if a multipart/signed is the _only_ sub-part of a multipart/encrypted,
     * cache signature verification status.  */
    if (mutt_is_multipart_signed(tattach) && !tattach->next)
    {
      b->goodsig = tattach->goodsig;
      if (!b->goodsig)
        b->warnsig = tattach->warnsig;
    }
    else if (tattach->goodsig)
    {
      b->goodsig = true;
      b->warnsig = tattach->warnsig;
    }
 
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, is_signed ? _("[-- End of S/MIME signed data --]\n") :
                                           _("[-- End of S/MIME encrypted data --]\n"));
    }
 
    mutt_body_free(&tattach);
  }
 
  mutt_file_fclose(&fp_out);
  mutt_debug(LL_DEBUG2, "Leaving handler\n");
 
  return rc;
}

Here is the call graph for this function:

pgp_class_application_handler()

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

Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.

Definition at line 472 of file pgp.c.

{
  bool could_not_decrypt = false;
  int decrypt_okay_rc = 0;
  int needpass = -1;
  bool pgp_keyblock = false;
  bool clearsign = false;
  int rc = -1;
  int c = 1;
  long bytes;
  LOFF_T last_pos, offset;
  char buf[8192] = { 0 };
  FILE *fp_pgp_out = NULL, *fp_pgp_in = NULL, *fp_pgp_err = NULL;
  FILE *fp_tmp = NULL;
  pid_t pid;
  struct Buffer *tempfile = buf_pool_get();
 
  bool maybe_goodsig = true;
  bool have_any_sigs = false;
 
  char *gpgcharset = NULL;
  char body_charset[256] = { 0 };
  mutt_body_get_charset(b, body_charset, sizeof(body_charset));
 
  if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
  {
    return -1;
  }
  last_pos = b->offset;
 
  for (bytes = b->length; bytes > 0;)
  {
    if (!fgets(buf, sizeof(buf), state->fp_in))
      break;
 
    offset = ftello(state->fp_in);
    bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
    last_pos = offset;
 
    size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
    if (plen != 0)
    {
      needpass = false;
      clearsign = false;
      could_not_decrypt = false;
      decrypt_okay_rc = 0;
 
      if (mutt_str_startswith(buf + plen, "MESSAGE-----\n"))
      {
        needpass = 1;
      }
      else if (mutt_str_startswith(buf + plen, "SIGNED MESSAGE-----\n"))
      {
        clearsign = true;
      }
      else if (mutt_str_startswith(buf + plen, "PUBLIC KEY BLOCK-----\n"))
      {
        pgp_keyblock = true;
      }
      else
      {
        /* XXX we may wish to recode here */
        if (state->prefix)
          state_puts(state, state->prefix);
        state_puts(state, buf);
        continue;
      }
 
      have_any_sigs = have_any_sigs || (clearsign && (state->flags & STATE_VERIFY));
 
      /* Copy PGP material to temporary file */
      buf_mktemp(tempfile);
      fp_tmp = mutt_file_fopen(buf_string(tempfile), "w+");
      if (!fp_tmp)
      {
        mutt_perror("%s", buf_string(tempfile));
        FREE(&gpgcharset);
        goto out;
      }
 
      fputs(buf, fp_tmp);
      while ((bytes > 0) && fgets(buf, sizeof(buf) - 1, state->fp_in))
      {
        offset = ftello(state->fp_in);
        bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
        last_pos = offset;
 
        fputs(buf, fp_tmp);
 
        if ((needpass && mutt_str_equal("-----END PGP MESSAGE-----\n", buf)) ||
            (!needpass && (mutt_str_equal("-----END PGP SIGNATURE-----\n", buf) ||
                           mutt_str_equal("-----END PGP PUBLIC KEY BLOCK-----\n", buf))))
        {
          break;
        }
        /* remember optional Charset: armor header as defined by RFC4880 */
        if (mutt_str_startswith(buf, "Charset: "))
        {
          size_t l = 0;
          FREE(&gpgcharset);
          gpgcharset = mutt_str_dup(buf + 9);
          l = mutt_str_len(gpgcharset);
          if ((l > 0) && (gpgcharset[l - 1] == '\n'))
            gpgcharset[l - 1] = 0;
          if (!mutt_ch_check_charset(gpgcharset, false))
            mutt_str_replace(&gpgcharset, "UTF-8");
        }
      }
 
      /* leave fp_tmp open in case we still need it - but flush it! */
      fflush(fp_tmp);
 
      /* Invoke PGP if needed */
      if (!clearsign || (state->flags & STATE_VERIFY))
      {
        fp_pgp_out = mutt_file_mkstemp();
        if (!fp_pgp_out)
        {
          mutt_perror(_("Can't create temporary file"));
          goto out;
        }
 
        fp_pgp_err = mutt_file_mkstemp();
        if (!fp_pgp_err)
        {
          mutt_perror(_("Can't create temporary file"));
          goto out;
        }
 
        pid = pgp_invoke_decode(&fp_pgp_in, NULL, NULL, -1, fileno(fp_pgp_out),
                                fileno(fp_pgp_err), buf_string(tempfile),
                                (needpass != 0));
        if (pid == -1)
        {
          mutt_file_fclose(&fp_pgp_out);
          maybe_goodsig = false;
          fp_pgp_in = NULL;
          state_attach_puts(state, _("[-- Error: unable to create PGP subprocess --]\n"));
        }
        else /* PGP started successfully */
        {
          if (needpass)
          {
            if (!pgp_class_valid_passphrase())
              pgp_class_void_passphrase();
            if (pgp_use_gpg_agent())
              *PgpPass = '\0';
            fprintf(fp_pgp_in, "%s\n", PgpPass);
          }
 
          mutt_file_fclose(&fp_pgp_in);
 
          int wait_filter_rc = filter_wait(pid);
 
          fflush(fp_pgp_err);
          /* If we are expecting an encrypted message, verify status fd output.
           * Note that BEGIN PGP MESSAGE does not guarantee the content is encrypted,
           * so we need to be more selective about the value of decrypt_okay_rc.
           *
           * -3 indicates we actively found a DECRYPTION_FAILED.
           * -2 and -1 indicate part or all of the content was plaintext.  */
          if (needpass)
          {
            rewind(fp_pgp_err);
            decrypt_okay_rc = pgp_check_decryption_okay(fp_pgp_err);
            if (decrypt_okay_rc <= -3)
              mutt_file_fclose(&fp_pgp_out);
          }
 
          if (state->flags & STATE_DISPLAY)
          {
            rewind(fp_pgp_err);
            crypt_current_time(state, "PGP");
            int checksig_rc = pgp_copy_checksig(fp_pgp_err, state->fp_out);
 
            if (checksig_rc == 0)
              have_any_sigs = true;
            /* Sig is bad if
             * gpg_good_sign-pattern did not match || pgp_decode_command returned not 0
             * Sig _is_ correct if
             *  gpg_good_sign="" && pgp_decode_command returned 0 */
            if (checksig_rc == -1 || (wait_filter_rc != 0))
              maybe_goodsig = false;
 
            state_attach_puts(state, _("[-- End of PGP output --]\n\n"));
          }
          if (pgp_use_gpg_agent())
          {
            mutt_need_hard_redraw();
          }
        }
 
        /* treat empty result as sign of failure */
        /* TODO: maybe on failure neomutt should include the original undecoded text. */
        if (fp_pgp_out)
        {
          rewind(fp_pgp_out);
          c = fgetc(fp_pgp_out);
          ungetc(c, fp_pgp_out);
        }
        if (!clearsign && (!fp_pgp_out || (c == EOF)))
        {
          could_not_decrypt = true;
          pgp_class_void_passphrase();
        }
 
        if ((could_not_decrypt || (decrypt_okay_rc <= -3)) && !(state->flags & STATE_DISPLAY))
        {
          mutt_error(_("Could not decrypt PGP message"));
          goto out;
        }
      }
 
      /* Now, copy cleartext to the screen.  */
      if (state->flags & STATE_DISPLAY)
      {
        if (needpass)
          state_attach_puts(state, _("[-- BEGIN PGP MESSAGE --]\n\n"));
        else if (pgp_keyblock)
          state_attach_puts(state, _("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"));
        else
          state_attach_puts(state, _("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"));
      }
 
      if (clearsign)
      {
        rewind(fp_tmp);
        pgp_copy_clearsigned(fp_tmp, state, body_charset);
      }
      else if (fp_pgp_out)
      {
        struct FgetConv *fc = NULL;
        int ch;
        char *expected_charset = (gpgcharset && *gpgcharset) ? gpgcharset : "utf-8";
 
        mutt_debug(LL_DEBUG3, "pgp: recoding inline from [%s] to [%s]\n",
                   expected_charset, cc_charset());
 
        rewind(fp_pgp_out);
        state_set_prefix(state);
        fc = mutt_ch_fgetconv_open(fp_pgp_out, expected_charset, cc_charset(),
                                   MUTT_ICONV_HOOK_FROM);
        while ((ch = mutt_ch_fgetconv(fc)) != EOF)
          state_prefix_putc(state, ch);
        mutt_ch_fgetconv_close(&fc);
      }
 
      /* Multiple PGP blocks can exist, so these need to be closed and
       * unlinked inside the loop.  */
      mutt_file_fclose(&fp_tmp);
      mutt_file_unlink(buf_string(tempfile));
      mutt_file_fclose(&fp_pgp_out);
      mutt_file_fclose(&fp_pgp_err);
 
      if (state->flags & STATE_DISPLAY)
      {
        state_putc(state, '\n');
        if (needpass)
        {
          state_attach_puts(state, _("[-- END PGP MESSAGE --]\n"));
          if (could_not_decrypt || (decrypt_okay_rc <= -3))
          {
            mutt_error(_("Could not decrypt PGP message"));
          }
          else if (decrypt_okay_rc < 0)
          {
            /* L10N: You will see this error message if (1) you are decrypting
               (not encrypting) something and (2) it is a plaintext. So the
               message does not mean "You failed to encrypt the message." */
            mutt_error(_("PGP message is not encrypted"));
          }
          else
          {
            mutt_message(_("PGP message successfully decrypted"));
          }
        }
        else if (pgp_keyblock)
        {
          state_attach_puts(state, _("[-- END PGP PUBLIC KEY BLOCK --]\n"));
        }
        else
        {
          state_attach_puts(state, _("[-- END PGP SIGNED MESSAGE --]\n"));
        }
      }
    }
    else
    {
      /* A traditional PGP part may mix signed and unsigned content */
      /* XXX we may wish to recode here */
      if (state->prefix)
        state_puts(state, state->prefix);
      state_puts(state, buf);
    }
  }
 
  rc = 0;
 
out:
  b->goodsig = (maybe_goodsig && have_any_sigs);
 
  if (fp_tmp)
  {
    mutt_file_fclose(&fp_tmp);
    mutt_file_unlink(buf_string(tempfile));
  }
  mutt_file_fclose(&fp_pgp_out);
  mutt_file_fclose(&fp_pgp_err);
 
  buf_pool_release(&tempfile);
 
  FREE(&gpgcharset);
 
  if (needpass == -1)
  {
    state_attach_puts(state, _("[-- Error: could not find beginning of PGP message --]\n\n"));
    return -1;
  }
 
  return rc;
}

Here is the call graph for this function:

smime_class_application_handler()

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

Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.

Definition at line 1980 of file smime.c.

{
  int rc = -1;
 
  /* clear out any mime headers before the handler, so they can't be spoofed. */
  mutt_env_free(&b->mime_headers);
 
  struct Body *tattach = smime_handle_entity(b, state, NULL);
  if (tattach)
  {
    rc = 0;
    mutt_body_free(&tattach);
  }
  return rc;
}

Here is the call graph for this function: