/* * *  BlueZ - Bluetooth protocol stack for Linux * *  Copyright (C) 2004-2008  Marcel Holtmann <marcel@holtmann.org> * * *  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 <stdlib.h>#include <errno.h>#include <fcntl.h>#include <unistd.h>#include <sys/stat.h>#include <sys/ioctl.h>#include <sys/socket.h>#include <bluetooth/bluetooth.h>#include <bluetooth/hidp.h>#include <bluetooth/l2cap.h>#include <bluetooth/rfcomm.h>#include <glib.h>#include <dbus/dbus.h>#include "dbus.h"#include "dbus-helper.h"#include "logging.h"#include "textfile.h"#include "uinput.h"#include "device.h"#include "error.h"#include "manager.h"#include "storage.h"#define INPUT_DEVICE_INTERFACE	"org.bluez.input.Device"#define BUF_SIZE	16#define UPDOWN_ENABLED		1#define FI_FLAG_CONNECTED	1struct device;struct fake_input {	int		flags;	GIOChannel	*io;	int		rfcomm; /* RFCOMM socket */	int		uinput;	/* uinput socket */	uint8_t		ch;	/* RFCOMM channel number */	gboolean	(*connect)(struct device *idev);	int		(*disconnect)(struct device *idev);};struct device {	bdaddr_t		src;	bdaddr_t		dst;	char			*name;	uint8_t			major;	uint8_t			minor;	uint16_t		product;	uint16_t		vendor;	struct fake_input	*fake;	DBusMessage		*pending_connect;	DBusConnection		*conn;	char			*path;	int			ctrl_sk;	int			intr_sk;	guint			ctrl_watch;	guint			intr_watch;};GSList *devices = NULL;static struct device *device_new(bdaddr_t *src, bdaddr_t *dst, uint8_t subclass){	struct device *idev;	uint32_t cls;	uint8_t major, minor;	if (!subclass) {		if (read_device_class(src, dst, &cls) < 0)			return NULL;		major = (cls >> 8) & 0x1f;		minor = (cls >> 2) & 0x3f;	} else {		major = 0x05; /* Peripheral */		minor = (subclass >> 2) & 0x3f;	}	idev = g_new0(struct device, 1);	bacpy(&idev->src, src);	bacpy(&idev->dst, dst);	read_device_name(src, dst, &idev->name);	idev->major	= major;	idev->minor	= minor;	idev->ctrl_sk	= -1;	idev->intr_sk	= -1;	return idev;}static void device_free(struct device *idev){	if (!idev)		return;	if (idev->name)		g_free(idev->name);	if (idev->fake)		g_free(idev->fake);	if (idev->path)		g_free(idev->path);	if (idev->pending_connect)		dbus_message_unref(idev->pending_connect);	dbus_connection_unref(idev->conn);	g_free(idev);}static int uinput_create(char *name){	struct uinput_dev dev;	int fd, err;	fd = open("/dev/uinput", O_RDWR);	if (fd < 0) {		fd = open("/dev/input/uinput", O_RDWR);		if (fd < 0) {			fd = open("/dev/misc/uinput", O_RDWR);			if (fd < 0) {				err = errno;				error("Can't open input device: %s (%d)",							strerror(err), err);				return -err;			}		}	}	memset(&dev, 0, sizeof(dev));	if (name)		strncpy(dev.name, name, UINPUT_MAX_NAME_SIZE);	dev.id.bustype = BUS_BLUETOOTH;	dev.id.vendor  = 0x0000;	dev.id.product = 0x0000;	dev.id.version = 0x0000;	if (write(fd, &dev, sizeof(dev)) < 0) {		err = errno;		error("Can't write device information: %s (%d)",						strerror(err), err);		close(fd);		errno = err;		return -err;	}	ioctl(fd, UI_SET_EVBIT, EV_KEY);	ioctl(fd, UI_SET_EVBIT, EV_REL);	ioctl(fd, UI_SET_EVBIT, EV_REP);	ioctl(fd, UI_SET_KEYBIT, KEY_UP);	ioctl(fd, UI_SET_KEYBIT, KEY_PAGEUP);	ioctl(fd, UI_SET_KEYBIT, KEY_DOWN);	ioctl(fd, UI_SET_KEYBIT, KEY_PAGEDOWN);	if (ioctl(fd, UI_DEV_CREATE, NULL) < 0) {		err = errno;		error("Can't create uinput device: %s (%d)",						strerror(err), err);		close(fd);		errno = err;		return -err;	}	return fd;}static const char *create_input_path(uint8_t major, uint8_t minor){	static char path[48];	char subpath[32];	static int next_id = 0;	switch (major) {	case 0x02: /* Phone */		strcpy(subpath, "phone");		break;	case 0x04: /* Audio */		switch (minor) {		/* FIXME: Testing required */		case 0x01: /* Wearable Headset Device */			strcpy(subpath, "wearable");			break;		case 0x02: /* Hands-free */			strcpy(subpath, "handsfree");			break;		case 0x06: /* Headphone */			strcpy(subpath, "headphone");			break;		default:			return NULL;		}		break;	case 0x05: /* Peripheral */		switch (minor & 0x30) {		case 0x10:			strcpy(subpath, "keyboard");			break;		case 0x20:			strcpy(subpath, "pointing");			break;		case 0x30:			strcpy(subpath, "combo");			break;		default:			subpath[0] = '\0';			break;		}		if ((minor & 0x0f) && (strlen(subpath) > 0))			strcat(subpath, "/");		switch (minor & 0x0f) {		case 0x00:			break;		case 0x01:			strcat(subpath, "joystick");			break;		case 0x02:			strcat(subpath, "gamepad");			break;		case 0x03:			strcat(subpath, "remotecontrol");			break;		case 0x04:			strcat(subpath, "sensing");			break;		case 0x05:			strcat(subpath, "digitizertablet");			break;		case 0x06:			strcat(subpath, "cardreader");			break;		default:			strcat(subpath, "reserved");			break;		}		break;	default:			return NULL;	}	snprintf(path, 48, "%s/%s%d", INPUT_PATH, subpath, next_id++);	return path;}static int decode_key(const char *str){	static int mode = UPDOWN_ENABLED, gain = 0;	uint16_t key;	int new_gain;	/* Switch from key up/down to page up/down */	if (strncmp("AT+CKPD=200", str, 11) == 0) {		mode = ~mode;		return KEY_RESERVED;	}	if (strncmp("AT+VG", str, 5))		return KEY_RESERVED;	/* Gain key pressed */	if (strlen(str) != 10)		return KEY_RESERVED;	new_gain = strtol(&str[7], NULL, 10);	if (new_gain <= gain)		key = (mode == UPDOWN_ENABLED ? KEY_UP : KEY_PAGEUP);	else		key = (mode == UPDOWN_ENABLED ? KEY_DOWN : KEY_PAGEDOWN);	gain = new_gain;	return key;}static void send_event(int fd, uint16_t type, uint16_t code, int32_t value){	struct uinput_event event;	int err;	memset(&event, 0, sizeof(event));	event.type	= type;	event.code	= code;	event.value	= value;	err = write(fd, &event, sizeof(event));}static void send_key(int fd, uint16_t key){	/* Key press */	send_event(fd, EV_KEY, key, 1);	send_event(fd, EV_SYN, SYN_REPORT, 0);	/* Key release */	send_event(fd, EV_KEY, key, 0);	send_event(fd, EV_SYN, SYN_REPORT, 0);}static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond, gpointer data){	struct fake_input *fake = data;	const char *ok = "\r\nOK\r\n";	char buf[BUF_SIZE];	gsize bread = 0, bwritten;	uint16_t key;	if (cond & G_IO_NVAL)		return FALSE;	if (cond & (G_IO_HUP | G_IO_ERR)) {		error("Hangup or error on rfcomm server socket");		goto failed;	}	memset(buf, 0, BUF_SIZE);	if (g_io_channel_read(chan, buf, sizeof(buf) - 1,				&bread) != G_IO_ERROR_NONE) {		error("IO Channel read error");		goto failed;	}	debug("Received: %s", buf);	if (g_io_channel_write(chan, ok, 6, &bwritten) != G_IO_ERROR_NONE) {		error("IO Channel write error");		goto failed;	}	key = decode_key(buf);	if (key != KEY_RESERVED)		send_key(fake->uinput, key);	return TRUE;failed:	ioctl(fake->uinput, UI_DEV_DESTROY);	close(fake->uinput);	fake->uinput = -1;	g_io_channel_unref(fake->io);	return FALSE;}static gboolean rfcomm_connect_cb(GIOChannel *chan,			GIOCondition cond, struct device *idev){	struct fake_input *fake;	DBusMessage *reply;	const char *path;	socklen_t len;	int ret, err;	fake = idev->fake;	fake->rfcomm = g_io_channel_unix_get_fd(chan);	if (cond & G_IO_NVAL)		return FALSE;	if (cond & (G_IO_ERR | G_IO_HUP)) {		err = EIO;		goto failed;	}	len = sizeof(ret);	if (getsockopt(fake->rfcomm, SOL_SOCKET, SO_ERROR, &ret, &len) < 0) {		err = errno;		error("getsockopt(SO_ERROR): %s (%d)", strerror(err), err);		goto failed;	}	if (ret != 0) {		err = ret;		error("connect(): %s (%d)", strerror(err), err);		goto failed;	}	/*	 * FIXME: Some headsets required a sco connection	 * first to report volume gain key events	 */	fake->uinput = uinput_create(idev->name);	if (fake->uinput < 0) {		err = errno;		goto failed;	}	fake->io = g_io_channel_unix_new(fake->rfcomm);	g_io_channel_set_close_on_unref(fake->io, TRUE);	g_io_add_watch(fake->io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,						(GIOFunc) rfcomm_io_cb, fake);	/* Replying to the requestor */	reply = dbus_message_new_method_return(idev->pending_connect);	send_message_and_unref(idev->conn, reply);	/* Sending the Connected signal */	path = dbus_message_get_path(idev->pending_connect);	dbus_connection_emit_signal(idev->conn, path,			INPUT_DEVICE_INTERFACE, "Connected",			DBUS_TYPE_INVALID);	dbus_message_unref(idev->pending_connect);	idev->pending_connect = NULL;	return FALSE;failed:	error_connection_attempt_failed(idev->conn,			idev->pending_connect, err);	dbus_message_unref(idev->pending_connect);	idev->pending_connect = NULL;	g_io_channel_close(chan);	return FALSE;}static int rfcomm_connect(struct device *idev){	struct sockaddr_rc addr;	GIOChannel *io;	int sk, err;	sk = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);	if (sk < 0) {		err = errno;		error("socket: %s (%d)", strerror(err), err);		return -err;	}	memset(&addr, 0, sizeof(addr));	addr.rc_family = AF_BLUETOOTH;	bacpy(&addr.rc_bdaddr, &idev->src);	addr.rc_channel =  0;	if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {		err = errno;		error("bind: %s (%d)", strerror(err), err);		goto failed;	}	if (set_nonblocking(sk) < 0) {		err = errno;		error("Set non blocking: %s (%d)", strerror(err), err);		goto failed;	}	memset(&addr, 0, sizeof(addr));	addr.rc_family = AF_BLUETOOTH;	bacpy(&addr.rc_bdaddr, &idev->dst);	addr.rc_channel = idev->fake->ch;	io = g_io_channel_unix_new(sk);	g_io_channel_set_close_on_unref(io, FALSE);	if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {		char peer[18]; /* FIXME: debug purpose */		if (!(errno == EAGAIN || errno == EINPROGRESS)) {			err = errno;			error("connect() failed: %s (%d)",					strerror(err), err);			g_io_channel_unref(io);			goto failed;		}		ba2str(&idev->dst, peer);		debug("RFCOMM connection in progress: %s channel:%d", peer, idev->fake->ch);		g_io_add_watch(io, G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,				(GIOFunc) rfcomm_connect_cb, idev);	} else {		debug("Connect succeeded with first try");		rfcomm_connect_cb(io, G_IO_OUT, idev);	}	g_io_channel_unref(io);	return 0;failed:	close(sk);	errno = err;	return -err;}static gboolean intr_watch_cb(GIOChannel *chan, GIOCondition cond, gpointer data){	struct device *idev = data;	if (cond & (G_IO_HUP | G_IO_ERR))		g_io_channel_close(chan);	dbus_connection_emit_signal(idev->conn,			idev->path,			INPUT_DEVICE_INTERFACE,			"Disconnected",			DBUS_TYPE_INVALID);	g_source_remove(idev->ctrl_watch);	idev->ctrl_watch = 0;	idev->intr_watch = 0;	/* Close control channel */	if (idev->ctrl_sk > 0) {		close(idev->ctrl_sk);		idev->ctrl_sk = -1;	}	return FALSE;}static gboolean ctrl_watch_cb(GIOChannel *chan, GIOCondition cond, gpointer data){	struct device *idev = data;	if (cond & (G_IO_HUP | G_IO_ERR))		g_io_channel_close(chan);	dbus_connection_emit_signal(idev->conn,			idev->path,			INPUT_DEVICE_INTERFACE,			"Disconnected",			DBUS_TYPE_INVALID);	g_source_remove(idev->intr_watch);	idev->intr_watch = 0;	idev->ctrl_watch = 0;	/* Close interrupt channel */	if (idev->intr_sk > 0) {		close(idev->intr_sk);		idev->intr_sk = -1;	}	return FALSE;}static guint create_watch(int sk, GIOFunc cb, struct device *idev){	guint id;	GIOChannel *io;	io = g_io_channel_unix_new(sk);	id = g_io_add_watch(io, G_IO_HUP | G_IO_ERR | G_IO_NVAL, cb, idev);	g_io_channel_unref(io);	return id;}static int hidp_connadd(bdaddr_t *src, bdaddr_t *dst,		int ctrl_sk, int intr_sk, const char *name){	struct hidp_connadd_req req;	char addr[18];	int ctl, err, timeout = 30;	ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HIDP);	if (ctl < 0) {		error("Can't open HIDP interface");		return -errno;	}	ba2str(dst, addr);	memset(&req, 0, sizeof(req));	req.ctrl_sock = ctrl_sk;	req.intr_sock = intr_sk;	req.flags     = 0;	req.idle_to   = timeout * 60;	err = get_stored_device_info(src, dst, &req);	if (err < 0) {		error("Rejected connection from unknown device %s", addr);		goto cleanup;	}	if (req.subclass & 0x40) {		err = encrypt_link(src, dst);		if (err < 0 && err != -ENOKEY)			goto cleanup;	}	if (name)		strncpy(req.name, name, 128);	info("New input device %s (%s)", addr, req.name);	if (req.vendor == 0x054c && req.product == 0x0268) {		unsigned char buf[] = { 0x53, 0xf4,  0x42, 0x03, 0x00, 0x00 };		err = write(ctrl_sk, buf, sizeof(buf));	}	err = ioctl(ctl, HIDPCONNADD, &req);cleanup:	close(ctl);	if (req.rd_data)		free(req.rd_data);	return err;}static gboolean interrupt_connect_cb(GIOChannel *chan,			GIOCondition cond, struct device *idev){	int isk, ret, err;	socklen_t len;	isk = g_io_channel_unix_get_fd(chan);	if (cond & G_IO_NVAL) {		err = EHOSTDOWN;		isk = -1;		goto failed;	}	if (cond & (G_IO_HUP | G_IO_ERR)) {		err = EHOSTDOWN;		error("Hangup or error on HIDP interrupt socket");		goto failed;	}	len = sizeof(ret);	if (getsockopt(isk, SOL_SOCKET, SO_ERROR, &ret, &len) < 0) {		err = errno;		error("getsockopt(SO_ERROR): %s (%d)", strerror(err), err);		goto failed;	}	if (ret != 0) {		err = ret;		error("connect(): %s (%d)", strerror(ret), ret);		goto failed;	}	idev->intr_sk = isk;	err = hidp_connadd(&idev->src, &idev->dst,			idev->ctrl_sk, idev->intr_sk, idev->name);	if (err < 0)		goto failed;	idev->intr_watch = create_watch(idev->intr_sk, intr_watch_cb, idev);	idev->ctrl_watch = create_watch(idev->ctrl_sk, ctrl_watch_cb, idev);	dbus_connection_emit_signal(idev->conn,			idev->path,			INPUT_DEVICE_INTERFACE,