colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1e69874e598711cf713b2c6ea6f73cb8b1a9d6db
ModemManager/cli/mmcli-modem.c
Aleksander Morgado 3206e95663 api,introspection: new 'Ports' property in the Modem interface 
We will expose a new 'Ports' property listing all ports currently known by a
given modem. Ports which are not used but are detected as being part of the
modem will be listed with an 'unknown' port type.

This change uses the new 'MMModemPortType' enum and the new 'MMModemPortInfo'
helper struct to handle these values in libmm-glib. The already available
'MMPortType' enum hasn't been re-used for the interface because it contains
values that we don't need (e.g. IGNORED).

The port list is now also included in the modem information command of mmcli:

$ sudo mmcli -m 0

/org/freedesktop/ModemManager1/Modem/0 (device id '97b7b99e3e2bea103880545b619fb05a3cc81b26')
  -------------------------
  System   |         device: '/sys/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.4'
           |        drivers: 'qcserial, qmi_wwan'
           |         plugin: 'Gobi'
           |   primary port: 'cdc-wdm0'
           |          ports: 'ttyUSB0 (qcdm), ttyUSB1 (at), cdc-wdm0 (qmi), wwp0s29u1u4 (net)'

https://bugzilla.gnome.org/show_bug.cgi?id=702678
2013-06-24 19:44:57 +02:00

1382 lines
44 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* mmcli -- Control modem status & access information from the command line
*
* 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 3 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright (C) 2011 Aleksander Morgado <aleksander@gnu.org>
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <glib.h>
#include <gio/gio.h>
#define _LIBMM_INSIDE_MMCLI
#include <libmm-glib.h>
#include "mmcli.h"
#include "mmcli-common.h"
/* Context */
typedef struct {
MMManager *manager;
GCancellable *cancellable;
MMObject *object;
MMModem *modem;
MMModem3gpp *modem_3gpp;
MMModemCdma *modem_cdma;
} Context;
static Context *ctx;
/* Options */
static gboolean info_flag; /* set when no action found */
static gboolean monitor_state_flag;
static gboolean enable_flag;
static gboolean disable_flag;
static gboolean set_power_state_on_flag;
static gboolean set_power_state_low_flag;
static gboolean reset_flag;
static gchar *factory_reset_str;
static gchar *command_str;
static gboolean list_bearers_flag;
static gchar *create_bearer_str;
static gchar *delete_bearer_str;
static gchar *set_current_capabilities_str;
static gchar *set_allowed_modes_str;
static gchar *set_preferred_mode_str;
static gchar *set_current_bands_str;
static GOptionEntry entries[] = {
{ "monitor-state", 'w', 0, G_OPTION_ARG_NONE, &monitor_state_flag,
"Monitor state of a given modem",
NULL
},
{ "enable", 'e', 0, G_OPTION_ARG_NONE, &enable_flag,
"Enable a given modem",
NULL
},
{ "disable", 'd', 0, G_OPTION_ARG_NONE, &disable_flag,
"Disable a given modem",
NULL
},
{ "set-power-state-on", 0, 0, G_OPTION_ARG_NONE, &set_power_state_on_flag,
"Set full power state in the modem",
NULL
},
{ "set-power-state-low", 0, 0, G_OPTION_ARG_NONE, &set_power_state_low_flag,
"Set low power state in the modem",
NULL
},
{ "reset", 'r', 0, G_OPTION_ARG_NONE, &reset_flag,
"Reset a given modem",
NULL
},
{ "factory-reset", 0, 0, G_OPTION_ARG_STRING, &factory_reset_str,
"Reset a given modem to its factory state",
"[CODE]"
},
{ "command", 0, 0, G_OPTION_ARG_STRING, &command_str,
"Send an AT command to the modem",
"[COMMAND]"
},
{ "list-bearers", 0, 0, G_OPTION_ARG_NONE, &list_bearers_flag,
"List packet data bearers available in a given modem",
NULL
},
{ "create-bearer", 0, 0, G_OPTION_ARG_STRING, &create_bearer_str,
"Create a new packet data bearer in a given modem",
"[\"key=value,...\"]"
},
{ "delete-bearer", 0, 0, G_OPTION_ARG_STRING, &delete_bearer_str,
"Delete a data bearer from a given modem",
"[PATH]"
},
{ "set-current-capabilities", 0, 0, G_OPTION_ARG_STRING, &set_current_capabilities_str,
"Set current modem capabilities.",
"[CAPABILITY1|CAPABILITY2...]"
},
{ "set-allowed-modes", 0, 0, G_OPTION_ARG_STRING, &set_allowed_modes_str,
"Set allowed modes in a given modem.",
"[MODE1|MODE2...]"
},
{ "set-preferred-mode", 0, 0, G_OPTION_ARG_STRING, &set_preferred_mode_str,
"Set preferred mode in a given modem (Must give allowed modes with --set-allowed-modes)",
"[MODE]"
},
{ "set-current-bands", 0, 0, G_OPTION_ARG_STRING, &set_current_bands_str,
"Set bands to be used by a given modem.",
"[BAND1|BAND2...]"
},
{ NULL }
};
GOptionGroup *
mmcli_modem_get_option_group (void)
{
GOptionGroup *group;
/* Status options */
group = g_option_group_new ("modem",
"Modem options",
"Show modem options",
NULL,
NULL);
g_option_group_add_entries (group, entries);
return group;
}
gboolean
mmcli_modem_options_enabled (void)
{
static guint n_actions = 0;
static gboolean checked = FALSE;
if (checked)
return !!n_actions;
n_actions = (monitor_state_flag +
enable_flag +
disable_flag +
set_power_state_on_flag +
set_power_state_low_flag +
reset_flag +
list_bearers_flag +
!!create_bearer_str +
!!delete_bearer_str +
!!factory_reset_str +
!!command_str +
!!set_current_capabilities_str +
!!set_allowed_modes_str +
!!set_preferred_mode_str +
!!set_current_bands_str);
if (n_actions == 0 && mmcli_get_common_modem_string ()) {
/* default to info */
info_flag = TRUE;
n_actions++;
}
if (set_preferred_mode_str) {
if (!set_allowed_modes_str) {
g_printerr ("error: setting preferred mode requires list of allowed modes\n");
exit (EXIT_FAILURE);
}
n_actions--;
}
if (n_actions > 1) {
g_printerr ("error: too many modem actions requested\n");
exit (EXIT_FAILURE);
}
if (monitor_state_flag)
mmcli_force_async_operation ();
if (info_flag)
mmcli_force_sync_operation ();
checked = TRUE;
return !!n_actions;
}
static void
context_free (Context *ctx)
{
if (!ctx)
return;
if (ctx->cancellable)
g_object_unref (ctx->cancellable);
if (ctx->modem)
g_object_unref (ctx->modem);
if (ctx->modem_3gpp)
g_object_unref (ctx->modem_3gpp);
if (ctx->modem_cdma)
g_object_unref (ctx->modem_cdma);
if (ctx->object)
g_object_unref (ctx->object);
if (ctx->manager)
g_object_unref (ctx->manager);
g_free (ctx);
}
void
mmcli_modem_shutdown (void)
{
context_free (ctx);
}
static void
cancelled (GCancellable *cancellable)
{
mmcli_async_operation_done ();
}
static void
print_bearer_short_info (MMBearer *bearer)
{
g_print ("\t%s\n",
mm_bearer_get_path (bearer));
}
static void
print_modem_info (void)
{
gchar *drivers_string;
gchar *prefixed_revision;
gchar *supported_capabilities_string;
MMModemCapability *capabilities = NULL;
guint n_capabilities = 0;
gchar *current_capabilities_string;
gchar *access_technologies_string;
MMModemModeCombination *modes = NULL;
guint n_modes = 0;
gchar *supported_modes_string;
MMModemMode allowed_modes;
gchar *allowed_modes_string = NULL;
MMModemMode preferred_mode;
gchar *preferred_mode_string = NULL;
gchar *supported_bands_string;
gchar *current_bands_string;
gchar *supported_ip_families_string;
gchar *unlock_retries_string;
gchar *own_numbers_string;
MMModemBand *bands = NULL;
guint n_bands = 0;
MMModemPortInfo *ports = NULL;
guint n_ports = 0;
gchar *ports_string;
MMUnlockRetries *unlock_retries;
guint signal_quality = 0;
gboolean signal_quality_recent = FALSE;
/* Not the best thing to do, as we may be doing _get() calls twice, but
* easiest to maintain */
#undef VALIDATE_UNKNOWN
#define VALIDATE_UNKNOWN(str) (str ? str : "unknown")
#undef VALIDATE_PATH
#define VALIDATE_PATH(str) ((str && !g_str_equal (str, "/")) ? str : "none")
/* Strings in heap */
mm_modem_get_supported_capabilities (ctx->modem, &capabilities, &n_capabilities);
supported_capabilities_string = mm_common_build_capabilities_string (capabilities, n_capabilities);
g_free (capabilities);
current_capabilities_string = mm_modem_capability_build_string_from_mask (
mm_modem_get_current_capabilities (ctx->modem));
access_technologies_string = mm_modem_access_technology_build_string_from_mask (
mm_modem_get_access_technologies (ctx->modem));
mm_modem_get_supported_modes (ctx->modem, &modes, &n_modes);
supported_modes_string = mm_common_build_mode_combinations_string (modes, n_modes);
g_free (modes);
mm_modem_get_current_bands (ctx->modem, &bands, &n_bands);
current_bands_string = mm_common_build_bands_string (bands, n_bands);
g_free (bands);
mm_modem_get_supported_bands (ctx->modem, &bands, &n_bands);
supported_bands_string = mm_common_build_bands_string (bands, n_bands);
g_free (bands);
mm_modem_get_ports (ctx->modem, &ports, &n_ports);
ports_string = mm_common_build_ports_string (ports, n_ports);
mm_modem_port_info_array_free (ports, n_ports);
if (mm_modem_get_current_modes (ctx->modem, &allowed_modes, &preferred_mode)) {
allowed_modes_string = mm_modem_mode_build_string_from_mask (allowed_modes);
preferred_mode_string = mm_modem_mode_build_string_from_mask (preferred_mode);
}
supported_ip_families_string = mm_bearer_ip_family_build_string_from_mask (
mm_modem_get_supported_ip_families (ctx->modem));
unlock_retries = mm_modem_get_unlock_retries (ctx->modem);
unlock_retries_string = mm_unlock_retries_build_string (unlock_retries);
g_object_unref (unlock_retries);
if (mm_modem_get_own_numbers (ctx->modem)) {
own_numbers_string = g_strjoinv (", ", (gchar **)mm_modem_get_own_numbers (ctx->modem));
if (!own_numbers_string[0]) {
g_free (own_numbers_string);
own_numbers_string = NULL;
}
} else
own_numbers_string = NULL;
if (mm_modem_get_drivers (ctx->modem)) {
drivers_string = g_strjoinv (", ", (gchar **)mm_modem_get_drivers (ctx->modem));
if (!drivers_string[0]) {
g_free (drivers_string);
drivers_string = NULL;
}
} else
drivers_string = NULL;
/* Rework possible multiline strings */
if (mm_modem_get_revision (ctx->modem))
prefixed_revision = mmcli_prefix_newlines (" | ",
mm_modem_get_revision (ctx->modem));
else
prefixed_revision = NULL;
if (supported_modes_string) {
gchar *prefixed;
prefixed = mmcli_prefix_newlines (" | ",
supported_modes_string);
g_free (supported_modes_string);
supported_modes_string = prefixed;
}
if (supported_capabilities_string) {
gchar *prefixed;
prefixed = mmcli_prefix_newlines (" | ",
supported_capabilities_string);
g_free (supported_capabilities_string);
supported_capabilities_string = prefixed;
}
/* Get signal quality info */
signal_quality = mm_modem_get_signal_quality (ctx->modem, &signal_quality_recent);
/* Global IDs */
g_print ("\n"
"%s (device id '%s')\n",
VALIDATE_UNKNOWN (mm_modem_get_path (ctx->modem)),
VALIDATE_UNKNOWN (mm_modem_get_device_identifier (ctx->modem)));
/* Hardware related stuff */
g_print (" -------------------------\n"
" Hardware | manufacturer: '%s'\n"
" | model: '%s'\n"
" | revision: '%s'\n"
" | supported: '%s'\n"
" | current: '%s'\n"
" | equipment id: '%s'\n",
VALIDATE_UNKNOWN (mm_modem_get_manufacturer (ctx->modem)),
VALIDATE_UNKNOWN (mm_modem_get_model (ctx->modem)),
VALIDATE_UNKNOWN (prefixed_revision),
VALIDATE_UNKNOWN (supported_capabilities_string),
VALIDATE_UNKNOWN (current_capabilities_string),
VALIDATE_UNKNOWN (mm_modem_get_equipment_identifier (ctx->modem)));
/* System related stuff */
g_print (" -------------------------\n"
" System | device: '%s'\n"
" | drivers: '%s'\n"
" | plugin: '%s'\n"
" | primary port: '%s'\n"
" | ports: '%s'\n",
VALIDATE_UNKNOWN (mm_modem_get_device (ctx->modem)),
VALIDATE_UNKNOWN (drivers_string),
VALIDATE_UNKNOWN (mm_modem_get_plugin (ctx->modem)),
VALIDATE_UNKNOWN (mm_modem_get_primary_port (ctx->modem)),
VALIDATE_UNKNOWN (ports_string));
/* Numbers related stuff */
g_print (" -------------------------\n"
" Numbers | own : '%s'\n",
VALIDATE_UNKNOWN (own_numbers_string));
/* Status related stuff */
g_print (" -------------------------\n"
" Status | lock: '%s'\n"
" | unlock retries: '%s'\n"
" | state: '%s'\n",
mm_modem_lock_get_string (mm_modem_get_unlock_required (ctx->modem)),
VALIDATE_UNKNOWN (unlock_retries_string),
VALIDATE_UNKNOWN (mm_modem_state_get_string (mm_modem_get_state (ctx->modem))));
if (mm_modem_get_state (ctx->modem) == MM_MODEM_STATE_FAILED)
g_print (" | failed reason: '%s'\n",
VALIDATE_UNKNOWN (mm_modem_state_failed_reason_get_string (mm_modem_get_state_failed_reason (ctx->modem))));
g_print (" | power state: '%s'\n"
" | access tech: '%s'\n"
" | signal quality: '%u' (%s)\n",
VALIDATE_UNKNOWN (mm_modem_power_state_get_string (mm_modem_get_power_state (ctx->modem))),
VALIDATE_UNKNOWN (access_technologies_string),
signal_quality, signal_quality_recent ? "recent" : "cached");
/* Modes */
g_print (" -------------------------\n"
" Modes | supported: '%s'\n"
" | current: 'allowed: %s; preferred: %s'\n",
VALIDATE_UNKNOWN (supported_modes_string),
VALIDATE_UNKNOWN (allowed_modes_string),
VALIDATE_UNKNOWN (preferred_mode_string));
/* Band related stuff */
g_print (" -------------------------\n"
" Bands | supported: '%s'\n"
" | current: '%s'\n",
VALIDATE_UNKNOWN (supported_bands_string),
VALIDATE_UNKNOWN (current_bands_string));
/* IP families */
g_print (" -------------------------\n"
" IP | supported: '%s'\n",
VALIDATE_UNKNOWN (supported_ip_families_string));
/* If available, 3GPP related stuff */
if (ctx->modem_3gpp) {
gchar *facility_locks;
facility_locks = (mm_modem_3gpp_facility_build_string_from_mask (
mm_modem_3gpp_get_enabled_facility_locks (ctx->modem_3gpp)));
g_print (" -------------------------\n"
" 3GPP | imei: '%s'\n"
" | enabled locks: '%s'\n"
" | operator id: '%s'\n"
" | operator name: '%s'\n"
" | registration: '%s'\n",
VALIDATE_UNKNOWN (mm_modem_3gpp_get_imei (ctx->modem_3gpp)),
facility_locks,
VALIDATE_UNKNOWN (mm_modem_3gpp_get_operator_code (ctx->modem_3gpp)),
VALIDATE_UNKNOWN (mm_modem_3gpp_get_operator_name (ctx->modem_3gpp)),
mm_modem_3gpp_registration_state_get_string (
mm_modem_3gpp_get_registration_state ((ctx->modem_3gpp))));
g_free (facility_locks);
}
/* If available, CDMA related stuff */
if (ctx->modem_cdma) {
guint sid;
guint nid;
gchar *sid_str;
gchar *nid_str;
sid = mm_modem_cdma_get_sid (ctx->modem_cdma);
sid_str = (sid != MM_MODEM_CDMA_SID_UNKNOWN ?
g_strdup_printf ("%u", sid) :
NULL);
nid = mm_modem_cdma_get_nid (ctx->modem_cdma);
nid_str = (nid != MM_MODEM_CDMA_NID_UNKNOWN ?
g_strdup_printf ("%u", nid) :
NULL);
g_print (" -------------------------\n"
" CDMA | meid: '%s'\n"
" | esn: '%s'\n"
" | sid: '%s'\n"
" | nid: '%s'\n"
" | registration: CDMA1x '%s'\n"
" | EV-DO '%s'\n"
" | activation: '%s'\n",
VALIDATE_UNKNOWN (mm_modem_cdma_get_meid (ctx->modem_cdma)),
VALIDATE_UNKNOWN (mm_modem_cdma_get_esn (ctx->modem_cdma)),
VALIDATE_UNKNOWN (sid_str),
VALIDATE_UNKNOWN (nid_str),
mm_modem_cdma_registration_state_get_string (
mm_modem_cdma_get_cdma1x_registration_state (ctx->modem_cdma)),
mm_modem_cdma_registration_state_get_string (
mm_modem_cdma_get_evdo_registration_state (ctx->modem_cdma)),
mm_modem_cdma_activation_state_get_string (
mm_modem_cdma_get_activation_state (ctx->modem_cdma)));
g_free (sid_str);
g_free (nid_str);
}
/* SIM */
g_print (" -------------------------\n"
" SIM | path: '%s'\n",
VALIDATE_PATH (mm_modem_get_sim_path (ctx->modem)));
g_print ("\n");
g_free (ports_string);
g_free (supported_ip_families_string);
g_free (current_bands_string);
g_free (supported_bands_string);
g_free (access_technologies_string);
g_free (supported_capabilities_string);
g_free (current_capabilities_string);
g_free (prefixed_revision);
g_free (allowed_modes_string);
g_free (preferred_mode_string);
g_free (supported_modes_string);
g_free (unlock_retries_string);
g_free (own_numbers_string);
g_free (drivers_string);
}
static void
enable_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't enable the modem: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully enabled the modem\n");
}
static void
enable_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_enable_finish (modem, result, &error);
enable_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
disable_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't disable the modem: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully disabled the modem\n");
}
static void
disable_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_disable_finish (modem, result, &error);
disable_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
set_power_state_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't set new power state in the modem: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully set new power state in the modem\n");
}
static void
set_power_state_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_set_power_state_finish (modem, result, &error);
set_power_state_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
reset_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't reset the modem: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully reseted the modem\n");
}
static void
reset_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_reset_finish (modem, result, &error);
reset_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
factory_reset_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't reset the modem to factory state: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully reseted the modem to factory state\n");
}
static void
factory_reset_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_factory_reset_finish (modem, result, &error);
factory_reset_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
command_process_reply (gchar *result,
const GError *error)
{
if (!result) {
g_printerr ("error: command failed: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("response: '%s'\n", result);
g_free (result);
}
static void
command_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gchar * operation_result;
GError *error = NULL;
operation_result = mm_modem_command_finish (modem, result, &error);
command_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static guint
command_get_timeout (MMModem *modem)
{
gint timeout;
/* If --timeout was given, it should already have been set in the proxy */
timeout = (g_dbus_proxy_get_default_timeout (G_DBUS_PROXY (modem)) / 1000) - 1;
if (timeout <= 0) {
g_printerr ("error: timeout is too short (%d)\n", timeout);
exit (EXIT_FAILURE);
}
return (guint)timeout;
}
static void
list_bearers_process_reply (GList *result,
const GError *error)
{
if (error) {
g_printerr ("error: couldn't list bearers: '%s'\n",
error->message);
exit (EXIT_FAILURE);
}
g_print ("\n");
if (!result) {
g_print ("No bearers were found\n");
} else {
GList *l;
g_print ("Found %u bearers:\n", g_list_length (result));
for (l = result; l; l = g_list_next (l)) {
MMBearer *bearer = MM_BEARER (l->data);
g_print ("\n");
print_bearer_short_info (bearer);
g_object_unref (bearer);
}
g_list_free (result);
}
}
static void
list_bearers_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
GList *operation_result;
GError *error = NULL;
operation_result = mm_modem_list_bearers_finish (modem, result, &error);
list_bearers_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
create_bearer_process_reply (MMBearer *bearer,
const GError *error)
{
if (!bearer) {
g_printerr ("error: couldn't create new bearer: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("Successfully created new bearer in modem:\n");
print_bearer_short_info (bearer);
g_object_unref (bearer);
}
static void
create_bearer_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
MMBearer *bearer;
GError *error = NULL;
bearer = mm_modem_create_bearer_finish (modem, result, &error);
create_bearer_process_reply (bearer, error);
mmcli_async_operation_done ();
}
static void
delete_bearer_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't delete bearer: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully deleted bearer from modem\n");
}
static void
delete_bearer_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_delete_bearer_finish (modem, result, &error);
delete_bearer_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
set_current_capabilities_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't set current capabilities: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully set current capabilities in the modem\n");
}
static void
set_current_capabilities_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_set_current_capabilities_finish (modem, result, &error);
set_current_capabilities_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
parse_current_capabilities (MMModemCapability *capabilities)
{
GError *error = NULL;
*capabilities = mm_common_get_capabilities_from_string (set_current_capabilities_str,
&error);
if (error) {
g_printerr ("error: couldn't parse list of capabilities: '%s'\n",
error->message);
exit (EXIT_FAILURE);
}
}
static void
set_current_modes_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't set current modes: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully set current modes in the modem\n");
}
static void
set_current_modes_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_set_current_modes_finish (modem, result, &error);
set_current_modes_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
parse_modes (MMModemMode *allowed,
MMModemMode *preferred)
{
GError *error = NULL;
*allowed = mm_common_get_modes_from_string (set_allowed_modes_str, &error);
if (error) {
g_printerr ("error: couldn't parse list of allowed modes: '%s'\n",
error->message);
exit (EXIT_FAILURE);
}
*preferred = (set_preferred_mode_str ?
mm_common_get_modes_from_string (set_preferred_mode_str, &error) :
MM_MODEM_MODE_NONE);
if (error) {
g_printerr ("error: couldn't parse preferred mode: '%s'\n",
error->message);
exit (EXIT_FAILURE);
}
}
static void
set_current_bands_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't set current bands: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully set current bands in the modem\n");
}
static void
set_current_bands_ready (MMModem *modem,
GAsyncResult *result,
gpointer nothing)
{
gboolean operation_result;
GError *error = NULL;
operation_result = mm_modem_set_current_bands_finish (modem, result, &error);
set_current_bands_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
parse_current_bands (MMModemBand **bands,
guint *n_bands)
{
GError *error = NULL;
mm_common_get_bands_from_string (set_current_bands_str,
bands,
n_bands,
&error);
if (error) {
g_printerr ("error: couldn't parse list of bands: '%s'\n",
error->message);
exit (EXIT_FAILURE);
}
}
static void
state_changed (MMModem *modem,
MMModemState old_state,
MMModemState new_state,
MMModemStateChangeReason reason)
{
g_print ("\t%s: State changed, '%s' --> '%s' (Reason: %s)\n",
mm_modem_get_path (modem),
mm_modem_state_get_string (old_state),
mm_modem_state_get_string (new_state),
mmcli_get_state_reason_string (reason));
fflush (stdout);
}
static void
get_modem_ready (GObject *source,
GAsyncResult *result,
gpointer none)
{
ctx->object = mmcli_get_modem_finish (result, &ctx->manager);
ctx->modem = mm_object_get_modem (ctx->object);
ctx->modem_3gpp = mm_object_get_modem_3gpp (ctx->object);
ctx->modem_cdma = mm_object_get_modem_cdma (ctx->object);
/* Setup operation timeout */
if (ctx->modem)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem));
if (ctx->modem_3gpp)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_3gpp));
if (ctx->modem_cdma)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_cdma));
if (info_flag)
g_assert_not_reached ();
/* Request to monitor modems? */
if (monitor_state_flag) {
MMModemState current;
g_signal_connect (ctx->modem,
"state-changed",
G_CALLBACK (state_changed),
NULL);
current = mm_modem_get_state (ctx->modem);
g_print ("\t%s: Initial state, '%s'\n",
mm_object_get_path (ctx->object),
mm_modem_state_get_string (current));
/* If we get cancelled, operation done */
g_cancellable_connect (ctx->cancellable,
G_CALLBACK (cancelled),
NULL,
NULL);
return;
}
/* Request to enable the modem? */
if (enable_flag) {
g_debug ("Asynchronously enabling modem...");
mm_modem_enable (ctx->modem,
ctx->cancellable,
(GAsyncReadyCallback)enable_ready,
NULL);
return;
}
/* Request to disable the modem? */
if (disable_flag) {
g_debug ("Asynchronously disabling modem...");
mm_modem_disable (ctx->modem,
ctx->cancellable,
(GAsyncReadyCallback)disable_ready,
NULL);
return;
}
/* Request to full power the modem? */
if (set_power_state_on_flag) {
g_debug ("Asynchronously setting full power...");
mm_modem_set_power_state (ctx->modem,
MM_MODEM_POWER_STATE_ON,
ctx->cancellable,
(GAsyncReadyCallback)set_power_state_ready,
NULL);
return;
}
/* Request to low power the modem? */
if (set_power_state_low_flag) {
g_debug ("Asynchronously setting low power...");
mm_modem_set_power_state (ctx->modem,
MM_MODEM_POWER_STATE_LOW,
ctx->cancellable,
(GAsyncReadyCallback)set_power_state_ready,
NULL);
return;
}
/* Request to reset the modem? */
if (reset_flag) {
g_debug ("Asynchronously reseting modem...");
mm_modem_reset (ctx->modem,
ctx->cancellable,
(GAsyncReadyCallback)reset_ready,
NULL);
return;
}
/* Request to reset the modem to factory state? */
if (factory_reset_str) {
g_debug ("Asynchronously factory-reseting modem...");
mm_modem_factory_reset (ctx->modem,
factory_reset_str,
ctx->cancellable,
(GAsyncReadyCallback)factory_reset_ready,
NULL);
return;
}
/* Request to send a command to the modem? */
if (command_str) {
guint timeout;
timeout = command_get_timeout (ctx->modem);
g_debug ("Asynchronously sending a command to the modem (%u seconds timeout)...",
timeout);
mm_modem_command (ctx->modem,
command_str,
timeout,
ctx->cancellable,
(GAsyncReadyCallback)command_ready,
NULL);
return;
}
/* Request to list bearers? */
if (list_bearers_flag) {
g_debug ("Asynchronously listing bearers in modem...");
mm_modem_list_bearers (ctx->modem,
ctx->cancellable,
(GAsyncReadyCallback)list_bearers_ready,
NULL);
return;
}
/* Request to create a new bearer? */
if (create_bearer_str) {
GError *error = NULL;
MMBearerProperties *properties;
properties = mm_bearer_properties_new_from_string (create_bearer_str, &error);
if (!properties) {
g_printerr ("Error parsing properties string: '%s'\n", error->message);
exit (EXIT_FAILURE);
}
g_debug ("Asynchronously creating new bearer in modem...");
mm_modem_create_bearer (ctx->modem,
properties,
ctx->cancellable,
(GAsyncReadyCallback)create_bearer_ready,
NULL);
g_object_unref (properties);
return;
}
/* Request to delete a given bearer? */
if (delete_bearer_str) {
mm_modem_delete_bearer (ctx->modem,
delete_bearer_str,
ctx->cancellable,
(GAsyncReadyCallback)delete_bearer_ready,
NULL);
return;
}
/* Request to set current capabilities in a given modem? */
if (set_current_capabilities_str) {
MMModemCapability current_capabilities;
parse_current_capabilities (&current_capabilities);
mm_modem_set_current_capabilities (ctx->modem,
current_capabilities,
ctx->cancellable,
(GAsyncReadyCallback)set_current_capabilities_ready,
NULL);
return;
}
/* Request to set allowed modes in a given modem? */
if (set_allowed_modes_str) {
MMModemMode allowed;
MMModemMode preferred;
parse_modes (&allowed, &preferred);
mm_modem_set_current_modes (ctx->modem,
allowed,
preferred,
ctx->cancellable,
(GAsyncReadyCallback)set_current_modes_ready,
NULL);
return;
}
/* Request to set current bands in a given modem? */
if (set_current_bands_str) {
MMModemBand *current_bands;
guint n_current_bands;
parse_current_bands (&current_bands, &n_current_bands);
mm_modem_set_current_bands (ctx->modem,
current_bands,
n_current_bands,
ctx->cancellable,
(GAsyncReadyCallback)set_current_bands_ready,
NULL);
g_free (current_bands);
return;
}
g_warn_if_reached ();
}
void
mmcli_modem_run_asynchronous (GDBusConnection *connection,
GCancellable *cancellable)
{
/* Initialize context */
ctx = g_new0 (Context, 1);
if (cancellable)
ctx->cancellable = g_object_ref (cancellable);
/* Get proper modem */
mmcli_get_modem (connection,
mmcli_get_common_modem_string (),
cancellable,
(GAsyncReadyCallback)get_modem_ready,
NULL);
}
void
mmcli_modem_run_synchronous (GDBusConnection *connection)
{
GError *error = NULL;
if (monitor_state_flag)
g_assert_not_reached ();
/* Initialize context */
ctx = g_new0 (Context, 1);
ctx->object = mmcli_get_modem_sync (connection,
mmcli_get_common_modem_string (),
&ctx->manager);
ctx->modem = mm_object_get_modem (ctx->object);
ctx->modem_3gpp = mm_object_get_modem_3gpp (ctx->object);
ctx->modem_cdma = mm_object_get_modem_cdma (ctx->object);
/* Setup operation timeout */
if (ctx->modem)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem));
if (ctx->modem_3gpp)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_3gpp));
if (ctx->modem_cdma)
mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_cdma));
/* Request to get info from modem? */
if (info_flag) {
g_debug ("Printing modem info...");
print_modem_info ();
return;
}
/* Request to enable the modem? */
if (enable_flag) {
gboolean result;
g_debug ("Synchronously enabling modem...");
result = mm_modem_enable_sync (ctx->modem, NULL, &error);
enable_process_reply (result, error);
return;
}
/* Request to disable the modem? */
if (disable_flag) {
gboolean result;
g_debug ("Synchronously disabling modem...");
result = mm_modem_disable_sync (ctx->modem, NULL, &error);
disable_process_reply (result, error);
return;
}
/* Request to set full power state? */
if (set_power_state_on_flag) {
gboolean result;
g_debug ("Synchronously setting full power...");
result = mm_modem_set_power_state_sync (ctx->modem, MM_MODEM_POWER_STATE_ON, NULL, &error);
set_power_state_process_reply (result, error);
return;
}
/* Request to set low power state? */
if (set_power_state_low_flag) {
gboolean result;
g_debug ("Synchronously setting low power...");
result = mm_modem_set_power_state_sync (ctx->modem, MM_MODEM_POWER_STATE_LOW, NULL, &error);
set_power_state_process_reply (result, error);
return;
}
/* Request to reset the modem? */
if (reset_flag) {
gboolean result;
g_debug ("Synchronously reseting modem...");
result = mm_modem_reset_sync (ctx->modem, NULL, &error);
reset_process_reply (result, error);
return;
}
/* Request to reset the modem to factory state? */
if (factory_reset_str) {
gboolean result;
g_debug ("Synchronously factory-reseting modem...");
result = mm_modem_factory_reset_sync (ctx->modem,
factory_reset_str,
NULL,
&error);
factory_reset_process_reply (result, error);
return;
}
/* Request to send a command to the modem? */
if (command_str) {
gchar *result;
guint timeout;
timeout = command_get_timeout (ctx->modem);
g_debug ("Synchronously sending command to modem (%u seconds timeout)...",
timeout);
result = mm_modem_command_sync (ctx->modem,
command_str,
timeout,
NULL,
&error);
command_process_reply (result, error);
return;
}
/* Request to list the bearers? */
if (list_bearers_flag) {
GList *result;
g_debug ("Synchronously listing bearers...");
result = mm_modem_list_bearers_sync (ctx->modem, NULL, &error);
list_bearers_process_reply (result, error);
return;
}
/* Request to create a new bearer? */
if (create_bearer_str) {
MMBearer *bearer;
GError *error = NULL;
MMBearerProperties *properties;
properties = mm_bearer_properties_new_from_string (create_bearer_str, &error);
if (!properties) {
g_printerr ("Error parsing properties string: '%s'\n", error->message);
exit (EXIT_FAILURE);
}
g_debug ("Synchronously creating new bearer in modem...");
bearer = mm_modem_create_bearer_sync (ctx->modem,
properties,
NULL,
&error);
g_object_unref (properties);
create_bearer_process_reply (bearer, error);
return;
}
/* Request to delete a given bearer? */
if (delete_bearer_str) {
gboolean result;
result = mm_modem_delete_bearer_sync (ctx->modem,
delete_bearer_str,
NULL,
&error);
delete_bearer_process_reply (result, error);
return;
}
/* Request to set capabilities in a given modem? */
if (set_current_capabilities_str) {
gboolean result;
MMModemCapability current_capabilities;
parse_current_capabilities (&current_capabilities);
result = mm_modem_set_current_capabilities_sync (ctx->modem,
current_capabilities,
NULL,
&error);
set_current_capabilities_process_reply (result, error);
return;
}
/* Request to set allowed modes in a given modem? */
if (set_allowed_modes_str) {
MMModemMode allowed;
MMModemMode preferred;
gboolean result;
parse_modes (&allowed, &preferred);
result = mm_modem_set_current_modes_sync (ctx->modem,
allowed,
preferred,
NULL,
&error);
set_current_modes_process_reply (result, error);
return;
}
/* Request to set allowed bands in a given modem? */
if (set_current_bands_str) {
gboolean result;
MMModemBand *current_bands;
guint n_current_bands;
parse_current_bands (&current_bands, &n_current_bands);
result = mm_modem_set_current_bands_sync (ctx->modem,
current_bands,
n_current_bands,
NULL,
&error);
g_free (current_bands);
set_current_bands_process_reply (result, error);
return;
}
g_warn_if_reached ();
}
Reference in New Issue View Git Blame Copy Permalink