/[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 167 by twoaday, Thu Jan 26 10:17:17 2006 UTC revision 262 by twoaday, Sat Sep 30 10:24:34 2006 UTC
# Line 1  Line 1 
1  /* wptRegistry.cpp - W32 Registry access  /* wptRegistry.cpp - Windows Registry access
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 33  Line 33 
33  #include "wptTypes.h"  #include "wptTypes.h"
34  #include "wptNLS.h"  #include "wptNLS.h"
35  #include "wptVersion.h"  #include "wptVersion.h"
36    #include "wptHotkey.h"
37    
38  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)
39    
40    #define WINPT_REG "Software\\WinPT"
41    
42    /* GPG file association context. */
43  struct reg_hotkey_s reg_hotkeys[] = {  struct gpg_filetype {    
44      {"ClipEncrypt", "", 0},      const char *descr;
45      {"ClipDecrypt", "", 0},      const char *ext;
46      {"ClipSign",    "", 0},      int nicon;
     {"ClipSignEnc", "", 0},  
     {"CwsEncrypt",  "", 0},  
     {"CwsDecrypt",  "", 0},  
     {"CwsSign",     "", 0},  
     {"CwsSignEnc",  "", 0},  
     {NULL, "", 0}  
47  };  };
48    
49    /* Global WinPT registry prefereneces. */
50  winpt_reg_prefs_s reg_prefs;  winpt_reg_prefs_s reg_prefs;
51    
 #define WINPT_REG "Software\\WinPT"  
   
52    
53  /* Return != 0 if GPG4win is installed. */  /* Return != 0 if GPG4win is installed. */
54  int  int
# Line 159  regist_inst_winpt (int with_ext, int *cr Line 154  regist_inst_winpt (int with_ext, int *cr
154      HKEY reg;      HKEY reg;
155      char *p = NULL;      char *p = NULL;
156      char modpath[MAX_PATH+1];      char modpath[MAX_PATH+1];
157      int rc, i, id, n = 0;      int rc, i, id, n;
158    
159      gpg_filetype gpg_filetypes[] = {      gpg_filetype gpg_filetypes[] = {
160          {_("GPG Detached Signature"), ".sig", 1},          {_("GPG Detached Signature"), ".sig", 1},
# Line 170  regist_inst_winpt (int with_ext, int *cr Line 165  regist_inst_winpt (int with_ext, int *cr
165    
166      if (created)      if (created)
167          *created = 0;          *created = 0;
168        if (is_gpgee_installed ())
     p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions");  
     if ((p && *p == '1') || is_gpgee_installed ())  
169          with_ext = 0;          with_ext = 0;
     free_if_alloc (p);  
170    
     if (with_ext) {  
         id = msg_box (NULL, _("WinPT can register some GPG file types for you so they can "  
                               "be processed with a double click in the explorer.\n"  
                               "Do you want to continue?"), _("WinPT"), MB_YESNO|MB_INFO);  
         if (id == IDNO) {  
             set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");  
             goto start;  
         }  
         for (i = 0; gpg_filetypes[i].ext; i++) {  
             rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);  
             if (rc_ok (rc)) {  
                 RegCloseKey (reg);  
                 id = log_box (_("WinPT WARNING"), MB_YESNO|MB_INFO,  
                               _("It seems there was already a '%s' file type registered by another application.\n"  
                                 "Do you want to overwrite it?"), gpg_filetypes[i].ext);  
                 if (id == IDNO)  
                     continue;  
             }  
             regist_single_filetype (&gpg_filetypes[i]);  
             n++;  
         }  
     }  
           
 start:  
171      rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);      rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);
172      if (rc_ok (rc)) {      if (rc_ok (rc)) {
173          RegCloseKey (reg);          RegCloseKey (reg);
# Line 216  start: Line 184  start:
184              set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);              set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
185          }          }
186          free_if_alloc (p);          free_if_alloc (p);
         if (n)  
             set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );  
187          return 0;          return 0;
188      }      }
189      rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);      rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
# Line 226  start: Line 192  start:
192      if (created)      if (created)
193          *created = 1;          *created = 1;
194      RegCloseKey (reg);      RegCloseKey (reg);
195      if (n > 0 || is_gpgee_installed ())      if (with_ext) {
196          set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1");          id = msg_box (NULL, _("WinPT can register some GPG file types for you so they can "
197                                  "be processed with a double click in the explorer.\n"
198                                  "Do you want to continue?"), _("WinPT"), MB_YESNO|MB_INFO);
199            if (id == IDYES) {
200                for (i = 0; gpg_filetypes[i].ext; i++) {
201                    rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);
202                    if (rc_ok (rc)) {
203                    RegCloseKey (reg);
204                        id = log_box (_("WinPT WARNING"), MB_YESNO|MB_INFO,
205                                      _("It seems there was already a '%s' file type registered by another application.\n"
206                                        "Do you want to overwrite it?"), gpg_filetypes[i].ext);
207                        if (id == IDNO)
208                            continue;
209                    }
210                    regist_single_filetype (&gpg_filetypes[i]);
211                }
212            }
213        }
214      if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {      if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
215          while (n-- > 0) {          while (n-- > 0) {
216              if (modpath[n] == '\\') {              if (modpath[n] == '\\') {
# Line 254  create_file_type (const char *exefile, c Line 237  create_file_type (const char *exefile, c
237            
238      rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );      rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );
239      if( rc_ok( rc ) )      if( rc_ok( rc ) )
240          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)extname, strlen( extname ) );          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *)extname, strlen( extname ) );
241      if( rc_ok( rc ) )      if( rc_ok( rc ) )
242          rc = RegCloseKey( reg );          rc = RegCloseKey( reg );
243      if( rc_ok( rc ) )          if( rc_ok( rc ) )    
244          rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );          rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );
245      if( rc_ok( rc ) )      if( rc_ok( rc ) )
246          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *) extname, strlen( extname ) );          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *) extname, strlen( extname ) );
247      if( rc_ok( rc ) )      if( rc_ok( rc ) )
248          rc = RegCloseKey( reg );          rc = RegCloseKey( reg );
249      if( !rc_ok( rc ) ) {      if( !rc_ok( rc ) ) {
# Line 277  create_file_type (const char *exefile, c Line 260  create_file_type (const char *exefile, c
260            
261      rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );      rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );
262      if( rc_ok( rc ) )      if( rc_ok( rc ) )
263          rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (byte *)iconfile, strlen( iconfile ) );          rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (BYTE *)iconfile, strlen( iconfile ) );
264      if( rc_ok( rc ) )      if( rc_ok( rc ) )
265          rc = RegCloseKey( reg );          rc = RegCloseKey( reg );
266      if( rc_ok( rc ) )      if( rc_ok( rc ) )
267          rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );          rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );
268      if( rc_ok( rc ) )      if( rc_ok( rc ) )
269          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)p_exefile, strlen( exefile ) );          rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *)p_exefile, strlen( exefile ) );
270      if( rc_ok( rc ) )      if( rc_ok( rc ) )
271          rc = RegCloseKey( reg );          rc = RegCloseKey( reg );
272      if( !rc_ok( rc ) ) {      if( !rc_ok( rc ) ) {
# Line 295  leave: Line 278  leave:
278      if( reg )      if( reg )
279          RegCloseKey( reg );          RegCloseKey( reg );
280      return rc;      return rc;
281  } /* create_file_type */  }
282    
283    
284  /* Expand a string with %foo% entries so that %foo% will  /* Expand a string with %foo% entries so that %foo% will
# Line 326  expand_path (const char *path) Line 309  expand_path (const char *path)
309     and the key given in @key.     and the key given in @key.
310     Return value is the value or NULL otherwise. */     Return value is the value or NULL otherwise. */
311  char*  char*
312  get_reg_entry (HKEY root_key, const char * dir, const char * key)  get_reg_entry (HKEY root_key, const char *dir, const char *key)
313  {  {
     int rc;  
     char text[384] = {0};  
     DWORD nbytes, type;  
314      HKEY reg_key = NULL;      HKEY reg_key = NULL;
315      char * p = NULL;      char *p = NULL, *pp;    
316            DWORD type = REG_SZ, nbytes = 0;
317        int rc;
318    
319      rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);      rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);
320      if( !rc_ok( rc ) )      if (!rc_ok (rc))
321          goto leave;          goto leave;
322      nbytes = sizeof (text) - 1;      rc = RegQueryValueEx (reg_key, key, NULL, &type, NULL, &nbytes);
323      type = REG_SZ;      if (!rc_ok (rc))
       
     rc = RegQueryValueEx (reg_key, key, 0, &type, (BYTE *)&text, &nbytes);  
     if (!rc_ok (rc) || !nbytes)  
324          goto leave;          goto leave;
325            if (!nbytes)
326      if (type == REG_EXPAND_SZ && strchr (text, '%'))          goto leave; /* empty */
327          p = expand_path (text);      p = new char[nbytes+1];
328      else {      if (!p)
329          p = new char[nbytes + 1];          BUG (0);
330          if (!p)      rc = RegQueryValueEx (reg_key, key, NULL, &type, (BYTE*)p,  &nbytes);
331              BUG (0);      if (!rc_ok (rc))
332          memcpy (p, text, nbytes);          goto leave;
333          p[nbytes] = '\0';      if (type == REG_EXPAND_SZ && strchr (p, '%')) {
334            pp = p;
335            p = expand_path (pp);
336            free_if_alloc (pp);
337      }      }
338        
339  leave:  leave:
340      if (reg_key)      if (reg_key != NULL)
341          RegCloseKey (reg_key);          RegCloseKey (reg_key);
342      return p;      return p;
343  }  }
# Line 380  set_reg_entry (HKEY root_key, const char Line 362  set_reg_entry (HKEY root_key, const char
362          rc = WPTERR_REGISTRY;            rc = WPTERR_REGISTRY;  
363      RegCloseKey( reg_key );      RegCloseKey( reg_key );
364      return rc;      return rc;
365  } /* set_reg_entry */  }
366    
367    
368  int  int
369  set_reg_key( HKEY root_key, const char * dir, const char * key,  set_reg_key( HKEY root_key, const char * dir, const char * key,
370               const char * value )               const char * value )
371  {  {
372      int rc = 0;      int rc;
373      HKEY reg_key;      HKEY reg_key;
374            
375      rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );      rc = RegOpenKeyEx (root_key, dir, 0, KEY_WRITE, &reg_key);
376      if( !rc_ok( rc ) )      if (!rc_ok (rc))
377          return WPTERR_REGISTRY;          return WPTERR_REGISTRY;
378            
379      rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );            rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
380      if( !rc_ok( rc ) ) {              if (!rc_ok (rc)) {  
381          if ( RegCreateKey( root_key, key, &reg_key ) != ERROR_SUCCESS ) {          if (RegCreateKey (root_key, key, &reg_key) != ERROR_SUCCESS) {
382              rc = WPTERR_REGISTRY;              rc = WPTERR_REGISTRY;
383              goto leave;              goto leave;
384          }          }
385          rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );                    rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
386          if ( !rc_ok( rc ) )          if  (!rc_ok (rc))
387              rc = WPTERR_REGISTRY;              rc = WPTERR_REGISTRY;
388      }      }
389            
390  leave:  leave:
391      RegCloseKey( reg_key );      RegCloseKey (reg_key);
392      return rc;      return rc;
393  } /* set_reg_key */  }
394    
395    
396  int  int
# Line 472  get_reg_entry_mo (void) Line 454  get_reg_entry_mo (void)
454          return p;          return p;
455    
456      lang = get_gettext_langid ();      lang = get_gettext_langid ();
457      if (!lang)          if (!lang)
458          return NULL;              return NULL;
459      pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];      pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];
460      if (!pp)          if (!pp)    
461          BUG (NULL);          BUG (NULL);
# Line 485  get_reg_entry_mo (void) Line 467  get_reg_entry_mo (void)
467    
468    
469  /* All valid configuration commands. */  /* All valid configuration commands. */
470  static const char * cfg [] = {  static const char *cfg [] = {
471          NULL,      NULL,      
472          "CacheTime",      "CacheTime",
473          "WordWrap",      "WordWrap",
474          "FastMode",      "DefaultExt",
475          "Viewer",      "Viewer",
476          "KeylistMode",      "WipeMode",
477          "WipeMode",      "AlwaysTrust",
478          "AlwaysTrust",      "AutoBackup",
479          "AutoBackup",      "BackupMode",
480          "BackupMode",      "DisableHotkeys",  
481          "DisableHotkeys",            "NoCompressMultiMedia",    
482          "NoCompressMultiMedia",      "Expert",
483          "Expert",      "FMProgressBar",
484          "FMProgressBar",      "BackupSecring"
485      };  };
486    
487    
488  int  int
# Line 518  set_reg_winpt_single (int id, int val) Line 500  set_reg_winpt_single (int id, int val)
500  int  int
501  get_reg_winpt_single (int id)  get_reg_winpt_single (int id)
502  {  {
503      char * buf = NULL;      char *buf;
504      int val = 0;      int val = 0;
505    
506      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
# Line 550  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 532  set_reg_winpt_prefs (winpt_reg_prefs_s *
532          case CFG_WIPEMODE:          case CFG_WIPEMODE:
533              sprintf (buf, "%d", opt->wipe_mode);              sprintf (buf, "%d", opt->wipe_mode);
534              break;              break;
535          case CFG_FASTMODE:          case CFG_FILEEXT:
536              sprintf (buf, "%d", opt->use_tmpfiles);              sprintf (buf, "%d", opt->default_ext);
537              break;              break;
538          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
539              sprintf (buf, "%d", opt->no_zip_mmedia);              sprintf (buf, "%d", opt->no_zip_mmedia);
# Line 559  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 541  set_reg_winpt_prefs (winpt_reg_prefs_s *
541          case CFG_VIEWER:          case CFG_VIEWER:
542              sprintf (buf, "%d", opt->use_viewer);              sprintf (buf, "%d", opt->use_viewer);
543              break;              break;
         case CFG_KEYLISTMODE:  
             sprintf (buf, "%d", opt->keylist_mode);  
             break;  
544          case CFG_ALWAYSTRUST:          case CFG_ALWAYSTRUST:
545              sprintf (buf, "%d", opt->always_trust);              sprintf (buf, "%d", opt->always_trust);
546              break;              break;
# Line 581  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 560  set_reg_winpt_prefs (winpt_reg_prefs_s *
560          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
561              sprintf (buf, "%d", opt->fm.progress);              sprintf (buf, "%d", opt->fm.progress);
562              break;              break;
563    
564            case CFG_BACKUP_INC_SKR:
565                sprintf (buf, "%d", opt->backup.include_secr);
566                break;
567          }          }
568          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
569          if (rc)          if (rc)
# Line 594  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 577  set_reg_winpt_prefs (winpt_reg_prefs_s *
577              goto leave;              goto leave;
578      }      }
579    
580      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name; i++) {
581          strcpy (buf, " ");          if (wpt_hotkeys[i].enabled) {
582          if (reg_hotkeys[i].enabled)              buf[0] = wpt_hotkeys[i].key;
583              strcpy (buf, reg_hotkeys[i].key);              buf[1] = 0;
584            }
585            else
586                strcpy (buf, " ");
587          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,
588                            reg_hotkeys[i].reg_entry, buf);                            wpt_hotkeys[i].name, buf);
589          if (rc)          if (rc)
590              break;              break;
591      }      }
# Line 617  int Line 603  int
603  set_reg_winpt_flag (const char * name, int val)  set_reg_winpt_flag (const char * name, int val)
604  {  {
605      return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");      return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");
606  } /* set_reg_winpt_flag */  }
607    
608    
609  int  int
# Line 633  get_reg_winpt_flag (const char * name) Line 619  get_reg_winpt_flag (const char * name)
619          flag = -1;          flag = -1;
620      free_if_alloc (buf);      free_if_alloc (buf);
621      return flag;      return flag;
622  } /* get_reg_winpt_flag */  }
623    
624    
625  /* Retrieve the winpt preferences from the registry. */  /* Retrieve the winpt preferences from the registry. */
# Line 652  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 638  get_reg_winpt_prefs (winpt_reg_prefs_s *
638          switch (i) {          switch (i) {
639          case CFG_CACHETIME:          case CFG_CACHETIME:
640              opt->cache_time = atol (val);              opt->cache_time = atol (val);
             /* We do NOT support passphrase caching for more than an hour.  
              * Perhaps we should allow it, but for now we silently drop this.  
              */  
             if (opt->cache_time > 3600)  
                 opt->cache_time = 3600;  
641              break;              break;
642          case CFG_WORDWRAP:          case CFG_WORDWRAP:
643              opt->word_wrap = atol (val);              opt->word_wrap = atol (val);
644              break;              break;
645          case CFG_FASTMODE:          case CFG_FILEEXT:
646              opt->use_tmpfiles = atol (val);              opt->default_ext = atol (val);
647              break;              break;
648          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
649              opt->no_zip_mmedia = atol (val);              opt->no_zip_mmedia = atol (val);
# Line 670  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 651  get_reg_winpt_prefs (winpt_reg_prefs_s *
651          case CFG_VIEWER:          case CFG_VIEWER:
652              opt->use_viewer = atol (val);              opt->use_viewer = atol (val);
653              break;              break;
         case CFG_KEYLISTMODE:  
             opt->keylist_mode = atol (val);  
             break;  
654          case CFG_WIPEMODE:          case CFG_WIPEMODE:
655              opt->wipe_mode = atol (val);              opt->wipe_mode = atol (val);
656              break;              break;
# Line 691  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 669  get_reg_winpt_prefs (winpt_reg_prefs_s *
669          case CFG_EXPERT:          case CFG_EXPERT:
670              opt->expert = atol (val);              opt->expert = atol (val);
671              break;              break;
   
672          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
673              opt->fm.progress = atol (val);              opt->fm.progress = atol (val);
674              break;              break;
675    
676            case CFG_BACKUP_INC_SKR:
677                opt->backup.include_secr = atol (val);
678                break;
679          }          }
680          free_if_alloc (val);          free_if_alloc (val);
681      }          }    
# Line 704  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 685  get_reg_winpt_prefs (winpt_reg_prefs_s *
685          opt->backup.path = m_strdup (val);          opt->backup.path = m_strdup (val);
686      free_if_alloc (val);      free_if_alloc (val);
687            
688      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name; i++) {
689          val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);          wpt_hotkeys[i].enabled = 0;
690            val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, wpt_hotkeys[i].name);
691          if (val && val[0] != ' ') {          if (val && val[0] != ' ') {
692              reg_hotkeys[i].key[0] = *val;              wpt_hotkeys[i].key = *val;
693              reg_hotkeys[i].enabled = 1;              wpt_hotkeys[i].enabled = 1;
694          }          }
         else  
             reg_hotkeys[i].enabled = 0;  
695          free_if_alloc (val);          free_if_alloc (val);
696      }      }
697      return 0;      return 0;
698  } /* get_reg_winpt_prefs */  }
699    
700    
701  char*  char*
702  get_reg_entry_keyserver (const char *name)  get_reg_entry_keyserver (const char *name)
703  {  {
704      char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);      char *p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
705      if (p && !strcmp (p, "")) {      if (p && (!strcmp (p, "") || strlen (p) == 0)) {
706          free_if_alloc (p);          free_if_alloc (p);
707          return NULL;          return NULL;
708      }      }
# Line 730  get_reg_entry_keyserver (const char *nam Line 710  get_reg_entry_keyserver (const char *nam
710  }  }
711    
712    
713    int
714    set_reg_entry_keyserver (const char *name, const char *val)
715    {
716        return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val);
717    }
718    
719    static int
720    get_reg_entry_keyserver_int (const char *key)
721    {
722        char *p;
723        int val = 0;
724    
725        p = get_reg_entry_keyserver (key);
726        if (p && *p)
727            val = atoi (p);
728        free_if_alloc (p);
729        return val;
730    }
731    
732    
733  void  void
734  get_reg_proxy_prefs (char ** host, int * port, char ** user, char ** pass)  get_reg_proxy_prefs (keyserver_proxy_t prox)
735  {  {
736      if (host)      if (!prox)
737          *host = get_reg_entry_keyserver ("Host");          return;
738      if (user)      
739          *user = get_reg_entry_keyserver ("User");      free_if_alloc (prox->host);
740      if (pass)      prox->host = get_reg_entry_keyserver ("Host");
741          *pass = get_reg_entry_keyserver ("Pass");      free_if_alloc (prox->user);
742      if (port) {      prox->user = get_reg_entry_keyserver ("User");
743          char * p = get_reg_entry_keyserver ("Port");      free_if_alloc (prox->pass);
744          if (p) {      prox->pass = get_reg_entry_keyserver ("Pass");
745              *port = atol (p);      prox->port = get_reg_entry_keyserver_int ("Port");
746              free_if_alloc (p);  }
         }  
     }  
 } /* get_reg_proxy_prefs */  
747    
748    
749  int  static int
750  set_reg_entry_keyserver( const char * name, const char * val )  set_reg_entry_keyserver_int (const char *key, int val)
751  {  {
752      return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );      char buf[32];
753  } /* set_reg_entry_keyserver */  
754        sprintf (buf, "%d", val);
755        return set_reg_entry_keyserver (key, buf);
756    }
757    
758    
759  int  int
760  set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )  set_reg_proxy_prefs (keyserver_proxy_t prox)
761  {  {    
762      int rc;      int rc;
763            
764      rc = set_reg_entry_keyserver( "Host", host? host : "" );      rc = set_reg_entry_keyserver_int ("Proto", prox->proto);
765      if( !rc ) {      if (!rc)
766          char buf[32];          rc = set_reg_entry_keyserver ("Host", prox->host? prox->host : "");
767          sprintf( buf, "%d", port );      if (!rc)
768          rc = set_reg_entry_keyserver( "Port", buf );          rc = set_reg_entry_keyserver_int ("Port", prox->port);
769      }      if (!rc)
770      if( !rc )          rc = set_reg_entry_keyserver ("User", prox->user? prox->user : "");
771          rc = set_reg_entry_keyserver( "User", user? user : "" );      if (!rc)
772      if( !rc )          rc = set_reg_entry_keyserver ("Pass", prox->pass? prox->pass : "");
         rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );  
773      return rc;      return rc;
774  } /* set_reg_proxy_prefs */  }
Legend:
Removed from v.167  
changed lines
  Added in v.262
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26