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 SeahorseOperation*
seahorse_hkp_source_search (SeahorseSource *src, const gchar *match)
{
SeahorseHKPOperation *hop;
SoupMessage *message;
GHashTable *form;
gchar *t;
SoupURI *uri;
gchar hexfpr[11];
g_assert (SEAHORSE_IS_SOURCE (src));
g_assert (SEAHORSE_IS_HKP_SOURCE (src));
hop = setup_hkp_operation (SEAHORSE_HKP_SOURCE (src));
uri = get_http_server_uri (src, "/pks/lookup");
g_return_val_if_fail (uri, FALSE);
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);
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 (hop->session, message,
(SoupSessionCallback)refresh_callback, hop);
hop->total = hop->requests = 1;
t = g_strdup_printf (_("Searching for keys on: %s"), uri->host);
seahorse_operation_mark_progress (SEAHORSE_OPERATION (hop), t, -1);
g_free (t);
soup_uri_free (uri);
seahorse_server_source_take_operation (SEAHORSE_SERVER_SOURCE (src),
SEAHORSE_OPERATION (hop));
g_object_ref (hop);
return SEAHORSE_OPERATION (hop);
}
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);
}
static SeahorseOperation*
seahorse_hkp_source_export_raw (SeahorseSource *sksrc, GSList *keyids,
GOutputStream *output)
{
SeahorseHKPOperation *hop;
SeahorseHKPSource *hsrc;
SoupMessage *message;
gchar *t;
SoupURI *uri;
const gchar *fpr;
gchar hexfpr[11];
GHashTable *form;
guint len;
GSList *l;
g_return_val_if_fail (SEAHORSE_IS_HKP_SOURCE (sksrc), NULL);
g_return_val_if_fail (output == NULL || G_IS_OUTPUT_STREAM (output), NULL);
hsrc = SEAHORSE_HKP_SOURCE (sksrc);
if (g_slist_length (keyids) == 0)
return seahorse_operation_new_complete (NULL);
uri = get_http_server_uri (sksrc, "/pks/lookup");
g_return_val_if_fail (uri, FALSE);
/* New operation started */
hop = setup_hkp_operation (hsrc);
g_object_ref (output);
seahorse_operation_mark_result (SEAHORSE_OPERATION (hop), output, g_object_unref);
/* 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 (l = keyids; l; l = g_slist_next (l)) {
/* Get the key id and limit it to 8 characters */
fpr = seahorse_pgp_key_calc_rawid (GPOINTER_TO_UINT (l->data));
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 (hop->session, message,
(SoupSessionCallback)get_callback, hop);
hop->requests++;
}
g_hash_table_destroy (form);
hop->total = hop->requests;
t = g_strdup_printf (_("Connecting to: %s"), uri->host);
seahorse_operation_mark_progress (SEAHORSE_OPERATION (hop), t, -1);
g_free (t);
soup_uri_free (uri);
return SEAHORSE_OPERATION (hop);
}
static SeahorseOperation*
seahorse_hkp_source_import (SeahorseSource *sksrc, GInputStream *input)
{
SeahorseHKPOperation *hop;
SeahorseHKPSource *hsrc;
SoupMessage *message;
GSList *keydata = NULL;
GString *buf = NULL;
GHashTable *form;
gchar *key, *t;
SoupURI *uri;
GSList *l;
guint len;
g_return_val_if_fail (SEAHORSE_IS_HKP_SOURCE (sksrc), NULL);
hsrc = SEAHORSE_HKP_SOURCE (sksrc);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_object_ref (input);
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_slist_prepend (keydata, g_string_free (buf, FALSE));
} else {
g_string_free (buf, TRUE);
break;
}
}
if (g_slist_length (keydata) == 0) {
g_object_unref (input);
return seahorse_operation_new_complete (NULL);
}
/* Figure out the URI we're sending to */
uri = get_http_server_uri (sksrc, "/pks/add");
g_return_val_if_fail (uri, FALSE);
/* New operation and away we go */
keydata = g_slist_reverse (keydata);
hop = setup_hkp_operation (hsrc);
form = g_hash_table_new (g_str_hash, g_str_equal);
for (l = keydata; l; l = g_slist_next (l)) {
g_assert (l->data != NULL);
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 (hop->session, message,
(SoupSessionCallback)send_callback, hop);
hop->requests++;
}
g_hash_table_destroy (form);
hop->total = hop->requests;
t = g_strdup_printf (_("Connecting to: %s"), uri->host);
seahorse_operation_mark_progress (SEAHORSE_OPERATION (hop), t, -1);
g_free (t);
soup_uri_free (uri);
seahorse_util_string_slist_free (keydata);
g_object_unref (input);
return SEAHORSE_OPERATION (hop);
}