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         GSList *key_group = NULL;
 224         GtkWidget *key_default;
 225         GtkWidget *key_by_from;
 226         GtkWidget *key_custom;
 227         GtkWidget *keyid_label;
 228         GtkWidget *keyid;
 229
 230         vbox = gtk_vbox_new(FALSE, 0);
 231         gtk_widget_show(vbox);
 232
 233         frame1 = gtk_frame_new(_("Sign key"));
 234         gtk_widget_show(frame1);
 235         gtk_box_pack_start(GTK_BOX(vbox), frame1, FALSE, FALSE, 0);
 236         gtk_frame_set_label_align(GTK_FRAME(frame1), 0.0, 0.5);
 237
 238         table1 = gtk_table_new(4, 3, FALSE);
 239         gtk_widget_show(table1);
 240         gtk_container_add(GTK_CONTAINER(frame1), table1);
 241         gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
 242         gtk_table_set_row_spacings(GTK_TABLE(table1), 4);
 243         gtk_table_set_col_spacings(GTK_TABLE(table1), 4);
 244
 245         key_default = gtk_radio_button_new_with_label(key_group,
 246                         _("Use default GnuPG key"));
 247         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_default));
 248         gtk_widget_show(key_default);
 249         gtk_table_attach(GTK_TABLE(table1), key_default, 0, 3, 0, 1,
 250                          (GtkAttachOptions) (GTK_FILL),
 251                          (GtkAttachOptions) (0), 0, 0);
 252
 253         key_by_from = gtk_radio_button_new_with_label(key_group,
 254                 _("Select key by your email address"));
 255         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_by_from));
 256         gtk_widget_show(key_by_from);
 257         gtk_table_attach(GTK_TABLE(table1), key_by_from, 0, 3, 1, 2,
 258                          (GtkAttachOptions) (GTK_FILL),
 259                          (GtkAttachOptions) (0), 0, 0);
 260
 261         key_custom = gtk_radio_button_new_with_label(key_group,
 262                 _("Specify key manually"));
 263         key_group = gtk_radio_button_group(GTK_RADIO_BUTTON(key_custom));
 264         gtk_widget_show(key_custom);
 265         gtk_table_attach(GTK_TABLE(table1), key_custom, 0, 3, 2, 3,
 266                          (GtkAttachOptions) (GTK_FILL),
 267                          (GtkAttachOptions) (0), 0, 0);
 268
 269         keyid_label = gtk_label_new(_("User or key ID:"));
 270         gtk_widget_show(keyid_label);
 271         gtk_table_attach(GTK_TABLE(table1), keyid_label, 0, 2, 3, 4,
 272                          (GtkAttachOptions) (GTK_FILL),
 273                          (GtkAttachOptions) (0), 0, 0);
 274         gtk_label_set_justify(GTK_LABEL(keyid_label), GTK_JUSTIFY_LEFT);
 275
 276         keyid = gtk_entry_new();
 277         gtk_widget_show(keyid);
 278         gtk_table_attach(GTK_TABLE(table1), keyid, 2, 3, 3, 4,
 279                          (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 280                          (GtkAttachOptions) (0), 0, 0);
 281
 282         config = prefs_gpg_account_get_config(account);
 283         switch (config->sign_key) {
 284         case SIGN_KEY_DEFAULT:
 285                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_default), TRUE);
 286                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 287                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 288                 break;
 289         case SIGN_KEY_BY_FROM:
 290                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_by_from), TRUE);
 291                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), FALSE);
 292                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), FALSE);
 293                 break;
 294         case SIGN_KEY_CUSTOM:
 295                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(key_custom), TRUE);
 296                 gtk_widget_set_sensitive(GTK_WIDGET(keyid_label), TRUE);
 297                 gtk_widget_set_sensitive(GTK_WIDGET(keyid), TRUE);
 298                 break;
 299         }
 300
 301         if (config->sign_key_id != NULL)
 302                 gtk_entry_set_text(GTK_ENTRY(keyid), config->sign_key_id);
 303
 304         g_signal_connect(G_OBJECT(key_custom), "toggled", G_CALLBACK(key_custom_toggled), page);
 305
 306         page->key_default = key_default;
 307         page->key_by_from = key_by_from;
 308         page->key_custom = key_custom;
 309         page->keyid = keyid;
 310         page->keyid_label = keyid_label;
 311
 312         page->page.widget = vbox;
 313         page->account = account;
 314 }
 315
 316 static void prefs_gpg_account_destroy_widget_func(PrefsPage *_page)
 317 {
 318         /* nothing to do here */
 319 }
 320
 321 static void prefs_gpg_account_save_func(PrefsPage *_page)
 322 {
 323         struct GPGAccountPage *page = (struct GPGAccountPage *) _page;
 324         GPGAccountConfig *config;
 325
 326         config = prefs_gpg_account_get_config(page->account);
 327
 328         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_default)))
 329                 config->sign_key = SIGN_KEY_DEFAULT;
 330         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_by_from)))
 331                 config->sign_key = SIGN_KEY_BY_FROM;
 332         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom))) {
 333                 config->sign_key = SIGN_KEY_CUSTOM;
 334                 g_free(config->sign_key_id);
 335                 config->sign_key_id = gtk_editable_get_chars(GTK_EDITABLE(page->keyid), 0, -1);
 336         }
 337
 338         prefs_gpg_account_set_config(page->account, config);
 339         prefs_gpg_account_free_config(config);
 340 }
 341
 342 GPGConfig *prefs_gpg_get_config(void)
 343 {
 344         return &prefs_gpg;
 345 }
 346
 347 void prefs_gpg_save_config(void)
 348 {
 349         PrefFile *pfile;
 350         gchar *rcpath;
 351
 352         debug_print("Saving GPG config\n");
 353
 354         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 355         pfile = prefs_write_open(rcpath);
 356         g_free(rcpath);
 357         if (!pfile || (prefs_set_block_label(pfile, "GPG") < 0))
 358                 return;
 359
 360         if (prefs_write_param(param, pfile->fp) < 0) {
 361                 g_warning("failed to write GPG configuration to file\n");
 362                 prefs_file_close_revert(pfile);
 363                 return;
 364         }
 365         fprintf(pfile->fp, "\n");
 366
 367         prefs_file_close(pfile);
 368 }
 369
 370 struct GPGAccountConfig *prefs_gpg_account_get_config(PrefsAccount *account)
 371 {
 372         GPGAccountConfig *config;
 373         const gchar *confstr;
 374         gchar **strv;
 375
 376         config = g_new0(GPGAccountConfig, 1);
 377         config->sign_key = SIGN_KEY_DEFAULT;
 378         config->sign_key_id = NULL;
 379
 380         confstr = prefs_account_get_privacy_prefs(account, "gpg");
 381         if (confstr == NULL)
 382                 return config;
 383
 384         strv = g_strsplit(confstr, ";", 0);
 385         if (strv[0] != NULL) {
 386                 if (!strcmp(strv[0], "DEFAULT"))
 387                         config->sign_key = SIGN_KEY_DEFAULT;
 388                 if (!strcmp(strv[0], "BY_FROM"))
 389                         config->sign_key = SIGN_KEY_BY_FROM;
 390                 if (!strcmp(strv[0], "CUSTOM")) {
 391                         if (strv[1] != NULL) {
 392                                 config->sign_key = SIGN_KEY_CUSTOM;
 393                                 config->sign_key_id = g_strdup(strv[1]);
 394                         } else
 395                                 config->sign_key = SIGN_KEY_DEFAULT;
 396                 }
 397         }
 398         g_strfreev(strv);
 399
 400         return config;
 401 }
 402
 403 void prefs_gpg_account_set_config(PrefsAccount *account, GPGAccountConfig *config)
 404 {
 405         gchar *confstr = NULL;
 406
 407         switch (config->sign_key) {
 408         case SIGN_KEY_DEFAULT:
 409                 confstr = g_strdup("DEFAULT");
 410                 break;
 411         case SIGN_KEY_BY_FROM:
 412                 confstr = g_strdup("BY_FROM");
 413                 break;
 414         case SIGN_KEY_CUSTOM:
 415                 confstr = g_strdup_printf("CUSTOM;%s", config->sign_key_id);
 416                 break;
 417         default:
 418                 confstr = g_strdup("");
 419                 g_warning("prefs_gpg_account_set_config: bad sign_key val\n");
 420         }
 421
 422         prefs_account_set_privacy_prefs(account, "gpg", confstr);
 423
 424         g_free(confstr);
 425 }
 426
 427 void prefs_gpg_account_free_config(GPGAccountConfig *config)
 428 {
 429         g_free(config->sign_key_id);
 430         g_free(config);
 431 }
 432
 433 static struct GPGPage gpg_page;
 434 static struct GPGAccountPage gpg_account_page;
 435
 436 void prefs_gpg_init()
 437 {
 438         static gchar *path[3];
 439         gchar *rcpath;
 440
 441         prefs_set_default(param);
 442         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 443         prefs_read_config(param, "GPG", rcpath, NULL);
 444         g_free(rcpath);
 445
 446         path[0] = _("Plugins");
 447         path[1] = _("GPG");
 448         path[2] = NULL;
 449
 450         gpg_page.page.path = path;
 451         gpg_page.page.create_widget = prefs_gpg_create_widget_func;
 452         gpg_page.page.destroy_widget = prefs_gpg_destroy_widget_func;
 453         gpg_page.page.save_page = prefs_gpg_save_func;
 454         gpg_page.page.weight = 30.0;
 455
 456         prefs_gtk_register_page((PrefsPage *) &gpg_page);
 457
 458         gpg_account_page.page.path = path;
 459         gpg_account_page.page.create_widget = prefs_gpg_account_create_widget_func;
 460         gpg_account_page.page.destroy_widget = prefs_gpg_account_destroy_widget_func;
 461         gpg_account_page.page.save_page = prefs_gpg_account_save_func;
 462         gpg_account_page.page.weight = 30.0;
 463
 464         prefs_account_register_page((PrefsPage *) &gpg_account_page);
 465 }
 466
 467 void prefs_gpg_done()
 468 {
 469         prefs_gtk_unregister_page((PrefsPage *) &gpg_page);
 470         prefs_account_unregister_page((PrefsPage *) &gpg_account_page);
 471 }