trunk/Src/wptGPG.cpp

/* wptGPG.cpp - GnuPG configuration
 *      Copyright (C) 2001-2005 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 <string.h>
#include <stdio.h>
#include <shlobj.h>
#include <ctype.h>
#include <io.h>
#include <time.h>

#include "wptGPG.h"
#include "wptGpgCmds.h"
#include "wptGPGOptSkel.h"
#include "wptTypes.h"
#include "wptNLS.h"
#include "wptRegistry.h"
#include "wptErrors.h"
#include "wptW32API.h"
#include "wptCrypto.h"

#define GPG_CONF        "gpg.conf"
#define GPG_REG_EXE     "gpgProgram"    /* registry name for the binary. */
#define GPG_REG_HOME    "HomeDir"       /* registry name of the home dir. */

struct gpg_watcher_s {
    FILETIME    last_access;
    FILETIME    access;
    char        *object;
    int         modified;
};


/* XXX need to watch for gpg.conf due to the fact keyring entries could be changed */
static const char * gpg_objs[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg"};
static gpg_watcher_s gpg_table[3];
static int gpg_table_count = DIM (gpg_table);

int idea_available = 0;

static int check_keyring (char ** r_path);


/* Return the application data folder of the current user. */
char*
multi_gnupg_path (int strict)
{
    static char buf[256+64];
    BOOL ec;

    /* MSDN: buf must be at least MAX_PATH=256 bytes */
    memset (buf, 0, sizeof (buf));
    /* XXX: ec should be NOERROR (MSDN) but NOERROR is defined as '0' !? */
    ec = SHGetSpecialFolderPath (HWND_DESKTOP, buf, CSIDL_APPDATA, TRUE);
    if (ec != 1) {
        log_debug ("multi_gnupg_path: SHGetSpecialFolderPath() failed\r\n",
                   (int)GetLastError ());
        return NULL;
    }
    strcat (buf, "\\gnupg");
    if (strict && access (buf, 00))
        return NULL;
    return m_strdup (buf);
}


/* Return the full path to the GPG home directory. First the 'HomeDir' entry
   from the registry is used. Then the default $APPDATA\gnupg path. */
char*
get_gnupg_path (void)
{
    char *path;

    path = get_reg_entry_gpg (GPG_REG_HOME);
    if (path) {
        if (dir_exist_check (path) == 0)
            return path;
        free_if_alloc (path);
    }
    path = multi_gnupg_path (1);
    return path;
}


/* Return the full path of the gpg config file.
   A value of NULL indicates an error. */
char*
get_gnupg_cfgfile (void)
{    
    char *p = NULL;
    char *optfile = NULL;
    char *path = NULL;
    size_t nlen = 0;

    path = get_gnupg_path ();
    if (!path)
        return NULL;
    p = get_reg_entry_gpg ("OptFile");
    if (p && !strcmp (p, "")) {
        nlen = strlen (path) + 64;
        optfile = new char[nlen + 1];
        if (!optfile)
            BUG (0);
        _snprintf (optfile, nlen, "%s\\"GPG_CONF, path);
    }
    else if (p) {
        nlen = strlen( p ) + 4;
        optfile = new char[nlen + 1];
        if (!optfile)
            BUG (NULL);
        _snprintf (optfile, nlen, "%s", p);
    }
    else {
        nlen = strlen (path) + 64;
        optfile = new char[nlen + 1];
        if( !optfile)
            BUG (NULL);
        _snprintf (optfile, nlen, "%s\\"GPG_CONF, path);
    }
    free_if_alloc (path);
    free_if_alloc (p);
    return optfile;
}


/* Return the full path of the keyring. If @pub is 1, the public
   keyring is return, otherwise the secret keyring. */
char*
get_gnupg_keyring (int pub, int strict)
{    
    char *optfile = NULL;
    char *path = NULL;
    char *keyring = NULL;

    path = get_gnupg_path ();
    if (!path)
        return NULL;
    keyring = make_filename (path, pub? "pubring" : "secring", "gpg");
    if (strict && !file_exist_check (keyring)) {
        free_if_alloc (path);
        return keyring;
    }
    else if (!strict) {
        free_if_alloc (path);
        return keyring;
    }
    if (file_exist_check (keyring) || pub && get_file_size (keyring) == 0) {
        free_if_alloc (keyring);
        optfile = make_filename (path, GPG_CONF, NULL);
        keyring = get_gnupg_keyring_from_options (optfile, pub);
    }
    free_if_alloc (path);
    free_if_alloc (optfile);
    return keyring;
}


/* Return the full path (with the gpg exe name). First the registry is scanned
   for the entry 'gpgProgram'. If it wasn't set, the default path is the
   appended string 'gpg.exe' is used. */

/* FIXME:  Use gpgme's engine info here. */
char*
get_gnupg_prog (void)
{    
    char *p;
    char *pgm = NULL;

    p = get_reg_entry_gpg (GPG_REG_EXE);
    if (!p) {
        char *path = get_gnupg_path ();
        if (!path)
            return NULL;
        pgm = make_filename (path, "gpg", "exe");
        free_if_alloc (path);
    }
    else {
        pgm = m_strdup (p);
        free_if_alloc (p);
    }
    return pgm;
}


/* Retrieve the first usable secret key from cache.
   If no usable was found, @ret_no_useable is 1. 
   Return value: the keyid of the secret key. */
static char *
default_key_from_cache (int *ret_no_useable)
{
    const char *s;
    char *keyid = NULL;
    gpgme_key_t key;
    gpg_keycache_t sec = keycache_get_ctx (0);

    if (!sec)
        BUG (0);
    gpg_keycache_rewind (sec);
    while (!gpg_keycache_next_key (sec, 1, &key)) {
        if (key_is_useable (key)) {
            s = key->subkeys->keyid;
            if (s)    
                keyid = m_strdup (s+8); 
            break;
        }
    }
    if (!keyid)
        *ret_no_useable = 1;
    return keyid;
}


/* Load the gpg.conf and search for some options
   and store the result in the global preference context.
   Return value: 0 on success. */
int
gnupg_load_config (void)
{
    int rc;
    gpg_optfile_t opt;
    gpg_option_t o;
    char *conf = get_gnupg_cfgfile ();
    if (!conf)
        return -1;
    rc = parse_gpg_options (conf, &opt);
    if (rc) {
        free_if_alloc (conf);
        return -1;
    }
    o = find_option (opt, "ask-cert-level");
    if (o)
        reg_prefs.gpg.ask_cert_level = 1;
    release_gpg_options (opt);
    free_if_alloc (conf);
    return 0;
}


char*
get_gnupg_default_key (void)
{    
    gpg_optfile_t opt = NULL;
    gpg_option_t e;
    char * keyid = NULL, * optfile = NULL;
    int no_usable=0, rc = 0;

    optfile = get_gnupg_cfgfile ();
    if (!optfile)
        return default_key_from_cache (&no_usable);
    rc = parse_gpg_options (optfile, &opt);
    if (rc) {
        free_if_alloc (optfile);
        return default_key_from_cache (&no_usable);
    }
    e = find_option( opt, "default-key" );
    if ( e )
        keyid = m_strdup( e->val );
    if( !e ) {
        e = find_option( opt, "local-user" );
        if( e )
            keyid = m_strdup( e->val );
    }
    if( !e ) {
        e = find_option( opt, "encrypt-to" );
        if( e )
            keyid = m_strdup( e->val );
    }
    free_if_alloc (optfile);
    release_gpg_options (opt);

    if (!keyid)
        keyid = default_key_from_cache (&no_usable);
    return keyid;
} /* get_gnupg_default_key */


/* Check if GPG4WIN is available and if so, use the
   install path to figure out where the gpg.exe is. */
char*
check_for_gpg4win (void)
{
    return get_reg_entry_gpg4win ("gpg.exe");
}


/* Check if the gpg application (exe file) is available. */
int
check_gnupg_prog (void)
{
    char *gpgexe = NULL;
    int rc = 0;

    gpgexe = get_gnupg_prog ();
    if (!gpgexe || file_exist_check (gpgexe)) {
        free_if_alloc (gpgexe);
        gpgexe = check_for_gpg4win ();
        if (!gpgexe || file_exist_check (gpgexe))
            rc = WPTERR_GPG_EXEFILE;
        else
            set_reg_entry_gpg (GPG_REG_EXE, gpgexe);
    }
    free_if_alloc (gpgexe);
    return rc;
}


static int
parse_version_nr (const char *buf, int *major, int *minor, int *patch)
{
    char tmp[8];
    int i;
    
    i=0;
    while (buf && *buf != '.' && i < 8)
        tmp[i++] = *buf++;
    tmp[i] = 0; buf++;
    *major = atol( tmp );
    i=0;
    while (buf && *buf != '.' && i < 8)
        tmp[i++] = *buf++;
    tmp[i] = 0; buf++;
    *minor = atol (tmp);
    i=0;
    while (buf && isdigit (*buf) && i < 8)
        tmp[i++] = *buf++;
    tmp[i] = 0;
    *patch = atol (tmp);
    return 0;
}


/* Check if the gnupg engine fullfills the minimum requirement
   version given in @r_major.@r_minor.@r_patch. On success these
   variables contain the GPG version which is installed. */
int
check_gnupg_engine (const char *need_gpg_ver,
                    int *r_major, int *r_minor, int *r_patch)
{
    gpgme_ctx_t ctx;
    gpgme_engine_info_t inf;
    char *eng = NULL;
    int major=0, minor=0, patch=0;
    int need_major = 0, need_minor = 0, need_patch = 0;
    int rc = 1;

    /* Convert the needed GPG version to the integer format. */
    rc = parse_version_nr (need_gpg_ver, 
                           &need_major, &need_minor, &need_patch);
    if (rc)
        return rc;
    
    gpgme_new (&ctx);
    inf = gpgme_ctx_get_engine_info (ctx);
    if (!inf) {
        gpgme_release (ctx);
        return -1;
    }

    /* We need to exec GPG again to find out if IDEA is available. */
    if (gpg_get_version (&eng))
        return -1;
    if (strstr (eng, "IDEA"))
        idea_available = 1;
    free (eng);
    rc = parse_version_nr (inf->version, &major, &minor, &patch);
    if (rc) {
        gpgme_release (ctx);
        return rc;
    }

    if (major > need_major)
        rc = 0;
    else if (major == need_major && minor > need_minor)      
        rc = 0;
    else if (major == need_major && minor == need_minor &&
             patch >= need_patch)
        rc = 0;

    /* Return the current GPG version. */
    *r_major = major;
    *r_minor = minor;
    *r_patch = patch;
    return rc;
}


int
check_gnupg_cfgfile (const char *fname, int *r_secrings, int *r_pubrings)
{
    gpg_optfile_t opt;    
    gpg_option_t e;
    int rc = 0;

    *r_secrings = 0;
    *r_pubrings = 0;
    rc = parse_gpg_options( fname, &opt );
    if( rc )
        return WPTERR_FILE_OPEN;

    for( e = opt->list; e; e = e->next ) {
        if( !strcmp( e->name, "secret-keyring" ) ) {
            if( !file_exist_check( e->val ) )
                r_secrings[0]++;
        }
        else if( !strcmp( e->name, "keyring" ) ) {
            if( !file_exist_check( e->val ) )
                r_pubrings[0]++;
        }
    }
    release_gpg_options( opt );
    return 0;
} /* check_gnupg_cfgfile */


/* Usually GPG creates the pubring.gpg, secring.gpg on
   the first start, but to make sure they always exist
   create them empty if needed. */
static void
create_empty_keyring (int _pub)
{
    char *name;
    FILE *f;

    name = get_gnupg_keyring (_pub, 0);
    if (file_exist_check (name) != 0) {
        f = fopen (name, "ab");
        if (f != NULL)
            fclose (f);
    }
    free_if_alloc (name);
}


/* Check if both keyrings are located in the gnupg home directory. */
int
gnupg_access_files (void)
{
    int rc = 0;
    int pubring_ok = 0, secring_ok = 0;
    int secrings = 0, pubrings = 0;
    char *optfile;

    create_empty_keyring (1);
    if (gnupg_access_keyring (1))
        rc = WPTERR_GPG_KEYRINGS;
    else
        pubring_ok = 1;

    create_empty_keyring (0);
    if (gnupg_access_keyring (0))
        rc = WPTERR_GPG_KEYRINGS;
    else
        secring_ok = 1;

    if (!pubring_ok || !secring_ok) {
        optfile = get_gnupg_cfgfile ();
        if (!optfile)
            return WPTERR_GPG_KEYRINGS;
        rc = file_exist_check (optfile);
        if (!rc && get_file_size (optfile) > 0) {
            rc = check_gnupg_cfgfile (optfile, &secrings, &pubrings);
            if (!rc && secrings && pubrings) {
                free_if_alloc (optfile);
                return 0; /* found two keyrings in the option file */
            }
            else if ((!rc && pubrings && secring_ok) 
                  || (!rc && secrings && pubring_ok)) {
                free_if_alloc (optfile);
                return 0; /* found one keyring and one entry in the options file */
            }
            else
                return WPTERR_GPG_OPT_KEYRINGS;
        }
        free_if_alloc (optfile);
        rc = WPTERR_GPG_KEYRINGS;
    }
    return rc;
}


static int
create_gpg_options (void)
{
    FILE *fp;
    char *s, *optfile;

    s = get_gnupg_path ();
    if( s == NULL )
        return WPTERR_FILE_CREAT;
    optfile = make_filename (s, GPG_CONF, NULL);
    fp = fopen (optfile, "wb");
    if (fp == NULL) {   
        return WPTERR_FILE_CREAT;
        goto fail;
    }
    fwrite (options_skel, 1, strlen (options_skel), fp);
    fclose (fp);

fail:
    free_if_alloc (s);
    free_if_alloc (optfile);
    return 0;
} /* create_gpg_options */


/*
 * Return the contents of the options file as a char buf.
 */
char *
get_gnupg_config (void)
{
    FILE * fp;
    char * p = NULL, * optfile = NULL;
    int fsize, rc = 0;
        
    optfile = get_gnupg_cfgfile ();
    if( optfile == NULL )
        return NULL;
    fsize = get_file_size( optfile );
    if( !fsize ) {
        rc = create_gpg_options( );
        if ( rc )
            return NULL;
        fsize = get_file_size( optfile );
    }
    if( fsize > 100000 )
        goto leave; /* too large */
    p = new char[fsize+1];
    if( p == NULL )
        BUG( NULL );
    fp = fopen( optfile, "rb" );
    if( fp == NULL ) {
        free_if_alloc( p );
        return NULL;
    }
    fread( p, 1, fsize, fp );
    fclose( fp );
    p[fsize] = '\0';
    free_if_alloc( optfile );

leave:
    return p;
} /* get_gnupg_config */


int
set_gnupg_default_key (const char * key)
{
    gpg_optfile_t opt;
    gpg_option_t e;
    char *optfile = NULL;
    int rc = 0;

    optfile = get_gnupg_cfgfile ();
    if (!optfile)
        return -1;
    rc = parse_gpg_options (optfile, &opt);
    if( rc ) {
        free_if_alloc (optfile);
        return -1;
    }
    e = find_option (opt, "default-key");
    if (e) {
        free_if_alloc (e->val);
        e->val = m_strdup (key);
        e->used = 1;
    }
    else
        add_entry (opt, ENTRY_MULTI, "default-key", key);
    rc = commit_gpg_options (optfile, opt);

    free_if_alloc (optfile);
    release_gpg_options (opt);

    return rc;
} /* set_gnupg_default_key */


/*
 * Set the contents of the options file.
 */
int
set_gnupg_options( const char *buf, size_t buflen )
{
    FILE *fp;   
    char *optfile = NULL;

    optfile = get_gnupg_cfgfile( );
    if( optfile == NULL )
        return WPTERR_FILE_CREAT;

    fp = fopen( optfile, "wb" );
    if( fp == NULL ) {
        free_if_alloc( optfile );
        return WPTERR_FILE_CREAT;
    }
    fwrite( buf, 1, buflen, fp );
    fclose( fp );
    free_if_alloc( optfile );
    return 0;
} /* set_gnupg_options */

/*
 * Check if the line contains a valid GPG argument.
 */
static int
check_line( const char *buf )
{
    int j, len;
    int rc = 0;

    if( *buf == '#' || *buf == '\r' || *buf == '\n' )
        return 1;
    rc = 0;
    for ( j = 0; valid_gpg_args[j]; j++ ) {
        len = strlen( valid_gpg_args[j] );
        if( !strncmp( valid_gpg_args[j], buf, len ) )
            rc = 1;     
    }

    return rc;
} /* check_line */


int
check_gnupg_options( const char *buf )
{
    char line[1024];
    int nbytes = 0;
    unsigned j;
        
    for ( j = 0; j<strlen( buf ) && j < sizeof(line); j++ ) {
        line[nbytes++] = buf[j];
        if ( buf[j] == '\n' || j == ( strlen( buf ) - 1 ) ) {
            line[nbytes] = '\0';
            if( !check_line( line ) ) {
                msg_box( NULL, line, "options", MB_OK );
                return 1;       
            }
            nbytes = 0;
        }       
    }

    return 0;
} /* check_gnupg_options */


/* Store the last access of the file inside the watcher @ctx. */
static int
get_last_gnupg_access (gpg_watcher_s *ctx)
{
    HANDLE fd;
    char *path;
    char *file;

    path = get_gnupg_path ();
    file =  make_filename (path, ctx->object, NULL);
    fd = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, NULL);
    if (fd == INVALID_HANDLE_VALUE) {
        free_if_alloc (path);
        free_if_alloc (file);
        return WPTERR_FILE_OPEN;
    }
    GetFileTime (fd, NULL, NULL, &ctx->access);
    CloseHandle (fd);
    free_if_alloc (path);
    free_if_alloc (file);
    return 0;
}


/* Check if the file inside watcher @ctx was modified. */
static void
check_last_gnupg_access (gpg_watcher_s *ctx)
{               
    ctx->modified = 0;

    if (ctx->last_access.dwHighDateTime != ctx->access.dwHighDateTime &&
        ctx->last_access.dwLowDateTime != ctx->access.dwLowDateTime)
        ctx->modified = 1;
    
    /* XXX: find a better way. without it, winpt --keymanager loads
            the key cache twice. */
    if (ctx->last_access.dwLowDateTime == 0)
        ctx->modified = 0;

    ctx->last_access.dwLowDateTime = ctx->access.dwLowDateTime;
    ctx->last_access.dwHighDateTime = ctx->access.dwHighDateTime;
}


/* Init GPG watcher table for all monitored files. */
void
init_gnupg_table (void)
{       
    char *p;
    int j;

    for (j = 0; j < gpg_table_count; j++) {
        p = gpg_table[j].object = m_strdup (gpg_objs[j]);
        if (!p)
            BUG (NULL);
        memset (&gpg_table[j].access, 0, sizeof (FILETIME));
        memset (&gpg_table[j].last_access, 0, sizeof (FILETIME));
        gpg_table[j].modified = 0;
    }
}


void
free_gnupg_table (void)
{
    int j;

    for (j=0; j < gpg_table_count; j++)
        free_if_alloc (gpg_table[j].object);
}


/* Return the amount of files modified since the last call. */
int
keyring_check_last_access (void)
{       
    int rc, j;

    rc = 0;
    for (j = 0; j < gpg_table_count; j++) {
        get_last_gnupg_access (&gpg_table[j]);
        check_last_gnupg_access (&gpg_table[j]);
        if (gpg_table[j].modified)
            rc++;       
    }

    return rc;
}


const char*
gnupg_check_file_ext (const char *fname, int *r_type)
{               
    char file_ext[5];

    if (r_type) 
        *r_type = PGP_NONE;
    if (!strchr (fname, '.' ))
        return "UNKNOWN";

    strncpy (file_ext, fname + strlen (fname) - 4, 4);
    file_ext[4] = '\0';
    if (!stricmp (file_ext, ".asc"))
        return "ARMORED";
    else if (!stricmp (file_ext, ".sig")) {
        if (r_type) 
            *r_type = PGP_SIG;
        return "SIGNED";
    }
    else if  (!stricmp (file_ext, ".gpg") || !stricmp (file_ext, ".pgp")) {
        if (r_type) 
            *r_type = PGP_MESSAGE;
        return "ENCRYPTED";
    }
    return "UNKNOWN";
}


char*
get_gnupg_keyring_from_options (const char * fname, int pub)
{
    gpg_optfile_t opt;
    gpg_option_t e;
    char * kring = NULL;
    int rc = 0;

    rc = parse_gpg_options (fname, &opt);
    if (rc)
        return NULL;
    if (pub)
        e = find_option (opt, "keyring");
    else
        e = find_option (opt, "secret-keyring");
    if (e)
        kring = m_strdup (e->val);
    release_gpg_options (opt);

    return kring;
}


/* XXX: does not work with write-protected floppies */
static int
my_access (const char *fname)
{
    HANDLE hd;
    hd = CreateFile (fname, GENERIC_WRITE, FILE_SHARE_WRITE, 
                     NULL, OPEN_EXISTING, 0, NULL);
    if (hd == INVALID_HANDLE_VALUE)
        return -1;
    CloseHandle (hd);
    return 0;
}


/* Check the file permissions of the public keyring.
   If @showmsg is 1 output a message in case of errors.
   Return value: 1 if read-only attribute
                 2 if file is opened by another process exclusively. */
int
gpg_check_permissions (int showmsg)
{
    char *p = NULL;
    char *name = NULL;
    int failed = 0, ans=0, attrs=0;

    p = get_gnupg_path ();
    if (check_keyring (&p) && p) {
        name = make_filename (p, "pubring", "gpg");
        if ((attrs=GetFileAttributes (name)) & FILE_ATTRIBUTE_READONLY) {
            ans = msg_box (NULL, 
                           _("The selected keyring has the read-only file\n"
                             "attribute. In this state you do not have write\n"
                             "access. Do you want to remove the attribute?"),
                     _("GPG Information"), MB_YESNO);
            if (ans == IDYES) {
                attrs &= ~FILE_ATTRIBUTE_READONLY;
                if (!SetFileAttributes (name, attrs)) {
                    msg_box (NULL, _("Could not reset read-only state."), 
                             _("GPG Error"), MB_ERR);
                    failed = 1;
                }
            }
            else if (ans == IDNO) {
                /* All commands with write access will be disabled. */
                failed = 1;
            }
        }
        if (my_access (name)) {
            if (showmsg)
                msg_box (NULL, 
                _("You do not have file access to modify the contents of\n"
                  "one or both of the selected keyrings.\n"
                  "\n"
                  "The keyrings are in a read-only state which is propably\n"
                  "caused by another program which already opened the files.\n"),
                   _("GPG Warning"), MB_WARN);
            failed = 2;
        }
    }
    free_if_alloc (p);
    free_if_alloc (name);
    return failed;
}


/* Check the GPG home dir. First try to read the 'HomeDir' registry entry, 
   then check for $APPDATA\gnupg. Create the dir if it does not exists. */
int
gnupg_check_homedir (void)
{       
    char *homedir = NULL;
    int val = 0;
    int rc = 0;

    homedir = get_reg_entry_gpg (GPG_REG_HOME);
    if (!homedir)
        homedir = multi_gnupg_path (0);
    if (homedir) {
        if (GetFileAttributes (homedir) == 0xFFFFFFFF) {
            val = log_box (_("Preferences"), MB_YESNO,
                           _("%s does not exit.\n"
                             "Do you want to create this directory?"), homedir);
            if (val == IDYES) {
                if (!CreateDirectory (homedir, NULL))
                    rc = WPTERR_DIR_CREAT;
            }
            else
                rc = WPTERR_DIR_OPEN;
        }
        free_if_alloc (homedir);
    }
    return rc;
}


int
gnupg_copy_keyrings (void)
{
    const char * pring, * sring;
    char * file = NULL, * path = NULL;
    int id = 0, rc = 0;
    HWND hwnd;
    
    path = get_gnupg_path ();
    if (!path)
        return WPTERR_GENERAL;
    hwnd = GetDesktopWindow ();

    pring = get_fileopen_dlg (hwnd, _("Please choose your public keyring"),
                              _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),NULL);
    if (!pring) {
        msg_box (hwnd, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR);
        free_if_alloc (path);
        return WPTERR_GENERAL;
    }
    file = make_filename (path, "pubring", "gpg");
    if (file_exist_check (file) == 0) {
        id = msg_box (hwnd, _("Overwrite old public keyring?"), "WinPT", MB_INFO|MB_YESNO);
        if (id == IDNO)
            goto fail;
    }
    if (!CopyFile (pring, file, FALSE)) {
        msg_box (hwnd, _("Could not copy file."), _("WinPT Error"), MB_ERR);
        rc = WPTERR_FILE_READ;
        goto fail;
    }
    free_if_alloc (file);

    sring = get_fileopen_dlg (hwnd, _("Please choose your secret keyring"),
                              _("GPG Keyrings (*.gpg)\0*.gpg\0\0"), NULL);
    if (!sring) {
        msg_box( NULL, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR );
        return WPTERR_GENERAL;
    }
    file = make_filename (path, "secring", "gpg");
    if (file_exist_check (file) == 0) {
        id = msg_box (hwnd, _("Overwrite old secret keyring?"), "WinPT", MB_INFO|MB_YESNO);
        if( id == IDNO )
            goto fail;
    }
    if (!CopyFile (sring, file, FALSE)) {
        msg_box( NULL, _("Could not copy file."), _("WinPT Error"), MB_ERR);
        rc = WPTERR_FILE_READ;
    }

fail:
    free_if_alloc (file);
    free_if_alloc (path);
    return rc;
} /* gnupg_import_keyrings */


/* Backup the gpg.conf file. */
void
gnupg_backup_options (void)
{
    char *cfgfile = NULL;
    char bak[512];

    cfgfile = get_gnupg_cfgfile ();
    if (!cfgfile)
        return;
    _snprintf (bak, DIM (bak)-1, "%s.bak", cfgfile);
    CopyFile (cfgfile, bak, FALSE);
    free_if_alloc (cfgfile);
}


static int
backup_one_file (const char *srcpath, const char *srcn,
                 const char *dstpath, const char *dstn)
{
    char * src, * dst;
    BOOL rc;

    src = make_filename (srcpath, srcn, "gpg");
    if (!src)
        BUG (NULL);
    dst = make_filename (dstpath, dstn, "gpg");
    if (!dst)
        BUG (NULL);
    rc = CopyFile (src, dst, FALSE);
    free_if_alloc (src);
    free_if_alloc (dst);
    if (!rc)
    {
        log_box (_("Backup"), MB_ERR, _("Backup keyring \"%s\" failed"), srcn);
        return WPTERR_GENERAL;
    }
    return 0;
} /* backup_one_file */


/* Figure out first public keyring which is not empty.
   Return value: 1 on success. */
static int
check_keyring (char **r_path)
{
    char *p;
    char *opt;
    char *name;

    if (!*r_path)
        return 0;
    p = make_filename (*r_path, "pubring", "gpg");
    if (!p || get_file_size (p) <= 0)
        return 0;

    opt = get_gnupg_cfgfile ();
    if (!opt)
        BUG (0);
    name = get_gnupg_keyring_from_options (opt, 1);
    free_if_alloc (opt);
    free_if_alloc (p);
    if (!name)
        return 0;
    p = strrchr (name, '\\');
    if (!p) {
        free_if_alloc (name);
        return 0;       
    }
    free_if_alloc (*r_path);
    *r_path = new char [strlen (name)+1];
    memset (*r_path, 0, strlen (name));
    strncpy (*r_path, name, (p-name));
    free_if_alloc (name);
    return 1;
}


/* Return a temp name based on the day of the week. */
static char*
get_backup_name (const char *templ)
{
    struct tm *tm;
    char *p;
    time_t t;

    t = time (NULL);
    tm = localtime (&t);
    p = new char [strlen (templ) + 8 + 1];
    if (!p)
        BUG (0);
    sprintf (p, "%s-%d", templ, tm->tm_wday % 3);
    return p;
}


/* Make backups of all keyrings. The public key ring is
   rotated like this pubring-%d.gpg. */
void
gnupg_backup_keyrings (void)
{
    char *srcpath = NULL, *dstpath = NULL;
    char *name=NULL;
    int rc, bakmode=0;

    if (!reg_prefs.auto_backup)
        return;
    bakmode = reg_prefs.backup.mode;
    srcpath = get_gnupg_path ();
    check_keyring (&srcpath);
    if (bakmode == 1) {
        dstpath = multi_gnupg_path (1);
        check_keyring (&dstpath);
    }
    else if (bakmode == 2) {
        char *tmpfile;
        FILE *fp;

        dstpath = m_strdup (reg_prefs.backup.path);
        if (!dstpath)
            BUG (0);
        tmpfile = make_filename (reg_prefs.backup.path, "test", "tmp");
        fp = fopen (tmpfile, "wb");
        if (!fp)
            rc = log_box (_("Backup"), MB_WARN|MB_RETRYCANCEL,
                          _("The backup drive '%s' does not seems to accessable.\n"
                            "Please insert/check the drive to continue."), dstpath);
        else {
            rc = 0;
            fclose (fp);
            remove (tmpfile);
        }
        free_if_alloc (tmpfile);
        if (!fp || rc == IDCANCEL)
            return;
    }
    else {
        log_box (_("Backup"), MB_ERR, _("Invalid backup mode %d"), bakmode);
        return;
    }
    name = get_backup_name ("pubring-bak");
    rc = backup_one_file (srcpath, "pubring", dstpath, name);
    if (!rc)
        rc = backup_one_file (srcpath, "secring", dstpath, "secring-bak");
    free_if_alloc (name);
    free_if_alloc (srcpath);
    free_if_alloc (dstpath);
}


/* Display GPG error from file if possible. */
void
gnupg_display_error (void)
{       
    char tmpath[512], * errstr;
    size_t size = 0;
    FILE * fp;

    GetTempPath (sizeof tmpath - 32, (tmpath));
    strcat (tmpath, "gpg_stderr");
    size = get_file_size (tmpath);
    if (file_exist_check (tmpath) || size <= 0)
        return;
    fp = fopen( tmpath, "rb" );
    if (!fp) {
        msg_box (NULL, _("No GPG error description available."),
                 _("GPG Error"), MB_INFO);
        return;
    }
    errstr = new char[size+1];
    if (!errstr)
        BUG (0);
    fread (errstr, 1, size, fp);
    errstr[size] = '\0';
    fclose (fp);
    msg_box (NULL, errstr, _("GPG Error"), MB_INFO);
    free_if_alloc (errstr);
}


/* check that the requested GPG keyring exist and.
   Return value: 0 for success. */
int
gnupg_access_keyring (int _pub)
{
    int rc = 0;
    char *name = get_gnupg_keyring (_pub, 1);
    if (!name || file_exist_check (name))
        rc = -1;
    free_if_alloc (name);
    return rc;
}