trunk/Src/wptGPG.cpp

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

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. */
static char*
multi_gnupg_path (void)
{
    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)
        return NULL;
    strcat (buf, "\\gnupg");
    if (access (buf, 00))
        return NULL;
    return m_strdup (buf);
}


/* Return the full path of the GnuPG application. First the registry is scanned
   for the entry 'HomeDir'. If it wasn't set, the default dir C:\GNUPG is used. 
*/
char*
get_gnupg_path (void)
{
    char *p = NULL, *path = NULL;
    
    p = get_reg_entry_gpg ("HomeDir");
    if (p) {
        path = m_strdup (p);
        free_if_alloc (p);
        return path;
    }
    else
        return multi_gnupg_path ();
    return m_strdup ("c:\\gnupg");
}


/* Return the full path of the gpg config file.
   A value of NULL indicates an error. */
char*
get_gnupg_cfgfile (void)
{    
    char *p = NULL, *optfile = NULL, *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;
    }
    if (file_exist_check (keyring) || 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. */
char*
get_gnupg_prog (void)
{    
    char *p;
    char *pgm = NULL;
    size_t nlen = 0;

    p = get_reg_entry_gpg ("gpgProgram");
    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;
        msg_box (NULL, _("No useable secret key found."), _("GPG Error"), MB_ERR);
    }
    return keyid;
}


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 the gpg application (exe file) is available. */
int
check_gnupg_prog (void)
{
    char *pgm = NULL;
    int rc = 0;

    pgm = get_gnupg_prog ();
    if (!pgm)
        rc = WPTERR_GPG_EXEFILE;
    if (file_exist_check (pgm))
        rc = WPTERR_GPG_EXEFILE;
    free_if_alloc (pgm);
    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 (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 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 < *r_major || minor < *r_minor)
        rc = 1;
    else {
        if (patch < *r_patch)
            rc = 1;
        rc = 0;
    }
    *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 */


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

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

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


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;

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


int
gpg_check_permissions (int showmsg)
{
    char * p, * name = NULL;
    int failed = 0, ans=0, attrs=0;

    p = get_gnupg_path ();
    check_keyring (&p);
    if (p) {
        name = make_filename (p, "pubring", "gpg");
        free_if_alloc (p);
        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) {
                /*
                msg_box (NULL, _("All commands with write access to the keyring\n"
                                 "will be disabled."), _("GPG Information"), MB_INFO);
                */
                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 (name);
    return failed;
} /* gpg_check_permissions */


/* Check the GPG home dir. If all methods failed, try to
   create the default folder. */
static int
check_homedir (void)
{       
    char *homedir = NULL;
    int yes = 0;

    homedir = get_reg_entry_gpg ("HomeDir");
    if (!homedir)
        homedir = multi_gnupg_path ();
    if (!homedir)
        homedir = m_strdup ("c:\\gnupg");
    if (homedir) {
        if (GetFileAttributes (homedir) == 0xFFFFFFFF) {
            yes = log_box (_("Preferences"), MB_YESNO,
                           _("%s does not exit.\n"
                             "Do you want to create this directory?"), homedir);
            if (yes == IDYES) {
                BOOL ec = CreateDirectory (homedir, NULL);
                free_if_alloc (homedir);
                if (ec == FALSE)
                    return WPTERR_DIR_CREAT;
                return 0;
            }
            return WPTERR_DIR_OPEN;
        }
        free_if_alloc (homedir);
    }
    return 0;
}


int
gnupg_check_homedir (void)
{       
    char *homedir = NULL;
    char *prog = NULL;
    int rc = 0, ec = 0;
    
    rc = check_homedir ();
    if (rc)
        return rc;
    if ((homedir = get_reg_entry_gpg ("HomeDir")) &&
        !(prog = get_reg_entry_gpg ("gpgProgram" ))) {
        prog = make_filename (homedir, "gpg", "exe");
        if (file_exist_check (prog) == 0) {
            rc = set_reg_entry_gpg ("gpgProgram", prog);
            if (rc)
                goto fail;
        }
        free_if_alloc (homedir);
        free_if_alloc (prog);
        return rc;
    }
    if ((prog = get_reg_entry_gpg ("gpgProgram"))
        && file_exist_check (prog)) {
        free_if_alloc (prog);
        homedir = get_reg_entry_gpg ("HomeDir");
        if (!homedir) {
            rc = WPTERR_GENERAL;
            goto fail;
        }
        prog = make_filename (homedir, "gpg", "exe");
        if (file_exist_check (prog) == 0) {
            rc = set_reg_entry_gpg ("gpgProgram", prog);
            if (rc)
                goto fail;
            free_if_alloc (prog);
            return rc;
        }
    }
    
    /* Change the return code if homedir doesn't exist or if the program 
       doesn't exist. Note that exist_checks return 0 to suggest existance. */
    if ((!homedir || dir_exist_check (homedir)))
        rc = WPTERR_GENERAL;
    
fail:
    free_if_alloc (homedir);
    free_if_alloc (prog);
    return rc;
} /* gnupg_check_homedir */


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_filename_dlg (hwnd, FILE_OPEN, _("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_filename_dlg (hwnd, FILE_OPEN, _("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 */


void
gnupg_backup_options (void)
{
    char *cfgfile = NULL;
    char bak[512];

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


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


static int
check_keyring (char ** r_path)
{
    char * p;
    char * opt, * 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;
}


static char*
get_backup_name (const char *templ)
{
    struct tm *tm;
    char *p;

    time_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;
}


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 = get_gnupg_path ();
        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);
            unlink (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);
} /* gnupg_backup_keyrings */


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