pidgin/gtkcertmgr.c

   1 /* pidgin
   2  *
   3  * Pidgin is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  *
  21  */
  22
  23 #include "internal.h"
  24 #include "core.h"
  25 #include "pidgin.h"
  26 #include "pidginstock.h"
  27
  28 #include "debug.h"
  29 #include "notify.h"
  30 #include "request.h"
  31 #include "tls-certificate.h"
  32 #include "tls-certificate-info.h"
  33
  34 #include "gtk3compat.h"
  35 #include "gtkblist.h"
  36 #include "gtkutils.h"
  37
  38 #include "gtkcertmgr.h"
  39
  40 /*****************************************************************************
  41  * X.509 certificate management interface                                    *
  42  *****************************************************************************/
  43
  44 typedef struct {
  45         GtkWidget *mgmt_widget;
  46         GtkTreeView *listview;
  47         GtkTreeSelection *listselect;
  48         GtkWidget *importbutton;
  49         GtkWidget *exportbutton;
  50         GtkWidget *infobutton;
  51         GtkWidget *deletebutton;
  52 } tls_peers_mgmt_data;
  53
  54 tls_peers_mgmt_data *tpm_dat = NULL;
  55
  56 /* Columns
  57    See http://developer.gnome.org/doc/API/2.0/gtk/TreeWidget.html */
  58 enum
  59 {
  60         TPM_HOSTNAME_COLUMN,
  61         TPM_N_COLUMNS
  62 };
  63
  64 static void
  65 tls_peers_mgmt_destroy(GtkWidget *mgmt_widget, gpointer data)
  66 {
  67         purple_debug_info("certmgr",
  68                           "tls peers self-destructs\n");
  69
  70         purple_signals_disconnect_by_handle(tpm_dat);
  71         purple_request_close_with_handle(tpm_dat);
  72         g_free(tpm_dat); tpm_dat = NULL;
  73 }
  74
  75 static void
  76 tls_peers_mgmt_repopulate_list(void)
  77 {
  78         GtkTreeView *listview = tpm_dat->listview;
  79         GList *idlist, *l;
  80
  81         GtkListStore *store = GTK_LIST_STORE(
  82                 gtk_tree_view_get_model(GTK_TREE_VIEW(listview)));
  83
  84         /* First, delete everything in the list */
  85         gtk_list_store_clear(store);
  86
  87         /* Grab the available certificates */
  88         idlist = purple_tls_certificate_list_ids();
  89
  90         /* Populate the listview */
  91         for (l = idlist; l; l = l->next) {
  92                 GtkTreeIter iter;
  93                 gtk_list_store_append(store, &iter);
  94
  95                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
  96                                    TPM_HOSTNAME_COLUMN, l->data,
  97                                    -1);
  98         }
  99
 100         purple_tls_certificate_free_ids(idlist);
 101 }
 102
 103 static void
 104 tls_peers_mgmt_select_chg_cb(GtkTreeSelection *ignored, gpointer data)
 105 {
 106         GtkTreeSelection *select = tpm_dat->listselect;
 107         GtkTreeIter iter;
 108         GtkTreeModel *model;
 109
 110         /* See if things are selected */
 111         if (gtk_tree_selection_get_selected(select, &model, &iter)) {
 112                 /* Enable buttons if something is selected */
 113                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->exportbutton), TRUE);
 114                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->infobutton), TRUE);
 115                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->deletebutton), TRUE);
 116         } else {
 117                 /* Otherwise, disable them */
 118                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->exportbutton), FALSE);
 119                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->infobutton), FALSE);
 120                 gtk_widget_set_sensitive(GTK_WIDGET(tpm_dat->deletebutton), FALSE);
 121
 122         }
 123 }
 124
 125 static void
 126 tls_peers_mgmt_import_ok2_cb(gpointer data, const char *result)
 127 {
 128         GTlsCertificate *crt = data;
 129         GError *error = NULL;
 130
 131         /* TODO: Perhaps prompt if you're overwriting a cert? */
 132
 133         /* Trust the certificate */
 134         if (result && *result) {
 135                 if(!purple_tls_certificate_trust(result, crt, &error)) {
 136                         purple_debug_error("gtkcertmgr/tls_peers_mgmt",
 137                                         "Error trusting certificate '%s': %s",
 138                                         result, error->message);
 139                         g_clear_error(&error);
 140                 }
 141
 142                 tls_peers_mgmt_repopulate_list();
 143         }
 144
 145         /* And this certificate is not needed any more */
 146         g_object_unref(crt);
 147 }
 148
 149 static void
 150 tls_peers_mgmt_import_cancel2_cb(gpointer data, const char *result)
 151 {
 152         GTlsCertificate *crt = data;
 153         g_object_unref(crt);
 154 }
 155
 156 static void
 157 tls_peers_mgmt_import_ok_cb(gpointer data, const char *filename)
 158 {
 159         GTlsCertificate *crt;
 160         GError *error = NULL;
 161
 162         /* Now load the certificate from disk */
 163         crt = g_tls_certificate_new_from_file(filename, &error);
 164
 165         /* Did it work? */
 166         if (crt != NULL) {
 167                 gchar *default_hostname;
 168                 PurpleTlsCertificateInfo *info;
 169
 170                 /* Get name to add trust as */
 171                 /* Make a guess about what the hostname should be */
 172                 info = purple_tls_certificate_get_info(crt);
 173                 default_hostname = purple_tls_certificate_info_get_subject_name(info);
 174                 purple_tls_certificate_info_free(info);
 175
 176                 /* TODO: Find a way to make sure that crt gets destroyed
 177                    if the window gets closed unusually, such as by handle
 178                    deletion */
 179                 /* TODO: Display some more information on the certificate? */
 180                 purple_request_input(tpm_dat,
 181                                      _("Certificate Import"),
 182                                      _("Specify a hostname"),
 183                                      _("Type the host name for this certificate."),
 184                                      default_hostname,
 185                                      FALSE, /* Not multiline */
 186                                      FALSE, /* Not masked? */
 187                                      NULL,  /* No hints? */
 188                                      _("OK"),
 189                                      G_CALLBACK(tls_peers_mgmt_import_ok2_cb),
 190                                      _("Cancel"),
 191                                      G_CALLBACK(tls_peers_mgmt_import_cancel2_cb),
 192                                      NULL,  /* No additional parameters */
 193                                      crt    /* Pass cert instance to callback*/
 194                                      );
 195
 196                 g_free(default_hostname);
 197         } else {
 198                 /* Errors! Oh no! */
 199                 /* TODO: Perhaps find a way to be specific about what just
 200                    went wrong? */
 201                 gchar * secondary;
 202
 203                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 204                                 "File %s couldn't be imported: %s",
 205                                 filename, error->message);
 206                 g_clear_error(&error);
 207
 208                 secondary = g_strdup_printf(_("File %s could not be imported.\nMake sure that the file is readable and in PEM format.\n"), filename);
 209                 purple_notify_error(NULL,
 210                                     _("Certificate Import Error"),
 211                                     _("X.509 certificate import failed"),
 212                                     secondary, NULL);
 213                 g_free(secondary);
 214         }
 215 }
 216
 217 static void
 218 tls_peers_mgmt_import_cb(GtkWidget *button, gpointer data)
 219 {
 220         /* TODO: need to tell the user that we want a .PEM file! */
 221         purple_request_file(tpm_dat,
 222                             _("Select a PEM certificate"),
 223                             "certificate.pem",
 224                             FALSE, /* Not a save dialog */
 225                             G_CALLBACK(tls_peers_mgmt_import_ok_cb),
 226                             NULL,  /* Do nothing if cancelled */
 227                             NULL, NULL); /* No extra parameters */
 228 }
 229
 230 static void
 231 tls_peers_mgmt_export_ok_cb(gpointer data, const char *filename)
 232 {
 233         GTlsCertificate *crt = data;
 234         gchar *pem = NULL;
 235         GError *error = NULL;
 236
 237         g_assert(filename);
 238
 239         g_object_get(crt, "certificate-pem", &pem, NULL);
 240
 241         if (!g_file_set_contents(filename, pem, -1, &error)) {
 242                 /* Errors! Oh no! */
 243                 /* TODO: Perhaps find a way to be specific about what just
 244                    went wrong? */
 245                 gchar * secondary;
 246
 247                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 248                                 "File %s couldn't be exported: %s",
 249                                 filename, error->message);
 250                 g_clear_error(&error);
 251
 252                 secondary = g_strdup_printf(_("Export to file %s failed.\nCheck that you have write permission to the target path\n"), filename);
 253                 purple_notify_error(NULL,
 254                                     _("Certificate Export Error"),
 255                                     _("X.509 certificate export failed"),
 256                                     secondary, NULL);
 257                 g_free(secondary);
 258         } else {
 259                 tls_peers_mgmt_repopulate_list();
 260         }
 261
 262         g_free(pem);
 263         g_object_unref(crt);
 264 }
 265
 266 static void
 267 tls_peers_mgmt_export_cb(GtkWidget *button, gpointer data)
 268 {
 269         GTlsCertificate *crt;
 270         GtkTreeSelection *select = tpm_dat->listselect;
 271         GtkTreeIter iter;
 272         GtkTreeModel *model;
 273         gchar *id;
 274         GError *error = NULL;
 275
 276         /* See if things are selected */
 277         if (!gtk_tree_selection_get_selected(select, &model, &iter)) {
 278                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 279                                      "Export clicked with no selection?\n");
 280                 return;
 281         }
 282
 283         /* Retrieve the selected hostname */
 284         gtk_tree_model_get(model, &iter, TPM_HOSTNAME_COLUMN, &id, -1);
 285
 286         /* Extract the certificate from the pool now to make sure it doesn't
 287            get deleted out from under us */
 288         crt = purple_tls_certificate_new_from_id(id, &error);
 289
 290         if (NULL == crt) {
 291                 purple_debug_error("gtkcertmgr/tls_peers_mgmt",
 292                                    "Error fetching trusted cert '%s': %s\n",
 293                                    id, error->message);
 294                 g_clear_error(&error);
 295                 g_free(id);
 296                 return;
 297         }
 298         g_free(id);
 299
 300         /* TODO: inform user that it will be a PEM? */
 301         purple_request_file(tpm_dat,
 302                             _("PEM X.509 Certificate Export"),
 303                             "certificate.pem",
 304                             TRUE, /* Is a save dialog */
 305                             G_CALLBACK(tls_peers_mgmt_export_ok_cb),
 306                             G_CALLBACK(g_object_unref),
 307                             NULL, /* No extra parameters */
 308                             crt); /* Pass the certificate on to the callback */
 309 }
 310
 311 static void
 312 tls_peers_mgmt_info_cb(GtkWidget *button, gpointer data)
 313 {
 314         GtkTreeSelection *select = tpm_dat->listselect;
 315         GtkTreeIter iter;
 316         GtkTreeModel *model;
 317         gchar *id;
 318         GTlsCertificate *crt;
 319         gchar *title;
 320         GError *error = NULL;
 321
 322         /* See if things are selected */
 323         if (!gtk_tree_selection_get_selected(select, &model, &iter)) {
 324                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 325                                      "Info clicked with no selection?\n");
 326                 return;
 327         }
 328
 329         /* Retrieve the selected hostname */
 330         gtk_tree_model_get(model, &iter, TPM_HOSTNAME_COLUMN, &id, -1);
 331
 332         /* Now retrieve the certificate */
 333         crt = purple_tls_certificate_new_from_id(id, &error);
 334
 335         if (crt == NULL) {
 336                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 337                                 "Unable to fetch certificate '%s': %s",
 338                                 id, error ? error->message : "unknown error");
 339                 g_clear_error(&error);
 340                 g_free(id);
 341         }
 342
 343         /* Fire the notification */
 344         title = g_strdup_printf(_("Certificate Information for %s"), id);
 345         purple_request_certificate(tpm_dat, title, NULL, NULL, crt,
 346                                    _("OK"), G_CALLBACK(g_object_unref),
 347                                    _("Cancel"), G_CALLBACK(g_object_unref),
 348                                    crt);
 349
 350         g_free(id);
 351         g_free(title);
 352 }
 353
 354 static void
 355 tls_peers_mgmt_activated_cb(GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer data)
 356 {
 357         tls_peers_mgmt_info_cb(NULL, NULL);
 358 }
 359
 360 static void
 361 tls_peers_mgmt_delete_confirm_cb(gchar *id, gint choice)
 362 {
 363         GError *error = NULL;
 364
 365         if (1 == choice) {
 366                 /* Yes, distrust was confirmed */
 367                 /* Now distrust the thing */
 368                 if (!purple_tls_certificate_distrust(id, &error)) {
 369                         purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 370                                              "Deletion failed on id %s: %s\n",
 371                                              id, error->message);
 372                         g_clear_error(&error);
 373                 } else {
 374                         tls_peers_mgmt_repopulate_list();
 375                 }
 376         }
 377
 378         g_free(id);
 379 }
 380
 381 static void
 382 tls_peers_mgmt_delete_cb(GtkWidget *button, gpointer data)
 383 {
 384         GtkTreeSelection *select = tpm_dat->listselect;
 385         GtkTreeIter iter;
 386         GtkTreeModel *model;
 387
 388         /* See if things are selected */
 389         if (gtk_tree_selection_get_selected(select, &model, &iter)) {
 390
 391                 gchar *id;
 392                 gchar *primary;
 393
 394                 /* Retrieve the selected hostname */
 395                 gtk_tree_model_get(model, &iter, TPM_HOSTNAME_COLUMN, &id, -1);
 396
 397                 /* Prompt to confirm deletion */
 398                 primary = g_strdup_printf(
 399                         _("Really delete certificate for %s?"), id );
 400
 401                 purple_request_yes_no(tpm_dat, _("Confirm certificate delete"),
 402                                       primary, NULL, /* Can this be NULL? */
 403                                       0, /* "yes" is the default action */
 404                                       NULL,
 405                                       id, /* id ownership passed to callback */
 406                                       tls_peers_mgmt_delete_confirm_cb,
 407                                       tls_peers_mgmt_delete_confirm_cb );
 408
 409                 g_free(primary);
 410
 411         } else {
 412                 purple_debug_warning("gtkcertmgr/tls_peers_mgmt",
 413                                      "Delete clicked with no selection?\n");
 414                 return;
 415         }
 416 }
 417
 418 static GtkWidget *
 419 tls_peers_mgmt_build(void)
 420 {
 421         GtkWidget *bbox;
 422         GtkListStore *store;
 423
 424         /* This block of variables will end up in tpm_dat */
 425         GtkTreeView *listview;
 426         GtkTreeSelection *select;
 427         GtkWidget *importbutton;
 428         GtkWidget *exportbutton;
 429         GtkWidget *infobutton;
 430         GtkWidget *deletebutton;
 431         /** Element to return to the Certmgr window to put in the Notebook */
 432         GtkWidget *mgmt_widget;
 433
 434         /* Create a struct to store context information about this window */
 435         tpm_dat = g_new0(tls_peers_mgmt_data, 1);
 436
 437         tpm_dat->mgmt_widget = mgmt_widget = gtk_box_new(
 438                 GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 439         gtk_container_set_border_width(GTK_CONTAINER(mgmt_widget),
 440                 PIDGIN_HIG_BOX_SPACE);
 441         gtk_widget_show(mgmt_widget);
 442
 443         /* Ensure that everything gets cleaned up when the dialog box
 444            is closed */
 445         g_signal_connect(G_OBJECT(mgmt_widget), "destroy",
 446                          G_CALLBACK(tls_peers_mgmt_destroy), NULL);
 447
 448         /* List view */
 449         store = gtk_list_store_new(TPM_N_COLUMNS, G_TYPE_STRING);
 450
 451         tpm_dat->listview = listview =
 452                 GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)));
 453         g_object_unref(G_OBJECT(store));
 454
 455         {
 456                 GtkCellRenderer *renderer;
 457                 GtkTreeViewColumn *column;
 458
 459                 /* Set up the display columns */
 460                 renderer = gtk_cell_renderer_text_new();
 461                 column = gtk_tree_view_column_new_with_attributes(
 462                         _("Hostname"),
 463                         renderer,
 464                         "text", TPM_HOSTNAME_COLUMN,
 465                         NULL);
 466                 gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);
 467
 468                 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
 469                                 TPM_HOSTNAME_COLUMN, GTK_SORT_ASCENDING);
 470         }
 471
 472         /* Get the treeview selector into the struct */
 473         tpm_dat->listselect = select =
 474                 gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
 475
 476         /* Force the selection mode */
 477         gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
 478
 479         /* Use a callback to enable/disable the buttons based on whether
 480            something is selected */
 481         g_signal_connect(G_OBJECT(select), "changed",
 482                          G_CALLBACK(tls_peers_mgmt_select_chg_cb), NULL);
 483
 484         g_signal_connect(G_OBJECT(listview), "row-activated",
 485                          G_CALLBACK(tls_peers_mgmt_activated_cb), NULL);
 486
 487         gtk_box_pack_start(GTK_BOX(mgmt_widget),
 488                         pidgin_make_scrollable(GTK_WIDGET(listview), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS, GTK_SHADOW_IN, -1, -1),
 489                         TRUE, TRUE, /* Take up lots of space */
 490                         0);
 491         gtk_widget_show(GTK_WIDGET(listview));
 492
 493         /* Fill the list for the first time */
 494         tls_peers_mgmt_repopulate_list();
 495
 496         /* Right-hand side controls box */
 497         bbox = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
 498         gtk_box_pack_end(GTK_BOX(mgmt_widget), bbox,
 499                          FALSE, FALSE, /* Do not take up space */
 500                          0);
 501         gtk_box_set_spacing(GTK_BOX(bbox), PIDGIN_HIG_BOX_SPACE);
 502         gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
 503         gtk_widget_show(bbox);
 504
 505         /* Import button */
 506         tpm_dat->importbutton = importbutton =
 507                 gtk_button_new_from_stock(GTK_STOCK_OPEN);
 508         gtk_box_pack_start(GTK_BOX(bbox), importbutton, FALSE, FALSE, 0);
 509         gtk_widget_show(importbutton);
 510         g_signal_connect(G_OBJECT(importbutton), "clicked",
 511                          G_CALLBACK(tls_peers_mgmt_import_cb), NULL);
 512
 513
 514         /* Export button */
 515         tpm_dat->exportbutton = exportbutton =
 516                 gtk_button_new_from_stock(GTK_STOCK_SAVE_AS);
 517         gtk_box_pack_start(GTK_BOX(bbox), exportbutton, FALSE, FALSE, 0);
 518         gtk_widget_show(exportbutton);
 519         g_signal_connect(G_OBJECT(exportbutton), "clicked",
 520                          G_CALLBACK(tls_peers_mgmt_export_cb), NULL);
 521
 522
 523         /* Info button */
 524         tpm_dat->infobutton = infobutton =
 525                 gtk_button_new_from_stock(PIDGIN_STOCK_INFO);
 526         gtk_box_pack_start(GTK_BOX(bbox), infobutton, FALSE, FALSE, 0);
 527         gtk_widget_show(infobutton);
 528         g_signal_connect(G_OBJECT(infobutton), "clicked",
 529                          G_CALLBACK(tls_peers_mgmt_info_cb), NULL);
 530
 531
 532         /* Delete button */
 533         tpm_dat->deletebutton = deletebutton =
 534                 gtk_button_new_from_stock(GTK_STOCK_DELETE);
 535         gtk_box_pack_start(GTK_BOX(bbox), deletebutton, FALSE, FALSE, 0);
 536         gtk_widget_show(deletebutton);
 537         g_signal_connect(G_OBJECT(deletebutton), "clicked",
 538                          G_CALLBACK(tls_peers_mgmt_delete_cb), NULL);
 539
 540         /* Call the "selection changed" callback, which will probably disable
 541            all the buttons since nothing is selected yet */
 542         tls_peers_mgmt_select_chg_cb(select, NULL);
 543
 544         return mgmt_widget;
 545 }
 546
 547 const PidginCertificateManager tls_peers_mgmt = {
 548         tls_peers_mgmt_build, /* Widget creation function */
 549         N_("SSL Servers")
 550 };
 551
 552 /*****************************************************************************
 553  * GTK+ main certificate manager                                             *
 554  *****************************************************************************/
 555 typedef struct
 556 {
 557         GtkWidget *window;
 558         GtkWidget *notebook;
 559
 560         GtkWidget *closebutton;
 561 } CertMgrDialog;
 562
 563 /* If a certificate manager window is open, this will point to it.
 564    So if it is set, don't open another one! */
 565 CertMgrDialog *certmgr_dialog = NULL;
 566
 567 static gboolean
 568 certmgr_close_cb(GtkWidget *w, CertMgrDialog *dlg)
 569 {
 570         /* TODO: Ignoring the arguments to this function may not be ideal,
 571            but there *should* only be "one dialog to rule them all" at a time*/
 572         pidgin_certmgr_hide();
 573         return FALSE;
 574 }
 575
 576 void
 577 pidgin_certmgr_show(void)
 578 {
 579         CertMgrDialog *dlg;
 580         GtkWidget *win;
 581         GtkWidget *vbox;
 582
 583         /* Enumerate all the certificates on file */
 584         {
 585                 GList *idlist;
 586                 GList *l;
 587
 588                 purple_debug_info("gtkcertmgr",
 589                                   "Enumerating X.509 certificates:\n");
 590
 591                 idlist = purple_tls_certificate_list_ids();
 592
 593                 for (l=idlist; l; l = l->next) {
 594                         purple_debug_info("gtkcertmgr",
 595                                           "- %s\n",
 596                                           l->data ? (gchar *) l->data : "(null)");
 597                 } /* idlist */
 598
 599                 purple_tls_certificate_free_ids(idlist);
 600         }
 601
 602
 603         /* If the manager is already open, bring it to the front */
 604         if (certmgr_dialog != NULL) {
 605                 gtk_window_present(GTK_WINDOW(certmgr_dialog->window));
 606                 return;
 607         }
 608
 609         /* Create the dialog, and set certmgr_dialog so we never create
 610            more than one at a time */
 611         dlg = certmgr_dialog = g_new0(CertMgrDialog, 1);
 612
 613         win = dlg->window =
 614                 pidgin_create_dialog(_("Certificate Manager"),/* Title */
 615                                      0, /*Window border*/
 616                                      "certmgr",         /* Role */
 617                                      TRUE); /* Allow resizing */
 618         g_signal_connect(G_OBJECT(win), "delete_event",
 619                          G_CALLBACK(certmgr_close_cb), dlg);
 620
 621
 622         /* TODO: Retrieve the user-set window size and use it */
 623         gtk_window_set_default_size(GTK_WINDOW(win), 400, 400);
 624
 625         /* Main vbox */
 626         vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(win), FALSE, PIDGIN_HIG_BORDER);
 627
 628         /* Notebook of various certificate managers */
 629         dlg->notebook = gtk_notebook_new();
 630         gtk_box_pack_start(GTK_BOX(vbox), dlg->notebook,
 631                            TRUE, TRUE, /* Notebook should take extra space */
 632                            0);
 633         gtk_widget_show(dlg->notebook);
 634
 635         /* Close button */
 636         dlg->closebutton = pidgin_dialog_add_button(GTK_DIALOG(win), GTK_STOCK_CLOSE,
 637                         G_CALLBACK(certmgr_close_cb), dlg);
 638
 639         /* Add the defined certificate managers */
 640         /* TODO: Find a way of determining whether each is shown or not */
 641         /* TODO: Implement this correctly */
 642         gtk_notebook_append_page(GTK_NOTEBOOK (dlg->notebook),
 643                                  (tls_peers_mgmt.build)(),
 644                                  gtk_label_new(_(tls_peers_mgmt.label)) );
 645
 646         gtk_widget_show(win);
 647 }
 648
 649 void
 650 pidgin_certmgr_hide(void)
 651 {
 652         /* If it isn't open, do nothing */
 653         if (certmgr_dialog == NULL) {
 654                 return;
 655         }
 656
 657         purple_signals_disconnect_by_handle(certmgr_dialog);
 658         purple_prefs_disconnect_by_handle(certmgr_dialog);
 659
 660         gtk_widget_destroy(certmgr_dialog->window);
 661         g_free(certmgr_dialog);
 662         certmgr_dialog = NULL;
 663 }