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