2005-12-06 [paul] 1.9.100cvs69

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

diff --git a/src/plugins/pgpcore/sgpgme.c b/src/plugins/pgpcore/sgpgme.c
index 61e19915afac1088a431aed1f6249567a7531e45..c9377ff39a74bcb98d0a1011aca0a66e0574ed48 100644 (file)
--- a/src/plugins/pgpcore/sgpgme.c
+++ b/src/plugins/pgpcore/sgpgme.c
@@ -30,6 +30,9 @@
 #include <glib/gi18n.h>
 #include <stdio.h>
 #include <errno.h>
+#if HAVE_LOCALE_H
+#  include <locale.h>
+#endif
 
 #include "sgpgme.h"
 #include "privacy.h"
@@ -54,7 +57,8 @@ gpgme_verify_result_t sgpgme_verify_signature(gpgme_ctx_t ctx, gpgme_data_t sig,
 
        if ((err = gpgme_op_verify(ctx, sig, plain, dummy)) != GPG_ERR_NO_ERROR) {
                debug_print("op_verify err %s\n", gpgme_strerror(err));
-               return NULL;
+               return GINT_TO_POINTER(-GPG_ERR_SYSTEM_ERROR);
+               
        }
        status = gpgme_op_verify_result(ctx);
 
@@ -66,22 +70,26 @@ SignatureStatus sgpgme_sigstat_gpgme_to_privacy(gpgme_ctx_t ctx, gpgme_verify_re
        unsigned long validity = 0;
        gpgme_signature_t sig = NULL;
        
-       if (status == NULL)
-               return SIGNATURE_UNCHECKED;
+       if (GPOINTER_TO_INT(status) == -GPG_ERR_SYSTEM_ERROR) {
+               debug_print("system error\n");
+               return SIGNATURE_CHECK_FAILED;
+       }
 
+       if (status == NULL) {
+               debug_print("status == NULL\n");
+               return SIGNATURE_UNCHECKED;
+       }
        sig = status->signatures;
 
-       if (sig == NULL)
+       if (sig == NULL) {
+               debug_print("sig == NULL\n");
                return SIGNATURE_UNCHECKED;
-
+       }
        validity = sig->validity;
 
+       debug_print("err code %d\n", gpg_err_code(sig->status));
        switch (gpg_err_code(sig->status)) {
        case GPG_ERR_NO_ERROR:
-               if ((validity != GPGME_VALIDITY_MARGINAL) &&
-                   (validity != GPGME_VALIDITY_FULL) &&
-                   (validity != GPGME_VALIDITY_ULTIMATE))
-                       return SIGNATURE_WARN;
                return SIGNATURE_OK;
        case GPG_ERR_SIG_EXPIRED:
        case GPG_ERR_KEY_EXPIRED:
@@ -116,11 +124,34 @@ static const gchar *get_validity_str(unsigned long validity)
        }
 }
 
+static gchar *extract_name(const char *uid)
+{
+       if (uid == NULL)
+               return NULL;
+       if (!strncmp(uid, "CN=", 3)) {
+               gchar *result = g_strdup(uid+3);
+               if (strstr(result, ","))
+                       *(strstr(result, ",")) = '\0';
+               return result;
+       } else if (strstr(uid, ",CN=")) {
+               gchar *result = g_strdup(strstr(uid, ",CN=")+4);
+               if (strstr(result, ","))
+                       *(strstr(result, ",")) = '\0';
+               return result;
+       } else {
+               return g_strdup(uid);
+       }
+}
 gchar *sgpgme_sigstat_info_short(gpgme_ctx_t ctx, gpgme_verify_result_t status)
 {
        gpgme_signature_t sig = NULL;
        gchar *uname = NULL;
        gpgme_key_t key;
+       gchar *result = NULL;
+
+       if (GPOINTER_TO_INT(status) == -GPG_ERR_SYSTEM_ERROR) {
+               return g_strdup(_("The signature can't be checked - GPG error."));
+       }
 
        if (status == NULL) {
                return g_strdup(_("The signature has not been checked."));
@@ -132,27 +163,34 @@ gchar *sgpgme_sigstat_info_short(gpgme_ctx_t ctx, gpgme_verify_result_t status)
 
        gpgme_get_key(ctx, sig->fpr, &key, 0);
        if (key)
-               uname = key->uids->uid;
+               uname = extract_name(key->uids->uid);
        else
-               uname = "<?>";
+               uname = g_strdup("<?>");
        switch (gpg_err_code(sig->status)) {
        case GPG_ERR_NO_ERROR:
-       {
-               return g_strdup_printf(_("Good signature from %s (Trust: %s)."),
-                       uname, get_validity_str(sig->validity));
-       }
+               result = g_strdup_printf(_("Good signature from %s."),
+                       uname);
+               break;
        case GPG_ERR_SIG_EXPIRED:
-               return g_strdup_printf(_("Expired signature from %s."), uname);
+               result = g_strdup_printf(_("Expired signature from %s."), uname);
+               break;
        case GPG_ERR_KEY_EXPIRED:
-               return g_strdup_printf(_("Expired key from %s."), uname);
+               result = g_strdup_printf(_("Expired key from %s."), uname);
+               break;
        case GPG_ERR_BAD_SIGNATURE:
-               return g_strdup_printf(_("Bad signature from %s."), uname);
+               result = g_strdup_printf(_("Bad signature from %s."), uname);
+               break;
        case GPG_ERR_NO_PUBKEY:
-               return g_strdup(_("No key available to verify this signature."));
+               result = g_strdup(_("No key available to verify this signature."));
+               break;
        default:
-               return g_strdup(_("The signature has not been checked."));
+               result = g_strdup(_("The signature has not been checked."));
+               break;
        }
-       return g_strdup(_("Error"));
+       if (result == NULL)
+               result = g_strdup(_("Error"));
+       g_free(uname);
+       return result;
 }
 
 gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
@@ -170,21 +208,28 @@ gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                const gchar *keytype, *keyid, *uid;
                
                gpgme_get_key(ctx, sig->fpr, &key, 0);
-               user = key->uids;
 
-               keytype = gpgme_pubkey_algo_name(key->subkeys->pubkey_algo);
-               keyid = key->subkeys->keyid;
+               if (key) {
+                       user = key->uids;
+                       keytype = gpgme_pubkey_algo_name(
+                                       key->subkeys->pubkey_algo);
+                       keyid = key->subkeys->keyid;
+                       uid = user->uid;
+               } else {
+                       keytype = "?";
+                       keyid = "?";
+                       uid = "?";
+               }
                g_string_append_printf(siginfo,
                        _("Signature made using %s key ID %s\n"),
                        keytype, keyid);
                
-               uid = user->uid;
                switch (gpg_err_code(sig->status)) {
                case GPG_ERR_NO_ERROR:
                case GPG_ERR_KEY_EXPIRED:
                        g_string_append_printf(siginfo,
-                               _("Good signature from \"%s\"\n"),
-                               uid);
+                               _("Good signature from \"%s\" (Trust: %s)\n"),
+                               uid, get_validity_str(sig->validity));
                        break;
                case GPG_ERR_SIG_EXPIRED:
                        g_string_append_printf(siginfo,
@@ -201,7 +246,7 @@ gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                }
                if (sig->status != GPG_ERR_BAD_SIGNATURE) {
                        gint j = 1;
-                       user = user->next;
+                       user = user ? user->next : NULL;
                        while (user != NULL) {
                                g_string_append_printf(siginfo,
                                        _("                aka \"%s\"\n"),
@@ -211,7 +256,7 @@ gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
                        }
                        g_string_append_printf(siginfo,
                                _("Primary key fingerprint: %s\n"), 
-                               sig->fpr);
+                               sig ? sig->fpr: "?");
                }
                
                g_string_append(siginfo, "\n");