PpDevicesList *
pp_host_get_snmp_devices_finish (PpHost *host,
GAsyncResult *res,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
GSDData *data;
PpDevicesList *result;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == pp_host_get_snmp_devices_async);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
result = data->devices;
data->devices = NULL;
return result;
}
static void
async_verify_chain_thread (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
AsyncVerifyChain *args = g_simple_async_result_get_op_res_gpointer (res);
GError *error = NULL;
args->verify_result = g_tls_database_verify_chain (G_TLS_DATABASE (object),
args->chain,
args->purpose,
args->identity,
args->interaction,
args->flags,
cancellable,
&error);
if (error)
g_simple_async_result_take_error (res, error);
}
static gboolean
connect_finish (MMBearer *self,
GAsyncResult *res,
MMPort **data,
MMBearerIpConfig **ipv4_config,
MMBearerIpConfig **ipv6_config,
GError **error)
{
ConnectResult *result;
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
return FALSE;
result = (ConnectResult *) g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
*data = MM_PORT (g_object_ref (result->data));
*ipv4_config = (result->ipv4_config ? g_object_ref (result->ipv4_config) : NULL);
*ipv6_config = (result->ipv6_config ? g_object_ref (result->ipv6_config) : NULL);
return TRUE;
}
/**
* gdk_pixbuf_new_from_stream_finish:
* @async_result: a #GAsyncResult
* @error: a #GError, or %NULL
*
* Finishes an asynchronous pixbuf creation operation started with
* gdk_pixbuf_new_from_stream_async().
*
* Return value: a #GdkPixbuf or %NULL on error. Free the returned
* object with g_object_unref().
*
* Since: 2.18
**/
static GdkPixbuf *
totem_gdk_pixbuf_new_from_stream_finish (GAsyncResult *async_result,
GError **error)
{
GdkPixbuf *pixbuf;
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
g_warn_if_fail (g_simple_async_result_get_source_tag (result) == totem_gdk_pixbuf_new_from_stream_async ||
g_simple_async_result_get_source_tag (result) == totem_gdk_pixbuf_new_from_stream_at_scale_async);
if (g_simple_async_result_propagate_error (result, error))
return NULL;
pixbuf = GDK_PIXBUF (g_simple_async_result_get_op_res_gpointer (result));
if (pixbuf != NULL)
return g_object_ref (pixbuf);
return NULL;
}
static void
save_to_buffer_thread (GSimpleAsyncResult *result,
GObject *object,
GCancellable *cancellable)
{
SaveArguments *arguments;
GthImageSaveData *data;
GError *error = NULL;
arguments = g_simple_async_result_get_op_res_gpointer (result);
data = _gth_image_save_to_buffer_common (arguments->image,
arguments->mime_type,
arguments->file_data,
cancellable,
&error);
if (data != NULL)
g_simple_async_result_set_op_res_gpointer (result, data, NULL);
else
g_simple_async_result_take_error (result, error);
}
static GList*
g_tls_database_real_lookup_certificates_issued_by_finish (GTlsDatabase *self,
GAsyncResult *result,
GError **error)
{
AsyncLookupCertificatesIssuedBy *args;
GList *results;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
g_tls_database_real_lookup_certificates_issued_by_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return NULL;
args = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
results = args->results;
args->results = NULL;
return results;
}
gboolean
ostree_checksum_file_async_finish (GFile *f,
GAsyncResult *result,
guchar **out_csum,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
ChecksumFileAsyncData *data;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == ostree_checksum_file_async);
if (g_simple_async_result_propagate_error (simple, error))
return FALSE;
data = g_simple_async_result_get_op_res_gpointer (simple);
/* Transfer ownership */
*out_csum = data->csum;
data->csum = NULL;
return TRUE;
}
static GTlsCertificate*
g_tls_database_real_lookup_certificate_for_handle_finish (GTlsDatabase *self,
GAsyncResult *result,
GError **error)
{
AsyncLookupCertificateForHandle *args;
GTlsCertificate *certificate;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
g_tls_database_real_lookup_certificate_for_handle_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return NULL;
args = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
certificate = args->result;
args->result = NULL;
return certificate;
}
static void
on_export_connect_completed (GObject *source,
GAsyncResult *result,
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;
closure->ldap = seahorse_ldap_source_connect_finish (SEAHORSE_LDAP_SOURCE (source),
result, &error);
if (error != NULL) {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete (res);
} else {
export_retrieve_key (SEAHORSE_LDAP_SOURCE (source), res);
}
g_object_unref (res);
}
const char *
nm_bluez_device_connect_finish (NMBluezDevice *self,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
const char *device;
g_return_val_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (self),
nm_bluez_device_connect_async),
NULL);
simple = (GSimpleAsyncResult *) result;
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
device = (const char *) g_simple_async_result_get_op_res_gpointer (simple);
return device;
}
gboolean
fr_process_execute_finish (FrProcess *process,
GAsyncResult *result,
FrError **error)
{
ExecuteData *exec_data;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (process), fr_process_execute), FALSE);
exec_data = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
if (exec_data->error == NULL)
return TRUE;
if (error != NULL) {
if (exec_data->error->gerror == NULL)
exec_data->error->gerror = g_error_new_literal (FR_ERROR, exec_data->error->type, "");
*error = fr_error_copy (exec_data->error);
}
return FALSE;
}
static void
get_stream_thread_func (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
GetStreamData *data;
GError *error;
data = g_simple_async_result_get_op_res_gpointer (res);
error = NULL;
data->stream = g_dbus_address_get_stream_sync (data->address,
&data->guid,
cancellable,
&error);
if (data->stream == NULL)
{
g_simple_async_result_set_from_error (res, error);
g_error_free (error);
}
}
GVariant *
mm_base_modem_at_sequence_full_finish (MMBaseModem *self,
GAsyncResult *res,
gpointer *response_processor_context,
GError **error)
{
AtSequenceContext *ctx;
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res),
error))
return NULL;
ctx = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
if (response_processor_context)
/* transfer none, no need to free the context ourselves, if
* we gave a response_processor_context_free callback */
*response_processor_context = ctx->response_processor_context;
/* transfer-none! (so that we can ignore it) */
return ctx->result;
}
static void
metadata_get_coverart_thread (GSimpleAsyncResult *result,
GObject *object,
GCancellable *cancellable)
{
GetCoverArtData *data;
CaaCoverArt cover_art;
CaaImageData image_data;
data = g_simple_async_result_get_op_res_gpointer (result);
cover_art = caa_coverart_new (PACKAGE_NAME "-" PACKAGE_VERSION);
image_data = caa_coverart_fetch_front (cover_art, data->album->id);
if (image_data != NULL) {
data->size = caa_imagedata_size (image_data);
data->buffer = g_new (guchar, data->size);
memcpy (data->buffer, caa_imagedata_data (image_data), data->size);
}
caa_coverart_delete (cover_art);
}
static gchar *
lookup_by_address_finish (GResolver *resolver,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
gchar *name;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_by_address_async), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
req = g_simple_async_result_get_op_res_gpointer (simple);
name = req->u.address.hostname;
req->u.address.hostname = NULL;
return name;
}
static GList *
lookup_service_finish (GResolver *resolver,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
GList *targets;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_service_async), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
req = g_simple_async_result_get_op_res_gpointer (simple);
targets = req->u.service.targets;
req->u.service.targets = NULL;
return targets;
}
static gssize
data_wrapper_decode_to_stream_finish (CamelDataWrapper *data_wrapper,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
AsyncContext *async_context;
g_return_val_if_fail (
g_simple_async_result_is_valid (
result, G_OBJECT (data_wrapper),
data_wrapper_decode_to_stream), -1);
simple = G_SIMPLE_ASYNC_RESULT (result);
async_context = g_simple_async_result_get_op_res_gpointer (simple);
if (g_simple_async_result_propagate_error (simple, error))
return -1;
return async_context->bytes_written;
}
static GInputStream *
g_loadable_icon_real_load_finish (GLoadableIcon *icon,
GAsyncResult *res,
char **type,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
LoadData *data;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_loadable_icon_real_load_async);
data = g_simple_async_result_get_op_res_gpointer (simple);
if (type)
{
*type = data->type;
data->type = NULL;
}
return g_object_ref (data->stream);
}
static void
data_wrapper_decode_to_stream_thread (GSimpleAsyncResult *simple,
GObject *object,
GCancellable *cancellable)
{
AsyncContext *async_context;
GError *error = NULL;
async_context = g_simple_async_result_get_op_res_gpointer (simple);
async_context->bytes_written =
camel_data_wrapper_decode_to_stream_sync (
CAMEL_DATA_WRAPPER (object),
async_context->stream,
cancellable, &error);
if (error != NULL) {
g_simple_async_result_set_from_error (simple, error);
g_error_free (error);
}
}
static void
create_channel_cb (GObject *acr,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GError *error = NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
data->channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (acr), res, NULL, &error);
if (!TP_IS_STREAM_TUBE_CHANNEL (data->channel))
{
tp_clear_object (&data->channel);
if (error == NULL)
error = g_error_new_literal (TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
"Not supported channel type");
create_tube_complete (simple, error);
g_clear_error (&error);
g_object_unref (simple);
return;
}
g_signal_connect (data->channel, "invalidated",
G_CALLBACK (create_tube_channel_invalidated_cb), simple);
g_signal_connect_data (data->channel, "incoming",
G_CALLBACK (create_tube_incoming_cb),
g_object_ref (simple), (GClosureNotify) g_object_unref, 0);
tp_stream_tube_channel_offer_async (TP_STREAM_TUBE_CHANNEL (data->channel),
NULL, create_tube_offer_cb, g_object_ref (simple));
g_object_unref (simple);
}
/**
* json_parser_load_from_stream_finish:
* @parser: a #JsonParser
* @result: a #GAsyncResult
* @error: the return location for a #GError or %NULL
*
* Finishes an asynchronous stream loading started with
* json_parser_load_from_stream_async().
*
* Return value: %TRUE if the content of the stream was successfully retrieves
* and parsed, and %FALSE otherwise. In case of error, the #GError will be
* filled accordingly.
*
* Since: 0.12
*/
gboolean
json_parser_load_from_stream_finish (JsonParser *parser,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GError *internal_error;
LoadStreamData *data;
gboolean res;
g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return FALSE;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == json_parser_load_from_stream_async);
data = g_simple_async_result_get_op_res_gpointer (simple);
if (data->error)
{
g_propagate_error (error, data->error);
data->error = NULL;
return FALSE;
}
g_byte_array_set_size (data->content, data->pos + 1);
data->content->data[data->pos] = 0;
internal_error = NULL;
res = json_parser_load (parser, (const gchar *) data->content->data, data->content->len, &internal_error);
if (internal_error != NULL)
g_propagate_error (error, internal_error);
return res;
}
static void g_simple_async_config_thread_handler(GSimpleAsyncResult *simple,
GObject *object, GCancellable *cancellable)
{
HevSerialPort *self = HEV_SERIAL_PORT(object);
HevSerialPortPrivate *priv = HEV_SERIAL_PORT_GET_PRIVATE(self);
struct termios *options = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
options = g_simple_async_result_get_op_res_gpointer(simple);
if(-1 == tcflush(priv->fd, TCIFLUSH))
{
GError *error = NULL;
error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno),
"%s", strerror(errno));
g_simple_async_result_take_error(simple, error);
g_simple_async_result_set_op_res_gboolean(simple, FALSE);
goto ret;
}
if(-1 == tcsetattr(priv->fd, TCSANOW, options))
{
GError *error = NULL;
error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno),
"%s", strerror(errno));
g_simple_async_result_take_error(simple, error);
g_simple_async_result_set_op_res_gboolean(simple, FALSE);
goto ret;
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
ret:
g_free(options);
}
static void
rejilla_track_image_cfg_get_info_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
RejillaTrackImageInfo *info;
RejillaTrackImageCfgPrivate *priv;
priv = REJILLA_TRACK_IMAGE_CFG_PRIVATE (object);
info = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
if (priv->cancel == info->cancel) {
g_object_unref (priv->cancel);
priv->cancel = NULL;
}
if (g_cancellable_is_cancelled (info->cancel)) {
rejilla_track_changed (REJILLA_TRACK (object));
return;
}
if (info->format == REJILLA_IMAGE_FORMAT_NONE
|| info->blocks == 0) {
GError *error = NULL;
g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), &error);
priv->error = error;
rejilla_track_changed (REJILLA_TRACK (object));
return;
}
rejilla_track_image_cfg_set_uri (REJILLA_TRACK_IMAGE_CFG (object),
info->uri,
priv->format != REJILLA_IMAGE_FORMAT_NONE? priv->format:info->format);
REJILLA_TRACK_IMAGE_CLASS (rejilla_track_image_cfg_parent_class)->set_block_num (REJILLA_TRACK_IMAGE (object), info->blocks);
rejilla_track_changed (REJILLA_TRACK (object));
}
gboolean
um_user_manager_cache_user_finish (UmUserManager *manager,
GAsyncResult *result,
UmUser **user,
GError **error)
{
gchar *path;
GSimpleAsyncResult *res;
res = G_SIMPLE_ASYNC_RESULT (result);
*user = NULL;
if (g_simple_async_result_propagate_error (res, error)) {
return FALSE;
}
path = g_simple_async_result_get_op_res_gpointer (res);
*user = g_hash_table_lookup (manager->user_by_object_path, path);
return TRUE;
}
static GList *
lookup_by_name_finish (GResolver *resolver,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
GList *addresses;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_by_name_async), NULL);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
req = g_simple_async_result_get_op_res_gpointer (simple);
addresses = req->u.name.addresses;
req->u.name.addresses = NULL;
return addresses;
}
static void
_lookup_async (GSimpleAsyncResult *simple,
GObject *object,
GCancellable *cancellable)
{
GLibProxyResolver *resolver = G_LIBPROXY_RESOLVER (object);
GError *error = NULL;
gchar **proxies = NULL;
gchar *uri;
uri = g_simple_async_result_get_op_res_gpointer (simple);
proxies = get_libproxy_proxies (resolver, uri, cancellable, &error);
if (error)
{
g_simple_async_result_set_from_error (simple, error);
g_error_free (error);
}
else
g_simple_async_result_set_op_res_gpointer (simple, proxies, (GDestroyNotify)free_libproxy_proxies);
}
static CockpitCreds *
cockpit_auth_remote_login_finish (CockpitAuth *self,
GAsyncResult *result,
GHashTable *headers,
CockpitTransport **transport,
GError **error)
{
RemoteLoginData *rl;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
cockpit_auth_remote_login_async), NULL);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return NULL;
rl = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
if (transport)
*transport = g_object_ref (rl->transport);
return cockpit_creds_ref (rl->creds);
}
static gpointer
seahorse_hkp_source_export_finish (SeahorseServerSource *source,
GAsyncResult *result,
gsize *size,
GError **error)
{
ExportClosure *closure;
gpointer output;
g_return_val_if_fail (size != NULL, NULL);
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (source),
seahorse_hkp_source_export_async), NULL);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return NULL;
closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
*size = closure->data->len;
output = g_string_free (closure->data, FALSE);
closure->data = NULL;
return output;
}
static void
save_snapshot_replace_cb (GFile *snapshot_file,
GAsyncResult *result,
GSimpleAsyncResult *simple)
{
GObject *object;
SaveContext *context;
GFileOutputStream *output_stream;
GError *local_error = NULL;
context = g_simple_async_result_get_op_res_gpointer (simple);
/* Output stream might be NULL, so don't use cast macro. */
output_stream = g_file_replace_finish (
snapshot_file, result, &local_error);
context->output_stream = (GOutputStream *) output_stream;
if (local_error != NULL) {
g_warn_if_fail (output_stream == NULL);
g_simple_async_result_take_error (simple, local_error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
g_return_if_fail (G_IS_OUTPUT_STREAM (output_stream));
/* g_async_result_get_source_object() returns a new reference. */
object = g_async_result_get_source_object (G_ASYNC_RESULT (simple));
/* Extract a MIME message from the composer. */
e_msg_composer_get_message_draft (
E_MSG_COMPOSER (object), G_PRIORITY_DEFAULT,
context->cancellable, (GAsyncReadyCallback)
save_snapshot_get_message_cb, simple);
g_object_unref (object);
}
gboolean
mongo_cursor_count_finish (MongoCursor *cursor,
GAsyncResult *result,
guint64 *count,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
MongoMessageReply *reply;
MongoBsonIter iter;
gboolean ret = FALSE;
GList *list;
g_return_val_if_fail(MONGO_IS_CURSOR(cursor), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE);
g_return_val_if_fail(count, FALSE);
if (!(reply = g_simple_async_result_get_op_res_gpointer(simple))) {
g_simple_async_result_propagate_error(simple, error);
GOTO(failure);
}
if (!(list = mongo_message_reply_get_documents(reply))) {
GOTO(failure);
}
mongo_bson_iter_init(&iter, list->data);
if (!mongo_bson_iter_find(&iter, "n") ||
(mongo_bson_iter_get_value_type(&iter) != MONGO_BSON_DOUBLE)) {
GOTO(failure);
}
*count = mongo_bson_iter_get_value_double(&iter);
ret = TRUE;
failure:
RETURN(ret);
}
