pgp.c File Reference

PGP sign, encrypt, check routines. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "lib.h"
#include "attach/lib.h"
#include "editor/lib.h"
#include "history/lib.h"
#include "hooks/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "crypt.h"
#include "cryptglue.h"
#include "globals.h"
#include "module_data.h"
#include "pgpinvoke.h"
#include "pgpkey.h"
#include "pgpmicalg.h"
#include "pgp.h"
#include "pgplib.h"

Include dependency graph for pgp.c:

Go to the source code of this file.

Functions
void	pgp_class_void_passphrase (void)
	Forget the cached passphrase - Implements CryptModuleSpecs::void_passphrase() -.
bool	pgp_class_valid_passphrase (void)
	Ensure we have a valid passphrase - Implements CryptModuleSpecs::valid_passphrase() -.
bool	pgp_use_gpg_agent (void)
	Does the user want to use the gpg agent?
static struct PgpKeyInfo *	key_parent (struct PgpKeyInfo *k)
	Find a key's parent (if it's a subkey)
char *	pgp_long_keyid (struct PgpKeyInfo *k)
	Get a key's long id.
char *	pgp_short_keyid (struct PgpKeyInfo *k)
	Get a key's short id.
char *	pgp_this_keyid (struct PgpKeyInfo *k)
	Get the ID of this key.
char *	pgp_keyid (struct PgpKeyInfo *k)
	Get the ID of the main (parent) key.
static char *	pgp_fingerprint (struct PgpKeyInfo *k)
	Get the key's fingerprint.
char *	pgp_fpr_or_lkeyid (struct PgpKeyInfo *k)
	Get the fingerprint or long keyid.
static int	pgp_copy_checksig (FILE *fp_in, FILE *fp_out)
	Copy PGP output and look for signs of a good signature.
static int	pgp_check_pgp_decryption_okay_regex (FILE *fp_in)
	Check PGP output to look for successful outcome.
static int	pgp_check_decryption_okay (FILE *fp_in)
	Check GPG output for status codes.
static void	pgp_copy_clearsigned (FILE *fp_in, struct State *state, char *charset)
	Copy a clearsigned message, stripping the signature.
int	pgp_class_application_handler (struct Body *b, struct State *state)
	Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::application_handler() -.
static bool	pgp_check_traditional_one_body (FILE *fp, struct Body *b)
	Check the body of an inline PGP message.
bool	pgp_class_check_traditional (FILE *fp, struct Body *b, bool just_one)
	Look for inline (non-MIME) PGP content - Implements CryptModuleSpecs::pgp_check_traditional() -.
int	pgp_class_verify_one (struct Body *b, struct State *state, const char *tempfile)
	Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
static void	pgp_extract_keys_from_attachment (FILE *fp, struct Body *b)
	Extract pgp keys from messages/attachments.
void	pgp_class_extract_key_from_attachment (FILE *fp, struct Body *b)
	Extract PGP key from an attachment - Implements CryptModuleSpecs::pgp_extract_key_from_attachment() -.
static struct Body *	pgp_decrypt_part (struct Body *a, struct State *state, FILE *fp_out, struct Body *p)
	Decrypt part of a PGP message.
int	pgp_class_decrypt_mime (FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
	Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
int	pgp_class_encrypted_handler (struct Body *b, struct State *state)
	Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.
struct Body *	pgp_class_sign_message (struct Body *b, const struct AddressList *from)
	Cryptographically sign the Body of a message - Implements CryptModuleSpecs::sign_message() -.
char *	pgp_class_find_keys (const struct AddressList *addrlist, bool oppenc_mode)
	Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
struct Body *	pgp_class_encrypt_message (struct Body *b, char *keylist, bool sign, const struct AddressList *from)
	PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.
struct Body *	pgp_class_traditional_encryptsign (struct Body *b, SecurityFlags flags, char *keylist)
	Create an inline PGP encrypted, signed email - Implements CryptModuleSpecs::pgp_traditional_encryptsign() -.
SecurityFlags	pgp_class_send_menu (struct Email *e)
	Ask the user whether to sign and/or encrypt the email - Implements CryptModuleSpecs::send_menu() -.

Detailed Description

PGP sign, encrypt, check routines.

Authors

• Richard Russon
• Pietro Cerutti
• Alejandro Colomar

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 pgp.c.

Function Documentation

pgp_use_gpg_agent()

bool pgp_use_gpg_agent

(

void

)

Does the user want to use the gpg agent?

Return values

true	The user wants to use the gpg agent

Note

This functions sets the environment variable $GPG_TTY

Definition at line 124 of file pgp.c.

{
  char *tty = NULL;
 
  /* GnuPG 2.1 no longer exports GPG_AGENT_INFO */
  const bool c_pgp_use_gpg_agent = cs_subset_bool(NeoMutt->sub, "pgp_use_gpg_agent");
  if (!c_pgp_use_gpg_agent)
    return false;
 
  tty = ttyname(0);
  if (tty)
  {
    setenv("GPG_TTY", tty, 0);
    envlist_set(&NeoMutt->env, "GPG_TTY", tty, false);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

key_parent()

static struct PgpKeyInfo * key_parent ( struct PgpKeyInfo * k )

static

Find a key's parent (if it's a subkey)

Parameters

k

PGP key

Return values

ptr	Parent key

Definition at line 148 of file pgp.c.

{
  const bool c_pgp_ignore_subkeys = cs_subset_bool(NeoMutt->sub, "pgp_ignore_subkeys");
  if ((k->flags & KEYFLAG_SUBKEY) && k->parent && c_pgp_ignore_subkeys)
    k = k->parent;
 
  return k;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_long_keyid()

char * pgp_long_keyid

(

struct PgpKeyInfo *

k

)

Get a key's long id.

Parameters

k

PGP key

Return values

ptr	Long key id string

Definition at line 162 of file pgp.c.

{
  k = key_parent(k);
 
  return k->keyid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_short_keyid()

char * pgp_short_keyid

(

struct PgpKeyInfo *

k

)

Get a key's short id.

Parameters

k

PGP key

Return values

ptr	Short key id string

Definition at line 174 of file pgp.c.

{
  k = key_parent(k);
 
  return k->keyid + 8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_this_keyid()

char * pgp_this_keyid

(

struct PgpKeyInfo *

k

)

Get the ID of this key.

Parameters

k

PGP key

Return values

ptr	Long/Short key id string

Note

The string returned depends on $pgp_long_ids

Definition at line 188 of file pgp.c.

{
  const bool c_pgp_long_ids = cs_subset_bool(NeoMutt->sub, "pgp_long_ids");
  if (c_pgp_long_ids)
    return k->keyid;
  return k->keyid + 8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_keyid()

char * pgp_keyid

(

struct PgpKeyInfo *

k

)

Get the ID of the main (parent) key.

Parameters

k

PGP key

Return values

ptr	Long/Short key id string

Definition at line 201 of file pgp.c.

{
  k = key_parent(k);
 
  return pgp_this_keyid(k);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_fingerprint()

static char * pgp_fingerprint ( struct PgpKeyInfo * k )

static

Get the key's fingerprint.

Parameters

k

PGP key

Return values

ptr	Fingerprint string

Definition at line 213 of file pgp.c.

{
  k = key_parent(k);
 
  return k->fingerprint;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_fpr_or_lkeyid()

char * pgp_fpr_or_lkeyid

(

struct PgpKeyInfo *

k

)

Get the fingerprint or long keyid.

Parameters

k

PGP key

Return values

ptr	String fingerprint or long keyid

Grab the longest key identifier available: fingerprint or else the long keyid.

The longest available should be used for internally identifying the key and for invoking pgp commands.

Definition at line 231 of file pgp.c.

{
  char *fingerprint = pgp_fingerprint(k);
  return fingerprint ? fingerprint : pgp_long_keyid(k);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_copy_checksig()

static int pgp_copy_checksig ( FILE * fp_in, FILE * fp_out )

static

Copy PGP output and look for signs of a good signature.

Parameters

fp_in	File to read from
fp_out	File to write to

Return values

0	Success
-1	Error

Definition at line 248 of file pgp.c.

{
  if (!fp_in || !fp_out)
    return -1;
 
  int rc = -1;
 
  const struct Regex *c_pgp_good_sign = cs_subset_regex(NeoMutt->sub, "pgp_good_sign");
  if (c_pgp_good_sign && c_pgp_good_sign->regex)
  {
    char *line = NULL;
    size_t linelen;
 
    while ((line = mutt_file_read_line(line, &linelen, fp_in, NULL, MUTT_RL_NONE)))
    {
      if (mutt_regex_match(c_pgp_good_sign, line))
      {
        mutt_debug(LL_DEBUG2, "\"%s\" matches regex\n", line);
        rc = 0;
      }
      else
      {
        mutt_debug(LL_DEBUG2, "\"%s\" doesn't match regex\n", line);
      }
 
      if (mutt_strn_equal(line, "[GNUPG:] ", 9))
        continue;
      fputs(line, fp_out);
      fputc('\n', fp_out);
    }
    FREE(&line);
  }
  else
  {
    mutt_debug(LL_DEBUG2, "No pattern\n");
    mutt_file_copy_stream(fp_in, fp_out);
    rc = 1;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_check_pgp_decryption_okay_regex()

static int pgp_check_pgp_decryption_okay_regex ( FILE * fp_in )

static

Check PGP output to look for successful outcome.

Parameters

fp_in

File to read from

Return values

0	Success
-1	Error

Checks PGP output messages to look for the $pgp_decryption_okay message. This protects against messages with multipart/encrypted headers but which aren't actually encrypted.

Definition at line 300 of file pgp.c.

{
  int rc = -1;
 
  const struct Regex *c_pgp_decryption_okay = cs_subset_regex(NeoMutt->sub, "pgp_decryption_okay");
  if (c_pgp_decryption_okay && c_pgp_decryption_okay->regex)
  {
    char *line = NULL;
    size_t linelen;
 
    while ((line = mutt_file_read_line(line, &linelen, fp_in, NULL, MUTT_RL_NONE)))
    {
      if (mutt_regex_match(c_pgp_decryption_okay, line))
      {
        mutt_debug(LL_DEBUG2, "\"%s\" matches regex\n", line);
        rc = 0;
        break;
      }
      else
      {
        mutt_debug(LL_DEBUG2, "\"%s\" doesn't match regex\n", line);
      }
    }
    FREE(&line);
  }
  else
  {
    mutt_debug(LL_DEBUG2, "No pattern\n");
    rc = 1;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_check_decryption_okay()

static int pgp_check_decryption_okay ( FILE * fp_in )

static

Check GPG output for status codes.

Parameters

fp_in

File to read from

Return values

1	- no patterns were matched (if delegated to decryption_okay_regex)
0	- DECRYPTION_OKAY was seen, with no PLAINTEXT outside
-1	- No decryption status codes were encountered
-2	- PLAINTEXT was encountered outside of DECRYPTION delimiters
-3	- DECRYPTION_FAILED was encountered

Checks GnuPGP status fd output for various status codes indicating an issue. If $pgp_check_gpg_decrypt_status_fd is unset, it falls back to the old behavior of just scanning for $pgp_decryption_okay.

pgp_decrypt_part() should fail if the part is not encrypted, so we return less than 0 to indicate part or all was NOT actually encrypted.

On the other hand, for pgp_application_pgp_handler(), a "BEGIN PGP MESSAGE" could indicate a signed and armored message. For that we allow -1 and -2 as "valid" (with a warning).

Definition at line 354 of file pgp.c.

{
  int rc = -1;
  char *line = NULL, *s = NULL;
  size_t linelen;
  int inside_decrypt = 0;
 
  const bool c_pgp_check_gpg_decrypt_status_fd = cs_subset_bool(NeoMutt->sub, "pgp_check_gpg_decrypt_status_fd");
  if (!c_pgp_check_gpg_decrypt_status_fd)
    return pgp_check_pgp_decryption_okay_regex(fp_in);
 
  while ((line = mutt_file_read_line(line, &linelen, fp_in, NULL, MUTT_RL_NONE)))
  {
    size_t plen = mutt_str_startswith(line, "[GNUPG:] ");
    if (plen == 0)
      continue;
    s = line + plen;
    mutt_debug(LL_DEBUG2, "checking \"%s\"\n", line);
    if (mutt_str_startswith(s, "BEGIN_DECRYPTION"))
    {
      inside_decrypt = 1;
    }
    else if (mutt_str_startswith(s, "END_DECRYPTION"))
    {
      inside_decrypt = 0;
    }
    else if (mutt_str_startswith(s, "PLAINTEXT"))
    {
      if (!inside_decrypt)
      {
        mutt_debug(LL_DEBUG2, "    PLAINTEXT encountered outside of DECRYPTION\n");
        rc = -2;
        break;
      }
    }
    else if (mutt_str_startswith(s, "DECRYPTION_FAILED"))
    {
      mutt_debug(LL_DEBUG2, "    DECRYPTION_FAILED encountered.  Failure\n");
      rc = -3;
      break;
    }
    else if (mutt_str_startswith(s, "DECRYPTION_OKAY"))
    {
      /* Don't break out because we still have to check for
       * PLAINTEXT outside of the decryption boundaries. */
      mutt_debug(LL_DEBUG2, "    DECRYPTION_OKAY encountered\n");
      rc = 0;
    }
  }
  FREE(&line);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_copy_clearsigned()

static void pgp_copy_clearsigned ( FILE * fp_in, struct State * state, char * charset )

static

Copy a clearsigned message, stripping the signature.

Parameters

fp_in	File to read from
state	State to use
charset	Charset of file

XXX charset handling: We assume that it is safe to do character set decoding first, dash decoding second here, while we do it the other way around in the main handler.

(Note that we aren't worse than Outlook &c in this, and also note that we can successfully handle anything produced by any existing versions of neomutt.)

Definition at line 421 of file pgp.c.

{
  char buf[8192] = { 0 };
  bool complete, armor_header;
 
  rewind(fp_in);
 
  /* fromcode comes from the MIME Content-Type charset label. It might
   * be a wrong label, so we want the ability to do corrections via
   * charset-hooks. Therefore we set flags to MUTT_ICONV_HOOK_FROM.  */
  struct FgetConv *fc = mutt_ch_fgetconv_open(fp_in, charset, cc_charset(), MUTT_ICONV_HOOK_FROM);
 
  for (complete = true, armor_header = true;
       mutt_ch_fgetconvs(buf, sizeof(buf), fc); complete = (strchr(buf, '\n')))
  {
    if (!complete)
    {
      if (!armor_header)
        state_puts(state, buf);
      continue;
    }
 
    if (mutt_str_equal(buf, "-----BEGIN PGP SIGNATURE-----\n"))
      break;
 
    if (armor_header)
    {
      char *p = mutt_str_skip_whitespace(buf);
      if (*p == '\0')
        armor_header = false;
      continue;
    }
 
    if (state->prefix)
      state_puts(state, state->prefix);
 
    if ((buf[0] == '-') && (buf[1] == ' '))
      state_puts(state, buf + 2);
    else
      state_puts(state, buf);
  }
 
  mutt_ch_fgetconv_close(&fc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_check_traditional_one_body()

static bool pgp_check_traditional_one_body ( FILE * fp, struct Body * b )

static

Check the body of an inline PGP message.

Parameters

fp	File to read
b	Body to populate

Return values

true	Success
false	Error

Definition at line 799 of file pgp.c.

{
  struct Buffer *tempfile = NULL;
  char buf[8192] = { 0 };
  bool rc = false;
 
  bool sgn = false;
  bool enc = false;
  bool key = false;
 
  if (b->type != TYPE_TEXT)
    goto cleanup;
 
  tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  if (mutt_decode_save_attachment(fp, b, buf_string(tempfile), STATE_NONE, MUTT_SAVE_NONE) != 0)
  {
    unlink(buf_string(tempfile));
    goto cleanup;
  }
 
  FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "r");
  if (!fp_tmp)
  {
    unlink(buf_string(tempfile));
    goto cleanup;
  }
 
  while (fgets(buf, sizeof(buf), fp_tmp))
  {
    size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
    if (plen != 0)
    {
      if (mutt_str_startswith(buf + plen, "MESSAGE-----\n"))
        enc = true;
      else if (mutt_str_startswith(buf + plen, "SIGNED MESSAGE-----\n"))
        sgn = true;
      else if (mutt_str_startswith(buf + plen, "PUBLIC KEY BLOCK-----\n"))
        key = true;
    }
  }
  mutt_file_fclose(&fp_tmp);
  unlink(buf_string(tempfile));
 
  if (!enc && !sgn && !key)
    goto cleanup;
 
  /* fix the content type */
 
  mutt_param_set(&b->parameter, "format", "fixed");
  if (enc)
    mutt_param_set(&b->parameter, "x-action", "pgp-encrypted");
  else if (sgn)
    mutt_param_set(&b->parameter, "x-action", "pgp-signed");
  else if (key)
    mutt_param_set(&b->parameter, "x-action", "pgp-keys");
 
  rc = true;
 
cleanup:
  buf_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_extract_keys_from_attachment()

static void pgp_extract_keys_from_attachment ( FILE * fp, struct Body * b )

static

Extract pgp keys from messages/attachments.

Parameters

fp	File to read from
b	Top Attachment

Definition at line 968 of file pgp.c.

{
  struct State state = { 0 };
  struct Buffer *tempfile = buf_pool_get();
 
  buf_mktemp(tempfile);
  FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_tmp)
  {
    mutt_perror("%s", buf_string(tempfile));
    goto cleanup;
  }
 
  state.fp_in = fp;
  state.fp_out = fp_tmp;
 
  mutt_body_handler(b, &state);
 
  mutt_file_fclose(&fp_tmp);
 
  pgp_class_invoke_import(buf_string(tempfile));
  mutt_any_key_to_continue(NULL);
 
  mutt_file_unlink(buf_string(tempfile));
 
cleanup:
  buf_pool_release(&tempfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_decrypt_part()

static struct Body * pgp_decrypt_part ( struct Body * a, struct State * state, FILE * fp_out, struct Body * p )

static

Decrypt part of a PGP message.

Parameters

a	Body of attachment
state	State to use
fp_out	File to write to
p	Body of parent (main email)

Return values

ptr	New Body for the attachment

Definition at line 1023 of file pgp.c.

{
  if (!a || !state || !fp_out || !p)
    return NULL;
 
  struct NcryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NCRYPT);
  char buf[1024] = { 0 };
  FILE *fp_pgp_in = NULL, *fp_pgp_out = NULL, *fp_pgp_tmp = NULL;
  struct Body *tattach = NULL;
  pid_t pid;
  int rv;
  struct Buffer *tempfile = buf_pool_get();
 
  FILE *fp_pgp_err = mutt_file_mkstemp();
  if (!fp_pgp_err)
  {
    mutt_perror(_("Can't create temporary file"));
    goto cleanup;
  }
 
  buf_mktemp(tempfile);
  fp_pgp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_pgp_tmp)
  {
    mutt_perror("%s", buf_string(tempfile));
    mutt_file_fclose(&fp_pgp_err);
    goto cleanup;
  }
 
  /* Position the stream at the beginning of the body, and send the data to
   * the temporary file.  */
 
  if (!mutt_file_seek(state->fp_in, a->offset, SEEK_SET))
  {
    mutt_file_fclose(&fp_pgp_tmp);
    mutt_file_fclose(&fp_pgp_err);
    goto cleanup;
  }
  mutt_file_copy_bytes(state->fp_in, fp_pgp_tmp, a->length);
  mutt_file_fclose(&fp_pgp_tmp);
 
  pid = pgp_invoke_decrypt(&fp_pgp_in, &fp_pgp_out, NULL, -1, -1,
                           fileno(fp_pgp_err), buf_string(tempfile));
  if (pid == -1)
  {
    mutt_file_fclose(&fp_pgp_err);
    unlink(buf_string(tempfile));
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, _("[-- Error: could not create a PGP subprocess --]\n\n"));
    }
    goto cleanup;
  }
 
  /* send the PGP passphrase to the subprocess.  Never do this if the agent is
   * active, because this might lead to a passphrase send as the message. */
  if (!pgp_use_gpg_agent())
    fputs(mod_data->pgp_pass, fp_pgp_in);
  fputc('\n', fp_pgp_in);
  mutt_file_fclose(&fp_pgp_in);
 
  /* Read the output from PGP, and make sure to change CRLF to LF, otherwise
   * read_mime_header has a hard time parsing the message.  */
  while (fgets(buf, sizeof(buf) - 1, fp_pgp_out))
  {
    size_t len = mutt_str_len(buf);
    if ((len > 1) && (buf[len - 2] == '\r'))
      strcpy(buf + len - 2, "\n");
    fputs(buf, fp_out);
  }
 
  mutt_file_fclose(&fp_pgp_out);
 
  rv = filter_wait(pid);
  const bool c_pgp_use_gpg_agent = cs_subset_bool(NeoMutt->sub, "pgp_use_gpg_agent");
  if (c_pgp_use_gpg_agent)
    mutt_need_hard_redraw();
 
  mutt_file_unlink(buf_string(tempfile));
 
  fflush(fp_pgp_err);
  rewind(fp_pgp_err);
  if (pgp_check_decryption_okay(fp_pgp_err) < 0)
  {
    mutt_error(_("Decryption failed"));
    pgp_class_void_passphrase();
    mutt_file_fclose(&fp_pgp_err);
    goto cleanup;
  }
 
  if (state->flags & STATE_DISPLAY)
  {
    rewind(fp_pgp_err);
    if ((pgp_copy_checksig(fp_pgp_err, state->fp_out) == 0) && !rv)
      p->goodsig = true;
    else
      p->goodsig = false;
    state_attach_puts(state, _("[-- End of PGP output --]\n\n"));
  }
  mutt_file_fclose(&fp_pgp_err);
 
  fflush(fp_out);
  rewind(fp_out);
 
  if (fgetc(fp_out) == EOF)
  {
    mutt_error(_("Decryption failed"));
    pgp_class_void_passphrase();
    goto cleanup;
  }
 
  rewind(fp_out);
  const long size = mutt_file_get_size_fp(fp_out);
  if (size == 0)
  {
    goto cleanup;
  }
 
  tattach = mutt_read_mime_header(fp_out, 0);
  if (tattach)
  {
    /* Need to set the length of this body part.  */
    tattach->length = size - tattach->offset;
 
    /* See if we need to recurse on this MIME part.  */
    mutt_parse_part(fp_out, tattach);
  }
 
cleanup:
  buf_pool_release(&tempfile);
  return tattach;
}

Here is the call graph for this function:

Here is the caller graph for this function: