[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.11"

/* 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;
	int err;

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

	switch (cmd) {
	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("Maxim Krasnyansky <maxk@qualcomm.com>, 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
4c67bc74	52	#define VERSION "2.11"
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;
	338	int err;
	339
	340	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	341
	342	switch (cmd) {
	343	case SIOCGSTAMP:
	344	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	345	break;
	346
	347	case SIOCGSTAMPNS:
	348	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	349	break;
	350
	351	default:
	352	err = -ENOIOCTLCMD;
	353	break;
	354	}
	355
	356	return err;
	357	}
	358	EXPORT_SYMBOL(bt_sock_ioctl);
	359
1da177e4 LT	360	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	361	{
	362	DECLARE_WAITQUEUE(wait, current);
	363	int err = 0;
	364
	365	BT_DBG("sk %p", sk);
	366
	367	add_wait_queue(sk->sk_sleep, &wait);
	368	while (sk->sk_state != state) {
	369	set_current_state(TASK_INTERRUPTIBLE);
	370
	371	if (!timeo) {
b4c612a4	372	err = -EINPROGRESS;
1da177e4 LT	373	break;
	374	}
	375
	376	if (signal_pending(current)) {
	377	err = sock_intr_errno(timeo);
	378	break;
	379	}
	380
	381	release_sock(sk);
	382	timeo = schedule_timeout(timeo);
	383	lock_sock(sk);
	384
c1cbe4b7 BL	385	err = sock_error(sk);
c1cbe4b7 BL	386	if (err)
1da177e4	387	break;
1da177e4 LT	388	}
	389	set_current_state(TASK_RUNNING);
	390	remove_wait_queue(sk->sk_sleep, &wait);
	391	return err;
	392	}
	393	EXPORT_SYMBOL(bt_sock_wait_state);
	394
	395	static struct net_proto_family bt_sock_family_ops = {
	396	.owner = THIS_MODULE,
	397	.family = PF_BLUETOOTH,
	398	.create = bt_sock_create,
	399	};
	400
1da177e4 LT	401	static int __init bt_init(void)
1da177e4 LT	402	{
27d35284 MH	403	int err;
27d35284 MH	404
1da177e4 LT	405	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	406
27d35284 MH	407	err = bt_sysfs_init();
	408	if (err < 0)
	409	return err;
1da177e4	410
27d35284 MH	411	err = sock_register(&bt_sock_family_ops);
	412	if (err < 0) {
	413	bt_sysfs_cleanup();
	414	return err;
	415	}
1da177e4	416
27d35284	417	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	418
	419	hci_sock_init();
	420
	421	return 0;
	422	}
	423
	424	static void __exit bt_exit(void)
	425	{
	426	hci_sock_cleanup();
	427
1da177e4	428	sock_unregister(PF_BLUETOOTH);
27d35284 MH	429
27d35284 MH	430	bt_sysfs_cleanup();
1da177e4 LT	431	}
	432
	433	subsys_initcall(bt_init);
	434	module_exit(bt_exit);
	435
	436	MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
	437	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	438	MODULE_VERSION(VERSION);
	439	MODULE_LICENSE("GPL");
	440	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);