find_keys()

Find the keyids of the recipients of a message. More...

Collaboration diagram for find_keys():

Functions
char *	pgp_gpgme_find_keys (const struct AddressList *addrlist, bool oppenc_mode)
	Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
char *	smime_gpgme_find_keys (const struct AddressList *addrlist, bool oppenc_mode)
	Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
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() -.
char *	smime_class_find_keys (const struct AddressList *al, bool oppenc_mode)
	Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Detailed Description

Find the keyids of the recipients of a message.

Parameters

addrlist	Address List
oppenc_mode	If true, use opportunistic encryption

Return values

ptr	Space-separated string of keys
NULL	At least one of the keys can't be found

If oppenc_mode is true, only keys that can be determined without prompting will be used.

Function Documentation

pgp_gpgme_find_keys()

char * pgp_gpgme_find_keys	(	const struct AddressList *	addrlist,
		bool	oppenc_mode
	)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 3660 of file crypt_gpgme.c.

{
  return find_keys(addrlist, APPLICATION_PGP, oppenc_mode);
}

Here is the call graph for this function:

smime_gpgme_find_keys()

char * smime_gpgme_find_keys	(	const struct AddressList *	addrlist,
		bool	oppenc_mode
	)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 3668 of file crypt_gpgme.c.

{
  return find_keys(addrlist, APPLICATION_SMIME, oppenc_mode);
}

Here is the call graph for this function:

pgp_class_find_keys()

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

Definition at line 1463 of file pgp.c.

{
  struct ListHead crypt_hook_list = STAILQ_HEAD_INITIALIZER(crypt_hook_list);
  struct ListNode *crypt_hook = NULL;
  const char *keyid = NULL;
  char *keylist = NULL;
  size_t keylist_size = 0;
  size_t keylist_used = 0;
  struct Address *p = NULL;
  struct PgpKeyInfo *k_info = NULL;
  const char *fqdn = mutt_fqdn(true, NeoMutt->sub);
  char buf[1024] = { 0 };
  bool key_selected;
  struct AddressList hookal = TAILQ_HEAD_INITIALIZER(hookal);
 
  struct Address *a = NULL;
  const bool c_crypt_confirm_hook = cs_subset_bool(NeoMutt->sub, "crypt_confirm_hook");
  TAILQ_FOREACH(a, addrlist, entries)
  {
    key_selected = false;
    mutt_crypt_hook(&crypt_hook_list, a);
    crypt_hook = STAILQ_FIRST(&crypt_hook_list);
    do
    {
      p = a;
      k_info = NULL;
 
      if (crypt_hook)
      {
        keyid = crypt_hook->data;
        enum QuadOption ans = MUTT_YES;
        if (!oppenc_mode && c_crypt_confirm_hook && isatty(STDIN_FILENO))
        {
          snprintf(buf, sizeof(buf), _("Use keyID = \"%s\" for %s?"), keyid,
                   buf_string(p->mailbox));
          ans = query_yesorno_help(buf, MUTT_YES, NeoMutt->sub, "crypt_confirm_hook");
        }
        if (ans == MUTT_YES)
        {
          if (crypt_is_numerical_keyid(keyid))
          {
            if (mutt_strn_equal(keyid, "0x", 2))
              keyid += 2;
            goto bypass_selection; /* you don't see this. */
          }
 
          /* check for e-mail address */
          mutt_addrlist_clear(&hookal);
          if (strchr(keyid, '@') && (mutt_addrlist_parse(&hookal, keyid) != 0))
          {
            mutt_addrlist_qualify(&hookal, fqdn);
            p = TAILQ_FIRST(&hookal);
          }
          else if (!oppenc_mode)
          {
            k_info = pgp_getkeybystr(keyid, KEYFLAG_CANENCRYPT, PGP_PUBRING);
          }
        }
        else if (ans == MUTT_NO)
        {
          if (key_selected || STAILQ_NEXT(crypt_hook, entries))
          {
            crypt_hook = STAILQ_NEXT(crypt_hook, entries);
            continue;
          }
        }
        else if (ans == MUTT_ABORT)
        {
          FREE(&keylist);
          mutt_addrlist_clear(&hookal);
          mutt_list_free(&crypt_hook_list);
          return NULL;
        }
      }
 
      if (!k_info)
      {
        pgp_class_invoke_getkeys(p);
        k_info = pgp_getkeybyaddr(p, KEYFLAG_CANENCRYPT, PGP_PUBRING, oppenc_mode);
      }
 
      if (!k_info && !oppenc_mode && isatty(STDIN_FILENO))
      {
        snprintf(buf, sizeof(buf), _("Enter keyID for %s: "), buf_string(p->mailbox));
        k_info = pgp_ask_for_key(buf, buf_string(p->mailbox), KEYFLAG_CANENCRYPT, PGP_PUBRING);
      }
 
      if (!k_info)
      {
        FREE(&keylist);
        mutt_addrlist_clear(&hookal);
        mutt_list_free(&crypt_hook_list);
        return NULL;
      }
 
      keyid = pgp_fpr_or_lkeyid(k_info);
 
    bypass_selection:
      keylist_size += mutt_str_len(keyid) + 4;
      MUTT_MEM_REALLOC(&keylist, keylist_size, char);
      sprintf(keylist + keylist_used, "%s0x%s", keylist_used ? " " : "", keyid);
      keylist_used = mutt_str_len(keylist);
 
      key_selected = true;
 
      pgp_key_free(&k_info);
      mutt_addrlist_clear(&hookal);
 
      if (crypt_hook)
        crypt_hook = STAILQ_NEXT(crypt_hook, entries);
 
    } while (crypt_hook);
 
    mutt_list_free(&crypt_hook_list);
  }
  return keylist;
}

Here is the call graph for this function:

smime_class_find_keys()

char * smime_class_find_keys	(	const struct AddressList *	al,
		bool	oppenc_mode
	)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 656 of file smime.c.

{
  struct SmimeKey *key = NULL;
  char *keyid = NULL, *keylist = NULL;
  size_t keylist_size = 0;
  size_t keylist_used = 0;
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    key = smime_get_key_by_addr(buf_string(a->mailbox), KEYFLAG_CANENCRYPT, true, oppenc_mode);
    if (!key && !oppenc_mode && isatty(STDIN_FILENO))
    {
      struct Buffer *prompt = buf_pool_get();
      buf_printf(prompt, _("Enter keyID for %s: "), buf_string(a->mailbox));
      key = smime_ask_for_key(buf_string(prompt), KEYFLAG_CANENCRYPT, true);
      buf_pool_release(&prompt);
    }
    if (!key)
    {
      if (!oppenc_mode)
        mutt_message(_("No (valid) certificate found for %s"), buf_string(a->mailbox));
      FREE(&keylist);
      return NULL;
    }
 
    keyid = key->hash;
    keylist_size += mutt_str_len(keyid) + 2;
    MUTT_MEM_REALLOC(&keylist, keylist_size, char);
    sprintf(keylist + keylist_used, "%s%s", keylist_used ? " " : "", keyid);
    keylist_used = mutt_str_len(keylist);
 
    smime_key_free(&key);
  }
  return keylist;
}

Here is the call graph for this function: