static void
cockpit_auth_none_login_async (CockpitAuth *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *task;
task = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
cockpit_auth_none_login_async);
g_simple_async_result_set_error (task, COCKPIT_ERROR, COCKPIT_ERROR_AUTHENTICATION_FAILED,
"Authentication disabled");
g_simple_async_result_complete_in_idle (task);
g_object_unref (task);
}
static void
abort_verification (EmpathyTLSVerifier *self,
EmpTLSCertificateRejectReason reason)
{
EmpathyTLSVerifierPriv *priv = GET_PRIV (self);
DEBUG ("Verification error %u, aborting...", reason);
g_simple_async_result_set_error (priv->verify_result,
G_IO_ERROR, reason, "TLS verification failed with reason %u",
reason);
g_simple_async_result_complete_in_idle (priv->verify_result);
tp_clear_object (&priv->verify_result);
}
static void
connect_3gpp_context_complete_and_free (Connect3gppContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->cancellable);
g_object_unref (ctx->result);
g_object_unref (ctx->modem);
g_object_unref (ctx->self);
g_clear_object (&ctx->data);
g_clear_object (&ctx->primary);
g_slice_free (Connect3gppContext, ctx);
}
static gboolean guess_content_job(GIOSchedulerJob *job, GCancellable* cancellable, gpointer user_data)
{
GuessContentData* data = (GuessContentData*)user_data;
char** content_types;
GSimpleAsyncResult* res;
content_types = g_content_type_guess_for_tree(data->root);
res = g_simple_async_result_new(data->mnt,
data->callback,
data->user_data,
NULL);
g_simple_async_result_set_op_res_gpointer(res, content_types, g_strfreev);
g_simple_async_result_complete_in_idle(res);
g_object_unref(res);
return FALSE;
}
/* This function can be called in any thread */
void
tracker_extract_file (TrackerExtract *extract,
const gchar *file,
const gchar *mimetype,
const gchar *graph,
GCancellable *cancellable,
GAsyncReadyCallback cb,
gpointer user_data)
{
GSimpleAsyncResult *res;
GError *error = NULL;
TrackerExtractTask *task;
g_return_if_fail (TRACKER_IS_EXTRACT (extract));
g_return_if_fail (file != NULL);
g_return_if_fail (cb != NULL);
#ifdef THREAD_ENABLE_TRACE
g_debug ("Thread:%p <-- '%s': Processing file\n",
g_thread_self (),
file);
#endif /* THREAD_ENABLE_TRACE */
res = g_simple_async_result_new (G_OBJECT (extract), cb, user_data, NULL);
task = extract_task_new (extract, file, mimetype, graph,
cancellable, G_ASYNC_RESULT (res), &error);
if (error) {
g_warning ("Could not get mimetype, %s", error->message);
g_simple_async_result_set_from_error (res, error);
g_simple_async_result_complete_in_idle (res);
g_error_free (error);
} else {
TrackerExtractPrivate *priv;
priv = TRACKER_EXTRACT_GET_PRIVATE (task->extract);
g_mutex_lock (&priv->task_mutex);
priv->running_tasks = g_list_prepend (priv->running_tasks, task);
g_mutex_unlock (&priv->task_mutex);
g_idle_add ((GSourceFunc) dispatch_task_cb, task);
}
/* Task takes a ref and if this fails, we want to unref anyway */
g_object_unref (res);
}
static void
on_status_advertise_status_returned (TpYtsStatus *self,
const GError *error,
gpointer user_data,
GObject *weak_object)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
if (error != NULL)
{
DEBUG ("Status.AdvertiseStatus failed: %s", error->message);
g_simple_async_result_set_from_error (res, error);
}
g_simple_async_result_complete_in_idle (res);
}
static void abort_verification(HevImpathyTLSVerifier *self,
TpTLSCertificateRejectReason reason)
{
HevImpathyTLSVerifierPrivate *priv =
HEV_IMPATHY_TLS_VERIFIER_GET_PRIVATE(self);
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_simple_async_result_set_error(priv->verify_result,
G_IO_ERROR, reason,
"TLS verification failed with reason %u",
reason);
g_simple_async_result_complete_in_idle(priv->verify_result);
tp_clear_object(&priv->verify_result);
}
static gboolean
timeout_cb (gpointer user_data)
{
SpawnData *data = user_data;
data->timed_out = TRUE;
/* ok, timeout is history, make sure we don't free it in spawn_data_free() */
data->timeout_source = NULL;
/* we're done */
g_simple_async_result_complete_in_idle (data->simple);
g_object_unref (data->simple);
return FALSE; /* remove source */
}
static void
_pp_new_printer_add_async_cb (gboolean success,
PpNewPrinter *printer)
{
PpNewPrinterPrivate *priv = printer->priv;
if (!success)
{
g_simple_async_result_set_error (priv->res,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Installation of the new printer failed.");
}
g_simple_async_result_set_op_res_gboolean (priv->res, success);
g_simple_async_result_complete_in_idle (priv->res);
}
static void
find_file_insensitive_exists_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GFileInfo *info;
InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data);
/* The file exists and can be found with the given path, no need to search. */
if ((info = g_file_query_info_finish (G_FILE (source_object), res, NULL)))
{
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (source_object), g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
g_object_unref (info);
}
else
{
data->split_path = g_strsplit (data->original_path, G_DIR_SEPARATOR_S, -1);
data->index = 0;
data->enumerator = NULL;
data->current_file = g_object_ref (data->root);
/* Skip any empty components due to multiple slashes */
while (data->split_path[data->index] != NULL &&
*data->split_path[data->index] == 0)
data->index++;
g_file_enumerate_children_async (data->current_file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
0, G_PRIORITY_DEFAULT,
data->cancellable,
enumerated_children_callback, data);
}
g_object_unref (source_object);
}
static gboolean pdp_qmi_real_statusUpdate_co (pdp_qmi_statusUpdateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
g_assert_not_reached ();
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
static void
disconnect_context_complete_and_free (DisconnectContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
if (ctx->error_ipv4)
g_error_free (ctx->error_ipv4);
if (ctx->error_ipv6)
g_error_free (ctx->error_ipv6);
if (ctx->client_ipv4)
g_object_unref (ctx->client_ipv4);
if (ctx->client_ipv6)
g_object_unref (ctx->client_ipv6);
g_object_unref (ctx->data);
g_object_unref (ctx->self);
g_slice_free (DisconnectContext, ctx);
}
static void
g_unix_resolver_request_complete (GUnixResolverRequest *req)
{
if (req->cancellable)
{
g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req);
g_object_unref (req->cancellable);
req->cancellable = NULL;
}
/* We always complete_in_idle, even if we were called from
* g_unix_resolver_watch(), since we might have been started under a
* non-default g_main_context_get_thread_default().
*/
g_simple_async_result_complete_in_idle (req->async_result);
g_object_unref (req->async_result);
}
static void
mail_config_page_submit (EMailConfigPage *page,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (
G_OBJECT (page), callback,
user_data, mail_config_page_submit);
g_simple_async_result_set_check_cancellable (simple, cancellable);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
static gboolean pdp_qmi_real_sc_deactivate_co (PdpQmiScDeactivateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp0_ = _data_->self->fd;
write (_data_->_tmp0_, "down", (gsize) 5);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
static gboolean vibrator_timed_outputclass_real_stop_co (VibratorTimedOutputclassStopData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
vibrator_timed_outputclass_cleanTimeouts (_data_->self);
vibrator_timed_outputclass_set_enable (_data_->self, 0);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
static void
_upload_file_progress_cb (DBusGProxy *proxy,
gint opid,
gint progress,
const char *error_message,
gpointer userdata)
{
SwClientServiceCallClosure *closure = (SwClientServiceCallClosure *) userdata;
if (opid != closure->opid) {
/* Ignore, that's not our upload */
return;
}
if (progress == -1) {
g_simple_async_report_error_in_idle (G_OBJECT (closure->service),
(GAsyncReadyCallback) closure->cb,
closure->userdata,
SW_CLIENT_SERVICE_ERROR,
0,
error_message);
g_object_unref (closure->service);
g_slice_free (SwClientServiceCallClosure, closure);
return;
}
(closure->progress_cb) ((float) progress * closure->filesize,
closure->filesize,
closure->progress_cb_data);
if (progress == 100) {
GSimpleAsyncResult *res;
res = g_simple_async_result_new (G_OBJECT (closure->service),
(GAsyncReadyCallback) closure->cb,
closure->userdata,
closure->iface == PHOTO_UPLOAD_IFACE ?
sw_client_service_upload_photo :
sw_client_service_upload_video);
g_simple_async_result_set_op_res_gboolean (res, TRUE);
g_simple_async_result_complete_in_idle (res);
g_object_unref (res);
g_object_unref (closure->service);
g_slice_free (SwClientServiceCallClosure, closure);
}
}
void
nemo_connect_server_dialog_display_location_async (NemoConnectServerDialog *self,
GFile *location,
GAsyncReadyCallback callback,
gpointer user_data)
{
GError *error;
GdkAppLaunchContext *launch_context;
gchar *uri;
display_location_res = g_simple_async_result_new (G_OBJECT (self),
callback, user_data,
nemo_connect_server_dialog_display_location_async);
error = NULL;
uri = g_file_get_uri (location);
if (just_print_uri) {
g_print ("%s\n", uri);
}
else {
launch_context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (self)));
gdk_app_launch_context_set_screen (launch_context,
gtk_widget_get_screen (GTK_WIDGET (self)));
g_app_info_launch_default_for_uri (uri,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
g_object_unref (launch_context);
}
if (error != NULL) {
g_simple_async_result_set_from_error (display_location_res, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (display_location_res);
g_free (uri);
g_object_unref (display_location_res);
display_location_res = NULL;
}
static void
tls_certificate_prepared_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TpTLSCertificate *certificate = TP_TLS_CERTIFICATE (source);
EmpathyServerTLSHandler *self = user_data;
GError *error = NULL;
EmpathyServerTLSHandlerPriv *priv = GET_PRIV (self);
if (!tp_proxy_prepare_finish (certificate, result, &error))
{
g_simple_async_result_set_from_error (priv->async_init_res, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (priv->async_init_res);
tp_clear_object (&priv->async_init_res);
}
static void
on_ca_play_full_finished(ca_context *ca,
guint32 id,
int error_code,
gpointer user_data)
{
GSimpleAsyncResult *result = user_data;
if (error_code != CA_SUCCESS)
{
g_simple_async_result_set_error(result,
GSOUND_ERROR,
error_code,
ca_strerror(error_code));
}
g_simple_async_result_complete_in_idle (result);
g_object_unref(result);
}
static gboolean deja_dup_backend_real_get_envp_co (DejaDupBackendGetEnvpData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp0_ = NULL;
g_signal_emit_by_name (_data_->self, "envp-ready", TRUE, _data_->_tmp0_, NULL);
__g_list_free__g_free0_0 (_data_->_tmp0_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
void
empathy_account_set_enabled_async (EmpathyAccount *account,
gboolean enabled,
GAsyncReadyCallback callback,
gpointer user_data)
{
EmpathyAccountPriv *priv = GET_PRIV (account);
EmpathyAccountManager *acc_manager;
GValue value = {0, };
GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
callback, user_data, empathy_account_set_enabled_finish);
char *status = NULL;
char *status_message = NULL;
TpConnectionPresenceType presence;
if (priv->enabled == enabled)
{
g_simple_async_result_complete_in_idle (result);
return;
}
if (enabled)
{
acc_manager = empathy_account_manager_dup_singleton ();
presence = empathy_account_manager_get_requested_global_presence
(acc_manager, &status, &status_message);
if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET)
empathy_account_request_presence (account, presence, status,
status_message);
g_object_unref (acc_manager);
g_free (status);
g_free (status_message);
}
g_value_init (&value, G_TYPE_BOOLEAN);
g_value_set_boolean (&value, enabled);
tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-1, TP_IFACE_ACCOUNT, "Enabled", &value,
account_enabled_set_cb, result, NULL, G_OBJECT (account));
}
static void
gb_project_format_real_open_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
const gchar *directory;
JsonParser *parser = (JsonParser *)object;
JsonNode *root;
GObject *project;
GError *error = NULL;
ENTRY;
g_assert(JSON_IS_PARSER(parser));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
if (!json_parser_load_from_stream_finish(parser, result, &error)) {
g_simple_async_result_take_error(simple, error);
GOTO(failure);
}
root = json_parser_get_root(parser);
g_assert(root);
if (!(project = json_gobject_deserialize(GB_TYPE_PROJECT, root))) {
g_simple_async_result_set_error(simple, GB_PROJECT_FORMAT_ERROR,
GB_PROJECT_FORMAT_ERROR_INVALID_JSON,
_("Failed to deserialize from JSON."));
GOTO(failure);
}
directory = g_object_get_data(G_OBJECT(simple), "directory");
g_object_set(project, "directory", directory, NULL);
g_simple_async_result_set_op_res_gpointer(simple, project, g_object_unref);
failure:
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
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);
}
void
gclue_locator_stop (GClueLocator *locator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
g_return_if_fail (GCLUE_IS_LOCATOR (locator));
gclue_locator_stop_sync (locator);
simple = g_simple_async_result_new (G_OBJECT (locator),
callback,
user_data,
gclue_locator_stop);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
/**
* pk_package_sack_merge_bool_state_finish:
**/
static void
pk_package_sack_merge_bool_state_finish (PkPackageSackState *state, const GError *error)
{
/* get result */
if (state->ret) {
g_simple_async_result_set_op_res_gboolean (state->res, state->ret);
} else {
g_simple_async_result_set_from_error (state->res, error);
}
/* complete */
g_simple_async_result_complete_in_idle (state->res);
/* deallocate */
if (state->cancellable != NULL)
g_object_unref (state->cancellable);
g_object_unref (state->res);
g_object_unref (state->sack);
g_slice_free (PkPackageSackState, state);
}
static void
port_probe_run_task_complete (PortProbeRunTask *task,
gboolean result,
GError *error)
{
/* As soon as we have the task completed, disable the buffer-full signal
* handling, so that we do not get unwanted errors reported */
if (task->buffer_full_id) {
g_source_remove (task->buffer_full_id);
task->buffer_full_id = 0;
}
if (error)
g_simple_async_result_take_error (task->result, error);
else
g_simple_async_result_set_op_res_gboolean (task->result, result);
/* Always complete in idle */
g_simple_async_result_complete_in_idle (task->result);
}
static gboolean
http_client_check_data_free (gpointer user_data)
{
CheckData *data = user_data;
g_simple_async_result_complete_in_idle (data->res);
if (data->cancellable_id > 0)
{
g_cancellable_disconnect (data->cancellable, data->cancellable_id);
g_object_unref (data->cancellable);
}
/* soup_session_queue_message stole the references to data->msg */
g_object_unref (data->res);
g_object_unref (data->session);
g_slice_free (CheckData, data);
return G_SOURCE_REMOVE;
}
static void
_get_properties_cb (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
MtnConnman *connman;
GError *error;
GVariant *var;
InitData *data;
connman = MTN_CONNMAN (obj);
data = (InitData*)user_data;
error = NULL;
var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error);
if (!var) {
g_warning ("Initial Service.GetProperties() failed: %s\n",
error->message);
g_error_free (error);
} else {
GVariant *value;
char *key;
GVariantIter *iter;
g_variant_get (var, "(a{sv})", &iter);
while (g_variant_iter_next (iter, "{sv}", &key, &value)) {
g_hash_table_insert (connman->priv->properties,
key, value);
}
g_variant_iter_free (iter);
g_variant_unref (var);
}
if (data->done_services) {
g_simple_async_result_complete_in_idle (data->res);
g_object_unref (data->res);
g_free (data);
} else {
data->done_props = TRUE;
}
}
static void
execute_cancelled_cb (GCancellable *cancellable,
gpointer user_data)
{
ExecuteData *exec_data = user_data;
FrProcess *process = exec_data->process;
if (! process->priv->running)
return;
if (process->priv->stopping)
return;
process->priv->stopping = TRUE;
exec_data->error = fr_error_new (FR_ERROR_STOPPED, 0, NULL);
if (command_is_sticky (process, process->priv->current_command))
allow_sticky_processes_only (exec_data);
else if (process->priv->command_pid > 0)
killpg (process->priv->command_pid, SIGTERM);
else {
if (process->priv->check_timeout != 0) {
g_source_remove (process->priv->check_timeout);
process->priv->check_timeout = 0;
}
process->priv->command_pid = 0;
fr_channel_data_close_source (&process->out);
fr_channel_data_close_source (&process->err);
process->priv->running = FALSE;
if (exec_data->cancel_id != 0) {
g_signal_handler_disconnect (exec_data->cancellable, exec_data->cancel_id);
exec_data->cancel_id = 0;
}
g_simple_async_result_complete_in_idle (exec_data->result);
}
}
