+2005-07-13 [colin] 1.9.12cvs40
+
+ * configure.ac
+ * src/plugins/pgpmime/passphrase.c
+ * src/plugins/pgpmime/passphrase.h
+ * src/plugins/pgpmime/pgpmime.c
+ * src/plugins/pgpmime/plugin.c
+ * src/plugins/pgpmime/select-keys.c
+ * src/plugins/pgpmime/select-keys.h
+ * src/plugins/pgpmime/sgpgme.c
+ * src/plugins/pgpmime/sgpgme.h
+ Port pgpmime to gpgme-1.0.
+
2005-07-12 [paul] 1.9.12cvs39
* AUTHORS
( cvs diff -u -r 1.5.12.4 -r 1.5.12.5 src/editjpilot.c; ) > 1.9.12cvs37.patchset
( cvs diff -u -r 1.5.2.5 -r 1.5.2.6 src/statusbar.c; ) > 1.9.12cvs38.patchset
( cvs diff -u -r 1.100.2.21 -r 1.100.2.22 AUTHORS; cvs diff -u -r 1.43.2.19 -r 1.43.2.20 src/toolbar.c; cvs diff -u -r 1.19.2.3 -r 1.19.2.4 src/toolbar.h; ) > 1.9.12cvs39.patchset
+( cvs diff -u -r 1.654.2.674 -r 1.654.2.675 configure.ac; cvs diff -u -r 1.1.2.8 -r 1.1.2.9 src/plugins/pgpmime/passphrase.c; cvs diff -u -r 1.1.2.1 -r 1.1.2.2 src/plugins/pgpmime/passphrase.h; cvs diff -u -r 1.1.2.17 -r 1.1.2.18 src/plugins/pgpmime/pgpmime.c; cvs diff -u -r 1.1.2.9 -r 1.1.2.10 src/plugins/pgpmime/plugin.c; cvs diff -u -r 1.1.2.6 -r 1.1.2.7 src/plugins/pgpmime/select-keys.c; cvs diff -u -r 1.1.2.1 -r 1.1.2.2 src/plugins/pgpmime/select-keys.h; cvs diff -u -r 1.1.2.8 -r 1.1.2.9 src/plugins/pgpmime/sgpgme.c; cvs diff -u -r 1.1.2.4 -r 1.1.2.5 src/plugins/pgpmime/sgpgme.h; ) > 1.9.12cvs40.patchset
MICRO_VERSION=12
INTERFACE_AGE=0
BINARY_AGE=0
-EXTRA_VERSION=39
+EXTRA_VERSION=40
EXTRA_RELEASE=
EXTRA_GTK2_VERSION=
[ --disable-pgpmime-plugin Do not build PGP/MIME plugin],
[ac_cv_enable_pgpmime_plugin=$enableval], [ac_cv_enable_pgpmime_plugin=yes])
if test x"$ac_cv_enable_pgpmime_plugin" = xyes; then
- AM_PATH_GPGME(0.3.10, AC_DEFINE(USE_GPGME, 1, Define if you use GPGME to support OpenPGP.),
+ AM_PATH_GPGME(0.4.5, AC_DEFINE(USE_GPGME, 1, Define if you use GPGME to support OpenPGP.),
[ac_cv_enable_pgpmime_plugin=no])
if test x"$ac_cv_enable_pgpmime_plugin" = xyes; then
PLUGINS="pgpmime $PLUGINS"
#include "passphrase.h"
#include "prefs_common.h"
+#include "prefs_gpg.h"
#include "manage_window.h"
#include "utils.h"
-#include "prefs_gpg.h"
static gboolean grab_all = FALSE;
gpointer data);
static gboolean passphrase_key_pressed(GtkWidget *widget, GdkEventKey *event,
gpointer data);
-static gchar* passphrase_mbox (const gchar *desc);
-
+static gchar* passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint,
+ gint prev_bad);
-static GtkWidget *create_description (const gchar *desc);
+static GtkWidget *create_description(const gchar *uid_hint,
+ const gchar *pass_hint, gint prev_bad);
void
gpgmegtk_set_passphrase_grab(gint yes)
}
static gchar*
-passphrase_mbox (const gchar *desc)
+passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
gchar *the_passphrase = NULL;
GtkWidget *vbox;
gtk_widget_set_size_request(window, 450, -1);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
- gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+ gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(window), "delete_event",
- G_CALLBACK(passphrase_deleted), NULL);
+ G_CALLBACK(passphrase_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
- G_CALLBACK(passphrase_key_pressed), NULL);
+ G_CALLBACK(passphrase_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
manage_window_set_transient(GTK_WINDOW(window));
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
- if (desc) {
+ if (uid_hint || pass_hint) {
GtkWidget *label;
- label = create_description (desc);
+ label = create_description (uid_hint, pass_hint, prev_bad);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
}
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
- G_CALLBACK(passphrase_ok_cb), NULL);
+ G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(pass_entry), "activate",
- G_CALLBACK(passphrase_ok_cb), NULL);
+ G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
- G_CALLBACK(passphrase_cancel_cb), NULL);
+ G_CALLBACK(passphrase_cancel_cb), NULL);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
if (grab_all)
- gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+ gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_widget_show_all(window);
if (grab_all) {
- int err, cnt = 0;
-try_again:
- /* make sure that window is viewable */
+ int err = 0, cnt = 0;
+ /* make sure that window is viewable */
gtk_widget_show_now(window);
gdk_flush();
while(gtk_events_pending())
gtk_main_iteration();
+#ifdef GDK_WINDOWING_X11
+ gdk_x11_display_grab(gdk_display_get_default());
+#endif /* GDK_WINDOWING_X11 */
+try_again:
if ((err = gdk_pointer_grab(window->window, TRUE, 0,
window->window, NULL, GDK_CURRENT_TIME))) {
if (err == GDK_GRAB_NOT_VIEWABLE && cnt < 10) {
- /* HACK! */
- cnt++;
+ cnt++;
g_warning("trying to grab mouse again\n");
goto try_again;
- } else {
- g_warning("OOPS: Could not grab mouse (%d)\n", err);
- gtk_widget_destroy(window);
- return NULL;
+ } else {
+#ifdef GDK_WINDOWING_X11
+ gdk_x11_display_ungrab(gdk_display_get_default());
+#endif /* GDK_WINDOWING_X11 */
+ g_warning("OOPS: Could not grab mouse\n");
+ gtk_widget_destroy(window);
+ return NULL;
}
}
if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
gdk_display_pointer_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
+#ifdef GDK_WINDOWING_X11
+ gdk_x11_display_ungrab(gdk_display_get_default());
+#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab keyboard\n");
gtk_widget_destroy(window);
return NULL;
gdk_display_keyboard_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
+#ifdef GDK_WINDOWING_X11
+ gdk_x11_display_ungrab(gdk_display_get_default());
+#endif /* GDK_WINDOWING_X11 */
gdk_flush();
}
manage_window_focus_out(window, NULL, NULL);
if (pass_ack) {
- const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
+ const gchar *entry_text;
+ entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
if (entry_text) /* Hmmm: Do we really need this? */
the_passphrase = g_strdup (entry_text);
}
}
static GtkWidget *
-create_description (const gchar *desc)
+create_description(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
- const gchar *cmd = NULL, *uid = NULL, *info = NULL;
+ const gchar *uid = NULL, *info = NULL;
gchar *buf;
GtkWidget *label;
- cmd = desc;
- uid = strchr (cmd, '\n');
- if (uid) {
- info = strchr (++uid, '\n');
- if (info )
- info++;
- }
-
- if (!uid)
+ if (!uid_hint)
uid = _("[no user id]");
- if (!info)
+ else
+ uid = uid_hint;
+ if (!pass_hint)
info = "";
+ else
+ info = pass_hint;
buf = g_strdup_printf (_("%sPlease enter the passphrase for:\n\n"
" %.*s \n"
"(%.*s)\n"),
- !strncmp (cmd, "TRY_AGAIN", 9 ) ?
+ prev_bad ?
_("Bad passphrase! Try again...\n\n") : "",
linelen (uid), uid, linelen (info), info);
return FALSE;
}
-const char*
-gpgmegtk_passphrase_cb (void *opaque, const char *desc, void **r_hd)
+gpgme_error_t
+gpgmegtk_passphrase_cb(void *opaque, const char *uid_hint,
+ const char *passphrase_hint, int prev_bad, int fd)
{
- struct passphrase_cb_info_s *info = opaque;
- GpgmeCtx ctx = info ? info->c : NULL;
const char *pass;
- if (!desc) {
- /* FIXME: cleanup by looking at *r_hd */
- return NULL;
+ if (prefs_gpg_get_config()->store_passphrase && last_pass != NULL && !prev_bad) {
+ write(fd, last_pass, strlen(last_pass));
+ write(fd, "\n", 1);
+ return GPG_ERR_NO_ERROR;
}
- if (prefs_gpg_get_config()->store_passphrase && last_pass != NULL &&
- strncmp(desc, "TRY_AGAIN", 9) != 0)
- return g_strdup(last_pass);
-
gpgmegtk_set_passphrase_grab (prefs_gpg_get_config()->passphrase_grab);
- debug_print ("%% requesting passphrase for `%s': ", desc);
- pass = passphrase_mbox (desc);
+ debug_print ("%% requesting passphrase for `%s': ", uid_hint);
+ pass = passphrase_mbox (uid_hint, passphrase_hint, prev_bad);
gpgmegtk_free_passphrase();
if (!pass) {
debug_print ("%% cancel passphrase entry");
- gpgme_cancel (ctx);
+ write(fd, "\n", 1);
+ return GPG_ERR_CANCELED;
}
else {
if (prefs_gpg_get_config()->store_passphrase) {
}
debug_print ("%% sending passphrase");
}
-
- return pass;
+ write(fd, pass, strlen(pass));
+ write(fd, "\n", 1);
+ return GPG_ERR_NO_ERROR;
}
-void gpgmegtk_free_passphrase(void)
+void gpgmegtk_free_passphrase()
{
- (void)free_passphrase(NULL); /* could be inline */
+ (void)free_passphrase(NULL); // could be inline
}
#endif /* USE_GPGME */
#include <gpgme.h>
struct passphrase_cb_info_s {
- GpgmeCtx c;
+ gpgme_ctx_t c;
int did_it;
};
void gpgmegtk_set_passphrase_grab (gint yesno);
-const char* gpgmegtk_passphrase_cb(void *opaque, const char *desc, void **r_hd);
-void gpgmegtk_free_passphrase (void);
+gpgme_error_t gpgmegtk_passphrase_cb(void *opaque, const char *uid_hint,
+const char *passphrase_info, int prev_bad, int fd);
+void gpgmegtk_free_passphrase();
#endif /* GPGMEGTK_PASSPHRASE_H */
gboolean done_sigtest;
gboolean is_signed;
- GpgmeSigStat sigstatus;
- GpgmeCtx ctx;
+ gpgme_verify_result_t sigstatus;
+ gpgme_ctx_t ctx;
};
static PrivacySystem pgpmime_system;
data->data.system = &pgpmime_system;
data->done_sigtest = FALSE;
data->is_signed = FALSE;
- data->sigstatus = GPGME_SIG_STAT_NONE;
+ data->sigstatus = NULL;
gpgme_new(&data->ctx);
return data;
FILE *fp;
gchar *boundary;
gchar *textstr;
- GpgmeData sigdata, textdata;
-
+ gpgme_data_t sigdata = NULL, textdata = NULL;
+ gpgme_error_t err;
g_return_val_if_fail(mimeinfo != NULL, -1);
g_return_val_if_fail(mimeinfo->privacy != NULL, -1);
data = (PrivacyDataPGP *) mimeinfo->privacy;
+ gpgme_new(&data->ctx);
debug_print("Checking PGP/MIME signature\n");
parent = procmime_mimeinfo_parent(mimeinfo);
textstr = get_canonical_content(fp, boundary);
- gpgme_data_new_from_mem(&textdata, textstr, strlen(textstr), 0);
+ err = gpgme_data_new_from_mem(&textdata, textstr, strlen(textstr), 0);
+ if (err) {
+ debug_print ("gpgme_data_new_from_mem failed: %s\n",
+ gpgme_strerror (err));
+ }
signature = (MimeInfo *) mimeinfo->node->next->data;
sigdata = sgpgme_data_from_mimeinfo(signature);
data->sigstatus =
- sgpgme_verify_signature (data->ctx, sigdata, textdata);
-
+ sgpgme_verify_signature (data->ctx, sigdata, textdata, NULL);
+
gpgme_data_release(sigdata);
gpgme_data_release(textdata);
g_free(textstr);
g_return_val_if_fail(data != NULL, SIGNATURE_INVALID);
- if (data->sigstatus == GPGME_SIG_STAT_NONE &&
+ if (data->sigstatus == NULL &&
prefs_gpg_get_config()->auto_check_signatures)
pgpmime_check_signature(mimeinfo);
g_return_val_if_fail(data != NULL, g_strdup("Error"));
- if (data->sigstatus == GPGME_SIG_STAT_NONE &&
+ if (data->sigstatus == NULL &&
prefs_gpg_get_config()->auto_check_signatures)
pgpmime_check_signature(mimeinfo);
g_return_val_if_fail(data != NULL, g_strdup("Error"));
- if (data->sigstatus == GPGME_SIG_STAT_NONE &&
+ if (data->sigstatus == NULL &&
prefs_gpg_get_config()->auto_check_signatures)
pgpmime_check_signature(mimeinfo);
static MimeInfo *pgpmime_decrypt(MimeInfo *mimeinfo)
{
MimeInfo *encinfo, *decinfo, *parseinfo;
- GpgmeData cipher, plain;
+ gpgme_data_t cipher = NULL, plain = NULL;
static gint id = 0;
FILE *dstfp;
gint nread;
gchar *fname;
gchar buf[BUFFSIZE];
- GpgmeSigStat sigstat = 0;
+ gpgme_verify_result_t sigstat = NULL;
PrivacyDataPGP *data = NULL;
- GpgmeCtx ctx;
-
- if (gpgme_new(&ctx) != GPGME_No_Error)
+ gpgme_ctx_t ctx;
+
+ if (gpgme_new(&ctx) != GPG_ERR_NO_ERROR)
return NULL;
gpgme_data_release(cipher);
if (plain == NULL) {
+ debug_print("plain is null!\n");
gpgme_release(ctx);
return NULL;
}
g_free(fname);
gpgme_data_release(plain);
gpgme_release(ctx);
+ debug_print("can't open!\n");
return NULL;
}
fprintf(dstfp, "MIME-Version: 1.0\n");
- gpgme_data_rewind (plain);
- while (gpgme_data_read(plain, buf, sizeof(buf), &nread) == GPGME_No_Error) {
+
+ while ((nread = gpgme_data_read(plain, buf, sizeof(buf))) > 0) {
+ debug_print("read %d:%s\n", nread, buf);
fwrite (buf, nread, 1, dstfp);
}
+ debug_print("nread %d!\n", nread);
fclose(dstfp);
gpgme_data_release(plain);
decinfo->tmp = TRUE;
- if (sigstat != GPGME_SIG_STAT_NONE) {
+ if (sigstat != NULL && sigstat->signatures != NULL) {
if (decinfo->privacy != NULL) {
data = (PrivacyDataPGP *) decinfo->privacy;
} else {
return decinfo;
}
-/*
- * Find TAG in XML and return a pointer into xml set just behind the
- * closing angle. Return NULL if not found.
- */
-static const char *
-find_xml_tag (const char *xml, const char *tag)
-{
- int taglen = strlen (tag);
- const char *s = xml;
-
- while ( (s = strchr (s, '<')) ) {
- s++;
- if (!strncmp (s, tag, taglen)) {
- const char *s2 = s + taglen;
- if (*s2 == '>' || isspace (*(const unsigned char*)s2) ) {
- /* found */
- while (*s2 && *s2 != '>') /* skip attributes */
- s2++;
- /* fixme: do need to handle angles inside attribute vallues? */
- return *s2? (s2+1):NULL;
- }
- }
- while (*s && *s != '>') /* skip to end of tag */
- s++;
- }
- return NULL;
-}
-
-
-/*
- * Extract the micalg from an GnupgOperationInfo XML container.
- */
-static char *
-extract_micalg (char *xml)
-{
- const char *s;
-
- s = find_xml_tag (xml, "GnupgOperationInfo");
- if (s) {
- const char *s_end = find_xml_tag (s, "/GnupgOperationInfo");
- s = find_xml_tag (s, "signature");
- if (s && s_end && s < s_end) {
- const char *s_end2 = find_xml_tag (s, "/signature");
- if (s_end2 && s_end2 < s_end) {
- s = find_xml_tag (s, "micalg");
- if (s && s < s_end2) {
- s_end = strchr (s, '<');
- if (s_end) {
- char *p = g_malloc (s_end - s + 1);
- memcpy (p, s, s_end - s);
- p[s_end-s] = 0;
- return p;
- }
- }
- }
- }
- }
- return NULL;
-}
-
gboolean pgpmime_sign(MimeInfo *mimeinfo, PrefsAccount *account)
{
MimeInfo *msgcontent, *sigmultipart, *newinfo;
- gchar *textstr, *opinfo, *micalg;
+ gchar *textstr, *micalg;
FILE *fp;
gchar *boundary, *sigcontent;
- GpgmeCtx ctx;
- GpgmeData gpgtext, gpgsig;
+ gpgme_ctx_t ctx;
+ gpgme_data_t gpgtext, gpgsig;
size_t len;
struct passphrase_cb_info_s info;
+ gpgme_sign_result_t result = NULL;
memset (&info, 0, sizeof info);
gpgme_new(&ctx);
gpgme_set_textmode(ctx, 1);
gpgme_set_armor(ctx, 1);
+ gpgme_signers_clear (ctx);
if (!sgpgme_setup_signers(ctx, account)) {
gpgme_release(ctx);
gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);
}
- if (gpgme_op_sign(ctx, gpgtext, gpgsig, GPGME_SIG_MODE_DETACH) != GPGME_No_Error) {
+ if (gpgme_op_sign(ctx, gpgtext, gpgsig, GPGME_SIG_MODE_DETACH) != GPG_ERR_NO_ERROR) {
gpgme_release(ctx);
return FALSE;
}
- opinfo = gpgme_get_op_info(ctx, 0);
- micalg = extract_micalg(opinfo);
- g_free(opinfo);
+ result = gpgme_op_sign_result(ctx);
+ if (result && result->signatures) {
+ if (gpgme_get_protocol(ctx) == GPGME_PROTOCOL_OpenPGP) {
+ micalg = g_strdup_printf("PGP-%s", gpgme_hash_algo_name(
+ result->signatures->hash_algo));
+ } else {
+ micalg = g_strdup(gpgme_hash_algo_name(
+ result->signatures->hash_algo));
+ }
+ } else {
+ /* can't get result (maybe no signing key?) */
+ return FALSE;
+ }
gpgme_release(ctx);
sigcontent = gpgme_data_release_and_get_mem(gpgsig, &len);
return TRUE;
}
-
gchar *pgpmime_get_encrypt_data(GSList *recp_names)
{
return sgpgme_get_encrypt_data(recp_names);
gchar *boundary, *enccontent;
size_t len;
gchar *textstr;
- GpgmeData gpgtext, gpgenc;
- gchar **recipients, **nextrecp;
- GpgmeRecipients recp;
- GpgmeCtx ctx;
-
- /* build GpgmeRecipients from encrypt_data */
- recipients = g_strsplit(encrypt_data, " ", 0);
- gpgme_recipients_new(&recp);
- for (nextrecp = recipients; *nextrecp != NULL; nextrecp++) {
- gpgme_recipients_add_name_with_validity(recp, *nextrecp,
- GPGME_VALIDITY_FULL);
+ gpgme_data_t gpgtext = NULL, gpgenc = NULL;
+ gpgme_ctx_t ctx = NULL;
+ gpgme_key_t *kset = NULL;
+ gchar **fprs = g_strsplit(encrypt_data, " ", -1);
+ gint i = 0;
+ while (fprs[i] && strlen(fprs[i])) {
+ i++;
}
- g_strfreev(recipients);
-
+
+ kset = g_malloc(sizeof(gpgme_key_t)*(i+1));
+ memset(kset, 0, sizeof(gpgme_key_t)*(i+1));
+ gpgme_new(&ctx);
+ i = 0;
+ while (fprs[i] && strlen(fprs[i])) {
+ gpgme_key_t key;
+ gpgme_error_t err;
+ err = gpgme_get_key(ctx, fprs[i], &key, 0);
+ if (err) {
+ debug_print("can't add key '%s'[%d] (%s)\n", fprs[i],i, gpgme_strerror(err));
+ break;
+ }
+ debug_print("found %s at %d\n", fprs[i], i);
+ kset[i] = key;
+ i++;
+ }
+
debug_print("Encrypting message content\n");
/* remove content node from message */
/* encrypt data */
gpgme_data_new_from_mem(&gpgtext, textstr, strlen(textstr), 0);
gpgme_data_new(&gpgenc);
- gpgme_new(&ctx);
gpgme_set_armor(ctx, 1);
-
- gpgme_op_encrypt(ctx, recp, gpgtext, gpgenc);
+ gpgme_data_seek(gpgtext, 0, SEEK_SET);
+
+ gpgme_op_encrypt(ctx, kset, GPGME_ENCRYPT_ALWAYS_TRUST, gpgtext, gpgenc);
gpgme_release(ctx);
enccontent = gpgme_data_release_and_get_mem(gpgenc, &len);
- gpgme_recipients_release(recp);
gpgme_data_release(gpgtext);
g_free(textstr);
return -1;
}
- if ((sylpheed_get_version() < MAKE_NUMERIC_VERSION(0, 9, 12, 164))) {
+ if ((sylpheed_get_version() < MAKE_NUMERIC_VERSION(1, 9, 12, 40))) {
*error = g_strdup("Your sylpheed version is too old");
return -1;
}
#include "gtkutils.h"
#include "inputdialog.h"
#include "manage_window.h"
+#include "alertpanel.h"
#define DIM(v) (sizeof(v)/sizeof((v)[0]))
#define DIMof(type,member) DIM(((type *)0)->member)
GtkLabel *toplabel;
GtkCList *clist;
const char *pattern;
- GpgmeRecipients rset;
- GpgmeCtx select_ctx;
+ unsigned int num_keys;
+ gpgme_key_t *kset;
+ gpgme_ctx_t select_ctx;
GtkSortType sort_type;
enum col_titles sort_column;
};
-static void set_row (GtkCList *clist, GpgmeKey key);
+static void set_row (GtkCList *clist, gpgme_key_t key);
static void fill_clist (struct select_keys_s *sk, const char *pattern);
static void create_dialog (struct select_keys_s *sk);
static void open_dialog (struct select_keys_s *sk);
GdkEventAny *event, gpointer data);
static gboolean key_pressed_cb (GtkWidget *widget,
GdkEventKey *event, gpointer data);
-static void showall_btn_cb (GtkWidget *widget, gpointer data);
static void select_btn_cb (GtkWidget *widget, gpointer data);
static void cancel_btn_cb (GtkWidget *widget, gpointer data);
static void other_btn_cb (GtkWidget *widget, gpointer data);
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 void
update_progress (struct select_keys_s *sk, int running, const char *pattern)
/**
- * select_keys_get_recipients:
+ * gpgmegtk_recipient_selection:
* @recp_names: A list of email addresses
*
* Select a list of recipients from a given list of email addresses.
*
* Return value: NULL on error or a list of list of recipients.
**/
-GpgmeRecipients
+gpgme_key_t *
gpgmegtk_recipient_selection (GSList *recp_names)
{
struct select_keys_s sk;
- GpgmeError err;
memset (&sk, 0, sizeof sk);
- err = gpgme_recipients_new (&sk.rset);
- if (err) {
- g_warning ("failed to allocate recipients set: %s",
- gpgme_strerror (err));
- return NULL;
- }
-
open_dialog (&sk);
do {
close_dialog (&sk);
if (!sk.okay) {
- gpgme_recipients_release (sk.rset);
- sk.rset = NULL;
+ g_free(sk.kset);
+ sk.kset = NULL;
+ } else {
+ sk.kset = g_realloc(sk.kset, sizeof(gpgme_key_t) * (sk.num_keys + 1));
+ sk.kset[sk.num_keys] = NULL;
}
- return sk.rset;
+ return sk.kset;
}
static void
destroy_key (gpointer data)
{
- GpgmeKey key = data;
+ gpgme_key_t key = data;
gpgme_key_release (key);
}
static void
-set_row (GtkCList *clist, GpgmeKey key)
+set_row (GtkCList *clist, gpgme_key_t key)
{
const char *s;
const char *text[N_COL_TITLES];
char *algo_buf;
int row;
- gssize by_read = 0, by_written = 0;
- gchar *ret_str;
/* first check whether the key is capable of encryption which is not
* the case for revoked, expired or sign-only keys */
- if ( !gpgme_key_get_ulong_attr (key, GPGME_ATTR_CAN_ENCRYPT, NULL, 0 ) )
+ if (!key->can_encrypt)
return;
-
- algo_buf = g_strdup_printf ("%lu/%s",
- gpgme_key_get_ulong_attr (key, GPGME_ATTR_LEN, NULL, 0 ),
- gpgme_key_get_string_attr (key, GPGME_ATTR_ALGO, NULL, 0 ) );
+ algo_buf = g_strdup_printf ("%du/%s",
+ key->subkeys->length,
+ gpgme_pubkey_algo_name(key->subkeys->pubkey_algo) );
text[COL_ALGO] = algo_buf;
- s = gpgme_key_get_string_attr (key, GPGME_ATTR_KEYID, NULL, 0);
+ s = key->subkeys->keyid;
if (strlen (s) == 16)
s += 8; /* show only the short keyID */
text[COL_KEYID] = s;
- s = gpgme_key_get_string_attr (key, GPGME_ATTR_NAME, NULL, 0);
- ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
- if (ret_str && by_written) {
- s = ret_str;
- }
+ s = key->uids->name;
text[COL_NAME] = s;
- s = gpgme_key_get_string_attr (key, GPGME_ATTR_EMAIL, NULL, 0);
- ret_str = g_locale_to_utf8 (s, strlen(s), &by_read, &by_written, NULL);
- if (ret_str && by_written) {
- s = ret_str;
- }
+ s = key->uids->email;
text[COL_EMAIL] = s;
- s = gpgme_key_get_string_attr (key, GPGME_ATTR_VALIDITY, NULL, 0);
- 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";
+ break;
+ case GPGME_VALIDITY_NEVER:
+ s = "n";
+ break;
+ case GPGME_VALIDITY_MARGINAL:
+ s = "m";
+ break;
+ case GPGME_VALIDITY_FULL:
+ s = "f";
+ break;
+ case GPGME_VALIDITY_ULTIMATE:
+ s = "u";
+ break;
+ case GPGME_VALIDITY_UNKNOWN:
+ default:
+ s = "?";
+ break;
+ }
text[COL_VALIDITY] = s;
row = gtk_clist_append (clist, (gchar**)text);
gtk_clist_set_row_data_full (clist, row, key, destroy_key);
}
-
static void
fill_clist (struct select_keys_s *sk, const char *pattern)
{
GtkCList *clist;
- GpgmeCtx ctx;
- GpgmeError err;
- GpgmeKey key;
+ gpgme_ctx_t ctx;
+ gpgme_error_t err;
+ gpgme_key_t key;
int running=0;
g_return_if_fail (sk);
debug_print ("** gpgme_op_keylist_start(%s) failed: %s",
pattern, gpgme_strerror (err));
sk->select_ctx = NULL;
+ gpgme_release(ctx);
return;
}
update_progress (sk, ++running, pattern);
gtk_main_iteration ();
}
debug_print ("%% %s:%d: ready\n", __FILE__ ,__LINE__ );
- if (err != GPGME_EOF)
+ 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);*/
GtkWidget *clist;
GtkWidget *label;
GtkWidget *select_btn, *cancel_btn, *other_btn;
- GtkWidget *showall_btn;
const char *titles[N_COL_TITLES];
g_assert (!sk->window);
gtk_window_set_title (GTK_WINDOW (window), _("Select Keys"));
gtk_window_set_modal (GTK_WINDOW (window), TRUE);
g_signal_connect (G_OBJECT (window), "delete_event",
- G_CALLBACK (delete_event_cb), sk);
+ G_CALLBACK (delete_event_cb), sk);
g_signal_connect (G_OBJECT (window), "key_press_event",
- G_CALLBACK (key_pressed_cb), sk);
+ G_CALLBACK (key_pressed_cb), sk);
MANAGE_WINDOW_SIGNALS_CONNECT (window);
vbox = gtk_vbox_new (FALSE, 8);
gtk_clist_set_selection_mode (GTK_CLIST(clist), GTK_SELECTION_BROWSE);
g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_NAME].button),
"clicked",
- G_CALLBACK(sort_keys_name), sk);
+ G_CALLBACK(sort_keys_name), sk);
g_signal_connect (G_OBJECT(GTK_CLIST(clist)->column[COL_EMAIL].button),
"clicked",
- G_CALLBACK(sort_keys_email), sk);
+ G_CALLBACK(sort_keys_email), sk);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- showall_btn = gtk_button_new_with_label (_(" List all keys "));
- gtk_widget_show (showall_btn);
- gtk_box_pack_start (GTK_BOX (hbox), showall_btn, FALSE, FALSE, 0);
-
- g_signal_connect(G_OBJECT (showall_btn), "clicked",
- G_CALLBACK(showall_btn_cb), sk);
-
gtkut_stock_button_set_create (&bbox,
&select_btn, _("Select"),
&cancel_btn, GTK_STOCK_CANCEL,
gtk_widget_grab_default (select_btn);
g_signal_connect (G_OBJECT (select_btn), "clicked",
- G_CALLBACK (select_btn_cb), sk);
+ G_CALLBACK (select_btn_cb), sk);
g_signal_connect (G_OBJECT(cancel_btn), "clicked",
- G_CALLBACK (cancel_btn_cb), sk);
+ G_CALLBACK (cancel_btn_cb), sk);
g_signal_connect (G_OBJECT (other_btn), "clicked",
- G_CALLBACK (other_btn_cb), sk);
+ G_CALLBACK (other_btn_cb), sk);
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
}
-static gboolean
+static gboolean
key_pressed_cb (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
struct select_keys_s *sk = data;
sk->okay = 0;
gtk_main_quit ();
}
- return FALSE;
+ return FALSE;
}
{
struct select_keys_s *sk = data;
int row;
- GpgmeKey key;
+ gboolean use_key;
+ gpgme_key_t key;
g_return_if_fail (sk);
if (!sk->clist->selection) {
row = GPOINTER_TO_INT(sk->clist->selection->data);
key = gtk_clist_get_row_data(sk->clist, row);
if (key) {
- const char *s = gpgme_key_get_string_attr (key,
- GPGME_ATTR_FPR,
- NULL, 0 );
- if ( gpgme_key_get_ulong_attr (key, GPGME_ATTR_VALIDITY, NULL, 0 )
- < GPGME_VALIDITY_FULL ) {
- debug_print ("** FIXME: we are faking the trust calculation");
+ if ( key->uids->validity < GPGME_VALIDITY_FULL ) {
+ use_key = use_untrusted(key);
+ if (!use_key) {
+ debug_print ("** Key untrusted, will not encrypt");
+ return;
+ }
}
- if (!gpgme_recipients_add_name_with_validity (sk->rset, s,
- GPGME_VALIDITY_FULL) ) {
+ 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;
gtk_main_quit ();
- }
}
}
g_free (uid);
}
-static void
-showall_btn_cb (GtkWidget *widget, gpointer data)
-{
- struct select_keys_s *sk = data;
- char *uid;
- g_return_if_fail (sk);
- uid = "";
-
- fill_clist (sk, uid);
- update_progress (sk, 0, sk->pattern);
+static gboolean
+use_untrusted (gpgme_key_t key)
+{
+ AlertValue aval;
+
+ 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?"),
+ GTK_STOCK_YES, GTK_STOCK_NO, NULL);
+ if (aval == G_ALERTDEFAULT)
+ return TRUE;
+ else
+ return FALSE;
}
+
static gint
-cmp_attr (gconstpointer pa, gconstpointer pb, GpgmeAttr attr)
+cmp_name (GtkCList *clist, gconstpointer pa, gconstpointer pb)
{
- GpgmeKey a = ((GtkCListRow *)pa)->data;
- GpgmeKey b = ((GtkCListRow *)pb)->data;
+ gpgme_key_t a = ((GtkCListRow *)pa)->data;
+ gpgme_key_t b = ((GtkCListRow *)pb)->data;
const char *sa, *sb;
- sa = a? gpgme_key_get_string_attr (a, attr, NULL, 0 ) : NULL;
- sb = b? gpgme_key_get_string_attr (b, attr, NULL, 0 ) : NULL;
+ sa = a? a->uids->name : NULL;
+ sb = b? b->uids->name : NULL;
if (!sa)
return !!sb;
if (!sb)
return g_ascii_strcasecmp(sa, sb);
}
-static gint
-cmp_name (GtkCList *clist, gconstpointer pa, gconstpointer pb)
-{
- return cmp_attr (pa, pb, GPGME_ATTR_NAME);
-}
-
static gint
cmp_email (GtkCList *clist, gconstpointer pa, gconstpointer pb)
{
- return cmp_attr (pa, pb, GPGME_ATTR_EMAIL);
+ gpgme_key_t a = ((GtkCListRow *)pa)->data;
+ gpgme_key_t b = ((GtkCListRow *)pb)->data;
+ const char *sa, *sb;
+
+ sa = a? a->uids->email : NULL;
+ sb = b? b->uids->email : NULL;
+ if (!sa)
+ return !!sb;
+ if (!sb)
+ return -1;
+ return g_ascii_strcasecmp(sa, sb);
}
static void
#include <gpgme.h>
-GpgmeRecipients gpgmegtk_recipient_selection (GSList *recp_names);
+gpgme_key_t *gpgmegtk_recipient_selection (GSList *recp_names);
#endif /* GPGMEGTK_SELECT_KEYS_H */
#include <gpgme.h>
#include <glib.h>
#include <glib/gi18n.h>
+#include <stdio.h>
#include "sgpgme.h"
#include "privacy.h"
#include "prefs_gpg.h"
#include "select-keys.h"
-static void idle_function_for_gpgme(void)
-{
- while (gtk_events_pending())
- gtk_main_iteration();
-}
-
static void sgpgme_disable_all(void)
{
/* FIXME: set a flag, so that we don't bother the user with failed
* gpgme messages */
}
-GpgmeSigStat sgpgme_verify_signature(GpgmeCtx ctx, GpgmeData sig,
- GpgmeData plain)
+gpgme_verify_result_t sgpgme_verify_signature(gpgme_ctx_t ctx, gpgme_data_t sig,
+ gpgme_data_t plain, gpgme_data_t dummy)
{
- GpgmeSigStat status;
+ gpgme_verify_result_t status = NULL;
+ gpgme_error_t err;
- if (gpgme_op_verify(ctx, sig, plain, &status) != GPGME_No_Error)
- return GPGME_SIG_STAT_ERROR;
+ if ((err = gpgme_op_verify(ctx, sig, plain, dummy)) != GPG_ERR_NO_ERROR) {
+ debug_print("op_verify err %s\n", gpgme_strerror(err));
+ return NULL;
+ }
+ status = gpgme_op_verify_result(ctx);
return status;
}
-SignatureStatus sgpgme_sigstat_gpgme_to_privacy(GpgmeCtx ctx, GpgmeSigStat status)
+SignatureStatus sgpgme_sigstat_gpgme_to_privacy(gpgme_ctx_t ctx, gpgme_verify_result_t status)
{
unsigned long validity = 0;
+ gpgme_signature_t sig = NULL;
- validity = gpgme_get_sig_ulong_attr(ctx, 0,
- GPGME_ATTR_VALIDITY, 0);
+ if (status == NULL)
+ return SIGNATURE_UNCHECKED;
+
+ sig = status->signatures;
- switch (status) {
- case GPGME_SIG_STAT_GOOD:
+ if (sig == NULL)
+ return SIGNATURE_UNCHECKED;
+
+ validity = sig->validity;
+
+ switch (gpg_err_code(sig->status)) {
+ case GPG_ERR_NO_ERROR:
if ((validity != GPGME_VALIDITY_MARGINAL) &&
(validity != GPGME_VALIDITY_FULL) &&
(validity != GPGME_VALIDITY_ULTIMATE))
return SIGNATURE_WARN;
return SIGNATURE_OK;
- case GPGME_SIG_STAT_GOOD_EXP:
- case GPGME_SIG_STAT_GOOD_EXPKEY:
- case GPGME_SIG_STAT_DIFF:
+ case GPG_ERR_SIG_EXPIRED:
+ case GPG_ERR_KEY_EXPIRED:
return SIGNATURE_WARN;
- case GPGME_SIG_STAT_BAD:
+ case GPG_ERR_BAD_SIGNATURE:
return SIGNATURE_INVALID;
- case GPGME_SIG_STAT_NOKEY:
- case GPGME_SIG_STAT_NOSIG:
- case GPGME_SIG_STAT_ERROR:
+ case GPG_ERR_NO_PUBKEY:
+ return SIGNATURE_CHECK_FAILED;
+ default:
return SIGNATURE_CHECK_FAILED;
- case GPGME_SIG_STAT_NONE:
- return SIGNATURE_UNCHECKED;
}
return SIGNATURE_CHECK_FAILED;
}
static const gchar *get_validity_str(unsigned long validity)
{
- switch (validity) {
+ switch (gpg_err_code(validity)) {
case GPGME_VALIDITY_UNKNOWN:
return _("Unknown");
case GPGME_VALIDITY_UNDEFINED:
}
}
-gchar *sgpgme_sigstat_info_short(GpgmeCtx ctx, GpgmeSigStat status)
+gchar *sgpgme_sigstat_info_short(gpgme_ctx_t ctx, gpgme_verify_result_t status)
{
- switch (status) {
- case GPGME_SIG_STAT_GOOD:
- {
- GpgmeKey key;
- unsigned long validity = 0;
+ gpgme_signature_t sig = NULL;
- if (gpgme_get_sig_key(ctx, 0, &key) != GPGME_No_Error)
- return g_strdup(_("Error"));
+ if (status == NULL) {
+ return g_strdup(_("The signature has not been checked"));
+ }
+ sig = status->signatures;
+ if (sig == NULL) {
+ return g_strdup(_("The signature has not been checked"));
+ }
+
+ switch (gpg_err_code(sig->status)) {
+ case GPG_ERR_NO_ERROR:
+ { gpgme_user_id_t user = NULL;
+ gpgme_key_t key;
+
+ gpgme_get_key(ctx, sig->fpr, &key, 0);
+
+ user = key->uids;
- validity = gpgme_get_sig_ulong_attr(ctx, 0,
- GPGME_ATTR_VALIDITY, 0);
-
return g_strdup_printf(_("Valid signature by %s (Trust: %s)"),
- gpgme_key_get_string_attr(key, GPGME_ATTR_NAME, NULL, 0),
- get_validity_str(validity));
+ user->uid, get_validity_str(sig->validity));
}
- case GPGME_SIG_STAT_GOOD_EXP:
+ case GPG_ERR_SIG_EXPIRED:
return g_strdup(_("The signature has expired"));
- case GPGME_SIG_STAT_GOOD_EXPKEY:
+ case GPG_ERR_KEY_EXPIRED:
return g_strdup(_("The key that was used to sign this part has expired"));
- case GPGME_SIG_STAT_DIFF:
- return g_strdup(_("Not all signatures are valid"));
- case GPGME_SIG_STAT_BAD:
+ case GPG_ERR_BAD_SIGNATURE:
return g_strdup(_("This signature is invalid"));
- case GPGME_SIG_STAT_NOKEY:
+ case GPG_ERR_NO_PUBKEY:
return g_strdup(_("You have no key to verify this signature"));
- case GPGME_SIG_STAT_NOSIG:
- return g_strdup(_("No signature found"));
- case GPGME_SIG_STAT_ERROR:
- return g_strdup(_("An error occured"));
- case GPGME_SIG_STAT_NONE:
+ default:
return g_strdup(_("The signature has not been checked"));
}
return g_strdup(_("Error"));
}
-gchar *sgpgme_sigstat_info_full(GpgmeCtx ctx, GpgmeSigStat status)
+gchar *sgpgme_sigstat_info_full(gpgme_ctx_t ctx, gpgme_verify_result_t status)
{
gint i = 0;
gchar *ret;
GString *siginfo;
- GpgmeKey key;
+ gpgme_signature_t sig = status->signatures;
siginfo = g_string_sized_new(64);
- while (gpgme_get_sig_key(ctx, i, &key) != GPGME_EOF) {
- time_t sigtime, expiretime;
- GpgmeSigStat sigstatus;
- gchar timestr[64];
+ while (sig) {
+ gpgme_user_id_t user = NULL;
+ gpgme_key_t key;
+
const gchar *keytype, *keyid, *uid;
- sigtime = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_CREATED, 0);
- strftime(timestr, 64, "%c", gmtime(&sigtime));
- keytype = gpgme_key_get_string_attr(key, GPGME_ATTR_ALGO, NULL, 0);
- keyid = gpgme_key_get_string_attr(key, GPGME_ATTR_KEYID, NULL, 0);
+ gpgme_get_key(ctx, sig->fpr, &key, 0);
+ user = key->uids;
+
+ keytype = gpgme_pubkey_algo_name(key->subkeys->pubkey_algo);
+ keyid = key->subkeys->keyid;
g_string_append_printf(siginfo,
- _("Signature made %s using %s key ID %s\n"),
- timestr, keytype, keyid);
+ _("Signature made using %s key ID %s\n"),
+ keytype, keyid);
- sigstatus = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_SIG_STATUS, 0);
- uid = gpgme_key_get_string_attr(key, GPGME_ATTR_USERID, NULL, 0);
- switch (sigstatus) {
- case GPGME_SIG_STAT_GOOD:
- case GPGME_SIG_STAT_GOOD_EXPKEY:
+ uid = user->uid;
+ switch (gpg_err_code(sig->status)) {
+ case GPG_ERR_NO_ERROR:
+ case GPG_ERR_KEY_EXPIRED:
g_string_append_printf(siginfo,
_("Good signature from \"%s\"\n"),
uid);
break;
- case GPGME_SIG_STAT_GOOD_EXP:
+ case GPG_ERR_SIG_EXPIRED:
g_string_append_printf(siginfo,
_("Expired signature from \"%s\"\n"),
uid);
break;
- case GPGME_SIG_STAT_BAD:
+ case GPG_ERR_BAD_SIGNATURE:
g_string_append_printf(siginfo,
_("BAD signature from \"%s\"\n"),
uid);
default:
break;
}
- if (sigstatus != GPGME_SIG_STAT_BAD) {
+ if (sig->status != GPG_ERR_BAD_SIGNATURE) {
gint j = 1;
-
- while ((uid = gpgme_key_get_string_attr(key, GPGME_ATTR_USERID, NULL, j)) != 0) {
+ user = user->next;
+ while (user != NULL) {
g_string_append_printf(siginfo,
_(" aka \"%s\"\n"),
- uid);
+ user->uid);
j++;
+ user = user->next;
}
g_string_append_printf(siginfo,
_("Primary key fingerprint: %s\n"),
- gpgme_key_get_string_attr(key, GPGME_ATTR_FPR, NULL, 0));
- }
-
-
- expiretime = gpgme_get_sig_ulong_attr(ctx, i, GPGME_ATTR_EXPIRE, 0);
- if (expiretime > 0) {
- const gchar *format;
-
- strftime(timestr, 64, "%c", gmtime(&expiretime));
- if (time(NULL) < expiretime)
- format = _("Signature expires %s\n");
- else
- format = _("Signature expired %s\n");
- g_string_append_printf(siginfo, format, timestr);
+ sig->fpr);
}
g_string_append(siginfo, "\n");
i++;
+ sig = sig->next;
}
ret = siginfo->str;
return ret;
}
-GpgmeData sgpgme_data_from_mimeinfo(MimeInfo *mimeinfo)
+gpgme_data_t sgpgme_data_from_mimeinfo(MimeInfo *mimeinfo)
{
- GpgmeData data;
-
- gpgme_data_new_from_filepart(&data,
- mimeinfo->data.filename,
- NULL,
- mimeinfo->offset,
- mimeinfo->length);
+ gpgme_data_t data = NULL;
+ gpgme_error_t err;
+ FILE *fp = fopen(mimeinfo->data.filename, "rb");
+ gchar *tmp_file = NULL;
+
+ if (!fp)
+ return NULL;
+
+ tmp_file = get_tmp_file();
+ copy_file_part(fp, mimeinfo->offset, mimeinfo->length, tmp_file);
+ fclose(fp);
+ fp = fopen(tmp_file, "rb");
+ debug_print("tmp file %s\n", tmp_file);
+ if (!fp)
+ return NULL;
+ err = gpgme_data_new_from_file(&data, tmp_file, 1);
+ unlink(tmp_file);
+ g_free(tmp_file);
+
+ debug_print("data %p (%d %d)\n", data, mimeinfo->offset, mimeinfo->length);
+ if (err) {
+ debug_print ("gpgme_data_new_from_file failed: %s\n",
+ gpgme_strerror (err));
+ return NULL;
+ }
return data;
}
-GpgmeData sgpgme_decrypt_verify(GpgmeData cipher, GpgmeSigStat *status, GpgmeCtx ctx)
+gpgme_data_t sgpgme_decrypt_verify(gpgme_data_t cipher, gpgme_verify_result_t *status, gpgme_ctx_t ctx)
{
struct passphrase_cb_info_s info;
- GpgmeData plain;
- GpgmeError err;
+ gpgme_data_t plain;
+ gpgme_error_t err;
memset (&info, 0, sizeof info);
- if (gpgme_data_new(&plain) != GPGME_No_Error) {
+ if (gpgme_data_new(&plain) != GPG_ERR_NO_ERROR) {
gpgme_release(ctx);
return NULL;
}
gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);
}
- err = gpgme_op_decrypt_verify(ctx, cipher, plain, status);
-
- if (err != GPGME_No_Error) {
+ err = gpgme_op_decrypt_verify(ctx, cipher, plain);
+ if (err != GPG_ERR_NO_ERROR) {
+ debug_print("can't decrypt (%s)\n", gpgme_strerror(err));
gpgmegtk_free_passphrase();
gpgme_data_release(plain);
return NULL;
}
+ err = gpgme_data_rewind(plain); /* why doesn't gpgme_data_seek() work here?! */
+/* err = gpgme_data_seek(plain, 0, SEEK_SET);*/
+ if (err) {
+ debug_print("can't seek (%d %d %s)\n", err, errno, strerror(errno));
+ }
+
+ debug_print("decrypted.\n");
+ *status = gpgme_op_verify_result (ctx);
+
return plain;
}
gchar *sgpgme_get_encrypt_data(GSList *recp_names)
{
-
- GpgmeRecipients recp;
- GString *encdata;
- void *iter;
- const gchar *recipient;
- gchar *data;
-
- recp = gpgmegtk_recipient_selection(recp_names);
- if (recp == NULL)
- return NULL;
-
- if (gpgme_recipients_enum_open(recp, &iter) != GPGME_No_Error) {
- gpgme_recipients_release(recp);
- return NULL;
- }
-
- encdata = g_string_sized_new(64);
- while ((recipient = gpgme_recipients_enum_read(recp, &iter)) != NULL) {
- if (encdata->len > 0)
- g_string_append_c(encdata, ' ');
- g_string_append(encdata, recipient);
+ gpgme_key_t *keys = gpgmegtk_recipient_selection(recp_names);
+ gchar *ret = NULL;
+ int i = 0;
+ while (keys[i]) {
+ gpgme_subkey_t skey = keys[i]->subkeys;
+ gchar *fpr = skey->fpr;
+ gchar *tmp = NULL;
+ debug_print("adding %s\n", fpr);
+ tmp = g_strconcat(ret?ret:"", fpr, " ", NULL);
+ g_free(ret);
+ ret = tmp;
+ i++;
}
-
- gpgme_recipients_release(recp);
-
- data = encdata->str;
- g_string_free(encdata, FALSE);
-
- return data;
+ return ret;
}
-gboolean sgpgme_setup_signers(GpgmeCtx ctx, PrefsAccount *account)
+gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account)
{
GPGAccountConfig *config;
if (config->sign_key != SIGN_KEY_DEFAULT) {
gchar *keyid;
- GpgmeKey key;
+ gpgme_key_t key;
if (config->sign_key == SIGN_KEY_BY_FROM)
keyid = account->address;
gpgme_op_keylist_start(ctx, keyid, 1);
while (!gpgme_op_keylist_next(ctx, &key)) {
- debug_print("adding key: %s\n",
- gpgme_key_get_string_attr(key, GPGME_ATTR_KEYID, NULL, 0));
gpgme_signers_add(ctx, key);
gpgme_key_release(key);
}
void sgpgme_init()
{
- if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) !=
- GPGME_No_Error) { /* Also does some gpgme init */
+ gpgme_engine_info_t engineInfo;
+ if (gpgme_check_version("0.4.5")) {
+ gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
+ gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
+ if (!gpgme_get_engine_info(&engineInfo)) {
+ while (engineInfo) {
+ debug_print("GpgME Protocol: %s\n Version: %s\n",
+ gpgme_get_protocol_name(engineInfo->protocol),
+ engineInfo->version);
+ engineInfo = engineInfo->next;
+ }
+ }
+ } else {
sgpgme_disable_all();
- debug_print("gpgme_engine_version:\n%s\n",
- gpgme_get_engine_info());
if (prefs_gpg_get_config()->gpg_warning) {
AlertValue val;
prefs_gpg_get_config()->gpg_warning = FALSE;
}
}
-
- gpgme_register_idle(idle_function_for_gpgme);
}
void sgpgme_done()
{
gpgmegtk_free_passphrase();
- gpgme_register_idle(NULL);
}
#endif /* USE_GPGME */
void sgpgme_init(void);
void sgpgme_done(void);
-GpgmeSigStat sgpgme_verify_signature (GpgmeCtx ctx,
- GpgmeData sig,
- GpgmeData plain);
+gpgme_verify_result_t sgpgme_verify_signature (gpgme_ctx_t ctx,
+ gpgme_data_t sig,
+ gpgme_data_t plain,
+ gpgme_data_t dummy);
SignatureStatus sgpgme_sigstat_gpgme_to_privacy
- (GpgmeCtx ctx,
- GpgmeSigStat status);
-gchar *sgpgme_sigstat_info_short (GpgmeCtx ctx,
- GpgmeSigStat status);
-gchar *sgpgme_sigstat_info_full (GpgmeCtx ctx,
- GpgmeSigStat status);
-GpgmeData sgpgme_data_from_mimeinfo (MimeInfo *mimeinfo);
-GpgmeData sgpgme_decrypt_verify (GpgmeData cipher, GpgmeSigStat *status,
- GpgmeCtx ctx);
+ (gpgme_ctx_t ctx,
+ gpgme_verify_result_t status);
+gchar *sgpgme_sigstat_info_short (gpgme_ctx_t ctx,
+ gpgme_verify_result_t status);
+gchar *sgpgme_sigstat_info_full (gpgme_ctx_t ctx,
+ gpgme_verify_result_t status);
+gpgme_data_t sgpgme_data_from_mimeinfo (MimeInfo *mimeinfo);
+gpgme_data_t sgpgme_decrypt_verify (gpgme_data_t cipher,
+ gpgme_verify_result_t *status,
+ gpgme_ctx_t ctx);
gchar *sgpgme_get_encrypt_data (GSList *recp_names);
-gboolean sgpgme_setup_signers(GpgmeCtx ctx, PrefsAccount *account);
+gboolean sgpgme_setup_signers(gpgme_ctx_t ctx, PrefsAccount *account);
#endif /* SGPGME_H */
projects / claws.git / commitdiff