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

Diff of /trunk/Src/wptRegistry.cpp

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

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