From 165224b485cfc5df07ea7b1a9a6be78e24b530f8 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 19:42:26 +0100 Subject: [PATCH 01/13] core/rfkill: move rfkill_type property to NMDeviceClass GObject Properties are flexible and powerful. In practice, NMDevicePrivate.rfkill_type was only set once via the construct-only property NM_DEVICE_RFKILL_TYPE. Which in turn was always set to a well-known value, only depending on the device type. We don't need this flexibility. The rfkill-type only depends on the device type and doesn't change. Replace the property by a field in NMDeviceClass. For one, construct properties have an overhead, that the property setter is called whenever we construct a NMDevice. But the real reason for this change, is that a property give a notion as this could change during the lifetime of a NMDevice (which it in fact did not, being construct-only). Or that the type depends on something more complex, when instead it only depends on the device type. A non-mutated class property is simpler, because it's clear that it does not depend on the device instance, only on the type/class. Also, `git grep -w rfkill_type` now nicely shows the (few) references to this variable and its easier to understand. --- src/core/devices/nm-device.c | 27 +++++++--------------- src/core/devices/nm-device.h | 4 ++-- src/core/devices/wifi/nm-device-iwd-p2p.c | 4 ++-- src/core/devices/wifi/nm-device-iwd.c | 4 ++-- src/core/devices/wifi/nm-device-wifi-p2p.c | 4 ++-- src/core/devices/wifi/nm-device-wifi.c | 4 ++-- src/core/devices/wwan/nm-device-modem.c | 4 ++-- 7 files changed, 20 insertions(+), 31 deletions(-) diff --git a/src/core/devices/nm-device.c b/src/core/devices/nm-device.c index bdfb70a5ae..b23788a3ea 100644 --- a/src/core/devices/nm-device.c +++ b/src/core/devices/nm-device.c @@ -361,7 +361,6 @@ NM_GOBJECT_PROPERTIES_DEFINE(NMDevice, PROP_FIRMWARE_MISSING, PROP_NM_PLUGIN_MISSING, PROP_TYPE_DESC, - PROP_RFKILL_TYPE, PROP_IFINDEX, PROP_AVAILABLE_CONNECTIONS, PROP_PHYSICAL_PORT_ID, @@ -473,7 +472,6 @@ typedef struct _NMDevicePrivate { char *driver; char *driver_version; char *firmware_version; - RfKillType rfkill_type; bool firmware_missing : 1; bool nm_plugin_missing : 1; bool @@ -5152,9 +5150,14 @@ nm_device_get_applied_setting(NMDevice *self, GType setting_type) RfKillType nm_device_get_rfkill_type(NMDevice *self) { + RfKillType t; + g_return_val_if_fail(NM_IS_DEVICE(self), FALSE); - return NM_DEVICE_GET_PRIVATE(self)->rfkill_type; + t = NM_DEVICE_GET_CLASS(self)->rfkill_type; + + nm_assert(NM_IN_SET(t, RFKILL_TYPE_UNKNOWN, RFKILL_TYPE_WLAN, RFKILL_TYPE_WWAN)); + return t; } static const char * @@ -16987,9 +16990,6 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) case PROP_TYPE_DESC: g_value_set_string(value, priv->type_desc); break; - case PROP_RFKILL_TYPE: - g_value_set_uint(value, priv->rfkill_type); - break; case PROP_AVAILABLE_CONNECTIONS: nm_dbus_utils_g_value_set_object_path_from_hash(value, priv->available_connections, TRUE); break; @@ -17125,10 +17125,6 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps /* construct-only */ priv->type_desc = g_value_dup_string(value); break; - case PROP_RFKILL_TYPE: - /* construct-only */ - priv->rfkill_type = g_value_get_uint(value); - break; case PROP_PERM_HW_ADDRESS: /* construct-only */ priv->hw_addr_perm = g_value_dup_string(value); @@ -17178,7 +17174,6 @@ nm_device_init(NMDevice *self) priv->capabilities = NM_DEVICE_CAP_NM_SUPPORTED; priv->state = NM_DEVICE_STATE_UNMANAGED; priv->state_reason = NM_DEVICE_STATE_REASON_NONE; - priv->rfkill_type = RFKILL_TYPE_UNKNOWN; priv->unmanaged_flags = NM_UNMANAGED_PLATFORM_INIT; priv->unmanaged_mask = priv->unmanaged_flags; priv->available_connections = g_hash_table_new_full(nm_direct_hash, NULL, g_object_unref, NULL); @@ -17581,6 +17576,8 @@ nm_device_class_init(NMDeviceClass *klass) klass->reapply_connection = reapply_connection; klass->set_platform_mtu = set_platform_mtu; + klass->rfkill_type = RFKILL_TYPE_UNKNOWN; + obj_properties[PROP_UDI] = g_param_spec_string(NM_DEVICE_UDI, "", @@ -17738,14 +17735,6 @@ nm_device_class_init(NMDeviceClass *klass) "", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); - obj_properties[PROP_RFKILL_TYPE] = - g_param_spec_uint(NM_DEVICE_RFKILL_TYPE, - "", - "", - RFKILL_TYPE_WLAN, - RFKILL_TYPE_MAX, - RFKILL_TYPE_UNKNOWN, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); obj_properties[PROP_IFINDEX] = g_param_spec_int(NM_DEVICE_IFINDEX, "", "", diff --git a/src/core/devices/nm-device.h b/src/core/devices/nm-device.h index 4c3abc05f7..7780860d6f 100644 --- a/src/core/devices/nm-device.h +++ b/src/core/devices/nm-device.h @@ -65,7 +65,6 @@ #define NM_DEVICE_SLAVES "slaves" /* partially internal */ #define NM_DEVICE_TYPE_DESC "type-desc" /* Internal only */ -#define NM_DEVICE_RFKILL_TYPE "rfkill-type" /* Internal only */ #define NM_DEVICE_IFINDEX "ifindex" /* Internal only */ #define NM_DEVICE_MASTER "master" /* Internal only */ #define NM_DEVICE_HAS_PENDING_ACTION "has-pending-action" /* Internal only */ @@ -208,6 +207,8 @@ typedef struct _NMDeviceClass { bool can_reapply_change_ovs_external_ids : 1; + RfKillType rfkill_type : 4; + void (*state_changed)(NMDevice *device, NMDeviceState new_state, NMDeviceState old_state, @@ -409,7 +410,6 @@ typedef struct _NMDeviceClass { gboolean (*set_platform_mtu)(NMDevice *self, guint32 mtu); const char *(*get_dhcp_anycast_address)(NMDevice *self); - } NMDeviceClass; GType nm_device_get_type(void); diff --git a/src/core/devices/wifi/nm-device-iwd-p2p.c b/src/core/devices/wifi/nm-device-iwd-p2p.c index 01774b12f7..b0f7e39280 100644 --- a/src/core/devices/wifi/nm-device-iwd-p2p.c +++ b/src/core/devices/wifi/nm-device-iwd-p2p.c @@ -1196,8 +1196,6 @@ nm_device_iwd_p2p_new(GDBusObject *dbus_obj) NM_DEVICE_TYPE_WIFI_P2P, NM_DEVICE_LINK_TYPE, NM_LINK_TYPE_WIFI, - NM_DEVICE_RFKILL_TYPE, - RFKILL_TYPE_WLAN, NULL); if (!self || !nm_device_iwd_p2p_set_dbus_obj(self, dbus_obj)) @@ -1252,6 +1250,8 @@ nm_device_iwd_p2p_class_init(NMDeviceIwdP2PClass *klass) device_class->state_changed = device_state_changed; + device_class->rfkill_type = RFKILL_TYPE_WLAN; + obj_properties[PROP_PEERS] = g_param_spec_boxed(NM_DEVICE_IWD_P2P_PEERS, "", "", diff --git a/src/core/devices/wifi/nm-device-iwd.c b/src/core/devices/wifi/nm-device-iwd.c index 7543d9daf8..a92f92642b 100644 --- a/src/core/devices/wifi/nm-device-iwd.c +++ b/src/core/devices/wifi/nm-device-iwd.c @@ -3426,8 +3426,6 @@ nm_device_iwd_new(const char *iface) NM_DEVICE_TYPE_WIFI, NM_DEVICE_LINK_TYPE, NM_LINK_TYPE_WIFI, - NM_DEVICE_RFKILL_TYPE, - RFKILL_TYPE_WLAN, NULL); } @@ -3490,6 +3488,8 @@ nm_device_iwd_class_init(NMDeviceIwdClass *klass) device_class->state_changed = device_state_changed; + device_class->rfkill_type = RFKILL_TYPE_WLAN; + obj_properties[PROP_MODE] = g_param_spec_uint(NM_DEVICE_IWD_MODE, "", "", diff --git a/src/core/devices/wifi/nm-device-wifi-p2p.c b/src/core/devices/wifi/nm-device-wifi-p2p.c index dfbf89785c..326729fadf 100644 --- a/src/core/devices/wifi/nm-device-wifi-p2p.c +++ b/src/core/devices/wifi/nm-device-wifi-p2p.c @@ -1229,8 +1229,6 @@ nm_device_wifi_p2p_new(const char *iface) NM_DEVICE_TYPE_WIFI_P2P, NM_DEVICE_LINK_TYPE, NM_LINK_TYPE_WIFI, - NM_DEVICE_RFKILL_TYPE, - RFKILL_TYPE_WLAN, NULL); } @@ -1293,6 +1291,8 @@ nm_device_wifi_p2p_class_init(NMDeviceWifiP2PClass *klass) device_class->state_changed = device_state_changed; + device_class->rfkill_type = RFKILL_TYPE_WLAN; + obj_properties[PROP_PEERS] = g_param_spec_boxed(NM_DEVICE_WIFI_P2P_PEERS, "", "", diff --git a/src/core/devices/wifi/nm-device-wifi.c b/src/core/devices/wifi/nm-device-wifi.c index 010cee0834..5d1099ada7 100644 --- a/src/core/devices/wifi/nm-device-wifi.c +++ b/src/core/devices/wifi/nm-device-wifi.c @@ -3663,8 +3663,6 @@ nm_device_wifi_new(const char *iface, _NMDeviceWifiCapabilities capabilities) NM_DEVICE_TYPE_WIFI, NM_DEVICE_LINK_TYPE, NM_LINK_TYPE_WIFI, - NM_DEVICE_RFKILL_TYPE, - RFKILL_TYPE_WLAN, NM_DEVICE_WIFI_CAPABILITIES, (guint) capabilities, NULL); @@ -3756,6 +3754,8 @@ nm_device_wifi_class_init(NMDeviceWifiClass *klass) device_class->state_changed = device_state_changed; + device_class->rfkill_type = RFKILL_TYPE_WLAN; + obj_properties[PROP_MODE] = g_param_spec_uint(NM_DEVICE_WIFI_MODE, "", "", diff --git a/src/core/devices/wwan/nm-device-modem.c b/src/core/devices/wwan/nm-device-modem.c index ef802a44f2..6ac4e6e359 100644 --- a/src/core/devices/wwan/nm-device-modem.c +++ b/src/core/devices/wwan/nm-device-modem.c @@ -757,8 +757,6 @@ nm_device_modem_new(NMModem *modem) "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, @@ -840,6 +838,8 @@ nm_device_modem_class_init(NMDeviceModemClass *klass) device_class->state_changed = device_state_changed; + device_class->rfkill_type = RFKILL_TYPE_WWAN; + obj_properties[PROP_MODEM] = g_param_spec_object(NM_DEVICE_MODEM_MODEM, "", From 99ceb205e97a5574d29c70ff322725c71926fc72 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 20:07:18 +0100 Subject: [PATCH 02/13] core/rfkill: cleanup rfkill handling in NMManager - use "const RadioState" where possible - use "bool" bitfields in RadioState (boolean flags in structs should be `bool` types for consistency) and order fields by alignment. - break lines for variable declaration in manager_rfkill_update_one_type(). - return (and nm_assert()) from update_rstate_from_rfkill(). By not adding a default case, compiler would warn if we forget to handle an enum value. We can easily do that, by just returning, and let the "default" case be handled by nm_assert_not_reached() -- which unlike g_warn_if_reached() compiles to nothing in release build. - add nm_assert() that `priv->radio_states[rtype]` is not out of range. - use designated initializers for priv->radio_states[]. --- src/core/nm-manager.c | 77 ++++++++++++++++++++++--------------------- 1 file changed, 40 insertions(+), 37 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index b440b22457..42fb0e3633 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -54,14 +54,14 @@ /*****************************************************************************/ typedef struct { - gboolean user_enabled; - gboolean sw_enabled; - gboolean hw_enabled; - RfKillType rtype; - NMConfigRunStatePropertyType key; const char *desc; const char *prop; const char *hw_prop; + RfKillType rtype; + NMConfigRunStatePropertyType key; + bool user_enabled : 1; + bool sw_enabled : 1; + bool hw_enabled : 1; } RadioState; typedef enum { @@ -169,7 +169,8 @@ typedef struct { NMSettings *settings; - RadioState radio_states[RFKILL_TYPE_MAX]; + RadioState radio_states[RFKILL_TYPE_MAX]; + NMVpnManager *vpn_manager; NMSleepMonitor *sleep_monitor; @@ -2280,7 +2281,7 @@ _static_hostname_changed_cb(NMHostnameManager *hostname_manager, GParamSpec *psp /*****************************************************************************/ static gboolean -radio_enabled_for_rstate(RadioState *rstate, gboolean check_changeable) +radio_enabled_for_rstate(const RadioState *rstate, gboolean check_changeable) { gboolean enabled; @@ -2295,11 +2296,13 @@ radio_enabled_for_type(NMManager *self, RfKillType rtype, gboolean check_changea { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + nm_assert(_NM_INT_NOT_NEGATIVE(rtype) && rtype < G_N_ELEMENTS(priv->radio_states)); + return radio_enabled_for_rstate(&priv->radio_states[rtype], check_changeable); } static void -manager_update_radio_enabled(NMManager *self, RadioState *rstate, gboolean enabled) +manager_update_radio_enabled(NMManager *self, const RadioState *rstate, gboolean enabled) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); NMDevice *device; @@ -2333,26 +2336,28 @@ update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, RadioState *rstate) case RFKILL_UNBLOCKED: rstate->sw_enabled = TRUE; rstate->hw_enabled = TRUE; - break; + return; case RFKILL_SOFT_BLOCKED: rstate->sw_enabled = FALSE; rstate->hw_enabled = TRUE; - break; + return; case RFKILL_HARD_BLOCKED: rstate->sw_enabled = FALSE; rstate->hw_enabled = FALSE; - break; - default: - g_warn_if_reached(); - break; + return; } + nm_assert_not_reached(); } static void manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, RfKillType rtype) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); - gboolean old_enabled, new_enabled, old_rfkilled, new_rfkilled, old_hwe; + gboolean old_enabled; + gboolean new_enabled; + gboolean old_rfkilled; + gboolean new_rfkilled; + gboolean old_hwe; old_enabled = radio_enabled_for_rstate(rstate, TRUE); old_rfkilled = rstate->hw_enabled && rstate->sw_enabled; @@ -6331,8 +6336,8 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) * to killswitch changes during sleep. */ for (i = 0; i < RFKILL_TYPE_MAX; i++) { - RadioState *rstate = &priv->radio_states[i]; - gboolean enabled = radio_enabled_for_rstate(rstate, TRUE); + const RadioState *rstate = &priv->radio_states[i]; + gboolean enabled = radio_enabled_for_rstate(rstate, TRUE); if (rstate->desc) { _LOGD(LOGD_RFKILL, @@ -7904,7 +7909,6 @@ static void nm_manager_init(NMManager *self) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); - guint i; GFile *file; c_list_init(&priv->auth_lst_head); @@ -7918,25 +7922,24 @@ nm_manager_init(NMManager *self) priv->capabilities = g_array_new(FALSE, FALSE, sizeof(guint32)); - /* Initialize rfkill structures and states */ - memset(priv->radio_states, 0, sizeof(priv->radio_states)); - - priv->radio_states[RFKILL_TYPE_WLAN].user_enabled = TRUE; - priv->radio_states[RFKILL_TYPE_WLAN].key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED; - priv->radio_states[RFKILL_TYPE_WLAN].prop = NM_MANAGER_WIRELESS_ENABLED; - priv->radio_states[RFKILL_TYPE_WLAN].hw_prop = NM_MANAGER_WIRELESS_HARDWARE_ENABLED; - priv->radio_states[RFKILL_TYPE_WLAN].desc = "Wi-Fi"; - priv->radio_states[RFKILL_TYPE_WLAN].rtype = RFKILL_TYPE_WLAN; - - priv->radio_states[RFKILL_TYPE_WWAN].user_enabled = TRUE; - priv->radio_states[RFKILL_TYPE_WWAN].key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED; - priv->radio_states[RFKILL_TYPE_WWAN].prop = NM_MANAGER_WWAN_ENABLED; - priv->radio_states[RFKILL_TYPE_WWAN].hw_prop = NM_MANAGER_WWAN_HARDWARE_ENABLED; - priv->radio_states[RFKILL_TYPE_WWAN].desc = "WWAN"; - priv->radio_states[RFKILL_TYPE_WWAN].rtype = RFKILL_TYPE_WWAN; - - for (i = 0; i < RFKILL_TYPE_MAX; i++) - priv->radio_states[i].hw_enabled = TRUE; + priv->radio_states[RFKILL_TYPE_WLAN] = (RadioState){ + .user_enabled = TRUE, + .key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED, + .prop = NM_MANAGER_WIRELESS_ENABLED, + .hw_prop = NM_MANAGER_WIRELESS_HARDWARE_ENABLED, + .desc = "Wi-Fi", + .rtype = RFKILL_TYPE_WLAN, + .hw_enabled = TRUE, + }; + priv->radio_states[RFKILL_TYPE_WWAN] = (RadioState){ + .user_enabled = TRUE, + .key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED, + .prop = NM_MANAGER_WWAN_ENABLED, + .hw_prop = NM_MANAGER_WWAN_HARDWARE_ENABLED, + .desc = "WWAN", + .rtype = RFKILL_TYPE_WWAN, + .hw_enabled = TRUE, + }; priv->sleeping = FALSE; priv->state = NM_STATE_DISCONNECTED; From 454992ed85842f5c6ff2e15813a3319b89588976 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 20:21:34 +0100 Subject: [PATCH 03/13] core/rfkill: add "nm" prefix to RfKillState and RfKillType enums Names in header files should have an "nm" prefix. We do that pretty consistently. Fix the offenders RfKillState and RfKillType. Also, rename the RfKillState enums to follow the type name. For example, NM_RFKILL_STATE_SOFT_BLOCKED instead of RFKILL_SOFT_BLOCKED. Also, when we camel-case a typedef (NMRfKillState) we would want that the lower-case names use underscore between the words. So it should be `nm_rf_kill_state_to_string()`. But that looks awkward. So the right solution here is to also rename "RfKill" to "Rfkill". That make is consistent with the spelling of the existing `NMRfkillManager` type and the `nm-rfkill-manager.h` file. --- src/core/devices/nm-device.c | 8 +-- src/core/devices/nm-device.h | 4 +- src/core/devices/wifi/nm-device-iwd-p2p.c | 2 +- src/core/devices/wifi/nm-device-iwd.c | 2 +- src/core/devices/wifi/nm-device-wifi-p2p.c | 2 +- src/core/devices/wifi/nm-device-wifi.c | 2 +- src/core/devices/wwan/nm-device-modem.c | 2 +- src/core/nm-manager.c | 80 +++++++++++----------- src/core/nm-rfkill-manager.c | 78 ++++++++++----------- src/core/nm-rfkill-manager.h | 22 +++--- 10 files changed, 101 insertions(+), 101 deletions(-) diff --git a/src/core/devices/nm-device.c b/src/core/devices/nm-device.c index b23788a3ea..a22bd82483 100644 --- a/src/core/devices/nm-device.c +++ b/src/core/devices/nm-device.c @@ -5147,16 +5147,16 @@ nm_device_get_applied_setting(NMDevice *self, GType setting_type) return connection ? nm_connection_get_setting(connection, setting_type) : NULL; } -RfKillType +NMRfkillType nm_device_get_rfkill_type(NMDevice *self) { - RfKillType t; + NMRfkillType t; g_return_val_if_fail(NM_IS_DEVICE(self), FALSE); t = NM_DEVICE_GET_CLASS(self)->rfkill_type; - nm_assert(NM_IN_SET(t, RFKILL_TYPE_UNKNOWN, RFKILL_TYPE_WLAN, RFKILL_TYPE_WWAN)); + nm_assert(NM_IN_SET(t, NM_RFKILL_TYPE_UNKNOWN, NM_RFKILL_TYPE_WLAN, NM_RFKILL_TYPE_WWAN)); return t; } @@ -17576,7 +17576,7 @@ nm_device_class_init(NMDeviceClass *klass) klass->reapply_connection = reapply_connection; klass->set_platform_mtu = set_platform_mtu; - klass->rfkill_type = RFKILL_TYPE_UNKNOWN; + klass->rfkill_type = NM_RFKILL_TYPE_UNKNOWN; obj_properties[PROP_UDI] = g_param_spec_string(NM_DEVICE_UDI, diff --git a/src/core/devices/nm-device.h b/src/core/devices/nm-device.h index 7780860d6f..d9cfc7e621 100644 --- a/src/core/devices/nm-device.h +++ b/src/core/devices/nm-device.h @@ -207,7 +207,7 @@ typedef struct _NMDeviceClass { bool can_reapply_change_ovs_external_ids : 1; - RfKillType rfkill_type : 4; + NMRfkillType rfkill_type : 4; void (*state_changed)(NMDevice *device, NMDeviceState new_state, @@ -535,7 +535,7 @@ gboolean nm_device_get_enabled(NMDevice *device); void nm_device_set_enabled(NMDevice *device, gboolean enabled); -RfKillType nm_device_get_rfkill_type(NMDevice *device); +NMRfkillType nm_device_get_rfkill_type(NMDevice *device); /* IPv6 prefix delegation */ diff --git a/src/core/devices/wifi/nm-device-iwd-p2p.c b/src/core/devices/wifi/nm-device-iwd-p2p.c index b0f7e39280..40e38321bf 100644 --- a/src/core/devices/wifi/nm-device-iwd-p2p.c +++ b/src/core/devices/wifi/nm-device-iwd-p2p.c @@ -1250,7 +1250,7 @@ nm_device_iwd_p2p_class_init(NMDeviceIwdP2PClass *klass) device_class->state_changed = device_state_changed; - device_class->rfkill_type = RFKILL_TYPE_WLAN; + device_class->rfkill_type = NM_RFKILL_TYPE_WLAN; obj_properties[PROP_PEERS] = g_param_spec_boxed(NM_DEVICE_IWD_P2P_PEERS, "", diff --git a/src/core/devices/wifi/nm-device-iwd.c b/src/core/devices/wifi/nm-device-iwd.c index a92f92642b..ab37cbec91 100644 --- a/src/core/devices/wifi/nm-device-iwd.c +++ b/src/core/devices/wifi/nm-device-iwd.c @@ -3488,7 +3488,7 @@ nm_device_iwd_class_init(NMDeviceIwdClass *klass) device_class->state_changed = device_state_changed; - device_class->rfkill_type = RFKILL_TYPE_WLAN; + device_class->rfkill_type = NM_RFKILL_TYPE_WLAN; obj_properties[PROP_MODE] = g_param_spec_uint(NM_DEVICE_IWD_MODE, "", diff --git a/src/core/devices/wifi/nm-device-wifi-p2p.c b/src/core/devices/wifi/nm-device-wifi-p2p.c index 326729fadf..4576af95cb 100644 --- a/src/core/devices/wifi/nm-device-wifi-p2p.c +++ b/src/core/devices/wifi/nm-device-wifi-p2p.c @@ -1291,7 +1291,7 @@ nm_device_wifi_p2p_class_init(NMDeviceWifiP2PClass *klass) device_class->state_changed = device_state_changed; - device_class->rfkill_type = RFKILL_TYPE_WLAN; + device_class->rfkill_type = NM_RFKILL_TYPE_WLAN; obj_properties[PROP_PEERS] = g_param_spec_boxed(NM_DEVICE_WIFI_P2P_PEERS, "", diff --git a/src/core/devices/wifi/nm-device-wifi.c b/src/core/devices/wifi/nm-device-wifi.c index 5d1099ada7..cfb73848fb 100644 --- a/src/core/devices/wifi/nm-device-wifi.c +++ b/src/core/devices/wifi/nm-device-wifi.c @@ -3754,7 +3754,7 @@ nm_device_wifi_class_init(NMDeviceWifiClass *klass) device_class->state_changed = device_state_changed; - device_class->rfkill_type = RFKILL_TYPE_WLAN; + device_class->rfkill_type = NM_RFKILL_TYPE_WLAN; obj_properties[PROP_MODE] = g_param_spec_uint(NM_DEVICE_WIFI_MODE, "", diff --git a/src/core/devices/wwan/nm-device-modem.c b/src/core/devices/wwan/nm-device-modem.c index 6ac4e6e359..31c03f7350 100644 --- a/src/core/devices/wwan/nm-device-modem.c +++ b/src/core/devices/wwan/nm-device-modem.c @@ -838,7 +838,7 @@ nm_device_modem_class_init(NMDeviceModemClass *klass) device_class->state_changed = device_state_changed; - device_class->rfkill_type = RFKILL_TYPE_WWAN; + device_class->rfkill_type = NM_RFKILL_TYPE_WWAN; obj_properties[PROP_MODEM] = g_param_spec_object(NM_DEVICE_MODEM_MODEM, diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index 42fb0e3633..02a1761e40 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -57,7 +57,7 @@ typedef struct { const char *desc; const char *prop; const char *hw_prop; - RfKillType rtype; + NMRfkillType rtype; NMConfigRunStatePropertyType key; bool user_enabled : 1; bool sw_enabled : 1; @@ -169,7 +169,7 @@ typedef struct { NMSettings *settings; - RadioState radio_states[RFKILL_TYPE_MAX]; + RadioState radio_states[NM_RFKILL_TYPE_MAX]; NMVpnManager *vpn_manager; @@ -2292,7 +2292,7 @@ radio_enabled_for_rstate(const RadioState *rstate, gboolean check_changeable) } static gboolean -radio_enabled_for_type(NMManager *self, RfKillType rtype, gboolean check_changeable) +radio_enabled_for_type(NMManager *self, NMRfkillType rtype, gboolean check_changeable) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); @@ -2333,15 +2333,15 @@ static void update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, RadioState *rstate) { switch (nm_rfkill_manager_get_rfkill_state(rfkill_mgr, rstate->rtype)) { - case RFKILL_UNBLOCKED: + case NM_RFKILL_STATE_UNBLOCKED: rstate->sw_enabled = TRUE; rstate->hw_enabled = TRUE; return; - case RFKILL_SOFT_BLOCKED: + case NM_RFKILL_STATE_SOFT_BLOCKED: rstate->sw_enabled = FALSE; rstate->hw_enabled = TRUE; return; - case RFKILL_HARD_BLOCKED: + case NM_RFKILL_STATE_HARD_BLOCKED: rstate->sw_enabled = FALSE; rstate->hw_enabled = FALSE; return; @@ -2350,7 +2350,7 @@ update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, RadioState *rstate) } static void -manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, RfKillType rtype) +manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, NMRfkillType rtype) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); gboolean old_enabled; @@ -2401,16 +2401,16 @@ manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, RfKillType r } static void -nm_manager_rfkill_update(NMManager *self, RfKillType rtype) +nm_manager_rfkill_update(NMManager *self, NMRfkillType rtype) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); guint i; - if (rtype != RFKILL_TYPE_UNKNOWN) + if (rtype != NM_RFKILL_TYPE_UNKNOWN) manager_rfkill_update_one_type(self, &priv->radio_states[rtype], rtype); else { /* Otherwise, sync all radio types */ - for (i = 0; i < RFKILL_TYPE_MAX; i++) + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) manager_rfkill_update_one_type(self, &priv->radio_states[i], i); } } @@ -3212,7 +3212,7 @@ add_device(NMManager *self, NMDevice *device, GError **error) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); const char *iface, *type_desc; - RfKillType rtype; + NMRfkillType rtype; GSList *iter, *remove = NULL; int ifindex; const char *dbus_path; @@ -3299,7 +3299,7 @@ add_device(NMManager *self, NMDevice *device, GError **error) * global state. */ rtype = nm_device_get_rfkill_type(device); - if (rtype != RFKILL_TYPE_UNKNOWN) { + if (rtype != NM_RFKILL_TYPE_UNKNOWN) { nm_manager_rfkill_update(self, rtype); nm_device_set_enabled(device, radio_enabled_for_type(self, rtype, TRUE)); } @@ -3677,8 +3677,8 @@ platform_query_devices(NMManager *self) static void rfkill_manager_rfkill_changed_cb(NMRfkillManager *rfkill_mgr, - RfKillType rtype, - RfKillState udev_state, + NMRfkillType rtype, + NMRfkillState udev_state, gpointer user_data) { nm_manager_rfkill_update(NM_MANAGER(user_data), rtype); @@ -6318,7 +6318,7 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) /* Ensure rfkill state is up-to-date since we don't respond to state * changes during sleep. */ - nm_manager_rfkill_update(self, RFKILL_TYPE_UNKNOWN); + nm_manager_rfkill_update(self, NM_RFKILL_TYPE_UNKNOWN); /* Re-manage managed devices */ c_list_for_each_entry (device, &priv->devices_lst_head, devices_lst) { @@ -6335,7 +6335,7 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) /* enable/disable wireless devices since that we don't respond * to killswitch changes during sleep. */ - for (i = 0; i < RFKILL_TYPE_MAX; i++) { + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { const RadioState *rstate = &priv->radio_states[i]; gboolean enabled = radio_enabled_for_rstate(rstate, TRUE); @@ -6934,7 +6934,7 @@ nm_manager_start(NMManager *self, GError **error) nm_device_factory_manager_for_each_factory(start_factory, NULL); /* Set initial radio enabled/disabled state */ - for (i = 0; i < RFKILL_TYPE_MAX; i++) { + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { RadioState *rstate = &priv->radio_states[i]; gboolean enabled; @@ -7605,14 +7605,14 @@ struct rfkill_event { } _nm_packed; static void -rfkill_change(NMManager *self, const char *desc, RfKillType rtype, gboolean enabled) +rfkill_change(NMManager *self, const char *desc, NMRfkillType rtype, gboolean enabled) { int fd; struct rfkill_event event; ssize_t len; int errsv; - g_return_if_fail(rtype == RFKILL_TYPE_WLAN || rtype == RFKILL_TYPE_WWAN); + g_return_if_fail(rtype == NM_RFKILL_TYPE_WLAN || rtype == NM_RFKILL_TYPE_WWAN); fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC); if (fd < 0) { @@ -7633,10 +7633,10 @@ rfkill_change(NMManager *self, const char *desc, RfKillType rtype, gboolean enab memset(&event, 0, sizeof(event)); event.op = KERN_RFKILL_OP_CHANGE_ALL; switch (rtype) { - case RFKILL_TYPE_WLAN: + case NM_RFKILL_TYPE_WLAN: event.type = KERN_RFKILL_TYPE_WLAN; break; - case RFKILL_TYPE_WWAN: + case NM_RFKILL_TYPE_WWAN: event.type = KERN_RFKILL_TYPE_WWAN; break; default: @@ -7699,7 +7699,7 @@ manager_radio_user_toggled(NMManager *self, RadioState *rstate, gboolean enabled new_enabled = radio_enabled_for_rstate(rstate, FALSE); if (new_enabled != old_enabled) { /* Try to change the kernel rfkill state */ - if (rstate->rtype == RFKILL_TYPE_WLAN || rstate->rtype == RFKILL_TYPE_WWAN) + if (rstate->rtype == NM_RFKILL_TYPE_WLAN || rstate->rtype == NM_RFKILL_TYPE_WWAN) rfkill_change(self, rstate->desc, rstate->rtype, new_enabled); manager_update_radio_enabled(self, rstate, new_enabled); @@ -7881,8 +7881,8 @@ constructed(GObject *object) priv->net_enabled = state->net_enabled; - priv->radio_states[RFKILL_TYPE_WLAN].user_enabled = state->wifi_enabled; - priv->radio_states[RFKILL_TYPE_WWAN].user_enabled = state->wwan_enabled; + priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled = state->wifi_enabled; + priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled = state->wwan_enabled; priv->rfkill_mgr = nm_rfkill_manager_new(); g_signal_connect(priv->rfkill_mgr, @@ -7896,13 +7896,13 @@ constructed(GObject *object) * rfkill. */ rfkill_change(self, - priv->radio_states[RFKILL_TYPE_WLAN].desc, - RFKILL_TYPE_WLAN, - priv->radio_states[RFKILL_TYPE_WLAN].user_enabled); + priv->radio_states[NM_RFKILL_TYPE_WLAN].desc, + NM_RFKILL_TYPE_WLAN, + priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled); rfkill_change(self, - priv->radio_states[RFKILL_TYPE_WWAN].desc, - RFKILL_TYPE_WWAN, - priv->radio_states[RFKILL_TYPE_WWAN].user_enabled); + priv->radio_states[NM_RFKILL_TYPE_WWAN].desc, + NM_RFKILL_TYPE_WWAN, + priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled); } static void @@ -7922,22 +7922,22 @@ nm_manager_init(NMManager *self) priv->capabilities = g_array_new(FALSE, FALSE, sizeof(guint32)); - priv->radio_states[RFKILL_TYPE_WLAN] = (RadioState){ + priv->radio_states[NM_RFKILL_TYPE_WLAN] = (RadioState){ .user_enabled = TRUE, .key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED, .prop = NM_MANAGER_WIRELESS_ENABLED, .hw_prop = NM_MANAGER_WIRELESS_HARDWARE_ENABLED, .desc = "Wi-Fi", - .rtype = RFKILL_TYPE_WLAN, + .rtype = NM_RFKILL_TYPE_WLAN, .hw_enabled = TRUE, }; - priv->radio_states[RFKILL_TYPE_WWAN] = (RadioState){ + priv->radio_states[NM_RFKILL_TYPE_WWAN] = (RadioState){ .user_enabled = TRUE, .key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED, .prop = NM_MANAGER_WWAN_ENABLED, .hw_prop = NM_MANAGER_WWAN_HARDWARE_ENABLED, .desc = "WWAN", - .rtype = RFKILL_TYPE_WWAN, + .rtype = NM_RFKILL_TYPE_WWAN, .hw_enabled = TRUE, }; @@ -8011,16 +8011,16 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) g_value_set_boolean(value, priv->net_enabled); break; case PROP_WIRELESS_ENABLED: - g_value_set_boolean(value, radio_enabled_for_type(self, RFKILL_TYPE_WLAN, TRUE)); + g_value_set_boolean(value, radio_enabled_for_type(self, NM_RFKILL_TYPE_WLAN, TRUE)); break; case PROP_WIRELESS_HARDWARE_ENABLED: - g_value_set_boolean(value, priv->radio_states[RFKILL_TYPE_WLAN].hw_enabled); + g_value_set_boolean(value, priv->radio_states[NM_RFKILL_TYPE_WLAN].hw_enabled); break; case PROP_WWAN_ENABLED: - g_value_set_boolean(value, radio_enabled_for_type(self, RFKILL_TYPE_WWAN, TRUE)); + g_value_set_boolean(value, radio_enabled_for_type(self, NM_RFKILL_TYPE_WWAN, TRUE)); break; case PROP_WWAN_HARDWARE_ENABLED: - g_value_set_boolean(value, priv->radio_states[RFKILL_TYPE_WWAN].hw_enabled); + g_value_set_boolean(value, priv->radio_states[NM_RFKILL_TYPE_WWAN].hw_enabled); break; case PROP_WIMAX_ENABLED: g_value_set_boolean(value, FALSE); @@ -8112,12 +8112,12 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps switch (prop_id) { case PROP_WIRELESS_ENABLED: manager_radio_user_toggled(NM_MANAGER(object), - &priv->radio_states[RFKILL_TYPE_WLAN], + &priv->radio_states[NM_RFKILL_TYPE_WLAN], g_value_get_boolean(value)); break; case PROP_WWAN_ENABLED: manager_radio_user_toggled(NM_MANAGER(object), - &priv->radio_states[RFKILL_TYPE_WWAN], + &priv->radio_states[NM_RFKILL_TYPE_WWAN], g_value_get_boolean(value)); break; case PROP_WIMAX_ENABLED: diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index f3851e5ca6..9bffdd3c3a 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -24,8 +24,8 @@ typedef struct { NMUdevClient *udev_client; /* Authoritative rfkill state (RFKILL_* enum) */ - RfKillState rfkill_states[RFKILL_TYPE_MAX]; - GSList *killswitches; + NMRfkillState rfkill_states[NM_RFKILL_TYPE_MAX]; + GSList *killswitches; } NMRfkillManagerPrivate; struct _NMRfkillManager { @@ -45,26 +45,26 @@ G_DEFINE_TYPE(NMRfkillManager, nm_rfkill_manager, G_TYPE_OBJECT) /*****************************************************************************/ typedef struct { - char *name; - guint64 seqnum; - char *path; - char *driver; - RfKillType rtype; - int state; - gboolean platform; + char *name; + guint64 seqnum; + char *path; + char *driver; + NMRfkillType rtype; + int state; + gboolean platform; } Killswitch; -RfKillState -nm_rfkill_manager_get_rfkill_state(NMRfkillManager *self, RfKillType rtype) +NMRfkillState +nm_rfkill_manager_get_rfkill_state(NMRfkillManager *self, NMRfkillType rtype) { - g_return_val_if_fail(self != NULL, RFKILL_UNBLOCKED); - g_return_val_if_fail(rtype < RFKILL_TYPE_MAX, RFKILL_UNBLOCKED); + g_return_val_if_fail(self != NULL, NM_RFKILL_STATE_UNBLOCKED); + g_return_val_if_fail(rtype < NM_RFKILL_TYPE_MAX, NM_RFKILL_STATE_UNBLOCKED); return NM_RFKILL_MANAGER_GET_PRIVATE(self)->rfkill_states[rtype]; } static const char * -rfkill_type_to_desc(RfKillType rtype) +rfkill_type_to_desc(NMRfkillType rtype) { if (rtype == 0) return "Wi-Fi"; @@ -76,7 +76,7 @@ rfkill_type_to_desc(RfKillType rtype) } static const char * -rfkill_state_to_desc(RfKillState rstate) +rfkill_state_to_desc(NMRfkillState rstate) { if (rstate == 0) return "unblocked"; @@ -88,7 +88,7 @@ rfkill_state_to_desc(RfKillState rstate) } static Killswitch * -killswitch_new(struct udev_device *device, RfKillType rtype) +killswitch_new(struct udev_device *device, NMRfkillType rtype) { Killswitch *ks; struct udev_device *parent = NULL, *grandparent = NULL; @@ -140,21 +140,21 @@ killswitch_destroy(Killswitch *ks) g_free(ks); } -static RfKillState +static NMRfkillState sysfs_state_to_nm_state(int sysfs_state) { switch (sysfs_state) { case 0: - return RFKILL_SOFT_BLOCKED; + return NM_RFKILL_STATE_SOFT_BLOCKED; case 1: - return RFKILL_UNBLOCKED; + return NM_RFKILL_STATE_UNBLOCKED; case 2: - return RFKILL_HARD_BLOCKED; + return NM_RFKILL_STATE_HARD_BLOCKED; default: nm_log_warn(LOGD_RFKILL, "unhandled rfkill state %d", sysfs_state); break; } - return RFKILL_UNBLOCKED; + return NM_RFKILL_STATE_UNBLOCKED; } static void @@ -162,15 +162,15 @@ recheck_killswitches(NMRfkillManager *self) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); GSList *iter; - RfKillState poll_states[RFKILL_TYPE_MAX]; - RfKillState platform_states[RFKILL_TYPE_MAX]; - gboolean platform_checked[RFKILL_TYPE_MAX]; + NMRfkillState poll_states[NM_RFKILL_TYPE_MAX]; + NMRfkillState platform_states[NM_RFKILL_TYPE_MAX]; + gboolean platform_checked[NM_RFKILL_TYPE_MAX]; int i; /* Default state is unblocked */ - for (i = 0; i < RFKILL_TYPE_MAX; i++) { - poll_states[i] = RFKILL_UNBLOCKED; - platform_states[i] = RFKILL_UNBLOCKED; + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { + poll_states[i] = NM_RFKILL_STATE_UNBLOCKED; + platform_states[i] = NM_RFKILL_STATE_UNBLOCKED; platform_checked[i] = FALSE; } @@ -178,7 +178,7 @@ recheck_killswitches(NMRfkillManager *self) for (iter = priv->killswitches; iter; iter = g_slist_next(iter)) { Killswitch *ks = iter->data; struct udev_device *device; - RfKillState dev_state; + NMRfkillState dev_state; int sysfs_state; device = udev_device_new_from_subsystem_sysname(nm_udev_client_get_udev(priv->udev_client), @@ -214,12 +214,12 @@ recheck_killswitches(NMRfkillManager *self) } /* Log and emit change signal for final rfkill states */ - for (i = 0; i < RFKILL_TYPE_MAX; i++) { + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { if (platform_checked[i] == TRUE) { /* blocked platform switch state overrides device state, otherwise * let the device state stand. (bgo #655773) */ - if (platform_states[i] != RFKILL_UNBLOCKED) + if (platform_states[i] != NM_RFKILL_STATE_UNBLOCKED) poll_states[i] = platform_states[i]; } @@ -252,17 +252,17 @@ killswitch_find_by_name(NMRfkillManager *self, const char *name) return NULL; } -static RfKillType +static NMRfkillType rfkill_type_to_enum(const char *str) { - g_return_val_if_fail(str != NULL, RFKILL_TYPE_UNKNOWN); + g_return_val_if_fail(str != NULL, NM_RFKILL_TYPE_UNKNOWN); if (!strcmp(str, "wlan")) - return RFKILL_TYPE_WLAN; + return NM_RFKILL_TYPE_WLAN; else if (!strcmp(str, "wwan")) - return RFKILL_TYPE_WWAN; + return NM_RFKILL_TYPE_WWAN; - return RFKILL_TYPE_UNKNOWN; + return NM_RFKILL_TYPE_UNKNOWN; } static void @@ -270,12 +270,12 @@ add_one_killswitch(NMRfkillManager *self, struct udev_device *device) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); const char *str_type; - RfKillType rtype; + NMRfkillType rtype; Killswitch *ks; str_type = udev_device_get_property_value(device, "RFKILL_TYPE"); rtype = rfkill_type_to_enum(str_type); - if (rtype == RFKILL_TYPE_UNKNOWN) + if (rtype == NM_RFKILL_TYPE_UNKNOWN) return; ks = killswitch_new(device, rtype); @@ -364,8 +364,8 @@ nm_rfkill_manager_init(NMRfkillManager *self) struct udev_list_entry *iter; guint i; - for (i = 0; i < RFKILL_TYPE_MAX; i++) - priv->rfkill_states[i] = RFKILL_UNBLOCKED; + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) + priv->rfkill_states[i] = NM_RFKILL_STATE_UNBLOCKED; priv->udev_client = nm_udev_client_new(NM_MAKE_STRV("rfkill"), handle_uevent, self); diff --git a/src/core/nm-rfkill-manager.h b/src/core/nm-rfkill-manager.h index bae6a7e4d0..b1de831c0e 100644 --- a/src/core/nm-rfkill-manager.h +++ b/src/core/nm-rfkill-manager.h @@ -8,22 +8,22 @@ #define __NM_RFKILL_MANAGER_H__ typedef enum { - RFKILL_UNBLOCKED = 0, - RFKILL_SOFT_BLOCKED = 1, - RFKILL_HARD_BLOCKED = 2, -} RfKillState; + NM_RFKILL_STATE_UNBLOCKED = 0, + NM_RFKILL_STATE_SOFT_BLOCKED = 1, + NM_RFKILL_STATE_HARD_BLOCKED = 2, +} NMRfkillState; typedef enum { - RFKILL_TYPE_WLAN = 0, - RFKILL_TYPE_WWAN = 1, + NM_RFKILL_TYPE_WLAN = 0, + NM_RFKILL_TYPE_WWAN = 1, /* UNKNOWN and MAX should always be 1 more than - * the last rfkill type since RFKILL_TYPE_MAX is + * the last rfkill type since NM_RFKILL_TYPE_MAX is * used as an array size. */ - RFKILL_TYPE_UNKNOWN, /* KEEP LAST */ - RFKILL_TYPE_MAX = RFKILL_TYPE_UNKNOWN, -} RfKillType; + NM_RFKILL_TYPE_UNKNOWN, /* KEEP LAST */ + NM_RFKILL_TYPE_MAX = NM_RFKILL_TYPE_UNKNOWN, +} NMRfkillType; #define NM_TYPE_RFKILL_MANAGER (nm_rfkill_manager_get_type()) #define NM_RFKILL_MANAGER(obj) \ @@ -43,6 +43,6 @@ GType nm_rfkill_manager_get_type(void); NMRfkillManager *nm_rfkill_manager_new(void); -RfKillState nm_rfkill_manager_get_rfkill_state(NMRfkillManager *manager, RfKillType rtype); +NMRfkillState nm_rfkill_manager_get_rfkill_state(NMRfkillManager *manager, NMRfkillType rtype); #endif /* __NM_RFKILL_MANAGER_H__ */ From 858a0ee47f129b518390f02c061b5f5d1eb2a8e4 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:08:52 +0100 Subject: [PATCH 04/13] core/rfkill: move immutable type description of Rfkill to global field RadioState contained both the mutable user-data and meta-data about the radio state. The latter is immutable. The parts that cannot change, should be separate from those that can change. Move them to a separate array. Of course, we only have on NMManager instance, so having these fields embedded in NMManagerPrivate did not waste memory. This change is done, because immutable fields should be const. In this case, they are now const global data, which is even protected by the linker from accidental mutation. --- src/core/nm-manager.c | 193 ++++++++++++++++++++---------------------- 1 file changed, 94 insertions(+), 99 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index 02a1761e40..a5bf8d2f52 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -55,13 +55,15 @@ typedef struct { const char *desc; - const char *prop; - const char *hw_prop; - NMRfkillType rtype; + guint prop_id; + guint hw_prop_id; NMConfigRunStatePropertyType key; - bool user_enabled : 1; - bool sw_enabled : 1; - bool hw_enabled : 1; +} RfkillTypeDesc; + +typedef struct { + bool user_enabled : 1; + bool sw_enabled : 1; + bool hw_enabled : 1; } RadioState; typedef enum { @@ -2277,9 +2279,26 @@ _static_hostname_changed_cb(NMHostnameManager *hostname_manager, GParamSpec *psp } /*****************************************************************************/ -/* General NMManager stuff */ +/* General NMManager stuff */ /*****************************************************************************/ +static const RfkillTypeDesc _rfkill_type_desc[NM_RFKILL_TYPE_MAX] = { + [NM_RFKILL_TYPE_WLAN] = + { + .desc = "Wi-Fi", + .prop_id = PROP_WIRELESS_ENABLED, + .hw_prop_id = PROP_WIRELESS_HARDWARE_ENABLED, + .key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED, + }, + [NM_RFKILL_TYPE_WWAN] = + { + .desc = "WWAN", + .prop_id = PROP_WWAN_ENABLED, + .hw_prop_id = PROP_WWAN_HARDWARE_ENABLED, + .key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED, + }, +}; + static gboolean radio_enabled_for_rstate(const RadioState *rstate, gboolean check_changeable) { @@ -2302,16 +2321,12 @@ radio_enabled_for_type(NMManager *self, NMRfkillType rtype, gboolean check_chang } static void -manager_update_radio_enabled(NMManager *self, const RadioState *rstate, gboolean enabled) +manager_update_radio_enabled(NMManager *self, NMRfkillType rtype, gboolean enabled) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); NMDevice *device; - /* Do nothing for radio types not yet implemented */ - if (!rstate->prop) - return; - - g_object_notify(G_OBJECT(self), rstate->prop); + _notify(self, _rfkill_type_desc[rtype].prop_id); /* Don't touch devices if asleep/networking disabled */ if (manager_sleeping(self)) @@ -2319,7 +2334,7 @@ manager_update_radio_enabled(NMManager *self, const RadioState *rstate, gboolean /* enable/disable wireless devices as required */ c_list_for_each_entry (device, &priv->devices_lst_head, devices_lst) { - if (nm_device_get_rfkill_type(device) == rstate->rtype) { + if (nm_device_get_rfkill_type(device) == rtype) { _LOG2D(LOGD_RFKILL, device, "rfkill: setting radio %s", @@ -2330,9 +2345,9 @@ manager_update_radio_enabled(NMManager *self, const RadioState *rstate, gboolean } static void -update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, RadioState *rstate) +update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, NMRfkillType rtype, RadioState *rstate) { - switch (nm_rfkill_manager_get_rfkill_state(rfkill_mgr, rstate->rtype)) { + switch (nm_rfkill_manager_get_rfkill_state(rfkill_mgr, rtype)) { case NM_RFKILL_STATE_UNBLOCKED: rstate->sw_enabled = TRUE; rstate->hw_enabled = TRUE; @@ -2350,45 +2365,44 @@ update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, RadioState *rstate) } static void -manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, NMRfkillType rtype) +manager_rfkill_update_one_type(NMManager *self, NMRfkillType rtype) { - NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + RadioState *rstate = &priv->radio_states[rtype]; gboolean old_enabled; gboolean new_enabled; gboolean old_rfkilled; gboolean new_rfkilled; gboolean old_hwe; + nm_assert(_NM_INT_NOT_NEGATIVE(rtype) && rtype < G_N_ELEMENTS(priv->radio_states)); + old_enabled = radio_enabled_for_rstate(rstate, TRUE); old_rfkilled = rstate->hw_enabled && rstate->sw_enabled; old_hwe = rstate->hw_enabled; /* recheck kernel rfkill state */ - update_rstate_from_rfkill(priv->rfkill_mgr, rstate); + update_rstate_from_rfkill(priv->rfkill_mgr, rtype, rstate); /* Print out all states affecting device enablement */ - if (rstate->desc) { - _LOGD(LOGD_RFKILL, - "rfkill: %s hw-enabled %d sw-enabled %d", - rstate->desc, - rstate->hw_enabled, - rstate->sw_enabled); - } + _LOGD(LOGD_RFKILL, + "rfkill: %s hw-enabled %d sw-enabled %d", + _rfkill_type_desc[rtype].desc, + rstate->hw_enabled, + rstate->sw_enabled); /* Log new killswitch state */ new_rfkilled = rstate->hw_enabled && rstate->sw_enabled; if (old_rfkilled != new_rfkilled) { _LOGI(LOGD_RFKILL, "rfkill: %s now %s by radio killswitch", - rstate->desc, + _rfkill_type_desc[rtype].desc, new_rfkilled ? "enabled" : "disabled"); } /* Send out property changed signal for HW enabled */ - if (rstate->hw_enabled != old_hwe) { - if (rstate->hw_prop) - g_object_notify(G_OBJECT(self), rstate->hw_prop); - } + if (rstate->hw_enabled != old_hwe) + _notify(self, _rfkill_type_desc[rtype].hw_prop_id); /* And finally update the actual device radio state itself; respect the * daemon state here because this is never called from user-triggered @@ -2397,21 +2411,20 @@ manager_rfkill_update_one_type(NMManager *self, RadioState *rstate, NMRfkillType */ new_enabled = radio_enabled_for_rstate(rstate, TRUE); if (new_enabled != old_enabled) - manager_update_radio_enabled(self, rstate, new_enabled); + manager_update_radio_enabled(self, rtype, new_enabled); } static void nm_manager_rfkill_update(NMManager *self, NMRfkillType rtype) { - NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); - guint i; + guint i; if (rtype != NM_RFKILL_TYPE_UNKNOWN) - manager_rfkill_update_one_type(self, &priv->radio_states[rtype], rtype); + manager_rfkill_update_one_type(self, rtype); else { /* Otherwise, sync all radio types */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) - manager_rfkill_update_one_type(self, &priv->radio_states[i], i); + manager_rfkill_update_one_type(self, i); } } @@ -6336,19 +6349,18 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) * to killswitch changes during sleep. */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { - const RadioState *rstate = &priv->radio_states[i]; + NMRfkillType rtype = i; + const RadioState *rstate = &priv->radio_states[rtype]; gboolean enabled = radio_enabled_for_rstate(rstate, TRUE); - if (rstate->desc) { - _LOGD(LOGD_RFKILL, - "rfkill: %s %s devices (hw_enabled %d, sw_enabled %d, user_enabled %d)", - enabled ? "enabling" : "disabling", - rstate->desc, - rstate->hw_enabled, - rstate->sw_enabled, - rstate->user_enabled); - } - if (nm_device_get_rfkill_type(device) == rstate->rtype) + _LOGD(LOGD_RFKILL, + "rfkill: %s %s devices (hw_enabled %d, sw_enabled %d, user_enabled %d)", + enabled ? "enabling" : "disabling", + _rfkill_type_desc[rtype].desc, + rstate->hw_enabled, + rstate->sw_enabled, + rstate->user_enabled); + if (nm_device_get_rfkill_type(device) == rtype) nm_device_set_enabled(device, enabled); } @@ -6935,24 +6947,20 @@ nm_manager_start(NMManager *self, GError **error) /* Set initial radio enabled/disabled state */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { - RadioState *rstate = &priv->radio_states[i]; - gboolean enabled; - - if (!rstate->desc) - continue; + NMRfkillType rtype = i; + RadioState *rstate = &priv->radio_states[rtype]; + gboolean enabled; /* recheck kernel rfkill state */ - update_rstate_from_rfkill(priv->rfkill_mgr, rstate); + update_rstate_from_rfkill(priv->rfkill_mgr, rtype, rstate); - if (rstate->desc) { - _LOGI(LOGD_RFKILL, - "rfkill: %s %s by radio killswitch; %s by state file", - rstate->desc, - (rstate->hw_enabled && rstate->sw_enabled) ? "enabled" : "disabled", - rstate->user_enabled ? "enabled" : "disabled"); - } + _LOGI(LOGD_RFKILL, + "rfkill: %s %s by radio killswitch; %s by state file", + _rfkill_type_desc[rtype].desc, + (rstate->hw_enabled && rstate->sw_enabled) ? "enabled" : "disabled", + rstate->user_enabled ? "enabled" : "disabled"); enabled = radio_enabled_for_rstate(rstate, TRUE); - manager_update_radio_enabled(self, rstate, enabled); + manager_update_radio_enabled(self, rtype, enabled); } _LOGI(LOGD_CORE, "Networking is %s by state file", priv->net_enabled ? "enabled" : "disabled"); @@ -7605,7 +7613,7 @@ struct rfkill_event { } _nm_packed; static void -rfkill_change(NMManager *self, const char *desc, NMRfkillType rtype, gboolean enabled) +rfkill_change(NMManager *self, NMRfkillType rtype, gboolean enabled) { int fd; struct rfkill_event event; @@ -7617,7 +7625,9 @@ rfkill_change(NMManager *self, const char *desc, NMRfkillType rtype, gboolean en fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC); if (fd < 0) { if (errno == EACCES) - _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to open killswitch device", desc); + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to open killswitch device", + _rfkill_type_desc[rtype].desc); return; } @@ -7625,7 +7635,7 @@ rfkill_change(NMManager *self, const char *desc, NMRfkillType rtype, gboolean en _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to set killswitch device for " "non-blocking operation", - desc); + _rfkill_type_desc[rtype].desc); nm_close(fd); return; } @@ -7649,41 +7659,42 @@ rfkill_change(NMManager *self, const char *desc, NMRfkillType rtype, gboolean en errsv = errno; _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to change Wi-Fi killswitch state: (%d) %s", - desc, + _rfkill_type_desc[rtype].desc, errsv, nm_strerror_native(errsv)); } else if (len == sizeof(event)) { _LOGI(LOGD_RFKILL, "rfkill: %s hardware radio set %s", - desc, + _rfkill_type_desc[rtype].desc, enabled ? "enabled" : "disabled"); } else { /* Failed to write full structure */ - _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to change Wi-Fi killswitch state", desc); + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to change Wi-Fi killswitch state", + _rfkill_type_desc[rtype].desc); } nm_close(fd); } static void -manager_radio_user_toggled(NMManager *self, RadioState *rstate, gboolean enabled) +manager_radio_user_toggled(NMManager *self, NMRfkillType rtype, gboolean enabled) { - NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + RadioState *rstate = &priv->radio_states[rtype]; gboolean old_enabled, new_enabled; /* Don't touch devices if asleep/networking disabled */ if (manager_sleeping(self)) return; - if (rstate->desc) { - _LOGD(LOGD_RFKILL, - "rfkill: (%s): setting radio %s by user", - rstate->desc, - enabled ? "enabled" : "disabled"); - } + _LOGD(LOGD_RFKILL, + "rfkill: (%s): setting radio %s by user", + _rfkill_type_desc[rtype].desc, + enabled ? "enabled" : "disabled"); /* Update enabled key in state file */ - nm_config_state_set(priv->config, TRUE, FALSE, rstate->key, enabled); + nm_config_state_set(priv->config, TRUE, FALSE, _rfkill_type_desc[rtype].key, enabled); /* When the user toggles the radio, their request should override any * daemon (like ModemManager) enabled state that can be changed. For WWAN @@ -7699,10 +7710,10 @@ manager_radio_user_toggled(NMManager *self, RadioState *rstate, gboolean enabled new_enabled = radio_enabled_for_rstate(rstate, FALSE); if (new_enabled != old_enabled) { /* Try to change the kernel rfkill state */ - if (rstate->rtype == NM_RFKILL_TYPE_WLAN || rstate->rtype == NM_RFKILL_TYPE_WWAN) - rfkill_change(self, rstate->desc, rstate->rtype, new_enabled); + nm_assert(NM_IN_SET(rtype, NM_RFKILL_TYPE_WLAN, NM_RFKILL_TYPE_WWAN)); + rfkill_change(self, rtype, new_enabled); - manager_update_radio_enabled(self, rstate, new_enabled); + manager_update_radio_enabled(self, rtype, new_enabled); } } @@ -7895,14 +7906,8 @@ constructed(GObject *object) * changes to the WirelessEnabled/WWANEnabled properties which toggle kernel * rfkill. */ - rfkill_change(self, - priv->radio_states[NM_RFKILL_TYPE_WLAN].desc, - NM_RFKILL_TYPE_WLAN, - priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled); - rfkill_change(self, - priv->radio_states[NM_RFKILL_TYPE_WWAN].desc, - NM_RFKILL_TYPE_WWAN, - priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled); + rfkill_change(self, NM_RFKILL_TYPE_WLAN, priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled); + rfkill_change(self, NM_RFKILL_TYPE_WWAN, priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled); } static void @@ -7924,20 +7929,10 @@ nm_manager_init(NMManager *self) priv->radio_states[NM_RFKILL_TYPE_WLAN] = (RadioState){ .user_enabled = TRUE, - .key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED, - .prop = NM_MANAGER_WIRELESS_ENABLED, - .hw_prop = NM_MANAGER_WIRELESS_HARDWARE_ENABLED, - .desc = "Wi-Fi", - .rtype = NM_RFKILL_TYPE_WLAN, .hw_enabled = TRUE, }; priv->radio_states[NM_RFKILL_TYPE_WWAN] = (RadioState){ .user_enabled = TRUE, - .key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED, - .prop = NM_MANAGER_WWAN_ENABLED, - .hw_prop = NM_MANAGER_WWAN_HARDWARE_ENABLED, - .desc = "WWAN", - .rtype = NM_RFKILL_TYPE_WWAN, .hw_enabled = TRUE, }; @@ -8112,12 +8107,12 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps switch (prop_id) { case PROP_WIRELESS_ENABLED: manager_radio_user_toggled(NM_MANAGER(object), - &priv->radio_states[NM_RFKILL_TYPE_WLAN], + NM_RFKILL_TYPE_WLAN, g_value_get_boolean(value)); break; case PROP_WWAN_ENABLED: manager_radio_user_toggled(NM_MANAGER(object), - &priv->radio_states[NM_RFKILL_TYPE_WWAN], + NM_RFKILL_TYPE_WWAN, g_value_get_boolean(value)); break; case PROP_WIMAX_ENABLED: From 467b21afa78c700a706903826c1ecc7047420469 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:19:36 +0100 Subject: [PATCH 05/13] core/rfkill: rename Rfkill related functions in "nm-manager.c" Naming is important. Especially when we have a 8k LOC monster, that manages everything. Rename things related to Rfkill to give them a common prefix. Also, move code around so it's beside each other. --- src/core/nm-manager.c | 365 ++++++++++++++++++++++-------------------- 1 file changed, 188 insertions(+), 177 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index a5bf8d2f52..fe1ad5d7b2 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -64,7 +64,7 @@ typedef struct { bool user_enabled : 1; bool sw_enabled : 1; bool hw_enabled : 1; -} RadioState; +} RfkillRadioState; typedef enum { ASYNC_OP_TYPE_AC_AUTH_ACTIVATE_INTERNAL, @@ -171,7 +171,7 @@ typedef struct { NMSettings *settings; - RadioState radio_states[NM_RFKILL_TYPE_MAX]; + RfkillRadioState radio_states[NM_RFKILL_TYPE_MAX]; NMVpnManager *vpn_manager; @@ -2278,8 +2278,6 @@ _static_hostname_changed_cb(NMHostnameManager *hostname_manager, GParamSpec *psp nm_dispatcher_call_hostname(NULL, NULL, NULL); } -/*****************************************************************************/ -/* General NMManager stuff */ /*****************************************************************************/ static const RfkillTypeDesc _rfkill_type_desc[NM_RFKILL_TYPE_MAX] = { @@ -2300,7 +2298,7 @@ static const RfkillTypeDesc _rfkill_type_desc[NM_RFKILL_TYPE_MAX] = { }; static gboolean -radio_enabled_for_rstate(const RadioState *rstate, gboolean check_changeable) +_rfkill_radio_state_get_enabled(const RfkillRadioState *rstate, gboolean check_changeable) { gboolean enabled; @@ -2310,18 +2308,40 @@ radio_enabled_for_rstate(const RadioState *rstate, gboolean check_changeable) return enabled; } +static void +_rfkill_radio_state_set_from_manager(NMRfkillManager *rfkill_mgr, + NMRfkillType rtype, + RfkillRadioState *rstate) +{ + switch (nm_rfkill_manager_get_rfkill_state(rfkill_mgr, rtype)) { + case NM_RFKILL_STATE_UNBLOCKED: + rstate->sw_enabled = TRUE; + rstate->hw_enabled = TRUE; + return; + case NM_RFKILL_STATE_SOFT_BLOCKED: + rstate->sw_enabled = FALSE; + rstate->hw_enabled = TRUE; + return; + case NM_RFKILL_STATE_HARD_BLOCKED: + rstate->sw_enabled = FALSE; + rstate->hw_enabled = FALSE; + return; + } + nm_assert_not_reached(); +} + static gboolean -radio_enabled_for_type(NMManager *self, NMRfkillType rtype, gboolean check_changeable) +_rfkill_radio_state_get(NMManager *self, NMRfkillType rtype) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); nm_assert(_NM_INT_NOT_NEGATIVE(rtype) && rtype < G_N_ELEMENTS(priv->radio_states)); - return radio_enabled_for_rstate(&priv->radio_states[rtype], check_changeable); + return _rfkill_radio_state_get_enabled(&priv->radio_states[rtype], TRUE); } static void -manager_update_radio_enabled(NMManager *self, NMRfkillType rtype, gboolean enabled) +_rfkill_update_devices(NMManager *self, NMRfkillType rtype, gboolean enabled) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); NMDevice *device; @@ -2345,30 +2365,10 @@ manager_update_radio_enabled(NMManager *self, NMRfkillType rtype, gboolean enabl } static void -update_rstate_from_rfkill(NMRfkillManager *rfkill_mgr, NMRfkillType rtype, RadioState *rstate) -{ - switch (nm_rfkill_manager_get_rfkill_state(rfkill_mgr, rtype)) { - case NM_RFKILL_STATE_UNBLOCKED: - rstate->sw_enabled = TRUE; - rstate->hw_enabled = TRUE; - return; - case NM_RFKILL_STATE_SOFT_BLOCKED: - rstate->sw_enabled = FALSE; - rstate->hw_enabled = TRUE; - return; - case NM_RFKILL_STATE_HARD_BLOCKED: - rstate->sw_enabled = FALSE; - rstate->hw_enabled = FALSE; - return; - } - nm_assert_not_reached(); -} - -static void -manager_rfkill_update_one_type(NMManager *self, NMRfkillType rtype) +_rfkill_update_one_type(NMManager *self, NMRfkillType rtype) { NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); - RadioState *rstate = &priv->radio_states[rtype]; + RfkillRadioState *rstate = &priv->radio_states[rtype]; gboolean old_enabled; gboolean new_enabled; gboolean old_rfkilled; @@ -2377,12 +2377,12 @@ manager_rfkill_update_one_type(NMManager *self, NMRfkillType rtype) nm_assert(_NM_INT_NOT_NEGATIVE(rtype) && rtype < G_N_ELEMENTS(priv->radio_states)); - old_enabled = radio_enabled_for_rstate(rstate, TRUE); + old_enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); old_rfkilled = rstate->hw_enabled && rstate->sw_enabled; old_hwe = rstate->hw_enabled; /* recheck kernel rfkill state */ - update_rstate_from_rfkill(priv->rfkill_mgr, rtype, rstate); + _rfkill_radio_state_set_from_manager(priv->rfkill_mgr, rtype, rstate); /* Print out all states affecting device enablement */ _LOGD(LOGD_RFKILL, @@ -2409,25 +2409,144 @@ manager_rfkill_update_one_type(NMManager *self, NMRfkillType rtype) * radio changes and we only want to ignore the daemon enabled state when * handling user radio change requests. */ - new_enabled = radio_enabled_for_rstate(rstate, TRUE); + new_enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); if (new_enabled != old_enabled) - manager_update_radio_enabled(self, rtype, new_enabled); + _rfkill_update_devices(self, rtype, new_enabled); } static void -nm_manager_rfkill_update(NMManager *self, NMRfkillType rtype) +_rfkill_update(NMManager *self, NMRfkillType rtype) { guint i; if (rtype != NM_RFKILL_TYPE_UNKNOWN) - manager_rfkill_update_one_type(self, rtype); + _rfkill_update_one_type(self, rtype); else { /* Otherwise, sync all radio types */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) - manager_rfkill_update_one_type(self, i); + _rfkill_update_one_type(self, i); } } +/*****************************************************************************/ + +#define KERN_RFKILL_OP_CHANGE_ALL 3 +#define KERN_RFKILL_TYPE_WLAN 1 +#define KERN_RFKILL_TYPE_WWAN 5 + +struct rfkill_event { + uint32_t idx; + uint8_t type; + uint8_t op; + uint8_t soft; + uint8_t hard; +} _nm_packed; + +static void +_rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) +{ + int fd; + struct rfkill_event event; + ssize_t len; + int errsv; + + nm_assert(NM_IN_SET(rtype, NM_RFKILL_TYPE_WLAN, NM_RFKILL_TYPE_WWAN)); + + fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC); + if (fd < 0) { + if (errno == EACCES) + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to open killswitch device", + _rfkill_type_desc[rtype].desc); + return; + } + + if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) { + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to set killswitch device for " + "non-blocking operation", + _rfkill_type_desc[rtype].desc); + nm_close(fd); + return; + } + + memset(&event, 0, sizeof(event)); + event.op = KERN_RFKILL_OP_CHANGE_ALL; + switch (rtype) { + case NM_RFKILL_TYPE_WLAN: + event.type = KERN_RFKILL_TYPE_WLAN; + break; + case NM_RFKILL_TYPE_WWAN: + event.type = KERN_RFKILL_TYPE_WWAN; + break; + default: + nm_assert_not_reached(); + } + event.soft = enabled ? 0 : 1; + + len = write(fd, &event, sizeof(event)); + if (len < 0) { + errsv = errno; + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to change Wi-Fi killswitch state: (%d) %s", + _rfkill_type_desc[rtype].desc, + errsv, + nm_strerror_native(errsv)); + } else if (len == sizeof(event)) { + _LOGI(LOGD_RFKILL, + "rfkill: %s hardware radio set %s", + _rfkill_type_desc[rtype].desc, + enabled ? "enabled" : "disabled"); + } else { + /* Failed to write full structure */ + _LOGW(LOGD_RFKILL, + "rfkill: (%s): failed to change Wi-Fi killswitch state", + _rfkill_type_desc[rtype].desc); + } + + nm_close(fd); +} + +static void +_rfkill_update_from_user(NMManager *self, NMRfkillType rtype, gboolean enabled) +{ + NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); + RfkillRadioState *rstate = &priv->radio_states[rtype]; + gboolean old_enabled, new_enabled; + + /* Don't touch devices if asleep/networking disabled */ + if (manager_sleeping(self)) + return; + + _LOGD(LOGD_RFKILL, + "rfkill: (%s): setting radio %s by user", + _rfkill_type_desc[rtype].desc, + enabled ? "enabled" : "disabled"); + + /* Update enabled key in state file */ + nm_config_state_set(priv->config, TRUE, FALSE, _rfkill_type_desc[rtype].key, enabled); + + /* When the user toggles the radio, their request should override any + * daemon (like ModemManager) enabled state that can be changed. For WWAN + * for example, we want the WwanEnabled property to reflect the daemon state + * too so that users can toggle the modem powered, but we don't want that + * daemon state to affect whether or not the user *can* turn it on, which is + * what the kernel rfkill state does. So we ignore daemon enabled state + * when determining what the new state should be since it shouldn't block + * the user's request. + */ + old_enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); + rstate->user_enabled = enabled; + new_enabled = _rfkill_radio_state_get_enabled(rstate, FALSE); + if (new_enabled != old_enabled) { + /* Try to change the kernel rfkill state */ + _rfkill_update_system(self, rtype, new_enabled); + _rfkill_update_devices(self, rtype, new_enabled); + } +} + +/*****************************************************************************/ + static void device_auth_done_cb(NMAuthChain *chain, GDBusMethodInvocation *context, gpointer user_data) { @@ -3313,8 +3432,8 @@ add_device(NMManager *self, NMDevice *device, GError **error) */ rtype = nm_device_get_rfkill_type(device); if (rtype != NM_RFKILL_TYPE_UNKNOWN) { - nm_manager_rfkill_update(self, rtype); - nm_device_set_enabled(device, radio_enabled_for_type(self, rtype, TRUE)); + _rfkill_update(self, rtype); + nm_device_set_enabled(device, _rfkill_radio_state_get(self, rtype)); } iface = nm_device_get_iface(device); @@ -3694,7 +3813,7 @@ rfkill_manager_rfkill_changed_cb(NMRfkillManager *rfkill_mgr, NMRfkillState udev_state, gpointer user_data) { - nm_manager_rfkill_update(NM_MANAGER(user_data), rtype); + _rfkill_update(NM_MANAGER(user_data), rtype); } const CList * @@ -6331,7 +6450,7 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) /* Ensure rfkill state is up-to-date since we don't respond to state * changes during sleep. */ - nm_manager_rfkill_update(self, NM_RFKILL_TYPE_UNKNOWN); + _rfkill_update(self, NM_RFKILL_TYPE_UNKNOWN); /* Re-manage managed devices */ c_list_for_each_entry (device, &priv->devices_lst_head, devices_lst) { @@ -6349,9 +6468,9 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) * to killswitch changes during sleep. */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { - NMRfkillType rtype = i; - const RadioState *rstate = &priv->radio_states[rtype]; - gboolean enabled = radio_enabled_for_rstate(rstate, TRUE); + const NMRfkillType rtype = i; + const RfkillRadioState *rstate = &priv->radio_states[rtype]; + gboolean enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); _LOGD(LOGD_RFKILL, "rfkill: %s %s devices (hw_enabled %d, sw_enabled %d, user_enabled %d)", @@ -6947,20 +7066,20 @@ nm_manager_start(NMManager *self, GError **error) /* Set initial radio enabled/disabled state */ for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) { - NMRfkillType rtype = i; - RadioState *rstate = &priv->radio_states[rtype]; - gboolean enabled; + const NMRfkillType rtype = i; + RfkillRadioState *rstate = &priv->radio_states[rtype]; + gboolean enabled; /* recheck kernel rfkill state */ - update_rstate_from_rfkill(priv->rfkill_mgr, rtype, rstate); + _rfkill_radio_state_set_from_manager(priv->rfkill_mgr, rtype, rstate); _LOGI(LOGD_RFKILL, "rfkill: %s %s by radio killswitch; %s by state file", _rfkill_type_desc[rtype].desc, (rstate->hw_enabled && rstate->sw_enabled) ? "enabled" : "disabled", rstate->user_enabled ? "enabled" : "disabled"); - enabled = radio_enabled_for_rstate(rstate, TRUE); - manager_update_radio_enabled(self, rtype, enabled); + enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); + _rfkill_update_devices(self, rtype, enabled); } _LOGI(LOGD_CORE, "Networking is %s by state file", priv->net_enabled ? "enabled" : "disabled"); @@ -7601,121 +7720,7 @@ auth_mgr_changed(NMAuthManager *auth_manager, gpointer user_data) "()"); } -#define KERN_RFKILL_OP_CHANGE_ALL 3 -#define KERN_RFKILL_TYPE_WLAN 1 -#define KERN_RFKILL_TYPE_WWAN 5 -struct rfkill_event { - uint32_t idx; - uint8_t type; - uint8_t op; - uint8_t soft; - uint8_t hard; -} _nm_packed; - -static void -rfkill_change(NMManager *self, NMRfkillType rtype, gboolean enabled) -{ - int fd; - struct rfkill_event event; - ssize_t len; - int errsv; - - g_return_if_fail(rtype == NM_RFKILL_TYPE_WLAN || rtype == NM_RFKILL_TYPE_WWAN); - - fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC); - if (fd < 0) { - if (errno == EACCES) - _LOGW(LOGD_RFKILL, - "rfkill: (%s): failed to open killswitch device", - _rfkill_type_desc[rtype].desc); - return; - } - - if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) { - _LOGW(LOGD_RFKILL, - "rfkill: (%s): failed to set killswitch device for " - "non-blocking operation", - _rfkill_type_desc[rtype].desc); - nm_close(fd); - return; - } - - memset(&event, 0, sizeof(event)); - event.op = KERN_RFKILL_OP_CHANGE_ALL; - switch (rtype) { - case NM_RFKILL_TYPE_WLAN: - event.type = KERN_RFKILL_TYPE_WLAN; - break; - case NM_RFKILL_TYPE_WWAN: - event.type = KERN_RFKILL_TYPE_WWAN; - break; - default: - g_assert_not_reached(); - } - event.soft = enabled ? 0 : 1; - - len = write(fd, &event, sizeof(event)); - if (len < 0) { - errsv = errno; - _LOGW(LOGD_RFKILL, - "rfkill: (%s): failed to change Wi-Fi killswitch state: (%d) %s", - _rfkill_type_desc[rtype].desc, - errsv, - nm_strerror_native(errsv)); - } else if (len == sizeof(event)) { - _LOGI(LOGD_RFKILL, - "rfkill: %s hardware radio set %s", - _rfkill_type_desc[rtype].desc, - enabled ? "enabled" : "disabled"); - } else { - /* Failed to write full structure */ - _LOGW(LOGD_RFKILL, - "rfkill: (%s): failed to change Wi-Fi killswitch state", - _rfkill_type_desc[rtype].desc); - } - - nm_close(fd); -} - -static void -manager_radio_user_toggled(NMManager *self, NMRfkillType rtype, gboolean enabled) -{ - NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE(self); - RadioState *rstate = &priv->radio_states[rtype]; - gboolean old_enabled, new_enabled; - - /* Don't touch devices if asleep/networking disabled */ - if (manager_sleeping(self)) - return; - - _LOGD(LOGD_RFKILL, - "rfkill: (%s): setting radio %s by user", - _rfkill_type_desc[rtype].desc, - enabled ? "enabled" : "disabled"); - - /* Update enabled key in state file */ - nm_config_state_set(priv->config, TRUE, FALSE, _rfkill_type_desc[rtype].key, enabled); - - /* When the user toggles the radio, their request should override any - * daemon (like ModemManager) enabled state that can be changed. For WWAN - * for example, we want the WwanEnabled property to reflect the daemon state - * too so that users can toggle the modem powered, but we don't want that - * daemon state to affect whether or not the user *can* turn it on, which is - * what the kernel rfkill state does. So we ignore daemon enabled state - * when determining what the new state should be since it shouldn't block - * the user's request. - */ - old_enabled = radio_enabled_for_rstate(rstate, TRUE); - rstate->user_enabled = enabled; - new_enabled = radio_enabled_for_rstate(rstate, FALSE); - if (new_enabled != old_enabled) { - /* Try to change the kernel rfkill state */ - nm_assert(NM_IN_SET(rtype, NM_RFKILL_TYPE_WLAN, NM_RFKILL_TYPE_WWAN)); - rfkill_change(self, rtype, new_enabled); - - manager_update_radio_enabled(self, rtype, new_enabled); - } -} +/*****************************************************************************/ static gboolean periodic_update_active_connection_timestamps(gpointer user_data) @@ -7906,8 +7911,12 @@ constructed(GObject *object) * changes to the WirelessEnabled/WWANEnabled properties which toggle kernel * rfkill. */ - rfkill_change(self, NM_RFKILL_TYPE_WLAN, priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled); - rfkill_change(self, NM_RFKILL_TYPE_WWAN, priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled); + _rfkill_update_system(self, + NM_RFKILL_TYPE_WLAN, + priv->radio_states[NM_RFKILL_TYPE_WLAN].user_enabled); + _rfkill_update_system(self, + NM_RFKILL_TYPE_WWAN, + priv->radio_states[NM_RFKILL_TYPE_WWAN].user_enabled); } static void @@ -7927,12 +7936,14 @@ nm_manager_init(NMManager *self) priv->capabilities = g_array_new(FALSE, FALSE, sizeof(guint32)); - priv->radio_states[NM_RFKILL_TYPE_WLAN] = (RadioState){ + priv->radio_states[NM_RFKILL_TYPE_WLAN] = (RfkillRadioState){ .user_enabled = TRUE, + .sw_enabled = FALSE, .hw_enabled = TRUE, }; - priv->radio_states[NM_RFKILL_TYPE_WWAN] = (RadioState){ + priv->radio_states[NM_RFKILL_TYPE_WWAN] = (RfkillRadioState){ .user_enabled = TRUE, + .sw_enabled = FALSE, .hw_enabled = TRUE, }; @@ -8006,13 +8017,13 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) g_value_set_boolean(value, priv->net_enabled); break; case PROP_WIRELESS_ENABLED: - g_value_set_boolean(value, radio_enabled_for_type(self, NM_RFKILL_TYPE_WLAN, TRUE)); + g_value_set_boolean(value, _rfkill_radio_state_get(self, NM_RFKILL_TYPE_WLAN)); break; case PROP_WIRELESS_HARDWARE_ENABLED: g_value_set_boolean(value, priv->radio_states[NM_RFKILL_TYPE_WLAN].hw_enabled); break; case PROP_WWAN_ENABLED: - g_value_set_boolean(value, radio_enabled_for_type(self, NM_RFKILL_TYPE_WWAN, TRUE)); + g_value_set_boolean(value, _rfkill_radio_state_get(self, NM_RFKILL_TYPE_WWAN)); break; case PROP_WWAN_HARDWARE_ENABLED: g_value_set_boolean(value, priv->radio_states[NM_RFKILL_TYPE_WWAN].hw_enabled); @@ -8106,14 +8117,14 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps switch (prop_id) { case PROP_WIRELESS_ENABLED: - manager_radio_user_toggled(NM_MANAGER(object), - NM_RFKILL_TYPE_WLAN, - g_value_get_boolean(value)); + _rfkill_update_from_user(NM_MANAGER(object), + NM_RFKILL_TYPE_WLAN, + g_value_get_boolean(value)); break; case PROP_WWAN_ENABLED: - manager_radio_user_toggled(NM_MANAGER(object), - NM_RFKILL_TYPE_WWAN, - g_value_get_boolean(value)); + _rfkill_update_from_user(NM_MANAGER(object), + NM_RFKILL_TYPE_WWAN, + g_value_get_boolean(value)); break; case PROP_WIMAX_ENABLED: /* WIMAX is deprecated. This does nothing. */ From 3b7d861eef74061719434a381c713db082a96b76 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:24:45 +0100 Subject: [PATCH 06/13] core/rfkill: use "nm_auto_close" in _rfkill_update_system() to close FD --- src/core/nm-manager.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index fe1ad5d7b2..60d2badc73 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -2445,7 +2445,7 @@ struct rfkill_event { static void _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) { - int fd; + nm_auto_close int fd = -1; struct rfkill_event event; ssize_t len; int errsv; @@ -2466,7 +2466,6 @@ _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) "rfkill: (%s): failed to set killswitch device for " "non-blocking operation", _rfkill_type_desc[rtype].desc); - nm_close(fd); return; } @@ -2503,8 +2502,6 @@ _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) "rfkill: (%s): failed to change Wi-Fi killswitch state", _rfkill_type_desc[rtype].desc); } - - nm_close(fd); } static void From 6b001b0685a482e7355416e7a5e72124558a5c16 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:32:46 +0100 Subject: [PATCH 07/13] core/rfkill: add nm_rfkill_type_to_string() helper --- src/core/nm-manager.c | 23 ++++++++++------------- src/core/nm-rfkill-manager.c | 22 ++++++++++++---------- src/core/nm-rfkill-manager.h | 2 ++ 3 files changed, 24 insertions(+), 23 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index 60d2badc73..a9cf0c86c5 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -54,7 +54,6 @@ /*****************************************************************************/ typedef struct { - const char *desc; guint prop_id; guint hw_prop_id; NMConfigRunStatePropertyType key; @@ -2283,14 +2282,12 @@ _static_hostname_changed_cb(NMHostnameManager *hostname_manager, GParamSpec *psp static const RfkillTypeDesc _rfkill_type_desc[NM_RFKILL_TYPE_MAX] = { [NM_RFKILL_TYPE_WLAN] = { - .desc = "Wi-Fi", .prop_id = PROP_WIRELESS_ENABLED, .hw_prop_id = PROP_WIRELESS_HARDWARE_ENABLED, .key = NM_CONFIG_STATE_PROPERTY_WIFI_ENABLED, }, [NM_RFKILL_TYPE_WWAN] = { - .desc = "WWAN", .prop_id = PROP_WWAN_ENABLED, .hw_prop_id = PROP_WWAN_HARDWARE_ENABLED, .key = NM_CONFIG_STATE_PROPERTY_WWAN_ENABLED, @@ -2387,7 +2384,7 @@ _rfkill_update_one_type(NMManager *self, NMRfkillType rtype) /* Print out all states affecting device enablement */ _LOGD(LOGD_RFKILL, "rfkill: %s hw-enabled %d sw-enabled %d", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), rstate->hw_enabled, rstate->sw_enabled); @@ -2396,7 +2393,7 @@ _rfkill_update_one_type(NMManager *self, NMRfkillType rtype) if (old_rfkilled != new_rfkilled) { _LOGI(LOGD_RFKILL, "rfkill: %s now %s by radio killswitch", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), new_rfkilled ? "enabled" : "disabled"); } @@ -2457,7 +2454,7 @@ _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) if (errno == EACCES) _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to open killswitch device", - _rfkill_type_desc[rtype].desc); + nm_rfkill_type_to_string(rtype)); return; } @@ -2465,7 +2462,7 @@ _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to set killswitch device for " "non-blocking operation", - _rfkill_type_desc[rtype].desc); + nm_rfkill_type_to_string(rtype)); return; } @@ -2488,19 +2485,19 @@ _rfkill_update_system(NMManager *self, NMRfkillType rtype, gboolean enabled) errsv = errno; _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to change Wi-Fi killswitch state: (%d) %s", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), errsv, nm_strerror_native(errsv)); } else if (len == sizeof(event)) { _LOGI(LOGD_RFKILL, "rfkill: %s hardware radio set %s", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), enabled ? "enabled" : "disabled"); } else { /* Failed to write full structure */ _LOGW(LOGD_RFKILL, "rfkill: (%s): failed to change Wi-Fi killswitch state", - _rfkill_type_desc[rtype].desc); + nm_rfkill_type_to_string(rtype)); } } @@ -2517,7 +2514,7 @@ _rfkill_update_from_user(NMManager *self, NMRfkillType rtype, gboolean enabled) _LOGD(LOGD_RFKILL, "rfkill: (%s): setting radio %s by user", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), enabled ? "enabled" : "disabled"); /* Update enabled key in state file */ @@ -6472,7 +6469,7 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) _LOGD(LOGD_RFKILL, "rfkill: %s %s devices (hw_enabled %d, sw_enabled %d, user_enabled %d)", enabled ? "enabling" : "disabling", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), rstate->hw_enabled, rstate->sw_enabled, rstate->user_enabled); @@ -7072,7 +7069,7 @@ nm_manager_start(NMManager *self, GError **error) _LOGI(LOGD_RFKILL, "rfkill: %s %s by radio killswitch; %s by state file", - _rfkill_type_desc[rtype].desc, + nm_rfkill_type_to_string(rtype), (rstate->hw_enabled && rstate->sw_enabled) ? "enabled" : "disabled", rstate->user_enabled ? "enabled" : "disabled"); enabled = _rfkill_radio_state_get_enabled(rstate, TRUE); diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 9bffdd3c3a..9dcc9fb866 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -63,16 +63,18 @@ nm_rfkill_manager_get_rfkill_state(NMRfkillManager *self, NMRfkillType rtype) return NM_RFKILL_MANAGER_GET_PRIVATE(self)->rfkill_states[rtype]; } -static const char * -rfkill_type_to_desc(NMRfkillType rtype) +const char * +nm_rfkill_type_to_string(NMRfkillType type) { - if (rtype == 0) + switch (type) { + case NM_RFKILL_TYPE_WLAN: return "Wi-Fi"; - else if (rtype == 1) + case NM_RFKILL_TYPE_WWAN: return "WWAN"; - else if (rtype == 2) - return "WiMAX"; - return "unknown"; + case NM_RFKILL_TYPE_UNKNOWN: + break; + } + return nm_assert_unreachable_val("unknown"); } static const char * @@ -196,7 +198,7 @@ recheck_killswitches(NMRfkillManager *self) nm_log_dbg(LOGD_RFKILL, "%s rfkill%s switch %s state now %d/%u", - rfkill_type_to_desc(ks->rtype), + nm_rfkill_type_to_string(ks->rtype), ks->platform ? " platform" : "", ks->name, sysfs_state, @@ -226,7 +228,7 @@ recheck_killswitches(NMRfkillManager *self) if (poll_states[i] != priv->rfkill_states[i]) { nm_log_dbg(LOGD_RFKILL, "%s rfkill state now '%s'", - rfkill_type_to_desc(i), + nm_rfkill_type_to_string(i), rfkill_state_to_desc(poll_states[i])); priv->rfkill_states[i] = poll_states[i]; @@ -284,7 +286,7 @@ add_one_killswitch(NMRfkillManager *self, struct udev_device *device) nm_log_info(LOGD_RFKILL, "%s: found %s radio killswitch (at %s) (%sdriver %s)", ks->name, - rfkill_type_to_desc(rtype), + nm_rfkill_type_to_string(rtype), ks->path, ks->platform ? "platform " : "", ks->driver ?: ""); diff --git a/src/core/nm-rfkill-manager.h b/src/core/nm-rfkill-manager.h index b1de831c0e..db1385ea6a 100644 --- a/src/core/nm-rfkill-manager.h +++ b/src/core/nm-rfkill-manager.h @@ -25,6 +25,8 @@ typedef enum { NM_RFKILL_TYPE_MAX = NM_RFKILL_TYPE_UNKNOWN, } NMRfkillType; +const char *nm_rfkill_type_to_string(NMRfkillType rtype); + #define NM_TYPE_RFKILL_MANAGER (nm_rfkill_manager_get_type()) #define NM_RFKILL_MANAGER(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_RFKILL_MANAGER, NMRfkillManager)) From a19ca08bcf26425ba5e064deb03ac56562518b1b Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:38:26 +0100 Subject: [PATCH 08/13] core/rfkill: rename rfkill_state_to_desc() to nm_rfkill_state_to_string() --- src/core/nm-rfkill-manager.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 9dcc9fb866..287c0e6b11 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -78,15 +78,17 @@ nm_rfkill_type_to_string(NMRfkillType type) } static const char * -rfkill_state_to_desc(NMRfkillState rstate) +nm_rfkill_state_to_string(NMRfkillState state) { - if (rstate == 0) + switch (state) { + case NM_RFKILL_STATE_UNBLOCKED: return "unblocked"; - else if (rstate == 1) + case NM_RFKILL_STATE_SOFT_BLOCKED: return "soft-blocked"; - else if (rstate == 2) + case NM_RFKILL_STATE_HARD_BLOCKED: return "hard-blocked"; - return "unknown"; + } + return nm_assert_unreachable_val("unknown"); } static Killswitch * @@ -229,7 +231,7 @@ recheck_killswitches(NMRfkillManager *self) nm_log_dbg(LOGD_RFKILL, "%s rfkill state now '%s'", nm_rfkill_type_to_string(i), - rfkill_state_to_desc(poll_states[i])); + nm_rfkill_state_to_string(poll_states[i])); priv->rfkill_states[i] = poll_states[i]; g_signal_emit(self, signals[RFKILL_CHANGED], 0, i, priv->rfkill_states[i]); From 96abd25c72b6a089a34f2c2d2bf7c6f2ae7a125a Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:41:27 +0100 Subject: [PATCH 09/13] core/rfkill: don't assert for valid string in rfkill_type_to_enum() "str" comes from udev. This is not a trusted component, and we must not assert for valid input. --- src/core/nm-rfkill-manager.c | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 287c0e6b11..4f89bd40b3 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -259,12 +259,12 @@ killswitch_find_by_name(NMRfkillManager *self, const char *name) static NMRfkillType rfkill_type_to_enum(const char *str) { - g_return_val_if_fail(str != NULL, NM_RFKILL_TYPE_UNKNOWN); - - if (!strcmp(str, "wlan")) - return NM_RFKILL_TYPE_WLAN; - else if (!strcmp(str, "wwan")) - return NM_RFKILL_TYPE_WWAN; + if (str) { + if (nm_streq(str, "wlan")) + return NM_RFKILL_TYPE_WLAN; + if (nm_streq(str, "wwan")) + return NM_RFKILL_TYPE_WWAN; + } return NM_RFKILL_TYPE_UNKNOWN; } @@ -273,12 +273,10 @@ static void add_one_killswitch(NMRfkillManager *self, struct udev_device *device) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); - const char *str_type; NMRfkillType rtype; Killswitch *ks; - str_type = udev_device_get_property_value(device, "RFKILL_TYPE"); - rtype = rfkill_type_to_enum(str_type); + rtype = rfkill_type_to_enum(udev_device_get_property_value(device, "RFKILL_TYPE")); if (rtype == NM_RFKILL_TYPE_UNKNOWN) return; From bc7a3870720db072119c3e011e66c6efbace767f Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:46:27 +0100 Subject: [PATCH 10/13] core/rfkill: cleanup initializing Killswitch struct - use slice allocator - use designated initializers - first determine all parameters in killswitch_new() before setting ks. - drop unnecessary memset(). --- src/core/nm-rfkill-manager.c | 42 ++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 4f89bd40b3..adf67f066c 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -46,12 +46,12 @@ G_DEFINE_TYPE(NMRfkillManager, nm_rfkill_manager, G_TYPE_OBJECT) typedef struct { char *name; - guint64 seqnum; char *path; char *driver; + guint64 seqnum; NMRfkillType rtype; int state; - gboolean platform; + bool platform : 1; } Killswitch; NMRfkillState @@ -95,14 +95,12 @@ static Killswitch * killswitch_new(struct udev_device *device, NMRfkillType rtype) { Killswitch *ks; - struct udev_device *parent = NULL, *grandparent = NULL; - const char *driver, *subsys, *parent_subsys = NULL; - - ks = g_malloc0(sizeof(Killswitch)); - ks->name = g_strdup(udev_device_get_sysname(device)); - ks->seqnum = udev_device_get_seqnum(device); - ks->path = g_strdup(udev_device_get_syspath(device)); - ks->rtype = rtype; + struct udev_device *parent = NULL; + struct udev_device *grandparent = NULL; + const char *driver; + const char *subsys; + const char *parent_subsys = NULL; + gboolean platform; driver = udev_device_get_property_value(device, "DRIVER"); subsys = udev_device_get_subsystem(device); @@ -120,14 +118,23 @@ killswitch_new(struct udev_device *device, NMRfkillType rtype) driver = udev_device_get_property_value(grandparent, "DRIVER"); } } - if (!driver) driver = "(unknown)"; - ks->driver = g_strdup(driver); - if (g_strcmp0(subsys, "platform") == 0 || g_strcmp0(parent_subsys, "platform") == 0 - || g_strcmp0(subsys, "acpi") == 0 || g_strcmp0(parent_subsys, "acpi") == 0) - ks->platform = TRUE; + platform = FALSE; + if (nm_streq0(subsys, "platform") || nm_streq0(parent_subsys, "platform") + || nm_streq0(subsys, "acpi") || nm_streq0(parent_subsys, "acpi")) + platform = TRUE; + + ks = g_slice_new(Killswitch); + *ks = (Killswitch){ + .name = g_strdup(udev_device_get_sysname(device)), + .seqnum = udev_device_get_seqnum(device), + .path = g_strdup(udev_device_get_syspath(device)), + .rtype = rtype, + .driver = g_strdup(driver), + .platform = platform, + }; return ks; } @@ -135,13 +142,10 @@ killswitch_new(struct udev_device *device, NMRfkillType rtype) static void killswitch_destroy(Killswitch *ks) { - g_return_if_fail(ks != NULL); - g_free(ks->name); g_free(ks->path); g_free(ks->driver); - memset(ks, 0, sizeof(Killswitch)); - g_free(ks); + nm_g_slice_free(ks); } static NMRfkillState From e3e17f0b4b8691c5a9aa3c63eb23e9e6531827c0 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 22:55:15 +0100 Subject: [PATCH 11/13] core/rfkill: use CList to track Rfkill killswitches GSList is almost always the wrong choice. We can just embed the next pointers in the structure using the intrusive CList. --- src/core/nm-rfkill-manager.c | 50 +++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index adf67f066c..2106128c6c 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -9,6 +9,7 @@ #include +#include "c-list/src/c-list.h" #include "libnm-udev-aux/nm-udev-utils.h" /*****************************************************************************/ @@ -25,7 +26,8 @@ typedef struct { /* Authoritative rfkill state (RFKILL_* enum) */ NMRfkillState rfkill_states[NM_RFKILL_TYPE_MAX]; - GSList *killswitches; + + CList killswitch_lst_head; } NMRfkillManagerPrivate; struct _NMRfkillManager { @@ -45,6 +47,7 @@ G_DEFINE_TYPE(NMRfkillManager, nm_rfkill_manager, G_TYPE_OBJECT) /*****************************************************************************/ typedef struct { + CList killswitch_lst; char *name; char *path; char *driver; @@ -142,6 +145,7 @@ killswitch_new(struct udev_device *device, NMRfkillType rtype) static void killswitch_destroy(Killswitch *ks) { + c_list_unlink_stale(&ks->killswitch_lst); g_free(ks->name); g_free(ks->path); g_free(ks->driver); @@ -169,7 +173,7 @@ static void recheck_killswitches(NMRfkillManager *self) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); - GSList *iter; + Killswitch *ks; NMRfkillState poll_states[NM_RFKILL_TYPE_MAX]; NMRfkillState platform_states[NM_RFKILL_TYPE_MAX]; gboolean platform_checked[NM_RFKILL_TYPE_MAX]; @@ -183,8 +187,7 @@ recheck_killswitches(NMRfkillManager *self) } /* Poll the states of all killswitches */ - for (iter = priv->killswitches; iter; iter = g_slist_next(iter)) { - Killswitch *ks = iter->data; + c_list_for_each_entry (ks, &priv->killswitch_lst_head, killswitch_lst) { struct udev_device *device; NMRfkillState dev_state; int sysfs_state; @@ -218,6 +221,7 @@ recheck_killswitches(NMRfkillManager *self) if (dev_state > platform_states[ks->rtype]) platform_states[ks->rtype] = dev_state; } + udev_device_unref(device); } @@ -247,15 +251,13 @@ static Killswitch * killswitch_find_by_name(NMRfkillManager *self, const char *name) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); - GSList *iter; + Killswitch *ks; - g_return_val_if_fail(name != NULL, NULL); + nm_assert(name); - for (iter = priv->killswitches; iter; iter = g_slist_next(iter)) { - Killswitch *candidate = iter->data; - - if (!strcmp(name, candidate->name)) - return candidate; + c_list_for_each_entry (ks, &priv->killswitch_lst_head, killswitch_lst) { + if (nm_streq(name, ks->name)) + return ks; } return NULL; } @@ -284,8 +286,8 @@ add_one_killswitch(NMRfkillManager *self, struct udev_device *device) if (rtype == NM_RFKILL_TYPE_UNKNOWN) return; - ks = killswitch_new(device, rtype); - priv->killswitches = g_slist_prepend(priv->killswitches, ks); + ks = killswitch_new(device, rtype); + c_list_link_front(&priv->killswitch_lst_head, &ks->killswitch_lst); nm_log_info(LOGD_RFKILL, "%s: found %s radio killswitch (at %s) (%sdriver %s)", @@ -313,21 +315,20 @@ static void rfkill_remove(NMRfkillManager *self, struct udev_device *device) { NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); - GSList *iter; + Killswitch *ks; const char *name; g_return_if_fail(device != NULL); + name = udev_device_get_sysname(device); + g_return_if_fail(name != NULL); - for (iter = priv->killswitches; iter; iter = g_slist_next(iter)) { - Killswitch *ks = iter->data; - - if (!strcmp(ks->name, name)) { + c_list_for_each_entry (ks, &priv->killswitch_lst_head, killswitch_lst) { + if (nm_streq(ks->name, name)) { nm_log_info(LOGD_RFKILL, "radio killswitch %s disappeared", ks->path); - priv->killswitches = g_slist_remove(priv->killswitches, ks); killswitch_destroy(ks); - break; + return; } } } @@ -370,6 +371,8 @@ nm_rfkill_manager_init(NMRfkillManager *self) struct udev_list_entry *iter; guint i; + c_list_init(&priv->killswitch_lst_head); + for (i = 0; i < NM_RFKILL_TYPE_MAX; i++) priv->rfkill_states[i] = NM_RFKILL_STATE_UNBLOCKED; @@ -405,11 +408,10 @@ dispose(GObject *object) { NMRfkillManager *self = NM_RFKILL_MANAGER(object); NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE(self); + Killswitch *ks; - if (priv->killswitches) { - g_slist_free_full(priv->killswitches, (GDestroyNotify) killswitch_destroy); - priv->killswitches = NULL; - } + while ((ks = c_list_first_entry(&priv->killswitch_lst_head, Killswitch, killswitch_lst))) + killswitch_destroy(ks); priv->udev_client = nm_udev_client_destroy(priv->udev_client); From aa15ec6090706cfe9a3de905131f56a6cbc5f443 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 1 Feb 2022 23:00:58 +0100 Subject: [PATCH 12/13] core/rfkill: use nm_streq() in "nm-rfkill-manager.c" --- src/core/nm-rfkill-manager.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 2106128c6c..87646227f2 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -305,6 +305,7 @@ rfkill_add(NMRfkillManager *self, struct udev_device *device) g_return_if_fail(device != NULL); name = udev_device_get_sysname(device); + g_return_if_fail(name != NULL); if (!killswitch_find_by_name(self, name)) @@ -346,16 +347,16 @@ handle_uevent(NMUdevClient *client, struct udev_device *device, gpointer user_da /* A bit paranoid */ subsys = udev_device_get_subsystem(device); - g_return_if_fail(!g_strcmp0(subsys, "rfkill")); + g_return_if_fail(nm_streq0(subsys, "rfkill")); nm_log_dbg(LOGD_PLATFORM, "udev rfkill event: action '%s' device '%s'", action, udev_device_get_sysname(device)); - if (!strcmp(action, "add")) + if (nm_streq(action, "add")) rfkill_add(self, device); - else if (!strcmp(action, "remove")) + else if (nm_streq(action, "remove")) rfkill_remove(self, device); recheck_killswitches(self); From 26e9deb831b352c0ffd7d6542fe1ad59f667797c Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 2 Feb 2022 12:04:27 +0100 Subject: [PATCH 13/13] core/rfkill: cleanup arguments for "rfkill-changed" signal The signal parameters are G_TYPE_UINT. We should not assume that our enums are a compatible integer type. In practice of course they always were. Let's just be clear about when we have an integer and when we have an enum. --- src/core/nm-manager.c | 10 ++++++---- src/core/nm-rfkill-manager.c | 10 +++++++--- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index a9cf0c86c5..003552bc47 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -3802,11 +3802,13 @@ platform_query_devices(NMManager *self) } static void -rfkill_manager_rfkill_changed_cb(NMRfkillManager *rfkill_mgr, - NMRfkillType rtype, - NMRfkillState udev_state, - gpointer user_data) +rfkill_manager_rfkill_changed_cb(NMRfkillManager *rfkill_mgr, + /* NMRfkillType */ guint rtype, + /* NMRfkillState */ guint udev_state, + gpointer user_data) { + nm_assert(rtype < NM_RFKILL_TYPE_MAX); + _rfkill_update(NM_MANAGER(user_data), rtype); } diff --git a/src/core/nm-rfkill-manager.c b/src/core/nm-rfkill-manager.c index 87646227f2..bb6dcfd72c 100644 --- a/src/core/nm-rfkill-manager.c +++ b/src/core/nm-rfkill-manager.c @@ -242,7 +242,11 @@ recheck_killswitches(NMRfkillManager *self) nm_rfkill_state_to_string(poll_states[i])); priv->rfkill_states[i] = poll_states[i]; - g_signal_emit(self, signals[RFKILL_CHANGED], 0, i, priv->rfkill_states[i]); + g_signal_emit(self, + signals[RFKILL_CHANGED], + 0, + (guint) i, + (guint) priv->rfkill_states[i]); } } } @@ -435,6 +439,6 @@ nm_rfkill_manager_class_init(NMRfkillManagerClass *klass) NULL, G_TYPE_NONE, 2, - G_TYPE_UINT, - G_TYPE_UINT); + G_TYPE_UINT /* NMRfkillType */, + G_TYPE_UINT /* NMRfkillState */); }