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