code/pgpinvoke_8c_source.html

#include "config.h"

#include <fcntl.h>

#include <stdbool.h>

#include <stdio.h>

#include <unistd.h>

#include "mutt/lib.h"

#include "address/lib.h"

#include "config/lib.h"

#include "core/lib.h"

#include "gui/lib.h"

#include "pgpinvoke.h"

#include "lib.h"

#include "expando/lib.h"

#include "expando_command.h"

#include "globals.h"

#include "mutt_logging.h"

#include "pgpkey.h"

#include "protos.h"

#ifdef CRYPT_BACKEND_CLASSIC_PGP

#include "pgp.h"

#endif


static void mutt_pgp_command(struct Buffer *buf, struct PgpCommandContext *cctx,

                             const struct Expando *exp)

{

  expando_render(exp, PgpCommandRenderCallbacks, cctx, MUTT_FORMAT_NO_FLAGS, buf->dsize, buf);

  mutt_debug(LL_DEBUG2, "%s\n", buf_string(buf));

}


static pid_t pgp_invoke(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                        int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                        bool need_passphrase, const char *fname, const char *sig_fname,

                        const char *ids, const struct Expando *exp)

{

  struct PgpCommandContext cctx = { 0 };


  if (!exp)

    return (pid_t) -1;


  cctx.need_passphrase = need_passphrase;

  cctx.fname = fname;

  cctx.sig_fname = sig_fname;

  const char *const c_pgp_sign_as = cs_subset_string(NeoMutt->sub, "pgp_sign_as");

  const char *const c_pgp_default_key = cs_subset_string(NeoMutt->sub, "pgp_default_key");

  if (c_pgp_sign_as)

    cctx.signas = c_pgp_sign_as;

  else

    cctx.signas = c_pgp_default_key;

  cctx.ids = ids;


  struct Buffer *cmd = buf_pool_get();

  mutt_pgp_command(cmd, &cctx, exp);


  pid_t pid = filter_create_fd(buf_string(cmd), fp_pgp_in, fp_pgp_out, fp_pgp_err,

                               fd_pgp_in, fd_pgp_out, fd_pgp_err, EnvList);

  buf_pool_release(&cmd);

  return pid;

}


pid_t pgp_invoke_decode(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                        int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                        const char *fname, bool need_passphrase)

{

  const struct Expando *c_pgp_decode_command = cs_subset_expando(NeoMutt->sub, "pgp_decode_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out, fd_pgp_err,

                    need_passphrase, fname, NULL, NULL, c_pgp_decode_command);

}


pid_t pgp_invoke_verify(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                        int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                        const char *fname, const char *sig_fname)

{

  const struct Expando *c_pgp_verify_command = cs_subset_expando(NeoMutt->sub, "pgp_verify_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                    fd_pgp_err, false, fname, sig_fname, NULL, c_pgp_verify_command);

}


pid_t pgp_invoke_decrypt(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                         int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname)

{

  const struct Expando *c_pgp_decrypt_command = cs_subset_expando(NeoMutt->sub, "pgp_decrypt_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                    fd_pgp_err, true, fname, NULL, NULL, c_pgp_decrypt_command);

}


pid_t pgp_invoke_sign(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                      int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname)

{

  const struct Expando *c_pgp_sign_command = cs_subset_expando(NeoMutt->sub, "pgp_sign_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                    fd_pgp_err, true, fname, NULL, NULL, c_pgp_sign_command);

}


pid_t pgp_invoke_encrypt(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                         int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                         const char *fname, const char *uids, bool sign)

{

  if (sign)

  {

    const struct Expando *c_pgp_encrypt_sign_command = cs_subset_expando(NeoMutt->sub, "pgp_encrypt_sign_command");

    return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                      fd_pgp_err, true, fname, NULL, uids, c_pgp_encrypt_sign_command);

  }

  else

  {

    const struct Expando *c_pgp_encrypt_only_command = cs_subset_expando(NeoMutt->sub, "pgp_encrypt_only_command");

    return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                      fd_pgp_err, false, fname, NULL, uids, c_pgp_encrypt_only_command);

  }

}


pid_t pgp_invoke_traditional(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                             int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                             const char *fname, const char *uids, SecurityFlags flags)

{

  if (flags & SEC_ENCRYPT)

  {

    const struct Expando *c_pgp_encrypt_only_command = cs_subset_expando(NeoMutt->sub, "pgp_encrypt_only_command");

    const struct Expando *c_pgp_encrypt_sign_command = cs_subset_expando(NeoMutt->sub, "pgp_encrypt_sign_command");

    return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                      fd_pgp_err, (flags & SEC_SIGN), fname, NULL, uids,

                      (flags & SEC_SIGN) ? c_pgp_encrypt_sign_command : c_pgp_encrypt_only_command);

  }

  else

  {

    const struct Expando *c_pgp_clear_sign_command = cs_subset_expando(NeoMutt->sub, "pgp_clear_sign_command");

    return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                      fd_pgp_err, true, fname, NULL, NULL, c_pgp_clear_sign_command);

  }

}


void pgp_class_invoke_import(const char *fname)

{

  struct PgpCommandContext cctx = { 0 };


  struct Buffer *buf_fname = buf_pool_get();

  struct Buffer *cmd = buf_pool_get();


  buf_quote_filename(buf_fname, fname, true);

  cctx.fname = buf_string(buf_fname);

  const char *const c_pgp_sign_as = cs_subset_string(NeoMutt->sub, "pgp_sign_as");

  const char *const c_pgp_default_key = cs_subset_string(NeoMutt->sub, "pgp_default_key");

  if (c_pgp_sign_as)

    cctx.signas = c_pgp_sign_as;

  else

    cctx.signas = c_pgp_default_key;


  const struct Expando *c_pgp_import_command = cs_subset_expando(NeoMutt->sub, "pgp_import_command");

  mutt_pgp_command(cmd, &cctx, c_pgp_import_command);

  if (mutt_system(buf_string(cmd)) != 0)

    mutt_debug(LL_DEBUG1, "Error running \"%s\"\n", buf_string(cmd));


  buf_pool_release(&buf_fname);

  buf_pool_release(&cmd);

}


void pgp_class_invoke_getkeys(struct Address *addr)

{

  struct Buffer *personal = NULL;

  struct PgpCommandContext cctx = { 0 };


  const struct Expando *c_pgp_get_keys_command = cs_subset_expando(NeoMutt->sub, "pgp_get_keys_command");

  if (!c_pgp_get_keys_command)

    return;


  struct Buffer *buf = buf_pool_get();

  struct Buffer *cmd = buf_pool_get();

  personal = addr->personal;

  addr->personal = NULL;


  struct Buffer *tmp = buf_pool_get();

  mutt_addr_to_local(addr);

  mutt_addr_write(tmp, addr, false);

  buf_quote_filename(buf, buf_string(tmp), true);

  buf_pool_release(&tmp);


  addr->personal = personal;


  cctx.ids = buf_string(buf);


  mutt_pgp_command(cmd, &cctx, c_pgp_get_keys_command);


  int fd_null = open("/dev/null", O_RDWR);


  if (!isendwin())

    mutt_message(_("Fetching PGP key..."));


  if (mutt_system(buf_string(cmd)) != 0)

    mutt_debug(LL_DEBUG1, "Error running \"%s\"\n", buf_string(cmd));


  if (!isendwin())

    mutt_clear_error();


  if (fd_null >= 0)

    close(fd_null);


  buf_pool_release(&buf);

  buf_pool_release(&cmd);

}


pid_t pgp_invoke_export(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                        int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *uids)

{

  const struct Expando *c_pgp_export_command = cs_subset_expando(NeoMutt->sub, "pgp_export_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                    fd_pgp_err, false, NULL, NULL, uids, c_pgp_export_command);

}


pid_t pgp_invoke_verify_key(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                            int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *uids)

{

  const struct Expando *c_pgp_verify_key_command = cs_subset_expando(NeoMutt->sub, "pgp_verify_key_command");

  return pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in, fd_pgp_out,

                    fd_pgp_err, false, NULL, NULL, uids, c_pgp_verify_key_command);

}


pid_t pgp_invoke_list_keys(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err,

                           int fd_pgp_in, int fd_pgp_out, int fd_pgp_err,

                           enum PgpRing keyring, struct ListHead *hints)

{

  struct Buffer *uids = buf_pool_get();

  struct Buffer *quoted = buf_pool_get();


  struct ListNode *np = NULL;

  STAILQ_FOREACH(np, hints, entries)

  {

    buf_quote_filename(quoted, (char *) np->data, true);

    buf_addstr(uids, buf_string(quoted));

    if (STAILQ_NEXT(np, entries))

      buf_addch(uids, ' ');

  }


  const struct Expando *c_pgp_list_pubring_command = cs_subset_expando(NeoMutt->sub, "pgp_list_pubring_command");

  const struct Expando *c_pgp_list_secring_command = cs_subset_expando(NeoMutt->sub, "pgp_list_secring_command");

  pid_t rc = pgp_invoke(fp_pgp_in, fp_pgp_out, fp_pgp_err, fd_pgp_in,

                        fd_pgp_out, fd_pgp_err, 0, NULL, NULL, buf_string(uids),

                        (keyring == PGP_SECRING) ? c_pgp_list_secring_command :

                                                   c_pgp_list_pubring_command);


  buf_pool_release(&uids);

  buf_pool_release(&quoted);

  return rc;

}

mutt_addr_write
size_t mutt_addr_write(struct Buffer *buf, struct Address *addr, bool display)
Write a single Address to a buffer.
Definition: address.c:1050

mutt_addr_to_local
bool mutt_addr_to_local(struct Address *a)
Convert an Address from Punycode.
Definition: address.c:1340

lib.h
Email Address Handling.

buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241

buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226

buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96

cs_subset_string
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291

cs_subset_expando
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:357

lib.h
Convenience wrapper for the config headers.

lib.h
Convenience wrapper for the core headers.

expando_render
int expando_render(const struct Expando *exp, const struct ExpandoRenderCallback *erc, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Render an Expando + data into a string.
Definition: expando.c:118

lib.h
Parse Expando string.

PgpCommandRenderCallbacks
const struct ExpandoRenderCallback PgpCommandRenderCallbacks[]
Callbacks for PGP Command Expandos.
Definition: expando_command.c:101

expando_command.h
Ncrypt PGP Expando definitions.

buf_quote_filename
void buf_quote_filename(struct Buffer *buf, const char *filename, bool add_outer)
Quote a filename to survive the shell's quoting rules.
Definition: file.c:933

EnvList
char ** EnvList
Private copy of the environment variables.
Definition: globals.c:75

pgp_class_invoke_getkeys
void pgp_class_invoke_getkeys(struct Address *addr)
Run a command to download a PGP key - Implements CryptModuleSpecs::pgp_invoke_getkeys() -.
Definition: pgpinvoke.c:316

pgp_class_invoke_import
void pgp_class_invoke_import(const char *fname)
Import a key from a message into the user's public key ring - Implements CryptModuleSpecs::pgp_invoke...
Definition: pgpinvoke.c:288

mutt_message
#define mutt_message(...)
Definition: logging2.h:91

mutt_debug
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89

lib.h
Convenience wrapper for the gui headers.

LL_DEBUG2
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44

LL_DEBUG1
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43

filter_create_fd
pid_t filter_create_fd(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, int fdin, int fdout, int fderr, char **envlist)
Run a command on a pipe (optionally connect stdin/stdout)
Definition: filter.c:62

lib.h
Convenience wrapper for the library headers.

_
#define _(a)
Definition: message.h:28

mutt_clear_error
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74

mutt_logging.h
NeoMutt Logging.

SecurityFlags
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:82

SEC_ENCRYPT
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:84

SEC_SIGN
#define SEC_SIGN
Email is signed.
Definition: lib.h:85

pgp.h
PGP sign, encrypt, check routines.

pgp_invoke_verify_key
pid_t pgp_invoke_verify_key(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *uids)
Use PGP to verify a key.
Definition: pgpinvoke.c:398

pgp_invoke_encrypt
pid_t pgp_invoke_encrypt(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, const char *uids, bool sign)
Use PGP to encrypt a file.
Definition: pgpinvoke.c:230

pgp_invoke_decode
pid_t pgp_invoke_decode(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, bool need_passphrase)
Use PGP to decode a message.
Definition: pgpinvoke.c:133

pgp_invoke_traditional
pid_t pgp_invoke_traditional(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, const char *uids, SecurityFlags flags)
Use PGP to create in inline-signed message.
Definition: pgpinvoke.c:265

pgp_invoke
static pid_t pgp_invoke(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, bool need_passphrase, const char *fname, const char *sig_fname, const char *ids, const struct Expando *exp)
Run a PGP command.
Definition: pgpinvoke.c:87

pgp_invoke_sign
pid_t pgp_invoke_sign(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname)
Use PGP to sign a file.
Definition: pgpinvoke.c:205

pgp_invoke_verify
pid_t pgp_invoke_verify(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, const char *sig_fname)
Use PGP to verify a message.
Definition: pgpinvoke.c:158

pgp_invoke_export
pid_t pgp_invoke_export(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *uids)
Use PGP to export a key from the user's keyring.
Definition: pgpinvoke.c:375

mutt_pgp_command
static void mutt_pgp_command(struct Buffer *buf, struct PgpCommandContext *cctx, const struct Expando *exp)
Prepare a PGP Command.
Definition: pgpinvoke.c:61

pgp_invoke_list_keys
pid_t pgp_invoke_list_keys(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, enum PgpRing keyring, struct ListHead *hints)
Find matching PGP Keys.
Definition: pgpinvoke.c:422

pgp_invoke_decrypt
pid_t pgp_invoke_decrypt(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname)
Use PGP to decrypt a file.
Definition: pgpinvoke.c:182

pgpinvoke.h
Wrapper around calls to external PGP program.

pgpkey.h
PGP key management routines.

PgpRing
PgpRing
PGP ring type.
Definition: pgpkey.h:38

PGP_SECRING
@ PGP_SECRING
Secret keys.
Definition: pgpkey.h:40

buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82

buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96

protos.h
Prototypes for many functions.

mutt_system
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:52

STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352

STAILQ_NEXT
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400

MUTT_FORMAT_NO_FLAGS
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: render.h:33

lib.h
Key value store.

Address
An email address.
Definition: address.h:36

Address::personal
struct Buffer * personal
Real name of address.
Definition: address.h:37

Buffer
String manipulation buffer.
Definition: buffer.h:36

Buffer::dsize
size_t dsize
Length of data.
Definition: buffer.h:39

Expando
Parsed Expando trees.
Definition: expando.h:41

ListNode
A List node for strings.
Definition: list.h:37

ListNode::data
char * data
String.
Definition: list.h:38

NeoMutt
Container for Accounts, Notifications.
Definition: neomutt.h:42

NeoMutt::sub
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46

PgpCommandContext
Data for a PGP command.
Definition: pgp.h:43

PgpCommandContext::need_passphrase
bool need_passphrase
p
Definition: pgp.h:44

PgpCommandContext::signas
const char * signas
a
Definition: pgp.h:47

PgpCommandContext::fname
const char * fname
f
Definition: pgp.h:45

PgpCommandContext::ids
const char * ids
r
Definition: pgp.h:48

PgpCommandContext::sig_fname
const char * sig_fname
s
Definition: pgp.h:46