[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / af_bluetooth.c

/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth address family and sockets. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <net/sock.h>
#include <asm/ioctls.h>
#include <linux/kmod.h>

#include <net/bluetooth/bluetooth.h>

#define VERSION "2.16"

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

static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
static const char *const bt_key_strings[BT_MAX_PROTO] = {
	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
{
	struct sock *sk = sock->sk;

	if (!sk)
		return;

	BUG_ON(sock_owned_by_user(sk));

	sock_lock_init_class_and_name(sk,
			bt_slock_key_strings[proto], &bt_slock_key[proto],
				bt_key_strings[proto], &bt_lock_key[proto]);
}

int bt_sock_register(int proto, const struct net_proto_family *ops)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (bt_proto[proto])
		err = -EEXIST;
	else
		bt_proto[proto] = ops;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_register);

int bt_sock_unregister(int proto)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (!bt_proto[proto])
		err = -ENOENT;
	else
		bt_proto[proto] = NULL;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct net *net, struct socket *sock, int proto,
			  int kern)
{
	int err;

	if (net != &init_net)
		return -EAFNOSUPPORT;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	if (!bt_proto[proto])
		request_module("bt-proto-%d", proto);

	err = -EPROTONOSUPPORT;

	read_lock(&bt_proto_lock);

	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(net, sock, proto, kern);
		bt_sock_reclassify_lock(sock, proto);
		module_put(bt_proto[proto]->owner);
	}

	read_unlock(&bt_proto_lock);

	return err;
}

void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_del_node_init(sk);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_unlink);

void bt_accept_enqueue(struct sock *parent, struct sock *sk)
{
	BT_DBG("parent %p, sk %p", parent, sk);

	sock_hold(sk);
	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	bt_sk(sk)->parent = parent;
	parent->sk_ack_backlog++;
}
EXPORT_SYMBOL(bt_accept_enqueue);

void bt_accept_unlink(struct sock *sk)
{
	BT_DBG("sk %p state %d", sk, sk->sk_state);

	list_del_init(&bt_sk(sk)->accept_q);
	bt_sk(sk)->parent->sk_ack_backlog--;
	bt_sk(sk)->parent = NULL;
	sock_put(sk);
}
EXPORT_SYMBOL(bt_accept_unlink);

struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
{
	struct list_head *p, *n;
	struct sock *sk;

	BT_DBG("parent %p", parent);

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

		lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			release_sock(sk);
			bt_accept_unlink(sk);
			continue;
		}

		if (sk->sk_state == BT_CONNECTED || !newsock ||
						bt_sk(parent)->defer_setup) {
			bt_accept_unlink(sk);
			if (newsock)
				sock_graft(sk, newsock);

			release_sock(sk);
			return sk;
		}

		release_sock(sk);
	}

	return NULL;
}
EXPORT_SYMBOL(bt_accept_dequeue);

int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	size_t copied;
	int err;

	BT_DBG("sock %p sk %p len %zu", sock, sk, len);

	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb) {
		if (sk->sk_shutdown & RCV_SHUTDOWN)
			return 0;
		return err;
	}

	msg->msg_namelen = 0;

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	skb_reset_transport_header(skb);
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err == 0)
		sock_recv_ts_and_drops(msg, sk, skb);

	skb_free_datagram(sk, skb);

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

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

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

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

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

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

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

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

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

	if (flags & MSG_OOB)
		return -EOPNOTSUPP;

	msg->msg_namelen = 0;

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

	lock_sock(sk);

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

	do {
		struct sk_buff *skb;
		int chunk;

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

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

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

			timeo = bt_sock_data_wait(sk, timeo);

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

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

		sock_recv_ts_and_drops(msg, sk, skb);

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

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

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

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

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

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

out:
	release_sock(sk);
	return copied ? : err;
}
EXPORT_SYMBOL(bt_sock_stream_recvmsg);

static inline unsigned int bt_accept_poll(struct sock *parent)
{
	struct list_head *p, *n;
	struct sock *sk;

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
		if (sk->sk_state == BT_CONNECTED ||
					(bt_sk(parent)->defer_setup &&
						sk->sk_state == BT_CONNECT2))
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask = 0;

	BT_DBG("sock %p, sk %p", sock, sk);

	poll_wait(file, sk_sleep(sk), wait);

	if (sk->sk_state == BT_LISTEN)
		return bt_accept_poll(sk);

	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
		mask |= POLLERR;

	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP | POLLIN | POLLRDNORM;

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

	if (!skb_queue_empty(&sk->sk_receive_queue))
		mask |= POLLIN | POLLRDNORM;

	if (sk->sk_state == BT_CLOSED)
		mask |= POLLHUP;

	if (sk->sk_state == BT_CONNECT ||
			sk->sk_state == BT_CONNECT2 ||
			sk->sk_state == BT_CONFIG)
		return mask;

	if (sock_writeable(sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
	else
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

	return mask;
}
EXPORT_SYMBOL(bt_sock_poll);

int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	long amount;
	int err;

	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);

	switch (cmd) {
	case TIOCOUTQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
		if (amount < 0)
			amount = 0;
		err = put_user(amount, (int __user *) arg);
		break;

	case TIOCINQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		lock_sock(sk);
		skb = skb_peek(&sk->sk_receive_queue);
		amount = skb ? skb->len : 0;
		release_sock(sk);
		err = put_user(amount, (int __user *) arg);
		break;

	case SIOCGSTAMP:
		err = sock_get_timestamp(sk, (struct timeval __user *) arg);
		break;

	case SIOCGSTAMPNS:
		err = sock_get_timestampns(sk, (struct timespec __user *) arg);
		break;

	default:
		err = -ENOIOCTLCMD;
		break;
	}

	return err;
}
EXPORT_SYMBOL(bt_sock_ioctl);

int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
{
	DECLARE_WAITQUEUE(wait, current);
	int err = 0;

	BT_DBG("sk %p", sk);

	add_wait_queue(sk_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (sk->sk_state != state) {
		if (!timeo) {
			err = -EINPROGRESS;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		set_current_state(TASK_INTERRUPTIBLE);

		err = sock_error(sk);
		if (err)
			break;
	}
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return err;
}
EXPORT_SYMBOL(bt_sock_wait_state);

static struct net_proto_family bt_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_BLUETOOTH,
	.create	= bt_sock_create,
};

static int __init bt_init(void)
{
	int err;

	BT_INFO("Core ver %s", VERSION);

	err = bt_sysfs_init();
	if (err < 0)
		return err;

	err = sock_register(&bt_sock_family_ops);
	if (err < 0) {
		bt_sysfs_cleanup();
		return err;
	}

	BT_INFO("HCI device and connection manager initialized");

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

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

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

	return 0;

sock_err:
	hci_sock_cleanup();

error:
	sock_unregister(PF_BLUETOOTH);
	bt_sysfs_cleanup();

	return err;
}

static void __exit bt_exit(void)
{

	sco_exit();

	l2cap_exit();

	hci_sock_cleanup();

	sock_unregister(PF_BLUETOOTH);

	bt_sysfs_cleanup();
}

subsys_initcall(bt_init);
module_exit(bt_exit);

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