[GitHub/mt8127/android_kernel_alcatel_ttab.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>

/* ----- 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(hci_sk_list.lock)
};

/* 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 HCIGETCONNINFO:
		return hci_get_conn_info(hdev, (void __user *) arg);

	case HCIGETAUTHINFO:
		return hci_get_auth_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);

		data = &tv;
		len = sizeof(tv);
#ifdef CONFIG_COMPAT
		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);
		}
#endif

		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 (!test_bit(HCI_UP, &hdev->flags)) {
		err = -ENETDOWN;
		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 = 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 == 0x3f)) {
			skb_queue_tail(&hdev->raw_q, skb);
			tasklet_schedule(&hdev->tx_task);
		} else {
			skb_queue_tail(&hdev->cmd_q, skb);
			tasklet_schedule(&hdev->cmd_task);
		}
	} else {
		if (!capable(CAP_NET_RAW)) {
			err = -EPERM;
			goto drop;
		}

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

	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, unsigned 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 net *net, struct socket *sock, int protocol,
			   int kern)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

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

	sock->ops = &hci_sock_ops;

	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
	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 const 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;
}

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