Check RFKILL block state before enable the device

When starting, the device RFKILL block state will be recorded using
update_rfkill_state(). And at following device detection stage,
before enable the device, __connman_udev_get_blocked() should be
used to check the block state. If the device is blocked, it should
not be enabled. This avoids unnecessary enable and disable operation
and a race condition.

4 files changed, 69 insertions, 0 deletions

diff --git a/src/connman.h b/src/connman.h
index a6619df6..a7040270 100644
--- a/src/connman.h
+++ b/src/connman.h
@@ -265,6 +265,7 @@ char *__connman_udev_get_devtype(const char *ifname);
 char *__connman_udev_get_mbm_devnode(const char *ifname);
 void __connman_udev_rfkill(const char *sysname, connman_bool_t blocked);
 void __connman_udev_enable_rfkill_processing(void);
+connman_bool_t __connman_udev_get_blocked(int phyindex);
 
 #include <connman/device.h>
 
diff --git a/src/device.c b/src/device.c
index 0d418639..875b1972 100644
--- a/src/device.c
+++ b/src/device.c
@@ -545,6 +545,9 @@ static int setup_device(struct connman_device *device)
 		break;
 	}
 
+	if (__connman_udev_get_blocked(device->phyindex) == TRUE)
+		return 0;
+
 	if (device->offlinemode == FALSE &&
 				device->powered_persistent == TRUE)
 		__connman_device_enable(device);
diff --git a/src/udev-compat.c b/src/udev-compat.c
index 70cc3bba..11567050 100644
--- a/src/udev-compat.c
+++ b/src/udev-compat.c
@@ -127,6 +127,11 @@ void __connman_udev_rfkill(const char *sysname, connman_bool_t blocked)
 	DBG("sysname %s blocked %d", sysname, blocked);
 }
 
+connman_bool_t __connman_udev_get_blocked(int phyindex)
+{
+	return FALSE;
+}
+
 int __connman_udev_init(void)
 {
 	DBG("");
diff --git a/src/udev.c b/src/udev.c
index 59f36eaf..676fe6fc 100644
--- a/src/udev.c
+++ b/src/udev.c
@@ -155,6 +155,56 @@ static void remove_net_device(struct udev_device *udev_device)
 	connman_device_unref(device);
 }
 
+static GSList *rfkill_list = NULL;
+
+struct rfkill_data {
+	int phyindex;
+	connman_bool_t blocked;
+};
+
+connman_bool_t __connman_udev_get_blocked(int phyindex)
+{
+	GSList *list;
+
+	if (phyindex < 0)
+		return FALSE;
+
+	for (list = rfkill_list; list; list = rfkill_list->next) {
+		struct rfkill_data *block = list->data;
+
+		if (block->phyindex == phyindex)
+			return block->blocked;
+	}
+
+	return FALSE;
+}
+
+static void update_rfkill_state(int phyindex, connman_bool_t blocked)
+{
+	GSList *list;
+	struct rfkill_data *block;
+
+	DBG("index %d blocked %d", phyindex, blocked);
+
+	for (list = rfkill_list; list; list = rfkill_list->next) {
+		block = list->data;
+
+		if (block->phyindex == phyindex) {
+			block->blocked = blocked;
+			return;
+		}
+	}
+
+	block = g_try_new0(struct rfkill_data, 1);
+	if (block == NULL)
+		return;
+
+	block->phyindex = phyindex;
+	block->blocked = blocked;
+
+	rfkill_list = g_slist_prepend(rfkill_list, block);
+}
+
 static void phyindex_rfkill(int phyindex, connman_bool_t blocked)
 {
 	GSList *list;
@@ -162,6 +212,8 @@ static void phyindex_rfkill(int phyindex, connman_bool_t blocked)
 	if (phyindex < 0)
 		return;
 
+	update_rfkill_state(phyindex, blocked);
+
 	for (list = device_list; list; list = list->next) {
 		struct connman_device *device = list->data;
 
@@ -543,6 +595,14 @@ void __connman_udev_cleanup(void)
 	g_slist_free(device_list);
 	device_list = NULL;
 
+	for (list = rfkill_list; list; list = list->next) {
+		struct rfkill_data *block = list->data;
+		g_free(block);
+	}
+
+	g_slist_free(rfkill_list);
+	rfkill_list = NULL;
+
 	if (udev_ctx == NULL)
 		return;