mmcli,oma: support for the new OMA interface

cli/Makefile.am

@@ -24,6 +24,7 @@ mmcli_SOURCES = \
 	mmcli-modem-time.c \
 	mmcli-modem-firmware.c \
 	mmcli-modem-signal.c \
+	mmcli-modem-oma.c \
 	mmcli-bearer.c \
 	mmcli-sim.c \
 	mmcli-sms.c

cli/mmcli-modem-oma.c

@@ -0,0 +1,521 @@
+/* -*- 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) 2013 Google, Inc.
+ */
+
+#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;
+    GCancellable *cancellable;
+    MMObject *object;
+    MMModemOma *modem_oma;
+} Context;
+static Context *ctx;
+
+/* Options */
+static gboolean status_flag;
+static gchar *setup_str;
+static gchar *start_str;
+static gchar *accept_str;
+static gchar *reject_str;
+static gboolean cancel_flag;
+
+static GOptionEntry entries[] = {
+    { "oma-status", 0, 0, G_OPTION_ARG_NONE, &status_flag,
+      "Current status of the OMA device management",
+      NULL
+    },
+    { "oma-setup", 0, 0, G_OPTION_ARG_STRING, &setup_str,
+      "Setup OMA features",
+      "[FEATURE1|FEATURE2...]"
+    },
+    { "oma-start-client-initiated-session", 0, 0, G_OPTION_ARG_STRING, &start_str,
+      "Start client initiated OMA DM session",
+      "[Session type]"
+    },
+    { "oma-accept-network-initiated-session", 0, 0, G_OPTION_ARG_STRING, &accept_str,
+      "Accept network initiated OMA DM session",
+      "[Session ID]"
+    },
+    { "oma-reject-network-initiated-session", 0, 0, G_OPTION_ARG_STRING, &reject_str,
+      "Reject network initiated OMA DM session",
+      "[Session ID]"
+    },
+    { "oma-cancel-session", 0, 0, G_OPTION_ARG_NONE, &cancel_flag,
+      "Cancel current OMA DM session",
+      NULL
+    },
+
+    { NULL }
+};
+
+GOptionGroup *
+mmcli_modem_oma_get_option_group (void)
+{
+	GOptionGroup *group;
+
+	group = g_option_group_new ("oma",
+	                            "OMA options",
+	                            "Show OMA options",
+	                            NULL,
+	                            NULL);
+	g_option_group_add_entries (group, entries);
+
+	return group;
+}
+
+gboolean
+mmcli_modem_oma_options_enabled (void)
+{
+    static guint n_actions = 0;
+    static gboolean checked = FALSE;
+
+    if (checked)
+        return !!n_actions;
+
+    n_actions = (status_flag +
+                 !!setup_str +
+                 !!start_str +
+                 !!accept_str +
+                 !!reject_str +
+                 cancel_flag);
+
+    if (n_actions > 1) {
+        g_printerr ("error: too many OMA actions requested\n");
+        exit (EXIT_FAILURE);
+    }
+
+    if (status_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_oma)
+        g_object_unref (ctx->modem_oma);
+    if (ctx->object)
+        g_object_unref (ctx->object);
+    if (ctx->manager)
+        g_object_unref (ctx->manager);
+    g_free (ctx);
+}
+
+static void
+ensure_modem_oma (void)
+{
+    if (!ctx->modem_oma) {
+        g_printerr ("error: modem has no OMA capabilities\n");
+        exit (EXIT_FAILURE);
+    }
+
+    /* Success */
+}
+
+void
+mmcli_modem_oma_shutdown (void)
+{
+    context_free (ctx);
+}
+
+static void
+print_oma_status (void)
+{
+    gchar *features_str;
+    const MMOmaPendingNetworkInitiatedSession *pending_sessions;
+    guint n_pending_sessions;
+
+#undef VALIDATE_UNKNOWN
+#define VALIDATE_UNKNOWN(str) (str ? str : "unknown")
+
+    features_str = mm_oma_feature_build_string_from_mask (mm_modem_oma_get_features (ctx->modem_oma));
+
+    /* Global IDs */
+    g_print ("\n"
+             "%s\n",
+             VALIDATE_UNKNOWN (mm_modem_oma_get_path (ctx->modem_oma)));
+
+    /* Overall setup */
+    g_print ("  -------------------------\n"
+             "  Setup            | features: '%s'\n",
+             VALIDATE_UNKNOWN (features_str));
+
+    /* Current session */
+    if (mm_modem_oma_get_session_type (ctx->modem_oma) != MM_OMA_SESSION_TYPE_UNKNOWN) {
+        g_print ("  -------------------------\n"
+                 "  Current session  |     type: '%s'\n"
+                 "                   |    state: '%s'\n",
+            VALIDATE_UNKNOWN (mm_oma_session_type_get_string (mm_modem_oma_get_session_type (ctx->modem_oma))),
+            VALIDATE_UNKNOWN (mm_oma_session_state_get_string (mm_modem_oma_get_session_state (ctx->modem_oma))));
+    }
+
+    /* If 1 or more pending sessions... */
+    if (mm_modem_peek_pending_network_initiated_sessions (ctx->modem_oma, &pending_sessions, &n_pending_sessions) &&
+        n_pending_sessions > 0) {
+        guint i;
+
+        g_print ("  -------------------------\n"
+                 "  Pending sessions |\n");
+        for (i = 0; i < n_pending_sessions; i++) {
+            g_print ("               [%u] |     type: '%s'\n"
+                     "                    |       id: '%u'\n",
+                     i,
+                     VALIDATE_UNKNOWN (mm_oma_session_type_get_string (pending_sessions[i].session_type)),
+                     pending_sessions[i].session_id);
+        }
+    }
+
+    g_free (features_str);
+}
+
+static void
+setup_process_reply (gboolean result,
+                     const GError *error)
+{
+    if (!result) {
+        g_printerr ("error: couldn't setup OMA features: '%s'\n",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    g_print ("Successfully setup OMA features\n");
+}
+
+static void
+setup_ready (MMModemOma *modem,
+             GAsyncResult *result)
+{
+    gboolean res;
+    GError *error = NULL;
+
+    res = mm_modem_oma_setup_finish (modem, result, &error);
+    setup_process_reply (res, error);
+
+    mmcli_async_operation_done ();
+}
+
+static void
+start_process_reply (gboolean result,
+                     const GError *error)
+{
+    if (!result) {
+        g_printerr ("error: couldn't start OMA session: '%s'\n",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    g_print ("Successfully started OMA session\n");
+}
+
+static void
+start_ready (MMModemOma *modem,
+             GAsyncResult *result)
+{
+    gboolean res;
+    GError *error = NULL;
+
+    res = mm_modem_oma_start_client_initiated_session_finish (modem, result, &error);
+    start_process_reply (res, error);
+
+    mmcli_async_operation_done ();
+}
+
+static void
+accept_process_reply (gboolean result,
+                      const GError *error)
+{
+    if (!result) {
+        g_printerr ("error: couldn't %s OMA session: '%s'\n",
+                    accept_str ? "accept" : "reject",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    g_print ("Successfully %s OMA session\n",
+             accept_str ? "accepted" : "rejected");
+}
+
+static void
+accept_ready (MMModemOma *modem,
+              GAsyncResult *result)
+{
+    gboolean res;
+    GError *error = NULL;
+
+    res = mm_modem_oma_accept_network_initiated_session_finish (modem, result, &error);
+    accept_process_reply (res, error);
+
+    mmcli_async_operation_done ();
+}
+
+static void
+cancel_process_reply (gboolean result,
+                      const GError *error)
+{
+    if (!result) {
+        g_printerr ("error: couldn't cancel OMA session: '%s'\n",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    g_print ("Successfully cancelled OMA session\n");
+}
+
+static void
+cancel_ready (MMModemOma *modem,
+              GAsyncResult *result)
+{
+    gboolean res;
+    GError *error = NULL;
+
+    res = mm_modem_oma_cancel_session_finish (modem, result, &error);
+    cancel_process_reply (res, error);
+
+    mmcli_async_operation_done ();
+}
+
+static void
+get_modem_ready (GObject      *source,
+                 GAsyncResult *result)
+{
+    ctx->object = mmcli_get_modem_finish (result, &ctx->manager);
+    ctx->modem_oma = mm_object_get_modem_oma (ctx->object);
+
+    /* Setup operation timeout */
+    if (ctx->modem_oma)
+        mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_oma));
+
+    ensure_modem_oma ();
+
+    g_assert (!status_flag);
+
+    /* Request to setup OMA features? */
+    if (setup_str) {
+        GError *error = NULL;
+        MMOmaFeature features;
+
+        features = mm_common_get_oma_features_from_string (setup_str, &error);
+        if (error) {
+            g_printerr ("Error parsing OMA features string: '%s'\n", error->message);
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Asynchronously setting up OMA features...");
+        mm_modem_oma_setup (ctx->modem_oma,
+                            features,
+                            ctx->cancellable,
+                            (GAsyncReadyCallback)setup_ready,
+                            NULL);
+        return;
+    }
+
+    /* Request to start session? */
+    if (start_str) {
+        GError *error = NULL;
+        MMOmaSessionType session_type;
+
+        session_type = mm_common_get_oma_session_type_from_string (start_str, &error);
+        if (error) {
+            g_printerr ("Error parsing OMA session type string: '%s'\n", error->message);
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Asynchronously starting OMA session...");
+        mm_modem_oma_start_client_initiated_session (ctx->modem_oma,
+                                                     session_type,
+                                                     ctx->cancellable,
+                                                     (GAsyncReadyCallback)start_ready,
+                                                     NULL);
+        return;
+    }
+
+    /* Request to accept or reject session? */
+    if (accept_str || reject_str) {
+        guint session_id;
+
+        if (!mm_get_uint_from_str (accept_str ? accept_str : reject_str, &session_id)) {
+            g_printerr ("Error parsing OMA session id string: not a number");
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Asynchronously %s OMA session...", accept_str ? "accepting" : "rejecting");
+        mm_modem_oma_accept_network_initiated_session (ctx->modem_oma,
+                                                       session_id,
+                                                       !!accept_str,
+                                                       ctx->cancellable,
+                                                       (GAsyncReadyCallback)accept_ready,
+                                                       NULL);
+        return;
+    }
+
+    /* Request to cancel a session? */
+    if (cancel_flag) {
+        g_debug ("Asynchronously cancelling OMA session...");
+        mm_modem_oma_cancel_session (ctx->modem_oma,
+                                     ctx->cancellable,
+                                     (GAsyncReadyCallback)cancel_ready,
+                                     NULL);
+        return;
+    }
+
+    g_warn_if_reached ();
+}
+
+void
+mmcli_modem_oma_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_oma_run_synchronous (GDBusConnection *connection)
+{
+    GError *error = NULL;
+
+    /* Initialize context */
+    ctx = g_new0 (Context, 1);
+    ctx->object = mmcli_get_modem_sync (connection,
+                                        mmcli_get_common_modem_string (),
+                                        &ctx->manager);
+    ctx->modem_oma = mm_object_get_modem_oma (ctx->object);
+
+    /* Setup operation timeout */
+    if (ctx->modem_oma)
+        mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_oma));
+
+    ensure_modem_oma ();
+
+    /* Request to get status? */
+    if (status_flag) {
+        g_debug ("Printing OMA status...");
+        print_oma_status ();
+        return;
+    }
+
+    /* Request to setup OMA features? */
+    if (setup_str) {
+        gboolean result;
+        GError *error = NULL;
+        MMOmaFeature features;
+
+        features = mm_common_get_oma_features_from_string (setup_str, &error);
+        if (error) {
+            g_printerr ("Error parsing OMA features string: '%s'\n", error->message);
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Synchronously setting up OMA features...");
+        result = mm_modem_oma_setup_sync (ctx->modem_oma,
+                                          features,
+                                          NULL,
+                                          &error);
+        setup_process_reply (result, error);
+        return;
+    }
+
+    /* Request to start session? */
+    if (start_str) {
+        gboolean result;
+        GError *error = NULL;
+        MMOmaSessionType session_type;
+
+        session_type = mm_common_get_oma_session_type_from_string (start_str, &error);
+        if (error) {
+            g_printerr ("Error parsing OMA session type string: '%s'\n", error->message);
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Synchronously starting OMA session...");
+        result = mm_modem_oma_start_client_initiated_session_sync (ctx->modem_oma,
+                                                                   session_type,
+                                                                   NULL,
+                                                                   &error);
+        start_process_reply (result, error);
+        return;
+    }
+
+    /* Request to accept or reject session? */
+    if (accept_str || reject_str) {
+        gboolean result;
+        GError *error = NULL;
+        guint session_id;
+
+        if (!mm_get_uint_from_str (accept_str ? accept_str : reject_str, &session_id)) {
+            g_printerr ("Error parsing OMA session id string: not a number");
+            exit (EXIT_FAILURE);
+        }
+
+        g_debug ("Synchronously %s OMA session...", accept_str ? "accepting" : "rejecting");
+        result = mm_modem_oma_accept_network_initiated_session_sync (ctx->modem_oma,
+                                                                     session_id,
+                                                                     !!accept_str,
+                                                                     NULL,
+                                                                     &error);
+        accept_process_reply (result, error);
+        return;
+    }
+
+    /* Request to cancel a session? */
+    if (cancel_flag) {
+        gboolean result;
+
+        g_debug ("Synchronously cancelling OMA session...");
+        result = mm_modem_oma_cancel_session_sync (ctx->modem_oma,
+                                                   NULL,
+                                                   &error);
+        cancel_process_reply (result, error);
+        return;
+    }
+
+    g_warn_if_reached ();
+}

cli/mmcli.c

@@ -210,6 +210,8 @@ main (gint argc, gchar **argv)
 	                            mmcli_modem_firmware_get_option_group ());
 	g_option_context_add_group (context,
 	                            mmcli_modem_signal_get_option_group ());
+	g_option_context_add_group (context,
+	                            mmcli_modem_oma_get_option_group ());
 	g_option_context_add_group (context,
 	                            mmcli_sim_get_option_group ());
 	g_option_context_add_group (context,
@@ -334,6 +336,13 @@ main (gint argc, gchar **argv)
         else
             mmcli_modem_signal_run_synchronous (connection);
     }
+    /* Modem Oma options? */
+    else if (mmcli_modem_oma_options_enabled ()) {
+        if (async_flag)
+            mmcli_modem_oma_run_asynchronous (connection, cancellable);
+        else
+            mmcli_modem_oma_run_synchronous (connection);
+    }
     /* Modem options?
      * NOTE: let this check be always the last one, as other groups also need
      * having a modem specified, and therefore if -m is set, modem options
@@ -372,6 +381,8 @@ main (gint argc, gchar **argv)
         mmcli_modem_firmware_shutdown ();
     } else if (mmcli_modem_signal_options_enabled ()) {
         mmcli_modem_signal_shutdown ();
+    } else if (mmcli_modem_oma_options_enabled ()) {
+        mmcli_modem_oma_shutdown ();
     }  else if (mmcli_sim_options_enabled ()) {
         mmcli_sim_shutdown ();
     } else if (mmcli_bearer_options_enabled ()) {

cli/mmcli.h

@@ -109,6 +109,14 @@ void          mmcli_modem_signal_run_asynchronous   (GDBusConnection *connection
 void          mmcli_modem_signal_run_synchronous    (GDBusConnection *connection);
 void          mmcli_modem_signal_shutdown           (void);
 
+/* Oma group */
+GOptionGroup *mmcli_modem_oma_get_option_group   (void);
+gboolean      mmcli_modem_oma_options_enabled    (void);
+void          mmcli_modem_oma_run_asynchronous   (GDBusConnection *connection,
+                                                  GCancellable    *cancellable);
+void          mmcli_modem_oma_run_synchronous    (GDBusConnection *connection);
+void          mmcli_modem_oma_shutdown           (void);
+
 /* Bearer group */
 GOptionGroup *mmcli_bearer_get_option_group   (void);
 gboolean      mmcli_bearer_options_enabled    (void);

docs/man/mmcli.8

@@ -65,6 +65,9 @@ Show time specific options.
 .B \-\-help\-firmware
 Show firmware specific options.
 .TP
+.B \-\-help\-oma
+Show OMA specific options.
+.TP
 .B \-\-help\-sim
 Show SIM card specific options.
 .TP
@@ -426,6 +429,30 @@ of available firmware images can be seen using the
 
 The \fBID\fR provided is a \fIUNIQUE\fR identifier for the firmware.
 
+.SH OMA OPTIONS
+All OMA options require the \fB\-\-modem\fR or \fB\-m\fR option.
+
+.TP
+.B \-\-oma\-status
+Show the status of the OMA device management subsystem.
+.TP
+.B \-\-oma\-start\-client\-initiated\-session=[SESSION TYPE]
+Request to start a client initiated session.
+
+The given session type must be one of:
+ 'client\-initiated\-device\-configure'
+ 'client\-initiated\-prl\-update'
+ 'client\-initiated\-hands\-free\-activation'
+.TP
+.B \-\-oma\-accept\-network\-initiated\-session=[SESSION ID]
+Request to accept a network initiated session.
+.TP
+.B \-\-oma\-reject\-network\-initiated\-session=[SESSION ID]
+Request to reject a network initiated session.
+.TP
+.B \-\-oma\-cancel\-session
+Request to cancel current OMA session, if any.
+
 .SH SIM OPTIONS
 .TP
 .B \-\-pin=PIN

libmm-glib/mm-common-helpers.c

@@ -957,6 +957,78 @@ mm_common_get_sms_storage_from_string (const gchar *str,
     return MM_SMS_STORAGE_UNKNOWN;
 }
 
+MMOmaFeature
+mm_common_get_oma_features_from_string (const gchar *str,
+                                        GError **error)
+{
+    GError *inner_error = NULL;
+    MMOmaFeature features;
+    gchar **feature_strings;
+	GFlagsClass *flags_class;
+
+    features = MM_OMA_FEATURE_NONE;
+
+    flags_class = G_FLAGS_CLASS (g_type_class_ref (MM_TYPE_OMA_FEATURE));
+    feature_strings = g_strsplit (str, "|", -1);
+
+    if (feature_strings) {
+        guint i;
+
+        for (i = 0; feature_strings[i]; i++) {
+            guint j;
+            gboolean found = FALSE;
+
+            for (j = 0; flags_class->values[j].value_nick; j++) {
+                if (!g_ascii_strcasecmp (feature_strings[i], flags_class->values[j].value_nick)) {
+                    features |= flags_class->values[j].value;
+                    found = TRUE;
+                    break;
+                }
+            }
+
+            if (!found) {
+                inner_error = g_error_new (
+                    MM_CORE_ERROR,
+                    MM_CORE_ERROR_INVALID_ARGS,
+                    "Couldn't match '%s' with a valid MMOmaFeature value",
+                    feature_strings[i]);
+                break;
+            }
+        }
+    }
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        features = MM_OMA_FEATURE_NONE;
+    }
+
+    g_type_class_unref (flags_class);
+    g_strfreev (feature_strings);
+    return features;
+}
+
+MMOmaSessionType
+mm_common_get_oma_session_type_from_string (const gchar *str,
+                                            GError **error)
+{
+	GEnumClass *enum_class;
+    guint i;
+
+    enum_class = G_ENUM_CLASS (g_type_class_ref (MM_TYPE_OMA_SESSION_TYPE));
+
+    for (i = 0; enum_class->values[i].value_nick; i++) {
+        if (!g_ascii_strcasecmp (str, enum_class->values[i].value_nick))
+            return enum_class->values[i].value;
+    }
+
+    g_set_error (error,
+                 MM_CORE_ERROR,
+                 MM_CORE_ERROR_INVALID_ARGS,
+                 "Couldn't match '%s' with a valid MMOmaSessionType value",
+                 str);
+    return MM_OMA_SESSION_TYPE_UNKNOWN;
+}
+
 GVariant *
 mm_common_build_bands_unknown (void)
 {

libmm-glib/mm-common-helpers.h

@@ -59,6 +59,10 @@ MMBearerAllowedAuth   mm_common_get_allowed_auth_from_string (const gchar *str,
                                                               GError **error);
 MMSmsStorage          mm_common_get_sms_storage_from_string  (const gchar *str,
                                                               GError **error);
+MMOmaFeature          mm_common_get_oma_features_from_string (const gchar *str,
+                                                              GError **error);
+MMOmaSessionType      mm_common_get_oma_session_type_from_string (const gchar *str,
+                                                                  GError **error);
 
 GArray          *mm_common_ports_variant_to_garray (GVariant *variant);
 MMModemPortInfo *mm_common_ports_variant_to_array  (GVariant *variant,