static void pgpview_show_mime_part(TextView *textview, MimeInfo *partinfo)
{
GtkTextView *text;
GtkTextBuffer *buffer;
GtkTextIter iter;
gpgme_data_t sigdata = NULL;
gpgme_verify_result_t sigstatus = NULL;
gpgme_ctx_t ctx = NULL;
gpgme_key_t key = NULL;
gpgme_signature_t sig = NULL;
gpgme_error_t err = 0;
gboolean imported = FALSE;
if (!partinfo) return;
textview_set_font(textview, NULL);
textview_clear(textview);
text = GTK_TEXT_VIEW(textview->text);
buffer = gtk_text_view_get_buffer(text);
gtk_text_buffer_get_start_iter(buffer, &iter);
err = gpgme_new (&ctx);
if (err) {
debug_print("err : %s\n", gpgme_strerror(err));
textview_show_mime_part(textview, partinfo);
return;
}
sigdata = sgpgme_data_from_mimeinfo(partinfo);
if (!sigdata) {
g_warning("no sigdata");
textview_show_mime_part(textview, partinfo);
return;
}
/* Here we do not care about what data we attempt to verify with the
* signature, or about result of the verification - all we care about
* is that we find out ID of the key used to make this signature. */
sigstatus = sgpgme_verify_signature(ctx, sigdata, NULL, sigdata);
if (!sigstatus || sigstatus == GINT_TO_POINTER(-GPG_ERR_SYSTEM_ERROR)) {
g_warning("no sigstatus");
textview_show_mime_part(textview, partinfo);
return;
}
sig = sigstatus->signatures;
if (!sig) {
g_warning("no sig");
textview_show_mime_part(textview, partinfo);
return;
}
gpgme_get_key(ctx, sig->fpr, &key, 0);
if (!key) {
gchar *gpgbin = get_gpg_executable_name();
gchar *cmd = g_strdup_printf("\"%s\" --batch --no-tty --recv-keys %s",
(gpgbin ? gpgbin : "gpg"), sig->fpr);
AlertValue val = G_ALERTDEFAULT;
if (!prefs_common_get_prefs()->work_offline) {
val = alertpanel(_("Key import"),
_("This key is not in your keyring. Do you want "
"Claws Mail to try and import it from a "
"keyserver?"),
GTK_STOCK_NO, GTK_STOCK_YES, NULL, ALERTFOCUS_SECOND);
GTK_EVENTS_FLUSH();
}
if (val == G_ALERTDEFAULT) {
TEXTVIEW_INSERT(_("\n Key ID "));
TEXTVIEW_INSERT(sig->fpr);
TEXTVIEW_INSERT(":\n\n");
TEXTVIEW_INSERT(_(" This key is not in your keyring.\n"));
TEXTVIEW_INSERT(_(" It should be possible to import it "));
if (prefs_common_get_prefs()->work_offline)
TEXTVIEW_INSERT(_("when working online,\n or "));
TEXTVIEW_INSERT(_("with the following command: \n\n "));
TEXTVIEW_INSERT(cmd);
} else {
TEXTVIEW_INSERT(_("\n Importing key ID "));
TEXTVIEW_INSERT(sig->fpr);
TEXTVIEW_INSERT(":\n\n");
main_window_cursor_wait(mainwindow_get_mainwindow());
textview_cursor_wait(textview);
GTK_EVENTS_FLUSH();
#ifndef G_OS_WIN32
int res = 0;
pid_t pid = 0;
pid = fork();
if (pid == -1) {
res = -1;
} else if (pid == 0) {
/* son */
gchar **argv;
argv = strsplit_with_quote(cmd, " ", 0);
res = execvp(argv[0], argv);
perror("execvp");
exit(255);
} else {
int status = 0;
time_t start_wait = time(NULL);
res = -1;
do {
if (waitpid(pid, &status, WNOHANG) == 0 || !WIFEXITED(status)) {
usleep(200000);
} else {
res = WEXITSTATUS(status);
break;
}
if (time(NULL) - start_wait > 9) {
debug_print("SIGTERM'ing gpg %d\n", pid);
kill(pid, SIGTERM);
}
if (time(NULL) - start_wait > 10) {
debug_print("SIGKILL'ing gpg %d\n", pid);
kill(pid, SIGKILL);
break;
}
} while(1);
}
debug_print("res %d\n", res);
if (res == 0)
imported = TRUE;
#else
/* We need to call gpg in a separate thread, so that waiting for
* it to finish does not block the UI. */
pthread_t pt;
struct _ImportCtx *ctx = malloc(sizeof(struct _ImportCtx));
ctx->done = FALSE;
ctx->exitcode = STILL_ACTIVE;
ctx->cmd = cmd;
if (pthread_create(&pt, NULL,
_import_threaded, (void *)ctx) != 0) {
debug_print("Couldn't create thread, continuing unthreaded.\n");
_import_threaded(ctx);
} else {
debug_print("Thread created, waiting for it to finish...\n");
while (!ctx->done)
claws_do_idle();
}
debug_print("Thread finished.\n");
pthread_join(pt, NULL);
if (ctx->exitcode == 0) {
imported = TRUE;
}
g_free(ctx);
#endif
main_window_cursor_normal(mainwindow_get_mainwindow());
textview_cursor_normal(textview);
if (imported) {
TEXTVIEW_INSERT(_(" This key has been imported to your keyring.\n"));
} else {
TEXTVIEW_INSERT(_(" This key couldn't be imported to your keyring.\n"));
TEXTVIEW_INSERT(_(" Key servers are sometimes slow.\n"));
TEXTVIEW_INSERT(_(" You can try to import it manually with the command:\n\n "));
TEXTVIEW_INSERT(cmd);
}
}
g_free(cmd);
return;
} else {
TEXTVIEW_INSERT(_("\n Key ID "));
#if defined GPGME_VERSION_NUMBER && GPGME_VERSION_NUMBER >= 0x010700
TEXTVIEW_INSERT(key->fpr);
#else
TEXTVIEW_INSERT(sig->fpr);
#endif
TEXTVIEW_INSERT(":\n\n");
TEXTVIEW_INSERT(_(" This key is in your keyring.\n"));
}
gpgme_data_release(sigdata);
gpgme_release(ctx);
textview_show_icon(textview, GTK_STOCK_DIALOG_AUTHENTICATION);
}
static gint pgpinline_check_signature(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = NULL;
gchar *textdata = NULL, *tmp = NULL;
gpgme_data_t plain = NULL, cipher = NULL;
gpgme_error_t err;
cm_return_val_if_fail(mimeinfo != NULL, 0);
if (procmime_mimeinfo_parent(mimeinfo) == NULL) {
privacy_set_error(_("Incorrect part"));
return 0; /* not parent */
}
if (mimeinfo->type != MIMETYPE_TEXT) {
privacy_set_error(_("Not a text part"));
debug_print("type %d\n", mimeinfo->type);
return 0;
}
cm_return_val_if_fail(mimeinfo->privacy != NULL, 0);
data = (PrivacyDataPGP *) mimeinfo->privacy;
textdata = get_part_as_string(mimeinfo);
if (!textdata) {
g_free(textdata);
privacy_set_error(_("Couldn't get text data."));
return 0;
}
/* gtk2: convert back from utf8 */
tmp = conv_codeset_strdup(textdata, CS_UTF_8,
procmime_mimeinfo_get_parameter(mimeinfo, "charset"));
if (!tmp) {
tmp = conv_codeset_strdup(textdata, CS_UTF_8,
conv_get_locale_charset_str_no_utf8());
}
if (!tmp) {
g_warning("Can't convert charset to anything sane");
tmp = conv_codeset_strdup(textdata, CS_UTF_8, CS_US_ASCII);
}
g_free(textdata);
if (!tmp) {
privacy_set_error(_("Couldn't convert text data to any sane charset."));
return 0;
}
textdata = g_strdup(tmp);
g_free(tmp);
if ((err = gpgme_new(&data->ctx)) != GPG_ERR_NO_ERROR) {
debug_print(("Couldn't initialize GPG context, %s"), gpgme_strerror(err));
privacy_set_error(_("Couldn't initialize GPG context, %s"), gpgme_strerror(err));
g_free(textdata);
return 0;
}
gpgme_set_textmode(data->ctx, 1);
gpgme_set_armor(data->ctx, 1);
gpgme_data_new_from_mem(&plain, textdata, (size_t)strlen(textdata), 1);
gpgme_data_new(&cipher);
data->sigstatus = sgpgme_verify_signature(data->ctx, plain, NULL, cipher);
gpgme_data_release(plain);
gpgme_data_release(cipher);
g_free(textdata);
return 0;
}
static gint pgpmime_check_signature(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data;
MimeInfo *parent, *signature;
FILE *fp;
gchar *boundary;
gchar *textstr;
gpgme_data_t sigdata = NULL, textdata = NULL;
gpgme_error_t err;
cm_return_val_if_fail(mimeinfo != NULL, -1);
cm_return_val_if_fail(mimeinfo->privacy != NULL, -1);
data = (PrivacyDataPGP *) mimeinfo->privacy;
if ((err = gpgme_new(&data->ctx)) != GPG_ERR_NO_ERROR) {
debug_print(("Couldn't initialize GPG context, %s\n"), gpgme_strerror(err));
privacy_set_error(_("Couldn't initialize GPG context, %s"), gpgme_strerror(err));
return 0;
}
debug_print("Checking PGP/MIME signature\n");
err = gpgme_set_protocol(data->ctx, GPGME_PROTOCOL_OpenPGP);
if (err) {
debug_print ("gpgme_set_protocol failed: %s\n",
gpgme_strerror (err));
}
parent = procmime_mimeinfo_parent(mimeinfo);
fp = claws_fopen(parent->data.filename, "rb");
cm_return_val_if_fail(fp != NULL, SIGNATURE_INVALID);
boundary = g_hash_table_lookup(parent->typeparameters, "boundary");
if (!boundary) {
privacy_set_error(_("Signature boundary not found."));
claws_fclose(fp);
return 0;
}
textstr = get_canonical_content(fp, boundary);
err = gpgme_data_new_from_mem(&textdata, textstr, (size_t)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);
err = 0;
if (signature->encoding_type == ENC_BASE64) {
err = gpgme_data_set_encoding (sigdata, GPGME_DATA_ENCODING_BASE64);
}
if (err) {
debug_print ("gpgme_data_set_encoding failed: %s\n",
gpgme_strerror (err));
}
data->sigstatus =
sgpgme_verify_signature (data->ctx, sigdata, textdata, NULL);
gpgme_data_release(sigdata);
gpgme_data_release(textdata);
g_free(textstr);
claws_fclose(fp);
return 0;
}
