cli: start to port Modem actions to use the new libmm-glib

7 files changed, 655 insertions, 444 deletions

diff --git a/cli/Makefile.am b/cli/Makefile.am
index 4c4add02..fcff016a 100644
--- a/cli/Makefile.am
+++ b/cli/Makefile.am
@@ -12,6 +12,8 @@ mmcli_CPPFLAGS = \
 mmcli_SOURCES = \
 	mmcli.h \
 	mmcli.c \
+	mmcli-common.h \
+	mmcli-common.c \
 	mmcli-manager.c \
 	mmcli-modem.c
 
diff --git a/cli/mmcli-common.c b/cli/mmcli-common.c
new file mode 100644
index 00000000..0e5b746e
--- /dev/null
+++ b/cli/mmcli-common.c
@@ -0,0 +1,237 @@
+/* -*- 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 <stdlib.h>
+
+#include "mmcli-common.h"
+
+static void
+manager_new_ready (GDBusConnection *connection,
+                   GAsyncResult *res,
+                   GSimpleAsyncResult *simple)
+{
+    MMManager *manager;
+    gchar *name_owner;
+    GError *error = NULL;
+
+    manager = mm_manager_new_finish (res, &error);
+    if (!manager) {
+        g_printerr ("error: couldn't create manager: %s\n",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    name_owner = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (manager));
+    if (!name_owner) {
+        g_printerr ("error: couldn't find the ModemManager process in the bus\n");
+        exit (EXIT_FAILURE);
+    }
+
+    g_debug ("ModemManager process found at '%s'", name_owner);
+    g_free (name_owner);
+
+    g_simple_async_result_set_op_res_gpointer (simple, manager, NULL);
+    g_simple_async_result_complete (simple);
+    g_object_unref (simple);
+}
+
+MMManager *
+mmcli_get_manager_finish (GAsyncResult *res)
+{
+    return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
+}
+
+void
+mmcli_get_manager (GDBusConnection *connection,
+                   GCancellable *cancellable,
+                   GAsyncReadyCallback callback,
+                   gpointer user_data)
+{
+    GSimpleAsyncResult *result;
+
+    result = g_simple_async_result_new (G_OBJECT (connection),
+                                        callback,
+                                        user_data,
+                                        mmcli_get_manager);
+    mm_manager_new (connection,
+                    G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
+                    cancellable,
+                    (GAsyncReadyCallback)manager_new_ready,
+                    result);
+}
+
+MMManager *
+mmcli_get_manager_sync (GDBusConnection *connection)
+{
+    MMManager *manager;
+    gchar *name_owner;
+    GError *error = NULL;
+
+    manager = mm_manager_new_sync (connection,
+                                   G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
+                                   NULL,
+                                   &error);
+    if (!manager) {
+        g_printerr ("error: couldn't create manager: %s\n",
+                    error ? error->message : "unknown error");
+        exit (EXIT_FAILURE);
+    }
+
+    name_owner = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (manager));
+    if (!name_owner) {
+        g_printerr ("error: couldn't find the ModemManager process in the bus\n");
+        exit (EXIT_FAILURE);
+    }
+
+    g_debug ("ModemManager process found at '%s'", name_owner);
+    g_free (name_owner);
+
+    return manager;
+}
+
+#define MODEM_PATH_TAG "modem-path-tag"
+
+static MMModem *
+find_modem (MMManager *manager,
+            const gchar *modem_path)
+{
+    GList *modems;
+    GList *l;
+    MMModem *found = NULL;
+
+    modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager));
+    for (l = modems; l; l = g_list_next (l)) {
+        MMModem *modem = MM_MODEM (l->data);
+
+        if (g_str_equal (mm_modem_get_path (modem),
+                         modem_path)) {
+            found = g_object_ref (modem);
+            break;
+        }
+    }
+    g_list_foreach (modems, (GFunc)g_object_unref, NULL);
+    g_list_free (modems);
+
+    if (!found) {
+        g_printerr ("error: couldn't find the Modem at '%s'\n", modem_path);
+        exit (EXIT_FAILURE);
+    }
+
+    g_debug ("Modem found at '%s'", modem_path);
+
+    return found;
+}
+
+static gchar *
+get_modem_path (const gchar *modem_str)
+{
+    gchar *modem_path;
+
+    /* We must have a given modem specified */
+    if (!modem_str) {
+        g_printerr ("error: no modem was specified\n");
+        exit (EXIT_FAILURE);
+    }
+
+    /* Modem path may come in two ways: full DBus path or just modem index.
+     * If it is a modem index, we'll need to generate the DBus path ourselves */
+    if (modem_str[0] == '/')
+        modem_path = g_strdup (modem_str);
+    else {
+        if (g_ascii_isdigit (modem_str[0]))
+            modem_path = g_strdup_printf (MM_DBUS_PATH "/Modems/%s", modem_str);
+        else {
+            g_printerr ("error: invalid modem string specified: '%s'\n",
+                        modem_str);
+            exit (EXIT_FAILURE);
+        }
+    }
+
+    return modem_path;
+}
+
+static void
+get_manager_ready (GDBusConnection *connection,
+                   GAsyncResult *res,
+                   GSimpleAsyncResult *simple)
+{
+    MMManager *manager;
+    MMModem *found;
+    const gchar *modem_path;
+
+    manager = mmcli_get_manager_finish (res);
+    modem_path = g_object_get_data (G_OBJECT (simple), MODEM_PATH_TAG);
+    found = find_modem (manager, modem_path);
+    g_object_unref (manager);
+
+    g_simple_async_result_set_op_res_gpointer (simple, found, NULL);
+    g_simple_async_result_complete (simple);
+    g_object_unref (simple);
+}
+
+MMModem *
+mmcli_get_modem_finish (GAsyncResult *res)
+{
+    return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
+}
+
+void
+mmcli_get_modem (GDBusConnection *connection,
+                 const gchar *modem_str,
+                 GCancellable *cancellable,
+                 GAsyncReadyCallback callback,
+                 gpointer user_data)
+{
+    GSimpleAsyncResult *result;
+    gchar *modem_path;
+
+    modem_path = get_modem_path (modem_str);
+    result = g_simple_async_result_new (G_OBJECT (connection),
+                                        callback,
+                                        user_data,
+                                        mmcli_get_modem);
+    g_object_set_data_full (G_OBJECT (result),
+                            MODEM_PATH_TAG,
+                            modem_path,
+                            g_free);
+
+    mmcli_get_manager (connection,
+                       cancellable,
+                       (GAsyncReadyCallback)get_manager_ready,
+                       result);
+}
+
+MMModem *
+mmcli_get_modem_sync (GDBusConnection *connection,
+                      const gchar *modem_str)
+{
+    MMManager *manager;
+    MMModem *found;
+    gchar *modem_path;
+
+    manager = mmcli_get_manager_sync (connection);
+    modem_path = get_modem_path (modem_str);
+
+    found = find_modem (manager, modem_path);
+    g_object_unref (manager);
+    g_free (modem_path);
+
+    return found;
+}
diff --git a/cli/mmcli-common.h b/cli/mmcli-common.h
new file mode 100644
index 00000000..42e2a84e
--- /dev/null
+++ b/cli/mmcli-common.h
@@ -0,0 +1,39 @@
+/* -*- 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) 2011 Aleksander Morgado <aleksander@gnu.org>
+ */
+
+#ifndef _MMCLI_COMMON_H_
+#define _MMCLI_COMMON_H_
+
+#include <gio/gio.h>
+#include <libmm-glib.h>
+
+void       mmcli_get_manager        (GDBusConnection *connection,
+                                     GCancellable *cancellable,
+                                     GAsyncReadyCallback callback,
+                                     gpointer user_data);
+MMManager *mmcli_get_manager_finish (GAsyncResult *res);
+MMManager *mmcli_get_manager_sync   (GDBusConnection *connection);
+
+
+void     mmcli_get_modem        (GDBusConnection *connection,
+                                 const gchar *modem_str,
+                                 GCancellable *cancellable,
+                                 GAsyncReadyCallback callback,
+                                 gpointer user_data);
+MMModem *mmcli_get_modem_finish (GAsyncResult *res);
+MMModem *mmcli_get_modem_sync   (GDBusConnection *connection,
+                                 const gchar *modem_str);
+
+#endif /* _MMCLI_COMMON_H_ */
diff --git a/cli/mmcli-manager.c b/cli/mmcli-manager.c
index 4c8c5230..8e84619b 100644
--- a/cli/mmcli-manager.c
+++ b/cli/mmcli-manager.c
@@ -32,6 +32,7 @@
 #include "libmm-glib.h"
 
 #include "mmcli.h"
+#include "mmcli-common.h"
 
 /* Context */
 typedef struct {
@@ -90,7 +91,7 @@ mmcli_manager_options_enabled (void)
     n_actions = (list_modems_flag +
                  monitor_modems_flag +
                  scan_modems_flag +
-                 (set_logging_str ? 1 : 0));
+                 !!set_logging_str);
 
     if (n_actions > 1) {
         g_printerr ("error: too many manager actions requested\n");
@@ -206,11 +207,14 @@ list_current_modems (MMManager *manager)
     else {
         GList *l;
 
-        g_print ("Found %u modems\n", g_list_length (modems));
+        g_print ("Found %u modems:\n", g_list_length (modems));
         for (l = modems; l; l = g_list_next (l)) {
-            g_print ("\t[TODO: Print path]\n");
-            g_object_unref (l->data);
+            MMModem *modem = MM_MODEM (l->data);
+
+            g_print ("\t%s\n",
+                     mm_modem_get_path (modem));
         }
+        g_list_foreach (modems, (GFunc)g_object_unref, NULL);
         g_list_free (modems);
     }
 }
@@ -222,28 +226,11 @@ cancelled (GCancellable *cancellable)
 }
 
 static void
-manager_new_ready (GObject      *source,
+get_manager_ready (GObject      *source,
                    GAsyncResult *result,
                    gpointer      none)
 {
-    gchar *name_owner;
-    GError *error = NULL;
-
-    ctx->manager = mm_manager_new_finish (result, &error);
-    if (!ctx->manager) {
-        g_printerr ("error: couldn't create manager: %s\n",
-                    error ? error->message : "unknown error");
-        exit (EXIT_FAILURE);
-    }
-
-    name_owner = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (ctx->manager));
-    if (!name_owner) {
-        g_printerr ("error: couldn't find the ModemManager process in the bus\n");
-        exit (EXIT_FAILURE);
-    }
-
-    g_debug ("ModemManager process found at '%s'", name_owner);
-    g_free (name_owner);
+    ctx->manager = mmcli_get_manager_finish (result);
 
     /* Request to set log level? */
     if (set_logging_str) {
@@ -304,17 +291,15 @@ mmcli_manager_run_asynchronous (GDBusConnection *connection,
         ctx->cancellable = g_object_ref (cancellable);
 
     /* Create a new Manager object asynchronously */
-    mm_manager_new (connection,
-                    G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
-                    cancellable,
-                    (GAsyncReadyCallback)manager_new_ready,
-                    NULL);
+    mmcli_get_manager (connection,
+                       cancellable,
+                       (GAsyncReadyCallback)get_manager_ready,
+                       NULL);
 }
 
 void
 mmcli_manager_run_synchronous (GDBusConnection *connection)
 {
-    gchar *name_owner;
     GError *error = NULL;
 
     if (monitor_modems_flag) {
@@ -324,24 +309,7 @@ mmcli_manager_run_synchronous (GDBusConnection *connection)
 
     /* Initialize context */
     ctx = g_new0 (Context, 1);
-    ctx->manager = mm_manager_new_sync (connection,
-                                        G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
-                                        NULL,
-                                        &error);
-    if (!ctx->manager) {
-        g_printerr ("error: couldn't create manager: %s\n",
-                    error ? error->message : "unknown error");
-        exit (EXIT_FAILURE);
-    }
-
-    name_owner = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (ctx->manager));
-    if (!name_owner) {
-        g_printerr ("error: couldn't find the ModemManager process in the bus\n");
-        exit (EXIT_FAILURE);
-    }
-
-    g_debug ("ModemManager process found at '%s'", name_owner);
-    g_free (name_owner);
+    ctx->manager = mmcli_get_manager_sync (connection);
 
     /* Request to set log level? */
     if (set_logging_str) {
diff --git a/cli/mmcli-modem.c b/cli/mmcli-modem.c
index 66705757..100e0cd4 100644
--- a/cli/mmcli-modem.c
+++ b/cli/mmcli-modem.c
@@ -28,51 +28,53 @@
 #include <glib.h>
 #include <gio/gio.h>
 
-#include <libmm.h>
+#include <libmm-glib.h>
 
 #include "mmcli.h"
+#include "mmcli-common.h"
 
 /* Context */
 typedef struct {
-    /* Input options */
-    gchar *modem_str;
-    gboolean info_flag;
-    gboolean monitor_state_flag;
-    gboolean enable_flag;
-    gboolean disable_flag;
-    gboolean reset_flag;
-    gchar *factory_reset_str;
-    /* The modem proxy */
+    GCancellable *cancellable;
     MMModem *modem;
 } Context;
-static Context ctxt;
+static Context *ctx;
+
+/* Options */
+static gchar *modem_str;
+static gboolean info_flag;
+static gboolean monitor_state_flag;
+static gboolean enable_flag;
+static gboolean disable_flag;
+static gboolean reset_flag;
+static gchar *factory_reset_str;
 
 static GOptionEntry entries[] = {
-    { "modem", 'm', 0, G_OPTION_ARG_STRING, &ctxt.modem_str,
+    { "modem", 'm', 0, G_OPTION_ARG_STRING, &modem_str,
       "Specify modem by path or index",
       NULL
     },
-    { "info", 'i', 0, G_OPTION_ARG_NONE, &ctxt.info_flag,
+    { "info", 'i', 0, G_OPTION_ARG_NONE, &info_flag,
       "Get information of a given modem",
       NULL
     },
-    { "monitor-state", 'w', 0, G_OPTION_ARG_NONE, &ctxt.monitor_state_flag,
+    { "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, &ctxt.enable_flag,
+    { "enable", 'e', 0, G_OPTION_ARG_NONE, &enable_flag,
       "Enable a given modem",
       NULL
     },
-    { "disable", 'd', 0, G_OPTION_ARG_NONE, &ctxt.disable_flag,
+    { "disable", 'd', 0, G_OPTION_ARG_NONE, &disable_flag,
       "Disable a given modem",
       NULL
     },
-    { "reset", 'r', 0, G_OPTION_ARG_NONE, &ctxt.reset_flag,
+    { "reset", 'r', 0, G_OPTION_ARG_NONE, &reset_flag,
       "Reset a given modem",
       NULL
     },
-    { "factory-reset", 0, 0, G_OPTION_ARG_STRING, &ctxt.factory_reset_str,
+    { "factory-reset", 0, 0, G_OPTION_ARG_STRING, &factory_reset_str,
       "Reset a given modem to its factory state",
       "[CODE]"
     },
@@ -100,12 +102,12 @@ mmcli_modem_options_enabled (void)
 {
     guint n_actions;
 
-    n_actions = (ctxt.info_flag +
-                 ctxt.monitor_state_flag +
-                 ctxt.enable_flag +
-                 ctxt.disable_flag +
-                 ctxt.reset_flag +
-                 !!ctxt.factory_reset_str);
+    n_actions = (info_flag +
+                 monitor_state_flag +
+                 enable_flag +
+                 disable_flag +
+                 reset_flag +
+                 !!factory_reset_str);
 
     if (n_actions > 1) {
         g_printerr ("error: too many modem actions requested\n");
@@ -116,293 +118,236 @@ mmcli_modem_options_enabled (void)
 }
 
 static void
-init (GDBusConnection *connection)
+context_free (Context *ctx)
 {
-    GError *error = NULL;
-
-    /* We must have a given modem specified */
-    if (!ctxt.modem_str) {
-        g_printerr ("error: no modem was specified\n");
-        exit (EXIT_FAILURE);
-    }
-
-    /* Modem path may come in two ways: full DBus path or just modem index.
-     * If it is a modem index, we'll need to generate the DBus path ourselves */
-    if (ctxt.modem_str[0] != '/') {
-        if (g_ascii_isdigit (ctxt.modem_str[0])) {
-            gchar *tmp;
-
-            tmp = g_strdup_printf (MM_DBUS_PATH "/Modems/%s", ctxt.modem_str);
-            g_free (ctxt.modem_str);
-            ctxt.modem_str = tmp;
-        } else {
-            g_printerr ("error: invalid modem string specified: '%s'\n",
-                        ctxt.modem_str);
-            exit (EXIT_FAILURE);
-        }
-    }
+    if (!ctx)
+        return;
 
-    /* Create new modem */
-    ctxt.modem = mm_modem_new (ctxt.modem_str, connection, NULL, &error);
-    if (!ctxt.modem) {
-        g_printerr ("error: couldn't find modem '%s': %s\n",
-                    ctxt.modem_str,
-                    error ? error->message : "unknown error");
-        exit (EXIT_FAILURE);
-    }
+    if (ctx->cancellable)
+        g_object_unref (ctx->cancellable);
+    if (ctx->modem)
+        g_object_unref (ctx->modem);
+    g_free (ctx);
 }
 
 void
 mmcli_modem_shutdown (void)
 {
-    g_free (ctxt.modem_str);
-    g_object_unref (ctxt.modem);
-}
-
-static gchar *
-prefix_newlines (const gchar *prefix,
-                 const gchar *str)
-{
-    GString *prefixed_string = NULL;
-    const gchar *line_start = str;
-    const gchar *line_end;
-
-    while ((line_end = strchr (line_start, '\n'))) {
-        gssize line_length;
-
-        line_length = line_end - line_start;
-        if (line_start[line_length - 1] == '\r')
-            line_length--;
-
-        if (line_length > 0) {
-            if (prefixed_string) {
-                /* If not the first line, add the prefix */
-                g_string_append_printf (prefixed_string,
-                                        "\n%s", prefix);
-            } else {
-                prefixed_string = g_string_new ("");
-            }
-
-            g_string_append_len (prefixed_string,
-                                 line_start,
-                                 line_length);
-        }
-
-        line_start = line_end + 1;
-    }
-
-    return (prefixed_string ?
-            g_string_free (prefixed_string, FALSE) :
-            NULL);
-}
-
-static const gchar *
-get_ip_method_string (MMModemIpMethod ip_method)
-{
-    switch (ip_method) {
-    case MM_MODEM_IP_METHOD_PPP:
-        return "PPP";
-    case MM_MODEM_IP_METHOD_STATIC:
-        return "Static";
-    case MM_MODEM_IP_METHOD_DHCP:
-        return "DHCP";
-    }
-
-    g_warn_if_reached ();
-    return NULL;
-}
-
-static const gchar *
-get_modem_type_string (MMModemType type)
-{
-    switch (type) {
-    case MM_MODEM_TYPE_UNKNOWN:
-        return "Unknown";
-    case MM_MODEM_TYPE_GSM:
-        return "GSM";
-    case MM_MODEM_TYPE_CDMA:
-        return "CDMA";
-    }
-
-    g_warn_if_reached ();
-    return NULL;
-}
-
-static const gchar *
-get_state_string (MMModemState state)
-{
-    switch (state) {
-    case MM_MODEM_STATE_UNKNOWN:
-        return "Unknown";
-    case MM_MODEM_STATE_DISABLED:
-        return "Disabled";
-    case MM_MODEM_STATE_DISABLING:
-        return "Disabling";
-    case MM_MODEM_STATE_ENABLING:
-        return "Enabling";
-    case MM_MODEM_STATE_ENABLED:
-        return "Enabled";
-    case MM_MODEM_STATE_SEARCHING:
-        return "Searching";
-    case MM_MODEM_STATE_REGISTERED:
-        return "Registered";
-    case MM_MODEM_STATE_DISCONNECTING:
-        return "Disconnecting";
-    case MM_MODEM_STATE_CONNECTING:
-        return "Connecting";
-    case MM_MODEM_STATE_CONNECTED:
-        return "Connected";
-    }
-
-    g_warn_if_reached ();
-    return NULL;
-}
-
-static const gchar *
-get_state_reason_string (MMModemStateReason reason)
-{
-    switch (reason) {
-    case MM_MODEM_STATE_REASON_NONE:
-        return "None or unknown";
-    case MM_MODEM_STATE_REASON_USER_REQUESTED:
-        return "User request";
-    case MM_MODEM_STATE_REASON_SUSPEND:
-        return "Suspend";
-    }
-
-    g_warn_if_reached ();
-    return NULL;
-}
-
-static void
-get_info_process_reply (gboolean      result,
-                        const GError *error,
-                        const gchar  *manufacturer,
-                        const gchar  *model,
-                        const gchar  *revision)
-{
-    gchar *prefixed_revision;
-    gchar *master_device;
-    gchar *device;
-    gchar *device_id;
-    gchar *equipment_id;
-    gchar *driver;
-    gchar *plugin;
-    MMModemType type;
-    gboolean enabled;
-    gchar *unlock_required;
-    guint32 unlock_retries;
-    gchar *unlock;
-    MMModemIpMethod ip_method;
-    MMModemState state;
-
-    if (!result) {
-        g_printerr ("couldn't get info from modem: '%s'\n",
-                    error ? error->message : "unknown error");
-        exit (EXIT_FAILURE);
-    }
-
-    /* Get additional info from properties */
-    master_device = mm_modem_get_master_device (ctxt.modem);
-    device = mm_modem_get_device (ctxt.modem);
-    device_id = mm_modem_get_device_identifier (ctxt.modem);
-    equipment_id = mm_modem_get_equipment_identifier (ctxt.modem);
-    driver = mm_modem_get_driver (ctxt.modem);
-    plugin = mm_modem_get_plugin (ctxt.modem);
-    type = mm_modem_get_modem_type (ctxt.modem);
-    enabled = mm_modem_get_enabled (ctxt.modem);
-    unlock_required = mm_modem_get_unlock_required (ctxt.modem);
-    unlock_retries = mm_modem_get_unlock_retries (ctxt.modem);
-    ip_method = mm_modem_get_ip_method (ctxt.modem);
-    state = mm_modem_get_state (ctxt.modem);
-
-    /* Strings with mixed properties */
-    unlock = (unlock_required ?
-              g_strdup_printf ("%s (%u retries)",
-                               unlock_required,
-                               unlock_retries) :
-              g_strdup ("not required"));
-
-    /* Rework possible multiline strings */
-    prefixed_revision = prefix_newlines ("           |                 ",
-                                         revision);
-
-    g_print ("\n"
-             "%s\n"
-             "  -------------------------\n"
-             "  Hardware |  manufacturer: '%s'\n"
-             "           |         model: '%s'\n"
-             "           |      revision: '%s'\n"
-             "           |          type: '%s'\n"
-             "  -------------------------\n"
-             "  System   | master device: '%s'\n"
-             "           |        device: '%s'\n"
-             "           |     device id: '%s'\n"
-             "           |  equipment id: '%s'\n"
-             "           |        driver: '%s'\n"
-             "           |        plugin: '%s'\n"
-             "  -------------------------\n"
-             "  Status   |       enabled: '%s'\n"
-             "           |        unlock: '%s'\n"
-             "           |     IP method: '%s'\n"
-             "           |         state: '%s'\n"
-             "\n",
-             ctxt.modem_str,
-             manufacturer,
-             model,
-             prefixed_revision ? prefixed_revision : revision,
-             get_modem_type_string (type),
-             master_device,
-             device,
-             device_id,
-             equipment_id,
-             driver,
-             plugin,
-             enabled ? "yes" : "no",
-             unlock,
-             get_ip_method_string (ip_method),
-             get_state_string (state));
-
-    g_free (prefixed_revision);
-    g_free (master_device);
-    g_free (device);
-    g_free (device_id);
-    g_free (equipment_id);
-    g_free (driver);
-    g_free (plugin);
-    g_free (unlock_required);
-    g_free (unlock);
+    context_free (ctx);
 }
 
-static void
-get_info_ready (MMModem      *modem,
-                GAsyncResult *result,
-                gpointer      nothing)
-{
-    gboolean operation_result;
-    gchar *manufacturer = NULL;
-    gchar *model = NULL;
-    gchar *revision = NULL;
-    GError *error = NULL;
-
-    operation_result = mm_modem_get_info_finish (modem,
-                                                 result,
-                                                 &manufacturer,
-                                                 &model,
-                                                 &revision,
-                                                 &error);
-    get_info_process_reply (operation_result,
-                            error,
-                            manufacturer,
-                            model,
-                            revision);
-
-    g_free (manufacturer);
-    g_free (model);
-    g_free (revision);
-
-    mmcli_async_operation_done ();
-}
+/* static gchar * */
+/* prefix_newlines (const gchar *prefix, */
+/*                  const gchar *str) */
+/* { */
+/*     GString *prefixed_string = NULL; */
+/*     const gchar *line_start = str; */
+/*     const gchar *line_end; */
+
+/*     while ((line_end = strchr (line_start, '\n'))) { */
+/*         gssize line_length; */
+
+/*         line_length = line_end - line_start; */
+/*         if (line_start[line_length - 1] == '\r') */
+/*             line_length--; */
+
+/*         if (line_length > 0) { */
+/*             if (prefixed_string) { */
+/*                 /\* If not the first line, add the prefix *\/ */
+/*                 g_string_append_printf (prefixed_string, */
+/*                                         "\n%s", prefix); */
+/*             } else { */
+/*                 prefixed_string = g_string_new (""); */
+/*             } */
+
+/*             g_string_append_len (prefixed_string, */
+/*                                  line_start, */
+/*                                  line_length); */
+/*         } */
+
+/*         line_start = line_end + 1; */
+/*     } */
+
+/*     return (prefixed_string ? */
+/*             g_string_free (prefixed_string, FALSE) : */
+/*             NULL); */
+/* } */
+
+/* static const gchar * */
+/* get_state_string (MMModemState state) */
+/* { */
+/*     switch (state) { */
+/*     case MM_MODEM_STATE_UNKNOWN: */
+/*         return "Unknown"; */
+/*     case MM_MODEM_STATE_DISABLED: */
+/*         return "Disabled"; */
+/*     case MM_MODEM_STATE_DISABLING: */
+/*         return "Disabling"; */
+/*     case MM_MODEM_STATE_ENABLING: */
+/*         return "Enabling"; */
+/*     case MM_MODEM_STATE_ENABLED: */
+/*         return "Enabled"; */
+/*     case MM_MODEM_STATE_SEARCHING: */
+/*         return "Searching"; */
+/*     case MM_MODEM_STATE_REGISTERED: */
+/*         return "Registered"; */
+/*     case MM_MODEM_STATE_DISCONNECTING: */
+/*         return "Disconnecting"; */
+/*     case MM_MODEM_STATE_CONNECTING: */
+/*         return "Connecting"; */
+/*     case MM_MODEM_STATE_CONNECTED: */
+/*         return "Connected"; */
+/*     } */
+
+/*     g_warn_if_reached (); */
+/*     return NULL; */
+/* } */
+
+/* static const gchar * */
+/* get_state_reason_string (MMModemStateReason reason) */
+/* { */
+/*     switch (reason) { */
+/*     case MM_MODEM_STATE_REASON_NONE: */
+/*         return "None or unknown"; */
+/*     case MM_MODEM_STATE_REASON_USER_REQUESTED: */
+/*         return "User request"; */
+/*     case MM_MODEM_STATE_REASON_SUSPEND: */
+/*         return "Suspend"; */
+/*     } */
+
+/*     g_warn_if_reached (); */
+/*     return NULL; */
+/* } */
+
+/* static void */
+/* get_info_process_reply (gboolean      result, */
+/*                         const GError *error, */
+/*                         const gchar  *manufacturer, */
+/*                         const gchar  *model, */
+/*                         const gchar  *revision) */
+/* { */
+/*     gchar *prefixed_revision; */
+/*     gchar *master_device; */
+/*     gchar *device; */
+/*     gchar *device_id; */
+/*     gchar *equipment_id; */
+/*     gchar *driver; */
+/*     gchar *plugin; */
+/*     MMModemType type; */
+/*     gboolean enabled; */
+/*     gchar *unlock_required; */
+/*     guint32 unlock_retries; */
+/*     gchar *unlock; */
+/*     MMModemIpMethod ip_method; */
+/*     MMModemState state; */
+
+/*     if (!result) { */
+/*         g_printerr ("couldn't get info from modem: '%s'\n", */
+/*                     error ? error->message : "unknown error"); */
+/*         exit (EXIT_FAILURE); */
+/*     } */
+
+/*     /\* Get additional info from properties *\/ */
+/*     master_device = mm_modem_get_master_device (ctxt.modem); */
+/*     device = mm_modem_get_device (ctxt.modem); */
+/*     device_id = mm_modem_get_device_identifier (ctxt.modem); */
+/*     equipment_id = mm_modem_get_equipment_identifier (ctxt.modem); */
+/*     driver = mm_modem_get_driver (ctxt.modem); */
+/*     plugin = mm_modem_get_plugin (ctxt.modem); */
+/*     type = mm_modem_get_modem_type (ctxt.modem); */
+/*     enabled = mm_modem_get_enabled (ctxt.modem); */
+/*     unlock_required = mm_modem_get_unlock_required (ctxt.modem); */
+/*     unlock_retries = mm_modem_get_unlock_retries (ctxt.modem); */
+/*     ip_method = mm_modem_get_ip_method (ctxt.modem); */
+/*     state = mm_modem_get_state (ctxt.modem); */
+
+/*     /\* Strings with mixed properties *\/ */
+/*     unlock = (unlock_required ? */
+/*               g_strdup_printf ("%s (%u retries)", */
+/*                                unlock_required, */
+/*                                unlock_retries) : */
+/*               g_strdup ("not required")); */
+
+/*     /\* Rework possible multiline strings *\/ */
+/*     prefixed_revision = prefix_newlines ("           |                 ", */
+/*                                          revision); */
+
+/*     g_print ("\n" */
+/*              "%s\n" */
+/*              "  -------------------------\n" */
+/*              "  Hardware |  manufacturer: '%s'\n" */
+/*              "           |         model: '%s'\n" */
+/*              "           |      revision: '%s'\n" */
+/*              "           |          type: '%s'\n" */
+/*              "  -------------------------\n" */
+/*              "  System   | master device: '%s'\n" */
+/*              "           |        device: '%s'\n" */
+/*              "           |     device id: '%s'\n" */
+/*              "           |  equipment id: '%s'\n" */
+/*              "           |        driver: '%s'\n" */
+/*              "           |        plugin: '%s'\n" */
+/*              "  -------------------------\n" */
+/*              "  Status   |       enabled: '%s'\n" */
+/*              "           |        unlock: '%s'\n" */
+/*              "           |     IP method: '%s'\n" */
+/*              "           |         state: '%s'\n" */
+/*              "\n", */
+/*              ctxt.modem_str, */
+/*              manufacturer, */
+/*              model, */
+/*              prefixed_revision ? prefixed_revision : revision, */
+/*              get_modem_type_string (type), */
+/*              master_device, */
+/*              device, */
+/*              device_id, */
+/*              equipment_id, */
+/*              driver, */
+/*              plugin, */
+/*              enabled ? "yes" : "no", */
+/*              unlock, */
+/*              get_ip_method_string (ip_method), */
+/*              get_state_string (state)); */
+
+/*     g_free (prefixed_revision); */
+/*     g_free (master_device); */
+/*     g_free (device); */
+/*     g_free (device_id); */
+/*     g_free (equipment_id); */
+/*     g_free (driver); */
+/*     g_free (plugin); */
+/*     g_free (unlock_required); */
+/*     g_free (unlock); */
+/* } */
+
+/* static void */
+/* get_info_ready (MMModem      *modem, */
+/*                 GAsyncResult *result, */
+/*                 gpointer      nothing) */
+/* { */
+/*     gboolean operation_result; */
+/*     gchar *manufacturer = NULL; */
+/*     gchar *model = NULL; */
+/*     gchar *revision = NULL; */
+/*     GError *error = NULL; */
+
+/*     operation_result = mm_modem_get_info_finish (modem, */
+/*                                                  result, */
+/*                                                  &manufacturer, */
+/*                                                  &model, */
+/*                                                  &revision, */
+/*                                                  &error); */
+/*     get_info_process_reply (operation_result, */
+/*                             error, */
+/*                             manufacturer, */
+/*                             model, */
+/*                             revision); */
+
+/*     g_free (manufacturer); */
+/*     g_free (model); */
+/*     g_free (revision); */
+
+/*     mmcli_async_operation_done (); */
+/* } */
 
 static void
 enable_process_reply (gboolean      result,
@@ -520,90 +465,109 @@ factory_reset_ready (MMModem      *modem,
     mmcli_async_operation_done ();
 }
 
-static void
-state_changed (MMModem            *modem,
-               MMModemState        old_state,
-               MMModemState        new_state,
-               MMModemStateReason  reason)
-{
-    g_print ("State changed: '%s' --> '%s' (Reason: %s)\n",
-             get_state_string (old_state),
-             get_state_string (new_state),
-             get_state_reason_string (reason));
-    fflush (stdout);
-}
+/* static void */
+/* state_changed (MMModem            *modem, */
+/*                MMModemState        old_state, */
+/*                MMModemState        new_state, */
+/*                MMModemStateReason  reason) */
+/* { */
+/*     g_print ("State changed: '%s' --> '%s' (Reason: %s)\n", */
+/*              get_state_string (old_state), */
+/*              get_state_string (new_state), */
+/*              get_state_reason_string (reason)); */
+/*     fflush (stdout); */
+/* } */
 
-gboolean
-mmcli_modem_run_asynchronous (GDBusConnection *connection,
-                              GCancellable    *cancellable)
+static void
+get_modem_ready (GObject      *source,
+                 GAsyncResult *result,
+                 gpointer      none)
 {
-    /* Initialize context */
-    init (connection);
+    ctx->modem = mmcli_get_modem_finish (result);
 
     /* Request to get info from modem? */
-    if (ctxt.info_flag) {
-        mm_modem_get_info_async (ctxt.modem,
-                                 cancellable,
-                                 (GAsyncReadyCallback)get_info_ready,
-                                 NULL);
-        return FALSE;
+    if (info_flag) {
+        /* TODO */
+
+        /* mm_modem_get_info_async (ctxt.modem, */
+        /*                          cancellable, */
+        /*                          (GAsyncReadyCallback)get_info_ready, */
+        /*                          NULL); */
+        return;
     }
 
     /* Request to monitor modems? */
-    if (ctxt.monitor_state_flag) {
-        MMModemState current;
+    if (monitor_state_flag) {
+        /* TODO */
 
-        g_signal_connect (ctxt.modem,
-                          "state-changed",
-                          G_CALLBACK (state_changed),
-                          NULL);
+        /* MMModemState current; */
 
-        current = mm_modem_get_state (ctxt.modem);
-        g_print ("Initial state: '%s'\n", get_state_string (current));
+        /* g_signal_connect (ctxt.modem, */
+        /*                   "state-changed", */
+        /*                   G_CALLBACK (state_changed), */
+        /*                   NULL); */
 
-        /* We need to keep the loop */
-        return TRUE;
+        /* current = mm_modem_get_state (ctxt.modem); */
+        /* g_print ("Initial state: '%s'\n", get_state_string (current)); */
+
+        return;
     }
 
     /* Request to enable the modem? */
-    if (ctxt.enable_flag) {
-        mm_modem_enable_async (ctxt.modem,
-                               cancellable,
-                               (GAsyncReadyCallback)enable_ready,
-                               NULL);
-        return FALSE;
+    if (enable_flag) {
+        mm_modem_enable (ctx->modem,
+                         ctx->cancellable,
+                         (GAsyncReadyCallback)enable_ready,
+                         NULL);
+        return;
     }
 
     /* Request to disable the modem? */
-    if (ctxt.disable_flag) {
-        mm_modem_disable_async (ctxt.modem,
-                                cancellable,
-                                (GAsyncReadyCallback)disable_ready,
-                                NULL);
-        return FALSE;
+    if (disable_flag) {
+        mm_modem_disable (ctx->modem,
+                          ctx->cancellable,
+                          (GAsyncReadyCallback)disable_ready,
+                          NULL);
+        return;
     }
 
     /* Request to reset the modem? */
-    if (ctxt.reset_flag) {
-        mm_modem_reset_async (ctxt.modem,
-                              cancellable,
-                              (GAsyncReadyCallback)reset_ready,
-                              NULL);
-        return FALSE;
+    if (reset_flag) {
+        mm_modem_reset (ctx->modem,
+                        ctx->cancellable,
+                        (GAsyncReadyCallback)reset_ready,
+                        NULL);
+        return;
     }
 
     /* Request to reset the modem to factory state? */
-    if (ctxt.factory_reset_str) {
-        mm_modem_factory_reset_async (ctxt.modem,
-                                      ctxt.factory_reset_str,
-                                      cancellable,
-                                      (GAsyncReadyCallback)factory_reset_ready,
-                                      NULL);
-        return FALSE;
+    if (factory_reset_str) {
+        mm_modem_factory_reset (ctx->modem,
+                                factory_reset_str,
+                                ctx->cancellable,
+                                (GAsyncReadyCallback)factory_reset_ready,
+                                NULL);
+        return;
     }
 
     g_warn_if_reached ();
-    return FALSE;
+}
+
+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,
+                      modem_str,
+                      cancellable,
+                      (GAsyncReadyCallback)get_modem_ready,
+                      NULL);
 }
 
 void
@@ -611,70 +575,74 @@ mmcli_modem_run_synchronous (GDBusConnection *connection)
 {
     GError *error = NULL;
 
-    if (ctxt.monitor_state_flag) {
+    if (monitor_state_flag) {
         g_printerr ("error: monitoring state cannot be done synchronously\n");
         exit (EXIT_FAILURE);
     }
 
-    /* Initialize context */
-    init (connection);
+    ctx->modem = mmcli_get_modem_sync (connection, modem_str);
 
     /* Request to get info from modem? */
-    if (ctxt.info_flag) {
-        gboolean result;
-        gchar *manufacturer = NULL;
-        gchar *model = NULL;
-        gchar *revision = NULL;
-
-        result = mm_modem_get_info (ctxt.modem,
-                                    &manufacturer,
-                                    &model,
-                                    &revision,
-                                    &error);
-        get_info_process_reply (result,
-                                error,
-                                manufacturer,
-                                model,
-                                revision);
-
-        g_free (manufacturer);
-        g_free (model);
-        g_free (revision);
+    if (info_flag) {
+        /* TODO */
+
+        /* gboolean result; */
+        /* gchar *manufacturer = NULL; */
+        /* gchar *model = NULL; */
+        /* gchar *revision = NULL; */
+
+        /* result = mm_modem_get_info (ctxt.modem, */
+        /*                             &manufacturer, */
+        /*                             &model, */
+        /*                             &revision, */
+        /*                             &error); */
+        /* get_info_process_reply (result, */
+        /*                         error, */
+        /*                         manufacturer, */
+        /*                         model, */
+        /*                         revision); */
+
+        /* g_free (manufacturer); */
+        /* g_free (model); */
+        /* g_free (revision); */
         return;
     }
 
     /* Request to enable the modem? */
-    if (ctxt.enable_flag) {
+    if (enable_flag) {
         gboolean result;
 
-        result = mm_modem_enable (ctxt.modem, &error);
+        result = mm_modem_enable_sync (ctx->modem, NULL, &error);
         enable_process_reply (result, error);
         return;
     }
 
     /* Request to disable the modem? */
-    if (ctxt.disable_flag) {
+    if (disable_flag) {
         gboolean result;
 
-        result = mm_modem_disable (ctxt.modem, &error);
+        result = mm_modem_disable_sync (ctx->modem, NULL, &error);
         disable_process_reply (result, error);
         return;
     }
 
     /* Request to reset the modem? */
-    if (ctxt.reset_flag) {
+    if (reset_flag) {
         gboolean result;
 
-        result = mm_modem_reset (ctxt.modem, &error);
+        result = mm_modem_reset_sync (ctx->modem, NULL, &error);
         reset_process_reply (result, error);
         return;
     }
 
     /* Request to reset the modem to factory state? */
-    if (ctxt.factory_reset_str) {
+    if (factory_reset_str) {
         gboolean result;
 
-        result = mm_modem_factory_reset (ctxt.modem, ctxt.factory_reset_str, &error);
+        result = mm_modem_factory_reset_sync (ctx->modem,
+                                              factory_reset_str,
+                                              NULL,
+                                              &error);
         factory_reset_process_reply (result, error);
         return;
     }
diff --git a/cli/mmcli.c b/cli/mmcli.c
index f403d31f..79906602 100644
--- a/cli/mmcli.c
+++ b/cli/mmcli.c
@@ -158,14 +158,11 @@ main (gint argc, gchar **argv)
             mmcli_manager_run_asynchronous (connection, cancellable);
         else
             mmcli_manager_run_synchronous (connection);
-    } else {
-        g_printerr ("error: no actions specified\n");
-        exit (EXIT_FAILURE);
     }
     /* Modem options? */
     else if (mmcli_modem_options_enabled ()) {
         if (async_flag)
-            keep_loop = mmcli_modem_run_asynchronous (connection, cancellable);
+            mmcli_modem_run_asynchronous (connection, cancellable);
         else
             mmcli_modem_run_synchronous (connection);
     }
diff --git a/cli/mmcli.h b/cli/mmcli.h
index 72f13cc1..37647141 100644
--- a/cli/mmcli.h
+++ b/cli/mmcli.h
@@ -37,7 +37,7 @@ void          mmcli_manager_shutdown         (void);
 /* Modem group */
 GOptionGroup *mmcli_modem_get_option_group   (void);
 gboolean      mmcli_modem_options_enabled    (void);
-gboolean      mmcli_modem_run_asynchronous   (GDBusConnection *connection,
+void          mmcli_modem_run_asynchronous   (GDBusConnection *connection,
                                               GCancellable    *cancellable);
 void          mmcli_modem_run_synchronous    (GDBusConnection *connection);
 void          mmcli_modem_shutdown           (void);