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

Diff of /trunk/Src/wptGPG.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 32 by twoaday,
Mon Oct 24 08:03:48 2005 UTC
+revision 304 by twoaday,
Wed Mar 21 10:59:31 2007 UTC
 Line 1
  /* wptGPG.cpp - GnuPG configuration
-  *      Copyright (C) 2001-2004 Timo Schulz
+  *      Copyright (C) 2001-2007 Timo Schulz
   *
   * This file is part of WinPT.
   *
   * WinPT is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version 2
   * of the License, or (at your option) any later version.
   *
   * WinPT is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
-  *
+  */
-  * You should have received a copy of the GNU General Public License
+ #ifdef HAVE_CONFIG_H
-  * along with WinPT; if not, write to the Free Software Foundation,
+ #include <config.h>
-  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ #endif
-  */
+ #include <windows.h>
  #include <string.h>
  #include <stdio.h>
- #include <windows.h>
+ #include <shlobj.h>
- #include <shlobj.h>
+ #include <ctype.h>
- #include <ctype.h>
+ #include <io.h>
- #include <io.h>
+ #include <time.h>
  #include "wptGPG.h"
- #include "wptGPGCmds.h"
+ #include "wptGpgCmds.h"
  #include "wptGPGOptSkel.h"
  #include "wptTypes.h"
  #include "wptNLS.h"
  #include "wptRegistry.h"
  #include "wptErrors.h"
  #include "wptW32API.h"
  #include "wptCrypto.h"
- #define GPG_CONF "gpg.conf"
+ #define GPG_CONF        "gpg.conf"
+ #define GPG_REG_EXE     "gpgProgram"    /* registry name for the binary. */
- struct gpg_watcher_s {
+ #define GPG_REG_HOME    "HomeDir"       /* registry name of the home dir. */
-     FILETIME last_access;
-     FILETIME access;
+ /* Context to monitor GPG file changes. */
-     char * object;
+ struct gpg_monitor_s {
-     int modified;
+     FILETIME    last_access;    /* last write access. */
- };
+     FILETIME    access;
+     char        *object;        /* name of the object. */
- /* XXX need to watch for gpg.conf due to the fact keyring entries could be changed */
+     char        *fpath_object;  /* full path to the object. */
- static const char * gpg_objs[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg"};
+     int         modified;       /* 1 = modified. */
- static gpg_watcher_s gpg_table[3];
+ };
- static int gpg_table_count = DIM (gpg_table);
+ typedef struct gpg_monitor_s *gpg_monitor_t;
- int idea_available = 0;
+ static const char *gpg_objs[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg"};
+ static gpg_monitor_s gpg_table[3];
- static int check_keyring (char ** r_path);
+ static int gpg_table_count = DIM (gpg_table);
+ int idea_available = 0; /* if the IDEA extension is available. */
- static char*
- multi_gnupg_path (void)
- {
+ static int check_keyring (char ** r_path);
-     static char buf[256+64];
-     BOOL ec;
+ /* Return the application data folder of the current user. */
-     /* MSDN: buf must be at least MAX_PATH=256 bytes */
+ char*
-     memset (buf, 0, sizeof (buf));
+ multi_gnupg_path (int strict)
-     ec = SHGetSpecialFolderPath (HWND_DESKTOP, buf, CSIDL_APPDATA, TRUE);
+ {
-     if (ec != 1)
+     static char buf[MAX_PATH+64];
-         return NULL;
+     BOOL ec;
-     strcat (buf, "\\gnupg");
-     if (access (buf, 00))
+     /* MSDN: buf must be at least MAX_PATH=256 bytes */
-         return NULL;
+     memset (buf, 0, sizeof (buf));
-     return m_strdup (buf);
+     /* XXX: ec should be NOERROR (MSDN) but NOERROR is defined as '0' !? */
- }
+     ec = SHGetSpecialFolderPath (HWND_DESKTOP, buf, CSIDL_APPDATA, TRUE);
+     if (ec != 1) {
- /* Return the full path of the GnuPG application. First the registry is scanned
+         log_debug ("multi_gnupg_path: SHGetSpecialFolderPath() failed\r\n",
-    for the entry 'HomeDir'. If it wasn't set, the default dir C:\GNUPG is used.
+                    (int)GetLastError ());
-  */
+         return NULL;
- char*
+     }
- get_gnupg_path (void)
+     strcat (buf, "\\gnupg");
- {
+     if (strict && access (buf, 00))
-     char *p = NULL, *path = NULL;
+         return NULL;
+     return m_strdup (buf);
-     p = get_reg_entry_gpg ("HomeDir");
+ }
-     if (p) {
-         path = m_strdup (p);
-         free_if_alloc (p);
+ /* Return the full path to the GPG home directory. First the 'HomeDir' entry
-         return path;
+    from the registry is used. Then the default $APPDATA\gnupg path. */
-     }
+ char*
-     else
+ get_gnupg_path (void)
-         return multi_gnupg_path ();
+ {
-     return m_strdup ("c:\\gnupg");
+     char *path;
- }
+     path = get_reg_entry_gpg (GPG_REG_HOME);
+     if (path && dir_exist_check (path) == 0)
- char*
+         return path;
- get_gnupg_cfgfile (void)
+     free_if_alloc (path);
- {
+     return multi_gnupg_path (1);
-     char *p = NULL, *optfile = NULL, *path = NULL;
+ }
-     size_t nlen = 0;
-     path = get_gnupg_path ();
+ /* Return the full path of the gpg config file.
-     if (path == NULL)
+    A value of NULL indicates an error. */
-         return NULL;
+ char*
-     p = get_reg_entry_gpg ("OptFile");
+ get_gnupg_cfgfile (void)
-     if (p && !strcmp (p, ""))
+ {
-     {
+     char *optfile;
-         nlen = strlen (path) + 64;
+     char *path;
-         optfile = new char[nlen + 1];
-         if (optfile == NULL)
+     path = get_gnupg_path ();
-             BUG (0);
+     if (!path)
-         _snprintf (optfile, nlen, "%s\\"GPG_CONF, path);
+         return NULL;
-     }
+     optfile = make_filename (path, GPG_CONF, NULL);
-     else if( p ) {
+     free_if_alloc (path);
-         nlen = strlen( p ) + 4;
-         optfile = new char[nlen + 1];
+     return optfile;
-         if( optfile == NULL )
+ }
-             BUG( NULL );
-         _snprintf( optfile, nlen, "%s", p );
-     }
+ static char*
-     else {
+ get_keyring_from_conf (const char *fname, int pub)
-         nlen = strlen( path ) + 64;
+ {
-         optfile = new char[nlen + 1];
+     config_file_t opt;
-         if( optfile == NULL )
+     conf_option_t e;
-             BUG( NULL );
+     char *kring = NULL;
-         _snprintf( optfile, nlen, "%s\\"GPG_CONF, path );
+     int rc;
-     }
-     free_if_alloc (path);
+     rc = parse_config (fname, &opt);
-     free_if_alloc (p);
+     if (rc)
+         return NULL;
-     return optfile;
+     if (pub)
- } /* get_gnupg_cfgfile */
+         e = conf_find_option (opt, "keyring");
+     else
+         e = conf_find_option (opt, "secret-keyring");
- char *
+     if (e != NULL)
- get_gnupg_keyring (int pub, int strict)
+         kring = m_strdup (e->val);
- {
+     release_config (opt);
-     char * optfile = NULL, * path = NULL;
-     char * keyring = NULL;
+     return kring;
+ }
-     path = get_gnupg_path ();
-     if (!path)
-         return NULL;
+ /* Return the full path of the keyring. If @pub is 1, the public
-     keyring = make_filename (path, pub? "pubring" : "secring", "gpg");
+    keyring is return, otherwise the secret keyring. */
-     if (!strict && !file_exist_check (keyring)) {
+ char*
-         free_if_alloc (path);
+ get_gnupg_keyring (int pub, int strict)
-         return keyring;
+ {
-     }
+     char *optfile;
-     if (file_exist_check (keyring) || get_file_size (keyring) == 0) {
+     char *path;
-         free_if_alloc (keyring);
+     char *keyring;
-         optfile = make_filename (path, GPG_CONF, NULL);
-         keyring = get_gnupg_keyring_from_options (optfile, pub);
+     path = get_gnupg_path ();
-     }
+     if (!path)
-     free_if_alloc (path);
+         return NULL;
-     free_if_alloc (optfile);
+     keyring = make_filename (path, pub? "pubring" : "secring", "gpg");
-     return keyring;
+     if (strict && !file_exist_check (keyring)) {
- } /* get_gnupg_keyring */
+         free_if_alloc (path);
+         return keyring;
+     }
- /*
+     else if (!strict) {
-  * Return the full path (with the gpg exe name). First the registry is scanned
+         free_if_alloc (path);
-  * for the entry 'gpgProgram'. If it wasn't set, the default path is the
+         return keyring;
-  * appended string 'gpg.exe' is used.
+     }
-  */
+     if (file_exist_check (keyring) ||
- char*
+         pub && get_file_size (keyring) == 0) {
- get_gnupg_prog (void)
+         free_if_alloc (keyring);
- {
+         optfile = make_filename (path, GPG_CONF, NULL);
-     char *p, *path, *pgm = NULL;
+         keyring = get_keyring_from_conf (optfile, pub);
-     size_t nlen = 0;
+         free_if_alloc (optfile);
+     }
-     path = get_gnupg_path ();
+     free_if_alloc (path);
-     if (path == NULL)
-         return NULL;
+     return keyring;
+ }
-     p = get_reg_entry_gpg ("gpgProgram");
-     if (p == NULL)
-         pgm = make_filename (path, "gpg", "exe");
+ /* Return the full path (with the gpg exe name). First the registry is scanned
-     else {
+    for the entry 'gpgProgram'. If it wasn't set, the default path is the
-         pgm = m_strdup (p);
+    appended string 'gpg.exe' is used. */
-         free_if_alloc (p);
+ char*
-     }
+ get_gnupg_prog (void)
-     free_if_alloc (path);
+ {
-     return pgm;
+     char *path;
- } /* get_gnupg_prog */
+     char *pgm;
+     pgm = get_reg_entry_gpg (GPG_REG_EXE);
- static char *
+     if (pgm)
- default_key_from_cache (int *ret_no_useable)
+         return pgm;
- {
+     path = get_gnupg_path ();
-     const char * s;
+     if (!path)
-     char * keyid = NULL;
+         return NULL;
-     gpgme_key_t key;
+     pgm = make_filename (path, "gpg", "exe");
-     gpg_keycache_t sec = keycache_get_ctx (0);
+     free_if_alloc (path);
+     return pgm;
-     if (!sec)
+ }
-         BUG (0);
-     gpg_keycache_rewind (sec);
-     while (!gpg_keycache_next_key (sec, 1, &key)) {
+ /* Retrieve the first usable secret key from cache.
-         if (key_is_useable (key)) {
+    If no usable was found, @ret_no_useable is 1.
-             s = key->subkeys->keyid;
+    Return value: the keyid of the secret key. */
-             if (s)
+ static char*
-                 keyid = m_strdup (s+8);
+ default_key_from_cache (int *ret_no_useable)
-             break;
+ {
-         }
+     gpgme_key_t key, pk;
-     }
+     gpg_keycache_t sec, pub;
-     if (!keyid) {
+     const char *s;
-         *ret_no_useable = 1;
+     char *keyid = NULL;
-         msg_box( NULL, _("No useable secret key found."), _("GPG Error"), MB_ERR);
-     }
+     sec = keycache_get_ctx (0);
-     return keyid;
+     pub = keycache_get_ctx (1);
- } /* default_key_from_cache */
+     gpg_keycache_rewind (sec);
+     while (!gpg_keycache_next_key (sec, 1, &key)) {
+         if (key_is_useable (key) && !get_pubkey (key->subkeys->keyid, &pk)) {
- char *
+             s = key->subkeys->keyid;
- get_gnupg_default_key (void)
+             if (s)
- {
+                 keyid = m_strdup (s+8);
-     gpg_optfile_t opt = NULL;
+             break;
-     gpg_option_t e;
+         }
-     char * keyid = NULL, * optfile = NULL;
+     }
-     int no_usable=0, rc = 0;
+     if (!keyid)
+         *ret_no_useable = 1;
-     optfile = get_gnupg_cfgfile ();
+     return keyid;
-     if (!optfile)
+ }
-         return default_key_from_cache( &no_usable );
-     rc = parse_gpg_options( optfile, &opt );
-     if( rc ) {
+ /* Load the gpg.conf and search for some options
-         free_if_alloc( optfile );
+    and store the result in the global preference context.
-         return default_key_from_cache( &no_usable );
+    Return value: 0 on success. */
-     }
+ int
-     e = find_option( opt, "default-key" );
+ gnupg_load_config (void)
-     if ( e )
+ {
-         keyid = m_strdup( e->val );
+     config_file_t opt;
-     if( !e ) {
+     char *conf;
-         e = find_option( opt, "local-user" );
+     int rc = 0;
-         if( e )
-             keyid = m_strdup( e->val );
+     conf = get_gnupg_cfgfile ();
-     }
+     if (!conf)
-     if( !e ) {
+         return -1;
-         e = find_option( opt, "encrypt-to" );
+     if (parse_config (conf, &opt)) {
-         if( e )
+         free_if_alloc (conf);
-             keyid = m_strdup( e->val );
+         return -1;
      }
-     free_if_alloc( optfile );
+     free_if_alloc (conf);
-     release_gpg_options( opt );
+     if (conf_find_option (opt, "ask-cert-level"))
+         reg_prefs.gpg.ask_cert_level = 1;
-     if( !keyid )
+     if (conf_find_option (opt, "ask-cert-expire"))
-         keyid = default_key_from_cache( &no_usable );
+         reg_prefs.gpg.ask_cert_expire = 1;
-     return keyid;
+     /* The 'textmode' option for GPG is useful for text files
- } /* get_gnupg_default_key */
+        but it breaks the output of any binary data. Thus we return
+        a warning here to inform the user that binary output is broken. */
+     if (conf_find_option (opt, "textmode"))
- /* Check if the gpg application (exe file) is available. */
+         rc = -2;
- int
+     release_config (opt);
- check_gnupg_prog (void)
- {
+     return rc;
-     char *pgm = NULL;
+ }
-     int rc = 0;
-     pgm = get_gnupg_prog ();
+ /* handle the case the user added a '!' to force a subkey. */
-     if (!pgm)
+ static char*
-         rc = WPTERR_GPG_EXEFILE;
+ extract_keyid (const char *val)
-     if (file_exist_check (pgm))
+ {
-         rc = WPTERR_GPG_EXEFILE;
+     size_t len = strlen (val);
-     free_if_alloc (pgm);
-     return rc;
+     if (len > 1 && val[len-1] == '!')
- }
+         return substr (val, 0, len-1);
+     return m_strdup (val);
+ }
- static int
- parse_version_nr (const char * buf, int *major, int *minor, int *patch)
- {
+ /* Return the default key.
-     char tmp[8];
+    This can be either a substring or a key ID. */
-     int i;
+ char*
+ get_gnupg_default_key (void)
-     i=0;
+ {
-     while( buf && *buf != '.' && i < 8 )
+     config_file_t opt = NULL;
-         tmp[i++] = *buf++;
+     conf_option_t e;
-     tmp[i] = 0; buf++;
+     char *keyid = NULL, *optfile = NULL;
-     *major = atol( tmp );
+     int no_usable=0;
-     i=0;
-     while( buf && *buf != '.' && i < 8 )
+     optfile = get_gnupg_cfgfile ();
-         tmp[i++] = *buf++;
+     if (!optfile)
-     tmp[i] = 0; buf++;
+         return default_key_from_cache (&no_usable);
-     *minor = atol( tmp );
+     if (parse_config (optfile, &opt)) {
-     i=0;
+         free_if_alloc (optfile);
-     while( buf && isdigit( *buf ) && i < 8 )
+         return default_key_from_cache (&no_usable);
-         tmp[i++] = *buf++;
+     }
-     tmp[i] = 0;
+     /* First we search for config entries which specify a default key. */
-     *patch = atol( tmp );
+     e = conf_find_option (opt, "default-key");
-     return 0;
+     if (!e)
- }
+         e = conf_find_option (opt, "local-user");
+     if (e)
+         keyid = extract_keyid (e->val);
- /* Check if the gnupg engine fullfills the minimum requirement
-    version given in @r_major.@r_minor.@r_patch. On success these
+     free_if_alloc (optfile);
-    variables contain the GPG version which is installed. */
+     release_config (opt);
- int
- check_gnupg_engine (int *r_major, int *r_minor, int *r_patch)
+     /* If no entry in the config has been found, we get a key
- {
+        from the key cache. */
-     gpgme_ctx_t ctx;
+     if (!keyid)
-     gpgme_engine_info_t inf;
+         keyid = default_key_from_cache (&no_usable);
-     char * eng = NULL;
+     return keyid;
-     int major=0, minor=0, patch=0;
+ }
-     int rc;
-     gpgme_new (&ctx);
+ /* Check if GPG4WIN is available and if so, use the
-     inf = gpgme_ctx_get_engine_info (ctx);
+    install path to figure out where the gpg.exe is. */
-     if (!inf) {
+ char*
-         gpgme_release (ctx);
+ check_for_gpg4win (void)
-         return -1;
+ {
-     }
+     return get_reg_entry_gpg4win ("gpg.exe");
-     /* We need to exec GPG again to find out if IDEA is available. */
+ }
-     if (gpg_get_version (&eng))
-         return -1;
-     if (strstr (eng, "IDEA"))
+ /* Check if the gpg application (exe file) is available. */
-         idea_available = 1;
+ int
-     free (eng);
+ check_gnupg_prog (void)
-     rc = parse_version_nr( inf->version, &major, &minor, &patch );
+ {
-     if( rc ) {
+     char *gpgexe = NULL;
-         gpgme_release (ctx);
+     int rc = 0;
-         return rc;
-     }
+     gpgexe = get_gnupg_prog ();
-     if (major < *r_major || minor < *r_minor)
+     if (!gpgexe || file_exist_check (gpgexe)) {
-         rc = 1;
+         free_if_alloc (gpgexe);
-     else {
+         gpgexe = check_for_gpg4win ();
-         if (patch < *r_patch)
+         if (!gpgexe || file_exist_check (gpgexe))
-             rc = 1;
+             rc = WPTERR_GPG_EXEFILE;
-         rc = 0;
+         else
-     }
+             set_reg_entry_gpg (GPG_REG_EXE, gpgexe);
-     *r_major = major;
+     }
-     *r_minor = minor;
+     free_if_alloc (gpgexe);
-     *r_patch = patch;
+     return rc;
-     return rc;
+ }
- }
+ static int
- int
+ parse_version_nr (const char *buf, int *major, int *minor, int *patch)
- check_gnupg_cfgfile (const char *fname, int *r_secrings, int *r_pubrings)
+ {
- {
+     char tmp[8];
-     gpg_optfile_t opt;
+     int i;
-     gpg_option_t e;
-     int rc = 0;
+     i=0;
+     while (buf && *buf != '.' && i < 8)
-     if( r_secrings )
+         tmp[i++] = *buf++;
-         *r_secrings = 0;
+     tmp[i] = 0; buf++;
-     if( r_pubrings )
+     *major = atoi (tmp);
-         *r_pubrings = 0;
+     i=0;
-     rc = parse_gpg_options( fname, &opt );
+     while (buf && *buf != '.' && i < 8)
-     if( rc )
+         tmp[i++] = *buf++;
-         return WPTERR_FILE_OPEN;
+     tmp[i] = 0; buf++;
+     *minor = atoi (tmp);
-     for( e = opt->list; e; e = e->next ) {
+     i=0;
-         if( !strcmp( e->name, "secret-keyring" ) ) {
+     while (buf && isdigit (*buf) && i < 8)
-             if( !file_exist_check( e->val ) )
+         tmp[i++] = *buf++;
-                 r_secrings[0]++;
+     tmp[i] = 0;
-         }
+     *patch = atoi (tmp);
-         else if( !strcmp( e->name, "keyring" ) ) {
+     return 0;
-             if( !file_exist_check( e->val ) )
+ }
-                 r_pubrings[0]++;
-         }
-     }
+ /* Check if the gnupg engine fullfills the minimum requirement
-     release_gpg_options( opt );
+    version given in @r_major.@r_minor.@r_patch. On success these
-     return 0;
+    variables contain the GPG version which is installed. */
- } /* check_gnupg_cfgfile */
+ int
+ check_gnupg_engine (const char *need_gpg_ver,
- /*
+                     int *r_major, int *r_minor, int *r_patch)
-  * Check if both keyrings are located in the gnupg home directory.
+ {
-  */
+     gpgme_ctx_t ctx;
- int
+     gpgme_engine_info_t inf;
- gnupg_access_files (void)
+     char *eng = NULL;
- {
+     int major=0, minor=0, patch=0;
-     int rc = 0;
+     int need_major = 0, need_minor = 0, need_patch = 0;
-     int pubring_ok = 0, secring_ok = 0;
+     int rc = 1;
-     int secrings = 0, pubrings = 0;
-     char *optfile;
+     /* Convert the needed GPG version to the integer format. */
+     if (parse_version_nr (need_gpg_ver,
-     if (gnupg_access_keyring (1))
+                           &need_major, &need_minor, &need_patch))
-         rc = WPTERR_GPG_KEYRINGS;
+         return 1;
-     else
-         pubring_ok = 1;
+     gpgme_new (&ctx);
+     inf = gpgme_ctx_get_engine_info (ctx);
-     if (gnupg_access_keyring (0))
+     if (!inf) {
-         rc = WPTERR_GPG_KEYRINGS;
+         gpgme_release (ctx);
-     else
+         return -1;
-         secring_ok = 1;
+     }
-     if (!pubring_ok || !secring_ok) {
-         optfile = get_gnupg_cfgfile ();
+     /* We need to exec GPG again to find out if IDEA is available. */
-         if (!optfile)
+     if (gpg_get_version (&eng)) {
-             return WPTERR_GPG_KEYRINGS;
+         gpgme_release (ctx);
-         rc = file_exist_check (optfile);
+         return -1;
-         if (!rc && get_file_size(optfile) > 0) {
+     }
-             rc = check_gnupg_cfgfile (optfile, &secrings, &pubrings);
+     if (strstr (eng, "IDEA"))
-             if (!rc && secrings && pubrings) {
+         idea_available = 1;
-                 free_if_alloc (optfile);
+     safe_free (eng);
-                 return 0; /* found two keyrings in the option file */
+     if (parse_version_nr (inf->version, &major, &minor, &patch)) {
-             }
+         gpgme_release (ctx);
-             else if ((!rc && pubrings && secring_ok)
+         return 1;
-                   || (!rc && secrings && pubring_ok)) {
+     }
-                 free_if_alloc (optfile);
+     gpgme_release (ctx);
-                 return 0; /* found one keyring and one entry in the options file */
-             }
+     if (major > need_major)
-             else
+         rc = 0;
-                 return WPTERR_GPG_OPT_KEYRINGS;
+     else if (major == need_major && minor > need_minor)
-         }
+         rc = 0;
-         free_if_alloc (optfile);
+     else if (major == need_major && minor == need_minor &&
-         rc = WPTERR_GPG_KEYRINGS;
+              patch >= need_patch)
-     }
+         rc = 0;
-     return rc;
- } /* gnupg_access_files */
+     /* Return the current GPG version. */
+     *r_major = major;
+     *r_minor = minor;
- static int
+     *r_patch = patch;
- create_gpg_options( void )
+     return rc;
- {
+ }
-     FILE *fp;
-     char *s, *optfile;
+ /* Count the keyring entries in the gpg.conf file.
-     s = get_gnupg_path( );
+    Return value: 0 on success. */
-     if( s == NULL )
+ static int
-         return WPTERR_FILE_CREAT;
+ cfgfile_count_keyrings (const char *fname, int *r_secrings, int *r_pubrings)
-     optfile = make_filename( s, GPG_CONF, NULL );
+ {
-     fp = fopen( optfile, "wb" );
+     config_file_t opt;
-     if( fp == NULL ) {
+     conf_option_t e;
-         return WPTERR_FILE_CREAT;
-         goto fail;
+     *r_secrings = 0;
-     }
+     *r_pubrings = 0;
-     fwrite( options_skel, 1, strlen( options_skel ), fp );
-     fclose( fp );
+     if (parse_config (fname, &opt))
+         return WPTERR_FILE_OPEN;
- fail:
+     for (e = opt->list; e; e = e->next) {
-     free_if_alloc( s );
+         if (!strcmp (e->name, "secret-keyring")) {
-     free_if_alloc( optfile );
+             if (!file_exist_check (e->val))
-     return 0;
+                 r_secrings[0]++;
- } /* create_gpg_options */
+         }
+         else if (!strcmp (e->name, "keyring")) {
+             if (!file_exist_check (e->val))
- /*
+                 r_pubrings[0]++;
-  * Return the contents of the options file as a char buf.
+         }
-  */
+     }
- char *
+     release_config (opt);
- get_gnupg_config (void)
+     return 0;
- {
+ }
-     FILE * fp;
-     char * p = NULL, * optfile = NULL;
-     int fsize, rc = 0;
+ /* Usually GPG creates the pubring.gpg, secring.gpg on
+    the first start, but to make sure they always exist
-     optfile = get_gnupg_cfgfile ();
+    create them empty if needed. */
-     if( optfile == NULL )
+ static void
-         return NULL;
+ create_empty_keyring (int _pub)
-     fsize = get_file_size( optfile );
+ {
-     if( !fsize ) {
+     char *name;
-         rc = create_gpg_options( );
+     FILE *fp;
-         if ( rc )
-             return NULL;
+     name = get_gnupg_keyring (_pub, 0);
-         fsize = get_file_size( optfile );
+     if (name && file_exist_check (name) != 0) {
-     }
+         fp = fopen (name, "ab");
-     if( fsize > 100000 )
+         if (fp != NULL)
-         goto leave; /* too large */
+             fclose (fp);
-     p = new char[fsize+1];
+     }
-     if( p == NULL )
+     free_if_alloc (name);
-         BUG( NULL );
+ }
-     fp = fopen( optfile, "rb" );
-     if( fp == NULL ) {
-         free_if_alloc( p );
+ /* Check if both keyrings are located in the gnupg home directory. */
-         return NULL;
+ int
-     }
+ gnupg_access_files (void)
-     fread( p, 1, fsize, fp );
+ {
-     fclose( fp );
+     int rc = 0;
-     p[fsize] = '\0';
+     int pubring_ok = 0, secring_ok = 0;
-     free_if_alloc( optfile );
+     int secrings = 0, pubrings = 0;
+     char *optfile;
- leave:
-     return p;
+     create_empty_keyring (1);
- } /* get_gnupg_config */
+     if (gnupg_access_keyring (1))
+         rc = WPTERR_GPG_KEYRINGS;
+     else
- int
+         pubring_ok = 1;
- set_gnupg_default_key (const char * key)
- {
+     create_empty_keyring (0);
-     gpg_optfile_t opt;
+     if (gnupg_access_keyring (0))
-     gpg_option_t e;
+         rc = WPTERR_GPG_KEYRINGS;
-     char *optfile = NULL;
+     else
-     int rc = 0;
+         secring_ok = 1;
-     optfile = get_gnupg_cfgfile ();
+     if (!pubring_ok || !secring_ok) {
-     if (!optfile)
+         optfile = get_gnupg_cfgfile ();
-         return -1;
+         if (!optfile)
-     rc = parse_gpg_options (optfile, &opt);
+             return WPTERR_GPG_KEYRINGS;
-     if( rc ) {
+         rc = file_exist_check (optfile);
-         free_if_alloc (optfile);
+         if (!rc && get_file_size (optfile) > 0) {
-         return -1;
+             rc = cfgfile_count_keyrings (optfile, &secrings, &pubrings);
-     }
+             if (!rc && secrings > 0 && pubrings > 0) {
-     e = find_option (opt, "default-key");
+                 free_if_alloc (optfile);
-     if (e) {
+                 return 0; /* found two keyrings in the option file */
-         free_if_alloc (e->val);
+             }
-         e->val = m_strdup (key);
+             else if ((!rc && pubrings && secring_ok)
-         e->used = 1;
+                   || (!rc && secrings && pubring_ok)) {
-     }
+                 free_if_alloc (optfile);
-     else
+                 return 0; /* found one keyring and one entry in the options file */
-         add_entry (opt, ENTRY_MULTI, "default-key", key);
+             }
-     rc = commit_gpg_options (optfile, opt);
+             else
+                 return WPTERR_GPG_OPT_KEYRINGS;
-     free_if_alloc (optfile);
+         }
-     release_gpg_options (opt);
+         free_if_alloc (optfile);
+         rc = WPTERR_GPG_KEYRINGS;
-     return rc;
+     }
- } /* set_gnupg_default_key */
+     return rc;
+ }
- /*
-  * Set the contents of the options file.
+ static int
-  */
+ create_gpg_conf (void)
- int
+ {
- set_gnupg_options( const char *buf, size_t buflen )
+     FILE *fp;
- {
+     char *s, *optfile;
-     FILE *fp;
-     char *optfile = NULL;
+     s = get_gnupg_path ();
+     if (!s)
-     optfile = get_gnupg_cfgfile( );
+         return WPTERR_FILE_CREAT;
-     if( optfile == NULL )
+     optfile = make_filename (s, GPG_CONF, NULL);
-         return WPTERR_FILE_CREAT;
+     fp = fopen (optfile, "wb");
+     if (!fp) {
-     fp = fopen( optfile, "wb" );
+         return WPTERR_FILE_CREAT;
-     if( fp == NULL ) {
+         goto fail;
-         free_if_alloc( optfile );
+     }
-         return WPTERR_FILE_CREAT;
+     fwrite (options_skel, 1, strlen (options_skel), fp);
-     }
+     fclose (fp);
-     fwrite( buf, 1, buflen, fp );
-     fclose( fp );
+ fail:
-     free_if_alloc( optfile );
+     free_if_alloc (s);
-     return 0;
+     free_if_alloc (optfile);
- } /* set_gnupg_options */
+     return 0;
+ }
- /*
-  * Check if the line contains a valid GPG argument.
-  */
+ /* Return the contents of the options file as a char buf. */
- static int
+ char*
- check_line( const char *buf )
+ get_gnupg_config (void)
  {
-     int j, len;
+     FILE *fp;
-     int rc = 0;
+     char *p = NULL, *optfile = NULL;
+     int fsize;
-     if( *buf == '#' || *buf == '\r' || *buf == '\n' )
-         return 1;
+     optfile = get_gnupg_cfgfile ();
-     rc = 0;
+     if (!optfile)
-     for ( j = 0; valid_gpg_args[j]; j++ ) {
+         return NULL;
-         len = strlen( valid_gpg_args[j] );
+     fsize = get_file_size (optfile);
-         if( !strncmp( valid_gpg_args[j], buf, len ) )
+     if (!fsize) {
-             rc = 1;
+         if (create_gpg_conf ())
-     }
+             return NULL;
+         fsize = get_file_size (optfile);
-     return rc;
+     }
- } /* check_line */
+     if (fsize > 100000)
+         goto leave; /* too large */
+     p = new char[fsize+1];
- int
+     if (!p)
- check_gnupg_options( const char *buf )
+         BUG (NULL);
- {
+     fp = fopen( optfile, "rb" );
-     char line[1024];
+     if (!fp) {
-     int nbytes = 0;
+         free_if_alloc (p);
-     unsigned j;
+         return NULL;
+     }
-     for ( j = 0; j<strlen( buf ) && j < sizeof(line); j++ ) {
+     fread (p, 1, fsize, fp);
-         line[nbytes++] = buf[j];
+     fclose (fp);
-         if ( buf[j] == '\n' || j == ( strlen( buf ) - 1 ) ) {
+     p[fsize] = '\0';
-             line[nbytes] = '\0';
+     free_if_alloc (optfile);
-             if( !check_line( line ) ) {
-                 msg_box( NULL, line, "options", MB_OK );
+ leave:
-                 return 1;
+     return p;
-             }
+ }
-             nbytes = 0;
-         }
-     }
+ /* Set the default key in the gpg.conf.
+    If @key is NULL, the entry will be deleted. */
-     return 0;
+ int
- } /* check_gnupg_options */
+ set_gnupg_default_key (const char *key)
+ {
+     config_file_t opt;
- static int
+     conf_option_t e;
- get_last_gnupg_access (gpg_watcher_s * ctx)
+     char *optfile = NULL;
- {
+     int rc = 0;
-     HANDLE fd;
-     char *path = NULL, *file = NULL;
+     optfile = get_gnupg_cfgfile ();
+     if (!optfile)
-     path = get_gnupg_path ();
+         return WPTERR_FILE_OPEN;
-     file =  make_filename (path, ctx->object, NULL);
+     rc = parse_config (optfile, &opt);
-     fd = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, NULL);
+     if (rc) {
-     if( fd == INVALID_HANDLE_VALUE ) {
+         free_if_alloc (optfile);
-         free_if_alloc (path);
+         return WPTERR_GENERAL;
-         free_if_alloc (file);
+     }
-         return WPTERR_FILE_OPEN;
+     e = conf_find_option (opt, "default-key");
-     }
+     if (e && !key)
-     GetFileTime (fd, NULL, NULL, &ctx->access);
+         e->used = 0;
-     CloseHandle (fd);
+     else if (e) {
-     free_if_alloc (path);
+         free_if_alloc (e->val);
-     free_if_alloc (file);
+         e->val = m_strdup (key);
-     return 0;
+         e->used = 1;
- } /* get_last_gnupg_access */
+     }
+     else if (key)
+         conf_add_entry (opt, ENTRY_MULTI, "default-key", key);
- static void
+     rc = commit_config (optfile, opt);
- check_last_gnupg_access( gpg_watcher_s *ctx )
- {
+     free_if_alloc (optfile);
-     ctx->modified = 0;
+     release_config (opt);
+     return rc;
-     if( ctx->last_access.dwHighDateTime != ctx->access.dwHighDateTime &&
+ }
-         ctx->last_access.dwLowDateTime != ctx->access.dwLowDateTime )
-         ctx->modified = 1;
+ /* Set the contents of the options file. */
-     ctx->last_access.dwLowDateTime = ctx->access.dwLowDateTime;
+ int
-     ctx->last_access.dwHighDateTime = ctx->access.dwHighDateTime;
+ set_gnupg_options (const char *buf, size_t buflen)
- } /* check_last_gnupg_access */
+ {
+     FILE *fp;
+     char *optfile;
- void
- init_gnupg_table (void)
+     optfile = get_gnupg_cfgfile ();
- {
+     if (!optfile)
-     int j;
+         return WPTERR_FILE_CREAT;
-     for (j = 0; j < gpg_table_count; j++) {
+     fp = fopen (optfile, "wb");
-         gpg_table[j].object = m_strdup (gpg_objs[j]);
+     if (!fp) {
-         memset (&gpg_table[j].access, 0, sizeof (FILETIME));
+         free_if_alloc (optfile);
-         memset (&gpg_table[j].last_access, 0, sizeof (FILETIME));
+         return WPTERR_FILE_CREAT;
-         gpg_table[j].modified = 0;
+     }
-     }
+     fwrite (buf, 1, buflen, fp);
- } /* init_gnupg_table */
+     fclose (fp);
+     free_if_alloc (optfile);
+     return 0;
- void
+ }
- free_gnupg_table (void)
- {
-     int j;
+ /* Check if the parameter for the option @buf is an existing file name.
+    Return value: 0 on success. */
-     for (j=0; j < gpg_table_count; j++)
+ static int
-         free_if_alloc (gpg_table[j].object);
+ check_arg_file_exist (const char *buf)
- } /* free_gnupg_table */
+ {
+     const char *s = "load-extension ";
- int
+     /* XXX: this is a bit of a kludge because we just
- keyring_check_last_access (void)
+             detect errors for 'load-extension'. */
- {
+     if (!strncmp (buf, s, strlen (s)))
-     int rc, j;
+         buf += strlen (s);
+     else
-     rc = 0;
+         return 0;
-     for (j = 0; j < gpg_table_count; j++) {
+     return file_exist_check (buf);
-         get_last_gnupg_access( &gpg_table[j] );
+ }
-         check_last_gnupg_access( &gpg_table[j] );
-         if ( gpg_table[j].modified )
-             rc++;
+ /* Check if the line contains a valid GPG argument. */
-     }
+ static int
+ check_line (const char *buf)
-     return rc;
+ {
- } /* keyring_check_last_access */
+     int j, len;
+     int rc = 0;
- const char*
+     if (*buf == '#' || *buf == '\r' || *buf == '\n')
- gnupg_check_file_ext (const char *fname, int *r_type)
+         return 1;
- {
+     for (j = 0; valid_gpg_args[j]; j++) {
-     char file_ext[5];
+         len = strlen (valid_gpg_args[j]);
+         if (!strncmp (valid_gpg_args[j], buf, len))
-     if (r_type) *r_type = PGP_NONE;
+             rc = 1;
-     if (!strchr (fname, '.' ))
+     }
-         return "UNKNOWN";
+     return rc;
+ }
-     strncpy (file_ext, fname + strlen (fname) - 4, 4);
-     file_ext[4] = '\0';
-     if (!stricmp (file_ext, ".asc"))
+ int
-         return "ARMORED";
+ check_gnupg_options (const char *buf, int showerr)
-     else if (!stricmp (file_ext, ".sig")) {
+ {
-         if (r_type)
+     char line[1024];
-             *r_type = PGP_SIG;
+     int nbytes = 0, lineno=0;
-         return "SIGNED";
+     unsigned j;
-     }
-     else if  (!stricmp (file_ext, ".gpg") || !stricmp (file_ext, ".pgp")) {
+     for  (j = 0; j < strlen (buf) && j < DIM (line); j++) {
-         if (r_type)
+         line[nbytes++] = buf[j];
-             *r_type = PGP_MESSAGE;
+         if (buf[j] == '\n' || j == (strlen (buf) - 1)) {
-         return "ENCRYPTED";
+             line[nbytes] = '\0';
-     }
+             lineno++;
-     return "UNKNOWN";
+             if (!check_line (line)) {
- }
+                 if (showerr)
+                     log_box ("GPG Config File", MB_ERR,
+                              "gpg.conf:%d: invalid keyword '%s'",
- char *
+                              lineno, line);
- get_gnupg_keyring_from_options (const char * fname, int pub)
+                 return 1;
- {
+             }
-     gpg_optfile_t opt;
+             if (check_arg_file_exist (line))
-     gpg_option_t e;
+                 return WPTERR_FILE_EXIST;
-     char * kring = NULL;
+             nbytes = 0;
-     int rc = 0;
+         }
+     }
-     rc = parse_gpg_options (fname, &opt);
+     return 0;
-     if (rc)
+ }
-         return NULL;
-     if (pub)
-         e = find_option (opt, "keyring");
+ /* Store the last access of the file inside the watcher @ctx. */
-     else
+ static int
-         e = find_option (opt, "secret-keyring");
+ get_last_gnupg_access (gpg_monitor_t ctx)
-     if (e)
+ {
-         kring = m_strdup (e->val);
+     HANDLE fd;
-     release_gpg_options (opt);
+     fd = CreateFile (ctx->fpath_object, GENERIC_READ, FILE_SHARE_READ,
-     return kring;
+                      NULL, OPEN_EXISTING, 0, NULL);
- } /* get_gnupg_keyring_from_options */
+     if (fd == INVALID_HANDLE_VALUE)
+         return WPTERR_FILE_OPEN;
+     GetFileTime (fd, NULL, NULL, &ctx->access);
+     CloseHandle (fd);
- /* XXX: does not work with write-protected floppies */
+     return 0;
- static int
+ }
- my_access (const char * fname)
- {
-     HANDLE hd;
+ /* Check if the file inside watcher @ctx was modified. */
-     hd = CreateFile (fname, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+ static void
-     if (hd == INVALID_HANDLE_VALUE)
+ check_last_gnupg_access (gpg_monitor_t ctx)
-         return -1;
+ {
-     CloseHandle (hd);
+     ctx->modified = 0;
-     return 0;
- } /* my_access */
+     if (ctx->last_access.dwHighDateTime != ctx->access.dwHighDateTime &&
+         ctx->last_access.dwLowDateTime != ctx->access.dwLowDateTime)
+         ctx->modified = 1;
- int
- gpg_check_permissions (int showmsg)
+     if (ctx->last_access.dwLowDateTime == 0)
- {
+         ctx->modified = 0;
-     char * p, * name = NULL;
-     int failed = 0, ans=0, attrs=0;
+     ctx->last_access.dwLowDateTime = ctx->access.dwLowDateTime;
+     ctx->last_access.dwHighDateTime = ctx->access.dwHighDateTime;
-     p = get_gnupg_path ();
+ }
-     check_keyring (&p);
-     if (p) {
-         name = make_filename (p, "pubring", "gpg");
+ /* Init GPG monitor table for all monitored files. */
-         free_if_alloc (p);
+ void
-         if ((attrs=GetFileAttributes (name)) & FILE_ATTRIBUTE_READONLY) {
+ init_gnupg_table (void)
-             ans = msg_box (NULL,
+ {
-                            _("The selected keyring has the read-only file\n"
+     char *path;
-                              "attribute. In this state you do not have write\n"
+     int j;
-                              "access. Do you want to remove the attribute?"),
-                      _("GPG Information"), MB_YESNO);
+     path = get_gnupg_path ();
-             if (ans == IDYES) {
+     for (j = 0; j < gpg_table_count; j++) {
-                 attrs &= ~FILE_ATTRIBUTE_READONLY;
+         gpg_table[j].object = m_strdup (gpg_objs[j]);
-                 if (!SetFileAttributes (name, attrs)) {
+         gpg_table[j].fpath_object = make_filename (path, gpg_objs[j], NULL);
-                     msg_box (NULL, _("Could not reset read-only state."),
+         memset (&gpg_table[j].access, 0, sizeof (FILETIME));
-                              _("GPG Error"), MB_ERR);
+         memset (&gpg_table[j].last_access, 0, sizeof (FILETIME));
-                     failed = 1;
+         gpg_table[j].modified = 0;
-                 }
+     }
-             }
+     free_if_alloc (path);
-             else if (ans == IDNO) {
+ }
-                 /*
-                 msg_box (NULL, _("All commands with write access to the keyring\n"
-                                  "will be disabled."), _("GPG Information"), MB_INFO);
+ /* Release the GPG monitor table. */
-                 */
+ void
-                 failed = 1;
+ free_gnupg_table (void)
-             }
+ {
-         }
+     int j;
-         if (my_access (name)) {
-             if (showmsg)
+     for (j=0; j < gpg_table_count; j++) {
-                 msg_box (NULL,
+         free_if_alloc (gpg_table[j].object);
-                 _("You do not have file access to modify the contents of\n"
+         free_if_alloc (gpg_table[j].fpath_object);
-                   "one or both of the selected keyrings.\n"
+     }
-                   "\n"
+ }
-                   "The keyrings are in a read-only state which is propably\n"
-                   "caused by another program which already opened the files.\n"),
-                    _("GPG Warning"), MB_WARN);
+ /* Return the amount of files modified since the last call. */
-             failed = 2;
+ int
-         }
+ keyring_check_last_access (void)
-     }
+ {
-     free_if_alloc (name);
+     int nfiles;
-     return failed;
+     int pos;
- } /* gpg_check_permissions */
+     nfiles = 0;
+     for (pos = 0; pos < gpg_table_count; pos++) {
- static int
+         get_last_gnupg_access (&gpg_table[pos]);
- check_homedir (void)
+         check_last_gnupg_access (&gpg_table[pos]);
- {
+         if (gpg_table[pos].modified)
-     char * homedir = NULL;
+             nfiles++;
-     int yes = 0;
+     }
-     homedir = get_reg_entry_gpg ("HomeDir");
+     return nfiles;
-     if (!homedir)
+ }
-         homedir = multi_gnupg_path ();
-     if (!homedir)
-         homedir = m_strdup ("c:\\gnupg");
+ const char*
-     if (homedir) {
+ gnupg_check_file_ext (const char *fname, int *r_type)
-         if (GetFileAttributes (homedir) == 0xFFFFFFFF) {
+ {
-             yes = log_box (_("Preferences"), MB_YESNO,
+     char file_ext[5];
-                            _("%s does not exit.\n"
-                              "Do you want to create this directory?"), homedir);
+     if (r_type)
-             if (yes == IDYES) {
+         *r_type = PGP_NONE;
-                 if (CreateDirectory (homedir, NULL) == FALSE) {
+     if (!strchr (fname, '.' ))
-                     free_if_alloc (homedir);
+         return "UNKNOWN";
-                     return WPTERR_DIR_CREAT;
-                 }
+     strncpy (file_ext, fname + strlen (fname) - 4, 4);
-             }
+     file_ext[4] = '\0';
-             return WPTERR_DIR_OPEN;
+     if (!stricmp (file_ext, ".asc"))
-         }
+         return "ARMORED";
-         free_if_alloc (homedir);
+     else if (!stricmp (file_ext, ".sig")) {
-     }
+         if (r_type)
-     return 0;
+             *r_type = PGP_SIG;
- } /* check_homedir */
+         return "SIGNED";
+     }
+     else if  (!stricmp (file_ext, ".gpg") ||
- int
+               !stricmp (file_ext, ".pgp")) {
- gnupg_check_homedir (void)
+         if (r_type)
- {
+             *r_type = PGP_MESSAGE;
-     char *homedir = NULL, *prog = NULL;
+         return "ENCRYPTED";
-     int rc = 0, ec = 0;
+     }
+     return "UNKNOWN";
-     rc = check_homedir ();
+ }
-     if (rc)
-         return rc;
-     if ((homedir = get_reg_entry_gpg ("HomeDir")) &&
+ /* Check if the device where file @fname is stored on, is write-protected. */
-         !(prog = get_reg_entry_gpg ("gpgProgram" ))) {
+ static int
-         prog = make_filename (homedir, "gpg", "exe");
+ check_file_access (const char *fname, int mode)
-         if (file_exist_check (prog) == 0) {
+ {
-             rc = set_reg_entry_gpg ("gpgProgram", prog);
+     HANDLE hd;
-             if (rc)
-                 goto fail;
+     if (!mode)
-         }
+         mode = FILE_SHARE_WRITE;
-         free_if_alloc (homedir);
+     hd = CreateFile (fname, GENERIC_WRITE, mode,
-         free_if_alloc (prog);
+                      NULL, OPEN_EXISTING, 0, NULL);
-         return rc;
+     if (hd == INVALID_HANDLE_VALUE)
-     }
+         return -1;
-     if ((prog = get_reg_entry_gpg ("gpgProgram"))
+     CloseHandle (hd);
-         && file_exist_check (prog)) {
+     return 0;
-         free_if_alloc (prog);
+ }
-         homedir = get_reg_entry_gpg ("HomeDir");
-         if (!homedir) {
-             rc = WPTERR_GENERAL;
+ /* Check the device where the file @fname is stored on, is either
-             goto fail;
+    write-protected or if the file is already opened by another process
-         }
+    exclusively. And as a result, we cannot use the file for output. */
-         prog = make_filename (homedir, "gpg", "exe");
+ int
-         if (file_exist_check (prog) == 0) {
+ gpg_check_file_permissions (const char *fname, int mode)
-             rc = set_reg_entry_gpg ("gpgProgram", prog);
+ {
-             if (rc)
+     int api_mode;
-                 goto fail;
-             free_if_alloc (prog);
+     switch (mode) {
-             return rc;
+     case 0: api_mode = FILE_SHARE_READ; break;
-         }
+     case 1: api_mode = FILE_SHARE_WRITE; break;
-     }
+     case 2: api_mode = FILE_SHARE_WRITE|FILE_SHARE_READ; break;
+     default: api_mode = FILE_SHARE_READ; break;
-     /* 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)))
+     return check_file_access (fname, api_mode);
-         rc = WPTERR_GENERAL;
+ }
- fail:
-     free_if_alloc (homedir);
+ /* Check the file permissions of the public keyring.
-     free_if_alloc (prog);
+    If @showmsg is 1 output a message in case of errors.
-     return rc;
+    Return value: 1 if read-only attribute
- } /* gnupg_check_homedir */
+if file is opened by another process exclusively. */
+ int
+ gpg_check_permissions (int showmsg)
- int
+ {
- gnupg_copy_keyrings (void)
+     char *p = NULL;
- {
+     char *name = NULL;
-     const char * pring, * sring;
+     int failed = 0, ans=0, attrs=0;
-     char * file = NULL, * path = NULL;
-     int id = 0, rc = 0;
+     p = get_gnupg_path ();
-     HWND hwnd;
+     if (p && check_keyring (&p)) {
+         name = make_filename (p, "pubring", "gpg");
-     path = get_gnupg_path ();
+         if ((attrs=GetFileAttributes (name)) & FILE_ATTRIBUTE_READONLY) {
-     if (!path)
+             ans = msg_box (NULL,
-         return WPTERR_GENERAL;
+                            _("The selected keyring has the read-only file\n"
-     hwnd = GetDesktopWindow ();
+                              "attribute. In this state you do not have write\n"
+                              "access. Do you want to remove the attribute?"),
-     pring = get_filename_dlg (hwnd, FILE_OPEN, _("Please choose your public keyring"),
+                      _("GPG Information"), MB_YESNO);
-                               _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),NULL);
+             if (ans == IDYES) {
-     if (!pring) {
+                 attrs &= ~FILE_ATTRIBUTE_READONLY;
-         msg_box (hwnd, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR);
+                 if (!SetFileAttributes (name, attrs)) {
-         free_if_alloc (path);
+                     msg_box (NULL, _("Could not reset read-only state."),
-         return WPTERR_GENERAL;
+                              _("GPG Error"), MB_ERR);
-     }
+                     failed = 1;
-     file = make_filename (path, "pubring", "gpg");
+                 }
-     if (file_exist_check (file) == 0) {
+             }
-         id = msg_box (hwnd, _("Overwrite old public keyring?"), "WinPT", MB_INFO|MB_YESNO);
+             else if (ans == IDNO) {
-         if (id == IDNO)
+                 /* All commands with write access will be disabled. */
-             goto fail;
+                 failed = 1;
-     }
+             }
-     if (!CopyFile (pring, file, FALSE)) {
+         }
-         msg_box (hwnd, _("Could not copy file."), _("WinPT Error"), MB_ERR);
+         if (gpg_check_file_permissions (name, 1)) {
-         rc = WPTERR_FILE_READ;
+             if (showmsg)
-         goto fail;
+                 msg_box (NULL,
-     }
+                 _("You do not have file access to modify the contents of\n"
-     free_if_alloc (file);
+                   "one or both of the selected keyrings.\n"
+                   "\n"
-     sring = get_filename_dlg (hwnd, FILE_OPEN, _("Please choose your secret keyring"),
+                   "The keyrings are in a read-only state which is propably\n"
-                               _("GPG Keyrings (*.gpg)\0*.gpg\0\0"), NULL);
+                   "caused by another program which already opened the files.\n"),
-     if (!sring) {
+                    _("GPG Warning"), MB_WARN);
-         msg_box( NULL, _("No keyring was chosen. Exit."), _("WinPT Error"), MB_ERR );
+             failed = 2;
-         return WPTERR_GENERAL;
+         }
      }
-     file = make_filename (path, "secring", "gpg");
+     free_if_alloc (p);
-     if (file_exist_check (file) == 0) {
+     free_if_alloc (name);
-         id = msg_box (hwnd, _("Overwrite old secret keyring?"), "WinPT", MB_INFO|MB_YESNO);
+     return failed;
-         if( id == IDNO )
+ }
-             goto fail;
-     }
-     if (!CopyFile (sring, file, FALSE)) {
+ /* Check the GPG home dir. First try to read the 'HomeDir' registry entry,
-         msg_box( NULL, _("Could not copy file."), _("WinPT Error"), MB_ERR);
+    then check for $APPDATA\gnupg. Create the dir if it does not exists. */
-         rc = WPTERR_FILE_READ;
+ int
-     }
+ gnupg_check_homedir (void)
+ {
- fail:
+     char *homedir;
-     free_if_alloc (file);
+     int val;
-     free_if_alloc (path);
+     int rc = 0;
-     return rc;
- } /* gnupg_import_keyrings */
+ #ifdef WINPT_MOBILE
+     return 0;
+ #endif
- void
- gnupg_backup_options (void)
+     homedir = get_reg_entry_gpg (GPG_REG_HOME);
- {
+     if (!homedir)
-     char *cfgfile = NULL;
+         homedir = multi_gnupg_path (0);
-     char bak[512];
+     if (homedir) {
+         if (GetFileAttributes (homedir) == 0xFFFFFFFF) {
-     cfgfile = get_gnupg_cfgfile ();
+             val = log_box (_("Preferences"), MB_YESNO,
-     if (cfgfile == NULL)
+                            _("%s does not exit.\n"
-         return;
+                              "Do you want to create this directory?"), homedir);
-     _snprintf (bak, DIM (bak)-1, "%s.bak", cfgfile);
+             if (val == IDYES) {
-     CopyFile (cfgfile, bak, FALSE);
+                 if (!CreateDirectory (homedir, NULL))
-     free_if_alloc (cfgfile);
+                     rc = WPTERR_DIR_CREAT;
- } /* gnupg_backup_options */
+             }
+             else
+                 rc = WPTERR_DIR_OPEN;
+         }
- static int
+         free_if_alloc (homedir);
- backup_one_file (const char * srcpath, const char * srcn,
+     }
-                  const char * dstpath, const char * dstn)
+     return rc;
- {
+ }
-     char * src, * dst;
-     BOOL rc;
+ int
-     src = make_filename (srcpath, srcn, "gpg");
+ gnupg_copy_keyrings (void)
-     if (!src)
+ {
-         BUG (NULL);
+     const char *pring, *sring;
-     dst = make_filename (dstpath, dstn, "gpg");
+     char *file = NULL, *path = NULL;
-     if (!dst)
+     int id = 0, rc = 0;
-         BUG (NULL);
+     HWND hwnd;
-     rc = CopyFile (src, dst, FALSE);
-     free_if_alloc (src);
+     path = get_gnupg_path ();
-     free_if_alloc (dst);
+     if (!path)
-     if (!rc)
+         return WPTERR_GENERAL;
-     {
+     hwnd = GetDesktopWindow ();
-         log_box (_("Backup"), MB_ERR, _("Backup keyring \"%s\" failed"), srcn);
-         return WPTERR_GENERAL;
+     pring = get_fileopen_dlg (hwnd, _("Please choose your Public Keyring"),
-     }
+                               "GPG Keyrings (*.gpg)\0*.gpg\0\0",NULL);
-     return 0;
+     if (!pring) {
- } /* backup_one_file */
+         msg_box (hwnd, _("No keyring was chosen. Exit."),
+                  _("WinPT Error"), MB_ERR);
+         free_if_alloc (path);
- static int
+         return WPTERR_GENERAL;
- check_keyring (char ** r_path)
+     }
- {
+     file = make_filename (path, "pubring", "gpg");
-     char * p;
+     if (file_exist_check (file) == 0) {
-     char * opt, * name;
+         id = msg_box (hwnd, _("Overwrite old public keyring?"),
+                       "WinPT", MB_INFO|MB_YESNO);
-     if (!*r_path)
+         if (id == IDNO)
-         return 0;
+             goto fail;
-     p = make_filename (*r_path, "pubring", "gpg");
+     }
-     if (!p || get_file_size (p) > 0)
+     if (!CopyFile (pring, file, FALSE)) {
-         return 0;
+         msg_box (hwnd, _("Could not copy file."), _("WinPT Error"), MB_ERR);
+         rc = WPTERR_FILE_READ;
-     opt = get_gnupg_cfgfile ();
+         goto fail;
-     if (!opt)
+     }
-         BUG (0);
+     free_if_alloc (file);
-     name = get_gnupg_keyring_from_options (opt, 1);
-     free_if_alloc (opt);
+     sring = get_fileopen_dlg (hwnd, _("Please choose your Secret Keyring"),
-     free_if_alloc (p);
+                               "GPG Keyrings (*.gpg)\0*.gpg\0\0", NULL);
-     if (!name)
+     if (!sring) {
-         return 0;
+         msg_box (NULL, _("No keyring was chosen. Exit."),
-     p = strrchr (name, '\\');
+                  _("WinPT Error"), MB_ERR);
-     if (!p)
+         return WPTERR_GENERAL;
-     {
+     }
-         free_if_alloc (name);
+     file = make_filename (path, "secring", "gpg");
-         return 0;
+     if (file_exist_check (file) == 0) {
-     }
+         id = msg_box (hwnd, _("Overwrite old secret keyring?"),
-     free_if_alloc (*r_path);
+                       "WinPT", MB_INFO|MB_YESNO);
-     *r_path = new char [strlen (name)+1];
+         if (id == IDNO)
-     memset (*r_path, 0, strlen (name));
+             goto fail;
-     strncpy (*r_path, name, (p-name));
+     }
-     free_if_alloc (name);
+     if (!CopyFile (sring, file, FALSE)) {
-     return 1;
+         msg_box (NULL, _("Could not copy file."), _("WinPT Error"), MB_ERR);
- }
+         rc = WPTERR_FILE_READ;
+     }
- static char*
+ fail:
- get_backup_name (const char *templ)
+     free_if_alloc (file);
- {
+     free_if_alloc (path);
-     struct tm *tm;
+     return rc;
-     char *p;
+ }
-     time_t t = time (NULL);
-     tm = localtime (&t);
+ /* Backup the gpg.conf file. */
-     p = new char [strlen (templ) + 8 + 1];
+ void
-     if (!p)
+ gnupg_backup_options (void)
-         BUG (0);
+ {
-     sprintf (p, "%s-%d", templ, tm->tm_wday % 3);
+     char *cfgfile;
-     return p;
+     char bak[MAX_PATH+32];
- }
+     cfgfile = get_gnupg_cfgfile ();
+     if (!cfgfile)
- void
+         return;
- gnupg_backup_keyrings (void)
+     _snprintf (bak, DIM (bak)-1, "%s.bak", cfgfile);
- {
+     CopyFile (cfgfile, bak, FALSE);
-     char *srcpath = NULL, *dstpath = NULL;
+     free_if_alloc (cfgfile);
-     char *name=NULL;
+ }
-     int rc, bakmode=0;
-     if (!reg_prefs.auto_backup)
+ static int
-         return;
+ backup_one_file (const char *srcpath, const char *srcn,
-     bakmode = reg_prefs.backup.mode;
+                  const char *dstpath, const char *dstn)
-     srcpath =  get_gnupg_path ();
+ {
-     check_keyring (&srcpath);
+     char *src, *dst;
-     if (bakmode == 1) {
+     BOOL rc;
-         dstpath = get_gnupg_path ();
-         check_keyring (&dstpath);
+     src = make_filename (srcpath, srcn, "gpg");
-     }
+     dst = make_filename (dstpath, dstn, "gpg");
-     else if (bakmode == 2) {
+     rc = CopyFile (src, dst, FALSE);
-         char * tmpfile;
+     free_if_alloc (src);
-         FILE * fp;
+     free_if_alloc (dst);
+     if (!rc) {
-         dstpath = m_strdup (reg_prefs.backup.path);
+         log_box (_("Backup"), MB_ERR, _("Backup keyring \"%s\" failed"), srcn);
-         if (!dstpath)
+         return WPTERR_GENERAL;
-             BUG (0);
+     }
-         tmpfile = make_filename (reg_prefs.backup.path, "test", "tmp");
+     return 0;
-         fp = fopen (tmpfile, "wb");
+ }
-         if (!fp)
-             rc = log_box (_("Backup"), MB_WARN|MB_RETRYCANCEL, _("The backup drive '%s' does not seems to accessable.\n"
-                                                                  "Please insert/check the drive to continue."), dstpath);
+ /* Figure out first public keyring which is not empty.
-         else {
+    Return value: 1 on success. */
-             rc = 0;
+ static int
-             fclose (fp);
+ check_keyring (char **r_path)
-             unlink (tmpfile);
+ {
-         }
+     char *p;
-         free_if_alloc (tmpfile);
+     char *opt;
-         if (!fp || rc == IDCANCEL)
+     char *name;
-             return;
-     }
+     if (!*r_path)
-     else {
+         return 0;
-         log_box (_("Backup"), MB_ERR, _("Invalid backup mode %d"), bakmode);
+     p = make_filename (*r_path, "pubring", "gpg");
-         return;
+     if (get_file_size (p) <= 0)
-     }
+         return 0;
-     name = get_backup_name ("pubring-bak");
-     rc = backup_one_file (srcpath, "pubring", dstpath, name);
+     opt = get_gnupg_cfgfile ();
-     if (!rc)
+     if (!opt)
-         rc = backup_one_file (srcpath, "secring", dstpath, "secring-bak");
+         BUG (0);
-     free_if_alloc (name);
+     name = get_keyring_from_conf (opt, 1);
-     free_if_alloc (srcpath);
+     free_if_alloc (opt);
-     free_if_alloc (dstpath);
+     free_if_alloc (p);
- } /* gnupg_backup_keyrings */
+     if (!name)
+         return 0;
+     p = strrchr (name, '\\');
- void
+     if (!p) {
- gnupg_display_error (void)
+         free_if_alloc (name);
- {
+         return 0;
-     char tmpath[512], * errstr;
+     }
-     size_t size = 0;
+     free_if_alloc (*r_path);
-     FILE * fp;
+     *r_path = new char [strlen (name)+1];
+     memset (*r_path, 0, strlen (name));
-     GetTempPath (sizeof tmpath - 32, (tmpath));
+     strncpy (*r_path, name, (p-name));
-     strcat (tmpath, "gpg_stderr");
+     free_if_alloc (name);
-     size = get_file_size (tmpath);
+     return 1;
-     if (file_exist_check (tmpath) || size <= 0)
+ }
-         return;
-     fp = fopen( tmpath, "rb" );
-     if (!fp) {
+ /* Return a temp name based on the day of the week. */
-         msg_box( NULL, _("No GPG error description available."), _("GPG Error"), MB_INFO );
+ static char*
-         return;
+ get_backup_name (const char *templ)
-     }
+ {
-     errstr = new char[size+1];
+     struct tm *tm;
-     if (!errstr)
+     const char *fmt;
-         BUG (0);
+     char *p;
-     fread (errstr, 1, size, fp);
+     time_t t;
-     errstr[size] = '\0';
-     fclose (fp);
+     t = time (NULL);
-     msg_box (NULL, errstr, _("GPG Error"), MB_INFO);
+     tm = localtime (&t);
-     free_if_alloc (errstr);
+     fmt = "%s-%d";
- } /* gnupg_display_error */
+     p = new char [strlen (templ) + strlen (fmt) + 8 + 1];
+     if (!p)
+         BUG (0);
- int
+     sprintf (p, fmt, templ, tm->tm_wday % 3);
- gnupg_access_keyring (int _pub)
+     return p;
- {
+ }
-     int rc = 0;
-     char * name = get_gnupg_keyring (_pub, 1);
-     if (file_exist_check (name))
+ /* Make backups of all keyrings. The public key ring is rotated like
-         rc = -1;
+    this pubring-%d.gpg.
-     free_if_alloc (name);
+    If @auto_backup is false, no action is performed.
-     return rc;
+    @include_secr indicated if the backup includes the secret keyring. */
- }
+ void
+ gnupg_backup_keyrings (int auto_backup, int backup_mode, int include_secr)
+ {
+     char *srcpath, *dstpath;
+     char *name;
+     int rc;
+     if (!auto_backup)
+         return;
+     srcpath = get_gnupg_path ();
+     check_keyring (&srcpath);
+     if (backup_mode == 1) {
+         /* If the backup mode uses the home directory the source
+            and destination folder will be the same. */
+         dstpath = get_gnupg_path ();
+         check_keyring (&dstpath);
+     }
+     else if (backup_mode == 2) {
+         char *tmpfile;
+         FILE *fp;
+         dstpath = m_strdup (reg_prefs.backup.path);
+         tmpfile = make_filename (reg_prefs.backup.path, "test", "tmp");
+         fp = fopen (tmpfile, "wb");
+         if (!fp)
+             rc = log_box (_("Backup"), MB_WARN|MB_RETRYCANCEL,
+                           _("The backup drive '%s' does not seems to be accessable.\n"
+                             "Please insert/check the drive to continue."), dstpath);
+         else {
+             rc = 0;
+             fclose (fp);
+             DeleteFile (tmpfile);
+         }
+         free_if_alloc (tmpfile);
+         if (!fp || rc == IDCANCEL) {
+             free_if_alloc (dstpath);
+             free_if_alloc (srcpath);
+             return;
+         }
+     }
+     else {
+         log_box (_("Backup"), MB_ERR, _("Invalid backup mode %d"), backup_mode);
+         free_if_alloc (srcpath);
+         return;
+     }
+     name = get_backup_name ("pubring-bak");
+     rc = backup_one_file (srcpath, "pubring", dstpath, name);
+     if (!rc && include_secr)
+         rc = backup_one_file (srcpath, "secring", dstpath, "secring-bak");
+     free_if_alloc (name);
+     free_if_alloc (srcpath);
+     free_if_alloc (dstpath);
+ }
+ /* check that the requested GPG keyring exist and.
+    Return value: 0 for success. */
+ int
+ gnupg_access_keyring (int _pub)
+ {
+     int rc = 0;
+     char *name = get_gnupg_keyring (_pub, 1);
+     if (!name || file_exist_check (name))
+         rc = -1;
+     free_if_alloc (name);
+     return rc;
+ }

 Legend:



Removed from v.32
 


changed lines


 
Added in v.304
 Legend:



Removed from v.32
 


changed lines


 
Added in v.304
-Removed from v.32
+Added in v.304

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26