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