fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-05 14:38:09 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

core/rfkill: add "nm" prefix to RfKillState and RfKillType enums

Browse source 
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.
This commit is contained in:
Thomas Haller 2022-02-01 20:21:34 +01:00
parent 99ceb205e9
commit 454992ed85
No known key found for this signature in database
GPG key ID: 29C2366E4DFC5728
10 changed files with 101 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/core/devices/nm-device.c
View file

@ -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,

4
src/core/devices/nm-device.h
View file

@ -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 */

2
src/core/devices/wifi/nm-device-iwd-p2p.c
View file

@ -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,
"",

2
src/core/devices/wifi/nm-device-iwd.c
View file

@ -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,
"",

2
src/core/devices/wifi/nm-device-wifi-p2p.c
View file

@ -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,
"",

2
src/core/devices/wifi/nm-device-wifi.c
View file

@ -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,
"",

2
src/core/devices/wwan/nm-device-modem.c
View file

@ -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,

80
src/core/nm-manager.c
View file

@ -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:

78
src/core/nm-rfkill-manager.c
View file

@ -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);

22
src/core/nm-rfkill-manager.h
View file

@ -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__ */