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 
 */
#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"


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

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


#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)
{
    char t[32], t2[64];
    int type = 0;
    
    if (utrust)
        *utrust = 0;
    listview_get_item_text (lv, pos, 5, t, DIM (t)-1);
    listview_get_item_text (lv, pos, 2, t2, DIM (t2)-1);
    if (!strcmp (t2, "pub/sec"))
        type = 1;
    else if (!strcmp (t2, "pub/crd"))
        type = 2;
    if ((strstr (t, "Expired") || strstr (t, "Revoked")) && utrust)
        *utrust = -1;
    else if (stristr (t, "Ultimate") && utrust)
        *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;
}


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


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


/* 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)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;
    char keyid[32];

    listview_get_item_text (lv, pos, 1, keyid, DIM (keyid)-1);

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

    err = enable? ke->enable () : ke->disable ();
    if (!err) {
        show_msg (dlg, 1500, _("Key status changed."));
        keycache_set_reload (1); /* XXX: set update flag */
    }
    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;
} /* km_clip_export */


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


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


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


/* Import keys from the clipboard. */
int
km_clip_import (HWND dlg)
{
    gpgme_error_t err;
    gpg_pgptype_t 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, NULL,
                      _("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);
    unlink (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;
    }
    
    err = gpgme_op_import (ctx, keydata);
    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;

    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, k;
    char keyid[32], uid[256], date[64], keylen[64];    
    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 WPTERR_GENERAL;
    }
        
    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 ) ) {
            listview_get_item_text( lv, i, 0, uid, sizeof uid - 1 );
            listview_get_item_text( lv, i, 1, keyid, sizeof keyid - 1 );
            listview_get_item_text( lv, i, 3, keylen, sizeof keylen - 1 );
            listview_get_item_text( lv, i, 7, date, sizeof date - 1 );
            seckey_type = km_check_for_seckey (lv, i, NULL);
            if (confirm && !seckey_type) {
                rc = log_box( _("Key Manager"), MB_YESNO|MB_ICONWARNING,
                              _("Do you really want to delete this key?\n\n"
                                "pub %s %s %s\n"
                                "  \"%s\""), keylen, keyid, date, uid );
                if (rc == IDYES) {
                    get_pubkey (keyid, &k);
                    rset[k_pos++] = k;
                }
                with_seckey = 0;
            }
            else if (confirm) {
                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"
                                "pub/sec %s %s %s\n"
                                "  \"%s\""), keylen, keyid, date, uid );
                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 );
                    get_pubkey (keyid, &k);
                    rset[k_pos++] = k;
                }
                with_seckey = 1;
            }
            else {
                with_seckey = 1;
                get_pubkey (keyid, &k);
                rset[k_pos++] = k;
            }
        }
    }
    
    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;
}


int
km_send_to_keyserver (listview_ctrl_t lv, HWND dlg, const char * host, u16 port)
{
    char keyid[32];
    const char *t;
    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;
    }

    listview_get_item_text( lv, id, 1, keyid, sizeof keyid - 1 );
    id = log_box (_("Key Manager"), MB_YESNO,
                  _("Do you really want to send '%s' to keyserver %s?"),
                    keyid, host);
    if (id == IDYES) {
        t = keyid;
        if (!strncmp (keyid, "0x", 2)) 
            t += 2;
        hkp_send_key (dlg, host, port, t);
    }

    return 0;
} /* km_send_to_keyserver */


int
km_send_to_mail_recipient( listview_ctrl_t lv, HWND dlg )
{
#if 0 /*FIXME*/
    gpgme_key_t key;
    gpgme_ctx_t ctx=NULL;
    gpgme_recipients_t rset=NULL;
    gpgme_error_t rc;
    const char * s;
    char keyid[32], tmp[192+256], * p =NULL;
    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;
    }
    listview_get_item_text( lv, pos, 1, keyid, sizeof keyid-1 );
    if( get_pubkey( keyid, &key ) )
        BUG( NULL );
    s = key->uids->name;
    GetTempPath (sizeof tmp-1, tmp);
    strncat (tmp, s, sizeof tmp-200);
    strncat (tmp, ".asc", sizeof tmp-200);
    p = fm_quote_file (tmp);

    rc = gpgme_recipients_new( &rset );
    if( !rc )
        rc = gpgme_recipients_add_name( rset, keyid );
    if( !rc )
        rc = gpgme_new( &ctx );
    if( !rc ) {
        gpgme_set_armor (ctx, 1);
        rc = gpgme_op_file_export( ctx, rset, p );
    }
    if( rc )
        msg_box( dlg, gpgme_strerror( rc ), _("Key Manager"), MB_ERR );
    else
        mapi_send_pubkey (keyid, tmp);
    free_if_alloc( p );
    gpgme_recipients_release( rset );
    gpgme_release( ctx );    
    return rc;
#endif
    return 0;
}


static void
km_refresh_one_key (listview_ctrl_t lv, HWND dlg, int pos)
{
    int idx;
    char keyid[32];
    const char *t;

    if (pos != 0)
        idx = pos;
    else
        idx = listview_get_curr_pos (lv);
    if (idx != -1) 
    {
        listview_get_item_text (lv, idx, 1, keyid, sizeof keyid - 1);
        t = keyid;
        if (!strncmp (keyid, "0x", 2))
            t += 2;
        hkp_recv_key (dlg, default_keyserver, default_keyserver_port, t, 0, KM_KS_REFRESH);
    }
}


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


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


/* 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;
    char keyid[32];

    listview_get_item_text (lv, pos, 1, keyid, sizeof keyid-1);
    if (get_pubkey (keyid, &pk))
        BUG (NULL);
    if (strlen (pk->subkeys->fpr) == 32 && 
        pk->subkeys->pubkey_algo == GPGME_PK_RSA)
        return -1;
    return 0;
}


void
km_update_default_key_str (HWND dlg)
{
    char * keyid, defkeyinf[512];
    const char * fmt;
    
    keyid = get_gnupg_default_key ();
    if (!keyid)
        BUG (0);
    if( (keyid[0] >= 'A' && keyid[0] <= 'Z') || (keyid[0] >= 'a' && keyid[0] <= 'z')
        || (keyid[0] == '0' && keyid[1] == 'x') )
        fmt = _("Default Key: %s");
    else
        fmt = _("Default Key: 0x%s");
    _snprintf (defkeyinf, sizeof defkeyinf - 1, fmt, keyid);
    SendMessage (dlg, SB_SETTEXT, 0, (LPARAM)defkeyinf);
    free_if_alloc (keyid);
} /* km_return_default_key_str */


void
km_complete_status_bar (HWND sb, listview_ctrl_t lv)
{
    char txt_sec[128], txt_pub[128];
    int nkeys = 0, nsec = 0, i;

    nkeys = listview_count_items (lv, 0);
    for (i = 0; i < nkeys; i++) {
        if (km_check_for_seckey (lv, i, NULL))
            nsec++;
    }
    _snprintf (txt_sec, sizeof (txt_sec)-1, _("%d secret keys"), nsec);
    _snprintf (txt_pub, sizeof (txt_pub)-1, _("%d keys"), nkeys);
    SendMessage (sb, SB_SETTEXT, 1, (LPARAM)txt_sec);
    SendMessage (sb, SB_SETTEXT, 2, (LPARAM)txt_pub);
} /* km_complete_status_bar */


int
km_set_implicit_trust (HWND dlg, listview_ctrl_t lv, int pos)
{
    GpgKeyEdit *ke;
    gpgme_error_t err;    
    char keyid[32];

    listview_get_item_text (lv, pos, 1, keyid, 31);

    ke = new GpgKeyEdit (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);
}


void
km_dump_key (gpgme_key_t key)
{
#if _DEBUG
    log_box ("DEBUG", MB_OK,
             "%d %d %s %d\n%s", key->subkeys->length,
             key->subkeys->pubkey_algo,
             key->subkeys->keyid,
             key->subkeys->timestamp,
             key->uids->uid);
#endif
}

#if 0
gpg_optfile_t
km_groupdb_open( void )
{       
    gpg_optfile_t opt;
    char * optfile;
    int err = 0;
    
    optfile = get_gnupg_cfgfile();
    if( !optfile )
        BUG( NULL );
    if( parse_gpg_options( optfile, &opt ) )
        err = 1;
    free_if_alloc( optfile );
    return err? NULL : opt;
} /* km_groupdb_open */


int
km_groupdb_expand_recipients( const char *name, gpgme_recipients_t rset )
{   
    gpg_keycache_t kc;
    gpgme_key_t pk;
    gpg_optfile_t opt;
    gpg_group_t grp;    
    gpg_member_t mbr;
    int no_trust = 0, n;
 
    kc = keycache_get_ctx( 1 );
    if( !kc )
        BUG( NULL );

    opt = km_groupdb_open( );
    if( !opt )
        return WPTERR_FILE_OPEN;
    
    grp = find_group( opt, name );
    if( !grp )
        return WPTERR_GENERAL;
    
    /* we are paranoid and check that all group members exist in the
       key cache. there is no need that it is really the real key, but
       an entry should be available. the rest is up to GPG. */
    for( mbr = grp->list; mbr; mbr = mbr->next ) {
        if( gpgme_keycache_find_key( kc, mbr->name, 0, &pk ) )
            BUG( NULL );
        n = count_userids (pk);
        while( n-- ) {
            gpgme_user_id_t u = get_nth_userid (pk, n);
            const char * s =  u->uid;
            if( s && stristr( s, mbr->name )
                && u->validity < 3 )
                no_trust++;
        }
    }

    gpgme_recipients_add_name( rset, name );
    release_gpg_options( opt );
    
    return no_trust;
} /* km_groupdb_expand_recipients */


static HTREEITEM
km_tv_insert_item( HWND tree, HTREEITEM parent, const char *text )
{
    TVINSERTSTRUCT tvis;
    HTREEITEM node;
    
    memset( &tvis, 0, sizeof tvis );
    tvis.hParent = parent;
    tvis.hInsertAfter = TVI_LAST;
    tvis.item.mask = TVIF_TEXT;
    tvis.item.pszText = (char *)text;
    node = TreeView_InsertItem( tree, &tvis );
    return node;
} /* km_tv_insert_item */


int
km_groups_new( km_group_t *r_gc, HWND ctrl )
{
    km_group_t gc;
    
    gc = new km_group_s;
    if (!gc)
        BUG (NULL);
    gc->tree = ctrl;
    gc->gh = km_groupdb_open ();
    *r_gc = gc;
    return 0;
} /* km_groups_new */


void
km_groups_sync( km_group_t gc )
{
    char * optfile;

    optfile = get_gnupg_cfgfile ();
    if( !optfile )
        BUG( NULL );
    commit_gpg_options( optfile, gc->gh );
    free_if_alloc( optfile );
    gc->need_sync = 0;
} /* km_groups_sync */


void
km_groups_release (km_group_t gc)
{
    if( gc ) {
        /* xxx: this reset the default key (sync=1) */
        gc->need_sync=0;
        if (gc->need_sync)
            km_groups_sync (gc);
        if (gc->gh)
            release_gpg_options( gc->gh );
        gc->gh = NULL;
        gc->tree = NULL;
        delete gc;
    }    
} /* km_groups_release */


int
km_groups_load( km_group_t gc )
{    
    HTREEITEM n;
    gpg_group_t grp, g;
    gpg_member_t mbr;
    u32 gid = 0; 
    
    if( !gc->gh )
        return 0;
    grp = gc->gh->grp;
    if( !grp )
        return 0; /* no groups */
        
    for( g = grp; g; g = g->next ) {
        n = km_tv_insert_item( gc->tree, NULL, g->name );
        for( mbr = g->list; mbr; mbr = mbr->next ) {
            if( mbr->used && mbr->name )
                km_tv_insert_item( gc->tree, n, mbr->name );
        }
    }
    DragAcceptFiles( gc->tree, TRUE );
    gc->need_sync = 0;
    return 0;
} /* km_groups_load */


int
km_groups_add( km_group_t gc, listview_ctrl_t lv, int km_index )
{
    TVITEM tvi;
    char uid[128], valid[64], text[128];
    int i_valid;
    
    memset( &tvi, 0, sizeof tvi );
    tvi.hItem = TreeView_GetSelection( gc->tree );
    tvi.pszText = text;
    tvi.cchTextMax = sizeof text -1;
    tvi.mask = TVIF_TEXT;
    TreeView_GetItem( gc->tree, &tvi );
    
    
    listview_get_item_text( lv, km_index, 0, uid, sizeof uid -1 );
    listview_get_item_text( lv, km_index, 5, valid, sizeof valid -1 );
    
    if( strstr( valid, "Ultimate" ) )
        i_valid = 5;    
    else if( !strstr( valid, "Full" ) )
        i_valid = 4;
    else if( !strstr( valid, "Marginal" ) )
        i_valid = 3;
    else
        i_valid = 0;
    
    /* we can't add the full name. one way would be to use the first
       text until a space appears. 
    group_add_entry(&gc->gh, gid, i_valid, uid);
    treeview_add_item(gc->tree, tvi.hItem, uid);
    */
    gc->need_sync = 1;
    
    return 0;
} /* km_groups_add */


static int
km_groups_del_main( km_group_t gc )
{
    TVITEM tvi;
    char text[128];
    int id;
    
    memset( &tvi, 0, sizeof tvi );
    tvi.hItem = TreeView_GetSelection( gc->tree );
    tvi.pszText = text;
    tvi.cchTextMax = sizeof text -1;
    tvi.mask = TVIF_TEXT;
    TreeView_GetItem( gc->tree, &tvi );
                             
    id = log_box( _("Key Manager"), MB_INFO_ASK, 
                   _("Do you really want to delete this group?\n\n%s"), text);
    if( id == IDNO )
        return 0;
    delete_group( gc->gh, text );    
    TreeView_DeleteItem( gc->tree, &tvi );
    gc->need_sync = 1;
    
    return 0;
} /* km_groups_del */


static int
km_groups_del_entry( km_group_t gc )
{
    TVITEM tvi;
    HTREEITEM root;
    int id;
    char text[128], info[256];
    gpg_group_t  grp = NULL;
    
    memset( &tvi, 0, sizeof tvi );
    tvi.hItem = TreeView_GetSelection( gc->tree );
    tvi.pszText = text;
    tvi.cchTextMax = sizeof text-1;
    tvi.mask = TVIF_TEXT;
    TreeView_GetItem( gc->tree, &tvi );
    
    _snprintf( info, sizeof info -1,
              _("Do you really want to delete this entry?\n\n%s"), text );
    
    id = msg_box( gc->tree, info, _("Key Manager"), MB_INFO_ASK );
    if( id == IDNO )
        return 0;

    root = TreeView_GetParent( gc->tree, tvi.hItem );
    if( root ) {
    }
    
    delete_member( gc->gh, /*fixme*/NULL, text );
    TreeView_DeleteItem( gc->tree, &tvi );
    gc->need_sync = 1;
    return 0;
} /* km_groups_del_entry */


int
km_groups_del( km_group_t gc )
{
    if ( TreeView_GetParent( gc->tree, TreeView_GetSelection( gc->tree ) ) )
        return km_groups_del_entry( gc );
    else
        return km_groups_del_main( gc );
} /* km_groups_del */
#endif