2006-02-15 [wwp] 2.0.0cvs51
[claws.git] / 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 }