SymbX/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d30ba8414ae28ed1116e4120975497b8add45ea0
ModemManager/src/mm-base-modem.c
T
Aleksander Morgado a5058eb799 base-modem: don't assume ports tables always exist 
The 'link_ports' and 'ports' tables are created during object init(),
but they are fully removed and cleared during dispose(). Given that
the MMDevice executes an explicit g_object_run_dispose(), there may be
cases where a long-running operation that isn't cancelled ends up
being completed by the time the object disposal has already run at
least once.

That would end up crashing the process if we attempt to e.g. iterate
over one of the ports hash tables:

  0x00007c3594eb3b93 (libglib-2.0.so.0 - ghash.c: 1180)   g_hash_table_iter_next
  0x00005b60d86f2563 (ModemManager - mm-base-modem.c: 1133)       mm_base_modem_get_port_infos
  0x00005b60d870228e (ModemManager - mm-iface-modem.c: 4013)      fcc_unlock
  0x00007c35950126a8 (libgio-2.0.so.0 - gtask.c: 1230)    g_task_return_now
  0x00007c35950116fa (libgio-2.0.so.0 - gtask.c: 1300)    g_task_return
  0x00007c3595011d12 (libgio-2.0.so.0 - gtask.c: 1930)    g_task_return_new_error
  0x00005b60d87518f2 (ModemManager - mm-broadband-modem-mbim.c: 1970)     radio_state_set_up_ready
  0x00007c35950126a8 (libgio-2.0.so.0 - gtask.c: 1230)    g_task_return_now
  0x00007c35950116fa (libgio-2.0.so.0 - gtask.c: 1300)    g_task_return
  0x00007c35950c486c (libmbim-glib.so.4 - mbim-device.c: 253)     transaction_task_complete_and_free
  0x00007c35950c714b (libmbim-glib.so.4 - mbim-device.c: 335)     transaction_timed_out
  0x00007c3594ec1232 (libglib-2.0.so.0 - gmain.c: 4971)   g_timeout_dispatch
  0x00007c3594ec43fc (libglib-2.0.so.0 - gmain.c: 3417)   g_main_context_dispatch
  0x00007c3594ec4704 (libglib-2.0.so.0 - gmain.c: 4211)   g_main_context_iterate
  0x00007c3594ec4978 (libglib-2.0.so.0 - gmain.c: 4411)   g_main_loop_run
  0x00005b60d86d7c56 (ModemManager - main.c: 217) main
  0x00007c3594c526c5 (libc.so.6 + 0x000286c5)     __libc_init_first
  0x00007c3594c52781 (libc.so.6 + 0x00028781)     __libc_start_main
  0x00005b60d86d7970 (ModemManager + 0x00061970)  _start

Fixes https://gitlab.freedesktop.org/mobile-broadband/ModemManager/-/issues/677

Change-Id: I6695c284f86a196e60de7f714bc1671332d08848
2022-12-20 20:53:58 +00:00

2186 lines
69 KiB
C
Raw Blame History

/* -*- 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.
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ModemManager.h>
#include <ModemManager-tags.h>
#include <mm-errors-types.h>
#include <mm-gdbus-modem.h>
#include "mm-context.h"
#include "mm-base-modem.h"
#if defined WITH_QRTR
#include "mm-kernel-device-qrtr.h"
#endif
#include "mm-log-object.h"
#include "mm-port-enums-types.h"
#include "mm-serial-parsers.h"
#include "mm-modem-helpers.h"
static void log_object_iface_init (MMLogObjectInterface *iface);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MMBaseModem, mm_base_modem, MM_GDBUS_TYPE_OBJECT_SKELETON,
G_IMPLEMENT_INTERFACE (MM_TYPE_LOG_OBJECT, log_object_iface_init))
/* If we get 10 consecutive timeouts in a serial port, we consider the modem
* invalid and we request re-probing. */
#define DEFAULT_MAX_TIMEOUTS 10
enum {
PROP_0,
PROP_VALID,
PROP_MAX_TIMEOUTS,
PROP_DEVICE,
PROP_DRIVERS,
PROP_PLUGIN,
PROP_VENDOR_ID,
PROP_PRODUCT_ID,
PROP_SUBSYSTEM_VENDOR_ID,
PROP_CONNECTION,
PROP_REPROBE,
PROP_DATA_NET_SUPPORTED,
PROP_DATA_TTY_SUPPORTED,
PROP_LAST
};
enum {
SIGNAL_LINK_PORT_GRABBED,
SIGNAL_LINK_PORT_RELEASED,
SIGNAL_LAST
};
static GParamSpec *properties[PROP_LAST];
static guint signals[SIGNAL_LAST];
struct _MMBaseModemPrivate {
/* The connection to the system bus */
GDBusConnection *connection;
guint dbus_id;
/* Modem-wide cancellable. If it ever gets cancelled, no further operations
* should be done by the modem. */
GCancellable *cancellable;
gulong invalid_if_cancelled;
gchar *device;
gchar **drivers;
gchar *plugin;
guint vendor_id;
guint product_id;
guint subsystem_vendor_id;
gboolean hotplugged;
gboolean valid;
gboolean reprobe;
guint max_timeouts;
/* The authorization provider */
MMAuthProvider *authp;
GCancellable *authp_cancellable;
GHashTable *ports;
MMPortSerialAt *primary;
MMPortSerialAt *secondary;
MMPortSerialQcdm *qcdm;
GList *data;
gboolean data_net_supported;
gboolean data_tty_supported;
/* GPS-enabled modems will have an AT port for control, and a raw serial
* port to receive all GPS traces */
MMPortSerialAt *gps_control;
MMPortSerialGps *gps;
/* Some audio-capable devices will have a port for audio specifically */
MMPortSerial *audio;
/* Support for parallel enable/disable operations */
GList *enable_tasks;
GList *disable_tasks;
#if defined WITH_QMI
/* QMI ports */
GList *qmi;
#endif
#if defined WITH_MBIM
/* MBIM ports */
GList *mbim;
#endif
/* Additional port links grabbed after having
* organized ports */
GHashTable *link_ports;
};
guint
mm_base_modem_get_dbus_id (MMBaseModem *self)
{
return self->priv->dbus_id;
}
/******************************************************************************/
static void
port_removed_cb (MMPort *port,
MMBaseModem *self)
{
/* We have to do a full re-probe here because simply reopening the device
* and restarting proxy would leave us without proper notifications. */
mm_obj_msg (self, "port '%s' no longer controllable, reprobing",
mm_port_get_device (MM_PORT (port)));
self->priv->reprobe = TRUE;
g_cancellable_cancel (self->priv->cancellable);
}
static void
port_timed_out_cb (MMPort *port,
guint n_consecutive_timeouts,
MMBaseModem *self)
{
/* If reached the maximum number of timeouts, invalidate modem */
if (n_consecutive_timeouts >= self->priv->max_timeouts) {
mm_obj_err (self, "port %s timed out %u consecutive times, marking modem as invalid",
mm_port_get_device (MM_PORT (port)),
n_consecutive_timeouts);
g_cancellable_cancel (self->priv->cancellable);
return;
}
if (n_consecutive_timeouts > 1)
mm_obj_warn (self, "port %s timed out %u consecutive times",
mm_port_get_device (MM_PORT (port)),
n_consecutive_timeouts);
}
static MMPort *
base_modem_create_ignored_port (MMBaseModem *self,
const gchar *name)
{
return MM_PORT (g_object_new (MM_TYPE_PORT,
MM_PORT_DEVICE, name,
MM_PORT_TYPE, MM_PORT_TYPE_IGNORED,
NULL));
}
static MMPort *
base_modem_create_net_port (MMBaseModem *self,
const gchar *name)
{
return MM_PORT (mm_port_net_new (name));
}
static MMPort *
base_modem_create_tty_port (MMBaseModem *self,
const gchar *name,
MMKernelDevice *kernel_device,
MMPortType ptype)
{
MMPort *port = NULL;
const gchar *flow_control_tag;
if (ptype == MM_PORT_TYPE_QCDM)
port = MM_PORT (mm_port_serial_qcdm_new (name, MM_PORT_SUBSYS_TTY));
else if (ptype == MM_PORT_TYPE_GPS)
port = MM_PORT (mm_port_serial_gps_new (name));
else if (ptype == MM_PORT_TYPE_AUDIO)
port = MM_PORT (mm_port_serial_new (name, ptype));
else if (ptype == MM_PORT_TYPE_AT)
port = MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_TTY));
if (!port)
return NULL;
/* Optional user-provided baudrate */
if (mm_kernel_device_has_property (kernel_device, ID_MM_TTY_BAUDRATE))
g_object_set (port,
MM_PORT_SERIAL_BAUD, mm_kernel_device_get_property_as_int (kernel_device, ID_MM_TTY_BAUDRATE),
NULL);
/* Optional user-provided flow control */
flow_control_tag = mm_kernel_device_get_property (kernel_device, ID_MM_TTY_FLOW_CONTROL);
if (flow_control_tag) {
MMFlowControl flow_control;
g_autoptr(GError) inner_error = NULL;
flow_control = mm_flow_control_from_string (flow_control_tag, &inner_error);
if (flow_control != MM_FLOW_CONTROL_UNKNOWN)
g_object_set (port,
MM_PORT_SERIAL_FLOW_CONTROL, flow_control,
NULL);
else
mm_obj_warn (self, "unsupported flow control settings in port %s: %s",
name, inner_error->message);
}
return port;
}
static MMPort *
base_modem_create_usbmisc_port (MMBaseModem *self,
const gchar *name,
MMPortType ptype)
{
#if defined WITH_QMI
if (ptype == MM_PORT_TYPE_QMI)
return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_USBMISC));
#endif
#if defined WITH_MBIM
if (ptype == MM_PORT_TYPE_MBIM)
return MM_PORT (mm_port_mbim_new (name, MM_PORT_SUBSYS_USBMISC));
#endif
if (ptype == MM_PORT_TYPE_AT)
return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_USBMISC));
return NULL;
}
static MMPort *
base_modem_create_rpmsg_port (MMBaseModem *self,
const gchar *name,
MMPortType ptype)
{
#if defined WITH_QMI
if (ptype == MM_PORT_TYPE_QMI)
return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_RPMSG));
#endif
if (ptype == MM_PORT_TYPE_AT)
return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_RPMSG));
return NULL;
}
#if defined WITH_QRTR
static MMPort *
base_modem_create_qrtr_port (MMBaseModem *self,
const gchar *name,
MMKernelDevice *kernel_device,
MMPortType ptype)
{
if (ptype == MM_PORT_TYPE_QMI) {
g_autoptr(QrtrNode) node = NULL;
g_assert (MM_IS_KERNEL_DEVICE_QRTR (kernel_device));
node = mm_kernel_device_qrtr_get_node (MM_KERNEL_DEVICE_QRTR (kernel_device));
return MM_PORT (mm_port_qmi_new_from_node (name, node));
}
return NULL;
}
#endif
static MMPort *
base_modem_create_wwan_port (MMBaseModem *self,
const gchar *name,
MMPortType ptype)
{
#if defined WITH_QMI
if (ptype == MM_PORT_TYPE_QMI)
return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_WWAN));
#endif
#if defined WITH_MBIM
if (ptype == MM_PORT_TYPE_MBIM)
return MM_PORT (mm_port_mbim_new (name, MM_PORT_SUBSYS_WWAN));
#endif
if (ptype == MM_PORT_TYPE_QCDM)
return MM_PORT (mm_port_serial_qcdm_new (name, MM_PORT_SUBSYS_WWAN));
if (ptype == MM_PORT_TYPE_AT)
return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_WWAN));
return NULL;
}
static MMPort *
base_modem_create_virtual_port (MMBaseModem *self,
const gchar *name)
{
return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_UNIX));
}
static MMPort *
base_modem_internal_grab_port (MMBaseModem *self,
MMKernelDevice *kernel_device,
gboolean link_port,
MMPortType ptype,
MMPortSerialAtFlag at_pflags,
GError **error)
{
MMPort *port;
const gchar *subsys;
const gchar *name;
g_autofree gchar *key = NULL;
gboolean port_monitoring = FALSE;
subsys = mm_kernel_device_get_subsystem (kernel_device);
name = mm_kernel_device_get_name (kernel_device);
if (!self->priv->ports || (link_port && !self->priv->link_ports)) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Cannot add port '%s/%s', no ports table", subsys, name);
return NULL;
}
/* Check whether we already have it stored */
key = g_strdup_printf ("%s%s", subsys, name);
port = g_hash_table_lookup (self->priv->ports, key);
if (port) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Cannot add port '%s/%s', already exists", subsys, name);
return NULL;
}
/* Explicitly ignored ports, grab them but explicitly flag them as ignored
* right away, all the same way (i.e. regardless of subsystem). */
if (ptype == MM_PORT_TYPE_IGNORED)
port = base_modem_create_ignored_port (self, name);
else if (g_str_equal (subsys, "net"))
port = base_modem_create_net_port (self, name);
else if (g_str_equal (subsys, "tty"))
port = base_modem_create_tty_port (self, name, kernel_device, ptype);
else if (g_str_equal (subsys, "usbmisc"))
port = base_modem_create_usbmisc_port (self, name, ptype);
else if (g_str_equal (subsys, "rpmsg"))
port = base_modem_create_rpmsg_port (self, name, ptype);
#if defined WITH_QRTR
else if (g_str_equal (subsys, "qrtr"))
port = base_modem_create_qrtr_port (self, name, kernel_device, ptype);
#endif
else if (g_str_equal (subsys, "virtual"))
port = base_modem_create_virtual_port (self, name);
else if (g_str_equal (subsys, "wwan"))
port = base_modem_create_wwan_port (self, name, ptype);
if (!port) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Cannot add port '%s/%s', unhandled port type", subsys, name);
return NULL;
}
/* Setup consecutive ports and removal watchers in all control ports */
if (MM_IS_PORT_SERIAL_AT (port)) {
mm_obj_dbg (port, "port monitoring enabled in AT port");
port_monitoring = TRUE;
} else if (MM_IS_PORT_SERIAL_QCDM (port)) {
mm_obj_dbg (port, "port monitoring enabled in QCDM port");
port_monitoring = TRUE;
}
#if defined WITH_QMI
else if (MM_IS_PORT_QMI (port)) {
mm_obj_dbg (port, "port monitoring enabled in QMI port");
port_monitoring = TRUE;
}
#endif
#if defined WITH_MBIM
else if (MM_IS_PORT_MBIM (port)) {
mm_obj_dbg (port, "port monitoring enabled in MBIM port");
port_monitoring = TRUE;
}
#endif
if (port_monitoring) {
if (self->priv->max_timeouts > 0)
g_signal_connect (port,
MM_PORT_SIGNAL_TIMED_OUT,
G_CALLBACK (port_timed_out_cb),
self);
g_signal_connect (port,
MM_PORT_SIGNAL_REMOVED,
G_CALLBACK (port_removed_cb),
self);
}
/* Store kernel device */
g_object_set (port, MM_PORT_KERNEL_DEVICE, kernel_device, NULL);
/* Set owner ID */
mm_log_object_set_owner_id (MM_LOG_OBJECT (port), mm_log_object_get_id (MM_LOG_OBJECT (self)));
/* Common setup for all AT ports from all subsystems */
if (MM_IS_PORT_SERIAL_AT (port)) {
mm_port_serial_at_set_response_parser (MM_PORT_SERIAL_AT (port),
mm_serial_parser_v1_parse,
mm_serial_parser_v1_new (),
mm_serial_parser_v1_destroy);
/* Prefer plugin-provided flags to the generic ones */
if (at_pflags == MM_PORT_SERIAL_AT_FLAG_NONE) {
if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PRIMARY)) {
mm_obj_dbg (port, "AT port flagged as primary");
at_pflags = MM_PORT_SERIAL_AT_FLAG_PRIMARY;
} else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_SECONDARY)) {
mm_obj_dbg (port, "AT port flagged as secondary");
at_pflags = MM_PORT_SERIAL_AT_FLAG_SECONDARY;
} else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PPP)) {
mm_obj_dbg (port, "AT port flagged as PPP");
at_pflags = MM_PORT_SERIAL_AT_FLAG_PPP;
}
/* Additionally, the ports may also be flagged as GPS control explicitly, if there is
* one specific port to be used for that purpose */
if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_GPS_CONTROL)) {
mm_obj_dbg (port, "AT port flagged as GPS control");
at_pflags = MM_PORT_SERIAL_AT_FLAG_GPS_CONTROL;
}
}
/* The plugin may specify NONE_NO_GENERIC to avoid the generic
* port type hints from being applied. */
if (at_pflags == MM_PORT_SERIAL_AT_FLAG_NONE_NO_GENERIC)
at_pflags = MM_PORT_SERIAL_AT_FLAG_NONE;
mm_port_serial_at_set_flags (MM_PORT_SERIAL_AT (port), at_pflags);
}
/* Add it to the tracking HT.
* Note: 'key' and 'port' now owned by the HT. */
if (link_port)
g_hash_table_insert (self->priv->link_ports, g_steal_pointer (&key), port);
else
g_hash_table_insert (self->priv->ports, g_steal_pointer (&key), port);
return port;
}
gboolean
mm_base_modem_grab_port (MMBaseModem *self,
MMKernelDevice *kernel_device,
MMPortType ptype,
MMPortSerialAtFlag at_pflags,
GError **error)
{
if (!base_modem_internal_grab_port (self, kernel_device, FALSE, ptype, at_pflags, error))
return FALSE;
mm_obj_dbg (self, "port '%s/%s' grabbed",
mm_kernel_device_get_subsystem (kernel_device),
mm_kernel_device_get_name (kernel_device));
return TRUE;
}
/******************************************************************************/
gboolean
mm_base_modem_grab_link_port (MMBaseModem *self,
MMKernelDevice *kernel_device,
GError **error)
{
const gchar *subsystem;
const gchar *name;
MMPort *port;
/* To simplify things, we only support NET link ports at this point */
subsystem = mm_kernel_device_get_subsystem (kernel_device);
name = mm_kernel_device_get_name (kernel_device);
if (!g_str_equal (subsystem, "net")) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Cannot add port '%s/%s', unexpected link port subsystem", subsystem, name);
return FALSE;
}
/* all the newly added link ports will NOT be 'organized'; i.e. they won't
* be available as 'data ports' in the modem, but they can be looked up
* by name */
port = base_modem_internal_grab_port (self,
kernel_device,
TRUE,
MM_PORT_TYPE_NET,
MM_PORT_SERIAL_AT_FLAG_NONE,
error);
if (!port)
return FALSE;
mm_obj_dbg (self, "link port '%s/%s' grabbed", subsystem, name);
g_signal_emit (self, signals[SIGNAL_LINK_PORT_GRABBED], 0, port);
return TRUE;
}
gboolean
mm_base_modem_release_link_port (MMBaseModem *self,
const gchar *subsystem,
const gchar *name,
GError **error)
{
g_autofree gchar *key = NULL;
MMPort *port;
if (!self->priv->link_ports) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Cannot release link port '%s/%s', no link ports table", subsystem, name);
return FALSE;
}
key = g_strdup_printf ("%s%s", subsystem, name);
port = g_hash_table_lookup (self->priv->link_ports, key);
if (!port) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Cannot release link port '%s/%s', not grabbed", subsystem, name);
return FALSE;
}
/* make sure the port object is valid during the port release signal */
g_object_ref (port);
g_hash_table_remove (self->priv->link_ports, key);
mm_obj_dbg (self, "link port '%s/%s' released", subsystem, name);
g_signal_emit (self, signals[SIGNAL_LINK_PORT_RELEASED], 0, port);
g_object_unref (port);
return TRUE;
}
/******************************************************************************/
typedef struct {
gchar *name;
gulong link_port_grabbed_id;
guint timeout_id;
} WaitLinkPortContext;
static void
wait_link_port_context_free (WaitLinkPortContext *ctx)
{
g_assert (!ctx->link_port_grabbed_id);
g_assert (!ctx->timeout_id);
g_free (ctx->name);
g_slice_free (WaitLinkPortContext, ctx);
}
MMPort *
mm_base_modem_wait_link_port_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_pointer (G_TASK (res), error);
}
static gboolean
wait_link_port_timeout_cb (GTask *task)
{
WaitLinkPortContext *ctx;
MMBaseModem *self;
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
ctx->timeout_id = 0;
g_signal_handler_disconnect (self, ctx->link_port_grabbed_id);
ctx->link_port_grabbed_id = 0;
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_NOT_FOUND,
"Timed out waiting for link port 'net/%s'",
ctx->name);
g_object_unref (task);
return G_SOURCE_REMOVE;
}
static void
wait_link_port_grabbed_cb (MMBaseModem *self,
MMPort *link_port,
GTask *task)
{
WaitLinkPortContext *ctx;
MMPortSubsys link_port_subsystem;
const gchar *link_port_name;
ctx = g_task_get_task_data (task);
link_port_subsystem = mm_port_get_subsys (link_port);
link_port_name = mm_port_get_device (link_port);
if (link_port_subsystem != MM_PORT_SUBSYS_NET) {
mm_obj_warn (self, "unexpected link port subsystem grabbed: %s/%s",
mm_port_subsys_get_string (link_port_subsystem),
link_port_name);
return;
}
if (g_strcmp0 (link_port_name, ctx->name) != 0)
return;
/* we got it! */
g_source_remove (ctx->timeout_id);
ctx->timeout_id = 0;
g_signal_handler_disconnect (self, ctx->link_port_grabbed_id);
ctx->link_port_grabbed_id = 0;
g_task_return_pointer (task, g_object_ref (link_port), g_object_unref);
g_object_unref (task);
}
void
mm_base_modem_wait_link_port (MMBaseModem *self,
const gchar *subsystem,
const gchar *name,
guint timeout_ms,
GAsyncReadyCallback callback,
gpointer user_data)
{
WaitLinkPortContext *ctx;
GTask *task;
g_autofree gchar *key = NULL;
MMPort *port;
task = g_task_new (self, NULL, callback, user_data);
if (!g_str_equal (subsystem, "net")) {
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Cannot wait for port '%s/%s', unexpected link port subsystem", subsystem, name);
g_object_unref (task);
return;
}
if (!self->priv->link_ports) {
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Cannot wait for port '%s/%s', no link ports table", subsystem, name);
g_object_unref (task);
return;
}
key = g_strdup_printf ("%s%s", subsystem, name);
port = g_hash_table_lookup (self->priv->link_ports, key);
if (port) {
mm_obj_dbg (self, "no need to wait for port '%s/%s': already grabbed", subsystem, name);
g_task_return_pointer (task, g_object_ref (port), g_object_unref);
g_object_unref (task);
return;
}
ctx = g_slice_new0 (WaitLinkPortContext);
ctx->name = g_strdup (name);
g_task_set_task_data (task, ctx, (GDestroyNotify)wait_link_port_context_free);
/* task ownership shared between timeout and signal handler */
ctx->timeout_id = g_timeout_add (timeout_ms,
(GSourceFunc) wait_link_port_timeout_cb,
task);
ctx->link_port_grabbed_id = g_signal_connect (self,
MM_BASE_MODEM_SIGNAL_LINK_PORT_GRABBED,
G_CALLBACK (wait_link_port_grabbed_cb),
task);
mm_obj_dbg (self, "waiting for port '%s/%s'...", subsystem, name);
}
/******************************************************************************/
#if defined WITH_SUSPEND_RESUME
gboolean
mm_base_modem_sync_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
sync_ready (MMBaseModem *self,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!MM_BASE_MODEM_GET_CLASS (self)->sync_finish (self, res, &error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
void
mm_base_modem_sync (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (self, NULL, callback, user_data);
if (!MM_BASE_MODEM_GET_CLASS (self)->sync ||
!MM_BASE_MODEM_GET_CLASS (self)->sync_finish) {
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Suspend/resume quick synchronization unsupported");
g_object_unref (task);
return;
}
MM_BASE_MODEM_GET_CLASS (self)->sync (self,
(GAsyncReadyCallback) sync_ready,
task);
}
#endif /* WITH_SUSPEND_RESUME */
/******************************************************************************/
gboolean
mm_base_modem_disable_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
disable_ready (MMBaseModem *self,
GAsyncResult *res)
{
GError *error = NULL;
GList *l;
GList *disable_tasks;
g_assert (self->priv->disable_tasks);
disable_tasks = self->priv->disable_tasks;
self->priv->disable_tasks = NULL;
MM_BASE_MODEM_GET_CLASS (self)->disable_finish (self, res, &error);
for (l = disable_tasks; l; l = g_list_next (l)) {
if (error)
g_task_return_error (G_TASK (l->data), g_error_copy (error));
else
g_task_return_boolean (G_TASK (l->data), TRUE);
}
g_clear_error (&error);
g_list_free_full (disable_tasks, g_object_unref);
}
void
mm_base_modem_disable (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
gboolean run_disable;
g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable_finish != NULL);
/* If the list of disable tasks is empty, we need to run */
run_disable = !self->priv->disable_tasks;
/* Store task */
task = g_task_new (self, self->priv->cancellable, callback, user_data);
self->priv->disable_tasks = g_list_append (self->priv->disable_tasks, task);
if (!run_disable)
return;
MM_BASE_MODEM_GET_CLASS (self)->disable (
self,
self->priv->cancellable,
(GAsyncReadyCallback) disable_ready,
NULL);
}
gboolean
mm_base_modem_enable_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
enable_ready (MMBaseModem *self,
GAsyncResult *res)
{
GError *error = NULL;
GList *l;
GList *enable_tasks;
g_assert (self->priv->enable_tasks);
enable_tasks = self->priv->enable_tasks;
self->priv->enable_tasks = NULL;
MM_BASE_MODEM_GET_CLASS (self)->enable_finish (self, res, &error);
for (l = enable_tasks; l; l = g_list_next (l)) {
if (error)
g_task_return_error (G_TASK (l->data), g_error_copy (error));
else
g_task_return_boolean (G_TASK (l->data), TRUE);
}
g_clear_error (&error);
g_list_free_full (enable_tasks, g_object_unref);
}
void
mm_base_modem_enable (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
gboolean run_enable;
g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable_finish != NULL);
/* If the list of enable tasks is empty, we need to run */
run_enable = !self->priv->enable_tasks;
/* Store task */
task = g_task_new (self, self->priv->cancellable, callback, user_data);
self->priv->enable_tasks = g_list_append (self->priv->enable_tasks, task);
if (!run_enable)
return;
MM_BASE_MODEM_GET_CLASS (self)->enable (
self,
self->priv->cancellable,
(GAsyncReadyCallback) enable_ready,
NULL);
}
gboolean
mm_base_modem_initialize_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return MM_BASE_MODEM_GET_CLASS (self)->initialize_finish (self, res, error);
}
void
mm_base_modem_initialize (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize_finish != NULL);
MM_BASE_MODEM_GET_CLASS (self)->initialize (
self,
self->priv->cancellable,
callback,
user_data);
}
void
mm_base_modem_set_hotplugged (MMBaseModem *self,
gboolean hotplugged)
{
g_return_if_fail (MM_IS_BASE_MODEM (self));
self->priv->hotplugged = hotplugged;
}
gboolean
mm_base_modem_get_hotplugged (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE);
return self->priv->hotplugged;
}
void
mm_base_modem_set_valid (MMBaseModem *self,
gboolean new_valid)
{
g_return_if_fail (MM_IS_BASE_MODEM (self));
/* If validity changed OR if both old and new were invalid, notify. This
* last case is to cover failures during initialization. */
if (self->priv->valid != new_valid ||
!new_valid) {
self->priv->valid = new_valid;
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VALID]);
}
}
void
mm_base_modem_set_reprobe (MMBaseModem *self,
gboolean reprobe)
{
g_return_if_fail (MM_IS_BASE_MODEM (self));
self->priv->reprobe = reprobe;
}
gboolean
mm_base_modem_get_reprobe (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE);
return self->priv->reprobe;
}
gboolean
mm_base_modem_get_valid (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE);
return self->priv->valid;
}
GCancellable *
mm_base_modem_peek_cancellable (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->cancellable;
}
GCancellable *
mm_base_modem_get_cancellable (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return g_object_ref (self->priv->cancellable);
}
MMPortSerialAt *
mm_base_modem_get_port_primary (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->primary ? g_object_ref (self->priv->primary) : NULL);
}
MMPortSerialAt *
mm_base_modem_peek_port_primary (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->primary;
}
MMPortSerialAt *
mm_base_modem_get_port_secondary (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->secondary ? g_object_ref (self->priv->secondary) : NULL);
}
MMPortSerialAt *
mm_base_modem_peek_port_secondary (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->secondary;
}
MMPortSerialQcdm *
mm_base_modem_get_port_qcdm (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->qcdm ? g_object_ref (self->priv->qcdm) : NULL);
}
MMPortSerialQcdm *
mm_base_modem_peek_port_qcdm (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->qcdm;
}
MMPortSerialAt *
mm_base_modem_get_port_gps_control (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->gps_control ? g_object_ref (self->priv->gps_control) : NULL);
}
MMPortSerialAt *
mm_base_modem_peek_port_gps_control (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->gps_control;
}
MMPortSerialGps *
mm_base_modem_get_port_gps (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->gps ? g_object_ref (self->priv->gps) : NULL);
}
MMPortSerialGps *
mm_base_modem_peek_port_gps (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->gps;
}
MMPortSerial *
mm_base_modem_get_port_audio (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (self->priv->audio ? g_object_ref (self->priv->audio) : NULL);
}
MMPortSerial *
mm_base_modem_peek_port_audio (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->audio;
}
MMPort *
mm_base_modem_get_best_data_port (MMBaseModem *self,
MMPortType type)
{
MMPort *port;
port = mm_base_modem_peek_best_data_port (self, type);
return (port ? g_object_ref (port) : NULL);
}
MMPort *
mm_base_modem_peek_best_data_port (MMBaseModem *self,
MMPortType type)
{
GList *l;
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
/* Return first not-connected data port */
for (l = self->priv->data; l; l = g_list_next (l)) {
if (!mm_port_get_connected ((MMPort *)l->data) &&
(mm_port_get_port_type ((MMPort *)l->data) == type ||
type == MM_PORT_TYPE_UNKNOWN)) {
return (MMPort *)l->data;
}
}
return NULL;
}
GList *
mm_base_modem_get_data_ports (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return g_list_copy_deep (self->priv->data, (GCopyFunc)g_object_ref, NULL);
}
GList *
mm_base_modem_peek_data_ports (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->data;
}
MMPortSerialAt *
mm_base_modem_get_best_at_port (MMBaseModem *self,
GError **error)
{
MMPortSerialAt *best;
best = mm_base_modem_peek_best_at_port (self, error);
return (best ? g_object_ref (best) : NULL);
}
MMPortSerialAt *
mm_base_modem_peek_best_at_port (MMBaseModem *self,
GError **error)
{
/* Decide which port to use */
if (self->priv->primary &&
!mm_port_get_connected (MM_PORT (self->priv->primary)))
return self->priv->primary;
/* If primary port is connected, check if we can get the secondary
* port */
if (self->priv->secondary &&
!mm_port_get_connected (MM_PORT (self->priv->secondary)))
return self->priv->secondary;
/* Otherwise, we cannot get any port */
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_CONNECTED,
"No AT port available to run command");
return NULL;
}
gboolean
mm_base_modem_has_at_port (MMBaseModem *self)
{
GHashTableIter iter;
gpointer value;
gpointer key;
if (!self->priv->ports)
return FALSE;
/* We'll iterate the ht of ports, looking for any port which is AT */
g_hash_table_iter_init (&iter, self->priv->ports);
while (g_hash_table_iter_next (&iter, &key, &value)) {
if (MM_IS_PORT_SERIAL_AT (value))
return TRUE;
}
return FALSE;
}
static gint
port_info_cmp (const MMModemPortInfo *a,
const MMModemPortInfo *b)
{
/* default to alphabetical sorting on the port name */
return g_strcmp0 (a->name, b->name);
}
MMModemPortInfo *
mm_base_modem_get_port_infos (MMBaseModem *self,
guint *n_port_infos)
{
GHashTableIter iter;
GArray *port_infos;
MMPort *port;
if (!self->priv->ports) {
*n_port_infos = 0;
return NULL;
}
*n_port_infos = g_hash_table_size (self->priv->ports);
port_infos = g_array_sized_new (FALSE, FALSE, sizeof (MMModemPortInfo), *n_port_infos);
g_hash_table_iter_init (&iter, self->priv->ports);
while (g_hash_table_iter_next (&iter, NULL, (gpointer)&port)) {
MMModemPortInfo port_info;
port_info.name = g_strdup (mm_port_get_device (port));
switch (mm_port_get_port_type (port)) {
case MM_PORT_TYPE_NET:
port_info.type = MM_MODEM_PORT_TYPE_NET;
break;
case MM_PORT_TYPE_AT:
port_info.type = MM_MODEM_PORT_TYPE_AT;
break;
case MM_PORT_TYPE_QCDM:
port_info.type = MM_MODEM_PORT_TYPE_QCDM;
break;
case MM_PORT_TYPE_GPS:
port_info.type = MM_MODEM_PORT_TYPE_GPS;
break;
case MM_PORT_TYPE_AUDIO:
port_info.type = MM_MODEM_PORT_TYPE_AUDIO;
break;
case MM_PORT_TYPE_QMI:
port_info.type = MM_MODEM_PORT_TYPE_QMI;
break;
case MM_PORT_TYPE_MBIM:
port_info.type = MM_MODEM_PORT_TYPE_MBIM;
break;
case MM_PORT_TYPE_IGNORED:
port_info.type = MM_MODEM_PORT_TYPE_IGNORED;
break;
case MM_PORT_TYPE_UNKNOWN:
default:
port_info.type = MM_MODEM_PORT_TYPE_UNKNOWN;
break;
}
g_array_append_val (port_infos, port_info);
}
g_assert (*n_port_infos == port_infos->len);
g_array_sort (port_infos, (GCompareFunc) port_info_cmp);
return (MMModemPortInfo *) g_array_free (port_infos, FALSE);
}
static gint
port_cmp (MMPort *a,
MMPort *b)
{
/* default to alphabetical sorting on the port name */
return g_strcmp0 (mm_port_get_device (a), mm_port_get_device (b));
}
GList *
mm_base_modem_find_ports (MMBaseModem *self,
MMPortSubsys subsys,
MMPortType type)
{
GList *out = NULL;
GHashTableIter iter;
gpointer value;
gpointer key;
if (!self->priv->ports)
return NULL;
g_hash_table_iter_init (&iter, self->priv->ports);
while (g_hash_table_iter_next (&iter, &key, &value)) {
MMPort *port = MM_PORT (value);
if (subsys != MM_PORT_SUBSYS_UNKNOWN && mm_port_get_subsys (port) != subsys)
continue;
if (type != MM_PORT_TYPE_UNKNOWN && mm_port_get_port_type (port) != type)
continue;
out = g_list_append (out, g_object_ref (port));
}
return g_list_sort (out, (GCompareFunc) port_cmp);
}
static MMPort *
peek_port_in_ht (GHashTable *ht,
const gchar *name)
{
GHashTableIter iter;
gpointer value;
gpointer key;
if (!ht)
return NULL;
g_hash_table_iter_init (&iter, ht);
while (g_hash_table_iter_next (&iter, &key, &value)) {
MMPort *port = MM_PORT (value);
if (g_str_equal (mm_port_get_device (port), name))
return port;
}
return NULL;
}
MMPort *
mm_base_modem_peek_port (MMBaseModem *self,
const gchar *name)
{
MMPort *found;
found = peek_port_in_ht (self->priv->ports, name);
if (!found)
found = peek_port_in_ht (self->priv->link_ports, name);
return found;
}
MMPort *
mm_base_modem_get_port (MMBaseModem *self,
const gchar *name)
{
MMPort *port;
port = mm_base_modem_peek_port (self, name);
return (port ? g_object_ref (port) : NULL);
}
static void
initialize_ready (MMBaseModem *self,
GAsyncResult *res)
{
g_autoptr(GError) error = NULL;
if (!mm_base_modem_initialize_finish (self, res, &error)) {
if (g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED)) {
/* FATAL error, won't even be exported in DBus */
mm_obj_err (self, "fatal error initializing: %s", error->message);
} else {
/* non-fatal error */
mm_obj_warn (self, "error initializing: %s", error->message);
mm_base_modem_set_valid (self, TRUE);
}
} else {
mm_obj_dbg (self, "modem initialized");
mm_base_modem_set_valid (self, TRUE);
}
}
static inline void
log_port (MMBaseModem *self,
MMPort *port,
const gchar *desc)
{
if (!port)
return;
mm_obj_info (self, "%s/%s: %s",
mm_port_subsys_get_string (mm_port_get_subsys (port)),
mm_port_get_device (port),
desc);
}
gboolean
mm_base_modem_organize_ports (MMBaseModem *self,
GError **error)
{
GHashTableIter iter;
MMPort *candidate;
MMPortSerialAtFlag flags;
MMPortSerialAt *backup_primary = NULL;
MMPortSerialAt *primary = NULL;
MMPortSerialAt *secondary = NULL;
MMPortSerialAt *backup_secondary = NULL;
MMPortSerialQcdm *qcdm = NULL;
MMPortSerialAt *gps_control = NULL;
MMPortSerialGps *gps = NULL;
MMPortSerial *audio = NULL;
MMPortSerialAt *data_at_primary = NULL;
GList *l;
/* These lists don't keep full references, so they should be
* g_list_free()-ed on error exits */
g_autoptr(GList) data_at = NULL;
g_autoptr(GList) data_net = NULL;
#if defined WITH_QMI
g_autoptr(GList) qmi = NULL;
#endif
#if defined WITH_MBIM
g_autoptr(GList) mbim = NULL;
#endif
g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE);
/* If ports have already been organized, just return success */
if (self->priv->primary)
return TRUE;
/* Ports table is created on init and removed on dispose(), not on
* finalize(), so there is a chance this may happen */
if (!self->priv->ports) {
g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No ports table");
return FALSE;
}
g_hash_table_iter_init (&iter, self->priv->ports);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &candidate)) {
switch (mm_port_get_port_type (candidate)) {
case MM_PORT_TYPE_AT:
g_assert (MM_IS_PORT_SERIAL_AT (candidate));
flags = mm_port_serial_at_get_flags (MM_PORT_SERIAL_AT (candidate));
if (flags & MM_PORT_SERIAL_AT_FLAG_PRIMARY) {
if (!primary)
primary = MM_PORT_SERIAL_AT (candidate);
else if (!backup_primary) {
/* Just in case the plugin gave us more than one primary
* and no secondaries, treat additional primary ports as
* secondary.
*/
backup_primary = MM_PORT_SERIAL_AT (candidate);
}
}
if (flags & MM_PORT_SERIAL_AT_FLAG_PPP) {
if (!data_at_primary)
data_at_primary = MM_PORT_SERIAL_AT (candidate);
else
data_at = g_list_append (data_at, candidate);
}
/* Explicitly flagged secondary ports trump NONE ports for secondary */
if (flags & MM_PORT_SERIAL_AT_FLAG_SECONDARY) {
if (!secondary || !(mm_port_serial_at_get_flags (secondary) & MM_PORT_SERIAL_AT_FLAG_SECONDARY))
secondary = MM_PORT_SERIAL_AT (candidate);
}
if (flags & MM_PORT_SERIAL_AT_FLAG_GPS_CONTROL) {
if (!gps_control)
gps_control = MM_PORT_SERIAL_AT (candidate);
}
/* Fallback secondary */
if (flags == MM_PORT_SERIAL_AT_FLAG_NONE) {
if (!secondary)
secondary = MM_PORT_SERIAL_AT (candidate);
else if (!backup_secondary)
backup_secondary = MM_PORT_SERIAL_AT (candidate);
}
break;
case MM_PORT_TYPE_QCDM:
g_assert (MM_IS_PORT_SERIAL_QCDM (candidate));
if (!qcdm)
qcdm = MM_PORT_SERIAL_QCDM (candidate);
break;
case MM_PORT_TYPE_NET:
data_net = g_list_append (data_net, candidate);
break;
case MM_PORT_TYPE_GPS:
g_assert (MM_IS_PORT_SERIAL_GPS (candidate));
if (!gps)
gps = MM_PORT_SERIAL_GPS (candidate);
break;
case MM_PORT_TYPE_AUDIO:
g_assert (MM_IS_PORT_SERIAL (candidate));
if (!audio)
audio = MM_PORT_SERIAL (candidate);
break;
#if defined WITH_QMI
case MM_PORT_TYPE_QMI:
qmi = g_list_append (qmi, candidate);
break;
#endif
#if defined WITH_MBIM
case MM_PORT_TYPE_MBIM:
mbim = g_list_append (mbim, candidate);
break;
#endif
case MM_PORT_TYPE_UNKNOWN:
case MM_PORT_TYPE_IGNORED:
#if !defined WITH_MBIM
case MM_PORT_TYPE_MBIM:
#endif
#if !defined WITH_QMI
case MM_PORT_TYPE_QMI:
#endif
default:
/* Ignore port */
break;
}
}
if (!primary) {
/* Fall back to a secondary port if we didn't find a primary port */
if (secondary) {
primary = secondary;
secondary = NULL;
}
/* Fallback to a data port if no primary or secondary */
else if (data_at_primary) {
primary = data_at_primary;
data_at_primary = NULL;
}
else {
gboolean allow_modem_without_at_port = FALSE;
#if defined WITH_QMI
if (qmi)
allow_modem_without_at_port = TRUE;
#endif
#if defined WITH_MBIM
if (mbim)
allow_modem_without_at_port = TRUE;
#endif
if (!allow_modem_without_at_port) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to find primary AT port");
return FALSE;
}
}
}
/* If the plugin didn't give us any secondary ports, use any additional
* primary ports or backup secondary ports as secondary.
*/
if (!secondary)
secondary = backup_primary ? backup_primary : backup_secondary;
#if defined WITH_QMI
/* On QMI-based modems, we need to have at least a net port */
if (qmi && !data_net) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to find a net port in the QMI modem");
return FALSE;
}
#endif
#if defined WITH_MBIM
/* On MBIM-based modems, we need to have at least a net port */
if (mbim && !data_net) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to find a net port in the MBIM modem");
return FALSE;
}
#endif
/* Data port defaults to primary AT port */
if (primary && !data_at_primary)
data_at_primary = primary;
/* Reset flags on all ports; clear data port first since it might also
* be the primary or secondary port.
*/
if (data_at_primary)
mm_port_serial_at_set_flags (data_at_primary, MM_PORT_SERIAL_AT_FLAG_NONE);
if (primary)
mm_port_serial_at_set_flags (primary, MM_PORT_SERIAL_AT_FLAG_PRIMARY);
if (secondary)
mm_port_serial_at_set_flags (secondary, MM_PORT_SERIAL_AT_FLAG_SECONDARY);
if (data_at_primary) {
flags = mm_port_serial_at_get_flags (data_at_primary);
mm_port_serial_at_set_flags (data_at_primary, flags | MM_PORT_SERIAL_AT_FLAG_PPP);
}
/* sort ports by name */
#if defined WITH_QMI
qmi = g_list_sort (qmi, (GCompareFunc) port_cmp);
#endif
#if defined WITH_MBIM
mbim = g_list_sort (mbim, (GCompareFunc) port_cmp);
#endif
data_net = g_list_sort (data_net, (GCompareFunc) port_cmp);
data_at = g_list_sort (data_at, (GCompareFunc) port_cmp);
log_port (self, MM_PORT (primary), "at (primary)");
log_port (self, MM_PORT (secondary), "at (secondary)");
log_port (self, MM_PORT (data_at_primary), "at (data primary)");
for (l = data_at; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "at (data secondary)");
for (l = data_net; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "net (data)");
log_port (self, MM_PORT (qcdm), "qcdm");
log_port (self, MM_PORT (gps_control), "gps (control)");
log_port (self, MM_PORT (gps), "gps (nmea)");
log_port (self, MM_PORT (audio), "audio");
#if defined WITH_QMI
for (l = qmi; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "qmi");
#endif
#if defined WITH_MBIM
for (l = mbim; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "mbim");
#endif
/* We keep new refs to the objects here */
self->priv->primary = (primary ? g_object_ref (primary) : NULL);
self->priv->secondary = (secondary ? g_object_ref (secondary) : NULL);
self->priv->qcdm = (qcdm ? g_object_ref (qcdm) : NULL);
self->priv->gps_control = (gps_control ? g_object_ref (gps_control) : NULL);
self->priv->gps = (gps ? g_object_ref (gps) : NULL);
/* Append net ports to the final list of data ports, but only if the modem
* supports them */
if (data_net) {
if (self->priv->data_net_supported) {
g_list_foreach (data_net, (GFunc)g_object_ref, NULL);
self->priv->data = g_list_concat (self->priv->data, g_steal_pointer (&data_net));
} else
mm_obj_dbg (self, "net ports available but ignored");
}
/* Append tty ports to the final list of data ports, but only if the modem
* supports them */
if (data_at_primary || data_at) {
if (self->priv->data_tty_supported) {
if (data_at_primary)
self->priv->data = g_list_append (self->priv->data, g_object_ref (data_at_primary));
if (data_at) {
g_list_foreach (data_at, (GFunc)g_object_ref, NULL);
self->priv->data = g_list_concat (self->priv->data, g_steal_pointer (&data_at));
}
} else
mm_obj_dbg (self, "at data ports available but ignored");
}
/* Fail if we haven't added any single data port; this is probably a plugin
* misconfiguration */
if (!self->priv->data) {
g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Failed to find a data port in the modem");
return FALSE;
}
#if defined WITH_QMI
if (qmi) {
/* The first item in the data list must be a net port, because
* QMI modems only expect net ports */
g_assert (MM_IS_PORT_NET (self->priv->data->data));
/* let the MMPortQmi know which net driver is being used, taken
* from the first item in the net port list */
g_list_foreach (qmi,
(GFunc)mm_port_qmi_set_net_driver,
(gpointer) mm_kernel_device_get_driver (
mm_port_peek_kernel_device (
MM_PORT (self->priv->data->data))));
g_list_foreach (qmi,
(GFunc)mm_port_qmi_set_net_sysfs_path,
(gpointer) mm_kernel_device_get_sysfs_path (
mm_port_peek_kernel_device (
MM_PORT (self->priv->data->data))));
g_list_foreach (qmi, (GFunc)g_object_ref, NULL);
self->priv->qmi = g_steal_pointer (&qmi);
}
#endif
#if defined WITH_MBIM
if (mbim) {
g_list_foreach (mbim, (GFunc)g_object_ref, NULL);
self->priv->mbim = g_steal_pointer (&mbim);
}
#endif
/* As soon as we get the ports organized, we initialize the modem */
mm_base_modem_initialize (self,
(GAsyncReadyCallback)initialize_ready,
NULL);
return TRUE;
}
/*****************************************************************************/
/* Authorization */
gboolean
mm_base_modem_authorize_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
authorize_ready (MMAuthProvider *authp,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!mm_auth_provider_authorize_finish (authp, res, &error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
void
mm_base_modem_authorize (MMBaseModem *self,
GDBusMethodInvocation *invocation,
const gchar *authorization,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (self, self->priv->authp_cancellable, callback, user_data);
/* When running in the session bus for tests, default to always allow */
if (mm_context_get_test_session ()) {
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
mm_auth_provider_authorize (self->priv->authp,
invocation,
authorization,
self->priv->authp_cancellable,
(GAsyncReadyCallback)authorize_ready,
task);
}
/*****************************************************************************/
const gchar *
mm_base_modem_get_device (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->device;
}
const gchar **
mm_base_modem_get_drivers (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return (const gchar **)self->priv->drivers;
}
const gchar *
mm_base_modem_get_plugin (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL);
return self->priv->plugin;
}
guint
mm_base_modem_get_vendor_id (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0);
return self->priv->vendor_id;
}
guint
mm_base_modem_get_product_id (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0);
return self->priv->product_id;
}
guint
mm_base_modem_get_subsystem_vendor_id (MMBaseModem *self)
{
g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0);
return self->priv->subsystem_vendor_id;
}
/*****************************************************************************/
static gboolean
base_modem_invalid_idle (MMBaseModem *self)
{
/* Ensure the modem is set invalid if we get the modem-wide cancellable
* cancelled */
mm_base_modem_set_valid (self, FALSE);
g_object_unref (self);
return G_SOURCE_REMOVE;
}
static void
base_modem_cancelled (GCancellable *cancellable,
MMBaseModem *self)
{
/* NOTE: Don't call set_valid() directly here, do it in an idle, and ensure
* that we pass a valid reference of the modem object as context. */
g_idle_add ((GSourceFunc)base_modem_invalid_idle, g_object_ref (self));
}
/*****************************************************************************/
static void
setup_ports_table (GHashTable **ht)
{
g_assert (ht && !*ht);
*ht = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
}
static void
cleanup_modem_port (MMBaseModem *self,
MMPort *port)
{
mm_obj_dbg (self, "cleaning up port '%s/%s'...",
mm_port_subsys_get_string (mm_port_get_subsys (MM_PORT (port))),
mm_port_get_device (MM_PORT (port)));
/* Cleanup on all control ports */
g_signal_handlers_disconnect_by_func (port, port_timed_out_cb, self);
g_signal_handlers_disconnect_by_func (port, port_removed_cb, self);
#if defined WITH_MBIM
/* We need to close the MBIM port cleanly when disposing the modem object */
if (MM_IS_PORT_MBIM (port)) {
mm_port_mbim_close (MM_PORT_MBIM (port), NULL, NULL);
return;
}
#endif
#if defined WITH_QMI
/* We need to close the QMI port cleanly when disposing the modem object,
* otherwise the allocated CIDs will be kept allocated, and if we end up
* allocating too many newer allocations will fail with client-ids-exhausted
* errors. */
if (MM_IS_PORT_QMI (port)) {
mm_port_qmi_close (MM_PORT_QMI (port), NULL, NULL);
return;
}
#endif
}
static void
teardown_ports_table (MMBaseModem *self,
GHashTable **ht)
{
GHashTableIter iter;
gpointer value;
gpointer key;
if (!*ht)
return;
g_hash_table_iter_init (&iter, *ht);
while (g_hash_table_iter_next (&iter, &key, &value))
cleanup_modem_port (self, MM_PORT (value));
g_hash_table_destroy (g_steal_pointer (ht));
}
/*****************************************************************************/
static gchar *
log_object_build_id (MMLogObject *_self)
{
MMBaseModem *self;
self = MM_BASE_MODEM (_self);
return g_strdup_printf ("modem%u", self->priv->dbus_id);
}
/*****************************************************************************/
static void
mm_base_modem_init (MMBaseModem *self)
{
static guint id = 0;
/* Initialize private data */
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
MM_TYPE_BASE_MODEM,
MMBaseModemPrivate);
/* Each modem is given a unique id to build its own DBus path */
self->priv->dbus_id = id++;
/* Setup authorization provider */
self->priv->authp = mm_auth_provider_get ();
self->priv->authp_cancellable = g_cancellable_new ();
/* Setup modem-wide cancellable */
self->priv->cancellable = g_cancellable_new ();
self->priv->invalid_if_cancelled =
g_cancellable_connect (self->priv->cancellable,
G_CALLBACK (base_modem_cancelled),
self,
NULL);
self->priv->max_timeouts = DEFAULT_MAX_TIMEOUTS;
setup_ports_table (&self->priv->ports);
setup_ports_table (&self->priv->link_ports);
}
static void
set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MMBaseModem *self = MM_BASE_MODEM (object);
switch (prop_id) {
case PROP_VALID:
mm_base_modem_set_valid (self, g_value_get_boolean (value));
break;
case PROP_REPROBE:
mm_base_modem_set_reprobe (self, g_value_get_boolean (value));
break;
case PROP_MAX_TIMEOUTS:
self->priv->max_timeouts = g_value_get_uint (value);
break;
case PROP_DEVICE:
g_free (self->priv->device);
self->priv->device = g_value_dup_string (value);
break;
case PROP_DRIVERS:
g_strfreev (self->priv->drivers);
self->priv->drivers = g_value_dup_boxed (value);
break;
case PROP_PLUGIN:
g_free (self->priv->plugin);
self->priv->plugin = g_value_dup_string (value);
break;
case PROP_VENDOR_ID:
self->priv->vendor_id = g_value_get_uint (value);
break;
case PROP_PRODUCT_ID:
self->priv->product_id = g_value_get_uint (value);
break;
case PROP_SUBSYSTEM_VENDOR_ID:
self->priv->subsystem_vendor_id = g_value_get_uint (value);
break;
case PROP_CONNECTION:
g_clear_object (&self->priv->connection);
self->priv->connection = g_value_dup_object (value);
break;
case PROP_DATA_NET_SUPPORTED:
self->priv->data_net_supported = g_value_get_boolean (value);
break;
case PROP_DATA_TTY_SUPPORTED:
self->priv->data_tty_supported = g_value_get_boolean (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)
{
MMBaseModem *self = MM_BASE_MODEM (object);
switch (prop_id) {
case PROP_VALID:
g_value_set_boolean (value, self->priv->valid);
break;
case PROP_REPROBE:
g_value_set_boolean (value, self->priv->reprobe);
break;
case PROP_MAX_TIMEOUTS:
g_value_set_uint (value, self->priv->max_timeouts);
break;
case PROP_DEVICE:
g_value_set_string (value, self->priv->device);
break;
case PROP_DRIVERS:
g_value_set_boxed (value, self->priv->drivers);
break;
case PROP_PLUGIN:
g_value_set_string (value, self->priv->plugin);
break;
case PROP_VENDOR_ID:
g_value_set_uint (value, self->priv->vendor_id);
break;
case PROP_PRODUCT_ID:
g_value_set_uint (value, self->priv->product_id);
break;
case PROP_SUBSYSTEM_VENDOR_ID:
g_value_set_uint (value, self->priv->subsystem_vendor_id);
break;
case PROP_CONNECTION:
g_value_set_object (value, self->priv->connection);
break;
case PROP_DATA_NET_SUPPORTED:
g_value_set_boolean (value, self->priv->data_net_supported);
break;
case PROP_DATA_TTY_SUPPORTED:
g_value_set_boolean (value, self->priv->data_tty_supported);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
finalize (GObject *object)
{
MMBaseModem *self = MM_BASE_MODEM (object);
/* TODO
* mm_auth_provider_cancel_for_owner (self->priv->authp, object);
*/
g_assert (!self->priv->enable_tasks);
g_assert (!self->priv->disable_tasks);
mm_obj_dbg (self, "completely disposed");
g_free (self->priv->device);
g_strfreev (self->priv->drivers);
g_free (self->priv->plugin);
G_OBJECT_CLASS (mm_base_modem_parent_class)->finalize (object);
}
static void
dispose (GObject *object)
{
MMBaseModem *self = MM_BASE_MODEM (object);
/* Cancel all ongoing auth requests */
g_cancellable_cancel (self->priv->authp_cancellable);
g_clear_object (&self->priv->authp_cancellable);
/* note: authp is a singleton, we don't keep a full reference */
/* Ensure we cancel any ongoing operation, but before
* disconnect our own signal handler, or we'll end up with
* another reference of the modem object around. */
g_cancellable_disconnect (self->priv->cancellable,
self->priv->invalid_if_cancelled);
g_cancellable_cancel (self->priv->cancellable);
g_clear_object (&self->priv->cancellable);
g_clear_object (&self->priv->primary);
g_clear_object (&self->priv->secondary);
g_list_free_full (g_steal_pointer (&self->priv->data), g_object_unref);
g_clear_object (&self->priv->qcdm);
g_clear_object (&self->priv->gps_control);
g_clear_object (&self->priv->gps);
g_clear_object (&self->priv->audio);
#if defined WITH_QMI
g_list_free_full (g_steal_pointer (&self->priv->qmi), g_object_unref);
#endif
#if defined WITH_MBIM
g_list_free_full (g_steal_pointer (&self->priv->mbim), g_object_unref);
#endif
teardown_ports_table (self, &self->priv->link_ports);
teardown_ports_table (self, &self->priv->ports);
g_clear_object (&self->priv->connection);
G_OBJECT_CLASS (mm_base_modem_parent_class)->dispose (object);
}
static void
log_object_iface_init (MMLogObjectInterface *iface)
{
iface->build_id = log_object_build_id;
}
static void
mm_base_modem_class_init (MMBaseModemClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (object_class, sizeof (MMBaseModemPrivate));
/* Virtual methods */
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->finalize = finalize;
object_class->dispose = dispose;
properties[PROP_MAX_TIMEOUTS] =
g_param_spec_uint (MM_BASE_MODEM_MAX_TIMEOUTS,
"Max timeouts",
"Maximum number of consecutive timed out commands sent to "
"the modem before disabling it. If 0, this feature is disabled.",
0, G_MAXUINT, DEFAULT_MAX_TIMEOUTS,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_MAX_TIMEOUTS, properties[PROP_MAX_TIMEOUTS]);
properties[PROP_VALID] =
g_param_spec_boolean (MM_BASE_MODEM_VALID,
"Valid",
"Whether the modem is to be considered valid or not.",
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_VALID, properties[PROP_VALID]);
properties[PROP_DEVICE] =
g_param_spec_string (MM_BASE_MODEM_DEVICE,
"Device",
"Main modem parent device of all the modem's ports",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_DEVICE, properties[PROP_DEVICE]);
properties[PROP_DRIVERS] =
g_param_spec_boxed (MM_BASE_MODEM_DRIVERS,
"Drivers",
"Kernel drivers",
G_TYPE_STRV,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_DRIVERS, properties[PROP_DRIVERS]);
properties[PROP_PLUGIN] =
g_param_spec_string (MM_BASE_MODEM_PLUGIN,
"Plugin",
"Name of the plugin managing this modem",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_PLUGIN, properties[PROP_PLUGIN]);
properties[PROP_VENDOR_ID] =
g_param_spec_uint (MM_BASE_MODEM_VENDOR_ID,
"Hardware vendor ID",
"Hardware vendor ID. May be unknown for serial devices.",
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_VENDOR_ID, properties[PROP_VENDOR_ID]);
properties[PROP_PRODUCT_ID] =
g_param_spec_uint (MM_BASE_MODEM_PRODUCT_ID,
"Hardware product ID",
"Hardware product ID. May be unknown for serial devices.",
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_PRODUCT_ID, properties[PROP_PRODUCT_ID]);
properties[PROP_SUBSYSTEM_VENDOR_ID] =
g_param_spec_uint (MM_BASE_MODEM_SUBSYSTEM_VENDOR_ID,
"Hardware subsystem vendor ID",
"Hardware subsystem vendor ID. Available for pci devices.",
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_property (object_class, PROP_SUBSYSTEM_VENDOR_ID, properties[PROP_SUBSYSTEM_VENDOR_ID]);
properties[PROP_CONNECTION] =
g_param_spec_object (MM_BASE_MODEM_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_REPROBE] =
g_param_spec_boolean (MM_BASE_MODEM_REPROBE,
"Reprobe",
"Whether the modem needs to be reprobed or not.",
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_REPROBE, properties[PROP_REPROBE]);
properties[PROP_DATA_NET_SUPPORTED] =
g_param_spec_boolean (MM_BASE_MODEM_DATA_NET_SUPPORTED,
"Data NET supported",
"Whether the modem supports connection via a NET port.",
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_DATA_NET_SUPPORTED, properties[PROP_DATA_NET_SUPPORTED]);
properties[PROP_DATA_TTY_SUPPORTED] =
g_param_spec_boolean (MM_BASE_MODEM_DATA_TTY_SUPPORTED,
"Data TTY supported",
"Whether the modem supports connection via a TTY port.",
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_DATA_TTY_SUPPORTED, properties[PROP_DATA_TTY_SUPPORTED]);
signals[SIGNAL_LINK_PORT_GRABBED] =
g_signal_new (MM_BASE_MODEM_SIGNAL_LINK_PORT_GRABBED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MMBaseModemClass, link_port_grabbed),
NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE, 1, MM_TYPE_PORT);
signals[SIGNAL_LINK_PORT_RELEASED] =
g_signal_new (MM_BASE_MODEM_SIGNAL_LINK_PORT_RELEASED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MMBaseModemClass, link_port_released),
NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE, 1, MM_TYPE_PORT);
}
Reference in New Issue View Git Blame Copy Permalink