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

#include <windows.h>
#include <stdio.h>

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

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

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

winpt_reg_prefs_s reg_prefs;

#define WINPT_REG "Software\\WinPT"


void
free_reg_prefs (void)
{
    free_if_alloc (reg_prefs.backup.path);
    free_if_alloc (reg_prefs.kserv_conf);
    memset (&reg_prefs, 0, sizeof reg_prefs);
} /* free_reg_prefs */


/*
 * Register the given WinPT filetype.
 */
static int
regist_single_filetype (gpg_filetype *gfile)
{
    char icon[256], 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);
} /* regist_single_filetype */


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


/*
 * Install WinPT into the W32 registry, if the entry already 
 * exists the function returns immediately.
 */
int
regist_inst_winpt( int with_ext, int * created )
{
    HKEY reg;
    char * p = NULL;
    int rc, i, id, n = 0;

    if( created )
        *created = 0;

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

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


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


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];    
    if( !p )
        return NULL;
    len = ExpandEnvironmentStrings( path, p, len );
    if( !len ) {
        free_if_alloc( p );
        return NULL;
    }
    return p; 
} /* expand_path */


char *
get_reg_entry( HKEY root_key, const char * dir, const char * key )
{
    int rc;
    char text[384] = {0};
    DWORD nbytes, type, n1 = 0;
    HKEY reg_key = NULL;
    char * p = NULL, * tmp = 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;
} /* get_reg_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 );
} /* set_reg_entry_gpg */


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


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


char *
get_reg_entry_mo( void )
{       
    return get_reg_entry( HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS", "MODir" );
} /* get_reg_entry_mo */


static const char * cfg [] = {
        NULL,
        "CacheTime",
        "WordWrap",
        "FastMode",
        "Viewer",
        "KeylistMode",
        "WipeMode",
        "AlwaysTrust",
        "AutoBackup",
        "BackupMode",
        "DisableHotkeys",       
        "NoCompressMultiMedia", 
        "Expert",
    };


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


int
set_reg_winpt_prefs (winpt_reg_prefs_s * opt)
{
    char buf[128];
    int rc = 0, i;

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

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

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


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


int
get_reg_winpt_prefs (winpt_reg_prefs_s * opt)
{
    char * val = NULL;
    int i;

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

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

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


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


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


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


int
set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )
{
    int rc;
    
    rc = set_reg_entry_keyserver( "Host", host? host : "" );
    if( !rc ) {
        char buf[32];
        sprintf( buf, "%d", port );
        rc = set_reg_entry_keyserver( "Port", buf );
    }
    if( !rc )
        rc = set_reg_entry_keyserver( "User", user? user : "" );
    if( !rc )
        rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );
    return rc;
} /* set_reg_proxy_prefs */
1	twoaday	2	/* 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			#include <windows.h>
22			#include <stdio.h>
23
24			#include "wptErrors.h"
25			#include "wptW32API.h"
26			#include "wptGPG.h"
27			#include "wptRegistry.h"
28			#include "wptKeyserver.h"
29			#include "wptTypes.h"
30			#include "wptNLS.h"
31			#include "wptVersion.h"
32
33			#define rc_ok(rc) ((rc) == ERROR_SUCCESS)
34
35			struct reg_hotkey_s reg_hotkeys[] = {
36			{"ClipEncrypt", NULL, 0},
37			{"ClipDecrypt", NULL, 0},
38			{"ClipSign", NULL, 0},
39			{"ClipSignEnc", NULL, 0},
40			{"CwsEncrypt", NULL, 0},
41			{"CwsDecrypt", NULL, 0},
42			{"CwsSign", NULL, 0},
43			{"CwsSignEnc", NULL, 0},
44			{0}
45			};
46
47			winpt_reg_prefs_s reg_prefs;
48
49			#define WINPT_REG "Software\\WinPT"
50
51
52			void
53			free_reg_prefs (void)
54			{
55			free_if_alloc (reg_prefs.backup.path);
56			free_if_alloc (reg_prefs.kserv_conf);
57			memset (&reg_prefs, 0, sizeof reg_prefs);
58			} /* free_reg_prefs */
59
60
61			/*
62			* Register the given WinPT filetype.
63			*/
64			static int
65			regist_single_filetype (gpg_filetype *gfile)
66			{
67			char icon[256], prog[256];
68
69			memset (&icon, 0, sizeof (icon));
70			GetModuleFileName (glob_hinst, prog, sizeof (prog)-1);
71			_snprintf (icon, sizeof (icon) -1, "%s,%d", prog, gfile->nicon);
72			return create_file_type (prog, gfile->ext, gfile->descr, icon);
73			} /* regist_single_filetype */
74
75
76			/*
77			* Install the GPG related into the W32 resgistry, if the entry already
78			* exists< the function returns immediately.
79			*/
80			int
81			regist_inst_gnupg( int create_mokey )
82			{
83			int rc;
84			HKEY reg;
85
86			rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", 0, KEY_READ, &reg );
87			if( rc_ok( rc ) ) {
88			RegCloseKey( reg );
89			return 0;
90			}
91			rc = RegCreateKey( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", &reg );
92			if( !rc_ok( rc ) )
93			return WPTERR_REGISTRY;
94			RegCloseKey( reg );
95			if( create_mokey ) {
96			rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", 0, KEY_READ, &reg );
97			if( rc_ok( rc ) ) {
98			RegCloseKey( reg );
99			return 0;
100			}
101			rc = RegCreateKey( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", &reg );
102			if( !rc_ok( rc ) )
103			return WPTERR_REGISTRY;
104			RegCloseKey( reg );
105			}
106
107			return 0;
108			} /* regist_inst_gpg */
109
110
111			/*
112			* Install WinPT into the W32 registry, if the entry already
113			* exists the function returns immediately.
114			*/
115			int
116			regist_inst_winpt( int with_ext, int * created )
117			{
118			HKEY reg;
119			char * p = NULL;
120			int rc, i, id, n = 0;
121
122			if( created )
123			*created = 0;
124
125			p = get_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions" );
126			if( p && *p == '1' )
127			with_ext = 0;
128			free_if_alloc( p );
129
130			if( with_ext ) {
131			id = msg_box( NULL, _("WinPT can register some GPG file types for you so they can "
132			"be processed with a double click in the explorer.\n"
133			"Do you want to continue?"), _("WinPT"), MB_YESNO\|MB_INFO );
134			if( id == IDNO ) {
135			set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );
136			goto start;
137			}
138			for( i = 0; gpg_filetypes[i].ext; i++ ) {
139			rc = RegOpenKeyEx( HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg );
140			if( rc_ok( rc ) ) {
141			RegCloseKey( reg );
142			id = log_box( _("WinPT WARNING"), MB_YESNO\|MB_INFO,
143			_("It seems there was already a '%s' file type registered by another application.\n"
144			"Do you want to overwrite it?"), gpg_filetypes[i].ext );
145			if( id == IDNO )
146			continue;
147			}
148			regist_single_filetype( &gpg_filetypes[i] );
149			n++;
150			}
151			}
152
153			start:
154			rc = RegOpenKeyEx( HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg );
155			if( rc_ok( rc ) ) {
156			RegCloseKey( reg );
157			rc = RegOpenKeyEx( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg );
158			if( !rc_ok( rc ) ) {
159			RegCreateKey( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg );
160			RegCloseKey( reg );
161			}
162			p = get_reg_entry_keyserver ("Default");
163			if (!p) {
164			char buf[16];
165			sprintf (buf, "%d", HKP_PORT);
166			set_reg_entry_keyserver ("Default_Port", buf);
167			set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
168			}
169			free_if_alloc( p );
170			if( n )
171			set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );
172			return 0;
173			}
174			rc = RegCreateKey( HKEY_CURRENT_USER, WINPT_REG, &reg );
175			if( !rc_ok( rc ) )
176			return WPTERR_REGISTRY;
177			if( created )
178			*created = 1;
179			RegCloseKey( reg );
180			if( n )
181			set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );
182			return 0;
183			} /* regist_inst_winpt */
184
185
186			/*
187			* Create a new filetype in the W32 registry.
188			* We should really care of errors! Otherwise we can damage the registry!
189			*/
190			int
191			create_file_type( const char exefile, const char ext, const char extname, char iconfile )
192			{
193			int rc;
194			HKEY reg = NULL;
195			char deficon[256], defexec[256], p_exefile[256];
196
197
198			rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );
199			if( rc_ok( rc ) )
200			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)extname, strlen( extname ) );
201			if( rc_ok( rc ) )
202			rc = RegCloseKey( reg );
203			if( rc_ok( rc ) )
204			rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );
205			if( rc_ok( rc ) )
206			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *) extname, strlen( extname ) );
207			if( rc_ok( rc ) )
208			rc = RegCloseKey( reg );
209			if( !rc_ok( rc ) ) {
210			rc = WPTERR_REGISTRY;
211			goto leave;
212			}
213
214			memset( &deficon, 0, sizeof deficon );
215			_snprintf( deficon, sizeof deficon - 1, "%s\\DefaultIcon", extname );
216			memset( &defexec, 0, sizeof defexec );
217			_snprintf( defexec, sizeof defexec - 1, "%s\\shell\\open\\command", extname );
218			memset( &p_exefile, 0, sizeof p_exefile );
219			_snprintf( p_exefile, sizeof p_exefile - 1, "%s %%1", exefile );
220
221			rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );
222			if( rc_ok( rc ) )
223			rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (byte *)iconfile, strlen( iconfile ) );
224			if( rc_ok( rc ) )
225			rc = RegCloseKey( reg );
226			if( rc_ok( rc ) )
227			rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );
228			if( rc_ok( rc ) )
229			rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)p_exefile, strlen( exefile ) );
230			if( rc_ok( rc ) )
231			rc = RegCloseKey( reg );
232			if( !rc_ok( rc ) ) {
233			rc = WPTERR_REGISTRY;
234			goto leave;
235			}
236
237			leave:
238			if( reg )
239			RegCloseKey( reg );
240			return rc;
241			} /* create_file_type */
242
243
244			static char *
245			expand_path( const char *path )
246			{
247			DWORD len;
248			char *p;
249
250			len = ExpandEnvironmentStrings( path, NULL, 0 );
251			if( !len )
252			return NULL;
253			len += 1;
254			p = new char[len];
255			if( !p )
256			return NULL;
257			len = ExpandEnvironmentStrings( path, p, len );
258			if( !len ) {
259			free_if_alloc( p );
260			return NULL;
261			}
262			return p;
263			} /* expand_path */
264
265
266			char *
267			get_reg_entry( HKEY root_key, const char * dir, const char * key )
268			{
269			int rc;
270			char text[384] = {0};
271			DWORD nbytes, type, n1 = 0;
272			HKEY reg_key = NULL;
273			char * p = NULL, * tmp = NULL;
274
275			rc = RegOpenKeyEx( root_key, dir, 0, KEY_QUERY_VALUE, &reg_key );
276			if( !rc_ok( rc ) )
277			goto leave;
278			nbytes = sizeof text - 1;
279			type = REG_SZ;
280
281			rc = RegQueryValueEx (reg_key, key, 0, &type, (BYTE *)&text, &nbytes);
282			if (!rc_ok (rc) \|\| !nbytes)
283			goto leave;
284
285			if (type == REG_EXPAND_SZ && strchr (text, '%'))
286			p = expand_path (text);
287			else {
288			p = new char[nbytes + 1];
289			if (!p)
290			BUG (0);
291			memcpy (p, text, nbytes);
292			p[nbytes] = '\0';
293			}
294
295			leave:
296			if (reg_key)
297			RegCloseKey (reg_key);
298			return p;
299			} /* get_reg_entry */
300
301
302			int
303			set_reg_entry( HKEY root_key, const char * dir, const char * key,
304			const char * value )
305			{
306			int rc = 0;
307			HKEY reg_key;
308
309			rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
310			if( !rc_ok( rc ) )
311			return WPTERR_REGISTRY;
312			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
313			if( !rc_ok( rc ) )
314			rc = WPTERR_REGISTRY;
315			RegCloseKey( reg_key );
316			return rc;
317			} /* set_reg_entry */
318
319
320			int
321			set_reg_key( HKEY root_key, const char * dir, const char * key,
322			const char * value )
323			{
324			int rc = 0;
325			HKEY reg_key;
326
327			rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );
328			if( !rc_ok( rc ) )
329			return WPTERR_REGISTRY;
330
331			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
332			if( !rc_ok( rc ) ) {
333			if ( RegCreateKey( root_key, key, &reg_key ) != ERROR_SUCCESS ) {
334			rc = WPTERR_REGISTRY;
335			goto leave;
336			}
337			rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );
338			if ( !rc_ok( rc ) )
339			rc = WPTERR_REGISTRY;
340			}
341
342			leave:
343			RegCloseKey( reg_key );
344			return rc;
345			} /* set_reg_key */
346
347
348			int
349			set_reg_entry_gpg( const char * key, const char * value )
350			{
351			return set_reg_entry( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key, value );
352			} /* set_reg_entry_gpg */
353
354
355			int
356			set_reg_entry_mo( const char * value )
357			{
358			return set_reg_entry( HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS", "MODir", value );
359			} /* set_reg_entry_mo */
360
361
362			char *
363			get_reg_entry_gpg( const char *key )
364			{
365			return get_reg_entry( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key );
366			} /* get_reg_entry_gpg */
367
368
369			char *
370			get_reg_entry_mo( void )
371			{
372			return get_reg_entry( HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS", "MODir" );
373			} /* get_reg_entry_mo */
374
375
376			static const char * cfg [] = {
377			NULL,
378			"CacheTime",
379			"WordWrap",
380			"FastMode",
381			"Viewer",
382			"KeylistMode",
383			"WipeMode",
384			"AlwaysTrust",
385			"AutoBackup",
386			"BackupMode",
387			"DisableHotkeys",
388			"NoCompressMultiMedia",
389			"Expert",
390			};
391
392
393			int
394			set_reg_winpt_single (int id, int val)
395			{
396			char buf[64];
397			int rc;
398
399			sprintf (buf, "%d", val);
400			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id], buf);
401			return rc;
402			}
403
404
405			int
406			get_reg_winpt_single (int id)
407			{
408			char * buf = NULL;
409			int val = 0;
410
411			buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
412			if (buf && *buf != ' ')
413			val = 1;
414			else if (!buf)
415			val = -1;
416			free_if_alloc (buf);
417			return val;
418			}
419
420
421			int
422			set_reg_winpt_prefs (winpt_reg_prefs_s * opt)
423			{
424			char buf[128];
425			int rc = 0, i;
426
427			for (i=1; i < DIM (cfg); i++) {
428			switch (i) {
429			case CFG_CACHETIME:
430			sprintf (buf, "%d", opt->cache_time);
431			break;
432			case CFG_WORDWRAP:
433			sprintf (buf, "%d", opt->word_wrap);
434			break;
435			case CFG_WIPEMODE:
436			sprintf (buf, "%d", opt->wipe_mode);
437			break;
438			case CFG_FASTMODE:
439			sprintf (buf, "%d", opt->use_tmpfiles);
440			break;
441			case CFG_NOZIP_MMEDIA:
442			sprintf (buf, "%d", opt->no_zip_mmedia);
443			break;
444			case CFG_VIEWER:
445			sprintf (buf, "%d", opt->use_viewer);
446			break;
447			case CFG_KEYLISTMODE:
448			sprintf (buf, "%d", opt->keylist_mode);
449			break;
450			case CFG_ALWAYSTRUST:
451			sprintf (buf, "%d", opt->always_trust);
452			break;
453			case CFG_AUTOBACKUP:
454			sprintf (buf, "%d", opt->auto_backup);
455			break;
456			case CFG_AUTOBAKMODE:
457			sprintf (buf, "%d", opt->backup.mode);
458			break;
459			case CFG_DISHOTKEYS:
460			sprintf (buf, "%d", opt->no_hotkeys);
461			break;
462			case CFG_EXPERT:
463			sprintf (buf, "%d", opt->expert);
464			break;
465			}
466			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
467			if (rc)
468			goto leave;
469			}
470
471			if (opt->backup.path) {
472			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath",
473			opt->backup.path);
474			if (rc)
475			goto leave;
476			}
477			if (opt->kserv_conf) {
478			rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig",
479			opt->kserv_conf);
480			if (rc)
481			goto leave;
482			}
483
484			for (i=0; reg_hotkeys[i].reg_entry; i++) {
485			strcpy (buf, " ");
486			if (reg_hotkeys[i].enabled)
487			strcpy (buf, reg_hotkeys[i].key);
488			rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,
489			reg_hotkeys[i].reg_entry, buf);
490			if (rc)
491			break;
492			}
493
494			leave:
495			if (rc) {
496			msg_box (NULL, _("Could not write to Registry."), _("Preferences"), MB_ERR);
497			return rc;
498			}
499			return 0;
500			} /* set_reg_winpt_prefs */
501
502
503			int
504			set_reg_winpt_flag (const char * name, int val)
505			{
506			return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");
507			} /* set_reg_winpt_flag */
508
509
510			int
511			get_reg_winpt_flag (const char * name)
512			{
513			char * buf;
514			int flag = 0;
515
516			buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name);
517			if (buf && buf[0] == '1')
518			flag = 1;
519			else if (!buf \|\| buf && buf[0] != '0')
520			flag = -1;
521			free_if_alloc (buf);
522			return flag;
523			} /* get_reg_winpt_flag */
524
525
526			int
527			get_reg_winpt_prefs (winpt_reg_prefs_s * opt)
528			{
529			char * val = NULL;
530			int i;
531
532			for (i=1; i < DIM (cfg); i++) {
533			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i]);
534			if (!val \|\| *val == ' ') {
535			free_if_alloc (val);
536			continue;
537			}
538			switch (i) {
539			case CFG_CACHETIME:
540			opt->cache_time = atol (val);
541			/* We do NOT support passphrase caching for more than an hour.
542			* Perhaps we should allow it, but for now we silently drop this.
543			*/
544			if (opt->cache_time > 3600)
545			opt->cache_time = 3600;
546			break;
547			case CFG_WORDWRAP:
548			opt->word_wrap = atol (val);
549			break;
550			case CFG_FASTMODE:
551			opt->use_tmpfiles = atol (val);
552			break;
553			case CFG_NOZIP_MMEDIA:
554			opt->no_zip_mmedia = atol (val);
555			break;
556			case CFG_VIEWER:
557			opt->use_viewer = atol (val);
558			break;
559			case CFG_KEYLISTMODE:
560			opt->keylist_mode = atol (val);
561			break;
562			case CFG_WIPEMODE:
563			opt->wipe_mode = atol (val);
564			break;
565			case CFG_DISHOTKEYS:
566			opt->no_hotkeys = atol (val);
567			break;
568			case CFG_ALWAYSTRUST:
569			opt->always_trust = atol (val);
570			break;
571			case CFG_AUTOBACKUP:
572			opt->auto_backup = atol (val);
573			break;
574			case CFG_AUTOBAKMODE:
575			opt->backup.mode = atol (val);
576			break;
577			case CFG_EXPERT:
578			opt->expert = atol (val);
579			break;
580			}
581			free_if_alloc (val);
582			}
583
584			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "BackupPath");
585			if (val && val[0] != ' ')
586			opt->backup.path = m_strdup (val);
587			free_if_alloc (val);
588
589			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "KeyserverConfig");
590			if (val && val[0] != ' ')
591			opt->kserv_conf = m_strdup (val);
592			free_if_alloc (val);
593
594			for (i=0; reg_hotkeys[i].reg_entry; i++) {
595			val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);
596			if (val && val[0] != ' ') {
597			reg_hotkeys[i].key[0] = *val;
598			reg_hotkeys[i].enabled = 1;
599			}
600			else
601			reg_hotkeys[i].enabled = 0;
602			free_if_alloc (val);
603			}
604			return 0;
605			} /* get_reg_winpt_prefs */
606
607
608			char *
609			get_reg_entry_keyserver (const char *name)
610			{
611			char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
612			if (p && !strcmp (p, "")) {
613			free_if_alloc (p);
614			return NULL;
615			}
616			return p;
617			} /* get_reg_entry_keyserver */
618
619
620			void
621			get_reg_proxy_prefs (char ** host, int * port, char user, char pass)
622			{
623			if (host)
624			*host = get_reg_entry_keyserver ("Host");
625			if (user)
626			*user = get_reg_entry_keyserver ("User");
627			if (pass)
628			*pass = get_reg_entry_keyserver ("Pass");
629			if (port) {
630			char * p = get_reg_entry_keyserver ("Port");
631			if (p) {
632			*port = atol (p);
633			free_if_alloc (p);
634			}
635			}
636			} /* get_reg_proxy_prefs */
637
638
639			int
640			set_reg_entry_keyserver( const char * name, const char * val )
641			{
642			return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );
643			} /* set_reg_entry_keyserver */
644
645
646			int
647			set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )
648			{
649			int rc;
650
651			rc = set_reg_entry_keyserver( "Host", host? host : "" );
652			if( !rc ) {
653			char buf[32];
654			sprintf( buf, "%d", port );
655			rc = set_reg_entry_keyserver( "Port", buf );
656			}
657			if( !rc )
658			rc = set_reg_entry_keyserver( "User", user? user : "" );
659			if( !rc )
660			rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );
661			return rc;
662			} /* set_reg_proxy_prefs */