2006-02-21 [wwp] 2.0.0cvs69
[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         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 }