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