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