d1d46153df1edfb220ae90a99b712b9fd0363927
[claws.git] / src / plugins / pgpcore / select-keys.c
1 /* select-keys.c - GTK+ based key selection
2  *      Copyright (C) 2001 Werner Koch (dd9jn)
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 2 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, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  */
18
19 #ifdef HAVE_CONFIG_H
20 #  include <config.h>
21 #endif
22
23 #ifdef USE_GPGME
24 #include <stdio.h>
25 #include <stdlib.h>
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29 #include <gdk/gdkkeysyms.h>
30 #include <gtk/gtkmain.h>
31 #include <gtk/gtkwidget.h>
32 #include <gtk/gtkwindow.h>
33 #include <gtk/gtkscrolledwindow.h>
34 #include <gtk/gtkvbox.h>
35 #include <gtk/gtkhbox.h>
36 #include <gtk/gtkclist.h>
37 #include <gtk/gtklabel.h>
38 #include <gtk/gtkentry.h>
39 #include <gtk/gtkhbbox.h>
40 #include <gtk/gtkbutton.h>
41 #include <gtk/gtkstock.h>
42
43 #include "select-keys.h"
44 #include "utils.h"
45 #include "gtkutils.h"
46 #include "inputdialog.h"
47 #include "manage_window.h"
48 #include "alertpanel.h"
49
50 #define DIM(v) (sizeof(v)/sizeof((v)[0]))
51 #define DIMof(type,member)   DIM(((type *)0)->member)
52
53
54 enum col_titles { 
55     COL_ALGO,
56     COL_KEYID,
57     COL_NAME,
58     COL_EMAIL,
59     COL_VALIDITY,
60
61     N_COL_TITLES
62 };
63
64 struct select_keys_s {
65     int okay;
66     GtkWidget *window;
67     GtkLabel *toplabel;
68     GtkCList *clist;
69     const char *pattern;
70     unsigned int num_keys;
71     gpgme_key_t *kset;
72     gpgme_ctx_t select_ctx;
73
74     GtkSortType sort_type;
75     enum col_titles sort_column;
76     
77 };
78
79
80 static void set_row (GtkCList *clist, gpgme_key_t key);
81 static void fill_clist (struct select_keys_s *sk, const char *pattern);
82 static void create_dialog (struct select_keys_s *sk);
83 static void open_dialog (struct select_keys_s *sk);
84 static void close_dialog (struct select_keys_s *sk);
85 static gint delete_event_cb (GtkWidget *widget,
86                              GdkEventAny *event, gpointer data);
87 static gboolean key_pressed_cb (GtkWidget *widget,
88                                 GdkEventKey *event, gpointer data);
89 static void select_btn_cb (GtkWidget *widget, gpointer data);
90 static void cancel_btn_cb (GtkWidget *widget, gpointer data);
91 static void other_btn_cb (GtkWidget *widget, gpointer data);
92 static void sort_keys (struct select_keys_s *sk, enum col_titles column);
93 static void sort_keys_name (GtkWidget *widget, gpointer data);
94 static void sort_keys_email (GtkWidget *widget, gpointer data);
95
96 static gboolean use_untrusted (gpgme_key_t);
97
98 static void
99 update_progress (struct select_keys_s *sk, int running, const char *pattern)
100 {
101     static int windmill[] = { '-', '\\', '|', '/' };
102     char *buf;
103
104     if (!running)
105         buf = g_strdup_printf (_("Please select key for '%s'"),
106                                pattern);
107     else 
108         buf = g_strdup_printf (_("Collecting info for '%s' ... %c"),
109                                pattern,
110                                windmill[running%DIM(windmill)]);
111     gtk_label_set_text (sk->toplabel, buf);
112     g_free (buf);
113 }
114
115
116 /**
117  * gpgmegtk_recipient_selection:
118  * @recp_names: A list of email addresses
119  * 
120  * Select a list of recipients from a given list of email addresses.
121  * This may pop up a window to present the user a choice, it will also
122  * check that the recipients key are all valid.
123  * 
124  * Return value: NULL on error or a list of list of recipients.
125  **/
126 gpgme_key_t *
127 gpgmegtk_recipient_selection (GSList *recp_names)
128 {
129     struct select_keys_s sk;
130
131     memset (&sk, 0, sizeof sk);
132
133     open_dialog (&sk);
134
135     do {
136         sk.pattern = recp_names? recp_names->data:NULL;
137         gtk_clist_clear (sk.clist);
138         fill_clist (&sk, sk.pattern);
139         update_progress (&sk, 0, sk.pattern);
140         gtk_main ();
141         if (recp_names)
142             recp_names = recp_names->next;
143     } while (sk.okay && recp_names);
144
145     close_dialog (&sk);
146
147     if (!sk.okay) {
148         g_free(sk.kset);
149         sk.kset = NULL;
150     } else {
151         sk.kset = g_realloc(sk.kset, sizeof(gpgme_key_t) * (sk.num_keys + 1));
152         sk.kset[sk.num_keys] = NULL;
153     }
154     return sk.kset;
155
156
157 static void
158 destroy_key (gpointer data)
159 {
160     gpgme_key_t key = data;
161     gpgme_key_release (key);
162 }
163
164 static void
165 set_row (GtkCList *clist, gpgme_key_t key)
166 {
167     const char *s;
168     const char *text[N_COL_TITLES];
169     char *algo_buf;
170     int row;
171     gssize by_read = 0, by_written = 0;
172     gchar *ret_str;
173
174     /* first check whether the key is capable of encryption which is not
175      * the case for revoked, expired or sign-only keys */
176     if (!key->can_encrypt)
177         return;
178     algo_buf = g_strdup_printf ("%du/%s", 
179          key->subkeys->length,
180          gpgme_pubkey_algo_name(key->subkeys->pubkey_algo) );
181     text[COL_ALGO] = algo_buf;
182
183     s = key->subkeys->keyid;
184     if (strlen (s) == 16)
185         s += 8; /* show only the short keyID */
186     text[COL_KEYID] = s;
187
188     s = key->uids->name;
189     ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
190     if (ret_str && by_written) {
191         s = ret_str;
192     }
193     text[COL_NAME] = s;
194
195     s = key->uids->email;
196     ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
197     if (ret_str && by_written) {
198         s = ret_str;
199     }
200     text[COL_EMAIL] = s;
201
202     switch (key->uids->validity)
203       {
204       case GPGME_VALIDITY_UNDEFINED:
205         s = "q";
206         break;
207       case GPGME_VALIDITY_NEVER:
208         s = "n";
209         break;
210       case GPGME_VALIDITY_MARGINAL:
211         s = "m";
212         break;
213       case GPGME_VALIDITY_FULL:
214         s = "f";
215         break;
216       case GPGME_VALIDITY_ULTIMATE:
217         s = "u";
218         break;
219       case GPGME_VALIDITY_UNKNOWN:
220       default:
221         s = "?";
222         break;
223       }
224     text[COL_VALIDITY] = s;
225
226     row = gtk_clist_append (clist, (gchar**)text);
227     g_free (algo_buf);
228
229     gtk_clist_set_row_data_full (clist, row, key, destroy_key);
230 }
231
232 static void 
233 fill_clist (struct select_keys_s *sk, const char *pattern)
234 {
235     GtkCList *clist;
236     gpgme_ctx_t ctx;
237     gpgme_error_t err;
238     gpgme_key_t key;
239     int running=0;
240
241     g_return_if_fail (sk);
242     clist = sk->clist;
243     g_return_if_fail (clist);
244
245     debug_print ("select_keys:fill_clist:  pattern '%s'\n", pattern);
246
247     /*gtk_clist_freeze (select_keys.clist);*/
248     err = gpgme_new (&ctx);
249     g_assert (!err);
250
251     sk->select_ctx = ctx;
252
253     update_progress (sk, ++running, pattern);
254     while (gtk_events_pending ())
255         gtk_main_iteration ();
256
257     err = gpgme_op_keylist_start (ctx, pattern, 0);
258     if (err) {
259         debug_print ("** gpgme_op_keylist_start(%s) failed: %s",
260                      pattern, gpgme_strerror (err));
261         sk->select_ctx = NULL;
262         gpgme_release(ctx);
263         return;
264     }
265     update_progress (sk, ++running, pattern);
266     while ( !(err = gpgme_op_keylist_next ( ctx, &key )) ) {
267         debug_print ("%% %s:%d:  insert\n", __FILE__ ,__LINE__ );
268         set_row (clist, key ); key = NULL;
269         update_progress (sk, ++running, pattern);
270         while (gtk_events_pending ())
271             gtk_main_iteration ();
272     }
273     debug_print ("%% %s:%d:  ready\n", __FILE__ ,__LINE__ );
274     if (gpgme_err_code(err) != GPG_ERR_EOF) {
275         debug_print ("** gpgme_op_keylist_next failed: %s",
276                      gpgme_strerror (err));
277         gpgme_op_keylist_end(ctx);
278     }
279     sk->select_ctx = NULL;
280     gpgme_release (ctx);
281     /*gtk_clist_thaw (select_keys.clist);*/
282 }
283
284
285 static void 
286 create_dialog (struct select_keys_s *sk)
287 {
288     GtkWidget *window;
289     GtkWidget *vbox, *vbox2, *hbox;
290     GtkWidget *bbox;
291     GtkWidget *scrolledwin;
292     GtkWidget *clist;
293     GtkWidget *label;
294     GtkWidget *select_btn, *cancel_btn, *other_btn;
295     const char *titles[N_COL_TITLES];
296
297     g_assert (!sk->window);
298     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
299     gtk_widget_set_size_request (window, 520, 280);
300     gtk_container_set_border_width (GTK_CONTAINER (window), 8);
301     gtk_window_set_title (GTK_WINDOW (window), _("Select Keys"));
302     gtk_window_set_modal (GTK_WINDOW (window), TRUE);
303     g_signal_connect (G_OBJECT (window), "delete_event",
304                       G_CALLBACK (delete_event_cb), sk);
305     g_signal_connect (G_OBJECT (window), "key_press_event",
306                       G_CALLBACK (key_pressed_cb), sk);
307     MANAGE_WINDOW_SIGNALS_CONNECT (window);
308
309     vbox = gtk_vbox_new (FALSE, 8);
310     gtk_container_add (GTK_CONTAINER (window), vbox);
311
312     hbox  = gtk_hbox_new(FALSE, 4);
313     gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
314     label = gtk_label_new ( "" );
315     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
316
317     hbox = gtk_hbox_new (FALSE, 8);
318     gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
319     gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
320
321     scrolledwin = gtk_scrolled_window_new (NULL, NULL);
322     gtk_box_pack_start (GTK_BOX (hbox), scrolledwin, TRUE, TRUE, 0);
323     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
324                                     GTK_POLICY_AUTOMATIC,
325                                     GTK_POLICY_AUTOMATIC);
326
327     titles[COL_ALGO]     = _("Size");
328     titles[COL_KEYID]    = _("Key ID");
329     titles[COL_NAME]     = _("Name");
330     titles[COL_EMAIL]    = _("Address");
331     titles[COL_VALIDITY] = _("Val");
332
333     clist = gtk_clist_new_with_titles (N_COL_TITLES, (char**)titles);
334     gtk_container_add (GTK_CONTAINER (scrolledwin), clist);
335     gtk_clist_set_column_width (GTK_CLIST(clist), COL_ALGO,      72);
336     gtk_clist_set_column_width (GTK_CLIST(clist), COL_KEYID,     76);
337     gtk_clist_set_column_width (GTK_CLIST(clist), COL_NAME,     130);
338     gtk_clist_set_column_width (GTK_CLIST(clist), COL_EMAIL,    130);
339     gtk_clist_set_column_width (GTK_CLIST(clist), COL_VALIDITY,  20);
340     gtk_clist_set_selection_mode (GTK_CLIST(clist), GTK_SELECTION_BROWSE);
341     g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_NAME].button),
342                       "clicked",
343                       G_CALLBACK(sort_keys_name), sk);
344     g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_EMAIL].button),
345                       "clicked",
346                       G_CALLBACK(sort_keys_email), sk);
347
348     hbox = gtk_hbox_new (FALSE, 8);
349     gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
350
351     gtkut_stock_button_set_create (&bbox, 
352                                    &select_btn, _("Select"),
353                                    &cancel_btn, GTK_STOCK_CANCEL,
354                                    &other_btn,  _("Other"));
355     gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
356     gtk_widget_grab_default (select_btn);
357
358     g_signal_connect (G_OBJECT (select_btn), "clicked",
359                       G_CALLBACK (select_btn_cb), sk);
360     g_signal_connect (G_OBJECT(cancel_btn), "clicked",
361                       G_CALLBACK (cancel_btn_cb), sk);
362     g_signal_connect (G_OBJECT (other_btn), "clicked",
363                       G_CALLBACK (other_btn_cb), sk);
364
365     vbox2 = gtk_vbox_new (FALSE, 4);
366     gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
367
368     gtk_widget_show_all (window);
369
370     sk->window = window;
371     sk->toplabel = GTK_LABEL (label);
372     sk->clist  = GTK_CLIST (clist);
373 }
374
375
376 static void
377 open_dialog (struct select_keys_s *sk)
378 {
379     if (!sk->window)
380         create_dialog (sk);
381     manage_window_set_transient (GTK_WINDOW (sk->window));
382     sk->okay = 0;
383     sk->sort_column = N_COL_TITLES; /* use an invalid value */
384     sk->sort_type = GTK_SORT_ASCENDING;
385     gtk_widget_show (sk->window);
386 }
387
388
389 static void
390 close_dialog (struct select_keys_s *sk)
391 {
392     g_return_if_fail (sk);
393     gtk_widget_destroy (sk->window);
394     sk->window = NULL;
395 }
396
397
398 static gint
399 delete_event_cb (GtkWidget *widget, GdkEventAny *event, gpointer data)
400 {
401     struct select_keys_s *sk = data;
402
403     sk->okay = 0;
404     gtk_main_quit ();
405
406     return TRUE;
407 }
408
409
410 static gboolean
411 key_pressed_cb (GtkWidget *widget, GdkEventKey *event, gpointer data)
412 {
413     struct select_keys_s *sk = data;
414
415     g_return_val_if_fail (sk, FALSE);
416     if (event && event->keyval == GDK_Escape) {
417         sk->okay = 0;
418         gtk_main_quit ();
419     }
420     return FALSE;
421 }
422
423
424 static void 
425 select_btn_cb (GtkWidget *widget, gpointer data)
426 {
427     struct select_keys_s *sk = data;
428     int row;
429     gboolean use_key;
430     gpgme_key_t key;
431
432     g_return_if_fail (sk);
433     if (!sk->clist->selection) {
434         debug_print ("** nothing selected");
435         return;
436     }
437     row = GPOINTER_TO_INT(sk->clist->selection->data);
438     key = gtk_clist_get_row_data(sk->clist, row);
439     if (key) {
440         if ( key->uids->validity < GPGME_VALIDITY_FULL ) {
441             use_key = use_untrusted(key);
442             if (!use_key) {
443                 debug_print ("** Key untrusted, will not encrypt");
444                 return;
445             }
446         }
447         sk->kset = g_realloc(sk->kset,
448                 sizeof(gpgme_key_t) * (sk->num_keys + 1));
449         gpgme_key_ref(key);
450         sk->kset[sk->num_keys] = key;
451         sk->num_keys++;
452             sk->okay = 1;
453             gtk_main_quit ();
454     }
455 }
456
457
458 static void 
459 cancel_btn_cb (GtkWidget *widget, gpointer data)
460 {
461     struct select_keys_s *sk = data;
462
463     g_return_if_fail (sk);
464     sk->okay = 0;
465     if (sk->select_ctx)
466         gpgme_cancel (sk->select_ctx);
467     gtk_main_quit ();
468 }
469
470
471 static void
472 other_btn_cb (GtkWidget *widget, gpointer data)
473 {
474     struct select_keys_s *sk = data;
475     char *uid;
476
477     g_return_if_fail (sk);
478     uid = input_dialog ( _("Add key"),
479                          _("Enter another user or key ID:"),
480                          NULL );
481     if (!uid)
482         return;
483     fill_clist (sk, uid);
484     update_progress (sk, 0, sk->pattern);
485     g_free (uid);
486 }
487
488
489 static gboolean
490 use_untrusted (gpgme_key_t key)
491 {
492     AlertValue aval;
493
494     aval = alertpanel
495             (_("Trust key"),
496              _("The selected key is not fully trusted.\n"
497                "If you choose to encrypt the message with this key you don't\n"
498                "know for sure that it will go to the person you mean it to.\n"
499                "Do you trust it enough to use it anyway?"),
500              GTK_STOCK_YES, GTK_STOCK_NO, NULL);
501     if (aval == G_ALERTDEFAULT)
502         return TRUE;
503     else
504         return FALSE;
505 }
506
507
508 static gint 
509 cmp_name (GtkCList *clist, gconstpointer pa, gconstpointer pb)
510 {
511     gpgme_key_t a = ((GtkCListRow *)pa)->data;
512     gpgme_key_t b = ((GtkCListRow *)pb)->data;
513     const char *sa, *sb;
514     
515     sa = a? a->uids->name : NULL;
516     sb = b? b->uids->name : NULL;
517     if (!sa)
518         return !!sb;
519     if (!sb)
520         return -1;
521     return g_ascii_strcasecmp(sa, sb);
522 }
523
524 static gint 
525 cmp_email (GtkCList *clist, gconstpointer pa, gconstpointer pb)
526 {
527     gpgme_key_t a = ((GtkCListRow *)pa)->data;
528     gpgme_key_t b = ((GtkCListRow *)pb)->data;
529     const char *sa, *sb;
530     
531     sa = a? a->uids->email : NULL;
532     sb = b? b->uids->email : NULL;
533     if (!sa)
534         return !!sb;
535     if (!sb)
536         return -1;
537     return g_ascii_strcasecmp(sa, sb);
538 }
539
540 static void
541 sort_keys ( struct select_keys_s *sk, enum col_titles column)
542 {
543     GtkCList *clist = sk->clist;
544
545     switch (column) {
546       case COL_NAME:
547         gtk_clist_set_compare_func (clist, cmp_name);
548         break;
549       case COL_EMAIL:
550         gtk_clist_set_compare_func (clist, cmp_email);
551         break;
552       default:
553         return;
554     }
555
556     /* column clicked again: toggle as-/decending */
557     if ( sk->sort_column == column) {
558         sk->sort_type = sk->sort_type == GTK_SORT_ASCENDING ?
559                         GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
560     }
561     else
562         sk->sort_type = GTK_SORT_ASCENDING;
563
564     sk->sort_column = column;
565     gtk_clist_set_sort_type (clist, sk->sort_type);
566     gtk_clist_sort (clist);
567 }
568
569 static void
570 sort_keys_name (GtkWidget *widget, gpointer data)
571 {
572     sort_keys ((struct select_keys_s*)data, COL_NAME);
573 }
574
575 static void
576 sort_keys_email (GtkWidget *widget, gpointer data)
577 {
578     sort_keys ((struct select_keys_s*)data, COL_EMAIL);
579 }
580
581 #endif /*USE_GPGME*/