[net-next-2.6.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 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;

	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_ts_and_drops(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
ec1b4cf7	48	static const 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	88
ec1b4cf7	89	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	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
3f378b68 EP	129	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	130	int kern)
1da177e4	131	{
74da626a	132	int err;
1da177e4	133
1b8d7ae4 EB	134	if (net != &init_net)
	135	return -EAFNOSUPPORT;
	136
1da177e4 LT	137	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	138	return -EINVAL;
	139
95a5afca	140	if (!bt_proto[proto])
1da177e4	141	request_module("bt-proto-%d", proto);
74da626a	142
1da177e4	143	err = -EPROTONOSUPPORT;
74da626a MH	144
	145	read_lock(&bt_proto_lock);
	146
1da177e4	147	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	148	err = bt_proto[proto]->create(net, sock, proto, kern);
db7aa1c2	149	bt_sock_reclassify_lock(sock, proto);
1da177e4 LT	150	module_put(bt_proto[proto]->owner);
1da177e4 LT	151	}
74da626a MH	152
	153	read_unlock(&bt_proto_lock);
	154
8e87d142	155	return err;
1da177e4 LT	156	}
	157
	158	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	159	{
	160	write_lock_bh(&l->lock);
	161	sk_add_node(sk, &l->head);
	162	write_unlock_bh(&l->lock);
	163	}
	164	EXPORT_SYMBOL(bt_sock_link);
	165
	166	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	167	{
	168	write_lock_bh(&l->lock);
	169	sk_del_node_init(sk);
	170	write_unlock_bh(&l->lock);
	171	}
	172	EXPORT_SYMBOL(bt_sock_unlink);
	173
	174	void bt_accept_enqueue(struct sock parent, struct sock sk)
	175	{
	176	BT_DBG("parent %p, sk %p", parent, sk);
	177
	178	sock_hold(sk);
	179	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	180	bt_sk(sk)->parent = parent;
	181	parent->sk_ack_backlog++;
	182	}
	183	EXPORT_SYMBOL(bt_accept_enqueue);
	184
	185	void bt_accept_unlink(struct sock *sk)
	186	{
	187	BT_DBG("sk %p state %d", sk, sk->sk_state);
	188
	189	list_del_init(&bt_sk(sk)->accept_q);
	190	bt_sk(sk)->parent->sk_ack_backlog--;
	191	bt_sk(sk)->parent = NULL;
	192	sock_put(sk);
	193	}
	194	EXPORT_SYMBOL(bt_accept_unlink);
	195
	196	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	197	{
	198	struct list_head p, n;
	199	struct sock *sk;
	200
	201	BT_DBG("parent %p", parent);
	202
	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
	206	lock_sock(sk);
	207
	208	/* FIXME: Is this check still needed */
	209	if (sk->sk_state == BT_CLOSED) {
	210	release_sock(sk);
	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);
	220	release_sock(sk);
	221	return sk;
	222	}
	223
	224	release_sock(sk);
	225	}
	226	return NULL;
	227	}
	228	EXPORT_SYMBOL(bt_accept_dequeue);
	229
	230	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	231	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	232	{
	233	int noblock = flags & MSG_DONTWAIT;
	234	struct sock *sk = sock->sk;
	235	struct sk_buff *skb;
	236	size_t copied;
	237	int err;
	238
a418b893	239	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	240
	241	if (flags & (MSG_OOB))
	242	return -EOPNOTSUPP;
	243
	244	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
	245	if (sk->sk_shutdown & RCV_SHUTDOWN)
	246	return 0;
	247	return err;
	248	}
	249
	250	msg->msg_namelen = 0;
	251
	252	copied = skb->len;
	253	if (len < copied) {
	254	msg->msg_flags \|= MSG_TRUNC;
	255	copied = len;
	256	}
	257
badff6d0	258	skb_reset_transport_header(skb);
1da177e4	259	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
3241ad82	260	if (err == 0)
3b885787	261	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 LT	262
	263	skb_free_datagram(sk, skb);
	264
	265	return err ? : copied;
	266	}
	267	EXPORT_SYMBOL(bt_sock_recvmsg);
	268
	269	static inline unsigned int bt_accept_poll(struct sock *parent)
	270	{
	271	struct list_head p, n;
	272	struct sock *sk;
	273
	274	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	275	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be MH	276	if (sk->sk_state == BT_CONNECTED \|\|
	277	(bt_sk(parent)->defer_setup &&
	278	sk->sk_state == BT_CONNECT2))
1da177e4 LT	279	return POLLIN \| POLLRDNORM;
	280	}
	281
	282	return 0;
	283	}
	284
	285	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	286	{
	287	struct sock *sk = sock->sk;
	288	unsigned int mask = 0;
	289
	290	BT_DBG("sock %p, sk %p", sock, sk);
	291
	292	poll_wait(file, sk->sk_sleep, wait);
	293
	294	if (sk->sk_state == BT_LISTEN)
	295	return bt_accept_poll(sk);
	296
	297	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	298	mask \|= POLLERR;
	299
f348d70a DL	300	if (sk->sk_shutdown & RCV_SHUTDOWN)
	301	mask \|= POLLRDHUP;
	302
1da177e4 LT	303	if (sk->sk_shutdown == SHUTDOWN_MASK)
	304	mask \|= POLLHUP;
	305
8e87d142	306	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
1da177e4 LT	307	(sk->sk_shutdown & RCV_SHUTDOWN))
	308	mask \|= POLLIN \| POLLRDNORM;
	309
	310	if (sk->sk_state == BT_CLOSED)
	311	mask \|= POLLHUP;
	312
	313	if (sk->sk_state == BT_CONNECT \|\|
	314	sk->sk_state == BT_CONNECT2 \|\|
	315	sk->sk_state == BT_CONFIG)
	316	return mask;
	317
	318	if (sock_writeable(sk))
	319	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	320	else
	321	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	322
	323	return mask;
	324	}
	325	EXPORT_SYMBOL(bt_sock_poll);
	326
3241ad82 MH	327	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	328	{
	329	struct sock *sk = sock->sk;
43cbeee9 MH	330	struct sk_buff *skb;
43cbeee9 MH	331	long amount;
3241ad82 MH	332	int err;
	333
	334	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	335
	336	switch (cmd) {
43cbeee9 MH	337	case TIOCOUTQ:
	338	if (sk->sk_state == BT_LISTEN)
	339	return -EINVAL;
	340
31e6d363	341	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	342	if (amount < 0)
	343	amount = 0;
	344	err = put_user(amount, (int __user *) arg);
	345	break;
	346
	347	case TIOCINQ:
	348	if (sk->sk_state == BT_LISTEN)
	349	return -EINVAL;
	350
	351	lock_sock(sk);
	352	skb = skb_peek(&sk->sk_receive_queue);
	353	amount = skb ? skb->len : 0;
	354	release_sock(sk);
	355	err = put_user(amount, (int __user *) arg);
	356	break;
	357
3241ad82 MH	358	case SIOCGSTAMP:
	359	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	360	break;
	361
	362	case SIOCGSTAMPNS:
	363	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	364	break;
	365
	366	default:
	367	err = -ENOIOCTLCMD;
	368	break;
	369	}
	370
	371	return err;
	372	}
	373	EXPORT_SYMBOL(bt_sock_ioctl);
	374
1da177e4 LT	375	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	376	{
	377	DECLARE_WAITQUEUE(wait, current);
	378	int err = 0;
	379
	380	BT_DBG("sk %p", sk);
	381
	382	add_wait_queue(sk->sk_sleep, &wait);
	383	while (sk->sk_state != state) {
	384	set_current_state(TASK_INTERRUPTIBLE);
	385
	386	if (!timeo) {
b4c612a4	387	err = -EINPROGRESS;
1da177e4 LT	388	break;
	389	}
	390
	391	if (signal_pending(current)) {
	392	err = sock_intr_errno(timeo);
	393	break;
	394	}
	395
	396	release_sock(sk);
	397	timeo = schedule_timeout(timeo);
	398	lock_sock(sk);
	399
c1cbe4b7 BL	400	err = sock_error(sk);
c1cbe4b7 BL	401	if (err)
1da177e4	402	break;
1da177e4 LT	403	}
	404	set_current_state(TASK_RUNNING);
	405	remove_wait_queue(sk->sk_sleep, &wait);
	406	return err;
	407	}
	408	EXPORT_SYMBOL(bt_sock_wait_state);
	409
	410	static struct net_proto_family bt_sock_family_ops = {
	411	.owner = THIS_MODULE,
	412	.family = PF_BLUETOOTH,
	413	.create = bt_sock_create,
	414	};
	415
1da177e4 LT	416	static int __init bt_init(void)
1da177e4 LT	417	{
27d35284 MH	418	int err;
27d35284 MH	419
1da177e4 LT	420	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	421
27d35284 MH	422	err = bt_sysfs_init();
	423	if (err < 0)
	424	return err;
1da177e4	425
27d35284 MH	426	err = sock_register(&bt_sock_family_ops);
	427	if (err < 0) {
	428	bt_sysfs_cleanup();
	429	return err;
	430	}
1da177e4	431
27d35284	432	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	433
	434	hci_sock_init();
	435
	436	return 0;
	437	}
	438
	439	static void __exit bt_exit(void)
	440	{
	441	hci_sock_cleanup();
	442
1da177e4	443	sock_unregister(PF_BLUETOOTH);
27d35284 MH	444
27d35284 MH	445	bt_sysfs_cleanup();
1da177e4 LT	446	}
	447
	448	subsys_initcall(bt_init);
	449	module_exit(bt_exit);
	450
63fbd24e	451	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	452	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	453	MODULE_VERSION(VERSION);
	454	MODULE_LICENSE("GPL");
	455	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);