2008-12-15 [colin] 3.6.1cvs78
[claws.git] / src / plugins / pgpcore / passphrase.c
1 /* passphrase.c - GTK+ based passphrase callback
2  *      Copyright (C) 2001-2007 Werner Koch (dd9jn) and the Claws Mail team
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  * 
17  */
18
19 #ifdef HAVE_CONFIG_H
20 #  include <config.h>
21 #endif
22
23 #if USE_GPGME
24
25 #include <glib.h>
26 #include <glib/gi18n.h>
27 #include <gdk/gdk.h>
28 #include <gdk/gdkkeysyms.h>
29 #ifdef GDK_WINDOWING_X11
30 #  include <gdk/gdkx.h>
31 #endif /* GDK_WINDOWING_X11 */
32 #include <gtk/gtk.h> 
33 #include <string.h>
34 #include <sys/types.h>
35 #ifdef G_OS_WIN32
36 #include <w32lib.h>
37 #else
38 #include <sys/mman.h>
39 #endif
40
41 #include "passphrase.h"
42 #include "prefs_common.h"
43 #include "prefs_gpg.h"
44 #include "manage_window.h"
45 #include "utils.h"
46 #include "mainwindow.h"
47 #include "summaryview.h"
48
49 static gboolean grab_all = FALSE;
50
51 static gboolean pass_ack;
52 static gchar *last_pass = NULL;
53
54 static void passphrase_ok_cb(GtkWidget *widget, gpointer data);
55 static void passphrase_cancel_cb(GtkWidget *widget, gpointer data);
56 static gint passphrase_deleted(GtkWidget *widget, GdkEventAny *event,
57                                gpointer data);
58 static gboolean passphrase_key_pressed(GtkWidget *widget, GdkEventKey *event,
59                                        gpointer data);
60
61 static GtkWidget *create_description(const gchar *uid_hint,
62                                      const gchar *pass_hint, gint prev_bad, gint new_key);
63
64 void
65 gpgmegtk_set_passphrase_grab(gint yes)
66 {
67     grab_all = yes;
68 }
69
70 gchar*
71 passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad, gint new_key)
72 {
73     gchar *the_passphrase = NULL;
74     GtkWidget *vbox, *hbox;
75     GtkWidget *confirm_box;
76     GtkWidget *window;
77     GtkWidget *pass_entry;
78     GtkWidget *ok_button;
79     GtkWidget *cancel_button;
80
81     SummaryView *summaryview = mainwindow_get_mainwindow()->summaryview;
82     
83     gtk_menu_popdown(GTK_MENU(summaryview->popupmenu));
84
85     window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "passphrase");
86     gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
87     gtk_window_set_default_size(GTK_WINDOW(window), 375, 100);
88     gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
89     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
90     gtk_window_set_modal(GTK_WINDOW(window), TRUE);
91     g_signal_connect(G_OBJECT(window), "delete_event",
92                      G_CALLBACK(passphrase_deleted), NULL);
93     g_signal_connect(G_OBJECT(window), "key_press_event",
94                      G_CALLBACK(passphrase_key_pressed), NULL);
95     MANAGE_WINDOW_SIGNALS_CONNECT(window);
96     manage_window_set_transient(GTK_WINDOW(window));
97
98     vbox = gtk_vbox_new(FALSE, 8);
99     gtk_container_add(GTK_CONTAINER(window), vbox);
100     gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
101
102     if (uid_hint || pass_hint) {
103         GtkWidget *label, *icon;
104         label = create_description (uid_hint, pass_hint, prev_bad, new_key);
105         icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
106                                 GTK_ICON_SIZE_DIALOG); 
107
108         hbox = gtk_hbox_new (FALSE, 12);
109         gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
110         gtk_widget_show (hbox);
111         gtk_box_pack_start (GTK_BOX(hbox), icon, FALSE, FALSE, 0);
112         gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
113         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
114     }
115
116     pass_entry = gtk_entry_new();
117     gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0);
118     gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE);
119 #ifdef MAEMO
120     hildon_gtk_entry_set_input_mode(GTK_ENTRY(pass_entry), 
121         HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
122 #endif
123     gtk_widget_grab_focus(pass_entry);
124
125     gtkut_stock_button_set_create(&confirm_box, 
126                                   &cancel_button, GTK_STOCK_CANCEL,
127                                   &ok_button, GTK_STOCK_OK,
128                                   NULL, NULL);
129
130     gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
131     gtk_widget_grab_default(ok_button);
132
133     g_signal_connect(G_OBJECT(ok_button), "clicked",
134                      G_CALLBACK(passphrase_ok_cb), NULL);
135     g_signal_connect(G_OBJECT(pass_entry), "activate",
136                      G_CALLBACK(passphrase_ok_cb), NULL);
137     g_signal_connect(G_OBJECT(cancel_button), "clicked",
138                      G_CALLBACK(passphrase_cancel_cb), NULL);
139
140     gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
141     if (grab_all)   
142         gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
143     
144     gtk_widget_show_all(window);
145
146     if (grab_all) {
147         int err = 0, cnt = 0;
148         /* make sure that window is viewable */
149         gtk_widget_show_now(window);
150         gdk_window_process_updates(window->window, TRUE);
151         gdk_flush();
152         while(gtk_events_pending()) {
153                 gtk_main_iteration();
154         }
155 try_again:
156         if ((err = gdk_pointer_grab(window->window, TRUE, 0,
157                              window->window, NULL, GDK_CURRENT_TIME))) {
158             if (err == GDK_GRAB_NOT_VIEWABLE && cnt < 10) {
159                 cnt++;
160                 g_warning("trying to grab mouse again\n");
161                 gtk_main_iteration();
162                 goto try_again;
163             } else {
164                 g_warning("OOPS: Could not grab mouse\n");
165                 gtk_widget_destroy(window);
166                 return NULL;
167             }
168         }
169         if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
170             gdk_display_pointer_ungrab(gdk_display_get_default(),
171                                        GDK_CURRENT_TIME);
172             g_warning("OOPS: Could not grab keyboard\n");
173             gtk_widget_destroy(window);
174             return NULL;
175         }
176     }
177
178     gtk_main();
179
180     if (grab_all) {
181         gdk_display_keyboard_ungrab(gdk_display_get_default(),
182                                     GDK_CURRENT_TIME);
183         gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
184         gdk_flush();
185     }
186
187     manage_window_focus_out(window, NULL, NULL);
188
189     if (pass_ack) {
190         const gchar *entry_text;
191         entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
192         the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL);
193         if (the_passphrase == NULL) 
194             the_passphrase = g_strdup (entry_text);
195     }
196     gtk_widget_destroy (window);
197
198     return the_passphrase;
199 }
200
201
202 static void 
203 passphrase_ok_cb(GtkWidget *widget, gpointer data)
204 {
205     pass_ack = TRUE;
206     gtk_main_quit();
207 }
208
209 static void 
210 passphrase_cancel_cb(GtkWidget *widget, gpointer data)
211 {
212     pass_ack = FALSE;
213     gtk_main_quit();
214 }
215
216
217 static gint
218 passphrase_deleted(GtkWidget *widget, GdkEventAny *event, gpointer data)
219 {
220     passphrase_cancel_cb(NULL, NULL);
221     return TRUE;
222 }
223
224
225 static gboolean
226 passphrase_key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
227 {
228     if (event && event->keyval == GDK_Escape)
229         passphrase_cancel_cb(NULL, NULL);
230     return FALSE;
231 }
232
233 static gint 
234 linelen (const gchar *s)
235 {
236     gint i;
237
238     for (i = 0; *s && *s != '\n'; s++, i++)
239         ;
240
241     return i;
242 }
243
244 static GtkWidget *
245 create_description(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad, gint new_key)
246 {
247     const gchar *uid = NULL, *info = NULL;
248     gchar *buf;
249     GtkWidget *label;
250     gchar *my_uid = NULL;
251     if (!uid_hint)
252         uid = _("[no user id]");
253     else
254         uid = uid_hint;
255     if (!pass_hint)
256         info = "";
257     else
258         info = pass_hint;
259
260     my_uid = g_strdup(uid);
261     while (strchr(my_uid, '<')) 
262         *(strchr(my_uid, '<')) = '(';
263     while (strchr(my_uid, '>')) 
264         *(strchr(my_uid, '>')) = ')';
265
266     if (new_key == 1) {
267             buf = g_strdup_printf (_("<span weight=\"bold\" size=\"larger\">%sPlease enter the passphrase for the new key:</span>\n\n"
268                            "%.*s\n"),
269                            prev_bad ?
270                            _("Passphrases did not match.\n") : "",
271                            linelen (my_uid), my_uid);
272     } else if (new_key == 2) {
273             buf = g_strdup_printf (_("<span weight=\"bold\" size=\"larger\">Please re-enter the passphrase for the new key:</span>\n\n"
274                            "%.*s\n"),
275                            linelen (my_uid), my_uid);
276     } else {
277             buf = g_strdup_printf (_("<span weight=\"bold\" size=\"larger\">%sPlease enter the passphrase for:</span>\n\n"
278                            "%.*s\n"),
279                            prev_bad ?
280                            _("Bad passphrase.\n") : "",
281                            linelen (my_uid), my_uid);
282     }
283     g_free(my_uid);
284     label = gtk_label_new (buf);
285     gtk_label_set_use_markup(GTK_LABEL (label), TRUE);
286     gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
287     gtk_label_set_line_wrap(GTK_LABEL (label), TRUE);
288     g_free (buf);
289
290     return label;
291 }
292
293 static int free_passphrase(gpointer _unused)
294 {
295     if (last_pass != NULL) {
296 #ifndef G_PLATFORM_WIN32
297         munlock(last_pass, strlen(last_pass));
298 #endif
299         g_free(last_pass);
300         last_pass = NULL;
301         debug_print("%% passphrase removed\n");
302     }
303     
304     return FALSE;
305 }
306
307 gpgme_error_t
308 gpgmegtk_passphrase_cb(void *opaque, const char *uid_hint,
309         const char *passphrase_hint, int prev_bad, int fd)
310 {
311     char *pass = NULL;
312
313     if (prefs_gpg_get_config()->store_passphrase && last_pass && !prev_bad)
314         pass = g_strdup(last_pass);
315     else {
316         gpgmegtk_set_passphrase_grab (prefs_gpg_get_config()->passphrase_grab);
317         debug_print ("%% requesting passphrase for '%s'\n ", uid_hint);
318         pass = passphrase_mbox (uid_hint, passphrase_hint, prev_bad, FALSE);
319         gpgmegtk_free_passphrase();
320         if (!pass) {
321             debug_print ("%% cancel passphrase entry\n");
322             write(fd, "\n", 1);
323             return GPG_ERR_CANCELED;
324         }
325         else {
326             if (prefs_gpg_get_config()->store_passphrase) {
327                 last_pass = g_strdup(pass);
328 #ifndef G_PLATFORM_WIN32
329                 if (mlock(last_pass, strlen(last_pass)) == -1)
330                     debug_print("%% locking passphrase failed\n");
331 #endif
332                 if (prefs_gpg_get_config()->store_passphrase_timeout > 0) {
333                         g_timeout_add(prefs_gpg_get_config()
334                                       ->store_passphrase_timeout*60*1000,
335                                       free_passphrase, NULL);
336                 }
337             }
338             debug_print ("%% sending passphrase\n");
339         }
340     }
341
342 #ifdef G_OS_WIN32
343     {
344         /* Under Windows FD is actually a System handle. */
345         DWORD nwritten;
346         WriteFile ((HANDLE)fd, pass, strlen (pass), &nwritten, NULL);
347         WriteFile ((HANDLE)fd, "\n", 1, &nwritten, NULL);
348     }
349 #else
350     write(fd, pass, strlen(pass));
351     write(fd, "\n", 1);
352 #endif
353     g_free(pass);
354
355     return GPG_ERR_NO_ERROR;
356 }
357
358 void gpgmegtk_free_passphrase()
359 {
360     (void)free_passphrase(NULL); /* could be inline */
361 }
362
363 #endif /* USE_GPGME */