/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2013 - 2016 Canonical Ltd.
 */

#include "nm-default.h"

#include "nm-modem-ofono.h"

#include "nm-core-internal.h"
#include "devices/nm-device-private.h"
#include "nm-modem.h"
#include "platform/nm-platform.h"
#include "nm-ip4-config.h"

#define VARIANT_IS_OF_TYPE_BOOLEAN(v) \
    ((v) != NULL && (g_variant_is_of_type((v), G_VARIANT_TYPE_BOOLEAN)))
#define VARIANT_IS_OF_TYPE_STRING(v) \
    ((v) != NULL && (g_variant_is_of_type((v), G_VARIANT_TYPE_STRING)))
#define VARIANT_IS_OF_TYPE_OBJECT_PATH(v) \
    ((v) != NULL && (g_variant_is_of_type((v), G_VARIANT_TYPE_OBJECT_PATH)))
#define VARIANT_IS_OF_TYPE_STRING_ARRAY(v) \
    ((v) != NULL && (g_variant_is_of_type((v), G_VARIANT_TYPE_STRING_ARRAY)))
#define VARIANT_IS_OF_TYPE_DICTIONARY(v) \
    ((v) != NULL && (g_variant_is_of_type((v), G_VARIANT_TYPE_DICTIONARY)))

/*****************************************************************************/

typedef struct {
    GHashTable *connect_properties;

    GDBusProxy *modem_proxy;
    GDBusProxy *connman_proxy;
    GDBusProxy *context_proxy;
    GDBusProxy *sim_proxy;

    GCancellable *modem_proxy_cancellable;
    GCancellable *connman_proxy_cancellable;
    GCancellable *context_proxy_cancellable;
    GCancellable *sim_proxy_cancellable;

    GError *property_error;

    char *context_path;
    char *imsi;

    gboolean modem_online;
    gboolean gprs_attached;

    NMIP4Config *ip4_config;
} NMModemOfonoPrivate;

struct _NMModemOfono {
    NMModem             parent;
    NMModemOfonoPrivate _priv;
};

struct _NMModemOfonoClass {
    NMModemClass parent;
};

G_DEFINE_TYPE(NMModemOfono, nm_modem_ofono, NM_TYPE_MODEM)

#define NM_MODEM_OFONO_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMModemOfono, NM_IS_MODEM_OFONO)

/*****************************************************************************/

#define _NMLOG_DOMAIN      LOGD_MB
#define _NMLOG_PREFIX_NAME "modem-ofono"
#define _NMLOG(level, ...)                                                  \
    G_STMT_START                                                            \
    {                                                                       \
        const NMLogLevel _level = (level);                                  \
                                                                            \
        if (nm_logging_enabled(_level, (_NMLOG_DOMAIN))) {                  \
            NMModemOfono *const __self = (self);                            \
            char                __prefix_name[128];                         \
            const char *        __uid;                                      \
                                                                            \
            _nm_log(_level,                                                 \
                    (_NMLOG_DOMAIN),                                        \
                    0,                                                      \
                    NULL,                                                   \
                    NULL,                                                   \
                    "%s%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__),            \
                    _NMLOG_PREFIX_NAME,                                     \
                    (__self ? ({                                            \
                        ((__uid = nm_modem_get_uid((NMModem *) __self))     \
                             ? nm_sprintf_buf(__prefix_name, "[%s]", __uid) \
                             : "(null)");                                   \
                    })                                                      \
                            : "") _NM_UTILS_MACRO_REST(__VA_ARGS__));       \
        }                                                                   \
    }                                                                       \
    G_STMT_END

/*****************************************************************************/

static void
get_capabilities(NMModem *                  _self,
                 NMDeviceModemCapabilities *modem_caps,
                 NMDeviceModemCapabilities *current_caps)
{
    /* FIXME: auto-detect capabilities to allow LTE */
    *modem_caps   = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;
    *current_caps = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;
}

static void
update_modem_state(NMModemOfono *self)
{
    NMModemOfonoPrivate *priv      = NM_MODEM_OFONO_GET_PRIVATE(self);
    NMModemState         state     = nm_modem_get_state(NM_MODEM(self));
    NMModemState         new_state = NM_MODEM_STATE_DISABLED;
    const char *         reason    = NULL;

    _LOGI("'Attached': %s 'Online': %s 'IMSI': %s",
          priv->gprs_attached ? "true" : "false",
          priv->modem_online ? "true" : "false",
          priv->imsi);

    if (priv->modem_online == FALSE) {
        reason = "modem 'Online=false'";
    } else if (priv->imsi == NULL && state != NM_MODEM_STATE_ENABLING) {
        reason = "modem not ready";
    } else if (priv->gprs_attached == FALSE) {
        new_state = NM_MODEM_STATE_SEARCHING;
        reason    = "modem searching";
    } else {
        new_state = NM_MODEM_STATE_REGISTERED;
        reason    = "modem ready";
    }

    if (state != new_state)
        nm_modem_set_state(NM_MODEM(self), new_state, reason);
}

/* Disconnect */
typedef struct {
    NMModemOfono *             self;
    _NMModemDisconnectCallback callback;
    gpointer                   callback_user_data;
    GCancellable *             cancellable;
    gboolean                   warn;
} DisconnectContext;

static void
disconnect_context_complete(DisconnectContext *ctx, GError *error)
{
    if (ctx->callback)
        ctx->callback(NM_MODEM(ctx->self), error, ctx->callback_user_data);
    nm_g_object_unref(ctx->cancellable);
    g_object_unref(ctx->self);
    g_slice_free(DisconnectContext, ctx);
}

static void
disconnect_context_complete_on_idle(gpointer user_data, GCancellable *cancellable)
{
    DisconnectContext *ctx      = user_data;
    gs_free_error GError *error = NULL;

    if (!g_cancellable_set_error_if_cancelled(cancellable, &error)) {
        g_set_error_literal(&error,
                            NM_UTILS_ERROR,
                            NM_UTILS_ERROR_UNKNOWN,
                            ("modem is currently not connected"));
    }
    disconnect_context_complete(ctx, error);
}

static void
disconnect_done(GObject *source, GAsyncResult *result, gpointer user_data)
{
    DisconnectContext *ctx       = user_data;
    NMModemOfono *     self      = ctx->self;
    gs_free_error GError *error  = NULL;
    gs_unref_variant GVariant *v = NULL;

    v = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, &error);
    if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
        disconnect_context_complete(ctx, error);
        return;
    }

    if (error && ctx->warn)
        _LOGW("failed to disconnect modem: %s", error->message);

    _LOGD("modem disconnected");

    update_modem_state(self);
    disconnect_context_complete(ctx, error);
}

static void
disconnect(NMModem *                  modem,
           gboolean                   warn,
           GCancellable *             cancellable,
           _NMModemDisconnectCallback callback,
           gpointer                   user_data)
{
    NMModemOfono *       self = NM_MODEM_OFONO(modem);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);
    DisconnectContext *  ctx;
    NMModemState         state = nm_modem_get_state(NM_MODEM(self));

    _LOGD("warn: %s modem_state: %s", warn ? "TRUE" : "FALSE", nm_modem_state_to_string(state));

    ctx                     = g_slice_new0(DisconnectContext);
    ctx->self               = g_object_ref(self);
    ctx->cancellable        = nm_g_object_ref(cancellable);
    ctx->warn               = warn;
    ctx->callback           = callback;
    ctx->callback_user_data = user_data;

    if (state != NM_MODEM_STATE_CONNECTED || g_cancellable_is_cancelled(cancellable)) {
        nm_utils_invoke_on_idle(cancellable, disconnect_context_complete_on_idle, ctx);
        return;
    }

    nm_modem_set_state(NM_MODEM(self),
                       NM_MODEM_STATE_DISCONNECTING,
                       nm_modem_state_to_string(NM_MODEM_STATE_DISCONNECTING));

    g_dbus_proxy_call(priv->context_proxy,
                      "SetProperty",
                      g_variant_new("(sv)", "Active", g_variant_new("b", warn)),
                      G_DBUS_CALL_FLAGS_NONE,
                      20000,
                      ctx->cancellable,
                      disconnect_done,
                      ctx);
}

static void
deactivate_cleanup(NMModem *modem, NMDevice *device, gboolean stop_ppp_manager)
{
    NMModemOfono *       self = NM_MODEM_OFONO(modem);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    /* TODO: cancel SimpleConnect() if any */

    g_clear_object(&priv->ip4_config);

    NM_MODEM_CLASS(nm_modem_ofono_parent_class)
        ->deactivate_cleanup(modem, device, stop_ppp_manager);
}

static gboolean
check_connection_compatible_with_modem(NMModem *modem, NMConnection *connection, GError **error)
{
    NMModemOfono *       self = NM_MODEM_OFONO(modem);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);
    const char *         id;

    if (!_nm_connection_check_main_setting(connection, NM_SETTING_GSM_SETTING_NAME, NULL)) {
        nm_utils_error_set(error,
                           NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
                           "connection type %s is not supported by ofono modem",
                           nm_connection_get_connection_type(connection));
        return FALSE;
    }

    if (!priv->imsi) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "modem has no IMSI");
        return FALSE;
    }

    id = nm_connection_get_id(connection);

    if (!strstr(id, "/context")) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "the connection ID has no context");
        return FALSE;
    }

    if (!strstr(id, priv->imsi)) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "the connection ID does not contain the IMSI");
        return FALSE;
    }

    return TRUE;
}

static void
handle_sim_property(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    NMModemOfono *       self = NM_MODEM_OFONO(user_data);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (g_strcmp0(property, "SubscriberIdentity") == 0 && VARIANT_IS_OF_TYPE_STRING(v)) {
        gsize       length;
        const char *value_str = g_variant_get_string(v, &length);

        _LOGD("SubscriberIdentify found");

        /* Check for empty DBus string value */
        if (length && g_strcmp0(value_str, "(null)") != 0
            && g_strcmp0(value_str, priv->imsi) != 0) {
            if (priv->imsi != NULL) {
                _LOGW("SimManager:'SubscriberIdentity' changed: %s", priv->imsi);
                g_free(priv->imsi);
            }

            priv->imsi = g_strdup(value_str);
            update_modem_state(self);
        }
    }
}

static void
sim_property_changed(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    GVariant *v_child = g_variant_get_child_value(v, 0);

    handle_sim_property(proxy, property, v_child, user_data);
    g_variant_unref(v_child);
}

static void
sim_get_properties_done(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error             = NULL;
    gs_unref_variant GVariant *v_properties = NULL;
    gs_unref_variant GVariant *v_dict       = NULL;
    GVariant *                 v;
    GVariantIter               i;
    const char *               property;

    v_properties =
        _nm_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, G_VARIANT_TYPE("(a{sv})"), &error);
    if (!v_properties && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    g_clear_object(&priv->sim_proxy_cancellable);

    if (!v_properties) {
        g_dbus_error_strip_remote_error(error);
        _LOGW("error getting sim properties: %s", error->message);
        return;
    }

    _LOGD("sim v_properties is type: %s", g_variant_get_type_string(v_properties));

    v_dict = g_variant_get_child_value(v_properties, 0);
    if (!v_dict) {
        _LOGW("error getting sim properties: no v_dict");
        return;
    }

    _LOGD("sim v_dict is type: %s", g_variant_get_type_string(v_dict));

    /*
     * TODO:
     * 1) optimize by looking up properties ( Online, Interfaces ), instead
     *    of iterating
     *
     * 2) reduce code duplication between all of the get_properties_done
     *    functions in this class.
     */

    g_variant_iter_init(&i, v_dict);
    while (g_variant_iter_next(&i, "{&sv}", &property, &v)) {
        handle_sim_property(NULL, property, v, self);
        g_variant_unref(v);
    }
}

static void
_sim_proxy_new_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error = NULL;
    GDBusProxy *          proxy;

    proxy = g_dbus_proxy_new_for_bus_finish(result, &error);
    if (!proxy && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = user_data;
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (!proxy) {
        _LOGW("failed to create SimManager proxy: %s", error->message);
        g_clear_object(&priv->sim_proxy_cancellable);
        return;
    }

    priv->sim_proxy = proxy;

    /* Watch for custom ofono PropertyChanged signals */
    _nm_dbus_signal_connect(priv->sim_proxy,
                            "PropertyChanged",
                            G_VARIANT_TYPE("(sv)"),
                            G_CALLBACK(sim_property_changed),
                            self);

    g_dbus_proxy_call(priv->sim_proxy,
                      "GetProperties",
                      NULL,
                      G_DBUS_CALL_FLAGS_NONE,
                      20000,
                      priv->sim_proxy_cancellable,
                      sim_get_properties_done,
                      self);
}

static void
handle_sim_iface(NMModemOfono *self, gboolean found)
{
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    _LOGD("SimManager interface %sfound", found ? "" : "not ");

    if (!found && (priv->sim_proxy || priv->sim_proxy_cancellable)) {
        _LOGI("SimManager interface disappeared");
        nm_clear_g_cancellable(&priv->sim_proxy_cancellable);
        if (priv->sim_proxy) {
            g_signal_handlers_disconnect_by_data(priv->sim_proxy, self);
            g_clear_object(&priv->sim_proxy);
        }
        nm_clear_g_free(&priv->imsi);
        update_modem_state(self);
    } else if (found && (!priv->sim_proxy && !priv->sim_proxy_cancellable)) {
        _LOGI("found new SimManager interface");

        priv->sim_proxy_cancellable = g_cancellable_new();

        g_dbus_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES
                                     | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
                                 NULL, /* GDBusInterfaceInfo */
                                 OFONO_DBUS_SERVICE,
                                 nm_modem_get_path(NM_MODEM(self)),
                                 OFONO_DBUS_INTERFACE_SIM_MANAGER,
                                 priv->sim_proxy_cancellable, /* GCancellable */
                                 _sim_proxy_new_cb,
                                 self);
    }
}

static void
handle_connman_property(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    NMModemOfono *       self = NM_MODEM_OFONO(user_data);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (g_strcmp0(property, "Attached") == 0 && VARIANT_IS_OF_TYPE_BOOLEAN(v)) {
        gboolean attached     = g_variant_get_boolean(v);
        gboolean old_attached = priv->gprs_attached;

        _LOGD("Attached: %s", attached ? "True" : "False");

        if (priv->gprs_attached != attached) {
            priv->gprs_attached = attached;

            _LOGI("Attached %s -> %s",
                  old_attached ? "true" : "false",
                  attached ? "true" : "false");

            update_modem_state(self);
        }
    }
}

static void
connman_property_changed(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    GVariant *v_child = g_variant_get_child_value(v, 0);

    handle_connman_property(proxy, property, v_child, user_data);
    g_variant_unref(v_child);
}

static void
connman_get_properties_done(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error             = NULL;
    gs_unref_variant GVariant *v_properties = NULL;
    gs_unref_variant GVariant *v_dict       = NULL;
    GVariant *                 v;
    GVariantIter               i;
    const char *               property;

    v_properties =
        _nm_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, G_VARIANT_TYPE("(a{sv})"), &error);
    if (!v_properties && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    g_clear_object(&priv->connman_proxy_cancellable);

    if (!v_properties) {
        g_dbus_error_strip_remote_error(error);
        _LOGW("error getting connman properties: %s", error->message);
        return;
    }

    v_dict = g_variant_get_child_value(v_properties, 0);

    /*
     * TODO:
     * 1) optimize by looking up properties ( Online, Interfaces ), instead
     *    of iterating
     *
     * 2) reduce code duplication between all of the get_properties_done
     *    functions in this class.
     */

    g_variant_iter_init(&i, v_dict);
    while (g_variant_iter_next(&i, "{&sv}", &property, &v)) {
        handle_connman_property(NULL, property, v, self);
        g_variant_unref(v);
    }
}

static void
_connman_proxy_new_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error = NULL;
    GDBusProxy *          proxy;

    proxy = g_dbus_proxy_new_for_bus_finish(result, &error);
    if (!proxy && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = user_data;
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (!proxy) {
        _LOGW("failed to create ConnectionManager proxy: %s", error->message);
        g_clear_object(&priv->connman_proxy_cancellable);
        return;
    }

    priv->connman_proxy = proxy;

    _nm_dbus_signal_connect(priv->connman_proxy,
                            "PropertyChanged",
                            G_VARIANT_TYPE("(sv)"),
                            G_CALLBACK(connman_property_changed),
                            self);

    g_dbus_proxy_call(priv->connman_proxy,
                      "GetProperties",
                      NULL,
                      G_DBUS_CALL_FLAGS_NONE,
                      20000,
                      priv->connman_proxy_cancellable,
                      connman_get_properties_done,
                      self);
}

static void
handle_connman_iface(NMModemOfono *self, gboolean found)
{
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    _LOGD("ConnectionManager interface %sfound", found ? "" : "not ");

    if (!found && (priv->connman_proxy || priv->connman_proxy_cancellable)) {
        _LOGI("ConnectionManager interface disappeared");
        nm_clear_g_cancellable(&priv->connman_proxy_cancellable);
        if (priv->connman_proxy) {
            g_signal_handlers_disconnect_by_data(priv->connman_proxy, self);
            g_clear_object(&priv->connman_proxy);
        }

        /* The connection manager proxy disappeared, we should
         * consider the modem disabled.
         */
        priv->gprs_attached = FALSE;

        update_modem_state(self);
    } else if (found && (!priv->connman_proxy && !priv->connman_proxy_cancellable)) {
        _LOGI("found new ConnectionManager interface");

        priv->connman_proxy_cancellable = g_cancellable_new();

        g_dbus_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES
                                     | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
                                 NULL, /* GDBusInterfaceInfo */
                                 OFONO_DBUS_SERVICE,
                                 nm_modem_get_path(NM_MODEM(self)),
                                 OFONO_DBUS_INTERFACE_CONNECTION_MANAGER,
                                 priv->connman_proxy_cancellable,
                                 _connman_proxy_new_cb,
                                 self);
    }
}

static void
handle_modem_property(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    NMModemOfono *       self = NM_MODEM_OFONO(user_data);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if ((g_strcmp0(property, "Online") == 0) && VARIANT_IS_OF_TYPE_BOOLEAN(v)) {
        gboolean online = g_variant_get_boolean(v);

        _LOGD("Online: %s", online ? "True" : "False");

        if (online != priv->modem_online) {
            priv->modem_online = online;
            _LOGI("modem is now %s", online ? "Online" : "Offline");
            update_modem_state(self);
        }

    } else if ((g_strcmp0(property, "Interfaces") == 0) && VARIANT_IS_OF_TYPE_STRING_ARRAY(v)) {
        const char **array, **iter;
        gboolean     found_connman = FALSE;
        gboolean     found_sim     = FALSE;

        _LOGD("Interfaces found");

        array = g_variant_get_strv(v, NULL);
        if (array) {
            for (iter = array; *iter; iter++) {
                if (g_strcmp0(OFONO_DBUS_INTERFACE_SIM_MANAGER, *iter) == 0)
                    found_sim = TRUE;
                else if (g_strcmp0(OFONO_DBUS_INTERFACE_CONNECTION_MANAGER, *iter) == 0)
                    found_connman = TRUE;
            }
            g_free(array);
        }

        handle_sim_iface(self, found_sim);
        handle_connman_iface(self, found_connman);
    }
}

static void
modem_property_changed(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    GVariant *v_child = g_variant_get_child_value(v, 0);

    handle_modem_property(proxy, property, v_child, user_data);
    g_variant_unref(v_child);
}

static void
modem_get_properties_done(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error             = NULL;
    gs_unref_variant GVariant *v_properties = NULL;
    gs_unref_variant GVariant *v_dict       = NULL;
    GVariant *                 v;
    GVariantIter               i;
    const char *               property;

    v_properties =
        _nm_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, G_VARIANT_TYPE("(a{sv})"), &error);
    if (!v_properties && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    g_clear_object(&priv->modem_proxy_cancellable);

    if (!v_properties) {
        g_dbus_error_strip_remote_error(error);
        _LOGW("error getting modem properties: %s", error->message);
        return;
    }

    v_dict = g_variant_get_child_value(v_properties, 0);
    if (!v_dict) {
        _LOGW("error getting modem properties: no v_dict");
        return;
    }

    /*
     * TODO:
     * 1) optimize by looking up properties ( Online, Interfaces ), instead
     *    of iterating
     *
     * 2) reduce code duplication between all of the get_properties_done
     *    functions in this class.
     */

    g_variant_iter_init(&i, v_dict);
    while (g_variant_iter_next(&i, "{&sv}", &property, &v)) {
        handle_modem_property(NULL, property, v, self);
        g_variant_unref(v);
    }
}

static void
stage1_prepare_done(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error  = NULL;
    gs_unref_variant GVariant *v = NULL;

    v = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, &error);
    if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    g_clear_object(&priv->context_proxy_cancellable);

    nm_clear_pointer(&priv->connect_properties, g_hash_table_destroy);

    if (error) {
        _LOGW("connection failed: %s", error->message);

        nm_modem_emit_prepare_result(NM_MODEM(self), FALSE, NM_DEVICE_STATE_REASON_MODEM_BUSY);
        /*
         * FIXME: add code to check for InProgress so that the
         * connection doesn't continue to try and activate,
         * leading to the connection being disabled, and a 5m
         * timeout...
         */
    }
}

static void
context_property_changed(GDBusProxy *proxy, const char *property, GVariant *v, gpointer user_data)
{
    NMModemOfono *       self = NM_MODEM_OFONO(user_data);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);
    NMPlatformIP4Address addr;
    gboolean             ret          = FALSE;
    gs_unref_variant GVariant *v_dict = NULL;
    const char *               interface;
    const char *               s;
    const char **              array, **iter;
    guint32                    address_network, gateway_network;
    guint32                    ip4_route_table, ip4_route_metric;
    int                        ifindex;
    GError *                   error = NULL;

    _LOGD("PropertyChanged: %s", property);

    /*
     * TODO: might be a good idea and re-factor this to mimic bluez-device,
     * ie. have this function just check the key, and call a sub-func to
     * handle the action.
     */

    if (g_strcmp0(property, "Settings") != 0)
        return;

    v_dict = g_variant_get_child_value(v, 0);
    if (!v_dict) {
        _LOGW("error getting IPv4 Settings: no v_dict");
        goto out;
    }

    _LOGI("IPv4 static Settings:");

    if (!g_variant_lookup(v_dict, "Interface", "&s", &interface)) {
        _LOGW("Settings 'Interface' missing");
        goto out;
    }

    _LOGD("Interface: %s", interface);
    if (!nm_modem_set_data_port(NM_MODEM(self),
                                NM_PLATFORM_GET,
                                interface,
                                NM_MODEM_IP_METHOD_STATIC,
                                NM_MODEM_IP_METHOD_UNKNOWN,
                                0,
                                &error)) {
        _LOGW("failed to connect to modem: %s", error->message);
        g_clear_error(&error);
        goto out;
    }

    ifindex = nm_modem_get_ip_ifindex(NM_MODEM(self));
    nm_assert(ifindex > 0);

    /* TODO: verify handling of ip4_config; check other places it's used... */
    g_clear_object(&priv->ip4_config);

    priv->ip4_config = nm_ip4_config_new(nm_platform_get_multi_idx(NM_PLATFORM_GET), ifindex);

    if (!g_variant_lookup(v_dict, "Address", "&s", &s)) {
        _LOGW("Settings 'Address' missing");
        goto out;
    }
    if (!s || !nm_utils_parse_inaddr_bin(AF_INET, s, NULL, &address_network)) {
        _LOGW("can't convert 'Address' %s to addr", s ?: "");
        goto out;
    }
    memset(&addr, 0, sizeof(addr));
    addr.ifindex     = ifindex;
    addr.address     = address_network;
    addr.addr_source = NM_IP_CONFIG_SOURCE_WWAN;

    if (!g_variant_lookup(v_dict, "Netmask", "&s", &s)) {
        _LOGW("Settings 'Netmask' missing");
        goto out;
    }
    if (!s || !nm_utils_parse_inaddr_bin(AF_INET, s, NULL, &address_network)) {
        _LOGW("invalid 'Netmask': %s", s ?: "");
        goto out;
    }
    addr.plen = nm_utils_ip4_netmask_to_prefix(address_network);

    _LOGI("Address: %s", nm_platform_ip4_address_to_string(&addr, NULL, 0));
    nm_ip4_config_add_address(priv->ip4_config, &addr);

    if (!g_variant_lookup(v_dict, "Gateway", "&s", &s) || !s) {
        _LOGW("Settings 'Gateway' missing");
        goto out;
    }
    if (!nm_utils_parse_inaddr_bin(AF_INET, s, NULL, &gateway_network)) {
        _LOGW("invalid 'Gateway': %s", s);
        goto out;
    }
    nm_modem_get_route_parameters(NM_MODEM(self), &ip4_route_table, &ip4_route_metric, NULL, NULL);
    {
        const NMPlatformIP4Route r = {
            .rt_source     = NM_IP_CONFIG_SOURCE_WWAN,
            .gateway       = gateway_network,
            .table_coerced = nm_platform_route_table_coerce(ip4_route_table),
            .metric        = ip4_route_metric,
        };

        _LOGI("Gateway: %s", s);
        nm_ip4_config_add_route(priv->ip4_config, &r, NULL);
    }

    if (!g_variant_lookup(v_dict, "DomainNameServers", "^a&s", &array)) {
        _LOGW("Settings 'DomainNameServers' missing");
        goto out;
    }
    if (array) {
        for (iter = array; *iter; iter++) {
            if (nm_utils_parse_inaddr_bin(AF_INET, *iter, NULL, &address_network)
                && address_network) {
                _LOGI("DNS: %s", *iter);
                nm_ip4_config_add_nameserver(priv->ip4_config, address_network);
            } else {
                _LOGW("invalid NameServer: %s", *iter);
            }
        }

        if (iter == array) {
            _LOGW("Settings: 'DomainNameServers': none specified");
            g_free(array);
            goto out;
        }
        g_free(array);
    }

    if (g_variant_lookup(v_dict, "MessageProxy", "&s", &s)) {
        _LOGI("MessageProxy: %s", s);
        if (s && nm_utils_parse_inaddr_bin(AF_INET, s, NULL, &address_network)) {
            nm_modem_get_route_parameters(NM_MODEM(self),
                                          &ip4_route_table,
                                          &ip4_route_metric,
                                          NULL,
                                          NULL);

            {
                const NMPlatformIP4Route mms_route = {
                    .network       = address_network,
                    .plen          = 32,
                    .gateway       = gateway_network,
                    .table_coerced = nm_platform_route_table_coerce(ip4_route_table),
                    .metric        = ip4_route_metric,
                };

                nm_ip4_config_add_route(priv->ip4_config, &mms_route, NULL);
            }
        } else {
            _LOGW("invalid MessageProxy: %s", s);
        }
    }

    ret = TRUE;

out:
    if (nm_modem_get_state(NM_MODEM(self)) != NM_MODEM_STATE_CONNECTED) {
        _LOGI("emitting PREPARE_RESULT: %s", ret ? "TRUE" : "FALSE");
        nm_modem_emit_prepare_result(NM_MODEM(self),
                                     ret,
                                     ret ? NM_DEVICE_STATE_REASON_NONE
                                         : NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
    } else {
        _LOGW("MODEM_PPP_FAILED");
        nm_modem_emit_ppp_failed(NM_MODEM(self), NM_DEVICE_STATE_REASON_PPP_FAILED);
    }
}

static NMActStageReturn
static_stage3_ip4_config_start(NMModem *            modem,
                               NMActRequest *       req,
                               NMDeviceStateReason *out_failure_reason)
{
    NMModemOfono *       self  = NM_MODEM_OFONO(modem);
    NMModemOfonoPrivate *priv  = NM_MODEM_OFONO_GET_PRIVATE(self);
    GError *             error = NULL;

    if (!priv->ip4_config) {
        _LOGD("IP4 config not ready(?)");
        return NM_ACT_STAGE_RETURN_FAILURE;
    }

    _LOGD("IP4 config is done; setting modem_state -> CONNECTED");
    g_signal_emit_by_name(self, NM_MODEM_IP4_CONFIG_RESULT, priv->ip4_config, error);

    /* Signal listener takes ownership of the IP4Config */
    priv->ip4_config = NULL;

    nm_modem_set_state(NM_MODEM(self),
                       NM_MODEM_STATE_CONNECTED,
                       nm_modem_state_to_string(NM_MODEM_STATE_CONNECTED));
    return NM_ACT_STAGE_RETURN_POSTPONE;
}

static void
context_proxy_new_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error = NULL;
    GDBusProxy *          proxy;

    proxy = g_dbus_proxy_new_for_bus_finish(result, &error);
    if (!proxy || g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (!proxy) {
        _LOGE("failed to create ofono ConnectionContext DBus proxy: %s", error->message);
        g_clear_object(&priv->context_proxy_cancellable);
        nm_modem_emit_prepare_result(NM_MODEM(self), FALSE, NM_DEVICE_STATE_REASON_MODEM_BUSY);
        return;
    }

    priv->context_proxy = proxy;

    if (!priv->gprs_attached) {
        g_clear_object(&priv->context_proxy_cancellable);
        nm_modem_emit_prepare_result(NM_MODEM(self),
                                     FALSE,
                                     NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER);
        return;
    }

    /* We have an old copy of the settings from a previous activation,
     * clear it so that we can gate getting the IP config from oFono
     * on whether or not we have already received them
     */
    g_clear_object(&priv->ip4_config);

    _nm_dbus_signal_connect(priv->context_proxy,
                            "PropertyChanged",
                            G_VARIANT_TYPE("(sv)"),
                            G_CALLBACK(context_property_changed),
                            self);

    g_dbus_proxy_call(priv->context_proxy,
                      "SetProperty",
                      g_variant_new("(sv)", "Active", g_variant_new("b", TRUE)),
                      G_DBUS_CALL_FLAGS_NONE,
                      20000,
                      priv->context_proxy_cancellable,
                      stage1_prepare_done,
                      self);
}

static void
do_context_activate(NMModemOfono *self)
{
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    g_return_if_fail(NM_IS_MODEM_OFONO(self));

    nm_clear_g_cancellable(&priv->context_proxy_cancellable);
    g_clear_object(&priv->context_proxy);

    priv->context_proxy_cancellable = g_cancellable_new();

    g_dbus_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
                             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
                             NULL,
                             OFONO_DBUS_SERVICE,
                             priv->context_path,
                             OFONO_DBUS_INTERFACE_CONNECTION_CONTEXT,
                             priv->context_proxy_cancellable,
                             context_proxy_new_cb,
                             self);
}

static GHashTable *
create_connect_properties(NMConnection *connection)
{
    NMSettingGsm *setting;
    GHashTable *  properties;
    const char *  str;

    setting    = nm_connection_get_setting_gsm(connection);
    properties = g_hash_table_new(nm_str_hash, g_str_equal);

    str = nm_setting_gsm_get_apn(setting);
    if (str)
        g_hash_table_insert(properties, "AccessPointName", g_strdup(str));

    str = nm_setting_gsm_get_username(setting);
    if (str)
        g_hash_table_insert(properties, "Username", g_strdup(str));

    str = nm_setting_gsm_get_password(setting);
    if (str)
        g_hash_table_insert(properties, "Password", g_strdup(str));

    return properties;
}

static NMActStageReturn
modem_act_stage1_prepare(NMModem *            modem,
                         NMConnection *       connection,
                         NMDeviceStateReason *out_failure_reason)
{
    NMModemOfono *       self = NM_MODEM_OFONO(modem);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);
    const char *         context_id;
    char **              id = NULL;

    context_id = nm_connection_get_id(connection);
    id         = g_strsplit(context_id, "/", 0);
    g_return_val_if_fail(id[2], NM_ACT_STAGE_RETURN_FAILURE);

    _LOGD("trying %s %s", id[1], id[2]);

    g_free(priv->context_path);
    priv->context_path = g_strdup_printf("%s/%s", nm_modem_get_path(modem), id[2]);
    g_strfreev(id);

    if (!priv->context_path) {
        NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_GSM_APN_FAILED);
        return NM_ACT_STAGE_RETURN_FAILURE;
    }

    if (priv->connect_properties)
        g_hash_table_destroy(priv->connect_properties);

    priv->connect_properties = create_connect_properties(connection);

    _LOGI("activating context %s", priv->context_path);

    if (nm_modem_get_state(modem) == NM_MODEM_STATE_REGISTERED) {
        do_context_activate(self);
    } else {
        _LOGW("could not activate context: modem is not registered.");
        NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER);
        return NM_ACT_STAGE_RETURN_FAILURE;
    }

    return NM_ACT_STAGE_RETURN_POSTPONE;
}

static void
modem_proxy_new_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMModemOfono *       self;
    NMModemOfonoPrivate *priv;
    gs_free_error GError *error = NULL;
    GDBusProxy *          proxy;

    proxy = g_dbus_proxy_new_for_bus_finish(result, &error);
    if (!proxy && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = NM_MODEM_OFONO(user_data);
    priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    if (!proxy) {
        _LOGE("failed to create ofono modem DBus proxy: %s", error->message);
        g_clear_object(&priv->modem_proxy_cancellable);
        return;
    }

    priv->modem_proxy = proxy;

    _nm_dbus_signal_connect(priv->modem_proxy,
                            "PropertyChanged",
                            G_VARIANT_TYPE("(sv)"),
                            G_CALLBACK(modem_property_changed),
                            self);

    g_dbus_proxy_call(priv->modem_proxy,
                      "GetProperties",
                      NULL,
                      G_DBUS_CALL_FLAGS_NONE,
                      20000,
                      priv->modem_proxy_cancellable,
                      modem_get_properties_done,
                      self);
}

/*****************************************************************************/

static void
nm_modem_ofono_init(NMModemOfono *self)
{}

static void
constructed(GObject *object)
{
    NMModemOfono *       self = NM_MODEM_OFONO(object);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    priv->modem_proxy_cancellable = g_cancellable_new();

    g_dbus_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
                             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
                             NULL,
                             OFONO_DBUS_SERVICE,
                             nm_modem_get_path(NM_MODEM(self)),
                             OFONO_DBUS_INTERFACE_MODEM,
                             priv->modem_proxy_cancellable,
                             modem_proxy_new_cb,
                             self);

    G_OBJECT_CLASS(nm_modem_ofono_parent_class)->constructed(object);
}

NMModem *
nm_modem_ofono_new(const char *path)
{
    gs_free char *basename = NULL;

    g_return_val_if_fail(path != NULL, NULL);

    nm_log_info(LOGD_MB, "ofono: creating new Ofono modem path %s", path);

    /* Use short modem name (not its object path) as the NM device name (which
     * comes from NM_MODEM_UID)and the device ID.
     */
    basename = g_path_get_basename(path);

    return g_object_new(NM_TYPE_MODEM_OFONO,
                        NM_MODEM_PATH,
                        path,
                        NM_MODEM_UID,
                        basename,
                        NM_MODEM_DEVICE_ID,
                        basename,
                        NM_MODEM_CONTROL_PORT,
                        "ofono", /* mandatory */
                        NM_MODEM_DRIVER,
                        "ofono",
                        NM_MODEM_STATE,
                        (int) NM_MODEM_STATE_INITIALIZING,
                        NULL);
}

static void
dispose(GObject *object)
{
    NMModemOfono *       self = NM_MODEM_OFONO(object);
    NMModemOfonoPrivate *priv = NM_MODEM_OFONO_GET_PRIVATE(self);

    nm_clear_g_cancellable(&priv->modem_proxy_cancellable);
    nm_clear_g_cancellable(&priv->connman_proxy_cancellable);
    nm_clear_g_cancellable(&priv->context_proxy_cancellable);
    nm_clear_g_cancellable(&priv->sim_proxy_cancellable);

    if (priv->connect_properties) {
        g_hash_table_destroy(priv->connect_properties);
        priv->connect_properties = NULL;
    }

    g_clear_object(&priv->ip4_config);

    if (priv->modem_proxy) {
        g_signal_handlers_disconnect_by_data(priv->modem_proxy, self);
        g_clear_object(&priv->modem_proxy);
    }

    if (priv->connman_proxy) {
        g_signal_handlers_disconnect_by_data(priv->connman_proxy, self);
        g_clear_object(&priv->connman_proxy);
    }

    if (priv->context_proxy) {
        g_signal_handlers_disconnect_by_data(priv->context_proxy, self);
        g_clear_object(&priv->context_proxy);
    }

    if (priv->sim_proxy) {
        g_signal_handlers_disconnect_by_data(priv->sim_proxy, self);
        g_clear_object(&priv->sim_proxy);
    }

    g_free(priv->imsi);
    priv->imsi = NULL;

    G_OBJECT_CLASS(nm_modem_ofono_parent_class)->dispose(object);
}

static void
nm_modem_ofono_class_init(NMModemOfonoClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS(klass);
    NMModemClass *modem_class  = NM_MODEM_CLASS(klass);

    object_class->constructed = constructed;
    object_class->dispose     = dispose;

    modem_class->get_capabilities                       = get_capabilities;
    modem_class->disconnect                             = disconnect;
    modem_class->deactivate_cleanup                     = deactivate_cleanup;
    modem_class->check_connection_compatible_with_modem = check_connection_compatible_with_modem;

    modem_class->modem_act_stage1_prepare       = modem_act_stage1_prepare;
    modem_class->static_stage3_ip4_config_start = static_stage3_ip4_config_start;
}