trunk/Src/wptRegistry.cpp

/* wptRegistry.cpp - Windows Registry access
 *      Copyright (C) 2000-2006 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.
 */
#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"
#include "wptHotkey.h"

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

/* WinPT registry path. */
#define WINPT_REG "Software\\WinPT"

/* GPG registry path. */
#define GPG_REG "Software\\GNU\\GnuPG"

#define GPG_MO_REG "Control Panel\\MingW32\\NLS"

/* GPG file association context. */
struct gpg_filetype_s {    
    const char *descr;  /* description. */
    const char *ext;    /* extension. */
    int nicon;          /* number of the image icon. */
};
typedef struct gpg_filetype_s *gpg_filetype_t;

/* Global WinPT registry prefereneces. */
struct winpt_prefs_s reg_prefs;

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

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


/* 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, GPG_REG, 0, KEY_READ, &reg);
    if (rc == ERROR_SUCCESS) {
        RegCloseKey (reg);
        return 0;       
    }
    rc = RegCreateKey (HKEY_CURRENT_USER, GPG_REG, &reg);
    if (rc != ERROR_SUCCESS)
        return WPTERR_REGISTRY; 
    RegCloseKey (reg);

    if (!create_mokey)
        return 0;

    rc = RegOpenKeyEx (HKEY_CURRENT_USER,  GPG_MO_REG, 0, KEY_READ, &reg);
    if (rc == ERROR_SUCCESS) {
        RegCloseKey (reg);
        return 0;       
    }
    rc = RegCreateKey (HKEY_CURRENT_USER, GPG_MO_REG, &reg);
    if (rc != ERROR_SUCCESS)
        return WPTERR_REGISTRY;

    RegCloseKey (reg);
    return 0;
}


/* Create a new filetype in the W32 registry.
   We should really care of errors! Otherwise we can damage the registry! */
static int
create_file_type (const char *exefile, const char *ext, 
                  const char *extname, char *iconfile)
{
    HKEY reg = NULL;
    char deficon[MAX_PATH+1];
    char defexec[MAX_PATH+1];
    char p_exefile[MAX_PATH+1];
    int rc;
    
    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, DIM (deficon) - 1, "%s\\DefaultIcon", extname );
    memset( &defexec, 0, sizeof defexec );
    _snprintf( defexec, DIM (defexec) - 1, "%s\\shell\\open\\command", extname );       
    memset( &p_exefile, 0, sizeof p_exefile );
    _snprintf( p_exefile, DIM (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;
}


/* Register the given WinPT filetype. */
static int
regist_single_filetype (gpg_filetype_t gfile)
{
    char icon[MAX_PATH+1] = {0};
    char prog[MAX_PATH+1] = {0};

    if (!GetModuleFileName (glob_hinst, prog, DIM (prog)-1))
        return WPTERR_REGISTRY;
    _snprintf (icon, DIM (icon) -1, "%s,%d", prog, gfile->nicon);
    return create_file_type (prog, gfile->ext, gfile->descr, icon);
}

/* 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)
{
    struct gpg_filetype_s gpg_filetypes[] = {
        {_("GPG Detached Signature"), ".sig", 1},
        {_("GPG Encrypted Data"),     ".gpg", 2},
        {_("GPG Armored Data"),       ".asc", 2},
        {0}
    };
    HKEY reg;
    char *p = NULL;
    char modpath[MAX_PATH+1];
    int rc, i, id, n;

    if (created)
        *created = 0;

    /* If GPGee is already installed deactivate file extension registering
       because it is very likely this would overwrite the GPGee settings. */
    if (is_gpgee_installed ())
        with_ext = 0;

    rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);
    if (rc == ERROR_SUCCESS) {
        RegCloseKey (reg);
        rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg);
        if (rc != ERROR_SUCCESS) {
            rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg);
            if (rc == ERROR_SUCCESS)
                RegCloseKey (reg);
        }
        else
            RegCloseKey (reg);
        p = get_reg_entry_keyserver ("Default");
        if (!p) {
            char buf[16];

            _snprintf (buf, DIM (buf)-1, "%d", HKP_PORT);
            set_reg_entry_keyserver ("Default_Port", buf);
            set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
        }
        free_if_alloc (p);
        return 0;
    }
    rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
    if (rc != ERROR_SUCCESS)
        return WPTERR_REGISTRY;
    if (created)
        *created = 1;
    RegCloseKey (reg);
    /* FIXME: check this part */
    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 == IDYES) {
            for (i = 0; gpg_filetypes[i].ext; i++) {
                rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);
                if (rc == ERROR_SUCCESS) {
                    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]);
            }
        }
    }
    /* Store the install directory for later use. */
    n = GetModuleFileName (NULL, modpath, MAX_PATH-1);
    if (n > 0) {
        while (n-- > 0) {
            if (modpath[n] == '\\') {
                modpath[n] = 0;
                break;
            }
        }
        log_debug("storing install directory '%s'", modpath);
        set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Install Directory", modpath);     
    }
    return 0;
}


/* 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)
{
    HKEY reg_key = NULL;
    char *p = NULL, *pp;    
    DWORD type = REG_SZ, nbytes = 0;
    int rc;

    rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);
    if (rc != ERROR_SUCCESS)
        goto leave;
    rc = RegQueryValueEx (reg_key, key, NULL, &type, NULL, &nbytes);
    if (rc != ERROR_SUCCESS)
        goto leave;
    if (!nbytes)
        goto leave; /* empty */
    p = new char[nbytes+1];
    if (!p)
        BUG (0);
    rc = RegQueryValueEx (reg_key, key, NULL, &type, (BYTE*)p,  &nbytes);
    if (rc != ERROR_SUCCESS)
        goto leave;
    if (type == REG_EXPAND_SZ && strchr (p, '%')) {
        pp = p;
        p = expand_path (pp);
        free_if_alloc (pp);
    }

leave:
    if (reg_key != NULL)
        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)
{
    HKEY reg_key;
    int rc;

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


int
set_reg_key (HKEY root_key, const char *dir, const char *key,
             const char *value)
{    
    HKEY reg_key;
    int rc;
    
    rc = RegOpenKeyEx (root_key, dir, 0, KEY_WRITE, &reg_key);
    if (rc != ERROR_SUCCESS)
        return WPTERR_REGISTRY;
    
    rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
    if (rc != ERROR_SUCCESS) {
        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 != ERROR_SUCCESS)
            rc = WPTERR_REGISTRY;
    }
    
leave:
    RegCloseKey (reg_key);
    return rc;
}


int
set_reg_entry_gpg (const char *key, const char *value)
{       
    return set_reg_entry (HKEY_CURRENT_USER, GPG_REG, key, value);
}


char*
get_reg_entry_gpg (const char *key)
{
    char *p;

    p = get_reg_entry (HKEY_CURRENT_USER, GPG_REG, key);
    if (!p || strlen (p) == 0) {
        free_if_alloc (p);
        return NULL;
    }
    return p;
}


/* Return if possible the GPG4Win installation directory concatenated
   with the string in @path if given. */
char*
get_reg_entry_gpg4win (const char *path)
{
    const char *fmt;
    char *p, *pp;

    p = get_reg_entry (HKEY_LOCAL_MACHINE, GPG_REG, "Install Directory");
    if (!p)
        return NULL;
    if (!path)
        return p;
    fmt = "%s\\%s";
    pp = new char[strlen (p) + strlen (path) + strlen (fmt) + 1];
    if (!pp)
        BUG (NULL);
    sprintf (pp, fmt, p, path);
    free_if_alloc (p);
    return pp;
}

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

    p = get_reg_entry (HKEY_CURRENT_USER, GPG_MO_REG, "MODir");
    if (p)
        return p;

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


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

    _snprintf (buf, DIM (buf)-1, "%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;
    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_prefs_t 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_FILEEXT:
            sprintf (buf, "%d", opt->default_ext);
            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_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;

        case CFG_BACKUP_INC_SKR:
            sprintf (buf, "%d", opt->backup.include_secr);
            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;
    }

    for (i=0; wpt_hotkeys[i].name != NULL; i++) {
        if (wpt_hotkeys[i].enabled == 1) {
            buf[0] = wpt_hotkeys[i].key;
            buf[1] = 0;
        }
        else
            strcpy (buf, " ");
        rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG, 
                          wpt_hotkeys[i].name, 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");
}


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


/* Retrieve the winpt preferences from the registry. */
int
get_reg_winpt_prefs (winpt_prefs_t 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 = atoi (val);
            break;
        case CFG_WORDWRAP:
            opt->word_wrap = atoi (val);
            break;
        case CFG_FILEEXT:
            opt->default_ext = atoi (val);
            break;
        case CFG_NOZIP_MMEDIA:
            opt->no_zip_mmedia = atoi (val);
            break;
        case CFG_VIEWER:
            opt->use_viewer = atoi (val);
            break;
        case CFG_DISHOTKEYS:
            opt->no_hotkeys = atoi (val);
            break;
        case CFG_ALWAYSTRUST:
            opt->always_trust = atoi (val);
            break;
        case CFG_AUTOBACKUP:
            opt->auto_backup = atoi (val);
            break;
        case CFG_AUTOBAKMODE:
            opt->backup.mode = atoi (val);
            break;
        case CFG_EXPERT:
            opt->expert = atoi (val);
            break;
        case CFG_FM_PROGRESS:
            opt->fm.progress = atoi (val);
            break;

        case CFG_BACKUP_INC_SKR:
            opt->backup.include_secr = atoi (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);
    
    for (i=0; wpt_hotkeys[i].name; i++) {
        wpt_hotkeys[i].enabled = 0;
        val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, wpt_hotkeys[i].name);
        if (val && val[0] != ' ') {
            wpt_hotkeys[i].key = *val;
            wpt_hotkeys[i].enabled = 1;
        }
        free_if_alloc (val);
    }
    return 0;
}


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


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

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