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

#if defined(CONFIG_KMOD)
#include <linux/kmod.h>
#endif

#include <net/bluetooth/bluetooth.h>

#ifndef CONFIG_BT_SOCK_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

#define VERSION "2.10"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static struct net_proto_family *bt_proto[BT_MAX_PROTO];

int bt_sock_register(int proto, struct net_proto_family *ops)
{
	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	if (bt_proto[proto])
		return -EEXIST;

	bt_proto[proto] = ops;
	return 0;
}
EXPORT_SYMBOL(bt_sock_register);

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

	if (!bt_proto[proto])
		return -ENOENT;

	bt_proto[proto] = NULL;
	return 0;
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct socket *sock, int proto)
{
	int err = 0;

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

#if defined(CONFIG_KMOD)
	if (!bt_proto[proto]) {
		request_module("bt-proto-%d", proto);
	}
#endif
	err = -EPROTONOSUPPORT;
	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(sock, proto);
		module_put(bt_proto[proto]->owner);
	}
	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_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 %d", 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->h.raw = skb->data;
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);

	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)
			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_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 = -EAGAIN;
			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("Maxim Krasnyansky <maxk@qualcomm.com>, 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
1da177e4 LT	1	/*
	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
	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
	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	19
	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
	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 LT	38	#include <net/sock.h>
	39
	40	#if defined(CONFIG_KMOD)
	41	#include <linux/kmod.h>
	42	#endif
	43
	44	#include <net/bluetooth/bluetooth.h>
	45
	46	#ifndef CONFIG_BT_SOCK_DEBUG
	47	#undef BT_DBG
	48	#define BT_DBG(D...)
	49	#endif
	50
27d35284	51	#define VERSION "2.10"
1da177e4 LT	52
	53	/* Bluetooth sockets */
	54	#define BT_MAX_PROTO 8
	55	static struct net_proto_family *bt_proto[BT_MAX_PROTO];
	56
	57	int bt_sock_register(int proto, struct net_proto_family *ops)
	58	{
	59	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	60	return -EINVAL;
	61
	62	if (bt_proto[proto])
	63	return -EEXIST;
	64
	65	bt_proto[proto] = ops;
	66	return 0;
	67	}
	68	EXPORT_SYMBOL(bt_sock_register);
	69
	70	int bt_sock_unregister(int proto)
	71	{
	72	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	73	return -EINVAL;
	74
	75	if (!bt_proto[proto])
	76	return -ENOENT;
	77
	78	bt_proto[proto] = NULL;
	79	return 0;
	80	}
	81	EXPORT_SYMBOL(bt_sock_unregister);
	82
	83	static int bt_sock_create(struct socket *sock, int proto)
	84	{
	85	int err = 0;
	86
	87	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	88	return -EINVAL;
	89
	90	#if defined(CONFIG_KMOD)
	91	if (!bt_proto[proto]) {
	92	request_module("bt-proto-%d", proto);
	93	}
	94	#endif
	95	err = -EPROTONOSUPPORT;
	96	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
	97	err = bt_proto[proto]->create(sock, proto);
	98	module_put(bt_proto[proto]->owner);
	99	}
	100	return err;
	101	}
	102
	103	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	104	{
	105	write_lock_bh(&l->lock);
	106	sk_add_node(sk, &l->head);
	107	write_unlock_bh(&l->lock);
	108	}
	109	EXPORT_SYMBOL(bt_sock_link);
	110
	111	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	112	{
	113	write_lock_bh(&l->lock);
	114	sk_del_node_init(sk);
	115	write_unlock_bh(&l->lock);
116	}
117	EXPORT_SYMBOL(bt_sock_unlink);
118
119	void bt_accept_enqueue(struct sock parent, struct sock sk)
120	{
121	BT_DBG("parent %p, sk %p", parent, sk);
122
123	sock_hold(sk);
124	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
125	bt_sk(sk)->parent = parent;
126	parent->sk_ack_backlog++;
127	}
128	EXPORT_SYMBOL(bt_accept_enqueue);
129
130	void bt_accept_unlink(struct sock *sk)
131	{
132	BT_DBG("sk %p state %d", sk, sk->sk_state);
133
134	list_del_init(&bt_sk(sk)->accept_q);
135	bt_sk(sk)->parent->sk_ack_backlog--;
136	bt_sk(sk)->parent = NULL;
137	sock_put(sk);
138	}
139	EXPORT_SYMBOL(bt_accept_unlink);
140
141	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
142	{
143	struct list_head p, n;
144	struct sock *sk;
145
146	BT_DBG("parent %p", parent);
147
148	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
149	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
150
151	lock_sock(sk);
152
153	/* FIXME: Is this check still needed */
154	if (sk->sk_state == BT_CLOSED) {
155	release_sock(sk);
156	bt_accept_unlink(sk);
157	continue;
158	}
159
160	if (sk->sk_state == BT_CONNECTED \|\| !newsock) {
161	bt_accept_unlink(sk);
162	if (newsock)
163	sock_graft(sk, newsock);
164	release_sock(sk);
165	return sk;
166	}
167
168	release_sock(sk);
169	}
170	return NULL;
171	}
172	EXPORT_SYMBOL(bt_accept_dequeue);
173
174	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
175	struct msghdr *msg, size_t len, int flags)
176	{
177	int noblock = flags & MSG_DONTWAIT;
178	struct sock *sk = sock->sk;
179	struct sk_buff *skb;
180	size_t copied;
181	int err;
182
183	BT_DBG("sock %p sk %p len %d", sock, sk, len);
184
185	if (flags & (MSG_OOB))
186	return -EOPNOTSUPP;
187
188	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
189	if (sk->sk_shutdown & RCV_SHUTDOWN)
190	return 0;
191	return err;
192	}
193
194	msg->msg_namelen = 0;
195
196	copied = skb->len;
197	if (len < copied) {
198	msg->msg_flags \|= MSG_TRUNC;
199	copied = len;
200	}
201
202	skb->h.raw = skb->data;
203	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
204
205	skb_free_datagram(sk, skb);
206
207	return err ? : copied;
208	}
209	EXPORT_SYMBOL(bt_sock_recvmsg);
210
211	static inline unsigned int bt_accept_poll(struct sock *parent)
212	{
213	struct list_head p, n;
214	struct sock *sk;
215
216	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
217	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
218	if (sk->sk_state == BT_CONNECTED)
219	return POLLIN \| POLLRDNORM;
220	}
221
222	return 0;
223	}
224
225	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
226	{
227	struct sock *sk = sock->sk;
228	unsigned int mask = 0;
229
230	BT_DBG("sock %p, sk %p", sock, sk);
231
232	poll_wait(file, sk->sk_sleep, wait);
233
234	if (sk->sk_state == BT_LISTEN)
235	return bt_accept_poll(sk);
236
237	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
238	mask \|= POLLERR;
239
f348d70a DL	240	if (sk->sk_shutdown & RCV_SHUTDOWN)
	241	mask \|= POLLRDHUP;
	242
1da177e4 LT	243	if (sk->sk_shutdown == SHUTDOWN_MASK)
	244	mask \|= POLLHUP;
	245
	246	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
	247	(sk->sk_shutdown & RCV_SHUTDOWN))
	248	mask \|= POLLIN \| POLLRDNORM;
	249
	250	if (sk->sk_state == BT_CLOSED)
	251	mask \|= POLLHUP;
	252
	253	if (sk->sk_state == BT_CONNECT \|\|
	254	sk->sk_state == BT_CONNECT2 \|\|
	255	sk->sk_state == BT_CONFIG)
	256	return mask;
	257
	258	if (sock_writeable(sk))
	259	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	260	else
	261	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	262
	263	return mask;
	264	}
	265	EXPORT_SYMBOL(bt_sock_poll);
	266
	267	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	268	{
	269	DECLARE_WAITQUEUE(wait, current);
	270	int err = 0;
	271
	272	BT_DBG("sk %p", sk);
	273
	274	add_wait_queue(sk->sk_sleep, &wait);
	275	while (sk->sk_state != state) {
	276	set_current_state(TASK_INTERRUPTIBLE);
	277
	278	if (!timeo) {
	279	err = -EAGAIN;
	280	break;
	281	}
	282
	283	if (signal_pending(current)) {
	284	err = sock_intr_errno(timeo);
	285	break;
	286	}
	287
	288	release_sock(sk);
	289	timeo = schedule_timeout(timeo);
	290	lock_sock(sk);
	291
c1cbe4b7 BL	292	err = sock_error(sk);
c1cbe4b7 BL	293	if (err)
1da177e4	294	break;
1da177e4 LT	295	}
	296	set_current_state(TASK_RUNNING);
	297	remove_wait_queue(sk->sk_sleep, &wait);
	298	return err;
	299	}
	300	EXPORT_SYMBOL(bt_sock_wait_state);
	301
	302	static struct net_proto_family bt_sock_family_ops = {
	303	.owner = THIS_MODULE,
	304	.family = PF_BLUETOOTH,
	305	.create = bt_sock_create,
	306	};
	307
1da177e4 LT	308	static int __init bt_init(void)
1da177e4 LT	309	{
27d35284 MH	310	int err;
27d35284 MH	311
1da177e4 LT	312	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	313
27d35284 MH	314	err = bt_sysfs_init();
	315	if (err < 0)
	316	return err;
1da177e4	317
27d35284 MH	318	err = sock_register(&bt_sock_family_ops);
	319	if (err < 0) {
	320	bt_sysfs_cleanup();
	321	return err;
	322	}
1da177e4	323
27d35284	324	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	325
	326	hci_sock_init();
	327
	328	return 0;
	329	}
	330
	331	static void __exit bt_exit(void)
	332	{
	333	hci_sock_cleanup();
	334
1da177e4	335	sock_unregister(PF_BLUETOOTH);
27d35284 MH	336
27d35284 MH	337	bt_sysfs_cleanup();
1da177e4 LT	338	}
	339
	340	subsys_initcall(bt_init);
	341	module_exit(bt_exit);
	342
	343	MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
	344	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	345	MODULE_VERSION(VERSION);
	346	MODULE_LICENSE("GPL");
	347	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);