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

/* 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 (memcpy_toiovec(msg->msg_iov, skb->data, 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)) {
			skb_pull(skb, chunk);
			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);
	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_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");

	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	33	#include <linux/sched.h>
1da177e4 LT	34	#include <linux/skbuff.h>
	35	#include <linux/init.h>
	36	#include <linux/poll.h>
1da177e4	37	#include <net/sock.h>
3241ad82	38	#include <asm/ioctls.h>
1da177e4	39	#include <linux/kmod.h>
1da177e4 LT	40
	41	#include <net/bluetooth/bluetooth.h>
	42
5f9018af	43	#define VERSION "2.15"
1da177e4 LT	44
	45	/* Bluetooth sockets */
	46	#define BT_MAX_PROTO 8
ec1b4cf7	47	static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2	48	static DEFINE_RWLOCK(bt_proto_lock);
68845cb2	49
68845cb2	50	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc	51	static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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
db7aa1c2	62	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc	63	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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	};
db7aa1c2 MH	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	}
1da177e4	87
ec1b4cf7	88	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	89	{
74da626a MH	90	int err = 0;
74da626a MH	91
1da177e4 LT	92	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	93	return -EINVAL;
	94
74da626a MH	95	write_lock(&bt_proto_lock);
74da626a MH	96
1da177e4	97	if (bt_proto[proto])
74da626a MH	98	err = -EEXIST;
	99	else
	100	bt_proto[proto] = ops;
	101
	102	write_unlock(&bt_proto_lock);
1da177e4	103
74da626a	104	return err;
1da177e4 LT	105	}
	106	EXPORT_SYMBOL(bt_sock_register);
	107
	108	int bt_sock_unregister(int proto)
	109	{
74da626a MH	110	int err = 0;
74da626a MH	111
1da177e4 LT	112	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	113	return -EINVAL;
	114
74da626a MH	115	write_lock(&bt_proto_lock);
74da626a MH	116
1da177e4	117	if (!bt_proto[proto])
74da626a MH	118	err = -ENOENT;
	119	else
	120	bt_proto[proto] = NULL;
1da177e4	121
74da626a MH	122	write_unlock(&bt_proto_lock);
	123
	124	return err;
1da177e4 LT	125	}
	126	EXPORT_SYMBOL(bt_sock_unregister);
	127
3f378b68 EP	128	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	129	int kern)
1da177e4	130	{
74da626a	131	int err;
1da177e4	132
1b8d7ae4 EB	133	if (net != &init_net)
	134	return -EAFNOSUPPORT;
	135
1da177e4 LT	136	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	137	return -EINVAL;
	138
95a5afca	139	if (!bt_proto[proto])
1da177e4	140	request_module("bt-proto-%d", proto);
74da626a	141
1da177e4	142	err = -EPROTONOSUPPORT;
74da626a MH	143
	144	read_lock(&bt_proto_lock);
	145
1da177e4	146	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	147	err = bt_proto[proto]->create(net, sock, proto, kern);
db7aa1c2	148	bt_sock_reclassify_lock(sock, proto);
1da177e4 LT	149	module_put(bt_proto[proto]->owner);
1da177e4 LT	150	}
74da626a MH	151
	152	read_unlock(&bt_proto_lock);
	153
8e87d142	154	return err;
1da177e4 LT	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
c4f912e1 MH	214	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
c4f912e1 MH	215	bt_sk(parent)->defer_setup) {
1da177e4 LT	216	bt_accept_unlink(sk);
	217	if (newsock)
	218	sock_graft(sk, newsock);
	219	release_sock(sk);
	220	return sk;
	221	}
	222
	223	release_sock(sk);
	224	}
	225	return NULL;
	226	}
	227	EXPORT_SYMBOL(bt_accept_dequeue);
	228
	229	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	230	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	231	{
	232	int noblock = flags & MSG_DONTWAIT;
	233	struct sock *sk = sock->sk;
	234	struct sk_buff *skb;
	235	size_t copied;
	236	int err;
	237
a418b893	238	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	239
	240	if (flags & (MSG_OOB))
	241	return -EOPNOTSUPP;
	242
5a08ecce AE	243	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	244	if (!skb) {
1da177e4 LT	245	if (sk->sk_shutdown & RCV_SHUTDOWN)
	246	return 0;
	247	return err;
	248	}
	249
	250	msg->msg_namelen = 0;
	251
	252	copied = skb->len;
	253	if (len < copied) {
	254	msg->msg_flags \|= MSG_TRUNC;
	255	copied = len;
	256	}
	257
badff6d0	258	skb_reset_transport_header(skb);
1da177e4	259	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
3241ad82	260	if (err == 0)
3b885787	261	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 LT	262
	263	skb_free_datagram(sk, skb);
	264
	265	return err ? : copied;
	266	}
	267	EXPORT_SYMBOL(bt_sock_recvmsg);
	268
796c86ee MM	269	static long bt_sock_data_wait(struct sock *sk, long timeo)
	270	{
	271	DECLARE_WAITQUEUE(wait, current);
	272
	273	add_wait_queue(sk_sleep(sk), &wait);
	274	for (;;) {
	275	set_current_state(TASK_INTERRUPTIBLE);
	276
	277	if (!skb_queue_empty(&sk->sk_receive_queue))
	278	break;
	279
	280	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	281	break;
	282
	283	if (signal_pending(current) \|\| !timeo)
	284	break;
	285
	286	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	287	release_sock(sk);
	288	timeo = schedule_timeout(timeo);
	289	lock_sock(sk);
	290	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	291	}
	292
	293	__set_current_state(TASK_RUNNING);
	294	remove_wait_queue(sk_sleep(sk), &wait);
	295	return timeo;
	296	}
	297
	298	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	299	struct msghdr *msg, size_t size, int flags)
	300	{
	301	struct sock *sk = sock->sk;
	302	int err = 0;
	303	size_t target, copied = 0;
	304	long timeo;
	305
	306	if (flags & MSG_OOB)
	307	return -EOPNOTSUPP;
	308
	309	msg->msg_namelen = 0;
	310
	311	BT_DBG("sk %p size %zu", sk, size);
	312
	313	lock_sock(sk);
	314
	315	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	316	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	317
	318	do {
	319	struct sk_buff *skb;
	320	int chunk;
	321
	322	skb = skb_dequeue(&sk->sk_receive_queue);
	323	if (!skb) {
	324	if (copied >= target)
	325	break;
	326
5a08ecce AE	327	err = sock_error(sk);
5a08ecce AE	328	if (err)
796c86ee MM	329	break;
	330	if (sk->sk_shutdown & RCV_SHUTDOWN)
	331	break;
	332
	333	err = -EAGAIN;
	334	if (!timeo)
	335	break;
	336
	337	timeo = bt_sock_data_wait(sk, timeo);
	338
	339	if (signal_pending(current)) {
	340	err = sock_intr_errno(timeo);
	341	goto out;
	342	}
	343	continue;
	344	}
	345
	346	chunk = min_t(unsigned int, skb->len, size);
	347	if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
	348	skb_queue_head(&sk->sk_receive_queue, skb);
	349	if (!copied)
	350	copied = -EFAULT;
	351	break;
	352	}
	353	copied += chunk;
	354	size -= chunk;
	355
	356	sock_recv_ts_and_drops(msg, sk, skb);
	357
	358	if (!(flags & MSG_PEEK)) {
	359	skb_pull(skb, chunk);
	360	if (skb->len) {
	361	skb_queue_head(&sk->sk_receive_queue, skb);
	362	break;
	363	}
	364	kfree_skb(skb);
	365
	366	} else {
	367	/* put message back and return */
	368	skb_queue_head(&sk->sk_receive_queue, skb);
	369	break;
	370	}
	371	} while (size);
	372
	373	out:
	374	release_sock(sk);
	375	return copied ? : err;
	376	}
	377	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	378
1da177e4 LT	379	static inline unsigned int bt_accept_poll(struct sock *parent)
	380	{
	381	struct list_head p, n;
	382	struct sock *sk;
	383
	384	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	385	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	386	if (sk->sk_state == BT_CONNECTED \|\|
	387	(bt_sk(parent)->defer_setup &&
	388	sk->sk_state == BT_CONNECT2))
1da177e4 LT	389	return POLLIN \| POLLRDNORM;
	390	}
	391
	392	return 0;
	393	}
	394
	395	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	396	{
	397	struct sock *sk = sock->sk;
	398	unsigned int mask = 0;
	399
	400	BT_DBG("sock %p, sk %p", sock, sk);
	401
aa395145	402	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	403
	404	if (sk->sk_state == BT_LISTEN)
	405	return bt_accept_poll(sk);
	406
	407	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	408	mask \|= POLLERR;
	409
f348d70a	410	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	411	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	412
1da177e4 LT	413	if (sk->sk_shutdown == SHUTDOWN_MASK)
	414	mask \|= POLLHUP;
	415
db40980f	416	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	417	mask \|= POLLIN \| POLLRDNORM;
	418
	419	if (sk->sk_state == BT_CLOSED)
	420	mask \|= POLLHUP;
	421
	422	if (sk->sk_state == BT_CONNECT \|\|
	423	sk->sk_state == BT_CONNECT2 \|\|
	424	sk->sk_state == BT_CONFIG)
	425	return mask;
	426
	427	if (sock_writeable(sk))
	428	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	429	else
	430	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	431
	432	return mask;
	433	}
	434	EXPORT_SYMBOL(bt_sock_poll);
	435
3241ad82 MH	436	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	437	{
	438	struct sock *sk = sock->sk;
43cbeee9 MH	439	struct sk_buff *skb;
43cbeee9 MH	440	long amount;
3241ad82 MH	441	int err;
	442
	443	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	444
	445	switch (cmd) {
43cbeee9 MH	446	case TIOCOUTQ:
	447	if (sk->sk_state == BT_LISTEN)
	448	return -EINVAL;
	449
31e6d363	450	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	451	if (amount < 0)
	452	amount = 0;
	453	err = put_user(amount, (int __user *) arg);
	454	break;
	455
	456	case TIOCINQ:
	457	if (sk->sk_state == BT_LISTEN)
	458	return -EINVAL;
	459
	460	lock_sock(sk);
	461	skb = skb_peek(&sk->sk_receive_queue);
	462	amount = skb ? skb->len : 0;
	463	release_sock(sk);
	464	err = put_user(amount, (int __user *) arg);
	465	break;
	466
3241ad82 MH	467	case SIOCGSTAMP:
	468	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	469	break;
	470
	471	case SIOCGSTAMPNS:
	472	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	473	break;
	474
	475	default:
	476	err = -ENOIOCTLCMD;
	477	break;
	478	}
	479
	480	return err;
	481	}
	482	EXPORT_SYMBOL(bt_sock_ioctl);
	483
1da177e4 LT	484	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	485	{
	486	DECLARE_WAITQUEUE(wait, current);
	487	int err = 0;
	488
	489	BT_DBG("sk %p", sk);
	490
aa395145	491	add_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	492	while (sk->sk_state != state) {
	493	set_current_state(TASK_INTERRUPTIBLE);
	494
	495	if (!timeo) {
b4c612a4	496	err = -EINPROGRESS;
1da177e4 LT	497	break;
	498	}
	499
	500	if (signal_pending(current)) {
	501	err = sock_intr_errno(timeo);
	502	break;
	503	}
	504
	505	release_sock(sk);
	506	timeo = schedule_timeout(timeo);
	507	lock_sock(sk);
	508
c1cbe4b7 BL	509	err = sock_error(sk);
c1cbe4b7 BL	510	if (err)
1da177e4	511	break;
1da177e4 LT	512	}
1da177e4 LT	513	set_current_state(TASK_RUNNING);
aa395145	514	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	515	return err;
	516	}
	517	EXPORT_SYMBOL(bt_sock_wait_state);
	518
	519	static struct net_proto_family bt_sock_family_ops = {
	520	.owner = THIS_MODULE,
	521	.family = PF_BLUETOOTH,
	522	.create = bt_sock_create,
	523	};
	524
1da177e4 LT	525	static int __init bt_init(void)
1da177e4 LT	526	{
27d35284 MH	527	int err;
27d35284 MH	528
1da177e4 LT	529	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	530
27d35284 MH	531	err = bt_sysfs_init();
	532	if (err < 0)
	533	return err;
1da177e4	534
27d35284 MH	535	err = sock_register(&bt_sock_family_ops);
	536	if (err < 0) {
	537	bt_sysfs_cleanup();
	538	return err;
	539	}
1da177e4	540
27d35284	541	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	542
	543	hci_sock_init();
	544
	545	return 0;
	546	}
	547
	548	static void __exit bt_exit(void)
	549	{
	550	hci_sock_cleanup();
	551
1da177e4	552	sock_unregister(PF_BLUETOOTH);
27d35284 MH	553
27d35284 MH	554	bt_sysfs_cleanup();
1da177e4 LT	555	}
	556
	557	subsys_initcall(bt_init);
	558	module_exit(bt_exit);
	559
63fbd24e	560	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	561	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	562	MODULE_VERSION(VERSION);
	563	MODULE_LICENSE("GPL");
	564	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);