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