From 3ca267b01f5496e1d03f31801a14a383acbd33a2 Mon Sep 17 00:00:00 2001 From: Aleksander Morgado Date: Sun, 6 Jul 2014 15:55:34 +0200 Subject: bearer: rename 'MMBearer' to 'MMBaseBearer' Just so that we don't have same header names in src/ and /libmm-glib. --- src/Makefile.am | 10 +- src/mm-base-bearer.c | 1300 ++++++++++++++++++++++++++++++++++++++++ src/mm-base-bearer.h | 139 +++++ src/mm-bearer-list.c | 24 +- src/mm-bearer-list.h | 10 +- src/mm-bearer-mbim.c | 42 +- src/mm-bearer-mbim.h | 12 +- src/mm-bearer-qmi.c | 46 +- src/mm-bearer-qmi.h | 10 +- src/mm-bearer.c | 1301 ----------------------------------------- src/mm-bearer.h | 138 ----- src/mm-broadband-bearer.c | 64 +- src/mm-broadband-bearer.h | 24 +- src/mm-broadband-modem-mbim.c | 16 +- src/mm-broadband-modem-qmi.c | 12 +- src/mm-broadband-modem.c | 8 +- src/mm-iface-modem-simple.c | 50 +- src/mm-iface-modem.c | 24 +- src/mm-iface-modem.h | 22 +- 19 files changed, 1625 insertions(+), 1627 deletions(-) create mode 100644 src/mm-base-bearer.c create mode 100644 src/mm-base-bearer.h delete mode 100644 src/mm-bearer.c delete mode 100644 src/mm-bearer.h (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index bda13e1f..15521c73 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -113,12 +113,12 @@ endif # Daemon specific enum types DAEMON_ENUMS = \ - $(srcdir)/mm-bearer.h \ + $(srcdir)/mm-base-bearer.h \ $(srcdir)/mm-port-probe.h mm-daemon-enums-types.h: Makefile.am $(DAEMON_ENUMS) $(top_srcdir)/build-aux/mm-enums-template.h $(AM_V_GEN) $(GLIB_MKENUMS) \ - --fhead "#include \"mm-bearer.h\"\n#include \"mm-port-probe.h\"\n#ifndef __MM_DAEMON_ENUMS_TYPES_H__\n#define __MM_DAEMON_ENUMS_TYPES_H__\n" \ + --fhead "#include \"mm-base-bearer.h\"\n#include \"mm-port-probe.h\"\n#ifndef __MM_DAEMON_ENUMS_TYPES_H__\n#define __MM_DAEMON_ENUMS_TYPES_H__\n" \ --template $(top_srcdir)/build-aux/mm-enums-template.h \ --ftail "#endif /* __MM_DAEMON_ENUMS_TYPES_H__ */\n" \ $(DAEMON_ENUMS) > $@ @@ -177,8 +177,8 @@ ModemManager_SOURCES = \ mm-plugin-manager.h \ mm-sim.h \ mm-sim.c \ - mm-bearer.h \ - mm-bearer.c \ + mm-base-bearer.h \ + mm-base-bearer.c \ mm-broadband-bearer.h \ mm-broadband-bearer.c \ mm-bearer-list.h \ @@ -225,7 +225,7 @@ ModemManager_SOURCES = \ mm-plugin.h # Additional dependency rules -mm-bearer.c: mm-daemon-enums-types.h +mm-base-bearer.c: mm-daemon-enums-types.h # Additional Polkit support if WITH_POLKIT diff --git a/src/mm-base-bearer.c b/src/mm-base-bearer.c new file mode 100644 index 00000000..1b1c7b31 --- /dev/null +++ b/src/mm-base-bearer.c @@ -0,0 +1,1300 @@ +/* -*- 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) 2008 - 2009 Novell, Inc. + * Copyright (C) 2009 - 2011 Red Hat, Inc. + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2011 - 2014 Aleksander Morgado + */ + +#include +#include +#include +#include +#include +#include + +#include +#define _LIBMM_INSIDE_MM +#include + +#include "mm-daemon-enums-types.h" +#include "mm-iface-modem.h" +#include "mm-iface-modem-3gpp.h" +#include "mm-iface-modem-cdma.h" +#include "mm-base-bearer.h" +#include "mm-base-modem-at.h" +#include "mm-base-modem.h" +#include "mm-log.h" +#include "mm-modem-helpers.h" + +/* We require up to 20s to get a proper IP when using PPP */ +#define BEARER_IP_TIMEOUT_DEFAULT 20 + +#define BEARER_DEFERRED_UNREGISTRATION_TIMEOUT 15 + +G_DEFINE_TYPE (MMBaseBearer, mm_base_bearer, MM_GDBUS_TYPE_BEARER_SKELETON); + +typedef enum { + CONNECTION_FORBIDDEN_REASON_NONE, + CONNECTION_FORBIDDEN_REASON_UNREGISTERED, + CONNECTION_FORBIDDEN_REASON_ROAMING, + CONNECTION_FORBIDDEN_REASON_LAST +} ConnectionForbiddenReason; + +enum { + PROP_0, + PROP_PATH, + PROP_CONNECTION, + PROP_MODEM, + PROP_STATUS, + PROP_CONFIG, + PROP_DEFAULT_IP_FAMILY, + PROP_LAST +}; + +static GParamSpec *properties[PROP_LAST]; + +struct _MMBaseBearerPrivate { + /* The connection to the system bus */ + GDBusConnection *connection; + /* The modem which owns this BEARER */ + MMBaseModem *modem; + /* The path where the BEARER object is exported */ + gchar *path; + /* Status of this bearer */ + MMBearerStatus status; + /* Configuration of the bearer */ + MMBearerProperties *config; + /* Default IP family of this bearer */ + MMBearerIpFamily default_ip_family; + + /* Cancellable for connect() */ + GCancellable *connect_cancellable; + /* handler id for the disconnect + cancel connect request */ + gulong disconnect_signal_handler; + + /*-- 3GPP specific --*/ + guint deferred_3gpp_unregistration_id; + /* Reason if 3GPP connection is forbidden */ + ConnectionForbiddenReason reason_3gpp; + /* Handler ID for the registration state change signals */ + guint id_3gpp_registration_change; + + /*-- CDMA specific --*/ + guint deferred_cdma_unregistration_id; + /* Reason if CDMA connection is forbidden */ + ConnectionForbiddenReason reason_cdma; + /* Handler IDs for the registration state change signals */ + guint id_cdma1x_registration_change; + guint id_evdo_registration_change; +}; + +/*****************************************************************************/ + +static const gchar *connection_forbidden_reason_str [CONNECTION_FORBIDDEN_REASON_LAST] = { + "none", + "Not registered in the network", + "Registered in roaming network, and roaming not allowed" +}; + +/*****************************************************************************/ + +void +mm_base_bearer_export (MMBaseBearer *self) +{ + static guint id = 0; + gchar *path; + + path = g_strdup_printf (MM_DBUS_BEARER_PREFIX "/%d", id++); + g_object_set (self, + MM_BASE_BEARER_PATH, path, + NULL); + g_free (path); +} + +/*****************************************************************************/ + +static void +bearer_reset_interface_status (MMBaseBearer *self) +{ + mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), FALSE); + mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); + mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), NULL); + mm_gdbus_bearer_set_ip4_config ( + MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (NULL)); + mm_gdbus_bearer_set_ip6_config ( + MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (NULL)); +} + +static void +bearer_update_status (MMBaseBearer *self, + MMBearerStatus status) +{ + /* NOTE: we do allow status 'CONNECTED' here; it may happen if we go into + * DISCONNECTING and we cannot disconnect */ + + /* Update the property value */ + self->priv->status = status; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_STATUS]); + + /* Ensure that we don't expose any connection related data in the + * interface when going into disconnected state. */ + if (self->priv->status == MM_BEARER_STATUS_DISCONNECTED) + bearer_reset_interface_status (self); +} + +static void +bearer_update_status_connected (MMBaseBearer *self, + const gchar *interface, + MMBearerIpConfig *ipv4_config, + MMBearerIpConfig *ipv6_config) +{ + mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), TRUE); + mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); + mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), interface); + mm_gdbus_bearer_set_ip4_config ( + MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (ipv4_config)); + mm_gdbus_bearer_set_ip6_config ( + MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (ipv6_config)); + + /* Update the property value */ + self->priv->status = MM_BEARER_STATUS_CONNECTED; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_STATUS]); +} + +/*****************************************************************************/ + +static void +reset_deferred_unregistration (MMBaseBearer *self) +{ + if (self->priv->deferred_cdma_unregistration_id) { + g_source_remove (self->priv->deferred_cdma_unregistration_id); + self->priv->deferred_cdma_unregistration_id = 0; + } + + if (self->priv->deferred_3gpp_unregistration_id) { + g_source_remove (self->priv->deferred_3gpp_unregistration_id); + self->priv->deferred_3gpp_unregistration_id = 0; + } +} + +static gboolean +deferred_3gpp_unregistration_cb (MMBaseBearer *self) +{ + g_warn_if_fail (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_UNREGISTERED); + self->priv->deferred_3gpp_unregistration_id = 0; + + mm_dbg ("Forcing bearer disconnection, not registered in 3GPP network"); + mm_base_bearer_disconnect_force (self); + return FALSE; +} + +static void +modem_3gpp_registration_state_changed (MMIfaceModem3gpp *modem, + GParamSpec *pspec, + MMBaseBearer *self) +{ + MMModem3gppRegistrationState state = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN; + + g_object_get (modem, + MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, &state, + NULL); + + switch (state) { + case MM_MODEM_3GPP_REGISTRATION_STATE_IDLE: + case MM_MODEM_3GPP_REGISTRATION_STATE_DENIED: + case MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN: + self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_UNREGISTERED; + break; + case MM_MODEM_3GPP_REGISTRATION_STATE_HOME: + case MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING: + self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; + break; + case MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING: + if (mm_bearer_properties_get_allow_roaming (mm_base_bearer_peek_config (self))) + self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; + else + self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_ROAMING; + break; + } + + /* If no reason to disconnect, or if it's a mixed CDMA+LTE modem without a CDMA reason, + * just don't do anything. */ + if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_NONE || + (mm_iface_modem_is_cdma (MM_IFACE_MODEM (modem)) && + self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_NONE)) { + reset_deferred_unregistration (self); + return; + } + + /* Modem is roaming and roaming not allowed, report right away */ + if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_ROAMING) { + mm_dbg ("Bearer not allowed to connect, registered in roaming 3GPP network"); + reset_deferred_unregistration (self); + mm_base_bearer_disconnect_force (self); + return; + } + + /* Modem reports being unregistered */ + if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_UNREGISTERED) { + /* If there is already a notification pending, just return */ + if (self->priv->deferred_3gpp_unregistration_id) + return; + + /* If the bearer is not connected, report right away */ + if (self->priv->status != MM_BEARER_STATUS_CONNECTED) { + mm_dbg ("Bearer not allowed to connect, not registered in 3GPP network"); + mm_base_bearer_disconnect_force (self); + return; + } + + /* Otherwise, setup the new timeout */ + mm_dbg ("Connected bearer not registered in 3GPP network"); + self->priv->deferred_3gpp_unregistration_id = + g_timeout_add_seconds (BEARER_DEFERRED_UNREGISTRATION_TIMEOUT, + (GSourceFunc) deferred_3gpp_unregistration_cb, + self); + return; + } + + g_assert_not_reached (); +} + +static gboolean +deferred_cdma_unregistration_cb (MMBaseBearer *self) +{ + g_warn_if_fail (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_UNREGISTERED); + self->priv->deferred_cdma_unregistration_id = 0; + + mm_dbg ("Forcing bearer disconnection, not registered in CDMA network"); + mm_base_bearer_disconnect_force (self); + return FALSE; +} + +static void +modem_cdma_registration_state_changed (MMIfaceModemCdma *modem, + GParamSpec *pspec, + MMBaseBearer *self) +{ + MMModemCdmaRegistrationState cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; + MMModemCdmaRegistrationState evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; + + g_object_get (modem, + MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, &cdma1x_state, + MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, &evdo_state, + NULL); + + if (cdma1x_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING || + evdo_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING) { + if (mm_bearer_properties_get_allow_roaming (mm_base_bearer_peek_config (self))) + self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; + else + self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_ROAMING; + } else if (cdma1x_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN || + evdo_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { + self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; + } else { + self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_UNREGISTERED; + } + + /* If no reason to disconnect, or if it's a mixed CDMA+LTE modem without a 3GPP reason, + * just don't do anything. */ + if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_NONE || + (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (modem)) && + self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_NONE)) { + reset_deferred_unregistration (self); + return; + } + + /* Modem is roaming and roaming not allowed, report right away */ + if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_ROAMING) { + mm_dbg ("Bearer not allowed to connect, registered in roaming CDMA network"); + reset_deferred_unregistration (self); + mm_base_bearer_disconnect_force (self); + return; + } + + /* Modem reports being unregistered */ + if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_UNREGISTERED) { + /* If there is already a notification pending, just return */ + if (self->priv->deferred_cdma_unregistration_id) + return; + + /* If the bearer is not connected, report right away */ + if (self->priv->status != MM_BEARER_STATUS_CONNECTED) { + mm_dbg ("Bearer not allowed to connect, not registered in CDMA network"); + mm_base_bearer_disconnect_force (self); + return; + } + + /* Otherwise, setup the new timeout */ + mm_dbg ("Connected bearer not registered in CDMA network"); + self->priv->deferred_cdma_unregistration_id = + g_timeout_add_seconds (BEARER_DEFERRED_UNREGISTRATION_TIMEOUT, + (GSourceFunc) deferred_cdma_unregistration_cb, + self); + return; + } + + g_assert_not_reached (); +} + +static void +set_signal_handlers (MMBaseBearer *self) +{ + g_assert (self->priv->modem != NULL); + g_assert (self->priv->config != NULL); + + /* Don't set the 3GPP registration change signal handlers if they + * are already set. */ + if (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self->priv->modem)) && + !self->priv->id_3gpp_registration_change) { + self->priv->id_3gpp_registration_change = + g_signal_connect (self->priv->modem, + "notify::" MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, + G_CALLBACK (modem_3gpp_registration_state_changed), + self); + modem_3gpp_registration_state_changed (MM_IFACE_MODEM_3GPP (self->priv->modem), NULL, self); + } + + /* Don't set the CDMA1x/EV-DO registration change signal handlers if they + * are already set. */ + if (mm_iface_modem_is_cdma (MM_IFACE_MODEM (self->priv->modem)) && + !self->priv->id_cdma1x_registration_change && + !self->priv->id_evdo_registration_change) { + self->priv->id_cdma1x_registration_change = + g_signal_connect (self->priv->modem, + "notify::" MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, + G_CALLBACK (modem_cdma_registration_state_changed), + self); + self->priv->id_evdo_registration_change = + g_signal_connect (self->priv->modem, + "notify::" MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, + G_CALLBACK (modem_cdma_registration_state_changed), + self); + modem_cdma_registration_state_changed (MM_IFACE_MODEM_CDMA (self->priv->modem), NULL, self); + } +} + +static void +reset_signal_handlers (MMBaseBearer *self) +{ + if (!self->priv->modem) + return; + + if (self->priv->id_3gpp_registration_change) { + if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_3gpp_registration_change)) + g_signal_handler_disconnect (self->priv->modem, self->priv->id_3gpp_registration_change); + self->priv->id_3gpp_registration_change = 0; + } + if (self->priv->id_cdma1x_registration_change) { + if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_cdma1x_registration_change)) + g_signal_handler_disconnect (self->priv->modem, self->priv->id_cdma1x_registration_change); + self->priv->id_cdma1x_registration_change = 0; + } + if (self->priv->id_evdo_registration_change) { + if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_evdo_registration_change)) + g_signal_handler_disconnect (self->priv->modem, self->priv->id_evdo_registration_change); + self->priv->id_evdo_registration_change = 0; + } +} + +/*****************************************************************************/ +/* CONNECT */ + +gboolean +mm_base_bearer_connect_finish (MMBaseBearer *self, + GAsyncResult *res, + GError **error) +{ + return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error); +} + +static void +disconnect_after_cancel_ready (MMBaseBearer *self, + GAsyncResult *res) +{ + GError *error = NULL; + + if (!MM_BASE_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { + mm_warn ("Error disconnecting bearer '%s': '%s'. " + "Will assume disconnected anyway.", + self->priv->path, + error->message); + g_error_free (error); + } + else + mm_dbg ("Disconnected bearer '%s'", self->priv->path); + + /* Report disconnection to the bearer object using class method + * mm_bearer_report_connection_status. This gives subclass implementations a + * chance to correctly update their own connection state, in case this base + * class ignores a failed disconnection attempt. + */ + mm_base_bearer_report_connection_status (self, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); +} + +static void +connect_ready (MMBaseBearer *self, + GAsyncResult *res, + GSimpleAsyncResult *simple) +{ + GError *error = NULL; + gboolean launch_disconnect = FALSE; + MMBearerConnectResult *result; + + /* NOTE: connect() implementations *MUST* handle cancellations themselves */ + result = MM_BASE_BEARER_GET_CLASS (self)->connect_finish (self, res, &error); + if (!result) { + mm_dbg ("Couldn't connect bearer '%s': '%s'", + self->priv->path, + error->message); + if (g_error_matches (error, + MM_CORE_ERROR, + MM_CORE_ERROR_CANCELLED)) { + /* Will launch disconnection */ + launch_disconnect = TRUE; + } else + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); + + g_simple_async_result_take_error (simple, error); + } + /* Handle cancellations detected after successful connection */ + else if (g_cancellable_is_cancelled (self->priv->connect_cancellable)) { + mm_dbg ("Connected bearer '%s', but need to disconnect", self->priv->path); + mm_bearer_connect_result_unref (result); + g_simple_async_result_set_error ( + simple, + MM_CORE_ERROR, + MM_CORE_ERROR_CANCELLED, + "Bearer got connected, but had to disconnect after cancellation request"); + launch_disconnect = TRUE; + } + else { + mm_dbg ("Connected bearer '%s'", self->priv->path); + + /* Update bearer and interface status */ + bearer_update_status_connected ( + self, + mm_port_get_device (mm_bearer_connect_result_peek_data (result)), + mm_bearer_connect_result_peek_ipv4_config (result), + mm_bearer_connect_result_peek_ipv6_config (result)); + mm_bearer_connect_result_unref (result); + g_simple_async_result_set_op_res_gboolean (simple, TRUE); + } + + if (launch_disconnect) { + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); + MM_BASE_BEARER_GET_CLASS (self)->disconnect ( + self, + (GAsyncReadyCallback)disconnect_after_cancel_ready, + NULL); + } + + g_clear_object (&self->priv->connect_cancellable); + g_simple_async_result_complete (simple); + g_object_unref (simple); +} + +void +mm_base_bearer_connect (MMBaseBearer *self, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GSimpleAsyncResult *result; + + g_assert (MM_BASE_BEARER_GET_CLASS (self)->connect != NULL); + g_assert (MM_BASE_BEARER_GET_CLASS (self)->connect_finish != NULL); + + /* If already connecting, return error, don't allow a second request. */ + if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { + g_simple_async_report_error_in_idle ( + G_OBJECT (self), + callback, + user_data, + MM_CORE_ERROR, + MM_CORE_ERROR_IN_PROGRESS, + "Bearer already being connected"); + return; + } + + /* If currently disconnecting, return error, previous operation should + * finish before allowing to connect again. */ + if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING) { + g_simple_async_report_error_in_idle ( + G_OBJECT (self), + callback, + user_data, + MM_CORE_ERROR, + MM_CORE_ERROR_FAILED, + "Bearer currently being disconnected"); + return; + } + + /* Check 3GPP roaming allowance, *only* roaming related here */ + if (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self->priv->modem)) && + self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_ROAMING) { + g_simple_async_report_error_in_idle ( + G_OBJECT (self), + callback, + user_data, + MM_CORE_ERROR, + MM_CORE_ERROR_UNAUTHORIZED, + "Not allowed to connect bearer in 3GPP network: '%s'", + connection_forbidden_reason_str[self->priv->reason_3gpp]); + return; + } + + /* Check CDMA roaming allowance, *only* roaming related here */ + if (mm_iface_modem_is_cdma (MM_IFACE_MODEM (self->priv->modem)) && + self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_ROAMING) { + g_simple_async_report_error_in_idle ( + G_OBJECT (self), + callback, + user_data, + MM_CORE_ERROR, + MM_CORE_ERROR_UNAUTHORIZED, + "Not allowed to connect bearer in CDMA network: '%s'", + connection_forbidden_reason_str[self->priv->reason_cdma]); + return; + } + + result = g_simple_async_result_new (G_OBJECT (self), + callback, + user_data, + mm_base_bearer_connect); + + /* If already connected, done */ + if (self->priv->status == MM_BEARER_STATUS_CONNECTED) { + g_simple_async_result_set_op_res_gboolean (result, TRUE); + g_simple_async_result_complete_in_idle (result); + g_object_unref (result); + return; + } + + /* Connecting! */ + mm_dbg ("Connecting bearer '%s'", self->priv->path); + self->priv->connect_cancellable = g_cancellable_new (); + bearer_update_status (self, MM_BEARER_STATUS_CONNECTING); + MM_BASE_BEARER_GET_CLASS (self)->connect ( + self, + self->priv->connect_cancellable, + (GAsyncReadyCallback)connect_ready, + result); +} + +typedef struct { + MMBaseBearer *self; + MMBaseModem *modem; + GDBusMethodInvocation *invocation; +} HandleConnectContext; + +static void +handle_connect_context_free (HandleConnectContext *ctx) +{ + g_object_unref (ctx->invocation); + g_object_unref (ctx->modem); + g_object_unref (ctx->self); + g_free (ctx); +} + +static void +handle_connect_ready (MMBaseBearer *self, + GAsyncResult *res, + HandleConnectContext *ctx) +{ + GError *error = NULL; + + if (!mm_base_bearer_connect_finish (self, res, &error)) + g_dbus_method_invocation_take_error (ctx->invocation, error); + else + mm_gdbus_bearer_complete_connect (MM_GDBUS_BEARER (self), ctx->invocation); + + handle_connect_context_free (ctx); +} + +static void +handle_connect_auth_ready (MMBaseModem *modem, + GAsyncResult *res, + HandleConnectContext *ctx) +{ + GError *error = NULL; + + if (!mm_base_modem_authorize_finish (modem, res, &error)) { + g_dbus_method_invocation_take_error (ctx->invocation, error); + handle_connect_context_free (ctx); + return; + } + + mm_base_bearer_connect (ctx->self, + (GAsyncReadyCallback)handle_connect_ready, + ctx); +} + +static gboolean +handle_connect (MMBaseBearer *self, + GDBusMethodInvocation *invocation) +{ + HandleConnectContext *ctx; + + ctx = g_new0 (HandleConnectContext, 1); + ctx->self = g_object_ref (self); + ctx->invocation = g_object_ref (invocation); + g_object_get (self, + MM_BASE_BEARER_MODEM, &ctx->modem, + NULL); + + mm_base_modem_authorize (ctx->modem, + invocation, + MM_AUTHORIZATION_DEVICE_CONTROL, + (GAsyncReadyCallback)handle_connect_auth_ready, + ctx); + return TRUE; +} + +/*****************************************************************************/ +/* DISCONNECT */ + +gboolean +mm_base_bearer_disconnect_finish (MMBaseBearer *self, + GAsyncResult *res, + GError **error) +{ + return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error); +} + +static void +disconnect_ready (MMBaseBearer *self, + GAsyncResult *res, + GSimpleAsyncResult *simple) +{ + GError *error = NULL; + + if (!MM_BASE_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { + mm_dbg ("Couldn't disconnect bearer '%s'", self->priv->path); + bearer_update_status (self, MM_BEARER_STATUS_CONNECTED); + g_simple_async_result_take_error (simple, error); + } + else { + mm_dbg ("Disconnected bearer '%s'", self->priv->path); + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); + g_simple_async_result_set_op_res_gboolean (simple, TRUE); + } + + g_simple_async_result_complete (simple); + g_object_unref (simple); +} + +static void +status_changed_complete_disconnect (MMBaseBearer *self, + GParamSpec *pspec, + GSimpleAsyncResult *simple) +{ + /* We may get other states here before DISCONNECTED, like DISCONNECTING or + * even CONNECTED. */ + if (self->priv->status != MM_BEARER_STATUS_DISCONNECTED) + return; + + mm_dbg ("Disconnected bearer '%s' after cancelling previous connect request", + self->priv->path); + g_signal_handler_disconnect (self, + self->priv->disconnect_signal_handler); + self->priv->disconnect_signal_handler = 0; + + /* Note: interface state is updated when the DISCONNECTED state is set */ + + g_simple_async_result_set_op_res_gboolean (simple, TRUE); + g_simple_async_result_complete (simple); + g_object_unref (simple); +} + +void +mm_base_bearer_disconnect (MMBaseBearer *self, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GSimpleAsyncResult *simple; + + g_assert (MM_BASE_BEARER_GET_CLASS (self)->disconnect != NULL); + g_assert (MM_BASE_BEARER_GET_CLASS (self)->disconnect_finish != NULL); + + simple = g_simple_async_result_new (G_OBJECT (self), + callback, + user_data, + mm_base_bearer_disconnect); + + /* If already disconnected, done */ + if (self->priv->status == MM_BEARER_STATUS_DISCONNECTED) { + g_simple_async_result_set_op_res_gboolean (simple, TRUE); + g_simple_async_result_complete_in_idle (simple); + g_object_unref (simple); + return; + } + + /* If already disconnecting, return error, don't allow a second request. */ + if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING) { + g_simple_async_result_set_error ( + simple, + MM_CORE_ERROR, + MM_CORE_ERROR_IN_PROGRESS, + "Bearer already being disconnected"); + g_simple_async_result_complete_in_idle (simple); + g_object_unref (simple); + return; + } + + mm_dbg ("Disconnecting bearer '%s'", self->priv->path); + + /* If currently connecting, try to cancel that operation, and wait to get + * disconnected. */ + if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { + /* Set ourselves as disconnecting */ + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); + + /* We MUST ensure that we get to DISCONNECTED */ + g_cancellable_cancel (self->priv->connect_cancellable); + /* Note that we only allow to remove disconnected bearers, so should + * be safe to assume that we'll get the signal handler called properly + */ + self->priv->disconnect_signal_handler = + g_signal_connect (self, + "notify::" MM_BASE_BEARER_STATUS, + (GCallback)status_changed_complete_disconnect, + simple); /* takes ownership */ + + return; + } + + /* Disconnecting! */ + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); + MM_BASE_BEARER_GET_CLASS (self)->disconnect ( + self, + (GAsyncReadyCallback)disconnect_ready, + simple); /* takes ownership */ +} + +typedef struct { + MMBaseBearer *self; + MMBaseModem *modem; + GDBusMethodInvocation *invocation; +} HandleDisconnectContext; + +static void +handle_disconnect_context_free (HandleDisconnectContext *ctx) +{ + g_object_unref (ctx->invocation); + g_object_unref (ctx->modem); + g_object_unref (ctx->self); + g_free (ctx); +} + +static void +handle_disconnect_ready (MMBaseBearer *self, + GAsyncResult *res, + HandleDisconnectContext *ctx) +{ + GError *error = NULL; + + if (!mm_base_bearer_disconnect_finish (self, res, &error)) + g_dbus_method_invocation_take_error (ctx->invocation, error); + else + mm_gdbus_bearer_complete_disconnect (MM_GDBUS_BEARER (self), ctx->invocation); + + handle_disconnect_context_free (ctx); +} + +static void +handle_disconnect_auth_ready (MMBaseModem *modem, + GAsyncResult *res, + HandleDisconnectContext *ctx) +{ + GError *error = NULL; + + if (!mm_base_modem_authorize_finish (modem, res, &error)) { + g_dbus_method_invocation_take_error (ctx->invocation, error); + handle_disconnect_context_free (ctx); + return; + } + + mm_base_bearer_disconnect (ctx->self, + (GAsyncReadyCallback)handle_disconnect_ready, + ctx); +} + +static gboolean +handle_disconnect (MMBaseBearer *self, + GDBusMethodInvocation *invocation) +{ + HandleDisconnectContext *ctx; + + ctx = g_new0 (HandleDisconnectContext, 1); + ctx->self = g_object_ref (self); + ctx->invocation = g_object_ref (invocation); + g_object_get (self, + MM_BASE_BEARER_MODEM, &ctx->modem, + NULL); + + mm_base_modem_authorize (ctx->modem, + invocation, + MM_AUTHORIZATION_DEVICE_CONTROL, + (GAsyncReadyCallback)handle_disconnect_auth_ready, + ctx); + return TRUE; +} + +/*****************************************************************************/ + +static void +base_bearer_dbus_export (MMBaseBearer *self) +{ + GError *error = NULL; + + /* Handle method invocations */ + g_signal_connect (self, + "handle-connect", + G_CALLBACK (handle_connect), + NULL); + g_signal_connect (self, + "handle-disconnect", + G_CALLBACK (handle_disconnect), + NULL); + + if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self), + self->priv->connection, + self->priv->path, + &error)) { + mm_warn ("couldn't export BEARER at '%s': '%s'", + self->priv->path, + error->message); + g_error_free (error); + } +} + +static void +base_bearer_dbus_unexport (MMBaseBearer *self) +{ + const gchar *path; + + path = g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (self)); + /* Only unexport if currently exported */ + if (path) { + mm_dbg ("Removing from DBus bearer at '%s'", path); + g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (self)); + } +} + +/*****************************************************************************/ + +MMBearerStatus +mm_base_bearer_get_status (MMBaseBearer *self) +{ + return self->priv->status; +} + +const gchar * +mm_base_bearer_get_path (MMBaseBearer *self) +{ + return self->priv->path; +} + +MMBearerProperties * +mm_base_bearer_peek_config (MMBaseBearer *self) +{ + return self->priv->config; +} + +MMBearerProperties * +mm_base_bearer_get_config (MMBaseBearer *self) +{ + return (self->priv->config ? + g_object_ref (self->priv->config) : + NULL); +} + +MMBearerIpFamily +mm_base_bearer_get_default_ip_family (MMBaseBearer *self) +{ + return self->priv->default_ip_family; +} + +/*****************************************************************************/ + +static void +disconnect_force_ready (MMBaseBearer *self, + GAsyncResult *res) +{ + GError *error = NULL; + + if (!MM_BASE_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { + mm_warn ("Error disconnecting bearer '%s': '%s'. " + "Will assume disconnected anyway.", + self->priv->path, + error->message); + g_error_free (error); + } + else + mm_dbg ("Disconnected bearer '%s'", self->priv->path); + + /* Report disconnection to the bearer object using class method + * mm_bearer_report_connection_status. This gives subclass implementations a + * chance to correctly update their own connection state, in case this base + * class ignores a failed disconnection attempt. + */ + mm_base_bearer_report_connection_status (self, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); +} + +void +mm_base_bearer_disconnect_force (MMBaseBearer *self) +{ + if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING || + self->priv->status == MM_BEARER_STATUS_DISCONNECTED) + return; + + mm_dbg ("Forcing disconnection of bearer '%s'", self->priv->path); + + /* If currently connecting, try to cancel that operation. */ + if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { + g_cancellable_cancel (self->priv->connect_cancellable); + return; + } + + /* Disconnecting! */ + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); + MM_BASE_BEARER_GET_CLASS (self)->disconnect ( + self, + (GAsyncReadyCallback)disconnect_force_ready, + NULL); +} + +/*****************************************************************************/ + +static void +report_connection_status (MMBaseBearer *self, + MMBearerConnectionStatus status) +{ + /* The only status expected at this point is DISCONNECTED. + * No other status should have been given to the generic implementation + * of report_connection_status (it would be an error). + */ + g_assert (status == MM_BEARER_CONNECTION_STATUS_DISCONNECTED); + + /* In the generic bearer implementation we just need to reset the + * interface status */ + bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); +} + +void +mm_base_bearer_report_connection_status (MMBaseBearer *self, + MMBearerConnectionStatus status) +{ + return MM_BASE_BEARER_GET_CLASS (self)->report_connection_status (self, status); +} + +static void +set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + MMBaseBearer *self = MM_BASE_BEARER (object); + + switch (prop_id) { + case PROP_PATH: + g_free (self->priv->path); + self->priv->path = g_value_dup_string (value); + + /* Export when we get a DBus connection AND we have a path */ + if (self->priv->path && + self->priv->connection) + base_bearer_dbus_export (self); + break; + case PROP_CONNECTION: + g_clear_object (&self->priv->connection); + self->priv->connection = g_value_dup_object (value); + + /* Export when we get a DBus connection AND we have a path */ + if (!self->priv->connection) + base_bearer_dbus_unexport (self); + else if (self->priv->path) + base_bearer_dbus_export (self); + break; + case PROP_MODEM: + g_clear_object (&self->priv->modem); + self->priv->modem = g_value_dup_object (value); + if (self->priv->modem) { + /* Bind the modem's connection (which is set when it is exported, + * and unset when unexported) to the BEARER's connection */ + g_object_bind_property (self->priv->modem, MM_BASE_MODEM_CONNECTION, + self, MM_BASE_BEARER_CONNECTION, + G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); + if (self->priv->config) { + /* Listen to 3GPP/CDMA registration state changes. We need both + * 'config' and 'modem' set. */ + set_signal_handlers (self); + } + } + break; + case PROP_STATUS: + /* We don't allow g_object_set()-ing the status property */ + g_assert_not_reached (); + break; + case PROP_CONFIG: { + GVariant *dictionary; + + g_clear_object (&self->priv->config); + self->priv->config = g_value_dup_object (value); + if (self->priv->modem) { + /* Listen to 3GPP/CDMA registration state changes. We need both + * 'config' and 'modem' set. */ + set_signal_handlers (self); + } + /* Also expose the properties */ + dictionary = mm_bearer_properties_get_dictionary (self->priv->config); + mm_gdbus_bearer_set_properties (MM_GDBUS_BEARER (self), dictionary); + if (dictionary) + g_variant_unref (dictionary); + break; + } + case PROP_DEFAULT_IP_FAMILY: + self->priv->default_ip_family = g_value_get_flags (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + MMBaseBearer *self = MM_BASE_BEARER (object); + + switch (prop_id) { + case PROP_PATH: + g_value_set_string (value, self->priv->path); + break; + case PROP_CONNECTION: + g_value_set_object (value, self->priv->connection); + break; + case PROP_MODEM: + g_value_set_object (value, self->priv->modem); + break; + case PROP_STATUS: + g_value_set_enum (value, self->priv->status); + break; + case PROP_CONFIG: + g_value_set_object (value, self->priv->config); + break; + case PROP_DEFAULT_IP_FAMILY: + g_value_set_flags (value, self->priv->default_ip_family); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +mm_base_bearer_init (MMBaseBearer *self) +{ + /* Initialize private data */ + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, + MM_TYPE_BASE_BEARER, + MMBaseBearerPrivate); + self->priv->status = MM_BEARER_STATUS_DISCONNECTED; + self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; + self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; + self->priv->default_ip_family = MM_BEARER_IP_FAMILY_IPV4; + + /* Set defaults */ + mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), NULL); + mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), FALSE); + mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); + mm_gdbus_bearer_set_properties (MM_GDBUS_BEARER (self), NULL); + mm_gdbus_bearer_set_ip_timeout (MM_GDBUS_BEARER (self), BEARER_IP_TIMEOUT_DEFAULT); + mm_gdbus_bearer_set_ip4_config (MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (NULL)); + mm_gdbus_bearer_set_ip6_config (MM_GDBUS_BEARER (self), + mm_bearer_ip_config_get_dictionary (NULL)); +} + +static void +finalize (GObject *object) +{ + MMBaseBearer *self = MM_BASE_BEARER (object); + + g_free (self->priv->path); + + G_OBJECT_CLASS (mm_base_bearer_parent_class)->finalize (object); +} + +static void +dispose (GObject *object) +{ + MMBaseBearer *self = MM_BASE_BEARER (object); + + if (self->priv->connection) { + base_bearer_dbus_unexport (self); + g_clear_object (&self->priv->connection); + } + + reset_signal_handlers (self); + reset_deferred_unregistration (self); + + g_clear_object (&self->priv->modem); + g_clear_object (&self->priv->config); + + G_OBJECT_CLASS (mm_base_bearer_parent_class)->dispose (object); +} + +static void +mm_base_bearer_class_init (MMBaseBearerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (MMBaseBearerPrivate)); + + /* Virtual methods */ + object_class->get_property = get_property; + object_class->set_property = set_property; + object_class->finalize = finalize; + object_class->dispose = dispose; + + klass->report_connection_status = report_connection_status; + + properties[PROP_CONNECTION] = + g_param_spec_object (MM_BASE_BEARER_CONNECTION, + "Connection", + "GDBus connection to the system bus.", + G_TYPE_DBUS_CONNECTION, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_CONNECTION, properties[PROP_CONNECTION]); + + properties[PROP_PATH] = + g_param_spec_string (MM_BASE_BEARER_PATH, + "Path", + "DBus path of the Bearer", + NULL, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_PATH, properties[PROP_PATH]); + + properties[PROP_MODEM] = + g_param_spec_object (MM_BASE_BEARER_MODEM, + "Modem", + "The Modem which owns this Bearer", + MM_TYPE_BASE_MODEM, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_MODEM, properties[PROP_MODEM]); + + properties[PROP_STATUS] = + g_param_spec_enum (MM_BASE_BEARER_STATUS, + "Bearer status", + "Status of the bearer", + MM_TYPE_BEARER_STATUS, + MM_BEARER_STATUS_DISCONNECTED, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_STATUS, properties[PROP_STATUS]); + + properties[PROP_CONFIG] = + g_param_spec_object (MM_BASE_BEARER_CONFIG, + "Bearer configuration", + "List of user provided properties", + MM_TYPE_BEARER_PROPERTIES, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_CONFIG, properties[PROP_CONFIG]); + + properties[PROP_DEFAULT_IP_FAMILY] = + g_param_spec_flags (MM_BASE_BEARER_DEFAULT_IP_FAMILY, + "Bearer default IP family", + "IP family to use for this bearer when no IP family is specified", + MM_TYPE_BEARER_IP_FAMILY, + MM_BEARER_IP_FAMILY_IPV4, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_DEFAULT_IP_FAMILY, properties[PROP_DEFAULT_IP_FAMILY]); +} + +/*****************************************************************************/ +/* Helpers to implement connect() */ + +struct _MMBearerConnectResult { + volatile gint ref_count; + MMPort *data; + MMBearerIpConfig *ipv4_config; + MMBearerIpConfig *ipv6_config; +}; + +MMBearerConnectResult * +mm_bearer_connect_result_ref (MMBearerConnectResult *result) +{ + g_atomic_int_inc (&result->ref_count); + return result; +} + +void +mm_bearer_connect_result_unref (MMBearerConnectResult *result) +{ + if (g_atomic_int_dec_and_test (&result->ref_count)) { + if (result->ipv4_config) + g_object_unref (result->ipv4_config); + if (result->ipv6_config) + g_object_unref (result->ipv6_config); + if (result->data) + g_object_unref (result->data); + g_slice_free (MMBearerConnectResult, result); + } +} + +MMPort * +mm_bearer_connect_result_peek_data (MMBearerConnectResult *result) +{ + return result->data; +} + +MMBearerIpConfig * +mm_bearer_connect_result_peek_ipv4_config (MMBearerConnectResult *result) +{ + return result->ipv4_config; +} + +MMBearerIpConfig * +mm_bearer_connect_result_peek_ipv6_config (MMBearerConnectResult *result) +{ + return result->ipv6_config; +} + +MMBearerConnectResult * +mm_bearer_connect_result_new (MMPort *data, + MMBearerIpConfig *ipv4_config, + MMBearerIpConfig *ipv6_config) +{ + MMBearerConnectResult *result; + + /* 'data' must always be given */ + g_assert (MM_IS_PORT (data)); + + result = g_slice_new0 (MMBearerConnectResult); + result->ref_count = 1; + result->data = g_object_ref (data); + if (ipv4_config) + result->ipv4_config = g_object_ref (ipv4_config); + if (ipv6_config) + result->ipv6_config = g_object_ref (ipv6_config); + return result; +} diff --git a/src/mm-base-bearer.h b/src/mm-base-bearer.h new file mode 100644 index 00000000..2c196f67 --- /dev/null +++ b/src/mm-base-bearer.h @@ -0,0 +1,139 @@ +/* -*- 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: + * + * Author: Aleksander Morgado + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2011 - 2013 Aleksander Morgado + */ + +#ifndef MM_BASE_BEARER_H +#define MM_BASE_BEARER_H + +#include +#include + +#include +#define _LIBMM_INSIDE_MM +#include + +#include "mm-base-modem.h" + +/*****************************************************************************/ +/* Helpers to implement connect() */ + +typedef struct _MMBearerConnectResult MMBearerConnectResult; +MMBearerConnectResult *mm_bearer_connect_result_new (MMPort *data, + MMBearerIpConfig *ipv4_config, + MMBearerIpConfig *ipv6_config); +void mm_bearer_connect_result_unref (MMBearerConnectResult *result); +MMBearerConnectResult *mm_bearer_connect_result_ref (MMBearerConnectResult *result); +MMPort *mm_bearer_connect_result_peek_data (MMBearerConnectResult *result); +MMBearerIpConfig *mm_bearer_connect_result_peek_ipv4_config (MMBearerConnectResult *result); +MMBearerIpConfig *mm_bearer_connect_result_peek_ipv6_config (MMBearerConnectResult *result); + +/*****************************************************************************/ + +#define MM_TYPE_BASE_BEARER (mm_base_bearer_get_type ()) +#define MM_BASE_BEARER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_BASE_BEARER, MMBaseBearer)) +#define MM_BASE_BEARER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_BASE_BEARER, MMBaseBearerClass)) +#define MM_IS_BASE_BEARER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_BASE_BEARER)) +#define MM_IS_BASE_BEARER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MM_TYPE_BASE_BEARER)) +#define MM_BASE_BEARER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_BASE_BEARER, MMBaseBearerClass)) + +typedef struct _MMBaseBearer MMBaseBearer; +typedef struct _MMBaseBearerClass MMBaseBearerClass; +typedef struct _MMBaseBearerPrivate MMBaseBearerPrivate; + +#define MM_BASE_BEARER_PATH "bearer-path" +#define MM_BASE_BEARER_CONNECTION "bearer-connection" +#define MM_BASE_BEARER_MODEM "bearer-modem" +#define MM_BASE_BEARER_STATUS "bearer-status" +#define MM_BASE_BEARER_CONFIG "bearer-config" +#define MM_BASE_BEARER_DEFAULT_IP_FAMILY "bearer-deafult-ip-family" + +typedef enum { /*< underscore_name=mm_bearer_status >*/ + MM_BEARER_STATUS_DISCONNECTED, + MM_BEARER_STATUS_DISCONNECTING, + MM_BEARER_STATUS_CONNECTING, + MM_BEARER_STATUS_CONNECTED, +} MMBearerStatus; + +typedef enum { /*< underscore_name=mm_bearer_connection_status >*/ + MM_BEARER_CONNECTION_STATUS_UNKNOWN, + MM_BEARER_CONNECTION_STATUS_DISCONNECTED, + MM_BEARER_CONNECTION_STATUS_DISCONNECTING, + MM_BEARER_CONNECTION_STATUS_CONNECTED, + MM_BEARER_CONNECTION_STATUS_CONNECTION_FAILED, +} MMBearerConnectionStatus; + +struct _MMBaseBearer { + MmGdbusBearerSkeleton parent; + MMBaseBearerPrivate *priv; +}; + +struct _MMBaseBearerClass { + MmGdbusBearerSkeletonClass parent; + + /* Connect this bearer */ + void (* connect) (MMBaseBearer *bearer, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + MMBearerConnectResult * (* connect_finish) (MMBaseBearer *bearer, + GAsyncResult *res, + GError **error); + + /* Disconnect this bearer */ + void (* disconnect) (MMBaseBearer *bearer, + GAsyncReadyCallback callback, + gpointer user_data); + gboolean (* disconnect_finish) (MMBaseBearer *bearer, + GAsyncResult *res, + GError **error); + + /* Report connection status of this bearer */ + void (* report_connection_status) (MMBaseBearer *bearer, + MMBearerConnectionStatus status); +}; + +GType mm_base_bearer_get_type (void); + +void mm_base_bearer_export (MMBaseBearer *self); + +const gchar *mm_base_bearer_get_path (MMBaseBearer *self); +MMBearerStatus mm_base_bearer_get_status (MMBaseBearer *self); +MMBearerProperties *mm_base_bearer_peek_config (MMBaseBearer *self); +MMBearerProperties *mm_base_bearer_get_config (MMBaseBearer *self); +MMBearerIpFamily mm_base_bearer_get_default_ip_family (MMBaseBearer *self); + + +void mm_base_bearer_connect (MMBaseBearer *self, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean mm_base_bearer_connect_finish (MMBaseBearer *self, + GAsyncResult *res, + GError **error); + +void mm_base_bearer_disconnect (MMBaseBearer *self, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean mm_base_bearer_disconnect_finish (MMBaseBearer *self, + GAsyncResult *res, + GError **error); + +void mm_base_bearer_disconnect_force (MMBaseBearer *self); + +void mm_base_bearer_report_connection_status (MMBaseBearer *self, + MMBearerConnectionStatus status); + +#endif /* MM_BASE_BEARER_H */ diff --git a/src/mm-bearer-list.c b/src/mm-bearer-list.c index ef1f8399..14477419 100644 --- a/src/mm-bearer-list.c +++ b/src/mm-bearer-list.c @@ -78,7 +78,7 @@ mm_bearer_list_get_count_active (MMBearerList *self) gboolean mm_bearer_list_add_bearer (MMBearerList *self, - MMBearer *bearer, + MMBaseBearer *bearer, GError **error) { /* Just in case, ensure we don't go off limits */ @@ -115,7 +115,7 @@ mm_bearer_list_delete_bearer (MMBearerList *self, } for (l = self->priv->bearers; l; l = g_list_next (l)) { - if (g_str_equal (path, mm_bearer_get_path (MM_BEARER (l->data)))) { + if (g_str_equal (path, mm_base_bearer_get_path (MM_BASE_BEARER (l->data)))) { g_object_unref (l->data); self->priv->bearers = g_list_delete_link (self->priv->bearers, l); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_NUM_BEARERS]); @@ -153,7 +153,7 @@ mm_bearer_list_get_paths (MMBearerList *self) 1 + g_list_length (self->priv->bearers)); for (i = 0, l = self->priv->bearers; l; l = g_list_next (l)) - path_list[i++] = g_strdup (mm_bearer_get_path (MM_BEARER (l->data))); + path_list[i++] = g_strdup (mm_base_bearer_get_path (MM_BASE_BEARER (l->data))); return path_list; } @@ -166,14 +166,14 @@ mm_bearer_list_foreach (MMBearerList *self, g_list_foreach (self->priv->bearers, (GFunc)func, user_data); } -MMBearer * +MMBaseBearer * mm_bearer_list_find (MMBearerList *self, MMBearerProperties *properties) { GList *l; for (l = self->priv->bearers; l; l = g_list_next (l)) { - if (mm_bearer_properties_cmp (mm_bearer_peek_config (MM_BEARER (l->data)), properties)) + if (mm_bearer_properties_cmp (mm_base_bearer_peek_config (MM_BASE_BEARER (l->data)), properties)) return g_object_ref (l->data); } @@ -185,7 +185,7 @@ mm_bearer_list_find (MMBearerList *self, typedef struct { GSimpleAsyncResult *result; GList *pending; - MMBearer *current; + MMBaseBearer *current; } DisconnectAllContext; static void @@ -210,13 +210,13 @@ mm_bearer_list_disconnect_all_bearers_finish (MMBearerList *self, static void disconnect_next_bearer (DisconnectAllContext *ctx); static void -disconnect_ready (MMBearer *bearer, +disconnect_ready (MMBaseBearer *bearer, GAsyncResult *res, DisconnectAllContext *ctx) { GError *error = NULL; - if (!mm_bearer_disconnect_finish (bearer, res, &error)) { + if (!mm_base_bearer_disconnect_finish (bearer, res, &error)) { g_simple_async_result_take_error (ctx->result, error); disconnect_all_context_complete_and_free (ctx); return; @@ -238,12 +238,12 @@ disconnect_next_bearer (DisconnectAllContext *ctx) return; } - ctx->current = MM_BEARER (ctx->pending->data); + ctx->current = MM_BASE_BEARER (ctx->pending->data); ctx->pending = g_list_delete_link (ctx->pending, ctx->pending); - mm_bearer_disconnect (ctx->current, - (GAsyncReadyCallback)disconnect_ready, - ctx); + mm_base_bearer_disconnect (ctx->current, + (GAsyncReadyCallback)disconnect_ready, + ctx); } void diff --git a/src/mm-bearer-list.h b/src/mm-bearer-list.h index 292e3d52..a9698958 100644 --- a/src/mm-bearer-list.h +++ b/src/mm-bearer-list.h @@ -21,7 +21,7 @@ #include #include -#include "mm-bearer.h" +#include "mm-base-bearer.h" #define MM_TYPE_BEARER_LIST (mm_bearer_list_get_type ()) #define MM_BEARER_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_BEARER_LIST, MMBearerList)) @@ -60,21 +60,21 @@ guint mm_bearer_list_get_max (MMBearerList *self); guint mm_bearer_list_get_max_active (MMBearerList *self); gboolean mm_bearer_list_add_bearer (MMBearerList *self, - MMBearer *bearer, + MMBaseBearer *bearer, GError **error); gboolean mm_bearer_list_delete_bearer (MMBearerList *self, const gchar *path, GError **error); void mm_bearer_list_delete_all_bearers (MMBearerList *self); -typedef void (*MMBearerListForeachFunc) (MMBearer *bearer, +typedef void (*MMBearerListForeachFunc) (MMBaseBearer *bearer, gpointer user_data); void mm_bearer_list_foreach (MMBearerList *self, MMBearerListForeachFunc func, gpointer user_data); -MMBearer *mm_bearer_list_find (MMBearerList *self, - MMBearerProperties *properties); +MMBaseBearer *mm_bearer_list_find (MMBearerList *self, + MMBearerProperties *properties); void mm_bearer_list_disconnect_all_bearers (MMBearerList *self, GAsyncReadyCallback callback, diff --git a/src/mm-bearer-mbim.c b/src/mm-bearer-mbim.c index 781a6680..e4adbb3d 100644 --- a/src/mm-bearer-mbim.c +++ b/src/mm-bearer-mbim.c @@ -32,7 +32,7 @@ #include "mm-bearer-mbim.h" #include "mm-log.h" -G_DEFINE_TYPE (MMBearerMbim, mm_bearer_mbim, MM_TYPE_BEARER) +G_DEFINE_TYPE (MMBearerMbim, mm_bearer_mbim, MM_TYPE_BASE_BEARER) enum { PROP_0, @@ -61,7 +61,7 @@ peek_ports (gpointer self, MMBaseModem *modem = NULL; g_object_get (G_OBJECT (self), - MM_BEARER_MODEM, &modem, + MM_BASE_BEARER_MODEM, &modem, NULL); g_assert (MM_IS_BASE_MODEM (modem)); @@ -146,7 +146,7 @@ connect_context_complete_and_free (ConnectContext *ctx) } static MMBearerConnectResult * -connect_finish (MMBearer *self, +connect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -736,7 +736,7 @@ connect_context_step (ConnectContext *ctx) ip_family == MM_BEARER_IP_FAMILY_ANY) { gchar * str; - ip_family = mm_bearer_get_default_ip_family (MM_BEARER (ctx->self)); + ip_family = mm_base_bearer_get_default_ip_family (MM_BASE_BEARER (ctx->self)); str = mm_bearer_ip_family_build_string_from_mask (ip_family); mm_dbg ("No specific IP family requested, defaulting to %s", str); g_free (str); @@ -855,7 +855,7 @@ connect_context_step (ConnectContext *ctx) } static void -_connect (MMBearer *self, +_connect (MMBaseBearer *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) @@ -870,12 +870,12 @@ _connect (MMBearer *self, return; g_object_get (self, - MM_BEARER_MODEM, &modem, + MM_BASE_BEARER_MODEM, &modem, NULL); g_assert (modem); /* Check whether we have an APN */ - apn = mm_bearer_properties_get_apn (mm_bearer_peek_config (MM_BEARER (self))); + apn = mm_bearer_properties_get_apn (mm_base_bearer_peek_config (MM_BASE_BEARER (self))); /* Is this a 3GPP only modem and no APN was given? If so, error */ if (mm_iface_modem_is_3gpp_only (MM_IFACE_MODEM (modem)) && !apn) { @@ -908,7 +908,7 @@ _connect (MMBearer *self, _connect); g_object_get (self, - MM_BEARER_CONFIG, &ctx->properties, + MM_BASE_BEARER_CONFIG, &ctx->properties, NULL); /* Run! */ @@ -943,7 +943,7 @@ disconnect_context_complete_and_free (DisconnectContext *ctx) } static gboolean -disconnect_finish (MMBearer *self, +disconnect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -1074,7 +1074,7 @@ disconnect_context_step (DisconnectContext *ctx) } static void -disconnect (MMBearer *_self, +disconnect (MMBaseBearer *_self, GAsyncReadyCallback callback, gpointer user_data) { @@ -1126,24 +1126,24 @@ mm_bearer_mbim_get_session_id (MMBearerMbim *self) /*****************************************************************************/ -MMBearer * +MMBaseBearer * mm_bearer_mbim_new (MMBroadbandModemMbim *modem, MMBearerProperties *config, guint32 session_id) { - MMBearer *bearer; + MMBaseBearer *bearer; - /* The Mbim bearer inherits from MMBearer (so it's not a MMBroadbandBearer) + /* The Mbim bearer inherits from MMBaseBearer (so it's not a MMBroadbandBearer) * and that means that the object is not async-initable, so we just use * g_object_new() here */ bearer = g_object_new (MM_TYPE_BEARER_MBIM, - MM_BEARER_MODEM, modem, - MM_BEARER_CONFIG, config, + MM_BASE_BEARER_MODEM, modem, + MM_BASE_BEARER_CONFIG, config, MM_BEARER_MBIM_SESSION_ID, (guint)session_id, NULL); /* Only export valid bearers */ - mm_bearer_export (bearer); + mm_base_bearer_export (bearer); return bearer; } @@ -1208,7 +1208,7 @@ static void mm_bearer_mbim_class_init (MMBearerMbimClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - MMBearerClass *bearer_class = MM_BEARER_CLASS (klass); + MMBaseBearerClass *base_bearer_class = MM_BASE_BEARER_CLASS (klass); g_type_class_add_private (object_class, sizeof (MMBearerMbimPrivate)); @@ -1217,10 +1217,10 @@ mm_bearer_mbim_class_init (MMBearerMbimClass *klass) object_class->get_property = get_property; object_class->set_property = set_property; - bearer_class->connect = _connect; - bearer_class->connect_finish = connect_finish; - bearer_class->disconnect = disconnect; - bearer_class->disconnect_finish = disconnect_finish; + base_bearer_class->connect = _connect; + base_bearer_class->connect_finish = connect_finish; + base_bearer_class->disconnect = disconnect; + base_bearer_class->disconnect_finish = disconnect_finish; properties[PROP_SESSION_ID] = g_param_spec_uint (MM_BEARER_MBIM_SESSION_ID, diff --git a/src/mm-bearer-mbim.h b/src/mm-bearer-mbim.h index c3e7f1fc..67dea09a 100644 --- a/src/mm-bearer-mbim.h +++ b/src/mm-bearer-mbim.h @@ -22,7 +22,7 @@ #define _LIBMM_INSIDE_MM #include -#include "mm-bearer.h" +#include "mm-base-bearer.h" #include "mm-broadband-modem-mbim.h" #define MM_TYPE_BEARER_MBIM (mm_bearer_mbim_get_type ()) @@ -39,21 +39,21 @@ typedef struct _MMBearerMbimClass MMBearerMbimClass; typedef struct _MMBearerMbimPrivate MMBearerMbimPrivate; struct _MMBearerMbim { - MMBearer parent; + MMBaseBearer parent; MMBearerMbimPrivate *priv; }; struct _MMBearerMbimClass { - MMBearerClass parent; + MMBaseBearerClass parent; }; GType mm_bearer_mbim_get_type (void); /* MBIM bearer creation implementation. * NOTE it is *not* a broadband bearer, so not async-initable */ -MMBearer *mm_bearer_mbim_new (MMBroadbandModemMbim *modem, - MMBearerProperties *config, - guint32 session_id); +MMBaseBearer *mm_bearer_mbim_new (MMBroadbandModemMbim *modem, + MMBearerProperties *config, + guint32 session_id); guint32 mm_bearer_mbim_get_session_id (MMBearerMbim *self); diff --git a/src/mm-bearer-qmi.c b/src/mm-bearer-qmi.c index 41fdc6eb..c25b9f74 100644 --- a/src/mm-bearer-qmi.c +++ b/src/mm-bearer-qmi.c @@ -33,7 +33,7 @@ #include "mm-log.h" #include "mm-modem-helpers.h" -G_DEFINE_TYPE (MMBearerQmi, mm_bearer_qmi, MM_TYPE_BEARER); +G_DEFINE_TYPE (MMBearerQmi, mm_bearer_qmi, MM_TYPE_BASE_BEARER); #define GLOBAL_PACKET_DATA_HANDLE 0xFFFFFFFF @@ -116,7 +116,7 @@ connect_context_complete_and_free (ConnectContext *ctx) } static MMBearerConnectResult * -connect_finish (MMBearer *self, +connect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -869,7 +869,7 @@ connect_context_step (ConnectContext *ctx) } static void -_connect (MMBearer *self, +_connect (MMBaseBearer *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) @@ -883,7 +883,7 @@ _connect (MMBearer *self, const gchar *apn; g_object_get (self, - MM_BEARER_MODEM, &modem, + MM_BASE_BEARER_MODEM, &modem, NULL); g_assert (modem); @@ -915,7 +915,7 @@ _connect (MMBearer *self, } /* Check whether we have an APN */ - apn = mm_bearer_properties_get_apn (mm_bearer_peek_config (MM_BEARER (self))); + apn = mm_bearer_properties_get_apn (mm_base_bearer_peek_config (MM_BASE_BEARER (self))); /* Is this a 3GPP only modem and no APN was given? If so, error */ if (mm_iface_modem_is_3gpp_only (MM_IFACE_MODEM (modem)) && !apn) { @@ -963,7 +963,7 @@ _connect (MMBearer *self, connect); g_object_get (self, - MM_BEARER_CONFIG, &properties, + MM_BASE_BEARER_CONFIG, &properties, NULL); if (properties) { @@ -979,7 +979,7 @@ _connect (MMBearer *self, ip_family == MM_BEARER_IP_FAMILY_ANY) { gchar *ip_family_str; - ip_family = mm_bearer_get_default_ip_family (self); + ip_family = mm_base_bearer_get_default_ip_family (self); ip_family_str = mm_bearer_ip_family_build_string_from_mask (ip_family); mm_dbg ("No specific IP family requested, defaulting to %s", ip_family_str); @@ -1088,7 +1088,7 @@ disconnect_context_complete_and_free (DisconnectContext *ctx) } static gboolean -disconnect_finish (MMBearer *self, +disconnect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -1236,7 +1236,7 @@ disconnect_context_step (DisconnectContext *ctx) } static void -disconnect (MMBearer *_self, +disconnect (MMBaseBearer *_self, GAsyncReadyCallback callback, gpointer user_data) { @@ -1276,7 +1276,7 @@ disconnect (MMBearer *_self, /*****************************************************************************/ static void -report_connection_status (MMBearer *self, +report_connection_status (MMBaseBearer *self, MMBearerConnectionStatus status) { if (status == MM_BEARER_CONNECTION_STATUS_DISCONNECTED) @@ -1284,27 +1284,27 @@ report_connection_status (MMBearer *self, reset_bearer_connection (MM_BEARER_QMI (self), TRUE, TRUE); /* Chain up parent's report_connection_status() */ - MM_BEARER_CLASS (mm_bearer_qmi_parent_class)->report_connection_status (self, status); + MM_BASE_BEARER_CLASS (mm_bearer_qmi_parent_class)->report_connection_status (self, status); } /*****************************************************************************/ -MMBearer * +MMBaseBearer * mm_bearer_qmi_new (MMBroadbandModemQmi *modem, MMBearerProperties *config) { - MMBearer *bearer; + MMBaseBearer *bearer; - /* The Qmi bearer inherits from MMBearer (so it's not a MMBroadbandBearer) + /* The Qmi bearer inherits from MMBaseBearer (so it's not a MMBroadbandBearer) * and that means that the object is not async-initable, so we just use * g_object_new() here */ bearer = g_object_new (MM_TYPE_BEARER_QMI, - MM_BEARER_MODEM, modem, - MM_BEARER_CONFIG, config, + MM_BASE_BEARER_MODEM, modem, + MM_BASE_BEARER_CONFIG, config, NULL); /* Only export valid bearers */ - mm_bearer_export (bearer); + mm_base_bearer_export (bearer); return bearer; } @@ -1334,16 +1334,16 @@ static void mm_bearer_qmi_class_init (MMBearerQmiClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - MMBearerClass *bearer_class = MM_BEARER_CLASS (klass); + MMBaseBearerClass *base_bearer_class = MM_BASE_BEARER_CLASS (klass); g_type_class_add_private (object_class, sizeof (MMBearerQmiPrivate)); /* Virtual methods */ object_class->dispose = dispose; - bearer_class->connect = _connect; - bearer_class->connect_finish = connect_finish; - bearer_class->disconnect = disconnect; - bearer_class->disconnect_finish = disconnect_finish; - bearer_class->report_connection_status = report_connection_status; + base_bearer_class->connect = _connect; + base_bearer_class->connect_finish = connect_finish; + base_bearer_class->disconnect = disconnect; + base_bearer_class->disconnect_finish = disconnect_finish; + base_bearer_class->report_connection_status = report_connection_status; } diff --git a/src/mm-bearer-qmi.h b/src/mm-bearer-qmi.h index 77e8e188..b29fed37 100644 --- a/src/mm-bearer-qmi.h +++ b/src/mm-bearer-qmi.h @@ -24,7 +24,7 @@ #define _LIBMM_INSIDE_MM #include -#include "mm-bearer.h" +#include "mm-base-bearer.h" #include "mm-broadband-modem-qmi.h" #define MM_TYPE_BEARER_QMI (mm_bearer_qmi_get_type ()) @@ -39,19 +39,19 @@ typedef struct _MMBearerQmiClass MMBearerQmiClass; typedef struct _MMBearerQmiPrivate MMBearerQmiPrivate; struct _MMBearerQmi { - MMBearer parent; + MMBaseBearer parent; MMBearerQmiPrivate *priv; }; struct _MMBearerQmiClass { - MMBearerClass parent; + MMBaseBearerClass parent; }; GType mm_bearer_qmi_get_type (void); /* QMI bearer creation implementation. * NOTE it is *not* a broadband bearer, so not async-initable */ -MMBearer *mm_bearer_qmi_new (MMBroadbandModemQmi *modem, - MMBearerProperties *config); +MMBaseBearer *mm_bearer_qmi_new (MMBroadbandModemQmi *modem, + MMBearerProperties *config); #endif /* MM_BEARER_QMI_H */ diff --git a/src/mm-bearer.c b/src/mm-bearer.c deleted file mode 100644 index 12d1e58b..00000000 --- a/src/mm-bearer.c +++ /dev/null @@ -1,1301 +0,0 @@ -/* -*- 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) 2008 - 2009 Novell, Inc. - * Copyright (C) 2009 - 2011 Red Hat, Inc. - * Copyright (C) 2011 Google, Inc. - * Copyright (C) 2011 - 2013 Aleksander Morgado - */ - -#include -#include -#include -#include -#include -#include - -#include -#define _LIBMM_INSIDE_MM -#include - -#include "mm-daemon-enums-types.h" -#include "mm-iface-modem.h" -#include "mm-iface-modem-3gpp.h" -#include "mm-iface-modem-cdma.h" -#include "mm-bearer.h" -#include "mm-base-modem-at.h" -#include "mm-base-modem.h" -#include "mm-log.h" -#include "mm-modem-helpers.h" - -/* We require up to 20s to get a proper IP when using PPP */ -#define MM_BEARER_IP_TIMEOUT_DEFAULT 20 - -#define MM_BEARER_DEFERRED_UNREGISTRATION_TIMEOUT 15 - -G_DEFINE_TYPE (MMBearer, mm_bearer, MM_GDBUS_TYPE_BEARER_SKELETON); - - -typedef enum { - CONNECTION_FORBIDDEN_REASON_NONE, - CONNECTION_FORBIDDEN_REASON_UNREGISTERED, - CONNECTION_FORBIDDEN_REASON_ROAMING, - CONNECTION_FORBIDDEN_REASON_LAST -} ConnectionForbiddenReason; - -enum { - PROP_0, - PROP_PATH, - PROP_CONNECTION, - PROP_MODEM, - PROP_STATUS, - PROP_CONFIG, - PROP_DEFAULT_IP_FAMILY, - PROP_LAST -}; - -static GParamSpec *properties[PROP_LAST]; - -struct _MMBearerPrivate { - /* The connection to the system bus */ - GDBusConnection *connection; - /* The modem which owns this BEARER */ - MMBaseModem *modem; - /* The path where the BEARER object is exported */ - gchar *path; - /* Status of this bearer */ - MMBearerStatus status; - /* Configuration of the bearer */ - MMBearerProperties *config; - /* Default IP family of this bearer */ - MMBearerIpFamily default_ip_family; - - /* Cancellable for connect() */ - GCancellable *connect_cancellable; - /* handler id for the disconnect + cancel connect request */ - gulong disconnect_signal_handler; - - /*-- 3GPP specific --*/ - guint deferred_3gpp_unregistration_id; - /* Reason if 3GPP connection is forbidden */ - ConnectionForbiddenReason reason_3gpp; - /* Handler ID for the registration state change signals */ - guint id_3gpp_registration_change; - - /*-- CDMA specific --*/ - guint deferred_cdma_unregistration_id; - /* Reason if CDMA connection is forbidden */ - ConnectionForbiddenReason reason_cdma; - /* Handler IDs for the registration state change signals */ - guint id_cdma1x_registration_change; - guint id_evdo_registration_change; -}; - -/*****************************************************************************/ - -static const gchar *connection_forbidden_reason_str [CONNECTION_FORBIDDEN_REASON_LAST] = { - "none", - "Not registered in the network", - "Registered in roaming network, and roaming not allowed" -}; - -/*****************************************************************************/ - -void -mm_bearer_export (MMBearer *self) -{ - static guint id = 0; - gchar *path; - - path = g_strdup_printf (MM_DBUS_BEARER_PREFIX "/%d", id++); - g_object_set (self, - MM_BEARER_PATH, path, - NULL); - g_free (path); -} - -/*****************************************************************************/ - -static void -bearer_reset_interface_status (MMBearer *self) -{ - mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), FALSE); - mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); - mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), NULL); - mm_gdbus_bearer_set_ip4_config ( - MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (NULL)); - mm_gdbus_bearer_set_ip6_config ( - MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (NULL)); -} - -static void -bearer_update_status (MMBearer *self, - MMBearerStatus status) -{ - /* NOTE: we do allow status 'CONNECTED' here; it may happen if we go into - * DISCONNECTING and we cannot disconnect */ - - /* Update the property value */ - self->priv->status = status; - g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_STATUS]); - - /* Ensure that we don't expose any connection related data in the - * interface when going into disconnected state. */ - if (self->priv->status == MM_BEARER_STATUS_DISCONNECTED) - bearer_reset_interface_status (self); -} - -static void -bearer_update_status_connected (MMBearer *self, - const gchar *interface, - MMBearerIpConfig *ipv4_config, - MMBearerIpConfig *ipv6_config) -{ - mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), TRUE); - mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); - mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), interface); - mm_gdbus_bearer_set_ip4_config ( - MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (ipv4_config)); - mm_gdbus_bearer_set_ip6_config ( - MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (ipv6_config)); - - /* Update the property value */ - self->priv->status = MM_BEARER_STATUS_CONNECTED; - g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_STATUS]); -} - -/*****************************************************************************/ - -static void -reset_deferred_unregistration (MMBearer *self) -{ - if (self->priv->deferred_cdma_unregistration_id) { - g_source_remove (self->priv->deferred_cdma_unregistration_id); - self->priv->deferred_cdma_unregistration_id = 0; - } - - if (self->priv->deferred_3gpp_unregistration_id) { - g_source_remove (self->priv->deferred_3gpp_unregistration_id); - self->priv->deferred_3gpp_unregistration_id = 0; - } -} - -static gboolean -deferred_3gpp_unregistration_cb (MMBearer *self) -{ - g_warn_if_fail (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_UNREGISTERED); - self->priv->deferred_3gpp_unregistration_id = 0; - - mm_dbg ("Forcing bearer disconnection, not registered in 3GPP network"); - mm_bearer_disconnect_force (self); - return FALSE; -} - -static void -modem_3gpp_registration_state_changed (MMIfaceModem3gpp *modem, - GParamSpec *pspec, - MMBearer *self) -{ - MMModem3gppRegistrationState state = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN; - - g_object_get (modem, - MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, &state, - NULL); - - switch (state) { - case MM_MODEM_3GPP_REGISTRATION_STATE_IDLE: - case MM_MODEM_3GPP_REGISTRATION_STATE_DENIED: - case MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN: - self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_UNREGISTERED; - break; - case MM_MODEM_3GPP_REGISTRATION_STATE_HOME: - case MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING: - self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; - break; - case MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING: - if (mm_bearer_properties_get_allow_roaming (mm_bearer_peek_config (self))) - self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; - else - self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_ROAMING; - break; - } - - /* If no reason to disconnect, or if it's a mixed CDMA+LTE modem without a CDMA reason, - * just don't do anything. */ - if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_NONE || - (mm_iface_modem_is_cdma (MM_IFACE_MODEM (modem)) && - self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_NONE)) { - reset_deferred_unregistration (self); - return; - } - - /* Modem is roaming and roaming not allowed, report right away */ - if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_ROAMING) { - mm_dbg ("Bearer not allowed to connect, registered in roaming 3GPP network"); - reset_deferred_unregistration (self); - mm_bearer_disconnect_force (self); - return; - } - - /* Modem reports being unregistered */ - if (self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_UNREGISTERED) { - /* If there is already a notification pending, just return */ - if (self->priv->deferred_3gpp_unregistration_id) - return; - - /* If the bearer is not connected, report right away */ - if (self->priv->status != MM_BEARER_STATUS_CONNECTED) { - mm_dbg ("Bearer not allowed to connect, not registered in 3GPP network"); - mm_bearer_disconnect_force (self); - return; - } - - /* Otherwise, setup the new timeout */ - mm_dbg ("Connected bearer not registered in 3GPP network"); - self->priv->deferred_3gpp_unregistration_id = - g_timeout_add_seconds (MM_BEARER_DEFERRED_UNREGISTRATION_TIMEOUT, - (GSourceFunc) deferred_3gpp_unregistration_cb, - self); - return; - } - - g_assert_not_reached (); -} - -static gboolean -deferred_cdma_unregistration_cb (MMBearer *self) -{ - g_warn_if_fail (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_UNREGISTERED); - self->priv->deferred_cdma_unregistration_id = 0; - - mm_dbg ("Forcing bearer disconnection, not registered in CDMA network"); - mm_bearer_disconnect_force (self); - return FALSE; -} - -static void -modem_cdma_registration_state_changed (MMIfaceModemCdma *modem, - GParamSpec *pspec, - MMBearer *self) -{ - MMModemCdmaRegistrationState cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; - MMModemCdmaRegistrationState evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; - - g_object_get (modem, - MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, &cdma1x_state, - MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, &evdo_state, - NULL); - - if (cdma1x_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING || - evdo_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING) { - if (mm_bearer_properties_get_allow_roaming (mm_bearer_peek_config (self))) - self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; - else - self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_ROAMING; - } else if (cdma1x_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN || - evdo_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { - self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; - } else { - self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_UNREGISTERED; - } - - /* If no reason to disconnect, or if it's a mixed CDMA+LTE modem without a 3GPP reason, - * just don't do anything. */ - if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_NONE || - (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (modem)) && - self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_NONE)) { - reset_deferred_unregistration (self); - return; - } - - /* Modem is roaming and roaming not allowed, report right away */ - if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_ROAMING) { - mm_dbg ("Bearer not allowed to connect, registered in roaming CDMA network"); - reset_deferred_unregistration (self); - mm_bearer_disconnect_force (self); - return; - } - - /* Modem reports being unregistered */ - if (self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_UNREGISTERED) { - /* If there is already a notification pending, just return */ - if (self->priv->deferred_cdma_unregistration_id) - return; - - /* If the bearer is not connected, report right away */ - if (self->priv->status != MM_BEARER_STATUS_CONNECTED) { - mm_dbg ("Bearer not allowed to connect, not registered in CDMA network"); - mm_bearer_disconnect_force (self); - return; - } - - /* Otherwise, setup the new timeout */ - mm_dbg ("Connected bearer not registered in CDMA network"); - self->priv->deferred_cdma_unregistration_id = - g_timeout_add_seconds (MM_BEARER_DEFERRED_UNREGISTRATION_TIMEOUT, - (GSourceFunc) deferred_cdma_unregistration_cb, - self); - return; - } - - g_assert_not_reached (); -} - -static void -set_signal_handlers (MMBearer *self) -{ - g_assert (self->priv->modem != NULL); - g_assert (self->priv->config != NULL); - - /* Don't set the 3GPP registration change signal handlers if they - * are already set. */ - if (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self->priv->modem)) && - !self->priv->id_3gpp_registration_change) { - self->priv->id_3gpp_registration_change = - g_signal_connect (self->priv->modem, - "notify::" MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, - G_CALLBACK (modem_3gpp_registration_state_changed), - self); - modem_3gpp_registration_state_changed (MM_IFACE_MODEM_3GPP (self->priv->modem), NULL, self); - } - - /* Don't set the CDMA1x/EV-DO registration change signal handlers if they - * are already set. */ - if (mm_iface_modem_is_cdma (MM_IFACE_MODEM (self->priv->modem)) && - !self->priv->id_cdma1x_registration_change && - !self->priv->id_evdo_registration_change) { - self->priv->id_cdma1x_registration_change = - g_signal_connect (self->priv->modem, - "notify::" MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, - G_CALLBACK (modem_cdma_registration_state_changed), - self); - self->priv->id_evdo_registration_change = - g_signal_connect (self->priv->modem, - "notify::" MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, - G_CALLBACK (modem_cdma_registration_state_changed), - self); - modem_cdma_registration_state_changed (MM_IFACE_MODEM_CDMA (self->priv->modem), NULL, self); - } -} - -static void -reset_signal_handlers (MMBearer *self) -{ - if (!self->priv->modem) - return; - - if (self->priv->id_3gpp_registration_change) { - if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_3gpp_registration_change)) - g_signal_handler_disconnect (self->priv->modem, self->priv->id_3gpp_registration_change); - self->priv->id_3gpp_registration_change = 0; - } - if (self->priv->id_cdma1x_registration_change) { - if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_cdma1x_registration_change)) - g_signal_handler_disconnect (self->priv->modem, self->priv->id_cdma1x_registration_change); - self->priv->id_cdma1x_registration_change = 0; - } - if (self->priv->id_evdo_registration_change) { - if (g_signal_handler_is_connected (self->priv->modem, self->priv->id_evdo_registration_change)) - g_signal_handler_disconnect (self->priv->modem, self->priv->id_evdo_registration_change); - self->priv->id_evdo_registration_change = 0; - } -} - -/*****************************************************************************/ -/* CONNECT */ - -gboolean -mm_bearer_connect_finish (MMBearer *self, - GAsyncResult *res, - GError **error) -{ - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error); -} - -static void -disconnect_after_cancel_ready (MMBearer *self, - GAsyncResult *res) -{ - GError *error = NULL; - - if (!MM_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { - mm_warn ("Error disconnecting bearer '%s': '%s'. " - "Will assume disconnected anyway.", - self->priv->path, - error->message); - g_error_free (error); - } - else - mm_dbg ("Disconnected bearer '%s'", self->priv->path); - - /* Report disconnection to the bearer object using class method - * mm_bearer_report_connection_status. This gives subclass implementations a - * chance to correctly update their own connection state, in case this base - * class ignores a failed disconnection attempt. - */ - mm_bearer_report_connection_status (self, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); -} - -static void -connect_ready (MMBearer *self, - GAsyncResult *res, - GSimpleAsyncResult *simple) -{ - GError *error = NULL; - gboolean launch_disconnect = FALSE; - MMBearerConnectResult *result; - - /* NOTE: connect() implementations *MUST* handle cancellations themselves */ - result = MM_BEARER_GET_CLASS (self)->connect_finish (self, res, &error); - if (!result) { - mm_dbg ("Couldn't connect bearer '%s': '%s'", - self->priv->path, - error->message); - if (g_error_matches (error, - MM_CORE_ERROR, - MM_CORE_ERROR_CANCELLED)) { - /* Will launch disconnection */ - launch_disconnect = TRUE; - } else - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); - - g_simple_async_result_take_error (simple, error); - } - /* Handle cancellations detected after successful connection */ - else if (g_cancellable_is_cancelled (self->priv->connect_cancellable)) { - mm_dbg ("Connected bearer '%s', but need to disconnect", self->priv->path); - mm_bearer_connect_result_unref (result); - g_simple_async_result_set_error ( - simple, - MM_CORE_ERROR, - MM_CORE_ERROR_CANCELLED, - "Bearer got connected, but had to disconnect after cancellation request"); - launch_disconnect = TRUE; - } - else { - mm_dbg ("Connected bearer '%s'", self->priv->path); - - /* Update bearer and interface status */ - bearer_update_status_connected ( - self, - mm_port_get_device (mm_bearer_connect_result_peek_data (result)), - mm_bearer_connect_result_peek_ipv4_config (result), - mm_bearer_connect_result_peek_ipv6_config (result)); - mm_bearer_connect_result_unref (result); - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - } - - if (launch_disconnect) { - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); - MM_BEARER_GET_CLASS (self)->disconnect ( - self, - (GAsyncReadyCallback)disconnect_after_cancel_ready, - NULL); - } - - g_clear_object (&self->priv->connect_cancellable); - g_simple_async_result_complete (simple); - g_object_unref (simple); -} - -void -mm_bearer_connect (MMBearer *self, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GSimpleAsyncResult *result; - - g_assert (MM_BEARER_GET_CLASS (self)->connect != NULL); - g_assert (MM_BEARER_GET_CLASS (self)->connect_finish != NULL); - - /* If already connecting, return error, don't allow a second request. */ - if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { - g_simple_async_report_error_in_idle ( - G_OBJECT (self), - callback, - user_data, - MM_CORE_ERROR, - MM_CORE_ERROR_IN_PROGRESS, - "Bearer already being connected"); - return; - } - - /* If currently disconnecting, return error, previous operation should - * finish before allowing to connect again. */ - if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING) { - g_simple_async_report_error_in_idle ( - G_OBJECT (self), - callback, - user_data, - MM_CORE_ERROR, - MM_CORE_ERROR_FAILED, - "Bearer currently being disconnected"); - return; - } - - /* Check 3GPP roaming allowance, *only* roaming related here */ - if (mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self->priv->modem)) && - self->priv->reason_3gpp == CONNECTION_FORBIDDEN_REASON_ROAMING) { - g_simple_async_report_error_in_idle ( - G_OBJECT (self), - callback, - user_data, - MM_CORE_ERROR, - MM_CORE_ERROR_UNAUTHORIZED, - "Not allowed to connect bearer in 3GPP network: '%s'", - connection_forbidden_reason_str[self->priv->reason_3gpp]); - return; - } - - /* Check CDMA roaming allowance, *only* roaming related here */ - if (mm_iface_modem_is_cdma (MM_IFACE_MODEM (self->priv->modem)) && - self->priv->reason_cdma == CONNECTION_FORBIDDEN_REASON_ROAMING) { - g_simple_async_report_error_in_idle ( - G_OBJECT (self), - callback, - user_data, - MM_CORE_ERROR, - MM_CORE_ERROR_UNAUTHORIZED, - "Not allowed to connect bearer in CDMA network: '%s'", - connection_forbidden_reason_str[self->priv->reason_cdma]); - return; - } - - result = g_simple_async_result_new (G_OBJECT (self), - callback, - user_data, - mm_bearer_connect); - - /* If already connected, done */ - if (self->priv->status == MM_BEARER_STATUS_CONNECTED) { - g_simple_async_result_set_op_res_gboolean (result, TRUE); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); - return; - } - - /* Connecting! */ - mm_dbg ("Connecting bearer '%s'", self->priv->path); - self->priv->connect_cancellable = g_cancellable_new (); - bearer_update_status (self, MM_BEARER_STATUS_CONNECTING); - MM_BEARER_GET_CLASS (self)->connect ( - self, - self->priv->connect_cancellable, - (GAsyncReadyCallback)connect_ready, - result); -} - -typedef struct { - MMBearer *self; - MMBaseModem *modem; - GDBusMethodInvocation *invocation; -} HandleConnectContext; - -static void -handle_connect_context_free (HandleConnectContext *ctx) -{ - g_object_unref (ctx->invocation); - g_object_unref (ctx->modem); - g_object_unref (ctx->self); - g_free (ctx); -} - -static void -handle_connect_ready (MMBearer *self, - GAsyncResult *res, - HandleConnectContext *ctx) -{ - GError *error = NULL; - - if (!mm_bearer_connect_finish (self, res, &error)) - g_dbus_method_invocation_take_error (ctx->invocation, error); - else - mm_gdbus_bearer_complete_connect (MM_GDBUS_BEARER (self), ctx->invocation); - - handle_connect_context_free (ctx); -} - -static void -handle_connect_auth_ready (MMBaseModem *modem, - GAsyncResult *res, - HandleConnectContext *ctx) -{ - GError *error = NULL; - - if (!mm_base_modem_authorize_finish (modem, res, &error)) { - g_dbus_method_invocation_take_error (ctx->invocation, error); - handle_connect_context_free (ctx); - return; - } - - mm_bearer_connect (ctx->self, - (GAsyncReadyCallback)handle_connect_ready, - ctx); -} - -static gboolean -handle_connect (MMBearer *self, - GDBusMethodInvocation *invocation) -{ - HandleConnectContext *ctx; - - ctx = g_new0 (HandleConnectContext, 1); - ctx->self = g_object_ref (self); - ctx->invocation = g_object_ref (invocation); - g_object_get (self, - MM_BEARER_MODEM, &ctx->modem, - NULL); - - mm_base_modem_authorize (ctx->modem, - invocation, - MM_AUTHORIZATION_DEVICE_CONTROL, - (GAsyncReadyCallback)handle_connect_auth_ready, - ctx); - return TRUE; -} - -/*****************************************************************************/ -/* DISCONNECT */ - -gboolean -mm_bearer_disconnect_finish (MMBearer *self, - GAsyncResult *res, - GError **error) -{ - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error); -} - -static void -disconnect_ready (MMBearer *self, - GAsyncResult *res, - GSimpleAsyncResult *simple) -{ - GError *error = NULL; - - if (!MM_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { - mm_dbg ("Couldn't disconnect bearer '%s'", self->priv->path); - bearer_update_status (self, MM_BEARER_STATUS_CONNECTED); - g_simple_async_result_take_error (simple, error); - } - else { - mm_dbg ("Disconnected bearer '%s'", self->priv->path); - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - } - - g_simple_async_result_complete (simple); - g_object_unref (simple); -} - -static void -status_changed_complete_disconnect (MMBearer *self, - GParamSpec *pspec, - GSimpleAsyncResult *simple) -{ - /* We may get other states here before DISCONNECTED, like DISCONNECTING or - * even CONNECTED. */ - if (self->priv->status != MM_BEARER_STATUS_DISCONNECTED) - return; - - mm_dbg ("Disconnected bearer '%s' after cancelling previous connect request", - self->priv->path); - g_signal_handler_disconnect (self, - self->priv->disconnect_signal_handler); - self->priv->disconnect_signal_handler = 0; - - /* Note: interface state is updated when the DISCONNECTED state is set */ - - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - g_simple_async_result_complete (simple); - g_object_unref (simple); -} - -void -mm_bearer_disconnect (MMBearer *self, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GSimpleAsyncResult *simple; - - g_assert (MM_BEARER_GET_CLASS (self)->disconnect != NULL); - g_assert (MM_BEARER_GET_CLASS (self)->disconnect_finish != NULL); - - simple = g_simple_async_result_new (G_OBJECT (self), - callback, - user_data, - mm_bearer_disconnect); - - /* If already disconnected, done */ - if (self->priv->status == MM_BEARER_STATUS_DISCONNECTED) { - g_simple_async_result_set_op_res_gboolean (simple, TRUE); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - return; - } - - /* If already disconnecting, return error, don't allow a second request. */ - if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING) { - g_simple_async_result_set_error ( - simple, - MM_CORE_ERROR, - MM_CORE_ERROR_IN_PROGRESS, - "Bearer already being disconnected"); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); - return; - } - - mm_dbg ("Disconnecting bearer '%s'", self->priv->path); - - /* If currently connecting, try to cancel that operation, and wait to get - * disconnected. */ - if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { - /* Set ourselves as disconnecting */ - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); - - /* We MUST ensure that we get to DISCONNECTED */ - g_cancellable_cancel (self->priv->connect_cancellable); - /* Note that we only allow to remove disconnected bearers, so should - * be safe to assume that we'll get the signal handler called properly - */ - self->priv->disconnect_signal_handler = - g_signal_connect (self, - "notify::" MM_BEARER_STATUS, - (GCallback)status_changed_complete_disconnect, - simple); /* takes ownership */ - - return; - } - - /* Disconnecting! */ - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); - MM_BEARER_GET_CLASS (self)->disconnect ( - self, - (GAsyncReadyCallback)disconnect_ready, - simple); /* takes ownership */ -} - -typedef struct { - MMBearer *self; - MMBaseModem *modem; - GDBusMethodInvocation *invocation; -} HandleDisconnectContext; - -static void -handle_disconnect_context_free (HandleDisconnectContext *ctx) -{ - g_object_unref (ctx->invocation); - g_object_unref (ctx->modem); - g_object_unref (ctx->self); - g_free (ctx); -} - -static void -handle_disconnect_ready (MMBearer *self, - GAsyncResult *res, - HandleDisconnectContext *ctx) -{ - GError *error = NULL; - - if (!mm_bearer_disconnect_finish (self, res, &error)) - g_dbus_method_invocation_take_error (ctx->invocation, error); - else - mm_gdbus_bearer_complete_disconnect (MM_GDBUS_BEARER (self), ctx->invocation); - - handle_disconnect_context_free (ctx); -} - -static void -handle_disconnect_auth_ready (MMBaseModem *modem, - GAsyncResult *res, - HandleDisconnectContext *ctx) -{ - GError *error = NULL; - - if (!mm_base_modem_authorize_finish (modem, res, &error)) { - g_dbus_method_invocation_take_error (ctx->invocation, error); - handle_disconnect_context_free (ctx); - return; - } - - mm_bearer_disconnect (ctx->self, - (GAsyncReadyCallback)handle_disconnect_ready, - ctx); -} - -static gboolean -handle_disconnect (MMBearer *self, - GDBusMethodInvocation *invocation) -{ - HandleDisconnectContext *ctx; - - ctx = g_new0 (HandleDisconnectContext, 1); - ctx->self = g_object_ref (self); - ctx->invocation = g_object_ref (invocation); - g_object_get (self, - MM_BEARER_MODEM, &ctx->modem, - NULL); - - mm_base_modem_authorize (ctx->modem, - invocation, - MM_AUTHORIZATION_DEVICE_CONTROL, - (GAsyncReadyCallback)handle_disconnect_auth_ready, - ctx); - return TRUE; -} - -/*****************************************************************************/ - -static void -mm_bearer_dbus_export (MMBearer *self) -{ - GError *error = NULL; - - /* Handle method invocations */ - g_signal_connect (self, - "handle-connect", - G_CALLBACK (handle_connect), - NULL); - g_signal_connect (self, - "handle-disconnect", - G_CALLBACK (handle_disconnect), - NULL); - - if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self), - self->priv->connection, - self->priv->path, - &error)) { - mm_warn ("couldn't export BEARER at '%s': '%s'", - self->priv->path, - error->message); - g_error_free (error); - } -} - -static void -mm_bearer_dbus_unexport (MMBearer *self) -{ - const gchar *path; - - path = g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (self)); - /* Only unexport if currently exported */ - if (path) { - mm_dbg ("Removing from DBus bearer at '%s'", path); - g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (self)); - } -} - -/*****************************************************************************/ - -MMBearerStatus -mm_bearer_get_status (MMBearer *self) -{ - return self->priv->status; -} - -const gchar * -mm_bearer_get_path (MMBearer *self) -{ - return self->priv->path; -} - -MMBearerProperties * -mm_bearer_peek_config (MMBearer *self) -{ - return self->priv->config; -} - -MMBearerProperties * -mm_bearer_get_config (MMBearer *self) -{ - return (self->priv->config ? - g_object_ref (self->priv->config) : - NULL); -} - -MMBearerIpFamily -mm_bearer_get_default_ip_family (MMBearer *self) -{ - return self->priv->default_ip_family; -} - -/*****************************************************************************/ - -static void -disconnect_force_ready (MMBearer *self, - GAsyncResult *res) -{ - GError *error = NULL; - - if (!MM_BEARER_GET_CLASS (self)->disconnect_finish (self, res, &error)) { - mm_warn ("Error disconnecting bearer '%s': '%s'. " - "Will assume disconnected anyway.", - self->priv->path, - error->message); - g_error_free (error); - } - else - mm_dbg ("Disconnected bearer '%s'", self->priv->path); - - /* Report disconnection to the bearer object using class method - * mm_bearer_report_connection_status. This gives subclass implementations a - * chance to correctly update their own connection state, in case this base - * class ignores a failed disconnection attempt. - */ - mm_bearer_report_connection_status (self, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); -} - -void -mm_bearer_disconnect_force (MMBearer *self) -{ - if (self->priv->status == MM_BEARER_STATUS_DISCONNECTING || - self->priv->status == MM_BEARER_STATUS_DISCONNECTED) - return; - - mm_dbg ("Forcing disconnection of bearer '%s'", self->priv->path); - - /* If currently connecting, try to cancel that operation. */ - if (self->priv->status == MM_BEARER_STATUS_CONNECTING) { - g_cancellable_cancel (self->priv->connect_cancellable); - return; - } - - /* Disconnecting! */ - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTING); - MM_BEARER_GET_CLASS (self)->disconnect ( - self, - (GAsyncReadyCallback)disconnect_force_ready, - NULL); -} - -/*****************************************************************************/ - -static void -report_connection_status (MMBearer *self, - MMBearerConnectionStatus status) -{ - /* The only status expected at this point is DISCONNECTED. - * No other status should have been given to the generic implementation - * of report_connection_status (it would be an error). - */ - g_assert (status == MM_BEARER_CONNECTION_STATUS_DISCONNECTED); - - /* In the generic bearer implementation we just need to reset the - * interface status */ - bearer_update_status (self, MM_BEARER_STATUS_DISCONNECTED); -} - -void -mm_bearer_report_connection_status (MMBearer *self, - MMBearerConnectionStatus status) -{ - return MM_BEARER_GET_CLASS (self)->report_connection_status (self, status); -} - -static void -set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - MMBearer *self = MM_BEARER (object); - - switch (prop_id) { - case PROP_PATH: - g_free (self->priv->path); - self->priv->path = g_value_dup_string (value); - - /* Export when we get a DBus connection AND we have a path */ - if (self->priv->path && - self->priv->connection) - mm_bearer_dbus_export (self); - break; - case PROP_CONNECTION: - g_clear_object (&self->priv->connection); - self->priv->connection = g_value_dup_object (value); - - /* Export when we get a DBus connection AND we have a path */ - if (!self->priv->connection) - mm_bearer_dbus_unexport (self); - else if (self->priv->path) - mm_bearer_dbus_export (self); - break; - case PROP_MODEM: - g_clear_object (&self->priv->modem); - self->priv->modem = g_value_dup_object (value); - if (self->priv->modem) { - /* Bind the modem's connection (which is set when it is exported, - * and unset when unexported) to the BEARER's connection */ - g_object_bind_property (self->priv->modem, MM_BASE_MODEM_CONNECTION, - self, MM_BEARER_CONNECTION, - G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); - if (self->priv->config) { - /* Listen to 3GPP/CDMA registration state changes. We need both - * 'config' and 'modem' set. */ - set_signal_handlers (self); - } - } - break; - case PROP_STATUS: - /* We don't allow g_object_set()-ing the status property */ - g_assert_not_reached (); - break; - case PROP_CONFIG: { - GVariant *dictionary; - - g_clear_object (&self->priv->config); - self->priv->config = g_value_dup_object (value); - if (self->priv->modem) { - /* Listen to 3GPP/CDMA registration state changes. We need both - * 'config' and 'modem' set. */ - set_signal_handlers (self); - } - /* Also expose the properties */ - dictionary = mm_bearer_properties_get_dictionary (self->priv->config); - mm_gdbus_bearer_set_properties (MM_GDBUS_BEARER (self), dictionary); - if (dictionary) - g_variant_unref (dictionary); - break; - } - case PROP_DEFAULT_IP_FAMILY: - self->priv->default_ip_family = g_value_get_flags (value); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - MMBearer *self = MM_BEARER (object); - - switch (prop_id) { - case PROP_PATH: - g_value_set_string (value, self->priv->path); - break; - case PROP_CONNECTION: - g_value_set_object (value, self->priv->connection); - break; - case PROP_MODEM: - g_value_set_object (value, self->priv->modem); - break; - case PROP_STATUS: - g_value_set_enum (value, self->priv->status); - break; - case PROP_CONFIG: - g_value_set_object (value, self->priv->config); - break; - case PROP_DEFAULT_IP_FAMILY: - g_value_set_flags (value, self->priv->default_ip_family); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -mm_bearer_init (MMBearer *self) -{ - /* Initialize private data */ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - MM_TYPE_BEARER, - MMBearerPrivate); - self->priv->status = MM_BEARER_STATUS_DISCONNECTED; - self->priv->reason_3gpp = CONNECTION_FORBIDDEN_REASON_NONE; - self->priv->reason_cdma = CONNECTION_FORBIDDEN_REASON_NONE; - self->priv->default_ip_family = MM_BEARER_IP_FAMILY_IPV4; - - /* Set defaults */ - mm_gdbus_bearer_set_interface (MM_GDBUS_BEARER (self), NULL); - mm_gdbus_bearer_set_connected (MM_GDBUS_BEARER (self), FALSE); - mm_gdbus_bearer_set_suspended (MM_GDBUS_BEARER (self), FALSE); - mm_gdbus_bearer_set_properties (MM_GDBUS_BEARER (self), NULL); - mm_gdbus_bearer_set_ip_timeout (MM_GDBUS_BEARER (self), MM_BEARER_IP_TIMEOUT_DEFAULT); - mm_gdbus_bearer_set_ip4_config (MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (NULL)); - mm_gdbus_bearer_set_ip6_config (MM_GDBUS_BEARER (self), - mm_bearer_ip_config_get_dictionary (NULL)); -} - -static void -finalize (GObject *object) -{ - MMBearer *self = MM_BEARER (object); - - g_free (self->priv->path); - - G_OBJECT_CLASS (mm_bearer_parent_class)->finalize (object); -} - -static void -dispose (GObject *object) -{ - MMBearer *self = MM_BEARER (object); - - if (self->priv->connection) { - mm_bearer_dbus_unexport (self); - g_clear_object (&self->priv->connection); - } - - reset_signal_handlers (self); - reset_deferred_unregistration (self); - - g_clear_object (&self->priv->modem); - g_clear_object (&self->priv->config); - - G_OBJECT_CLASS (mm_bearer_parent_class)->dispose (object); -} - -static void -mm_bearer_class_init (MMBearerClass *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - g_type_class_add_private (object_class, sizeof (MMBearerPrivate)); - - /* Virtual methods */ - object_class->get_property = get_property; - object_class->set_property = set_property; - object_class->finalize = finalize; - object_class->dispose = dispose; - - klass->report_connection_status = report_connection_status; - - properties[PROP_CONNECTION] = - g_param_spec_object (MM_BEARER_CONNECTION, - "Connection", - "GDBus connection to the system bus.", - G_TYPE_DBUS_CONNECTION, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_CONNECTION, properties[PROP_CONNECTION]); - - properties[PROP_PATH] = - g_param_spec_string (MM_BEARER_PATH, - "Path", - "DBus path of the Bearer", - NULL, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_PATH, properties[PROP_PATH]); - - properties[PROP_MODEM] = - g_param_spec_object (MM_BEARER_MODEM, - "Modem", - "The Modem which owns this Bearer", - MM_TYPE_BASE_MODEM, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_MODEM, properties[PROP_MODEM]); - - properties[PROP_STATUS] = - g_param_spec_enum (MM_BEARER_STATUS, - "Bearer status", - "Status of the bearer", - MM_TYPE_BEARER_STATUS, - MM_BEARER_STATUS_DISCONNECTED, - G_PARAM_READABLE); - g_object_class_install_property (object_class, PROP_STATUS, properties[PROP_STATUS]); - - properties[PROP_CONFIG] = - g_param_spec_object (MM_BEARER_CONFIG, - "Bearer configuration", - "List of user provided properties", - MM_TYPE_BEARER_PROPERTIES, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_CONFIG, properties[PROP_CONFIG]); - - properties[PROP_DEFAULT_IP_FAMILY] = - g_param_spec_flags (MM_BEARER_DEFAULT_IP_FAMILY, - "Bearer default IP family", - "IP family to use for this bearer when no IP family is specified", - MM_TYPE_BEARER_IP_FAMILY, - MM_BEARER_IP_FAMILY_IPV4, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_DEFAULT_IP_FAMILY, properties[PROP_DEFAULT_IP_FAMILY]); -} - -/*****************************************************************************/ -/* Helpers to implement connect() */ - -struct _MMBearerConnectResult { - volatile gint ref_count; - MMPort *data; - MMBearerIpConfig *ipv4_config; - MMBearerIpConfig *ipv6_config; -}; - -MMBearerConnectResult * -mm_bearer_connect_result_ref (MMBearerConnectResult *result) -{ - g_atomic_int_inc (&result->ref_count); - return result; -} - -void -mm_bearer_connect_result_unref (MMBearerConnectResult *result) -{ - if (g_atomic_int_dec_and_test (&result->ref_count)) { - if (result->ipv4_config) - g_object_unref (result->ipv4_config); - if (result->ipv6_config) - g_object_unref (result->ipv6_config); - if (result->data) - g_object_unref (result->data); - g_slice_free (MMBearerConnectResult, result); - } -} - -MMPort * -mm_bearer_connect_result_peek_data (MMBearerConnectResult *result) -{ - return result->data; -} - -MMBearerIpConfig * -mm_bearer_connect_result_peek_ipv4_config (MMBearerConnectResult *result) -{ - return result->ipv4_config; -} - -MMBearerIpConfig * -mm_bearer_connect_result_peek_ipv6_config (MMBearerConnectResult *result) -{ - return result->ipv6_config; -} - -MMBearerConnectResult * -mm_bearer_connect_result_new (MMPort *data, - MMBearerIpConfig *ipv4_config, - MMBearerIpConfig *ipv6_config) -{ - MMBearerConnectResult *result; - - /* 'data' must always be given */ - g_assert (MM_IS_PORT (data)); - - result = g_slice_new0 (MMBearerConnectResult); - result->ref_count = 1; - result->data = g_object_ref (data); - if (ipv4_config) - result->ipv4_config = g_object_ref (ipv4_config); - if (ipv6_config) - result->ipv6_config = g_object_ref (ipv6_config); - return result; -} diff --git a/src/mm-bearer.h b/src/mm-bearer.h deleted file mode 100644 index c1bcaeee..00000000 --- a/src/mm-bearer.h +++ /dev/null @@ -1,138 +0,0 @@ -/* -*- 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: - * - * Author: Aleksander Morgado - * - * Copyright (C) 2011 Google, Inc. - * Copyright (C) 2011 - 2013 Aleksander Morgado - */ - -#ifndef MM_BEARER_H -#define MM_BEARER_H - -#include -#include - -#define _LIBMM_INSIDE_MM -#include - -#include "mm-base-modem.h" - -/*****************************************************************************/ -/* Helpers to implement connect() */ - -typedef struct _MMBearerConnectResult MMBearerConnectResult; -MMBearerConnectResult *mm_bearer_connect_result_new (MMPort *data, - MMBearerIpConfig *ipv4_config, - MMBearerIpConfig *ipv6_config); -void mm_bearer_connect_result_unref (MMBearerConnectResult *result); -MMBearerConnectResult *mm_bearer_connect_result_ref (MMBearerConnectResult *result); -MMPort *mm_bearer_connect_result_peek_data (MMBearerConnectResult *result); -MMBearerIpConfig *mm_bearer_connect_result_peek_ipv4_config (MMBearerConnectResult *result); -MMBearerIpConfig *mm_bearer_connect_result_peek_ipv6_config (MMBearerConnectResult *result); - -/*****************************************************************************/ - -#define MM_TYPE_BEARER (mm_bearer_get_type ()) -#define MM_BEARER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_BEARER, MMBearer)) -#define MM_BEARER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_BEARER, MMBearerClass)) -#define MM_IS_BEARER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_BEARER)) -#define MM_IS_BEARER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MM_TYPE_BEARER)) -#define MM_BEARER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_BEARER, MMBearerClass)) - -typedef struct _MMBearer MMBearer; -typedef struct _MMBearerClass MMBearerClass; -typedef struct _MMBearerPrivate MMBearerPrivate; - -#define MM_BEARER_PATH "bearer-path" -#define MM_BEARER_CONNECTION "bearer-connection" -#define MM_BEARER_MODEM "bearer-modem" -#define MM_BEARER_STATUS "bearer-status" -#define MM_BEARER_CONFIG "bearer-config" -#define MM_BEARER_DEFAULT_IP_FAMILY "bearer-deafult-ip-family" - -typedef enum { /*< underscore_name=mm_bearer_status >*/ - MM_BEARER_STATUS_DISCONNECTED, - MM_BEARER_STATUS_DISCONNECTING, - MM_BEARER_STATUS_CONNECTING, - MM_BEARER_STATUS_CONNECTED, -} MMBearerStatus; - -typedef enum { /*< underscore_name=mm_bearer_connection_status >*/ - MM_BEARER_CONNECTION_STATUS_UNKNOWN, - MM_BEARER_CONNECTION_STATUS_DISCONNECTED, - MM_BEARER_CONNECTION_STATUS_DISCONNECTING, - MM_BEARER_CONNECTION_STATUS_CONNECTED, - MM_BEARER_CONNECTION_STATUS_CONNECTION_FAILED, -} MMBearerConnectionStatus; - -struct _MMBearer { - MmGdbusBearerSkeleton parent; - MMBearerPrivate *priv; -}; - -struct _MMBearerClass { - MmGdbusBearerSkeletonClass parent; - - /* Connect this bearer */ - void (* connect) (MMBearer *bearer, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - MMBearerConnectResult * (* connect_finish) (MMBearer *bearer, - GAsyncResult *res, - GError **error); - - /* Disconnect this bearer */ - void (* disconnect) (MMBearer *bearer, - GAsyncReadyCallback callback, - gpointer user_data); - gboolean (* disconnect_finish) (MMBearer *bearer, - GAsyncResult *res, - GError **error); - - /* Report connection status of this bearer */ - void (* report_connection_status) (MMBearer *bearer, - MMBearerConnectionStatus status); -}; - -GType mm_bearer_get_type (void); - -void mm_bearer_export (MMBearer *self); - -const gchar *mm_bearer_get_path (MMBearer *bearer); -MMBearerStatus mm_bearer_get_status (MMBearer *bearer); -MMBearerProperties *mm_bearer_peek_config (MMBearer *self); -MMBearerProperties *mm_bearer_get_config (MMBearer *self); -MMBearerIpFamily mm_bearer_get_default_ip_family (MMBearer *self); - - -void mm_bearer_connect (MMBearer *self, - GAsyncReadyCallback callback, - gpointer user_data); -gboolean mm_bearer_connect_finish (MMBearer *self, - GAsyncResult *res, - GError **error); - -void mm_bearer_disconnect (MMBearer *self, - GAsyncReadyCallback callback, - gpointer user_data); -gboolean mm_bearer_disconnect_finish (MMBearer *self, - GAsyncResult *res, - GError **error); - -void mm_bearer_disconnect_force (MMBearer *self); - -void mm_bearer_report_connection_status (MMBearer *self, - MMBearerConnectionStatus status); - -#endif /* MM_BEARER_H */ diff --git a/src/mm-broadband-bearer.c b/src/mm-broadband-bearer.c index bed9ec2d..98714ebc 100644 --- a/src/mm-broadband-bearer.c +++ b/src/mm-broadband-bearer.c @@ -38,7 +38,7 @@ static void async_initable_iface_init (GAsyncInitableIface *iface); -G_DEFINE_TYPE_EXTENDED (MMBroadbandBearer, mm_broadband_bearer, MM_TYPE_BEARER, 0, +G_DEFINE_TYPE_EXTENDED (MMBroadbandBearer, mm_broadband_bearer, MM_TYPE_BASE_BEARER, 0, G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init)); @@ -167,12 +167,12 @@ detailed_connect_context_new (MMBroadbandBearer *self, user_data, detailed_connect_context_new); - ctx->ip_family = mm_bearer_properties_get_ip_type (mm_bearer_peek_config (MM_BEARER (self))); + ctx->ip_family = mm_bearer_properties_get_ip_type (mm_base_bearer_peek_config (MM_BASE_BEARER (self))); if (ctx->ip_family == MM_BEARER_IP_FAMILY_NONE || ctx->ip_family == MM_BEARER_IP_FAMILY_ANY) { gchar *default_family; - ctx->ip_family = mm_bearer_get_default_ip_family (MM_BEARER (self)); + ctx->ip_family = mm_base_bearer_get_default_ip_family (MM_BASE_BEARER (self)); default_family = mm_bearer_ip_family_build_string_from_mask (ctx->ip_family); mm_dbg ("No specific IP family requested, defaulting to %s", default_family); g_free (default_family); @@ -272,7 +272,7 @@ cdma_connect_context_dial (DetailedConnectContext *ctx) gchar *command; const gchar *number; - number = mm_bearer_properties_get_number (mm_bearer_peek_config (MM_BEARER (ctx->self))); + number = mm_bearer_properties_get_number (mm_base_bearer_peek_config (MM_BASE_BEARER (ctx->self))); /* If a number was given when creating the bearer, use that one. * Otherwise, use the default one, #777 @@ -351,14 +351,14 @@ current_rm_protocol_ready (MMBaseModem *self, return; } - if (current_rm != mm_bearer_properties_get_rm_protocol (mm_bearer_peek_config (MM_BEARER (self)))) { + if (current_rm != mm_bearer_properties_get_rm_protocol (mm_base_bearer_peek_config (MM_BASE_BEARER (self)))) { guint new_index; gchar *command; mm_dbg ("Setting requested RM protocol..."); new_index = (mm_cdma_get_index_from_rm_protocol ( - mm_bearer_properties_get_rm_protocol (mm_bearer_peek_config (MM_BEARER (self))), + mm_bearer_properties_get_rm_protocol (mm_base_bearer_peek_config (MM_BASE_BEARER (self))), &error)); if (error) { mm_warn ("Cannot set RM protocol: '%s'", @@ -419,7 +419,7 @@ connect_cdma (MMBroadbandBearer *self, ctx->close_data_on_exit = TRUE; if (mm_bearer_properties_get_rm_protocol ( - mm_bearer_peek_config (MM_BEARER (self))) != + mm_base_bearer_peek_config (MM_BASE_BEARER (self))) != MM_MODEM_CDMA_RM_PROTOCOL_UNKNOWN) { /* Need to query current RM protocol */ mm_dbg ("Querying current RM protocol set..."); @@ -828,7 +828,7 @@ find_cid_ready (MMBaseModem *modem, } /* Otherwise, initialize a new PDP context with our APN */ - apn = mm_port_serial_at_quote_string (mm_bearer_properties_get_apn (mm_bearer_peek_config (MM_BEARER (ctx->self)))); + apn = mm_port_serial_at_quote_string (mm_bearer_properties_get_apn (mm_base_bearer_peek_config (MM_BASE_BEARER (ctx->self)))); command = g_strdup_printf ("+CGDCONT=%u,\"%s\",%s", ctx->cid, pdp_type, @@ -984,7 +984,7 @@ parse_pdp_list (MMBaseModem *modem, } else { const gchar *apn; - apn = mm_bearer_properties_get_apn (mm_bearer_peek_config (MM_BEARER (ctx->self))); + apn = mm_bearer_properties_get_apn (mm_base_bearer_peek_config (MM_BASE_BEARER (ctx->self))); if (apn && g_str_equal (pdp->apn, apn)) { gchar *ip_family_str; @@ -1070,7 +1070,7 @@ connect_context_complete_and_free (ConnectContext *ctx) } static MMBearerConnectResult * -connect_finish (MMBearer *self, +connect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -1138,7 +1138,7 @@ connect_3gpp_ready (MMBroadbandBearer *self, } static void -connect (MMBearer *self, +connect (MMBaseBearer *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) @@ -1162,7 +1162,7 @@ connect (MMBearer *self, /* Get the owner modem object */ g_object_get (self, - MM_BEARER_MODEM, &modem, + MM_BASE_BEARER_MODEM, &modem, NULL); g_assert (modem != NULL); @@ -1213,7 +1213,7 @@ connect (MMBearer *self, */ /* Check whether we have an APN */ - apn = mm_bearer_properties_get_apn (mm_bearer_peek_config (MM_BEARER (self))); + apn = mm_bearer_properties_get_apn (mm_base_bearer_peek_config (MM_BASE_BEARER (self))); /* Is this a 3GPP only modem and no APN was given? If so, error */ if (mm_iface_modem_is_3gpp_only (MM_IFACE_MODEM (modem)) && !apn) { @@ -1665,7 +1665,7 @@ disconnect_context_complete_and_free (DisconnectContext *ctx) } static gboolean -disconnect_finish (MMBearer *self, +disconnect_finish (MMBaseBearer *self, GAsyncResult *res, GError **error) { @@ -1742,7 +1742,7 @@ disconnect_3gpp_ready (MMBroadbandBearer *self, } static void -disconnect (MMBearer *self, +disconnect (MMBaseBearer *self, GAsyncReadyCallback callback, gpointer user_data) { @@ -1762,7 +1762,7 @@ disconnect (MMBearer *self, } g_object_get (self, - MM_BEARER_MODEM, &modem, + MM_BASE_BEARER_MODEM, &modem, NULL); g_assert (modem != NULL); @@ -1823,7 +1823,7 @@ disconnect (MMBearer *self, /*****************************************************************************/ static void -report_connection_status (MMBearer *self, +report_connection_status (MMBaseBearer *self, MMBearerConnectionStatus status) { if (status == MM_BEARER_CONNECTION_STATUS_DISCONNECTED) @@ -1831,7 +1831,7 @@ report_connection_status (MMBearer *self, reset_bearer_connection (MM_BROADBAND_BEARER (self)); /* Chain up parent's report_connection_status() */ - MM_BEARER_CLASS (mm_broadband_bearer_parent_class)->report_connection_status ( + MM_BASE_BEARER_CLASS (mm_broadband_bearer_parent_class)->report_connection_status ( self, status); } @@ -1873,7 +1873,7 @@ init_async_context_free (InitAsyncContext *ctx, g_free (ctx); } -MMBearer * +MMBaseBearer * mm_broadband_bearer_new_finish (GAsyncResult *res, GError **error) { @@ -1888,9 +1888,9 @@ mm_broadband_bearer_new_finish (GAsyncResult *res, return NULL; /* Only export valid bearers */ - mm_bearer_export (MM_BEARER (bearer)); + mm_base_bearer_export (MM_BASE_BEARER (bearer)); - return MM_BEARER (bearer); + return MM_BASE_BEARER (bearer); } static gboolean @@ -1923,7 +1923,7 @@ crm_range_ready (MMBaseModem *modem, &error)) { MMModemCdmaRmProtocol current; - current = mm_bearer_properties_get_rm_protocol (mm_bearer_peek_config (MM_BEARER (ctx->self))); + current = mm_bearer_properties_get_rm_protocol (mm_base_bearer_peek_config (MM_BASE_BEARER (ctx->self))); /* Check if value within the range */ if (current >= min && current <= max) { @@ -1960,7 +1960,7 @@ interface_initialization_step (InitAsyncContext *ctx) * supported. */ if (mm_iface_modem_is_cdma (MM_IFACE_MODEM (ctx->modem)) && mm_bearer_properties_get_rm_protocol ( - mm_bearer_peek_config (MM_BEARER (ctx->self))) != MM_MODEM_CDMA_RM_PROTOCOL_UNKNOWN) { + mm_base_bearer_peek_config (MM_BASE_BEARER (ctx->self))) != MM_MODEM_CDMA_RM_PROTOCOL_UNKNOWN) { mm_base_modem_at_command_full (ctx->modem, ctx->port, "+CRM=?", @@ -2008,7 +2008,7 @@ initable_init_async (GAsyncInitable *initable, NULL); g_object_get (initable, - MM_BEARER_MODEM, &ctx->modem, + MM_BASE_BEARER_MODEM, &ctx->modem, NULL); ctx->port = mm_base_modem_get_port_primary (ctx->modem); @@ -2045,8 +2045,8 @@ mm_broadband_bearer_new (MMBroadbandModem *modem, cancellable, callback, user_data, - MM_BEARER_MODEM, modem, - MM_BEARER_CONFIG, properties, + MM_BASE_BEARER_MODEM, modem, + MM_BASE_BEARER_CONFIG, properties, NULL); } @@ -2083,18 +2083,18 @@ static void mm_broadband_bearer_class_init (MMBroadbandBearerClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - MMBearerClass *bearer_class = MM_BEARER_CLASS (klass); + MMBaseBearerClass *base_bearer_class = MM_BASE_BEARER_CLASS (klass); g_type_class_add_private (object_class, sizeof (MMBroadbandBearerPrivate)); /* Virtual methods */ object_class->dispose = dispose; - bearer_class->connect = connect; - bearer_class->connect_finish = connect_finish; - bearer_class->disconnect = disconnect; - bearer_class->disconnect_finish = disconnect_finish; - bearer_class->report_connection_status = report_connection_status; + base_bearer_class->connect = connect; + base_bearer_class->connect_finish = connect_finish; + base_bearer_class->disconnect = disconnect; + base_bearer_class->disconnect_finish = disconnect_finish; + base_bearer_class->report_connection_status = report_connection_status; klass->connect_3gpp = connect_3gpp; klass->connect_3gpp_finish = detailed_connect_finish; diff --git a/src/mm-broadband-bearer.h b/src/mm-broadband-bearer.h index f3869120..a3e9b165 100644 --- a/src/mm-broadband-bearer.h +++ b/src/mm-broadband-bearer.h @@ -25,7 +25,7 @@ #define _LIBMM_INSIDE_MM #include -#include "mm-bearer.h" +#include "mm-base-bearer.h" #include "mm-broadband-modem.h" #define MM_TYPE_BROADBAND_BEARER (mm_broadband_bearer_get_type ()) @@ -40,12 +40,12 @@ typedef struct _MMBroadbandBearerClass MMBroadbandBearerClass; typedef struct _MMBroadbandBearerPrivate MMBroadbandBearerPrivate; struct _MMBroadbandBearer { - MMBearer parent; + MMBaseBearer parent; MMBroadbandBearerPrivate *priv; }; struct _MMBroadbandBearerClass { - MMBearerClass parent; + MMBaseBearerClass parent; /* Full 3GPP connection sequence */ void (* connect_3gpp) (MMBroadbandBearer *self, @@ -129,14 +129,14 @@ struct _MMBroadbandBearerClass { GType mm_broadband_bearer_get_type (void); /* Default 3GPP bearer creation implementation */ -void mm_broadband_bearer_new (MMBroadbandModem *modem, - MMBearerProperties *properties, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); -MMBearer *mm_broadband_bearer_new_finish (GAsyncResult *res, - GError **error); - -guint mm_broadband_bearer_get_3gpp_cid (MMBroadbandBearer *self); +void mm_broadband_bearer_new (MMBroadbandModem *modem, + MMBearerProperties *properties, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +MMBaseBearer *mm_broadband_bearer_new_finish (GAsyncResult *res, + GError **error); + +guint mm_broadband_bearer_get_3gpp_cid (MMBroadbandBearer *self); #endif /* MM_BROADBAND_BEARER_H */ diff --git a/src/mm-broadband-modem-mbim.c b/src/mm-broadband-modem-mbim.c index f842a37d..f6589656 100644 --- a/src/mm-broadband-modem-mbim.c +++ b/src/mm-broadband-modem-mbim.c @@ -1054,15 +1054,15 @@ modem_power_up (MMIfaceModem *self, /*****************************************************************************/ /* Create Bearer (Modem interface) */ -static MMBearer * +static MMBaseBearer * modem_create_bearer_finish (MMIfaceModem *self, GAsyncResult *res, GError **error) { - MMBearer *bearer; + MMBaseBearer *bearer; bearer = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)); - mm_dbg ("New bearer created at DBus path '%s'", mm_bearer_get_path (bearer)); + mm_dbg ("New bearer created at DBus path '%s'", mm_base_bearer_get_path (bearer)); return g_object_ref (bearer); } @@ -1073,7 +1073,7 @@ typedef struct { } FindSessionId; static void -bearer_list_session_id_foreach (MMBearer *bearer, +bearer_list_session_id_foreach (MMBaseBearer *bearer, gpointer user_data) { FindSessionId *ctx = user_data; @@ -1124,7 +1124,7 @@ modem_create_bearer (MMIfaceModem *self, GAsyncReadyCallback callback, gpointer user_data) { - MMBearer *bearer; + MMBaseBearer *bearer; GSimpleAsyncResult *result; gint session_id; @@ -1632,15 +1632,15 @@ typedef struct { } ReportDisconnectedStatusContext; static void -bearer_list_report_disconnected_status (MMBearer *bearer, +bearer_list_report_disconnected_status (MMBaseBearer *bearer, gpointer user_data) { ReportDisconnectedStatusContext *ctx = user_data; if (MM_IS_BEARER_MBIM (bearer) && mm_bearer_mbim_get_session_id (MM_BEARER_MBIM (bearer)) == ctx->session_id) { - mm_dbg ("Bearer '%s' was disconnected.", mm_bearer_get_path (bearer)); - mm_bearer_report_connection_status (bearer, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); + mm_dbg ("Bearer '%s' was disconnected.", mm_base_bearer_get_path (bearer)); + mm_base_bearer_report_connection_status (bearer, MM_BEARER_CONNECTION_STATUS_DISCONNECTED); } } diff --git a/src/mm-broadband-modem-qmi.c b/src/mm-broadband-modem-qmi.c index 477b36ed..ef5bb569 100644 --- a/src/mm-broadband-modem-qmi.c +++ b/src/mm-broadband-modem-qmi.c @@ -288,15 +288,15 @@ power_cycle (MMBroadbandModemQmi *self, /*****************************************************************************/ /* Create Bearer (Modem interface) */ -static MMBearer * +static MMBaseBearer * modem_create_bearer_finish (MMIfaceModem *self, GAsyncResult *res, GError **error) { - MMBearer *bearer; + MMBaseBearer *bearer; bearer = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)); - mm_dbg ("New bearer created at DBus path '%s'", mm_bearer_get_path (bearer)); + mm_dbg ("New bearer created at DBus path '%s'", mm_base_bearer_get_path (bearer)); return g_object_ref (bearer); } @@ -307,7 +307,7 @@ modem_create_bearer (MMIfaceModem *self, GAsyncReadyCallback callback, gpointer user_data) { - MMBearer *bearer; + MMBaseBearer *bearer; GSimpleAsyncResult *result; /* Set a new ref to the bearer object as result */ @@ -318,9 +318,7 @@ modem_create_bearer (MMIfaceModem *self, /* We just create a MMBearerQmi */ mm_dbg ("Creating QMI bearer in QMI modem"); - bearer = mm_bearer_qmi_new (MM_BROADBAND_MODEM_QMI (self), - properties); - + bearer = mm_bearer_qmi_new (MM_BROADBAND_MODEM_QMI (self), properties); g_simple_async_result_set_op_res_gpointer (result, bearer, g_object_unref); g_simple_async_result_complete_in_idle (result); g_object_unref (result); diff --git a/src/mm-broadband-modem.c b/src/mm-broadband-modem.c index 4a36f7b0..fd4852cb 100644 --- a/src/mm-broadband-modem.c +++ b/src/mm-broadband-modem.c @@ -233,18 +233,18 @@ response_processor_string_ignore_at_errors (MMBaseModem *self, /*****************************************************************************/ /* Create Bearer (Modem interface) */ -static MMBearer * +static MMBaseBearer * modem_create_bearer_finish (MMIfaceModem *self, GAsyncResult *res, GError **error) { - MMBearer *bearer; + MMBaseBearer *bearer; if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error)) return NULL; bearer = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)); - mm_dbg ("New bearer created at DBus path '%s'", mm_bearer_get_path (bearer)); + mm_dbg ("New bearer created at DBus path '%s'", mm_base_bearer_get_path (bearer)); return g_object_ref (bearer); } @@ -254,7 +254,7 @@ broadband_bearer_new_ready (GObject *source, GAsyncResult *res, GSimpleAsyncResult *simple) { - MMBearer *bearer = NULL; + MMBaseBearer *bearer = NULL; GError *error = NULL; bearer = mm_broadband_bearer_new_finish (res, &error); diff --git a/src/mm-iface-modem-simple.c b/src/mm-iface-modem-simple.c index bb850a18..be3f6ff8 100644 --- a/src/mm-iface-modem-simple.c +++ b/src/mm-iface-modem-simple.c @@ -191,7 +191,7 @@ typedef struct { MMSimpleConnectProperties *properties; /* Results to set */ - MMBearer *bearer; + MMBaseBearer *bearer; } ConnectionContext; static void @@ -211,13 +211,13 @@ connection_context_free (ConnectionContext *ctx) static void connection_step (ConnectionContext *ctx); static void -connect_bearer_ready (MMBearer *bearer, +connect_bearer_ready (MMBaseBearer *bearer, GAsyncResult *res, ConnectionContext *ctx) { GError *error = NULL; - if (!mm_bearer_connect_finish (bearer, res, &error)) { + if (!mm_base_bearer_connect_finish (bearer, res, &error)) { mm_dbg ("Couldn't connect bearer: '%s'", error->message); g_dbus_method_invocation_take_error (ctx->invocation, error); connection_context_free (ctx); @@ -415,18 +415,18 @@ update_lock_info_ready (MMIfaceModem *self, } typedef struct { - MMBearer *found; + MMBaseBearer *found; } BearerListFindContext; static void -bearer_list_find_disconnected (MMBearer *bearer, +bearer_list_find_disconnected (MMBaseBearer *bearer, BearerListFindContext *ctx) { /* If already marked one to remove, do nothing */ if (ctx->found) return; - if (mm_bearer_get_status (bearer) == MM_BEARER_STATUS_DISCONNECTED) + if (mm_base_bearer_get_status (bearer) == MM_BEARER_STATUS_DISCONNECTED) ctx->found = g_object_ref (bearer); } @@ -534,15 +534,15 @@ connection_step (ConnectionContext *ctx) GError *error = NULL; if (!mm_bearer_list_delete_bearer (list, - mm_bearer_get_path (foreach_ctx.found), + mm_base_bearer_get_path (foreach_ctx.found), &error)) { mm_dbg ("Couldn't delete disconnected bearer at '%s': '%s'", - mm_bearer_get_path (foreach_ctx.found), + mm_base_bearer_get_path (foreach_ctx.found), error->message); g_error_free (error); } else mm_dbg ("Deleted disconnected bearer at '%s'", - mm_bearer_get_path (foreach_ctx.found)); + mm_base_bearer_get_path (foreach_ctx.found)); g_object_unref (foreach_ctx.found); } @@ -571,7 +571,7 @@ connection_step (ConnectionContext *ctx) } mm_dbg ("Using already existing bearer at '%s'...", - mm_bearer_get_path (ctx->bearer)); + mm_base_bearer_get_path (ctx->bearer)); g_object_unref (list); g_object_unref (bearer_properties); /* Fall down to next step */ @@ -584,15 +584,15 @@ connection_step (ConnectionContext *ctx) /* Wait... if we're already using an existing bearer, we need to check if it is * already connected; and if so, just don't do anything else */ - if (mm_bearer_get_status (ctx->bearer) != MM_BEARER_STATUS_CONNECTED) { - mm_bearer_connect (ctx->bearer, - (GAsyncReadyCallback)connect_bearer_ready, - ctx); + if (mm_base_bearer_get_status (ctx->bearer) != MM_BEARER_STATUS_CONNECTED) { + mm_base_bearer_connect (ctx->bearer, + (GAsyncReadyCallback)connect_bearer_ready, + ctx); return; } mm_dbg ("Bearer at '%s' is already connected...", - mm_bearer_get_path (ctx->bearer)); + mm_base_bearer_get_path (ctx->bearer)); /* Fall down to next step */ ctx->step++; @@ -604,7 +604,7 @@ connection_step (ConnectionContext *ctx) mm_gdbus_modem_simple_complete_connect ( ctx->skeleton, ctx->invocation, - mm_bearer_get_path (ctx->bearer)); + mm_base_bearer_get_path (ctx->bearer)); connection_context_free (ctx); return; } @@ -748,7 +748,7 @@ typedef struct { GDBusMethodInvocation *invocation; gchar *bearer_path; GList *bearers; - MMBearer *current; + MMBaseBearer *current; } DisconnectionContext; static void @@ -767,13 +767,13 @@ disconnection_context_free (DisconnectionContext *ctx) static void disconnect_next_bearer (DisconnectionContext *ctx); static void -disconnect_ready (MMBearer *bearer, +disconnect_ready (MMBaseBearer *bearer, GAsyncResult *res, DisconnectionContext *ctx) { GError *error = NULL; - if (!mm_bearer_disconnect_finish (bearer, res, &error)) { + if (!mm_base_bearer_disconnect_finish (bearer, res, &error)) { g_dbus_method_invocation_take_error (ctx->invocation, error); disconnection_context_free (ctx); return; @@ -796,20 +796,20 @@ disconnect_next_bearer (DisconnectionContext *ctx) return; } - ctx->current = MM_BEARER (ctx->bearers->data); + ctx->current = MM_BASE_BEARER (ctx->bearers->data); ctx->bearers = g_list_delete_link (ctx->bearers, ctx->bearers); - mm_bearer_disconnect (ctx->current, - (GAsyncReadyCallback)disconnect_ready, - ctx); + mm_base_bearer_disconnect (ctx->current, + (GAsyncReadyCallback)disconnect_ready, + ctx); } static void -build_connected_bearer_list (MMBearer *bearer, +build_connected_bearer_list (MMBaseBearer *bearer, DisconnectionContext *ctx) { if (!ctx->bearer_path || - g_str_equal (ctx->bearer_path, mm_bearer_get_path (bearer))) + g_str_equal (ctx->bearer_path, mm_base_bearer_get_path (bearer))) ctx->bearers = g_list_prepend (ctx->bearers, g_object_ref (bearer)); } diff --git a/src/mm-iface-modem.c b/src/mm-iface-modem.c index 87366640..fcdbc766 100644 --- a/src/mm-iface-modem.c +++ b/src/mm-iface-modem.c @@ -378,23 +378,23 @@ bearer_list_updated (MMBearerList *bearer_list, static MMModemState get_current_consolidated_state (MMIfaceModem *self, MMModemState modem_state); typedef struct { - MMBearer *self; + MMBaseBearer *self; guint others_connected; } CountOthersConnectedContext; static void -bearer_list_count_others_connected (MMBearer *bearer, +bearer_list_count_others_connected (MMBaseBearer *bearer, CountOthersConnectedContext *ctx) { /* We can safely compare pointers here */ if (bearer != ctx->self && - mm_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED) { + mm_base_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED) { ctx->others_connected++; } } static void -bearer_status_changed (MMBearer *bearer, +bearer_status_changed (MMBaseBearer *bearer, GParamSpec *pspec, MMIfaceModem *self) { @@ -429,7 +429,7 @@ bearer_status_changed (MMBearer *bearer, if (!ctx.others_connected) { MMModemState new_state = MM_MODEM_STATE_UNKNOWN; - switch (mm_bearer_get_status (bearer)) { + switch (mm_base_bearer_get_status (bearer)) { case MM_BEARER_STATUS_CONNECTED: new_state = MM_MODEM_STATE_CONNECTED; break; @@ -469,7 +469,7 @@ create_bearer_context_complete_and_free (CreateBearerContext *ctx) g_slice_free (CreateBearerContext, ctx); } -MMBearer * +MMBaseBearer * mm_iface_modem_create_bearer_finish (MMIfaceModem *self, GAsyncResult *res, GError **error) @@ -485,7 +485,7 @@ create_bearer_ready (MMIfaceModem *self, GAsyncResult *res, CreateBearerContext *ctx) { - MMBearer *bearer; + MMBaseBearer *bearer; GError *error = NULL; bearer = MM_IFACE_MODEM_GET_INTERFACE (self)->create_bearer_finish (self, res, &error); @@ -505,7 +505,7 @@ create_bearer_ready (MMIfaceModem *self, /* If bearer properly created and added to the list, follow its * status */ g_signal_connect (bearer, - "notify::" MM_BEARER_STATUS, + "notify::" MM_BASE_BEARER_STATUS, (GCallback)bearer_status_changed, self); g_simple_async_result_set_op_res_gpointer (ctx->result, bearer, g_object_unref); @@ -579,7 +579,7 @@ handle_create_bearer_ready (MMIfaceModem *self, GAsyncResult *res, HandleCreateBearerContext *ctx) { - MMBearer *bearer; + MMBaseBearer *bearer; GError *error = NULL; bearer = mm_iface_modem_create_bearer_finish (self, res, &error); @@ -588,7 +588,7 @@ handle_create_bearer_ready (MMIfaceModem *self, else { mm_gdbus_modem_complete_create_bearer (ctx->skeleton, ctx->invocation, - mm_bearer_get_path (bearer)); + mm_base_bearer_get_path (bearer)); g_object_unref (bearer); } @@ -1329,10 +1329,10 @@ periodic_signal_quality_check_enable (MMIfaceModem *self) /*****************************************************************************/ static void -bearer_list_count_connected (MMBearer *bearer, +bearer_list_count_connected (MMBaseBearer *bearer, guint *count) { - if (mm_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED) + if (mm_base_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED) (*count)++; } diff --git a/src/mm-iface-modem.h b/src/mm-iface-modem.h index 5ff26d97..56e38d13 100644 --- a/src/mm-iface-modem.h +++ b/src/mm-iface-modem.h @@ -24,7 +24,7 @@ #include "mm-charsets.h" #include "mm-port-serial-at.h" -#include "mm-bearer.h" +#include "mm-base-bearer.h" #include "mm-sim.h" #define MM_TYPE_IFACE_MODEM (mm_iface_modem_get_type ()) @@ -324,9 +324,9 @@ struct _MMIfaceModem { MMBearerProperties *properties, GAsyncReadyCallback callback, gpointer user_data); - MMBearer * (*create_bearer_finish) (MMIfaceModem *self, - GAsyncResult *res, - GError **error); + MMBaseBearer * (*create_bearer_finish) (MMIfaceModem *self, + GAsyncResult *res, + GError **error); }; GType mm_iface_modem_get_type (void); @@ -462,13 +462,13 @@ gboolean mm_iface_modem_set_current_bands_finish (MMIfaceModem *self, GError **error); /* Allow creating bearers */ -void mm_iface_modem_create_bearer (MMIfaceModem *self, - MMBearerProperties *properties, - GAsyncReadyCallback callback, - gpointer user_data); -MMBearer *mm_iface_modem_create_bearer_finish (MMIfaceModem *self, - GAsyncResult *res, - GError **error); +void mm_iface_modem_create_bearer (MMIfaceModem *self, + MMBearerProperties *properties, + GAsyncReadyCallback callback, + gpointer user_data); +MMBaseBearer *mm_iface_modem_create_bearer_finish (MMIfaceModem *self, + GAsyncResult *res, + GError **error); /* Helper method to wait for a final state */ void mm_iface_modem_wait_for_final_state (MMIfaceModem *self, -- cgit v1.2.3-70-g09d2