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