src/sgpgme.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto & the Sylpheed-Claws team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #ifdef USE_GPGME
  25
  26 #include <time.h>
  27 #include <gtk/gtk.h>
  28 #include <gpgme.h>
  29
  30 #include "sgpgme.h"
  31 #include "privacy.h"
  32 #include "prefs_common.h"
  33 #include "utils.h"
  34 #include "alertpanel.h"
  35 #include "passphrase.h"
  36 #include "intl.h"
  37
  38 static void idle_function_for_gpgme(void)
  39 {
  40         while (gtk_events_pending())
  41                 gtk_main_iteration();
  42 }
  43
  44 static void sgpgme_disable_all(void)
  45 {
  46     /* FIXME: set a flag, so that we don't bother the user with failed
  47      * gpgme messages */
  48 }
  49
  50 GpgmeSigStat sgpgme_verify_signature(GpgmeCtx ctx, GpgmeData sig,
  51                                         GpgmeData plain)
  52 {
  53         GpgmeSigStat status;
  54
  55         if (gpgme_op_verify(ctx, sig, plain, &status) != GPGME_No_Error)
  56                 return GPGME_SIG_STAT_ERROR;
  57
  58         return status;
  59 }
  60
  61 SignatureStatus sgpgme_sigstat_gpgme_to_privacy(GpgmeSigStat status)
  62 {
  63         switch (status) {
  64         case GPGME_SIG_STAT_GOOD:
  65                 return SIGNATURE_OK;
  66         case GPGME_SIG_STAT_GOOD_EXP:
  67         case GPGME_SIG_STAT_GOOD_EXPKEY:
  68         case GPGME_SIG_STAT_DIFF:
  69                 return SIGNATURE_WARN;
  70         case GPGME_SIG_STAT_BAD:
  71                 return SIGNATURE_INVALID;
  72         case GPGME_SIG_STAT_NOKEY:
  73         case GPGME_SIG_STAT_NOSIG:
  74         case GPGME_SIG_STAT_ERROR:
  75                 return SIGNATURE_CHECK_FAILED;
  76         case GPGME_SIG_STAT_NONE:
  77                 return SIGNATURE_UNCHECKED;
  78         }
  79         return SIGNATURE_CHECK_FAILED;
  80 }
  81
  82 static const gchar *get_validity_str(unsigned long validity)
  83 {
  84         switch (validity) {
  85         case GPGME_VALIDITY_UNKNOWN:
  86                 return _("Unknown");
  87         case GPGME_VALIDITY_UNDEFINED:
  88                 return _("Undefined");
  89         case GPGME_VALIDITY_NEVER:
  90                 return _("Never");
  91         case GPGME_VALIDITY_MARGINAL:
  92                 return _("Marginal");
  93         case GPGME_VALIDITY_FULL:
  94                 return _("Full");
  95         case GPGME_VALIDITY_ULTIMATE:
  96                 return _("Ultimate");
  97         default:
  98                 return _("Error");
  99         }
 100 }
 101
 102 gchar *sgpgme_sigstat_info_short(GpgmeCtx ctx, GpgmeSigStat status)
 103 {
 104         switch (status) {
 105         case GPGME_SIG_STAT_GOOD:
 106         {
 107                 GpgmeKey key;
 108                 unsigned long validity = 0;
 109
 110                 if (gpgme_get_sig_key(ctx, 0, &key) != GPGME_No_Error)
 111                         return g_strdup(_("Error"));
 112
 113                 validity = gpgme_get_sig_ulong_attr(ctx, 0,
 114                         GPGME_ATTR_VALIDITY, 0);
 115
 116                 return g_strdup_printf(_("Valid signature by %s (Trust: %s)"),
 117                         gpgme_key_get_string_attr(key, GPGME_ATTR_NAME, NULL, 0),
 118                         get_validity_str(validity));
 119         }
 120         case GPGME_SIG_STAT_GOOD_EXP:
 121                 return g_strdup(_("The signature of this part has expired"));
 122         case GPGME_SIG_STAT_GOOD_EXPKEY:
 123                 return g_strdup(_("The key that was used to sign this part has expired"));
 124         case GPGME_SIG_STAT_DIFF:
 125                 return g_strdup(_("Not all signatures are valid"));
 126         case GPGME_SIG_STAT_BAD:
 127                 return g_strdup(_("This signature is invalid"));
 128         case GPGME_SIG_STAT_NOKEY:
 129                 return g_strdup(_("You have no key to verify this signature"));
 130         case GPGME_SIG_STAT_NOSIG:
 131                 return g_strdup(_("Bo signature found"));
 132         case GPGME_SIG_STAT_ERROR:
 133                 return g_strdup(_("An error occured"));
 134         case GPGME_SIG_STAT_NONE:
 135                 return g_strdup(_("The signature of this part has not been checked"));
 136         }
 137         return g_strdup(_("Error"));
 138 }
 139
 140 gchar *sgpgme_sigstat_info_full(GpgmeCtx ctx, GpgmeSigStat status)
 141 {
 142         gint i = 0;
 143         gchar *ret;
 144         GString *siginfo;
 145         GpgmeKey key;
 146
 147         siginfo = g_string_sized_new(64);
 148         while (gpgme_get_sig_key(ctx, i, &key) != GPGME_EOF) {
 149                 time_t sigtime, expiretime;
 150                 GpgmeSigStat sigstatus;
 151                 gchar time[64];
 152                 const gchar *keytype, *keyid;
 153
 154                 sigtime = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_CREATED, 0);
 155                 strftime(time, 64, "%c", gmtime(&sigtime));
 156                 keytype = gpgme_key_get_string_attr(key, GPGME_ATTR_ALGO, NULL, 0);
 157                 keyid = gpgme_key_get_string_attr(key, GPGME_ATTR_KEYID, NULL, 0);
 158                 g_string_sprintfa(siginfo,
 159                         _("Signature made %s using %s key ID %s\n"),
 160                         time, keytype, keyid);
 161
 162                 sigstatus = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_SIG_STATUS, 0);
 163                 switch (sigstatus) {
 164                 case GPGME_SIG_STAT_GOOD:
 165                 case GPGME_SIG_STAT_GOOD_EXP:
 166                 case GPGME_SIG_STAT_GOOD_EXPKEY:
 167                 {
 168                         gint j = 1;
 169                         const gchar *uid;
 170
 171                         g_string_sprintfa(siginfo,
 172                                 _("Good signature from \"%s\"\n"),
 173                                 gpgme_key_get_string_attr(key, GPGME_ATTR_USERID, NULL, 0));
 174                         while (uid = gpgme_key_get_string_attr(key, GPGME_ATTR_USERID, NULL, j)) {
 175                                 g_string_sprintfa(siginfo,
 176                                         _("                aka \"%s\"\n"),
 177                                         uid);
 178                                 j++;
 179                         }
 180                         g_string_sprintfa(siginfo,
 181                                 _("Primary key fingerprint: %s\n"),
 182                                 gpgme_key_get_string_attr(key, GPGME_ATTR_FPR, NULL, 0));
 183                         break;
 184                 }
 185                 case GPGME_SIG_STAT_BAD:
 186                         g_string_sprintfa(siginfo,
 187                                 _("BAD signature from \"%s\"\n"),
 188                                 gpgme_key_get_string_attr(key, GPGME_ATTR_USERID, NULL, 0));
 189                         break;
 190                 default:
 191                         break;
 192                 }
 193
 194                 expiretime = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_EXPIRE, 0);
 195                 if (expiretime > 0) {
 196                         strftime(time, 64, "%c", gmtime(&expiretime));
 197                         g_string_sprintfa(siginfo,
 198                                 _("Signature expires %s\n"),
 199                                 time);
 200                 }
 201
 202                 g_string_append(siginfo, "\n");
 203                 i++;
 204         }
 205
 206         ret = siginfo->str;
 207         g_string_free(siginfo, FALSE);
 208         return ret;
 209 }
 210
 211 void sgpgme_init()
 212 {
 213         if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) !=
 214                         GPGME_No_Error) {  /* Also does some gpgme init */
 215                 sgpgme_disable_all();
 216                 debug_print("gpgme_engine_version:\n%s\n",
 217                             gpgme_get_engine_info());
 218
 219                 if (prefs_common.gpg_warning) {
 220                         AlertValue val;
 221
 222                         val = alertpanel_message_with_disable
 223                                 (_("Warning"),
 224                                  _("GnuPG is not installed properly, or needs to be upgraded.\n"
 225                                    "OpenPGP support disabled."));
 226                         if (val & G_ALERTDISABLE)
 227                                 prefs_common.gpg_warning = FALSE;
 228                 }
 229         }
 230
 231         gpgme_register_idle(idle_function_for_gpgme);
 232 }
 233
 234 void sgpgme_done()
 235 {
 236         gpgmegtk_free_passphrase();
 237 }
 238
 239 #endif /* USE_GPGME */