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

Diff of /trunk/Src/wptGPG.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 42 by werner, Fri Oct 28 08:25:30 2005 UTC revision 138 by twoaday, Mon Jan 9 14:20:00 2006 UTC
# Line 22  Line 22 
22  #endif  #endif
23    
24  #include <windows.h>  #include <windows.h>
 #include <windows.h>  
25  #include <string.h>  #include <string.h>
26  #include <stdio.h>  #include <stdio.h>
27  #include <shlobj.h>  #include <shlobj.h>
# Line 31  Line 30 
30  #include <time.h>  #include <time.h>
31    
32  #include "wptGPG.h"  #include "wptGPG.h"
33  #include "wptGPGCmds.h"  #include "wptGpgCmds.h"
34  #include "wptGPGOptSkel.h"  #include "wptGPGOptSkel.h"
35  #include "wptTypes.h"  #include "wptTypes.h"
36  #include "wptNLS.h"  #include "wptNLS.h"
# Line 40  Line 39 
39  #include "wptW32API.h"  #include "wptW32API.h"
40  #include "wptCrypto.h"  #include "wptCrypto.h"
41    
42  #define GPG_CONF "gpg.conf"  #define GPG_CONF        "gpg.conf"
43    #define GPG_REG_EXE     "gpgProgram"    /* registry name for the binary. */
44    #define GPG_REG_HOME    "HomeDir"       /* registry name of the home dir. */
45    
46  struct gpg_watcher_s {  struct gpg_watcher_s {
47      FILETIME    last_access;      FILETIME    last_access;
# Line 61  static int check_keyring (char ** r_path Line 62  static int check_keyring (char ** r_path
62    
63    
64  /* Return the application data folder of the current user. */  /* Return the application data folder of the current user. */
65  static char*  char*
66  multi_gnupg_path (void)  multi_gnupg_path (int strict)
67  {  {
68      static char buf[256+64];      static char buf[256+64];
69      BOOL ec;      BOOL ec;
# Line 71  multi_gnupg_path (void) Line 72  multi_gnupg_path (void)
72      memset (buf, 0, sizeof (buf));      memset (buf, 0, sizeof (buf));
73      /* XXX: ec should be NOERROR (MSDN) but NOERROR is defined as '0' !? */      /* XXX: ec should be NOERROR (MSDN) but NOERROR is defined as '0' !? */
74      ec = SHGetSpecialFolderPath (HWND_DESKTOP, buf, CSIDL_APPDATA, TRUE);      ec = SHGetSpecialFolderPath (HWND_DESKTOP, buf, CSIDL_APPDATA, TRUE);
75      if (ec != 1)      if (ec != 1) {
76            log_debug ("multi_gnupg_path: SHGetSpecialFolderPath() failed\r\n",
77                       (int)GetLastError ());
78          return NULL;          return NULL;
79        }
80      strcat (buf, "\\gnupg");      strcat (buf, "\\gnupg");
81      if (access (buf, 00))      if (strict && access (buf, 00))
82          return NULL;          return NULL;
83      return m_strdup (buf);      return m_strdup (buf);
84  }  }
85    
86    
87  /* Return the full path of the GnuPG application. First the registry is scanned  /* Return the full path to the GPG home directory. First the 'HomeDir' entry
88     for the entry 'HomeDir'. If it wasn't set, the default dir C:\GNUPG is used.     from the registry is used. Then the default $APPDATA\gnupg path. */
 */  
89  char*  char*
90  get_gnupg_path (void)  get_gnupg_path (void)
91  {  {
92      char *p = NULL, *path = NULL;      char *path;
93        
94      p = get_reg_entry_gpg ("HomeDir");      path = get_reg_entry_gpg (GPG_REG_HOME);
95      if (p) {      if (path) {
96          path = m_strdup (p);          if (dir_exist_check (path) == 0)
97          free_if_alloc (p);              return path;
98          return path;          free_if_alloc (path);
99      }      }
100      else      path = multi_gnupg_path (1);
101          return multi_gnupg_path ();      return path;
     return m_strdup ("c:\\gnupg");  
102  }  }
103    
104    
# Line 105  get_gnupg_path (void) Line 107  get_gnupg_path (void)
107  char*  char*
108  get_gnupg_cfgfile (void)  get_gnupg_cfgfile (void)
109  {      {    
110      char *p = NULL, *optfile = NULL, *path = NULL;      char *p = NULL;
111        char *optfile = NULL;
112        char *path = NULL;
113      size_t nlen = 0;      size_t nlen = 0;
114    
115      path = get_gnupg_path ();      path = get_gnupg_path ();
# Line 152  get_gnupg_keyring (int pub, int strict) Line 156  get_gnupg_keyring (int pub, int strict)
156      if (!path)      if (!path)
157          return NULL;          return NULL;
158      keyring = make_filename (path, pub? "pubring" : "secring", "gpg");      keyring = make_filename (path, pub? "pubring" : "secring", "gpg");
159      if (!strict && !file_exist_check (keyring)) {      if (strict && !file_exist_check (keyring)) {
160          free_if_alloc (path);          free_if_alloc (path);
161          return keyring;          return keyring;
162      }      }
163      if (file_exist_check (keyring) || get_file_size (keyring) == 0) {      else if (!strict) {
164            free_if_alloc (path);
165            return keyring;
166        }
167        if (file_exist_check (keyring) || pub && get_file_size (keyring) == 0) {
168          free_if_alloc (keyring);          free_if_alloc (keyring);
169          optfile = make_filename (path, GPG_CONF, NULL);          optfile = make_filename (path, GPG_CONF, NULL);
170          keyring = get_gnupg_keyring_from_options (optfile, pub);          keyring = get_gnupg_keyring_from_options (optfile, pub);
# Line 170  get_gnupg_keyring (int pub, int strict) Line 178  get_gnupg_keyring (int pub, int strict)
178  /* Return the full path (with the gpg exe name). First the registry is scanned  /* Return the full path (with the gpg exe name). First the registry is scanned
179     for the entry 'gpgProgram'. If it wasn't set, the default path is the     for the entry 'gpgProgram'. If it wasn't set, the default path is the
180     appended string 'gpg.exe' is used. */     appended string 'gpg.exe' is used. */
181    
182    /* FIXME:  Use gpgme's engine info here. */
183  char*  char*
184  get_gnupg_prog (void)  get_gnupg_prog (void)
185  {      {    
186      char *p;      char *p;
187      char *pgm = NULL;      char *pgm = NULL;
     size_t nlen = 0;  
188    
189      p = get_reg_entry_gpg ("gpgProgram");      p = get_reg_entry_gpg (GPG_REG_EXE);
190      if (!p) {      if (!p) {
191          char *path = get_gnupg_path ();          char *path = get_gnupg_path ();
192          if (!path)          if (!path)
# Line 199  get_gnupg_prog (void) Line 208  get_gnupg_prog (void)
208  static char *  static char *
209  default_key_from_cache (int *ret_no_useable)  default_key_from_cache (int *ret_no_useable)
210  {  {
211      const char * s;      const char *s;
212      char * keyid = NULL;      char *keyid = NULL;
213      gpgme_key_t key;      gpgme_key_t key;
214      gpg_keycache_t sec = keycache_get_ctx (0);      gpg_keycache_t sec = keycache_get_ctx (0);
215    
# Line 215  default_key_from_cache (int *ret_no_usea Line 224  default_key_from_cache (int *ret_no_usea
224              break;              break;
225          }          }
226      }      }
227      if (!keyid) {      if (!keyid)
228          *ret_no_useable = 1;          *ret_no_useable = 1;
         msg_box (NULL, _("No useable secret key found."), _("GPG Error"), MB_ERR);  
     }  
229      return keyid;      return keyid;
230  }  }
231    
# Line 262  get_gnupg_default_key (void) Line 269  get_gnupg_default_key (void)
269          return default_key_from_cache (&no_usable);          return default_key_from_cache (&no_usable);
270      rc = parse_gpg_options (optfile, &opt);      rc = parse_gpg_options (optfile, &opt);
271      if (rc) {      if (rc) {
272          free_if_alloc( optfile );          free_if_alloc (optfile);
273          return default_key_from_cache( &no_usable );          return default_key_from_cache (&no_usable);
274      }      }
275      e = find_option( opt, "default-key" );      e = find_option( opt, "default-key" );
276      if ( e )      if ( e )
# Line 287  get_gnupg_default_key (void) Line 294  get_gnupg_default_key (void)
294  } /* get_gnupg_default_key */  } /* get_gnupg_default_key */
295    
296    
297    /* Check if GPG4WIN is available and if so, use the
298       install path to figure out where the gpg.exe is. */
299    char*
300    check_for_gpg4win (void)
301    {
302        return get_reg_entry_gpg4win ("gpg.exe");
303    }
304    
305    
306  /* Check if the gpg application (exe file) is available. */  /* Check if the gpg application (exe file) is available. */
307  int  int
308  check_gnupg_prog (void)  check_gnupg_prog (void)
309  {  {
310      char *pgm = NULL;      char *gpgexe = NULL;
311      int rc = 0;      int rc = 0;
312    
313      pgm = get_gnupg_prog ();      gpgexe = get_gnupg_prog ();
314      if (!pgm)      if (!gpgexe || file_exist_check (gpgexe)) {
315          rc = WPTERR_GPG_EXEFILE;          free_if_alloc (gpgexe);
316      if (file_exist_check (pgm))          gpgexe = check_for_gpg4win ();
317          rc = WPTERR_GPG_EXEFILE;          if (!gpgexe || file_exist_check (gpgexe))
318      free_if_alloc (pgm);              rc = WPTERR_GPG_EXEFILE;
319            else
320                set_reg_entry_gpg (GPG_REG_EXE, gpgexe);
321        }
322        free_if_alloc (gpgexe);
323      return rc;      return rc;
324  }  }
325    
326    
327  static int  static int
328  parse_version_nr (const char * buf, int *major, int *minor, int *patch)  parse_version_nr (const char *buf, int *major, int *minor, int *patch)
329  {  {
330      char tmp[8];      char tmp[8];
331      int i;      int i;
# Line 321  parse_version_nr (const char * buf, int Line 341  parse_version_nr (const char * buf, int
341      tmp[i] = 0; buf++;      tmp[i] = 0; buf++;
342      *minor = atol (tmp);      *minor = atol (tmp);
343      i=0;      i=0;
344      while (buf && isdigit( *buf ) && i < 8)      while (buf && isdigit (*buf) && i < 8)
345          tmp[i++] = *buf++;          tmp[i++] = *buf++;
346      tmp[i] = 0;      tmp[i] = 0;
347      *patch = atol (tmp);      *patch = atol (tmp);
# Line 333  parse_version_nr (const char * buf, int Line 353  parse_version_nr (const char * buf, int
353     version given in @r_major.@r_minor.@r_patch. On success these     version given in @r_major.@r_minor.@r_patch. On success these
354     variables contain the GPG version which is installed. */     variables contain the GPG version which is installed. */
355  int  int
356  check_gnupg_engine (int *r_major, int *r_minor, int *r_patch)  check_gnupg_engine (const char *need_gpg_ver,
357                        int *r_major, int *r_minor, int *r_patch)
358  {  {
359      gpgme_ctx_t ctx;      gpgme_ctx_t ctx;
360      gpgme_engine_info_t inf;      gpgme_engine_info_t inf;
361      char * eng = NULL;      char *eng = NULL;
362      int major=0, minor=0, patch=0;      int major=0, minor=0, patch=0;
363      int rc;      int need_major = 0, need_minor = 0, need_patch = 0;
364                int rc = 1;
365    
366        /* Convert the needed GPG version to the integer format. */
367        if (parse_version_nr (need_gpg_ver,
368                              &need_major, &need_minor, &need_patch))
369            return 1;
370        
371      gpgme_new (&ctx);      gpgme_new (&ctx);
372      inf = gpgme_ctx_get_engine_info (ctx);      inf = gpgme_ctx_get_engine_info (ctx);
373      if (!inf) {      if (!inf) {
374          gpgme_release (ctx);          gpgme_release (ctx);
375          return -1;          return -1;
376      }      }
377    
378      /* We need to exec GPG again to find out if IDEA is available. */      /* We need to exec GPG again to find out if IDEA is available. */
379      if (gpg_get_version (&eng))      if (gpg_get_version (&eng))
380          return -1;          return -1;
381      if (strstr (eng, "IDEA"))      if (strstr (eng, "IDEA"))
382          idea_available = 1;          idea_available = 1;
383      free (eng);      free (eng);
384      rc = parse_version_nr( inf->version, &major, &minor, &patch );      if (parse_version_nr (inf->version, &major, &minor, &patch)) {
     if( rc ) {  
385          gpgme_release (ctx);          gpgme_release (ctx);
386          return rc;          return 1;
387      }      }
388      if (major < *r_major || minor < *r_minor)  
389          rc = 1;      if (major > need_major)
     else {  
         if (patch < *r_patch)  
             rc = 1;  
390          rc = 0;          rc = 0;
391      }      else if (major == need_major && minor > need_minor)      
392            rc = 0;
393        else if (major == need_major && minor == need_minor &&
394                 patch >= need_patch)
395            rc = 0;
396    
397        /* Return the current GPG version. */
398      *r_major = major;      *r_major = major;
399      *r_minor = minor;      *r_minor = minor;
400      *r_patch = patch;      *r_patch = patch;
# Line 400  check_gnupg_cfgfile (const char *fname, Line 430  check_gnupg_cfgfile (const char *fname,
430  } /* check_gnupg_cfgfile */  } /* check_gnupg_cfgfile */
431    
432    
433  /*  /* Usually GPG creates the pubring.gpg, secring.gpg on
434   * Check if both keyrings are located in the gnupg home directory.     the first start, but to make sure they always exist
435   */     create them empty if needed. */
436    static void
437    create_empty_keyring (int _pub)
438    {
439        char *name;
440        FILE *f;
441    
442        name = get_gnupg_keyring (_pub, 0);
443        if (file_exist_check (name) != 0) {
444            f = fopen (name, "ab");
445            if (f != NULL)
446                fclose (f);
447        }
448        free_if_alloc (name);
449    }
450    
451    
452    /* Check if both keyrings are located in the gnupg home directory. */
453  int  int
454  gnupg_access_files (void)  gnupg_access_files (void)
455  {  {
# Line 411  gnupg_access_files (void) Line 458  gnupg_access_files (void)
458      int secrings = 0, pubrings = 0;      int secrings = 0, pubrings = 0;
459      char *optfile;      char *optfile;
460    
461        create_empty_keyring (1);
462      if (gnupg_access_keyring (1))      if (gnupg_access_keyring (1))
463          rc = WPTERR_GPG_KEYRINGS;          rc = WPTERR_GPG_KEYRINGS;
464      else      else
465          pubring_ok = 1;          pubring_ok = 1;
466    
467        create_empty_keyring (0);
468      if (gnupg_access_keyring (0))      if (gnupg_access_keyring (0))
469          rc = WPTERR_GPG_KEYRINGS;          rc = WPTERR_GPG_KEYRINGS;
470      else      else
471          secring_ok = 1;          secring_ok = 1;
472    
473      if (!pubring_ok || !secring_ok) {      if (!pubring_ok || !secring_ok) {
474          optfile = get_gnupg_cfgfile ();          optfile = get_gnupg_cfgfile ();
475          if (!optfile)          if (!optfile)
476              return WPTERR_GPG_KEYRINGS;              return WPTERR_GPG_KEYRINGS;
477          rc = file_exist_check (optfile);          rc = file_exist_check (optfile);
478          if (!rc && get_file_size(optfile) > 0) {          if (!rc && get_file_size (optfile) > 0) {
479              rc = check_gnupg_cfgfile (optfile, &secrings, &pubrings);              rc = check_gnupg_cfgfile (optfile, &secrings, &pubrings);
480              if (!rc && secrings && pubrings) {              if (!rc && secrings && pubrings) {
481                  free_if_alloc (optfile);                  free_if_alloc (optfile);
# Line 443  gnupg_access_files (void) Line 493  gnupg_access_files (void)
493          rc = WPTERR_GPG_KEYRINGS;          rc = WPTERR_GPG_KEYRINGS;
494      }      }
495      return rc;      return rc;
496  } /* gnupg_access_files */  }
497    
498    
499  static int  static int
# Line 452  create_gpg_options (void) Line 502  create_gpg_options (void)
502      FILE *fp;      FILE *fp;
503      char *s, *optfile;      char *s, *optfile;
504    
505      s = get_gnupg_path( );      s = get_gnupg_path ();
506      if( s == NULL )      if( s == NULL )
507          return WPTERR_FILE_CREAT;          return WPTERR_FILE_CREAT;
508      optfile = make_filename( s, GPG_CONF, NULL );      optfile = make_filename (s, GPG_CONF, NULL);
509      fp = fopen( optfile, "wb" );      fp = fopen (optfile, "wb");
510      if( fp == NULL ) {        if (fp == NULL) {  
511          return WPTERR_FILE_CREAT;          return WPTERR_FILE_CREAT;
512          goto fail;          goto fail;
513      }      }
514      fwrite( options_skel, 1, strlen( options_skel ), fp );      fwrite (options_skel, 1, strlen (options_skel), fp);
515      fclose( fp );      fclose (fp);
516    
517  fail:  fail:
518      free_if_alloc( s );      free_if_alloc (s);
519      free_if_alloc( optfile );      free_if_alloc (optfile);
520      return 0;      return 0;
521  } /* create_gpg_options */  } /* create_gpg_options */
522    
# Line 646  check_last_gnupg_access (gpg_watcher_s * Line 696  check_last_gnupg_access (gpg_watcher_s *
696      if (ctx->last_access.dwHighDateTime != ctx->access.dwHighDateTime &&      if (ctx->last_access.dwHighDateTime != ctx->access.dwHighDateTime &&
697          ctx->last_access.dwLowDateTime != ctx->access.dwLowDateTime)          ctx->last_access.dwLowDateTime != ctx->access.dwLowDateTime)
698          ctx->modified = 1;          ctx->modified = 1;
699        
700        /* XXX: find a better way. without it, winpt --keymanager loads
701                the key cache twice. */
702        if (ctx->last_access.dwLowDateTime == 0)
703            ctx->modified = 0;
704    
705      ctx->last_access.dwLowDateTime = ctx->access.dwLowDateTime;      ctx->last_access.dwLowDateTime = ctx->access.dwLowDateTime;
706      ctx->last_access.dwHighDateTime = ctx->access.dwHighDateTime;      ctx->last_access.dwHighDateTime = ctx->access.dwHighDateTime;
# Line 752  get_gnupg_keyring_from_options (const ch Line 807  get_gnupg_keyring_from_options (const ch
807    
808  /* XXX: does not work with write-protected floppies */  /* XXX: does not work with write-protected floppies */
809  static int  static int
810  my_access (const char * fname)  my_access (const char *fname)
811  {  {
812      HANDLE hd;      HANDLE hd;
813      hd = CreateFile (fname, GENERIC_WRITE, FILE_SHARE_WRITE,      hd = CreateFile (fname, GENERIC_WRITE, FILE_SHARE_WRITE,
# Line 764  my_access (const char * fname) Line 819  my_access (const char * fname)
819  }  }
820    
821    
822    /* Check the file permissions of the public keyring.
823       If @showmsg is 1 output a message in case of errors.
824       Return value: 1 if read-only attribute
825                     2 if file is opened by another process exclusively. */
826  int  int
827  gpg_check_permissions (int showmsg)  gpg_check_permissions (int showmsg)
828  {  {
829      char * p, * name = NULL;      char *p = NULL;
830        char *name = NULL;
831      int failed = 0, ans=0, attrs=0;      int failed = 0, ans=0, attrs=0;
832    
833      p = get_gnupg_path ();      p = get_gnupg_path ();
834      check_keyring (&p);      if (check_keyring (&p) && p) {
     if (p) {  
835          name = make_filename (p, "pubring", "gpg");          name = make_filename (p, "pubring", "gpg");
         free_if_alloc (p);  
836          if ((attrs=GetFileAttributes (name)) & FILE_ATTRIBUTE_READONLY) {          if ((attrs=GetFileAttributes (name)) & FILE_ATTRIBUTE_READONLY) {
837              ans = msg_box (NULL,              ans = msg_box (NULL,
838                             _("The selected keyring has the read-only file\n"                             _("The selected keyring has the read-only file\n"
# Line 790  gpg_check_permissions (int showmsg) Line 848  gpg_check_permissions (int showmsg)
848                  }                  }
849              }              }
850              else if (ans == IDNO) {              else if (ans == IDNO) {
851                  /*                  /* All commands with write access will be disabled. */
                 msg_box (NULL, _("All commands with write access to the keyring\n"  
                                  "will be disabled."), _("GPG Information"), MB_INFO);  
                 */  
852                  failed = 1;                  failed = 1;
853              }              }
854          }          }
# Line 809  gpg_check_permissions (int showmsg) Line 864  gpg_check_permissions (int showmsg)
864              failed = 2;              failed = 2;
865          }          }
866      }      }
867        free_if_alloc (p);
868      free_if_alloc (name);      free_if_alloc (name);
869      return failed;      return failed;
870  } /* gpg_check_permissions */  }
871    
872    
873  /* Check the GPG home dir. If all methods failed, try to  /* Check the GPG home dir. First try to read the 'HomeDir' registry entry,
874     create the default folder. */     then check for $APPDATA\gnupg. Create the dir if it does not exists. */
875  static int  int
876  check_homedir (void)  gnupg_check_homedir (void)
877  {        {      
878      char *homedir = NULL;      char *homedir = NULL;
879      int yes = 0;      int val = 0;
880        int rc = 0;
881    
882      homedir = get_reg_entry_gpg ("HomeDir");      homedir = get_reg_entry_gpg (GPG_REG_HOME);
     if (!homedir)  
         homedir = multi_gnupg_path ();  
883      if (!homedir)      if (!homedir)
884          homedir = m_strdup ("c:\\gnupg");          homedir = multi_gnupg_path (0);
885      if (homedir) {      if (homedir) {
886          if (GetFileAttributes (homedir) == 0xFFFFFFFF) {          if (GetFileAttributes (homedir) == 0xFFFFFFFF) {
887              yes = log_box (_("Preferences"), MB_YESNO,              val = log_box (_("Preferences"), MB_YESNO,
888                             _("%s does not exit.\n"                             _("%s does not exit.\n"
889                               "Do you want to create this directory?"), homedir);                               "Do you want to create this directory?"), homedir);
890              if (yes == IDYES) {              if (val == IDYES) {
891                  BOOL ec = CreateDirectory (homedir, NULL);                  if (!CreateDirectory (homedir, NULL))
892                  free_if_alloc (homedir);                      rc = WPTERR_DIR_CREAT;
                 if (ec == FALSE)  
                     return WPTERR_DIR_CREAT;  
                 return 0;  
893              }              }
894              return WPTERR_DIR_OPEN;              else
895          }                  rc = WPTERR_DIR_OPEN;
         free_if_alloc (homedir);  
     }  
     return 0;  
 }  
   
   
 int  
 gnupg_check_homedir (void)  
 {        
     char *homedir = NULL;  
     char *prog = NULL;  
     int rc = 0, ec = 0;  
       
     rc = check_homedir ();  
     if (rc)  
         return rc;  
     if ((homedir = get_reg_entry_gpg ("HomeDir")) &&  
         !(prog = get_reg_entry_gpg ("gpgProgram" ))) {  
         prog = make_filename (homedir, "gpg", "exe");  
         if (file_exist_check (prog) == 0) {  
             rc = set_reg_entry_gpg ("gpgProgram", prog);  
             if (rc)  
                 goto fail;  
896          }          }
897          free_if_alloc (homedir);          free_if_alloc (homedir);
         free_if_alloc (prog);  
         return rc;  
     }  
     if ((prog = get_reg_entry_gpg ("gpgProgram"))  
         && file_exist_check (prog)) {  
         free_if_alloc (prog);  
         homedir = get_reg_entry_gpg ("HomeDir");  
         if (!homedir) {  
             rc = WPTERR_GENERAL;  
             goto fail;  
         }  
         prog = make_filename (homedir, "gpg", "exe");  
         if (file_exist_check (prog) == 0) {  
             rc = set_reg_entry_gpg ("gpgProgram", prog);  
             if (rc)  
                 goto fail;  
             free_if_alloc (prog);  
             return rc;  
         }  
898      }      }
       
     /* Change the return code if homedir doesn't exist or if the program  
        doesn't exist. Note that exist_checks return 0 to suggest existance. */  
     if ((!homedir || dir_exist_check (homedir)))  
         rc = WPTERR_GENERAL;  
       
 fail:  
     free_if_alloc (homedir);  
     free_if_alloc (prog);  
899      return rc;      return rc;
900  } /* gnupg_check_homedir */  }
901    
902    
903  int  int
# Line 912  gnupg_copy_keyrings (void) Line 913  gnupg_copy_keyrings (void)
913          return WPTERR_GENERAL;          return WPTERR_GENERAL;
914      hwnd = GetDesktopWindow ();      hwnd = GetDesktopWindow ();
915    
916      pring = get_filename_dlg (hwnd, FILE_OPEN, _("Please choose your public keyring"),      pring = get_fileopen_dlg (hwnd, _("Please choose your public keyring"),
917                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),NULL);                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),NULL);
918      if (!pring) {      if (!pring) {
919          msg_box (hwnd, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR);          msg_box (hwnd, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR);
# Line 932  gnupg_copy_keyrings (void) Line 933  gnupg_copy_keyrings (void)
933      }      }
934      free_if_alloc (file);      free_if_alloc (file);
935    
936      sring = get_filename_dlg (hwnd, FILE_OPEN, _("Please choose your secret keyring"),      sring = get_fileopen_dlg (hwnd, _("Please choose your secret keyring"),
937                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"), NULL);                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"), NULL);
938      if (!sring) {      if (!sring) {
939          msg_box( NULL, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR );          msg_box( NULL, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR );
# Line 956  fail: Line 957  fail:
957  } /* gnupg_import_keyrings */  } /* gnupg_import_keyrings */
958    
959    
960    /* Backup the gpg.conf file. */
961  void  void
962  gnupg_backup_options (void)  gnupg_backup_options (void)
963  {  {
# Line 963  gnupg_backup_options (void) Line 965  gnupg_backup_options (void)
965      char bak[512];      char bak[512];
966    
967      cfgfile = get_gnupg_cfgfile ();      cfgfile = get_gnupg_cfgfile ();
968      if (cfgfile == NULL)      if (!cfgfile)
969          return;          return;
970      _snprintf (bak, DIM (bak)-1, "%s.bak", cfgfile);      _snprintf (bak, DIM (bak)-1, "%s.bak", cfgfile);
971      CopyFile (cfgfile, bak, FALSE);      CopyFile (cfgfile, bak, FALSE);
972      free_if_alloc (cfgfile);      free_if_alloc (cfgfile);
973  } /* gnupg_backup_options */  }
   
974    
975    
976  static int  static int
# Line 997  backup_one_file (const char *srcpath, co Line 998  backup_one_file (const char *srcpath, co
998  } /* backup_one_file */  } /* backup_one_file */
999    
1000    
1001    /* Figure out first public keyring which is not empty.
1002       Return value: 1 on success. */
1003  static int  static int
1004  check_keyring (char ** r_path)  check_keyring (char **r_path)
1005  {  {
1006      char * p;      char *p;
1007      char * opt, * name;      char *opt;
1008        char *name;
1009    
1010      if (!*r_path)      if (!*r_path)
1011          return 0;          return 0;
1012      p = make_filename (*r_path, "pubring", "gpg");      p = make_filename (*r_path, "pubring", "gpg");
1013      if (!p || get_file_size (p) > 0)      if (!p || get_file_size (p) <= 0)
1014          return 0;          return 0;
1015    
1016      opt = get_gnupg_cfgfile ();      opt = get_gnupg_cfgfile ();
# Line 1018  check_keyring (char ** r_path) Line 1022  check_keyring (char ** r_path)
1022      if (!name)      if (!name)
1023          return 0;          return 0;
1024      p = strrchr (name, '\\');      p = strrchr (name, '\\');
1025      if (!p)      if (!p) {
     {  
1026          free_if_alloc (name);          free_if_alloc (name);
1027          return 0;                return 0;      
1028      }      }
# Line 1032  check_keyring (char ** r_path) Line 1035  check_keyring (char ** r_path)
1035  }  }
1036    
1037    
1038    /* Return a temp name based on the day of the week. */
1039  static char*  static char*
1040  get_backup_name (const char *templ)  get_backup_name (const char *templ)
1041  {  {
1042      struct tm *tm;      struct tm *tm;
1043      char *p;      char *p;
1044        time_t t;
1045    
1046      time_t t = time (NULL);      t = time (NULL);
1047      tm = localtime (&t);      tm = localtime (&t);
1048      p = new char [strlen (templ) + 8 + 1];      p = new char [strlen (templ) + 8 + 1];
1049      if (!p)      if (!p)
# Line 1048  get_backup_name (const char *templ) Line 1053  get_backup_name (const char *templ)
1053  }  }
1054    
1055    
1056    /* Make backups of all keyrings. The public key ring is
1057       rotated like this pubring-%d.gpg. */
1058  void  void
1059  gnupg_backup_keyrings (void)  gnupg_backup_keyrings (void)
1060  {  {
# Line 1058  gnupg_backup_keyrings (void) Line 1065  gnupg_backup_keyrings (void)
1065      if (!reg_prefs.auto_backup)      if (!reg_prefs.auto_backup)
1066          return;          return;
1067      bakmode = reg_prefs.backup.mode;      bakmode = reg_prefs.backup.mode;
1068      srcpath =  get_gnupg_path ();      srcpath = get_gnupg_path ();
1069      check_keyring (&srcpath);      check_keyring (&srcpath);
1070      if (bakmode == 1) {      if (bakmode == 1) {
1071          dstpath = get_gnupg_path ();          dstpath = multi_gnupg_path (1);
1072          check_keyring (&dstpath);          check_keyring (&dstpath);
1073      }      }
1074      else if (bakmode == 2) {      else if (bakmode == 2) {
1075          char * tmpfile;          char *tmpfile;
1076          FILE * fp;          FILE *fp;
1077    
1078          dstpath = m_strdup (reg_prefs.backup.path);          dstpath = m_strdup (reg_prefs.backup.path);
1079          if (!dstpath)          if (!dstpath)
# Line 1080  gnupg_backup_keyrings (void) Line 1087  gnupg_backup_keyrings (void)
1087          else {          else {
1088              rc = 0;              rc = 0;
1089              fclose (fp);              fclose (fp);
1090              unlink (tmpfile);              remove (tmpfile);
1091          }          }
1092          free_if_alloc (tmpfile);          free_if_alloc (tmpfile);
1093          if (!fp || rc == IDCANCEL)          if (!fp || rc == IDCANCEL)
# Line 1097  gnupg_backup_keyrings (void) Line 1104  gnupg_backup_keyrings (void)
1104      free_if_alloc (name);      free_if_alloc (name);
1105      free_if_alloc (srcpath);      free_if_alloc (srcpath);
1106      free_if_alloc (dstpath);      free_if_alloc (dstpath);
1107  } /* gnupg_backup_keyrings */  }
1108    
1109    
1110  /* Display GPG error from file if possible. */  /* Display GPG error from file if possible. */
# Line 1115  gnupg_display_error (void) Line 1122  gnupg_display_error (void)
1122          return;          return;
1123      fp = fopen( tmpath, "rb" );      fp = fopen( tmpath, "rb" );
1124      if (!fp) {      if (!fp) {
1125          msg_box( NULL, _("No GPG error description available."), _("GPG Error"), MB_INFO );          msg_box (NULL, _("No GPG error description available."),
1126                     _("GPG Error"), MB_INFO);
1127          return;          return;
1128      }      }
1129      errstr = new char[size+1];      errstr = new char[size+1];
Legend:
Removed from v.42  
changed lines
  Added in v.138
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26