/[winpt]/trunk/Src/wptRegistry.cpp
ViewVC logotype

Diff of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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