void idle_server_connection_disconnect_full_async(IdleServerConnection *conn, guint reason, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) {
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GSimpleAsyncResult *result;
g_assert(priv != NULL);
if (priv->state != SERVER_CONNECTION_STATE_CONNECTED) {
IDLE_DEBUG("the connection was not open");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"the connection was not open");
return;
}
if (priv->io_stream == NULL) {
IDLE_DEBUG("We were exploding anyway");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"We were exploding anyway");
return;
}
priv->reason = reason;
result = g_simple_async_result_new(G_OBJECT(conn), callback, user_data, idle_server_connection_disconnect_full_async);
g_io_stream_close_async(priv->io_stream, G_PRIORITY_DEFAULT, cancellable, _close_ready, result);
g_object_unref(priv->io_stream);
priv->io_stream = NULL;
}
/**
* gabble_plugin_create_sidecar:
* @plugin: a plugin
* @sidecar_interface: the primary D-Bus interface implemented by the sidecar,
* which must be a member of the list returned by
* gabble_plugin_get_sidecar_interfaces ()
* @callback: function to call when the new sidecar has been created, or an
* unrecoverable error has occured
* @user_data: data to pass to @callback
*/
void
gabble_plugin_create_sidecar (
GabblePlugin *plugin,
const gchar *sidecar_interface,
GabbleConnection *connection,
WockySession *session,
GAsyncReadyCallback callback,
gpointer user_data)
{
GabblePluginInterface *iface = GABBLE_PLUGIN_GET_INTERFACE (plugin);
if (!gabble_plugin_implements_sidecar (plugin, sidecar_interface))
g_simple_async_report_error_in_idle (G_OBJECT (plugin), callback,
user_data, TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
"Gabble is buggy: '%s' doesn't implement sidecar %s",
iface->name, sidecar_interface);
else if (iface->create_sidecar == NULL)
g_simple_async_report_error_in_idle (G_OBJECT (plugin), callback,
user_data, TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
"'%s' is buggy: it claims to implement %s, but does not implement "
"create_sidecar", iface->name, sidecar_interface);
else
iface->create_sidecar (plugin, sidecar_interface, connection, session,
callback, user_data);
}
void idle_server_connection_connect_async(IdleServerConnection *conn, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) {
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GSimpleAsyncResult *result;
if (priv->state != SERVER_CONNECTION_STATE_NOT_CONNECTED) {
IDLE_DEBUG("already connecting or connected!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"already connecting or connected!");
return;
}
if ((priv->host == NULL) || (priv->host[0] == '\0')) {
IDLE_DEBUG("host not set!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"host not set!");
return;
}
if (priv->port == 0) {
IDLE_DEBUG("port not set!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"port not set!");
return;
}
result = g_simple_async_result_new(G_OBJECT(conn), callback, user_data, idle_server_connection_connect_async);
g_socket_client_connect_to_host_async(priv->socket_client, priv->host, priv->port, cancellable, _connect_to_host_ready, result);
change_state(conn, SERVER_CONNECTION_STATE_CONNECTING, SERVER_CONNECTION_STATE_REASON_REQUESTED);
}
static gboolean
abort_async_if_port_unusable (MMBaseModem *self,
MMAtSerialPort *port,
GAsyncReadyCallback callback,
gpointer user_data)
{
GError *error = NULL;
/* If no port given, probably the port dissapeared */
if (!port) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"Cannot run sequence: port not given");
return FALSE;
}
/* Ensure we don't try to use a connected port */
if (mm_port_get_connected (MM_PORT (port))) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_CONNECTED,
"Cannot run sequence: port is connected");
return FALSE;
}
/* Ensure we have a port open during the sequence */
if (!mm_serial_port_open (MM_SERIAL_PORT (port), &error)) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_CONNECTED,
"Cannot run sequence: '%s'",
error->message);
g_error_free (error);
return FALSE;
}
return TRUE;
}
/**
* g_volume_eject_with_operation:
* @volume: a #GVolume.
* @flags: flags affecting the unmount if required for eject
* @mount_operation: (allow-none): a #GMountOperation or %NULL to
* avoid user interaction.
* @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback, or %NULL.
* @user_data: user data passed to @callback.
*
* Ejects a volume. This is an asynchronous operation, and is
* finished by calling g_volume_eject_with_operation_finish() with the @volume
* and #GAsyncResult data returned in the @callback.
*
* Since: 2.22
**/
void
g_volume_eject_with_operation (GVolume *volume,
GMountUnmountFlags flags,
GMountOperation *mount_operation,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GVolumeIface *iface;
g_return_if_fail (G_IS_VOLUME (volume));
iface = G_VOLUME_GET_IFACE (volume);
if (iface->eject == NULL && iface->eject_with_operation == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (volume),
callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
/* Translators: This is an error
* message for volume objects that
* don't implement any of eject or eject_with_operation. */
_("volume doesn't implement eject or eject_with_operation"));
return;
}
if (iface->eject_with_operation != NULL)
(* iface->eject_with_operation) (volume, flags, mount_operation, cancellable, callback, user_data);
else
(* iface->eject) (volume, flags, cancellable, callback, user_data);
}
void
empathy_account_set_display_name_async (EmpathyAccount *account,
const char *display_name,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *result;
GValue value = {0, };
EmpathyAccountPriv *priv = GET_PRIV (account);
if (display_name == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (account),
callback, user_data, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Can't set an empty display name"));
return;
}
result = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, empathy_account_set_display_name_finish);
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, display_name);
tp_cli_dbus_properties_call_set (priv->account, -1, TP_IFACE_ACCOUNT,
"DisplayName", &value, account_display_name_set_cb, result, NULL,
G_OBJECT (account));
}
static void
tf_call_channel_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
TfCallChannel *self = TF_CALL_CHANNEL (initable);
GSimpleAsyncResult *res;
if (cancellable != NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (self), callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
"TfCallChannel initialisation does not support cancellation");
return;
}
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
tf_call_channel_init_async);
tp_g_signal_connect_object (self->proxy, "content-added",
G_CALLBACK (content_added), self, 0);
tp_g_signal_connect_object (self->proxy, "content-removed",
G_CALLBACK (content_removed), self, 0);
tp_proxy_prepare_async (self->proxy, NULL, channel_prepared, res);
}
/**
* g_mount_remount:
* @mount: a #GMount.
* @flags: flags affecting the operation
* @mount_operation: a #GMountOperation or %NULL to avoid user interaction.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback, or %NULL.
* @user_data: user data passed to @callback.
*
* Remounts a mount. This is an asynchronous operation, and is
* finished by calling g_mount_remount_finish() with the @mount
* and #GAsyncResults data returned in the @callback.
*
* Remounting is useful when some setting affecting the operation
* of the volume has been changed, as these may need a remount to
* take affect. While this is semantically equivalent with unmounting
* and then remounting not all backends might need to actually be
* unmounted.
**/
void
g_mount_remount (GMount *mount,
GMountMountFlags flags,
GMountOperation *mount_operation,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GMountIface *iface;
g_return_if_fail (G_IS_MOUNT (mount));
iface = G_MOUNT_GET_IFACE (mount);
if (iface->remount == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (mount),
callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
/* Translators: This is an error
* message for mount objects that
* don't implement remount. */
_("mount doesn't implement \"remount\""));
return;
}
(* iface->remount) (mount, flags, mount_operation, cancellable, callback, user_data);
}
/**
* g_mount_guess_content_type:
* @mount: a #GMount
* @force_rescan: Whether to force a rescan of the content.
* Otherwise a cached result will be used if available
* @cancellable: optional #GCancellable object, %NULL to ignore
* @callback: a #GAsyncReadyCallback
* @user_data: user data passed to @callback
*
* Tries to guess the type of content stored on @mount. Returns one or
* more textual identifiers of well-known content types (typically
* prefixed with "x-content/"), e.g. x-content/image-dcf for camera
* memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
* specification for more on x-content types.
*
* This is an asynchronous operation (see
* g_mount_guess_content_type_sync() for the synchronous version), and
* is finished by calling g_mount_guess_content_type_finish() with the
* @mount and #GAsyncResult data returned in the @callback.
*
* Since: 2.18
*/
void
g_mount_guess_content_type (GMount *mount,
gboolean force_rescan,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GMountIface *iface;
g_return_if_fail (G_IS_MOUNT (mount));
iface = G_MOUNT_GET_IFACE (mount);
if (iface->guess_content_type == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (mount),
callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
/* Translators: This is an error
* message for mount objects that
* don't implement content type guessing. */
_("mount doesn't implement content type guessing"));
return;
}
(* iface->guess_content_type) (mount, force_rescan, cancellable, callback, user_data);
}
/**
* g_volume_mount:
* @volume: a #GVolume.
* @flags: flags affecting the operation
* @mount_operation: (allow-none): a #GMountOperation or %NULL to avoid user interaction.
* @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
* @callback: (allow-none): a #GAsyncReadyCallback, or %NULL.
* @user_data: user data that gets passed to @callback
*
* Mounts a volume. This is an asynchronous operation, and is
* finished by calling g_volume_mount_finish() with the @volume
* and #GAsyncResult returned in the @callback.
*
* Virtual: mount_fn
**/
void
g_volume_mount (GVolume *volume,
GMountMountFlags flags,
GMountOperation *mount_operation,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GVolumeIface *iface;
g_return_if_fail (G_IS_VOLUME (volume));
iface = G_VOLUME_GET_IFACE (volume);
if (iface->mount_fn == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (volume), callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("volume doesn't implement mount"));
return;
}
(* iface->mount_fn) (volume, flags, mount_operation, cancellable, callback, user_data);
}
static void
got_file_size_cb (GObject *source_object,
GAsyncResult *res,
gpointer userdata)
{
SwClientServiceCallClosure *closure = (SwClientServiceCallClosure *) userdata;
SwClientServicePrivate *priv = GET_PRIVATE (closure->service);
GFileInfo *info;
char *filename;
const char *signal;
info = g_file_query_info_finish (G_FILE (source_object), res, NULL);
if (info == NULL ||
g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) != G_FILE_TYPE_REGULAR) {
g_simple_async_report_error_in_idle (G_OBJECT (closure->service),
(GAsyncReadyCallback) closure->cb,
closure->userdata,
SW_CLIENT_SERVICE_ERROR,
0,
info ? "File to upload is not a regular file" :
"Could not get file size information for file");
if (info)
g_object_unref (info);
g_object_unref (closure->service);
g_hash_table_unref (closure->fields);
g_slice_free (SwClientServiceCallClosure, closure);
return;
}
closure->filesize = g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_STANDARD_SIZE);
g_object_unref (info);
signal = (closure->iface == PHOTO_UPLOAD_IFACE ? "PhotoUploadProgress" : "VideoUploadProgress");
dbus_g_proxy_connect_signal (priv->proxies[closure->iface], signal,
G_CALLBACK (_upload_file_progress_cb), closure, NULL);
filename = g_file_get_path (G_FILE (source_object));
if (closure->iface == PHOTO_UPLOAD_IFACE) {
org_gnome_libsocialweb_PhotoUpload_upload_photo_async (priv->proxies[PHOTO_UPLOAD_IFACE],
filename,
closure->fields,
_upload_file_cb,
closure);
} else {
org_gnome_libsocialweb_VideoUpload_upload_video_async (priv->proxies[VIDEO_UPLOAD_IFACE],
filename,
closure->fields,
_upload_file_cb,
closure);
}
g_hash_table_unref (closure->fields);
closure->fields = NULL;
g_free (filename);
}
/**
* gdata_calendar_service_query_own_calendars_async:
* @self: a #GDataCalendarService
* @query: a #GDataQuery with the query parameters, or %NULL
* @cancellable: optional #GCancellable object, or %NULL
* @progress_callback: a #GDataQueryProgressCallback to call when an entry is loaded, or %NULL
* @progress_user_data: data to pass to the @progress_callback function
* @callback: a #GAsyncReadyCallback to call when authentication is finished
* @user_data: data to pass to the @callback function
*
* Queries the service to return a list of calendars from the authenticated account which match the given
* @query, and the authenticated user owns. @self and @query are all reffed when this function is called,
* so can safely be unreffed after this function returns.
*
* For more details, see gdata_calendar_service_query_own_calendars(), which is the synchronous version of
* this function, and gdata_service_query_async(), which is the base asynchronous query function.
**/
void
gdata_calendar_service_query_own_calendars_async (GDataCalendarService *self, GDataQuery *query, GCancellable *cancellable,
GDataQueryProgressCallback progress_callback, gpointer progress_user_data,
GAsyncReadyCallback callback, gpointer user_data)
{
/* Ensure we're authenticated first */
if (gdata_service_is_authenticated (GDATA_SERVICE (self)) == FALSE) {
g_simple_async_report_error_in_idle (G_OBJECT (self), callback, user_data,
GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_AUTHENTICATION_REQUIRED,
_("You must be authenticated to query your own calendars."));
return;
}
gdata_service_query_async (GDATA_SERVICE (self), "http://www.google.com/calendar/feeds/default/owncalendars/full", query,
GDATA_TYPE_CALENDAR_CALENDAR, cancellable, progress_callback, progress_user_data, callback, user_data);
}
static void
connect_3gpp (MMBroadbandBearer *self,
MMBroadbandModem *modem,
MMPortSerialAt *primary,
MMPortSerialAt *secondary,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
Connect3gppContext *ctx;
MMPort *data;
g_assert (primary != NULL);
/* We need a net data port */
data = mm_base_modem_peek_best_data_port (MM_BASE_MODEM (modem), MM_PORT_TYPE_NET);
if (!data) {
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"No valid data port found to launch connection");
return;
}
/* Setup connection context */
ctx = g_slice_new0 (Connect3gppContext);
ctx->self = g_object_ref (self);
ctx->modem = g_object_ref (modem);
ctx->data = g_object_ref (data);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
connect_3gpp);
ctx->cancellable = g_object_ref (cancellable);
ctx->step = CONNECT_3GPP_CONTEXT_STEP_FIRST;
g_assert (ctx->self->priv->connect_pending == NULL);
g_assert (ctx->self->priv->disconnect_pending == NULL);
/* Get correct dial port to use */
ctx->primary = get_dial_port (MM_BROADBAND_MODEM_HUAWEI (ctx->modem), ctx->data, primary);
/* Run! */
connect_3gpp_context_step (ctx);
}
void
mongo_cursor_count_async (MongoCursor *cursor,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MongoCursorPrivate *priv;
GSimpleAsyncResult *simple;
MongoBson *command;
ENTRY;
g_return_if_fail(MONGO_IS_CURSOR(cursor));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
g_return_if_fail(callback);
priv = cursor->priv;
if (!priv->connection) {
g_simple_async_report_error_in_idle(G_OBJECT(cursor),
callback,
user_data,
MONGO_CONNECTION_ERROR,
MONGO_CONNECTION_ERROR_NOT_CONNECTED,
_("Cursor is missing MongoConnection."));
EXIT;
}
simple = g_simple_async_result_new(G_OBJECT(cursor), callback, user_data,
mongo_cursor_count_async);
g_simple_async_result_set_check_cancellable(simple, cancellable);
command = mongo_bson_new_empty();
mongo_bson_append_string(command, "count", priv->collection);
if (priv->query) {
mongo_bson_append_bson(command, "query", priv->query);
}
mongo_connection_command_async(priv->connection,
priv->database,
command,
cancellable,
mongo_cursor_count_cb,
simple);
mongo_bson_unref(command);
EXIT;
}
static void
authorize (MMAuthProvider *self,
GDBusMethodInvocation *invocation,
const gchar *authorization,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMAuthProviderPolkit *polkit = MM_AUTH_PROVIDER_POLKIT (self);
AuthorizeContext *ctx;
/* When creating the object, we actually allowed errors when looking for the
* authority. If that is the case, we'll just forbid any incoming
* authentication request */
if (!polkit->priv->authority) {
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"PolicyKit authorization error: "
"'authority not found'");
return;
}
ctx = g_new (AuthorizeContext, 1);
ctx->self = g_object_ref (self);
ctx->invocation = g_object_ref (invocation);
ctx->authorization = g_strdup (authorization);
ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
authorize);
ctx->subject = polkit_system_bus_name_new (g_dbus_method_invocation_get_sender (ctx->invocation));
polkit_authority_check_authorization (polkit->priv->authority,
ctx->subject,
authorization,
NULL, /* details */
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
ctx->cancellable,
(GAsyncReadyCallback)check_authorization_ready,
ctx);
}
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 hev_impathy_tls_certificate_prepare_async(HevImpathyTLSCertificate *self,
GAsyncReadyCallback callback, gpointer user_data)
{
HevImpathyTLSCertificatePrivate *priv = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_return_if_fail(HEV_IS_IMPATHY_TLS_CERTIFICATE(self));
priv = HEV_IMPATHY_TLS_CERTIFICATE_GET_PRIVATE(self);
/* emit an error if we're already preparing the object */
if(NULL != priv->async_prepare_res)
{
g_simple_async_report_error_in_idle(G_OBJECT(self),
callback, user_data,
G_IO_ERROR, G_IO_ERROR_PENDING,
"%s",
"Prepare operation already in progress"
" on the TLS certificate.");
return;
}
/* if the object is already prepared, just complete in idle */
if(priv->is_prepared)
{
tp_simple_async_report_success_in_idle(G_OBJECT(self),
callback, user_data,
hev_impathy_tls_certificate_prepare_async);
return;
}
priv->async_prepare_res = g_simple_async_result_new(G_OBJECT(self),
callback, user_data,
hev_impathy_tls_certificate_prepare_async);
/* call GetAll() on the certificate */
tp_cli_dbus_properties_call_get_all(self,
-1, TP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
tls_certificate_got_all_handler, NULL, NULL,
G_OBJECT(self));
}
void
mm_port_qmi_allocate_client (MMPortQmi *self,
QmiService service,
MMPortQmiFlag flag,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
AllocateClientContext *ctx;
if (!!mm_port_qmi_peek_client (self, service, flag)) {
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_EXISTS,
"Client for service '%s' already allocated",
qmi_service_get_string (service));
return;
}
ctx = g_new0 (AllocateClientContext, 1);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
mm_port_qmi_allocate_client);
ctx->info = g_new0 (ServiceInfo, 1);
ctx->info->service = service;
ctx->info->flag = flag;
qmi_device_allocate_client (self->priv->qmi_device,
service,
QMI_CID_NONE,
10,
cancellable,
(GAsyncReadyCallback)allocate_client_ready,
ctx);
}
void idle_server_connection_send_async(IdleServerConnection *conn, const gchar *cmd, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) {
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GOutputStream *output_stream;
GSimpleAsyncResult *result;
gsize output_buffer_size = sizeof(priv->output_buffer);
if (priv->state != SERVER_CONNECTION_STATE_CONNECTED
|| priv->io_stream == NULL) {
IDLE_DEBUG("connection was not open!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"connection was not open!");
return;
}
priv->count = strlen(cmd);
if (priv->count > output_buffer_size)
priv->count = output_buffer_size;
/* We only need to copy priv->count bytes, but padding the rest
* with null bytes gives us cleaner debug messages, without
* affecting the readability of the code.
*/
strncpy(priv->output_buffer, cmd, output_buffer_size);
priv->nwritten = 0;
if (cancellable != NULL) {
priv->cancellable = cancellable;
g_object_ref(priv->cancellable);
}
output_stream = g_io_stream_get_output_stream(priv->io_stream);
result = g_simple_async_result_new(G_OBJECT(conn), callback, user_data, idle_server_connection_send_async);
g_output_stream_write_async(output_stream, priv->output_buffer, priv->count, G_PRIORITY_DEFAULT, cancellable, _write_ready, result);
IDLE_DEBUG("sending \"%s\" to OutputStream %p", priv->output_buffer, output_stream);
}
/**
* g_drive_poll_for_media:
* @drive: a #GDrive.
* @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
* @callback: (allow-none): a #GAsyncReadyCallback, or %NULL.
* @user_data: user data to pass to @callback
*
* Asynchronously polls @drive to see if media has been inserted or removed.
*
* When the operation is finished, @callback will be called.
* You can then call g_drive_poll_for_media_finish() to obtain the
* result of the operation.
**/
void
g_drive_poll_for_media (GDrive *drive,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GDriveIface *iface;
g_return_if_fail (G_IS_DRIVE (drive));
iface = G_DRIVE_GET_IFACE (drive);
if (iface->poll_for_media == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (drive), callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("drive doesn't implement polling for media"));
return;
}
(* iface->poll_for_media) (drive, cancellable, callback, user_data);
}
static void
disconnect (MMBearer *_self,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMBearerQmi *self = MM_BEARER_QMI (_self);
DisconnectContext *ctx;
if ((!self->priv->packet_data_handle_ipv4 && !self->priv->packet_data_handle_ipv6) ||
(!self->priv->client_ipv4 && !self->priv->client_ipv6) ||
!self->priv->data) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't disconnect QMI bearer: this bearer is not connected");
return;
}
ctx = g_slice_new0 (DisconnectContext);
ctx->self = g_object_ref (self);
ctx->data = g_object_ref (self->priv->data);
ctx->client_ipv4 = self->priv->client_ipv4 ? g_object_ref (self->priv->client_ipv4) : NULL;
ctx->packet_data_handle_ipv4 = self->priv->packet_data_handle_ipv4;
ctx->client_ipv6 = self->priv->client_ipv6 ? g_object_ref (self->priv->client_ipv6) : NULL;
ctx->packet_data_handle_ipv6 = self->priv->packet_data_handle_ipv6;
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
disconnect);
ctx->step = DISCONNECT_STEP_FIRST;
/* Run! */
disconnect_context_step (ctx);
}
void
empathy_tls_certificate_prepare_async (EmpathyTLSCertificate *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
/* emit an error if we're already preparing the object */
if (priv->async_prepare_res != NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback, user_data,
G_IO_ERROR, G_IO_ERROR_PENDING,
"%s",
"Prepare operation already in progress on the TLS certificate.");
return;
}
/* if the object is already prepared, just complete in idle */
if (priv->is_prepared)
{
tp_simple_async_report_success_in_idle (G_OBJECT (self),
callback, user_data, empathy_tls_certificate_prepare_async);
return;
}
priv->async_prepare_res = g_simple_async_result_new (G_OBJECT (self),
callback, user_data, empathy_tls_certificate_prepare_async);
/* call GetAll() on the certificate */
tp_cli_dbus_properties_call_get_all (self,
-1, EMP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
tls_certificate_got_all_cb, NULL, NULL,
G_OBJECT (self));
}
/**
* g_drive_stop:
* @drive: a #GDrive.
* @flags: flags affecting the unmount if required for stopping.
* @mount_operation: (allow-none): a #GMountOperation or %NULL to avoid
* user interaction.
* @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
* @callback: (allow-none): a #GAsyncReadyCallback, or %NULL.
* @user_data: user data to pass to @callback
*
* Asynchronously stops a drive.
*
* When the operation is finished, @callback will be called.
* You can then call g_drive_stop_finish() to obtain the
* result of the operation.
*
* Since: 2.22
*/
void
g_drive_stop (GDrive *drive,
GMountUnmountFlags flags,
GMountOperation *mount_operation,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GDriveIface *iface;
g_return_if_fail (G_IS_DRIVE (drive));
iface = G_DRIVE_GET_IFACE (drive);
if (iface->stop == NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (drive), callback, user_data,
G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("drive doesn't implement stop"));
return;
}
(* iface->stop) (drive, flags, mount_operation, cancellable, callback, user_data);
}
static void
_connect (MMBearer *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMBearerProperties *properties = NULL;
ConnectContext *ctx;
MMBaseModem *modem = NULL;
MMPort *data;
MMQmiPort *qmi;
GError *error = NULL;
g_object_get (self,
MM_BEARER_MODEM, &modem,
NULL);
g_assert (modem);
/* Grab a data port */
data = mm_base_modem_get_best_data_port (modem);
if (!data) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"No valid data port found to launch connection");
g_object_unref (modem);
return;
}
/* Each data port has a single QMI port associated */
qmi = mm_base_modem_get_port_qmi_for_data (modem, data, &error);
if (!qmi) {
g_simple_async_report_take_gerror_in_idle (
G_OBJECT (self),
callback,
user_data,
error);
g_object_unref (data);
g_object_unref (modem);
return;
}
g_object_unref (modem);
mm_dbg ("Launching connection with QMI port (%s/%s) and data port (%s/%s)",
mm_port_subsys_get_string (mm_port_get_subsys (MM_PORT (qmi))),
mm_port_get_device (MM_PORT (qmi)),
mm_port_subsys_get_string (mm_port_get_subsys (data)),
mm_port_get_device (data));
ctx = g_slice_new0 (ConnectContext);
ctx->self = g_object_ref (self);
ctx->qmi = qmi;
ctx->data = data;
ctx->cancellable = g_object_ref (cancellable);
ctx->step = CONNECT_STEP_FIRST;
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
connect);
g_object_get (self,
MM_BEARER_CONFIG, &properties,
NULL);
if (properties) {
MMBearerAllowedAuth auth;
ctx->apn = g_strdup (mm_bearer_properties_get_apn (properties));
ctx->user = g_strdup (mm_bearer_properties_get_user (properties));
ctx->password = g_strdup (mm_bearer_properties_get_password (properties));
switch (mm_bearer_properties_get_ip_type (properties)) {
case MM_BEARER_IP_FAMILY_IPV4:
ctx->ipv4 = TRUE;
ctx->ipv6 = FALSE;
break;
case MM_BEARER_IP_FAMILY_IPV6:
ctx->ipv4 = FALSE;
ctx->ipv6 = TRUE;
break;
case MM_BEARER_IP_FAMILY_IPV4V6:
ctx->ipv4 = TRUE;
ctx->ipv6 = TRUE;
break;
case MM_BEARER_IP_FAMILY_UNKNOWN:
default:
mm_dbg ("No specific IP family requested, defaulting to IPv4");
ctx->no_ip_family_preference = TRUE;
ctx->ipv4 = TRUE;
ctx->ipv6 = FALSE;
break;
}
auth = mm_bearer_properties_get_allowed_auth (properties);
g_object_unref (properties);
if (auth == MM_BEARER_ALLOWED_AUTH_UNKNOWN) {
mm_dbg ("Using default (PAP) authentication method");
ctx->auth = QMI_WDS_AUTHENTICATION_PAP;
} else if (auth & (MM_BEARER_ALLOWED_AUTH_PAP |
MM_BEARER_ALLOWED_AUTH_CHAP |
MM_BEARER_ALLOWED_AUTH_NONE)) {
/* Only PAP and/or CHAP or NONE are supported */
ctx->auth = mm_bearer_allowed_auth_to_qmi_authentication (auth);
} else {
gchar *str;
str = mm_bearer_allowed_auth_build_string_from_mask (auth);
g_simple_async_result_set_error (
ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot use any of the specified authentication methods (%s)",
str);
g_free (str);
connect_context_complete_and_free (ctx);
return;
}
}
/* Run! */
connect_context_step (ctx);
}
void
_client_create_tube_async (const gchar *account_path,
const gchar *contact_id,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
CreateTubeData *data;
GHashTable *request;
TpDBusDaemon *dbus;
TpAccount *account = NULL;
TpAccountChannelRequest *acr;
GError *error = NULL;
if (g_cancellable_is_cancelled (cancellable))
{
g_simple_async_report_error_in_idle (NULL, callback,
user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED,
"Operation has been cancelled");
return;
}
dbus = tp_dbus_daemon_dup (&error);
if (dbus != NULL)
account = tp_account_new (dbus, account_path, &error);
if (account == NULL)
{
g_simple_async_report_gerror_in_idle (NULL, callback, user_data, error);
g_clear_error (&error);
tp_clear_object (&dbus);
return;
}
simple = g_simple_async_result_new (NULL, callback, user_data,
_client_create_tube_finish);
data = g_slice_new0 (CreateTubeData);
data->op_cancellable = g_cancellable_new ();
if (cancellable != NULL)
{
data->global_cancellable = g_object_ref (cancellable);
data->cancelled_id = g_cancellable_connect (data->global_cancellable,
G_CALLBACK (create_tube_cancelled_cb), simple, NULL);
}
g_simple_async_result_set_op_res_gpointer (simple, data,
(GDestroyNotify) create_tube_data_free);
request = tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
TP_IFACE_CHANNEL_TYPE_STREAM_TUBE,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
TP_HANDLE_TYPE_CONTACT,
TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING,
contact_id,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE, G_TYPE_STRING,
TUBE_SERVICE,
NULL);
acr = tp_account_channel_request_new (account, request, G_MAXINT64);
tp_account_channel_request_create_and_handle_channel_async (acr,
data->op_cancellable, create_channel_cb, simple);
g_hash_table_unref (request);
g_object_unref (dbus);
g_object_unref (account);
g_object_unref (acr);
}
void
mongo_cursor_foreach_async (MongoCursor *cursor,
MongoCursorCallback foreach_func,
gpointer foreach_data,
GDestroyNotify foreach_notify,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MongoCursorPrivate *priv;
GSimpleAsyncResult *simple;
gchar *db_and_collection;
ENTRY;
g_return_if_fail(MONGO_IS_CURSOR(cursor));
g_return_if_fail(foreach_func);
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
g_return_if_fail(callback);
priv = cursor->priv;
if (!priv->connection) {
g_simple_async_report_error_in_idle(G_OBJECT(cursor),
callback,
user_data,
MONGO_CONNECTION_ERROR,
MONGO_CONNECTION_ERROR_NOT_CONNECTED,
_("Not currently connected."));
GOTO(failure);
}
simple = g_simple_async_result_new(G_OBJECT(cursor),
callback,
user_data,
mongo_cursor_foreach_async);
g_simple_async_result_set_check_cancellable(simple, cancellable);
if (cancellable) {
g_object_set_data_full(G_OBJECT(simple), "cancellable",
cancellable, (GDestroyNotify)g_object_unref);
}
g_object_set_data(G_OBJECT(simple), "foreach-func", foreach_func);
if (foreach_notify) {
g_object_set_data_full(G_OBJECT(simple), "foreach-data",
foreach_data, foreach_notify);
} else {
g_object_set_data(G_OBJECT(simple), "foreach-data", foreach_data);
}
db_and_collection = g_strdup_printf("%s.%s",
priv->database,
priv->collection);
mongo_connection_query_async(priv->connection,
db_and_collection,
priv->flags,
priv->skip,
priv->limit,
priv->query,
priv->fields,
cancellable,
mongo_cursor_foreach_query_cb,
simple);
g_free(db_and_collection);
failure:
EXIT;
}
/**
* tp_stream_tube_channel_accept_async:
* @self: an incoming #TpStreamTubeChannel
* @callback: a callback to call when the tube has been accepted
* @user_data: data to pass to @callback
*
* Accept an incoming stream tube. When the tube has been accepted, @callback
* will be called. You can then call tp_stream_tube_channel_accept_finish()
* to get a #TpStreamTubeConnection connected to the tube.
*
* Since: 0.13.2
*/
void
tp_stream_tube_channel_accept_async (TpStreamTubeChannel *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *properties;
GHashTable *supported_sockets;
GError *error = NULL;
g_return_if_fail (TP_IS_STREAM_TUBE_CHANNEL (self));
g_return_if_fail (self->priv->result == NULL);
if (self->priv->access_control_param != NULL)
{
g_simple_async_report_error_in_idle (G_OBJECT (self), callback, user_data,
TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "Tube has already be accepted");
return;
}
self->priv->result = g_simple_async_result_new (G_OBJECT (self), callback,
user_data, tp_stream_tube_channel_accept_async);
properties = _tp_channel_get_immutable_properties (TP_CHANNEL (self));
supported_sockets = tp_asv_get_boxed (properties,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SUPPORTED_SOCKET_TYPES,
TP_HASH_TYPE_SUPPORTED_SOCKET_MAP);
if (!_tp_set_socket_address_type_and_access_control_type (supported_sockets,
&self->priv->socket_type, &self->priv->access_control, &error))
{
operation_failed (self, error);
g_clear_error (&error);
return;
}
DEBUG ("Using socket type %u with access control %u", self->priv->socket_type,
self->priv->access_control);
self->priv->client_socket = _tp_create_client_socket (self->priv->socket_type,
&error);
if (error != NULL)
{
DEBUG ("Failed to create socket: %s", error->message);
operation_failed (self, error);
g_clear_error (&error);
return;
}
switch (self->priv->access_control)
{
case TP_SOCKET_ACCESS_CONTROL_LOCALHOST:
/* Put a dummy value */
self->priv->access_control_param = tp_g_value_slice_new_uint (0);
break;
case TP_SOCKET_ACCESS_CONTROL_PORT:
{
GSocketAddress *addr;
guint16 port;
addr = g_socket_get_local_address (self->priv->client_socket, &error);
if (addr == NULL)
{
DEBUG ("Failed to get local address of client socket: %s",
error->message);
operation_failed (self, error);
g_error_free (error);
return;
}
port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
self->priv->access_control_param = tp_g_value_slice_new_uint (port);
g_object_unref (addr);
}
break;
case TP_SOCKET_ACCESS_CONTROL_CREDENTIALS:
self->priv->access_control_param = tp_g_value_slice_new_byte (
g_random_int_range (0, G_MAXUINT8));
break;
default:
g_assert_not_reached ();
}
/* Call Accept */
tp_cli_channel_type_stream_tube_call_accept (TP_CHANNEL (self), -1,
self->priv->socket_type, self->priv->access_control,
self->priv->access_control_param, _channel_accepted,
NULL, NULL, G_OBJECT (self));
}
