rfkill: Add RFKill support plugin on Linux systems

from https://github.com/GNOME/gnome-settings-daemon/commit/444af32e343a79ca3db0f957bf73687a0f0df9ec

Signed-off-by: Zhang Xianwei <[email protected]>

1 files changed, 517 insertions, 0 deletions

diff --git a/plugins/rfkill/rfkill-glib.c b/plugins/rfkill/rfkill-glib.c
new file mode 100644
index 0000000..9686cdf
--- /dev/null
+++ b/plugins/rfkill/rfkill-glib.c
@@ -0,0 +1,517 @@
+/*
+ *
+ *  gnome-bluetooth - Bluetooth integration for GNOME
+ *
+ *  Copyright (C) 2012  Bastien Nocera <[email protected]>
+ *  Copyright © 2017 Endless Mobile, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <gio/gunixoutputstream.h>
+
+#include "rfkill-glib.h"
+
+enum {
+	CHANGED,
+	LAST_SIGNAL
+};
+
+static int signals[LAST_SIGNAL] = { 0 };
+
+#define CC_RFKILL_GLIB_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				CC_RFKILL_TYPE_GLIB, CcRfkillGlibPrivate))
+
+struct CcRfkillGlibPrivate {
+	GOutputStream *stream;
+	GIOChannel *channel;
+	guint watch_id;
+
+	/* Pending Bluetooth enablement */
+	guint change_all_timeout_id;
+	struct rfkill_event *event;
+	GTask *task;
+	GCancellable *cancellable;
+};
+
+G_DEFINE_TYPE(CcRfkillGlib, cc_rfkill_glib, G_TYPE_OBJECT)
+
+#define CHANGE_ALL_TIMEOUT 500
+
+static const char *type_to_string (unsigned int type);
+
+/* Note that this can return %FALSE without setting @error. */
+gboolean
+cc_rfkill_glib_send_event_finish (CcRfkillGlib  *rfkill,
+				  GAsyncResult  *res,
+				  GError       **error)
+{
+	g_return_val_if_fail (RFKILL_IS_GLIB (rfkill), FALSE);
+	g_return_val_if_fail (g_task_is_valid (res, rfkill), FALSE);
+	g_return_val_if_fail (g_async_result_is_tagged (res, cc_rfkill_glib_send_event), FALSE);
+
+	return (g_task_propagate_int (G_TASK (res), error) >= 0);
+}
+
+static void
+write_done_cb (GObject      *source_object,
+	       GAsyncResult *res,
+	       gpointer      user_data)
+{
+	g_autoptr(GTask) task = G_TASK (user_data);
+	g_autoptr(GError) error = NULL;
+	gssize ret;
+
+	ret = g_output_stream_write_finish (G_OUTPUT_STREAM (source_object), res, &error);
+	if (ret < 0)
+		g_task_return_error (task, g_steal_pointer (&error));
+	else
+		g_task_return_int (task, ret);
+}
+
+void
+cc_rfkill_glib_send_event (CcRfkillGlib        *rfkill,
+			   struct rfkill_event *event,
+			   GCancellable        *cancellable,
+			   GAsyncReadyCallback  callback,
+			   gpointer             user_data)
+{
+	g_autoptr(GTask) task = NULL;
+
+	g_return_if_fail (RFKILL_IS_GLIB (rfkill));
+	g_return_if_fail (rfkill->priv->stream);
+
+	task = g_task_new (rfkill, cancellable, callback, user_data);
+	g_task_set_source_tag (task, cc_rfkill_glib_send_event);
+
+	g_output_stream_write_async (rfkill->priv->stream,
+				     event, sizeof(struct rfkill_event),
+				     G_PRIORITY_DEFAULT,
+				     cancellable, write_done_cb,
+				     g_object_ref (task));
+}
+
+/* Note that this can return %FALSE without setting @error. */
+gboolean
+cc_rfkill_glib_send_change_all_event_finish (CcRfkillGlib        *rfkill,
+					     GAsyncResult        *res,
+					     GError             **error)
+{
+	g_return_val_if_fail (RFKILL_IS_GLIB (rfkill), FALSE);
+	g_return_val_if_fail (g_task_is_valid (res, rfkill), FALSE);
+	g_return_val_if_fail (g_async_result_is_tagged (res, cc_rfkill_glib_send_change_all_event), FALSE);
+
+	return g_task_propagate_boolean (G_TASK (res), error);
+}
+
+static void
+write_change_all_again_done_cb (GObject      *source_object,
+				GAsyncResult *res,
+				gpointer      user_data)
+{
+	CcRfkillGlib *rfkill = user_data;
+	g_autoptr(GError) error = NULL;
+	gssize ret;
+
+	g_debug ("Finished writing second RFKILL_OP_CHANGE_ALL event");
+
+	ret = g_output_stream_write_finish (G_OUTPUT_STREAM (source_object), res, &error);
+	if (ret < 0)
+		g_task_return_error (rfkill->priv->task, g_steal_pointer (&error));
+	else
+		g_task_return_boolean (rfkill->priv->task, ret >= 0);
+
+	g_clear_object (&rfkill->priv->task);
+	g_clear_pointer (&rfkill->priv->event, g_free);
+}
+
+static gboolean
+write_change_all_timeout_cb (CcRfkillGlib *rfkill)
+{
+	g_assert (rfkill->priv->event);
+
+	g_debug ("Sending second RFKILL_OP_CHANGE_ALL timed out");
+
+	g_task_return_new_error (rfkill->priv->task,
+				 G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
+				 "Enabling rfkill for %s timed out",
+				 type_to_string (rfkill->priv->event->type));
+
+	g_clear_object (&rfkill->priv->task);
+	g_clear_pointer (&rfkill->priv->event, g_free);
+	g_clear_object (&rfkill->priv->cancellable);
+	rfkill->priv->change_all_timeout_id = 0;
+
+	return G_SOURCE_REMOVE;
+}
+
+static void
+write_change_all_done_cb (GObject      *source_object,
+			  GAsyncResult *res,
+			  gpointer      user_data)
+{
+	CcRfkillGlib *rfkill = user_data;
+	g_autoptr(GError) error = NULL;
+	gssize ret;
+
+	g_debug ("Sending original RFKILL_OP_CHANGE_ALL event done");
+
+	ret = g_output_stream_write_finish (G_OUTPUT_STREAM (source_object), res, &error);
+	if (ret < 0) {
+		g_task_return_error (rfkill->priv->task, g_steal_pointer (&error));
+		goto bail;
+	} else if (rfkill->priv->event->soft == 1 ||
+		   rfkill->priv->event->type != RFKILL_TYPE_BLUETOOTH) {
+		g_task_return_boolean (rfkill->priv->task, ret >= 0);
+		goto bail;
+	}
+
+	rfkill->priv->change_all_timeout_id = g_timeout_add (CHANGE_ALL_TIMEOUT,
+							     (GSourceFunc) write_change_all_timeout_cb,
+							     rfkill);
+
+	return;
+
+bail:
+	g_clear_object (&rfkill->priv->task);
+	g_clear_pointer (&rfkill->priv->event, g_free);
+	g_clear_object (&rfkill->priv->cancellable);
+}
+
+void
+cc_rfkill_glib_send_change_all_event (CcRfkillGlib        *rfkill,
+				      guint                rfkill_type,
+				      gboolean             enable,
+				      GCancellable        *cancellable,
+				      GAsyncReadyCallback  callback,
+				      gpointer             user_data)
+{
+	g_autoptr(GTask) task = NULL;
+	struct rfkill_event *event;
+
+	g_return_if_fail (RFKILL_IS_GLIB (rfkill));
+	g_return_if_fail (rfkill->priv->stream);
+
+	task = g_task_new (rfkill, cancellable, callback, user_data);
+	g_task_set_source_tag (task, cc_rfkill_glib_send_change_all_event);
+
+	if (rfkill->priv->change_all_timeout_id > 0) {
+		g_source_remove (rfkill->priv->change_all_timeout_id);
+		rfkill->priv->change_all_timeout_id = 0;
+		write_change_all_timeout_cb (rfkill);
+	}
+
+	event = g_new0 (struct rfkill_event, 1);
+	event->op = RFKILL_OP_CHANGE_ALL;
+	event->type = rfkill_type;
+	event->soft = enable ? 1 : 0;
+
+	rfkill->priv->event = event;
+	rfkill->priv->task = g_object_ref (task);
+	rfkill->priv->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
+	rfkill->priv->change_all_timeout_id = 0;
+
+	g_output_stream_write_async (rfkill->priv->stream,
+				     event, sizeof(struct rfkill_event),
+				     G_PRIORITY_DEFAULT,
+				     cancellable, write_change_all_done_cb, rfkill);
+}
+
+static const char *
+type_to_string (unsigned int type)
+{
+	switch (type) {
+	case RFKILL_TYPE_ALL:
+		return "ALL";
+	case RFKILL_TYPE_WLAN:
+		return "WLAN";
+	case RFKILL_TYPE_BLUETOOTH:
+		return "BLUETOOTH";
+	case RFKILL_TYPE_UWB:
+		return "UWB";
+	case RFKILL_TYPE_WIMAX:
+		return "WIMAX";
+	case RFKILL_TYPE_WWAN:
+		return "WWAN";
+	default:
+		return "UNKNOWN";
+	}
+}
+
+static const char *
+op_to_string (unsigned int op)
+{
+	switch (op) {
+	case RFKILL_OP_ADD:
+		return "ADD";
+	case RFKILL_OP_DEL:
+		return "DEL";
+	case RFKILL_OP_CHANGE:
+		return "CHANGE";
+	case RFKILL_OP_CHANGE_ALL:
+		return "CHANGE_ALL";
+	default:
+		g_assert_not_reached ();
+	}
+}
+
+static void
+print_event (struct rfkill_event *event)
+{
+	g_debug ("RFKILL event: idx %u type %u (%s) op %u (%s) soft %u hard %u",
+		 event->idx,
+		 event->type, type_to_string (event->type),
+		 event->op, op_to_string (event->op),
+		 event->soft, event->hard);
+}
+
+static gboolean
+got_change_event (GList *events)
+{
+	GList *l;
+
+	g_assert (events != NULL);
+
+	for (l = events ; l != NULL; l = l->next) {
+		struct rfkill_event *event = l->data;
+
+		if (event->op == RFKILL_OP_CHANGE)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+static void
+emit_changed_signal_and_free (CcRfkillGlib *rfkill,
+			      GList        *events)
+{
+	if (events == NULL)
+		return;
+
+	g_signal_emit (G_OBJECT (rfkill),
+		       signals[CHANGED],
+		       0, events);
+
+	if (rfkill->priv->change_all_timeout_id > 0 &&
+	    got_change_event (events)) {
+		g_debug ("Received a change event after a RFKILL_OP_CHANGE_ALL event, re-sending RFKILL_OP_CHANGE_ALL");
+
+		g_output_stream_write_async (rfkill->priv->stream,
+					     rfkill->priv->event, sizeof(struct rfkill_event),
+					     G_PRIORITY_DEFAULT,
+					     rfkill->priv->cancellable, write_change_all_again_done_cb, rfkill);
+
+		g_source_remove (rfkill->priv->change_all_timeout_id);
+		rfkill->priv->change_all_timeout_id = 0;
+	}
+
+	g_list_free_full (events, g_free);
+}
+
+static gboolean
+event_cb (GIOChannel   *source,
+	  GIOCondition  condition,
+	  CcRfkillGlib   *rfkill)
+{
+	GList *events;
+
+	events = NULL;
+
+	if (condition & G_IO_IN) {
+		GIOStatus status;
+		struct rfkill_event event;
+		gsize read;
+
+		status = g_io_channel_read_chars (source,
+						  (char *) &event,
+						  sizeof(event),
+						  &read,
+						  NULL);
+
+		while (status == G_IO_STATUS_NORMAL && read == sizeof(event)) {
+			struct rfkill_event *event_ptr;
+
+			print_event (&event);
+
+			event_ptr = g_memdup (&event, sizeof(event));
+			events = g_list_prepend (events, event_ptr);
+
+			status = g_io_channel_read_chars (source,
+							  (char *) &event,
+							  sizeof(event),
+							  &read,
+							  NULL);
+		}
+		events = g_list_reverse (events);
+	} else {
+		g_debug ("Something unexpected happened on rfkill fd");
+		return FALSE;
+	}
+
+	emit_changed_signal_and_free (rfkill, events);
+
+	return TRUE;
+}
+
+static void
+cc_rfkill_glib_init (CcRfkillGlib *rfkill)
+{
+	CcRfkillGlibPrivate *priv;
+
+	priv = CC_RFKILL_GLIB_GET_PRIVATE (rfkill);
+	rfkill->priv = priv;
+}
+
+int
+cc_rfkill_glib_open (CcRfkillGlib *rfkill)
+{
+	CcRfkillGlibPrivate *priv;
+	int fd;
+	int ret;
+	GList *events;
+
+	g_return_val_if_fail (RFKILL_IS_GLIB (rfkill), -1);
+	g_return_val_if_fail (rfkill->priv->stream == NULL, -1);
+
+	priv = rfkill->priv;
+
+	fd = open("/dev/rfkill", O_RDWR);
+	if (fd < 0) {
+		if (errno == EACCES)
+			g_warning ("Could not open RFKILL control device, please verify your installation");
+		return fd;
+	}
+
+	ret = fcntl(fd, F_SETFL, O_NONBLOCK);
+	if (ret < 0) {
+		g_debug ("Can't set RFKILL control device to non-blocking");
+		close(fd);
+		return ret;
+	}
+
+	events = NULL;
+
+	while (1) {
+		struct rfkill_event event;
+		struct rfkill_event *event_ptr;
+		ssize_t len;
+
+		len = read(fd, &event, sizeof(event));
+		if (len < 0) {
+			if (errno == EAGAIN)
+				break;
+			g_debug ("Reading of RFKILL events failed");
+			break;
+		}
+
+		if (len != RFKILL_EVENT_SIZE_V1) {
+			g_warning ("Wrong size of RFKILL event\n");
+			continue;
+		}
+
+		if (event.op != RFKILL_OP_ADD)
+			continue;
+
+		g_debug ("Read killswitch of type '%s' (idx=%d): soft %d hard %d",
+			 type_to_string (event.type),
+			 event.idx, event.soft, event.hard);
+
+		event_ptr = g_memdup (&event, sizeof(event));
+		events = g_list_prepend (events, event_ptr);
+	}
+
+	/* Setup monitoring */
+	priv->channel = g_io_channel_unix_new (fd);
+	priv->watch_id = g_io_add_watch (priv->channel,
+					 G_IO_IN | G_IO_HUP | G_IO_ERR,
+					 (GIOFunc) event_cb,
+					 rfkill);
+
+	if (events) {
+		events = g_list_reverse (events);
+		emit_changed_signal_and_free (rfkill, events);
+	} else {
+		g_debug ("No rfkill device available on startup");
+	}
+
+	/* Setup write stream */
+	priv->stream = g_unix_output_stream_new (fd, TRUE);
+
+	return fd;
+}
+
+static void
+cc_rfkill_glib_finalize (GObject *object)
+{
+	CcRfkillGlib *rfkill;
+	CcRfkillGlibPrivate *priv;
+
+	rfkill = CC_RFKILL_GLIB (object);
+	priv = rfkill->priv;
+
+	if (priv->change_all_timeout_id > 0)
+		write_change_all_timeout_cb (rfkill);
+
+	/* cleanup monitoring */
+	if (priv->watch_id > 0) {
+		g_source_remove (priv->watch_id);
+		priv->watch_id = 0;
+		g_io_channel_shutdown (priv->channel, FALSE, NULL);
+		g_io_channel_unref (priv->channel);
+	}
+	g_clear_object (&priv->stream);
+
+	G_OBJECT_CLASS(cc_rfkill_glib_parent_class)->finalize(object);
+}
+
+static void
+cc_rfkill_glib_class_init(CcRfkillGlibClass *klass)
+{
+	GObjectClass *object_class = (GObjectClass *) klass;
+
+	g_type_class_add_private(klass, sizeof(CcRfkillGlibPrivate));
+	object_class->finalize = cc_rfkill_glib_finalize;
+
+	signals[CHANGED] =
+		g_signal_new ("changed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CcRfkillGlibClass, changed),
+			      NULL, NULL,
+			      NULL,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+
+}
+
+CcRfkillGlib *
+cc_rfkill_glib_new (void)
+{
+	return CC_RFKILL_GLIB (g_object_new (CC_RFKILL_TYPE_GLIB, NULL));
+}