
We want to expose in the Modem interface the list of supported IP families, and the easiest way to do so is to have the IP family as flags, and provide in the interface a single enum. Also, a value of 0 for a MMBearerIpFamily specifies that no flags are set, so just rename it to 'NONE'. And add a new 'ANY' value which sets all flags to 1.
392 lines
12 KiB
C
392 lines
12 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* mmcli -- Control bearer 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 <string.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;
|
|
MMObject *object;
|
|
GCancellable *cancellable;
|
|
MMBearer *bearer;
|
|
} Context;
|
|
static Context *ctx;
|
|
|
|
/* Options */
|
|
static gboolean info_flag; /* set when no action found */
|
|
static gboolean connect_flag;
|
|
static gboolean disconnect_flag;
|
|
|
|
static GOptionEntry entries[] = {
|
|
{ "connect", 'c', 0, G_OPTION_ARG_NONE, &connect_flag,
|
|
"Connect a given bearer.",
|
|
NULL
|
|
},
|
|
{ "disconnect", 'x', 0, G_OPTION_ARG_NONE, &disconnect_flag,
|
|
"Disconnect a given bearer.",
|
|
NULL
|
|
},
|
|
{ NULL }
|
|
};
|
|
|
|
GOptionGroup *
|
|
mmcli_bearer_get_option_group (void)
|
|
{
|
|
GOptionGroup *group;
|
|
|
|
/* Status options */
|
|
group = g_option_group_new ("bearer",
|
|
"Bearer options",
|
|
"Show bearer options",
|
|
NULL,
|
|
NULL);
|
|
g_option_group_add_entries (group, entries);
|
|
|
|
return group;
|
|
}
|
|
|
|
gboolean
|
|
mmcli_bearer_options_enabled (void)
|
|
{
|
|
static guint n_actions = 0;
|
|
static gboolean checked = FALSE;
|
|
|
|
if (checked)
|
|
return !!n_actions;
|
|
|
|
n_actions = (connect_flag +
|
|
disconnect_flag);
|
|
|
|
if (n_actions == 0 && mmcli_get_common_bearer_string ()) {
|
|
/* default to info */
|
|
info_flag = TRUE;
|
|
n_actions++;
|
|
}
|
|
|
|
if (n_actions > 1) {
|
|
g_printerr ("error: too many bearer actions requested\n");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
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->bearer)
|
|
g_object_unref (ctx->bearer);
|
|
if (ctx->object)
|
|
g_object_unref (ctx->object);
|
|
if (ctx->manager)
|
|
g_object_unref (ctx->manager);
|
|
g_free (ctx);
|
|
}
|
|
|
|
void
|
|
mmcli_bearer_shutdown (void)
|
|
{
|
|
context_free (ctx);
|
|
}
|
|
|
|
static void
|
|
print_bearer_info (MMBearer *bearer)
|
|
{
|
|
MMBearerIpConfig *ipv4_config;
|
|
MMBearerIpConfig *ipv6_config;
|
|
MMBearerProperties *properties;
|
|
|
|
ipv4_config = mm_bearer_get_ipv4_config (bearer);
|
|
ipv6_config = mm_bearer_get_ipv6_config (bearer);
|
|
properties = mm_bearer_get_properties (bearer);
|
|
|
|
/* 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_NONE
|
|
#define VALIDATE_NONE(str) (str ? str : "none")
|
|
|
|
g_print ("Bearer '%s'\n",
|
|
mm_bearer_get_path (bearer));
|
|
g_print (" -------------------------\n"
|
|
" Status | connected: '%s'\n"
|
|
" | suspended: '%s'\n"
|
|
" | interface: '%s'\n"
|
|
" | IP timeout: '%u'\n",
|
|
mm_bearer_get_connected (bearer) ? "yes" : "no",
|
|
mm_bearer_get_suspended (bearer) ? "yes" : "no",
|
|
VALIDATE_UNKNOWN (mm_bearer_get_interface (bearer)),
|
|
mm_bearer_get_ip_timeout (bearer));
|
|
|
|
if (properties) {
|
|
gchar *ip_family_str;
|
|
|
|
ip_family_str = (mm_bearer_ip_family_build_string_from_mask (
|
|
mm_bearer_properties_get_ip_type (properties)));
|
|
g_print (" -------------------------\n"
|
|
" Properties | apn: '%s'\n"
|
|
" | roaming: '%s'\n"
|
|
" | IP type: '%s'\n"
|
|
" | user: '%s'\n"
|
|
" | password: '%s'\n"
|
|
" | number: '%s'\n"
|
|
" | Rm protocol: '%s'\n",
|
|
VALIDATE_NONE (mm_bearer_properties_get_apn (properties)),
|
|
mm_bearer_properties_get_allow_roaming (properties) ? "allowed" : "forbidden",
|
|
VALIDATE_UNKNOWN (ip_family_str),
|
|
VALIDATE_NONE (mm_bearer_properties_get_user (properties)),
|
|
VALIDATE_NONE (mm_bearer_properties_get_password (properties)),
|
|
VALIDATE_NONE (mm_bearer_properties_get_number (properties)),
|
|
VALIDATE_UNKNOWN (mm_modem_cdma_rm_protocol_get_string (
|
|
mm_bearer_properties_get_rm_protocol (properties))));
|
|
g_free (ip_family_str);
|
|
}
|
|
|
|
/* IPv4 */
|
|
g_print (" -------------------------\n"
|
|
" IPv4 configuration | method: '%s'\n",
|
|
(ipv4_config ?
|
|
mm_bearer_ip_method_get_string (mm_bearer_ip_config_get_method (ipv4_config)) :
|
|
"none"));
|
|
if (ipv4_config &&
|
|
mm_bearer_ip_config_get_method (ipv4_config) == MM_BEARER_IP_METHOD_STATIC) {
|
|
const gchar **dns;
|
|
guint i;
|
|
|
|
dns = mm_bearer_ip_config_get_dns (ipv4_config);
|
|
g_print (" | address: '%s'\n"
|
|
" | prefix: '%u'\n"
|
|
" | gateway: '%s'\n"
|
|
" | DNS: '%s'",
|
|
VALIDATE_UNKNOWN (mm_bearer_ip_config_get_address (ipv4_config)),
|
|
mm_bearer_ip_config_get_prefix (ipv4_config),
|
|
VALIDATE_UNKNOWN (mm_bearer_ip_config_get_gateway (ipv4_config)),
|
|
VALIDATE_UNKNOWN (dns[0]));
|
|
/* Additional DNS addresses */
|
|
for (i = 1; dns[i]; i++)
|
|
g_print (", '%s'", dns[i]);
|
|
g_print ("\n");
|
|
}
|
|
|
|
/* IPv6 */
|
|
g_print (" -------------------------\n"
|
|
" IPv6 configuration | method: '%s'\n",
|
|
(ipv6_config ?
|
|
mm_bearer_ip_method_get_string (mm_bearer_ip_config_get_method (ipv6_config)) :
|
|
"none"));
|
|
if (ipv6_config &&
|
|
mm_bearer_ip_config_get_method (ipv6_config) == MM_BEARER_IP_METHOD_STATIC) {
|
|
const gchar **dns;
|
|
guint i;
|
|
|
|
dns = mm_bearer_ip_config_get_dns (ipv6_config);
|
|
g_print (" | address: '%s'\n"
|
|
" | prefix: '%u'\n"
|
|
" | gateway: '%s'\n"
|
|
" | DNS: '%s'",
|
|
VALIDATE_UNKNOWN(mm_bearer_ip_config_get_address (ipv6_config)),
|
|
mm_bearer_ip_config_get_prefix (ipv6_config),
|
|
VALIDATE_UNKNOWN(mm_bearer_ip_config_get_gateway (ipv6_config)),
|
|
VALIDATE_UNKNOWN(dns[0]));
|
|
/* Additional DNS addresses */
|
|
for (i = 1; dns[i]; i++)
|
|
g_print (", '%s'", dns[i]);
|
|
g_print ("\n");
|
|
}
|
|
|
|
g_clear_object (&properties);
|
|
g_clear_object (&ipv4_config);
|
|
g_clear_object (&ipv6_config);
|
|
}
|
|
|
|
static void
|
|
connect_process_reply (gboolean result,
|
|
const GError *error)
|
|
{
|
|
if (!result) {
|
|
g_printerr ("error: couldn't connect the bearer: '%s'\n",
|
|
error ? error->message : "unknown error");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
g_print ("successfully connected the bearer\n");
|
|
}
|
|
|
|
static void
|
|
connect_ready (MMBearer *bearer,
|
|
GAsyncResult *result,
|
|
gpointer nothing)
|
|
{
|
|
gboolean operation_result;
|
|
GError *error = NULL;
|
|
|
|
operation_result = mm_bearer_connect_finish (bearer, result, &error);
|
|
connect_process_reply (operation_result, error);
|
|
|
|
mmcli_async_operation_done ();
|
|
}
|
|
|
|
static void
|
|
disconnect_process_reply (gboolean result,
|
|
const GError *error)
|
|
{
|
|
if (!result) {
|
|
g_printerr ("error: couldn't disconnect the bearer: '%s'\n",
|
|
error ? error->message : "unknown error");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
g_print ("successfully disconnected the bearer\n");
|
|
}
|
|
|
|
static void
|
|
disconnect_ready (MMBearer *bearer,
|
|
GAsyncResult *result,
|
|
gpointer nothing)
|
|
{
|
|
gboolean operation_result;
|
|
GError *error = NULL;
|
|
|
|
operation_result = mm_bearer_disconnect_finish (bearer, result, &error);
|
|
disconnect_process_reply (operation_result, error);
|
|
|
|
mmcli_async_operation_done ();
|
|
}
|
|
|
|
static void
|
|
get_bearer_ready (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer none)
|
|
{
|
|
ctx->bearer = mmcli_get_bearer_finish (result,
|
|
&ctx->manager,
|
|
&ctx->object);
|
|
|
|
if (info_flag)
|
|
g_assert_not_reached ();
|
|
|
|
/* Request to connect the bearer? */
|
|
if (connect_flag) {
|
|
g_debug ("Asynchronously connecting bearer...");
|
|
mm_bearer_connect (ctx->bearer,
|
|
ctx->cancellable,
|
|
(GAsyncReadyCallback)connect_ready,
|
|
NULL);
|
|
return;
|
|
}
|
|
|
|
/* Request to disconnect the bearer? */
|
|
if (disconnect_flag) {
|
|
g_debug ("Asynchronously disconnecting bearer...");
|
|
mm_bearer_disconnect (ctx->bearer,
|
|
ctx->cancellable,
|
|
(GAsyncReadyCallback)disconnect_ready,
|
|
NULL);
|
|
return;
|
|
}
|
|
|
|
g_warn_if_reached ();
|
|
}
|
|
|
|
void
|
|
mmcli_bearer_run_asynchronous (GDBusConnection *connection,
|
|
GCancellable *cancellable)
|
|
{
|
|
/* Initialize context */
|
|
ctx = g_new0 (Context, 1);
|
|
if (cancellable)
|
|
ctx->cancellable = g_object_ref (cancellable);
|
|
|
|
/* Get proper bearer */
|
|
mmcli_get_bearer (connection,
|
|
mmcli_get_common_bearer_string (),
|
|
cancellable,
|
|
(GAsyncReadyCallback)get_bearer_ready,
|
|
NULL);
|
|
}
|
|
|
|
void
|
|
mmcli_bearer_run_synchronous (GDBusConnection *connection)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
/* Initialize context */
|
|
ctx = g_new0 (Context, 1);
|
|
ctx->bearer = mmcli_get_bearer_sync (connection,
|
|
mmcli_get_common_bearer_string (),
|
|
&ctx->manager,
|
|
&ctx->object);
|
|
|
|
/* Request to get info from bearer? */
|
|
if (info_flag) {
|
|
g_debug ("Printing bearer info...");
|
|
print_bearer_info (ctx->bearer);
|
|
return;
|
|
}
|
|
|
|
/* Request to connect the bearer? */
|
|
if (connect_flag) {
|
|
gboolean result;
|
|
|
|
g_debug ("Synchronously connecting bearer...");
|
|
result = mm_bearer_connect_sync (ctx->bearer,
|
|
NULL,
|
|
&error);
|
|
connect_process_reply (result, error);
|
|
return;
|
|
}
|
|
|
|
/* Request to disconnect the bearer? */
|
|
if (disconnect_flag) {
|
|
gboolean result;
|
|
|
|
g_debug ("Synchronously disconnecting bearer...");
|
|
result = mm_bearer_disconnect_sync (ctx->bearer, NULL, &error);
|
|
disconnect_process_reply (result, error);
|
|
return;
|
|
}
|
|
|
|
g_warn_if_reached ();
|
|
}
|