[GitHub/mt8127/android_kernel_alcatel_ttab.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 <linux/kthread.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);
			if (scb->id < 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);

	set_user_nice(current, -15);

	init_waitqueue_entry(&wait, current);
	add_wait_queue(sk_sleep(sk), &wait);
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (atomic_read(&session->terminate))
			break;
		if (sk->sk_state != BT_CONNECTED)
			break;

		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
			skb_orphan(skb);
			if (!skb_linearize(skb))
				cmtp_recv_frame(session, skb);
			else
				kfree_skb(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)->chan->omtu,
					l2cap_pi(sock->sk)->chan->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);

	session->task = kthread_run(cmtp_session, session, "kcmtpd_ctr_%d",
								session->num);
	if (IS_ERR(session->task)) {
		err = PTR_ERR(session->task);
		goto unlink;
	}

	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
		err = cmtp_attach_device(session);
		if (err < 0) {
			atomic_inc(&session->terminate);
			wake_up_process(session->task);
			up_write(&cmtp_session_sem);
			return err;
		}
	}

	up_write(&cmtp_session_sem);
	return 0;

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);

		/* Stop session thread */
		atomic_inc(&session->terminate);
		wake_up_process(session->task);
	} 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)
{
	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>
fada4ac3	38	#include <linux/kthread.h>
1da177e4 LT	39	#include <net/sock.h>
	40
	41	#include <linux/isdn/capilli.h>
	42
	43	#include <net/bluetooth/bluetooth.h>
	44	#include <net/bluetooth/l2cap.h>
	45
	46	#include "cmtp.h"
	47
1da177e4 LT	48	#define VERSION "1.0"
	49
	50	static DECLARE_RWSEM(cmtp_session_sem);
	51	static LIST_HEAD(cmtp_session_list);
	52
	53	static struct cmtp_session __cmtp_get_session(bdaddr_t bdaddr)
	54	{
	55	struct cmtp_session *session;
	56	struct list_head *p;
	57
	58	BT_DBG("");
	59
	60	list_for_each(p, &cmtp_session_list) {
	61	session = list_entry(p, struct cmtp_session, list);
	62	if (!bacmp(bdaddr, &session->bdaddr))
	63	return session;
	64	}
	65	return NULL;
	66	}
	67
	68	static void __cmtp_link_session(struct cmtp_session *session)
	69	{
	70	__module_get(THIS_MODULE);
	71	list_add(&session->list, &cmtp_session_list);
	72	}
	73
	74	static void __cmtp_unlink_session(struct cmtp_session *session)
	75	{
	76	list_del(&session->list);
	77	module_put(THIS_MODULE);
	78	}
	79
	80	static void __cmtp_copy_session(struct cmtp_session session, struct cmtp_conninfo ci)
	81	{
3185fbd9	82	memset(ci, 0, sizeof(*ci));
1da177e4 LT	83	bacpy(&ci->bdaddr, &session->bdaddr);
	84
	85	ci->flags = session->flags;
	86	ci->state = session->state;
	87
	88	ci->num = session->num;
	89	}
	90
	91
	92	static inline int cmtp_alloc_block_id(struct cmtp_session *session)
	93	{
	94	int i, id = -1;
	95
	96	for (i = 0; i < 16; i++)
	97	if (!test_and_set_bit(i, &session->blockids)) {
	98	id = i;
	99	break;
	100	}
	101
	102	return id;
	103	}
	104
	105	static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
	106	{
	107	clear_bit(id, &session->blockids);
	108	}
	109
	110	static inline void cmtp_add_msgpart(struct cmtp_session session, int id, const unsigned char buf, int count)
	111	{
	112	struct sk_buff skb = session->reassembly[id], nskb;
	113	int size;
	114
	115	BT_DBG("session %p buf %p count %d", session, buf, count);
	116
	117	size = (skb) ? skb->len + count : count;
	118
5a08ecce AE	119	nskb = alloc_skb(size, GFP_ATOMIC);
5a08ecce AE	120	if (!nskb) {
1da177e4 LT	121	BT_ERR("Can't allocate memory for CAPI message");
	122	return;
	123	}
	124
	125	if (skb && (skb->len > 0))
d626f62b	126	skb_copy_from_linear_data(skb, skb_put(nskb, skb->len), skb->len);
1da177e4 LT	127
	128	memcpy(skb_put(nskb, count), buf, count);
	129
	130	session->reassembly[id] = nskb;
	131
7585b97a	132	kfree_skb(skb);
1da177e4 LT	133	}
	134
	135	static inline int cmtp_recv_frame(struct cmtp_session session, struct sk_buff skb)
	136	{
	137	__u8 hdr, hdrlen, id;
	138	__u16 len;
	139
	140	BT_DBG("session %p skb %p len %d", session, skb, skb->len);
	141
	142	while (skb->len > 0) {
	143	hdr = skb->data[0];
	144
	145	switch (hdr & 0xc0) {
	146	case 0x40:
	147	hdrlen = 2;
	148	len = skb->data[1];
	149	break;
	150	case 0x80:
	151	hdrlen = 3;
	152	len = skb->data[1] \| (skb->data[2] << 8);
	153	break;
	154	default:
	155	hdrlen = 1;
	156	len = 0;
	157	break;
	158	}
	159
	160	id = (hdr & 0x3c) >> 2;
	161
	162	BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);
	163
	164	if (hdrlen + len > skb->len) {
	165	BT_ERR("Wrong size or header information in CMTP frame");
	166	break;
	167	}
	168
	169	if (len == 0) {
	170	skb_pull(skb, hdrlen);
	171	continue;
	172	}
	173
	174	switch (hdr & 0x03) {
	175	case 0x00:
	176	cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
	177	cmtp_recv_capimsg(session, session->reassembly[id]);
	178	session->reassembly[id] = NULL;
	179	break;
	180	case 0x01:
	181	cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
	182	break;
	183	default:
	184	if (session->reassembly[id] != NULL)
	185	kfree_skb(session->reassembly[id]);
	186	session->reassembly[id] = NULL;
	187	break;
	188	}
	189
	190	skb_pull(skb, hdrlen + len);
	191	}
	192
	193	kfree_skb(skb);
	194	return 0;
	195	}
	196
197	static int cmtp_send_frame(struct cmtp_session session, unsigned char data, int len)
198	{
199	struct socket *sock = session->sock;
200	struct kvec iv = { data, len };
201	struct msghdr msg;
202
203	BT_DBG("session %p data %p len %d", session, data, len);
204
205	if (!len)
206	return 0;
207
208	memset(&msg, 0, sizeof(msg));
209
210	return kernel_sendmsg(sock, &msg, &iv, 1, len);
211	}
212
b03efcfb	213	static void cmtp_process_transmit(struct cmtp_session *session)
1da177e4 LT	214	{
	215	struct sk_buff skb, nskb;
	216	unsigned char *hdr;
	217	unsigned int size, tail;
	218
	219	BT_DBG("session %p", session);
	220
5a08ecce AE	221	nskb = alloc_skb(session->mtu, GFP_ATOMIC);
5a08ecce AE	222	if (!nskb) {
1da177e4	223	BT_ERR("Can't allocate memory for new frame");
b03efcfb	224	return;
1da177e4 LT	225	}
	226
	227	while ((skb = skb_dequeue(&session->transmit))) {
	228	struct cmtp_scb scb = (void ) skb->cb;
	229
5a08ecce AE	230	tail = session->mtu - nskb->len;
5a08ecce AE	231	if (tail < 5) {
1da177e4 LT	232	cmtp_send_frame(session, nskb->data, nskb->len);
	233	skb_trim(nskb, 0);
	234	tail = session->mtu;
	235	}
	236
	237	size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
	238
58aac468 SJ	239	if (scb->id < 0) {
	240	scb->id = cmtp_alloc_block_id(session);
	241	if (scb->id < 0) {
	242	skb_queue_head(&session->transmit, skb);
	243	break;
	244	}
1da177e4 LT	245	}
	246
	247	if (size < 256) {
	248	hdr = skb_put(nskb, 2);
	249	hdr[0] = 0x40
	250	\| ((scb->id << 2) & 0x3c)
	251	\| ((skb->len == size) ? 0x00 : 0x01);
	252	hdr[1] = size;
	253	} else {
	254	hdr = skb_put(nskb, 3);
	255	hdr[0] = 0x80
	256	\| ((scb->id << 2) & 0x3c)
	257	\| ((skb->len == size) ? 0x00 : 0x01);
	258	hdr[1] = size & 0xff;
	259	hdr[2] = size >> 8;
	260	}
	261
d626f62b	262	skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
1da177e4 LT	263	skb_pull(skb, size);
	264
	265	if (skb->len > 0) {
	266	skb_queue_head(&session->transmit, skb);
	267	} else {
	268	cmtp_free_block_id(session, scb->id);
	269	if (scb->data) {
	270	cmtp_send_frame(session, nskb->data, nskb->len);
	271	skb_trim(nskb, 0);
	272	}
	273	kfree_skb(skb);
	274	}
	275	}
	276
	277	cmtp_send_frame(session, nskb->data, nskb->len);
	278
	279	kfree_skb(nskb);
1da177e4 LT	280	}
	281
	282	static int cmtp_session(void *arg)
	283	{
	284	struct cmtp_session *session = arg;
	285	struct sock *sk = session->sock->sk;
	286	struct sk_buff *skb;
	287	wait_queue_t wait;
	288
	289	BT_DBG("session %p", session);
	290
1da177e4	291	set_user_nice(current, -15);
1da177e4 LT	292
1da177e4 LT	293	init_waitqueue_entry(&wait, current);
aa395145	294	add_wait_queue(sk_sleep(sk), &wait);
3a3f5c7d	295	while (1) {
1da177e4 LT	296	set_current_state(TASK_INTERRUPTIBLE);
1da177e4 LT	297
7176522c	298	if (atomic_read(&session->terminate))
3a3f5c7d	299	break;
1da177e4 LT	300	if (sk->sk_state != BT_CONNECTED)
	301	break;
	302
	303	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
	304	skb_orphan(skb);
44935720 MM	305	if (!skb_linearize(skb))
	306	cmtp_recv_frame(session, skb);
	307	else
	308	kfree_skb(skb);
1da177e4 LT	309	}
	310
	311	cmtp_process_transmit(session);
	312
	313	schedule();
	314	}
3a3f5c7d	315	__set_current_state(TASK_RUNNING);
aa395145	316	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	317
	318	down_write(&cmtp_session_sem);
	319
	320	if (!(session->flags & (1 << CMTP_LOOPBACK)))
	321	cmtp_detach_device(session);
	322
	323	fput(session->sock->file);
	324
	325	__cmtp_unlink_session(session);
	326
	327	up_write(&cmtp_session_sem);
	328
	329	kfree(session);
	330	return 0;
	331	}
	332
	333	int cmtp_add_connection(struct cmtp_connadd_req req, struct socket sock)
	334	{
	335	struct cmtp_session session, s;
1da177e4 LT	336	int i, err;
	337
	338	BT_DBG("");
	339
25ea6db0	340	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
8e87d142	341	if (!session)
1da177e4	342	return -ENOMEM;
1da177e4 LT	343
	344	down_write(&cmtp_session_sem);
	345
	346	s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
	347	if (s && s->state == BT_CONNECTED) {
	348	err = -EEXIST;
	349	goto failed;
	350	}
	351
	352	bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
	353
0c1bc5c6 GP	354	session->mtu = min_t(uint, l2cap_pi(sock->sk)->chan->omtu,
0c1bc5c6 GP	355	l2cap_pi(sock->sk)->chan->imtu);
1da177e4 LT	356
	357	BT_DBG("mtu %d", session->mtu);
	358
d6b2eb2f	359	sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));
1da177e4 LT	360
	361	session->sock = sock;
	362	session->state = BT_CONFIG;
	363
	364	init_waitqueue_head(&session->wait);
	365
	366	session->msgnum = CMTP_INITIAL_MSGNUM;
	367
	368	INIT_LIST_HEAD(&session->applications);
	369
	370	skb_queue_head_init(&session->transmit);
	371
	372	for (i = 0; i < 16; i++)
	373	session->reassembly[i] = NULL;
	374
	375	session->flags = req->flags;
	376
	377	__cmtp_link_session(session);
	378
fada4ac3 SJ	379	session->task = kthread_run(cmtp_session, session, "kcmtpd_ctr_%d",
	380	session->num);
	381	if (IS_ERR(session->task)) {
	382	err = PTR_ERR(session->task);
1da177e4	383	goto unlink;
fada4ac3	384	}
1da177e4 LT	385
	386	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
	387	err = cmtp_attach_device(session);
687beaa0 PH	388	if (err < 0) {
	389	atomic_inc(&session->terminate);
	390	wake_up_process(session->task);
	391	up_write(&cmtp_session_sem);
	392	return err;
	393	}
1da177e4 LT	394	}
	395
	396	up_write(&cmtp_session_sem);
	397	return 0;
	398
1da177e4 LT	399	unlink:
	400	__cmtp_unlink_session(session);
	401
	402	failed:
	403	up_write(&cmtp_session_sem);
	404	kfree(session);
	405	return err;
	406	}
	407
	408	int cmtp_del_connection(struct cmtp_conndel_req *req)
	409	{
	410	struct cmtp_session *session;
	411	int err = 0;
	412
	413	BT_DBG("");
	414
	415	down_read(&cmtp_session_sem);
	416
	417	session = __cmtp_get_session(&req->bdaddr);
	418	if (session) {
	419	/* Flush the transmit queue */
	420	skb_queue_purge(&session->transmit);
	421
fada4ac3	422	/* Stop session thread */
7176522c PH	423	atomic_inc(&session->terminate);
7176522c PH	424	wake_up_process(session->task);
1da177e4 LT	425	} else
	426	err = -ENOENT;
	427
	428	up_read(&cmtp_session_sem);
	429	return err;
	430	}
	431
	432	int cmtp_get_connlist(struct cmtp_connlist_req *req)
	433	{
	434	struct list_head *p;
	435	int err = 0, n = 0;
	436
	437	BT_DBG("");
	438
	439	down_read(&cmtp_session_sem);
	440
	441	list_for_each(p, &cmtp_session_list) {
	442	struct cmtp_session *session;
	443	struct cmtp_conninfo ci;
	444
	445	session = list_entry(p, struct cmtp_session, list);
	446
	447	__cmtp_copy_session(session, &ci);
	448
	449	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
	450	err = -EFAULT;
	451	break;
	452	}
	453
	454	if (++n >= req->cnum)
	455	break;
	456
	457	req->ci++;
	458	}
	459	req->cnum = n;
	460
	461	up_read(&cmtp_session_sem);
	462	return err;
	463	}
	464
	465	int cmtp_get_conninfo(struct cmtp_conninfo *ci)
	466	{
	467	struct cmtp_session *session;
	468	int err = 0;
	469
	470	down_read(&cmtp_session_sem);
	471
	472	session = __cmtp_get_session(&ci->bdaddr);
	473	if (session)
	474	__cmtp_copy_session(session, ci);
	475	else
	476	err = -ENOENT;
	477
	478	up_read(&cmtp_session_sem);
	479	return err;
	480	}
	481
	482
	483	static int __init cmtp_init(void)
	484	{
1da177e4 LT	485	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
	486
	487	cmtp_init_sockets();
	488
	489	return 0;
	490	}
	491
	492	static void __exit cmtp_exit(void)
	493	{
	494	cmtp_cleanup_sockets();
	495	}
	496
	497	module_init(cmtp_init);
	498	module_exit(cmtp_exit);
	499
	500	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	501	MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
	502	MODULE_VERSION(VERSION);
	503	MODULE_LICENSE("GPL");
	504	MODULE_ALIAS("bt-proto-5");