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