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