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