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