[deliverable/linux.git] / net / bluetooth / hci_sock.c

/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth HCI sockets. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/compat.h>
#include <linux/socket.h>
#include <linux/ioctl.h>
#include <net/sock.h>

#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/unaligned.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

#ifndef CONFIG_BT_HCI_SOCK_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

/* ----- HCI socket interface ----- */

static inline int hci_test_bit(int nr, void *addr)
{
	return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
}

/* Security filter */
static struct hci_sec_filter hci_sec_filter = {
	/* Packet types */
	0x10,
	/* Events */
	{ 0x1000d9fe, 0x0000b00c },
	/* Commands */
	{
		{ 0x0 },
		/* OGF_LINK_CTL */
		{ 0xbe000006, 0x00000001, 0x00000000, 0x00 },
		/* OGF_LINK_POLICY */
		{ 0x00005200, 0x00000000, 0x00000000, 0x00 },
		/* OGF_HOST_CTL */
		{ 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
		/* OGF_INFO_PARAM */
		{ 0x000002be, 0x00000000, 0x00000000, 0x00 },
		/* OGF_STATUS_PARAM */
		{ 0x000000ea, 0x00000000, 0x00000000, 0x00 }
	}
};

static struct bt_sock_list hci_sk_list = {
	.lock = RW_LOCK_UNLOCKED
};

/* Send frame to RAW socket */
void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct sock *sk;
	struct hlist_node *node;

	BT_DBG("hdev %p len %d", hdev, skb->len);

	read_lock(&hci_sk_list.lock);
	sk_for_each(sk, node, &hci_sk_list.head) {
		struct hci_filter *flt;
		struct sk_buff *nskb;

		if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
			continue;

		/* Don't send frame to the socket it came from */
		if (skb->sk == sk)
			continue;

		/* Apply filter */
		flt = &hci_pi(sk)->filter;

		if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
				0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
			continue;

		if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
			register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);

			if (!hci_test_bit(evt, &flt->event_mask))
				continue;

			if (flt->opcode &&
			    ((evt == HCI_EV_CMD_COMPLETE &&
			      flt->opcode !=
			      get_unaligned((__le16 *)(skb->data + 3))) ||
			     (evt == HCI_EV_CMD_STATUS &&
			      flt->opcode !=
			      get_unaligned((__le16 *)(skb->data + 4)))))
				continue;
		}

		if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
			continue;

		/* Put type byte before the data */
		memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);

		if (sock_queue_rcv_skb(sk, nskb))
			kfree_skb(nskb);
	}
	read_unlock(&hci_sk_list.lock);
}

static int hci_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;
	struct hci_dev *hdev;

	BT_DBG("sock %p sk %p", sock, sk);

	if (!sk)
		return 0;

	hdev = hci_pi(sk)->hdev;

	bt_sock_unlink(&hci_sk_list, sk);

	if (hdev) {
		atomic_dec(&hdev->promisc);
		hci_dev_put(hdev);
	}

	sock_orphan(sk);

	skb_queue_purge(&sk->sk_receive_queue);
	skb_queue_purge(&sk->sk_write_queue);

	sock_put(sk);
	return 0;
}

/* Ioctls that require bound socket */
static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
{
	struct hci_dev *hdev = hci_pi(sk)->hdev;

	if (!hdev)
		return -EBADFD;

	switch (cmd) {
	case HCISETRAW:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;

		if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
			return -EPERM;

		if (arg)
			set_bit(HCI_RAW, &hdev->flags);
		else
			clear_bit(HCI_RAW, &hdev->flags);

		return 0;

	case HCISETSECMGR:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;

		if (arg)
			set_bit(HCI_SECMGR, &hdev->flags);
		else
			clear_bit(HCI_SECMGR, &hdev->flags);

		return 0;

	case HCIGETCONNINFO:
		return hci_get_conn_info(hdev, (void __user *)arg);

	default:
		if (hdev->ioctl)
			return hdev->ioctl(hdev, cmd, arg);
		return -EINVAL;
	}
}

static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	void __user *argp = (void __user *)arg;
	int err;

	BT_DBG("cmd %x arg %lx", cmd, arg);

	switch (cmd) {
	case HCIGETDEVLIST:
		return hci_get_dev_list(argp);

	case HCIGETDEVINFO:
		return hci_get_dev_info(argp);

	case HCIGETCONNLIST:
		return hci_get_conn_list(argp);

	case HCIDEVUP:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_open(arg);

	case HCIDEVDOWN:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_close(arg);

	case HCIDEVRESET:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_reset(arg);

	case HCIDEVRESTAT:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_reset_stat(arg);

	case HCISETSCAN:
	case HCISETAUTH:
	case HCISETENCRYPT:
	case HCISETPTYPE:
	case HCISETLINKPOL:
	case HCISETLINKMODE:
	case HCISETACLMTU:
	case HCISETSCOMTU:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_cmd(cmd, argp);

	case HCIINQUIRY:
		return hci_inquiry(argp);

	default:
		lock_sock(sk);
		err = hci_sock_bound_ioctl(sk, cmd, arg);
		release_sock(sk);
		return err;
	}
}

static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
	struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
	struct sock *sk = sock->sk;
	struct hci_dev *hdev = NULL;
	int err = 0;

	BT_DBG("sock %p sk %p", sock, sk);

	if (!haddr || haddr->hci_family != AF_BLUETOOTH)
		return -EINVAL;

	lock_sock(sk);

	if (hci_pi(sk)->hdev) {
		err = -EALREADY;
		goto done;
	}

	if (haddr->hci_dev != HCI_DEV_NONE) {
		if (!(hdev = hci_dev_get(haddr->hci_dev))) {
			err = -ENODEV;
			goto done;
		}

		atomic_inc(&hdev->promisc);
	}

	hci_pi(sk)->hdev = hdev;
	sk->sk_state = BT_BOUND;

done:
	release_sock(sk);
	return err;
}

static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
{
	struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
	struct sock *sk = sock->sk;
	struct hci_dev *hdev = hci_pi(sk)->hdev;

	BT_DBG("sock %p sk %p", sock, sk);

	if (!hdev)
		return -EBADFD;

	lock_sock(sk);

	*addr_len = sizeof(*haddr);
	haddr->hci_family = AF_BLUETOOTH;
	haddr->hci_dev    = hdev->id;

	release_sock(sk);
	return 0;
}

static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
{
	__u32 mask = hci_pi(sk)->cmsg_mask;

	if (mask & HCI_CMSG_DIR) {
		int incoming = bt_cb(skb)->incoming;
		put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
	}

	if (mask & HCI_CMSG_TSTAMP) {
		struct timeval tv;
		void *data;
		int len;

		skb_get_timestamp(skb, &tv);

		if (msg->msg_flags & MSG_CMSG_COMPAT) {
			struct compat_timeval ctv;
			ctv.tv_sec = tv.tv_sec;
			ctv.tv_usec = tv.tv_usec;
			data = &ctv;
			len = sizeof(ctv);
		} else {
			data = &tv;
			len = sizeof(tv);
		}

		put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
	}
}

static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	int copied, err;

	BT_DBG("sock %p, sk %p", sock, sk);

	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	if (sk->sk_state == BT_CLOSED)
		return 0;

	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
		return err;

	msg->msg_namelen = 0;

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	skb_reset_transport_header(skb);
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);

	hci_sock_cmsg(sk, msg, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}

static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
			    struct msghdr *msg, size_t len)
{
	struct sock *sk = sock->sk;
	struct hci_dev *hdev;
	struct sk_buff *skb;
	int err;

	BT_DBG("sock %p sk %p", sock, sk);

	if (msg->msg_flags & MSG_OOB)
		return -EOPNOTSUPP;

	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
		return -EINVAL;

	if (len < 4 || len > HCI_MAX_FRAME_SIZE)
		return -EINVAL;

	lock_sock(sk);

	if (!(hdev = hci_pi(sk)->hdev)) {
		err = -EBADFD;
		goto done;
	}

	if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
		goto done;

	if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
		err = -EFAULT;
		goto drop;
	}

	bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
	skb_pull(skb, 1);
	skb->dev = (void *) hdev;

	if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
		u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data));
		u16 ogf = hci_opcode_ogf(opcode);
		u16 ocf = hci_opcode_ocf(opcode);

		if (((ogf > HCI_SFLT_MAX_OGF) ||
				!hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
					!capable(CAP_NET_RAW)) {
			err = -EPERM;
			goto drop;
		}

		if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
			skb_queue_tail(&hdev->raw_q, skb);
			hci_sched_tx(hdev);
		} else {
			skb_queue_tail(&hdev->cmd_q, skb);
			hci_sched_cmd(hdev);
		}
	} else {
		if (!capable(CAP_NET_RAW)) {
			err = -EPERM;
			goto drop;
		}

		skb_queue_tail(&hdev->raw_q, skb);
		hci_sched_tx(hdev);
	}

	err = len;

done:
	release_sock(sk);
	return err;

drop:
	kfree_skb(skb);
	goto done;
}

static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
{
	struct hci_ufilter uf = { .opcode = 0 };
	struct sock *sk = sock->sk;
	int err = 0, opt = 0;

	BT_DBG("sk %p, opt %d", sk, optname);

	lock_sock(sk);

	switch (optname) {
	case HCI_DATA_DIR:
		if (get_user(opt, (int __user *)optval)) {
			err = -EFAULT;
			break;
		}

		if (opt)
			hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
		else
			hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
		break;

	case HCI_TIME_STAMP:
		if (get_user(opt, (int __user *)optval)) {
			err = -EFAULT;
			break;
		}

		if (opt)
			hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
		else
			hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
		break;

	case HCI_FILTER:
		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			uf.type_mask = f->type_mask;
			uf.opcode    = f->opcode;
			uf.event_mask[0] = *((u32 *) f->event_mask + 0);
			uf.event_mask[1] = *((u32 *) f->event_mask + 1);
		}

		len = min_t(unsigned int, len, sizeof(uf));
		if (copy_from_user(&uf, optval, len)) {
			err = -EFAULT;
			break;
		}

		if (!capable(CAP_NET_RAW)) {
			uf.type_mask &= hci_sec_filter.type_mask;
			uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
			uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
		}

		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			f->type_mask = uf.type_mask;
			f->opcode    = uf.opcode;
			*((u32 *) f->event_mask + 0) = uf.event_mask[0];
			*((u32 *) f->event_mask + 1) = uf.event_mask[1];
		}
		break;

	default:
		err = -ENOPROTOOPT;
		break;
	}

	release_sock(sk);
	return err;
}

static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
{
	struct hci_ufilter uf;
	struct sock *sk = sock->sk;
	int len, opt;

	if (get_user(len, optlen))
		return -EFAULT;

	switch (optname) {
	case HCI_DATA_DIR:
		if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
			opt = 1;
		else
			opt = 0;

		if (put_user(opt, optval))
			return -EFAULT;
		break;

	case HCI_TIME_STAMP:
		if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
			opt = 1;
		else
			opt = 0;

		if (put_user(opt, optval))
			return -EFAULT;
		break;

	case HCI_FILTER:
		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			uf.type_mask = f->type_mask;
			uf.opcode    = f->opcode;
			uf.event_mask[0] = *((u32 *) f->event_mask + 0);
			uf.event_mask[1] = *((u32 *) f->event_mask + 1);
		}

		len = min_t(unsigned int, len, sizeof(uf));
		if (copy_to_user(optval, &uf, len))
			return -EFAULT;
		break;

	default:
		return -ENOPROTOOPT;
		break;
	}

	return 0;
}

static const struct proto_ops hci_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= hci_sock_release,
	.bind		= hci_sock_bind,
	.getname	= hci_sock_getname,
	.sendmsg	= hci_sock_sendmsg,
	.recvmsg	= hci_sock_recvmsg,
	.ioctl		= hci_sock_ioctl,
	.poll		= datagram_poll,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= hci_sock_setsockopt,
	.getsockopt	= hci_sock_getsockopt,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.mmap		= sock_no_mmap
};

static struct proto hci_sk_proto = {
	.name		= "HCI",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct hci_pinfo)
};

static int hci_sock_create(struct socket *sock, int protocol)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

	if (sock->type != SOCK_RAW)
		return -ESOCKTNOSUPPORT;

	sock->ops = &hci_sock_ops;

	sk = sk_alloc(PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto, 1);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = protocol;

	sock->state = SS_UNCONNECTED;
	sk->sk_state = BT_OPEN;

	bt_sock_link(&hci_sk_list, sk);
	return 0;
}

static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct hci_dev *hdev = (struct hci_dev *) ptr;
	struct hci_ev_si_device ev;

	BT_DBG("hdev %s event %ld", hdev->name, event);

	/* Send event to sockets */
	ev.event  = event;
	ev.dev_id = hdev->id;
	hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);

	if (event == HCI_DEV_UNREG) {
		struct sock *sk;
		struct hlist_node *node;

		/* Detach sockets from device */
		read_lock(&hci_sk_list.lock);
		sk_for_each(sk, node, &hci_sk_list.head) {
			local_bh_disable();
			bh_lock_sock_nested(sk);
			if (hci_pi(sk)->hdev == hdev) {
				hci_pi(sk)->hdev = NULL;
				sk->sk_err = EPIPE;
				sk->sk_state = BT_OPEN;
				sk->sk_state_change(sk);

				hci_dev_put(hdev);
			}
			bh_unlock_sock(sk);
			local_bh_enable();
		}
		read_unlock(&hci_sk_list.lock);
	}

	return NOTIFY_DONE;
}

static struct net_proto_family hci_sock_family_ops = {
	.family	= PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create	= hci_sock_create,
};

static struct notifier_block hci_sock_nblock = {
	.notifier_call = hci_sock_dev_event
};

int __init hci_sock_init(void)
{
	int err;

	err = proto_register(&hci_sk_proto, 0);
	if (err < 0)
		return err;

	err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
	if (err < 0)
		goto error;

	hci_register_notifier(&hci_sock_nblock);

	BT_INFO("HCI socket layer initialized");

	return 0;

error:
	BT_ERR("HCI socket registration failed");
	proto_unregister(&hci_sk_proto);
	return err;
}

int __exit hci_sock_cleanup(void)
{
	if (bt_sock_unregister(BTPROTO_HCI) < 0)
		BT_ERR("HCI socket unregistration failed");

	hci_unregister_notifier(&hci_sock_nblock);

	proto_unregister(&hci_sk_proto);

	return 0;
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	BlueZ - Bluetooth protocol stack for Linux
	3	Copyright (C) 2000-2001 Qualcomm Incorporated
	4
	5	Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License version 2 as
	9	published by the Free Software Foundation;
	10
	11	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	12	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	13	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	14	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	15	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	16	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	17	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	19
8e87d142 YH	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/* Bluetooth HCI sockets. */
	26
1da177e4 LT	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
4fc268d2	30	#include <linux/capability.h>
1da177e4 LT	31	#include <linux/errno.h>
1da177e4 LT	32	#include <linux/kernel.h>
1da177e4 LT	33	#include <linux/slab.h>
	34	#include <linux/poll.h>
	35	#include <linux/fcntl.h>
	36	#include <linux/init.h>
	37	#include <linux/skbuff.h>
	38	#include <linux/workqueue.h>
	39	#include <linux/interrupt.h>
767c5eb5	40	#include <linux/compat.h>
1da177e4 LT	41	#include <linux/socket.h>
	42	#include <linux/ioctl.h>
	43	#include <net/sock.h>
	44
	45	#include <asm/system.h>
	46	#include <asm/uaccess.h>
	47	#include <asm/unaligned.h>
	48
	49	#include <net/bluetooth/bluetooth.h>
	50	#include <net/bluetooth/hci_core.h>
	51
	52	#ifndef CONFIG_BT_HCI_SOCK_DEBUG
	53	#undef BT_DBG
	54	#define BT_DBG(D...)
	55	#endif
	56
	57	/* ----- HCI socket interface ----- */
	58
	59	static inline int hci_test_bit(int nr, void *addr)
	60	{
	61	return ((__u32 ) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
	62	}
	63
	64	/* Security filter */
	65	static struct hci_sec_filter hci_sec_filter = {
	66	/* Packet types */
	67	0x10,
	68	/* Events */
dd7f5527	69	{ 0x1000d9fe, 0x0000b00c },
1da177e4 LT	70	/* Commands */
	71	{
	72	{ 0x0 },
	73	/* OGF_LINK_CTL */
7c631a67	74	{ 0xbe000006, 0x00000001, 0x00000000, 0x00 },
1da177e4	75	/* OGF_LINK_POLICY */
7c631a67	76	{ 0x00005200, 0x00000000, 0x00000000, 0x00 },
1da177e4	77	/* OGF_HOST_CTL */
7c631a67	78	{ 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
1da177e4	79	/* OGF_INFO_PARAM */
7c631a67	80	{ 0x000002be, 0x00000000, 0x00000000, 0x00 },
1da177e4	81	/* OGF_STATUS_PARAM */
7c631a67	82	{ 0x000000ea, 0x00000000, 0x00000000, 0x00 }
1da177e4 LT	83	}
	84	};
	85
	86	static struct bt_sock_list hci_sk_list = {
	87	.lock = RW_LOCK_UNLOCKED
	88	};
	89
	90	/* Send frame to RAW socket */
	91	void hci_send_to_sock(struct hci_dev hdev, struct sk_buff skb)
	92	{
	93	struct sock *sk;
	94	struct hlist_node *node;
	95
	96	BT_DBG("hdev %p len %d", hdev, skb->len);
	97
	98	read_lock(&hci_sk_list.lock);
	99	sk_for_each(sk, node, &hci_sk_list.head) {
	100	struct hci_filter *flt;
	101	struct sk_buff *nskb;
	102
	103	if (sk->sk_state != BT_BOUND \|\| hci_pi(sk)->hdev != hdev)
	104	continue;
	105
	106	/* Don't send frame to the socket it came from */
	107	if (skb->sk == sk)
	108	continue;
	109
	110	/* Apply filter */
	111	flt = &hci_pi(sk)->filter;
	112
0d48d939 MH	113	if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
0d48d939 MH	114	0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
1da177e4 LT	115	continue;
1da177e4 LT	116
0d48d939	117	if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
1da177e4 LT	118	register int evt = ((__u8 )skb->data & HCI_FLT_EVENT_BITS);
	119
	120	if (!hci_test_bit(evt, &flt->event_mask))
	121	continue;
	122
4498c80d DM	123	if (flt->opcode &&
	124	((evt == HCI_EV_CMD_COMPLETE &&
	125	flt->opcode !=
905f3ed6	126	get_unaligned((__le16 *)(skb->data + 3))) \|\|
4498c80d DM	127	(evt == HCI_EV_CMD_STATUS &&
4498c80d DM	128	flt->opcode !=
905f3ed6	129	get_unaligned((__le16 *)(skb->data + 4)))))
1da177e4 LT	130	continue;
	131	}
	132
	133	if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
	134	continue;
	135
	136	/* Put type byte before the data */
0d48d939	137	memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
1da177e4 LT	138
	139	if (sock_queue_rcv_skb(sk, nskb))
	140	kfree_skb(nskb);
	141	}
	142	read_unlock(&hci_sk_list.lock);
	143	}
	144
	145	static int hci_sock_release(struct socket *sock)
	146	{
	147	struct sock *sk = sock->sk;
7b005bd3	148	struct hci_dev *hdev;
1da177e4 LT	149
	150	BT_DBG("sock %p sk %p", sock, sk);
	151
	152	if (!sk)
	153	return 0;
	154
7b005bd3 MH	155	hdev = hci_pi(sk)->hdev;
7b005bd3 MH	156
1da177e4 LT	157	bt_sock_unlink(&hci_sk_list, sk);
	158
	159	if (hdev) {
	160	atomic_dec(&hdev->promisc);
	161	hci_dev_put(hdev);
	162	}
	163
	164	sock_orphan(sk);
	165
	166	skb_queue_purge(&sk->sk_receive_queue);
	167	skb_queue_purge(&sk->sk_write_queue);
	168
	169	sock_put(sk);
	170	return 0;
	171	}
	172
8e87d142	173	/* Ioctls that require bound socket */
1da177e4 LT	174	static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
	175	{
	176	struct hci_dev *hdev = hci_pi(sk)->hdev;
	177
	178	if (!hdev)
	179	return -EBADFD;
	180
	181	switch (cmd) {
	182	case HCISETRAW:
	183	if (!capable(CAP_NET_ADMIN))
	184	return -EACCES;
	185
	186	if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
	187	return -EPERM;
	188
	189	if (arg)
	190	set_bit(HCI_RAW, &hdev->flags);
	191	else
	192	clear_bit(HCI_RAW, &hdev->flags);
	193
	194	return 0;
	195
	196	case HCISETSECMGR:
	197	if (!capable(CAP_NET_ADMIN))
	198	return -EACCES;
	199
	200	if (arg)
	201	set_bit(HCI_SECMGR, &hdev->flags);
	202	else
	203	clear_bit(HCI_SECMGR, &hdev->flags);
	204
	205	return 0;
	206
	207	case HCIGETCONNINFO:
	208	return hci_get_conn_info(hdev, (void __user *)arg);
	209
	210	default:
	211	if (hdev->ioctl)
	212	return hdev->ioctl(hdev, cmd, arg);
	213	return -EINVAL;
	214	}
	215	}
	216
	217	static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	218	{
	219	struct sock *sk = sock->sk;
	220	void __user argp = (void __user )arg;
	221	int err;
	222
	223	BT_DBG("cmd %x arg %lx", cmd, arg);
	224
	225	switch (cmd) {
	226	case HCIGETDEVLIST:
	227	return hci_get_dev_list(argp);
	228
	229	case HCIGETDEVINFO:
	230	return hci_get_dev_info(argp);
	231
	232	case HCIGETCONNLIST:
	233	return hci_get_conn_list(argp);
	234
	235	case HCIDEVUP:
	236	if (!capable(CAP_NET_ADMIN))
	237	return -EACCES;
238	return hci_dev_open(arg);
239
240	case HCIDEVDOWN:
241	if (!capable(CAP_NET_ADMIN))
242	return -EACCES;
243	return hci_dev_close(arg);
244
245	case HCIDEVRESET:
246	if (!capable(CAP_NET_ADMIN))
247	return -EACCES;
248	return hci_dev_reset(arg);
249
250	case HCIDEVRESTAT:
251	if (!capable(CAP_NET_ADMIN))
252	return -EACCES;
253	return hci_dev_reset_stat(arg);
254
255	case HCISETSCAN:
256	case HCISETAUTH:
257	case HCISETENCRYPT:
258	case HCISETPTYPE:
259	case HCISETLINKPOL:
260	case HCISETLINKMODE:
261	case HCISETACLMTU:
262	case HCISETSCOMTU:
263	if (!capable(CAP_NET_ADMIN))
264	return -EACCES;
265	return hci_dev_cmd(cmd, argp);
266
267	case HCIINQUIRY:
268	return hci_inquiry(argp);
269
270	default:
271	lock_sock(sk);
272	err = hci_sock_bound_ioctl(sk, cmd, arg);
273	release_sock(sk);
274	return err;
275	}
276	}
277
278	static int hci_sock_bind(struct socket sock, struct sockaddr addr, int addr_len)
279	{
280	struct sockaddr_hci haddr = (struct sockaddr_hci ) addr;
281	struct sock *sk = sock->sk;
282	struct hci_dev *hdev = NULL;
283	int err = 0;
284
285	BT_DBG("sock %p sk %p", sock, sk);
286
287	if (!haddr \|\| haddr->hci_family != AF_BLUETOOTH)
288	return -EINVAL;
289
290	lock_sock(sk);
291
292	if (hci_pi(sk)->hdev) {
293	err = -EALREADY;
294	goto done;
295	}
296
297	if (haddr->hci_dev != HCI_DEV_NONE) {
298	if (!(hdev = hci_dev_get(haddr->hci_dev))) {
299	err = -ENODEV;
300	goto done;
301	}
302
303	atomic_inc(&hdev->promisc);
304	}
305
306	hci_pi(sk)->hdev = hdev;
307	sk->sk_state = BT_BOUND;
308
309	done:
310	release_sock(sk);
311	return err;
312	}
313
314	static int hci_sock_getname(struct socket sock, struct sockaddr addr, int *addr_len, int peer)
315	{
316	struct sockaddr_hci haddr = (struct sockaddr_hci ) addr;
317	struct sock *sk = sock->sk;
7b005bd3	318	struct hci_dev *hdev = hci_pi(sk)->hdev;
1da177e4 LT	319
	320	BT_DBG("sock %p sk %p", sock, sk);
	321
7b005bd3 MH	322	if (!hdev)
	323	return -EBADFD;
	324
1da177e4 LT	325	lock_sock(sk);
	326
	327	addr_len = sizeof(haddr);
	328	haddr->hci_family = AF_BLUETOOTH;
7b005bd3	329	haddr->hci_dev = hdev->id;
1da177e4 LT	330
	331	release_sock(sk);
	332	return 0;
	333	}
	334
	335	static inline void hci_sock_cmsg(struct sock sk, struct msghdr msg, struct sk_buff *skb)
	336	{
	337	__u32 mask = hci_pi(sk)->cmsg_mask;
	338
0d48d939 MH	339	if (mask & HCI_CMSG_DIR) {
	340	int incoming = bt_cb(skb)->incoming;
	341	put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
	342	}
1da177e4	343
a61bbcf2 PM	344	if (mask & HCI_CMSG_TSTAMP) {
a61bbcf2 PM	345	struct timeval tv;
767c5eb5 MH	346	void *data;
767c5eb5 MH	347	int len;
a61bbcf2 PM	348
a61bbcf2 PM	349	skb_get_timestamp(skb, &tv);
767c5eb5 MH	350
	351	if (msg->msg_flags & MSG_CMSG_COMPAT) {
	352	struct compat_timeval ctv;
	353	ctv.tv_sec = tv.tv_sec;
	354	ctv.tv_usec = tv.tv_usec;
	355	data = &ctv;
	356	len = sizeof(ctv);
	357	} else {
	358	data = &tv;
	359	len = sizeof(tv);
	360	}
	361
	362	put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
a61bbcf2	363	}
1da177e4	364	}
8e87d142 YH	365
8e87d142 YH	366	static int hci_sock_recvmsg(struct kiocb iocb, struct socket sock,
1da177e4 LT	367	struct msghdr *msg, size_t len, int flags)
	368	{
	369	int noblock = flags & MSG_DONTWAIT;
	370	struct sock *sk = sock->sk;
	371	struct sk_buff *skb;
	372	int copied, err;
	373
	374	BT_DBG("sock %p, sk %p", sock, sk);
	375
	376	if (flags & (MSG_OOB))
	377	return -EOPNOTSUPP;
	378
	379	if (sk->sk_state == BT_CLOSED)
	380	return 0;
	381
	382	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
	383	return err;
	384
	385	msg->msg_namelen = 0;
	386
	387	copied = skb->len;
	388	if (len < copied) {
	389	msg->msg_flags \|= MSG_TRUNC;
	390	copied = len;
	391	}
	392
badff6d0	393	skb_reset_transport_header(skb);
1da177e4 LT	394	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	395
	396	hci_sock_cmsg(sk, msg, skb);
	397
	398	skb_free_datagram(sk, skb);
	399
	400	return err ? : copied;
	401	}
	402
8e87d142	403	static int hci_sock_sendmsg(struct kiocb iocb, struct socket sock,
1da177e4 LT	404	struct msghdr *msg, size_t len)
	405	{
	406	struct sock *sk = sock->sk;
	407	struct hci_dev *hdev;
	408	struct sk_buff *skb;
	409	int err;
	410
	411	BT_DBG("sock %p sk %p", sock, sk);
	412
	413	if (msg->msg_flags & MSG_OOB)
	414	return -EOPNOTSUPP;
	415
	416	if (msg->msg_flags & ~(MSG_DONTWAIT\|MSG_NOSIGNAL\|MSG_ERRQUEUE))
	417	return -EINVAL;
	418
	419	if (len < 4 \|\| len > HCI_MAX_FRAME_SIZE)
	420	return -EINVAL;
	421
	422	lock_sock(sk);
	423
	424	if (!(hdev = hci_pi(sk)->hdev)) {
	425	err = -EBADFD;
	426	goto done;
	427	}
	428
	429	if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
	430	goto done;
	431
	432	if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
	433	err = -EFAULT;
	434	goto drop;
	435	}
	436
0d48d939	437	bt_cb(skb)->pkt_type = ((unsigned char ) skb->data);
1da177e4 LT	438	skb_pull(skb, 1);
	439	skb->dev = (void *) hdev;
	440
0d48d939	441	if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
1ebb9252	442	u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data));
1da177e4 LT	443	u16 ogf = hci_opcode_ogf(opcode);
	444	u16 ocf = hci_opcode_ocf(opcode);
	445
	446	if (((ogf > HCI_SFLT_MAX_OGF) \|\|
	447	!hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
	448	!capable(CAP_NET_RAW)) {
	449	err = -EPERM;
	450	goto drop;
	451	}
	452
	453	if (test_bit(HCI_RAW, &hdev->flags) \|\| (ogf == OGF_VENDOR_CMD)) {
	454	skb_queue_tail(&hdev->raw_q, skb);
	455	hci_sched_tx(hdev);
	456	} else {
	457	skb_queue_tail(&hdev->cmd_q, skb);
	458	hci_sched_cmd(hdev);
	459	}
	460	} else {
	461	if (!capable(CAP_NET_RAW)) {
	462	err = -EPERM;
	463	goto drop;
	464	}
	465
	466	skb_queue_tail(&hdev->raw_q, skb);
	467	hci_sched_tx(hdev);
	468	}
	469
	470	err = len;
	471
	472	done:
	473	release_sock(sk);
	474	return err;
	475
	476	drop:
	477	kfree_skb(skb);
	478	goto done;
	479	}
	480
	481	static int hci_sock_setsockopt(struct socket sock, int level, int optname, char __user optval, int len)
	482	{
	483	struct hci_ufilter uf = { .opcode = 0 };
	484	struct sock *sk = sock->sk;
	485	int err = 0, opt = 0;
	486
	487	BT_DBG("sk %p, opt %d", sk, optname);
	488
	489	lock_sock(sk);
	490
	491	switch (optname) {
	492	case HCI_DATA_DIR:
	493	if (get_user(opt, (int __user *)optval)) {
	494	err = -EFAULT;
	495	break;
	496	}
	497
	498	if (opt)
	499	hci_pi(sk)->cmsg_mask \|= HCI_CMSG_DIR;
	500	else
	501	hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
	502	break;
	503
	504	case HCI_TIME_STAMP:
	505	if (get_user(opt, (int __user *)optval)) {
	506	err = -EFAULT;
507	break;
508	}
509
510	if (opt)
511	hci_pi(sk)->cmsg_mask \|= HCI_CMSG_TSTAMP;
512	else
513	hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
514	break;
515
516	case HCI_FILTER:
0878b666 MH	517	{
	518	struct hci_filter *f = &hci_pi(sk)->filter;
	519
	520	uf.type_mask = f->type_mask;
	521	uf.opcode = f->opcode;
	522	uf.event_mask[0] = ((u32 ) f->event_mask + 0);
	523	uf.event_mask[1] = ((u32 ) f->event_mask + 1);
	524	}
	525
1da177e4 LT	526	len = min_t(unsigned int, len, sizeof(uf));
	527	if (copy_from_user(&uf, optval, len)) {
	528	err = -EFAULT;
	529	break;
	530	}
	531
	532	if (!capable(CAP_NET_RAW)) {
	533	uf.type_mask &= hci_sec_filter.type_mask;
	534	uf.event_mask[0] &= ((u32 ) hci_sec_filter.event_mask + 0);
	535	uf.event_mask[1] &= ((u32 ) hci_sec_filter.event_mask + 1);
	536	}
	537
	538	{
	539	struct hci_filter *f = &hci_pi(sk)->filter;
	540
	541	f->type_mask = uf.type_mask;
	542	f->opcode = uf.opcode;
	543	((u32 ) f->event_mask + 0) = uf.event_mask[0];
	544	((u32 ) f->event_mask + 1) = uf.event_mask[1];
	545	}
8e87d142	546	break;
1da177e4 LT	547
	548	default:
	549	err = -ENOPROTOOPT;
	550	break;
	551	}
	552
	553	release_sock(sk);
	554	return err;
	555	}
	556
	557	static int hci_sock_getsockopt(struct socket sock, int level, int optname, char __user optval, int __user *optlen)
	558	{
	559	struct hci_ufilter uf;
	560	struct sock *sk = sock->sk;
8e87d142	561	int len, opt;
1da177e4 LT	562
	563	if (get_user(len, optlen))
	564	return -EFAULT;
	565
	566	switch (optname) {
	567	case HCI_DATA_DIR:
	568	if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
	569	opt = 1;
8e87d142	570	else
1da177e4 LT	571	opt = 0;
	572
	573	if (put_user(opt, optval))
	574	return -EFAULT;
	575	break;
	576
	577	case HCI_TIME_STAMP:
	578	if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
	579	opt = 1;
8e87d142	580	else
1da177e4 LT	581	opt = 0;
	582
	583	if (put_user(opt, optval))
	584	return -EFAULT;
	585	break;
	586
	587	case HCI_FILTER:
	588	{
	589	struct hci_filter *f = &hci_pi(sk)->filter;
	590
	591	uf.type_mask = f->type_mask;
	592	uf.opcode = f->opcode;
	593	uf.event_mask[0] = ((u32 ) f->event_mask + 0);
	594	uf.event_mask[1] = ((u32 ) f->event_mask + 1);
	595	}
	596
	597	len = min_t(unsigned int, len, sizeof(uf));
	598	if (copy_to_user(optval, &uf, len))
	599	return -EFAULT;
	600	break;
	601
	602	default:
	603	return -ENOPROTOOPT;
	604	break;
	605	}
	606
	607	return 0;
	608	}
	609
90ddc4f0	610	static const struct proto_ops hci_sock_ops = {
1da177e4 LT	611	.family = PF_BLUETOOTH,
	612	.owner = THIS_MODULE,
	613	.release = hci_sock_release,
	614	.bind = hci_sock_bind,
	615	.getname = hci_sock_getname,
	616	.sendmsg = hci_sock_sendmsg,
	617	.recvmsg = hci_sock_recvmsg,
	618	.ioctl = hci_sock_ioctl,
	619	.poll = datagram_poll,
	620	.listen = sock_no_listen,
	621	.shutdown = sock_no_shutdown,
	622	.setsockopt = hci_sock_setsockopt,
	623	.getsockopt = hci_sock_getsockopt,
	624	.connect = sock_no_connect,
	625	.socketpair = sock_no_socketpair,
	626	.accept = sock_no_accept,
	627	.mmap = sock_no_mmap
	628	};
	629
	630	static struct proto hci_sk_proto = {
	631	.name = "HCI",
	632	.owner = THIS_MODULE,
	633	.obj_size = sizeof(struct hci_pinfo)
	634	};
	635
	636	static int hci_sock_create(struct socket *sock, int protocol)
	637	{
	638	struct sock *sk;
	639
	640	BT_DBG("sock %p", sock);
	641
	642	if (sock->type != SOCK_RAW)
	643	return -ESOCKTNOSUPPORT;
	644
	645	sock->ops = &hci_sock_ops;
	646
74da626a	647	sk = sk_alloc(PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto, 1);
1da177e4 LT	648	if (!sk)
	649	return -ENOMEM;
	650
	651	sock_init_data(sock, sk);
	652
	653	sock_reset_flag(sk, SOCK_ZAPPED);
	654
	655	sk->sk_protocol = protocol;
	656
	657	sock->state = SS_UNCONNECTED;
	658	sk->sk_state = BT_OPEN;
	659
	660	bt_sock_link(&hci_sk_list, sk);
	661	return 0;
	662	}
	663
	664	static int hci_sock_dev_event(struct notifier_block this, unsigned long event, void ptr)
	665	{
	666	struct hci_dev hdev = (struct hci_dev ) ptr;
	667	struct hci_ev_si_device ev;
	668
	669	BT_DBG("hdev %s event %ld", hdev->name, event);
	670
	671	/* Send event to sockets */
	672	ev.event = event;
	673	ev.dev_id = hdev->id;
	674	hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
	675
	676	if (event == HCI_DEV_UNREG) {
	677	struct sock *sk;
	678	struct hlist_node *node;
	679
	680	/* Detach sockets from device */
	681	read_lock(&hci_sk_list.lock);
	682	sk_for_each(sk, node, &hci_sk_list.head) {
4ce61d1c SS	683	local_bh_disable();
4ce61d1c SS	684	bh_lock_sock_nested(sk);
1da177e4 LT	685	if (hci_pi(sk)->hdev == hdev) {
	686	hci_pi(sk)->hdev = NULL;
	687	sk->sk_err = EPIPE;
	688	sk->sk_state = BT_OPEN;
	689	sk->sk_state_change(sk);
	690
	691	hci_dev_put(hdev);
	692	}
4ce61d1c SS	693	bh_unlock_sock(sk);
4ce61d1c SS	694	local_bh_enable();
1da177e4 LT	695	}
	696	read_unlock(&hci_sk_list.lock);
	697	}
	698
	699	return NOTIFY_DONE;
	700	}
	701
	702	static struct net_proto_family hci_sock_family_ops = {
	703	.family = PF_BLUETOOTH,
	704	.owner = THIS_MODULE,
	705	.create = hci_sock_create,
	706	};
	707
	708	static struct notifier_block hci_sock_nblock = {
	709	.notifier_call = hci_sock_dev_event
	710	};
	711
	712	int __init hci_sock_init(void)
	713	{
	714	int err;
	715
	716	err = proto_register(&hci_sk_proto, 0);
	717	if (err < 0)
	718	return err;
	719
	720	err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
	721	if (err < 0)
	722	goto error;
	723
	724	hci_register_notifier(&hci_sock_nblock);
	725
	726	BT_INFO("HCI socket layer initialized");
	727
	728	return 0;
	729
	730	error:
	731	BT_ERR("HCI socket registration failed");
	732	proto_unregister(&hci_sk_proto);
	733	return err;
	734	}
	735
	736	int __exit hci_sock_cleanup(void)
	737	{
	738	if (bt_sock_unregister(BTPROTO_HCI) < 0)
	739	BT_ERR("HCI socket unregistration failed");
	740
	741	hci_unregister_notifier(&hci_sock_nblock);
	742
	743	proto_unregister(&hci_sk_proto);
	744
	745	return 0;
	746	}