trunk/Src/wptKeylist.cpp

/* wptKeylist.cpp - Keylist element
 *      Copyright (C) 2001-2006, 2009 Timo Schulz
 *      Copyright (C) 2004 Andreas Jobs
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation; either version 2 
 * of the License, or (at your option) any later version.
 *  
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <commctrl.h>
#include <time.h>

#include "wptCommonCtl.h"
#include "wptTypes.h"
#include "wptGPG.h"
#include "wptKeylist.h"
#include "wptKeyManager.h"
#include "wptW32API.h"
#include "wptNLS.h"
#include "wptErrors.h"
#include "wptUTF8.h"
#include "wptRegistry.h"
#include "wptContext.h"
#include "wptVersion.h"
#include "resource.h"
#include "StringBuffer.h"


struct key_array_s {
    char keyid[32];
    int  checked;
};


static key_array_s*
key_array_new (DWORD items)
{
    key_array_s *ka;
    
    if (items == 0)
        BUG (NULL);
    ka = new key_array_s[items + 1];
    if (!ka)
        BUG (NULL);
    for (DWORD i = 0; i < items; i++)
        ka[i].checked = 0;
    return ka;
}

static void
key_array_release (key_array_s *ka)
{
    free_if_alloc (ka);
}


/* Check if the keyid @keyid is in the key array @ka.
   Return value: 1 if it exists, 0 otherwise. */
static int
key_array_search (key_array_s *ka, DWORD items, const char *keyid)
{
    for (DWORD i = 0; i < items; i++) {
        if (!stricmp (keyid, ka[i].keyid))
            return 1;   
    }
    return 0;
}


/* Return if there is a secret for @key.
   0 means success. */
static int
find_secret_key (gpgme_key_t key)
{
    winpt_key_s skey;
    
    if (!key->subkeys->keyid)
        return 0;
    memset (&skey, 0, sizeof (skey));
    if (winpt_get_seckey (key->subkeys->keyid, &skey))
        return 0;
    if (skey.ext && skey.ext->gloflags.divert_to_card)
        return 2;
    return skey.ctx? 1 : 0;
}


/* Update the gpgme key pointer of a single entry. */
static void
update_key (keylist_ctrl_t kl, int pos,
            gpgme_key_t key)
{
    if ((size_t)pos > kl->nkeys)
        BUG (0);
    kl->keys[pos] = key;
}


/* If @re_sorted == 0, then all keys from the key list control
   are stored as references in the array.
   Otherwise we just re-order the references in the array. */
static size_t
update_keys (keylist_ctrl_t kl, int re_sorted,
             gpgme_key_t **r_list)
{
    gpgme_key_t *rset;
    gpgme_key_t key;
    listview_ctrl_t lv = kl->lv;
    struct keycache_s *c;    
    size_t k_pos;
    int nkeys;

    nkeys = listview_count_items (lv, 0);
    if (!nkeys)
        BUG (0);
    
    if (!re_sorted) {
        rset = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
        *r_list = rset;
    }
    else
        rset = *r_list;
    k_pos = 0;
    for (int i = 0; i < nkeys; i++) {
        key = km_get_key_ptr (kl, i, &c);
        rset[k_pos++] = key;
    }
    return k_pos;
}


gpgme_user_id_t
get_nth_userid (gpgme_key_t key, int idx)
{
    gpgme_user_id_t t;

    if (!key->uids)
        return NULL;
    t = key->uids;
    while (idx-- && t->next)
        t = t->next;
    return t;
}


int
count_userids (gpgme_key_t key)
{
    gpgme_user_id_t u;
    int n = 1;

    u = key->uids;
    if (!u)
        return 0;
    while (u->next) {
        u = u->next;
        n++;
    }
    return n;
}


gpgme_subkey_t
get_nth_key (gpgme_key_t key, int idx)
{
    gpgme_subkey_t t;

    if (!key->subkeys)
        return NULL;
    t = key->subkeys;
    while (idx-- && t->next)
        t = t->next;
    return t;
}


int
count_subkeys (gpgme_key_t key)
{
    gpgme_subkey_t k;
    int n = 1;

    k = key->subkeys;
    if (!k)
        return 0;
    while (k->next) {
        k = k->next;
        n++;
    }
    return n;
}


/* Return the self signature of the key @keyid.
   If first is set, the first self sig will be returned. */
gpgme_key_sig_t
get_selfsig (gpgme_key_sig_t sigs, const char *keyid, int first)
{
    gpgme_key_sig_t s, self_sig=NULL;
    long timestamp=0;
    int off = 0;

    if (strlen (keyid) == 8)
        off = 8;

    for (s = sigs; s; s = s->next) {
        if (!strcmp (s->keyid+off, keyid) && s->timestamp > timestamp) {
            self_sig = s;
            timestamp = s->timestamp;
            if (first) /* do not search for later self sigs. */
                break;
        }
    }
    return self_sig;
}


const char*
get_key_algo (gpgme_key_t key, int keyidx)
{
    static char algo_id[128];
    gpgme_subkey_t k;
    char alg[32];
    const char *subalg;
    int n;
    
    if (keyidx > 0) {
        k = get_nth_key (key, keyidx-1);
        subalg =  get_key_pubalgo (k->pubkey_algo);
        _snprintf (algo_id, DIM (algo_id)-1, "%s", subalg);
        return algo_id;
    }
    strcpy (alg, get_key_pubalgo (key->subkeys->pubkey_algo));
    n = count_subkeys (key);
    if (n > 1) {
        do {
            k = get_nth_key (key, --n);
            if (k->revoked || k->expired)
                continue;
            else
                break;
        } while (n > 0);
        subalg = get_key_pubalgo (k->pubkey_algo);
        if (k == key->subkeys)
            _snprintf (algo_id, DIM (algo_id)-1, "%s", subalg);
        else
            _snprintf (algo_id, DIM (algo_id)-1, "%s/%s", alg, subalg);
        return algo_id;
    }
    return get_key_pubalgo (key->subkeys->pubkey_algo);
}


const char*
get_key_created (long timestamp)
{
    static char timebuf[128];   

    if (timestamp < 1)
        return "????" "-??" "-??";
    if (!get_locale_date (timestamp, timebuf, DIM (timebuf)-1))
        return "????" "-??" "-??";
    return timebuf;
}


/* Return a string presentation of the time @timestamp. */
const char*
get_key_expire_date (long timestamp)
{
    static char timebuf[64];

    if (timestamp == 0)
        return _("Never");
    if (!get_locale_date (timestamp, timebuf, DIM (timebuf)-1))
        return "????" "-??" "-??";
    return timebuf;
}


const char*
get_key_type (gpgme_key_t key)
{
    int type = find_secret_key (key);

    if (type == 1)
        return _("Key Pair");
    else if (type == 2)
        return _("Key Pair (Card)");
    return _("Public Key");
}


const char*
get_key_size (gpgme_key_t key, int keyidx)
{
    static char size_id[64];
    gpgme_subkey_t k;
    int n, size_main, size_sub;
    
    if (keyidx > 0) {
        k = get_nth_key (key, keyidx-1);
        size_main = k->length;
        _snprintf (size_id, DIM (size_id)-1, "%d", size_main);
        return size_id;
    }
    size_main =  key->subkeys->length;
    n = count_subkeys (key);
    if (n > 1) {
        k = get_nth_key (key, n-1);
        size_sub = k->length;
        _snprintf (size_id, DIM (size_id) - 1, "%d/%d", 
                    size_main, size_sub);
        return size_id; 
    }
    _snprintf (size_id, DIM (size_id) - 1, "%d", size_main);
    return size_id;
}


const char*
get_key_pubalgo2 (gpgme_pubkey_algo_t alg)
{
    switch (alg) {
    case GPGME_PK_DSA: return "D";
    case GPGME_PK_RSA: return "R";
    case GPGME_PK_ELG: return "G";
    default: return "?";
    }
    return "?";
}


const char*
get_key_pubalgo (gpgme_pubkey_algo_t alg)
{
    switch (alg) {
    case GPGME_PK_DSA: 
        return "DSA";

    case GPGME_PK_ELG:
    case GPGME_PK_ELG_E: 
        return "ELG";
        
    case GPGME_PK_RSA: 
    case GPGME_PK_RSA_S:
    case GPGME_PK_RSA_E: 
        return "RSA";
        
    case 0:
        /* Should never happen */
        /*BUG (NULL);*/
            
    default: 
        return "???";
    }
    
    return "???";
}


const char*
get_key_fpr (gpgme_key_t key)
{
    static char fpr_md[64];
    const char *fpr;
    char t[16], tmp[40];
    size_t i;
    
    memset (fpr_md, 0, sizeof (fpr_md));
    fpr = key->subkeys->fpr;
    if (!fpr || !*fpr) {
        memset (tmp, '0', 40);
        fpr = tmp;
    }
    if (strlen (fpr) == 32) {
        strcat (fpr_md, "        ");
        for (i=0; i < strlen (fpr)/2; i++) {
            sprintf (t, "%c%c ", fpr[2*i], fpr[2*i+1]);
            strcat (fpr_md, t);
        }
    }
    else {
        strcat (fpr_md, " ");
        for (i = 0; i < strlen (fpr) / 4; i++) {
            sprintf (t, "%c%c%c%c ", fpr[4*i], fpr[4*i+1], fpr[4*i+2], fpr[4*i+3]);
            strcat (fpr_md, t);
        }
    }
    return fpr_md;
}


/* Extract the key ID from the fingerprint.
   A long ID will be converted into a short ID. */
const char*
get_keyid_from_fpr (const char *fpr)
{
    if (!fpr)
        return "????????";
    if (strlen (fpr) == 40)
        fpr += 32;
    else if (strlen (fpr) == 32)
        fpr += 24;
    else if (strlen (fpr) == 16)
        fpr += 8;
    else
        return "????????";
    return fpr;
}


const char*
get_key_trust2 (gpgme_key_t key, int val, int uididx, int listmode)
{
    if (key)
        val = key->owner_trust; /* uididx?? */
    switch (val) {
    case GPGME_VALIDITY_UNKNOWN:
    case GPGME_VALIDITY_UNDEFINED:    
        return _("None");
    case GPGME_VALIDITY_NEVER:    
        return _("Never");
    case GPGME_VALIDITY_MARGINAL:
        return _("Marginal");
    case GPGME_VALIDITY_FULL:
        return _("Full");
    case GPGME_VALIDITY_ULTIMATE:
        return _("Ultimate");
    }
    return "";
}


const char*
get_key_trust (gpgme_key_t key, int uididx, int listmode)
{
    return get_key_trust2 (key, 0, uididx, listmode);
}


const char*
get_key_trust_str (int val)
{
    return get_key_trust2 (NULL, val, 0, 0);
}


/* Return the status of the key @key. */
char*
get_key_status (gpgme_key_t key, int uididx, int listmode)
{
    gpgme_user_id_t u;
    const char *attr;
    u32 key_attr =0;

    if (uididx < 0 || count_userids (key) > uididx)
        uididx = 0;
    if (listmode) {
        const char *s;
        if (key->revoked)
            s = _("Revoked");
        else if (key->expired)
            s = _("Expired");
        else if (key->disabled)
            s = _("Disabled");
        else
            s = "";
        /* if the key has a special status, we don't continue to figure out
           the user-id validities. */
        if (*s)
            return m_strdup (s);
    }
    u = get_nth_userid (key, uididx);
    key_attr = u->validity;
    attr = get_key_trust2 (NULL, key_attr, 0, 0);
    return m_strdup (attr);
}


/* Return human readable description of the key @key. */
char*
get_key_desc (gpgme_key_t key)
{
    gpgme_key_t sk;
    const char *state, *alg, *type;
    char *desc;
    StringBuffer p;

    state = "";
    if (key->disabled)
        state = _("Disabled");
    if (key->expired)
        state = _("Expired");
    if (key->revoked)
        state = _("Revoked");

    /* If the fingerprint has 32 octets, we assume MD5 and thus
       an old, version 3, RSA key which is called 'Legacy' by other
       OpenPGP programs. */
    if (strlen (key->subkeys->fpr) == 32)
        alg = "RSA Legacy";
    else
        alg = "OpenPGP";
    type = _("public key");
    if (!get_seckey (key->subkeys->keyid+8, &sk))
        type = _("key pair");
    p = state;
    p = p + " " + alg + " " + type;
    desc = m_strdup (p.getBuffer ());
    return desc;
}


/* Integer comparsion of @a and @b. 
   Return values: same as in strcmp. */
static inline int
int_cmp (int a, int b)
{
    if (a == b) return 0;       
    else if (a > b) return 1;
    else return -1;
    return 0;
}


/* To allow to sort the keys, we need to take care of
   the expired/revoke status also. */
static int
get_ext_validity (gpgme_key_t k)
{
    if (k->revoked)
        return GPGME_VALIDITY_ULTIMATE+1;
    else if (k->expired)
        return GPGME_VALIDITY_ULTIMATE+2;
    else if (k->disabled)
        return GPGME_VALIDITY_ULTIMATE+3;
    return k->uids->validity;
}


/* List view sorting callback. */
static int CALLBACK
keylist_cmp_cb (LPARAM first, LPARAM second, LPARAM sortby)
{
    struct keycache_s *aa, *bb;
    gpgme_key_t a, b;
    int cmpresult = 0;
    
    aa = (struct keycache_s *)first;
    bb = (struct keycache_s *)second;
    if (!aa || !bb)
        BUG (NULL);
    a = aa->key;
    b = bb->key;
    
    switch (sortby & ~KEYLIST_SORT_DESC) {
    case KEY_SORT_USERID:
        cmpresult = strcmpi (a->uids->uid, b->uids->uid);
        break;
        
    case KEY_SORT_KEYID:
        cmpresult = strcmpi (a->subkeys->keyid+8,
                             b->subkeys->keyid+8);
        break;

    case KEY_SORT_VALIDITY:
        cmpresult = int_cmp (get_ext_validity (a), 
                             get_ext_validity (b));
        break;

    case KEY_SORT_OTRUST:
        cmpresult = int_cmp (a->owner_trust, b->owner_trust);
        break;

    case KEY_SORT_IS_SECRET:
        get_seckey (a->subkeys->keyid, &a);
        get_seckey (b->subkeys->keyid, &b);
        cmpresult = int_cmp (a? a->secret : 0, b? b->secret : 0);
        break;

    case KEY_SORT_LEN:
        cmpresult = int_cmp (a->subkeys->length, 
                             b->subkeys->length);
        break;

    case KEY_SORT_CREATED:
        cmpresult = int_cmp (a->subkeys->timestamp, 
                             b->subkeys->timestamp);
        break;

    case KEY_SORT_ALGO:
        cmpresult = int_cmp (a->subkeys->pubkey_algo,
                             b->subkeys->pubkey_algo);
        break;
        
    default:
        cmpresult = strcmpi (a->uids->uid, b->uids->uid);
        break;
    }
    if (sortby & KEYLIST_SORT_DESC)
        return (~cmpresult + 1);
    else
        return cmpresult;
}


int
keylist_add_groups (keylist_ctrl_t kl)
{
    return 0;
}


/* Synchronize the key array with the contents 
   of the keylist. */
void
keylist_sync (keylist_ctrl_t kl)
{
    free (kl->keys);
    kl->nkeys = update_keys (kl, 0, &kl->keys);
}


/* Create a listview for listing keys. Use the mode given in @mode
   and the control is given in @ctrl. */
static void
keylist_build (listview_ctrl_t *r_lv, HWND ctrl, int mode)
{
    struct listview_column_s klist_enc[] = {
    {0, 242, (char *)_("User ID")},
    {1, 80, (char *)_("Key ID")},
    {3, 46, (char *)_("Size")},
    {4, 50, (char *)_("Cipher")},
    {5, 70, (char *)_("Validity")},
    {0, 0, NULL}
    };
    struct listview_column_s klist[] = {
    {0, 240, (char *)_("User ID")},
    {1, 78, (char *)_("Key ID")},
    {2, 52, (char *)_("Type")},    
    {3, 66, (char *)_("Size")},
    {4, 60, (char *)_("Cipher")},
    {5, 66, (char *)_("Validity")},
    {6, 58, (char *)_("Trust")},
    {7, 72, (char *)_("Creation")},
    {0, 0, NULL}
    };
    HICON ico[8];
    listview_ctrl_t lv;
    listview_column_t col;
    int ncols = 0, ext_chkbox = 0;
    
    listview_new (&lv, ctrl);
    if (mode & KEYLIST_ENCRYPT_MIN) {
        col = klist_enc;
        ncols = (DIM (klist_enc) - 1);
        ext_chkbox = 1;
    }   
    else if (mode & KEYLIST_SIGN) {
        col = klist_enc;
        ncols = (DIM (klist_enc) - 1) - 1;
        ext_chkbox = 1;
    }
    else {
        col = klist;
        ncols = (DIM (klist) - 1);
    }
    
    for (int j = 0; j < ncols; j++)
        listview_add_column (lv, &col[j]);
    listview_set_ext_style (lv);
    if (ext_chkbox)
        listview_set_chkbox_style (lv);
    ico[0] = LoadIcon (glob_hinst, (LPCTSTR)IDI_PUBKEY);
    ico[1] = LoadIcon (glob_hinst, (LPCTSTR)IDI_KEYPAIR);
    ico[2] = LoadIcon (glob_hinst, (LPCTSTR)IDI_REV_KEYPAIR);
    ico[3] = LoadIcon (glob_hinst, (LPCTSTR)IDI_REV_PUBKEY);
    ico[4] = LoadIcon (glob_hinst, (LPCTSTR)IDI_SORT_DOWNARROW);
    ico[5] = LoadIcon (glob_hinst, (LPCTSTR)IDI_SORT_UPARROW);
    ico[6] = LoadIcon (glob_hinst, (LPCTSTR)IDI_EXP_PUBKEY);
    listview_set_image_list (lv, 20, 16, ico, 7);
    listview_del_all_items (lv);
    listview_set_grid_style (lv);
    *r_lv = lv;
}


static void
keylist_load_keycache (keylist_ctrl_t kl, int mode, 
                       gpg_keycache_t pubkc, gpg_keycache_t seckc)
{
    gpgme_key_t key, skey;
    struct keycache_s *c;
    const char *keyid;

    gpg_keycache_rewind (pubkc);
    if (pubkc && seckc) {
        while (!gpg_keycache_next_key2 (pubkc, 0, &c, &key)) {
            keyid = key->subkeys->keyid;
            if (keyid && !gpg_keycache_find_key (seckc, keyid, 0, &skey))
                keylist_add_key (kl, mode, c, key);
        }
    }
    else if (pubkc) {
        while (!gpg_keycache_next_key2 (pubkc, 0, &c, &key))
            keylist_add_key (kl, mode, c, key); 
    }
}


/* Load the list view @ctrl with the keys from the cache.
   Return value: list view context on success. */
keylist_ctrl_t
keylist_load (HWND ctrl, gpg_keycache_t pubkc, gpg_keycache_t seckc, 
              int mode, int sortby)
{    
    keylist_ctrl_t kl;
    
    kl = new keylist_ctrl_s;
    keylist_build (&kl->lv, ctrl, mode);  
    keylist_load_keycache (kl, mode, pubkc, seckc);
    kl->nkeys = update_keys (kl, 0, &kl->keys);
    keylist_sort (kl, sortby);    
    return kl;
}


/* Reload the given key list control @lv. */
int
keylist_reload (keylist_ctrl_t kl, gpg_keycache_t pubkc, int mode, int sortby)
{
    listview_del_all_items (kl->lv);
    keylist_load_keycache (kl, mode, pubkc, NULL);
    /* It is possible that the list shrinks or increases so we need to
       rebuild the list again. */
    free (kl->keys); kl->keys = NULL;
    kl->nkeys = update_keys (kl, 0, &kl->keys);
    keylist_sort (kl, sortby);
    return 0;
}


void
keylist_delete (keylist_ctrl_t kl)
{
    if (!kl)
        return;
    if (kl->keys != NULL) {
        free (kl->keys);
        kl->keys = NULL;
    }
    if (kl->lv != NULL) {
        listview_release (kl->lv);
        kl->lv = NULL;
    }
}


/* Enumeration for possible key icons. */
enum key_icontype_t {
    IMG_KEY_PUB = 0,
    IMG_KEY_PAIR = 1,
    IMG_KEY_PAIR_REV = 2,
    IMG_KEY_PUB_REV = 3,
    IMG_KEY_PUB_EXP = 6,
};


static int
key_get_image_id (gpgme_key_t key)
{
    if (find_secret_key (key))    
        return key->revoked ? IMG_KEY_PAIR_REV :IMG_KEY_PAIR;
    if (key->revoked)
        return IMG_KEY_PUB_REV;
    if (key->expired)
        return IMG_KEY_PUB_EXP;
    return IMG_KEY_PUB;
}


static int
do_addkey (listview_ctrl_t lv, struct keycache_s *ctx, gpgme_key_t key, 
           int uididx, int keyidx, int list)
{   
    gpgme_user_id_t u;
    gpgme_subkey_t k;
    LV_ITEM lvi;    
    char *p;
    const char *attr;
    int idx = 0;

    /* we check the pubkey algorithm here to make sure that no ElGamal
       sign+encrypt key is used in _any_ mode */
    if (list != 1 && key->subkeys->pubkey_algo == GPGME_PK_ELG) {
        log_debug ("ElGamal (E+S) key found: %s (%s)\n",
                   key->uids->name, key->subkeys->keyid);
        return 0;
    }

    if (listview_add_item2 (lv, " ", (void *)ctx))
        return WPTERR_GENERAL;

    attr = ctx->uids->uid;
    memset (&lvi, 0, sizeof lvi);
    lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
    lvi.pszText = (char *)attr;
    lvi.iImage = key_get_image_id (key);
    lvi.lParam = (LPARAM )ctx;
    if (ListView_SetItem (lv->ctrl, &lvi) == FALSE)
        return WPTERR_GENERAL;
        
    if (uididx == -1) { /* request the primary user-id of the key. */
        attr = ctx->uids->uid;
        uididx = 0;
    }
    else {
        u = get_nth_userid (key, uididx);
        if (!u || u->revoked || uididx < 0)
            uididx = 0;
        u = get_nth_userid (key, uididx);
        attr = u->uid;
    }
    if (attr == NULL || strlen (attr) < 5) { /* normal userids are > 5 chars */
        attr = _("Invalid User ID");
        listview_add_sub_item (lv, 0, idx++, attr);
    }   
    else        
        listview_add_sub_item (lv, 0, idx++, attr);
    k = get_nth_key (key, keyidx);
    if (k && k->keyid != NULL) {
        char keyid[16+1];

        _snprintf (keyid, DIM (keyid) -1, "0x%s", k->keyid + 8);
        listview_add_sub_item (lv, 0, idx++, keyid);
    }
    if (list > 0) {
        DWORD key_attr = find_secret_key (key);
        if (!key_attr)
            attr = "pub";
        else
            attr = key_attr == 1? "pub/sec" : "pub/crd";
        listview_add_sub_item (lv, 0, idx++, attr);
    }
    if (lv->cols >= 2) {
        attr = get_key_size (key, list == -1? keyidx+1 : 0);
        if (attr != NULL)
            listview_add_sub_item (lv, 0, idx++, attr);
    }
    if (lv->cols >= 3) {
        attr = get_key_algo (key, list == -1? keyidx+1 : 0);
        if (attr != NULL) 
            listview_add_sub_item( lv, 0, idx++, attr);
    }
    if (lv->cols >= 4) {
        p = get_key_status (key, uididx, list > 0? 1 : 0);
        if (p != NULL)
            listview_add_sub_item (lv, 0, idx++, p);
        free_if_alloc (p);
    }
    if (lv->cols >= 5) {
        attr = get_key_trust (key, uididx, list > 0? 1 : 0);
        listview_add_sub_item (lv, 0, idx++, attr);
    }
    if (lv->cols >= 6) {
        k = get_nth_key (key, keyidx);
        if (k->timestamp > 0) {
            attr = get_key_created (k->timestamp);
            listview_add_sub_item (lv, 0, idx++, attr);
        }
    }

    return 0;
}


/* Update a single column @col but for each element in the
   listview @lv. */
void
keylist_upd_col (keylist_ctrl_t kl, int col)
{
    gpgme_key_t key;
    const char *s;
    char buf[32], *p;

    for (int i=0; i < listview_count_items (kl->lv, 0); i++) {
        key = km_get_key_ptr (kl, i, NULL);
        if (!key)
            continue;
        switch (col) {
        case KM_COL_KEYID:
            _snprintf (buf, DIM (buf)-1, "0x%s", key->subkeys->keyid+8);
            listview_add_sub_item (kl->lv, i, col, buf);
            break;

        case KM_COL_CIPHER:
            s = get_key_algo (key, 0);
            listview_add_sub_item (kl->lv, i, col, s);
            break;

        case KM_COL_TYPE:
            s = find_secret_key (key)? "pub/sec" : "pub";
            listview_add_sub_item (kl->lv, i, col, s);
            break;

        case KM_COL_CREAT:
            s = get_key_created (key->subkeys->timestamp);
            listview_add_sub_item (kl->lv, i, col, s);
            break;

        case KM_COL_DESC:
            p = get_key_desc (key);
            listview_add_sub_item (kl->lv, i, col, p);
            free_if_alloc (p);
            break;
        }
    }
}


/* Update the listview item at position @pos with the data from
   the key @key. */
void
keylist_upd_key (keylist_ctrl_t kl, int pos, 
                 struct keycache_s *ctx, gpgme_key_t key)
{
    listview_ctrl_t lv = kl->lv;
    char *p;
    char tmp[32];

    listview_set_item2 (lv, pos, (void *)ctx);
    update_key (kl, pos, key);
    /* the only mode we support is KEYLIST_LIST in the Key Manager */
    
    const char *s = ctx->uids->uid;
    if (s)
        listview_add_sub_item (lv, pos, KM_COL_UID, s);

    s = key->subkeys->keyid;
    if (s) {
        sprintf (tmp, "0x%s", s+8);
        listview_add_sub_item (lv, pos, KM_COL_KEYID, tmp);
    }

    s = find_secret_key (key)? "pub/sec" : "pub";
    listview_add_sub_item (lv, pos, KM_COL_TYPE, s);

    s = get_key_size (key, 0);
    if (s)
        listview_add_sub_item (lv, pos, KM_COL_SIZE, s);

    s = get_key_algo (key, 0);
    if (s)
        listview_add_sub_item (lv, pos, KM_COL_CIPHER, s);

    p = get_key_status (key, 0, 1);
    if (p) {
        listview_add_sub_item (lv, pos, KM_COL_VALID, p);
        free_if_alloc (p);
    }

    s = get_key_trust (key, 0, 1);
    if (s)
        listview_add_sub_item (lv, pos, KM_COL_TRUST, s);

    long t = key->subkeys->timestamp;
    s = get_key_created (t);
    if (s)
        listview_add_sub_item (lv, pos, KM_COL_CREAT, s);
}


int
keylist_add_key (keylist_ctrl_t kl, int mode, 
                 struct keycache_s *ctx, gpgme_key_t key)
{    
    gpgme_subkey_t k;
    listview_ctrl_t lv = kl->lv;
    int uids, rc, i;

    /* if the entire key is disabled, just return. */
    if (key->disabled && !(mode & KEYLIST_LIST))
        return 0;

    for (k = key->subkeys, i = 0; i < count_subkeys (key); i++, k = k->next) {
        if (k->invalid) {
            log_debug ("keylist_add_key: invalid key \"%s\"\n", 
                       key->uids->name);
            continue; /* Don't use invalid keys */
        }

        if (mode & KEYLIST_ALL) {
            uids = count_userids (key);
            rc = do_addkey (lv, ctx, key, uids, i, 0);
            if (rc)
                return rc;
        }
        else if (mode & KEYLIST_LIST)
            return do_addkey (lv, ctx, key, -1, i, 1);
        else if (mode & KEYLIST_ENCRYPT) {
            if (k->can_encrypt && key_is_useable (k)) {
                if (mode & KEYLIST_FLAG_FILE) {
                    rc = do_addkey (lv, ctx, key, -1, i, -1);
                    if (rc)
                        return rc;
                }
                else {
                    for (uids = 0;  uids < count_userids (key); uids++) {
                        rc = do_addkey (lv, ctx, key, uids, i, -1);
                        if (rc)
                            return rc;
                    }
                }
            }
        }
        else if (mode & KEYLIST_ENCRYPT_MIN) {
            if (k->can_encrypt && key_is_useable (k)) {
                rc = do_addkey (lv, ctx, key, -1, i, -1);
                return rc;
            }
        }       
        else if (mode & KEYLIST_SIGN) {
            if (k->can_sign 
                && find_secret_key (key)
                && key_is_useable (k)) {
                rc = do_addkey (lv, ctx, key, -1, i, -1);
                if (rc)
                    return rc;  
            }
        }       
    }

    return 0;
}


int
keylist_sort (keylist_ctrl_t kl, int sortby)
{
    int ret = listview_sort_items (kl->lv, sortby, keylist_cmp_cb);
    kl->nkeys = update_keys (kl, 1, &kl->keys);
    return ret;
}


/* Check that the validity @validity is at least >= marginal. */
static int
key_check_validity (gpgme_key_t key)
{
    gpgme_user_id_t u;

    for (u=key->uids; u; u =u->next) {
        if (u->validity >= GPGME_VALIDITY_MARGINAL)
            return -1;
    }

    return 0;
}


/* Extract all selected recipients from the list @lv and return them 
   as a vector. @r_force_trust is >= 1 if one of the recipients is not
   fully trusted. @r_count returns the number of selected keys.
   Return value: the key list on success, NULL otherwise. */
gpgme_key_t*
keylist_get_recipients (keylist_ctrl_t kl, int *r_force_trust, size_t *r_count)
                        
{
    gpgme_key_t *keybuf, key;
    listview_ctrl_t lv = kl->lv;
    key_array_s *ka = NULL;
    keycache_s *c;    
    size_t count = 0;
    int force_trust = 0;
    int nkeys, ka_pos = 0, rc = 0;
    int k_pos=0;

    nkeys = listview_count_items (lv, 0);    
    ka = key_array_new (nkeys);
    keybuf = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
    if (!keybuf)
        BUG (NULL);
        
    for (int j = 0; j < nkeys; j++) {
        if (listview_get_item_state (lv, j) || nkeys == 1) {
            key = km_get_key_ptr (kl, j, &c);
            if (!key)
                BUG (0);
            if (!key_check_validity (key) &&
                !key_array_search (ka, ka_pos, key->subkeys->keyid)) {
                StringBuffer warn;
                warn = warn + c->uids->uid + ":\n\n"; 
                warn = warn +_("It is NOT certain that the key belongs to the person\n"
                         "named in the user ID.  If you *really* know what you are\n"
                         "doing, you may answer the next question with no\n"
                         "\nSkip this key?");
                rc = msg_box (NULL, warn.getBuffer(), _("Warning"), MB_WARN_ASK);
                if (reg_prefs.always_trust || rc == IDNO) {
                    keybuf[k_pos++] = key;
                    force_trust++;
                    ka[ka_pos].checked = 1;
                    strcpy (ka[ka_pos++].keyid, key->subkeys->keyid);
                    count++;
                }
            }
            else {
                keybuf[k_pos++] = key;
                count++;        
            }
        }
    }
    key_array_release (ka);
    if (r_force_trust)
        *r_force_trust = force_trust;
    if (r_count)
        *r_count = count;
    return keybuf;
}


static int
keylist_get_keyflags (gpgme_key_t key)
{
    int flags = KEYFLAG_NONE;

    if (key->revoked)
        flags |= KEYFLAG_REVOKED;
    if (key->expired)
        flags |= KEYFLAG_EXPIRED;
    if (key->disabled)
        flags |= KEYFLAG_DISABLED;

    return flags;
}


gpgme_key_t*
keylist_enum_recipients (keylist_ctrl_t kl,  int listype, size_t *r_count)
{
    gpgme_key_t *rset;
    gpgme_key_t key;
    listview_ctrl_t lv = kl->lv;
    struct keycache_s *c;    
    size_t k_pos;
    int nkeys, id;

    nkeys = listview_count_items (lv, 0);
    if (!nkeys)
        return 0;
    rset = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
    if (!rset)
        BUG (NULL);
    k_pos = 0;
    for (int i = 0; i < nkeys; i++) {
        if (!listview_get_item_state (lv, i))
            continue;
        key = km_get_key_ptr (kl, i, &c);
        switch (listype) {
        case KEYLIST_LIST:
            if (keylist_get_keyflags (key) & KEYFLAG_REVOKED) {
                id = printf_box (_("Recipients"), MB_INFO|MB_YESNO,
                _("KeyID %s.\nDo you really want to export a revoked key?"),
                                 c->uids->uid);
                if (id == IDNO)
                    continue;
            }
            break;
        }
        rset[k_pos++] = key;
    }
    if (r_count)
        *r_count = k_pos;
    return rset;
}


void
seclist_destroy (keylist_t *list)
{
    keylist_t l2;

    while (*list) {
        l2 = (*list)->next;
        safe_free (*list);
        *list = l2;     
    }
    *list = NULL;
}


void
seclist_init (HWND dlg, int ctlid, int flags, keylist_t *ret_list)
{    
    gpg_keycache_t kc;
    gpgme_key_t key = NULL;
    HWND kb;
    keylist_t list=NULL, l, l2;    
    long pos;

    SendDlgItemMessage (dlg, ctlid, CB_RESETCONTENT, 0, 0);
    kb = GetDlgItem (dlg, ctlid);
    kc = keycache_get_ctx (0);
    if (!kc)
        BUG (0);
    gpg_keycache_rewind (kc);
    
    while (!gpg_keycache_next_key (kc, 1, &key)) {
        StringBuffer inf;
        char *uid;
        const char *id;

        if (key->disabled || !key_is_useable (key->subkeys))
            continue;

        if (flags & KEYLIST_FLAG_SHORT)
            id = key->uids->name;
        else
            id = key->uids->uid;
        if (!id || !key->subkeys->keyid)
            continue;   

        uid = utf8_to_native (id);
        inf = uid;
        inf = inf + " (" + get_key_pubalgo (key->subkeys->pubkey_algo) + "/";
        inf = inf + "0x" + (key->subkeys->keyid+8) + ")";

        combox_add_string (kb, inf.getBuffer ());
        safe_free (uid);
        l = (struct keylist_s *)calloc (1, sizeof * l);
        if (!l)
            BUG (0);
        l->key = key;
        if (!list)
            list = l;
        else {
            for( l2 = list; l2->next; l2 = l2->next )
                ;
            l2->next = l;
        }
    }
    for (pos = 0, l2=list; pos < SendMessage (kb, CB_GETCOUNT, 0, 0); 
         pos++, l2=l2->next)
        SendMessage (kb, CB_SETITEMDATA, pos, (LPARAM)(DWORD)l2->key);
    SendMessage (kb, CB_SETCURSEL, 0, 0);
    *ret_list = list;
}


/* Select a secret key from the combo box with the ID @ctlid.
   Return the code on success in @ret_key. */
int
seclist_select_key (HWND dlg, int ctlid, gpgme_key_t *ret_key)
{
    int pos;
    DWORD k = 0;

    pos = SendDlgItemMessage (dlg, ctlid, CB_GETCURSEL, 0, 0);
    if (pos == CB_ERR) {
        msg_box (dlg, _("No key was selected."), _("Secret Key List"), MB_ERR);
        *ret_key = NULL;
    }
    else {
        k = SendDlgItemMessage (dlg, ctlid, CB_GETITEMDATA, pos, 0);
        *ret_key = (gpgme_key_t)k;
    }
    return k? 0 : -1; 
}


LRESULT 
keylist_listview_notify (HWND hwnd, gpgme_key_t *keys, 
                         int ctlid, LPARAM lparam)
{
    LPNMHDR lpnmh = (LPNMHDR)lparam;
    
    if (!lpnmh)
        BUG (NULL);

    /* Make sure the message is for the control and
       that we have a key list. */
    if (lpnmh->idFrom != (DWORD)ctlid || keys == NULL)
        return 0;
    
    switch (lpnmh->code) {
    case NM_CUSTOMDRAW:
        LPNMLVCUSTOMDRAW lplvcd;
        lplvcd = (LPNMLVCUSTOMDRAW)lparam;
        if (lplvcd->nmcd.dwDrawStage == CDDS_PREPAINT)            
            return CDRF_NOTIFYITEMDRAW;

        if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT) {
            int pos = lplvcd->nmcd.dwItemSpec;
            
            gpgme_key_t key = keys[pos];            
            if (key == NULL)
                return CDRF_DODEFAULT;
            
            HWND lv = GetDlgItem (hwnd, ctlid);
            HFONT hfont = (HFONT)SendMessage (lv, WM_GETFONT, 0, 0);
            LOGFONT lf;
            if (!GetObject (hfont, sizeof (lf), &lf))
                BUG (NULL);
            if (key->revoked)
                lf.lfStrikeOut = TRUE;
            else if (key->expired)
                lf.lfItalic = TRUE;
            if (find_secret_key (key))
                lf.lfWeight = FW_SEMIBOLD;
            hfont = CreateFontIndirect (&lf);
            SelectObject (lplvcd->nmcd.hdc, hfont);
            if (pos & 1)
                lplvcd->clrTextBk = RGB (0xE5, 0xE5, 0xE5);
            return CDRF_NEWFONT | CDRF_NOTIFYPOSTPAINT;
        }
        
        if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPOSTPAINT) {
            HFONT hfont = (HFONT)GetStockObject (DEFAULT_GUI_FONT);
            hfont = (HFONT)SelectObject (lplvcd->nmcd.hdc, hfont);
            DeleteObject (hfont);
            return CDRF_DODEFAULT;
        }
        return CDRF_DODEFAULT;   
    }

    return 0;
}