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