[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/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.16"

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

static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
static const char *const 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 *const 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]);
}

int bt_sock_register(int proto, const 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 kern)
{
	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, kern);
		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_sk(parent)->defer_setup) {
			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;

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

	skb_free_datagram(sk, skb);

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

static long bt_sock_data_wait(struct sock *sk, long timeo)
{
	DECLARE_WAITQUEUE(wait, current);

	add_wait_queue(sk_sleep(sk), &wait);
	for (;;) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!skb_queue_empty(&sk->sk_receive_queue))
			break;

		if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
			break;

		if (signal_pending(current) || !timeo)
			break;

		set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	}

	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return timeo;
}

int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
			       struct msghdr *msg, size_t size, int flags)
{
	struct sock *sk = sock->sk;
	int err = 0;
	size_t target, copied = 0;
	long timeo;

	if (flags & MSG_OOB)
		return -EOPNOTSUPP;

	msg->msg_namelen = 0;

	BT_DBG("sk %p size %zu", sk, size);

	lock_sock(sk);

	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);

	do {
		struct sk_buff *skb;
		int chunk;

		skb = skb_dequeue(&sk->sk_receive_queue);
		if (!skb) {
			if (copied >= target)
				break;

			err = sock_error(sk);
			if (err)
				break;
			if (sk->sk_shutdown & RCV_SHUTDOWN)
				break;

			err = -EAGAIN;
			if (!timeo)
				break;

			timeo = bt_sock_data_wait(sk, timeo);

			if (signal_pending(current)) {
				err = sock_intr_errno(timeo);
				goto out;
			}
			continue;
		}

		chunk = min_t(unsigned int, skb->len, size);
		if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
			skb_queue_head(&sk->sk_receive_queue, skb);
			if (!copied)
				copied = -EFAULT;
			break;
		}
		copied += chunk;
		size   -= chunk;

		sock_recv_ts_and_drops(msg, sk, skb);

		if (!(flags & MSG_PEEK)) {
			int skb_len = skb_headlen(skb);

			if (chunk <= skb_len) {
				__skb_pull(skb, chunk);
			} else {
				struct sk_buff *frag;

				__skb_pull(skb, skb_len);
				chunk -= skb_len;

				skb_walk_frags(skb, frag) {
					if (chunk <= frag->len) {
						/* Pulling partial data */
						skb->len -= chunk;
						skb->data_len -= chunk;
						__skb_pull(frag, chunk);
						break;
					} else if (frag->len) {
						/* Pulling all frag data */
						chunk -= frag->len;
						skb->len -= frag->len;
						skb->data_len -= frag->len;
						__skb_pull(frag, frag->len);
					}
				}
			}

			if (skb->len) {
				skb_queue_head(&sk->sk_receive_queue, skb);
				break;
			}
			kfree_skb(skb);

		} else {
			/* put message back and return */
			skb_queue_head(&sk->sk_receive_queue, skb);
			break;
		}
	} while (size);

out:
	release_sock(sk);
	return copied ? : err;
}
EXPORT_SYMBOL(bt_sock_stream_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 ||
					(bt_sk(parent)->defer_setup &&
						sk->sk_state == BT_CONNECT2))
			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_sleep(sk), 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 | POLLIN | POLLRDNORM;

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

	if (!skb_queue_empty(&sk->sk_receive_queue))
		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 - sk_wmem_alloc_get(sk);
		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_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (sk->sk_state != state) {
		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);
		set_current_state(TASK_INTERRUPTIBLE);

		err = sock_error(sk);
		if (err)
			break;
	}
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &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");

	err = hci_sock_init();
	if (err < 0)
		goto error;

	err = l2cap_init();
	if (err < 0)
		goto sock_err;

	err = sco_init();
	if (err < 0) {
		l2cap_exit();
		goto sock_err;
	}

	return 0;

sock_err:
	hci_sock_cleanup();

error:
	sock_unregister(PF_BLUETOOTH);
	bt_sysfs_cleanup();

	return err;
}

static void __exit bt_exit(void)
{

	sco_exit();

	l2cap_exit();

	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/skbuff.h>
	35	#include <linux/init.h>
	36	#include <linux/poll.h>
	37	#include <net/sock.h>
	38	#include <asm/ioctls.h>
	39	#include <linux/kmod.h>
	40
	41	#include <net/bluetooth/bluetooth.h>
	42
	43	#define VERSION "2.16"
	44
	45	/* Bluetooth sockets */
	46	#define BT_MAX_PROTO 8
	47	static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
	48	static DEFINE_RWLOCK(bt_proto_lock);
	49
	50	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
	51	static const char *const bt_key_strings[BT_MAX_PROTO] = {
	52	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	53	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	54	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	55	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	56	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	57	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	58	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	59	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
	60	};
	61
	62	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
	63	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
	64	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	65	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	66	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	67	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	68	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	69	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	70	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	71	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
	72	};
	73
	74	static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
	75	{
	76	struct sock *sk = sock->sk;
	77
	78	if (!sk)
	79	return;
	80
	81	BUG_ON(sock_owned_by_user(sk));
	82
	83	sock_lock_init_class_and_name(sk,
	84	bt_slock_key_strings[proto], &bt_slock_key[proto],
	85	bt_key_strings[proto], &bt_lock_key[proto]);
	86	}
	87
	88	int bt_sock_register(int proto, const struct net_proto_family *ops)
	89	{
	90	int err = 0;
	91
	92	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	93	return -EINVAL;
	94
	95	write_lock(&bt_proto_lock);
	96
	97	if (bt_proto[proto])
	98	err = -EEXIST;
	99	else
	100	bt_proto[proto] = ops;
	101
	102	write_unlock(&bt_proto_lock);
	103
	104	return err;
	105	}
	106	EXPORT_SYMBOL(bt_sock_register);
	107
	108	int bt_sock_unregister(int proto)
	109	{
	110	int err = 0;
	111
	112	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	113	return -EINVAL;
	114
	115	write_lock(&bt_proto_lock);
	116
	117	if (!bt_proto[proto])
	118	err = -ENOENT;
	119	else
	120	bt_proto[proto] = NULL;
	121
	122	write_unlock(&bt_proto_lock);
	123
	124	return err;
	125	}
	126	EXPORT_SYMBOL(bt_sock_unregister);
	127
	128	static int bt_sock_create(struct net net, struct socket sock, int proto,
	129	int kern)
	130	{
	131	int err;
	132
	133	if (net != &init_net)
	134	return -EAFNOSUPPORT;
	135
	136	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	137	return -EINVAL;
	138
	139	if (!bt_proto[proto])
	140	request_module("bt-proto-%d", proto);
	141
	142	err = -EPROTONOSUPPORT;
	143
	144	read_lock(&bt_proto_lock);
	145
	146	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
	147	err = bt_proto[proto]->create(net, sock, proto, kern);
	148	bt_sock_reclassify_lock(sock, proto);
	149	module_put(bt_proto[proto]->owner);
	150	}
	151
	152	read_unlock(&bt_proto_lock);
	153
	154	return err;
	155	}
	156
	157	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	158	{
	159	write_lock_bh(&l->lock);
	160	sk_add_node(sk, &l->head);
	161	write_unlock_bh(&l->lock);
	162	}
	163	EXPORT_SYMBOL(bt_sock_link);
	164
	165	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	166	{
	167	write_lock_bh(&l->lock);
	168	sk_del_node_init(sk);
	169	write_unlock_bh(&l->lock);
	170	}
	171	EXPORT_SYMBOL(bt_sock_unlink);
	172
	173	void bt_accept_enqueue(struct sock parent, struct sock sk)
	174	{
	175	BT_DBG("parent %p, sk %p", parent, sk);
	176
	177	sock_hold(sk);
	178	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	179	bt_sk(sk)->parent = parent;
	180	parent->sk_ack_backlog++;
	181	}
	182	EXPORT_SYMBOL(bt_accept_enqueue);
	183
	184	void bt_accept_unlink(struct sock *sk)
	185	{
	186	BT_DBG("sk %p state %d", sk, sk->sk_state);
	187
	188	list_del_init(&bt_sk(sk)->accept_q);
	189	bt_sk(sk)->parent->sk_ack_backlog--;
	190	bt_sk(sk)->parent = NULL;
	191	sock_put(sk);
	192	}
	193	EXPORT_SYMBOL(bt_accept_unlink);
	194
	195	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	196	{
	197	struct list_head p, n;
	198	struct sock *sk;
	199
	200	BT_DBG("parent %p", parent);
	201
	202	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	203	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	204
	205	lock_sock(sk);
	206
	207	/* FIXME: Is this check still needed */
	208	if (sk->sk_state == BT_CLOSED) {
	209	release_sock(sk);
	210	bt_accept_unlink(sk);
	211	continue;
	212	}
	213
	214	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
	215	bt_sk(parent)->defer_setup) {
	216	bt_accept_unlink(sk);
	217	if (newsock)
	218	sock_graft(sk, newsock);
	219
	220	release_sock(sk);
	221	return sk;
	222	}
	223
	224	release_sock(sk);
	225	}
	226
	227	return NULL;
	228	}
	229	EXPORT_SYMBOL(bt_accept_dequeue);
	230
	231	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
	232	struct msghdr *msg, size_t len, int flags)
	233	{
	234	int noblock = flags & MSG_DONTWAIT;
	235	struct sock *sk = sock->sk;
	236	struct sk_buff *skb;
	237	size_t copied;
	238	int err;
	239
	240	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
	241
	242	if (flags & (MSG_OOB))
	243	return -EOPNOTSUPP;
	244
	245	skb = skb_recv_datagram(sk, flags, noblock, &err);
	246	if (!skb) {
	247	if (sk->sk_shutdown & RCV_SHUTDOWN)
	248	return 0;
	249	return err;
	250	}
	251
	252	msg->msg_namelen = 0;
	253
	254	copied = skb->len;
	255	if (len < copied) {
	256	msg->msg_flags \|= MSG_TRUNC;
	257	copied = len;
	258	}
	259
	260	skb_reset_transport_header(skb);
	261	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	262	if (err == 0)
	263	sock_recv_ts_and_drops(msg, sk, skb);
	264
	265	skb_free_datagram(sk, skb);
	266
	267	return err ? : copied;
	268	}
	269	EXPORT_SYMBOL(bt_sock_recvmsg);
	270
	271	static long bt_sock_data_wait(struct sock *sk, long timeo)
	272	{
	273	DECLARE_WAITQUEUE(wait, current);
	274
	275	add_wait_queue(sk_sleep(sk), &wait);
	276	for (;;) {
	277	set_current_state(TASK_INTERRUPTIBLE);
	278
	279	if (!skb_queue_empty(&sk->sk_receive_queue))
	280	break;
	281
	282	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	283	break;
	284
	285	if (signal_pending(current) \|\| !timeo)
	286	break;
	287
	288	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	289	release_sock(sk);
	290	timeo = schedule_timeout(timeo);
	291	lock_sock(sk);
	292	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	293	}
	294
	295	__set_current_state(TASK_RUNNING);
	296	remove_wait_queue(sk_sleep(sk), &wait);
	297	return timeo;
	298	}
	299
	300	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	301	struct msghdr *msg, size_t size, int flags)
	302	{
	303	struct sock *sk = sock->sk;
	304	int err = 0;
	305	size_t target, copied = 0;
	306	long timeo;
	307
	308	if (flags & MSG_OOB)
	309	return -EOPNOTSUPP;
	310
	311	msg->msg_namelen = 0;
	312
	313	BT_DBG("sk %p size %zu", sk, size);
	314
	315	lock_sock(sk);
	316
	317	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	318	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	319
	320	do {
	321	struct sk_buff *skb;
	322	int chunk;
	323
	324	skb = skb_dequeue(&sk->sk_receive_queue);
	325	if (!skb) {
	326	if (copied >= target)
	327	break;
	328
	329	err = sock_error(sk);
	330	if (err)
	331	break;
	332	if (sk->sk_shutdown & RCV_SHUTDOWN)
	333	break;
	334
	335	err = -EAGAIN;
	336	if (!timeo)
	337	break;
	338
	339	timeo = bt_sock_data_wait(sk, timeo);
	340
	341	if (signal_pending(current)) {
	342	err = sock_intr_errno(timeo);
	343	goto out;
	344	}
	345	continue;
	346	}
	347
	348	chunk = min_t(unsigned int, skb->len, size);
	349	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
	350	skb_queue_head(&sk->sk_receive_queue, skb);
	351	if (!copied)
	352	copied = -EFAULT;
	353	break;
	354	}
	355	copied += chunk;
	356	size -= chunk;
	357
	358	sock_recv_ts_and_drops(msg, sk, skb);
	359
	360	if (!(flags & MSG_PEEK)) {
	361	int skb_len = skb_headlen(skb);
	362
	363	if (chunk <= skb_len) {
	364	__skb_pull(skb, chunk);
	365	} else {
	366	struct sk_buff *frag;
	367
	368	__skb_pull(skb, skb_len);
	369	chunk -= skb_len;
	370
	371	skb_walk_frags(skb, frag) {
	372	if (chunk <= frag->len) {
	373	/* Pulling partial data */
	374	skb->len -= chunk;
	375	skb->data_len -= chunk;
	376	__skb_pull(frag, chunk);
	377	break;
	378	} else if (frag->len) {
	379	/* Pulling all frag data */
	380	chunk -= frag->len;
	381	skb->len -= frag->len;
	382	skb->data_len -= frag->len;
	383	__skb_pull(frag, frag->len);
	384	}
	385	}
	386	}
	387
	388	if (skb->len) {
	389	skb_queue_head(&sk->sk_receive_queue, skb);
	390	break;
	391	}
	392	kfree_skb(skb);
	393
	394	} else {
	395	/* put message back and return */
	396	skb_queue_head(&sk->sk_receive_queue, skb);
	397	break;
	398	}
	399	} while (size);
	400
	401	out:
	402	release_sock(sk);
	403	return copied ? : err;
	404	}
	405	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	406
	407	static inline unsigned int bt_accept_poll(struct sock *parent)
	408	{
	409	struct list_head p, n;
	410	struct sock *sk;
	411
	412	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	413	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	414	if (sk->sk_state == BT_CONNECTED \|\|
	415	(bt_sk(parent)->defer_setup &&
	416	sk->sk_state == BT_CONNECT2))
	417	return POLLIN \| POLLRDNORM;
	418	}
	419
	420	return 0;
	421	}
	422
	423	unsigned int bt_sock_poll(struct file file, struct socket sock, poll_table *wait)
	424	{
	425	struct sock *sk = sock->sk;
	426	unsigned int mask = 0;
	427
	428	BT_DBG("sock %p, sk %p", sock, sk);
	429
	430	poll_wait(file, sk_sleep(sk), wait);
	431
	432	if (sk->sk_state == BT_LISTEN)
	433	return bt_accept_poll(sk);
	434
	435	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	436	mask \|= POLLERR;
	437
	438	if (sk->sk_shutdown & RCV_SHUTDOWN)
	439	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
	440
	441	if (sk->sk_shutdown == SHUTDOWN_MASK)
	442	mask \|= POLLHUP;
	443
	444	if (!skb_queue_empty(&sk->sk_receive_queue))
	445	mask \|= POLLIN \| POLLRDNORM;
	446
	447	if (sk->sk_state == BT_CLOSED)
	448	mask \|= POLLHUP;
	449
	450	if (sk->sk_state == BT_CONNECT \|\|
	451	sk->sk_state == BT_CONNECT2 \|\|
	452	sk->sk_state == BT_CONFIG)
	453	return mask;
	454
	455	if (sock_writeable(sk))
	456	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	457	else
	458	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	459
	460	return mask;
	461	}
	462	EXPORT_SYMBOL(bt_sock_poll);
	463
	464	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	465	{
	466	struct sock *sk = sock->sk;
	467	struct sk_buff *skb;
	468	long amount;
	469	int err;
	470
	471	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	472
	473	switch (cmd) {
	474	case TIOCOUTQ:
	475	if (sk->sk_state == BT_LISTEN)
	476	return -EINVAL;
	477
	478	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
	479	if (amount < 0)
	480	amount = 0;
	481	err = put_user(amount, (int __user *) arg);
	482	break;
	483
	484	case TIOCINQ:
	485	if (sk->sk_state == BT_LISTEN)
	486	return -EINVAL;
	487
	488	lock_sock(sk);
	489	skb = skb_peek(&sk->sk_receive_queue);
	490	amount = skb ? skb->len : 0;
	491	release_sock(sk);
	492	err = put_user(amount, (int __user *) arg);
	493	break;
	494
	495	case SIOCGSTAMP:
	496	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	497	break;
	498
	499	case SIOCGSTAMPNS:
	500	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	501	break;
	502
	503	default:
	504	err = -ENOIOCTLCMD;
	505	break;
	506	}
	507
	508	return err;
	509	}
	510	EXPORT_SYMBOL(bt_sock_ioctl);
	511
	512	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	513	{
	514	DECLARE_WAITQUEUE(wait, current);
	515	int err = 0;
	516
	517	BT_DBG("sk %p", sk);
	518
	519	add_wait_queue(sk_sleep(sk), &wait);
	520	set_current_state(TASK_INTERRUPTIBLE);
	521	while (sk->sk_state != state) {
	522	if (!timeo) {
	523	err = -EINPROGRESS;
	524	break;
	525	}
	526
	527	if (signal_pending(current)) {
	528	err = sock_intr_errno(timeo);
	529	break;
	530	}
	531
	532	release_sock(sk);
	533	timeo = schedule_timeout(timeo);
	534	lock_sock(sk);
	535	set_current_state(TASK_INTERRUPTIBLE);
	536
	537	err = sock_error(sk);
	538	if (err)
	539	break;
	540	}
	541	__set_current_state(TASK_RUNNING);
	542	remove_wait_queue(sk_sleep(sk), &wait);
	543	return err;
	544	}
	545	EXPORT_SYMBOL(bt_sock_wait_state);
	546
	547	static struct net_proto_family bt_sock_family_ops = {
	548	.owner = THIS_MODULE,
	549	.family = PF_BLUETOOTH,
	550	.create = bt_sock_create,
	551	};
	552
	553	static int __init bt_init(void)
	554	{
	555	int err;
	556
	557	BT_INFO("Core ver %s", VERSION);
	558
	559	err = bt_sysfs_init();
	560	if (err < 0)
	561	return err;
	562
	563	err = sock_register(&bt_sock_family_ops);
	564	if (err < 0) {
	565	bt_sysfs_cleanup();
	566	return err;
	567	}
	568
	569	BT_INFO("HCI device and connection manager initialized");
	570
	571	err = hci_sock_init();
	572	if (err < 0)
	573	goto error;
	574
	575	err = l2cap_init();
	576	if (err < 0)
	577	goto sock_err;
	578
	579	err = sco_init();
	580	if (err < 0) {
	581	l2cap_exit();
	582	goto sock_err;
	583	}
	584
	585	return 0;
	586
	587	sock_err:
	588	hci_sock_cleanup();
	589
	590	error:
	591	sock_unregister(PF_BLUETOOTH);
	592	bt_sysfs_cleanup();
	593
	594	return err;
	595	}
	596
	597	static void __exit bt_exit(void)
	598	{
	599
	600	sco_exit();
	601
	602	l2cap_exit();
	603
	604	hci_sock_cleanup();
	605
	606	sock_unregister(PF_BLUETOOTH);
	607
	608	bt_sysfs_cleanup();
	609	}
	610
	611	subsys_initcall(bt_init);
	612	module_exit(bt_exit);
	613
	614	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	615	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	616	MODULE_VERSION(VERSION);
	617	MODULE_LICENSE("GPL");
	618	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);