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

Annotation of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log

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

Properties

Name Value
svn:eol-style native
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26