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

	BT_DBG("");

	list_for_each_entry(session, &cmtp_session_list, list)
		if (!bacmp(bdaddr, &session->bdaddr))
			return session;

	return NULL;
}

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

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

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

	ci->flags = session->flags & valid_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:
			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 & BIT(CMTP_LOOPBACK)))
		cmtp_detach_device(session);

	fput(session->sock->file);

	__cmtp_unlink_session(session);

	up_write(&cmtp_session_sem);

	kfree(session);
	module_put_and_exit(0);
	return 0;
}

int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
{
	u32 valid_flags = BIT(CMTP_LOOPBACK);
	struct cmtp_session *session, *s;
	int i, err;

	BT_DBG("");

	if (!l2cap_is_socket(sock))
		return -EBADFD;

	if (req->flags & ~valid_flags)
		return -EINVAL;

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

	down_write(&cmtp_session_sem);

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

	bacpy(&session->bdaddr, &l2cap_pi(sock->sk)->chan->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, "%pMR", &session->bdaddr);

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

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

	if (!(session->flags & BIT(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)
{
	u32 valid_flags = 0;
	struct cmtp_session *session;
	int err = 0;

	BT_DBG("");

	if (req->flags & ~valid_flags)
		return -EINVAL;

	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 cmtp_session *session;
	int err = 0, n = 0;

	BT_DBG("");

	down_read(&cmtp_session_sem);

	list_for_each_entry(session, &cmtp_session_list, list) {
		struct cmtp_conninfo ci;

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