/**
* gsound_context_play_fullv:
* @context: A #GSoundContext
* @attrs: (element-type utf8 utf8): Attributes
* @cancellable: (allow-none): A #GCancellable, or %NULL
* @callback: (scope async): callback
* @user_data: user_data
*
* Rename to: gsound_context_play_full
*/
void
gsound_context_play_fullv(GSoundContext *self,
GHashTable *attrs,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GError *inner_error = NULL;
ca_proplist *proplist;
int res = ca_proplist_create(&proplist);
if (!test_return (res, &inner_error))
{
g_simple_async_report_take_gerror_in_idle (G_OBJECT(self),
callback,
user_data,
inner_error);
}
hash_table_to_prop_list (attrs, proplist);
GSimpleAsyncResult *result = g_simple_async_result_new(G_OBJECT(self),
callback,
user_data,
NULL /*FIXME*/);
res = ca_context_play_full(self->priv->ca,
GPOINTER_TO_INT(cancellable),
proplist,
on_ca_play_full_finished,
result);
if (cancellable)
g_cancellable_connect(cancellable,
G_CALLBACK(on_cancellable_cancelled),
g_object_ref(self),
g_object_unref);
ca_proplist_destroy(proplist);
if (!test_return (res, &inner_error))
{
g_simple_async_report_take_gerror_in_idle (G_OBJECT(self),
callback,
user_data,
inner_error);
g_object_unref(result);
}
}
static void
_at_command (MMBaseModem *self,
const gchar *command,
guint timeout,
gboolean allow_cached,
gboolean is_raw,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMAtSerialPort *port;
GError *error = NULL;
/* No port given, so we'll try to guess which is best */
port = mm_base_modem_peek_best_at_port (self, &error);
if (!port) {
g_assert (error != NULL);
g_simple_async_report_take_gerror_in_idle (G_OBJECT (self),
callback,
user_data,
error);
return;
}
mm_base_modem_at_command_full (self,
port,
command,
timeout,
allow_cached,
is_raw,
NULL,
callback,
user_data);
}
void
mm_base_modem_at_sequence (MMBaseModem *self,
const MMBaseModemAtCommand *sequence,
gpointer response_processor_context,
GDestroyNotify response_processor_context_free,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMAtSerialPort *port;
GError *error = NULL;
/* No port given, so we'll try to guess which is best */
port = mm_base_modem_peek_best_at_port (self, &error);
if (!port) {
g_assert (error != NULL);
g_simple_async_report_take_gerror_in_idle (G_OBJECT (self),
callback,
user_data,
error);
return;
}
mm_base_modem_at_sequence_full (
self,
port,
sequence,
response_processor_context,
response_processor_context_free,
NULL,
callback,
user_data);
}
void
g_vfs_afp_connection_send_command (GVfsAfpConnection *afp_connection,
GVfsAfpCommand *command,
char *reply_buf,
GAsyncReadyCallback callback,
GCancellable *cancellable,
gpointer user_data)
{
GVfsAfpConnectionPrivate *priv = afp_connection->priv;
GError *err = NULL;
RequestData *req_data;
if (!check_open (afp_connection, &err))
{
g_simple_async_report_take_gerror_in_idle (G_OBJECT(afp_connection), callback,
user_data, err);
return;
}
req_data = g_slice_new0 (RequestData);
req_data->type = REQUEST_TYPE_COMMAND;
req_data->command = g_object_ref (command);
req_data->reply_buf = reply_buf;
req_data->simple = g_simple_async_result_new (G_OBJECT (afp_connection), callback,
user_data,
g_vfs_afp_connection_send_command);
req_data->conn = afp_connection;
if (cancellable)
req_data->cancellable = g_object_ref (cancellable);
/* Take lock */
g_mutex_lock (&priv->mutex);
g_queue_push_tail (priv->request_queue, req_data);
if (!priv->send_loop_running)
{
g_main_context_invoke (priv->worker_context, start_send_loop_func,
afp_connection);
}
/* Release lock */
g_mutex_unlock (&priv->mutex);
}
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);
}
