trunk/Src/wptRegistry.cpp

/* wptRegistry.cpp - W32 Registry access
 *      Copyright (C) 2000-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 <stdio.h>

#include "wptErrors.h"
#include "wptW32API.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptKeyserver.h"
#include "wptTypes.h"
#include "wptNLS.h"
#include "wptVersion.h"

#define rc_ok(rc) ((rc) == ERROR_SUCCESS)


struct reg_hotkey_s reg_hotkeys[] = {
    {"ClipEncrypt", "", 0},
    {"ClipDecrypt", "", 0},
    {"ClipSign",    "", 0},
    {"ClipSignEnc", "", 0},
    {"CwsEncrypt",  "", 0},
    {"CwsDecrypt",  "", 0},
    {"CwsSign",     "", 0},
    {"CwsSignEnc",  "", 0},
    {NULL, "", 0}
};

winpt_reg_prefs_s reg_prefs;

#define WINPT_REG "Software\\WinPT"


/* Return != 0 if GPG4win is installed. */
int
is_gpg4win_installed (void)
{
    char *p;

    p = get_reg_entry_gpg4win (NULL);
    if (!p)
        return 0;
    if (dir_exist_check (p)) {
        free_if_alloc (p);
        return 0;
    }
    free_if_alloc (p);
    return -1;
}


/* Return != 0 if GPGee is installed. */
int
is_gpgee_installed (void)
{
    HKEY hk;
    LONG ec;

    ec = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\GPGee", 0, KEY_READ, &hk);
    if (ec == ERROR_SUCCESS) {
        RegCloseKey (hk);
        return -1;
    }

    return 0;
}


/* Free all members in the registry preference struct. */
void
free_reg_prefs (void)
{
    free_if_alloc (reg_prefs.backup.path);
    free_if_alloc (reg_prefs.kserv_conf);
    free_if_alloc (reg_prefs.homedir);
    memset (&reg_prefs, 0, sizeof reg_prefs);
}


/* Register the given WinPT filetype. */
static int
regist_single_filetype (gpg_filetype *gfile)
{
    char icon[256];
    char prog[256];
    
    memset (&icon, 0, sizeof (icon));
    GetModuleFileName (glob_hinst, prog, sizeof (prog)-1);
    _snprintf (icon, sizeof (icon) -1, "%s,%d", prog, gfile->nicon);
    return create_file_type (prog, gfile->ext, gfile->descr, icon);
}


/* Install the GPG related into the W32 resgistry, if the entry already
   exists the function returns immediately. */
int
regist_inst_gnupg (int create_mokey)
{
    int rc;
    HKEY reg;

    rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", 0, KEY_READ, &reg );  
    if( rc_ok( rc ) ) {
        RegCloseKey( reg );
        return 0;       
    }
    rc = RegCreateKey( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", &reg );
    if( !rc_ok( rc ) )          
        return WPTERR_REGISTRY; 
    RegCloseKey( reg );
    if( create_mokey ) {
        rc = RegOpenKeyEx( HKEY_CURRENT_USER,  "Control Panel\\MingW32\\NLS", 0, KEY_READ, &reg );
        if( rc_ok( rc ) ) {
            RegCloseKey( reg );
            return 0;   
        }
        rc = RegCreateKey( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", &reg );
        if( !rc_ok( rc ) )
            return WPTERR_REGISTRY;     
        RegCloseKey( reg );
    }

    return 0;
}


/* Install WinPT into the W32 registry, if the entry already 
   exists the function returns immediately. @with_ext can be
   used to register some file types (if 1). @created contains
   1 if the registry key was created.
   Return value: 0 on success. */
int
regist_inst_winpt (int with_ext, int *created)
{    
    HKEY reg;
    char *p = NULL;
    char modpath[MAX_PATH+1];
    int rc, i, id, n = 0;

    gpg_filetype gpg_filetypes[] = {
        {_("GPG Detached Signature"), ".sig", 1},
        {_("GPG Encrypted Data"),     ".gpg", 2},
        {_("GPG Armored Data"),       ".asc", 2},
        {0}
    };

    if (created)
        *created = 0;

    p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions");
    if ((p && *p == '1') || is_gpgee_installed ())
        with_ext = 0;
    free_if_alloc (p);

    if (with_ext) {
        id = msg_box (NULL, _("WinPT can register some GPG file types for you so they can "
                              "be processed with a double click in the explorer.\n"
                              "Do you want to continue?"), _("WinPT"), MB_YESNO|MB_INFO);
        if (id == IDNO) {
            set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");
            goto start;
        }
        for (i = 0; gpg_filetypes[i].ext; i++) {
            rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);
            if (rc_ok (rc)) {
                RegCloseKey (reg);
                id = log_box (_("WinPT WARNING"), MB_YESNO|MB_INFO, 
                              _("It seems there was already a '%s' file type registered by another application.\n"
                                "Do you want to overwrite it?"), gpg_filetypes[i].ext);
                if (id == IDNO)
                    continue;
            }
            regist_single_filetype (&gpg_filetypes[i]);
            n++;
        }
    }
        
start:
    rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);
    if (rc_ok (rc)) {
        RegCloseKey (reg);
        rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg);
        if( !rc_ok (rc)) {
            RegCreateKey (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg);
            RegCloseKey (reg);
        }
        p = get_reg_entry_keyserver ("Default");
        if (!p) {
            char buf[16];
            sprintf (buf, "%d", HKP_PORT);
            set_reg_entry_keyserver ("Default_Port", buf);
            set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
        }
        free_if_alloc (p);
        if (n)
            set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );
        return 0;
    }
    rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
    if (!rc_ok (rc))
        return WPTERR_REGISTRY;
    if (created)
        *created = 1;
    RegCloseKey (reg);
    if (n > 0 || is_gpgee_installed ())
        set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");
    if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
        while (n-- > 0) {
            if (modpath[n] == '\\') {
                modpath[n] = 0;
                break;
            }
        }
        set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Install Directory", modpath);
    }
    return 0;
}


/* Create a new filetype in the W32 registry.
   We should really care of errors! Otherwise we can damage the registry! */
int
create_file_type (const char *exefile, const char *ext, 
                  const char *extname, char *iconfile)
{
    int rc;
    HKEY reg = NULL;
    char deficon[256], defexec[256], p_exefile[256];
    
    
    rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );
    if( rc_ok( rc ) ) 
        rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)extname, strlen( extname ) );
    if( rc_ok( rc ) )
        rc = RegCloseKey( reg );
    if( rc_ok( rc ) )    
        rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );
    if( rc_ok( rc ) )
        rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *) extname, strlen( extname ) );
    if( rc_ok( rc ) )
        rc = RegCloseKey( reg );
    if( !rc_ok( rc ) ) {
        rc = WPTERR_REGISTRY;
        goto leave;
    }
    
    memset( &deficon, 0, sizeof deficon );
    _snprintf( deficon, sizeof deficon - 1, "%s\\DefaultIcon", extname );
    memset( &defexec, 0, sizeof defexec );
    _snprintf( defexec, sizeof defexec - 1, "%s\\shell\\open\\command", extname );      
    memset( &p_exefile, 0, sizeof p_exefile );
    _snprintf( p_exefile, sizeof p_exefile - 1, "%s %%1", exefile );
    
    rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );
    if( rc_ok( rc ) )
        rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (byte *)iconfile, strlen( iconfile ) );
    if( rc_ok( rc ) )
        rc = RegCloseKey( reg );
    if( rc_ok( rc ) )
        rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );
    if( rc_ok( rc ) )
        rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)p_exefile, strlen( exefile ) );
    if( rc_ok( rc ) )
        rc = RegCloseKey( reg );
    if( !rc_ok( rc ) ) {
        rc = WPTERR_REGISTRY;
        goto leave;     
    }
    
leave:
    if( reg )
        RegCloseKey( reg );
    return rc;
} /* create_file_type */


/* Expand a string with %foo% entries so that %foo% will
   be replaced with its actual value. */
static char *
expand_path (const char *path)
{
    DWORD len;
    char *p;

    len = ExpandEnvironmentStrings (path, NULL, 0);
    if (!len)
        return NULL;
    len += 1;
    p = new char[len+1];
    if (!p)
        return NULL;
    len = ExpandEnvironmentStrings (path, p, len);
    if (!len) {
        free_if_alloc (p);
        return NULL;
    }
    return p; 
}


/* Retrieve a registry entry with the directory given in @dir
   and the key given in @key.
   Return value is the value or NULL otherwise. */
char*
get_reg_entry (HKEY root_key, const char * dir, const char * key)
{
    int rc;
    char text[384] = {0};
    DWORD nbytes, type;
    HKEY reg_key = NULL;
    char * p = NULL;
    
    rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);
    if( !rc_ok( rc ) )
        goto leave;
    nbytes = sizeof (text) - 1;
    type = REG_SZ;
    
    rc = RegQueryValueEx (reg_key, key, 0, &type, (BYTE *)&text, &nbytes);
    if (!rc_ok (rc) || !nbytes)
        goto leave;
    
    if (type == REG_EXPAND_SZ && strchr (text, '%'))
        p = expand_path (text);
    else {
        p = new char[nbytes + 1];
        if (!p)
            BUG (0);
        memcpy (p, text, nbytes);
        p[nbytes] = '\0';
    }
    
leave:
    if (reg_key)
        RegCloseKey (reg_key);
    return p;
}


/* XXX: use REG_EXPAND_SZ to support multi user environments.
        keep this type and do not overwrite it with REG_SZ. */ 

/* Set a registry entry. */
int
set_reg_entry (HKEY root_key, const char *dir, const char *key,
               const char *value)
{
    int rc = 0;
    HKEY reg_key;

    rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
    if( !rc_ok( rc ) )
        return WPTERR_REGISTRY;
    rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
    if( !rc_ok( rc ) )
        rc = WPTERR_REGISTRY;   
    RegCloseKey( reg_key );
    return rc;
} /* set_reg_entry */


int
set_reg_key( HKEY root_key, const char * dir, const char * key,
             const char * value )
{
    int rc = 0;
    HKEY reg_key;
    
    rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
    if( !rc_ok( rc ) )
        return WPTERR_REGISTRY;
    
    rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );      
    if( !rc_ok( rc ) ) {        
        if ( RegCreateKey( root_key, key, &reg_key ) != ERROR_SUCCESS ) {
            rc = WPTERR_REGISTRY; 
            goto leave;
        }
        rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );          
        if ( !rc_ok( rc ) )
            rc = WPTERR_REGISTRY;
    }
    
leave:
    RegCloseKey( reg_key );
    return rc;
} /* set_reg_key */


int
set_reg_entry_gpg (const char * key, const char * value)
{       
    return set_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key, value);
}


int
set_reg_entry_mo (const char * value)
{       
    return set_reg_entry (HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS", 
                          "MODir", value);
}


char *
get_reg_entry_gpg (const char *key)
{
    return get_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key);
}


/* Return if possible the GPG4Win installation directory concatenated
   with the string in @path if given. */
char*
get_reg_entry_gpg4win (const char *path)
{
    char *p, *pp;
    p = get_reg_entry (HKEY_LOCAL_MACHINE,
                       "Software\\GNU\\GnuPG", "Install Directory");
    if (!p)
        return NULL;
    if (!path)
        return p;
    pp = new char[strlen (p) + strlen (path) + 4];
    if (!pp)
        BUG (NULL);
    sprintf (pp, "%s\\%s", p, path);
    free_if_alloc (p);
    return pp;
}

    
char*
get_reg_entry_mo (void)
{       
    char *p, *pp;
    const char *lang;

    p = get_reg_entry (HKEY_CURRENT_USER, 
                       "Control Panel\\Mingw32\\NLS", "MODir");
    if (p)
        return p;

    lang = get_gettext_langid ();
    if (!lang)    
        return NULL;    
    pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];
    if (!pp)    
        BUG (NULL);
    sprintf (pp, "share\\locale\\%s\\LC_MESSAGES", lang);
    p = get_reg_entry_gpg4win (pp);
    free_if_alloc (pp);
    return p;
}


/* All valid configuration commands. */
static const char * cfg [] = {
        NULL,
        "CacheTime",
        "WordWrap",
        "FastMode",
        "Viewer",
        "KeylistMode",
        "WipeMode",
        "AlwaysTrust",
        "AutoBackup",
        "BackupMode",
        "DisableHotkeys",       
        "NoCompressMultiMedia", 
        "Expert",
        "FMProgressBar",
    };


int
set_reg_winpt_single (int id, int val)
{
    char buf[64];
    int rc;

    sprintf (buf, "%d", val);
    rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id], buf);
    return rc;
}


int
get_reg_winpt_single (int id)
{
    char * buf = NULL;
    int val = 0;

    buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
    if (buf && *buf != ' ')
        val = 1;
    else if (!buf)
        val = -1;
    free_if_alloc (buf);
    return val;
}


/* Saves the winpt preferences in the registry. */
int
set_reg_winpt_prefs (winpt_reg_prefs_s * opt)
{
    char buf[128];
    size_t i;
    int rc = 0;

    for (i=1; i < DIM (cfg); i++) {
        switch (i) {
        case CFG_CACHETIME:
            sprintf (buf, "%d", opt->cache_time);
            break;
        case CFG_WORDWRAP:
            sprintf (buf, "%d", opt->word_wrap);
            break;
        case CFG_WIPEMODE:
            sprintf (buf, "%d", opt->wipe_mode);
            break;
        case CFG_FASTMODE:
            sprintf (buf, "%d", opt->use_tmpfiles);
            break;
        case CFG_NOZIP_MMEDIA:
            sprintf (buf, "%d", opt->no_zip_mmedia);
            break;
        case CFG_VIEWER:
            sprintf (buf, "%d", opt->use_viewer);
            break;
        case CFG_KEYLISTMODE:
            sprintf (buf, "%d", opt->keylist_mode);
            break;
        case CFG_ALWAYSTRUST:
            sprintf (buf, "%d", opt->always_trust);
            break;
        case CFG_AUTOBACKUP:
            sprintf (buf, "%d", opt->auto_backup);
            break;
        case CFG_AUTOBAKMODE:
            sprintf (buf, "%d", opt->backup.mode);
            break;
        case CFG_DISHOTKEYS:
            sprintf (buf, "%d", opt->no_hotkeys);
            break;
        case CFG_EXPERT:
            sprintf (buf, "%d", opt->expert);
            break;

        case CFG_FM_PROGRESS:
            sprintf (buf, "%d", opt->fm.progress);
            break;
        }
        rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
        if (rc)
            goto leave;
    }

    if (opt->backup.path) {
        rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath",
                            opt->backup.path);
        if (rc)
            goto leave;
    }
    if (opt->kserv_conf) {
        rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig",
                            opt->kserv_conf);
        if (rc)
            goto leave;
    }

    for (i=0; reg_hotkeys[i].reg_entry; i++) {
        strcpy (buf, " ");
        if (reg_hotkeys[i].enabled)
            strcpy (buf, reg_hotkeys[i].key);
        rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG, 
                          reg_hotkeys[i].reg_entry, buf);
        if (rc)
            break;
    }
    
leave:
    if (rc) {
        msg_box (NULL, _("Could not write to Registry."), _("Preferences"), MB_ERR);
        return rc;
    }
    return 0;
}


int
set_reg_winpt_flag (const char * name, int val)
{
    return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");
} /* set_reg_winpt_flag */


int
get_reg_winpt_flag (const char * name)
{
    char * buf;
    int flag = 0;

    buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name);
    if (buf && buf[0] == '1')
        flag = 1;
    else if (!buf || buf && buf[0] != '0')
        flag = -1;
    free_if_alloc (buf);
    return flag;
} /* get_reg_winpt_flag */


/* Retrieve the winpt preferences from the registry. */
int
get_reg_winpt_prefs (winpt_reg_prefs_s * opt)
{
    char *val = NULL;
    size_t i;

    for (i=1; i < DIM (cfg); i++) {
        val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i]);
        if (!val || *val == ' ') {
            free_if_alloc (val);
            continue;
        }
        switch (i) {
        case CFG_CACHETIME:
            opt->cache_time = atol (val);
            /* We do NOT support passphrase caching for more than an hour.
             * Perhaps we should allow it, but for now we silently drop this.
             */
            if (opt->cache_time > 3600)
                opt->cache_time = 3600;
            break;
        case CFG_WORDWRAP:
            opt->word_wrap = atol (val);
            break;
        case CFG_FASTMODE:
            opt->use_tmpfiles = atol (val);
            break;
        case CFG_NOZIP_MMEDIA:
            opt->no_zip_mmedia = atol (val);
            break;
        case CFG_VIEWER:
            opt->use_viewer = atol (val);
            break;
        case CFG_KEYLISTMODE:
            opt->keylist_mode = atol (val);
            break;
        case CFG_WIPEMODE:
            opt->wipe_mode = atol (val);
            break;
        case CFG_DISHOTKEYS:
            opt->no_hotkeys = atol (val);
            break;
        case CFG_ALWAYSTRUST:
            opt->always_trust = atol (val);
            break;
        case CFG_AUTOBACKUP:
            opt->auto_backup = atol (val);
            break;
        case CFG_AUTOBAKMODE:
            opt->backup.mode = atol (val);
            break;
        case CFG_EXPERT:
            opt->expert = atol (val);
            break;

        case CFG_FM_PROGRESS:
            opt->fm.progress = atol (val);
            break;
        }
        free_if_alloc (val);
    }    

    val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath");
    if (val && val[0] != ' ')
        opt->backup.path = m_strdup (val);
    free_if_alloc (val);

    val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig");
    if (val && val[0] != ' ')
        opt->kserv_conf = m_strdup (val);
    free_if_alloc (val);
    
    for (i=0; reg_hotkeys[i].reg_entry; i++) {
        val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);
        if (val && val[0] != ' ') {
            reg_hotkeys[i].key[0] = *val;
            reg_hotkeys[i].enabled = 1;
        }
        else
            reg_hotkeys[i].enabled = 0;
        free_if_alloc (val);
    }
    return 0;
} /* get_reg_winpt_prefs */


char*
get_reg_entry_keyserver (const char *name)
{
    char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
    if (p && !strcmp (p, "")) {
        free_if_alloc (p);
        return NULL;
    }
    return p;
}


void
get_reg_proxy_prefs (char ** host, int * port, char ** user, char ** pass)
{
    if (host)
        *host = get_reg_entry_keyserver ("Host");
    if (user)
        *user = get_reg_entry_keyserver ("User");
    if (pass)
        *pass = get_reg_entry_keyserver ("Pass");
    if (port) {
        char * p = get_reg_entry_keyserver ("Port");
        if (p) {
            *port = atol (p);
            free_if_alloc (p);
        }
    }
} /* get_reg_proxy_prefs */


int
set_reg_entry_keyserver( const char * name, const char * val )
{
    return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );
} /* set_reg_entry_keyserver */


int
set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )
{
    int rc;
    
    rc = set_reg_entry_keyserver( "Host", host? host : "" );
    if( !rc ) {
        char buf[32];
        sprintf( buf, "%d", port );
        rc = set_reg_entry_keyserver( "Port", buf );
    }
    if( !rc )
        rc = set_reg_entry_keyserver( "User", user? user : "" );
    if( !rc )
        rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );
    return rc;
} /* set_reg_proxy_prefs */
1	werner	36	/* wptRegistry.cpp - W32 Registry access
2			* Copyright (C) 2000-2005 Timo Schulz
3			*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU General Public License
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25			#include <windows.h>
26			#include <stdio.h>
27
28			#include "wptErrors.h"
29			#include "wptW32API.h"
30			#include "wptGPG.h"
31			#include "wptRegistry.h"
32			#include "wptKeyserver.h"
33			#include "wptTypes.h"
34			#include "wptNLS.h"
35			#include "wptVersion.h"
36
37			#define rc_ok(rc) ((rc) == ERROR_SUCCESS)
38
39	werner	48
40	twoaday	117
41	werner	36	struct reg_hotkey_s reg_hotkeys[] = {
42	twoaday	69	{"ClipEncrypt", "", 0},
43			{"ClipDecrypt", "", 0},
44			{"ClipSign", "", 0},
45			{"ClipSignEnc", "", 0},
46			{"CwsEncrypt", "", 0},
47			{"CwsDecrypt", "", 0},
48			{"CwsSign", "", 0},
49			{"CwsSignEnc", "", 0},
50			{NULL, "", 0}
51	werner	36	};
52
53			winpt_reg_prefs_s reg_prefs;
54
55			#define WINPT_REG "Software\\WinPT"
56
57
58	twoaday	128	/* Return != 0 if GPG4win is installed. */
59			int
60			is_gpg4win_installed (void)
61			{
62			char *p;
63
64			p = get_reg_entry_gpg4win (NULL);
65			if (!p)
66			return 0;
67			if (dir_exist_check (p)) {
68			free_if_alloc (p);
69			return 0;
70			}
71			free_if_alloc (p);
72			return -1;
73			}
74
75
76	twoaday	117	/* Return != 0 if GPGee is installed. */
77			int
78			is_gpgee_installed (void)
79			{
80			HKEY hk;
81			LONG ec;
82
83			ec = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\GPGee", 0, KEY_READ, &hk);
84			if (ec == ERROR_SUCCESS) {
85			RegCloseKey (hk);
86			return -1;
87			}
88
89			return 0;
90			}
91
92
93			/* Free all members in the registry preference struct. */
94	werner	36	void
95			free_reg_prefs (void)
96			{
97			free_if_alloc (reg_prefs.backup.path);
98			free_if_alloc (reg_prefs.kserv_conf);
99			free_if_alloc (reg_prefs.homedir);
100			memset (&reg_prefs, 0, sizeof reg_prefs);
101	twoaday	117	}
102	werner	36
103
104			/* Register the given WinPT filetype. */
105			static int
106			regist_single_filetype (gpg_filetype *gfile)
107			{
108	twoaday	128	char icon[256];
109			char prog[256];
110	werner	36
111			memset (&icon, 0, sizeof (icon));
112			GetModuleFileName (glob_hinst, prog, sizeof (prog)-1);
113			_snprintf (icon, sizeof (icon) -1, "%s,%d", prog, gfile->nicon);
114			return create_file_type (prog, gfile->ext, gfile->descr, icon);
115	twoaday	117	}
116	werner	36
117
118			/* Install the GPG related into the W32 resgistry, if the entry already
119			exists the function returns immediately. */
120			int
121			regist_inst_gnupg (int create_mokey)
122			{
123			int rc;
124			HKEY reg;
125
126			rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", 0, KEY_READ, &reg );
127			if( rc_ok( rc ) ) {
128			RegCloseKey( reg );
129			return 0;
130			}
131			rc = RegCreateKey( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", &reg );
132			if( !rc_ok( rc ) )
133			return WPTERR_REGISTRY;
134			RegCloseKey( reg );
135			if( create_mokey ) {
136			rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", 0, KEY_READ, &reg );
137			if( rc_ok( rc ) ) {
138			RegCloseKey( reg );
139			return 0;
140			}
141			rc = RegCreateKey( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", &reg );
142			if( !rc_ok( rc ) )
143			return WPTERR_REGISTRY;
144			RegCloseKey( reg );
145			}
146
147			return 0;
148	twoaday	128	}
149	werner	36
150
151	twoaday	117	/* Install WinPT into the W32 registry, if the entry already
152	twoaday	85	exists the function returns immediately. @with_ext can be
153			used to register some file types (if 1). @created contains
154			1 if the registry key was created.
155			Return value: 0 on success. */
156	werner	36	int
157	twoaday	117	regist_inst_winpt (int with_ext, int *created)
158	twoaday	129	{
159	werner	36	HKEY reg;
160	twoaday	80	char *p = NULL;
161			char modpath[MAX_PATH+1];
162	werner	36	int rc, i, id, n = 0;
163
164	twoaday	129	gpg_filetype gpg_filetypes[] = {
165			{_("GPG Detached Signature"), ".sig", 1},
166			{_("GPG Encrypted Data"), ".gpg", 2},
167			{_("GPG Armored Data"), ".asc", 2},
168			{0}
169			};
170
171	twoaday	85	if (created)
172	werner	36	*created = 0;
173
174			p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions");
175	twoaday	117	if ((p && *p == '1') \|\| is_gpgee_installed ())
176	werner	36	with_ext = 0;
177	twoaday	85	free_if_alloc (p);
178	werner	36
179	twoaday	85	if (with_ext) {
180			id = msg_box (NULL, _("WinPT can register some GPG file types for you so they can "
181	werner	36	"be processed with a double click in the explorer.\n"
182	twoaday	85	"Do you want to continue?"), _("WinPT"), MB_YESNO\|MB_INFO);
183			if (id == IDNO) {
184			set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");
185	werner	36	goto start;
186			}
187	twoaday	85	for (i = 0; gpg_filetypes[i].ext; i++) {
188			rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);
189			if (rc_ok (rc)) {
190			RegCloseKey (reg);
191			id = log_box (_("WinPT WARNING"), MB_YESNO\|MB_INFO,
192	werner	36	_("It seems there was already a '%s' file type registered by another application.\n"
193	twoaday	85	"Do you want to overwrite it?"), gpg_filetypes[i].ext);
194			if (id == IDNO)
195	werner	36	continue;
196			}
197	twoaday	85	regist_single_filetype (&gpg_filetypes[i]);
198	werner	36	n++;
199			}
200			}
201
202			start:
203	twoaday	85	rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);
204	twoaday	117	if (rc_ok (rc)) {
205	twoaday	85	RegCloseKey (reg);
206			rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg);
207	twoaday	117	if( !rc_ok (rc)) {
208	twoaday	85	RegCreateKey (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg);
209			RegCloseKey (reg);
210	werner	36	}
211			p = get_reg_entry_keyserver ("Default");
212			if (!p) {
213			char buf[16];
214			sprintf (buf, "%d", HKP_PORT);
215			set_reg_entry_keyserver ("Default_Port", buf);
216			set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
217			}
218	twoaday	85	free_if_alloc (p);
219			if (n)
220	twoaday	128	set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );
221	werner	36	return 0;
222			}
223	twoaday	117	rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
224	twoaday	85	if (!rc_ok (rc))
225	werner	36	return WPTERR_REGISTRY;
226	twoaday	85	if (created)
227	werner	36	*created = 1;
228	twoaday	85	RegCloseKey (reg);
229	twoaday	129	if (n > 0 \|\| is_gpgee_installed ())
230	twoaday	85	set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");
231	twoaday	80	if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
232			while (n-- > 0) {
233			if (modpath[n] == '\\') {
234			modpath[n] = 0;
235			break;
236			}
237			}
238	twoaday	117	set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Install Directory", modpath);
239	twoaday	80	}
240	werner	36	return 0;
241	twoaday	80	}
242	werner	36
243
244			/* Create a new filetype in the W32 registry.
245			We should really care of errors! Otherwise we can damage the registry! */
246			int
247	twoaday	128	create_file_type (const char exefile, const char ext,
248			const char extname, char iconfile)
249	werner	36	{
250			int rc;
251			HKEY reg = NULL;
252			char deficon[256], defexec[256], p_exefile[256];
253
254
255			rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );
256			if( rc_ok( rc ) )
257			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)extname, strlen( extname ) );
258			if( rc_ok( rc ) )
259			rc = RegCloseKey( reg );
260			if( rc_ok( rc ) )
261			rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );
262			if( rc_ok( rc ) )
263			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *) extname, strlen( extname ) );
264			if( rc_ok( rc ) )
265			rc = RegCloseKey( reg );
266			if( !rc_ok( rc ) ) {
267			rc = WPTERR_REGISTRY;
268			goto leave;
269			}
270
271			memset( &deficon, 0, sizeof deficon );
272			_snprintf( deficon, sizeof deficon - 1, "%s\\DefaultIcon", extname );
273			memset( &defexec, 0, sizeof defexec );
274			_snprintf( defexec, sizeof defexec - 1, "%s\\shell\\open\\command", extname );
275			memset( &p_exefile, 0, sizeof p_exefile );
276			_snprintf( p_exefile, sizeof p_exefile - 1, "%s %%1", exefile );
277
278			rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );
279			if( rc_ok( rc ) )
280			rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (byte *)iconfile, strlen( iconfile ) );
281			if( rc_ok( rc ) )
282			rc = RegCloseKey( reg );
283			if( rc_ok( rc ) )
284			rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );
285			if( rc_ok( rc ) )
286			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)p_exefile, strlen( exefile ) );
287			if( rc_ok( rc ) )
288			rc = RegCloseKey( reg );
289			if( !rc_ok( rc ) ) {
290			rc = WPTERR_REGISTRY;
291			goto leave;
292			}
293
294			leave:
295			if( reg )
296			RegCloseKey( reg );
297			return rc;
298			} /* create_file_type */
299
300
301			/* Expand a string with %foo% entries so that %foo% will
302			be replaced with its actual value. */
303			static char *
304			expand_path (const char *path)
305			{
306			DWORD len;
307			char *p;
308
309			len = ExpandEnvironmentStrings (path, NULL, 0);
310			if (!len)
311			return NULL;
312			len += 1;
313			p = new char[len+1];
314	twoaday	128	if (!p)
315	werner	36	return NULL;
316			len = ExpandEnvironmentStrings (path, p, len);
317			if (!len) {
318			free_if_alloc (p);
319			return NULL;
320			}
321			return p;
322	twoaday	128	}
323	werner	36
324
325			/* Retrieve a registry entry with the directory given in @dir
326			and the key given in @key.
327			Return value is the value or NULL otherwise. */
328			char*
329			get_reg_entry (HKEY root_key, const char * dir, const char * key)
330			{
331			int rc;
332			char text[384] = {0};
333	twoaday	69	DWORD nbytes, type;
334	werner	36	HKEY reg_key = NULL;
335	twoaday	128	char * p = NULL;
336	werner	36
337			rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);
338			if( !rc_ok( rc ) )
339			goto leave;
340			nbytes = sizeof (text) - 1;
341			type = REG_SZ;
342
343			rc = RegQueryValueEx (reg_key, key, 0, &type, (BYTE *)&text, &nbytes);
344			if (!rc_ok (rc) \|\| !nbytes)
345			goto leave;
346
347			if (type == REG_EXPAND_SZ && strchr (text, '%'))
348			p = expand_path (text);
349			else {
350			p = new char[nbytes + 1];
351			if (!p)
352			BUG (0);
353			memcpy (p, text, nbytes);
354			p[nbytes] = '\0';
355			}
356
357			leave:
358			if (reg_key)
359			RegCloseKey (reg_key);
360			return p;
361			}
362
363
364			/* XXX: use REG_EXPAND_SZ to support multi user environments.
365			keep this type and do not overwrite it with REG_SZ. */
366
367			/* Set a registry entry. */
368			int
369			set_reg_entry (HKEY root_key, const char dir, const char key,
370			const char *value)
371			{
372			int rc = 0;
373			HKEY reg_key;
374
375			rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
376			if( !rc_ok( rc ) )
377			return WPTERR_REGISTRY;
378			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
379			if( !rc_ok( rc ) )
380			rc = WPTERR_REGISTRY;
381			RegCloseKey( reg_key );
382			return rc;
383			} /* set_reg_entry */
384
385
386			int
387			set_reg_key( HKEY root_key, const char * dir, const char * key,
388			const char * value )
389			{
390			int rc = 0;
391			HKEY reg_key;
392
393			rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
394			if( !rc_ok( rc ) )
395			return WPTERR_REGISTRY;
396
397			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
398			if( !rc_ok( rc ) ) {
399			if ( RegCreateKey( root_key, key, &reg_key ) != ERROR_SUCCESS ) {
400			rc = WPTERR_REGISTRY;
401			goto leave;
402			}
403			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
404			if ( !rc_ok( rc ) )
405			rc = WPTERR_REGISTRY;
406			}
407
408			leave:
409			RegCloseKey( reg_key );
410			return rc;
411			} /* set_reg_key */
412
413
414			int
415			set_reg_entry_gpg (const char * key, const char * value)
416			{
417			return set_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key, value);
418			}
419
420
421			int
422			set_reg_entry_mo (const char * value)
423			{
424			return set_reg_entry (HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS",
425			"MODir", value);
426			}
427
428
429			char *
430			get_reg_entry_gpg (const char *key)
431			{
432			return get_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key);
433			}
434
435
436	twoaday	73	/* Return if possible the GPG4Win installation directory concatenated
437			with the string in @path if given. */
438			char*
439			get_reg_entry_gpg4win (const char *path)
440			{
441			char p, pp;
442			p = get_reg_entry (HKEY_LOCAL_MACHINE,
443			"Software\\GNU\\GnuPG", "Install Directory");
444			if (!p)
445			return NULL;
446			if (!path)
447			return p;
448			pp = new char[strlen (p) + strlen (path) + 4];
449			if (!pp)
450			BUG (NULL);
451			sprintf (pp, "%s\\%s", p, path);
452			free_if_alloc (p);
453			return pp;
454			}
455
456
457			char*
458			get_reg_entry_mo (void)
459	werner	36	{
460	twoaday	76	char p, pp;
461			const char *lang;
462	twoaday	117
463	twoaday	73	p = get_reg_entry (HKEY_CURRENT_USER,
464			"Control Panel\\Mingw32\\NLS", "MODir");
465	twoaday	76	if (p)
466			return p;
467	twoaday	117
468	twoaday	76	lang = get_gettext_langid ();
469	twoaday	117	if (!lang)
470			return NULL;
471	twoaday	76	pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];
472	twoaday	117	if (!pp)
473	twoaday	76	BUG (NULL);
474			sprintf (pp, "share\\locale\\%s\\LC_MESSAGES", lang);
475			p = get_reg_entry_gpg4win (pp);
476			free_if_alloc (pp);
477	twoaday	73	return p;
478	werner	36	}
479
480
481			/* All valid configuration commands. */
482			static const char * cfg [] = {
483			NULL,
484			"CacheTime",
485			"WordWrap",
486			"FastMode",
487			"Viewer",
488			"KeylistMode",
489			"WipeMode",
490			"AlwaysTrust",
491			"AutoBackup",
492			"BackupMode",
493			"DisableHotkeys",
494			"NoCompressMultiMedia",
495			"Expert",
496			"FMProgressBar",
497			};
498
499
500			int
501			set_reg_winpt_single (int id, int val)
502			{
503			char buf[64];
504			int rc;
505
506			sprintf (buf, "%d", val);
507			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id], buf);
508			return rc;
509			}
510
511
512			int
513			get_reg_winpt_single (int id)
514			{
515	twoaday	128	char * buf = NULL;
516	werner	36	int val = 0;
517
518			buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
519			if (buf && *buf != ' ')
520			val = 1;
521			else if (!buf)
522			val = -1;
523			free_if_alloc (buf);
524			return val;
525			}
526
527
528			/* Saves the winpt preferences in the registry. */
529			int
530			set_reg_winpt_prefs (winpt_reg_prefs_s * opt)
531			{
532			char buf[128];
533	twoaday	73	size_t i;
534			int rc = 0;
535	werner	36
536			for (i=1; i < DIM (cfg); i++) {
537			switch (i) {
538			case CFG_CACHETIME:
539			sprintf (buf, "%d", opt->cache_time);
540			break;
541			case CFG_WORDWRAP:
542			sprintf (buf, "%d", opt->word_wrap);
543			break;
544			case CFG_WIPEMODE:
545			sprintf (buf, "%d", opt->wipe_mode);
546			break;
547			case CFG_FASTMODE:
548			sprintf (buf, "%d", opt->use_tmpfiles);
549			break;
550			case CFG_NOZIP_MMEDIA:
551			sprintf (buf, "%d", opt->no_zip_mmedia);
552			break;
553			case CFG_VIEWER:
554			sprintf (buf, "%d", opt->use_viewer);
555			break;
556			case CFG_KEYLISTMODE:
557			sprintf (buf, "%d", opt->keylist_mode);
558			break;
559			case CFG_ALWAYSTRUST:
560			sprintf (buf, "%d", opt->always_trust);
561			break;
562			case CFG_AUTOBACKUP:
563			sprintf (buf, "%d", opt->auto_backup);
564			break;
565			case CFG_AUTOBAKMODE:
566			sprintf (buf, "%d", opt->backup.mode);
567			break;
568			case CFG_DISHOTKEYS:
569			sprintf (buf, "%d", opt->no_hotkeys);
570			break;
571			case CFG_EXPERT:
572			sprintf (buf, "%d", opt->expert);
573			break;
574
575			case CFG_FM_PROGRESS:
576			sprintf (buf, "%d", opt->fm.progress);
577			break;
578			}
579			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
580			if (rc)
581			goto leave;
582			}
583
584			if (opt->backup.path) {
585			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath",
586			opt->backup.path);
587			if (rc)
588			goto leave;
589			}
590			if (opt->kserv_conf) {
591			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig",
592			opt->kserv_conf);
593			if (rc)
594			goto leave;
595			}
596
597			for (i=0; reg_hotkeys[i].reg_entry; i++) {
598			strcpy (buf, " ");
599			if (reg_hotkeys[i].enabled)
600			strcpy (buf, reg_hotkeys[i].key);
601			rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,
602			reg_hotkeys[i].reg_entry, buf);
603			if (rc)
604			break;
605			}
606
607			leave:
608			if (rc) {
609			msg_box (NULL, _("Could not write to Registry."), _("Preferences"), MB_ERR);
610			return rc;
611			}
612			return 0;
613			}
614
615
616			int
617			set_reg_winpt_flag (const char * name, int val)
618			{
619			return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");
620			} /* set_reg_winpt_flag */
621
622
623			int
624			get_reg_winpt_flag (const char * name)
625			{
626			char * buf;
627			int flag = 0;
628
629			buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name);
630			if (buf && buf[0] == '1')
631			flag = 1;
632			else if (!buf \|\| buf && buf[0] != '0')
633			flag = -1;
634			free_if_alloc (buf);
635			return flag;
636			} /* get_reg_winpt_flag */
637
638
639			/* Retrieve the winpt preferences from the registry. */
640			int
641			get_reg_winpt_prefs (winpt_reg_prefs_s * opt)
642			{
643	twoaday	117	char *val = NULL;
644	twoaday	73	size_t i;
645	werner	36
646			for (i=1; i < DIM (cfg); i++) {
647			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i]);
648			if (!val \|\| *val == ' ') {
649			free_if_alloc (val);
650			continue;
651			}
652			switch (i) {
653			case CFG_CACHETIME:
654			opt->cache_time = atol (val);
655			/* We do NOT support passphrase caching for more than an hour.
656			* Perhaps we should allow it, but for now we silently drop this.
657			*/
658			if (opt->cache_time > 3600)
659			opt->cache_time = 3600;
660			break;
661			case CFG_WORDWRAP:
662			opt->word_wrap = atol (val);
663			break;
664			case CFG_FASTMODE:
665			opt->use_tmpfiles = atol (val);
666			break;
667			case CFG_NOZIP_MMEDIA:
668			opt->no_zip_mmedia = atol (val);
669			break;
670			case CFG_VIEWER:
671			opt->use_viewer = atol (val);
672			break;
673			case CFG_KEYLISTMODE:
674			opt->keylist_mode = atol (val);
675			break;
676			case CFG_WIPEMODE:
677			opt->wipe_mode = atol (val);
678			break;
679			case CFG_DISHOTKEYS:
680			opt->no_hotkeys = atol (val);
681			break;
682			case CFG_ALWAYSTRUST:
683			opt->always_trust = atol (val);
684			break;
685			case CFG_AUTOBACKUP:
686			opt->auto_backup = atol (val);
687			break;
688			case CFG_AUTOBAKMODE:
689			opt->backup.mode = atol (val);
690			break;
691			case CFG_EXPERT:
692			opt->expert = atol (val);
693			break;
694
695			case CFG_FM_PROGRESS:
696			opt->fm.progress = atol (val);
697			break;
698			}
699			free_if_alloc (val);
700			}
701
702			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath");
703			if (val && val[0] != ' ')
704			opt->backup.path = m_strdup (val);
705			free_if_alloc (val);
706
707			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig");
708			if (val && val[0] != ' ')
709			opt->kserv_conf = m_strdup (val);
710			free_if_alloc (val);
711
712			for (i=0; reg_hotkeys[i].reg_entry; i++) {
713			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);
714			if (val && val[0] != ' ') {
715			reg_hotkeys[i].key[0] = *val;
716			reg_hotkeys[i].enabled = 1;
717			}
718			else
719			reg_hotkeys[i].enabled = 0;
720			free_if_alloc (val);
721			}
722			return 0;
723			} /* get_reg_winpt_prefs */
724
725
726			char*
727			get_reg_entry_keyserver (const char *name)
728			{
729			char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
730			if (p && !strcmp (p, "")) {
731			free_if_alloc (p);
732			return NULL;
733			}
734			return p;
735			}
736
737
738			void
739			get_reg_proxy_prefs (char ** host, int * port, char user, char pass)
740			{
741			if (host)
742			*host = get_reg_entry_keyserver ("Host");
743			if (user)
744			*user = get_reg_entry_keyserver ("User");
745			if (pass)
746			*pass = get_reg_entry_keyserver ("Pass");
747			if (port) {
748			char * p = get_reg_entry_keyserver ("Port");
749			if (p) {
750			*port = atol (p);
751			free_if_alloc (p);
752			}
753			}
754			} /* get_reg_proxy_prefs */
755
756
757			int
758			set_reg_entry_keyserver( const char * name, const char * val )
759			{
760			return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );
761			} /* set_reg_entry_keyserver */
762
763
764			int
765			set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )
766			{
767			int rc;
768
769			rc = set_reg_entry_keyserver( "Host", host? host : "" );
770			if( !rc ) {
771			char buf[32];
772			sprintf( buf, "%d", port );
773			rc = set_reg_entry_keyserver( "Port", buf );
774			}
775			if( !rc )
776			rc = set_reg_entry_keyserver( "User", user? user : "" );
777			if( !rc )
778			rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );
779			return rc;
780			} /* set_reg_proxy_prefs */