2008-12-16 [colin] 3.6.1cvs79

[claws.git] / src / plugins / pgpcore / sgpgme.c

diff --git a/src/plugins/pgpcore/sgpgme.c b/src/plugins/pgpcore/sgpgme.c
index e168590c61ee0221a0123336da2304934d374c4b..c55eebf5c4b7f047bbaa0aa0e541ae5334ba9161 100644 (file)
--- a/src/plugins/pgpcore/sgpgme.c
+++ b/src/plugins/pgpcore/sgpgme.c
@@ -36,7 +36,7 @@
 #ifndef G_OS_WIN32
 #  include <sys/wait.h>
 #endif
-#if (defined(__DragonFly__) || defined (__NetBSD__) || defined (__FreeBSD__) || defined (__OpenBSD__))
+#if (defined(__DragonFly__) || defined(SOLARIS) || defined (__NetBSD__) || defined (__FreeBSD__) || defined (__OpenBSD__))
 #  include <sys/signal.h>
 #endif
 #ifndef G_OS_WIN32
@@ -72,7 +72,6 @@ gpgme_verify_result_t sgpgme_verify_signature(gpgme_ctx_t ctx, gpgme_data_t sig,
                debug_print("op_verify err %s\n", gpgme_strerror(err));
                privacy_set_error("%s", gpgme_strerror(err));
                return GINT_TO_POINTER(-GPG_ERR_SYSTEM_ERROR);
-               
        }
        status = gpgme_op_verify_result(ctx);
        if (status && status->signatures == NULL) {
@@ -201,6 +200,9 @@ gchar *sgpgme_sigstat_info_short(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                else
                        g_warning(_("PGP Core: Can't get key - no gpg-agent running."));
                warned = TRUE;
+       } else if (gpg_err_code(err) != GPG_ERR_NO_ERROR && gpg_err_code(err) != GPG_ERR_EOF) {
+               return g_strdup_printf(_("The signature can't be checked - %s"), 
+                       gpgme_strerror(err));
        }
        if (key)
                uname = extract_name(key->uids->uid);
@@ -289,13 +291,13 @@ gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                case GPG_ERR_NO_ERROR:
                case GPG_ERR_KEY_EXPIRED:
                        g_string_append_printf(siginfo,
-                               _("Good signature from \"%s\" (Trust: %s)\n"),
-                               uid, get_validity_str(sig->validity));
+                               _("Good signature from uid \"%s\" (Validity: %s)\n"),
+                               uid, get_validity_str(user->validity));
                        break;
                case GPG_ERR_SIG_EXPIRED:
                        g_string_append_printf(siginfo,
-                               _("Expired signature from \"%s\"\n"),
-                               uid);
+                               _("Expired signature from uid \"%s\" (Validity: %s)\n"),
+                               uid, get_validity_str(user->validity));
                        break;
                case GPG_ERR_BAD_SIGNATURE:
                        g_string_append_printf(siginfo,
@@ -310,8 +312,9 @@ gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                        user = user ? user->next : NULL;
                        while (user != NULL) {
                                g_string_append_printf(siginfo,
-                                       _("                aka \"%s\"\n"),
-                                       user->uid);
+                                       _("                    uid \"%s\" (Validity: %s)\n"),
+                                       user->uid,
+                                       get_validity_str(user->validity));
                                j++;
                                user = user->next;
                        }
@@ -467,12 +470,16 @@ gchar *sgpgme_get_encrypt_data(GSList *recp_names, gpgme_protocol_t proto)
        return ret;
 }
 
-gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account)
+gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account,
+                             const gchar *from_addr)
 {
        GPGAccountConfig *config;
+       const gchar *signer_addr = account->address;
 
        gpgme_signers_clear(ctx);
 
+       if (from_addr)
+               signer_addr = from_addr;
        config = prefs_gpg_account_get_config(account);
 
        switch(config->sign_key) {
@@ -480,7 +487,7 @@ gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account)
                debug_print("using default gnupg key\n");
                break;
        case SIGN_KEY_BY_FROM:
-               debug_print("using key for %s\n", account->address);
+               debug_print("using key for %s\n", signer_addr);
                break;
        case SIGN_KEY_CUSTOM:
                debug_print("using key for %s\n", config->sign_key_id);
@@ -488,28 +495,56 @@ gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account)
        }
 
        if (config->sign_key != SIGN_KEY_DEFAULT) {
-               gchar *keyid;
+               const gchar *keyid;
                gpgme_key_t key, key2;
                gpgme_error_t err;
 
                if (config->sign_key == SIGN_KEY_BY_FROM)
-                       keyid = account->address;
+                       keyid = signer_addr;
                else if (config->sign_key == SIGN_KEY_CUSTOM)
                        keyid = config->sign_key_id;
                else
                        goto bail;
 
                err = gpgme_op_keylist_start(ctx, keyid, 1);
-               if (!err)
-                       err = gpgme_op_keylist_next(ctx, &key);
+               if (!err) {
+                       do {
+                               err = gpgme_op_keylist_next(ctx, &key);
+                               if (!err && key && key->protocol == gpgme_get_protocol(ctx) &&
+                                   !key->expired && !key->revoked)
+                                       break;
+                               if (!err && key && key->protocol != gpgme_get_protocol(ctx)) {
+                                       debug_print("skipping a key (wrong protocol %d)\n", key->protocol);
+                                       gpgme_key_release(key);
+                               }
+                               if (!err && key && (key->expired || key->revoked)) {
+                                       debug_print("skipping a key (%s)\n", key->expired?"expired":"revoked");
+                                       gpgme_key_release(key);
+                               }
+                       } while (!err);
+               }
                if (err) {
                        g_warning("setup_signers start: %s", gpgme_strerror(err));
                        privacy_set_error(_("Secret key not found (%s)"), gpgme_strerror(err));
                        goto bail;
                }
                
-               err = gpgme_op_keylist_next(ctx, &key2);
+               do {
+                       err = gpgme_op_keylist_next(ctx, &key2);
+                       if (!err && key2 && key2->protocol == gpgme_get_protocol(ctx) &&
+                           !key2->expired && !key2->revoked)
+                               break;
+                       if (!err && key && key2->protocol != gpgme_get_protocol(ctx)) {
+                               debug_print("skipping a key (wrong protocol %d)\n", key2->protocol);
+                               gpgme_key_release(key2);
+                       }
+                       if (!err && key && (key2->expired || key2->revoked)) {
+                               debug_print("skipping a key (%s)\n", key2->expired?"expired":"revoked");
+                               gpgme_key_release(key2);
+                       }
+               } while (!err);
                if (!err) {
+                       gpgme_key_release(key2);
                        g_warning("ambiguous specification of secret key '%s'\n",
                                keyid);
                        privacy_set_error(_("Secret key specification is ambiguous"));
@@ -518,6 +553,8 @@ gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account)
                
                gpgme_op_keylist_end(ctx);
                err = gpgme_signers_add(ctx, key);
+               debug_print("got key (proto %d (pgp %d, smime %d).\n", key->protocol,
+                               GPGME_PROTOCOL_OpenPGP, GPGME_PROTOCOL_CMS);
                gpgme_key_release(key);
                
                if (err) {
@@ -547,13 +584,15 @@ void sgpgme_init()
 #endif
                if (!gpgme_get_engine_info(&engineInfo)) {
                        while (engineInfo) {
+#ifndef G_OS_WIN32
                                debug_print("GpgME Protocol: %s\n"
                                            "Version: %s (req %s)\n"
                                            "Executable: %s\n",
-                                       gpgme_get_protocol_name(engineInfo->protocol),
+                                       gpgme_get_protocol_name(engineInfo->protocol) ? gpgme_get_protocol_name(engineInfo->protocol):"???",
                                        engineInfo->version ? engineInfo->version:"???",
                                        engineInfo->req_version ? engineInfo->req_version:"???",
                                        engineInfo->file_name ? engineInfo->file_name:"???");
+#endif
                                if (engineInfo->protocol == GPGME_PROTOCOL_OpenPGP
                                &&  gpgme_engine_check_version(engineInfo->protocol) != 
                                        GPG_ERR_NO_ERROR) {