/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2009 - 2019 Red Hat, Inc.
 */

#include "nm-default.h"

#include "nm-device-modem.h"

#include "nm-modem.h"
#include "nm-ip4-config.h"
#include "devices/nm-device-private.h"
#include "nm-rfkill-manager.h"
#include "settings/nm-settings-connection.h"
#include "nm-modem-broadband.h"
#include "NetworkManagerUtils.h"
#include "nm-core-internal.h"

#define _NMLOG_DEVICE_TYPE NMDeviceModem
#include "devices/nm-device-logging.h"

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

NM_GOBJECT_PROPERTIES_DEFINE(NMDeviceModem,
                             PROP_MODEM,
                             PROP_CAPABILITIES,
                             PROP_CURRENT_CAPABILITIES,
                             PROP_DEVICE_ID,
                             PROP_OPERATOR_CODE,
                             PROP_APN, );

typedef struct {
    NMModem *                 modem;
    NMDeviceModemCapabilities caps;
    NMDeviceModemCapabilities current_caps;
    char *                    device_id;
    char *                    operator_code;
    char *                    apn;
    bool                      rf_enabled : 1;
    NMDeviceStageState        stage1_state : 3;
} NMDeviceModemPrivate;

struct _NMDeviceModem {
    NMDevice             parent;
    NMDeviceModemPrivate _priv;
};

struct _NMDeviceModemClass {
    NMDeviceClass parent;
};

G_DEFINE_TYPE(NMDeviceModem, nm_device_modem, NM_TYPE_DEVICE)

#define NM_DEVICE_MODEM_GET_PRIVATE(self) \
    _NM_GET_PRIVATE(self, NMDeviceModem, NM_IS_DEVICE_MODEM, NMDevice)

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

static void
ppp_failed(NMModem *modem, guint i_reason, gpointer user_data)
{
    NMDevice *          device = NM_DEVICE(user_data);
    NMDeviceModem *     self   = NM_DEVICE_MODEM(user_data);
    NMDeviceStateReason reason = i_reason;

    switch (nm_device_get_state(device)) {
    case NM_DEVICE_STATE_PREPARE:
    case NM_DEVICE_STATE_CONFIG:
    case NM_DEVICE_STATE_NEED_AUTH:
        nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, reason);
        break;
    case NM_DEVICE_STATE_IP_CONFIG:
    case NM_DEVICE_STATE_IP_CHECK:
    case NM_DEVICE_STATE_SECONDARIES:
    case NM_DEVICE_STATE_ACTIVATED:
        if (nm_device_activate_ip4_state_in_conf(device))
            nm_device_activate_schedule_ip_config_timeout(device, AF_INET);
        else if (nm_device_activate_ip6_state_in_conf(device))
            nm_device_activate_schedule_ip_config_timeout(device, AF_INET6);
        else if (nm_device_activate_ip4_state_done(device)) {
            nm_device_ip_method_failed(device,
                                       AF_INET,
                                       NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        } else if (nm_device_activate_ip6_state_done(device)) {
            nm_device_ip_method_failed(device,
                                       AF_INET6,
                                       NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        } else {
            _LOGW(LOGD_MB,
                  "PPP failure in unexpected state %u",
                  (guint) nm_device_get_state(device));
            nm_device_state_changed(device,
                                    NM_DEVICE_STATE_FAILED,
                                    NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        }
        break;
    default:
        break;
    }
}

static void
modem_prepare_result(NMModem *modem, gboolean success, guint i_reason, gpointer user_data)
{
    NMDeviceModem *       self   = NM_DEVICE_MODEM(user_data);
    NMDeviceModemPrivate *priv   = NM_DEVICE_MODEM_GET_PRIVATE(self);
    NMDevice *            device = NM_DEVICE(self);
    NMDeviceStateReason   reason = i_reason;

    if (nm_device_get_state(device) != NM_DEVICE_STATE_PREPARE
        || priv->stage1_state != NM_DEVICE_STAGE_STATE_PENDING) {
        nm_assert_not_reached();
        success = FALSE;
    }

    if (!success) {
        /* There are several reasons to block autoconnection at device level:
         *
         *  - Wrong SIM-PIN: The device won't autoconnect because it doesn't make sense
         *    to retry the connection with the same PIN. This error also makes autoconnection
         *    blocked at settings level, so not even a modem unplug and replug will allow
         *    autoconnection again. It is somewhat redundant to block autoconnection at
         *    both device and setting level really.
         *
         *  - SIM wrong or not inserted: If the modem is reporting a SIM not inserted error,
         *    we can block autoconnection at device level, so that if the same device is
         *    unplugged and replugged with a SIM (or if a SIM hotplug event happens in MM,
         *    recreating the device completely), we can try the autoconnection again.
         *
         *  - Modem initialization failed: For some reason unknown to NM, the modem wasn't
         *    initialized correctly, which leads to an unusable device. A device unplug and
         *    replug may solve the issue, so make it a device-level autoconnection blocking
         *    reason.
         */
        switch (nm_device_state_reason_check(reason)) {
        case NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED:
        case NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED:
        case NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT:
            nm_device_autoconnect_blocked_set(device, NM_DEVICE_AUTOCONNECT_BLOCKED_WRONG_PIN);
            break;
        case NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED:
        case NM_DEVICE_STATE_REASON_GSM_SIM_WRONG:
            nm_device_autoconnect_blocked_set(device, NM_DEVICE_AUTOCONNECT_BLOCKED_SIM_MISSING);
            break;
        case NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED:
            nm_device_autoconnect_blocked_set(device, NM_DEVICE_AUTOCONNECT_BLOCKED_INIT_FAILED);
            break;
        default:
            break;
        }
        nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, reason);
        return;
    }

    priv->stage1_state = NM_DEVICE_STAGE_STATE_COMPLETED;
    nm_device_activate_schedule_stage1_device_prepare(device, FALSE);
}

static void
modem_auth_requested(NMModem *modem, gpointer user_data)
{
    NMDevice *device = NM_DEVICE(user_data);

    /* Auth requests (PIN, PAP/CHAP passwords, etc) only get handled
     * during activation.
     */
    if (!nm_device_is_activating(device))
        return;

    nm_device_state_changed(device, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NONE);
}

static void
modem_auth_result(NMModem *modem, GError *error, gpointer user_data)
{
    NMDevice *            device = NM_DEVICE(user_data);
    NMDeviceModemPrivate *priv   = NM_DEVICE_MODEM_GET_PRIVATE(device);

    g_return_if_fail(nm_device_get_state(device) == NM_DEVICE_STATE_NEED_AUTH);

    if (error) {
        nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS);
        return;
    }

    priv->stage1_state = NM_DEVICE_STAGE_STATE_INIT;
    nm_device_activate_schedule_stage1_device_prepare(device, FALSE);
}

static void
modem_ip4_config_result(NMModem *modem, NMIP4Config *config, GError *error, gpointer user_data)
{
    NMDeviceModem *self   = NM_DEVICE_MODEM(user_data);
    NMDevice *     device = NM_DEVICE(self);

    g_return_if_fail(nm_device_activate_ip4_state_in_conf(device) == TRUE);

    if (error) {
        _LOGW(LOGD_MB | LOGD_IP4, "retrieving IPv4 configuration failed: %s", error->message);
        nm_device_ip_method_failed(device, AF_INET, NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
    } else {
        nm_device_set_dev2_ip_config(device, AF_INET, NM_IP_CONFIG_CAST(config));
        nm_device_activate_schedule_ip_config_result(device, AF_INET, NULL);
    }
}

static void
modem_ip6_config_result(NMModem *    modem,
                        NMIP6Config *config,
                        gboolean     do_slaac,
                        GError *     error,
                        gpointer     user_data)
{
    NMDeviceModem *     self   = NM_DEVICE_MODEM(user_data);
    NMDevice *          device = NM_DEVICE(self);
    NMActStageReturn    ret;
    NMDeviceStateReason failure_reason      = NM_DEVICE_STATE_REASON_NONE;
    gs_unref_object NMIP6Config *ignored    = NULL;
    gboolean                     got_config = !!config;

    g_return_if_fail(nm_device_activate_ip6_state_in_conf(device) == TRUE);

    if (error) {
        _LOGW(LOGD_MB | LOGD_IP6, "retrieving IPv6 configuration failed: %s", error->message);
        nm_device_ip_method_failed(device, AF_INET6, NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        return;
    }

    /* Re-enable IPv6 on the interface */
    nm_device_sysctl_ip_conf_set(device, AF_INET6, "disable_ipv6", "0");

    if (config)
        nm_device_set_dev2_ip_config(device, AF_INET6, NM_IP_CONFIG_CAST(config));

    if (do_slaac == FALSE) {
        if (got_config)
            nm_device_activate_schedule_ip_config_result(device, AF_INET6, NULL);
        else {
            _LOGW(LOGD_MB | LOGD_IP6,
                  "retrieving IPv6 configuration failed: SLAAC not requested and no addresses");
            nm_device_ip_method_failed(device,
                                       AF_INET6,
                                       NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        }
        return;
    }

    /* Start SLAAC now that we have a link-local address from the modem */
    ret =
        NM_DEVICE_CLASS(nm_device_modem_parent_class)
            ->act_stage3_ip_config_start(device, AF_INET6, (gpointer *) &ignored, &failure_reason);

    nm_assert(ignored == NULL);

    switch (ret) {
    case NM_ACT_STAGE_RETURN_FAILURE:
        nm_device_ip_method_failed(device, AF_INET6, failure_reason);
        break;
    case NM_ACT_STAGE_RETURN_IP_FAIL:
        /* all done */
        nm_device_activate_schedule_ip_config_result(device, AF_INET6, NULL);
        break;
    case NM_ACT_STAGE_RETURN_POSTPONE:
        /* let SLAAC run */
        break;
    default:
        /* Should never get here since we've assured that the IPv6 method
         * will either be "auto" or "ignored" when starting IPv6 configuration.
         */
        nm_assert_not_reached();
    }
}

static void
ip_ifindex_changed_cb(NMModem *modem, GParamSpec *pspec, gpointer user_data)
{
    NMDevice *device = NM_DEVICE(user_data);

    if (!nm_device_is_activating(device))
        return;

    if (!nm_device_set_ip_ifindex(device, nm_modem_get_ip_ifindex(modem))) {
        nm_device_state_changed(device,
                                NM_DEVICE_STATE_FAILED,
                                NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
        return;
    }

    /* Disable IPv6 immediately on the interface since NM handles IPv6
     * internally, and leaving it enabled could allow the kernel's IPv6
     * RA handling code to run before NM is ready.
     */
    nm_device_sysctl_ip_conf_set(device, AF_INET6, "disable_ipv6", "1");
}

static void
operator_code_changed_cb(NMModem *modem, GParamSpec *pspec, gpointer user_data)
{
    NMDeviceModem *       self          = NM_DEVICE_MODEM(user_data);
    NMDeviceModemPrivate *priv          = NM_DEVICE_MODEM_GET_PRIVATE(self);
    const char *          operator_code = nm_modem_get_operator_code(modem);

    if (g_strcmp0(priv->operator_code, operator_code) != 0) {
        g_free(priv->operator_code);
        priv->operator_code = g_strdup(operator_code);
        _notify(self, PROP_OPERATOR_CODE);
    }
}

static void
apn_changed_cb(NMModem *modem, GParamSpec *pspec, gpointer user_data)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(user_data);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);
    const char *          apn  = nm_modem_get_apn(modem);

    if (g_strcmp0(priv->apn, apn) != 0) {
        g_free(priv->apn);
        priv->apn = g_strdup(apn);
        _notify(self, PROP_APN);
    }
}

static void
ids_changed_cb(NMModem *modem, GParamSpec *pspec, gpointer user_data)
{
    nm_device_recheck_available_connections(NM_DEVICE(user_data));
}

static void
modem_state_cb(NMModem *modem, int new_state_i, int old_state_i, gpointer user_data)
{
    NMModemState          new_state = new_state_i;
    NMModemState          old_state = old_state_i;
    NMDevice *            device    = NM_DEVICE(user_data);
    NMDeviceModemPrivate *priv      = NM_DEVICE_MODEM_GET_PRIVATE(device);
    NMDeviceState         dev_state = nm_device_get_state(device);

    if (new_state <= NM_MODEM_STATE_DISABLING && old_state > NM_MODEM_STATE_DISABLING
        && priv->rf_enabled) {
        /* Called when the ModemManager modem enabled state is changed externally
         * to NetworkManager (eg something using MM's D-Bus API directly).
         */
        if (nm_device_is_activating(device) || dev_state == NM_DEVICE_STATE_ACTIVATED) {
            /* user-initiated action, hence DISCONNECTED not FAILED */
            nm_device_state_changed(device,
                                    NM_DEVICE_STATE_DISCONNECTED,
                                    NM_DEVICE_STATE_REASON_USER_REQUESTED);
            return;
        }
    }

    if (new_state < NM_MODEM_STATE_CONNECTING && old_state >= NM_MODEM_STATE_CONNECTING
        && dev_state >= NM_DEVICE_STATE_NEED_AUTH && dev_state <= NM_DEVICE_STATE_ACTIVATED) {
        /* Fail the device if the modem disconnects unexpectedly while the
         * device is activating/activated. */
        nm_device_state_changed(device,
                                NM_DEVICE_STATE_FAILED,
                                NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER);
        return;
    }

    if (new_state > NM_MODEM_STATE_LOCKED && old_state == NM_MODEM_STATE_LOCKED) {
        /* If the modem is now unlocked, enable/disable it according to the
         * device's enabled/disabled state.
         */
        nm_modem_set_mm_enabled(priv->modem, priv->rf_enabled);

        if (dev_state == NM_DEVICE_STATE_NEED_AUTH) {
            /* The modem was unlocked externally to NetworkManager,
             * deactivate so the default connection can be
             * automatically activated again */
            nm_device_state_changed(device,
                                    NM_DEVICE_STATE_DEACTIVATING,
                                    NM_DEVICE_STATE_REASON_MODEM_AVAILABLE);
        }

        /* Now allow connections without a PIN to be available */
        nm_device_recheck_available_connections(device);
    }

    nm_device_queue_recheck_available(device,
                                      NM_DEVICE_STATE_REASON_MODEM_AVAILABLE,
                                      NM_DEVICE_STATE_REASON_MODEM_FAILED);
}

static void
modem_removed_cb(NMModem *modem, gpointer user_data)
{
    g_signal_emit_by_name(NM_DEVICE(user_data), NM_DEVICE_REMOVED);
}

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

static gboolean
owns_iface(NMDevice *device, const char *iface)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);

    g_return_val_if_fail(priv->modem, FALSE);

    return nm_modem_owns_port(priv->modem, iface);
}

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

static void
device_state_changed(NMDevice *          device,
                     NMDeviceState       new_state,
                     NMDeviceState       old_state,
                     NMDeviceStateReason reason)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(device);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);

    g_return_if_fail(priv->modem);

    if (new_state == NM_DEVICE_STATE_UNAVAILABLE && old_state < NM_DEVICE_STATE_UNAVAILABLE) {
        /* Log initial modem state */
        _LOGI(LOGD_MB,
              "modem state '%s'",
              nm_modem_state_to_string(nm_modem_get_state(priv->modem)));
    }
    nm_modem_device_state_changed(priv->modem, new_state, old_state);
}

static NMDeviceCapabilities
get_generic_capabilities(NMDevice *device)
{
    return NM_DEVICE_CAP_IS_NON_KERNEL;
}

static const char *
get_type_description(NMDevice *device)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);

    if (NM_FLAGS_HAS(priv->current_caps, NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS))
        return "gsm";
    if (NM_FLAGS_HAS(priv->current_caps, NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO))
        return "cdma";
    return NM_DEVICE_CLASS(nm_device_modem_parent_class)->get_type_description(device);
}

static gboolean
check_connection_compatible(NMDevice *device, NMConnection *connection, GError **error)
{
    GError *local = NULL;

    if (!NM_DEVICE_CLASS(nm_device_modem_parent_class)
             ->check_connection_compatible(device, connection, error))
        return FALSE;

    if (!nm_modem_check_connection_compatible(NM_DEVICE_MODEM_GET_PRIVATE(device)->modem,
                                              connection,
                                              error ? &local : NULL)) {
        if (error) {
            g_set_error(error,
                        NM_UTILS_ERROR,
                        g_error_matches(local,
                                        NM_UTILS_ERROR,
                                        NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE)
                            ? NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE
                            : NM_UTILS_ERROR_UNKNOWN,
                        "modem is incompatible with connection: %s",
                        local->message);
            g_error_free(local);
        }
        return FALSE;
    }
    return TRUE;
}

static gboolean
check_connection_available(NMDevice *                     device,
                           NMConnection *                 connection,
                           NMDeviceCheckConAvailableFlags flags,
                           const char *                   specific_object,
                           GError **                      error)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(device);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);
    NMModemState          state;

    if (!priv->rf_enabled) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "RFKILL for modem enabled");
        return FALSE;
    }

    if (!priv->modem) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "modem not available");
        return FALSE;
    }

    state = nm_modem_get_state(priv->modem);
    if (state <= NM_MODEM_STATE_INITIALIZING) {
        nm_utils_error_set_literal(error,
                                   NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                   "modem not initialized");
        return FALSE;
    }

    if (state == NM_MODEM_STATE_LOCKED) {
        if (!nm_connection_get_setting_gsm(connection)) {
            nm_utils_error_set_literal(error,
                                       NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
                                       "modem is locked without pin available");
            return FALSE;
        }
    }

    return TRUE;
}

static gboolean
complete_connection(NMDevice *           device,
                    NMConnection *       connection,
                    const char *         specific_object,
                    NMConnection *const *existing_connections,
                    GError **            error)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);

    return nm_modem_complete_connection(priv->modem,
                                        nm_device_get_iface(device),
                                        connection,
                                        existing_connections,
                                        error);
}

static void
deactivate(NMDevice *device)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);

    nm_modem_deactivate(priv->modem, device);
    priv->stage1_state = NM_DEVICE_STAGE_STATE_INIT;
}

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

static void
modem_deactivate_async_cb(NMModem *modem, GError *error, gpointer user_data)
{
    gs_unref_object NMDevice * self = NULL;
    NMDeviceDeactivateCallback callback;
    gpointer                   callback_user_data;

    nm_utils_user_data_unpack(user_data, &self, &callback, &callback_user_data);
    callback(self, error, callback_user_data);
}

static void
deactivate_async(NMDevice *                 self,
                 GCancellable *             cancellable,
                 NMDeviceDeactivateCallback callback,
                 gpointer                   user_data)
{
    nm_assert(G_IS_CANCELLABLE(cancellable));
    nm_assert(callback);

    nm_modem_deactivate_async(NM_DEVICE_MODEM_GET_PRIVATE(self)->modem,
                              self,
                              cancellable,
                              modem_deactivate_async_cb,
                              nm_utils_user_data_pack(g_object_ref(self), callback, user_data));
}

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

static NMActStageReturn
act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);
    NMActRequest *        req;

    req = nm_device_get_act_request(device);
    g_return_val_if_fail(req, NM_ACT_STAGE_RETURN_FAILURE);

    if (priv->stage1_state == NM_DEVICE_STAGE_STATE_INIT) {
        priv->stage1_state = NM_DEVICE_STAGE_STATE_PENDING;
        return nm_modem_act_stage1_prepare(NM_DEVICE_MODEM_GET_PRIVATE(device)->modem,
                                           req,
                                           out_failure_reason);
    }

    if (priv->stage1_state == NM_DEVICE_STAGE_STATE_PENDING)
        return NM_ACT_STAGE_RETURN_POSTPONE;

    nm_assert(priv->stage1_state == NM_DEVICE_STAGE_STATE_COMPLETED);
    return NM_ACT_STAGE_RETURN_SUCCESS;
}

static NMActStageReturn
act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason)
{
    nm_modem_act_stage2_config(NM_DEVICE_MODEM_GET_PRIVATE(device)->modem);
    return NM_ACT_STAGE_RETURN_SUCCESS;
}

static NMActStageReturn
act_stage3_ip_config_start(NMDevice *           device,
                           int                  addr_family,
                           gpointer *           out_config,
                           NMDeviceStateReason *out_failure_reason)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(device);

    nm_assert_addr_family(addr_family);

    if (addr_family == AF_INET) {
        return nm_modem_stage3_ip4_config_start(priv->modem,
                                                device,
                                                NM_DEVICE_CLASS(nm_device_modem_parent_class),
                                                out_failure_reason);
    } else {
        return nm_modem_stage3_ip6_config_start(priv->modem, device, out_failure_reason);
    }
}

static void
ip4_config_pre_commit(NMDevice *device, NMIP4Config *config)
{
    nm_modem_ip4_pre_commit(NM_DEVICE_MODEM_GET_PRIVATE(device)->modem, device, config);
}

static gboolean
get_ip_iface_identifier(NMDevice *device, NMUtilsIPv6IfaceId *out_iid)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(device);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);
    gboolean              success;

    g_return_val_if_fail(priv->modem, FALSE);
    success = nm_modem_get_iid(priv->modem, out_iid);
    if (!success)
        success =
            NM_DEVICE_CLASS(nm_device_modem_parent_class)->get_ip_iface_identifier(device, out_iid);
    return success;
}

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

static gboolean
get_enabled(NMDevice *device)
{
    NMDeviceModemPrivate *priv        = NM_DEVICE_MODEM_GET_PRIVATE(device);
    NMModemState          modem_state = nm_modem_get_state(priv->modem);

    return priv->rf_enabled && (modem_state >= NM_MODEM_STATE_LOCKED);
}

static void
set_enabled(NMDevice *device, gboolean enabled)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(device);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);

    /* Called only by the Manager in response to rfkill switch changes or
     * global user WWAN enable/disable preference changes.
     */
    priv->rf_enabled = enabled;

    if (priv->modem) {
        /* Sync the ModemManager modem enabled/disabled with rfkill/user preference */
        nm_modem_set_mm_enabled(priv->modem, enabled);
    }

    if (enabled == FALSE) {
        nm_device_state_changed(device, NM_DEVICE_STATE_UNAVAILABLE, NM_DEVICE_STATE_REASON_NONE);
    }
}

static gboolean
is_available(NMDevice *device, NMDeviceCheckDevAvailableFlags flags)
{
    NMDeviceModem *       self = NM_DEVICE_MODEM(device);
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);
    NMModemState          modem_state;

    if (!priv->rf_enabled)
        return FALSE;

    g_assert(priv->modem);
    modem_state = nm_modem_get_state(priv->modem);
    if (modem_state <= NM_MODEM_STATE_INITIALIZING)
        return FALSE;

    return TRUE;
}

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

static void
set_modem(NMDeviceModem *self, NMModem *modem)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(self);

    g_return_if_fail(modem != NULL);

    priv->modem = nm_modem_claim(modem);

    g_signal_connect(modem, NM_MODEM_PPP_FAILED, G_CALLBACK(ppp_failed), self);
    g_signal_connect(modem, NM_MODEM_PREPARE_RESULT, G_CALLBACK(modem_prepare_result), self);
    g_signal_connect(modem, NM_MODEM_IP4_CONFIG_RESULT, G_CALLBACK(modem_ip4_config_result), self);
    g_signal_connect(modem, NM_MODEM_IP6_CONFIG_RESULT, G_CALLBACK(modem_ip6_config_result), self);
    g_signal_connect(modem, NM_MODEM_AUTH_REQUESTED, G_CALLBACK(modem_auth_requested), self);
    g_signal_connect(modem, NM_MODEM_AUTH_RESULT, G_CALLBACK(modem_auth_result), self);
    g_signal_connect(modem, NM_MODEM_STATE_CHANGED, G_CALLBACK(modem_state_cb), self);
    g_signal_connect(modem, NM_MODEM_REMOVED, G_CALLBACK(modem_removed_cb), self);

    g_signal_connect(modem,
                     "notify::" NM_MODEM_IP_IFINDEX,
                     G_CALLBACK(ip_ifindex_changed_cb),
                     self);
    g_signal_connect(modem, "notify::" NM_MODEM_DEVICE_ID, G_CALLBACK(ids_changed_cb), self);
    g_signal_connect(modem, "notify::" NM_MODEM_SIM_ID, G_CALLBACK(ids_changed_cb), self);
    g_signal_connect(modem, "notify::" NM_MODEM_SIM_OPERATOR_ID, G_CALLBACK(ids_changed_cb), self);
    g_signal_connect(modem,
                     "notify::" NM_MODEM_OPERATOR_CODE,
                     G_CALLBACK(operator_code_changed_cb),
                     self);
    g_signal_connect(modem, "notify::" NM_MODEM_APN, G_CALLBACK(apn_changed_cb), self);
}

static guint32
get_dhcp_timeout_for_device(NMDevice *device, int addr_family)
{
    /* DHCP is always done by the modem firmware, not by the network, and
     * by the time we get around to DHCP the firmware should already know
     * the IP addressing details.  So the DHCP timeout can be much shorter.
     */
    return 15;
}

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

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(object);

    switch (prop_id) {
    case PROP_MODEM:
        g_value_set_object(value, priv->modem);
        break;
    case PROP_CAPABILITIES:
        g_value_set_uint(value, priv->caps);
        break;
    case PROP_CURRENT_CAPABILITIES:
        g_value_set_uint(value, priv->current_caps);
        break;
    case PROP_DEVICE_ID:
        g_value_set_string(value, priv->device_id);
        break;
    case PROP_OPERATOR_CODE:
        g_value_set_string(value, priv->operator_code);
        break;
    case PROP_APN:
        g_value_set_string(value, priv->apn);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

static void
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(object);

    switch (prop_id) {
    case PROP_MODEM:
        /* construct-only */
        set_modem(NM_DEVICE_MODEM(object), g_value_get_object(value));
        break;
    case PROP_CAPABILITIES:
        priv->caps = g_value_get_uint(value);
        break;
    case PROP_CURRENT_CAPABILITIES:
        priv->current_caps = g_value_get_uint(value);
        break;
    case PROP_DEVICE_ID:
        /* construct-only */
        priv->device_id = g_value_dup_string(value);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

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

static void
nm_device_modem_init(NMDeviceModem *self)
{}

NMDevice *
nm_device_modem_new(NMModem *modem)
{
    NMDeviceModemCapabilities caps         = NM_DEVICE_MODEM_CAPABILITY_NONE;
    NMDeviceModemCapabilities current_caps = NM_DEVICE_MODEM_CAPABILITY_NONE;

    g_return_val_if_fail(NM_IS_MODEM(modem), NULL);

    /* Load capabilities */
    nm_modem_get_capabilities(modem, &caps, &current_caps);

    return g_object_new(NM_TYPE_DEVICE_MODEM,
                        NM_DEVICE_UDI,
                        nm_modem_get_path(modem),
                        NM_DEVICE_IFACE,
                        nm_modem_get_uid(modem),
                        NM_DEVICE_DRIVER,
                        nm_modem_get_driver(modem),
                        NM_DEVICE_TYPE_DESC,
                        "Broadband",
                        NM_DEVICE_DEVICE_TYPE,
                        NM_DEVICE_TYPE_MODEM,
                        NM_DEVICE_RFKILL_TYPE,
                        RFKILL_TYPE_WWAN,
                        NM_DEVICE_MODEM_MODEM,
                        modem,
                        NM_DEVICE_MODEM_CAPABILITIES,
                        caps,
                        NM_DEVICE_MODEM_CURRENT_CAPABILITIES,
                        current_caps,
                        NM_DEVICE_MODEM_DEVICE_ID,
                        nm_modem_get_device_id(modem),
                        NULL);
}

static void
dispose(GObject *object)
{
    NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE(object);

    if (priv->modem) {
        g_signal_handlers_disconnect_by_data(priv->modem, NM_DEVICE_MODEM(object));
        nm_clear_pointer(&priv->modem, nm_modem_unclaim);
    }

    nm_clear_g_free(&priv->device_id);
    nm_clear_g_free(&priv->operator_code);
    nm_clear_g_free(&priv->apn);

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

static const NMDBusInterfaceInfoExtended interface_info_device_modem = {
    .parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT(
        NM_DBUS_INTERFACE_DEVICE_MODEM,
        .signals    = NM_DEFINE_GDBUS_SIGNAL_INFOS(&nm_signal_info_property_changed_legacy, ),
        .properties = NM_DEFINE_GDBUS_PROPERTY_INFOS(
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("ModemCapabilities",
                                                             "u",
                                                             NM_DEVICE_MODEM_CAPABILITIES),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("CurrentCapabilities",
                                                             "u",
                                                             NM_DEVICE_MODEM_CURRENT_CAPABILITIES),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("DeviceId",
                                                           "s",
                                                           NM_DEVICE_MODEM_DEVICE_ID),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("OperatorCode",
                                                           "s",
                                                           NM_DEVICE_MODEM_OPERATOR_CODE),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Apn", "s", NM_DEVICE_MODEM_APN), ), ),
    .legacy_property_changed = TRUE,
};

static void
nm_device_modem_class_init(NMDeviceModemClass *klass)
{
    GObjectClass *     object_class      = G_OBJECT_CLASS(klass);
    NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass);
    NMDeviceClass *    device_class      = NM_DEVICE_CLASS(klass);

    object_class->dispose      = dispose;
    object_class->get_property = get_property;
    object_class->set_property = set_property;

    dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS(&interface_info_device_modem);

    device_class->get_generic_capabilities    = get_generic_capabilities;
    device_class->get_type_description        = get_type_description;
    device_class->check_connection_compatible = check_connection_compatible;
    device_class->check_connection_available  = check_connection_available;
    device_class->complete_connection         = complete_connection;
    device_class->deactivate_async            = deactivate_async;
    device_class->deactivate                  = deactivate;
    device_class->act_stage1_prepare          = act_stage1_prepare;
    device_class->act_stage2_config           = act_stage2_config;
    device_class->act_stage3_ip_config_start  = act_stage3_ip_config_start;
    device_class->ip4_config_pre_commit       = ip4_config_pre_commit;
    device_class->get_enabled                 = get_enabled;
    device_class->set_enabled                 = set_enabled;
    device_class->owns_iface                  = owns_iface;
    device_class->is_available                = is_available;
    device_class->get_ip_iface_identifier     = get_ip_iface_identifier;
    device_class->get_configured_mtu          = nm_modem_get_configured_mtu;
    device_class->get_dhcp_timeout_for_device = get_dhcp_timeout_for_device;

    device_class->state_changed = device_state_changed;

    obj_properties[PROP_MODEM] =
        g_param_spec_object(NM_DEVICE_MODEM_MODEM,
                            "",
                            "",
                            NM_TYPE_MODEM,
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_CAPABILITIES] =
        g_param_spec_uint(NM_DEVICE_MODEM_CAPABILITIES,
                          "",
                          "",
                          0,
                          G_MAXUINT32,
                          NM_DEVICE_MODEM_CAPABILITY_NONE,
                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_CURRENT_CAPABILITIES] =
        g_param_spec_uint(NM_DEVICE_MODEM_CURRENT_CAPABILITIES,
                          "",
                          "",
                          0,
                          G_MAXUINT32,
                          NM_DEVICE_MODEM_CAPABILITY_NONE,
                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_DEVICE_ID] =
        g_param_spec_string(NM_DEVICE_MODEM_DEVICE_ID,
                            "",
                            "",
                            NULL,
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_OPERATOR_CODE] =
        g_param_spec_string(NM_DEVICE_MODEM_OPERATOR_CODE,
                            "",
                            "",
                            NULL,
                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_APN] = g_param_spec_string(NM_DEVICE_MODEM_APN,
                                                   "",
                                                   "",
                                                   NULL,
                                                   G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}
