/* SPDX-License-Identifier: GPL-2.0+ */ /* * 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, ¤t_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); }