pgp_traditional_encryptsign()

Create an inline PGP encrypted, signed email. More...

Collaboration diagram for pgp_traditional_encryptsign():

Functions
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() -.

Detailed Description

Create an inline PGP encrypted, signed email.

Parameters

b	Body of the email
flags	Flags, see SecurityFlags
keylist	List of keys to encrypt to (space-separated)

Return values

ptr	New encrypted/signed Body
NULL	Error

Function Documentation

pgp_class_traditional_encryptsign()

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() -.

Definition at line 1720 of file pgp.c.

{
  struct Body *b_enc = NULL;
  char body_charset[256] = { 0 };
  const char *from_charset = NULL;
  const char *send_charset = NULL;
  bool empty = false;
  bool err;
  char buf[256] = { 0 };
  pid_t pid;
  struct Buffer *pgpinfile = buf_pool_get();
  struct Buffer *pgpoutfile = buf_pool_get();
 
  if (b->type != TYPE_TEXT)
    goto cleanup;
  if (!mutt_istr_equal(b->subtype, "plain"))
    goto cleanup;
 
  FILE *fp_body = mutt_file_fopen(b->filename, "r");
  if (!fp_body)
  {
    mutt_perror("%s", b->filename);
    goto cleanup;
  }
 
  buf_mktemp(pgpinfile);
  FILE *fp_pgp_in = mutt_file_fopen(buf_string(pgpinfile), "w");
  if (!fp_pgp_in)
  {
    mutt_perror("%s", buf_string(pgpinfile));
    mutt_file_fclose(&fp_body);
    goto cleanup;
  }
 
  /* The following code is really correct:  If noconv is set,
   * b's charset parameter contains the on-disk character set, and
   * we have to convert from that to utf-8.  If noconv is not set,
   * we have to convert from $charset to utf-8.  */
 
  mutt_body_get_charset(b, body_charset, sizeof(body_charset));
  if (b->noconv)
    from_charset = body_charset;
  else
    from_charset = cc_charset();
 
  if (mutt_ch_is_us_ascii(body_charset))
  {
    send_charset = "us-ascii";
    mutt_file_copy_stream(fp_body, fp_pgp_in);
  }
  else
  {
    int c;
    struct FgetConv *fc = NULL;
 
    if (flags & SEC_ENCRYPT)
      send_charset = "us-ascii";
    else
      send_charset = "utf-8";
 
    /* fromcode is assumed to be correct: we set flags to 0 */
    fc = mutt_ch_fgetconv_open(fp_body, from_charset, "utf-8", MUTT_ICONV_NO_FLAGS);
    while ((c = mutt_ch_fgetconv(fc)) != EOF)
      fputc(c, fp_pgp_in);
 
    mutt_ch_fgetconv_close(&fc);
  }
  mutt_file_fclose(&fp_body);
  mutt_file_fclose(&fp_pgp_in);
 
  buf_mktemp(pgpoutfile);
  FILE *fp_pgp_out = mutt_file_fopen(buf_string(pgpoutfile), "w+");
  FILE *fp_pgp_err = mutt_file_mkstemp();
  if (!fp_pgp_out || !fp_pgp_err)
  {
    mutt_perror("%s", fp_pgp_out ? "Can't create temporary file" : buf_string(pgpoutfile));
    unlink(buf_string(pgpinfile));
    if (fp_pgp_out)
    {
      mutt_file_fclose(&fp_pgp_out);
      unlink(buf_string(pgpoutfile));
    }
    mutt_file_fclose(&fp_pgp_err);
    goto cleanup;
  }
 
  pid = pgp_invoke_traditional(&fp_pgp_in, NULL, NULL, -1, fileno(fp_pgp_out),
                               fileno(fp_pgp_err), buf_string(pgpinfile), keylist, flags);
  if (pid == -1)
  {
    mutt_perror(_("Can't invoke PGP"));
    mutt_file_fclose(&fp_pgp_out);
    mutt_file_fclose(&fp_pgp_err);
    mutt_file_unlink(buf_string(pgpinfile));
    unlink(buf_string(pgpoutfile));
    goto cleanup;
  }
 
  if (pgp_use_gpg_agent())
    *PgpPass = '\0';
  if (flags & SEC_SIGN)
    fprintf(fp_pgp_in, "%s\n", PgpPass);
  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;
 
  mutt_file_unlink(buf_string(pgpinfile));
 
  fflush(fp_pgp_out);
  fflush(fp_pgp_err);
 
  rewind(fp_pgp_out);
  rewind(fp_pgp_err);
 
  if (!empty)
    empty = (fgetc(fp_pgp_out) == EOF);
  mutt_file_fclose(&fp_pgp_out);
 
  err = false;
 
  while (fgets(buf, sizeof(buf), fp_pgp_err))
  {
    err = true;
    fputs(buf, stdout);
  }
 
  mutt_file_fclose(&fp_pgp_err);
 
  if (err)
    mutt_any_key_to_continue(NULL);
 
  if (empty)
  {
    if (flags & SEC_SIGN)
      pgp_class_void_passphrase(); /* just in case */
    unlink(buf_string(pgpoutfile));
    goto cleanup;
  }
 
  b_enc = mutt_body_new();
 
  b_enc->encoding = ENC_7BIT;
 
  b_enc->type = TYPE_TEXT;
  b_enc->subtype = mutt_str_dup("plain");
 
  mutt_param_set(&b_enc->parameter, "x-action",
                 (flags & SEC_ENCRYPT) ? "pgp-encrypted" : "pgp-signed");
  mutt_param_set(&b_enc->parameter, "charset", send_charset);
 
  b_enc->filename = buf_strdup(pgpoutfile);
 
  b_enc->disposition = DISP_NONE;
  b_enc->unlink = true;
 
  b_enc->noconv = true;
  b_enc->use_disp = false;
 
  if (!(flags & SEC_ENCRYPT))
    b_enc->encoding = b->encoding;
 
cleanup:
  buf_pool_release(&pgpinfile);
  buf_pool_release(&pgpoutfile);
  return b_enc;
}

Here is the call graph for this function: