/[winpt]/trunk/Src/wptRegistry.cpp
ViewVC logotype

Diff of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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