[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>

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

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