[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/slab.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.15"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static 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, 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 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);
		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;

	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
		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_timestamp(msg, sk, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}
EXPORT_SYMBOL(bt_sock_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->sk_sleep, 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;

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

	if (!skb_queue_empty(&sk->sk_receive_queue) ||
			(sk->sk_shutdown & RCV_SHUTDOWN))
		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->sk_sleep, &wait);
	while (sk->sk_state != state) {
		set_current_state(TASK_INTERRUPTIBLE);

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

		err = sock_error(sk);
		if (err)
			break;
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(sk->sk_sleep, &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");

	hci_sock_init();

	return 0;
}

static void __exit bt_exit(void)
{
	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 LT	33	#include <linux/sched.h>
	34	#include <linux/slab.h>
	35	#include <linux/skbuff.h>
	36	#include <linux/init.h>
	37	#include <linux/poll.h>
1da177e4	38	#include <net/sock.h>
3241ad82	39	#include <asm/ioctls.h>
1da177e4	40	#include <linux/kmod.h>
1da177e4 LT	41
	42	#include <net/bluetooth/bluetooth.h>
	43
5f9018af	44	#define VERSION "2.15"
1da177e4 LT	45
	46	/* Bluetooth sockets */
	47	#define BT_MAX_PROTO 8
	48	static struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2	49	static DEFINE_RWLOCK(bt_proto_lock);
68845cb2	50
68845cb2	51	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc	52	static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	53	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	54	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	55	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	56	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	57	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	58	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	59	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	60	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
	61	};
	62
db7aa1c2	63	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc	64	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	65	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	66	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	67	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	68	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	69	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	70	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	71	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	72	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
	73	};
db7aa1c2 MH	74
	75	static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
	76	{
	77	struct sock *sk = sock->sk;
	78
	79	if (!sk)
	80	return;
	81
	82	BUG_ON(sock_owned_by_user(sk));
	83
	84	sock_lock_init_class_and_name(sk,
	85	bt_slock_key_strings[proto], &bt_slock_key[proto],
	86	bt_key_strings[proto], &bt_lock_key[proto]);
	87	}
1da177e4 LT	88
	89	int bt_sock_register(int proto, struct net_proto_family *ops)
	90	{
74da626a MH	91	int err = 0;
74da626a MH	92
1da177e4 LT	93	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	94	return -EINVAL;
	95
74da626a MH	96	write_lock(&bt_proto_lock);
74da626a MH	97
1da177e4	98	if (bt_proto[proto])
74da626a MH	99	err = -EEXIST;
	100	else
	101	bt_proto[proto] = ops;
	102
	103	write_unlock(&bt_proto_lock);
1da177e4	104
74da626a	105	return err;
1da177e4 LT	106	}
	107	EXPORT_SYMBOL(bt_sock_register);
	108
	109	int bt_sock_unregister(int proto)
	110	{
74da626a MH	111	int err = 0;
74da626a MH	112
1da177e4 LT	113	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	114	return -EINVAL;
	115
74da626a MH	116	write_lock(&bt_proto_lock);
74da626a MH	117
1da177e4	118	if (!bt_proto[proto])
74da626a MH	119	err = -ENOENT;
	120	else
	121	bt_proto[proto] = NULL;
1da177e4	122
74da626a MH	123	write_unlock(&bt_proto_lock);
	124
	125	return err;
1da177e4 LT	126	}
	127	EXPORT_SYMBOL(bt_sock_unregister);
	128
1b8d7ae4	129	static int bt_sock_create(struct net net, struct socket sock, int proto)
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)) {
1b8d7ae4	147	err = bt_proto[proto]->create(net, sock, proto);
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
	205	lock_sock(sk);
	206
	207	/* FIXME: Is this check still needed */
	208	if (sk->sk_state == BT_CLOSED) {
	209	release_sock(sk);
	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);
	219	release_sock(sk);
	220	return sk;
	221	}
	222
	223	release_sock(sk);
	224	}
	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
	243	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
	244	if (sk->sk_shutdown & RCV_SHUTDOWN)
	245	return 0;
	246	return err;
	247	}
	248
	249	msg->msg_namelen = 0;
	250
	251	copied = skb->len;
	252	if (len < copied) {
	253	msg->msg_flags \|= MSG_TRUNC;
	254	copied = len;
	255	}
	256
badff6d0	257	skb_reset_transport_header(skb);
1da177e4	258	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
3241ad82 MH	259	if (err == 0)
3241ad82 MH	260	sock_recv_timestamp(msg, sk, skb);
1da177e4 LT	261
	262	skb_free_datagram(sk, skb);
	263
	264	return err ? : copied;
	265	}
	266	EXPORT_SYMBOL(bt_sock_recvmsg);
	267
	268	static inline unsigned int bt_accept_poll(struct sock *parent)
	269	{
	270	struct list_head p, n;
	271	struct sock *sk;
	272
	273	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	274	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	275	if (sk->sk_state == BT_CONNECTED \|\|
	276	(bt_sk(parent)->defer_setup &&
	277	sk->sk_state == BT_CONNECT2))
1da177e4 LT	278	return POLLIN \| POLLRDNORM;
	279	}
	280
	281	return 0;
	282	}
	283
	284	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	285	{
	286	struct sock *sk = sock->sk;
	287	unsigned int mask = 0;
	288
	289	BT_DBG("sock %p, sk %p", sock, sk);
	290
	291	poll_wait(file, sk->sk_sleep, wait);
	292
	293	if (sk->sk_state == BT_LISTEN)
	294	return bt_accept_poll(sk);
	295
	296	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	297	mask \|= POLLERR;
	298
f348d70a DL	299	if (sk->sk_shutdown & RCV_SHUTDOWN)
	300	mask \|= POLLRDHUP;
	301
1da177e4 LT	302	if (sk->sk_shutdown == SHUTDOWN_MASK)
	303	mask \|= POLLHUP;
	304
8e87d142	305	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
1da177e4 LT	306	(sk->sk_shutdown & RCV_SHUTDOWN))
	307	mask \|= POLLIN \| POLLRDNORM;
	308
	309	if (sk->sk_state == BT_CLOSED)
	310	mask \|= POLLHUP;
	311
	312	if (sk->sk_state == BT_CONNECT \|\|
	313	sk->sk_state == BT_CONNECT2 \|\|
	314	sk->sk_state == BT_CONFIG)
	315	return mask;
	316
	317	if (sock_writeable(sk))
	318	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	319	else
	320	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	321
	322	return mask;
	323	}
	324	EXPORT_SYMBOL(bt_sock_poll);
	325
3241ad82 MH	326	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	327	{
	328	struct sock *sk = sock->sk;
43cbeee9 MH	329	struct sk_buff *skb;
43cbeee9 MH	330	long amount;
3241ad82 MH	331	int err;
	332
	333	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	334
	335	switch (cmd) {
43cbeee9 MH	336	case TIOCOUTQ:
	337	if (sk->sk_state == BT_LISTEN)
	338	return -EINVAL;
	339
31e6d363	340	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	341	if (amount < 0)
	342	amount = 0;
	343	err = put_user(amount, (int __user *) arg);
	344	break;
	345
	346	case TIOCINQ:
	347	if (sk->sk_state == BT_LISTEN)
	348	return -EINVAL;
	349
	350	lock_sock(sk);
	351	skb = skb_peek(&sk->sk_receive_queue);
	352	amount = skb ? skb->len : 0;
	353	release_sock(sk);
	354	err = put_user(amount, (int __user *) arg);
	355	break;
	356
3241ad82 MH	357	case SIOCGSTAMP:
	358	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	359	break;
	360
	361	case SIOCGSTAMPNS:
	362	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	363	break;
	364
	365	default:
	366	err = -ENOIOCTLCMD;
	367	break;
	368	}
	369
	370	return err;
	371	}
	372	EXPORT_SYMBOL(bt_sock_ioctl);
	373
1da177e4 LT	374	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	375	{
	376	DECLARE_WAITQUEUE(wait, current);
	377	int err = 0;
	378
	379	BT_DBG("sk %p", sk);
	380
	381	add_wait_queue(sk->sk_sleep, &wait);
	382	while (sk->sk_state != state) {
	383	set_current_state(TASK_INTERRUPTIBLE);
	384
	385	if (!timeo) {
b4c612a4	386	err = -EINPROGRESS;
1da177e4 LT	387	break;
	388	}
	389
	390	if (signal_pending(current)) {
	391	err = sock_intr_errno(timeo);
	392	break;
	393	}
	394
	395	release_sock(sk);
	396	timeo = schedule_timeout(timeo);
	397	lock_sock(sk);
	398
c1cbe4b7 BL	399	err = sock_error(sk);
c1cbe4b7 BL	400	if (err)
1da177e4	401	break;
1da177e4 LT	402	}
	403	set_current_state(TASK_RUNNING);
	404	remove_wait_queue(sk->sk_sleep, &wait);
	405	return err;
	406	}
	407	EXPORT_SYMBOL(bt_sock_wait_state);
	408
	409	static struct net_proto_family bt_sock_family_ops = {
	410	.owner = THIS_MODULE,
	411	.family = PF_BLUETOOTH,
	412	.create = bt_sock_create,
	413	};
	414
1da177e4 LT	415	static int __init bt_init(void)
1da177e4 LT	416	{
27d35284 MH	417	int err;
27d35284 MH	418
1da177e4 LT	419	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	420
27d35284 MH	421	err = bt_sysfs_init();
	422	if (err < 0)
	423	return err;
1da177e4	424
27d35284 MH	425	err = sock_register(&bt_sock_family_ops);
	426	if (err < 0) {
	427	bt_sysfs_cleanup();
	428	return err;
	429	}
1da177e4	430
27d35284	431	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	432
	433	hci_sock_init();
	434
	435	return 0;
	436	}
	437
	438	static void __exit bt_exit(void)
	439	{
	440	hci_sock_cleanup();
	441
1da177e4	442	sock_unregister(PF_BLUETOOTH);
27d35284 MH	443
27d35284 MH	444	bt_sysfs_cleanup();
1da177e4 LT	445	}
	446
	447	subsys_initcall(bt_init);
	448	module_exit(bt_exit);
	449
63fbd24e	450	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	451	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	452	MODULE_VERSION(VERSION);
	453	MODULE_LICENSE("GPL");
	454	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);