[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 <asm/ioctls.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",
};

void bt_sock_reclassify_lock(struct sock *sk, int proto)
{
	BUG_ON(!sk);
	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]);
}
EXPORT_SYMBOL(bt_sock_reclassify_lock);

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);
		if (!err)
			bt_sock_reclassify_lock(sock->sk, 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(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

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