pgp_encrypt_message()

PGP encrypt an email. More...

Collaboration diagram for pgp_encrypt_message():

Functions
struct Body *	pgp_gpgme_encrypt_message (struct Body *a, char *keylist, bool sign, const struct AddressList *from)
	Implements CryptModuleSpecs::pgp_encrypt_message() -.
struct Body *	pgp_class_encrypt_message (struct Body *a, char *keylist, bool sign, const struct AddressList *from)
	Implements CryptModuleSpecs::pgp_encrypt_message() -.

Detailed Description

PGP encrypt an email.

Parameters

a	Body of email to encrypt
keylist	List of keys, or fingerprints (space separated)
sign	If true, sign the message too
from	From line, to choose the key to sign

Return values

ptr	Encrypted Body
NULL	Error

Encrypt the mail body to all the given keys.

Function Documentation

pgp_gpgme_encrypt_message()

struct Body * pgp_gpgme_encrypt_message	(	struct Body *	a,
		char *	keylist,
		bool	sign,
		const struct AddressList *	from
	)

Implements CryptModuleSpecs::pgp_encrypt_message() -.

Definition at line 1037 of file crypt_gpgme.c.

{
  if (sign)
    crypt_convert_to_7bit(a);
  gpgme_data_t plaintext = body_to_data_object(a, false);
  if (!plaintext)
    return NULL;
 
  char *outfile = encrypt_gpgme_object(plaintext, keylist, false, sign, from);
  gpgme_data_release(plaintext);
  if (!outfile)
    return NULL;
 
  struct Body *t = mutt_body_new();
  t->type = TYPE_MULTIPART;
  t->subtype = mutt_str_dup("encrypted");
  t->encoding = ENC_7BIT;
  t->use_disp = false;
  t->disposition = DISP_INLINE;
 
  mutt_generate_boundary(&t->parameter);
  mutt_param_set(&t->parameter, "protocol", "application/pgp-encrypted");
 
  t->parts = mutt_body_new();
  t->parts->type = TYPE_APPLICATION;
  t->parts->subtype = mutt_str_dup("pgp-encrypted");
  t->parts->encoding = ENC_7BIT;
 
  t->parts->next = mutt_body_new();
  t->parts->next->type = TYPE_APPLICATION;
  t->parts->next->subtype = mutt_str_dup("octet-stream");
  t->parts->next->encoding = ENC_7BIT;
  t->parts->next->filename = outfile;
  t->parts->next->use_disp = true;
  t->parts->next->disposition = DISP_ATTACH;
  t->parts->next->unlink = true; /* delete after sending the message */
  t->parts->next->d_filename = mutt_str_dup("msg.asc"); /* non pgp/mime
                                                           can save */
 
  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_class_encrypt_message()

struct Body * pgp_class_encrypt_message	(	struct Body *	a,
		char *	keylist,
		bool	sign,
		const struct AddressList *	from
	)

Implements CryptModuleSpecs::pgp_encrypt_message() -.

Warning

"a" is no longer freed in this routine, you need to free it later. This is necessary for $fcc_attach.

Definition at line 1592 of file pgp.c.

{
  char buf[1024] = { 0 };
  FILE *fp_pgp_in = NULL, *fp_tmp = NULL;
  struct Body *t = NULL;
  int err = 0;
  bool empty = false;
  pid_t pid;
  struct Buffer *tempfile = buf_pool_get();
  struct Buffer *pgpinfile = buf_pool_get();
 
  buf_mktemp(tempfile);
  FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w+");
  if (!fp_out)
  {
    mutt_perror("%s", buf_string(tempfile));
    goto cleanup;
  }
 
  FILE *fp_pgp_err = mutt_file_mkstemp();
  if (!fp_pgp_err)
  {
    mutt_perror(_("Can't create temporary file"));
    unlink(buf_string(tempfile));
    mutt_file_fclose(&fp_out);
    goto cleanup;
  }
 
  buf_mktemp(pgpinfile);
  fp_tmp = mutt_file_fopen(buf_string(pgpinfile), "w");
  if (!fp_tmp)
  {
    mutt_perror("%s", buf_string(pgpinfile));
    unlink(buf_string(tempfile));
    mutt_file_fclose(&fp_out);
    mutt_file_fclose(&fp_pgp_err);
    goto cleanup;
  }
 
  if (sign)
    crypt_convert_to_7bit(a);
 
  mutt_write_mime_header(a, fp_tmp, NeoMutt->sub);
  fputc('\n', fp_tmp);
  mutt_write_mime_body(a, fp_tmp, NeoMutt->sub);
  mutt_file_fclose(&fp_tmp);
 
  pid = pgp_invoke_encrypt(&fp_pgp_in, NULL, NULL, -1, fileno(fp_out),
                           fileno(fp_pgp_err), buf_string(pgpinfile), keylist, sign);
  if (pid == -1)
  {
    mutt_file_fclose(&fp_out);
    mutt_file_fclose(&fp_pgp_err);
    unlink(buf_string(pgpinfile));
    goto cleanup;
  }
 
  if (sign)
  {
    if (!pgp_use_gpg_agent())
      fputs(PgpPass, fp_pgp_in);
    fputc('\n', fp_pgp_in);
  }
  mutt_file_fclose(&fp_pgp_in);
 
  const bool c_pgp_check_exit = cs_subset_bool(NeoMutt->sub, "pgp_check_exit");
  if (filter_wait(pid) && c_pgp_check_exit)
    empty = true;
 
  unlink(buf_string(pgpinfile));
 
  fflush(fp_out);
  rewind(fp_out);
  if (!empty)
    empty = (fgetc(fp_out) == EOF);
  mutt_file_fclose(&fp_out);
 
  fflush(fp_pgp_err);
  rewind(fp_pgp_err);
  while (fgets(buf, sizeof(buf) - 1, fp_pgp_err))
  {
    err = 1;
    fputs(buf, stdout);
  }
  mutt_file_fclose(&fp_pgp_err);
 
  /* pause if there is any error output from PGP */
  if (err)
    mutt_any_key_to_continue(NULL);
 
  if (empty)
  {
    /* fatal error while trying to encrypt message */
    if (sign)
      pgp_class_void_passphrase(); /* just in case */
    unlink(buf_string(tempfile));
    goto cleanup;
  }
 
  t = mutt_body_new();
  t->type = TYPE_MULTIPART;
  t->subtype = mutt_str_dup("encrypted");
  t->encoding = ENC_7BIT;
  t->use_disp = false;
  t->disposition = DISP_INLINE;
 
  mutt_generate_boundary(&t->parameter);
  mutt_param_set(&t->parameter, "protocol", "application/pgp-encrypted");
 
  t->parts = mutt_body_new();
  t->parts->type = TYPE_APPLICATION;
  t->parts->subtype = mutt_str_dup("pgp-encrypted");
  t->parts->encoding = ENC_7BIT;
 
  t->parts->next = mutt_body_new();
  t->parts->next->type = TYPE_APPLICATION;
  t->parts->next->subtype = mutt_str_dup("octet-stream");
  t->parts->next->encoding = ENC_7BIT;
  t->parts->next->filename = buf_strdup(tempfile);
  t->parts->next->use_disp = true;
  t->parts->next->disposition = DISP_ATTACH;
  t->parts->next->unlink = true; /* delete after sending the message */
  t->parts->next->d_filename = mutt_str_dup("msg.asc"); /* non pgp/mime can save */
 
cleanup:
  buf_pool_release(&tempfile);
  buf_pool_release(&pgpinfile);
  return t;
}

Here is the call graph for this function: