path: root/plugins/rfkill/rfkill-glib.c

/*
 *
 *  gnome-bluetooth - Bluetooth integration for GNOME
 *
 *  Copyright (C) 2012  Bastien Nocera <hadess@hadess.net>
 *  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));
}