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