/*
*
* 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 <sys/ioctl.h>
#include <glib.h>
#include <gio/gio.h>
#include <gio/gunixoutputstream.h>
#include "rfkill-glib.h"
#include <gudev/gudev.h>
enum {
CHANGED,
LAST_SIGNAL
};
enum {
PROP_RFKILL_INPUT_INHIBITED = 1
};
static int signals[LAST_SIGNAL] = { 0 };
struct _CcRfkillGlib {
GObject parent;
GUdevClient *udev;
gchar *device_file;
GOutputStream *stream;
GIOChannel *channel;
guint watch_id;
/* rfkill-input inhibitor */
gboolean noinput;
int noinput_fd;
/* Pending Bluetooth enablement.
* If (@change_all_timeout_id != 0), then (task != NULL). The converse
* does not necessarily hold. */
guint change_all_timeout_id;
GTask *task;
};
G_DEFINE_TYPE (CcRfkillGlib, cc_rfkill_glib, G_TYPE_OBJECT)
#define CHANGE_ALL_TIMEOUT 500
static const char *type_to_string (unsigned int type);
static void
cancel_current_task (CcRfkillGlib *rfkill)
{
if (rfkill->task != NULL) {
g_cancellable_cancel (g_task_get_cancellable (rfkill->task));
g_clear_object (&rfkill->task);
}
if (rfkill->change_all_timeout_id != 0) {
g_source_remove (rfkill->change_all_timeout_id);
rfkill->change_all_timeout_id = 0;
}
}
/* 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 (CC_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)
{
g_autoptr(GTask) task = G_TASK (user_data);
CcRfkillGlib *rfkill = g_task_get_source_object (task);
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 (task, g_steal_pointer (&error));
else
g_task_return_boolean (task, ret >= 0);
/* If this @task has been cancelled, it may have been superceded. */
if (rfkill->task == task)
g_clear_object (&rfkill->task);
}
static gboolean
write_change_all_timeout_cb (CcRfkillGlib *rfkill)
{
struct rfkill_event *event;
g_assert (rfkill->task != NULL);
g_debug ("Sending second RFKILL_OP_CHANGE_ALL timed out");
event = g_task_get_task_data (rfkill->task);
g_task_return_new_error (rfkill->task,
G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
"Enabling rfkill for %s timed out",
type_to_string (event->type));
g_clear_object (&rfkill->task);
rfkill->change_all_timeout_id = 0;
return G_SOURCE_REMOVE;
}
static void
write_change_all_done_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
CcRfkillGlib *rfkill = g_task_get_source_object (task);
g_autoptr(GError) error = NULL;
gssize ret;
struct rfkill_event *event;
g_debug ("Sending original RFKILL_OP_CHANGE_ALL event done");
event = g_task_get_task_data (task);
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));
goto bail;
} else if (event->soft == 1 ||
event->type != RFKILL_TYPE_BLUETOOTH) {
g_task_return_boolean (task, ret >= 0);
goto bail;
}
g_assert (rfkill->change_all_timeout_id == 0);
rfkill->change_all_timeout_id = g_timeout_add (CHANGE_ALL_TIMEOUT,
(GSourceFunc) write_change_all_timeout_cb,
rfkill);
return;
bail:
/* If this @task has been cancelled, it may have been superceded. */
if (rfkill->task == task)
g_clear_object (&rfkill->task);
}
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_autoptr(GCancellable) task_cancellable = NULL;
g_return_if_fail (CC_RFKILL_IS_GLIB (rfkill));
g_return_if_fail (rfkill->stream);
task_cancellable = g_cancellable_new ();
g_signal_connect_object (cancellable, "cancelled",
(GCallback) g_cancellable_cancel,
task_cancellable,
G_CONNECT_SWAPPED);
/* Now check if it is cancelled already */
if (g_cancellable_is_cancelled (cancellable))
g_cancellable_cancel (task_cancellable);
task = g_task_new (rfkill, task_cancellable, callback, user_data);
g_task_set_source_tag (task, cc_rfkill_glib_send_change_all_event);
/* Clear any previous task. */
cancel_current_task (rfkill);
g_assert (rfkill->task == NULL);
/* Start writing out a new event. */
event = g_new0 (struct rfkill_event, 1);
event->op = RFKILL_OP_CHANGE_ALL;
event->type = rfkill_type;
event->soft = enable ? 1 : 0;
g_task_set_task_data (task, event, g_free);
rfkill->task = g_object_ref (task);
rfkill->change_all_timeout_id = 0;
g_output_stream_write_async (rfkill->stream,
event, sizeof(struct rfkill_event),
G_PRIORITY_DEFAULT,
task_cancellable, write_change_all_done_cb,
g_object_ref (task));
}
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->change_all_timeout_id > 0 &&
got_change_event (events)) {
struct rfkill_event *event;
g_debug ("Received a change event after a RFKILL_OP_CHANGE_ALL event, re-sending RFKILL_OP_CHANGE_ALL");
event = g_task_get_task_data (rfkill->task);
g_output_stream_write_async (rfkill->stream,
event, sizeof(struct rfkill_event),
G_PRIORITY_DEFAULT,
g_task_get_cancellable (rfkill->task),
write_change_all_again_done_cb,
g_object_ref (rfkill->task));
g_source_remove (rfkill->change_all_timeout_id);
rfkill->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)
{
rfkill->device_file = NULL;
rfkill->noinput_fd = -1;
}
static gboolean
_cc_rfkill_glib_open (CcRfkillGlib *rfkill,
GError **error)
{
int fd;
int ret;
GList *events;
g_return_val_if_fail (CC_RFKILL_IS_GLIB (rfkill), FALSE);
g_return_val_if_fail (rfkill->stream == NULL, FALSE);
g_assert (rfkill->device_file);
fd = open (rfkill->device_file, O_RDWR);
if (fd < 0) {
g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errno),
"Could not open RFKILL control device, please verify your installation");
return FALSE;
}
ret = fcntl(fd, F_SETFL, O_NONBLOCK);
if (ret < 0) {
g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errno),
"Can't set RFKILL control device to non-blocking");
close(fd);
return FALSE;
}
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 */
rfkill->channel = g_io_channel_unix_new (fd);
g_io_channel_set_encoding (rfkill->channel, NULL, NULL);
rfkill->watch_id = g_io_add_watch (rfkill->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 */
rfkill->stream = g_unix_output_stream_new (fd, TRUE);
return TRUE;
}
static void
uevent_cb (GUdevClient *client,
gchar *action,
GUdevDevice *device,
gpointer user_data)
{
CcRfkillGlib *rfkill = CC_RFKILL_GLIB (user_data);
if (g_strcmp0 (action, "add") != 0)
return;
if (g_strcmp0 (g_udev_device_get_name (device), "rfkill") == 0) {
g_autoptr(GError) error = NULL;
g_debug ("Rfkill device has been created");
if (g_udev_device_get_device_file (device)) {
g_clear_pointer (&rfkill->device_file, g_free);
rfkill->device_file = g_strdup (g_udev_device_get_device_file (device));
} else {
g_warning ("rfkill udev device does not have a device file!");
}
if (!_cc_rfkill_glib_open (rfkill, &error))
g_warning ("Could not open rfkill device: %s", error->message);
else
g_debug ("Opened rfkill device after uevent");
g_clear_object (&rfkill->udev);
/* Sync rfkill input inhibition state*/
cc_rfkill_glib_set_rfkill_input_inhibited (rfkill, rfkill->noinput);
}
}
gboolean
cc_rfkill_glib_open (CcRfkillGlib *rfkill,
GError **error)
{
const char * const subsystems[] = { "misc", NULL };
GUdevDevice *device;
rfkill->udev = g_udev_client_new (subsystems);
g_debug ("Setting up uevent listener");
g_signal_connect (rfkill->udev, "uevent", G_CALLBACK (uevent_cb), rfkill);
/* Simulate uevent if device already exists. */
device = g_udev_client_query_by_subsystem_and_name (rfkill->udev, "misc", "rfkill");
if (device)
uevent_cb (rfkill->udev, "add", device, rfkill);
return TRUE;
}
#define RFKILL_INPUT_INHIBITED(rfkill) (rfkill->noinput_fd >= 0)
gboolean
cc_rfkill_glib_get_rfkill_input_inhibited (CcRfkillGlib *rfkill)
{
g_return_val_if_fail (CC_RFKILL_IS_GLIB (rfkill), FALSE);
return rfkill->noinput;
}
void
cc_rfkill_glib_set_rfkill_input_inhibited (CcRfkillGlib *rfkill,
gboolean inhibit)
{
g_return_if_fail (CC_RFKILL_IS_GLIB (rfkill));
/* Shortcut in case we don't have an rfkill device */
if (!rfkill->stream) {
if (rfkill->noinput == inhibit)
return;
rfkill->noinput = inhibit;
g_object_notify (G_OBJECT (rfkill), "rfkill-input-inhibited");
return;
}
if (!inhibit && RFKILL_INPUT_INHIBITED(rfkill)) {
close (rfkill->noinput_fd);
g_debug ("Closed rfkill noinput FD.");
rfkill->noinput_fd = -1;
}
if (inhibit && !RFKILL_INPUT_INHIBITED(rfkill)) {
int fd, res;
/* Open write only as we don't want to do any IO to it ever. */
fd = open (rfkill->device_file, O_WRONLY);
if (fd < 0) {
if (errno == EACCES)
g_warning ("Could not open RFKILL control device, please verify your installation");
else
g_debug ("Could not open RFKILL control device: %s", g_strerror (errno));
return;
}
res = ioctl (fd, RFKILL_IOCTL_NOINPUT, (long) 0);
if (res != 0) {
g_warning ("Could not disable kernel handling of RFKILL related keys: %s", g_strerror (errno));
close (fd);
return;
}
g_debug ("Opened rfkill-input inhibitor.");
rfkill->noinput_fd = fd;
}
if (rfkill->noinput != RFKILL_INPUT_INHIBITED(rfkill)) {
rfkill->noinput = RFKILL_INPUT_INHIBITED(rfkill);
g_object_notify (G_OBJECT (rfkill), "rfkill-input-inhibited");
}
}
static void
cc_rfkill_glib_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
CcRfkillGlib *rfkill = CC_RFKILL_GLIB (object);
switch (prop_id) {
case PROP_RFKILL_INPUT_INHIBITED:
cc_rfkill_glib_set_rfkill_input_inhibited (rfkill, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
cc_rfkill_glib_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
CcRfkillGlib *rfkill = CC_RFKILL_GLIB (object);
switch (prop_id) {
case PROP_RFKILL_INPUT_INHIBITED:
g_value_set_boolean (value, rfkill->noinput);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
cc_rfkill_glib_finalize (GObject *object)
{
CcRfkillGlib *rfkill = CC_RFKILL_GLIB (object);
cancel_current_task (rfkill);
/* cleanup monitoring */
if (rfkill->watch_id > 0) {
g_source_remove (rfkill->watch_id);
rfkill->watch_id = 0;
g_io_channel_shutdown (rfkill->channel, FALSE, NULL);
g_io_channel_unref (rfkill->channel);
}
g_clear_object (&rfkill->stream);
if (RFKILL_INPUT_INHIBITED(rfkill)) {
close (rfkill->noinput_fd);
rfkill->noinput_fd = -1;
}
g_clear_pointer (&rfkill->device_file, g_free);
g_clear_object (&rfkill->udev);
G_OBJECT_CLASS(cc_rfkill_glib_parent_class)->finalize(object);
}
static void
cc_rfkill_glib_class_init(CcRfkillGlibClass *klass)
{
GObjectClass *object_class = (GObjectClass *) klass;
object_class->set_property = cc_rfkill_glib_set_property;
object_class->get_property = cc_rfkill_glib_get_property;
object_class->finalize = cc_rfkill_glib_finalize;
g_object_class_install_property (object_class,
PROP_RFKILL_INPUT_INHIBITED,
g_param_spec_boolean ("rfkill-input-inhibited",
"Rfkill input inhibited",
"Whether to prevent the kernel from handling RFKILL related key events.",
FALSE,
G_PARAM_READWRITE));
signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
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));
}