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",
    "DefaultExt",
    "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_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;
        }
        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_FILEEXT:
            opt->default_ext = 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	twoaday	218	"DefaultExt",
476	twoaday	176	"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	twoaday	218	case CFG_FILEEXT:
536			sprintf (buf, "%d", opt->default_ext);
537	werner	36	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	twoaday	218	case CFG_FILEEXT:
642			opt->default_ext = atol (val);
643	werner	36	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	}