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