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

#if defined(CONFIG_KMOD)
#include <linux/kmod.h>
#endif

#include <net/bluetooth/bluetooth.h>

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

#define VERSION "2.13"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static struct net_proto_family *bt_proto[BT_MAX_PROTO];

static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
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 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 DEFINE_RWLOCK(bt_proto_lock);

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 void bt_reclassify_sock_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]);
}

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 defined(CONFIG_KMOD)
	if (!bt_proto[proto]) {
		request_module("bt-proto-%d", proto);
	}
#endif

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