[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",
};

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 ||
						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 (!bt_sk(sk)->suspended && 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 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
64274518	43	#define VERSION "2.16"
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	73
b5a30dda	74	void bt_sock_reclassify_lock(struct sock *sk, int proto)
db7aa1c2	75	{
b5a30dda	76	BUG_ON(!sk);
db7aa1c2 MH	77	BUG_ON(sock_owned_by_user(sk));
	78
	79	sock_lock_init_class_and_name(sk,
	80	bt_slock_key_strings[proto], &bt_slock_key[proto],
	81	bt_key_strings[proto], &bt_lock_key[proto]);
	82	}
b5a30dda	83	EXPORT_SYMBOL(bt_sock_reclassify_lock);
1da177e4	84
ec1b4cf7	85	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	86	{
74da626a MH	87	int err = 0;
74da626a MH	88
1da177e4 LT	89	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	90	return -EINVAL;
	91
74da626a MH	92	write_lock(&bt_proto_lock);
74da626a MH	93
1da177e4	94	if (bt_proto[proto])
74da626a MH	95	err = -EEXIST;
	96	else
	97	bt_proto[proto] = ops;
	98
	99	write_unlock(&bt_proto_lock);
1da177e4	100
74da626a	101	return err;
1da177e4 LT	102	}
	103	EXPORT_SYMBOL(bt_sock_register);
	104
	105	int bt_sock_unregister(int proto)
	106	{
74da626a MH	107	int err = 0;
74da626a MH	108
1da177e4 LT	109	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	110	return -EINVAL;
	111
74da626a MH	112	write_lock(&bt_proto_lock);
74da626a MH	113
1da177e4	114	if (!bt_proto[proto])
74da626a MH	115	err = -ENOENT;
	116	else
	117	bt_proto[proto] = NULL;
1da177e4	118
74da626a MH	119	write_unlock(&bt_proto_lock);
	120
	121	return err;
1da177e4 LT	122	}
	123	EXPORT_SYMBOL(bt_sock_unregister);
	124
3f378b68 EP	125	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	126	int kern)
1da177e4	127	{
74da626a	128	int err;
1da177e4	129
1b8d7ae4 EB	130	if (net != &init_net)
	131	return -EAFNOSUPPORT;
	132
1da177e4 LT	133	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	134	return -EINVAL;
	135
95a5afca	136	if (!bt_proto[proto])
1da177e4	137	request_module("bt-proto-%d", proto);
74da626a	138
1da177e4	139	err = -EPROTONOSUPPORT;
74da626a MH	140
	141	read_lock(&bt_proto_lock);
	142
1da177e4	143	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	144	err = bt_proto[proto]->create(net, sock, proto, kern);
b5a30dda OP	145	if (!err)
b5a30dda OP	146	bt_sock_reclassify_lock(sock->sk, proto);
1da177e4 LT	147	module_put(bt_proto[proto]->owner);
1da177e4 LT	148	}
74da626a MH	149
	150	read_unlock(&bt_proto_lock);
	151
8e87d142	152	return err;
1da177e4 LT	153	}
	154
	155	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	156	{
94f5bfb8	157	write_lock(&l->lock);
1da177e4	158	sk_add_node(sk, &l->head);
94f5bfb8	159	write_unlock(&l->lock);
1da177e4 LT	160	}
	161	EXPORT_SYMBOL(bt_sock_link);
	162
	163	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	164	{
94f5bfb8	165	write_lock(&l->lock);
1da177e4	166	sk_del_node_init(sk);
94f5bfb8	167	write_unlock(&l->lock);
1da177e4 LT	168	}
	169	EXPORT_SYMBOL(bt_sock_unlink);
	170
	171	void bt_accept_enqueue(struct sock parent, struct sock sk)
	172	{
	173	BT_DBG("parent %p, sk %p", parent, sk);
	174
	175	sock_hold(sk);
	176	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	177	bt_sk(sk)->parent = parent;
	178	parent->sk_ack_backlog++;
	179	}
	180	EXPORT_SYMBOL(bt_accept_enqueue);
	181
	182	void bt_accept_unlink(struct sock *sk)
	183	{
	184	BT_DBG("sk %p state %d", sk, sk->sk_state);
	185
	186	list_del_init(&bt_sk(sk)->accept_q);
	187	bt_sk(sk)->parent->sk_ack_backlog--;
	188	bt_sk(sk)->parent = NULL;
	189	sock_put(sk);
	190	}
	191	EXPORT_SYMBOL(bt_accept_unlink);
	192
	193	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	194	{
	195	struct list_head p, n;
	196	struct sock *sk;
	197
	198	BT_DBG("parent %p", parent);
	199
	200	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	201	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	202
8a154a8f	203	lock_sock(sk);
1da177e4 LT	204
	205	/* FIXME: Is this check still needed */
	206	if (sk->sk_state == BT_CLOSED) {
8a154a8f	207	release_sock(sk);
1da177e4 LT	208	bt_accept_unlink(sk);
	209	continue;
	210	}
	211
c4f912e1 MH	212	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
c4f912e1 MH	213	bt_sk(parent)->defer_setup) {
1da177e4 LT	214	bt_accept_unlink(sk);
	215	if (newsock)
	216	sock_graft(sk, newsock);
d37f50e1	217
8a154a8f	218	release_sock(sk);
1da177e4 LT	219	return sk;
	220	}
	221
8a154a8f	222	release_sock(sk);
1da177e4	223	}
d37f50e1	224
1da177e4 LT	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);
5b668eb3	347	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	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)) {
5b668eb3 MM	359	int skb_len = skb_headlen(skb);
	360
	361	if (chunk <= skb_len) {
	362	__skb_pull(skb, chunk);
	363	} else {
	364	struct sk_buff *frag;
	365
	366	__skb_pull(skb, skb_len);
	367	chunk -= skb_len;
	368
	369	skb_walk_frags(skb, frag) {
	370	if (chunk <= frag->len) {
	371	/* Pulling partial data */
	372	skb->len -= chunk;
	373	skb->data_len -= chunk;
	374	__skb_pull(frag, chunk);
	375	break;
	376	} else if (frag->len) {
	377	/* Pulling all frag data */
	378	chunk -= frag->len;
	379	skb->len -= frag->len;
	380	skb->data_len -= frag->len;
	381	__skb_pull(frag, frag->len);
	382	}
	383	}
	384	}
	385
796c86ee MM	386	if (skb->len) {
	387	skb_queue_head(&sk->sk_receive_queue, skb);
	388	break;
	389	}
	390	kfree_skb(skb);
	391
	392	} else {
	393	/* put message back and return */
	394	skb_queue_head(&sk->sk_receive_queue, skb);
	395	break;
	396	}
	397	} while (size);
	398
	399	out:
	400	release_sock(sk);
	401	return copied ? : err;
	402	}
	403	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	404
1da177e4 LT	405	static inline unsigned int bt_accept_poll(struct sock *parent)
	406	{
	407	struct list_head p, n;
	408	struct sock *sk;
	409
	410	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	411	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	412	if (sk->sk_state == BT_CONNECTED \|\|
	413	(bt_sk(parent)->defer_setup &&
	414	sk->sk_state == BT_CONNECT2))
1da177e4 LT	415	return POLLIN \| POLLRDNORM;
	416	}
	417
	418	return 0;
	419	}
	420
8ffd8784	421	unsigned int bt_sock_poll(struct file file, struct socket sock, poll_table *wait)
1da177e4 LT	422	{
	423	struct sock *sk = sock->sk;
	424	unsigned int mask = 0;
	425
	426	BT_DBG("sock %p, sk %p", sock, sk);
	427
aa395145	428	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	429
	430	if (sk->sk_state == BT_LISTEN)
	431	return bt_accept_poll(sk);
	432
	433	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	434	mask \|= POLLERR;
	435
f348d70a	436	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	437	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	438
1da177e4 LT	439	if (sk->sk_shutdown == SHUTDOWN_MASK)
	440	mask \|= POLLHUP;
	441
db40980f	442	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	443	mask \|= POLLIN \| POLLRDNORM;
	444
	445	if (sk->sk_state == BT_CLOSED)
	446	mask \|= POLLHUP;
	447
	448	if (sk->sk_state == BT_CONNECT \|\|
	449	sk->sk_state == BT_CONNECT2 \|\|
	450	sk->sk_state == BT_CONFIG)
	451	return mask;
	452
a7d7723a	453	if (!bt_sk(sk)->suspended && sock_writeable(sk))
1da177e4 LT	454	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	455	else
	456	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	457
	458	return mask;
	459	}
	460	EXPORT_SYMBOL(bt_sock_poll);
	461
3241ad82 MH	462	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	463	{
	464	struct sock *sk = sock->sk;
43cbeee9 MH	465	struct sk_buff *skb;
43cbeee9 MH	466	long amount;
3241ad82 MH	467	int err;
	468
	469	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	470
	471	switch (cmd) {
43cbeee9 MH	472	case TIOCOUTQ:
	473	if (sk->sk_state == BT_LISTEN)
	474	return -EINVAL;
	475
31e6d363	476	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	477	if (amount < 0)
	478	amount = 0;
	479	err = put_user(amount, (int __user *) arg);
	480	break;
	481
	482	case TIOCINQ:
	483	if (sk->sk_state == BT_LISTEN)
	484	return -EINVAL;
	485
	486	lock_sock(sk);
	487	skb = skb_peek(&sk->sk_receive_queue);
	488	amount = skb ? skb->len : 0;
	489	release_sock(sk);
	490	err = put_user(amount, (int __user *) arg);
	491	break;
	492
3241ad82 MH	493	case SIOCGSTAMP:
	494	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	495	break;
	496
	497	case SIOCGSTAMPNS:
	498	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	499	break;
	500
	501	default:
	502	err = -ENOIOCTLCMD;
	503	break;
	504	}
	505
	506	return err;
	507	}
	508	EXPORT_SYMBOL(bt_sock_ioctl);
	509
1da177e4 LT	510	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	511	{
	512	DECLARE_WAITQUEUE(wait, current);
	513	int err = 0;
	514
	515	BT_DBG("sk %p", sk);
	516
aa395145	517	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	518	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	519	while (sk->sk_state != state) {
1da177e4	520	if (!timeo) {
b4c612a4	521	err = -EINPROGRESS;
1da177e4 LT	522	break;
	523	}
	524
	525	if (signal_pending(current)) {
	526	err = sock_intr_errno(timeo);
	527	break;
	528	}
	529
	530	release_sock(sk);
	531	timeo = schedule_timeout(timeo);
	532	lock_sock(sk);
9be4e3fb	533	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	534
c1cbe4b7 BL	535	err = sock_error(sk);
c1cbe4b7 BL	536	if (err)
1da177e4	537	break;
1da177e4	538	}
9be4e3fb	539	__set_current_state(TASK_RUNNING);
aa395145	540	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	541	return err;
	542	}
	543	EXPORT_SYMBOL(bt_sock_wait_state);
	544
	545	static struct net_proto_family bt_sock_family_ops = {
	546	.owner = THIS_MODULE,
	547	.family = PF_BLUETOOTH,
	548	.create = bt_sock_create,
	549	};
	550
1da177e4 LT	551	static int __init bt_init(void)
1da177e4 LT	552	{
27d35284 MH	553	int err;
27d35284 MH	554
1da177e4 LT	555	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	556
27d35284 MH	557	err = bt_sysfs_init();
	558	if (err < 0)
	559	return err;
1da177e4	560
27d35284 MH	561	err = sock_register(&bt_sock_family_ops);
	562	if (err < 0) {
	563	bt_sysfs_cleanup();
	564	return err;
	565	}
1da177e4	566
27d35284	567	BT_INFO("HCI device and connection manager initialized");
1da177e4	568
64274518 GP	569	err = hci_sock_init();
	570	if (err < 0)
	571	goto error;
	572
	573	err = l2cap_init();
0ed54dad	574	if (err < 0)
64274518	575	goto sock_err;
64274518 GP	576
	577	err = sco_init();
	578	if (err < 0) {
	579	l2cap_exit();
	580	goto sock_err;
	581	}
1da177e4 LT	582
1da177e4 LT	583	return 0;
64274518 GP	584
	585	sock_err:
	586	hci_sock_cleanup();
	587
	588	error:
	589	sock_unregister(PF_BLUETOOTH);
	590	bt_sysfs_cleanup();
	591
	592	return err;
1da177e4 LT	593	}
	594
	595	static void __exit bt_exit(void)
	596	{
64274518 GP	597
	598	sco_exit();
	599
	600	l2cap_exit();
	601
1da177e4 LT	602	hci_sock_cleanup();
1da177e4 LT	603
1da177e4	604	sock_unregister(PF_BLUETOOTH);
27d35284 MH	605
27d35284 MH	606	bt_sysfs_cleanup();
1da177e4 LT	607	}
	608
	609	subsys_initcall(bt_init);
	610	module_exit(bt_exit);
	611
63fbd24e	612	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	613	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	614	MODULE_VERSION(VERSION);
	615	MODULE_LICENSE("GPL");
	616	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);