static void
on_import_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_import_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
g_autofree gchar *errmsg = NULL;
g_assert (closure->requests > 0);
seahorse_progress_end (closure->cancellable, GUINT_TO_POINTER (closure->requests));
closure->requests--;
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if ((errmsg = get_send_result (message->response_body->data)) != NULL) {
g_task_return_new_error (task, HKP_ERROR_DOMAIN, message->status_code,
"%s", errmsg);
return;
}
/* A successful status from the server is all we want in this case */
if (closure->requests == 0) {
/* We don't know which keys got imported, so just return NULL */
g_task_return_pointer (task, NULL, NULL);
}
}
static void
on_search_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_search_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
GError *error = NULL;
GList *keys, *l;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_simple_async_result_take_error (res, error);
} else {
keys = parse_hkp_index (message->response_body->data);
for (l = keys; l; l = g_list_next (l)) {
g_object_set (l->data, "place", closure->source, NULL);
gcr_simple_collection_add (closure->results, l->data);
}
g_list_free_full (keys, g_object_unref);
}
g_simple_async_result_complete_in_idle (res);
g_object_unref (res);
}
static void
on_search_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_search_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
GList *keys, *l;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
keys = parse_hkp_index (message->response_body->data);
for (l = keys; l; l = g_list_next (l)) {
g_object_set (l->data, "place", closure->source, NULL);
gcr_simple_collection_add (closure->results, l->data);
}
g_list_free_full (keys, g_object_unref);
g_task_return_boolean (task, TRUE);
}
static void
on_import_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_import_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
GError *error = NULL;
gchar *errmsg;
g_assert (closure->requests > 0);
seahorse_progress_end (closure->cancellable, GUINT_TO_POINTER (closure->requests));
closure->requests--;
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete_in_idle (res);
} else if ((errmsg = get_send_result (message->response_body->data)) != NULL) {
g_set_error (&error, HKP_ERROR_DOMAIN, message->status_code, "%s", errmsg);
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete_in_idle (res);
g_free (errmsg);
/* A successful status from the server is all we want in this case */
} else {
if (closure->requests == 0)
g_simple_async_result_complete_in_idle (res);
}
g_object_unref (res);
}
static void
import_send_key (SeahorseLDAPSource *self,
GSimpleAsyncResult *res)
{
source_import_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
LDAPServerInfo *sinfo;
gchar *base;
LDAPMod mod;
LDAPMod *attrs[2];
char *values[2];
GSource *gsource;
GError *error = NULL;
gchar *keydata;
int ldap_op;
int rc;
if (closure->current_index >= 0) {
keydata = closure->keydata->pdata[closure->current_index];
seahorse_progress_end (closure->cancellable, keydata);
}
closure->current_index++;
/* All done, complete operation */
if (closure->current_index == (gint)closure->keydata->len) {
g_simple_async_result_complete (res);
return;
}
keydata = closure->keydata->pdata[closure->current_index];
seahorse_progress_begin (closure->cancellable, keydata);
values[0] = keydata;
values[1] = NULL;
sinfo = get_ldap_server_info (self, TRUE);
memset (&mod, 0, sizeof (mod));
mod.mod_op = LDAP_MOD_ADD;
mod.mod_type = sinfo->key_attr;
mod.mod_values = values;
attrs[0] = &mod;
attrs[1] = NULL;
base = g_strdup_printf ("pgpCertid=virtual,%s", sinfo->base_dn);
rc = ldap_add_ext (closure->ldap, base, attrs, NULL, NULL, &ldap_op);
g_free (base);
if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
g_simple_async_result_complete (res);
return;
}
gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
closure->cancellable);
g_source_set_callback (gsource, (GSourceFunc)on_import_add_completed,
g_object_ref (res), g_object_unref);
g_source_attach (gsource, g_main_context_default ());
g_source_unref (gsource);
}
static void
export_retrieve_key (SeahorseLDAPSource *self,
GSimpleAsyncResult *res)
{
ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
LDAPServerInfo *sinfo;
gchar *filter;
char *attrs[2];
GSource *gsource;
const gchar *fingerprint;
GError *error = NULL;
int length, rc;
int ldap_op;
if (closure->current_index > 0) {
fingerprint = closure->fingerprints->pdata[closure->current_index];
seahorse_progress_end (closure->cancellable, fingerprint);
}
closure->current_index++;
/* All done, complete operation */
if (closure->current_index == (gint)closure->fingerprints->len) {
g_simple_async_result_complete (res);
return;
}
fingerprint = closure->fingerprints->pdata[closure->current_index];
seahorse_progress_begin (closure->cancellable, fingerprint);
length = strlen (fingerprint);
if (length > 16)
fingerprint += (length - 16);
filter = g_strdup_printf ("(pgpcertid=%.16s)", fingerprint);
sinfo = get_ldap_server_info (self, TRUE);
attrs[0] = sinfo->key_attr;
attrs[1] = NULL;
rc = ldap_search_ext (closure->ldap, sinfo->base_dn, LDAP_SCOPE_SUBTREE,
filter, attrs, 0,
NULL, NULL, NULL, 0, &ldap_op);
g_free (filter);
if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete (res);
return;
}
gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
closure->cancellable);
g_source_set_callback (gsource, (GSourceFunc)on_export_search_completed,
g_object_ref (res), g_object_unref);
g_source_attach (gsource, g_main_context_default ());
g_source_unref (gsource);
}
static gboolean
on_connect_bind_completed (LDAPMessage *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
LDAPServerInfo *sinfo;
GError *error = NULL;
char *message;
int ldap_op;
int code;
int rc;
g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_BIND, FALSE);
/* The result of the bind operation */
rc = ldap_parse_result (closure->ldap, result, &code, NULL, &message, NULL, NULL, 0);
g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
ldap_memfree (message);
if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete_in_idle (res);
return FALSE; /* don't call this callback again */
}
/* Check if we need server info */
sinfo = get_ldap_server_info (self, FALSE);
if (sinfo != NULL) {
g_simple_async_result_complete_in_idle (res);
seahorse_progress_end (closure->cancellable, res);
return FALSE; /* don't call this callback again */
}
/* Retrieve the server info */
rc = ldap_search_ext (closure->ldap, "cn=PGPServerInfo", LDAP_SCOPE_BASE,
"(objectclass=*)", (char **)SERVER_ATTRIBUTES, 0,
NULL, NULL, NULL, 0, &ldap_op);
if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete_in_idle (res);
return FALSE; /* don't call this callback again */
} else {
GSource *gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
closure->cancellable);
g_source_set_callback (gsource, (GSourceFunc)on_connect_server_info_completed,
g_object_ref (res), g_object_unref);
g_source_attach (gsource, g_main_context_default ());
g_source_unref (gsource);
}
return FALSE; /* don't call this callback again */
}
static gboolean
on_search_search_completed (LDAPMessage *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_search_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
GError *error = NULL;
char *message;
int code;
int type;
int rc;
type = ldap_msgtype (result);
g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
/* An LDAP entry */
if (type == LDAP_RES_SEARCH_ENTRY) {
g_debug ("Retrieved Key Entry");
#ifdef WITH_DEBUG
dump_ldap_entry (closure->ldap, result);
#endif
search_parse_key_from_ldap_entry (self, closure->results,
closure->ldap, result);
return TRUE; /* keep calling this callback */
/* All entries done */
} else {
rc = ldap_parse_result (closure->ldap, result, &code, NULL,
&message, NULL, NULL, 0);
g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
/* Error codes that we ignore */
switch (code) {
case LDAP_SIZELIMIT_EXCEEDED:
code = LDAP_SUCCESS;
break;
};
/* Failure */
if (code != LDAP_SUCCESS)
g_simple_async_result_set_error (res, LDAP_ERROR_DOMAIN,
code, "%s", message);
else if (seahorse_ldap_source_propagate_error (self, code, &error))
g_simple_async_result_take_error (res, error);
ldap_memfree (message);
seahorse_progress_end (closure->cancellable, res);
g_simple_async_result_complete (res);
return FALSE;
}
}
static gboolean
on_connect_server_info_completed (LDAPMessage *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
LDAPServerInfo *sinfo;
char *message;
int code;
int type;
int rc;
type = ldap_msgtype (result);
g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
/* If we have results then fill in the server info */
if (type == LDAP_RES_SEARCH_ENTRY) {
g_debug ("Server Info Result");
#ifdef WITH_DEBUG
dump_ldap_entry (closure->ldap, result);
#endif
/* NOTE: When adding attributes here make sure to add them to kServerAttributes */
sinfo = g_new0 (LDAPServerInfo, 1);
sinfo->version = get_int_attribute (closure->ldap, result, "version");
sinfo->base_dn = get_string_attribute (closure->ldap, result, "basekeyspacedn");
if (!sinfo->base_dn)
sinfo->base_dn = get_string_attribute (closure->ldap, result, "pgpbasekeyspacedn");
sinfo->key_attr = g_strdup (sinfo->version > 1 ? "pgpkeyv2" : "pgpkey");
set_ldap_server_info (self, sinfo);
return TRUE; /* callback again */
} else {
rc = ldap_parse_result (closure->ldap, result, &code, NULL,
&message, NULL, NULL, 0);
g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
if (code != LDAP_SUCCESS)
g_warning ("operation to get LDAP server info failed: %s", message);
ldap_memfree (message);
g_simple_async_result_complete_in_idle (res);
seahorse_progress_end (closure->cancellable, res);
return FALSE; /* don't callback again */
}
}
static void
on_export_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
ExportClosure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
const gchar *start, *end, *text;
guint len;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
end = text = message->response_body->data;
len = message->response_body->length;
for (;;) {
len -= end - text;
text = end;
if (!detect_key (text, len, &start, &end))
break;
g_string_append_len (closure->data, start, end - start);
g_string_append_c (closure->data, '\n');
}
g_assert (closure->requests > 0);
closure->requests--;
if (closure->requests == 0) {
closure->data_len = closure->data->len;
g_task_return_pointer (task,
g_string_free (g_steal_pointer (&closure->data), FALSE),
g_free);
}
}
static void
on_export_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
GError *error = NULL;
const gchar *start;
const gchar *end;
const gchar *text;
guint len;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_simple_async_result_take_error (res, error);
} else {
end = text = message->response_body->data;
len = message->response_body->length;
for (;;) {
len -= end - text;
text = end;
if (!detect_key (text, len, &start, &end))
break;
g_string_append_len (closure->data, start, end - start);
g_string_append_c (closure->data, '\n');
}
}
g_assert (closure->requests > 0);
closure->requests--;
if (closure->requests == 0)
g_simple_async_result_complete_in_idle (res);
g_object_unref (res);
}
