static void
on_remote_login_done (CockpitSshTransport *transport,
const gchar *problem,
gpointer user_data)
{
CockpitAuth *self = COCKPIT_AUTH (g_async_result_get_source_object (user_data));
GSimpleAsyncResult *task = user_data;
if (problem)
{
if (g_str_equal (problem, "authentication-failed"))
{
g_simple_async_result_set_error (task, COCKPIT_ERROR,
COCKPIT_ERROR_AUTHENTICATION_FAILED,
"Authentication failed");
}
else if (g_str_equal (problem, "not-supported") ||
g_str_equal (problem, "no-forwarding"))
{
g_simple_async_result_set_error (task, COCKPIT_ERROR,
COCKPIT_ERROR_AUTHENTICATION_FAILED,
"Authentication failed: no-supported-methods");
}
else
{
g_simple_async_result_set_error (task, COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"Couldn't connect or authenticate: %s", problem);
}
}
g_simple_async_result_complete (task);
g_object_unref (self);
g_object_unref (task);
}
/* Called when results come in for a key send */
static gboolean
on_import_add_completed (LDAPMessage *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
source_import_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 rc;
g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_ADD, FALSE);
rc = ldap_parse_result (closure->ldap, result, &code, NULL,
&message, NULL, NULL, 0);
g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
/* TODO: Somehow communicate this to the user */
if (code == LDAP_ALREADY_EXISTS)
code = LDAP_SUCCESS;
ldap_memfree (message);
if (seahorse_ldap_source_propagate_error (self, code, &error)) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete (res);
return FALSE; /* don't call for this source again */
}
import_send_key (self, res);
return FALSE; /* don't call for this source again */
}
static void
bluez_connect_cb (GDBusConnection *dbus_connection,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
GObject *result_object = g_async_result_get_source_object (G_ASYNC_RESULT (result));
NMBluezDevice *self = NM_BLUEZ_DEVICE (result_object);
NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self);
GError *error = NULL;
char *device;
GVariant *variant;
variant = g_dbus_connection_call_finish (dbus_connection, res, &error);
if (!variant) {
g_simple_async_result_take_error (result, error);
} else {
g_variant_get (variant, "(s)", &device);
g_simple_async_result_set_op_res_gpointer (result,
g_strdup (device),
g_free);
priv->bt_iface = device;
g_variant_unref (variant);
}
g_simple_async_result_complete (result);
g_object_unref (result);
g_object_unref (result_object);
}
static void
on_address_resolved_complete (SoupAddress *address,
guint status,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
gchar *server;
g_object_get (self, "key-server", &server, NULL);
g_return_if_fail (server && server[0]);
seahorse_progress_update (closure->cancellable, res, _("Connecting to: %s"), server);
g_free (server);
/* DNS failed */
if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
g_simple_async_result_set_error (res, SEAHORSE_ERROR, -1,
_("Couldn’t resolve address: %s"),
soup_address_get_name (address));
g_simple_async_result_complete_in_idle (res);
/* Yay resolved */
} else {
once_resolved_start_connect (self, res, soup_address_get_physical (address));
}
g_object_unref (res);
}
static void
list_build_object_ready (GDBusConnection *connection,
GAsyncResult *res,
ListSmsContext *ctx)
{
GError *error = NULL;
GObject *sms;
GObject *source_object;
source_object = g_async_result_get_source_object (res);
sms = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, &error);
g_object_unref (source_object);
if (error) {
g_simple_async_result_take_error (ctx->result, error);
list_sms_context_complete_and_free (ctx);
return;
}
/* Keep the object */
ctx->sms_objects = g_list_prepend (ctx->sms_objects, sms);
/* If no more smss, just end here. */
if (!ctx->sms_paths[++ctx->i]) {
g_simple_async_result_set_op_res_gpointer (ctx->result,
ctx->sms_objects,
(GDestroyNotify)sms_object_list_free);
ctx->sms_objects = NULL;
list_sms_context_complete_and_free (ctx);
return;
}
/* Keep on creating next object */
create_next_sms (ctx);
}
static void
news_sync_task_save_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NewsSyncTaskPrivate *priv;
GSimpleAsyncResult *simple = user_data;
NewsSyncTask *task;
GomResource *resource = (GomResource *)object;
GError *error = NULL;
g_assert(NEWS_IS_FEED(resource));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
task = (NewsSyncTask *)g_async_result_get_source_object(G_ASYNC_RESULT(simple));
g_assert(NEWS_IS_SYNC_TASK(task));
priv = task->priv;
if (!gom_resource_save_finish(resource, result, &error)) {
g_simple_async_result_take_error(simple, error);
gom_adapter_sqlite_rollback(GOM_ADAPTER_SQLITE(priv->adapter));
} else if (!gom_adapter_sqlite_commit(GOM_ADAPTER_SQLITE(priv->adapter),
&error)) {
g_simple_async_result_take_error(simple, error);
gom_adapter_sqlite_rollback(GOM_ADAPTER_SQLITE(priv->adapter));
}
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
}
static void
get_volumes_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GVfsAfpServer *server = G_VFS_AFP_SERVER (source_object);
GSimpleAsyncResult *simple = user_data;
GVfsBackendAfpBrowse *afp_backend;
GPtrArray *volumes;
GError *err = NULL;
afp_backend = G_VFS_BACKEND_AFP_BROWSE (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
volumes = g_vfs_afp_server_get_volumes_finish (server, res, &err);
if (!volumes)
{
g_simple_async_result_take_error (simple, err);
goto done;
}
if (afp_backend->volumes)
g_ptr_array_unref (afp_backend->volumes);
afp_backend->volumes = volumes;
done:
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
static void _write_ready(GObject *source_object, GAsyncResult *res, gpointer user_data) {
GOutputStream *output_stream = G_OUTPUT_STREAM(source_object);
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(user_data);
IdleServerConnection *conn = IDLE_SERVER_CONNECTION(g_async_result_get_source_object(G_ASYNC_RESULT(result)));
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
gssize nwrite;
GError *error = NULL;
g_object_unref(conn);
nwrite = g_output_stream_write_finish(output_stream, res, &error);
if (nwrite == -1) {
IDLE_DEBUG("g_output_stream_write failed : %s", error->message);
g_simple_async_result_set_error(result, TP_ERROR, TP_ERROR_NETWORK_ERROR, "%s", error->message);
g_error_free(error);
goto cleanup;
}
priv->nwritten += nwrite;
if (priv->nwritten < priv->count) {
g_output_stream_write_async(output_stream, priv->output_buffer + priv->nwritten, priv->count - priv->nwritten, G_PRIORITY_DEFAULT, priv->cancellable, _write_ready, result);
return;
}
cleanup:
if (priv->cancellable != NULL) {
g_object_unref(priv->cancellable);
priv->cancellable = NULL;
}
g_simple_async_result_complete(result);
g_object_unref(result);
}
static void
gom_resource_save_cb (GomAdapter *adapter,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
GomResource *resource;
gboolean ret;
GError *error = NULL;
GAsyncQueue *queue;
g_return_if_fail(GOM_IS_ADAPTER(adapter));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
resource = GOM_RESOURCE(g_async_result_get_source_object(G_ASYNC_RESULT(simple)));
g_assert(GOM_IS_RESOURCE(resource));
queue = g_object_get_data(G_OBJECT(simple), "queue");
if (!(ret = gom_resource_do_save(resource, adapter, &error))) {
g_simple_async_result_take_error(simple, error);
}
g_simple_async_result_set_op_res_gboolean(simple, ret);
if (!queue)
g_simple_async_result_complete_in_idle(simple);
else
g_async_queue_push(queue, GINT_TO_POINTER(TRUE));
g_object_unref(resource);
}
static void
on_prompt_completed (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
SecretPrompt *self = SECRET_PROMPT (g_async_result_get_source_object (user_data));
PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
gboolean dismissed;
closure->prompting = FALSE;
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(bv)"))) {
g_warning ("SecretPrompt received invalid %s signal of type %s",
signal_name, g_variant_get_type_string (parameters));
perform_prompt_complete (res, TRUE);
} else {
g_variant_get (parameters, "(bv)", &dismissed, &closure->result);
perform_prompt_complete (res, dismissed);
}
g_object_unref (self);
}
static void
catch_resource_group_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CatchResourceGroupPrivate *priv;
CatchResourceGroup *group;
GSimpleAsyncResult *simple = user_data;
gboolean ret = FALSE;
GError *error = NULL;
ENTRY;
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
group = CATCH_RESOURCE_GROUP(g_async_result_get_source_object(user_data));
g_return_if_fail(CATCH_IS_RESOURCE_GROUP(group));
priv = group->priv;
if (priv->group) {
ret = gom_resource_group_fetch_finish(GOM_RESOURCE_GROUP(object), result, &error);
} else {
g_assert_not_reached();
}
if (!ret) {
g_simple_async_result_take_error(simple, error);
}
g_simple_async_result_set_op_res_gboolean(simple, ret);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
static gboolean
create_thumbnail (GIOSchedulerJob *job,
GCancellable *cancellable,
gpointer user_data)
{
GSimpleAsyncResult *result = user_data;
GFile *file = G_FILE (g_async_result_get_source_object (G_ASYNC_RESULT (result)));
GnomeDesktopThumbnailFactory *factory;
GFileInfo *info;
gchar *uri;
GdkPixbuf *pixbuf;
guint64 mtime;
uri = g_file_get_uri (file);
info = g_file_query_info (file, ATTRIBUTES_FOR_THUMBNAIL,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
/* we don't care about reporting errors here, just fail the
* thumbnail.
*/
if (info == NULL)
{
g_simple_async_result_set_op_res_gboolean (result, FALSE);
goto out;
}
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail
(factory,
uri, g_file_info_get_content_type (info));
if (pixbuf != NULL)
{
gnome_desktop_thumbnail_factory_save_thumbnail (factory, pixbuf,
uri, (time_t) mtime);
g_simple_async_result_set_op_res_gboolean (result, TRUE);
}
else
{
g_simple_async_result_set_op_res_gboolean (result, FALSE);
}
g_object_unref (info);
g_object_unref (file);
g_object_unref (factory);
g_clear_object (&pixbuf);
out:
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
return FALSE;
}
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 */
}
/**
* cockpit_fake_manager_new_finish:
* @result: an async result
* @error: location to place an error or NULL
*
* Complete an async init of fake manager started with
* cockpit_fake_manager_new_for_bus().
*
* Returns: (transfer full): the new manager or NULL
*/
GDBusObjectManager *
cockpit_fake_manager_new_finish (GAsyncResult *result,
GError **error)
{
GObject *source_object;
GObject *object;
source_object = g_async_result_get_source_object (result);
object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), result, error);
g_object_unref (source_object);
return object ? G_DBUS_OBJECT_MANAGER (object) : NULL;
}
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 void
cloud_spy_dispatcher_invocation_perform (CloudSpyDispatcherInvocation * self)
{
CloudSpyDispatcher * dispatcher;
dispatcher = CLOUD_SPY_DISPATCHER (g_async_result_get_source_object (G_ASYNC_RESULT (self->res)));
cloud_spy_dispatcher_invocation_ref (self);
dispatcher->dispatch_func (NULL, NULL, NULL, NULL, self->method->name, self->parameters,
(GDBusMethodInvocation *) self, &dispatcher->target_object);
g_object_unref (dispatcher);
}
GObject * hev_serial_port_new_finish(GAsyncResult *res, GError **error)
{
GObject *object = NULL, *source_object = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
source_object = g_async_result_get_source_object(res);
object = g_async_initable_new_finish(G_ASYNC_INITABLE(source_object),
res, error);
g_object_unref(source_object);
return object;
}
/**
* nma_mobile_providers_database_new_finish:
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to nma_mobile_providers_database_new().
* @error: Return location for error or %NULL.
*
* Returns: (transfer full) (type NMAMobileProvidersDatabase): The constructed object or %NULL if @error is set.
*/
NMAMobileProvidersDatabase *
nma_mobile_providers_database_new_finish (GAsyncResult *res,
GError **error)
{
GObject *initable;
GObject *out;
initable = g_async_result_get_source_object (res);
out = g_async_initable_new_finish (G_ASYNC_INITABLE (initable), res, error);
g_object_unref (initable);
return out ? NMA_MOBILE_PROVIDERS_DATABASE (out) : NULL;
}
GDBusProxy *
_nm_dbus_new_proxy_for_connection_finish (GAsyncResult *result,
GError **error)
{
GObject *source;
GDBusProxy *proxy;
source = g_async_result_get_source_object (result);
proxy = G_DBUS_PROXY (g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, error));
g_object_unref (source);
_nm_dbus_proxy_replace_match (proxy);
return proxy;
}
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 */
}
}
/**
* goa_client_new_finish:
* @res: A #GAsyncResult.
* @error: Return location for error or %NULL.
*
* Finishes an operation started with goa_client_new().
*
* Returns: A #GoaClient or %NULL if @error is set. Free with
* g_object_unref() when done with it.
*/
GoaClient *
goa_client_new_finish (GAsyncResult *res,
GError **error)
{
GObject *ret;
GObject *source_object;
source_object = g_async_result_get_source_object (res);
ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
g_object_unref (source_object);
if (ret != NULL)
return GOA_CLIENT (ret);
else
return NULL;
}
/**
* gcr_certificate_request_capable_finish:
* @result: asynchronous result
* @error: location to place an error
*
* Get the result for asynchronously check whether #GcrCertificateRequest is
* capable of creating a request for the given @private_key.
*
* Returns: whether a request can be created
*/
gboolean
gcr_certificate_request_capable_finish (GAsyncResult *result,
GError **error)
{
GObject *source;
gulong mech;
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
source = g_async_result_get_source_object (result);
mech = _gcr_key_mechanisms_check_finish (GCK_OBJECT (source), result, error);
g_object_unref (source);
return mech != GCK_INVALID;
}
static void
gabble_auth_manager_start_auth_cb (GObject *channel,
GAsyncResult *result,
gpointer user_data)
{
GObject *self_object = g_async_result_get_source_object (user_data);
GabbleAuthManager *self = GABBLE_AUTH_MANAGER (self_object);
WockyAuthRegistryStartData *start_data = NULL;
GError *error = NULL;
if (gabble_server_sasl_channel_start_auth_finish (
GABBLE_SERVER_SASL_CHANNEL (channel), result, &start_data, &error))
{
if (!tp_strdiff (start_data->mechanism, X_TELEPATHY_PASSWORD))
{
/* restart authentication using our own base class */
g_assert (start_data->initial_response != NULL);
self->priv->falling_back = TRUE;
WOCKY_AUTH_REGISTRY_CLASS (
gabble_auth_manager_parent_class)->start_auth_async_func (
WOCKY_AUTH_REGISTRY (self), self->priv->mechanisms,
self->priv->allow_plain, self->priv->is_secure_channel,
self->priv->username,
start_data->initial_response->str,
self->priv->server,
self->priv->session_id,
gabble_auth_manager_start_fallback_cb, user_data);
/* we've transferred ownership of the result */
goto finally;
}
else
{
g_simple_async_result_set_op_res_gpointer (user_data, start_data,
(GDestroyNotify) wocky_auth_registry_start_data_free);
}
}
else
{
g_simple_async_result_set_from_error (user_data, error);
g_clear_error (&error);
}
g_simple_async_result_complete (user_data);
g_object_unref (user_data);
finally:
g_object_unref (self_object);
}
static void
nm_connectivity_check_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMConnectivity *self;
NMConnectivityPrivate *priv;
NMConnectivityState new_state;
const char *nm_header;
self = NM_CONNECTIVITY (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self);
priv = NM_CONNECTIVITY_GET_PRIVATE (self);
if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' failed with '%s'.",
priv->uri, msg->reason_phrase);
new_state = NM_CONNECTIVITY_LIMITED;
goto done;
}
/* Check headers; if we find the NM-specific one we're done */
nm_header = soup_message_headers_get_one (msg->response_headers, "X-NetworkManager-Status");
if (g_strcmp0 (nm_header, "online") == 0) {
nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' with Status header successful.", priv->uri);
new_state = NM_CONNECTIVITY_FULL;
} else if (msg->status_code == SOUP_STATUS_OK) {
/* check response */
if (msg->response_body->data && (g_str_has_prefix (msg->response_body->data, priv->response))) {
nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' successful.",
priv->uri);
new_state = NM_CONNECTIVITY_FULL;
} else {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' did not match expected response '%s'; assuming captive portal.",
priv->uri, priv->response);
new_state = NM_CONNECTIVITY_PORTAL;
}
} else {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' returned status '%d %s'; assuming captive portal.",
priv->uri, msg->status_code, msg->reason_phrase);
new_state = NM_CONNECTIVITY_PORTAL;
}
done:
g_simple_async_result_set_op_res_gssize (simple, new_state);
g_simple_async_result_complete (simple);
update_state (self, new_state);
}
/**
* e_gdbus_cal_factory_proxy_new_for_bus_finish:
* @res: A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to e_gdbus_cal_factory_proxy_new_for_bus().
* @error: Return location for error or %NULL.
*
* Finishes creating a #EGdbusCalFactoryProxy.
*
* Returns: A #EGdbusCalFactoryProxy or %NULL if @error is set. Free with g_object_unref().
*/
EGdbusCalFactory *e_gdbus_cal_factory_proxy_new_for_bus_finish (GAsyncResult *res,
GError **error)
{
GObject *object;
GObject *source_object;
source_object = g_async_result_get_source_object (res);
g_assert (source_object != NULL);
object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
res,
error);
g_object_unref (source_object);
if (object != NULL)
return E_GDBUS_CAL_FACTORY (object);
else
return NULL;
}
static gboolean
after_power_up_wait_cb (GSimpleAsyncResult *result)
{
MMBroadbandModemOption *option;
option = MM_BROADBAND_MODEM_OPTION (g_async_result_get_source_object (G_ASYNC_RESULT (result)));
g_simple_async_result_set_op_res_gboolean (result, TRUE);
g_simple_async_result_complete (result);
g_object_unref (result);
option->priv->after_power_up_wait_id = 0;
g_object_unref (option);
return FALSE;
}
static gboolean
after_atz_sleep_cb (GSimpleAsyncResult *simple)
{
MMBaseModem *self;
self = MM_BASE_MODEM (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
/* Now, run the remaining sequence */
mm_base_modem_at_sequence (self,
modem_init_sequence,
NULL, /* response_processor_context */
NULL, /* response_processor_context_free */
(GAsyncReadyCallback)init_sequence_ready,
simple);
g_object_unref (self);
return FALSE;
}
static void
news_sync_task_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NewsSyncTaskPrivate *priv;
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)user_data;
GInputStream *stream;
NewsSyncTask *task;
NewsSource *source = (NewsSource *)object;
NewsParser *parser;
GError *error = NULL;
g_assert(NEWS_IS_SOURCE(source));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
task = (NewsSyncTask *)g_async_result_get_source_object(G_ASYNC_RESULT(simple));
g_assert(NEWS_IS_SYNC_TASK(task));
priv = task->priv;
priv->fraction = 0.333;
g_object_notify_by_pspec(G_OBJECT(task), gParamSpecs[PROP_FRACTION]);
if (!(stream = news_source_fetch_finish(source, result, &error))) {
g_simple_async_result_take_error(simple, error);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
if (g_cancellable_is_cancelled(priv->cancellable)) {
g_simple_async_result_set_error(simple, NEWS_SYNC_TASK_ERROR,
NEWS_SYNC_TASK_ERROR_CANCELLED,
_("The task was cancelled."));
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
parser = g_object_new(NEWS_TYPE_PARSER,
"adapter", priv->adapter,
"source", priv->source,
NULL);
news_parser_parse_async(parser, stream, priv->cancellable,
news_sync_task_parse_cb, simple);
g_object_unref(parser);
}
GClueClientInfo *
gclue_client_info_new_finish (GAsyncResult *res,
GError **error)
{
GObject *object;
GObject *source_object;
source_object = g_async_result_get_source_object (res);
object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
res,
error);
g_object_unref (source_object);
if (object != NULL)
return GCLUE_CLIENT_INFO (object);
else
return NULL;
}
EmpathyServerTLSHandler *
empathy_server_tls_handler_new_finish (GAsyncResult *result,
GError **error)
{
GObject *object, *source_object;
source_object = g_async_result_get_source_object (result);
object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
result, error);
g_object_unref (source_object);
if (object != NULL)
return EMPATHY_SERVER_TLS_HANDLER (object);
else
return NULL;
}
