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"
#include "wptHotkey.h"

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

#define WINPT_REG "Software\\WinPT"

/* GPG file association context. */
struct gpg_filetype {    
    const char *descr;
    const char *ext;
    int nicon;
};

/* Global WinPT registry prefereneces. */
winpt_reg_prefs_s reg_prefs;


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

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

    if (created)
        *created = 0;
    if (is_gpgee_installed ())
        with_ext = 0;

    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);
        return 0;
    }
    rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
    if (!rc_ok (rc))
        return WPTERR_REGISTRY;
    if (created)
        *created = 1;
    RegCloseKey (reg);
    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_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]);
            }
        }
    }
    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)
{
    char *p;
    p = get_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", 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)
{
    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",
    "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_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;
    }

    for (i=0; wpt_hotkeys[i].name; i++) {
        if (wpt_hotkeys[i].enabled) {
            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");
} /* 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);
            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_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);
    
    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 );
}

static int
get_reg_entry_keyserver_int (const char *key)
{
    char *p;
    int val = 0;

    p = get_reg_entry_keyserver (key);
    if (p && *p)
        val = atoi (p);
    free_if_alloc (p);
    return val;
}


void
get_reg_proxy_prefs (keyserver_proxy_t prox)
{
    if (!prox)
        return;
    
    free_if_alloc (prox->host);
    prox->host = get_reg_entry_keyserver ("Host");
    free_if_alloc (prox->user);
    prox->user = get_reg_entry_keyserver ("User");
    free_if_alloc (prox->pass); 
    prox->pass = get_reg_entry_keyserver ("Pass");
    prox->port = get_reg_entry_keyserver_int ("Port");
}


static int
set_reg_entry_keyserver_int (const char *key, int val)
{
    char buf[32];

    sprintf (buf, "%d", val);
    return set_reg_entry_keyserver (key, buf);
}


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