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); }