src/plugins/pgpcore/prefs_gpg.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include <gtk/gtk.h>
  21 #include <glib.h>
  22 #include <glib/gi18n.h>
  23
  24 #include "defs.h"
  25 #include "utils.h"
  26 #include "prefs.h"
  27 #include "prefs_gtk.h"
  28 #include "prefs_gpg.h"
  29
  30 struct GPGConfig prefs_gpg;
  31
  32 static PrefParam param[] = {
  33         /* Privacy */
  34         {"auto_check_signatures", "FALSE",
  35          &prefs_gpg.auto_check_signatures, P_BOOL,
  36          NULL, NULL, NULL},
  37         {"store_passphrase", "FALSE", &prefs_gpg.store_passphrase, P_BOOL,
  38          NULL, NULL, NULL},
  39         {"store_passphrase_timeout", "0",
  40          &prefs_gpg.store_passphrase_timeout, P_INT,
  41          NULL, NULL, NULL},
  42         {"passphrase_grab", "FALSE", &prefs_gpg.passphrase_grab, P_BOOL,
  43          NULL, NULL, NULL},
  44         {"gpg_warning", "TRUE", &prefs_gpg.gpg_warning, P_BOOL,
  45          NULL, NULL, NULL},
  46
  47         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
  48 };
  49
  50 struct GPGPage
  51 {
  52         PrefsPage page;
  53
  54         GtkWidget *checkbtn_auto_check_signatures;
  55         GtkWidget *checkbtn_store_passphrase;
  56         GtkWidget *spinbtn_store_passphrase;
  57         GtkWidget *checkbtn_passphrase_grab;
  58         GtkWidget *checkbtn_gpg_warning;
  59 };
  60
  61 static void prefs_gpg_create_widget_func(PrefsPage *_page,
  62                                          GtkWindow *window,
  63                                          gpointer data)
  64 {
  65         struct GPGPage *page = (struct GPGPage *) _page;
  66         struct GPGConfig *config;
  67
  68         GtkWidget *checkbtn_passphrase_grab;
  69         GtkWidget *checkbtn_store_passphrase;
  70         GtkWidget *checkbtn_auto_check_signatures;
  71         GtkWidget *checkbtn_gpg_warning;
  72         GtkWidget *hbox1;
  73         GtkWidget *vbox1, *vbox2;
  74         GtkWidget *label_expire1;
  75         GtkObject *spinbtn_store_passphrase_adj;
  76         GtkWidget *spinbtn_store_passphrase;
  77         GtkWidget *label_expire2;
  78         GtkWidget *frame_passphrase;
  79         GtkTooltips *tooltips;
  80
  81         tooltips = gtk_tooltips_new();
  82
  83         vbox1 = gtk_vbox_new (FALSE, VSPACING);
  84         gtk_widget_show (vbox1);
  85         gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
  86
  87         vbox2 = gtk_vbox_new (FALSE, 0);
  88         gtk_widget_show (vbox2);
  89         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
  90
  91         PACK_CHECK_BUTTON (vbox2, checkbtn_auto_check_signatures,
  92                         _("Automatically check signatures"));
  93
  94         PACK_FRAME(vbox1, frame_passphrase, _("Passphrase"));
  95
  96         vbox2 = gtk_vbox_new (FALSE, VSPACING_NARROW);
  97         gtk_widget_show (vbox2);
  98         gtk_container_add (GTK_CONTAINER (frame_passphrase), vbox2);
  99         gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
 100
 101         PACK_CHECK_BUTTON (vbox2, checkbtn_store_passphrase,
 102                         _("Store passphrase in memory"));
 103
 104         hbox1 = gtk_hbox_new (FALSE, 8);
 105         gtk_widget_show (hbox1);
 106         gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
 107
 108         label_expire1 = gtk_label_new(_("Expire after"));
 109         gtk_widget_show (label_expire1);
 110         gtk_box_pack_start (GTK_BOX (hbox1), label_expire1, FALSE, FALSE, 0);
 111
 112         spinbtn_store_passphrase_adj =
 113             gtk_adjustment_new(1, 0, 1440, 1, 10, 10);
 114         spinbtn_store_passphrase =
 115             gtk_spin_button_new(GTK_ADJUSTMENT
 116                                 (spinbtn_store_passphrase_adj), 1, 0);
 117         gtk_widget_show(spinbtn_store_passphrase);
 118         gtk_box_pack_start(GTK_BOX(hbox1), spinbtn_store_passphrase, FALSE,
 119                            FALSE, 0);
 120         gtk_widget_set_size_request(spinbtn_store_passphrase, 64, -1);
 121         gtk_tooltips_set_tip(tooltips, spinbtn_store_passphrase,
 122                              _
 123                              ("Setting to '0' will store the passphrase for the whole session"),
 124                              NULL);
 125         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON
 126                                     (spinbtn_store_passphrase), TRUE);
 127
 128         label_expire2 = gtk_label_new(_("minute(s)"));
 129         gtk_widget_show(label_expire2);
 130         gtk_box_pack_start(GTK_BOX(hbox1), label_expire2, FALSE, FALSE, 0);
 131         gtk_misc_set_alignment(GTK_MISC(label_expire2), 0.0, 0.5);
 132
 133         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, label_expire1);
 134         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, spinbtn_store_passphrase);
 135         SET_TOGGLE_SENSITIVITY (checkbtn_store_passphrase, label_expire2);
 136
 137         PACK_CHECK_BUTTON (vbox2, checkbtn_passphrase_grab,
 138                         _("Grab input while entering a passphrase"));
 139
 140         vbox2 = gtk_vbox_new (FALSE, 0);
 141         gtk_widget_show (vbox2);
 142         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
 143
 144         PACK_CHECK_BUTTON (vbox2, checkbtn_gpg_warning,
 145                         _("Display warning on startup if GnuPG doesn't work"));
 146
 147         config = prefs_gpg_get_config();
 148
 149         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_auto_check_signatures), config->auto_check_signatures);
 150         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_store_passphrase), config->store_passphrase);
 151         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbtn_store_passphrase), (float) config->store_passphrase_timeout);
 152         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_passphrase_grab), config->passphrase_grab);
 153         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_gpg_warning), config->gpg_warning);
 154
 155         page->checkbtn_auto_check_signatures = checkbtn_auto_check_signatures;
 156         page->checkbtn_store_passphrase = checkbtn_store_passphrase;
 157         page->spinbtn_store_passphrase = spinbtn_store_passphrase;
 158         page->checkbtn_passphrase_grab = checkbtn_passphrase_grab;
 159         page->checkbtn_gpg_warning = checkbtn_gpg_warning;
 160
 161         page->page.widget = vbox1;
 162 }
 163
 164 static void prefs_gpg_destroy_widget_func(PrefsPage *_page)
 165 {
 166 }
 167
 168 static void prefs_gpg_save_func(PrefsPage *_page)
 169 {
 170         struct GPGPage *page = (struct GPGPage *) _page;
 171         GPGConfig *config = prefs_gpg_get_config();
 172
 173         config->auto_check_signatures =
 174                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_auto_check_signatures));
 175         config->store_passphrase =
 176                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_store_passphrase));
 177         config->store_passphrase_timeout =
 178                 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->spinbtn_store_passphrase));
 179         config->passphrase_grab =
 180                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_passphrase_grab));
 181         config->gpg_warning =
 182                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->checkbtn_gpg_warning));
 183
 184         prefs_gpg_save_config();
 185 }
 186
 187 struct GPGAccountPage
 188 {
 189         PrefsPage page;
 190
 191         GtkWidget *key_default;
 192         GtkWidget *key_by_from;
 193         GtkWidget *key_custom;
 194         GtkWidget *keyid;
 195         GtkWidget *keyid_label;
 196
 197         PrefsAccount *account;
 198 };
 199
 200 void key_custom_toggled(GtkToggleButton *togglebutton, gpointer user_data)
 201 {
 202         struct GPGAccountPage *page = (struct GPGAccountPage *) user_data;
 203         gboolean active;
 204
 205         active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom));
 206         gtk_widget_set_sensitive(GTK_WIDGET(page->keyid_label), active);
 207         gtk_widget_set_sensitive(GTK_WIDGET(page->keyid), active);
 208         if (!active)
 209                 gtk_editable_delete_text(GTK_EDITABLE(page->keyid), 0, -1);
 210 }
 211
 212 static void prefs_gpg_account_create_widget_func(PrefsPage *_page,
 213                                                  GtkWindow *window,
 214                                                  gpointer data)
 215 {
 216         struct GPGAccountPage *page = (struct GPGAccountPage *) _page;
 217         PrefsAccount *account = (PrefsAccount *) data;
 218         GPGAccountConfig *config;
 219
 220         GtkWidget *vbox;
 221         GtkWidget *frame1;
 222         GtkWidget *table1;
 223         GtkWidget *table2;
 224         GSList *key_group = NULL;
 225         GtkWidget *key_default;
 226         GtkWidget *key_by_from;
 227         GtkWidget *key_custom;
 228         GtkWidget *keyid_label;
 229         GtkWidget *keyid;
 230
 231         vbox = gtk_vbox_new(FALSE, 0);
 232         gtk_widget_show(vbox);
 233
 234         frame1 = gtk_frame_new(_("Sign key"));
 235         gtk_widget_show(frame1);
 236         gtk_box_pack_start(GTK_BOX(vbox), frame1, FALSE, FALSE, 0);
 237         gtk_frame_set_label_align(GTK_FRAME(frame1), 0.0, 0.5);
 238
 239         table1 = gtk_table_new(4, 3, FALSE);
 240         gtk_widget_show(table1);
 241         gtk_container_add(GTK_CONTAINER(frame1), table1);
 242         gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
 243         gtk_table_set_row_spacings(GTK_TABLE(table1), 4);
 244         gtk_table_set_col_spacings(GTK_TABLE(table1), 4);
 245
 246         key_default = gtk_radio_button_new_with_label(key_group,
 247                         _("Use default GnuPG key"));
 248         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_default));
 249         gtk_widget_show(key_default);
 250         gtk_table_attach(GTK_TABLE(table1), key_default, 0, 3, 0, 1,
 251                          (GtkAttachOptions) (GTK_FILL),
 252                          (GtkAttachOptions) (0), 0, 0);
 253
 254         key_by_from = gtk_radio_button_new_with_label(key_group,
 255                 _("Select key by your email address"));
 256         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_by_from));
 257         gtk_widget_show(key_by_from);
 258         gtk_table_attach(GTK_TABLE(table1), key_by_from, 0, 3, 1, 2,
 259                          (GtkAttachOptions) (GTK_FILL),
 260                          (GtkAttachOptions) (0), 0, 0);
 261
 262         key_custom = gtk_radio_button_new_with_label(key_group,
 263                 _("Specify key manually"));
 264         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_custom));
 265         gtk_widget_show(key_custom);
 266         gtk_table_attach(GTK_TABLE(table1), key_custom, 0, 3, 2, 3,
 267                          (GtkAttachOptions) (GTK_FILL),
 268                          (GtkAttachOptions) (0), 0, 0);
 269
 270         keyid_label = gtk_label_new(_("User or key ID:"));
 271         gtk_widget_show(keyid_label);
 272         gtk_table_attach(GTK_TABLE(table1), keyid_label, 0, 2, 3, 4,
 273                          (GtkAttachOptions) (GTK_FILL),
 274                          (GtkAttachOptions) (0), 0, 0);
 275         gtk_label_set_justify(GTK_LABEL(keyid_label), GTK_JUSTIFY_LEFT);
 276
 277         keyid = gtk_entry_new();
 278         gtk_widget_show(keyid);
 279         gtk_table_attach(GTK_TABLE(table1), keyid, 2, 3, 3, 4,
 280                          (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 281                          (GtkAttachOptions) (0), 0, 0);
 282
 283         config = prefs_gpg_account_get_config(account);
 284         switch (config->sign_key) {
 285         case SIGN_KEY_DEFAULT:
 286                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_default), TRUE);
 287                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 288                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 289                 break;
 290         case SIGN_KEY_BY_FROM:
 291                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_by_from), TRUE);
 292                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 293                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 294                 break;
 295         case SIGN_KEY_CUSTOM:
 296                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_custom), TRUE);
 297                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), TRUE);
 298                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), TRUE);
 299                 break;
 300         }
 301
 302         if (config->sign_key_id != NULL)
 303                 gtk_entry_set_text(GTK_ENTRY(keyid), config->sign_key_id);
 304
 305         g_signal_connect(G_OBJECT(key_custom), "toggled", G_CALLBACK(key_custom_toggled), page);
 306
 307         page->key_default = key_default;
 308         page->key_by_from = key_by_from;
 309         page->key_custom = key_custom;
 310         page->keyid = keyid;
 311         page->keyid_label = keyid_label;
 312
 313         page->page.widget = vbox;
 314         page->account = account;
 315 }
 316
 317 static void prefs_gpg_account_destroy_widget_func(PrefsPage *_page)
 318 {
 319         /* nothing to do here */
 320 }
 321
 322 static void prefs_gpg_account_save_func(PrefsPage *_page)
 323 {
 324         struct GPGAccountPage *page = (struct GPGAccountPage *) _page;
 325         GPGAccountConfig *config;
 326
 327         config = prefs_gpg_account_get_config(page->account);
 328
 329         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_default)))
 330                 config->sign_key = SIGN_KEY_DEFAULT;
 331         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_by_from)))
 332                 config->sign_key = SIGN_KEY_BY_FROM;
 333         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom))) {
 334                 config->sign_key = SIGN_KEY_CUSTOM;
 335                 g_free(config->sign_key_id);
 336                 config->sign_key_id = gtk_editable_get_chars(GTK_EDITABLE(page->keyid), 0, -1);
 337         }
 338
 339         prefs_gpg_account_set_config(page->account, config);
 340         prefs_gpg_account_free_config(config);
 341 }
 342
 343 GPGConfig *prefs_gpg_get_config(void)
 344 {
 345         return &prefs_gpg;
 346 }
 347
 348 void prefs_gpg_save_config(void)
 349 {
 350         PrefFile *pfile;
 351         gchar *rcpath;
 352
 353         debug_print("Saving GPG config\n");
 354
 355         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 356         pfile = prefs_write_open(rcpath);
 357         g_free(rcpath);
 358         if (!pfile || (prefs_set_block_label(pfile, "GPG") < 0))
 359                 return;
 360
 361         if (prefs_write_param(param, pfile->fp) < 0) {
 362                 g_warning("failed to write GPG configuration to file\n");
 363                 prefs_file_close_revert(pfile);
 364                 return;
 365         }
 366         fprintf(pfile->fp, "\n");
 367
 368         prefs_file_close(pfile);
 369 }
 370
 371 struct GPGAccountConfig *prefs_gpg_account_get_config(PrefsAccount *account)
 372 {
 373         GPGAccountConfig *config;
 374         const gchar *confstr;
 375         gchar **strv;
 376
 377         config = g_new0(GPGAccountConfig, 1);
 378         config->sign_key = SIGN_KEY_DEFAULT;
 379         config->sign_key_id = NULL;
 380
 381         confstr = prefs_account_get_privacy_prefs(account, "gpg");
 382         if (confstr == NULL)
 383                 return config;
 384
 385         strv = g_strsplit(confstr, ";", 0);
 386         if (strv[0] != NULL) {
 387                 if (!strcmp(strv[0], "DEFAULT"))
 388                         config->sign_key = SIGN_KEY_DEFAULT;
 389                 if (!strcmp(strv[0], "BY_FROM"))
 390                         config->sign_key = SIGN_KEY_BY_FROM;
 391                 if (!strcmp(strv[0], "CUSTOM")) {
 392                         if (strv[1] != NULL) {
 393                                 config->sign_key = SIGN_KEY_CUSTOM;
 394                                 config->sign_key_id = g_strdup(strv[1]);
 395                         } else
 396                                 config->sign_key = SIGN_KEY_DEFAULT;
 397                 }
 398         }
 399         g_strfreev(strv);
 400
 401         return config;
 402 }
 403
 404 void prefs_gpg_account_set_config(PrefsAccount *account, GPGAccountConfig *config)
 405 {
 406         gchar *confstr = NULL;
 407
 408         switch (config->sign_key) {
 409         case SIGN_KEY_DEFAULT:
 410                 confstr = g_strdup("DEFAULT");
 411                 break;
 412         case SIGN_KEY_BY_FROM:
 413                 confstr = g_strdup("BY_FROM");
 414                 break;
 415         case SIGN_KEY_CUSTOM:
 416                 confstr = g_strdup_printf("CUSTOM;%s", config->sign_key_id);
 417                 break;
 418         default:
 419                 confstr = g_strdup("");
 420                 g_warning("prefs_gpg_account_set_config: bad sign_key val\n");
 421         }
 422
 423         prefs_account_set_privacy_prefs(account, "gpg", confstr);
 424
 425         g_free(confstr);
 426 }
 427
 428 void prefs_gpg_account_free_config(GPGAccountConfig *config)
 429 {
 430         g_free(config->sign_key_id);
 431         g_free(config);
 432 }
 433
 434 static struct GPGPage gpg_page;
 435 static struct GPGAccountPage gpg_account_page;
 436
 437 void prefs_gpg_init()
 438 {
 439         static gchar *path[3];
 440         gchar *rcpath;
 441
 442         prefs_set_default(param);
 443         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 444         prefs_read_config(param, "GPG", rcpath, NULL);
 445         g_free(rcpath);
 446
 447         path[0] = _("Plugins");
 448         path[1] = _("GPG");
 449         path[2] = NULL;
 450
 451         gpg_page.page.path = path;
 452         gpg_page.page.create_widget = prefs_gpg_create_widget_func;
 453         gpg_page.page.destroy_widget = prefs_gpg_destroy_widget_func;
 454         gpg_page.page.save_page = prefs_gpg_save_func;
 455         gpg_page.page.weight = 30.0;
 456
 457         prefs_gtk_register_page((PrefsPage *) &gpg_page);
 458
 459         gpg_account_page.page.path = path;
 460         gpg_account_page.page.create_widget = prefs_gpg_account_create_widget_func;
 461         gpg_account_page.page.destroy_widget = prefs_gpg_account_destroy_widget_func;
 462         gpg_account_page.page.save_page = prefs_gpg_account_save_func;
 463         gpg_account_page.page.weight = 30.0;
 464
 465         prefs_account_register_page((PrefsPage *) &gpg_account_page);
 466 }
 467
 468 void prefs_gpg_done()
 469 {
 470         prefs_gtk_unregister_page((PrefsPage *) &gpg_page);
 471         prefs_account_unregister_page((PrefsPage *) &gpg_account_page);
 472 }