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