/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
*
* Copyright (C) 2013 Google, Inc.
*/
#include <ModemManager.h>
#define _LIBMM_INSIDE_MM
#include <libmm-glib.h>
#include "mm-iface-modem.h"
#include "mm-iface-modem-oma.h"
#include "mm-log.h"
#define SUPPORT_CHECKED_TAG "oma-support-checked-tag"
#define SUPPORTED_TAG "oma-supported-tag"
static GQuark support_checked_quark;
static GQuark supported_quark;
/*****************************************************************************/
void
mm_iface_modem_oma_bind_simple_status (MMIfaceModemOma *self,
MMSimpleStatus *status)
{
}
/*****************************************************************************/
/* Manage the list of pending network-initiated sessions */
static void
add_or_remove_pending_network_initiated_session (MMIfaceModemOma *self,
gboolean add,
MMOmaSessionType session_type,
guint session_id)
{
MmGdbusModemOma *skeleton;
GVariant *variant;
GArray *array;
guint i;
g_assert (session_type != MM_OMA_SESSION_TYPE_UNKNOWN);
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
variant = mm_gdbus_modem_oma_get_pending_network_initiated_sessions (skeleton);
array = mm_common_oma_pending_network_initiated_sessions_variant_to_garray (variant);
for (i = 0; i < array->len; i++) {
MMOmaPendingNetworkInitiatedSession *session;
session = &g_array_index (array, MMOmaPendingNetworkInitiatedSession, i);
if (session->session_id == session_id)
break;
}
/* If not in the array, and we want to add it, add it */
if (add && i == array->len) {
MMOmaPendingNetworkInitiatedSession session;
session.session_type = session_type;
session.session_id = session_id;
g_array_append_val (array, session);
mm_gdbus_modem_oma_set_pending_network_initiated_sessions (
skeleton,
mm_common_oma_pending_network_initiated_sessions_garray_to_variant (array));
}
/* If found in the array, and we want to remove it, remove it */
else if (!add && i < array->len) {
g_array_remove_index (array, i);
mm_gdbus_modem_oma_set_pending_network_initiated_sessions (
skeleton,
mm_common_oma_pending_network_initiated_sessions_garray_to_variant (array));
}
g_object_unref (skeleton);
g_array_unref (array);
}
void
mm_iface_modem_oma_add_pending_network_initiated_session (MMIfaceModemOma *self,
MMOmaSessionType session_type,
guint session_id)
{
add_or_remove_pending_network_initiated_session (self, TRUE, session_type, session_id);
}
/*****************************************************************************/
/* New session state reported */
void
mm_iface_modem_oma_update_session_state (MMIfaceModemOma *self,
MMOmaSessionState new_session_state,
MMOmaSessionStateFailedReason session_state_failed_reason)
{
MmGdbusModemOma *skeleton;
MMOmaSessionState old_session_state;
/* Make sure proper state vs failed reasons are given */
g_return_if_fail ((new_session_state != MM_OMA_SESSION_STATE_FAILED &&
session_state_failed_reason == MM_OMA_SESSION_STATE_FAILED_REASON_UNKNOWN) ||
(new_session_state == MM_OMA_SESSION_STATE_FAILED));
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
old_session_state = mm_gdbus_modem_oma_get_session_state (skeleton);
if (old_session_state != new_session_state) {
mm_info ("Modem %s: OMA session state changed (%s -> %s)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (self)),
mm_oma_session_state_get_string (old_session_state),
mm_oma_session_state_get_string (new_session_state));
/* Flush current change before signaling the state change,
* so that clients get the proper state already in the
* state-changed callback */
mm_gdbus_modem_oma_set_session_state (skeleton, new_session_state);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (skeleton));
mm_gdbus_modem_oma_emit_session_state_changed (
skeleton,
old_session_state,
new_session_state,
session_state_failed_reason);
}
}
/*****************************************************************************/
/* Handle Setup() */
typedef struct {
MmGdbusModemOma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemOma *self;
guint32 features;
} HandleSetupContext;
static void
handle_setup_context_free (HandleSetupContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_slice_free (HandleSetupContext, ctx);
}
static void
setup_ready (MMIfaceModemOma *self,
GAsyncResult *res,
HandleSetupContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->setup_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else {
/* Update current features in the interface */
mm_gdbus_modem_oma_set_features (ctx->skeleton, ctx->features);
mm_gdbus_modem_oma_complete_setup (ctx->skeleton, ctx->invocation);
}
handle_setup_context_free (ctx);
}
static void
handle_setup_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleSetupContext *ctx)
{
GError *error = NULL;
MMModemState modem_state;
gchar *str;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_setup_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state < MM_MODEM_STATE_ENABLED) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot setup OMA: "
"device not yet enabled");
handle_setup_context_free (ctx);
return;
}
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->setup ||
!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->setup_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot setup OMA: "
"operation not supported");
handle_setup_context_free (ctx);
return;
}
str = mm_oma_feature_build_string_from_mask (ctx->features);
mm_dbg ("Setting up OMA features: '%s'", str);
g_free (str);
MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->setup (
ctx->self,
ctx->features,
(GAsyncReadyCallback)setup_ready,
ctx);
}
static gboolean
handle_setup (MmGdbusModemOma *skeleton,
GDBusMethodInvocation *invocation,
guint32 features,
MMIfaceModemOma *self)
{
HandleSetupContext *ctx;
ctx = g_slice_new0 (HandleSetupContext);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->features = features;
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_setup_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
/* Handle StartClientInitiatedSession() */
typedef struct {
MmGdbusModemOma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemOma *self;
MMOmaSessionType session_type;
} HandleStartClientInitiatedSessionContext;
static void
handle_start_client_initiated_session_context_free (HandleStartClientInitiatedSessionContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_slice_free (HandleStartClientInitiatedSessionContext, ctx);
}
static void
start_client_initiated_session_ready (MMIfaceModemOma *self,
GAsyncResult *res,
HandleStartClientInitiatedSessionContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->start_client_initiated_session_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else {
/* Update interface info */
mm_gdbus_modem_oma_set_session_type (ctx->skeleton, ctx->session_type);
mm_iface_modem_oma_update_session_state (self, MM_OMA_SESSION_STATE_STARTED, MM_OMA_SESSION_STATE_FAILED_REASON_UNKNOWN);
mm_gdbus_modem_oma_complete_start_client_initiated_session (ctx->skeleton, ctx->invocation);
}
handle_start_client_initiated_session_context_free (ctx);
}
static void
handle_start_client_initiated_session_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleStartClientInitiatedSessionContext *ctx)
{
GError *error = NULL;
MMModemState modem_state;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_start_client_initiated_session_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state < MM_MODEM_STATE_ENABLED) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot start client-initiated OMA session: "
"device not yet enabled");
handle_start_client_initiated_session_context_free (ctx);
return;
}
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->start_client_initiated_session ||
!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->start_client_initiated_session_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot start client-initiated OMA session: "
"operation not supported");
handle_start_client_initiated_session_context_free (ctx);
return;
}
if (ctx->session_type != MM_OMA_SESSION_TYPE_CLIENT_INITIATED_DEVICE_CONFIGURE &&
ctx->session_type != MM_OMA_SESSION_TYPE_CLIENT_INITIATED_PRL_UPDATE &&
ctx->session_type != MM_OMA_SESSION_TYPE_CLIENT_INITIATED_HANDS_FREE_ACTIVATION) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot start client-initiated OMA session: "
"invalid session type specified (%s)",
mm_oma_session_type_get_string (ctx->session_type));
handle_start_client_initiated_session_context_free (ctx);
return;
}
mm_dbg ("Starting client-initiated OMA session (%s)",
mm_oma_session_type_get_string (ctx->session_type));
MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->start_client_initiated_session (
ctx->self,
ctx->session_type,
(GAsyncReadyCallback)start_client_initiated_session_ready,
ctx);
}
static gboolean
handle_start_client_initiated_session (MmGdbusModemOma *skeleton,
GDBusMethodInvocation *invocation,
guint32 session_type,
MMIfaceModemOma *self)
{
HandleStartClientInitiatedSessionContext *ctx;
ctx = g_slice_new0 (HandleStartClientInitiatedSessionContext);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->session_type = session_type;
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_start_client_initiated_session_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
/* Handle AcceptNetworkInitiatedSession() */
typedef struct {
MmGdbusModemOma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemOma *self;
MMOmaSessionType session_type;
guint session_id;
gboolean accept;
} HandleAcceptNetworkInitiatedSessionContext;
static void
handle_accept_network_initiated_session_context_free (HandleAcceptNetworkInitiatedSessionContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_slice_free (HandleAcceptNetworkInitiatedSessionContext, ctx);
}
static void
accept_network_initiated_session_ready (MMIfaceModemOma *self,
GAsyncResult *res,
HandleAcceptNetworkInitiatedSessionContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->accept_network_initiated_session_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else {
/* If accepted or rejected, remove from pending */
add_or_remove_pending_network_initiated_session (self, FALSE, ctx->session_type, ctx->session_id);
/* If accepted, set as current */
if (ctx->accept) {
mm_gdbus_modem_oma_set_session_type (ctx->skeleton, ctx->session_type);
mm_iface_modem_oma_update_session_state (self, MM_OMA_SESSION_STATE_STARTED, MM_OMA_SESSION_STATE_FAILED_REASON_UNKNOWN);
}
mm_gdbus_modem_oma_complete_accept_network_initiated_session (ctx->skeleton, ctx->invocation);
}
handle_accept_network_initiated_session_context_free (ctx);
}
static MMOmaSessionType
get_pending_network_initiated_session_type (MMIfaceModemOma *self,
guint session_id)
{
MMOmaSessionType session_type = MM_OMA_SESSION_TYPE_UNKNOWN;
MmGdbusModemOma *skeleton;
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &skeleton,
NULL);
if (skeleton) {
GArray *array;
guint i;
array = (mm_common_oma_pending_network_initiated_sessions_variant_to_garray (
mm_gdbus_modem_oma_get_pending_network_initiated_sessions (skeleton)));
for (i = 0; i < array->len && session_type == MM_OMA_SESSION_TYPE_UNKNOWN; i++) {
MMOmaPendingNetworkInitiatedSession *session;
session = &g_array_index (array, MMOmaPendingNetworkInitiatedSession, i);
if (session->session_id == session_id)
session_type = session->session_type;
}
g_array_unref (array);
g_object_unref (skeleton);
}
return session_type;
}
static void
handle_accept_network_initiated_session_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleAcceptNetworkInitiatedSessionContext *ctx)
{
GError *error = NULL;
MMModemState modem_state;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_accept_network_initiated_session_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state < MM_MODEM_STATE_ENABLED) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot accept network-initiated OMA session: "
"device not yet enabled");
handle_accept_network_initiated_session_context_free (ctx);
return;
}
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->accept_network_initiated_session ||
!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->accept_network_initiated_session_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot accept network-initiated OMA session: "
"operation not supported");
handle_accept_network_initiated_session_context_free (ctx);
return;
}
ctx->session_type = get_pending_network_initiated_session_type (ctx->self, ctx->session_id);
if (ctx->session_type == MM_OMA_SESSION_TYPE_UNKNOWN) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot accept network-initiated OMA session: "
"unknown session id (%u)",
ctx->session_id);
handle_accept_network_initiated_session_context_free (ctx);
return;
}
mm_dbg ("%s network-initiated OMA session (%s, %u)",
ctx->accept ? "Accepting" : "Rejecting",
mm_oma_session_type_get_string (ctx->session_type),
ctx->session_id);
MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->accept_network_initiated_session (
ctx->self,
ctx->session_id,
ctx->accept,
(GAsyncReadyCallback)accept_network_initiated_session_ready,
ctx);
}
static gboolean
handle_accept_network_initiated_session (MmGdbusModemOma *skeleton,
GDBusMethodInvocation *invocation,
guint32 session_id,
gboolean accept,
MMIfaceModemOma *self)
{
HandleAcceptNetworkInitiatedSessionContext *ctx;
ctx = g_slice_new0 (HandleAcceptNetworkInitiatedSessionContext);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->session_type = MM_OMA_SESSION_TYPE_UNKNOWN;
ctx->session_id = session_id;
ctx->accept = accept;
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_accept_network_initiated_session_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
/* Handle CancelSession() */
typedef struct {
MmGdbusModemOma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemOma *self;
} HandleCancelSessionContext;
static void
handle_cancel_session_context_free (HandleCancelSessionContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_slice_free (HandleCancelSessionContext, ctx);
}
static void
cancel_session_ready (MMIfaceModemOma *self,
GAsyncResult *res,
HandleCancelSessionContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->cancel_session_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else {
/* Clear interface info when cancelled */
mm_gdbus_modem_oma_set_session_type (ctx->skeleton, MM_OMA_SESSION_TYPE_UNKNOWN);
mm_iface_modem_oma_update_session_state (self, MM_OMA_SESSION_STATE_UNKNOWN, MM_OMA_SESSION_STATE_FAILED_REASON_UNKNOWN);
mm_gdbus_modem_oma_complete_cancel_session (ctx->skeleton, ctx->invocation);
}
handle_cancel_session_context_free (ctx);
}
static void
handle_cancel_session_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleCancelSessionContext *ctx)
{
GError *error = NULL;
MMModemState modem_state;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_cancel_session_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state < MM_MODEM_STATE_ENABLED) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot cancel OMA session: "
"device not yet enabled");
handle_cancel_session_context_free (ctx);
return;
}
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->cancel_session ||
!MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->cancel_session_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot cancel OMA session: "
"operation not supported");
handle_cancel_session_context_free (ctx);
return;
}
mm_dbg ("Cancelling OMA session");
MM_IFACE_MODEM_OMA_GET_INTERFACE (ctx->self)->cancel_session (
ctx->self,
(GAsyncReadyCallback)cancel_session_ready,
ctx);
}
static gboolean
handle_cancel_session (MmGdbusModemOma *skeleton,
GDBusMethodInvocation *invocation,
MMIfaceModemOma *self)
{
HandleCancelSessionContext *ctx;
ctx = g_slice_new0 (HandleCancelSessionContext);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_cancel_session_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
typedef struct _DisablingContext DisablingContext;
static void interface_disabling_step (GTask *task);
typedef enum {
DISABLING_STEP_FIRST,
DISABLING_STEP_DISABLE_UNSOLICITED_EVENTS,
DISABLING_STEP_CLEANUP_UNSOLICITED_EVENTS,
DISABLING_STEP_LAST
} DisablingStep;
struct _DisablingContext {
DisablingStep step;
MmGdbusModemOma *skeleton;
};
static void
disabling_context_free (DisablingContext *ctx)
{
if (ctx->skeleton)
g_object_unref (ctx->skeleton);
g_free (ctx);
}
gboolean
mm_iface_modem_oma_disable_finish (MMIfaceModemOma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
disable_unsolicited_events_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
DisablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->disable_unsolicited_events_finish (self, res, &error);
if (error) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_disabling_step (task);
}
static void
cleanup_unsolicited_events_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
DisablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->cleanup_unsolicited_events_finish (self, res, &error);
if (error) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_disabling_step (task);
}
static void
interface_disabling_step (GTask *task)
{
MMIfaceModemOma *self;
DisablingContext *ctx;
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case DISABLING_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_DISABLE_UNSOLICITED_EVENTS:
/* Allow cleaning up unsolicited events */
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->disable_unsolicited_events &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->disable_unsolicited_events_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->disable_unsolicited_events (
self,
(GAsyncReadyCallback)disable_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_CLEANUP_UNSOLICITED_EVENTS:
/* Allow cleaning up unsolicited events */
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->cleanup_unsolicited_events &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->cleanup_unsolicited_events_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->cleanup_unsolicited_events (
self,
(GAsyncReadyCallback)cleanup_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_LAST:
/* We are done without errors! */
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
void
mm_iface_modem_oma_disable (MMIfaceModemOma *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
DisablingContext *ctx;
GTask *task;
ctx = g_new0 (DisablingContext, 1);
ctx->step = DISABLING_STEP_FIRST;
task = g_task_new (self, NULL, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)disabling_context_free);
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &ctx->skeleton,
NULL);
if (!ctx->skeleton) {
g_task_return_new_error (task,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
g_object_unref (task);
return;
}
interface_disabling_step (task);
}
/*****************************************************************************/
typedef struct _EnablingContext EnablingContext;
static void interface_enabling_step (GTask *task);
typedef enum {
ENABLING_STEP_FIRST,
ENABLING_STEP_LOAD_FEATURES,
ENABLING_STEP_SETUP_UNSOLICITED_EVENTS,
ENABLING_STEP_ENABLE_UNSOLICITED_EVENTS,
ENABLING_STEP_LAST
} EnablingStep;
struct _EnablingContext {
EnablingStep step;
MmGdbusModemOma *skeleton;
};
static void
enabling_context_free (EnablingContext *ctx)
{
if (ctx->skeleton)
g_object_unref (ctx->skeleton);
g_free (ctx);
}
gboolean
mm_iface_modem_oma_enable_finish (MMIfaceModemOma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
load_features_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
EnablingContext *ctx;
GError *error = NULL;
MMOmaFeature features;
features = MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->load_features_finish (self, res, &error);
if (error) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
ctx = g_task_get_task_data (task);
/* Update in the interface */
mm_gdbus_modem_oma_set_features (ctx->skeleton, features);
/* Go on to next step */
ctx->step++;
interface_enabling_step (task);
}
static void
setup_unsolicited_events_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
EnablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->setup_unsolicited_events_finish (self, res, &error);
if (error) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_enabling_step (task);
}
static void
enable_unsolicited_events_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
EnablingContext *ctx;
GError *error = NULL;
/* Not critical! */
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->enable_unsolicited_events_finish (self, res, &error)) {
mm_dbg ("Couldn't enable unsolicited events: '%s'", error->message);
g_error_free (error);
}
/* Go on with next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_enabling_step (task);
}
static void
interface_enabling_step (GTask *task)
{
MMIfaceModemOma *self;
EnablingContext *ctx;
/* Don't run new steps if we're cancelled */
if (g_task_return_error_if_cancelled (task)) {
g_object_unref (task);
return;
}
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case ENABLING_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_LOAD_FEATURES:
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->load_features &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->load_features_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->load_features (
self,
(GAsyncReadyCallback)load_features_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_SETUP_UNSOLICITED_EVENTS:
/* Allow setting up unsolicited events */
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->setup_unsolicited_events &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->setup_unsolicited_events_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->setup_unsolicited_events (
self,
(GAsyncReadyCallback)setup_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_ENABLE_UNSOLICITED_EVENTS:
/* Allow setting up unsolicited events */
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->enable_unsolicited_events &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->enable_unsolicited_events_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->enable_unsolicited_events (
self,
(GAsyncReadyCallback)enable_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_LAST:
/* We are done without errors! */
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
void
mm_iface_modem_oma_enable (MMIfaceModemOma *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
EnablingContext *ctx;
GTask *task;
ctx = g_new0 (EnablingContext, 1);
ctx->step = ENABLING_STEP_FIRST;
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)enabling_context_free);
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &ctx->skeleton,
NULL);
if (!ctx->skeleton) {
g_task_return_new_error (task,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
g_object_unref (task);
return;
}
interface_enabling_step (task);
}
/*****************************************************************************/
typedef struct _InitializationContext InitializationContext;
static void interface_initialization_step (GTask *task);
typedef enum {
INITIALIZATION_STEP_FIRST,
INITIALIZATION_STEP_CHECK_SUPPORT,
INITIALIZATION_STEP_FAIL_IF_UNSUPPORTED,
INITIALIZATION_STEP_LAST
} InitializationStep;
struct _InitializationContext {
MmGdbusModemOma *skeleton;
InitializationStep step;
};
static void
initialization_context_free (InitializationContext *ctx)
{
g_object_unref (ctx->skeleton);
g_free (ctx);
}
static void
check_support_ready (MMIfaceModemOma *self,
GAsyncResult *res,
GTask *task)
{
InitializationContext *ctx;
GError *error = NULL;
if (!MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->check_support_finish (self, res, &error)) {
if (error) {
/* This error shouldn't be treated as critical */
mm_dbg ("OMA support check failed: '%s'", error->message);
g_error_free (error);
}
} else {
/* OMA is supported! */
g_object_set_qdata (G_OBJECT (self),
supported_quark,
GUINT_TO_POINTER (TRUE));
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_initialization_step (task);
}
static void
interface_initialization_step (GTask *task)
{
MMIfaceModemOma *self;
InitializationContext *ctx;
/* Don't run new steps if we're cancelled */
if (g_task_return_error_if_cancelled (task)) {
g_object_unref (task);
return;
}
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case INITIALIZATION_STEP_FIRST:
/* Setup quarks if we didn't do it before */
if (G_UNLIKELY (!support_checked_quark))
support_checked_quark = (g_quark_from_static_string (
SUPPORT_CHECKED_TAG));
if (G_UNLIKELY (!supported_quark))
supported_quark = (g_quark_from_static_string (
SUPPORTED_TAG));
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_CHECK_SUPPORT:
if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (self),
support_checked_quark))) {
/* Set the checked flag so that we don't run it again */
g_object_set_qdata (G_OBJECT (self),
support_checked_quark,
GUINT_TO_POINTER (TRUE));
/* Initially, assume we don't support it */
g_object_set_qdata (G_OBJECT (self),
supported_quark,
GUINT_TO_POINTER (FALSE));
if (MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->check_support &&
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->check_support_finish) {
MM_IFACE_MODEM_OMA_GET_INTERFACE (self)->check_support (
self,
(GAsyncReadyCallback)check_support_ready,
task);
return;
}
/* If there is no implementation to check support, assume we DON'T
* support it. */
}
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_FAIL_IF_UNSUPPORTED:
if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (self),
supported_quark))) {
g_task_return_new_error (task,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"OMA not supported");
g_object_unref (task);
return;
}
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_LAST:
/* We are done without errors! */
/* Handle method invocations */
g_signal_connect (ctx->skeleton,
"handle-setup",
G_CALLBACK (handle_setup),
self);
g_signal_connect (ctx->skeleton,
"handle-start-client-initiated-session",
G_CALLBACK (handle_start_client_initiated_session),
self);
g_signal_connect (ctx->skeleton,
"handle-accept-network-initiated-session",
G_CALLBACK (handle_accept_network_initiated_session),
self);
g_signal_connect (ctx->skeleton,
"handle-cancel-session",
G_CALLBACK (handle_cancel_session),
self);
/* Finally, export the new interface */
mm_gdbus_object_skeleton_set_modem_oma (MM_GDBUS_OBJECT_SKELETON (self),
MM_GDBUS_MODEM_OMA (ctx->skeleton));
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
gboolean
mm_iface_modem_oma_initialize_finish (MMIfaceModemOma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
void
mm_iface_modem_oma_initialize (MMIfaceModemOma *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
InitializationContext *ctx;
MmGdbusModemOma *skeleton = NULL;
GTask *task;
/* Did we already create it? */
g_object_get (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton) {
skeleton = mm_gdbus_modem_oma_skeleton_new ();
g_object_set (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, skeleton,
NULL);
/* Set all initial property defaults */
mm_gdbus_modem_oma_set_features (skeleton, MM_OMA_FEATURE_NONE);
mm_gdbus_modem_oma_set_session_type (skeleton, MM_OMA_SESSION_TYPE_UNKNOWN);
mm_gdbus_modem_oma_set_session_state (skeleton, MM_OMA_SESSION_STATE_UNKNOWN);
mm_gdbus_modem_oma_set_pending_network_initiated_sessions (skeleton, mm_common_build_oma_pending_network_initiated_sessions_default ());
}
/* Perform async initialization here */
ctx = g_new0 (InitializationContext, 1);
ctx->step = INITIALIZATION_STEP_FIRST;
ctx->skeleton = skeleton;
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)initialization_context_free);
interface_initialization_step (task);
}
void
mm_iface_modem_oma_shutdown (MMIfaceModemOma *self)
{
/* Unexport DBus interface and remove the skeleton */
mm_gdbus_object_skeleton_set_modem_oma (MM_GDBUS_OBJECT_SKELETON (self), NULL);
g_object_set (self,
MM_IFACE_MODEM_OMA_DBUS_SKELETON, NULL,
NULL);
}
/*****************************************************************************/
static void
iface_modem_oma_init (gpointer g_iface)
{
static gboolean initialized = FALSE;
if (initialized)
return;
/* Properties */
g_object_interface_install_property
(g_iface,
g_param_spec_object (MM_IFACE_MODEM_OMA_DBUS_SKELETON,
"OMA DBus skeleton",
"DBus skeleton for the OMA interface",
MM_GDBUS_TYPE_MODEM_OMA_SKELETON,
G_PARAM_READWRITE));
initialized = TRUE;
}
GType
mm_iface_modem_oma_get_type (void)
{
static GType iface_modem_oma_type = 0;
if (!G_UNLIKELY (iface_modem_oma_type)) {
static const GTypeInfo info = {
sizeof (MMIfaceModemOma), /* class_size */
iface_modem_oma_init, /* base_init */
NULL, /* base_finalize */
};
iface_modem_oma_type = g_type_register_static (G_TYPE_INTERFACE,
"MMIfaceModemOma",
&info,
0);
g_type_interface_add_prerequisite (iface_modem_oma_type, MM_TYPE_IFACE_MODEM);
}
return iface_modem_oma_type;
}