encrypted_handler()

Manage a PGP or S/MIME encrypted MIME part. More...

Collaboration diagram for encrypted_handler():

Functions
int	pgp_gpgme_encrypted_handler (struct Body *b, struct State *state)
	Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.
int	pgp_class_encrypted_handler (struct Body *b, struct State *state)
	Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.

Detailed Description

Manage a PGP or S/MIME encrypted MIME part.

Parameters

b	Body of the email
state	State of text being processed

Return values

0	Success
-1	Error

Function Documentation

pgp_gpgme_encrypted_handler()

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

Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.

This handler is passed the application/octet-stream directly. The caller must propagate b->goodsig to its parent.

Definition at line 2659 of file crypt_gpgme.c.

{
  int is_signed;
  int rc = 0;
 
  mutt_debug(LL_DEBUG2, "Entering handler\n");
 
  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, false, &is_signed);
  if (tattach)
  {
    tattach->goodsig = is_signed > 0;
 
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, is_signed ?
                                   _("[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
                                   _("[-- The following data is PGP/MIME encrypted --]\n\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 (state->flags & STATE_DISPLAY)
    {
      state_puts(state, "\n");
      state_attach_puts(state, is_signed ?
                                   _("[-- End of PGP/MIME signed and encrypted data --]\n") :
                                   _("[-- End of PGP/MIME encrypted data --]\n"));
    }
 
    mutt_body_free(&tattach);
    mutt_message(_("PGP message successfully decrypted"));
  }
  else
  {
#ifdef USE_AUTOCRYPT
    if (!OptAutocryptGpgme)
#endif
    {
      mutt_error(_("Could not decrypt PGP message"));
    }
    rc = -1;
  }
 
  mutt_file_fclose(&fp_out);
  mutt_debug(LL_DEBUG2, "Leaving handler\n");
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_class_encrypted_handler()

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

Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.

Definition at line 1249 of file pgp.c.

{
  FILE *fp_in = NULL;
  struct Body *tattach = NULL;
  int rc = 0;
 
  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;
  }
 
  if (state->flags & STATE_DISPLAY)
    crypt_current_time(state, "PGP");
 
  tattach = pgp_decrypt_part(b, state, fp_out, b);
  if (tattach)
  {
    if (state->flags & STATE_DISPLAY)
    {
      state_attach_puts(state, _("[-- The following data is PGP/MIME encrypted --]\n\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;
 
    fp_in = state->fp_in;
    state->fp_in = fp_out;
    rc = mutt_body_handler(tattach, state);
    state->fp_in = fp_in;
 
    /* 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 (state->flags & STATE_DISPLAY)
    {
      state_puts(state, "\n");
      state_attach_puts(state, _("[-- End of PGP/MIME encrypted data --]\n"));
    }
 
    mutt_body_free(&tattach);
    /* clear 'Invoking...' message, since there's no error */
    mutt_message(_("PGP message successfully decrypted"));
  }
  else
  {
    mutt_error(_("Could not decrypt PGP message"));
    /* void the passphrase, even if it's not necessarily the problem */
    pgp_class_void_passphrase();
    rc = -1;
  }
 
  mutt_file_fclose(&fp_out);
 
  return rc;
}

Here is the call graph for this function: