[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 (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
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);
5b668eb3	352	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	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)) {
5b668eb3 MM	364	int skb_len = skb_headlen(skb);
	365
	366	if (chunk <= skb_len) {
	367	__skb_pull(skb, chunk);
	368	} else {
	369	struct sk_buff *frag;
	370
	371	__skb_pull(skb, skb_len);
	372	chunk -= skb_len;
	373
	374	skb_walk_frags(skb, frag) {
	375	if (chunk <= frag->len) {
	376	/* Pulling partial data */
	377	skb->len -= chunk;
	378	skb->data_len -= chunk;
	379	__skb_pull(frag, chunk);
	380	break;
	381	} else if (frag->len) {
	382	/* Pulling all frag data */
	383	chunk -= frag->len;
	384	skb->len -= frag->len;
	385	skb->data_len -= frag->len;
	386	__skb_pull(frag, frag->len);
	387	}
	388	}
	389	}
	390
796c86ee MM	391	if (skb->len) {
	392	skb_queue_head(&sk->sk_receive_queue, skb);
	393	break;
	394	}
	395	kfree_skb(skb);
	396
	397	} else {
	398	/* put message back and return */
	399	skb_queue_head(&sk->sk_receive_queue, skb);
	400	break;
	401	}
	402	} while (size);
	403
	404	out:
	405	release_sock(sk);
	406	return copied ? : err;
	407	}
	408	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	409
1da177e4 LT	410	static inline unsigned int bt_accept_poll(struct sock *parent)
	411	{
	412	struct list_head p, n;
	413	struct sock *sk;
	414
	415	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	416	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	417	if (sk->sk_state == BT_CONNECTED \|\|
	418	(bt_sk(parent)->defer_setup &&
	419	sk->sk_state == BT_CONNECT2))
1da177e4 LT	420	return POLLIN \| POLLRDNORM;
	421	}
	422
	423	return 0;
	424	}
	425
8ffd8784	426	unsigned int bt_sock_poll(struct file file, struct socket sock, poll_table *wait)
1da177e4 LT	427	{
	428	struct sock *sk = sock->sk;
	429	unsigned int mask = 0;
	430
	431	BT_DBG("sock %p, sk %p", sock, sk);
	432
aa395145	433	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	434
	435	if (sk->sk_state == BT_LISTEN)
	436	return bt_accept_poll(sk);
	437
	438	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	439	mask \|= POLLERR;
	440
f348d70a	441	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	442	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	443
1da177e4 LT	444	if (sk->sk_shutdown == SHUTDOWN_MASK)
	445	mask \|= POLLHUP;
	446
db40980f	447	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	448	mask \|= POLLIN \| POLLRDNORM;
	449
	450	if (sk->sk_state == BT_CLOSED)
	451	mask \|= POLLHUP;
	452
	453	if (sk->sk_state == BT_CONNECT \|\|
	454	sk->sk_state == BT_CONNECT2 \|\|
	455	sk->sk_state == BT_CONFIG)
	456	return mask;
	457
	458	if (sock_writeable(sk))
	459	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	460	else
	461	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	462
	463	return mask;
	464	}
	465	EXPORT_SYMBOL(bt_sock_poll);
	466
3241ad82 MH	467	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	468	{
	469	struct sock *sk = sock->sk;
43cbeee9 MH	470	struct sk_buff *skb;
43cbeee9 MH	471	long amount;
3241ad82 MH	472	int err;
	473
	474	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	475
	476	switch (cmd) {
43cbeee9 MH	477	case TIOCOUTQ:
	478	if (sk->sk_state == BT_LISTEN)
	479	return -EINVAL;
	480
31e6d363	481	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	482	if (amount < 0)
	483	amount = 0;
	484	err = put_user(amount, (int __user *) arg);
	485	break;
	486
	487	case TIOCINQ:
	488	if (sk->sk_state == BT_LISTEN)
	489	return -EINVAL;
	490
	491	lock_sock(sk);
	492	skb = skb_peek(&sk->sk_receive_queue);
	493	amount = skb ? skb->len : 0;
	494	release_sock(sk);
	495	err = put_user(amount, (int __user *) arg);
	496	break;
	497
3241ad82 MH	498	case SIOCGSTAMP:
	499	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	500	break;
	501
	502	case SIOCGSTAMPNS:
	503	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	504	break;
	505
	506	default:
	507	err = -ENOIOCTLCMD;
	508	break;
	509	}
	510
	511	return err;
	512	}
	513	EXPORT_SYMBOL(bt_sock_ioctl);
	514
1da177e4 LT	515	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	516	{
	517	DECLARE_WAITQUEUE(wait, current);
	518	int err = 0;
	519
	520	BT_DBG("sk %p", sk);
	521
aa395145	522	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	523	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	524	while (sk->sk_state != state) {
1da177e4	525	if (!timeo) {
b4c612a4	526	err = -EINPROGRESS;
1da177e4 LT	527	break;
	528	}
	529
	530	if (signal_pending(current)) {
	531	err = sock_intr_errno(timeo);
	532	break;
	533	}
	534
	535	release_sock(sk);
	536	timeo = schedule_timeout(timeo);
	537	lock_sock(sk);
9be4e3fb	538	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	539
c1cbe4b7 BL	540	err = sock_error(sk);
c1cbe4b7 BL	541	if (err)
1da177e4	542	break;
1da177e4	543	}
9be4e3fb	544	__set_current_state(TASK_RUNNING);
aa395145	545	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	546	return err;
	547	}
	548	EXPORT_SYMBOL(bt_sock_wait_state);
	549
	550	static struct net_proto_family bt_sock_family_ops = {
	551	.owner = THIS_MODULE,
	552	.family = PF_BLUETOOTH,
	553	.create = bt_sock_create,
	554	};
	555
1da177e4 LT	556	static int __init bt_init(void)
1da177e4 LT	557	{
27d35284 MH	558	int err;
27d35284 MH	559
1da177e4 LT	560	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	561
27d35284 MH	562	err = bt_sysfs_init();
	563	if (err < 0)
	564	return err;
1da177e4	565
27d35284 MH	566	err = sock_register(&bt_sock_family_ops);
	567	if (err < 0) {
	568	bt_sysfs_cleanup();
	569	return err;
	570	}
1da177e4	571
27d35284	572	BT_INFO("HCI device and connection manager initialized");
1da177e4	573
64274518 GP	574	err = hci_sock_init();
	575	if (err < 0)
	576	goto error;
	577
	578	err = l2cap_init();
0ed54dad	579	if (err < 0)
64274518	580	goto sock_err;
64274518 GP	581
	582	err = sco_init();
	583	if (err < 0) {
	584	l2cap_exit();
	585	goto sock_err;
	586	}
1da177e4 LT	587
1da177e4 LT	588	return 0;
64274518 GP	589
	590	sock_err:
	591	hci_sock_cleanup();
	592
	593	error:
	594	sock_unregister(PF_BLUETOOTH);
	595	bt_sysfs_cleanup();
	596
	597	return err;
1da177e4 LT	598	}
	599
	600	static void __exit bt_exit(void)
	601	{
64274518 GP	602
	603	sco_exit();
	604
	605	l2cap_exit();
	606
1da177e4 LT	607	hci_sock_cleanup();
1da177e4 LT	608
1da177e4	609	sock_unregister(PF_BLUETOOTH);
27d35284 MH	610
27d35284 MH	611	bt_sysfs_cleanup();
1da177e4 LT	612	}
	613
	614	subsys_initcall(bt_init);
	615	module_exit(bt_exit);
	616
63fbd24e	617	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	618	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	619	MODULE_VERSION(VERSION);
	620	MODULE_LICENSE("GPL");
	621	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);