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

Contents of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log

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

Properties

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