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);
    free_if_alloc (reg_prefs.homedir);
    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",
        "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;
}


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;

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

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

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

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

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

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


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