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

Diff of /trunk/Src/wptRegistry.cpp

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

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