[deliverable/linux.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>

#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);

	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_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 LT	38	#include <net/sock.h>
	39
	40	#if defined(CONFIG_KMOD)
	41	#include <linux/kmod.h>
	42	#endif
	43
	44	#include <net/bluetooth/bluetooth.h>
	45
	46	#ifndef CONFIG_BT_SOCK_DEBUG
	47	#undef BT_DBG
	48	#define BT_DBG(D...)
	49	#endif
	50
4c67bc74	51	#define VERSION "2.11"
1da177e4 LT	52
	53	/* Bluetooth sockets */
	54	#define BT_MAX_PROTO 8
	55	static struct net_proto_family *bt_proto[BT_MAX_PROTO];
68845cb2 DY	56
	57	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
	58	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
	59	static const char *bt_key_strings[BT_MAX_PROTO] = {
	60	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	61	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	62	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	63	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	64	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	65	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	66	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	67	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
	68	};
	69
	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	};
74da626a	80	static DEFINE_RWLOCK(bt_proto_lock);
1da177e4 LT	81
	82	int bt_sock_register(int proto, struct net_proto_family *ops)
	83	{
74da626a MH	84	int err = 0;
74da626a MH	85
1da177e4 LT	86	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	87	return -EINVAL;
	88
74da626a MH	89	write_lock(&bt_proto_lock);
74da626a MH	90
1da177e4	91	if (bt_proto[proto])
74da626a MH	92	err = -EEXIST;
	93	else
	94	bt_proto[proto] = ops;
	95
	96	write_unlock(&bt_proto_lock);
1da177e4	97
74da626a	98	return err;
1da177e4 LT	99	}
	100	EXPORT_SYMBOL(bt_sock_register);
	101
	102	int bt_sock_unregister(int proto)
	103	{
74da626a MH	104	int err = 0;
74da626a MH	105
1da177e4 LT	106	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	107	return -EINVAL;
	108
74da626a MH	109	write_lock(&bt_proto_lock);
74da626a MH	110
1da177e4	111	if (!bt_proto[proto])
74da626a MH	112	err = -ENOENT;
	113	else
	114	bt_proto[proto] = NULL;
1da177e4	115
74da626a MH	116	write_unlock(&bt_proto_lock);
	117
	118	return err;
1da177e4 LT	119	}
	120	EXPORT_SYMBOL(bt_sock_unregister);
	121
68845cb2 DY	122	static void bt_reclassify_sock_lock(struct socket *sock, int proto)
	123	{
	124	struct sock *sk = sock->sk;
	125
	126	if (!sk)
	127	return;
	128	BUG_ON(sock_owned_by_user(sk));
	129
	130	sock_lock_init_class_and_name(sk,
	131	bt_slock_key_strings[proto],
	132	&bt_slock_key[proto],
	133	bt_key_strings[proto],
	134	&bt_lock_key[proto]);
	135	}
	136
1b8d7ae4	137	static int bt_sock_create(struct net net, struct socket sock, int proto)
1da177e4	138	{
74da626a	139	int err;
1da177e4	140
1b8d7ae4 EB	141	if (net != &init_net)
	142	return -EAFNOSUPPORT;
	143
1da177e4 LT	144	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	145	return -EINVAL;
	146
	147	#if defined(CONFIG_KMOD)
	148	if (!bt_proto[proto]) {
	149	request_module("bt-proto-%d", proto);
	150	}
	151	#endif
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);
68845cb2	159	bt_reclassify_sock_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 LT	268	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	269
	270	skb_free_datagram(sk, skb);
	271
	272	return err ? : copied;
	273	}
	274	EXPORT_SYMBOL(bt_sock_recvmsg);
	275
	276	static inline unsigned int bt_accept_poll(struct sock *parent)
	277	{
	278	struct list_head p, n;
	279	struct sock *sk;
	280
	281	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	282	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	283	if (sk->sk_state == BT_CONNECTED)
	284	return POLLIN \| POLLRDNORM;
	285	}
	286
	287	return 0;
	288	}
	289
	290	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	291	{
	292	struct sock *sk = sock->sk;
	293	unsigned int mask = 0;
	294
	295	BT_DBG("sock %p, sk %p", sock, sk);
	296
	297	poll_wait(file, sk->sk_sleep, wait);
	298
	299	if (sk->sk_state == BT_LISTEN)
	300	return bt_accept_poll(sk);
	301
	302	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	303	mask \|= POLLERR;
	304
f348d70a DL	305	if (sk->sk_shutdown & RCV_SHUTDOWN)
	306	mask \|= POLLRDHUP;
	307
1da177e4 LT	308	if (sk->sk_shutdown == SHUTDOWN_MASK)
	309	mask \|= POLLHUP;
	310
8e87d142	311	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
1da177e4 LT	312	(sk->sk_shutdown & RCV_SHUTDOWN))
	313	mask \|= POLLIN \| POLLRDNORM;
	314
	315	if (sk->sk_state == BT_CLOSED)
	316	mask \|= POLLHUP;
	317
	318	if (sk->sk_state == BT_CONNECT \|\|
	319	sk->sk_state == BT_CONNECT2 \|\|
	320	sk->sk_state == BT_CONFIG)
	321	return mask;
	322
	323	if (sock_writeable(sk))
	324	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	325	else
	326	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	327
	328	return mask;
	329	}
	330	EXPORT_SYMBOL(bt_sock_poll);
	331
	332	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	333	{
	334	DECLARE_WAITQUEUE(wait, current);
	335	int err = 0;
	336
	337	BT_DBG("sk %p", sk);
	338
	339	add_wait_queue(sk->sk_sleep, &wait);
	340	while (sk->sk_state != state) {
	341	set_current_state(TASK_INTERRUPTIBLE);
	342
	343	if (!timeo) {
b4c612a4	344	err = -EINPROGRESS;
1da177e4 LT	345	break;
	346	}
	347
	348	if (signal_pending(current)) {
	349	err = sock_intr_errno(timeo);
	350	break;
	351	}
	352
	353	release_sock(sk);
	354	timeo = schedule_timeout(timeo);
	355	lock_sock(sk);
	356
c1cbe4b7 BL	357	err = sock_error(sk);
c1cbe4b7 BL	358	if (err)
1da177e4	359	break;
1da177e4 LT	360	}
	361	set_current_state(TASK_RUNNING);
	362	remove_wait_queue(sk->sk_sleep, &wait);
	363	return err;
	364	}
	365	EXPORT_SYMBOL(bt_sock_wait_state);
	366
	367	static struct net_proto_family bt_sock_family_ops = {
	368	.owner = THIS_MODULE,
	369	.family = PF_BLUETOOTH,
	370	.create = bt_sock_create,
	371	};
	372
1da177e4 LT	373	static int __init bt_init(void)
1da177e4 LT	374	{
27d35284 MH	375	int err;
27d35284 MH	376
1da177e4 LT	377	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	378
27d35284 MH	379	err = bt_sysfs_init();
	380	if (err < 0)
	381	return err;
1da177e4	382
27d35284 MH	383	err = sock_register(&bt_sock_family_ops);
	384	if (err < 0) {
	385	bt_sysfs_cleanup();
	386	return err;
	387	}
1da177e4	388
27d35284	389	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	390
	391	hci_sock_init();
	392
	393	return 0;
	394	}
	395
	396	static void __exit bt_exit(void)
	397	{
	398	hci_sock_cleanup();
	399
1da177e4	400	sock_unregister(PF_BLUETOOTH);
27d35284 MH	401
27d35284 MH	402	bt_sysfs_cleanup();
1da177e4 LT	403	}
	404
	405	subsys_initcall(bt_init);
	406	module_exit(bt_exit);
	407
	408	MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
	409	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	410	MODULE_VERSION(VERSION);
	411	MODULE_LICENSE("GPL");
	412	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);