static void
handshake_thread_completed (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GTask *caller_task = user_data;
GTlsConnectionBase *tls = g_task_get_source_object (caller_task);
GError *error = NULL;
gboolean need_finish_handshake, success;
g_mutex_lock (&tls->op_mutex);
if (tls->need_finish_handshake)
{
need_finish_handshake = TRUE;
tls->need_finish_handshake = FALSE;
}
else
need_finish_handshake = FALSE;
g_mutex_unlock (&tls->op_mutex);
if (need_finish_handshake)
{
success = finish_handshake (tls, G_TASK (result), &error);
if (success)
g_task_return_boolean (caller_task, TRUE);
else
g_task_return_error (caller_task, error);
}
else if (tls->handshake_error)
g_task_return_error (caller_task, g_error_copy (tls->handshake_error));
else
g_task_return_boolean (caller_task, TRUE);
g_object_unref (caller_task);
}
void
ide_recent_projects_discover_async (IdeRecentProjects *self,
gboolean recent_only,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
gsize i;
g_return_if_fail (IDE_IS_RECENT_PROJECTS (self));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
if (self->discovered)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
_("%s() may only be executed once"),
G_STRFUNC);
return;
}
self->discovered = TRUE;
ide_recent_projects_load_recent (self);
if (recent_only)
{
g_task_return_boolean (task, TRUE);
return;
}
self->active = self->miners->len;
if (self->active == 0)
{
g_task_return_boolean (task, TRUE);
return;
}
for (i = 0; i < self->miners->len; i++)
{
IdeProjectMiner *miner;
miner = g_ptr_array_index (self->miners, i);
ide_project_miner_mine_async (miner,
self->cancellable,
ide_recent_projects__miner_mine_cb,
g_object_ref (task));
}
}
/* Cancels subscription of given id */
static void
cancel_subscription_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
ipp_t *request;
ipp_t *response = NULL;
gint id = GPOINTER_TO_INT (task_data);
if (id >= 0)
{
request = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, "/");
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser ());
ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
"notify-subscription-id", id);
response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
}
g_task_return_boolean (task, response != NULL && ippGetStatusCode (response) <= IPP_OK);
ippDelete (response);
}
static void
ide_async_helper_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = user_data;
GPtrArray *funcs;
GError *error = NULL;
g_return_if_fail (G_IS_TASK (task));
g_return_if_fail (G_IS_TASK (result));
funcs = g_task_get_task_data (task);
if (!g_task_propagate_boolean (G_TASK (result), &error))
{
g_task_return_error (task, error);
return;
}
g_ptr_array_remove_index (funcs, 0);
if (funcs->len)
{
IdeAsyncStep step;
step = g_ptr_array_index (funcs, 0);
step (g_task_get_source_object (task),
g_task_get_cancellable (task),
ide_async_helper_cb,
g_object_ref (task));
}
else
g_task_return_boolean (task, TRUE);
}
static void
on_reformatter_exited (GTask *task,
GError *error)
{
GisPage *page = GIS_PAGE (g_task_get_source_object (task));
gis_driver_show_window (page->driver);
if (error == NULL)
{
g_task_return_boolean (task, TRUE);
return;
}
GtkWindow *toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (page)));
GtkWidget *message_dialog;
g_critical ("Error running the reformatter: %s", error->message);
message_dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
/* Translators: this is shown when launching the
* reformatter (an external program) fails. The
* placeholder is an error message describing what went
* wrong.
*/
_("Error running the reformatter: %s"), error->message);
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, run_dialog_cb,
message_dialog, (GDestroyNotify) gtk_widget_destroy);
g_task_return_error (task, g_steal_pointer (&error));
}
static void
service_resolver_changed (GVfsDnsSdResolver *resolver,
GTask *task)
{
ResolveData *data = g_task_get_task_data (task);
if (resolver->is_resolved)
{
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
else
{
if (data->resolver->address != NULL)
{
/* keep going until timeout if we're missing TXT records */
}
else
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
/* Translators:
* - the first %s refers to the service type
* - the second %s refers to the service name
* - the third %s refers to the domain
*/
_("Error resolving “%s” service “%s” on domain “%s”"),
data->resolver->service_type,
data->resolver->service_name,
data->resolver->domain);
g_object_unref (task);
}
}
}
static void
ide_run_manager_run_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeRunner *runner = (IdeRunner *)object;
g_autoptr(GTask) task = user_data;
IdeRunManager *self;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_RUNNER (runner));
g_assert (G_IS_TASK (task));
self = g_task_get_source_object (task);
if (!ide_runner_run_finish (runner, result, &error))
{
g_task_return_error (task, error);
IDE_GOTO (failure);
}
g_task_return_boolean (task, TRUE);
failure:
g_signal_emit (self, signals [STOPPED], 0);
IDE_EXIT;
}
/**
* cd_profile_connect:
* @profile: a #CdProfile instance.
* @cancellable: a #GCancellable, or %NULL
* @callback: the function to run on completion
* @user_data: the data to pass to @callback
*
* Connects to the object and fills up initial properties.
*
* Since: 0.1.8
**/
void
cd_profile_connect (CdProfile *profile,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CdProfilePrivate *priv = GET_PRIVATE (profile);
GTask *task = NULL;
g_return_if_fail (CD_IS_PROFILE (profile));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
task = g_task_new (profile, cancellable, callback, user_data);
/* already connected */
if (priv->proxy != NULL) {
g_task_return_boolean (task, TRUE);
return;
}
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
COLORD_DBUS_SERVICE,
priv->object_path,
COLORD_DBUS_INTERFACE_PROFILE,
cancellable,
cd_profile_connect_cb,
task);
}
static void
gdk_clipboard_store_default_async (GdkClipboard *clipboard,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GdkClipboardPrivate *priv = gdk_clipboard_get_instance_private (clipboard);
GTask *task;
task = g_task_new (clipboard, cancellable, callback, user_data);
g_task_set_priority (task, io_priority);
g_task_set_source_tag (task, gdk_clipboard_store_default_async);
if (priv->local)
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("This clipboard cannot store data."));
}
else
{
g_task_return_boolean (task, TRUE);
}
g_object_unref (task);
}
static void
cd_sensor_unlock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
gboolean ret = FALSE;
g_autoptr(GError) error = NULL;
/* stop watching the dial */
libusb_cancel_transfer (priv->transfer_interrupt);
libusb_cancel_transfer (priv->transfer_state);
/* close */
if (priv->device != NULL) {
if (!g_usb_device_close (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
g_clear_object (&priv->device);
}
/* success */
g_task_return_boolean (task, TRUE);
}
static void
photos_base_item_create_thumbnail_in_thread_func (gpointer data, gpointer user_data)
{
GTask *task = G_TASK (data);
PhotosBaseItem *self;
GCancellable *cancellable;
GError *error;
gboolean op_res;
self = PHOTOS_BASE_ITEM (g_task_get_source_object (task));
cancellable = g_task_get_cancellable (task);
error = NULL;
op_res = PHOTOS_BASE_ITEM_GET_CLASS (self)->create_thumbnail (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_boolean (task, op_res);
out:
g_object_unref (task);
}
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_driver_registered (GsdSmartcardManager *self,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
DriverRegistrationOperation *operation;
GsdSmartcardManagerPrivate *priv = self->priv;
operation = g_task_get_task_data (G_TASK (result));
if (!register_driver_finish (self, result, &error)) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
watch_smartcards_from_driver_async (self,
operation->driver,
priv->cancellable,
(GAsyncReadyCallback) on_smartcards_from_driver_watched,
task);
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static void
cd_sensor_unlock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
g_autoptr(GError) error = NULL;
/* close */
if (priv->device != NULL) {
if (!g_usb_device_close (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
g_clear_object (&priv->device);
}
/* success */
g_task_return_boolean (task, TRUE);
}
static void
on_all_drivers_activated (GsdSmartcardManager *self,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
gboolean driver_activated;
PK11SlotInfo *login_token;
driver_activated = activate_all_drivers_async_finish (self, result, &error);
if (!driver_activated) {
g_task_return_error (task, error);
return;
}
login_token = gsd_smartcard_manager_get_login_token (self);
if (login_token || g_getenv ("PKCS11_LOGIN_TOKEN_NAME") != NULL) {
/* The card used to log in was removed before login completed.
* Do removal action immediately
*/
if (!login_token || !PK11_IsPresent (login_token))
gsd_smartcard_manager_do_remove_action (self);
}
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static void
gdav_options_request_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupRequestHTTP *request;
GTask *task = G_TASK (user_data);
AsyncContext *async_context;
GError *local_error = NULL;
request = SOUP_REQUEST_HTTP (source_object);
async_context = g_task_get_task_data (task);
gdav_request_send_finish (request, result, &local_error);
if (local_error == NULL) {
async_context->allow =
gdav_options_from_headers (
async_context->message->response_headers);
async_context->options =
gdav_options_from_headers (
async_context->message->response_headers);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_error (task, local_error);
}
g_object_unref (task);
}
static void
ide_subprocess_wait_check_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeSubprocess *self = (IdeSubprocess *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_SUBPROCESS (self));
g_assert (G_IS_TASK (task));
if (!ide_subprocess_wait_finish (self, result, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!ide_subprocess_check_exit_status (self, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
g_task_return_boolean (task, TRUE);
IDE_EXIT;
}
static void
dms_uim_set_pin_protection_ready (QmiClientDms *client,
GAsyncResult *res,
GTask *task)
{
QmiMessageDmsUimSetPinProtectionOutput *output = NULL;
GError *error = NULL;
MMSimQmi *self;
self = g_task_get_source_object (task);
output = qmi_client_dms_uim_set_pin_protection_finish (client, res, &error);
if (!output) {
g_prefix_error (&error, "QMI operation failed: ");
g_task_return_error (task, error);
} else if (!qmi_message_dms_uim_set_pin_protection_output_get_result (output, &error)) {
g_prefix_error (&error, "Couldn't enable PIN: ");
g_task_return_error (task, pin_qmi_error_to_mobile_equipment_error (error));
} else
g_task_return_boolean (task, TRUE);
if (output)
qmi_message_dms_uim_set_pin_protection_output_unref (output);
g_object_unref (task);
}
static void
read_from_stream (GTask *task,
gpointer source_obj,
gpointer task_data,
GCancellable *cancellable)
{
LoadData *data = task_data;
GError *error = NULL;
gssize res;
data->pos = 0;
g_byte_array_set_size (data->content, data->pos + GET_DATA_BLOCK_SIZE + 1);
while ((res = g_input_stream_read (data->stream,
data->content->data + data->pos,
GET_DATA_BLOCK_SIZE,
cancellable, &error)) > 0)
{
data->pos += res;
g_byte_array_set_size (data->content, data->pos + GET_DATA_BLOCK_SIZE + 1);
}
if (res < 0)
{
g_task_return_error (task, error);
return;
}
/* zero-terminate the content; we allocated an extra byte for this */
data->content->data[data->pos] = 0;
g_task_return_boolean (task, TRUE);
}
static void
ide_git_vcs_reload_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
IdeGitVcs *self = source_object;
g_autoptr(GgitRepository) repository1 = NULL;
g_autoptr(GgitRepository) repository2 = NULL;
GError *error = NULL;
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
if (!(repository1 = ide_git_vcs_load (self, &error)) ||
!(repository2 = ide_git_vcs_load (self, &error)))
{
g_task_return_error (task, error);
return;
}
g_set_object (&self->repository, repository1);
g_set_object (&self->change_monitor_repository, repository2);
if (!ide_git_vcs_load_monitor (self, &error))
{
g_task_return_error (task, error);
return;
}
g_task_return_boolean (task, TRUE);
}
void
ide_language_defaults_init_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
IDE_ENTRY;
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (NULL, cancellable, callback, user_data);
G_LOCK (lock);
if (initialized)
{
g_task_return_boolean (task, TRUE);
}
else if (initializing)
{
tasks = g_list_prepend (tasks, g_object_ref (task));
}
else
{
initializing = TRUE;
g_task_run_in_thread (task, ide_language_defaults_init_worker);
}
G_UNLOCK (lock);
IDE_EXIT;
}
static void
extract_gibest_hash (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = source_object;
guint64 buffer[2][CHUNK_N_BYTES/8];
GInputStream *stream = NULL;
gssize n_bytes, file_size;
GError *error = NULL;
guint64 hash = 0;
gint i;
char *str;
ResolveData *resolve_data = task_data;
GrlLocalMetadataSourcePriv *priv;
priv = GRL_LOCAL_METADATA_SOURCE_GET_PRIVATE (resolve_data->source);
stream = G_INPUT_STREAM (g_file_read (file, cancellable, &error));
if (stream == NULL)
goto fail;
/* Extract start/end chunks of the file */
n_bytes = g_input_stream_read (stream, buffer[0], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
if (!g_seekable_seek (G_SEEKABLE (stream), -CHUNK_N_BYTES, G_SEEK_END, cancellable, &error))
goto fail;
n_bytes = g_input_stream_read (stream, buffer[1], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
for (i = 0; i < G_N_ELEMENTS (buffer[0]); i++)
hash += buffer[0][i] + buffer[1][i];
file_size = g_seekable_tell (G_SEEKABLE (stream));
if (file_size < CHUNK_N_BYTES)
goto fail;
/* Include file size */
hash += file_size;
g_object_unref (stream);
str = g_strdup_printf ("%" G_GINT64_FORMAT, hash);
grl_data_set_string (GRL_DATA (resolve_data->rs->media), priv->hash_keyid, str);
g_free (str);
g_task_return_boolean (task, TRUE);
return;
fail:
GRL_DEBUG ("Could not get file hash: %s\n", error ? error->message : "Unknown error");
g_task_return_error (task, error);
g_clear_object (&stream);
}
static void
try_to_complete_all_drivers_activation (GTask *task)
{
ActivateAllDriversOperation *operation;
operation = g_task_get_task_data (task);
if (operation->pending_drivers_count > 0)
return;
if (operation->activated_drivers_count > 0)
g_task_return_boolean (task, TRUE);
else
g_task_return_boolean (task, FALSE);
g_object_unref (task);
}
static void
ide_context_addin_real_load_project_async (IdeContextAddin *addin,
IdeContext *context,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = g_task_new (addin, cancellable, callback, user_data);
g_task_return_boolean (task, TRUE);
}
static void
gdav_request_splice_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupMessage *message;
GTask *task = G_TASK (user_data);
GError *local_error = NULL;
message = g_task_get_task_data (task);
g_output_stream_splice_finish (
G_OUTPUT_STREAM (source_object), result, &local_error);
if (local_error != NULL) {
g_task_return_error (task, local_error);
/* XXX That the input stream's content is not automatically
* copied to the SoupMessage's response_body is a known
* libsoup bug which may be fixed in a future release.
* Check that the response body is empty so we don't
* accidentally duplicate the body. */
} else if (message->response_body->data == NULL) {
GMemoryOutputStream *output_stream;
gpointer data;
gsize size;
output_stream = G_MEMORY_OUTPUT_STREAM (source_object);
size = g_memory_output_stream_get_data_size (output_stream);
data = g_memory_output_stream_steal_data (output_stream);
soup_message_body_append_take (
message->response_body, data, size);
soup_message_body_flatten (message->response_body);
soup_message_finished (message);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_boolean (task, TRUE);
}
g_object_unref (task);
}
void
load_in_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CbMediaDownloader *downloader = source_object;
CbMedia *media = task_data;
cb_media_downloader_load_threaded (downloader, media);
g_task_return_boolean (task, TRUE);
}
static void
_pp_maintenance_command_is_supported_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
PpMaintenanceCommand *command = PP_MAINTENANCE_COMMAND (source_object);
PpMaintenanceCommandPrivate *priv = command->priv;
gboolean success = FALSE;
success = _pp_maintenance_command_is_supported (priv->printer_name, priv->command);
g_task_return_boolean (task, success);
}
static void
connection_test_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
http_t *http;
http = httpConnectEncrypt (cupsServer (), ippPort (), cupsEncryption ());
g_task_return_boolean (task, http != NULL);
httpClose (http);
}
static void
async_init_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GError *error = NULL;
if (g_initable_init (G_INITABLE (source_object), cancellable, &error))
g_task_return_boolean (task, TRUE);
else
g_task_return_error (task, error);
}
static gboolean
on_task_thread_to_complete_driver_registration (GTask *task)
{
DriverRegistrationOperation *operation;
operation = g_task_get_task_data (task);
if (operation->error != NULL)
g_task_return_error (task, operation->error);
else
g_task_return_boolean (task, TRUE);
return G_SOURCE_REMOVE;
}
