/[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 328 by twoaday, Fri Sep 25 16:07:38 2009 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 12  Line 12 
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   * General Public License for more details.   * General Public License for more details.
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  
15   */   */
   
16  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
17  #include <config.h>  #include <config.h>
18  #endif  #endif
# Line 33  Line 28 
28  #include "wptTypes.h"  #include "wptTypes.h"
29  #include "wptNLS.h"  #include "wptNLS.h"
30  #include "wptVersion.h"  #include "wptVersion.h"
31    #include "wptHotkey.h"
32    
33  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)
34    
35    /* WinPT registry path. */
36    #define WINPT_REG "Software\\WinPT"
37    
38    /* GPG registry path. */
39    #define GPG_REG "Software\\GNU\\GnuPG"
40    
41  struct reg_hotkey_s reg_hotkeys[] = {  #define GPG_MO_REG "Control Panel\\MingW32\\NLS"
     {"ClipEncrypt", "", 0},  
     {"ClipDecrypt", "", 0},  
     {"ClipSign",    "", 0},  
     {"ClipSignEnc", "", 0},  
     {"CwsEncrypt",  "", 0},  
     {"CwsDecrypt",  "", 0},  
     {"CwsSign",     "", 0},  
     {"CwsSignEnc",  "", 0},  
     {NULL, "", 0}  
 };  
42    
43  winpt_reg_prefs_s reg_prefs;  /* GPG file association context. */
44    struct gpg_filetype_s {    
45        const char *descr;  /* description. */
46        const char *ext;    /* extension. */
47        int nicon;          /* number of the image icon. */
48    };
49    typedef struct gpg_filetype_s *gpg_filetype_t;
50    
51  #define WINPT_REG "Software\\WinPT"  /* Global WinPT registry prefereneces. */
52    struct winpt_prefs_s reg_prefs;
53    
54    /* All valid configuration commands. */
55    const char *cfg [] = {
56        NULL,      
57        "CacheTime",
58        "WordWrap",
59        "DefaultExt",
60        "Viewer",
61        "AlwaysTrust",
62        "AutoBackup",
63        "BackupMode",
64        "DisableHotkeys",  
65        "NoCompressMultiMedia",    
66        "Expert",
67        "FMProgressBar",
68        "BackupSecring"
69    };
70    
71  /* Return != 0 if GPG4win is installed. */  /* Return != 0 if GPG4win is installed. */
72  int  int
# Line 74  is_gpg4win_installed (void) Line 87  is_gpg4win_installed (void)
87    
88    
89  /* Return != 0 if GPGee is installed. */  /* Return != 0 if GPGee is installed. */
90  int  static int
91  is_gpgee_installed (void)  is_gpgee_installed (void)
92  {  {
93      HKEY hk;      HKEY hk;
# Line 97  free_reg_prefs (void) Line 110  free_reg_prefs (void)
110      free_if_alloc (reg_prefs.backup.path);      free_if_alloc (reg_prefs.backup.path);
111      free_if_alloc (reg_prefs.kserv_conf);      free_if_alloc (reg_prefs.kserv_conf);
112      free_if_alloc (reg_prefs.homedir);      free_if_alloc (reg_prefs.homedir);
113      memset (&reg_prefs, 0, sizeof reg_prefs);      memset (&reg_prefs, 0, sizeof (reg_prefs));
114  }  }
115    
116    
 /* Register the given WinPT filetype. */  
 static int  
 regist_single_filetype (gpg_filetype *gfile)  
 {  
     char icon[256];  
     char prog[256];  
       
     memset (&icon, 0, sizeof (icon));  
     GetModuleFileName (glob_hinst, prog, sizeof (prog)-1);  
     _snprintf (icon, sizeof (icon) -1, "%s,%d", prog, gfile->nicon);  
     return create_file_type (prog, gfile->ext, gfile->descr, icon);  
 }  
   
117    
118  /* Install the GPG related into the W32 resgistry, if the entry already  /* Install the GPG related into the W32 resgistry, if the entry already
119     exists the function returns immediately. */     exists the function returns immediately. */
# Line 123  regist_inst_gnupg (int create_mokey) Line 123  regist_inst_gnupg (int create_mokey)
123      int rc;      int rc;
124      HKEY reg;      HKEY reg;
125    
126      rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", 0, KEY_READ, &reg );        rc = RegOpenKeyEx (HKEY_CURRENT_USER, GPG_REG, 0, KEY_READ, &reg);
127      if( rc_ok( rc ) ) {      if (rc == ERROR_SUCCESS) {
128          RegCloseKey( reg );          RegCloseKey (reg);
129          return 0;                return 0;      
130      }      }
131      rc = RegCreateKey( HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", &reg );      rc = RegCreateKey (HKEY_CURRENT_USER, GPG_REG, &reg);
132      if( !rc_ok( rc ) )                if (rc != ERROR_SUCCESS)
133          return WPTERR_REGISTRY;          return WPTERR_REGISTRY;
134      RegCloseKey( reg );      RegCloseKey (reg);
135      if( create_mokey ) {  
136          rc = RegOpenKeyEx( HKEY_CURRENT_USER,  "Control Panel\\MingW32\\NLS", 0, KEY_READ, &reg );      if (!create_mokey)
137          if( rc_ok( rc ) ) {          return 0;
138              RegCloseKey( reg );  
139              return 0;        rc = RegOpenKeyEx (HKEY_CURRENT_USER,  GPG_MO_REG, 0, KEY_READ, &reg);
140          }      if (rc == ERROR_SUCCESS) {
141          rc = RegCreateKey( HKEY_CURRENT_USER, "Control Panel\\MingW32\\NLS", &reg );          RegCloseKey (reg);
142          if( !rc_ok( rc ) )          return 0;      
             return WPTERR_REGISTRY;      
         RegCloseKey( reg );  
143      }      }
144        rc = RegCreateKey (HKEY_CURRENT_USER, GPG_MO_REG, &reg);
145        if (rc != ERROR_SUCCESS)
146            return WPTERR_REGISTRY;
147    
148        RegCloseKey (reg);
149      return 0;      return 0;
150  }  }
151    
152    
153    /* Create a new filetype in the W32 registry.
154       We should really care of errors! Otherwise we can damage the registry! */
155    static int
156    create_file_type (const char *exefile, const char *ext,
157                      const char *extname, char *iconfile)
158    {
159        HKEY reg = NULL;
160        char deficon[MAX_PATH+1];
161        char defexec[MAX_PATH+1];
162        char p_exefile[MAX_PATH+1];
163        int rc;
164        
165        rc = RegCreateKey (HKEY_CLASSES_ROOT, ext, &reg);
166        if( rc_ok( rc ) )
167            rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *)extname, strlen( extname ) );
168        if( rc_ok( rc ) )
169            rc = RegCloseKey( reg );
170        if( rc_ok( rc ) )    
171            rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );
172        if( rc_ok( rc ) )
173            rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *) extname, strlen( extname ) );
174        if( rc_ok( rc ) )
175            rc = RegCloseKey( reg );
176        if( !rc_ok( rc ) ) {
177            rc = WPTERR_REGISTRY;
178            goto leave;
179        }
180        
181        memset( &deficon, 0, sizeof deficon );
182        _snprintf( deficon, DIM (deficon) - 1, "%s\\DefaultIcon", extname );
183        memset( &defexec, 0, sizeof defexec );
184        _snprintf( defexec, DIM (defexec) - 1, "%s\\shell\\open\\command", extname );      
185        memset( &p_exefile, 0, sizeof p_exefile );
186        _snprintf( p_exefile, DIM (p_exefile) - 1, "%s %%1", exefile );
187        
188        rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );
189        if( rc_ok( rc ) )
190            rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (BYTE *)iconfile, strlen( iconfile ) );
191        if( rc_ok( rc ) )
192            rc = RegCloseKey( reg );
193        if( rc_ok( rc ) )
194            rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );
195        if( rc_ok( rc ) )
196            rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (BYTE *)p_exefile, strlen( exefile ) );
197        if( rc_ok( rc ) )
198            rc = RegCloseKey( reg );
199        if( !rc_ok( rc ) ) {
200            rc = WPTERR_REGISTRY;
201            goto leave;    
202        }
203        
204    leave:
205        if (reg)
206            RegCloseKey (reg);
207        return rc;
208    }
209    
210    
211    /* Register the given WinPT filetype. */
212    static int
213    regist_single_filetype (gpg_filetype_t gfile)
214    {
215        char icon[MAX_PATH+1] = {0};
216        char prog[MAX_PATH+1] = {0};
217    
218        if (!GetModuleFileName (glob_hinst, prog, DIM (prog)-1))
219            return WPTERR_REGISTRY;
220        _snprintf (icon, DIM (icon) -1, "%s,%d", prog, gfile->nicon);
221        return create_file_type (prog, gfile->ext, gfile->descr, icon);
222    }
223    
224  /* Install WinPT into the W32 registry, if the entry already  /* Install WinPT into the W32 registry, if the entry already
225     exists the function returns immediately. @with_ext can be     exists the function returns immediately. @with_ext can be
226     used to register some file types (if 1). @created contains     used to register some file types (if 1). @created contains
# Line 155  regist_inst_gnupg (int create_mokey) Line 228  regist_inst_gnupg (int create_mokey)
228     Return value: 0 on success. */     Return value: 0 on success. */
229  int  int
230  regist_inst_winpt (int with_ext, int *created)  regist_inst_winpt (int with_ext, int *created)
231  {      {
232      HKEY reg;      struct gpg_filetype_s gpg_filetypes[] = {
     char *p = NULL;  
     char modpath[MAX_PATH+1];  
     int rc, i, id, n = 0;  
   
     gpg_filetype gpg_filetypes[] = {  
233          {_("GPG Detached Signature"), ".sig", 1},          {_("GPG Detached Signature"), ".sig", 1},
234          {_("GPG Encrypted Data"),     ".gpg", 2},          {_("GPG Encrypted Data"),     ".gpg", 2},
235          {_("GPG Armored Data"),       ".asc", 2},          {_("GPG Armored Data"),       ".asc", 2},
236          {0}          {0}
237      };      };
238        HKEY reg;
239        char *p = NULL;
240        char modpath[MAX_PATH+1];
241        int rc, i, id, n;
242    
243      if (created)      if (created)
244          *created = 0;          *created = 0;
245    
246      p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, "Extensions");      /* If GPGee is already installed deactivate file extension registering
247      if ((p && *p == '1') || is_gpgee_installed ())         because it is very likely this would overwrite the GPGee settings. */
248        if (is_gpgee_installed ())
249          with_ext = 0;          with_ext = 0;
     free_if_alloc (p);  
250    
     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:  
251      rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);      rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG, 0, KEY_READ, &reg);
252      if (rc_ok (rc)) {      if (rc == ERROR_SUCCESS) {
253          RegCloseKey (reg);          RegCloseKey (reg);
254          rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg);          rc = RegOpenKeyEx (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", 0, KEY_READ, &reg);
255          if (!rc_ok (rc)) {          if (rc != ERROR_SUCCESS) {
256              RegCreateKey (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg);              rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", &reg);
257              RegCloseKey (reg);              if (rc == ERROR_SUCCESS)
258                    RegCloseKey (reg);
259          }          }
260            else
261                RegCloseKey (reg);
262          p = get_reg_entry_keyserver ("Default");          p = get_reg_entry_keyserver ("Default");
263          if (!p) {          if (!p) {
264              char buf[16];              char buf[16];
265              sprintf (buf, "%d", HKP_PORT);  
266                _snprintf (buf, DIM (buf)-1, "%d", HKP_PORT);
267              set_reg_entry_keyserver ("Default_Port", buf);              set_reg_entry_keyserver ("Default_Port", buf);
268              set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);              set_reg_entry_keyserver ("Default", DEF_HKP_KEYSERVER);
269          }          }
270          free_if_alloc (p);          free_if_alloc (p);
         if (n)  
             set_reg_entry( HKEY_CURRENT_USER, WINPT_REG, "Extensions", "1" );  
271          return 0;          return 0;
272      }      }
273      rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);      rc = RegCreateKey (HKEY_CURRENT_USER, WINPT_REG, &reg);
274      if (!rc_ok (rc))      if (rc != ERROR_SUCCESS)
275          return WPTERR_REGISTRY;          return WPTERR_REGISTRY;
276      if (created)      if (created)
277          *created = 1;          *created = 1;
278      RegCloseKey (reg);      RegCloseKey (reg);
279      if (n > 0 || is_gpgee_installed ())      if (with_ext) {
280          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 "
281                                  "be processed with a double click in the explorer.\n"
282                                  "Do you want to continue?"), _("WinPT"), MB_YESNO|MB_INFO);
283            if (id == IDYES) {
284                for (i = 0; gpg_filetypes[i].ext; i++) {
285                    rc = RegOpenKeyEx (HKEY_CLASSES_ROOT, gpg_filetypes[i].ext, 0, KEY_READ, &reg);
286                    if (rc == ERROR_SUCCESS) {
287                        RegCloseKey (reg);
288                        id = log_box (_("WinPT WARNING"), MB_YESNO|MB_INFO,
289                                      _("It seems there was already a '%s' file type registered by another application.\n"
290                                        "Do you want to overwrite it?"), gpg_filetypes[i].ext);
291                        if (id == IDNO)
292                            continue;
293                    }
294                    regist_single_filetype (&gpg_filetypes[i]);
295                }
296            }
297        }
298        /* Store the install directory for later use. */
299      if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {      if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
300          while (n-- > 0) {          while (n-- > 0) {
301              if (modpath[n] == '\\') {              if (modpath[n] == '\\') {
# Line 241  start: Line 309  start:
309  }  }
310    
311    
 /* Create a new filetype in the W32 registry.  
    We should really care of errors! Otherwise we can damage the registry! */  
 int  
 create_file_type (const char *exefile, const char *ext,  
                   const char *extname, char *iconfile)  
 {  
     int rc;  
     HKEY reg = NULL;  
     char deficon[256], defexec[256], p_exefile[256];  
       
       
     rc = RegCreateKey( HKEY_CLASSES_ROOT, ext, &reg );  
     if( rc_ok( rc ) )  
         rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)extname, strlen( extname ) );  
     if( rc_ok( rc ) )  
         rc = RegCloseKey( reg );  
     if( rc_ok( rc ) )      
         rc = RegCreateKey( HKEY_CLASSES_ROOT, extname, &reg );  
     if( rc_ok( rc ) )  
         rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *) extname, strlen( extname ) );  
     if( rc_ok( rc ) )  
         rc = RegCloseKey( reg );  
     if( !rc_ok( rc ) ) {  
         rc = WPTERR_REGISTRY;  
         goto leave;  
     }  
       
     memset( &deficon, 0, sizeof deficon );  
     _snprintf( deficon, sizeof deficon - 1, "%s\\DefaultIcon", extname );  
     memset( &defexec, 0, sizeof defexec );  
     _snprintf( defexec, sizeof defexec - 1, "%s\\shell\\open\\command", extname );        
     memset( &p_exefile, 0, sizeof p_exefile );  
     _snprintf( p_exefile, sizeof p_exefile - 1, "%s %%1", exefile );  
       
     rc = RegCreateKey( HKEY_CLASSES_ROOT, deficon, &reg );  
     if( rc_ok( rc ) )  
         rc = RegSetValueEx(reg, NULL, 0, REG_SZ, (byte *)iconfile, strlen( iconfile ) );  
     if( rc_ok( rc ) )  
         rc = RegCloseKey( reg );  
     if( rc_ok( rc ) )  
         rc = RegCreateKey( HKEY_CLASSES_ROOT, defexec, &reg );  
     if( rc_ok( rc ) )  
         rc = RegSetValueEx( reg, NULL, 0, REG_SZ, (byte *)p_exefile, strlen( exefile ) );  
     if( rc_ok( rc ) )  
         rc = RegCloseKey( reg );  
     if( !rc_ok( rc ) ) {  
         rc = WPTERR_REGISTRY;  
         goto leave;      
     }  
       
 leave:  
     if( reg )  
         RegCloseKey( reg );  
     return rc;  
 } /* create_file_type */  
   
   
312  /* Expand a string with %foo% entries so that %foo% will  /* Expand a string with %foo% entries so that %foo% will
313     be replaced with its actual value. */     be replaced with its actual value. */
314  static char *  static char*
315  expand_path (const char *path)  expand_path (const char *path)
316  {  {
317      DWORD len;      DWORD len;
# Line 326  expand_path (const char *path) Line 337  expand_path (const char *path)
337     and the key given in @key.     and the key given in @key.
338     Return value is the value or NULL otherwise. */     Return value is the value or NULL otherwise. */
339  char*  char*
340  get_reg_entry (HKEY root_key, const char * dir, const char * key)  get_reg_entry (HKEY root_key, const char *dir, const char *key)
341  {  {
     int rc;  
     char text[384] = {0};  
     DWORD nbytes, type;  
342      HKEY reg_key = NULL;      HKEY reg_key = NULL;
343      char * p = NULL;      char *p = NULL, *pp;    
344            DWORD type = REG_SZ, nbytes = 0;
345        int rc;
346    
347      rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);      rc = RegOpenKeyEx (root_key, dir, 0, KEY_QUERY_VALUE, &reg_key);
348      if( !rc_ok( rc ) )      if (rc != ERROR_SUCCESS)
349          goto leave;          goto leave;
350      nbytes = sizeof (text) - 1;      rc = RegQueryValueEx (reg_key, key, NULL, &type, NULL, &nbytes);
351      type = REG_SZ;      if (rc != ERROR_SUCCESS)
       
     rc = RegQueryValueEx (reg_key, key, 0, &type, (BYTE *)&text, &nbytes);  
     if (!rc_ok (rc) || !nbytes)  
352          goto leave;          goto leave;
353            if (!nbytes)
354      if (type == REG_EXPAND_SZ && strchr (text, '%'))          goto leave; /* empty */
355          p = expand_path (text);      p = new char[nbytes+1];
356      else {      if (!p)
357          p = new char[nbytes + 1];          BUG (0);
358          if (!p)      rc = RegQueryValueEx (reg_key, key, NULL, &type, (BYTE*)p,  &nbytes);
359              BUG (0);      if (rc != ERROR_SUCCESS)
360          memcpy (p, text, nbytes);          goto leave;
361          p[nbytes] = '\0';      if (type == REG_EXPAND_SZ && strchr (p, '%')) {
362            pp = p;
363            p = expand_path (pp);
364            free_if_alloc (pp);
365      }      }
366        
367  leave:  leave:
368      if (reg_key)      if (reg_key != NULL)
369          RegCloseKey (reg_key);          RegCloseKey (reg_key);
370      return p;      return p;
371  }  }
# Line 369  int Line 379  int
379  set_reg_entry (HKEY root_key, const char *dir, const char *key,  set_reg_entry (HKEY root_key, const char *dir, const char *key,
380                 const char *value)                 const char *value)
381  {  {
     int rc = 0;  
382      HKEY reg_key;      HKEY reg_key;
383        int rc;
384    
385      rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );      rc = RegOpenKeyEx (root_key, dir, 0, KEY_WRITE, &reg_key);
386      if( !rc_ok( rc ) )      if (rc != ERROR_SUCCESS)
387          return WPTERR_REGISTRY;          return WPTERR_REGISTRY;
388      rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );      rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
389      if( !rc_ok( rc ) )      if (rc != ERROR_SUCCESS)
390          rc = WPTERR_REGISTRY;            rc = WPTERR_REGISTRY;  
391      RegCloseKey( reg_key );      RegCloseKey (reg_key);
392      return rc;      return rc;
393  } /* set_reg_entry */  }
394    
395    
396  int  int
397  set_reg_key( HKEY root_key, const char * dir, const char * key,  set_reg_key (HKEY root_key, const char *dir, const char *key,
398               const char * value )               const char *value)
399  {  {    
     int rc = 0;  
400      HKEY reg_key;      HKEY reg_key;
401        int rc;
402            
403      rc = RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key );      rc = RegOpenKeyEx (root_key, dir, 0, KEY_WRITE, &reg_key);
404      if( !rc_ok( rc ) )      if (rc != ERROR_SUCCESS)
405          return WPTERR_REGISTRY;          return WPTERR_REGISTRY;
406            
407      rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );            rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
408      if( !rc_ok( rc ) ) {              if (rc != ERROR_SUCCESS) {
409          if ( RegCreateKey( root_key, key, &reg_key ) != ERROR_SUCCESS ) {          if (RegCreateKey (root_key, key, &reg_key) != ERROR_SUCCESS) {
410              rc = WPTERR_REGISTRY;              rc = WPTERR_REGISTRY;
411              goto leave;              goto leave;
412          }          }
413          rc = RegSetValueEx( reg_key, key, 0, REG_SZ, (BYTE *)value, strlen( value ) );                    rc = RegSetValueEx (reg_key, key, 0, REG_SZ, (BYTE *)value, strlen (value));
414          if ( !rc_ok( rc ) )          if (rc != ERROR_SUCCESS)
415              rc = WPTERR_REGISTRY;              rc = WPTERR_REGISTRY;
416      }      }
417            
418  leave:  leave:
419      RegCloseKey( reg_key );      RegCloseKey (reg_key);
420      return rc;      return rc;
 } /* set_reg_key */  
   
   
 int  
 set_reg_entry_gpg (const char * key, const char * value)  
 {        
     return set_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key, value);  
421  }  }
422    
423    
424  int  int
425  set_reg_entry_mo (const char * value)  set_reg_entry_gpg (const char *key, const char *value)
426  {        {      
427      return set_reg_entry (HKEY_CURRENT_USER, "Control Panel\\Mingw32\\NLS",      return set_reg_entry (HKEY_CURRENT_USER, GPG_REG, key, value);
                           "MODir", value);  
428  }  }
429    
430    
431    
432  char*  char*
433  get_reg_entry_gpg (const char *key)  get_reg_entry_gpg (const char *key)
434  {  {
435      char *p;      char *p;
436      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\GNU\\GnuPG", key);  
437        p = get_reg_entry (HKEY_CURRENT_USER, GPG_REG, key);
438      if (!p || strlen (p) == 0) {      if (!p || strlen (p) == 0) {
439          free_if_alloc (p);          free_if_alloc (p);
440          return NULL;          return NULL;
# Line 444  get_reg_entry_gpg (const char *key) Line 448  get_reg_entry_gpg (const char *key)
448  char*  char*
449  get_reg_entry_gpg4win (const char *path)  get_reg_entry_gpg4win (const char *path)
450  {  {
451        const char *fmt;
452      char *p, *pp;      char *p, *pp;
453      p = get_reg_entry (HKEY_LOCAL_MACHINE,  
454                         "Software\\GNU\\GnuPG", "Install Directory");      p = get_reg_entry (HKEY_LOCAL_MACHINE, GPG_REG, "Install Directory");
455      if (!p)      if (!p)
456          return NULL;          return NULL;
457      if (!path)      if (!path)
458          return p;          return p;
459      pp = new char[strlen (p) + strlen (path) + 4];      fmt = "%s\\%s";
460        pp = new char[strlen (p) + strlen (path) + strlen (fmt) + 1];
461      if (!pp)      if (!pp)
462          BUG (NULL);          BUG (NULL);
463      sprintf (pp, "%s\\%s", p, path);      sprintf (pp, fmt, p, path);
464      free_if_alloc (p);      free_if_alloc (p);
465      return pp;      return pp;
466  }  }
# Line 464  char* Line 470  char*
470  get_reg_entry_mo (void)  get_reg_entry_mo (void)
471  {        {      
472      char *p, *pp;      char *p, *pp;
473        const char *fmt;
474      const char *lang;      const char *lang;
475    
476      p = get_reg_entry (HKEY_CURRENT_USER,      p = get_reg_entry (HKEY_CURRENT_USER, GPG_MO_REG, "MODir");
                        "Control Panel\\Mingw32\\NLS", "MODir");  
477      if (p)      if (p)
478          return p;          return p;
479    
480      lang = get_gettext_langid ();      lang = gettext_get_langid ();
481      if (!lang)          if (!lang)
482          return NULL;              return NULL;
483      pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];      fmt = "share\\locale\\%s\\LC_MESSAGES";
484        pp = new char[strlen (fmt) + strlen (lang) + 4 + 1];
485      if (!pp)          if (!pp)    
486          BUG (NULL);          BUG (NULL);
487      sprintf (pp, "share\\locale\\%s\\LC_MESSAGES", lang);      sprintf (pp, fmt, lang);
488      p = get_reg_entry_gpg4win (pp);      p = get_reg_entry_gpg4win (pp);
489      free_if_alloc (pp);      free_if_alloc (pp);
490      return p;      return p;
491  }  }
492    
493    
 /* All valid configuration commands. */  
 static const char * cfg [] = {  
         NULL,  
         "CacheTime",  
         "WordWrap",  
         "FastMode",  
         "Viewer",  
         "KeylistMode",  
         "WipeMode",  
         "AlwaysTrust",  
         "AutoBackup",  
         "BackupMode",  
         "DisableHotkeys",        
         "NoCompressMultiMedia",  
         "Expert",  
         "FMProgressBar",  
     };  
   
   
494  int  int
495  set_reg_winpt_single (int id, int val)  set_reg_winpt_single (int id, int val)
496  {  {
497      char buf[64];      char buf[64];
498      int rc;      int rc;
499    
500      sprintf (buf, "%d", val);      _snprintf (buf, DIM (buf)-1, "%d", val);
501      rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id], buf);      rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id], buf);
502      return rc;      return rc;
503  }  }
# Line 518  set_reg_winpt_single (int id, int val) Line 506  set_reg_winpt_single (int id, int val)
506  int  int
507  get_reg_winpt_single (int id)  get_reg_winpt_single (int id)
508  {  {
509      char * buf = NULL;      char *buf;
510      int val = 0;      int val = 0;
511    
512      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
# Line 533  get_reg_winpt_single (int id) Line 521  get_reg_winpt_single (int id)
521    
522  /* Saves the winpt preferences in the registry. */  /* Saves the winpt preferences in the registry. */
523  int  int
524  set_reg_winpt_prefs (winpt_reg_prefs_s * opt)  set_reg_winpt_prefs (winpt_prefs_t opt)
525  {  {
526      char buf[128];      char buf[128];
527      size_t i;      size_t i;
# Line 544  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 532  set_reg_winpt_prefs (winpt_reg_prefs_s *
532          case CFG_CACHETIME:          case CFG_CACHETIME:
533              sprintf (buf, "%d", opt->cache_time);              sprintf (buf, "%d", opt->cache_time);
534              break;              break;
535                
536          case CFG_WORDWRAP:          case CFG_WORDWRAP:
537              sprintf (buf, "%d", opt->word_wrap);              sprintf (buf, "%d", opt->word_wrap);
538              break;              break;
539          case CFG_WIPEMODE:              
540              sprintf (buf, "%d", opt->wipe_mode);          case CFG_FILEEXT:
541              break;              sprintf (buf, "%d", opt->default_ext);
         case CFG_FASTMODE:  
             sprintf (buf, "%d", opt->use_tmpfiles);  
542              break;              break;
543                
544          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
545              sprintf (buf, "%d", opt->no_zip_mmedia);              sprintf (buf, "%d", opt->no_zip_mmedia);
546              break;              break;
547                
548          case CFG_VIEWER:          case CFG_VIEWER:
549              sprintf (buf, "%d", opt->use_viewer);              sprintf (buf, "%d", opt->use_viewer);
550              break;              break;
551          case CFG_KEYLISTMODE:              
             sprintf (buf, "%d", opt->keylist_mode);  
             break;  
552          case CFG_ALWAYSTRUST:          case CFG_ALWAYSTRUST:
553              sprintf (buf, "%d", opt->always_trust);              sprintf (buf, "%d", opt->always_trust);
554              break;              break;
555    
556          case CFG_AUTOBACKUP:          case CFG_AUTOBACKUP:
557              sprintf (buf, "%d", opt->auto_backup);              sprintf (buf, "%d", opt->auto_backup);
558              break;              break;
559                
560          case CFG_AUTOBAKMODE:          case CFG_AUTOBAKMODE:
561              sprintf (buf, "%d", opt->backup.mode);              sprintf (buf, "%d", opt->backup.mode);
562              break;              break;
563                
564          case CFG_DISHOTKEYS:          case CFG_DISHOTKEYS:
565              sprintf (buf, "%d", opt->no_hotkeys);              sprintf (buf, "%d", opt->no_hotkeys);
566              break;              break;
567                
568          case CFG_EXPERT:          case CFG_EXPERT:
569              sprintf (buf, "%d", opt->expert);              sprintf (buf, "%d", opt->expert);
570              break;              break;
# Line 581  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 572  set_reg_winpt_prefs (winpt_reg_prefs_s *
572          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
573              sprintf (buf, "%d", opt->fm.progress);              sprintf (buf, "%d", opt->fm.progress);
574              break;              break;
575    
576            case CFG_BACKUP_INC_SKR:
577                sprintf (buf, "%d", opt->backup.include_secr);
578                break;
579          }          }
580          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
581          if (rc)          if (rc)
# Line 594  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 589  set_reg_winpt_prefs (winpt_reg_prefs_s *
589              goto leave;              goto leave;
590      }      }
591    
592      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name != NULL; i++) {
593          strcpy (buf, " ");          if (wpt_hotkeys[i].enabled == 1) {
594          if (reg_hotkeys[i].enabled)              buf[0] = wpt_hotkeys[i].key;
595              strcpy (buf, reg_hotkeys[i].key);              buf[1] = 0;
596            }
597            else
598                strcpy (buf, " ");
599          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,
600                            reg_hotkeys[i].reg_entry, buf);                            wpt_hotkeys[i].name, buf);
601          if (rc)          if (rc)
602              break;              break;
603      }      }
# Line 614  leave: Line 612  leave:
612    
613    
614  int  int
615  set_reg_winpt_flag (const char * name, int val)  set_reg_winpt_flag (const char *name, int val)
616  {  {
617      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");
618  } /* set_reg_winpt_flag */  }
619    
620    
621  int  int
622  get_reg_winpt_flag (const char * name)  get_reg_winpt_flag (const char *name)
623  {  {
624      char * buf;      char *buf;
625      int flag = 0;      int flag = 0;
626    
627      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name);      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name);
628      if (buf && buf[0] == '1')      if (buf && buf[0] == '1')
629          flag = 1;          flag = 1;
630      else if (!buf || buf && buf[0] != '0')      else if (!buf || (buf && buf[0] != '0'))
631          flag = -1;          flag = -1;
632      free_if_alloc (buf);      free_if_alloc (buf);
633      return flag;      return flag;
634  } /* get_reg_winpt_flag */  }
635    
636    
637  /* Retrieve the winpt preferences from the registry. */  /* Retrieve the winpt preferences from the registry. */
638  int  int
639  get_reg_winpt_prefs (winpt_reg_prefs_s * opt)  get_reg_winpt_prefs (winpt_prefs_t opt)
640  {  {
641      char *val = NULL;      char *val = NULL;
642      size_t i;      size_t i;
# Line 651  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 649  get_reg_winpt_prefs (winpt_reg_prefs_s *
649          }          }
650          switch (i) {          switch (i) {
651          case CFG_CACHETIME:          case CFG_CACHETIME:
652              opt->cache_time = atol (val);              opt->cache_time = atoi (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;  
653              break;              break;
654          case CFG_WORDWRAP:          case CFG_WORDWRAP:
655              opt->word_wrap = atol (val);              opt->word_wrap = atoi (val);
656              break;              break;
657          case CFG_FASTMODE:          case CFG_FILEEXT:
658              opt->use_tmpfiles = atol (val);              opt->default_ext = atoi (val);
659              break;              break;
660          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
661              opt->no_zip_mmedia = atol (val);              opt->no_zip_mmedia = atoi (val);
662              break;              break;
663          case CFG_VIEWER:          case CFG_VIEWER:
664              opt->use_viewer = atol (val);              opt->use_viewer = atoi (val);
             break;  
         case CFG_KEYLISTMODE:  
             opt->keylist_mode = atol (val);  
             break;  
         case CFG_WIPEMODE:  
             opt->wipe_mode = atol (val);  
665              break;              break;
666          case CFG_DISHOTKEYS:          case CFG_DISHOTKEYS:
667              opt->no_hotkeys = atol (val);              opt->no_hotkeys = atoi (val);
668              break;              break;
669          case CFG_ALWAYSTRUST:          case CFG_ALWAYSTRUST:
670              opt->always_trust = atol (val);              opt->always_trust = atoi (val);
671              break;              break;
672          case CFG_AUTOBACKUP:          case CFG_AUTOBACKUP:
673              opt->auto_backup = atol (val);              opt->auto_backup = atoi (val);
674              break;              break;
675          case CFG_AUTOBAKMODE:          case CFG_AUTOBAKMODE:
676              opt->backup.mode = atol (val);              opt->backup.mode = atoi (val);
677              break;              break;
678          case CFG_EXPERT:          case CFG_EXPERT:
679              opt->expert = atol (val);              opt->expert = atoi (val);
680              break;              break;
   
681          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
682              opt->fm.progress = atol (val);              opt->fm.progress = atoi (val);
683                break;
684    
685            case CFG_BACKUP_INC_SKR:
686                opt->backup.include_secr = atoi (val);
687              break;              break;
688          }          }
689          free_if_alloc (val);          free_if_alloc (val);
# Line 704  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 694  get_reg_winpt_prefs (winpt_reg_prefs_s *
694          opt->backup.path = m_strdup (val);          opt->backup.path = m_strdup (val);
695      free_if_alloc (val);      free_if_alloc (val);
696            
697      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name; i++) {
698          val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);          wpt_hotkeys[i].enabled = 0;
699            val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, wpt_hotkeys[i].name);
700          if (val && val[0] != ' ') {          if (val && val[0] != ' ') {
701              reg_hotkeys[i].key[0] = *val;              wpt_hotkeys[i].key = *val;
702              reg_hotkeys[i].enabled = 1;              wpt_hotkeys[i].enabled = 1;
703          }          }
         else  
             reg_hotkeys[i].enabled = 0;  
704          free_if_alloc (val);          free_if_alloc (val);
705      }      }
706      return 0;      return 0;
707  } /* get_reg_winpt_prefs */  }
708    
709    
710  char*  char*
711  get_reg_entry_keyserver (const char *name)  get_reg_entry_keyserver (const char *name)
712  {  {
713      char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);      char *p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
714      if (p && !strcmp (p, "")) {      if (p && (!strcmp (p, "") || strlen (p) == 0)) {
715          free_if_alloc (p);          free_if_alloc (p);
716          return NULL;          return NULL;
717      }      }
# Line 730  get_reg_entry_keyserver (const char *nam Line 719  get_reg_entry_keyserver (const char *nam
719  }  }
720    
721    
 void  
 get_reg_proxy_prefs (char ** host, int * port, char ** user, char ** pass)  
 {  
     if (host)  
         *host = get_reg_entry_keyserver ("Host");  
     if (user)  
         *user = get_reg_entry_keyserver ("User");  
     if (pass)  
         *pass = get_reg_entry_keyserver ("Pass");  
     if (port) {  
         char * p = get_reg_entry_keyserver ("Port");  
         if (p) {  
             *port = atol (p);  
             free_if_alloc (p);  
         }  
     }  
 } /* get_reg_proxy_prefs */  
   
   
722  int  int
723  set_reg_entry_keyserver( const char * name, const char * val )  set_reg_entry_keyserver (const char *name, const char *val)
724  {  {
725      return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );      return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val);
726  } /* set_reg_entry_keyserver */  }
   
727    
 int  
 set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )  
 {  
     int rc;  
       
     rc = set_reg_entry_keyserver( "Host", host? host : "" );  
     if( !rc ) {  
         char buf[32];  
         sprintf( buf, "%d", port );  
         rc = set_reg_entry_keyserver( "Port", buf );  
     }  
     if( !rc )  
         rc = set_reg_entry_keyserver( "User", user? user : "" );  
     if( !rc )  
         rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );  
     return rc;  
 } /* set_reg_proxy_prefs */  
Legend:
Removed from v.167  
changed lines
  Added in v.328
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26