[linux.git] / net / bluetooth / af_bluetooth.c

/* 
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <[email protected]>

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