static void
seahorse_ldap_source_search_async (SeahorseServerSource *source,
const gchar *match,
GcrSimpleCollection *results,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
source_search_closure *closure;
GSimpleAsyncResult *res;
gchar *text;
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_ldap_source_search_async);
closure = g_new0 (source_search_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->results = g_object_ref (results);
text = escape_ldap_value (match);
closure->filter = g_strdup_printf ("(pgpuserid=*%s*)", text);
g_free (text);
g_simple_async_result_set_op_res_gpointer (res, closure, source_search_free);
seahorse_progress_prep_and_begin (closure->cancellable, res, NULL);
seahorse_ldap_source_connect_async (self, cancellable,
on_search_connect_completed,
g_object_ref (res));
g_object_unref (res);
}
static void
seahorse_hkp_source_search_async (SeahorseServerSource *source,
const gchar *match,
GcrSimpleCollection *results,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SeahorseHKPSource *self = SEAHORSE_HKP_SOURCE (source);
source_search_closure *closure;
GSimpleAsyncResult *res;
SoupMessage *message;
GHashTable *form;
SoupURI *uri;
gchar hexfpr[11];
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_hkp_source_search_async);
closure = g_new0 (source_search_closure, 1);
closure->source = g_object_ref (self);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->session = create_hkp_soup_session ();
closure->results = g_object_ref (results);
g_simple_async_result_set_op_res_gpointer (res, closure, source_search_free);
uri = get_http_server_uri (self, "/pks/lookup");
g_return_if_fail (uri);
form = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (form, "op", "index");
if (is_hex_keyid (match)) {
strncpy (hexfpr, "0x", 3);
strncpy (hexfpr + 2, match, 9);
g_hash_table_insert (form, "search", hexfpr);
} else {
g_hash_table_insert (form, "search", (char *)match);
}
g_hash_table_insert (form, "fingerprint", "on");
soup_uri_set_query_from_form (uri, form);
g_hash_table_destroy (form);
message = soup_message_new_from_uri ("GET", uri);
soup_session_queue_message (closure->session, message,
on_search_message_complete, g_object_ref (res));
seahorse_progress_prep_and_begin (cancellable, message, NULL);
if (cancellable)
closure->cancelled_sig = g_cancellable_connect (cancellable,
G_CALLBACK (on_session_cancelled),
closure->session, NULL);
soup_uri_free (uri);
g_object_unref (res);
}
static void
seahorse_ldap_source_connect_async (SeahorseLDAPSource *source,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
source_connect_closure *closure;
gchar *server = NULL;
gchar *pos;
#ifdef WITH_SOUP
SoupAddress *address;
#endif
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_ldap_source_connect_async);
closure = g_new0 (source_connect_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
g_simple_async_result_set_op_res_gpointer (res, closure, source_connect_free);
g_object_get (source, "key-server", &server, NULL);
g_return_if_fail (server && server[0]);
if ((pos = strchr (server, ':')) != NULL)
*pos = 0;
seahorse_progress_prep_and_begin (cancellable, res, NULL);
/* If we have libsoup, try and resolve asynchronously */
#ifdef WITH_SOUP
address = soup_address_new (server, LDAP_PORT);
seahorse_progress_update (cancellable, res, _("Resolving server address: %s"), server);
soup_address_resolve_async (address, NULL, cancellable,
on_address_resolved_complete,
g_object_ref (res));
g_object_unref (address);
#else /* !WITH_SOUP */
once_resolved_start_connect (source, res, server);
#endif
g_free (server);
g_object_unref (res);
}
static void
seahorse_hkp_source_export_async (SeahorseServerSource *source,
const gchar **keyids,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SeahorseHKPSource *self = SEAHORSE_HKP_SOURCE (source);
ExportClosure *closure;
g_autoptr(GTask) task = NULL;
SoupURI *uri;
g_autoptr(GHashTable) form = NULL;
gchar hexfpr[11];
gint i;
task = g_task_new (self, cancellable, callback, user_data);
closure = g_new0 (ExportClosure, 1);
closure->source = g_object_ref (self);
closure->data = g_string_sized_new (1024);
closure->session = create_hkp_soup_session ();
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
g_task_set_task_data (task, closure, export_closure_free);
if (!keyids || !keyids[0]) {
g_task_return_pointer (task, NULL, NULL);
return;
}
uri = get_http_server_uri (self, "/pks/lookup");
g_return_if_fail (uri);
/* prepend the hex prefix (0x) to make keyservers happy */
strncpy (hexfpr, "0x", 3);
form = g_hash_table_new (g_str_hash, g_str_equal);
for (i = 0; keyids[i] != NULL; i++) {
const gchar *fpr = keyids[i];
guint len;
SoupMessage *message;
g_hash_table_remove_all (form);
/* Get the key id and limit it to 8 characters */
len = strlen (fpr);
if (len > 8)
fpr += (len - 8);
strncpy (hexfpr + 2, fpr, 9);
/* The get key URI */
g_hash_table_insert (form, "op", "get");
g_hash_table_insert (form, "search", (char *)hexfpr);
soup_uri_set_query_from_form (uri, form);
message = soup_message_new_from_uri ("GET", uri);
soup_session_queue_message (closure->session, message,
on_export_message_complete,
g_object_ref (task));
closure->requests++;
seahorse_progress_prep_and_begin (cancellable, message, NULL);
}
if (cancellable)
closure->cancelled_sig = g_cancellable_connect (cancellable,
G_CALLBACK (on_session_cancelled),
closure->session, NULL);
}
static void
seahorse_hkp_source_import_async (SeahorseServerSource *source,
GInputStream *input,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SeahorseHKPSource *self = SEAHORSE_HKP_SOURCE (source);
g_autoptr(GTask) task = NULL;
source_import_closure *closure;
g_autoptr(GList) keydata = NULL;
g_autoptr(GHashTable) form = NULL;
g_autoptr(SoupURI) uri = NULL;
GList *l;
task = g_task_new (source, cancellable, callback, user_data);
closure = g_new0 (source_import_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->input = g_object_ref (input);
closure->source = g_object_ref (self);
closure->session = create_hkp_soup_session ();
g_task_set_task_data (task, closure, source_import_free);
for (;;) {
g_autoptr(GString) buf = g_string_sized_new (2048);
guint len;
len = seahorse_util_read_data_block (buf, input,
"-----BEGIN PGP PUBLIC KEY BLOCK-----",
"-----END PGP PUBLIC KEY BLOCK-----");
if (len <= 0)
break;
keydata = g_list_prepend (keydata,
g_string_free (g_steal_pointer (&buf), FALSE));
}
if (g_list_length (keydata) == 0) {
g_task_return_pointer (task, NULL, NULL);
return;
}
/* Figure out the URI we're sending to */
uri = get_http_server_uri (self, "/pks/add");
g_return_if_fail (uri);
/* New operation and away we go */
keydata = g_list_reverse (keydata);
form = g_hash_table_new (g_str_hash, g_str_equal);
for (l = keydata; l; l = g_list_next (l)) {
g_autoptr(SoupMessage) message = NULL;
gchar *key;
g_assert (l->data != NULL);
g_hash_table_remove_all (form);
g_hash_table_insert (form, "keytext", l->data);
key = soup_form_encode_urlencoded (form);
message = soup_message_new_from_uri ("POST", uri);
soup_message_set_request (message, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, key, strlen (key));
soup_session_queue_message (closure->session,
g_steal_pointer (&message),
on_import_message_complete,
g_object_ref (task));
closure->requests++;
seahorse_progress_prep_and_begin (cancellable, GUINT_TO_POINTER (closure->requests), NULL);
}
if (cancellable)
closure->cancelled_sig = g_cancellable_connect (cancellable,
G_CALLBACK (on_session_cancelled),
closure->session, NULL);
for (l = keydata; l != NULL; l = g_list_next (l))
g_free (l->data);
}
/**
* sksrc: The HKP source to use
* input: The input stream to add
*
* Imports a list of keys from the input stream to the keyserver
**/
static void
seahorse_hkp_source_import_async (SeahorseServerSource *source,
GInputStream *input,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SeahorseHKPSource *self = SEAHORSE_HKP_SOURCE (source);
GSimpleAsyncResult *res;
source_import_closure *closure;
SoupMessage *message;
GList *keydata = NULL;
GString *buf = NULL;
GHashTable *form;
gchar *key;
SoupURI *uri;
GList *l;
guint len;
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_hkp_source_import_async);
closure = g_new0 (source_import_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->input = g_object_ref (input);
closure->source = g_object_ref (self);
closure->session = create_hkp_soup_session ();
g_simple_async_result_set_op_res_gpointer (res, closure, source_import_free);
for (;;) {
buf = g_string_sized_new (2048);
len = seahorse_util_read_data_block (buf, input,
"-----BEGIN PGP PUBLIC KEY BLOCK-----",
"-----END PGP PUBLIC KEY BLOCK-----");
if (len > 0) {
keydata = g_list_prepend (keydata, g_string_free (buf, FALSE));
} else {
g_string_free (buf, TRUE);
break;
}
}
if (g_list_length (keydata) == 0) {
g_simple_async_result_complete_in_idle (res);
g_object_unref (res);
return;
}
/* Figure out the URI we're sending to */
uri = get_http_server_uri (self, "/pks/add");
g_return_if_fail (uri);
/* New operation and away we go */
keydata = g_list_reverse (keydata);
form = g_hash_table_new (g_str_hash, g_str_equal);
for (l = keydata; l; l = g_list_next (l)) {
g_assert (l->data != NULL);
g_hash_table_remove_all (form);
g_hash_table_insert (form, "keytext", l->data);
key = soup_form_encode_urlencoded (form);
message = soup_message_new_from_uri ("POST", uri);
soup_message_set_request (message, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, key, strlen (key));
soup_session_queue_message (closure->session, message,
on_import_message_complete, g_object_ref (res));
closure->requests++;
seahorse_progress_prep_and_begin (cancellable, GUINT_TO_POINTER (closure->requests), NULL);
}
g_hash_table_destroy (form);
if (cancellable)
closure->cancelled_sig = g_cancellable_connect (cancellable,
G_CALLBACK (on_session_cancelled),
closure->session, NULL);
soup_uri_free (uri);
for (l = keydata; l != NULL; l = g_list_next (l))
g_free (l->data);
g_list_free (keydata);
g_object_unref (res);
}
