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

Annotation of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log

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

Properties

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