/* select-keys.c - GTK+ based key selection
- * Copyright (C) 2001-2006 Werner Koch (dd9jn) and the Sylpheed-Claws team
+ * Copyright (C) 2001-2012 Werner Koch (dd9jn) and the Claws Mail team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
*/
#ifdef HAVE_CONFIG_H
#include <glib.h>
#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>
-#include <gtk/gtkmain.h>
-#include <gtk/gtkwidget.h>
-#include <gtk/gtkwindow.h>
-#include <gtk/gtkscrolledwindow.h>
-#include <gtk/gtkvbox.h>
-#include <gtk/gtkhbox.h>
-#include <gtk/gtkclist.h>
-#include <gtk/gtklabel.h>
-#include <gtk/gtkentry.h>
-#include <gtk/gtkhbbox.h>
-#include <gtk/gtkbutton.h>
-#include <gtk/gtkstock.h>
-
+#include <gtk/gtk.h>
#include "select-keys.h"
#include "utils.h"
#include "gtkutils.h"
int okay;
GtkWidget *window;
GtkLabel *toplabel;
- GtkCList *clist;
+ GtkCMCList *clist;
const char *pattern;
unsigned int num_keys;
gpgme_key_t *kset;
gpgme_ctx_t select_ctx;
-
+ gpgme_protocol_t proto;
GtkSortType sort_type;
enum col_titles sort_column;
SelectionResult result;
};
-static void set_row (GtkCList *clist, gpgme_key_t key);
-static void fill_clist (struct select_keys_s *sk, const char *pattern);
+static void set_row (GtkCMCList *clist, gpgme_key_t key, gpgme_protocol_t proto);
+static gpgme_key_t fill_clist (struct select_keys_s *sk, const char *pattern,
+ gpgme_protocol_t proto);
static void create_dialog (struct select_keys_s *sk);
static void open_dialog (struct select_keys_s *sk);
static void close_dialog (struct select_keys_s *sk);
static void sort_keys_name (GtkWidget *widget, gpointer data);
static void sort_keys_email (GtkWidget *widget, gpointer data);
-static gboolean use_untrusted (gpgme_key_t);
+static gboolean use_untrusted (gpgme_key_t, gpgme_user_id_t uid, gpgme_protocol_t proto);
static void
update_progress (struct select_keys_s *sk, int running, const char *pattern)
char *buf;
if (!running)
- buf = g_strdup_printf (_("Please select key for '%s'"),
+ buf = g_strdup_printf (_("No exact match for '%s'; please select the key."),
pattern);
else
buf = g_strdup_printf (_("Collecting info for '%s' ... %c"),
* Return value: NULL on error or a list of list of recipients.
**/
gpgme_key_t *
-gpgmegtk_recipient_selection (GSList *recp_names, SelectionResult *result)
+gpgmegtk_recipient_selection (GSList *recp_names, SelectionResult *result,
+ gpgme_protocol_t proto)
{
struct select_keys_s sk;
-
+ gpgme_key_t key = NULL;
memset (&sk, 0, sizeof sk);
open_dialog (&sk);
do {
sk.pattern = recp_names? recp_names->data:NULL;
- gtk_clist_clear (sk.clist);
- fill_clist (&sk, sk.pattern);
+ sk.proto = proto;
+ gtk_cmclist_clear (sk.clist);
+ key = fill_clist (&sk, sk.pattern, proto);
update_progress (&sk, 0, sk.pattern);
- gtk_main ();
+ if (!key) {
+ gtk_widget_show_all (sk.window);
+ gtk_main ();
+ } else {
+ gtk_widget_hide (sk.window);
+ sk.kset = g_realloc(sk.kset,
+ sizeof(gpgme_key_t) * (sk.num_keys + 1));
+ gpgme_key_ref(key);
+ sk.kset[sk.num_keys] = key;
+ sk.num_keys++;
+ sk.okay = 1;
+ sk.result = KEY_SELECTION_OK;
+ gpgme_release (sk.select_ctx);
+ sk.select_ctx = NULL;
+ debug_print("used %s\n", key->uids->email);
+ }
+ key = NULL;
if (recp_names)
recp_names = recp_names->next;
} while (sk.okay && recp_names);
}
static void
-set_row (GtkCList *clist, gpgme_key_t key)
+set_row (GtkCMCList *clist, gpgme_key_t key, gpgme_protocol_t proto)
{
const char *s;
const char *text[N_COL_TITLES];
char *algo_buf;
int row;
gsize by_read = 0, by_written = 0;
- gchar *ret_str;
+ gchar *ret_str = NULL;
/* first check whether the key is capable of encryption which is not
* the case for revoked, expired or sign-only keys */
- if (!key->can_encrypt)
+ if (!key->can_encrypt || key->revoked || key->expired || key->disabled)
return;
+
algo_buf = g_strdup_printf ("%du/%s",
key->subkeys->length,
gpgme_pubkey_algo_name(key->subkeys->pubkey_algo) );
text[COL_ALGO] = algo_buf;
- s = key->subkeys->keyid;
- if (strlen (s) == 16)
- s += 8; /* show only the short keyID */
- text[COL_KEYID] = s;
+ text[COL_KEYID] = key->subkeys->keyid;
s = key->uids->name;
- ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
+ if (!s || !*s)
+ s = key->uids->uid;
+ if (proto == GPGME_PROTOCOL_CMS) {
+ if (strstr(s, ",CN="))
+ s = strstr(s, ",CN=")+4;
+ else if (strstr(s, "CN="))
+ s = strstr(s, "CN=")+3;
+ }
+
+ ret_str = NULL;
+ if (!g_utf8_validate(s, -1, NULL))
+ ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
if (ret_str && by_written) {
s = ret_str;
}
text[COL_NAME] = s;
- s = key->uids->email;
- ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
+ if (proto == GPGME_PROTOCOL_CMS && (!key->uids->email || !*key->uids->email)) {
+ gpgme_user_id_t uid = key->uids->next;
+ if (uid)
+ s = uid->email;
+ else
+ s = key->uids->email;
+ } else {
+ s = key->uids->email;
+ }
+
+ ret_str = NULL;
+ if (!g_utf8_validate(s, -1, NULL))
+ ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
if (ret_str && by_written) {
s = ret_str;
}
switch (key->uids->validity)
{
case GPGME_VALIDITY_UNDEFINED:
- s = "q";
+ s = _("Undefined");
break;
case GPGME_VALIDITY_NEVER:
- s = "n";
+ s = _("Never");
break;
case GPGME_VALIDITY_MARGINAL:
- s = "m";
+ s = _("Marginal");
break;
case GPGME_VALIDITY_FULL:
- s = "f";
+ s = _("Full");
break;
case GPGME_VALIDITY_ULTIMATE:
- s = "u";
+ s = _("Ultimate");
break;
case GPGME_VALIDITY_UNKNOWN:
default:
- s = "?";
+ s = _("Unknown");
break;
}
text[COL_VALIDITY] = s;
- row = gtk_clist_append (clist, (gchar**)text);
+ row = gtk_cmclist_append (clist, (gchar**)text);
g_free (algo_buf);
- gtk_clist_set_row_data_full (clist, row, key, destroy_key);
+ gtk_cmclist_set_row_data_full (clist, row, key, destroy_key);
}
-static void
-fill_clist (struct select_keys_s *sk, const char *pattern)
+static gpgme_key_t
+fill_clist (struct select_keys_s *sk, const char *pattern, gpgme_protocol_t proto)
{
- GtkCList *clist;
+ GtkCMCList *clist;
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_key_t key;
int running=0;
-
- g_return_if_fail (sk);
+ int num_results = 0;
+ gboolean exact_match = FALSE;
+ gpgme_key_t last_key = NULL;
+ gpgme_user_id_t last_uid = NULL;
+ cm_return_val_if_fail (sk, NULL);
clist = sk->clist;
- g_return_if_fail (clist);
+ cm_return_val_if_fail (clist, NULL);
- debug_print ("select_keys:fill_clist: pattern '%s'\n", pattern);
+ debug_print ("select_keys:fill_clist: pattern '%s' proto %d\n", pattern, proto);
- /*gtk_clist_freeze (select_keys.clist);*/
+ /*gtk_cmclist_freeze (select_keys.clist);*/
err = gpgme_new (&ctx);
g_assert (!err);
+ gpgme_set_protocol(ctx, proto);
sk->select_ctx = ctx;
update_progress (sk, ++running, pattern);
pattern, gpgme_strerror (err));
sk->select_ctx = NULL;
gpgme_release(ctx);
- return;
+ return NULL;
}
update_progress (sk, ++running, pattern);
while ( !(err = gpgme_op_keylist_next ( ctx, &key )) ) {
+ gpgme_user_id_t uid = key->uids;
+ if (!key->can_encrypt || key->revoked || key->expired || key->disabled)
+ continue;
debug_print ("%% %s:%d: insert\n", __FILE__ ,__LINE__ );
- set_row (clist, key ); key = NULL;
+ set_row (clist, key, proto );
+ for (; uid; uid = uid->next) {
+ gchar *raw_mail = NULL;
+
+ if (!uid->email)
+ continue;
+ if (uid->revoked || uid->invalid)
+ continue;
+ raw_mail = g_strdup(uid->email);
+ extract_address(raw_mail);
+ if (!strcasecmp(pattern, raw_mail)) {
+ exact_match = TRUE;
+ last_uid = uid;
+ g_free(raw_mail);
+ break;
+ }
+ g_free(raw_mail);
+ }
+ num_results++;
+ last_key = key;
+ key = NULL;
update_progress (sk, ++running, pattern);
while (gtk_events_pending ())
gtk_main_iteration ();
}
+
+ if (exact_match == TRUE && num_results == 1) {
+ if (last_key->uids->validity < GPGME_VALIDITY_FULL &&
+ !use_untrusted(last_key, last_uid, proto))
+ exact_match = FALSE;
+ }
+
debug_print ("%% %s:%d: ready\n", __FILE__ ,__LINE__ );
if (gpgme_err_code(err) != GPG_ERR_EOF) {
debug_print ("** gpgme_op_keylist_next failed: %s",
gpgme_strerror (err));
gpgme_op_keylist_end(ctx);
}
- sk->select_ctx = NULL;
- gpgme_release (ctx);
- /*gtk_clist_thaw (select_keys.clist);*/
+ if (!exact_match || num_results != 1) {
+ sk->select_ctx = NULL;
+ gpgme_release (ctx);
+ }
+ /*gtk_cmclist_thaw (select_keys.clist);*/
+ return (exact_match == TRUE && num_results == 1 ? last_key:NULL);
}
const char *titles[N_COL_TITLES];
g_assert (!sk->window);
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_set_size_request (window, 520, 280);
+ window = gtkut_window_new (GTK_WINDOW_TOPLEVEL, "select-keys");
+ gtk_widget_set_size_request (window, 560, 280);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_window_set_title (GTK_WINDOW (window), _("Select Keys"));
gtk_window_set_modal (GTK_WINDOW (window), TRUE);
titles[COL_KEYID] = _("Key ID");
titles[COL_NAME] = _("Name");
titles[COL_EMAIL] = _("Address");
- titles[COL_VALIDITY] = _("Val");
+ titles[COL_VALIDITY] = _("Trust");
- clist = gtk_clist_new_with_titles (N_COL_TITLES, (char**)titles);
+ clist = gtk_cmclist_new_with_titles (N_COL_TITLES, (char**)titles);
gtk_container_add (GTK_CONTAINER (scrolledwin), clist);
- gtk_clist_set_column_width (GTK_CLIST(clist), COL_ALGO, 72);
- gtk_clist_set_column_width (GTK_CLIST(clist), COL_KEYID, 76);
- gtk_clist_set_column_width (GTK_CLIST(clist), COL_NAME, 130);
- gtk_clist_set_column_width (GTK_CLIST(clist), COL_EMAIL, 130);
- gtk_clist_set_column_width (GTK_CLIST(clist), COL_VALIDITY, 20);
- gtk_clist_set_selection_mode (GTK_CLIST(clist), GTK_SELECTION_BROWSE);
- g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_NAME].button),
+ gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_ALGO, 70);
+ gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_KEYID, 120);
+ gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_NAME, 115);
+ gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_EMAIL, 140);
+ gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_VALIDITY, 20);
+ gtk_cmclist_set_selection_mode (GTK_CMCLIST(clist), GTK_SELECTION_BROWSE);
+ g_signal_connect (G_OBJECT(GTK_CMCLIST(clist)->column[COL_NAME].button),
"clicked",
G_CALLBACK(sort_keys_name), sk);
- g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_EMAIL].button),
+ g_signal_connect (G_OBJECT(GTK_CMCLIST(clist)->column[COL_EMAIL].button),
"clicked",
G_CALLBACK(sort_keys_email), sk);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ /* TRANSLATORS: check that the accelerators in _Select, _Other and
+ * Do_n't encrypt are different than the one in the stock Cancel
+ * button */
gtkut_stock_button_set_create (&bbox,
- &select_btn, _("Select"),
- &other_btn, _("Other"),
- &dont_encrypt_btn, _("Don't encrypt"));
+ &select_btn, _("_Select"),
+ &other_btn, _("_Other"),
+ &dont_encrypt_btn, _("Do_n't encrypt"));
cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
- GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT);
+ gtkut_widget_set_can_default(cancel_btn, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), cancel_btn, TRUE, TRUE, 0);
gtk_widget_show(cancel_btn);
gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
- gtk_widget_show_all (window);
-
sk->window = window;
sk->toplabel = GTK_LABEL (label);
- sk->clist = GTK_CLIST (clist);
+ sk->clist = GTK_CMCLIST (clist);
}
sk->okay = 0;
sk->sort_column = N_COL_TITLES; /* use an invalid value */
sk->sort_type = GTK_SORT_ASCENDING;
- gtk_widget_show (sk->window);
}
static void
close_dialog (struct select_keys_s *sk)
{
- g_return_if_fail (sk);
+ cm_return_if_fail (sk);
gtk_widget_destroy (sk->window);
sk->window = NULL;
}
{
struct select_keys_s *sk = data;
- g_return_val_if_fail (sk, FALSE);
- if (event && event->keyval == GDK_Escape) {
+ cm_return_val_if_fail (sk, FALSE);
+ if (event && event->keyval == GDK_KEY_Escape) {
sk->okay = 0;
gtk_main_quit ();
}
gboolean use_key;
gpgme_key_t key;
- g_return_if_fail (sk);
+ cm_return_if_fail (sk);
if (!sk->clist->selection) {
debug_print ("** nothing selected");
return;
}
row = GPOINTER_TO_INT(sk->clist->selection->data);
- key = gtk_clist_get_row_data(sk->clist, row);
+ key = gtk_cmclist_get_row_data(sk->clist, row);
if (key) {
- if ( key->uids->validity < GPGME_VALIDITY_FULL ) {
- use_key = use_untrusted(key);
+ gpgme_user_id_t uid;
+ for (uid = key->uids; uid; uid = uid->next) {
+ gchar *raw_mail = NULL;
+
+ if (!uid->email)
+ continue;
+ raw_mail = g_strdup(uid->email);
+ extract_address(raw_mail);
+ if (sk->pattern && !strcasecmp(sk->pattern, raw_mail)) {
+ g_free(raw_mail);
+ break;
+ }
+ g_free(raw_mail);
+ }
+ if (!uid)
+ uid = key->uids;
+
+ if ( uid->validity < GPGME_VALIDITY_FULL ) {
+ use_key = use_untrusted(key, uid, sk->proto);
if (!use_key) {
debug_print ("** Key untrusted, will not encrypt");
return;
{
struct select_keys_s *sk = data;
- g_return_if_fail (sk);
+ cm_return_if_fail (sk);
sk->okay = 0;
sk->result = KEY_SELECTION_CANCEL;
if (sk->select_ctx)
{
struct select_keys_s *sk = data;
- g_return_if_fail (sk);
+ cm_return_if_fail (sk);
sk->okay = 0;
sk->result = KEY_SELECTION_DONT;
if (sk->select_ctx)
struct select_keys_s *sk = data;
char *uid;
- g_return_if_fail (sk);
+ cm_return_if_fail (sk);
uid = input_dialog ( _("Add key"),
_("Enter another user or key ID:"),
NULL );
if (!uid)
return;
- fill_clist (sk, uid);
+ if (fill_clist (sk, uid, sk->proto) != NULL) {
+ gpgme_release(sk->select_ctx);
+ sk->select_ctx = NULL;
+ }
update_progress (sk, 0, sk->pattern);
g_free (uid);
}
static gboolean
-use_untrusted (gpgme_key_t key)
+use_untrusted (gpgme_key_t key, gpgme_user_id_t uid, gpgme_protocol_t proto)
{
AlertValue aval;
-
+ gchar *buf = NULL;
+ gchar *title = NULL;
+ if (proto != GPGME_PROTOCOL_OpenPGP)
+ return TRUE;
+
+ title = g_strdup_printf(_("Encrypt to %s <%s>"), uid->name, uid->email);
+ buf = g_strdup_printf(_("This encryption key is not fully trusted.\n"
+ "If you choose to encrypt the message with this key, you don't\n"
+ "know for sure that it will go to the person you mean it to.\n\n"
+ "Key details: ID %s, primary identity %s <%s>\n\n"
+ "Do you trust this key enough to use it anyway?"),
+ key->subkeys->keyid, key->uids->name, key->uids->email);
aval = alertpanel
- (_("Trust key"),
- _("The selected key is not fully trusted.\n"
- "If you choose to encrypt the message with this key you don't\n"
- "know for sure that it will go to the person you mean it to.\n"
- "Do you trust it enough to use it anyway?"),
+ (title, buf,
GTK_STOCK_NO, GTK_STOCK_YES, NULL);
+ g_free(buf);
+ g_free(title);
if (aval == G_ALERTALTERNATE)
return TRUE;
else
static gint
-cmp_name (GtkCList *clist, gconstpointer pa, gconstpointer pb)
+cmp_name (GtkCMCList *clist, gconstpointer pa, gconstpointer pb)
{
- gpgme_key_t a = ((GtkCListRow *)pa)->data;
- gpgme_key_t b = ((GtkCListRow *)pb)->data;
+ gpgme_key_t a = ((GtkCMCListRow *)pa)->data;
+ gpgme_key_t b = ((GtkCMCListRow *)pb)->data;
const char *sa, *sb;
sa = a? a->uids->name : NULL;
}
static gint
-cmp_email (GtkCList *clist, gconstpointer pa, gconstpointer pb)
+cmp_email (GtkCMCList *clist, gconstpointer pa, gconstpointer pb)
{
- gpgme_key_t a = ((GtkCListRow *)pa)->data;
- gpgme_key_t b = ((GtkCListRow *)pb)->data;
+ gpgme_key_t a = ((GtkCMCListRow *)pa)->data;
+ gpgme_key_t b = ((GtkCMCListRow *)pb)->data;
const char *sa, *sb;
sa = a? a->uids->email : NULL;
static void
sort_keys ( struct select_keys_s *sk, enum col_titles column)
{
- GtkCList *clist = sk->clist;
+ GtkCMCList *clist = sk->clist;
switch (column) {
case COL_NAME:
- gtk_clist_set_compare_func (clist, cmp_name);
+ gtk_cmclist_set_compare_func (clist, cmp_name);
break;
case COL_EMAIL:
- gtk_clist_set_compare_func (clist, cmp_email);
+ gtk_cmclist_set_compare_func (clist, cmp_email);
break;
default:
return;
sk->sort_type = GTK_SORT_ASCENDING;
sk->sort_column = column;
- gtk_clist_set_sort_type (clist, sk->sort_type);
- gtk_clist_sort (clist);
+ gtk_cmclist_set_sort_type (clist, sk->sort_type);
+ gtk_cmclist_sort (clist);
}
static void