trunk/Src/wptKeyManager.cpp

/* wptKeyManager.cpp - Handy functions for the Key Manager dialog
 *      Copyright (C) 2001-2005 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * 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 <stdio.h>

#include "gpgme.h"
#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptCommonCtl.h"
#include "wptNLS.h"
#include "wptErrors.h"
#include "wptContext.h"
#include "wptGPG.h"
#include "wptKeylist.h"
#include "wptFileManager.h"
#include "wptDlgs.h"
#include "wptKeyserver.h"
#include "wptKeyManager.h"
#include "wptKeylist.h"
#include "wptHTTP.h"
#include "wptKeyEdit.h"
#include "wptImport.h"
#include "wptCrypto.h"
#include "wptUTF8.h"


/* Return a user friendly key representation in @buf of
   the key given by @keyid. */
static void 
key_get_clip_info (const char *keyid, char *buf, size_t buflen)
{
    gpgme_key_t pk;
    char *uid;

    if (get_pubkey (keyid, &pk))
        BUG (NULL);
    uid = utf8_to_wincp2 (pk->uids->uid);
    _snprintf (buf, buflen-1, 
               "pub %04d%s/%s %s %s\r\n"
               "    Primary key fingerprint: %s\r\n",
               pk->subkeys->length,
               get_key_pubalgo2 (pk->subkeys->pubkey_algo),
               pk->subkeys->keyid+8,
               get_key_created (pk->subkeys->timestamp),
               uid,
               get_key_fpr (pk));
    safe_free (uid);
}


/* Return a general description of the key @key. */
static char*
key_get_info (gpgme_key_t pk, int is_sec)
{
    const char *fmt = "%s %04d%s/0x%s %s\n  \"%s\"";
    char *p, *uid;
    int n;

    n = strlen (fmt) + 8 + 2 + 16 + 12 + strlen (pk->uids->uid) + 32;
    p = new char[n+1];
    if (!p)
        BUG (NULL);
    uid = utf8_to_wincp2 (pk->uids->uid);
    _snprintf (p, n, fmt, is_sec? "sec" : "pub",
               pk->subkeys->length,
               get_key_pubalgo2 (pk->subkeys->pubkey_algo),
               pk->subkeys->keyid+8, get_key_created (pk->subkeys->timestamp),
               uid);
    safe_free (uid);
    return p;
}


#if 0
/* Quoted the user-id given by @uid. If @uid is already
   quoted @uid is returned without any modifications.
   Return value: quoted @uid. */
char*
km_quote_uid (const char *uid)
{    
    char *q;

    if (*uid == '"' && uid[strlen (uid)-1] == '"')
        return m_strdup (uid);
    q = new char[strlen (uid) + 4];
    if (!q)
        BUG (NULL);
    _snprintf (q, strlen (uid) + 3, "\"%s\"", uid);
    return q;
}
#endif


/* Check if list view @lv contains a secret key at position @pos.
   If utrust is valid, set it to 1 if the key is valid -1 otherwise.
   Return value: 1 normal key, 2 smart card key. */
int
km_check_for_seckey (listview_ctrl_t lv, int pos, int *utrust)
{
    gpgme_key_t key;
    winpt_key_s sk;
    int type = 0;
    
    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!key)
        BUG (NULL);
    if (utrust)
        *utrust = 0;
    memset (&sk, 0, sizeof (sk));
    if (!winpt_get_seckey (key->subkeys->keyid+8, &sk))
        type = 1;
    if (sk.ext && sk.ext->gloflags.divert_to_card)
        type = 2;
    if (utrust && (key->expired || key->revoked))
        *utrust = -1;
    else if (utrust && key->owner_trust == GPGME_VALIDITY_ULTIMATE)
        *utrust = 1;
    return type;
}


/* Check if the key at position @pos is protected with a passwd. */
int
km_check_if_protected (listview_ctrl_t lv, int pos)
{
    gpgme_key_t key;
    winpt_key_s k;

    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!key)
        return 1; /* assume yes */
    winpt_get_pubkey (key->subkeys->keyid, &k);
    return k.is_protected;
}


/* Check if the key has a good status.
   Return value: 0 on success. */
int
km_check_key_status (listview_ctrl_t lv, int pos)
{
    int flags = km_get_key_status (lv, pos);
    
    if (flags & KM_FLAG_EXPIRED) {
        msg_box (lv->ctrl, _("This key has expired!\n"  
                             "Key check failed."), _("Key Manager"), MB_ERR);
        return -1;
    }
    else if (flags & KM_FLAG_REVOKED) {
        msg_box (lv->ctrl, _("This key has been revoked by its owner!\n"
                             "Key check failed."), _("Key Manager"), MB_ERR);
        return -1;
    }

    return 0;
}


/* Return all key flags ORed. */
int
km_get_key_status (listview_ctrl_t lv, int pos)
{
    gpgme_key_t key;
    int flags = 0;

    if (pos == -1)
        return 0;
    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (key == NULL)
        return 0;

    if (key->expired)
        flags |= KM_FLAG_EXPIRED;
    if (key->revoked)
        flags |= KM_FLAG_REVOKED;
    if (key->disabled)
        flags |= KM_FLAG_DISABLED;
    return flags;
}


/* Interface to enable or disable a key (@enable = 1 then enable).
   The key is retrieved from a list control @lv at the pos @pos. */
int
km_enable_disable_key (listview_ctrl_t lv, HWND dlg, int pos, int enable)
{
    gpgme_error_t err;
    gpgme_key_t key;
    GpgKeyEdit *ke;

    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!key)
        BUG (NULL);
    ke = new GpgKeyEdit (key->subkeys->keyid);
    if (!ke)
        BUG (NULL);

    err = enable? ke->enable () : ke->disable ();
    if (!err)
        show_msg (dlg, 1500, _("Key status changed."));
    else
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
    delete ke;
    return err? WPTERR_GENERAL : 0;
}


/* Create a string that contain all keyids from
   the key list @rset separated by a space. */
char*
gpg_keylist_to_pattern (gpgme_key_t *rset, int n)
{
    char *p;
    int i;

    if (!n)
        return NULL;
    p = (char *)calloc (1, n*(16+1)+n+2);
    if (!p)
        BUG (NULL);
    for (i=0; i < n; i++) {
        strcat (p, rset[i]->subkeys->keyid);
        strcat (p, " ");
    }
    return p;
}


/* Export the keys given in @rset to the clipboard.
   Return value: 0 on success. */
static gpgme_error_t
gpg_clip_export (gpgme_key_t *rset, int n)
{
    gpgme_error_t err = 0;
    gpgme_ctx_t ctx = NULL;
    gpgme_data_t keydata = NULL;
    char *patt=NULL;
    
    err = gpgme_new (&ctx);
    if (err)
        return err;
    gpgme_set_armor (ctx, 1);           
    err = gpgme_data_new (&keydata);
    if (err)
        goto leave;

    patt = gpg_keylist_to_pattern (rset, n);
    if (!patt) {
        err = gpg_error (GPG_ERR_ENOMEM);
        goto leave;
    }

    err = gpgme_op_export (ctx, patt, 0, keydata);
    if (err)
        goto leave;

    gpg_data_release_and_set_clipboard (keydata, 1);

leave:
    if (patt)
        free (patt);
    gpgme_release (ctx);
    return err;
}


/* Export the selected keys in @lv to the clipboard. */
int
km_clip_export (HWND dlg, listview_ctrl_t lv)
{
    gpgme_error_t err;
    gpgme_key_t *rset;
    char buf[256];
    int n=0;
    int rc=0;
    
    rset = keylist_enum_recipients (lv, KEYLIST_LIST, &n);
    if (!n) {
        msg_box (dlg, _("No key was selected for export."), 
                 _("Key Manager"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;
    }
    
    err = gpg_clip_export (rset, n);
    if (err) {
        msg_box( dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;
    }
    if (n == 1) {
        key_get_clip_info (rset[0]->subkeys->keyid, buf, sizeof (buf)-1);
        set_clip_text2 (NULL, buf, strlen (buf), 0);
    }

    show_msg (dlg, 1500, _("GnuPG Status: Finished"));
    
leave:
    free (rset);
    return rc;
}


/* Export the selected secret key from @lv into @fname.
   It is only allowed to export a single secret key. */
int
km_privkey_export (HWND dlg, listview_ctrl_t lv, const char *fname)
{
    gpgme_key_t *rset;
    gpgme_error_t err;
    int n = 0;

    rset = keylist_enum_recipients (lv, KEYLIST_LIST, &n);
    if (!n) {
        msg_box (dlg, _("No key was selected for export."), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_GENERAL;
    }
    if (n > 1) {
        msg_box (dlg, _("Only one secret key can be exported."), 
                 _("Key Manager"), MB_ERR);
        free (rset);
        return 0; /* we checked this before, so we just quit */
    }

    err = gpg_export_seckey (rset[0]->subkeys->keyid, fname);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
    else
        log_box (_("Key Manager"), MB_OK,
                 _("Secret key successfully saved in '%s'."), fname);

    free (rset);
    return err? WPTERR_GENERAL : 0;
}


/* Export the selected recipients from @lv into the file @fname. */
int
km_file_export (HWND dlg, listview_ctrl_t lv, const char *fname)
{
    gpgme_key_t *rset;
    gpgme_data_t keydata;       
    gpgme_error_t err;
    gpgme_ctx_t ctx;
    char *patt;
    int n;

    rset = keylist_enum_recipients (lv, KEYLIST_LIST, &n);
    if (!n) {
        msg_box (dlg, _("No key was selected for export."), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_GENERAL;
    }
    
    err = gpgme_data_new (&keydata);
    if (err)
        BUG (NULL);
    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    gpgme_set_armor (ctx, 1);

    /*gpgme_set_comment (ctx, "Generated by WinPT "PGM_VERSION);*/
    patt = gpg_keylist_to_pattern (rset, n);
    
    err = gpgme_op_export (ctx, patt, 0, keydata);
    if( err ) {
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        goto leave;
    }

    log_box (_("Key Manager"), MB_OK, 
             _("Key(s) successfully saved in '%s'."), fname);
    
leave:
    err = gpg_data_release_and_set_file (keydata, fname);
    if (err)
        log_box (_("Key Manager"), MB_OK,
                 _("Could not save data to '%s'."), fname);
    gpgme_release (ctx);
    free (patt);
    return (int)err;
}


/* Read a dash escaped key from the clipboard
   unescape it and write it back. */
static int
extract_dash_escaped_key (void)
{
    gpgme_data_t inp, plain;
    gpgme_error_t err;

    err = gpg_data_new_from_clipboard (&inp, 0);
    if (err) {
        msg_box (NULL, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        return -1;
    }
    gpg_data_extract_plaintext (inp, &plain);
    gpg_data_release_and_set_clipboard (plain, 0);
    gpgme_data_release (inp);

    return 0;
}


/* Import keys from the clipboard. */
int
km_clip_import (HWND dlg)
{
    gpgme_error_t err;
    int pgptype;
    int id;
    int has_data = 0;
    
    if (!gpg_clip_istext_avail (&has_data) && !has_data) {
        msg_box (dlg, winpt_strerror (WPTERR_CLIP_ISEMPTY), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_CLIP_ISEMPTY;
    }
    err = gpg_clip_is_secured (&pgptype, &has_data);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
    if (!has_data) {
        msg_box (dlg, _("No valid OpenPGP data found."), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_GENERAL;
    }
    if (!(pgptype & PGP_PUBKEY) && !(pgptype & PGP_SECKEY)) {
        msg_box (dlg, _("No valid OpenPGP keys found."), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_GENERAL;
    }
    if (pgptype & PGP_DASH_ESCAPED) {
        id = msg_box (dlg, _("The key you want to import is dash escacped.\n"
                             "Do you want to extract the key?"),
                      _("Key Manager"), MB_YESNO);
        if (id == IDYES)
            extract_dash_escaped_key ();
        else
            msg_box (dlg, _("Cannot import dash escaped OpenPGP keys."), 
                     _("Key Manager"), MB_INFO);
    }

    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
                      clip_import_dlg_proc, 0,
                      _("Key Import"), IDS_WINPT_IMPORT);

    return 0;
}


/* Import a key from the http URL @url. */
int
km_http_import (HWND dlg, const char *url)
{
    http_hd_t hd;
    FILE *fp;
    char *p;
    char tmpfile[500];
    int statcode;
    int rc = 0;

    if (strncmp (url, "http://", 7)) {
        log_box (_("Key Import HTTP"), MB_ERR, _("Invalid HTTP URL: %s"), url);
        return WPTERR_GENERAL;
    }

    GetTempPath (sizeof (tmpfile)-128, tmpfile);
    p = make_filename (tmpfile, "winpt_file_http", "tmp");
    if (!p)
        BUG (0);
    fp = fopen (p, "wb");
    if (!fp) {
        free_if_alloc (p);
        log_box (_("Key Import HTTP"), MB_ERR, "%s: %s", p, 
                 winpt_strerror (WPTERR_FILE_CREAT));
        return WPTERR_FILE_CREAT;
    }

    /* parse URL */
    rc = http_send_request2 (url, &hd);
    if (!rc)
        rc = http_parse_response (hd, &statcode);
    if (!rc)
        rc = http_parse_data (hd, fp);
    http_hd_free (hd);
    fclose (fp);
    if (rc) {   
        msg_box (dlg, winpt_strerror (rc), _("Key Import HTTP"), MB_ERR);
        rc = WPTERR_GENERAL;
    }
    km_file_import (dlg, p);
    remove (p);
    free_if_alloc (p);
    return rc;
}


/* Import a key from the given file @fname.
   On success an import statistics dialog is shown. */
int
km_file_import (HWND dlg, const char *fname)
{
    gpgme_data_t keydata = NULL;
    gpgme_ctx_t ctx;
    gpgme_error_t err;    
    fm_state_s fm_stat;
    gpgme_import_result_t res;
    
    memset (&fm_stat, 0, sizeof (fm_stat));
    fm_stat.opaque = m_strdup (fname);
    
    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
                      file_import_dlg_proc, (LPARAM)&fm_stat,
                      _("File Import"), IDS_WINPT_IMPORT);
    if (fm_stat.cancel == 1) {
        free_if_alloc (fm_stat.opaque);
        return WPTERR_GENERAL;
    }
    
    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    err = gpgme_data_new_from_file (&keydata, fname, 1);
    if (err) {
        msg_box (dlg, _("Could not read key-data from file."), 
                 _("Key Manager"), MB_ERR);
        goto leave;
    }
    
    SetCursor (LoadCursor (NULL, IDC_WAIT));
    err = gpgme_op_import (ctx, keydata);
    SetCursor (LoadCursor (NULL, IDC_ARROW));
    if (err) {
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        goto leave;
    }    

    res = gpgme_op_import_result (ctx);
    if (res->new_revocations == 0 && fm_stat.import.revcert == 1)
        res->new_revocations = 1;
    if (res->secret_imported == 0 && fm_stat.import.has_seckey == 1)
        res->secret_imported = 1;

    /* XXX: if we import a key pair but the secret key comes first,
            no_{valid}_user_id is 1 even so the public key, which comes
            later is valid and self-signed. */
    print_import_status (res);
    if (res->no_user_id > 0) {
        msg_box (dlg, _("Key without a self signature was dectected!\n"
                        "(This key is NOT usable for encryption, etc)\n"
                        "\n"    
                        "Cannot import these key(s)!"), _("Import"), MB_INFO);
    }

leave:
    gpgme_data_release (keydata);
    gpgme_release (ctx);
    free_if_alloc (fm_stat.opaque);
    return (int)err;
}


/* Mark the keys in @rset as deleted in the keycache. */
static void
delete_keys_from_cache (gpgme_key_t *rset, size_t n)
{
    gpg_keycache_t pub = keycache_get_ctx (1);
    int i=0;

    while (n-- > 0)
        gpg_keycache_delete_key (pub, rset[i++]->subkeys->keyid);
}


/* Delete all selected keys from the list view @lv. */
int
km_delete_keys (listview_ctrl_t lv, HWND dlg)
{
    gpgme_error_t err;
    gpgme_ctx_t ctx;
    gpgme_key_t *rset;
    gpgme_key_t key;
    char keyid[32];
    char *p;
    int with_seckey=0, seckey_type=0, confirm=0;
    int i, rc, n, k_pos=0;
    
    if (listview_get_curr_pos (lv) == -1) {
        msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
        return -1;
    }
        
    if (listview_count_items (lv, 1) > 8) {
        i = msg_box (NULL, _("Do you really want to confirm each key?"), 
                     _("Delete Confirmation"), MB_YESNOCANCEL|MB_ICONQUESTION);
        if (i == IDCANCEL)
            return 0;
        if (i != IDNO)
            confirm = 1;
    }
    else
        confirm = 1;

    n = listview_count_items (lv, 0);
    rset = (gpgme_key_t *)calloc (n+1, sizeof (gpgme_key_t));
    if (!rset)
        BUG (NULL);
    for (i = 0; i < n; i++) {
        if (listview_get_item_state(lv, i)) {
            key = (gpgme_key_t)listview_get_item2 (lv, i);
            if (!key)
                BUG (NULL);
            seckey_type = km_check_for_seckey (lv, i, NULL);
            if (confirm && !seckey_type) {
                p = key_get_info (key, 0);
                rc = log_box( _("Key Manager"), MB_YESNO|MB_ICONWARNING,
                              _("Do you really want to delete this key?\n\n"
                                "%s"), p);
                if (rc == IDYES)
                    rset[k_pos++] = key;
                with_seckey = 0;
                free_if_alloc (p);
            }
            else if (confirm) {
                p = key_get_info (key, 1);
                rc = log_box (_("Key Manager"), MB_YESNO|MB_ICONWARNING,                
                              _("Do you really want to delete this KEY PAIR?\n\n"
                                "Please remember that you are not able to decrypt\n"
                                "messages you stored with this key any longer.\n"
                                "\n"
                                "%s"), p);
                if( rc == IDYES ) {
                    if (seckey_type == 2)
                        msg_box (dlg, _("The actual secret key is stored on a smartcard.\n"
                                        "Only the public key and the secret key \n"
                                        "placeholder will be deleted.\n"), 
                                        _("Key Manager"), MB_OK);
                    rset[k_pos++] = key;
                }
                with_seckey = 1;
                free_if_alloc (p);
            }
            else {
                with_seckey = 1;
                get_pubkey (keyid, &key);
                rset[k_pos++] = key;
            }
        }
    }
    
    if (k_pos == 0) {
        free (rset);
        return 0;
    }

    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    n = k_pos;
    for (i=0; i < k_pos; i++) {
        err = gpgme_op_delete (ctx, rset[i], with_seckey);
        if (err)
            msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        else
            n--;
    }
    if (n == 0)
        show_msg (dlg, 1500, _("GnuPG Status: Finished"));      
    gpgme_release (ctx);
    listview_del_items (lv);
    delete_keys_from_cache (rset, k_pos);
    free (rset);

    return (int)err;
}


/* Send the select key in @lv to the keyserver @host:@port. */
int
km_send_to_keyserver (listview_ctrl_t lv, HWND dlg, const char *host, u16 port)
{
    gpgme_key_t key;
    int id;
    
    id = listview_get_curr_pos (lv);
    if (id == -1) {
        msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );
        return WPTERR_GENERAL;
    }

    key = (gpgme_key_t)listview_get_item2 (lv, id);
    if (!key)
        BUG (NULL);
    id = log_box (_("Key Manager"), MB_YESNO,
                  _("Do you really want to send '%s' to keyserver %s?"),
                    key->subkeys->keyid+8, host);
    if (id == IDYES)
        hkp_send_key (dlg, host, port, key->subkeys->keyid+8);

    return 0;
}


/* Send the selected key in @lv via MAPI to a mail recipient. */
int
km_send_to_mail_recipient (listview_ctrl_t lv, HWND dlg)
{
    gpgme_key_t key;
    gpgme_ctx_t ctx=NULL;
    gpgme_data_t out;
    gpgme_error_t rc;
    char tmp[128];
    char *fname;
    char *name;
    int pos;

    if (listview_count_items (lv, 1) > 1) {
        msg_box (dlg, _("Please only select one key."), 
                 _("Key Manager"), MB_INFO|MB_OK);
        return WPTERR_GENERAL;
    }
    pos = listview_get_curr_pos (lv);
    if (pos == -1) {
        msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
        return WPTERR_GENERAL;
    }
    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!key)
        BUG (NULL);

    GetTempPath (sizeof (tmp)-1, tmp);
    if (tmp[strlen (tmp)-1] == '\\')
        tmp[strlen (tmp)-1] = 0;
    name = utf8_to_wincp2 (key->uids->name); 
    fname = make_filename (tmp, name, "asc");
    for (pos=0; pos < (int)strlen (fname); pos++) {
        if (fname[pos] == ' ')
            fname[pos] = '_';
    }

    rc = gpgme_new (&ctx);
    if (rc)
        BUG (NULL);
    rc = gpgme_data_new (&out);
    if (rc)
        BUG (NULL);

    gpgme_set_armor (ctx, 1);
    rc = gpgme_op_export (ctx, key->subkeys->keyid, 0, out);
    if (rc)
        msg_box (dlg, gpgme_strerror (rc), _("Key Manager"), MB_ERR);
    else
        mapi_send_pubkey (key->subkeys->keyid+8, fname);

    gpg_data_release_and_set_file (out, fname);
    gpgme_release (ctx);
    safe_free (name);
    free_if_alloc (fname);
    return rc;
}


static void
km_refresh_one_key (listview_ctrl_t lv, HWND dlg, int pos)
{
    gpgme_key_t key;
    int idx;

    if (pos != 0)
        idx = pos;
    else
        idx = listview_get_curr_pos (lv);
    if (idx != -1) {
        key = (gpgme_key_t)listview_get_item2 (lv, idx);
        hkp_recv_key (dlg, default_keyserver, default_keyserver_port, 
                      key->subkeys->keyid+8, 0, KM_KS_REFRESH);
    }
}


/* Refresh all keys from the default keyserver. */
void
km_refresh_from_keyserver (listview_ctrl_t lv, HWND dlg)
{
    int idx, id, i;
    
    if (kserver_check_inet_connection ()) {
        msg_box (dlg, _("Could not connect to keyserver, abort procedure."),
                 _("Key Manager"), MB_ERR);
        return;
    }
    idx = listview_count_items (lv, 0);
    if (listview_count_items (lv, 1) == idx) {
        id = msg_box (dlg, _("Do you really want to refresh all keys in the keyring?"), 
                      _("Key Manager"), MB_YESNO);
        if (id == IDNO)
            return;
        for (i = 0; i < idx; i++)
            km_refresh_one_key (lv, dlg, i);
    }
    else if (idx == 1)
        km_refresh_one_key (lv, dlg, 0);
    else {
        for (i=0; i < listview_count_items (lv, 0); i++) {
            if (listview_get_item_state (lv, i))
                km_refresh_one_key (lv, dlg, i);
        }
    }
}


void
km_set_clip_info (const char *uid)
{    
    char buf[256];
    
    key_get_clip_info (uid, buf, sizeof (buf)-1);
    set_clip_text (NULL, buf, strlen (buf));
}


/* Return TRUE if the key in the list @lv at pos @pos is an
   old version 3 key. */
int
km_key_is_v3 (listview_ctrl_t lv, int pos)
{
    gpgme_key_t pk;

    pk = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!pk)
        BUG (NULL);
    if (strlen (pk->subkeys->fpr) == 32 && 
        pk->subkeys->pubkey_algo == GPGME_PK_RSA)
        return -1;
    return 0;
}


/* Set trust of selected key in @lv (at @pos) to ultimate. */
int
km_set_implicit_trust (HWND dlg, listview_ctrl_t lv, int pos)
{
    gpgme_error_t err;
    gpgme_key_t key;
    GpgKeyEdit *ke;

    key = (gpgme_key_t)listview_get_item2 (lv, pos);
    if (!key)
        BUG (NULL);
    ke = new GpgKeyEdit (key->subkeys->keyid);
    if (!ke)
        BUG (0);

    err = ke->setTrust (GPGME_VALIDITY_ULTIMATE);
    if (err)
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
    else
        show_msg (dlg, 1500, _("GnuPG Status: Finished"));

    delete ke;
    return (int)err;
}


void
km_find_key (HWND dlg, listview_ctrl_t lv)
{
    int oldpos = listview_get_curr_pos (lv);
    int n;
    char *name = get_input_dialog (dlg, _("Search"), _("Search for:"));
    if (name == NULL)
        return;
    if (oldpos < 0)
        oldpos = 0;
    n = listview_find (lv, name);
    if (n != -1) {
        listview_select_one (lv, n);
        listview_scroll (lv, oldpos, n);
    }
    else {
        const char *s = _("String pattern \"%s\" not found.");
        char *p = new char[strlen (s) + strlen (name) + 2];
        if (!p)
            BUG (0);
        sprintf (p, s, name);
        msg_box (dlg, p, _("Key Manager"), MB_INFO);
        free_if_alloc (p);
    }
    free_if_alloc (name);
}


/* Return a user-friendly name for a key derrived from
   name. If @is_secret is 1, a secret key name will be generated. */
char*
km_gen_export_filename (const char *keyid, int is_secret)
{
    gpgme_key_t key;
    char *p, *uid;

    if (get_pubkey (keyid, &key))
        return m_strdup (keyid);
    uid = utf8_to_wincp2 (key->uids->name);
    if (!uid)
        return m_strdup (keyid);
    p = new char[strlen (uid) + 8 + 16];
    if (!p)
        BUG (0);
    sprintf (p, "%s%s.asc", uid, is_secret? "_sec" : "");
    for (size_t i=0; i < strlen (p); i++) {
        if (p[i] == ' ' || p[i] == ':' || p[i] == '?' || p[i] == '|')
            p[i] = '_';
    }
    safe_free (uid);
    return p;
}