Files
ModemManager/plugins/mm-modem-hso.c
Dan Williams e3c87e4e14 hso: clean up connect and disconnect
Disconnect didn't actually work for HSO since it overrode the parent
class's connect handler and thus didn't set the right state after
the connection was made.  It turns out we can use the same logic
that 'mbm' does for connection and not have to override quite so
much of the parent class.

This also splits the authentication and connection parts into two
distinct stages, which wasn't the case before but was what was
intended.
2010-03-10 14:42:53 -08:00

743 lines
22 KiB
C

/* -*- 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 Red Hat, Inc.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <dbus/dbus-glib.h>
#define G_UDEV_API_IS_SUBJECT_TO_CHANGE
#include <gudev/gudev.h>
#include "mm-modem-hso.h"
#include "mm-modem-simple.h"
#include "mm-serial-parsers.h"
#include "mm-errors.h"
#include "mm-callback-info.h"
static void impl_hso_authenticate (MMModemHso *self,
const char *username,
const char *password,
DBusGMethodInvocation *context);
#include "mm-modem-gsm-hso-glue.h"
static void modem_init (MMModem *modem_class);
static void modem_simple_init (MMModemSimple *simple_class);
G_DEFINE_TYPE_EXTENDED (MMModemHso, mm_modem_hso, MM_TYPE_GENERIC_GSM, 0,
G_IMPLEMENT_INTERFACE (MM_TYPE_MODEM, modem_init)
G_IMPLEMENT_INTERFACE (MM_TYPE_MODEM_SIMPLE, modem_simple_init))
#define MM_MODEM_HSO_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_MODEM_HSO, MMModemHsoPrivate))
static void _internal_hso_modem_authenticate (MMModemHso *self, MMCallbackInfo *info);
const char *auth_commands[] = {
"$QCPDPP",
/* Icera-based devices (GI0322/Quicksilver, iCON 505) don't implement
* $QCPDPP, but instead use _OPDPP with the same arguments.
*/
"_OPDPP",
NULL
};
typedef struct {
/* Pending connection attempt */
MMCallbackInfo *connect_pending_data;
guint connect_pending_id;
char *username;
char *password;
guint32 auth_idx;
} MMModemHsoPrivate;
#define OWANDATA_TAG "_OWANDATA: "
MMModem *
mm_modem_hso_new (const char *device,
const char *driver,
const char *plugin)
{
g_return_val_if_fail (device != NULL, NULL);
g_return_val_if_fail (driver != NULL, NULL);
g_return_val_if_fail (plugin != NULL, NULL);
return MM_MODEM (g_object_new (MM_TYPE_MODEM_HSO,
MM_MODEM_MASTER_DEVICE, device,
MM_MODEM_DRIVER, driver,
MM_MODEM_PLUGIN, plugin,
MM_MODEM_IP_METHOD, MM_MODEM_IP_METHOD_STATIC,
NULL));
}
/*****************************************************************************/
static gint
hso_get_cid (MMModemHso *self)
{
gint cid;
cid = mm_generic_gsm_get_cid (MM_GENERIC_GSM (self));
if (cid < 0) {
g_warn_if_fail (cid >= 0);
cid = 0;
}
return cid;
}
static void
auth_done (MMSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
MMModemHso *self = MM_MODEM_HSO (info->modem);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
if (error) {
priv->auth_idx++;
if (auth_commands[priv->auth_idx]) {
/* Try the next auth command */
_internal_hso_modem_authenticate (self, info);
return;
} else
info->error = g_error_copy (error);
}
/* Reset to 0 so something gets tried the next connection */
priv->auth_idx = 0;
mm_callback_info_schedule (info);
}
static void
_internal_hso_modem_authenticate (MMModemHso *self, MMCallbackInfo *info)
{
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
MMSerialPort *primary;
gint cid;
char *command;
primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
g_assert (primary);
cid = hso_get_cid (self);
if (!priv->username && !priv->password)
command = g_strdup_printf ("%s=%d,0", auth_commands[priv->auth_idx], cid);
else {
command = g_strdup_printf ("%s=%d,1,\"%s\",\"%s\"",
auth_commands[priv->auth_idx],
cid,
priv->password ? priv->password : "",
priv->username ? priv->username : "");
}
mm_serial_port_queue_command (primary, command, 3, auth_done, info);
g_free (command);
}
void
mm_hso_modem_authenticate (MMModemHso *self,
const char *username,
const char *password,
MMModemFn callback,
gpointer user_data)
{
MMModemHsoPrivate *priv;
MMCallbackInfo *info;
g_return_if_fail (self != NULL);
g_return_if_fail (MM_IS_MODEM_HSO (self));
g_return_if_fail (callback != NULL);
info = mm_callback_info_new (MM_MODEM (self), callback, user_data);
priv = MM_MODEM_HSO_GET_PRIVATE (self);
g_free (priv->username);
priv->username = (username && strlen (username)) ? g_strdup (username) : NULL;
g_free (priv->password);
priv->password = (password && strlen (password)) ? g_strdup (password) : NULL;
_internal_hso_modem_authenticate (self, info);
}
/*****************************************************************************/
static void
connect_pending_done (MMModemHso *self)
{
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
GError *error = NULL;
if (priv->connect_pending_data) {
if (priv->connect_pending_data->error) {
error = priv->connect_pending_data->error;
priv->connect_pending_data->error = NULL;
}
/* Complete the connect */
mm_generic_gsm_connect_complete (MM_GENERIC_GSM (self), error, priv->connect_pending_data);
priv->connect_pending_data = NULL;
}
if (priv->connect_pending_id) {
g_source_remove (priv->connect_pending_id);
priv->connect_pending_id = 0;
}
}
static void
connection_enabled (MMSerialPort *port,
GMatchInfo *match_info,
gpointer user_data)
{
MMModemHso *self = MM_MODEM_HSO (user_data);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
char *str;
str = g_match_info_fetch (match_info, 2);
if (str[0] == '1')
connect_pending_done (self);
else if (str[0] == '3') {
MMCallbackInfo *info = priv->connect_pending_data;
if (info) {
info->error = g_error_new_literal (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Call setup failed");
}
connect_pending_done (self);
} else if (str[0] == '0') {
/* FIXME: disconnected. do something when we have modem status signals */
}
g_free (str);
}
/*****************************************************************************/
#define IGNORE_ERRORS_TAG "ignore-errors"
static void
hso_call_control_done (MMSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
if (error && !mm_callback_info_get_data (info, IGNORE_ERRORS_TAG))
info->error = g_error_copy (error);
mm_callback_info_schedule (info);
}
static void
hso_call_control (MMModemHso *self,
gboolean activate,
gboolean ignore_errors,
MMModemFn callback,
gpointer user_data)
{
MMCallbackInfo *info;
char *command;
MMSerialPort *primary;
info = mm_callback_info_new (MM_MODEM (self), callback, user_data);
mm_callback_info_set_data (info, IGNORE_ERRORS_TAG, GUINT_TO_POINTER (ignore_errors), NULL);
command = g_strdup_printf ("AT_OWANCALL=%d,%d,1", hso_get_cid (self), activate ? 1 : 0);
primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (self), MM_PORT_TYPE_PRIMARY);
g_assert (primary);
mm_serial_port_queue_command (primary, command, 3, hso_call_control_done, info);
g_free (command);
}
static void
timeout_done (MMModem *modem,
GError *error,
gpointer user_data)
{
if (modem)
connect_pending_done (MM_MODEM_HSO (modem));
}
static gboolean
hso_connect_timed_out (gpointer data)
{
MMModemHso *self = MM_MODEM_HSO (data);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
MMCallbackInfo *info = priv->connect_pending_data;
priv->connect_pending_id = 0;
if (info) {
info->error = g_error_new_literal (MM_SERIAL_ERROR,
MM_SERIAL_RESPONSE_TIMEOUT,
"Connection timed out");
}
hso_call_control (self, FALSE, TRUE, timeout_done, self);
return FALSE;
}
static void
hso_enabled (MMModem *modem,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
GError *tmp_error;
tmp_error = mm_modem_check_removed (modem, error);
if (tmp_error) {
mm_generic_gsm_connect_complete (MM_GENERIC_GSM (modem), tmp_error, info);
g_clear_error (&tmp_error);
} else {
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (modem);
priv->connect_pending_data = info;
priv->connect_pending_id = g_timeout_add_seconds (30, hso_connect_timed_out, modem);
}
}
static void
old_context_clear_done (MMModem *modem,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
GError *tmp_error;
tmp_error = mm_modem_check_removed (modem, error);
if (tmp_error) {
mm_generic_gsm_connect_complete (MM_GENERIC_GSM (modem), tmp_error, info);
g_clear_error (&tmp_error);
} else {
/* Success, activate the PDP context and start the data session */
hso_call_control (MM_MODEM_HSO (modem), TRUE, FALSE, hso_enabled, info);
}
}
static void
connect_auth_done (MMModem *modem,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
GError *tmp_error;
tmp_error = mm_modem_check_removed (modem, error);
if (tmp_error) {
mm_generic_gsm_connect_complete (MM_GENERIC_GSM (modem), tmp_error, info);
g_clear_error (&tmp_error);
} else {
/* Now connect; kill any existing connections first */
hso_call_control (MM_MODEM_HSO (modem), FALSE, TRUE, old_context_clear_done, info);
}
}
static void
do_connect (MMModem *modem,
const char *number,
MMModemFn callback,
gpointer user_data)
{
MMModemHso *self = MM_MODEM_HSO (modem);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
MMCallbackInfo *info;
mm_modem_set_state (modem, MM_MODEM_STATE_CONNECTING, MM_MODEM_STATE_REASON_NONE);
info = mm_callback_info_new (modem, callback, user_data);
mm_hso_modem_authenticate (self, priv->username, priv->password, connect_auth_done, info);
}
/*****************************************************************************/
static void
parent_disable_done (MMModem *modem, GError *error, gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
if (error)
info->error = g_error_copy (error);
mm_callback_info_schedule (info);
}
static void
disable_done (MMModem *modem,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
MMModem *parent_modem_iface;
/* Do the normal disable stuff */
parent_modem_iface = g_type_interface_peek_parent (MM_MODEM_GET_INTERFACE (info->modem));
parent_modem_iface->disable (info->modem, parent_disable_done, info);
}
static void
disable (MMModem *modem,
MMModemFn callback,
gpointer user_data)
{
MMModemHso *self = MM_MODEM_HSO (modem);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
MMCallbackInfo *info;
mm_generic_gsm_pending_registration_stop (MM_GENERIC_GSM (self));
g_free (priv->username);
priv->username = NULL;
g_free (priv->password);
priv->password = NULL;
info = mm_callback_info_new (modem, callback, user_data);
/* Kill any existing connection */
hso_call_control (MM_MODEM_HSO (modem), FALSE, TRUE, disable_done, info);
}
/*****************************************************************************/
static void
free_dns_array (gpointer data)
{
g_array_free ((GArray *) data, TRUE);
}
static void
ip4_config_invoke (MMCallbackInfo *info)
{
MMModemIp4Fn callback = (MMModemIp4Fn) info->callback;
callback (info->modem,
GPOINTER_TO_UINT (mm_callback_info_get_data (info, "ip4-address")),
(GArray *) mm_callback_info_get_data (info, "ip4-dns"),
info->error, info->user_data);
}
static void
get_ip4_config_done (MMSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
char **items, **iter;
GArray *dns_array;
int i;
guint32 tmp;
gint cid;
if (error) {
info->error = g_error_copy (error);
goto out;
} else if (!g_str_has_prefix (response->str, OWANDATA_TAG)) {
info->error = g_error_new_literal (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Retrieving failed: invalid response.");
goto out;
}
cid = hso_get_cid (MM_MODEM_HSO (info->modem));
dns_array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 2);
items = g_strsplit (response->str + strlen (OWANDATA_TAG), ", ", 0);
for (iter = items, i = 0; *iter; iter++, i++) {
if (i == 0) { /* CID */
long int num;
errno = 0;
num = strtol (*iter, NULL, 10);
if (errno != 0 || num < 0 || (gint) num != cid) {
info->error = g_error_new (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Unknown CID in OWANDATA response ("
"got %d, expected %d)", (guint) num, cid);
break;
}
} else if (i == 1) { /* IP address */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
mm_callback_info_set_data (info, "ip4-address", GUINT_TO_POINTER (tmp), NULL);
} else if (i == 3) { /* DNS 1 */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
g_array_append_val (dns_array, tmp);
} else if (i == 4) { /* DNS 2 */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
g_array_append_val (dns_array, tmp);
}
}
g_strfreev (items);
mm_callback_info_set_data (info, "ip4-dns", dns_array, free_dns_array);
out:
mm_callback_info_schedule (info);
}
static void
get_ip4_config (MMModem *modem,
MMModemIp4Fn callback,
gpointer user_data)
{
MMCallbackInfo *info;
char *command;
MMSerialPort *primary;
info = mm_callback_info_new_full (modem, ip4_config_invoke, G_CALLBACK (callback), user_data);
command = g_strdup_printf ("AT_OWANDATA=%d", hso_get_cid (MM_MODEM_HSO (modem)));
primary = mm_generic_gsm_get_port (MM_GENERIC_GSM (modem), MM_PORT_TYPE_PRIMARY);
g_assert (primary);
mm_serial_port_queue_command (primary, command, 3, get_ip4_config_done, info);
g_free (command);
}
/*****************************************************************************/
static void
disconnect_owancall_done (MMSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
mm_callback_info_schedule ((MMCallbackInfo *) user_data);
}
static void
do_disconnect (MMGenericGsm *gsm,
gint cid,
MMModemFn callback,
gpointer user_data)
{
MMCallbackInfo *info;
MMSerialPort *primary;
char *command;
info = mm_callback_info_new (MM_MODEM (gsm), callback, user_data);
primary = mm_generic_gsm_get_port (gsm, MM_PORT_TYPE_PRIMARY);
g_assert (primary);
command = g_strdup_printf ("AT_OWANCALL=%d,0,0", cid);
mm_serial_port_queue_command (primary, command, 3, disconnect_owancall_done, info);
g_free (command);
}
/*****************************************************************************/
static void
impl_hso_auth_done (MMModem *modem,
GError *error,
gpointer user_data)
{
DBusGMethodInvocation *context = (DBusGMethodInvocation *) user_data;
if (error)
dbus_g_method_return_error (context, error);
else
dbus_g_method_return (context);
}
static void
impl_hso_authenticate (MMModemHso *self,
const char *username,
const char *password,
DBusGMethodInvocation *context)
{
/* DBus doesn't support NULLs */
if (username && strlen (username) == 0)
username = NULL;
if (password && strlen (password) == 0)
password = NULL;
mm_hso_modem_authenticate (self, username, password, impl_hso_auth_done, context);
}
/*****************************************************************************/
static const char *
hso_simple_get_string_property (GHashTable *properties, const char *name, GError **error)
{
GValue *value;
value = (GValue *) g_hash_table_lookup (properties, name);
if (!value)
return NULL;
if (G_VALUE_HOLDS_STRING (value))
return g_value_get_string (value);
g_set_error (error, MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Invalid property type for '%s': %s (string expected)",
name, G_VALUE_TYPE_NAME (value));
return NULL;
}
static void
simple_connect (MMModemSimple *simple,
GHashTable *properties,
MMModemFn callback,
gpointer user_data)
{
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (simple);
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
MMModemSimple *parent_iface;
priv->username = g_strdup (hso_simple_get_string_property (properties, "username", NULL));
priv->password = g_strdup (hso_simple_get_string_property (properties, "password", NULL));
parent_iface = g_type_interface_peek_parent (MM_MODEM_SIMPLE_GET_INTERFACE (simple));
parent_iface->connect (MM_MODEM_SIMPLE (simple), properties, callback, info);
}
/*****************************************************************************/
static gboolean
grab_port (MMModem *modem,
const char *subsys,
const char *name,
MMPortType suggested_type,
gpointer user_data,
GError **error)
{
MMGenericGsm *gsm = MM_GENERIC_GSM (modem);
MMPortType ptype = MM_PORT_TYPE_IGNORED;
const char *sys[] = { "tty", "net", NULL };
GUdevClient *client;
GUdevDevice *device = NULL;
MMPort *port = NULL;
const char *sysfs_path;
client = g_udev_client_new (sys);
if (!client) {
g_set_error (error, 0, 0, "Could not get udev client.");
return FALSE;
}
device = g_udev_client_query_by_subsystem_and_name (client, subsys, name);
if (!device) {
g_set_error (error, 0, 0, "Could not get udev device.");
goto out;
}
sysfs_path = g_udev_device_get_sysfs_path (device);
if (!sysfs_path) {
g_set_error (error, 0, 0, "Could not get udev device sysfs path.");
goto out;
}
if (!strcmp (subsys, "tty")) {
char *hsotype_path;
char *contents = NULL;
hsotype_path = g_build_filename (sysfs_path, "hsotype", NULL);
if (g_file_get_contents (hsotype_path, &contents, NULL, NULL)) {
if (g_str_has_prefix (contents, "Control"))
ptype = MM_PORT_TYPE_PRIMARY;
else if (g_str_has_prefix (contents, "Application") || g_str_has_prefix (contents, "Application2"))
ptype = MM_PORT_TYPE_SECONDARY;
g_free (contents);
}
g_free (hsotype_path);
}
port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
if (!port)
goto out;
if (MM_IS_SERIAL_PORT (port)) {
g_object_set (G_OBJECT (port), MM_SERIAL_PORT_SEND_DELAY, (guint64) 10000, NULL);
if (ptype == MM_PORT_TYPE_PRIMARY) {
GRegex *regex;
regex = g_regex_new ("_OWANCALL: (\\d),\\s*(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
mm_serial_port_add_unsolicited_msg_handler (MM_SERIAL_PORT (port), regex, connection_enabled, modem, NULL);
g_regex_unref (regex);
}
}
out:
if (device)
g_object_unref (device);
g_object_unref (client);
return !!port;
}
/*****************************************************************************/
static void
mm_modem_hso_init (MMModemHso *self)
{
}
static void
modem_simple_init (MMModemSimple *class)
{
class->connect = simple_connect;
}
static void
modem_init (MMModem *modem_class)
{
modem_class->disable = disable;
modem_class->connect = do_connect;
modem_class->get_ip4_config = get_ip4_config;
modem_class->grab_port = grab_port;
}
static void
finalize (GObject *object)
{
MMModemHso *self = MM_MODEM_HSO (object);
MMModemHsoPrivate *priv = MM_MODEM_HSO_GET_PRIVATE (self);
/* Clear the pending connection if necessary */
connect_pending_done (self);
g_free (priv->username);
g_free (priv->password);
G_OBJECT_CLASS (mm_modem_hso_parent_class)->finalize (object);
}
static void
mm_modem_hso_class_init (MMModemHsoClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MMGenericGsmClass *gsm_class = MM_GENERIC_GSM_CLASS (klass);
mm_modem_hso_parent_class = g_type_class_peek_parent (klass);
g_type_class_add_private (object_class, sizeof (MMModemHsoPrivate));
/* Virtual methods */
object_class->finalize = finalize;
gsm_class->do_disconnect = do_disconnect;
}