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 "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_FPR,*/
    CMD_DELUID,
    CMD_DELKEY,
    CMD_DELPHOTO,
    /*CMD_DELSIG,*/
    CMD_EXPIRE,
    /*CMD_PREF,*/
    CMD_SHOWPREF,
    /*CMD_SETPREF,*/
    /*CMD_UPDPREF,*/
    CMD_PASSWD,
    CMD_PRIMARY,
    CMD_TRUST,
    /*CMD_REVSIG,*/
    CMD_REVUID,
    CMD_REVKEY,
    CMD_DISABLE,
    CMD_ENABLE,
    /*CMD_SHOWPHOTO,*/
};


/* 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
};

struct keyedit_callback_s {
    const char     *keyid;
    const char     *pass;
    listview_ctrl_t lv;
    void           *opaque;
    unsigned int    finished:1;
};
typedef struct keyedit_callback_s KEYEDIT_CB;

struct keygen_callback_s {
    int   bits;
    int   algo;
    u32   expire;
    char *fpr;
};
typedef struct keygen_callback_s KEYGEN_CB;


static subclass_s keyedit_subkey_proc;
static subclass_s keyedit_uid_proc;

int keygen_check_date (SYSTEMTIME *st);
void get_userid_preflist (char **r_prefs, int * r_flags);
char* get_subkey_fingerprint (const char *keyid);


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

    pub = keycache_get_ctx (1);
    if (!pub)
        BUG (0);

    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, k->keyid))
            continue;
        u = utf8_to_wincp (s, strlen (s));
        SendDlgItemMessage (dlg, IDC_ADDREV_KEYLIST, CB_ADDSTRING, 
                            0, (WPARAM)(char *)u);
        free (u);
    }
    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 * name, const char *email, const char * comment)
{
    char * p;
    size_t n;
    
    n = strlen (name) + strlen (email) + 16;
    if (comment)
        n += strlen (comment);
    p = new char[n+1];
    if (!p)
        BUG( NULL );
    if (comment)
        sprintf (p, "%s (%s)", name, comment);
    else
        sprintf (p, "%s", name);

    listview_add_item (lv, "");
    listview_add_sub_item (lv, 0, 0, _("Ultimate" ));
    listview_add_sub_item (lv, 0, 1, p);
    listview_add_sub_item (lv, 0, 2, email && *email? email : "");
    listview_add_sub_item (lv, 0, 3, get_key_created (time (NULL)));
    free_if_alloc (p);
}


static void
do_add_new_subkey (listview_ctrl_t lv, KEYGEN_CB *keygen, unsigned int flags)
{
    char info[128], keyid[32];
    const char * expdate, * s;
    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));
    _snprintf (keyid, sizeof keyid-1, "0x%s", keygen->fpr+32);
    n = listview_count_items (lv, 0);
    listview_add_item_pos (lv, n);
    listview_add_sub_item (lv, n, 0, info);
    listview_add_sub_item (lv, n, 1, keyid);
    listview_add_sub_item (lv, n, 2, get_key_created (time (NULL)));
    listview_add_sub_item (lv, n, 3, 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, 4, s);
} /* do_add_new_subkey */


/* Try to find the GPG edit key index which belongs to the user ID
   given by @name. 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 *name, gpg_uid_info_t *r_inf)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;
    gpg_uid_info_t inf, ui;
    int pos = -1;

    ke = new GpgKeyEdit (keyid);
    if (!ke)
        BUG (NULL);
    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 (!strcmp (ui->email, 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 winpt_key_t k;        
    GpgKeyEdit *ke;
    gpgme_error_t ec;    
    const char * s;    
    char pwd[128], file[128];
    int id;

    switch( msg ) {
    case WM_INITDIALOG:
        k = (winpt_key_t)lparam;
        if (!k)
            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_DESTROY:
        break;

    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, TRUE);
        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;
            }
            if (k->is_protected &&
                !GetDlgItemText (dlg, IDC_ADDPHOTO_PASS, pwd, sizeof (pwd)-1)) {
                msg_box (dlg, _("Please enter a passphrase."), _("Add Photo"), MB_ERR);
                return FALSE;
            }
            ke = new GpgKeyEdit (k->keyid);
            if (!ke)
                BUG (NULL);
            if (k->is_protected)
                ke->setPassphrase (pwd);
            ec = ke->addPhotoid (file);
            delete ke;
            wipememory (pwd, sizeof (pwd));
            if (ec) {
                msg_box (dlg, gpgme_strerror (ec), _("Add Photo"), MB_ERR );
                return FALSE;
            }
            else {
                k->update = 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 winpt_key_t k;
    static gpgme_key_t seckey;
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char uid[128], pwd[128];

    switch (msg) {
    case WM_INITDIALOG:
        k = (winpt_key_t)lparam;
        if (!k)
            BUG (NULL);
        if (get_seckey (k->keyid, &seckey))
            BUG (NULL);
        if (!k->is_protected)
            EnableWindow (GetDlgItem (dlg, IDC_ADDREV_PASS), FALSE);
        do_init_keylist (dlg, k);
        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);
        break;

    case WM_DESTROY:    
        break;

    case WM_SYSCOMMAND:
        if( LOWORD (wparam) == SC_CLOSE )
            EndDialog( dlg, TRUE );
        break;

    case WM_COMMAND:
        switch( LOWORD( wparam ) ) {
        case IDOK:          
            if( !GetDlgItemText( dlg, IDC_ADDREV_KEYLIST, uid, sizeof uid-1 ) ) {
                msg_box( dlg, _("Please select a user ID."), _("Add Revoker"), MB_ERR );
                return FALSE;
            }
        
            if( k->is_protected ) {
                if( !GetDlgItemText( dlg, IDC_ADDREV_PASS, pwd, sizeof pwd-1 ) ) {
                    msg_box( dlg, _("Please enter the passphrase."), _("Add Revoker"), MB_ERR );
                    return FALSE;
                }
            }
            ke = new GpgKeyEdit (k->keyid);
            if (k->is_protected)
                ke->setPassphrase (pwd);
            err = ke->addDesignatedRevoker (uid);
            delete ke;
            wipememory (pwd, sizeof (pwd));
            if (err) {
                msg_box (dlg, gpgme_strerror (err), _("Add Revoker"), MB_ERR);
                return TRUE;
            }
            else {
                k->update = 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 *ctx;
    gpgme_error_t err;
    GpgKeyEdit *ke;
    char *utf8_name = NULL;
    char name[128], email[128], comment[128];
    int rc;
    
    switch ( msg ) {
    case WM_INITDIALOG:
        ctx = (KEYEDIT_CB *)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);
        return FALSE;
        
    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE) {
            EndDialog(dlg, TRUE);
        }
        return FALSE;
        
    case WM_COMMAND:
        switch ( LOWORD( wparam ) )  {
        case IDOK:
            rc = GetDlgItemText( dlg, IDC_ADDUID_NAME, name, sizeof name-1 );
            if (!rc || rc < 5) {
                msg_box( dlg, _("Please enter a name (min. 5 chars.)"), _("UserID"), MB_ERR );
                return FALSE;
            }
            if (strchr (name, '@')) {
                msg_box( dlg, _("Please enter the email address in the email field and not in the name field"), _("UserID"), MB_INFO );
                return FALSE;
            }
                                   
            if( !GetDlgItemText( dlg, IDC_ADDUID_EMAIL, email, sizeof email -1 ) ) {
                msg_box( dlg, _("Please enter an email address."), _("UserID"), MB_ERR );
                return FALSE;
            }
            if( !strchr( email, '@' ) || strchr (email, ' ')) {
                msg_box( dlg, _("Invalid email address."), _("UserID"), MB_ERR );
                return FALSE;
            }
            
            rc = GetDlgItemText( dlg, IDC_ADDUID_COMMENT, comment, sizeof comment -1 );

            /* XXX: something is wrong with the encoding :-( */
            utf8_name = wincp_to_utf8 (name, strlen (name));

            ke = new GpgKeyEdit (ctx->keyid);
            if (!ke)
                BUG (NULL);
            if (ctx->pass)
                ke->setPassphrase (ctx->pass);
            err = ke->addUserid (utf8_name? utf8_name : name, 
                                 rc > 0? comment : NULL, 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;
            }
            delete ke;
            free (utf8_name);
            if (!err && ctx->lv)
                do_add_new_userid (ctx->lv, name, email, rc?comment : NULL);
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    
    return FALSE;
}


static int
diff_time (HWND dt, SYSTEMTIME *in_exp)
{
    SYSTEMTIME exp, now;
    double e=0, n=0;

    if (in_exp)
        memcpy (&exp, in_exp, sizeof (SYSTEMTIME));
    else
        DateTime_GetSystemtime (dt, &exp);
    GetSystemTime (&now);
    SystemTimeToVariantTime (&exp, &e);
    SystemTimeToVariantTime (&now, &n);
    if (n > e)
        return 0;
    return (int)(e-n);
}


static void
init_keysize_box (HWND dlg, int ctlid)
{
    const char *sizelist[] = {
        "1024", "1536", "2048", "2560", "3072", "3854", "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 atol (buf);
}


/* 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 *ctx;
    static KEYGEN_CB *keygen;
    GpgKeyEdit *ke;
    gpgme_error_t err;
    HWND lb;
    int index, size, valid;
    
    switch (msg) {
    case WM_INITDIALOG:
        ctx = (KEYEDIT_CB *)lparam;
        if (!ctx)
            dlg_fatal_error (dlg, "Could not get dialog param!");
        keygen = (KEYGEN_CB *)ctx->opaque;

        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"));

        lb = GetDlgItem (dlg, IDC_ADDSUBKEY_ALGO);
        listbox_add_string (lb, "DSA (sign only)");
        listbox_add_string (lb, "ElGamal (encrypt only)");
        listbox_add_string (lb, "RSA (sign only)");
        listbox_add_string (lb, "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);
        return FALSE;
        
    case WM_SYSCOMMAND:
        if( LOWORD (wparam) == SC_CLOSE ) {
            EndDialog( dlg, TRUE );
        }
        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:
            lb = GetDlgItem (dlg, IDC_ADDSUBKEY_ALGO);
            switch (listbox_get_cursel (lb)) {
            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;
            }
            valid = diff_time (GetDlgItem (dlg, IDC_ADDSUBKEY_EXPDATE), NULL);

            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 = new GpgKeyEdit (ctx->keyid);
            if (!ke)
                BUG (NULL);
            ke->setCallback (keygen_cb, NULL);
            if (ctx->pass)
                ke->setPassphrase (ctx->pass);      
            keygen_cb_dlg_create ();

            err = ke->addSubkey ((gpgme_pubkey_algo_t)index, size, valid);
            keygen->fpr = get_subkey_fingerprint (ctx->keyid);
            keygen_cb_dlg_destroy ();
            keygen_cb (NULL, NULL, 0, 0, 0); /* flush */
            if (err)
                msg_box (dlg, gpgme_strerror (err), _("Add Subkey"), MB_ERR);
            else {
                msg_box (dlg, _("Subkey successfully added."), _("GnuPG Status"), MB_OK);
                if (ctx->lv)
                    do_add_new_subkey (ctx->lv, keygen, /*XXXk->flags*/0);
                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 cb;
    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_passphrase( _("Key Edit"), 1, &cancel );
        if (cancel)
            return FALSE;
    }
           
    memset (&cb, 0, sizeof cb);
    cb.pass = k->is_protected? pass : NULL;
    cb.lv = lv;
    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 (cb.finished)
        k->update = 1;

    sfree_if_alloc (pass);
    return TRUE;
}


char*
get_subkey_fingerprint (const char *keyid)
{
    gpgme_error_t err;
    gpgme_key_t key, main;
    gpgme_ctx_t ctx;
    gpgme_subkey_t last_sk, k, new_sk;
    int n;

    err = gpgme_new (&ctx);
    if (err)
        return NULL;
    err = gpgme_get_key (ctx, keyid, &key, 0);
    if (err)
        return NULL;
    /* XXX: this is very slow and complicated */
    
    n = count_subkeys (key);
    last_sk = get_nth_key (key, n-1);
    new_sk = (gpgme_subkey_t)calloc (1, sizeof *new_sk);
    if (!new_sk)
        BUG (NULL);
    memcpy (new_sk, last_sk, sizeof *last_sk);
    new_sk->fpr = strdup (last_sk->fpr);
    new_sk->keyid = strdup (last_sk->keyid);

    get_pubkey (keyid, &main);
    for (k=main->subkeys; k->next; k=k->next)
        ;
    k->next = new_sk;

    gpgme_key_release (key);
    return new_sk->fpr;
}


BOOL
keyedit_add_subkey (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    KEYEDIT_CB cb;
    KEYGEN_CB 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_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;
    }

    memset (&keygen, 0, sizeof (keygen));
    memset (&cb, 0, sizeof (cb));
    cb.keyid = k->keyid;
    cb.pass = k->is_protected? pass : NULL;
    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 (cb.finished)
        k->update = 1;

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


BOOL
keyedit_set_pref_keyserver (winpt_key_t k, HWND dlg)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;
    struct URL_ctx_s *url;
    char *pass;

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

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

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    ke->setPassphrase (pass);
    err = ke->setPreferredKeyserver (0 /* XXX */, url->url);
    if (!err)
        msg_box (dlg, _("Preferred keyserver successfully set."), _("Key Edit"), MB_OK);

    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)
{
    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), _("Add Photo"), MB_ERR);
        return FALSE;
    }
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT_ADDPHOTO, dlg,
                    keyedit_addphoto_dlg_proc, (LPARAM)k);
    return TRUE;
}


BOOL
keyedit_add_revoker (winpt_key_t k, HWND dlg)
{
    if (!k->key_pair) {
        msg_box (dlg, _("There is no secret key available!"), _("Add Revoker"), MB_ERR);
        return FALSE;
    }
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT_ADDREV, dlg,
                    keyedit_addrevoker_dlg_proc, (LPARAM)k);
    return TRUE;
}


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);
    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;
} /* is_idea_protect_algo */


BOOL
keyedit_change_passwd (winpt_key_t k, HWND dlg)
{
    gpgme_error_t ec;
    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"), 1, &cancel);
        if (cancel)
            return FALSE;
    }
    new_pass = request_passphrase2 (_("New Passphrase" ), 1, &cancel);
    if (cancel) {
        free_if_alloc (old_pass);
        return FALSE;
    }

    if (is_8bit_string (new_pass)) {
        msg_box (dlg, _("The passphrase contains 8-bit characters.\n"
                         "It is not suggested to use charset specific characters."),
                         _("Key Edit"), MB_ERR);
        free_if_alloc (old_pass);
        free_if_alloc (new_pass);
        return FALSE;
    }

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);

    ke->setPassphrase (k->is_protected? old_pass : NULL);
    ec = ke->changePassphrase (new_pass, 0);
    if( ec )
        msg_box (dlg, gpgme_strerror (ec), _("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;
}


listview_ctrl_t
subkey_list_init( HWND dlg, winpt_key_t k )
{
    LV_ITEM lvi;
    gpgme_key_t key;
    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, rc = 0, i, bits;    

    if( get_pubkey( k->keyid, &key ) ) {
        msg_box( dlg, _("Could not find key."), _("Key Edit"), MB_ERR );
        return NULL;
    }
    if (!k->ctx)
        k->ctx = key;
    nkeys = count_subkeys (key);
    if( !nkeys ) {
        msg_box( dlg, _("No subkey(s) found."), _("Key Edit"), MB_ERR );
        return NULL;
    }
        
    rc  = listview_new( &lv );
    if( rc )
        BUG( dlg );
        
    lv->ctrl = GetDlgItem( dlg, IDC_KEYEDIT_KEYLIST );
    for( i = 0; cols[i].fieldname != NULL; i++ )     
        listview_add_column( lv, &cols[i] );
        
    for( i = 0; i < nkeys; i++ ) {
        listview_add_item( lv, "" );
        listview_add_sub_item( lv, 0, 1, "" );
        memset( &lvi, 0, sizeof lvi );
        lvi.mask = LVIF_PARAM;  
        lvi.lParam = (LPARAM )key;
        if( ListView_SetItem( lv->ctrl, &lvi ) == FALSE )
            return NULL;
    }
        
    listview_set_ext_style( lv );
    for( i = 0, sub = key->subkeys; i < nkeys; i++, sub = sub->next ) {
        memset( buf, 0, sizeof buf );

        bits = sub->length;
        _snprintf( tmp, sizeof tmp-1, "%d-bit ", bits );
        strcat( buf, tmp );

        _snprintf( tmp, sizeof tmp-1, "%s", get_key_pubalgo (sub->pubkey_algo));
        strcat( buf, tmp );
        
        listview_add_sub_item( lv, i, 0, buf );
        t = sub->keyid;
        if( !t )
            t = "DEADBEEFDEADBEEF";
        _snprintf( tmp, sizeof tmp-1, "0x%s", t+8 );
        listview_add_sub_item( lv, i, 1, tmp );

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

        if( sub->expires ) {
            t = get_key_created (sub->expires);
            listview_add_sub_item( lv, i, 3, t );
        }
        else
            listview_add_sub_item( lv, i, 3, _("Never") );

        if( sub->expired )
            t = _("Expired");
        else if( sub->revoked )
            t = _("Revoked");
        else
            t = _("OK");
        listview_add_sub_item( lv, i, 4, t );

        if (sub->can_certify) t = "*"; else t = "";
        listview_add_sub_item (lv, i, 5, t);
        if (sub->can_sign) t = "*"; else t = "";
        listview_add_sub_item( lv, i, 6, t );
        if (sub->can_encrypt) t = "*"; else t = "";
        listview_add_sub_item( lv, i, 7, t );
        if (sub->can_authenticate) t = "*"; else t = "";
        listview_add_sub_item (lv, i, 8, t);
    }
    return lv;
} /* subkey_list_init */


static listview_ctrl_t
userid_list_init (HWND dlg, winpt_key_t k)
{
    listview_ctrl_t lv = NULL;
    gpgme_key_t key;
    gpgme_key_sig_t ks;
    gpgme_user_id_t u;
    int nuids = 0, rc, 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;

    if (get_pubkey (k->keyid, &key)) {
        msg_box (dlg, _("Could not find key."), _("Key Edit"), MB_ERR);
        return NULL;
    }
    
    nuids = count_userids (key);
    if (!nuids) {
        msg_box (dlg, _("No user ID(s) found."), _("Key Edit"), MB_ERR);
        return NULL;
    }
        
    rc = listview_new (&lv);
    if (rc)
        BUG (dlg);
    lv->ctrl = 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=key->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, 0, (char *)attr );        

        /* XXX: add comment if available */
        attr = u->name;
        if (attr) {
            char *uid = utf8_to_wincp (attr, strlen (attr));
            if (uid) {
                listview_add_sub_item( lv, j, 1, uid );
                free( uid );
            }
        }
        else
            listview_add_sub_item( lv, j, 1, _("Invalid user ID") );
        attr = u->email;
        if (attr)
            listview_add_sub_item (lv, j, 2, attr);

        ks = get_selfsig (u, k->keyid, 1);
        if (ks)
            listview_add_sub_item (lv, j, 3, 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;
} /* userid_list_init */


static void
do_init_cmdlist( HWND dlg )
{
    const char *cmdlist[] = {
        "ADDKEY",
        "ADDUID",
        "ADDPHOTO",
        "ADDREVOKER",
        /*"FPR",*/
        "DELUID",
        "DELKEY",
        "DELPHOTO",
        /*"DELSIG",*/
        "EXPIRE",
        /*"PREF",*/
        "SHOWPREF",
        /*"SETPREF",*/
        "PASSWD",
        "PRIMARY",
        "TRUST",
        /*"REVSIG",*/
        "REVUID",
        "REVKEY",
        "DISABLE",
        "ENABLE",
        "SHOWPHOTO",
        NULL
    };
    const char * s;
    int i = 0;

    for( i = 0; (s=cmdlist[i]); i++ ) {
        SendDlgItemMessage( dlg, IDC_KEYEDIT_CMD, CB_ADDSTRING, 0,
                            (LPARAM)(char *)s );
    }
    SendDlgItemMessage( dlg, IDC_KEYEDIT_CMD, CB_SETCURSEL, 0, 0 );
} /* do_init_cmdlist */


static int
is_cmd_openpgp( int cmdid )
{
    switch( cmdid ) {
    case CMD_ADDKEY:
    case CMD_ADDPHOTO:
    case CMD_ADDREVOKER:
    case CMD_DELPHOTO:
    /*case CMD_SHOWPHOTO:*/
    /*case CMD_SETPREF:*/
        return 1;
    }
    return 0;
} /* is_cmd_openpgp */


static void
do_show_help( HWND dlg )
{
    char helptext[2048];

    _snprintf( helptext, sizeof helptext-1,
        _(/*"FPR            \t\tshow fingerprint\r\n"*/
         "ADDUID   \t\tadd a user ID\r\n"
         "ADDPHOTO  \t\tadd a photo ID\r\n"
         "DELUID    \t\tdelete a user ID\r\n"
         "ADDKEY    \t\tadd a secondard key\r\n"
         "DELKEY    \t\tdelete a secondary key\r\n"
         "ADDREVOKER\t\tadd a revocation key\r\n"
         /*"DELSIG    \t\tdelete signatures\r\n"*/
         "EXPIRE    \t\tchange the expire date\r\n"
         /*"PREF            \t\tlist preferences (expert)\r\n"
         "SHOWPREF  \t\tlist preferences (verbose)\r\n"
         "SETPREF   \t\tset preference list\r\n"*/
         "UPDPREF   \t\tupdated preferences\r\n"
         "PASSWD    \t\tchange the passphrase\r\n"
         "PRIMARY   \t\tflag user ID as primary\r\n"
         "TRUST     \t\tchange the ownertrust\r\n"
         /*"REVSIG    \t\trevoke signatures\r\n"*/
         "REVUID    \t\trevoke a user ID\r\n"
         "REVKEY    \t\trevoke a secondary key\r\n"
         "DISABLE   \t\tdisable a key\r\n"
         "ENABLE    \t\tenable a key\r\n"
         /*"SHOWPHOTO \t\tshow photo ID\r\n"*/) );
    msg_box( dlg, helptext, _("Key Edit Help"), MB_OK );
} /* do_show_help */


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

    if (!k->key_pair)
        return FALSE; /* XXX: shall we allow to modify non-secret keys?? */

    if( listview_count_items( lv, 0 ) == 1 ) {
        msg_box( dlg, _("Primary key can not be deleted!"), _("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;
    }
    if( j == 0 ) {
        msg_box( dlg, _("Primary subkey can not be deleted!"), _("Key Edit"), MB_ERR );
        return FALSE;
    }
     
    listview_get_item_text( lv, j, 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 = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    err = ke->delKey (j);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Delete Subkey"), MB_ERR);
    else {
        listview_del_item (lv, j);
        k->update = 1;
        status_box (dlg, _("Subkey successfully deleted."), _("GnuPG status"));
    }
    delete ke;
    return err? FALSE : TRUE;
} /* do_editkey_delkey */


/* 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;
    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;
    }

    /* If a key already expired, it is possible the user wants to
       set a new expiration date.. */   
    listview_get_item_text (lv, j, 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_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;
    }

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    if (k->is_protected)
        ke->setPassphrase (pass);
    err = ke->setKeyExpireDate (j, diff_time (NULL, &udd.st), true);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Expire Subkey"), MB_ERR);
    else {
        _snprintf (buf, sizeof buf - 1, "%04d-%02d-%02d",       
                   udd.st.wYear, udd.st.wMonth, udd.st.wDay);
        listview_add_sub_item (lv, j, 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_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;           
    }

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    if (k->is_protected)
        ke->setPassphrase (pass);
    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[256], t[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, 0, 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, 1, buf, sizeof buf -1);
    _snprintf( t, sizeof t -1, _("user ID \"%s\".\n\n"
                "Do you really want to revoke this user ID?"), buf );
    if( msg_box( dlg, t, _("Key Edit"), MB_WARN_ASK) == IDNO )
        return FALSE;
    if( k->is_protected ) {
        pass = request_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;           
    }
    listview_get_item_text (lv, j, 2, buf, sizeof (buf)-1);
    id = do_find_userid (k->keyid, buf, NULL);
    if (id == -1)
        BUG (NULL);

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    if (k->is_protected)
        ke->setPassphrase (pass);
    err = ke->revokeUserid (id);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Revoke Signature"), 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 rc;
    GpgKeyEdit *ke;
    char buf[256], * pass = NULL, * prefs;
    int j, id, cancel=0, flags=0;

    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, 2, buf, sizeof buf-1);
    id = do_find_userid (k->keyid, buf, NULL);
    if (id == -1)
        BUG (dlg);
    if (k->is_protected) {
        pass = request_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;
    }

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);
    if (k->is_protected)
        ke->setPassphrase (pass);

    get_userid_preflist (&prefs, &flags);

    rc = ke->setUseridPreferences (id, prefs);
    /* XXX */

    sfree_if_alloc (pass);
    free_if_alloc (prefs);
    delete ke;
    return 0;
}


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 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, 2, buf, sizeof buf-1);
    id = do_find_userid (k->keyid, buf, NULL);
    if (id == -1)
        BUG (dlg);
    if (k->is_protected) {
        pass = request_passphrase (_("Key Edit"), 1, &cancel);
        if (cancel)
            return FALSE;
    }

    ke = new GpgKeyEdit (k->keyid);
    if (k->is_protected)
        ke->setPassphrase (pass);
    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_callback_s *cb = NULL;
    gpg_uid_info_t inf=NULL;
    char buf[128];
    int pos;

    switch (msg) {
    case WM_INITDIALOG:
        cb = (keyedit_callback_s *)lparam;
        if (cb == NULL)
            BUG (dlg);
        pos = listview_get_curr_pos (cb->lv);
        listview_get_item_text (cb->lv, pos, 2, buf, DIM (buf)-1);
        SetDlgItemText (dlg, IDC_SHOWPREF_INFO, buf);
        pos = do_find_userid (((winpt_key_t)cb->opaque)->keyid, buf, &inf);
        if (inf) {
            const char *prefs = inf->prefs;
            if (prefs && *prefs) {
                if (parse_preflist (dlg, prefs) <= 0)
                    pos = -1;
            }
            else
                pos = -1;
            gpg_uid_info_release (inf);
            if (pos == -1) {
                msg_box (dlg, _("No preferences available."), _("Key Edit"), MB_ERR);
                EndDialog (dlg, TRUE);
            }
            if (inf->flags.mdc)
                CheckDlgButton (dlg, IDC_SHOWPREF_MDC, BST_CHECKED);
        }
        SetDlgItemText (dlg, IDC_SHOWPREF_MDC, _("MDC feature"));
        SetDlgItemText (dlg, IDC_SHOWPREF_PREFINF, _("Preferences"));
        SetWindowText (dlg, _("Key Preferences"));
        SetForegroundWindow (dlg);
        break;

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


static int
do_editkey_showpref (winpt_key_t k, HWND dlg, listview_ctrl_t lv)
{
    struct keyedit_callback_s cb;

    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.lv = lv;
    cb.opaque = k;
    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 buf[256], t[512];
    int j, id = 0;

    if (!k->key_pair)
        return FALSE; /* XXX: see do_editkey_delsubkey */

    if( listview_count_items( lv, 0 ) == 1 ) {
        msg_box( dlg, _("Primary user ID can not be deleted!"), _("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;
    }
    
    /* XXX: add a hint that also all signatures will be deleted? */
    listview_get_item_text( lv, j, 1, buf, DIM(buf) -1 );
    _snprintf( t, DIM (t)-1, _("user ID \"%s\".\n\n"
                               "Do you really want to delete this user ID?"),
                               buf);
    if( msg_box( dlg, t, _("Key Edit"), MB_YESNO|MB_ICONWARNING ) == IDNO )
        return FALSE;
    
    listview_get_item_text (lv, j, 2, buf, DIM (buf)-1);
    id = do_find_userid (k->keyid, buf, NULL);
    if (id == -1)
        BUG (dlg);

    ke = new GpgKeyEdit (k->keyid);
    if (!ke)
        BUG (NULL);

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


static BOOL CALLBACK
subkey_subclass_proc( HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam )
{
    switch( msg ) {
    case WM_KEYUP:
        int virt_key = (int)wparam;
        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 );
} /* subkey_subclass_proc */


static BOOL CALLBACK
uid_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch( msg ) {
    case WM_KEYUP:
        int virt_key = (int)wparam;
        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 );
} /* uid_subclass_proc */


/* 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;
    int cmd, idxsub = 0;
    HWND item;

    switch( msg ) {
    case WM_INITDIALOG:
        k = (winpt_key_t)lparam;
        if (!k)
            BUG (NULL);
        do_init_cmdlist (dlg);
        lvsub = subkey_list_init (dlg, k);
        if( !lvsub )
            BUG( NULL );
        lvuid = userid_list_init (dlg, k);
        if( !lvuid )
            BUG( NULL );
        item = GetDlgItem( dlg, IDC_KEYEDIT_KEYLIST );
        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 );
            }
        }
        item = GetDlgItem( dlg, IDC_KEYEDIT_UIDLIST );
        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->key_pair || 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"));
        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->code == NM_DBLCLK &&
            notify->idFrom == IDC_KEYEDIT_UIDLIST)
            do_editkey_showpref (k, dlg, lvuid);
        break;

    case WM_COMMAND:
        switch( LOWORD( wparam ) ) {
        case IDOK:
            cmd = SendDlgItemMessage (dlg, IDC_KEYEDIT_CMD, CB_GETCURSEL, 0, 0);
            if (cmd == LB_ERR) {
                msg_box( dlg, _("Please select a command."), _("Key Edit"), MB_INFO );
                return FALSE;
            }
            idxsub = listview_get_curr_pos (lvsub);
            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: km_enable_disable_key( lvsub, dlg, idxsub, 1 ); break;
            case CMD_DISABLE: km_enable_disable_key( lvsub, dlg, idxsub, 0 ); break;
            }
            break;

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

        case IDC_KEYEDIT_HELP:
            do_show_help (dlg);
            break;
        }
        break;
    }
    return FALSE;
}
