[deliverable/linux.git] / net / bluetooth / cmtp / core.c

/*
   CMTP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>

   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.
*/

#include <linux/module.h>

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/freezer.h>
#include <linux/skbuff.h>
#include <linux/socket.h>
#include <linux/ioctl.h>
#include <linux/file.h>
#include <linux/init.h>
#include <net/sock.h>

#include <linux/isdn/capilli.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/l2cap.h>

#include "cmtp.h"

#define VERSION "1.0"

static DECLARE_RWSEM(cmtp_session_sem);
static LIST_HEAD(cmtp_session_list);

static struct cmtp_session *__cmtp_get_session(bdaddr_t *bdaddr)
{
	struct cmtp_session *session;
	struct list_head *p;

	BT_DBG("");

	list_for_each(p, &cmtp_session_list) {
		session = list_entry(p, struct cmtp_session, list);
		if (!bacmp(bdaddr, &session->bdaddr))
			return session;
	}
	return NULL;
}

static void __cmtp_link_session(struct cmtp_session *session)
{
	__module_get(THIS_MODULE);
	list_add(&session->list, &cmtp_session_list);
}

static void __cmtp_unlink_session(struct cmtp_session *session)
{
	list_del(&session->list);
	module_put(THIS_MODULE);
}

static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
{
	memset(ci, 0, sizeof(*ci));
	bacpy(&ci->bdaddr, &session->bdaddr);

	ci->flags = session->flags;
	ci->state = session->state;

	ci->num = session->num;
}


static inline int cmtp_alloc_block_id(struct cmtp_session *session)
{
	int i, id = -1;

	for (i = 0; i < 16; i++)
		if (!test_and_set_bit(i, &session->blockids)) {
			id = i;
			break;
		}

	return id;
}

static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
{
	clear_bit(id, &session->blockids);
}

static inline void cmtp_add_msgpart(struct cmtp_session *session, int id, const unsigned char *buf, int count)
{
	struct sk_buff *skb = session->reassembly[id], *nskb;
	int size;

	BT_DBG("session %p buf %p count %d", session, buf, count);

	size = (skb) ? skb->len + count : count;

	nskb = alloc_skb(size, GFP_ATOMIC);
	if (!nskb) {
		BT_ERR("Can't allocate memory for CAPI message");
		return;
	}

	if (skb && (skb->len > 0))
		skb_copy_from_linear_data(skb, skb_put(nskb, skb->len), skb->len);

	memcpy(skb_put(nskb, count), buf, count);

	session->reassembly[id] = nskb;

	kfree_skb(skb);
}

static inline int cmtp_recv_frame(struct cmtp_session *session, struct sk_buff *skb)
{
	__u8 hdr, hdrlen, id;
	__u16 len;

	BT_DBG("session %p skb %p len %d", session, skb, skb->len);

	while (skb->len > 0) {
		hdr = skb->data[0];

		switch (hdr & 0xc0) {
		case 0x40:
			hdrlen = 2;
			len = skb->data[1];
			break;
		case 0x80:
			hdrlen = 3;
			len = skb->data[1] | (skb->data[2] << 8);
			break;
		default:
			hdrlen = 1;
			len = 0;
			break;
		}

		id = (hdr & 0x3c) >> 2;

		BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);

		if (hdrlen + len > skb->len) {
			BT_ERR("Wrong size or header information in CMTP frame");
			break;
		}

		if (len == 0) {
			skb_pull(skb, hdrlen);
			continue;
		}

		switch (hdr & 0x03) {
		case 0x00:
			cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
			cmtp_recv_capimsg(session, session->reassembly[id]);
			session->reassembly[id] = NULL;
			break;
		case 0x01:
			cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
			break;
		default:
			if (session->reassembly[id] != NULL)
				kfree_skb(session->reassembly[id]);
			session->reassembly[id] = NULL;
			break;
		}

		skb_pull(skb, hdrlen + len);
	}

	kfree_skb(skb);
	return 0;
}

static int cmtp_send_frame(struct cmtp_session *session, unsigned char *data, int len)
{
	struct socket *sock = session->sock;
	struct kvec iv = { data, len };
	struct msghdr msg;

	BT_DBG("session %p data %p len %d", session, data, len);

	if (!len)
		return 0;

	memset(&msg, 0, sizeof(msg));

	return kernel_sendmsg(sock, &msg, &iv, 1, len);
}

static void cmtp_process_transmit(struct cmtp_session *session)
{
	struct sk_buff *skb, *nskb;
	unsigned char *hdr;
	unsigned int size, tail;

	BT_DBG("session %p", session);

	nskb = alloc_skb(session->mtu, GFP_ATOMIC);
	if (!nskb) {
		BT_ERR("Can't allocate memory for new frame");
		return;
	}

	while ((skb = skb_dequeue(&session->transmit))) {
		struct cmtp_scb *scb = (void *) skb->cb;

		tail = session->mtu - nskb->len;
		if (tail < 5) {
			cmtp_send_frame(session, nskb->data, nskb->len);
			skb_trim(nskb, 0);
			tail = session->mtu;
		}

		size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);

		if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
			skb_queue_head(&session->transmit, skb);
			break;
		}

		if (size < 256) {
			hdr = skb_put(nskb, 2);
			hdr[0] = 0x40
				| ((scb->id << 2) & 0x3c)
				| ((skb->len == size) ? 0x00 : 0x01);
			hdr[1] = size;
		} else {
			hdr = skb_put(nskb, 3);
			hdr[0] = 0x80
				| ((scb->id << 2) & 0x3c)
				| ((skb->len == size) ? 0x00 : 0x01);
			hdr[1] = size & 0xff;
			hdr[2] = size >> 8;
		}

		skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
		skb_pull(skb, size);

		if (skb->len > 0) {
			skb_queue_head(&session->transmit, skb);
		} else {
			cmtp_free_block_id(session, scb->id);
			if (scb->data) {
				cmtp_send_frame(session, nskb->data, nskb->len);
				skb_trim(nskb, 0);
			}
			kfree_skb(skb);
		}
	}

	cmtp_send_frame(session, nskb->data, nskb->len);

	kfree_skb(nskb);
}

static int cmtp_session(void *arg)
{
	struct cmtp_session *session = arg;
	struct sock *sk = session->sock->sk;
	struct sk_buff *skb;
	wait_queue_t wait;

	BT_DBG("session %p", session);

	daemonize("kcmtpd_ctr_%d", session->num);
	set_user_nice(current, -15);

	init_waitqueue_entry(&wait, current);
	add_wait_queue(sk_sleep(sk), &wait);
	while (!atomic_read(&session->terminate)) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (sk->sk_state != BT_CONNECTED)
			break;

		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
			skb_orphan(skb);
			cmtp_recv_frame(session, skb);
		}

		cmtp_process_transmit(session);

		schedule();
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);

	down_write(&cmtp_session_sem);

	if (!(session->flags & (1 << CMTP_LOOPBACK)))
		cmtp_detach_device(session);

	fput(session->sock->file);

	__cmtp_unlink_session(session);

	up_write(&cmtp_session_sem);

	kfree(session);
	return 0;
}

int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
{
	struct cmtp_session *session, *s;
	int i, err;

	BT_DBG("");

	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
	if (!session)
		return -ENOMEM;

	down_write(&cmtp_session_sem);

	s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
	if (s && s->state == BT_CONNECTED) {
		err = -EEXIST;
		goto failed;
	}

	bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);

	session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);

	BT_DBG("mtu %d", session->mtu);

	sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));

	session->sock  = sock;
	session->state = BT_CONFIG;

	init_waitqueue_head(&session->wait);

	session->msgnum = CMTP_INITIAL_MSGNUM;

	INIT_LIST_HEAD(&session->applications);

	skb_queue_head_init(&session->transmit);

	for (i = 0; i < 16; i++)
		session->reassembly[i] = NULL;

	session->flags = req->flags;

	__cmtp_link_session(session);

	err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
	if (err < 0)
		goto unlink;

	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
		err = cmtp_attach_device(session);
		if (err < 0)
			goto detach;
	}

	up_write(&cmtp_session_sem);
	return 0;

detach:
	cmtp_detach_device(session);

unlink:
	__cmtp_unlink_session(session);

failed:
	up_write(&cmtp_session_sem);
	kfree(session);
	return err;
}

int cmtp_del_connection(struct cmtp_conndel_req *req)
{
	struct cmtp_session *session;
	int err = 0;

	BT_DBG("");

	down_read(&cmtp_session_sem);

	session = __cmtp_get_session(&req->bdaddr);
	if (session) {
		/* Flush the transmit queue */
		skb_queue_purge(&session->transmit);

		/* Kill session thread */
		atomic_inc(&session->terminate);
		cmtp_schedule(session);
	} else
		err = -ENOENT;

	up_read(&cmtp_session_sem);
	return err;
}

int cmtp_get_connlist(struct cmtp_connlist_req *req)
{
	struct list_head *p;
	int err = 0, n = 0;

	BT_DBG("");

	down_read(&cmtp_session_sem);

	list_for_each(p, &cmtp_session_list) {
		struct cmtp_session *session;
		struct cmtp_conninfo ci;

		session = list_entry(p, struct cmtp_session, list);

		__cmtp_copy_session(session, &ci);

		if (copy_to_user(req->ci, &ci, sizeof(ci))) {
			err = -EFAULT;
			break;
		}

		if (++n >= req->cnum)
			break;

		req->ci++;
	}
	req->cnum = n;

	up_read(&cmtp_session_sem);
	return err;
}

int cmtp_get_conninfo(struct cmtp_conninfo *ci)
{
	struct cmtp_session *session;
	int err = 0;

	down_read(&cmtp_session_sem);

	session = __cmtp_get_session(&ci->bdaddr);
	if (session)
		__cmtp_copy_session(session, ci);
	else
		err = -ENOENT;

	up_read(&cmtp_session_sem);
	return err;
}


static int __init cmtp_init(void)
{
	l2cap_load();

	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);

	cmtp_init_sockets();

	return 0;
}

static void __exit cmtp_exit(void)
{
	cmtp_cleanup_sockets();
}

module_init(cmtp_init);
module_exit(cmtp_exit);

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS("bt-proto-5");
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	CMTP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License version 2 as
	7	published by the Free Software Foundation;
	8
	9	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	10	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	11	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	12	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	13	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	14	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	15	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	16	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	17
8e87d142 YH	18	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	19	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	20	SOFTWARE IS DISCLAIMED.
	21	*/
	22
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/types.h>
	26	#include <linux/errno.h>
	27	#include <linux/kernel.h>
1da177e4 LT	28	#include <linux/sched.h>
	29	#include <linux/slab.h>
	30	#include <linux/poll.h>
	31	#include <linux/fcntl.h>
83144186	32	#include <linux/freezer.h>
1da177e4 LT	33	#include <linux/skbuff.h>
	34	#include <linux/socket.h>
	35	#include <linux/ioctl.h>
	36	#include <linux/file.h>
	37	#include <linux/init.h>
	38	#include <net/sock.h>
	39
	40	#include <linux/isdn/capilli.h>
	41
	42	#include <net/bluetooth/bluetooth.h>
	43	#include <net/bluetooth/l2cap.h>
	44
	45	#include "cmtp.h"
	46
1da177e4 LT	47	#define VERSION "1.0"
	48
	49	static DECLARE_RWSEM(cmtp_session_sem);
	50	static LIST_HEAD(cmtp_session_list);
	51
	52	static struct cmtp_session __cmtp_get_session(bdaddr_t bdaddr)
	53	{
	54	struct cmtp_session *session;
	55	struct list_head *p;
	56
	57	BT_DBG("");
	58
	59	list_for_each(p, &cmtp_session_list) {
	60	session = list_entry(p, struct cmtp_session, list);
	61	if (!bacmp(bdaddr, &session->bdaddr))
	62	return session;
	63	}
	64	return NULL;
	65	}
	66
	67	static void __cmtp_link_session(struct cmtp_session *session)
	68	{
	69	__module_get(THIS_MODULE);
	70	list_add(&session->list, &cmtp_session_list);
	71	}
	72
	73	static void __cmtp_unlink_session(struct cmtp_session *session)
	74	{
	75	list_del(&session->list);
	76	module_put(THIS_MODULE);
	77	}
	78
	79	static void __cmtp_copy_session(struct cmtp_session session, struct cmtp_conninfo ci)
	80	{
3185fbd9	81	memset(ci, 0, sizeof(*ci));
1da177e4 LT	82	bacpy(&ci->bdaddr, &session->bdaddr);
	83
	84	ci->flags = session->flags;
	85	ci->state = session->state;
	86
	87	ci->num = session->num;
	88	}
	89
	90
	91	static inline int cmtp_alloc_block_id(struct cmtp_session *session)
	92	{
	93	int i, id = -1;
	94
	95	for (i = 0; i < 16; i++)
	96	if (!test_and_set_bit(i, &session->blockids)) {
	97	id = i;
	98	break;
	99	}
	100
	101	return id;
	102	}
	103
	104	static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
	105	{
	106	clear_bit(id, &session->blockids);
	107	}
	108
	109	static inline void cmtp_add_msgpart(struct cmtp_session session, int id, const unsigned char buf, int count)
	110	{
	111	struct sk_buff skb = session->reassembly[id], nskb;
	112	int size;
	113
	114	BT_DBG("session %p buf %p count %d", session, buf, count);
	115
	116	size = (skb) ? skb->len + count : count;
	117
5a08ecce AE	118	nskb = alloc_skb(size, GFP_ATOMIC);
5a08ecce AE	119	if (!nskb) {
1da177e4 LT	120	BT_ERR("Can't allocate memory for CAPI message");
	121	return;
	122	}
	123
	124	if (skb && (skb->len > 0))
d626f62b	125	skb_copy_from_linear_data(skb, skb_put(nskb, skb->len), skb->len);
1da177e4 LT	126
	127	memcpy(skb_put(nskb, count), buf, count);
	128
	129	session->reassembly[id] = nskb;
	130
7585b97a	131	kfree_skb(skb);
1da177e4 LT	132	}
	133
	134	static inline int cmtp_recv_frame(struct cmtp_session session, struct sk_buff skb)
	135	{
	136	__u8 hdr, hdrlen, id;
	137	__u16 len;
	138
	139	BT_DBG("session %p skb %p len %d", session, skb, skb->len);
	140
	141	while (skb->len > 0) {
	142	hdr = skb->data[0];
	143
	144	switch (hdr & 0xc0) {
	145	case 0x40:
	146	hdrlen = 2;
	147	len = skb->data[1];
	148	break;
	149	case 0x80:
	150	hdrlen = 3;
	151	len = skb->data[1] \| (skb->data[2] << 8);
	152	break;
	153	default:
	154	hdrlen = 1;
	155	len = 0;
	156	break;
	157	}
	158
	159	id = (hdr & 0x3c) >> 2;
	160
	161	BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);
	162
	163	if (hdrlen + len > skb->len) {
	164	BT_ERR("Wrong size or header information in CMTP frame");
	165	break;
	166	}
	167
	168	if (len == 0) {
	169	skb_pull(skb, hdrlen);
	170	continue;
	171	}
	172
	173	switch (hdr & 0x03) {
	174	case 0x00:
	175	cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
	176	cmtp_recv_capimsg(session, session->reassembly[id]);
	177	session->reassembly[id] = NULL;
	178	break;
	179	case 0x01:
	180	cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
	181	break;
	182	default:
	183	if (session->reassembly[id] != NULL)
	184	kfree_skb(session->reassembly[id]);
	185	session->reassembly[id] = NULL;
	186	break;
	187	}
	188
	189	skb_pull(skb, hdrlen + len);
	190	}
	191
	192	kfree_skb(skb);
	193	return 0;
	194	}
	195
196	static int cmtp_send_frame(struct cmtp_session session, unsigned char data, int len)
197	{
198	struct socket *sock = session->sock;
199	struct kvec iv = { data, len };
200	struct msghdr msg;
201
202	BT_DBG("session %p data %p len %d", session, data, len);
203
204	if (!len)
205	return 0;
206
207	memset(&msg, 0, sizeof(msg));
208
209	return kernel_sendmsg(sock, &msg, &iv, 1, len);
210	}
211
b03efcfb	212	static void cmtp_process_transmit(struct cmtp_session *session)
1da177e4 LT	213	{
	214	struct sk_buff skb, nskb;
	215	unsigned char *hdr;
	216	unsigned int size, tail;
	217
	218	BT_DBG("session %p", session);
	219
5a08ecce AE	220	nskb = alloc_skb(session->mtu, GFP_ATOMIC);
5a08ecce AE	221	if (!nskb) {
1da177e4	222	BT_ERR("Can't allocate memory for new frame");
b03efcfb	223	return;
1da177e4 LT	224	}
	225
	226	while ((skb = skb_dequeue(&session->transmit))) {
	227	struct cmtp_scb scb = (void ) skb->cb;
	228
5a08ecce AE	229	tail = session->mtu - nskb->len;
5a08ecce AE	230	if (tail < 5) {
1da177e4 LT	231	cmtp_send_frame(session, nskb->data, nskb->len);
	232	skb_trim(nskb, 0);
	233	tail = session->mtu;
	234	}
	235
	236	size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
	237
	238	if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
	239	skb_queue_head(&session->transmit, skb);
	240	break;
	241	}
	242
	243	if (size < 256) {
	244	hdr = skb_put(nskb, 2);
	245	hdr[0] = 0x40
	246	\| ((scb->id << 2) & 0x3c)
	247	\| ((skb->len == size) ? 0x00 : 0x01);
	248	hdr[1] = size;
	249	} else {
	250	hdr = skb_put(nskb, 3);
	251	hdr[0] = 0x80
	252	\| ((scb->id << 2) & 0x3c)
	253	\| ((skb->len == size) ? 0x00 : 0x01);
	254	hdr[1] = size & 0xff;
	255	hdr[2] = size >> 8;
	256	}
	257
d626f62b	258	skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
1da177e4 LT	259	skb_pull(skb, size);
	260
	261	if (skb->len > 0) {
	262	skb_queue_head(&session->transmit, skb);
	263	} else {
	264	cmtp_free_block_id(session, scb->id);
	265	if (scb->data) {
	266	cmtp_send_frame(session, nskb->data, nskb->len);
	267	skb_trim(nskb, 0);
	268	}
	269	kfree_skb(skb);
	270	}
	271	}
	272
	273	cmtp_send_frame(session, nskb->data, nskb->len);
	274
	275	kfree_skb(nskb);
1da177e4 LT	276	}
	277
	278	static int cmtp_session(void *arg)
	279	{
	280	struct cmtp_session *session = arg;
	281	struct sock *sk = session->sock->sk;
	282	struct sk_buff *skb;
	283	wait_queue_t wait;
	284
	285	BT_DBG("session %p", session);
	286
	287	daemonize("kcmtpd_ctr_%d", session->num);
	288	set_user_nice(current, -15);
1da177e4 LT	289
1da177e4 LT	290	init_waitqueue_entry(&wait, current);
aa395145	291	add_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	292	while (!atomic_read(&session->terminate)) {
	293	set_current_state(TASK_INTERRUPTIBLE);
	294
	295	if (sk->sk_state != BT_CONNECTED)
	296	break;
	297
	298	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
	299	skb_orphan(skb);
	300	cmtp_recv_frame(session, skb);
	301	}
	302
	303	cmtp_process_transmit(session);
	304
	305	schedule();
	306	}
	307	set_current_state(TASK_RUNNING);
aa395145	308	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	309
	310	down_write(&cmtp_session_sem);
	311
	312	if (!(session->flags & (1 << CMTP_LOOPBACK)))
	313	cmtp_detach_device(session);
	314
	315	fput(session->sock->file);
	316
	317	__cmtp_unlink_session(session);
	318
	319	up_write(&cmtp_session_sem);
	320
	321	kfree(session);
	322	return 0;
	323	}
	324
	325	int cmtp_add_connection(struct cmtp_connadd_req req, struct socket sock)
	326	{
	327	struct cmtp_session session, s;
1da177e4 LT	328	int i, err;
	329
	330	BT_DBG("");
	331
25ea6db0	332	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
8e87d142	333	if (!session)
1da177e4	334	return -ENOMEM;
1da177e4 LT	335
	336	down_write(&cmtp_session_sem);
	337
	338	s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
	339	if (s && s->state == BT_CONNECTED) {
	340	err = -EEXIST;
	341	goto failed;
	342	}
	343
	344	bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
	345
	346	session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);
	347
	348	BT_DBG("mtu %d", session->mtu);
	349
d6b2eb2f	350	sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));
1da177e4 LT	351
	352	session->sock = sock;
	353	session->state = BT_CONFIG;
	354
	355	init_waitqueue_head(&session->wait);
	356
	357	session->msgnum = CMTP_INITIAL_MSGNUM;
	358
	359	INIT_LIST_HEAD(&session->applications);
	360
	361	skb_queue_head_init(&session->transmit);
	362
	363	for (i = 0; i < 16; i++)
	364	session->reassembly[i] = NULL;
	365
	366	session->flags = req->flags;
	367
	368	__cmtp_link_session(session);
	369
	370	err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
	371	if (err < 0)
	372	goto unlink;
	373
	374	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
	375	err = cmtp_attach_device(session);
	376	if (err < 0)
	377	goto detach;
	378	}
	379
	380	up_write(&cmtp_session_sem);
	381	return 0;
	382
	383	detach:
	384	cmtp_detach_device(session);
	385
	386	unlink:
	387	__cmtp_unlink_session(session);
	388
	389	failed:
	390	up_write(&cmtp_session_sem);
	391	kfree(session);
	392	return err;
	393	}
	394
	395	int cmtp_del_connection(struct cmtp_conndel_req *req)
	396	{
	397	struct cmtp_session *session;
	398	int err = 0;
	399
	400	BT_DBG("");
	401
	402	down_read(&cmtp_session_sem);
	403
	404	session = __cmtp_get_session(&req->bdaddr);
	405	if (session) {
	406	/* Flush the transmit queue */
	407	skb_queue_purge(&session->transmit);
	408
	409	/* Kill session thread */
	410	atomic_inc(&session->terminate);
	411	cmtp_schedule(session);
	412	} else
	413	err = -ENOENT;
	414
415	up_read(&cmtp_session_sem);
416	return err;
417	}
418
419	int cmtp_get_connlist(struct cmtp_connlist_req *req)
420	{
421	struct list_head *p;
422	int err = 0, n = 0;
423
424	BT_DBG("");
425
426	down_read(&cmtp_session_sem);
427
428	list_for_each(p, &cmtp_session_list) {
429	struct cmtp_session *session;
430	struct cmtp_conninfo ci;
431
432	session = list_entry(p, struct cmtp_session, list);
433
434	__cmtp_copy_session(session, &ci);
435
436	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
437	err = -EFAULT;
438	break;
439	}
440
441	if (++n >= req->cnum)
442	break;
443
444	req->ci++;
445	}
446	req->cnum = n;
447
448	up_read(&cmtp_session_sem);
449	return err;
450	}
451
452	int cmtp_get_conninfo(struct cmtp_conninfo *ci)
453	{
454	struct cmtp_session *session;
455	int err = 0;
456
457	down_read(&cmtp_session_sem);
458
459	session = __cmtp_get_session(&ci->bdaddr);
460	if (session)
461	__cmtp_copy_session(session, ci);
462	else
463	err = -ENOENT;
464
465	up_read(&cmtp_session_sem);
466	return err;
467	}
468
469
470	static int __init cmtp_init(void)
471	{
472	l2cap_load();
473
474	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
475
476	cmtp_init_sockets();
477
478	return 0;
479	}
480
481	static void __exit cmtp_exit(void)
482	{
483	cmtp_cleanup_sockets();
484	}
485
486	module_init(cmtp_init);
487	module_exit(cmtp_exit);
488
489	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
490	MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
491	MODULE_VERSION(VERSION);
492	MODULE_LICENSE("GPL");
493	MODULE_ALIAS("bt-proto-5");