[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/config.h>
#include <linux/module.h>

#include <linux/types.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/proc_fs.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.7"

struct proc_dir_entry *proc_bt;
EXPORT_SYMBOL(proc_bt);

/* 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 == 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);

		if (sk->sk_err) {
			err = sock_error(sk);
			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,
};

extern int hci_sock_init(void);
extern int hci_sock_cleanup(void);

extern int bt_sysfs_init(void);
extern int bt_sysfs_cleanup(void);

static int __init bt_init(void)
{
	BT_INFO("Core ver %s", VERSION);

	proc_bt = proc_mkdir("bluetooth", NULL);
	if (proc_bt)
		proc_bt->owner = THIS_MODULE;

	sock_register(&bt_sock_family_ops);

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

	bt_sysfs_init();

	hci_sock_init();

	return 0;
}

static void __exit bt_exit(void)
{
	hci_sock_cleanup();

	bt_sysfs_cleanup();

	sock_unregister(PF_BLUETOOTH);

	remove_proc_entry("bluetooth", NULL);
}

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