Add ManageSieve plugin
[claws.git] / src / plugins / managesieve / sieve_prefs.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2004-2015 the Claws Mail team
4  * Copyright (C) 2014-2015 Charles Lehner
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18  * 
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #include "claws-features.h"
24 #endif
25
26 #include <gtk/gtk.h>
27 #include <glib.h>
28 #include <glib/gi18n.h>
29
30 #include "defs.h"
31 #include "gtk/gtkutils.h"
32 #include "gtk/combobox.h"
33 #include "alertpanel.h"
34 #include "passcrypt.h"
35 #include "utils.h"
36 #include "prefs.h"
37 #include "prefs_gtk.h"
38 #include "sieve_prefs.h"
39 #include "managesieve.h"
40
41 #define PACK_HBOX(hbox, vbox) \
42 { \
43         hbox = gtk_hbox_new (FALSE, 5); \
44         gtk_widget_show (hbox); \
45         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); \
46 }
47
48 #define RADIO_ADD(radio, group, hbox, vbox, label) \
49 { \
50         PACK_HBOX(hbox, vbox); \
51         gtk_container_set_border_width(GTK_CONTAINER (hbox), 0); \
52         radio = gtk_radio_button_new_with_label(group, label); \
53         group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio)); \
54         gtk_widget_show(radio); \
55         gtk_box_pack_start(GTK_BOX(hbox), radio, FALSE, FALSE, 0); \
56 }
57
58 struct SieveAccountPage
59 {
60         PrefsPage page;
61
62         GtkWidget *enable_checkbtn;
63         GtkWidget *serv_frame;
64         GtkWidget *auth_frame;
65         GtkWidget *host_checkbtn, *host_entry;
66         GtkWidget *port_checkbtn, *port_spinbtn;
67         GtkWidget *tls_radio_no, *tls_radio_maybe, *tls_radio_yes;
68         GtkWidget *auth_radio_noauth, *auth_radio_reuse, *auth_radio_custom;
69         GtkWidget *auth_custom_vbox, *auth_method_hbox;
70         GtkWidget *uid_entry;
71         GtkWidget *pass_entry;
72         GtkWidget *auth_menu;
73
74         PrefsAccount *account;
75 };
76
77 static struct SieveAccountPage account_page;
78
79 static void update_auth_sensitive(struct SieveAccountPage *page)
80 {
81         gboolean use_auth, custom;
82
83         custom = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->auth_radio_custom));
84         use_auth = custom || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->auth_radio_reuse));
85
86         gtk_widget_set_sensitive(GTK_WIDGET(page->auth_custom_vbox), custom);
87         gtk_widget_set_sensitive(GTK_WIDGET(page->auth_method_hbox), use_auth);
88 }
89
90 static void auth_toggled(GtkToggleButton *togglebutton,
91                 gpointer user_data)
92 {
93         struct SieveAccountPage *page = (struct SieveAccountPage *) user_data;
94         update_auth_sensitive(page);
95 }
96
97 static void sieve_prefs_account_create_widget_func(PrefsPage *_page,
98                                                  GtkWindow *window,
99                                                  gpointer data)
100 {
101         struct SieveAccountPage *page = (struct SieveAccountPage *) _page;
102         PrefsAccount *account = (PrefsAccount *) data;
103         SieveAccountConfig *config;
104
105         GtkWidget *page_vbox, *sieve_vbox;
106         GtkWidget *hbox;
107         GtkWidget *hbox_spc;
108
109         GtkWidget *enable_checkbtn;
110         GtkWidget *serv_vbox, *tls_frame;
111         GtkWidget *tls_vbox, *serv_frame;
112         GtkWidget *auth_vbox, *auth_frame;
113         GtkWidget *auth_custom_vbox, *auth_method_hbox;
114         GtkSizeGroup *size_group;
115         GtkWidget *host_checkbtn, *host_entry;
116         GtkWidget *port_checkbtn, *port_spinbtn;
117         GSList *tls_group = NULL;
118         GSList *auth_group = NULL;
119         GtkWidget *tls_radio_no, *tls_radio_maybe, *tls_radio_yes;
120         GtkWidget *auth_radio_noauth, *auth_radio_reuse, *auth_radio_custom;
121         GtkWidget *label;
122         GtkWidget *uid_entry;
123         GtkWidget *pass_entry;
124         GtkWidget *auth_menu;
125         GtkListStore *menu;
126         GtkTreeIter iter;
127
128         page_vbox = gtk_vbox_new (FALSE, VSPACING);
129         gtk_widget_show (page_vbox);
130         gtk_container_set_border_width (GTK_CONTAINER (page_vbox), VBOX_BORDER);
131
132         /* Enable/disable */
133         PACK_CHECK_BUTTON (page_vbox, enable_checkbtn,
134                            _("Enable Sieve"));
135
136         sieve_vbox = gtk_vbox_new (FALSE, VSPACING);
137         gtk_widget_show (sieve_vbox);
138         gtk_box_pack_start (GTK_BOX (page_vbox), sieve_vbox, FALSE, FALSE, 0);
139
140         /* Server info */
141         serv_vbox = gtkut_get_options_frame(sieve_vbox, &serv_frame, _("Server information"));
142         gtk_widget_show (serv_vbox);
143         gtk_box_pack_start (GTK_BOX (page_vbox), serv_vbox, FALSE, FALSE, 0);
144
145         SET_TOGGLE_SENSITIVITY (enable_checkbtn, sieve_vbox);
146         size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
147
148         /* Server name */
149         PACK_HBOX (hbox, serv_vbox);
150         PACK_CHECK_BUTTON (hbox, host_checkbtn, _("Server name"));
151         gtk_size_group_add_widget(size_group, host_checkbtn);
152
153         host_entry = gtk_entry_new();
154         gtk_widget_show (host_entry);
155         gtk_box_pack_start (GTK_BOX (hbox), host_entry, TRUE, TRUE, 0);
156         SET_TOGGLE_SENSITIVITY (host_checkbtn, host_entry);
157         CLAWS_SET_TIP(hbox,
158                 _("Connect to this host instead of the host used for receiving mail"));
159
160         /* Port */
161         PACK_HBOX (hbox, serv_vbox);
162         PACK_CHECK_BUTTON (hbox, port_checkbtn, _("Server port"));
163         port_spinbtn = gtk_spin_button_new_with_range(1, 65535, 1);
164         gtk_widget_show (port_spinbtn);
165         gtk_box_pack_start (GTK_BOX (hbox), port_spinbtn, FALSE, FALSE, 0);
166         SET_TOGGLE_SENSITIVITY (port_checkbtn, port_spinbtn);
167         gtk_size_group_add_widget(size_group, port_checkbtn);
168         CLAWS_SET_TIP(hbox,
169                 _("Connect to this port instead of the default"));
170
171         /* Encryption */
172
173         tls_vbox = gtkut_get_options_frame(sieve_vbox, &tls_frame, _("Encryption"));
174         gtk_widget_show (tls_vbox);
175         gtk_box_pack_start (GTK_BOX (page_vbox), tls_vbox, FALSE, FALSE, 0);
176
177         RADIO_ADD(tls_radio_no, tls_group, hbox, tls_vbox,
178                         _("No TLS"));
179         RADIO_ADD(tls_radio_maybe, tls_group, hbox, tls_vbox,
180                         _("Use TLS when available"));
181         RADIO_ADD(tls_radio_yes, tls_group, hbox, tls_vbox,
182                         _("Require TLS"));
183
184         /* Authentication */
185
186         auth_vbox = gtkut_get_options_frame(sieve_vbox, &auth_frame,
187                         _("Authentication"));
188
189         RADIO_ADD(auth_radio_noauth, auth_group, hbox, auth_vbox,
190                 _("No authentication"));
191         RADIO_ADD(auth_radio_reuse, auth_group, hbox, auth_vbox,
192                 _("Use same authentication as for receiving mail"));
193         RADIO_ADD(auth_radio_custom, auth_group, hbox, auth_vbox,
194                 _("Specify authentication"));
195
196         g_signal_connect(G_OBJECT(auth_radio_custom), "toggled",
197                         G_CALLBACK(auth_toggled), page);
198         g_signal_connect(G_OBJECT(auth_radio_reuse), "toggled",
199                         G_CALLBACK(auth_toggled), page);
200
201         /* Custom Auth Settings */
202
203         hbox = gtk_hbox_new (FALSE, 0);
204         gtk_widget_show (hbox);
205         gtk_box_pack_start (GTK_BOX (auth_vbox), hbox, FALSE, FALSE, 0);
206
207         hbox_spc = gtk_hbox_new (FALSE, 0);
208         gtk_widget_show (hbox_spc);
209         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
210         gtk_widget_set_size_request (hbox_spc, 12, -1);
211
212         auth_custom_vbox = gtk_vbox_new (FALSE, VSPACING/2);
213         gtk_widget_show (auth_custom_vbox);
214         gtk_container_set_border_width (GTK_CONTAINER (auth_custom_vbox), 0);
215         gtk_box_pack_start (GTK_BOX (hbox), auth_custom_vbox, TRUE, TRUE, 0);
216
217         /* User ID + Password */
218
219         hbox = gtk_hbox_new (FALSE, 8);
220         gtk_widget_show (hbox);
221         gtk_box_pack_start (GTK_BOX (auth_custom_vbox), hbox, FALSE, FALSE, 0);
222
223         /* User ID*/
224         label = gtk_label_new (_("User ID"));
225         gtk_widget_show (label);
226         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
227
228         uid_entry = gtk_entry_new ();
229         gtk_widget_show (uid_entry);
230         gtk_widget_set_size_request (uid_entry, DEFAULT_ENTRY_WIDTH, -1);
231         gtk_box_pack_start (GTK_BOX (hbox), uid_entry, TRUE, TRUE, 0);
232
233         /* Password */
234         label = gtk_label_new (_("Password"));
235         gtk_widget_show (label);
236         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
237
238         pass_entry = gtk_entry_new ();
239         gtk_widget_show (pass_entry);
240         gtk_widget_set_size_request (pass_entry, DEFAULT_ENTRY_WIDTH, -1);
241         gtk_entry_set_visibility (GTK_ENTRY (pass_entry), FALSE);
242         gtk_box_pack_start (GTK_BOX (hbox), pass_entry, TRUE, TRUE, 0);
243
244         /* Authentication method */
245
246         auth_method_hbox = gtk_hbox_new (FALSE, 8);
247         gtk_widget_show (auth_method_hbox);
248         gtk_box_pack_start (GTK_BOX (auth_vbox), auth_method_hbox, FALSE, FALSE, 0);
249
250         label = gtk_label_new (_("Authentication method"));
251         gtk_widget_show (label);
252         gtk_box_pack_start (GTK_BOX (auth_method_hbox), label, FALSE, FALSE, 0);
253
254         auth_menu = gtkut_sc_combobox_create(NULL, FALSE);
255         menu = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(auth_menu)));
256         gtk_widget_show (auth_menu);
257         gtk_box_pack_start (GTK_BOX (auth_method_hbox), auth_menu, FALSE, FALSE, 0);
258
259         COMBOBOX_ADD (menu, _("Automatic"), SIEVEAUTH_AUTO);
260         COMBOBOX_ADD (menu, NULL, 0);
261         COMBOBOX_ADD (menu, "PLAIN", SIEVEAUTH_PLAIN);
262         COMBOBOX_ADD (menu, "LOGIN", SIEVEAUTH_LOGIN);
263         COMBOBOX_ADD (menu, "CRAM-MD5", SIEVEAUTH_CRAM_MD5);
264
265         /* Populate config */
266
267         config = sieve_prefs_account_get_config(account);
268
269         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_checkbtn), config->enable);
270         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(host_checkbtn), config->use_host);
271         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(port_checkbtn), config->use_port);
272         gtk_spin_button_set_value(GTK_SPIN_BUTTON(port_spinbtn), (float) config->port);
273
274         if (config->host != NULL)
275                 gtk_entry_set_text(GTK_ENTRY(host_entry), config->host);
276         if (config->userid != NULL)
277                 gtk_entry_set_text(GTK_ENTRY(uid_entry), config->userid);
278         if (config->passwd != NULL)
279                 gtk_entry_set_text(GTK_ENTRY(pass_entry), config->passwd);
280
281         combobox_select_by_data(GTK_COMBO_BOX(auth_menu), config->auth_type);
282
283         /* Add items to page struct */
284         page->account = account;
285         page->enable_checkbtn = enable_checkbtn;
286         page->serv_frame = serv_frame;
287         page->auth_frame = auth_frame;
288         page->auth_custom_vbox = auth_custom_vbox;
289         page->auth_method_hbox = auth_method_hbox;
290         page->host_checkbtn = host_checkbtn;
291         page->host_entry = host_entry;
292         page->port_checkbtn = port_checkbtn;
293         page->port_spinbtn = port_spinbtn;
294         page->auth_radio_noauth = auth_radio_noauth;
295         page->auth_radio_reuse = auth_radio_reuse;
296         page->auth_radio_custom = auth_radio_custom;
297         page->tls_radio_no = tls_radio_no;
298         page->tls_radio_maybe = tls_radio_maybe;
299         page->tls_radio_yes = tls_radio_yes;
300         page->uid_entry = uid_entry;
301         page->pass_entry = pass_entry;
302         page->auth_menu = auth_menu;
303         page->page.widget = page_vbox;
304
305         /* Update things */
306
307         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
308                                 config->tls_type == SIEVE_TLS_NO ? tls_radio_no :
309                                 config->tls_type == SIEVE_TLS_MAYBE ? tls_radio_maybe :
310                                 tls_radio_yes), TRUE);
311
312         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
313                                 config->auth == SIEVEAUTH_REUSE ? auth_radio_reuse :
314                                 config->auth == SIEVEAUTH_CUSTOM ? auth_radio_custom :
315                                 auth_radio_noauth), TRUE);
316
317         update_auth_sensitive(page);
318
319         /* Free things */
320         g_object_unref(G_OBJECT(size_group));
321 }
322
323 static void sieve_prefs_account_destroy_widget_func(PrefsPage *_page)
324 {
325 }
326
327 static gint sieve_prefs_account_apply(struct SieveAccountPage *page)
328 {
329         SieveAccountConfig *config;
330
331         config = sieve_prefs_account_get_config(page->account);
332
333         config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_checkbtn));
334         config->use_port = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->port_checkbtn));
335         config->use_host = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->host_checkbtn));
336         config->port = (gushort)gtk_spin_button_get_value_as_int
337                         (GTK_SPIN_BUTTON(page->port_spinbtn));
338
339         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->auth_radio_noauth)))
340                 config->auth = SIEVEAUTH_NONE;
341         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->auth_radio_reuse)))
342                 config->auth = SIEVEAUTH_REUSE;
343         else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->auth_radio_custom)))
344                 config->auth = SIEVEAUTH_CUSTOM;
345
346         config->tls_type =
347                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->tls_radio_no)) ?
348                         SIEVE_TLS_NO :
349                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->tls_radio_maybe)) ?
350                         SIEVE_TLS_MAYBE :
351                         SIEVE_TLS_YES;
352
353         config->host = gtk_editable_get_chars(GTK_EDITABLE(page->host_entry), 0, -1);
354         config->userid = gtk_editable_get_chars(GTK_EDITABLE(page->uid_entry), 0, -1);
355         config->passwd = gtk_editable_get_chars(GTK_EDITABLE(page->pass_entry), 0, -1);
356         config->auth_type = combobox_get_active_data(GTK_COMBO_BOX(page->auth_menu));
357
358         sieve_prefs_account_set_config(page->account, config);
359         sieve_prefs_account_free_config(config);
360         return TRUE;
361 }
362
363 static gboolean sieve_prefs_account_check(struct SieveAccountPage *page)
364 {
365         if (strchr(gtk_entry_get_text(GTK_ENTRY(page->host_entry)), ' ')) {
366                 alertpanel_error(_("Sieve server must not contain a space."));
367                 return FALSE;
368         }
369
370         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->host_checkbtn)) &&
371                         *gtk_entry_get_text(GTK_ENTRY(page->host_entry)) == '\0') {
372                 alertpanel_error(_("Sieve server is not entered."));
373                 return FALSE;
374         }
375
376         return TRUE;
377 }
378
379 static void sieve_prefs_account_save_func(PrefsPage *_page)
380 {
381         struct SieveAccountPage *page = (struct SieveAccountPage *) _page;
382         if (sieve_prefs_account_check(page)) {
383                 sieve_prefs_account_apply(page);
384         }
385 }
386
387 static gboolean sieve_prefs_account_can_close(PrefsPage *_page)
388 {
389         struct SieveAccountPage *page = (struct SieveAccountPage *) _page;
390         return sieve_prefs_account_check(page);
391 }
392
393 void sieve_prefs_init()
394 {
395         static gchar *path[3];
396         path[0] = _("Plugins");
397         path[1] = _("Sieve");
398         path[2] = NULL;
399
400         account_page.page.path = path;
401         account_page.page.create_widget = sieve_prefs_account_create_widget_func;
402         account_page.page.destroy_widget = sieve_prefs_account_destroy_widget_func;
403         account_page.page.save_page = sieve_prefs_account_save_func;
404         account_page.page.can_close = sieve_prefs_account_can_close;
405         account_page.page.weight = 30.0;
406         prefs_account_register_page((PrefsPage *) &account_page);
407 }
408
409 void sieve_prefs_done(void)
410 {
411         prefs_account_unregister_page((PrefsPage *) &account_page);
412 }
413
414 struct SieveAccountConfig *sieve_prefs_account_get_config(
415                 PrefsAccount *account)
416 {
417         SieveAccountConfig *config;
418         const gchar *confstr;
419         gchar enc_userid[256], enc_passwd[256];
420         gchar enable, use_host, use_port;
421         gsize len;
422
423         config = g_new0(SieveAccountConfig, 1);
424
425         config->enable = FALSE;
426         config->use_host = FALSE;
427         config->host = NULL;
428         config->use_port = FALSE;
429         config->port = 4190;
430         config->tls_type = SIEVE_TLS_YES;
431         config->auth = SIEVEAUTH_REUSE;
432         config->auth_type = SIEVEAUTH_AUTO;
433         config->userid = NULL;
434         config->passwd = NULL;
435
436         confstr = prefs_account_get_privacy_prefs(account, "sieve");
437         if (confstr == NULL)
438                 return config;
439
440
441         sscanf(confstr, "%c%c %ms %c%hu %hhu %hhu %hhu %256s %256s",
442                         &enable, &use_host,
443                         &config->host,
444                         &use_port, &config->port,
445                         (char *)&config->tls_type,
446                         (char *)&config->auth,
447                         (char *)&config->auth_type,
448                         enc_userid,
449                         enc_passwd);
450
451         config->enable = enable == 'y';
452         config->use_host = use_host == 'y';
453         config->use_port = use_port == 'y';
454
455         if (config->host[0] == '!' && !config->host[1]) {
456                 g_free(config->host);
457                 config->host = NULL;
458         }
459
460         config->userid = g_base64_decode(enc_userid, &len);
461         config->passwd = g_base64_decode(enc_passwd, &len);
462         passcrypt_decrypt(config->passwd, len);
463
464         return config;
465 }
466
467 void sieve_prefs_account_set_config(
468                 PrefsAccount *account, SieveAccountConfig *config)
469 {
470         gchar *confstr = NULL;
471         gchar *enc_userid = NULL;
472         gchar *enc_passwd = NULL;
473         gchar *tmp;
474         gsize len;
475
476         if (config->userid) {
477                 len = strlen(config->userid);
478                 enc_userid = g_base64_encode(config->userid, len);
479         }
480
481         if (config->passwd) {
482                 tmp = g_strdup(config->passwd);
483                 len = strlen(tmp);
484                 passcrypt_encrypt(tmp, len);
485                 enc_passwd = g_base64_encode(tmp, len);
486                 g_free(tmp);
487         }
488
489         confstr = g_strdup_printf("%c%c %s %c%hu %hhu %hhu %hhu %s %s",
490                         config->enable ? 'y' : 'n',
491                         config->use_host ? 'y' : 'n',
492                         config->host && config->host[0] ? config->host : "!",
493                         config->use_port ? 'y' : 'n',
494                         config->port,
495                         config->tls_type,
496                         config->auth,
497                         config->auth_type,
498                         enc_userid ? enc_userid : "",
499                         enc_passwd ? enc_passwd : "");
500
501         if (enc_userid)
502                 g_free(enc_userid);
503         if (enc_passwd)
504                 g_free(enc_passwd);
505
506         prefs_account_set_privacy_prefs(account, "sieve", confstr);
507
508         g_free(confstr);
509
510         sieve_account_prefs_updated(account);
511 }
512
513 void sieve_prefs_account_free_config(SieveAccountConfig *config)
514 {
515         g_free(config->host);
516         g_free(config->userid);
517         g_free(config->passwd);
518         g_free(config);
519 }
520