[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / af_bluetooth.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 address family and sockets. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <net/sock.h>
#include <asm/ioctls.h>
#include <linux/kmod.h>

#include <net/bluetooth/bluetooth.h>

#define VERSION "2.14"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static struct net_proto_family *bt_proto[BT_MAX_PROTO];
static DEFINE_RWLOCK(bt_proto_lock);

#ifdef CONFIG_DEBUG_LOCK_ALLOC
static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
static const char *bt_key_strings[BT_MAX_PROTO] = {
	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
{
	struct sock *sk = sock->sk;

	if (!sk)
		return;

	BUG_ON(sock_owned_by_user(sk));

	sock_lock_init_class_and_name(sk,
			bt_slock_key_strings[proto], &bt_slock_key[proto],
				bt_key_strings[proto], &bt_lock_key[proto]);
}
#else
static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
{
}
#endif

int bt_sock_register(int proto, struct net_proto_family *ops)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (bt_proto[proto])
		err = -EEXIST;
	else
		bt_proto[proto] = ops;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_register);

int bt_sock_unregister(int proto)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (!bt_proto[proto])
		err = -ENOENT;
	else
		bt_proto[proto] = NULL;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct net *net, struct socket *sock, int proto)
{
	int err;

	if (net != &init_net)
		return -EAFNOSUPPORT;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	if (!bt_proto[proto])
		request_module("bt-proto-%d", proto);

	err = -EPROTONOSUPPORT;

	read_lock(&bt_proto_lock);

	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(net, sock, proto);
		bt_sock_reclassify_lock(sock, proto);
		module_put(bt_proto[proto]->owner);
	}

	read_unlock(&bt_proto_lock);

	return err;
}

void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_del_node_init(sk);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_unlink);

void bt_accept_enqueue(struct sock *parent, struct sock *sk)
{
	BT_DBG("parent %p, sk %p", parent, sk);

	sock_hold(sk);
	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	bt_sk(sk)->parent = parent;
	parent->sk_ack_backlog++;
}
EXPORT_SYMBOL(bt_accept_enqueue);

void bt_accept_unlink(struct sock *sk)
{
	BT_DBG("sk %p state %d", sk, sk->sk_state);

	list_del_init(&bt_sk(sk)->accept_q);
	bt_sk(sk)->parent->sk_ack_backlog--;
	bt_sk(sk)->parent = NULL;
	sock_put(sk);
}
EXPORT_SYMBOL(bt_accept_unlink);

struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
{
	struct list_head *p, *n;
	struct sock *sk;

	BT_DBG("parent %p", parent);

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);

		lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			release_sock(sk);
			bt_accept_unlink(sk);
			continue;
		}

		if (sk->sk_state == BT_CONNECTED || !newsock) {
			bt_accept_unlink(sk);
			if (newsock)
				sock_graft(sk, newsock);
			release_sock(sk);
			return sk;
		}

		release_sock(sk);
	}
	return NULL;
}
EXPORT_SYMBOL(bt_accept_dequeue);

int bt_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;
	size_t copied;
	int err;

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

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

	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
		if (sk->sk_shutdown & RCV_SHUTDOWN)
			return 0;
		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);
	if (err == 0)
		sock_recv_timestamp(msg, sk, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}
EXPORT_SYMBOL(bt_sock_recvmsg);

static inline unsigned int bt_accept_poll(struct sock *parent)
{
	struct list_head *p, *n;
	struct sock *sk;

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
		if (sk->sk_state == BT_CONNECTED)
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask = 0;

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

	poll_wait(file, sk->sk_sleep, wait);

	if (sk->sk_state == BT_LISTEN)
		return bt_accept_poll(sk);

	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
		mask |= POLLERR;

	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP;

	if (sk->sk_shutdown == SHUTDOWN_MASK)
		mask |= POLLHUP;

	if (!skb_queue_empty(&sk->sk_receive_queue) ||
			(sk->sk_shutdown & RCV_SHUTDOWN))
		mask |= POLLIN | POLLRDNORM;

	if (sk->sk_state == BT_CLOSED)
		mask |= POLLHUP;

	if (sk->sk_state == BT_CONNECT ||
			sk->sk_state == BT_CONNECT2 ||
			sk->sk_state == BT_CONFIG)
		return mask;

	if (sock_writeable(sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
	else
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

	return mask;
}
EXPORT_SYMBOL(bt_sock_poll);

int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	long amount;
	int err;

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

	switch (cmd) {
	case TIOCOUTQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
		if (amount < 0)
			amount = 0;
		err = put_user(amount, (int __user *) arg);
		break;

	case TIOCINQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		lock_sock(sk);
		skb = skb_peek(&sk->sk_receive_queue);
		amount = skb ? skb->len : 0;
		release_sock(sk);
		err = put_user(amount, (int __user *) arg);
		break;

	case SIOCGSTAMP:
		err = sock_get_timestamp(sk, (struct timeval __user *) arg);
		break;

	case SIOCGSTAMPNS:
		err = sock_get_timestampns(sk, (struct timespec __user *) arg);
		break;

	default:
		err = -ENOIOCTLCMD;
		break;
	}

	return err;
}
EXPORT_SYMBOL(bt_sock_ioctl);

int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
{
	DECLARE_WAITQUEUE(wait, current);
	int err = 0;

	BT_DBG("sk %p", sk);

	add_wait_queue(sk->sk_sleep, &wait);
	while (sk->sk_state != state) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!timeo) {
			err = -EINPROGRESS;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);

		err = sock_error(sk);
		if (err)
			break;
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(sk->sk_sleep, &wait);
	return err;
}
EXPORT_SYMBOL(bt_sock_wait_state);

static struct net_proto_family bt_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_BLUETOOTH,
	.create	= bt_sock_create,
};

static int __init bt_init(void)
{
	int err;

	BT_INFO("Core ver %s", VERSION);

	err = bt_sysfs_init();
	if (err < 0)
		return err;

	err = sock_register(&bt_sock_family_ops);
	if (err < 0) {
		bt_sysfs_cleanup();
		return err;
	}

	BT_INFO("HCI device and connection manager initialized");

	hci_sock_init();

	return 0;
}

static void __exit bt_exit(void)
{
	hci_sock_cleanup();

	sock_unregister(PF_BLUETOOTH);

	bt_sysfs_cleanup();
}

subsys_initcall(bt_init);
module_exit(bt_exit);

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
Commit	Line	Data
	1	/*
	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
	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
	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	19
	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/* Bluetooth address family and sockets. */
	26
	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
	30	#include <linux/list.h>
	31	#include <linux/errno.h>
	32	#include <linux/kernel.h>
	33	#include <linux/sched.h>
	34	#include <linux/slab.h>
	35	#include <linux/skbuff.h>
	36	#include <linux/init.h>
	37	#include <linux/poll.h>
	38	#include <net/sock.h>
	39	#include <asm/ioctls.h>
	40	#include <linux/kmod.h>
	41
	42	#include <net/bluetooth/bluetooth.h>
	43
	44	#define VERSION "2.14"
	45
	46	/* Bluetooth sockets */
	47	#define BT_MAX_PROTO 8
	48	static struct net_proto_family *bt_proto[BT_MAX_PROTO];
	49	static DEFINE_RWLOCK(bt_proto_lock);
	50
	51	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	52	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
	53	static const char *bt_key_strings[BT_MAX_PROTO] = {
	54	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	55	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	56	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	57	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	58	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	59	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	60	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	61	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
	62	};
	63
	64	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
	65	static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
	66	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	67	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	68	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	69	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	70	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	71	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	72	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	73	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
	74	};
	75
	76	static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
	77	{
	78	struct sock *sk = sock->sk;
	79
	80	if (!sk)
	81	return;
	82
	83	BUG_ON(sock_owned_by_user(sk));
	84
	85	sock_lock_init_class_and_name(sk,
	86	bt_slock_key_strings[proto], &bt_slock_key[proto],
	87	bt_key_strings[proto], &bt_lock_key[proto]);
	88	}
	89	#else
	90	static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
	91	{
	92	}
	93	#endif
	94
	95	int bt_sock_register(int proto, struct net_proto_family *ops)
	96	{
	97	int err = 0;
	98
	99	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	100	return -EINVAL;
	101
	102	write_lock(&bt_proto_lock);
	103
	104	if (bt_proto[proto])
	105	err = -EEXIST;
	106	else
	107	bt_proto[proto] = ops;
	108
	109	write_unlock(&bt_proto_lock);
	110
	111	return err;
	112	}
	113	EXPORT_SYMBOL(bt_sock_register);
	114
	115	int bt_sock_unregister(int proto)
	116	{
	117	int err = 0;
	118
	119	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	120	return -EINVAL;
	121
	122	write_lock(&bt_proto_lock);
	123
	124	if (!bt_proto[proto])
	125	err = -ENOENT;
	126	else
	127	bt_proto[proto] = NULL;
	128
	129	write_unlock(&bt_proto_lock);
	130
	131	return err;
	132	}
	133	EXPORT_SYMBOL(bt_sock_unregister);
	134
	135	static int bt_sock_create(struct net net, struct socket sock, int proto)
	136	{
	137	int err;
	138
	139	if (net != &init_net)
	140	return -EAFNOSUPPORT;
	141
	142	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	143	return -EINVAL;
	144
	145	if (!bt_proto[proto])
	146	request_module("bt-proto-%d", proto);
	147
	148	err = -EPROTONOSUPPORT;
	149
	150	read_lock(&bt_proto_lock);
	151
	152	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
	153	err = bt_proto[proto]->create(net, sock, proto);
	154	bt_sock_reclassify_lock(sock, proto);
	155	module_put(bt_proto[proto]->owner);
	156	}
	157
	158	read_unlock(&bt_proto_lock);
	159
	160	return err;
	161	}
	162
	163	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	164	{
	165	write_lock_bh(&l->lock);
	166	sk_add_node(sk, &l->head);
	167	write_unlock_bh(&l->lock);
	168	}
	169	EXPORT_SYMBOL(bt_sock_link);
	170
	171	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	172	{
	173	write_lock_bh(&l->lock);
	174	sk_del_node_init(sk);
	175	write_unlock_bh(&l->lock);
	176	}
	177	EXPORT_SYMBOL(bt_sock_unlink);
	178
	179	void bt_accept_enqueue(struct sock parent, struct sock sk)
	180	{
	181	BT_DBG("parent %p, sk %p", parent, sk);
	182
	183	sock_hold(sk);
	184	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	185	bt_sk(sk)->parent = parent;
	186	parent->sk_ack_backlog++;
	187	}
	188	EXPORT_SYMBOL(bt_accept_enqueue);
	189
	190	void bt_accept_unlink(struct sock *sk)
	191	{
	192	BT_DBG("sk %p state %d", sk, sk->sk_state);
	193
	194	list_del_init(&bt_sk(sk)->accept_q);
	195	bt_sk(sk)->parent->sk_ack_backlog--;
	196	bt_sk(sk)->parent = NULL;
	197	sock_put(sk);
	198	}
	199	EXPORT_SYMBOL(bt_accept_unlink);
	200
	201	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	202	{
	203	struct list_head p, n;
	204	struct sock *sk;
	205
	206	BT_DBG("parent %p", parent);
	207
	208	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	209	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	210
	211	lock_sock(sk);
	212
	213	/* FIXME: Is this check still needed */
	214	if (sk->sk_state == BT_CLOSED) {
	215	release_sock(sk);
	216	bt_accept_unlink(sk);
	217	continue;
	218	}
	219
	220	if (sk->sk_state == BT_CONNECTED \|\| !newsock) {
	221	bt_accept_unlink(sk);
	222	if (newsock)
	223	sock_graft(sk, newsock);
	224	release_sock(sk);
	225	return sk;
	226	}
	227
	228	release_sock(sk);
	229	}
	230	return NULL;
	231	}
	232	EXPORT_SYMBOL(bt_accept_dequeue);
	233
	234	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
	235	struct msghdr *msg, size_t len, int flags)
	236	{
	237	int noblock = flags & MSG_DONTWAIT;
	238	struct sock *sk = sock->sk;
	239	struct sk_buff *skb;
	240	size_t copied;
	241	int err;
	242
	243	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
	244
	245	if (flags & (MSG_OOB))
	246	return -EOPNOTSUPP;
	247
	248	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
	249	if (sk->sk_shutdown & RCV_SHUTDOWN)
	250	return 0;
	251	return err;
	252	}
	253
	254	msg->msg_namelen = 0;
	255
	256	copied = skb->len;
	257	if (len < copied) {
	258	msg->msg_flags \|= MSG_TRUNC;
	259	copied = len;
	260	}
	261
	262	skb_reset_transport_header(skb);
	263	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	264	if (err == 0)
	265	sock_recv_timestamp(msg, sk, skb);
	266
	267	skb_free_datagram(sk, skb);
	268
	269	return err ? : copied;
	270	}
	271	EXPORT_SYMBOL(bt_sock_recvmsg);
	272
	273	static inline unsigned int bt_accept_poll(struct sock *parent)
	274	{
	275	struct list_head p, n;
	276	struct sock *sk;
	277
	278	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	279	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	280	if (sk->sk_state == BT_CONNECTED)
	281	return POLLIN \| POLLRDNORM;
	282	}
	283
	284	return 0;
	285	}
	286
	287	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	288	{
	289	struct sock *sk = sock->sk;
	290	unsigned int mask = 0;
	291
	292	BT_DBG("sock %p, sk %p", sock, sk);
	293
	294	poll_wait(file, sk->sk_sleep, wait);
	295
	296	if (sk->sk_state == BT_LISTEN)
	297	return bt_accept_poll(sk);
	298
	299	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	300	mask \|= POLLERR;
	301
	302	if (sk->sk_shutdown & RCV_SHUTDOWN)
	303	mask \|= POLLRDHUP;
	304
	305	if (sk->sk_shutdown == SHUTDOWN_MASK)
	306	mask \|= POLLHUP;
	307
	308	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
	309	(sk->sk_shutdown & RCV_SHUTDOWN))
	310	mask \|= POLLIN \| POLLRDNORM;
	311
	312	if (sk->sk_state == BT_CLOSED)
	313	mask \|= POLLHUP;
	314
	315	if (sk->sk_state == BT_CONNECT \|\|
	316	sk->sk_state == BT_CONNECT2 \|\|
	317	sk->sk_state == BT_CONFIG)
	318	return mask;
	319
	320	if (sock_writeable(sk))
	321	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	322	else
	323	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	324
	325	return mask;
	326	}
	327	EXPORT_SYMBOL(bt_sock_poll);
	328
	329	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	330	{
	331	struct sock *sk = sock->sk;
	332	struct sk_buff *skb;
	333	long amount;
	334	int err;
	335
	336	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	337
	338	switch (cmd) {
	339	case TIOCOUTQ:
	340	if (sk->sk_state == BT_LISTEN)
	341	return -EINVAL;
	342
	343	amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
	344	if (amount < 0)
	345	amount = 0;
	346	err = put_user(amount, (int __user *) arg);
	347	break;
	348
	349	case TIOCINQ:
	350	if (sk->sk_state == BT_LISTEN)
	351	return -EINVAL;
	352
	353	lock_sock(sk);
	354	skb = skb_peek(&sk->sk_receive_queue);
	355	amount = skb ? skb->len : 0;
	356	release_sock(sk);
	357	err = put_user(amount, (int __user *) arg);
	358	break;
	359
	360	case SIOCGSTAMP:
	361	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	362	break;
	363
	364	case SIOCGSTAMPNS:
	365	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	366	break;
	367
	368	default:
	369	err = -ENOIOCTLCMD;
	370	break;
	371	}
	372
	373	return err;
	374	}
	375	EXPORT_SYMBOL(bt_sock_ioctl);
	376
	377	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	378	{
	379	DECLARE_WAITQUEUE(wait, current);
	380	int err = 0;
	381
	382	BT_DBG("sk %p", sk);
	383
	384	add_wait_queue(sk->sk_sleep, &wait);
	385	while (sk->sk_state != state) {
	386	set_current_state(TASK_INTERRUPTIBLE);
	387
	388	if (!timeo) {
	389	err = -EINPROGRESS;
	390	break;
	391	}
	392
	393	if (signal_pending(current)) {
	394	err = sock_intr_errno(timeo);
	395	break;
	396	}
	397
	398	release_sock(sk);
	399	timeo = schedule_timeout(timeo);
	400	lock_sock(sk);
	401
	402	err = sock_error(sk);
	403	if (err)
	404	break;
	405	}
	406	set_current_state(TASK_RUNNING);
	407	remove_wait_queue(sk->sk_sleep, &wait);
	408	return err;
	409	}
	410	EXPORT_SYMBOL(bt_sock_wait_state);
	411
	412	static struct net_proto_family bt_sock_family_ops = {
	413	.owner = THIS_MODULE,
	414	.family = PF_BLUETOOTH,
	415	.create = bt_sock_create,
	416	};
	417
	418	static int __init bt_init(void)
	419	{
	420	int err;
	421
	422	BT_INFO("Core ver %s", VERSION);
	423
	424	err = bt_sysfs_init();
	425	if (err < 0)
	426	return err;
	427
	428	err = sock_register(&bt_sock_family_ops);
	429	if (err < 0) {
	430	bt_sysfs_cleanup();
	431	return err;
	432	}
	433
	434	BT_INFO("HCI device and connection manager initialized");
	435
	436	hci_sock_init();
	437
	438	return 0;
	439	}
	440
	441	static void __exit bt_exit(void)
	442	{
	443	hci_sock_cleanup();
	444
	445	sock_unregister(PF_BLUETOOTH);
	446
	447	bt_sysfs_cleanup();
	448	}
	449
	450	subsys_initcall(bt_init);
	451	module_exit(bt_exit);
	452
	453	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	454	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	455	MODULE_VERSION(VERSION);
	456	MODULE_LICENSE("GPL");
	457	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);