trunk/Src/wptKeyEditDlgs.cpp

/* wptKeyEditDlgs.cpp - GPG key edit dialogs
 *      Copyright (C) 2002-2006 Timo Schulz
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

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

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

/* All edit key commands. */
enum keyedit_commands {    
    CMD_ADDKEY = 0,
    CMD_ADDUID,
    CMD_ADDPHOTO,
    CMD_ADDREVOKER,
    CMD_DELUID,
    CMD_DELKEY,
    CMD_EXPIRE,
    CMD_SHOWPREF,
    CMD_SETPREF,
    CMD_PASSWD,
    CMD_PRIMARY,
    CMD_TRUST,
    CMD_REVUID,
    CMD_REVKEY,
    CMD_DISABLE,
    CMD_ENABLE,    
    CMD_SIGN,
    CMD_LSIGN,
    CMD_CHECK,
    CMD_CLEAN,
    CMD_MINIMIZE
};

struct cmdlist_s {
    const char   *name;
    unsigned int  need_pair:1;
    int       id;
} cmdlist[] = {
    {"ADDKEY", 1, CMD_ADDKEY},
    {"ADDUID", 1, CMD_ADDUID},
    {"ADDPHOTO", 1, CMD_ADDPHOTO},
    {"ADDREVOKER", 1, CMD_ADDREVOKER},
    {"DELUID", 1, CMD_DELUID},
    {"DELKEY", 1, CMD_DELKEY},
    {"EXPIRE", 1, CMD_EXPIRE},
    {"SHOWPREF", 0, CMD_SHOWPREF},
    {"SETPREF", 1, CMD_SETPREF},
    {"PASSWD", 1, CMD_PASSWD},
    {"PRIMARY", 1, CMD_PRIMARY},
    {"TRUST", 0, CMD_TRUST},
    {"REVUID", 1, CMD_REVUID},
    {"REVKEY", 1, CMD_REVKEY},
    {"DISABLE", 0, CMD_DISABLE},
    {"ENABLE", 0, CMD_ENABLE},
    {"SIGN", 0, CMD_SIGN},
    {"LSIGN", 0, CMD_LSIGN},
    {"CHECK", 0, CMD_CHECK},
    {"CLEAN", 0, CMD_CLEAN},
    {"MINIMIZE", 0, CMD_MINIMIZE},
    {NULL, 0}  
};


/* Symbolic ids for the subkey columns. */
enum subk_col_t {
    SUBK_COL_DESC       = 0,
    SUBK_COL_KEYID      = 1,    
    SUBK_COL_CREATION   = 2,    
    SUBK_COL_EXPIRES    = 3,
    SUBK_COL_STATUS     = 4,
    SUBK_COL_C_FLAG     = 5,
    SUBK_COL_S_FLAG     = 6,
    SUBK_COL_E_FLAG     = 7,
    SUBK_COL_A_FLAG     = 8
};

/* Symbolic ids for the userid columns. */
enum uid_col_t {
    UID_COL_VALID       = 0,
    UID_COL_NAME        = 1,
    UID_COL_EMAIL       = 2,
    UID_COL_CREATION    = 3
};

/* Key edit callback context. */
struct keyedit_cb_s {
    HWND            parent; /* parent window handle. */
    const char     *keyid;  /* key ID of the key. */
    const char     *pass;   /* pointer to the passphrase. */
    listview_ctrl_t lv;
    int             lv_pos;
    void           *opaque;
    unsigned int    finished:1;
    unsigned int    is_protected:1;
};
typedef struct keyedit_cb_s *keyedit_cb_t;


/* Key generation callback context. */
struct keygen_cb_s {
    int    bits;
    int    algo;
    DWORD  expire;
    char  *fpr;
    char  *name;
    char  *comment;
    char  *email;
};
typedef struct keygen_cb_s *keygen_cb_t;

/* Subclass context for the subkey list. */
static subclass_s keyedit_subkey_proc;

/* Subclass context for the user-id list. */
static subclass_s keyedit_uid_proc;

int keygen_check_date (SYSTEMTIME *st);
void get_userid_preflist (const char *old_prefs, char **r_prefs, int *r_flags);
char* get_subkey_keyid (const char *keyid);
void ComboBox_AddString_utf8 (HWND cb, const char *txt);


/* Safe wrapper for allocation. */
static GpgKeyEdit*
create_GpgKeyEdit (const char *keyid)
{
    GpgKeyEdit *ke;

    ke = new GpgKeyEdit (keyid);
    if (!ke)
        BUG (NULL);
    return ke;
}


/* Associate each key with a combo box entry. 
   Skip the key in @k. */
static void
do_init_keylist (HWND dlg, const char *keyid)
{
    gpg_keycache_t pub;
    gpgme_key_t key;
    const char *s, *kid;
    int i, n;

    pub = keycache_get_ctx (1);
    gpg_keycache_rewind (pub);
    while (!gpg_keycache_next_key (pub, 0, &key)) {
        if (key->expired || key->revoked || 
            key->disabled || key->invalid)
            continue;
        s = key->uids->uid;
        kid = key->subkeys->keyid;
        if (!s || !strcmp (kid+8, keyid))
            continue;
        ComboBox_AddString_utf8 (GetDlgItem (dlg, IDC_ADDREV_KEYLIST), s);
    }
    gpg_keycache_rewind (pub);
    n = SendDlgItemMessage (dlg, IDC_ADDREV_KEYLIST, CB_GETCOUNT, 0, 0);
    for (i = 0; i < n; i++) {
        gpg_keycache_next_key (pub, 0, &key);
        SendDlgItemMessage (dlg, IDC_ADDREV_KEYLIST, CB_SETITEMDATA, 
                            (WPARAM)(int)i, (LPARAM)key);
    }
    SendDlgItemMessage (dlg, IDC_ADDREV_KEYLIST, CB_SETCURSEL, 0, 0);
}


/* Add a new user-id to the list view @lv. */
static void
do_add_new_userid (listview_ctrl_t lv, 
                   const char *utf8_name, const char *email, 
                   const char *utf8_comment)
{
    char *p, *native;
    size_t n;
    
    n = strlen (utf8_name) + strlen (email) + 16;
    if (utf8_comment)
        n += strlen (utf8_comment);
    p = new char[n+1];
    if (!p)
        BUG (NULL);
    if (utf8_comment)
        sprintf (p, "%s (%s)", utf8_name, utf8_comment);
    else
        sprintf (p, "%s", utf8_name);
    native = utf8_to_native (p);
    free_if_alloc (p);

    listview_add_item (lv, "");
    listview_add_sub_item (lv, 0, UID_COL_VALID, _("Ultimate" ));
    listview_add_sub_item (lv, 0, UID_COL_NAME, native);
    listview_add_sub_item (lv, 0, UID_COL_EMAIL, email && *email? email : "");
    listview_add_sub_item (lv, 0, UID_COL_CREATION, get_key_created (time (NULL)));
    free_if_alloc (native);
}


static void
do_add_new_subkey (listview_ctrl_t lv, keygen_cb_t keygen, unsigned int flags)
{
    char info[128], keyid[32];
    const char *expdate, *s, *kid;
    int n;
    
    expdate = keygen->expire? get_key_expire_date (keygen->expire) : _("Never");
    _snprintf (info, sizeof (info)-1, "%d-bit %s",
               keygen->bits,
               get_key_pubalgo ((gpgme_pubkey_algo_t)keygen->algo));
    kid = get_keyid_from_fpr (keygen->fpr);
    _snprintf (keyid, sizeof (keyid)-1, "0x%s", kid);
    s = get_key_created (time (NULL));
    n = listview_count_items (lv, 0);
    listview_add_item_pos (lv, n);
    listview_add_sub_item (lv, n, SUBK_COL_DESC, info);
    listview_add_sub_item (lv, n, SUBK_COL_KEYID, keyid);
    listview_add_sub_item (lv, n, SUBK_COL_CREATION, s);
    listview_add_sub_item (lv, n, SUBK_COL_EXPIRES, expdate);
    if (flags & KM_FLAG_REVOKED)
        s = _("Revoked");       
    else if (flags & KM_FLAG_EXPIRED)
        s = _("Expired");
    else 
        s = _("OK");
    listview_add_sub_item (lv, n, SUBK_COL_STATUS, s);
}


/* Try to find the GPG edit key index which belongs to the user ID
   given by the email address @email, @name is used as a fallback.
   If @r_inf != NULL, the info context will be returned.
   Return value: index of the user ID or -1 on error. */
static int
do_find_userid (const char *keyid, const char *email, 
                const char *name, gpg_uid_info_t *r_inf)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;
    gpg_uid_info_t inf, ui;
    int pos = -1;

    ke = create_GpgKeyEdit (keyid);
    err = ke->getUseridInfo (&inf);
    delete ke;
    if (err) {
        log_box (_("user ID"), MB_ERR, 
                 _("Could not get key information for: \"%s\":\n%s"), 
                 name, gpgme_strerror (err));
        return -1;
    }

    for (ui = inf; ui; ui = ui->next) {
        if (name && email && ui->email && ui->name) {
            if (!strcmp (ui->email, email) && 
                !strncmp (ui->name, name, strlen (name))) {
                pos = ui->index;
                break;
            }
            continue;
        }
        if (email && ui->email) {
            if (!strcmp (ui->email, email)) {
                pos = ui->index;
                break;
            }
            /* The email address is more unique, use the name just
               as the fallbck when no email address is available. */
            continue;
        }
        if (ui->name && name && !strcmp (ui->name, name)) {
            pos = ui->index;
            break;
        }
    }
    if (r_inf)
        *r_inf = inf;
    else
        gpg_uid_info_release (inf);
    return pos;
}


/* Return true if @fname is a JPEG file. */
bool
is_jpg_file (const char *fname)
{
    FILE *fp;
    BYTE buf[10];
    int n;

    fp = fopen (fname, "rb");
    if (!fp)
        return false;
    n = fread (buf, 1, 10, fp);
    fclose (fp);
    if (n < 10)
        return false;
    return buf[6] == 'J' && buf[7] == 'F' &&
           buf[8] == 'I' && buf[9] == 'F';
}


/* Dialog box procedure to add a photo. */
BOOL CALLBACK
keyedit_addphoto_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keyedit_cb_t cb;
    GpgKeyEdit *ke;
    gpgme_error_t err;
    const char *s;    
    char file[128];
    int id;

    switch( msg ) {
    case WM_INITDIALOG:
        cb = (keyedit_cb_t)lparam;
        if (!cb)
            BUG (NULL);
        SetDlgItemText (dlg, IDC_ADDPHOTO_INF, _("Remember that the image is stored within your public key.  If you use a very large picture, your key will become very large as well! Keeping the image close to 240x288 is a good size to use."));
        SetDlgItemText (dlg, IDC_ADDPHOTO_FILEINF, _("Pick an image to use for your photo ID.\nThe image must be a JPEG file."));
        SetDlgItemText (dlg, IDC_ADDPHOTO_PWDINF, _("Passphrase"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        SetWindowText (dlg, _("Add Photo ID"));
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        switch( LOWORD (wparam)) {
        case IDC_ADDPHOTO_SELFILE:
            s = get_fileopen_dlg (dlg, _("Select Image File"), 
                                  "JPEG Files (*.jpg, *.jpeg)\0*.jpg;*.jpeg\0\0",
                                  NULL);
            if (s && !is_jpg_file (s)) {
                log_box (_("Add Photo"), MB_ERR, 
                         _("'%s' is not a valid JPEG file."), s);
                return FALSE;
            }
            if (s && *s)
                SetDlgItemText (dlg, IDC_ADDPHOTO_FILE, s);
            break;

        case IDOK:
            if (!GetDlgItemText (dlg, IDC_ADDPHOTO_FILE, file, sizeof (file)-1)){
                msg_box (dlg, _("Please enter a file name."), 
                         _("Add Photo"), MB_ERR);
                return FALSE;
            }
            if (get_file_size (file) == 0 || get_file_size (file) > 6144) {
                id = msg_box (dlg, _("The JPEG is really large.\n"
                                     "Are you sure you want to use it?"), 
                                     _("Add Photo"), MB_YESNO|MB_INFO);
                if (id == IDNO)
                    return TRUE;
            }
            ke = create_GpgKeyEdit (cb->keyid);
            if (cb->pass)
                ke->setPassphrase (cb->pass);
            else
                ke->setNoPassphrase (true);
            err = ke->addPhotoid (file);
            delete ke;
            if (err) {
                msg_box (dlg, gpgme_strerror (err), _("Add Photo"), MB_ERR);
                return FALSE;
            }
            else {
                cb->finished = 1;
                msg_box (dlg, _("Photo successfully added."), 
                         _("GnuPG Status"), MB_OK);
            }
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }
    return FALSE;
}


/* Dialog box procedure to add a designated revoker. */
BOOL CALLBACK
keyedit_addrevoker_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keyedit_cb_t cb;
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char *uid=NULL;

    switch (msg) {
    case WM_INITDIALOG:
        cb = (keyedit_cb_t)lparam;
        if (!cb)
            BUG (NULL);
        do_init_keylist (dlg, cb->keyid);
        SetDlgItemText (dlg, IDC_ADDREV_INF, 
                        _("Appointing a key as designated revoker cannot be undone."));
        SetDlgItemText (dlg, IDC_ADDREV_KEYINF, _("Public key"));
        SetDlgItemText (dlg, IDC_ADDREV_PWDINF, _("Passphrase"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        SetWindowText (dlg, _("Add Revoker"));
        SetForegroundWindow (dlg);
        center_window (dlg, cb->parent);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            if (!GetDlgItemText_utf8 (dlg, IDC_ADDREV_KEYLIST, &uid)) {
                msg_box (dlg, _("Please select a user ID."), _("Add Revoker"), MB_ERR);
                return FALSE;
            }
        
            ke = create_GpgKeyEdit (cb->keyid);
            if (cb->pass)
                ke->setPassphrase (cb->pass);
            else
                ke->setNoPassphrase (true);
            err = ke->addDesignatedRevoker (uid);
            delete ke;
            safe_free (uid);
            if (err) {
                msg_box (dlg, gpgme_strerror (err), _("Add Revoker"), MB_ERR);
                return TRUE;
            }
            else {
                cb->finished = 1;
                msg_box (dlg, _("Revoker successfully addded."), 
                         _("GnuPG Status"), MB_OK);
            }
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }
    return FALSE;
}


/* Dialog box procedure to add a new user-ID. */
BOOL CALLBACK
keyedit_adduid_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keyedit_cb_t ctx;
    keygen_cb_t keygen;
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char *utf8_name = NULL;
    char *utf8_comment = NULL;
    char email[128];
    int rc;
    
    switch (msg) {
    case WM_INITDIALOG:
        ctx = (keyedit_cb_t)lparam;
        if (!ctx)
            dlg_fatal_error(dlg, "Could not get dialog param!");
        SetWindowText (dlg, _("Add new User ID"));
        SetDlgItemText (dlg, IDC_ADDUID_INFNAME, _("&Name"));
        SetDlgItemText (dlg, IDC_ADDUID_INFEMAIL, _("&Email"));
        SetDlgItemText (dlg, IDC_ADDUID_INFCOMMENT, _("&Comment"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        SetForegroundWindow (dlg);
        center_window (dlg, ctx->parent);
        return FALSE;
        
    case WM_COMMAND:
        switch ( LOWORD( wparam ) )  {
        case IDOK:
            keygen = (keygen_cb_t)ctx->opaque;
            rc = GetDlgItemText_utf8 (dlg, IDC_ADDUID_NAME, &utf8_name);
            if (!rc || rc < 5) {
                msg_box (dlg, _("Please enter a name (min. 5 chars.)"), 
                         _("UserID"), MB_ERR);
                free_if_alloc (utf8_name);
                return FALSE;
            }
            if (strchr (utf8_name, '@')) {
                msg_box (dlg, _("Please enter the email address in the email field and not in the name field"), 
                         _("UserID"), MB_INFO);
                free_if_alloc (utf8_name);
                return FALSE;
            }

            if( !GetDlgItemText (dlg, IDC_ADDUID_EMAIL, email, sizeof (email) -1)) {
                msg_box (dlg, _("Please enter an email address."), _("UserID"), MB_ERR);
                free_if_alloc (utf8_name);
                return FALSE;
            }
            if (check_email_address (email)) {
                msg_box (dlg, _("Invalid email address."), _("UserID"), MB_ERR);
                free_if_alloc (utf8_name);
                return FALSE;
            }
            
            rc = GetDlgItemText_utf8 (dlg, IDC_ADDUID_COMMENT, &utf8_comment);

            ke = create_GpgKeyEdit (ctx->keyid);
            if (ctx->is_protected)
                ke->setPassphrase (ctx->pass);
            else
                ke->setNoPassphrase (true);
            err = ke->addUserid (utf8_name, utf8_comment, email);
            if (err)
                msg_box (dlg, gpgme_strerror (err), _("UserID"), MB_ERR);
            else {
                msg_box (dlg, _("user ID successfully added."), _("GnuPG Status"), MB_OK);
                ctx->finished = 1;
                /* The caller releases this items later. */
                keygen->name = utf8_name;
                keygen->comment = utf8_comment;
                keygen->email = m_strdup (email);
            }
            delete ke;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    
    return FALSE;
}


/* Initalize a combo box with default key sizes (1024-4096). */
static void
init_keysize_box (HWND dlg, int ctlid)
{
    const char *sizelist[] = {
        "1024", "1536", 
        "2048", "3072", 
        "4096", NULL
    };
    int i;

    for (i=0; sizelist[i] != NULL; i++)
        SendDlgItemMessage (dlg, ctlid, CB_ADDSTRING, 0, 
                            (LPARAM)(char*)sizelist[i]);
    SendDlgItemMessage (dlg, ctlid, CB_SETCURSEL, (WPARAM)2, 0);
}


static int
get_keysize_from_box (HWND dlg, int ctlid)
{
    int pos;
    char buf[32];

    pos = SendDlgItemMessage (dlg, ctlid, CB_GETCURSEL, 0, 0);
    if (pos == CB_ERR)
        return -1;
    SendDlgItemMessage (dlg, ctlid, CB_GETLBTEXT, pos, (LPARAM)(char*)buf);
    return atoi (buf);
}


/* Create a time_t from a system time @st. */
time_t
w32_mktime (SYSTEMTIME *st)
{
    struct tm tm;

    memset (&tm, 0, sizeof (tm));
    tm.tm_year = st->wYear-1900;
    tm.tm_mday = st->wDay+1;
    tm.tm_mon = st->wMonth-1;
    return mktime (&tm);
}


/* Dialog procedure for adding a new secondary key. */
BOOL CALLBACK
keyedit_addsubkey_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keyedit_cb_t ctx;
    keygen_cb_t keygen;
    GpgKeyEdit *ke;
    gpgme_error_t err;
    SYSTEMTIME st;
    HWND hwnd;
    int index, size, valid;
    
    switch (msg) {
    case WM_INITDIALOG:
        ctx = (keyedit_cb_t)lparam;
        if (!ctx)
            BUG (NULL);
        SetWindowText (dlg, _("Add new Subkey"));
        SetDlgItemText (dlg, IDC_ADDSUBKEY_INFALGO, _("Key type"));
        SetDlgItemText (dlg, IDC_ADDSUBKEY_INFSIZE, _("Size in bits"));
        SetDlgItemText (dlg, IDC_ADDSUBKEY_INFVALID, _("Key expiration"));
        SetDlgItemText (dlg, IDC_ADDSUBKEY_EXPIRE, _("&Never"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));

        hwnd = GetDlgItem (dlg, IDC_ADDSUBKEY_ALGO);
        listbox_add_string (hwnd, "DSA (sign only)");
        listbox_add_string (hwnd, "ElGamal (encrypt only)");
        listbox_add_string (hwnd, "RSA (sign only)");
        listbox_add_string (hwnd, "RSA (encrypt only)");
        CheckDlgButton (dlg, IDC_ADDSUBKEY_EXPIRE, BST_CHECKED);
        EnableWindow (GetDlgItem (dlg, IDC_ADDSUBKEY_EXPDATE), FALSE);
        init_keysize_box (dlg, IDC_ADDSUBKEY_SIZE);
        SetForegroundWindow (dlg);
        center_window (dlg, ctx->parent);
        return FALSE;
        
    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED && 
            LOWORD (wparam) == IDC_ADDSUBKEY_EXPIRE) {
            if (IsDlgButtonChecked (dlg, IDC_ADDSUBKEY_EXPIRE))
                EnableWindow (GetDlgItem (dlg, IDC_ADDSUBKEY_EXPDATE), FALSE);
            else
                EnableWindow (GetDlgItem (dlg, IDC_ADDSUBKEY_EXPDATE), TRUE);
        }
        if (HIWORD (wparam) == LBN_SELCHANGE && 
            LOWORD (wparam) == IDC_ADDSUBKEY_ALGO) {
            index = SendMessage ((HWND)lparam, LB_GETCURSEL, 0, 0);
            if (index == 0)
                SendDlgItemMessage (dlg, IDC_ADDSUBKEY_SIZE, CB_SETCURSEL, 0, 0);
        }

        switch (LOWORD (wparam)) {
        case IDOK:
            keygen = (keygen_cb_t)ctx->opaque;
            assert (keygen);
            hwnd = GetDlgItem (dlg, IDC_ADDSUBKEY_ALGO);
            switch (listbox_get_cursel (hwnd)) {
            case 0: index = 2; break;
            case 1: index = 4; break;
            case 2: index = 5; break;
            case 3: index = 6; break;
            default:
                msg_box (dlg, _("Please select one entry."), 
                         _("Add Subkey"), MB_ERR);
                return FALSE;
            }
            size = get_keysize_from_box (dlg, IDC_ADDSUBKEY_SIZE);
            if (index == 2 && size != 1024) {
                msg_box (dlg,_("DSS uses a fixed keysize of 1024. Size changed."),
                         _("Add Subkey"), MB_INFO);
                size = 1024;
            }

            hwnd = GetDlgItem (dlg, IDC_ADDSUBKEY_EXPDATE);
            DateTime_GetSystemtime (hwnd, &st);
            valid = w32_mktime (&st) - time (NULL);
            valid /= 86400;

            keygen->bits = size;
            switch (index) {
            case 2: keygen->algo = GPGME_PK_DSA; break;
            case 4: keygen->algo = GPGME_PK_ELG_E; break;
            case 5: keygen->algo = GPGME_PK_RSA_S; break;
            case 6: keygen->algo = GPGME_PK_RSA_E; break;
            }
            if (valid > 0)
                keygen->expire = time (NULL) + valid*24*60*60;

            ke = create_GpgKeyEdit (ctx->keyid);
            ke->setCallback (keygen_cb, NULL);
            if (ctx->is_protected)
                ke->setPassphrase (ctx->pass);
            else
                ke->setNoPassphrase (true);
            keygen_cb_dlg_create ();

            err = ke->addSubkey ((gpgme_pubkey_algo_t)index, size, valid);
            keygen->fpr = get_subkey_keyid (ctx->keyid);
            keygen_cb_dlg_destroy (1);
            if (err)
                msg_box (dlg, gpgme_strerror (err), _("Add Subkey"), MB_ERR);
            else {
                msg_box (dlg, _("Subkey successfully added."), 
                         _("GnuPG Status"), MB_OK);
                ctx->finished = 1;
            }
            delete ke;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    
    return FALSE;
}


BOOL
keyedit_add_userid (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    keyedit_cb_s cb;
    keygen_cb_s keygen;
    char *pass = NULL;
    int cancel = 0;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), 
                 _("Add user ID"), MB_ERR);
        return FALSE;
    }

    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }

    memset (&keygen, 0, sizeof (keygen));
    memset (&cb, 0, sizeof cb);
    cb.parent = dlg;
    cb.opaque = &keygen;
    cb.is_protected = k->is_protected;
    cb.pass = pass;
    cb.keyid = k->keyid;
    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYEDIT_ADDUID,
                      dlg, keyedit_adduid_dlg_proc,         
                      (LPARAM)&cb, _("Add user ID"),
                      IDS_WINPT_KEYEDIT_ADDUID);
    if (lv != NULL && cb.finished)
        do_add_new_userid (lv, keygen.name, keygen.email, keygen.comment);
    if (cb.finished)
        k->update = 1;

    free_if_alloc (keygen.name);
    free_if_alloc (keygen.email);
    free_if_alloc (keygen.comment);
    sfree_if_alloc (pass);
    return TRUE;
}


/* Return the keyID of the last subkey. */
char*
get_subkey_keyid (const char *keyid)
{
    gpgme_error_t err;
    gpgme_key_t key;
    gpgme_ctx_t ctx;
    gpgme_subkey_t subk;
    char *kid = NULL;

    err = gpgme_new (&ctx);
    if (err)
        return NULL;
    err = gpgme_get_key (ctx, keyid, &key, 0);
    gpgme_release (ctx);
    if (err)
        return NULL;
    subk = get_nth_key (key, count_subkeys (key));
    if (subk != NULL)
        kid = strdup (subk->keyid);
    gpgme_key_release (key);
    return kid;
}


BOOL
keyedit_add_subkey (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    keyedit_cb_s cb;
    keygen_cb_s keygen;
    char *pass = NULL;
    int cancel = 0;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), 
                 _("Add Subkey"), MB_ERR);
        return FALSE;
    }
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }

    memset (&keygen, 0, sizeof (keygen));
    memset (&cb, 0, sizeof (cb));
    cb.keyid = k->keyid;
    cb.is_protected = k->is_protected;
    cb.pass = pass;
    cb.opaque = &keygen;
    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYEDIT_ADDSUBKEY,    
                      dlg, keyedit_addsubkey_dlg_proc,
                      (LPARAM)&cb, _("Add new Subkey"),
                      IDS_WINPT_KEYEDIT_ADDSUBKEY);
    if (lv != NULL && cb.finished)
        do_add_new_subkey (lv, &keygen, 0);
    if (cb.finished)
        k->update = 1;

    safe_free (keygen.fpr);
    sfree_if_alloc (pass);
    return cb.finished? TRUE: FALSE;
}


/* Set the preferred keyserver of the given key @k. */
BOOL
keyedit_set_pref_keyserver (winpt_key_t k, HWND dlg)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;
    struct URL_ctx_s *url;
    char *pass = NULL;

    url = (struct URL_ctx_s *)get_keyserver_URL_dlg (dlg);
    if (url->cancel == 1) {
        delete url;
        return FALSE;
    }

    pass = request_key_passphrase (k->ctx, _("Key Edit"), &url->cancel);
    if (url->cancel) {
        delete url;
        return FALSE;
    }

    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    err = ke->setPreferredKeyserver (-1, url->url);
    if (!err)
        msg_box (dlg, _("Preferred keyserver successfully set."), _("Key Edit"), MB_OK);
    else
        msg_box (dlg, gpgme_strerror (err), _("Key Edit"), MB_ERR);

    sfree_if_alloc (pass);
    delete ke;
    delete url;
    return err == 0? 0 : WPTERR_GENERAL;
}


/* Add a photo-ID to the key specified in @k. @dlg is the handle of
   the calling dialog. */
BOOL
keyedit_add_photo (winpt_key_t k, HWND dlg)
{
    keyedit_cb_s cb;
    char *pass = NULL;
    int cancel;
    
    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), 
                 _("Add Photo"), MB_ERR);
        return FALSE;
    }

    memset (&cb, 0, sizeof (cb));
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }
    cb.parent = dlg;
    cb.pass = pass;
    cb.keyid = k->keyid;
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT_ADDPHOTO, dlg,
                    keyedit_addphoto_dlg_proc, (LPARAM)&cb);

    if (cb.finished)
        k->update = 1;
    sfree_if_alloc (pass);    
    return TRUE;
}


BOOL
keyedit_add_revoker (winpt_key_t k, HWND dlg)
{
    keyedit_cb_s cb;
    char *pass = NULL;
    int cancel;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), _("Add Revoker"), MB_ERR);
        return FALSE;
    }

    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }

    memset (&cb, 0, sizeof (cb));
    cb.parent = dlg;
    cb.is_protected = k->is_protected;
    cb.keyid = k->keyid;
    cb.pass = pass;
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT_ADDREV, dlg,
                    keyedit_addrevoker_dlg_proc, (LPARAM)&cb);

    if (cb.finished)
        k->update = 1;
    sfree_if_alloc (pass);
    return TRUE;
}


/* Change ownertrust of the given key @key.
   Return TRUE if the ownertrust was changed. */
BOOL
keyedit_change_ownertrust (winpt_key_t key, HWND dlg)
{
    int rc;

    rc = dialog_box_param (glob_hinst, 
                             (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
                             dlg, keyedit_ownertrust_dlg_proc,
                             (LPARAM)key, _("Change Ownertrust"),
                             IDS_WINPT_KEYEDIT_OWNERTRUST);
    if (rc == TRUE) {
        msg_box (dlg, _("Key status changed."), _("Key Edit"), MB_OK);
        key->update = 1;
    }
    return rc;
}


/* Check if the given key is supposed to have IDEA
   for secret key protection. */
static int
is_idea_protect_algo (const char *keyid)
{
    winpt_key_s k;
    const unsigned char *sym_prefs;
    size_t n;

    memset (&k, 0, sizeof (k));
    if (winpt_get_pubkey (keyid, &k))
        BUG (NULL);
    if (!k.is_v3)
        return 0;
    sym_prefs = k.ext->sym_prefs;
    if (!sym_prefs)
        return 1; /* assume that only v3 keys have no symmetric cipher preferences
                     and thus IDEA is explicit. */
    for (n = 0; sym_prefs[n]; n++)
        ;
    if ((n == 0 || n == 1) && *sym_prefs == 0x01)
        return 1;
    return 0;
}


BOOL
keyedit_change_passwd (winpt_key_t k, HWND dlg)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char *old_pass = NULL;
    char *new_pass = NULL;
    int cancel = 0;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), 
                 _("Key Edit"), MB_ERR);
        return FALSE;
    }

    if (!idea_available && is_idea_protect_algo (k->keyid)) {
        msg_box (dlg, _("Cannot change passphrase because the key\n"
                        "is protected with the IDEA encryption algorithm."),
                        _("Key Edit"), MB_ERR);
        return FALSE;
    }

    if (k->is_protected) {
        old_pass = request_passphrase (_("Current (old) Passphrase"), 
                                       PASSDLG_INIT, &cancel);
        if (cancel)
            return FALSE;
    }
    new_pass = request_passphrase2 (_("New Passphrase" ), 
                                    PASSDLG_INIT|PASSDLG_WARN_UTF8, &cancel);
    if (cancel) {
        sfree_if_alloc (old_pass);
        return FALSE;
    }

    if (strlen (new_pass) == 0) {
        cancel = msg_box (dlg, _("Are you sure that you really don't want a passphrase?\n"
                                 "This is propably a bad idea, still proceed?"),
                            _("Key Edit"), MB_WARN_ASK);
        if (cancel != IDYES) {
            sfree_if_alloc (old_pass);
            sfree_if_alloc (new_pass);
            return FALSE;
        }
    }

    ke = create_GpgKeyEdit (k->keyid);
    ke->setPassphrase (k->is_protected? old_pass : NULL);
    if (!k->is_protected)
        ke->setNoPassphrase (true);
    err = ke->changePassphrase (new_pass, 1);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Change Passwd"), MB_ERR);
    else
        msg_box (dlg, _("Passphrase successfully changed."),  _("GnuPG status"), MB_OK);
    sfree_if_alloc (old_pass);
    sfree_if_alloc (new_pass);
    delete ke;
    return TRUE;
}

                
/* Initialize sub key list from key @k and return
   the new listview control. */
listview_ctrl_t
subkey_list_init (HWND dlg, winpt_key_t k)
{
    LV_ITEM lvi;
    gpgme_subkey_t sub;
    struct listview_column_s cols[] = {
        {0, 80, (char *)_("Description")},
        {1, 78, (char *)_("Key ID")},
        {2, 66, (char *)_("Creation")},
        {3, 66, (char *)_("Expires")},
        {4, 64, (char *)_("Status")},
        {5, 16,  "C"/*ertify*/},
        {6, 16,  "S"/*ign*/},
        {7, 16,  "E"/*ncrypt*/},
        {8, 16,  "A"/*uth*/},
        {0, 0, 0}
    };
    listview_ctrl_t lv;
    char buf[256], tmp[128];
    const char *t;
    int nkeys = 0, i;

    nkeys = count_subkeys (k->ctx);
    if (!nkeys)
        BUG (NULL); /* should never happen. */
        
    listview_new (&lv, GetDlgItem (dlg, IDC_KEYEDIT_KEYLIST));
    for (i = 0; cols[i].fieldname != NULL; i++)
        listview_add_column (lv, &cols[i]);
        
    for (i = 0, sub = k->ctx->subkeys; i < nkeys; i++, sub = sub->next) {
        listview_add_item (lv, "");
        listview_add_sub_item (lv, 0, 1, "");
        memset (&lvi, 0, sizeof (lvi));
        lvi.mask = LVIF_PARAM;  
        lvi.lParam = (LPARAM)sub;
        if (ListView_SetItem (lv->ctrl, &lvi) == FALSE)
            BUG (NULL);
    }
        
    listview_set_ext_style (lv);
    for (i = 0, sub = k->ctx->subkeys; i < nkeys; i++, sub = sub->next) {
        _snprintf (buf, sizeof buf-1, "%d-bit %s", sub->length,
                                get_key_pubalgo (sub->pubkey_algo));
        listview_add_sub_item (lv, i, SUBK_COL_DESC, buf);
        t = sub->keyid;
        assert (t != NULL);
        _snprintf (tmp, sizeof tmp-1, "0x%s", t+8);
        listview_add_sub_item (lv, i, SUBK_COL_KEYID, tmp);

        t = get_key_created (sub->timestamp);
        if (!t)
            t = "????" "-??" "-??";
        listview_add_sub_item (lv, i, SUBK_COL_CREATION, t);

        if (sub->expires) {
            t = get_key_created (sub->expires);
            listview_add_sub_item (lv, i, SUBK_COL_EXPIRES, t);
        }
        else
            listview_add_sub_item (lv, i, SUBK_COL_EXPIRES, _("Never"));
        if (sub->expired)
            t = _("Expired");
        else if (sub->revoked)
            t = _("Revoked");
        else
            t = _("OK");
        listview_add_sub_item (lv, i, SUBK_COL_STATUS, t);

        if (sub->can_certify) t = "*"; else t = "";
        listview_add_sub_item (lv, i, SUBK_COL_C_FLAG, t);
        if (sub->can_sign) t = "*"; else t = "";
        listview_add_sub_item( lv, i, SUBK_COL_S_FLAG, t );
        if (sub->can_encrypt) t = "*"; else t = "";
        listview_add_sub_item( lv, i, SUBK_COL_E_FLAG, t );
        if (sub->can_authenticate) t = "*"; else t = "";
        listview_add_sub_item (lv, i, SUBK_COL_A_FLAG, t);
    }
    return lv;
}


static listview_ctrl_t
userid_list_init (HWND dlg, winpt_key_t k)
{
    listview_ctrl_t lv = NULL;
    gpgme_key_sig_t ks;
    struct native_uid_s *u;
    int nuids = 0, j, u_attr;
    struct listview_column_s cols[] = {
        {0,  72, (char *)_("Validity")},
        {1, 150, (char *)_("Name")},
        {2, 110, (char *)_("Email")},
        {3,  76, (char *)_("Creation")},
        {0, 0, 0}
    };    
    const char *attr;
    
    nuids = count_userids (k->ctx);
    if (!nuids)
        BUG (NULL); /* should never happen. */
        
    listview_new (&lv, GetDlgItem (dlg, IDC_KEYEDIT_UIDLIST));
    for (j = 0; cols[j].fieldname != NULL; j++)
        listview_add_column (lv, &cols[j]);
        
    for (j = 0; j < nuids; j++) {
        listview_add_item (lv, " ");
        listview_add_sub_item (lv, 0, 1, " " );        
    }

    listview_set_ext_style (lv);
    for (j = 0, u=k->ext->uids; j < nuids; u=u->next, j++) {
        if (u->revoked)
            attr = _("Revoked");
        else {
            u_attr = (int)u->validity;
            attr = get_key_trust2 (NULL, u_attr, 0, 0);
        }
        listview_add_sub_item (lv, j, UID_COL_VALID, (char *)attr);
        /* XXX: add comment if available */
        listview_add_sub_item (lv, j, UID_COL_NAME, 
                               u->name? u->name : _("Invalid user ID"));
        if (u->email)
            listview_add_sub_item (lv, j, UID_COL_EMAIL, u->email);

        ks = get_selfsig (u->signatures, k->keyid, 1);
        if (ks)
            listview_add_sub_item (lv, j, UID_COL_CREATION, 
                                   get_key_created (ks->timestamp));
    }
    if (!k->key_pair) {
        CheckDlgButton (dlg, IDC_KEYUID_ADD, BST_INDETERMINATE);
        CheckDlgButton (dlg, IDC_KEYUID_REVOKE, BST_INDETERMINATE);
    }
    return lv;
}


static void
do_init_cmdlist (HWND dlg, int is_keypair)
{    
    const char *s;
    int i = 0;

    for (i = 0; (s=cmdlist[i].name); i++) {
        if (is_keypair)
            SendDlgItemMessage (dlg, IDC_KEYEDIT_CMD, CB_ADDSTRING, 0,
                                (LPARAM)(char *)s);
        else if (!cmdlist[i].need_pair)
            SendDlgItemMessage (dlg, IDC_KEYEDIT_CMD, CB_ADDSTRING, 0,
                                (LPARAM)(char *)s);
    }
    SendDlgItemMessage (dlg, IDC_KEYEDIT_CMD, CB_SETCURSEL, 0, 0);
}


/* Return 1 if the requested command is RFC2440. */
static int
is_cmd_openpgp (int cmdid)
{
    switch (cmdid) {
    case CMD_ADDKEY:
    case CMD_ADDPHOTO:
    case CMD_ADDREVOKER:
    case CMD_SETPREF:
        return 1;
    }
    return 0;
}


/* Display a message box with a short description of the commands. */
static void
do_show_help (HWND dlg)
{
    const char *help;

    help =
        _(
         "ADDUID      add a user ID\r\n"
         "ADDPHOTO    add a photo ID\r\n"
         "DELUID      delete a user ID\r\n"
         "ADDKEY      add a secondard key\r\n"
         "DELKEY      delete a secondary key\r\n"
         "ADDREVOKER  add a revocation key\r\n"
         "EXPIRE      change the expire date\r\n"
         "SHOWPREF    list preferences (verbose)\r\n"
         "SETPREF     set preference list\r\n"
         "UPDPREF     updated preferences\r\n"
         "PASSWD      change the passphrase\r\n"
         "PRIMARY     flag user ID as primary\r\n"
         "TRUST       change the ownertrust\r\n"
         "REVUID      revoke a user ID\r\n"
         "REVKEY      revoke a secondary key\r\n"
         "DISABLE     disable a key\r\n"
         "ENABLE      enable a key\r\n"
         "SIGN        sign a user-id (exportable)\r\n"
         "LSIGN       sign a user-id (non-exportable)\r\n"
         "CLEAN       remove unusable signatures from key\r\n"
         "MINIMIZE    remove all signatures from key\r\n"
         );
    msg_box (dlg, help, _("Key Edit Help"), MB_OK);
}


static int
do_editkey_delkey (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    int pos, id;
    char tmp[64];

    if (!k->key_pair)
        return FALSE;

    if (listview_count_items (lv, 0) == 1) {
        msg_box (dlg, _("Primary key can not be deleted!"), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    pos = listview_get_curr_pos (lv);
    if (pos == -1) {
        msg_box (dlg, _("Please select a key."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    if (pos == 0) {
        msg_box (dlg, _("Primary key can not be deleted!"), _("Key Edit"), MB_ERR);
        return FALSE;
    }
     
    /* XXX: change the warning to make clear that verification won't work
            any longer if this is a sign-only key. */
    listview_get_item_text (lv, pos, 0, tmp, sizeof (tmp) -1);
    id = log_box (_("Key Edit"), MB_YESNO|MB_ICONWARNING,
                    _("\"Subkey %s.\"\n\n"
                      "Anything encrypted to the selected subkey will no longer\n"
                      "be able to be decrypted.\n\n"
                      "Do you really want to delete this subkey?"), tmp);
    if (id == IDNO)
        return FALSE;

    ke = create_GpgKeyEdit (k->keyid);
    err = ke->delKey (pos);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Delete Subkey"), MB_ERR);
    else {
        listview_del_item (lv, pos);
        k->update = 1;
        status_box (dlg, _("Subkey successfully deleted."), _("GnuPG status"));
    }
    delete ke;
    return err? FALSE : TRUE;
}


/* Set the expiration date for the selected key in list view @lv.
   Return value: TRUE on success. */
static int
do_editkey_expire (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    date_s udd = {0};
    char buf[256], * pass = NULL;
    time_t exp;
    int pos, cancel = 0;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    pos = listview_get_curr_pos (lv);
    if (pos == -1) {
        msg_box (dlg, _("Please select a key."), _("Key Edit"), MB_ERR);
        return FALSE;
    }

    /* If a key already expired, it is possible the user wants to
       set a new expiration date.. */
    listview_get_item_text (lv, pos, SUBK_COL_STATUS, buf, sizeof (buf)-1);
    if (!strcmp (buf, _("Expired"))) {
        cancel = msg_box (dlg, _("Key already expired.\n\n"
                          "Do you want to change the expiration date?"),
                          _("Key Edit"), MB_QUEST_ASK);
        if (cancel == IDNO)
            return FALSE;
        cancel = 0;
    }

    memset (&udd, 0, sizeof udd);
    udd.text = _("Key Expiration Date");
    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_DATE, dlg,    
                      date_dlg_proc, (LPARAM)&udd,
                      _("Key Expiration Date"), IDS_WINPT_DATE);
    if (udd.cancel == 1)
        return FALSE;
    if (!keygen_check_date (&udd.st)) {
        msg_box (dlg, _("The date you have chosen lies in the past."), 
                 _("Key Edit"), MB_ERR);
        return FALSE;
    }
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }
    exp = w32_mktime (&udd.st);
    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    err = ke->setKeyExpireDate (pos, exp, false);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Expire Subkey"), MB_ERR);
    else {
        _snprintf (buf, sizeof (buf)-1, "%s", get_key_created (exp));
        listview_add_sub_item (lv, pos, SUBK_COL_EXPIRES, buf);
        k->update = 1;
        msg_box (dlg, _("Subkey expire date successfully set."), 
                 _("GnuPG status"), MB_OK);
    }
    sfree_if_alloc (pass);
    delete ke;
    return TRUE;
}


/* Revoke the selected key in the list view @lv. @k contains 
   control information about the global key.
   Return value: TRUE on success. */
static int
do_editkey_revoke (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char buf[256];
    char *pass = NULL;
    int j, cancel = 0;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), _("Key Edit"), MB_ERR);
        return FALSE;
    }

    if ((j = listview_get_curr_pos (lv)) == -1) {
        msg_box( dlg, _("Please select a key."), _("Key Edit"), MB_ERR );
        return FALSE;
    }
    else if (listview_count_items (lv, 0) == 1) {
        msg_box( dlg, _("No subkeys were found, if you want to revoke the\n"
                        "whole key, please use the Key Manager command directly.\n\n"
                        "This command is only available to revoke single subkeys"),
                 _("Key Edit"), MB_INFO );
        return FALSE;
    }
            
    listview_get_item_text (lv, j, SUBK_COL_STATUS, buf, sizeof (buf)-1);
    if (!strcmp (buf, _("Revoked"))) {
        msg_box (dlg, _("Key already revoked."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;           
    }

    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    err = ke->revokeSubkey (j, 0, NULL);
    if (err)
        msg_box( dlg, gpgme_strerror (err), _("Revoke Subkey"), MB_ERR);
    else {
        listview_add_sub_item (lv, j, SUBK_COL_STATUS, _("Revoked"));
        k->update = 1;
        msg_box( dlg, _("Subkey successfully revoked."), _("GnuPG Status"), MB_OK );
    }
    sfree_if_alloc (pass);
    delete ke;
    return TRUE;
}


/* Revoked the selected userid in list view @lv.
   Return value: TRUE on success. */
int
do_editkey_revuid (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char buf[128], email[128];
    char inf[512];
    char *pass = NULL;
    int cancel = 0, id = 0, j;

    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), 
                 _("Revoke user ID"), MB_ERR);
        return FALSE;
    }

    if (listview_count_items (lv, 0) == 1) {
        msg_box (dlg, _("Key has only one user ID."), _("Key Edit"), MB_ERR);   
        return FALSE;
    }

    if( (j = listview_get_curr_pos( lv )) == -1 ) {
        msg_box( dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR );   
        return FALSE;   
    }
            
    listview_get_item_text( lv, j, UID_COL_VALID, buf, sizeof buf - 1);
    if (strstr (buf, _("Revoked"))) {
        msg_box (dlg, _("This user ID has been already revoked."), 
                 _("Key Edit"), MB_INFO);
        return FALSE;
    }
            
    listview_get_item_text (lv, j, UID_COL_NAME, buf, sizeof buf -1);
    _snprintf (inf, sizeof (inf) -1, _("user ID \"%s\".\n\n"
               "Do you really want to revoke this user ID?"), buf);
    if (msg_box (dlg, inf, _("Key Edit"), MB_WARN_ASK) == IDNO)
        return FALSE;
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;           
    }
    listview_get_item_text (lv, j, UID_COL_EMAIL, email, sizeof (email)-1);
    listview_get_item_text (lv, j, UID_COL_NAME, buf, sizeof (buf)-1);
    id = do_find_userid (k->keyid, email, buf, NULL);
    if (id == -1)
        BUG (NULL);

    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    err = ke->revokeUserid (id);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Revoke User ID"), MB_ERR);
    else {
        listview_add_sub_item (lv, j, 0, _("Revoked"));
        k->update = 1;
        status_box (dlg, _("User ID successfully revoked"), _("GnuPG Status"));
    }
    sfree_if_alloc (pass);
    delete ke;
    return err? FALSE : TRUE;
}


static int
do_editkey_setpref (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    gpg_uid_info_t uidinf = NULL;
    char buf[256], *pass = NULL, *prefs = NULL;
    int pos, id, cancel=0, flags=0;

    pos = listview_get_curr_pos (lv);
    if (pos == -1) {
        msg_box (dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    listview_get_item_text (lv, pos, 2, buf, sizeof buf-1);
    id = do_find_userid (k->keyid, buf, NULL, &uidinf);
    if (id == -1)
        BUG (NULL);
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        gpg_uid_info_release (uidinf);
        if (cancel)
            return FALSE;
    }

    get_userid_preflist (uidinf->prefs, &prefs, &flags);
    gpg_uid_info_release (uidinf);
    if (!prefs) {
        sfree_if_alloc (pass);
        return FALSE;
    }

    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);    
    err = ke->setUseridPreferences (id, prefs);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Set user ID preferences"), MB_ERR);
    else {
        k->update = 1;
        status_box (dlg, _("User ID preferences successfully updated"), _("GnuPG Status"));
    }

    sfree_if_alloc (pass);
    free_if_alloc (prefs);
    delete ke;
    return err? FALSE: TRUE;
}


static int
do_editkey_primary (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    int j, id, cancel=0;
    char valid[32];
    char buf[256], *pass = NULL;

    if (listview_count_items (lv, 0) == 1)
        return TRUE;
    if ((j = listview_get_curr_pos (lv)) == -1) {
        msg_box (dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    listview_get_item_text (lv, j, UID_COL_VALID, valid, sizeof (valid)-1);
    if (!strcmp (valid, _("Revoked")))
        return FALSE;
    listview_get_item_text (lv, j, UID_COL_EMAIL, buf, sizeof (buf)-1);
    id = do_find_userid (k->keyid, buf, NULL, NULL);
    if (id == -1)
        BUG (NULL);
    if (k->is_protected) {
        pass = request_key_passphrase (k->ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }

    ke = create_GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    err = ke->setPrimaryUserid (id);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Primary"), MB_ERR);
    else {
        k->update = 1;
        status_box (dlg, _("User ID successfully flagged"), _("GnuPG Status"));
    }

    sfree_if_alloc (pass);
    delete ke;
    return err? FALSE : TRUE;
}


#define CIPHER  11
#define HASH    11
#define COMPR    4

static int
parse_preflist (HWND dlg, const char *list)
{
    char buf[128] = {0};
    char *p, *pbuf = buf;
    const char *ciphers[CIPHER] = {"", "IDEA", "3DES", 
                                   "CAST5", "BLOWFISH", "", "", 
                                   "AES", "AES192", "AES256", "TWOFISH"};
    const char *hash[HASH] = {"", "MD5", "SHA1", "RMD160", "",
                              "", "", "", "SHA256", "SHA384", "SHA512"};
    const char *compress[COMPR] = {"", "ZIP", "ZLIB", "BZIP2"};
    int n=0;

    strncpy (buf, list, 127);
    p = strtok (pbuf, " ");
    while (p != NULL) {
        int algid = atol (p+1);
        n++;
        switch (*p) {
        case 'S':
            SendDlgItemMessage (dlg, IDC_SHOWPREF_CIPHERS, LB_ADDSTRING, 0, 
                                (LPARAM)(const char*)ciphers[algid % CIPHER]);
            break;

        case 'H':
            SendDlgItemMessage (dlg, IDC_SHOWPREF_HASH, LB_ADDSTRING, 0, 
                                (LPARAM)(const char*)hash[algid % HASH]);
            break;

        case 'Z':
            SendDlgItemMessage (dlg, IDC_SHOWPREF_ZIP, LB_ADDSTRING, 0, 
                                (LPARAM)(const char*)compress[algid % COMPR]);
            break;

        default:
            n--;
        }
        p = strtok (NULL, " ");
    }
    return n;
}


/* Dialog box procedure to show the key preferences. */
BOOL CALLBACK
showpref_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keyedit_cb_t cb = NULL;
    gpg_uid_info_t inf=NULL, u;
    gpgme_key_t key;
    char buf[128];
    int pos;

    switch (msg) {
    case WM_INITDIALOG:
        cb = (keyedit_cb_t)lparam;
        if (!cb)
            BUG (NULL);
        key = (gpgme_key_t)cb->opaque;
        listview_get_item_text (cb->lv, cb->lv_pos, 
                                UID_COL_EMAIL, buf, sizeof (buf)-1);
        pos = do_find_userid (cb->keyid, buf, NULL, &inf);
        if (pos < 0 || !inf) {
            gpg_uid_info_release (inf);
            EndDialog (dlg, FALSE);
            break;
        }
        for (u=inf; u; u = u->next) {
            if (u->index == pos && u->prefs && *u->prefs) {
                _snprintf (buf, sizeof (buf)-1, "%s", u->name);
                SetDlgItemText (dlg, IDC_SHOWPREF_INFO, buf);
                if (parse_preflist (dlg, u->prefs) <= 0)
                    pos = -1;
                if (u->flags.mdc)
                    CheckDlgButton (dlg, IDC_SHOWPREF_MDC, BST_CHECKED);
                break;
            }
        }
        gpg_uid_info_release (inf);
        if (pos == -1) {        
            msg_box (dlg, _("No preferences available."), _("Key Edit"), MB_ERR);
            EndDialog (dlg, FALSE);
            break;
        }
        SetDlgItemText (dlg, IDC_SHOWPREF_MDC, _("MDC feature"));
        SetDlgItemText (dlg, IDC_SHOWPREF_PREFINF, _("Preferences"));
        SetDlgItemText (dlg, IDC_SHOWPREF_UIDHINT, _("user ID:"));
        SetWindowText (dlg, _("Key Preferences"));
        SetForegroundWindow (dlg);
        center_window (dlg, cb->parent);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }
    return FALSE;
}


static int
do_editkey_showpref (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    struct keyedit_cb_s cb;
    char status[32];

    if (k->is_v3)
        return TRUE;

    if (listview_get_curr_pos (lv) == -1) {
        msg_box (dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    memset (&cb, 0, sizeof (cb));
    cb.parent = dlg;
    cb.opaque = k->ctx;
    cb.keyid = k->keyid;
    cb.lv = lv;
    cb.lv_pos = listview_get_curr_pos (lv);

    listview_get_item_text (lv, cb.lv_pos, UID_COL_VALID, 
                            status, sizeof (status)-1);
    if (!strcmp (status, _("Revoked")))
        return TRUE;
    
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT_SHOWPREF, dlg,
                    showpref_dlg_proc, (LPARAM)&cb);
    return TRUE;
}


static int
do_editkey_deluid (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char email[128], name[128];
    char inf[384];
    int pos, id = 0;

    if (!k->key_pair)
        return FALSE;

    if (listview_count_items (lv, 0) == 1) {
        msg_box (dlg, _("Primary user ID can not be deleted!"),
                 _("Key Edit"), MB_ERR);
        return FALSE;
    }
    pos = listview_get_curr_pos (lv);
    if (pos == -1) {
        msg_box (dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    
    listview_get_item_text (lv, pos, UID_COL_NAME, name, DIM(name) -1);
    _snprintf (inf, DIM (inf)-1, _("user ID \"%s\".\n\n"
                                   "All signatures on this user ID will be also deleted."
                                   "\n\n"
                                   "Do you really want to delete this user ID?"),
                               name);
    if (msg_box (dlg, inf, _("Key Edit"), MB_YESNO|MB_ICONWARNING) == IDNO)
        return FALSE;
    
    listview_get_item_text (lv, pos, UID_COL_EMAIL, email, DIM (email)-1);
    listview_get_item_text (lv, pos, UID_COL_NAME, name, DIM (name)-1);
    id = do_find_userid (k->keyid, email, name, NULL);
    if (id == -1)
        BUG (NULL);

    ke = create_GpgKeyEdit (k->keyid);
    err = ke->delUserid (id);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Delete User ID"), MB_ERR);
    else {
        listview_del_item (lv, pos);
        k->update = 1;
        status_box (dlg, _("User ID successfully deleted"), _("GnuPG Status"));
    }
    delete ke;
    return err? FALSE : TRUE;
}


/* Subclass routine for the subkey listview control to allow shortcuts. */
static BOOL CALLBACK
subkey_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    int virt_key = 0;
    winpt_key_t key;

    switch (msg) {
    case WM_KEYUP:
        virt_key = (int)wparam;
        key = (winpt_key_t)keyedit_subkey_proc.opaque;
        if (!key || !key->key_pair)
            break;

        switch (virt_key) {
        case VK_DELETE:
            SendDlgItemMessage (keyedit_subkey_proc.dlg, IDC_KEYEDIT_CMD, 
                                CB_SETCURSEL, CMD_DELKEY, 0);
            send_cmd_id (keyedit_subkey_proc.dlg, IDOK);
            break;

        case VK_INSERT:
            SendDlgItemMessage (keyedit_subkey_proc.dlg, IDC_KEYEDIT_CMD, 
                                CB_SETCURSEL, CMD_ADDKEY, 0);
            send_cmd_id (keyedit_subkey_proc.dlg, IDOK);
            break;
        }
    }
    return CallWindowProc (keyedit_subkey_proc.old, dlg, msg, wparam, lparam);
}


static BOOL CALLBACK
uid_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    int virt_key = 0;
    winpt_key_t key;

    switch (msg) {
    case WM_KEYUP:
        virt_key = (int)wparam;
        key = (winpt_key_t)keyedit_uid_proc.opaque;
        if (!key || !key->key_pair)
            break;

        switch (virt_key) {
        case VK_DELETE:
            SendDlgItemMessage (keyedit_uid_proc.dlg, IDC_KEYEDIT_CMD,
                                CB_SETCURSEL, CMD_DELUID, 0);
            send_cmd_id (keyedit_uid_proc.dlg, IDOK);
            break;

        case VK_INSERT:
            SendDlgItemMessage (keyedit_uid_proc.dlg, IDC_KEYEDIT_CMD,
                                CB_SETCURSEL, CMD_ADDUID, 0);
            send_cmd_id (keyedit_uid_proc.dlg, IDOK);
            break;
        }
    }
    return CallWindowProc (keyedit_uid_proc.old, dlg, msg, wparam, lparam);
}


/* Enable the key @k when @enable is 1, disable it otherwise. */
static void
do_editkey_enable_disable (winpt_key_t k, HWND dlg, 
                           listview_ctrl_t lv, int enable)
{
    km_enable_disable_key (lv, dlg, 0, enable);
    k->update = 1;
}


static void
do_editkey_minimize (winpt_key_t k, HWND dlg)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;

    ke = create_GpgKeyEdit (k->keyid);
    err = ke->minimizeKey ();
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Key Edit"), MB_ERR);
    else {
        msg_box (dlg, _("Finished to compact key."), _("Key Edit"), MB_OK);
        k->update = 1;
    }
    delete ke;
}


static void
do_editkey_clean (winpt_key_t k, HWND dlg)
{
    gpgme_error_t err;
    GpgKeyEdit *ke;
    
    ke = create_GpgKeyEdit (k->keyid);
    err = ke->cleanKey ();
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Key Edit"), MB_ERR);   
    else {
        msg_box (dlg, _("Finished to compact key."), _("Key Edit"), MB_OK);
        k->update = 1;
    }
    delete ke;
}


/* Start the dialog to list and display the status of all 
   signatures for this key. */
static void
do_editkey_check (winpt_key_t k, HWND dlg)
{
    if (!k->ctx)
        get_pubkey (k->keyid, &k->ctx);
    if (!k->uid && k->ctx)
        k->uid = k->ctx->uids->uid;
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYSIG_TREE, dlg,
                    sigtree_dlg_proc, (LPARAM)k);
}


static int
do_editkey_sign_userid (winpt_key_t k, HWND dlg, listview_ctrl_t lv, int mode)
{
    gpgme_error_t err;
    winpt_key_s signer;
    GpgKeyEdit *ke;
    char *pass = NULL;
    char *defkey;
    char email[64], name[128], valid[32];
    int uid_index;
    int cancel = 0;

    uid_index = listview_get_curr_pos (lv);
    if (uid_index == -1) {
        msg_box (dlg, _("Please select a user ID."), _("Key Edit"), MB_ERR);
        return FALSE;
    }
    listview_get_item_text (lv, uid_index, UID_COL_VALID, valid, sizeof (valid)-1);
    if (!strcmp (valid, _("Revoked")))
        return TRUE;
    if (mode == CMD_SIGN) {
        cancel = msg_box (dlg, _("Do you really want to make this sig exportable?"),
                          _("Key Edit"), MB_QUEST_ASK);
        if (cancel == IDNO)
            return FALSE;
    }
    listview_get_item_text (lv, uid_index, UID_COL_EMAIL, email, sizeof (email)-1);
    listview_get_item_text (lv, uid_index, UID_COL_NAME, name, sizeof (name)-1);
    uid_index = do_find_userid (k->keyid, email, name, NULL);

    defkey = get_gnupg_default_key ();
    memset (&signer, 0, sizeof (signer));
    if (winpt_get_seckey (defkey, &signer)) {
        log_debug ("do_editkey_sign_userid: no default secret key.\r\n");
        free_if_alloc (defkey);
        return FALSE;
    }
    if (signer.is_protected) {
        pass = request_key_passphrase (signer.ctx, _("Key Edit"), &cancel);
        if (cancel)
            return FALSE;
    }
    ke = create_GpgKeyEdit (k->keyid);
    if (signer.is_protected)
        ke->setPassphrase (pass);
    else
        ke->setNoPassphrase (true);
    ke->setLocalUser (signer.ctx);
    err = ke->signUserid (uid_index, 
                          mode == CMD_SIGN? GPG_EDITKEY_SIGN : GPG_EDITKEY_LSIGN,
                          0, NULL);
    if (!err) {
        msg_box (dlg, _("Key successfully signed."), _("Key Edit"), MB_OK);
        k->update = 1;
    }
    else
        msg_box (dlg, gpgme_strerror (err), _("Key Edit"), MB_ERR);
    delete ke;
    sfree_if_alloc (pass);
    return !err? TRUE : FALSE;
}


static int
lookup_cmd (HWND dlg)
{
    char buf[64];
    int i;

    i = SendDlgItemMessage (dlg, IDC_KEYEDIT_CMD, CB_GETCURSEL, 0, 0);
    if (i == LB_ERR)
        return LB_ERR;
    GetDlgItemText (dlg, IDC_KEYEDIT_CMD, buf, sizeof (buf)-1);
    for (i=0; cmdlist[i].name != NULL; i++) {
        if (!strcmp (buf, cmdlist[i].name))
            return cmdlist[i].id;
    }
    return LB_ERR;
}


gpgme_error_t key_get_revokers (winpt_key_t key, int reload, 
                                gpg_desig_rev_t *r_rev);

/* Check if the key supports designated revokers and if
    secret keys exist to generate such a revoke cert. */
static bool
check_desig_rev (winpt_key_t key)
{
    gpg_desig_rev_t rev, u;
    struct winpt_key_s sk;

    if (!key->ext->gloflags.has_desig_rev)
        return false;
    key_get_revokers (key, 0, &rev);
    for (u = rev; u; u = u->next) {
        memset (&sk, 0, sizeof (sk));
        if (!winpt_get_seckey (u->fpr+32, &sk))
            return true;
    }
    return false;
}


/* Use the gpg --desig-revoker command to create a revocation
   cert for a key that lists our key as a designated revoker. */
static void 
gen_desig_revoke_cert (winpt_key_t key, HWND dlg)
{
    const char *warn;
    char *inf, *p;
    int id;

    inf = km_key_get_info (key, 0);
    warn = _("Your keys is listed as a designated revoker for the key\n\n"
             "%s\n\n"
             "Are you sure you want to create a revocation certificate\n"
             "which allow to revoke the key listed above?");
    p = new char[strlen (inf)+1+strlen (warn)+1];
    sprintf (p, warn, inf);
    free_if_alloc (inf);

    id = msg_box (dlg, p, _("Key Edit"), MB_YESNO|MB_ICONWARNING);
    free_if_alloc (p);
    if (id == IDNO)
        return;

    key->internal = 1;
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKE, dlg,
                    key_revoke_dlg_proc, (LPARAM)key);
}


/* Create tooltip control for the listview header. */
static HWND
create_header_tooltip (HWND dlg)
{
    TOOLINFO ti;
    HWND tt;

    tt = CreateWindow (TOOLTIPS_CLASS, (LPSTR) NULL, TTS_ALWAYSTIP, 
                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
                        CW_USEDEFAULT, 
                        NULL, (HMENU) NULL, glob_hinst, NULL);
    if (!tt)
        BUG (NULL);
    memset (&ti, 0, sizeof (ti));
    ti.cbSize = sizeof(TOOLINFO); 
    ti.uFlags = TTF_IDISHWND|TTF_SUBCLASS;     
    ti.hwnd = dlg;     
    ti.uId = (UINT) ListView_GetHeader (GetDlgItem (dlg, IDC_KEYEDIT_KEYLIST));
    ti.hinst = 0;
    ti.lpszText = (char*)_("Capabilties: C = Certify, S = Sign, E = Encrypt, A = Authenticate");
    SendMessage(tt, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
    return tt;
}


/* Dialog box procedure for the edit key dialog. */
BOOL CALLBACK
keyedit_main_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static winpt_key_t k;
    static listview_ctrl_t lvsub = NULL, lvuid = NULL;
    static HWND tt;
    int cmd;
    HWND item;

    switch (msg) {
    case WM_INITDIALOG:
        k = (winpt_key_t)lparam;
        if (!k)
            BUG (NULL);
        do_init_cmdlist (dlg, k->key_pair);
        lvsub = subkey_list_init (dlg, k);
        lvuid = userid_list_init (dlg, k);
        item = GetDlgItem (dlg, IDC_KEYEDIT_KEYLIST);
        keyedit_subkey_proc.opaque = (void*)k;
        keyedit_subkey_proc.dlg = dlg;
        keyedit_subkey_proc.current = (WNDPROC)subkey_subclass_proc;
        keyedit_subkey_proc.old = (WNDPROC)GetWindowLong (item, GWL_WNDPROC);
        if (keyedit_subkey_proc.old) {
            if (!SetWindowLong (item, GWL_WNDPROC, 
                                (LONG)keyedit_subkey_proc.current)) {
                msg_box (dlg, "Could not set subkey window procedure.", 
                         _("Key Edit"), MB_ERR);
                BUG (NULL);
            }
        }
        tt = create_header_tooltip (dlg);
        item = GetDlgItem (dlg, IDC_KEYEDIT_UIDLIST);
        keyedit_uid_proc.opaque = (void*)k;
        keyedit_uid_proc.dlg = dlg;
        keyedit_uid_proc.current = (WNDPROC)uid_subclass_proc;
        keyedit_uid_proc.old = (WNDPROC)GetWindowLong (item, GWL_WNDPROC);
        if (keyedit_uid_proc.old) {
            if (!SetWindowLong (item, GWL_WNDPROC, 
                                (LONG)keyedit_uid_proc.current)) {
                msg_box (dlg, "Could not set user ID window procedure.", 
                         _("Key Edit"), MB_ERR);
                BUG (NULL);
            }
        }
        if (k->ctx->revoked) {
            EnableWindow (GetDlgItem (dlg, IDC_KEYEDIT_CMD), FALSE);
            EnableWindow (GetDlgItem (dlg, IDOK), FALSE);
        }
        SetDlgItemText (dlg, IDC_KEYEDIT_CMDINF, _("Command>"));
        SetDlgItemText (dlg, IDCANCEL, _("&Close"));
        SetDlgItemText (dlg, IDC_KEYEDIT_HELP, _("&Help"));
        SetDlgItemText (dlg, IDC_KEYEDIT_REVOKE, _("&Revoke..."));
        SetDlgItemText (dlg, IDOK, _("&OK"));
        if (!check_desig_rev (k))
            ShowWindow (GetDlgItem (dlg, IDC_KEYEDIT_REVOKE), SW_HIDE);
        SetWindowText (dlg, _("Key Edit"));
        SetForegroundWindow (dlg);
        center_window (dlg, NULL);
        return TRUE;

    case WM_DESTROY:
        if (lvsub) {
            listview_release (lvsub);
            lvsub = NULL;
        }
        if (lvuid) {
            listview_release (lvuid);
            lvuid = NULL;
        }
        break;

    case WM_NOTIFY:
        NMHDR *notify;
        notify = (NMHDR *)lparam;
        if (!notify || notify->idFrom != IDC_KEYEDIT_UIDLIST)
            break;
        if (notify->code == NM_DBLCLK)
            do_editkey_showpref (k, dlg, lvuid);
        else if (notify->code == NM_RCLICK && k->key_pair) {
            HMENU hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_KEYEDIT));
            HMENU popup = GetSubMenu (hm, 0);
            POINT p;

            GetCursorPos (&p);
            TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);
            DestroyMenu (hm);
            DestroyMenu (popup);
        }
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            cmd = lookup_cmd (dlg);
            if (cmd == LB_ERR) {
                msg_box( dlg, _("Please select a command."), _("Key Edit"), MB_INFO );
                return FALSE;
            }
            if (k->is_v3 && is_cmd_openpgp (cmd)) {
                msg_box (dlg, _("This command cannot be used with PGP 2 (v3) keys.\n"),
                                _("Key Edit"), MB_ERR);
                return FALSE;
            }
            switch (cmd) {
            case CMD_SHOWPREF: do_editkey_showpref (k, dlg, lvuid); break;
            case CMD_DELKEY: do_editkey_delkey (k, dlg, lvsub); break;
            case CMD_ADDKEY: keyedit_add_subkey (k, dlg, lvsub); break;
            case CMD_EXPIRE: do_editkey_expire (k, dlg, lvsub); break;
            case CMD_REVKEY: do_editkey_revoke (k, dlg, lvsub); break;
            case CMD_SETPREF:/*do_editkey_setpref (k, dlg, lvuid);*/ break;
            case CMD_ADDUID: keyedit_add_userid( k, dlg, lvuid ); break;
            case CMD_ADDREVOKER: keyedit_add_revoker( k, dlg ); break;
            case CMD_ADDPHOTO: keyedit_add_photo( k, dlg ); break;
            case CMD_REVUID: do_editkey_revuid( k, dlg, lvuid ); break;
            case CMD_DELUID: do_editkey_deluid( k, dlg, lvuid ); break;
            case CMD_PASSWD: keyedit_change_passwd( k, dlg ); break;
            case CMD_PRIMARY: do_editkey_primary( k, dlg, lvuid ); break;
            case CMD_ENABLE: do_editkey_enable_disable (k, dlg, lvsub, 1); break;
            case CMD_DISABLE: do_editkey_enable_disable (k, dlg, lvsub, 0); break;
            case CMD_CHECK: do_editkey_check (k, dlg); break;
            case CMD_TRUST: keyedit_change_ownertrust (k, dlg); break;
            case CMD_SIGN:
            case CMD_LSIGN: do_editkey_sign_userid (k, dlg, 
                                                    lvuid, cmd);
                            break;
            case CMD_CLEAN: do_editkey_clean (k, dlg); break;
            case CMD_MINIMIZE: do_editkey_minimize (k, dlg); break;
            }
            break;          

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;

        case IDC_KEYEDIT_HELP:
            do_show_help (dlg);
            break;

        case IDC_KEYEDIT_REVOKE:
            gen_desig_revoke_cert (k, dlg);
            break;

        case ID_KEYEDIT_UID_PRIM:
            do_editkey_primary (k, dlg, lvuid);
            break;

        case ID_KEYEDIT_UID_DEL:
            do_editkey_deluid (k, dlg, lvuid);
            break;

        case ID_KEYEDIT_UID_REV:
            do_editkey_revuid (k, dlg, lvuid);
            break;
        }
        break;
    }
    return FALSE;
}