trunk/Src/wptKeyManager.cpp

/* wptKeyManager.cpp - Handy functions for the Key Manager dialog
 *      Copyright (C) 2001-2006 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 <assert.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"
#include "wptGPGME.h"


/* Remove all kind of invalid characters which would
   result in an illegal file name. */
void
secure_filename (char *file, size_t len)
{
    char *p = file;
    size_t i;

    /* XXX: it is possible that the recipient has a different
            charset and thus maybe 8-bit chars should be stripped also. */
    for (i=0; i < len; i++) {
        if (p[i] == ' ' || p[i] == ':' || p[i] == '?' || p[i] == '|' ||
            p[i] == '\\' || p[i] == '/')
            p[i] = '_';
    }
}


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

    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        BUG (NULL);
    pk = key.ctx;
    _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),
               key.ext->uids->uid,
               get_key_fpr (pk));
}


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

    pk = key->ctx;
    n = strlen (fmt) + 8 + 2 + 16 + 12 + strlen (pk->uids->uid) + 32;
    p = new char[n+1];
    if (!p)
        BUG (NULL);
    _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),
               key->ext->uids->uid);
    return p;
}


/* Retrieve the opaque 32-bit param stored within the list view item
   at position @idx and return the gpgme key context. */
gpgme_key_t
km_get_key_ptr (listview_ctrl_t lv, int idx, struct keycache_s **r_ctx)
{
    struct keycache_s *ctx;

    ctx = (struct keycache_s *)listview_get_item2 (lv, idx);
    if (!ctx)
        BUG (0);
    if (r_ctx)
        *r_ctx = ctx;
    return ctx->key;
}


/* 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 = km_get_key_ptr (lv, pos, 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 = km_get_key_ptr (lv, pos, NULL);
    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 = km_get_key_ptr (lv, pos, NULL);
    if (!key)
        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 = km_get_key_ptr (lv, pos, 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 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;
    GPGME *ctx;
    char *patt=NULL;
    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);
        return WPTERR_GENERAL;
    }
    
    patt = gpg_keylist_to_pattern (rset, n);

    ctx = new GPGME ();
    if (!ctx)
        BUG (0);
    ctx->setArmor (true);
    err = ctx->exportToClipboard (patt);
    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:
    safe_free (rset);
    safe_free (patt);
    delete ctx;
    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 *ctx;
    gpgme_key_t *rset;
    gpgme_error_t err;
    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;
    }
    patt = gpg_keylist_to_pattern (rset, n);

    ctx = new GPGME ();
    ctx->setArmor (true);
    err = ctx->exportToFile (patt, fname);
    if (err) {
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        goto leave;
    }
    else
        log_box (_("Key Manager"), MB_OK, 
                 _("Key(s) successfully saved in '%s'."), fname);
    
leave:
    delete ctx;
    safe_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 the PGP key data from the clipboard.
   Return value: 0 on success. */
static gpgme_error_t
gpg_op_clip_import (gpgme_ctx_t ctx)
{
    gpgme_error_t err = 0;
    gpgme_data_t keydata = NULL;
    
    err = gpg_data_new_from_clipboard (&keydata, 0);
    if (!err)
        err = gpgme_op_import (ctx, keydata);

    gpgme_data_release (keydata);
    return err;
}

/* Import keys from the clipboard. */
int
km_clip_import (HWND dlg, int *r_newkeys, int *r_newsks)
{
    gpgme_error_t err;
    gpgme_ctx_t ctx = NULL;
    gpgme_import_result_t res;
    fm_state_s fm_stat;
    int pgptype;
    int id, has_data = 0;
    int new_keys = 0, new_sks = 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_NODATA;
    }
    if (!(pgptype & PGP_PUBKEY) && !(pgptype & PGP_SECKEY)) {
        msg_box (dlg, _("No valid OpenPGP keys found."), 
                 _("Key Manager"), MB_ERR);
        return WPTERR_NODATA;
    }
    if (pgptype & PGP_DASH_ESCAPED) {
        id = msg_box (dlg, _("The key you want to import is dash escaped.\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);
    }

    memset (&fm_stat, 0, sizeof (fm_stat));
    fm_stat.opaque = m_strdup ("Clipboard");
    fm_stat.import.is_clip = 1;
    has_data = dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
                                 file_import_dlg_proc, (LPARAM)&fm_stat,
                                 _("Key Import"), IDS_WINPT_IMPORT);
    if (!has_data)
        goto leave;

    err = gpgme_new (&ctx);         
    if (err)
        BUG (NULL);
    op_begin ();
    err = gpg_op_clip_import (ctx);
    op_end ();
    if (err) {
        msg_box (dlg, gpgme_strerror (err), _("Import"), MB_ERR);
        goto leave;
    }

    res = gpgme_op_import_result (ctx);
    print_import_status (res);
    new_keys = res->considered - res->unchanged;
    new_sks = res->secret_imported - res->secret_unchanged;
    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"),
                        _("Import"), MB_WARN);
    }

leave:
    if (ctx)
        gpgme_release (ctx);
    free_if_alloc (fm_stat.opaque);
    if (r_newkeys)
        *r_newkeys = new_keys;
    if (r_newsks)
        *r_newsks = new_sks;
    if (!new_keys || !has_data)
        return WPTERR_NODATA;
    return (int)err;
}


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

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

    get_temp_name (tmpfile, sizeof (tmpfile)-1, "winpt_http.tmp");
    fp = fopen (tmpfile, "wb");
    if (!fp) {
        log_box (_("Key Import HTTP"), MB_ERR, "%s: %s", tmpfile, 
                 winpt_strerror (WPTERR_FILE_CREAT));
        return WPTERR_FILE_CREAT;
    }

    hd = new wHTTP (url);
    if (hd->getStatusCode () == HTTP_STAT_200)
        hd->readData (fp);
    else {
        log_box (_("Key Import HTTP"), MB_ERR, 
                 _("Could not fetch key from URL: %s"), url);
        rc = WPTERR_GENERAL;
    }

    delete hd;
    fclose (fp);
    if (!rc)
        km_file_import (dlg, tmpfile, NULL, NULL);
    DeleteFile (tmpfile);
    return rc;
}


/* Import a key from the given file @fname, if @fname is
   NULL use the common 'file open' dialog.
   On success an import statistics dialog is shown. */
int
km_file_import (HWND dlg, const char *fname, int *r_newkeys, int *r_newsks)
{
    gpgme_data_t keydata = NULL;
    gpgme_ctx_t ctx;
    gpgme_error_t err;    
    fm_state_s fm_stat;
    gpgme_import_result_t res;
    const char *name;
    int no_data = 0;
    int new_keys = 0, new_sks = 0;

    if (!fname) {
        name = get_fileopen_dlg (dlg, _("Choose Name of the Key File"),
                                 NULL, NULL);
        if (!name)
            return WPTERR_GENERAL;
    }
    else
        name = fname;

    memset (&fm_stat, 0, sizeof (fm_stat));
    fm_stat.opaque = m_strdup (name);
    
    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, name, 1);
    if (err) {
        msg_box (dlg, _("Could not read key-data from file."), 
                 _("Key Manager"), MB_ERR);
        goto leave;
    }
    
    op_begin ();
    err = gpgme_op_import (ctx, keydata);
    op_end ();
    if (err) {
        msg_box (dlg, gpgme_strerror (err), _("Key Manager"), MB_ERR);
        goto leave;
    }    

    res = gpgme_op_import_result (ctx);
    if (res->unchanged == res->considered &&
        res->secret_unchanged == res->secret_imported)
        no_data = 1;
    new_keys = res->considered - res->unchanged;
    new_sks = res->secret_imported - res->secret_unchanged;
    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"),
                        _("Import"), MB_WARN);
    }

leave:
    gpgme_data_release (keydata);
    gpgme_release (ctx);
    free_if_alloc (fm_stat.opaque);
    if (r_newkeys)
        *r_newkeys = new_keys;
    if (r_newsks)
        *r_newsks = new_sks;
    if (no_data)
        return WPTERR_NODATA;
    return (int)err;
}


/* Import all dropped files. */
int
km_dropped_file_import (HWND dlg, HDROP hdrop, 
                        int *r_newkeys, int *r_newsks)
{
    char name[MAX_PATH+1];
    UINT n = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
    UINT i;
    int newk=0, newsk=0, err=0;

    for (i=0; i < n; i++) {
        DragQueryFile (hdrop, i, name, MAX_PATH);
        err = km_file_import (dlg, name, &newk, &newsk);
        *r_newkeys = (*r_newkeys) + newk;
        *r_newsks = (*r_newsks) + newsk;
    }
    DragFinish (hdrop);
    return 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);
    gpg_keycache_t sec = keycache_get_ctx (0);
    gpgme_key_t sk;
    int i=0;

    while (n-- > 0) {
        if (!get_seckey (rset[i]->subkeys->keyid, &sk))
            gpg_keycache_delete_key (sec, sk->subkeys->keyid);
        gpg_keycache_delete_key (pub, rset[i]->subkeys->keyid); 
        i++;
    }
}


/* Check that the selected default secret key is still
   available. If not, delete the entry in gpg.conf. */
static void
check_exist_default_key (void)
{
    gpgme_key_t sk;
    char *defkey;

    defkey = get_gnupg_default_key ();
    if (defkey && get_seckey (defkey, &sk))
        set_gnupg_default_key (NULL);
    free_if_alloc (defkey);
}


/* Delete the list view items which match a key ptr
   inside the @rset array. */
static void
lv_del_confirmed_keys (listview_ctrl_t lv, gpgme_key_t *rset)
{
    winpt_key_s key2;
    int j, i, n = listview_count_items (lv, 0);

    for (i=0; i < n; i++) {
        if (listview_get_item_state (lv, i)) {
            km_get_key (lv, i, &key2);
            for (j=0; rset[j] != NULL; j++) {
                if (rset[j] == key2.ctx)
                    listview_del_item (lv, i);
            }
        }
    }
}


/* 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;
    winpt_key_s key2;
    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 = total amount of keys, i is the selected amount. */
    n = listview_count_items (lv, 0);
    i = listview_count_items (lv, 1);
    rset = (gpgme_key_t *)calloc (i+1, sizeof (gpgme_key_t));
    if (!rset)
        BUG (NULL);
    for (i = 0; i < n; i++) {
        if (listview_get_item_state(lv, i)) {
            km_get_key (lv, i, &key2);

            seckey_type = km_check_for_seckey (lv, i, NULL);
            if (confirm && !seckey_type) {
                p = km_key_get_info (&key2, 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++] = key2.ctx;
                free_if_alloc (p);
            }
            else if (confirm) {
                p = km_key_get_info (&key2, 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++] = key2.ctx;
                }
                with_seckey = 1;
                free_if_alloc (p);
            }
            else {
                with_seckey = 1;
                rset[k_pos++] = key2.ctx;
            }
        }
    }
    
    if (k_pos == 0) {
        free (rset);
        return 0;
    }

    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    n = k_pos;
    op_begin ();
    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--;
    }
    op_end ();
    if (n == 0)
        show_msg (dlg, 1500, _("GnuPG Status: Finished"));
    gpgme_release (ctx);
    lv_del_confirmed_keys (lv, rset);
    delete_keys_from_cache (rset, k_pos);
    safe_free (rset);
    if (with_seckey)
        check_exist_default_key ();
    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, WORD port)
{
    winpt_key_s 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;
    }

    km_get_key (lv, id, &key);
    id = log_box (_("Key Manager"), MB_YESNO,
                  _("Do you really want to send '0x%s' to keyserver %s?"),
                  key.keyid, host);
    if (id == IDYES)
        hkp_send_key (dlg, host, port, key.keyid);

    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_error_t rc;
    GPGME *ctx;
    struct keycache_s *c;
    char *fname;
    int pos;
    int n;

    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 = km_get_key_ptr (lv, pos, &c);

    n = strlen (c->uids->name)+1 + MAX_PATH + 5;
    fname = new char[n+1];
    get_temp_name (fname, n-5, c->uids->name);
    secure_filename (fname, strlen (fname));
    strcat (fname, ".asc");
    ctx = new GPGME ();
    ctx->setArmor (true);
    rc = ctx->exportToFile (key->subkeys->keyid, fname);
    if (rc)
        msg_box (dlg, gpgme_strerror (rc), _("Key Manager"), MB_ERR);
    else
        mapi_send_pubkey (key->subkeys->keyid+8, fname);

    delete ctx;
    free_if_alloc (fname);
    return rc;
}


/* Refresh the selected key in the listview @lv at position @pos.
   Legal flags are 0 = single key. */
static void
km_refresh_one_key (listview_ctrl_t lv, HWND dlg, int pos, int flags)
{
    winpt_key_s pk;
    gpgme_key_t key;
    const char *pref_kserv = default_keyserver;
    unsigned short pref_kserv_port = default_keyserver_port;
    char keyid[16+1];
    int idx, err = 0;
    
    if (pos != 0)
        idx = pos;
    else
        idx = listview_get_curr_pos (lv);
    if (idx != -1) {
        key = km_get_key_ptr (lv, idx, NULL);
        
        /* In single refresh mode, try to use the users preferred keyserver. */
        if (flags == 0 &&
            !winpt_get_pubkey (key->subkeys->keyid+8, &pk) &&
            !gpg_keycache_update_attr (pk.ext, KC_ATTR_PREFKSERV, 0) &&
            pk.ext->pref_keyserver && 
            !strstr (pk.ext->pref_keyserver, "ldap://")) {
            pref_kserv = pk.ext->pref_keyserver;
            pref_kserv_port = pk.ext->pref_keyserver_port;
        }
        _snprintf (keyid, sizeof (keyid)-1, "%s", key->subkeys->keyid+8);
        err = hkp_recv_key (dlg, pref_kserv, pref_kserv_port,
                            keyid, 0, flags);
        /* if we receive just a single key (no refresh mode), update it. */
        if (!flags && !err)
            keycache_update (0, keyid);
    }
}


/* Refresh the selected keys from the default keyserver. */
int
km_refresh_from_keyserver (listview_ctrl_t lv, HWND dlg)
{
    int cnt, id, i;    

    cnt = listview_count_items (lv, 0);
    if (listview_count_items (lv, 1) == cnt) {
        id = msg_box (dlg, _("Do you really want to refresh all keys in the keyring?"),
                      _("Key Manager"), MB_YESNO);
        if (id == IDNO)
            return -1;
        if (kserver_check_inet_connection ()) {
            msg_box (dlg, _("Could not connect to keyserver, abort procedure."),
                     _("Key Manager"), MB_ERR);
            return -1;
        }
    }
    if (listview_count_items (lv, 1) == 1)
        km_refresh_one_key (lv, dlg, listview_get_curr_pos (lv), 0);
    else {
        for (i=0; i < cnt; i++) {
            if (listview_get_item_state (lv, i))
                km_refresh_one_key (lv, dlg, i, KM_KS_REFRESH); 
        }
    }
    return 0;
}


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 = km_get_key_ptr (lv, pos, 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 = km_get_key_ptr (lv, pos, 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;
}


/* Provide a search dialog and try to find and select
   the key which matches the entered pattern. */
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)
        return;
    if (oldpos < 0)
        oldpos = 0;
    n = listview_find (lv, name, 1);
    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)
{
    winpt_key_s key;
    char *p;

    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        return m_strdup (keyid);
    
    p = new char[strlen (key.ext->uids->name) + 8 + 16];
    if (!p)
        BUG (0);
    sprintf (p, "%s%s.asc", key.ext->uids->name, is_secret? "_sec" : "");
    secure_filename (p, strlen (p));
    return p;
}


/* Retrieve the GPGME pointer from the selected list view
   item and return the WinPT specific key context. */
int
km_get_key (listview_ctrl_t lv, int pos, winpt_key_t k)
{
    struct keycache_s *c;
    gpgme_key_t key;

    if (pos == -1)
        return -1;
    key = km_get_key_ptr (lv, pos, &c);
    memset (k, 0, sizeof (*k));
    strncpy (k->tmp_keyid, key->subkeys->keyid+8, 8);
    k->keyid = k->tmp_keyid;
    k->is_protected = km_check_if_protected (lv, pos);
    k->key_pair = km_check_for_seckey (lv, pos, NULL);
    k->is_v3 = km_key_is_v3 (lv, pos);
    k->flags = km_get_key_status (lv, pos);
    k->ctx = key;
    k->ext = c;
    k->uid = c->uids->uid;
    return 0;
}


/* Show details of the revocation of the key @k. */
void
km_key_show_revoc_info (winpt_key_t k)
{
    const char *desc;
    char *val=NULL, *p;
    int len, reason;
    const char *reasons[] = {
        _("0. No reason specified"),
        _("1. Key has been compromised"),
        _("2. Key is superseded"),
        _("3. Key is no longer used"),
        NULL
    };

    /* spk:29:1:19:%00This key is kaputt */
    gpg_find_key_subpacket (k->keyid, 29, &val);    
    if (!val || strlen (val) < 3) {
        safe_free (val);
        return;
    }

    len = atoi (val+9);
    p = strchr (val+9, ':');
    assert (p);
    p++;
    reason = atoi (p+1);
    if (strlen (p+1) > 0)
        desc = p+3;
    else
        desc = "none";
    log_box (_("Key Manager"), MB_OK, 
             "Key revocation info for '%s':\n"
             "Reason for revocation: %s\n"
             "Description: %s\n",
             k->ctx->uids->name, reasons[reason % 4]+3,
             desc);
    safe_free (val);
}