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

	local_bh_disable();
	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);

		bh_lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			bh_unlock_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);

			bh_unlock_sock(sk);
			local_bh_enable();
			return sk;
		}

		bh_unlock_sock(sk);
	}
	local_bh_enable();

	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);
	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 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
d37f50e1	202	local_bh_disable();
1da177e4 LT	203	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	204	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	205
d37f50e1	206	bh_lock_sock(sk);
1da177e4 LT	207
	208	/* FIXME: Is this check still needed */
	209	if (sk->sk_state == BT_CLOSED) {
d37f50e1	210	bh_unlock_sock(sk);
1da177e4 LT	211	bt_accept_unlink(sk);
	212	continue;
	213	}
	214
c4f912e1 MH	215	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
c4f912e1 MH	216	bt_sk(parent)->defer_setup) {
1da177e4 LT	217	bt_accept_unlink(sk);
	218	if (newsock)
	219	sock_graft(sk, newsock);
d37f50e1 AE	220
	221	bh_unlock_sock(sk);
	222	local_bh_enable();
1da177e4 LT	223	return sk;
	224	}
	225
d37f50e1	226	bh_unlock_sock(sk);
1da177e4	227	}
d37f50e1 AE	228	local_bh_enable();
d37f50e1 AE	229
1da177e4 LT	230	return NULL;
	231	}
	232	EXPORT_SYMBOL(bt_accept_dequeue);
	233
	234	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	235	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	236	{
	237	int noblock = flags & MSG_DONTWAIT;
	238	struct sock *sk = sock->sk;
	239	struct sk_buff *skb;
	240	size_t copied;
	241	int err;
	242
a418b893	243	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	244
	245	if (flags & (MSG_OOB))
	246	return -EOPNOTSUPP;
	247
5a08ecce AE	248	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	249	if (!skb) {
1da177e4 LT	250	if (sk->sk_shutdown & RCV_SHUTDOWN)
	251	return 0;
	252	return err;
	253	}
	254
	255	msg->msg_namelen = 0;
	256
	257	copied = skb->len;
	258	if (len < copied) {
	259	msg->msg_flags \|= MSG_TRUNC;
	260	copied = len;
	261	}
	262
badff6d0	263	skb_reset_transport_header(skb);
1da177e4	264	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
3241ad82	265	if (err == 0)
3b885787	266	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 LT	267
	268	skb_free_datagram(sk, skb);
	269
	270	return err ? : copied;
	271	}
	272	EXPORT_SYMBOL(bt_sock_recvmsg);
	273
796c86ee MM	274	static long bt_sock_data_wait(struct sock *sk, long timeo)
	275	{
	276	DECLARE_WAITQUEUE(wait, current);
	277
	278	add_wait_queue(sk_sleep(sk), &wait);
	279	for (;;) {
	280	set_current_state(TASK_INTERRUPTIBLE);
	281
	282	if (!skb_queue_empty(&sk->sk_receive_queue))
	283	break;
	284
	285	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	286	break;
	287
	288	if (signal_pending(current) \|\| !timeo)
	289	break;
	290
	291	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	292	release_sock(sk);
	293	timeo = schedule_timeout(timeo);
	294	lock_sock(sk);
	295	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	296	}
	297
	298	__set_current_state(TASK_RUNNING);
	299	remove_wait_queue(sk_sleep(sk), &wait);
	300	return timeo;
	301	}
	302
	303	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	304	struct msghdr *msg, size_t size, int flags)
	305	{
	306	struct sock *sk = sock->sk;
	307	int err = 0;
	308	size_t target, copied = 0;
	309	long timeo;
	310
	311	if (flags & MSG_OOB)
	312	return -EOPNOTSUPP;
	313
	314	msg->msg_namelen = 0;
	315
	316	BT_DBG("sk %p size %zu", sk, size);
	317
	318	lock_sock(sk);
	319
	320	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	321	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	322
	323	do {
	324	struct sk_buff *skb;
	325	int chunk;
	326
	327	skb = skb_dequeue(&sk->sk_receive_queue);
	328	if (!skb) {
	329	if (copied >= target)
	330	break;
	331
5a08ecce AE	332	err = sock_error(sk);
5a08ecce AE	333	if (err)
796c86ee MM	334	break;
	335	if (sk->sk_shutdown & RCV_SHUTDOWN)
	336	break;
	337
	338	err = -EAGAIN;
	339	if (!timeo)
	340	break;
	341
	342	timeo = bt_sock_data_wait(sk, timeo);
	343
	344	if (signal_pending(current)) {
	345	err = sock_intr_errno(timeo);
	346	goto out;
	347	}
	348	continue;
	349	}
	350
	351	chunk = min_t(unsigned int, skb->len, size);
	352	if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
	353	skb_queue_head(&sk->sk_receive_queue, skb);
	354	if (!copied)
	355	copied = -EFAULT;
	356	break;
	357	}
	358	copied += chunk;
	359	size -= chunk;
	360
	361	sock_recv_ts_and_drops(msg, sk, skb);
	362
	363	if (!(flags & MSG_PEEK)) {
	364	skb_pull(skb, chunk);
	365	if (skb->len) {
	366	skb_queue_head(&sk->sk_receive_queue, skb);
	367	break;
	368	}
	369	kfree_skb(skb);
	370
	371	} else {
	372	/* put message back and return */
	373	skb_queue_head(&sk->sk_receive_queue, skb);
	374	break;
	375	}
	376	} while (size);
	377
	378	out:
	379	release_sock(sk);
	380	return copied ? : err;
	381	}
	382	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	383
1da177e4 LT	384	static inline unsigned int bt_accept_poll(struct sock *parent)
	385	{
	386	struct list_head p, n;
	387	struct sock *sk;
	388
	389	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	390	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	391	if (sk->sk_state == BT_CONNECTED \|\|
	392	(bt_sk(parent)->defer_setup &&
	393	sk->sk_state == BT_CONNECT2))
1da177e4 LT	394	return POLLIN \| POLLRDNORM;
	395	}
	396
	397	return 0;
	398	}
	399
8ffd8784	400	unsigned int bt_sock_poll(struct file file, struct socket sock, poll_table *wait)
1da177e4 LT	401	{
	402	struct sock *sk = sock->sk;
	403	unsigned int mask = 0;
	404
	405	BT_DBG("sock %p, sk %p", sock, sk);
	406
aa395145	407	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	408
	409	if (sk->sk_state == BT_LISTEN)
	410	return bt_accept_poll(sk);
	411
	412	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	413	mask \|= POLLERR;
	414
f348d70a	415	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	416	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	417
1da177e4 LT	418	if (sk->sk_shutdown == SHUTDOWN_MASK)
	419	mask \|= POLLHUP;
	420
db40980f	421	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	422	mask \|= POLLIN \| POLLRDNORM;
	423
	424	if (sk->sk_state == BT_CLOSED)
	425	mask \|= POLLHUP;
	426
	427	if (sk->sk_state == BT_CONNECT \|\|
	428	sk->sk_state == BT_CONNECT2 \|\|
	429	sk->sk_state == BT_CONFIG)
	430	return mask;
	431
	432	if (sock_writeable(sk))
	433	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	434	else
	435	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	436
	437	return mask;
	438	}
	439	EXPORT_SYMBOL(bt_sock_poll);
	440
3241ad82 MH	441	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	442	{
	443	struct sock *sk = sock->sk;
43cbeee9 MH	444	struct sk_buff *skb;
43cbeee9 MH	445	long amount;
3241ad82 MH	446	int err;
	447
	448	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	449
	450	switch (cmd) {
43cbeee9 MH	451	case TIOCOUTQ:
	452	if (sk->sk_state == BT_LISTEN)
	453	return -EINVAL;
	454
31e6d363	455	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	456	if (amount < 0)
	457	amount = 0;
	458	err = put_user(amount, (int __user *) arg);
	459	break;
	460
	461	case TIOCINQ:
	462	if (sk->sk_state == BT_LISTEN)
	463	return -EINVAL;
	464
	465	lock_sock(sk);
	466	skb = skb_peek(&sk->sk_receive_queue);
	467	amount = skb ? skb->len : 0;
	468	release_sock(sk);
	469	err = put_user(amount, (int __user *) arg);
	470	break;
	471
3241ad82 MH	472	case SIOCGSTAMP:
	473	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	474	break;
	475
	476	case SIOCGSTAMPNS:
	477	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	478	break;
	479
	480	default:
	481	err = -ENOIOCTLCMD;
	482	break;
	483	}
	484
	485	return err;
	486	}
	487	EXPORT_SYMBOL(bt_sock_ioctl);
	488
1da177e4 LT	489	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	490	{
	491	DECLARE_WAITQUEUE(wait, current);
	492	int err = 0;
	493
	494	BT_DBG("sk %p", sk);
	495
aa395145	496	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	497	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	498	while (sk->sk_state != state) {
1da177e4	499	if (!timeo) {
b4c612a4	500	err = -EINPROGRESS;
1da177e4 LT	501	break;
	502	}
	503
	504	if (signal_pending(current)) {
	505	err = sock_intr_errno(timeo);
	506	break;
	507	}
	508
	509	release_sock(sk);
	510	timeo = schedule_timeout(timeo);
	511	lock_sock(sk);
9be4e3fb	512	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	513
c1cbe4b7 BL	514	err = sock_error(sk);
c1cbe4b7 BL	515	if (err)
1da177e4	516	break;
1da177e4	517	}
9be4e3fb	518	__set_current_state(TASK_RUNNING);
aa395145	519	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	520	return err;
	521	}
	522	EXPORT_SYMBOL(bt_sock_wait_state);
	523
	524	static struct net_proto_family bt_sock_family_ops = {
	525	.owner = THIS_MODULE,
	526	.family = PF_BLUETOOTH,
	527	.create = bt_sock_create,
	528	};
	529
1da177e4 LT	530	static int __init bt_init(void)
1da177e4 LT	531	{
27d35284 MH	532	int err;
27d35284 MH	533
1da177e4 LT	534	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	535
27d35284 MH	536	err = bt_sysfs_init();
	537	if (err < 0)
	538	return err;
1da177e4	539
27d35284 MH	540	err = sock_register(&bt_sock_family_ops);
	541	if (err < 0) {
	542	bt_sysfs_cleanup();
	543	return err;
	544	}
1da177e4	545
27d35284	546	BT_INFO("HCI device and connection manager initialized");
1da177e4	547
64274518 GP	548	err = hci_sock_init();
	549	if (err < 0)
	550	goto error;
	551
	552	err = l2cap_init();
0ed54dad	553	if (err < 0)
64274518	554	goto sock_err;
64274518 GP	555
	556	err = sco_init();
	557	if (err < 0) {
	558	l2cap_exit();
	559	goto sock_err;
	560	}
1da177e4 LT	561
1da177e4 LT	562	return 0;
64274518 GP	563
	564	sock_err:
	565	hci_sock_cleanup();
	566
	567	error:
	568	sock_unregister(PF_BLUETOOTH);
	569	bt_sysfs_cleanup();
	570
	571	return err;
1da177e4 LT	572	}
	573
	574	static void __exit bt_exit(void)
	575	{
64274518 GP	576
	577	sco_exit();
	578
	579	l2cap_exit();
	580
1da177e4 LT	581	hci_sock_cleanup();
1da177e4 LT	582
1da177e4	583	sock_unregister(PF_BLUETOOTH);
27d35284 MH	584
27d35284 MH	585	bt_sysfs_cleanup();
1da177e4 LT	586	}
	587
	588	subsys_initcall(bt_init);
	589	module_exit(bt_exit);
	590
63fbd24e	591	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	592	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	593	MODULE_VERSION(VERSION);
	594	MODULE_LICENSE("GPL");
	595	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);