src/plugins/pgpcore/prefs_gpg.c

   1 /*
   2  * Claws Mail -- a GTK based, lightweight, and fast e-mail client
   3  * Copyright (C) 2004-2019 the Claws Mail 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 3 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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #include "claws-features.h"
  22 #endif
  23
  24 #include <gtk/gtk.h>
  25 #include <glib.h>
  26 #include <glib/gi18n.h>
  27
  28 #include <gtk/filesel.h>
  29
  30 #include "defs.h"
  31 #include "gtk/gtkutils.h"
  32 #include "utils.h"
  33 #include "prefs.h"
  34 #include "prefs_common.h"
  35 #include "prefs_gtk.h"
  36 #include "prefs_gpg.h"
  37 #include "sgpgme.h"
  38
  39 struct GPGConfig prefs_gpg;
  40
  41 static PrefParam param[] = {
  42         /* Privacy */
  43         {"auto_check_signatures", "FALSE",
  44          &prefs_gpg.auto_check_signatures, P_BOOL,
  45          NULL, NULL, NULL},
  46         {"autocompletion", "FALSE",
  47          &prefs_gpg.autocompletion, P_BOOL,
  48          NULL, NULL, NULL},
  49         {"autocompletion_limit", "0",
  50          &prefs_gpg.autocompletion_limit, P_INT,
  51          NULL, NULL, NULL},
  52         {"use_gpg_agent", "TRUE", &prefs_gpg.use_gpg_agent, P_BOOL,
  53          NULL, NULL, NULL},
  54         {"store_passphrase", "FALSE", &prefs_gpg.store_passphrase, P_BOOL,
  55          NULL, NULL, NULL},
  56         {"store_passphrase_timeout", "0",
  57          &prefs_gpg.store_passphrase_timeout, P_INT,
  58          NULL, NULL, NULL},
  59         {"passphrase_grab", "FALSE", &prefs_gpg.passphrase_grab, P_BOOL,
  60          NULL, NULL, NULL},
  61         {"gpg_warning", "TRUE", &prefs_gpg.gpg_warning, P_BOOL,
  62          NULL, NULL, NULL},
  63         {"gpg_ask_create_key", "TRUE", &prefs_gpg.gpg_ask_create_key, P_BOOL,
  64          NULL, NULL, NULL},
  65         {"skip_encryption_warning", "", &prefs_gpg.skip_encryption_warning, P_STRING,
  66          NULL, NULL, NULL},
  67         {"gpg_path", "", &prefs_gpg.gpg_path, P_STRING,
  68          NULL, NULL, NULL},
  69
  70         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
  71 };
  72
  73 static gchar *saved_gpg_agent_info = NULL;
  74 static void gpg_path_browse_cb(GtkWidget *widget, gpointer data);
  75
  76 struct GPGPage
  77 {
  78         PrefsPage page;
  79
  80         GtkWidget *checkbtn_auto_check_signatures;
  81         GtkWidget *checkbtn_autocompletion;
  82         GtkWidget *checkbtn_use_gpg_agent;
  83         GtkWidget *checkbtn_store_passphrase;
  84         GtkWidget *spinbtn_store_passphrase;
  85         GtkWidget *checkbtn_passphrase_grab;
  86         GtkWidget *checkbtn_gpg_warning;
  87         GtkWidget *gpg_path;
  88 };
  89
  90 struct GPGAccountPage
  91 {
  92         PrefsPage page;
  93
  94         GtkWidget *key_default;
  95         GtkWidget *key_by_from;
  96         GtkWidget *key_custom;
  97         GtkWidget *keyid;
  98         GtkWidget *keyid_label;
  99         GtkWidget *new_key_label;
 100         GtkWidget *new_key_btn;
 101         GtkWidget *new_key_box;
 102
 103         PrefsAccount *account;
 104 };
 105
 106 static struct GPGPage gpg_page;
 107 static struct GPGAccountPage gpg_account_page;
 108 static struct GPGAccountPage smime_account_page;
 109
 110 static void prefs_gpg_create_widget_func(PrefsPage *_page,
 111                                          GtkWindow *window,
 112                                          gpointer data)
 113 {
 114         struct GPGPage *page = (struct GPGPage *) _page;
 115         struct GPGConfig *config;
 116
 117         GtkWidget *checkbtn_use_gpg_agent;
 118         GtkWidget *checkbtn_passphrase_grab;
 119         GtkWidget *checkbtn_store_passphrase;
 120         GtkWidget *checkbtn_auto_check_signatures;
 121         GtkWidget *checkbtn_autocompletion;
 122         GtkWidget *checkbtn_gpg_warning;
 123         GtkWidget *hbox1, *hbox2;
 124         GtkWidget *vbox1, *vbox2;
 125         GtkWidget *label_gpg_path;
 126         GtkWidget *label_expire1;
 127         GtkAdjustment *spinbtn_store_passphrase_adj;
 128         GtkWidget *spinbtn_store_passphrase;
 129         GtkWidget *label_expire2;
 130         GtkWidget *frame_passphrase;
 131         GtkWidget *gpg_path, *gpg_path_btn;
 132
 133         vbox1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, VSPACING);
 134         gtk_widget_show (vbox1);
 135         gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
 136
 137         vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 138         gtk_widget_show (vbox2);
 139         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
 140
 141         PACK_CHECK_BUTTON (vbox2, checkbtn_auto_check_signatures,
 142                         _("Automatically check signatures"));
 143
 144         PACK_CHECK_BUTTON (vbox2, checkbtn_autocompletion,
 145                         _("Use keyring for address autocompletion"));
 146
 147         vbox2 = gtkut_get_options_frame(vbox1, &frame_passphrase, _("Passphrase"));
 148
 149         PACK_CHECK_BUTTON (vbox2, checkbtn_use_gpg_agent,
 150                         _("Use gpg-agent to manage passwords"));
 151         if (saved_gpg_agent_info == NULL)
 152                 gtk_widget_set_sensitive(checkbtn_use_gpg_agent, FALSE);
 153
 154         PACK_CHECK_BUTTON (vbox2, checkbtn_store_passphrase,
 155                         _("Store passphrase in memory"));
 156
 157         SET_TOGGLE_SENSITIVITY_REVERSE(checkbtn_use_gpg_agent, checkbtn_store_passphrase);
 158
 159         hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 160         gtk_widget_show (hbox1);
 161         gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
 162
 163         SET_TOGGLE_SENSITIVITY_REVERSE(checkbtn_use_gpg_agent, hbox1);
 164
 165         label_expire1 = gtk_label_new(_("Expire after"));
 166         gtk_widget_show (label_expire1);
 167         gtk_box_pack_start (GTK_BOX (hbox1), label_expire1, FALSE, FALSE, 0);
 168
 169         spinbtn_store_passphrase_adj =
 170             GTK_ADJUSTMENT(gtk_adjustment_new(1, 0, 1440, 1, 10, 0));
 171         spinbtn_store_passphrase =
 172             gtk_spin_button_new(GTK_ADJUSTMENT
 173                                 (spinbtn_store_passphrase_adj), 1, 0);
 174         gtk_widget_show(spinbtn_store_passphrase);
 175         gtk_box_pack_start(GTK_BOX(hbox1), spinbtn_store_passphrase, FALSE,
 176                            FALSE, 0);
 177         CLAWS_SET_TIP(spinbtn_store_passphrase,
 178                       _("Setting to '0' will store the passphrase for the whole session"));
 179         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON
 180                                     (spinbtn_store_passphrase), TRUE);
 181
 182         label_expire2 = gtk_label_new(_("minutes"));
 183         gtk_widget_show(label_expire2);
 184         gtk_box_pack_start(GTK_BOX(hbox1), label_expire2, FALSE, FALSE, 0);
 185         gtk_label_set_xalign(GTK_LABEL(label_expire2), 0.0);
 186
 187         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, label_expire1);
 188         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, spinbtn_store_passphrase);
 189         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, label_expire2);
 190
 191         PACK_CHECK_BUTTON (vbox2, checkbtn_passphrase_grab,
 192                         _("Grab input while entering a passphrase"));
 193
 194         vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 195         gtk_widget_show (vbox2);
 196         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
 197
 198         PACK_CHECK_BUTTON (vbox2, checkbtn_gpg_warning,
 199                         _("Display warning on start-up if GnuPG doesn't work"));
 200
 201         hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
 202         label_gpg_path = gtk_label_new(_("Path to GnuPG executable"));
 203         gtk_box_pack_start(GTK_BOX(hbox2), label_gpg_path, FALSE, FALSE, 0);
 204         gpg_path = gtk_entry_new();
 205         gtk_box_pack_start(GTK_BOX(hbox2), gpg_path, TRUE, TRUE, 0);
 206         CLAWS_SET_TIP(gpg_path,
 207                       _("If left blank the location of the GnuPG executable will be automatically determined."));
 208         gpg_path_btn = gtkut_get_browse_file_btn(_("Bro_wse"));
 209         gtk_box_pack_start(GTK_BOX(hbox2), gpg_path_btn, FALSE, FALSE, 0);
 210         g_signal_connect(G_OBJECT(gpg_path_btn), "clicked",
 211                          G_CALLBACK(gpg_path_browse_cb), gpg_path);
 212         pref_set_entry_from_pref(GTK_ENTRY(gpg_path), prefs_gpg.gpg_path);
 213
 214         gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
 215         gtk_widget_show_all(vbox1);
 216
 217         config = prefs_gpg_get_config();
 218
 219         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_auto_check_signatures), config->auto_check_signatures);
 220         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_autocompletion), config->autocompletion);
 221         if (!g_getenv("GPG_AGENT_INFO"))
 222                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_use_gpg_agent), FALSE);
 223         else
 224                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_use_gpg_agent), config->use_gpg_agent);
 225         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbtn_use_gpg_agent)))
 226                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_store_passphrase), config->store_passphrase);
 227         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbtn_store_passphrase), (float) config->store_passphrase_timeout);
 228         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_passphrase_grab), config->passphrase_grab);
 229         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_gpg_warning), config->gpg_warning);
 230         gtk_entry_set_text(GTK_ENTRY(gpg_path), config->gpg_path);
 231
 232         page->checkbtn_auto_check_signatures = checkbtn_auto_check_signatures;
 233         page->checkbtn_autocompletion = checkbtn_autocompletion;
 234         page->checkbtn_store_passphrase = checkbtn_store_passphrase;
 235         page->spinbtn_store_passphrase = spinbtn_store_passphrase;
 236         page->checkbtn_passphrase_grab = checkbtn_passphrase_grab;
 237         page->checkbtn_gpg_warning = checkbtn_gpg_warning;
 238         page->checkbtn_use_gpg_agent = checkbtn_use_gpg_agent;
 239         page->gpg_path = gpg_path;
 240         page->page.widget = vbox1;
 241 }
 242
 243 static void gpg_path_browse_cb(GtkWidget* widget, gpointer data)
 244 {
 245         gchar *filename;
 246         GtkEntry *dest = GTK_ENTRY(data);
 247
 248         filename = filesel_select_file_open(_("Select GnuPG executable"), NULL);
 249         if (!filename)
 250                 return;
 251
 252         gtk_entry_set_text(GTK_ENTRY(dest), filename);
 253         g_free(filename);
 254 }
 255
 256 static void prefs_gpg_destroy_widget_func(PrefsPage *_page)
 257 {
 258 }
 259
 260 static void prefs_gpg_save_func(PrefsPage *_page)
 261 {
 262         struct GPGPage *page = (struct GPGPage *) _page;
 263         GPGConfig *config = prefs_gpg_get_config();
 264
 265         config->auto_check_signatures =
 266                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_auto_check_signatures));
 267         config->autocompletion =
 268                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_autocompletion));
 269         config->use_gpg_agent =
 270                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_use_gpg_agent));
 271         config->store_passphrase =
 272                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_store_passphrase));
 273         config->store_passphrase_timeout =
 274                 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->spinbtn_store_passphrase));
 275         config->passphrase_grab =
 276                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_passphrase_grab));
 277         config->gpg_warning =
 278                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_gpg_warning));
 279         g_free(config->gpg_path);
 280         config->gpg_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(page->gpg_path)));
 281         if (strcmp(config->gpg_path, "") != 0 && access(config->gpg_path, X_OK) != -1) {
 282                 gpgme_error_t err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, config->gpg_path, NULL);
 283                 if (err != GPG_ERR_NO_ERROR)
 284                         g_warning("failed to set crypto engine configuration: %s", gpgme_strerror(err));
 285         }
 286
 287         prefs_gpg_enable_agent(config->use_gpg_agent);
 288
 289         prefs_gpg_save_config();
 290 }
 291
 292 void key_custom_toggled(GtkToggleButton *togglebutton, gpointer user_data)
 293 {
 294         struct GPGAccountPage *page = (struct GPGAccountPage *) user_data;
 295         gboolean active;
 296
 297         active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom));
 298         gtk_widget_set_sensitive(GTK_WIDGET(page->keyid_label), active);
 299         gtk_widget_set_sensitive(GTK_WIDGET(page->keyid), active);
 300 }
 301
 302 static void prefs_gpg_update_sens(struct GPGAccountPage *page)
 303 {
 304         gboolean active;
 305         active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom));
 306         if (sgpgme_has_secret_key()) {
 307                 gtk_widget_hide(page->new_key_box);
 308                 gtk_widget_set_sensitive(page->key_default, TRUE);
 309                 gtk_widget_set_sensitive(page->key_by_from, TRUE);
 310                 gtk_widget_set_sensitive(page->key_custom, TRUE);
 311                 gtk_widget_set_sensitive(page->keyid, active);
 312                 gtk_widget_set_sensitive(page->keyid_label, active);
 313         } else {
 314                 gtk_widget_show(page->new_key_box);
 315                 gtk_widget_set_sensitive(page->key_default, FALSE);
 316                 gtk_widget_set_sensitive(page->key_by_from, FALSE);
 317                 gtk_widget_set_sensitive(page->key_custom, FALSE);
 318                 gtk_widget_set_sensitive(page->keyid, FALSE);
 319                 gtk_widget_set_sensitive(page->keyid_label, FALSE);
 320         }
 321 }
 322
 323 static void new_key_clicked(GtkWidget *widget, gpointer user_data)
 324 {
 325         struct GPGAccountPage *page = (struct GPGAccountPage *) user_data;
 326         sgpgme_create_secret_key(page->account, FALSE);
 327         prefs_gpg_update_sens(page);
 328 }
 329
 330 static void prefs_gpg_account_create_widget_func(PrefsPage *_page,
 331                                                  GtkWindow *window,
 332                                                  gpointer data)
 333 {
 334         struct GPGAccountPage *page = (struct GPGAccountPage *) _page;
 335         PrefsAccount *account = (PrefsAccount *) data;
 336         GPGAccountConfig *config;
 337         SignKeyType sign_key;
 338
 339         GtkWidget *vbox;
 340         GtkWidget *frame1;
 341         GtkWidget *vbox2;
 342         GtkWidget *hbox;
 343         GSList *key_group = NULL;
 344         GtkWidget *key_default;
 345         GtkWidget *key_by_from;
 346         GtkWidget *key_custom;
 347         GtkWidget *keyid_label;
 348         GtkWidget *keyid;
 349         GtkWidget *image;
 350         GtkWidget *new_key_label;
 351         GtkWidget *new_key_btn;
 352         GtkWidget *new_key_box;
 353
 354         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, VSPACING);
 355         gtk_container_set_border_width (GTK_CONTAINER (vbox), VBOX_BORDER);
 356         gtk_widget_show(vbox);
 357
 358         vbox2 = gtkut_get_options_frame(vbox, &frame1, _("Sign key"));
 359
 360         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 361         gtk_widget_show (hbox);
 362         gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 363         gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
 364
 365         key_default = gtk_radio_button_new_with_label(key_group,
 366                         _("Use default GnuPG key"));
 367         key_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(key_default));
 368         gtk_widget_show(key_default);
 369         gtk_box_pack_start(GTK_BOX(hbox), key_default, FALSE, FALSE, 0);
 370
 371         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 372         gtk_widget_show (hbox);
 373         gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 374         gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
 375
 376         key_by_from = gtk_radio_button_new_with_label(key_group,
 377                 _("Select key by your email address"));
 378         key_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(key_by_from));
 379         gtk_widget_show(key_by_from);
 380         gtk_box_pack_start(GTK_BOX(hbox), key_by_from, FALSE, FALSE, 0);
 381
 382         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 383         gtk_widget_show (hbox);
 384         gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 385         gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
 386
 387         key_custom = gtk_radio_button_new_with_label(key_group,
 388                 _("Specify key manually"));
 389         key_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(key_custom));
 390         gtk_widget_show(key_custom);
 391         gtk_box_pack_start(GTK_BOX(hbox), key_custom, FALSE, FALSE, 0);
 392
 393         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 394         gtk_widget_show (hbox);
 395         gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 396         gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
 397
 398         keyid_label = gtk_label_new(_("User or key ID:"));
 399         gtk_widget_show(keyid_label);
 400         gtk_label_set_justify(GTK_LABEL(keyid_label), GTK_JUSTIFY_LEFT);
 401         gtk_box_pack_start(GTK_BOX(hbox), keyid_label, FALSE, FALSE, 0);
 402
 403         keyid = gtk_entry_new();
 404         gtk_widget_show(keyid);
 405         gtk_box_pack_start(GTK_BOX(hbox), keyid, FALSE, FALSE, 0);
 406
 407         config = prefs_gpg_account_get_config(account);
 408
 409         sign_key =
 410                 (page == &smime_account_page ? config->smime_sign_key : config->sign_key);
 411         switch (sign_key) {
 412         case SIGN_KEY_DEFAULT:
 413                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_default), TRUE);
 414                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 415                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 416                 break;
 417         case SIGN_KEY_BY_FROM:
 418                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_by_from), TRUE);
 419                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 420                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 421                 break;
 422         case SIGN_KEY_CUSTOM:
 423                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_custom), TRUE);
 424                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), TRUE);
 425                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), TRUE);
 426                 break;
 427         }
 428
 429         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 430         gtk_widget_show (hbox);
 431         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 432
 433         new_key_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
 434         gtk_widget_show(new_key_box);
 435         gtk_box_pack_start(GTK_BOX(hbox), new_key_box, FALSE, FALSE, 0);
 436
 437         image = gtk_button_new_from_icon_name("dialog-warning",
 438                         GTK_ICON_SIZE_SMALL_TOOLBAR);
 439
 440         gtk_box_pack_start(GTK_BOX(new_key_box), image, FALSE, FALSE, 0);
 441         new_key_label = gtk_label_new(
 442                         _("No secret key found."));
 443         gtk_box_pack_start(GTK_BOX(new_key_box), new_key_label, FALSE, FALSE, 0);
 444
 445         new_key_btn = gtk_button_new_with_label(_("Generate a new key pair"));
 446         gtk_widget_show(new_key_btn);
 447         gtk_box_pack_start(GTK_BOX(hbox), new_key_btn, FALSE, FALSE, 0);
 448
 449         if (page == &smime_account_page) {
 450                 if (config->smime_sign_key_id != NULL)
 451                         gtk_entry_set_text(GTK_ENTRY(keyid), config->smime_sign_key_id);
 452         } else {
 453                 if (config->sign_key_id != NULL)
 454                         gtk_entry_set_text(GTK_ENTRY(keyid), config->sign_key_id);
 455         }
 456         g_signal_connect(G_OBJECT(key_custom), "toggled", G_CALLBACK(key_custom_toggled), page);
 457         g_signal_connect(G_OBJECT(new_key_btn), "clicked", G_CALLBACK(new_key_clicked), page);
 458
 459         page->key_default = key_default;
 460         page->key_by_from = key_by_from;
 461         page->key_custom = key_custom;
 462         page->keyid = keyid;
 463         page->keyid_label = keyid_label;
 464         page->new_key_box = new_key_box;
 465
 466         page->page.widget = vbox;
 467         page->account = account;
 468         prefs_gpg_update_sens(page);
 469
 470         prefs_gpg_account_free_config(config);
 471 }
 472
 473 static void prefs_gpg_account_destroy_widget_func(PrefsPage *_page)
 474 {
 475         /* nothing to do here */
 476 }
 477
 478 static void prefs_gpg_account_save_func(PrefsPage *_page)
 479 {
 480         struct GPGAccountPage *page = (struct GPGAccountPage *) _page;
 481         GPGAccountConfig *config;
 482
 483         config = prefs_gpg_account_get_config(page->account);
 484
 485         if (page == &smime_account_page) {
 486                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_default)))
 487                         config->smime_sign_key = SIGN_KEY_DEFAULT;
 488                 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_by_from)))
 489                         config->smime_sign_key = SIGN_KEY_BY_FROM;
 490                 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom))) {
 491                         config->smime_sign_key = SIGN_KEY_CUSTOM;
 492                 }
 493                 g_free(config->smime_sign_key_id);
 494                 config->smime_sign_key_id = gtk_editable_get_chars(GTK_EDITABLE(page->keyid), 0, -1);
 495         } else {
 496                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_default)))
 497                         config->sign_key = SIGN_KEY_DEFAULT;
 498                 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_by_from)))
 499                         config->sign_key = SIGN_KEY_BY_FROM;
 500                 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom))) {
 501                         config->sign_key = SIGN_KEY_CUSTOM;
 502                 }
 503                 g_free(config->sign_key_id);
 504                 config->sign_key_id = gtk_editable_get_chars(GTK_EDITABLE(page->keyid), 0, -1);
 505         }
 506
 507         prefs_gpg_account_set_config(page->account, config);
 508         prefs_gpg_account_free_config(config);
 509 }
 510
 511 GPGConfig *prefs_gpg_get_config(void)
 512 {
 513         return &prefs_gpg;
 514 }
 515
 516 void prefs_gpg_save_config(void)
 517 {
 518         PrefFile *pfile;
 519         gchar *rcpath;
 520
 521         debug_print("Saving GPG config\n");
 522
 523         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 524         pfile = prefs_write_open(rcpath);
 525         g_free(rcpath);
 526         if (!pfile || (prefs_set_block_label(pfile, "GPG") < 0))
 527                 return;
 528
 529         if (prefs_write_param(param, pfile->fp) < 0) {
 530                 g_warning("failed to write GPG configuration to file");
 531                 prefs_file_close_revert(pfile);
 532                 return;
 533         }
 534         if (fprintf(pfile->fp, "\n") < 0) {
 535                 FILE_OP_ERROR(rcpath, "fprintf");
 536                 prefs_file_close_revert(pfile);
 537         } else
 538                 prefs_file_close(pfile);
 539 }
 540
 541 struct GPGAccountConfig *prefs_gpg_account_get_config(PrefsAccount *account)
 542 {
 543         GPGAccountConfig *config;
 544         const gchar *confstr;
 545         gchar **strv;
 546
 547         config = g_new0(GPGAccountConfig, 1);
 548         config->sign_key = SIGN_KEY_DEFAULT;
 549         config->sign_key_id = NULL;
 550         config->smime_sign_key = SIGN_KEY_DEFAULT;
 551         config->smime_sign_key_id = NULL;
 552
 553         confstr = prefs_account_get_privacy_prefs(account, "gpg");
 554         if (confstr != NULL) {
 555                 strv = g_strsplit(confstr, ";", 0);
 556                 if (strv[0] != NULL) {
 557                         if (!strcmp(strv[0], "DEFAULT"))
 558                                 config->sign_key = SIGN_KEY_DEFAULT;
 559                         else if (!strcmp(strv[0], "BY_FROM"))
 560                                 config->sign_key = SIGN_KEY_BY_FROM;
 561                         else if (!strcmp(strv[0], "CUSTOM")) {
 562                                 config->sign_key = SIGN_KEY_CUSTOM;
 563                         } else {
 564                                 config->sign_key = SIGN_KEY_DEFAULT;
 565                         }
 566
 567                         if (strv[1] != NULL) {
 568                                 config->sign_key_id = g_strdup(strv[1]);
 569                         }
 570                 }
 571                 g_strfreev(strv);
 572         }
 573
 574         confstr = prefs_account_get_privacy_prefs(account, "smime");
 575         /* If the "smime" section does not yet exist, fall back to
 576          * "gpg" section even for smime_ values. This will generally
 577          * only happen on first run. */
 578         if (confstr == NULL)
 579                 confstr = prefs_account_get_privacy_prefs(account, "gpg");
 580         if (confstr != NULL) {
 581                 strv = g_strsplit(confstr, ";", 0);
 582                 if (strv[0] != NULL) {
 583                         if (!strcmp(strv[0], "DEFAULT"))
 584                                 config->smime_sign_key = SIGN_KEY_DEFAULT;
 585                         else if (!strcmp(strv[0], "BY_FROM"))
 586                                 config->smime_sign_key = SIGN_KEY_BY_FROM;
 587                         else if (!strcmp(strv[0], "CUSTOM")) {
 588                                 config->smime_sign_key = SIGN_KEY_CUSTOM;
 589                         } else {
 590                                 config->smime_sign_key = SIGN_KEY_DEFAULT;
 591                         }
 592
 593                         if (strv[1] != NULL) {
 594                                 config->smime_sign_key_id = g_strdup(strv[1]);
 595                         }
 596                 }
 597                 g_strfreev(strv);
 598         }
 599
 600         return config;
 601 }
 602
 603 void prefs_gpg_account_set_config(PrefsAccount *account, GPGAccountConfig *config)
 604 {
 605         gchar *confstr = NULL;
 606
 607         switch (config->sign_key) {
 608         case SIGN_KEY_DEFAULT:
 609                 confstr = g_strdup_printf("DEFAULT;%s", config->sign_key_id);
 610                 break;
 611         case SIGN_KEY_BY_FROM:
 612                 confstr = g_strdup_printf("BY_FROM;%s", config->sign_key_id);
 613                 break;
 614         case SIGN_KEY_CUSTOM:
 615                 confstr = g_strdup_printf("CUSTOM;%s", config->sign_key_id);
 616                 break;
 617         default:
 618                 confstr = g_strdup("");
 619                 g_warning("prefs_gpg_account_set_config: bad sign_key val");
 620         }
 621
 622         prefs_account_set_privacy_prefs(account, "gpg", confstr);
 623
 624         g_free(confstr);
 625         confstr = NULL;
 626
 627         switch (config->smime_sign_key) {
 628         case SIGN_KEY_DEFAULT:
 629                 confstr = g_strdup_printf("DEFAULT;%s", config->smime_sign_key_id);
 630                 break;
 631         case SIGN_KEY_BY_FROM:
 632                 confstr = g_strdup_printf("BY_FROM;%s", config->smime_sign_key_id);
 633                 break;
 634         case SIGN_KEY_CUSTOM:
 635                 confstr = g_strdup_printf("CUSTOM;%s", config->smime_sign_key_id);
 636                 break;
 637         default:
 638                 confstr = g_strdup("");
 639                 g_warning("prefs_gpg_account_set_config: bad sign_key val");
 640         }
 641
 642         prefs_account_set_privacy_prefs(account, "smime", confstr);
 643
 644         g_free(confstr);
 645 }
 646
 647 void prefs_gpg_account_free_config(GPGAccountConfig *config)
 648 {
 649         g_free(config->smime_sign_key_id);
 650         g_free(config->sign_key_id);
 651         g_free(config);
 652 }
 653
 654 void prefs_gpg_enable_agent(gboolean enable)
 655 {
 656         if (enable) {
 657                 if (saved_gpg_agent_info) {
 658                         g_setenv("GPG_AGENT_INFO",
 659                                  saved_gpg_agent_info, TRUE);
 660                         debug_print("set GPG_AGENT_INFO=%s\n",
 661                                 saved_gpg_agent_info);
 662                 } else {
 663                         debug_print("Can't enable gpg agent (no GPG_AGENT_INFO)\n");
 664                 }
 665         } else {
 666                 if (saved_gpg_agent_info) {
 667                         g_unsetenv("GPG_AGENT_INFO");
 668                         debug_print("unset GPG_AGENT_INFO=%s\n",
 669                                 saved_gpg_agent_info);
 670                 } else {
 671                         debug_print("Can't disable gpg agent (no GPG_AGENT_INFO)\n");
 672                 }
 673         }
 674 }
 675
 676 void prefs_gpg_init()
 677 {
 678         static gchar *path[3], *spath[3];
 679         gchar *rcpath;
 680         const gchar *tmp = NULL;
 681
 682         prefs_set_default(param);
 683         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 684         prefs_read_config(param, "GPG", rcpath, NULL);
 685         g_free(rcpath);
 686
 687         path[0] = _("Plugins");
 688         path[1] = _("GPG");
 689         path[2] = NULL;
 690
 691         gpg_page.page.path = path;
 692         gpg_page.page.create_widget = prefs_gpg_create_widget_func;
 693         gpg_page.page.destroy_widget = prefs_gpg_destroy_widget_func;
 694         gpg_page.page.save_page = prefs_gpg_save_func;
 695         gpg_page.page.weight = 30.0;
 696
 697         prefs_gtk_register_page((PrefsPage *) &gpg_page);
 698
 699         gpg_account_page.page.path = path;
 700         gpg_account_page.page.create_widget = prefs_gpg_account_create_widget_func;
 701         gpg_account_page.page.destroy_widget = prefs_gpg_account_destroy_widget_func;
 702         gpg_account_page.page.save_page = prefs_gpg_account_save_func;
 703         gpg_account_page.page.weight = 30.0;
 704
 705         prefs_account_register_page((PrefsPage *) &gpg_account_page);
 706
 707         spath[0] = _("Plugins");
 708         spath[1] = _("S/MIME");
 709         spath[2] = NULL;
 710         smime_account_page.page.path = spath;
 711         smime_account_page.page.create_widget = prefs_gpg_account_create_widget_func;
 712         smime_account_page.page.destroy_widget = prefs_gpg_account_destroy_widget_func;
 713         smime_account_page.page.save_page = prefs_gpg_account_save_func;
 714         smime_account_page.page.weight = 30.0;
 715
 716         prefs_account_register_page((PrefsPage *) &smime_account_page);
 717
 718         tmp = g_getenv("GPG_AGENT_INFO");
 719         if (tmp)
 720                 saved_gpg_agent_info = g_strdup(tmp);
 721
 722         prefs_gpg_enable_agent(prefs_gpg_get_config()->use_gpg_agent);
 723 }
 724
 725 void prefs_gpg_done()
 726 {
 727         prefs_gtk_unregister_page((PrefsPage *) &gpg_page);
 728         prefs_account_unregister_page((PrefsPage *) &gpg_account_page);
 729         prefs_gpg_enable_agent(TRUE);
 730 }
 731
 732 gboolean prefs_gpg_should_skip_encryption_warning(const gchar *systemid)
 733 {
 734         gchar **systems = NULL;
 735         int i = 0;
 736         if (prefs_gpg_get_config()->skip_encryption_warning == NULL)
 737                 return FALSE;
 738         systems = g_strsplit(prefs_gpg_get_config()->skip_encryption_warning,
 739                                 ",", -1);
 740         while (systems && systems[i]) {
 741                 debug_print(" cmp %s %s\n", systems[i], systemid);
 742                 if (!strcmp(systems[i],systemid)) {
 743                         g_strfreev(systems);
 744                         return TRUE;
 745                 }
 746                 i++;
 747         }
 748         g_strfreev(systems);
 749         return FALSE;
 750 }
 751
 752 void prefs_gpg_add_skip_encryption_warning(const gchar *systemid)
 753 {
 754         gchar *tmp = NULL;
 755         if (prefs_gpg_get_config()->skip_encryption_warning == NULL)
 756                 prefs_gpg_get_config()->skip_encryption_warning =
 757                         g_strdup_printf("%s,", systemid);
 758         else if (!prefs_gpg_should_skip_encryption_warning(systemid)) {
 759                 tmp = g_strdup_printf("%s%s,",
 760                         prefs_gpg_get_config()->skip_encryption_warning,
 761                         systemid);
 762                 g_free(prefs_gpg_get_config()->skip_encryption_warning);
 763                 prefs_gpg_get_config()->skip_encryption_warning = tmp;
 764         }
 765         prefs_gpg_save_config();
 766 }
 767
 768 void prefs_gpg_remove_skip_encryption_warning(const gchar *systemid)
 769 {
 770         gchar **systems = NULL;
 771         int i = 0;
 772         if (prefs_gpg_get_config()->skip_encryption_warning == NULL)
 773                 return;
 774
 775         if (prefs_gpg_should_skip_encryption_warning(systemid)) {
 776                 systems = g_strsplit(prefs_gpg_get_config()->skip_encryption_warning,
 777                                 ",", -1);
 778                 g_free(prefs_gpg_get_config()->skip_encryption_warning);
 779                 prefs_gpg_get_config()->skip_encryption_warning = NULL;
 780
 781                 while (systems && systems[i]) {
 782                         if (!strcmp(systems[i],systemid)) {
 783                                 i++;
 784                                 continue;
 785                         }
 786                         prefs_gpg_add_skip_encryption_warning(systems[i]);
 787                         i++;
 788                 }
 789
 790                 g_strfreev(systems);
 791         }
 792         prefs_gpg_save_config();
 793 }
 794
 795 gboolean prefs_gpg_auto_check_signatures(void)
 796 {
 797         return prefs_gpg_get_config()->auto_check_signatures;
 798 }