[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:
			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 & 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:
	181	if (session->reassembly[id] != NULL)
	182	kfree_skb(session->reassembly[id]);
	183	session->reassembly[id] = NULL;
	184	break;
	185	}
	186
	187	skb_pull(skb, hdrlen + len);
	188	}
	189
	190	kfree_skb(skb);
	191	return 0;
	192	}
	193
194	static int cmtp_send_frame(struct cmtp_session session, unsigned char data, int len)
195	{
196	struct socket *sock = session->sock;
197	struct kvec iv = { data, len };
198	struct msghdr msg;
199
200	BT_DBG("session %p data %p len %d", session, data, len);
201
202	if (!len)
203	return 0;
204
205	memset(&msg, 0, sizeof(msg));
206
207	return kernel_sendmsg(sock, &msg, &iv, 1, len);
208	}
209
b03efcfb	210	static void cmtp_process_transmit(struct cmtp_session *session)
1da177e4 LT	211	{
	212	struct sk_buff skb, nskb;
	213	unsigned char *hdr;
	214	unsigned int size, tail;
	215
	216	BT_DBG("session %p", session);
	217
5a08ecce AE	218	nskb = alloc_skb(session->mtu, GFP_ATOMIC);
5a08ecce AE	219	if (!nskb) {
1da177e4	220	BT_ERR("Can't allocate memory for new frame");
b03efcfb	221	return;
1da177e4 LT	222	}
	223
	224	while ((skb = skb_dequeue(&session->transmit))) {
	225	struct cmtp_scb scb = (void ) skb->cb;
	226
5a08ecce AE	227	tail = session->mtu - nskb->len;
5a08ecce AE	228	if (tail < 5) {
1da177e4 LT	229	cmtp_send_frame(session, nskb->data, nskb->len);
	230	skb_trim(nskb, 0);
	231	tail = session->mtu;
	232	}
	233
	234	size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
	235
58aac468 SJ	236	if (scb->id < 0) {
	237	scb->id = cmtp_alloc_block_id(session);
	238	if (scb->id < 0) {
	239	skb_queue_head(&session->transmit, skb);
	240	break;
	241	}
1da177e4 LT	242	}
	243
	244	if (size < 256) {
	245	hdr = skb_put(nskb, 2);
	246	hdr[0] = 0x40
	247	\| ((scb->id << 2) & 0x3c)
	248	\| ((skb->len == size) ? 0x00 : 0x01);
	249	hdr[1] = size;
	250	} else {
	251	hdr = skb_put(nskb, 3);
	252	hdr[0] = 0x80
	253	\| ((scb->id << 2) & 0x3c)
	254	\| ((skb->len == size) ? 0x00 : 0x01);
	255	hdr[1] = size & 0xff;
	256	hdr[2] = size >> 8;
	257	}
	258
d626f62b	259	skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
1da177e4 LT	260	skb_pull(skb, size);
	261
	262	if (skb->len > 0) {
	263	skb_queue_head(&session->transmit, skb);
	264	} else {
	265	cmtp_free_block_id(session, scb->id);
	266	if (scb->data) {
	267	cmtp_send_frame(session, nskb->data, nskb->len);
	268	skb_trim(nskb, 0);
	269	}
	270	kfree_skb(skb);
	271	}
	272	}
	273
	274	cmtp_send_frame(session, nskb->data, nskb->len);
	275
	276	kfree_skb(nskb);
1da177e4 LT	277	}
	278
	279	static int cmtp_session(void *arg)
	280	{
	281	struct cmtp_session *session = arg;
	282	struct sock *sk = session->sock->sk;
	283	struct sk_buff *skb;
	284	wait_queue_t wait;
	285
	286	BT_DBG("session %p", session);
	287
1da177e4	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);
3a3f5c7d	292	while (1) {
1da177e4 LT	293	set_current_state(TASK_INTERRUPTIBLE);
1da177e4 LT	294
7176522c	295	if (atomic_read(&session->terminate))
3a3f5c7d	296	break;
1da177e4 LT	297	if (sk->sk_state != BT_CONNECTED)
	298	break;
	299
	300	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
	301	skb_orphan(skb);
44935720 MM	302	if (!skb_linearize(skb))
	303	cmtp_recv_frame(session, skb);
	304	else
	305	kfree_skb(skb);
1da177e4 LT	306	}
	307
	308	cmtp_process_transmit(session);
	309
	310	schedule();
	311	}
3a3f5c7d	312	__set_current_state(TASK_RUNNING);
aa395145	313	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	314
	315	down_write(&cmtp_session_sem);
	316
b2ddeb11	317	if (!(session->flags & BIT(CMTP_LOOPBACK)))
1da177e4 LT	318	cmtp_detach_device(session);
	319
	320	fput(session->sock->file);
	321
	322	__cmtp_unlink_session(session);
	323
	324	up_write(&cmtp_session_sem);
	325
	326	kfree(session);
48b28b8d	327	module_put_and_exit(0);
1da177e4 LT	328	return 0;
	329	}
	330
	331	int cmtp_add_connection(struct cmtp_connadd_req req, struct socket sock)
	332	{
8bf17a36	333	u32 valid_flags = BIT(CMTP_LOOPBACK);
1da177e4	334	struct cmtp_session session, s;
1da177e4 LT	335	int i, err;
	336
	337	BT_DBG("");
	338
96c26653 AV	339	if (!l2cap_is_socket(sock))
	340	return -EBADFD;
	341
8bf17a36 MH	342	if (req->flags & ~valid_flags)
	343	return -EINVAL;
	344
25ea6db0	345	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
8e87d142	346	if (!session)
1da177e4	347	return -ENOMEM;
1da177e4 LT	348
	349	down_write(&cmtp_session_sem);
	350
88f1fd27	351	s = __cmtp_get_session(&l2cap_pi(sock->sk)->chan->dst);
1da177e4 LT	352	if (s && s->state == BT_CONNECTED) {
	353	err = -EEXIST;
	354	goto failed;
	355	}
	356
88f1fd27	357	bacpy(&session->bdaddr, &l2cap_pi(sock->sk)->chan->dst);
1da177e4	358
0c1bc5c6 GP	359	session->mtu = min_t(uint, l2cap_pi(sock->sk)->chan->omtu,
0c1bc5c6 GP	360	l2cap_pi(sock->sk)->chan->imtu);
1da177e4 LT	361
	362	BT_DBG("mtu %d", session->mtu);
	363
88f1fd27	364	sprintf(session->name, "%pMR", &session->bdaddr);
1da177e4 LT	365
	366	session->sock = sock;
	367	session->state = BT_CONFIG;
	368
	369	init_waitqueue_head(&session->wait);
	370
	371	session->msgnum = CMTP_INITIAL_MSGNUM;
	372
	373	INIT_LIST_HEAD(&session->applications);
	374
	375	skb_queue_head_init(&session->transmit);
	376
	377	for (i = 0; i < 16; i++)
	378	session->reassembly[i] = NULL;
	379
	380	session->flags = req->flags;
	381
	382	__cmtp_link_session(session);
	383
48b28b8d	384	__module_get(THIS_MODULE);
fada4ac3 SJ	385	session->task = kthread_run(cmtp_session, session, "kcmtpd_ctr_%d",
	386	session->num);
	387	if (IS_ERR(session->task)) {
48b28b8d	388	module_put(THIS_MODULE);
fada4ac3	389	err = PTR_ERR(session->task);
1da177e4	390	goto unlink;
fada4ac3	391	}
1da177e4	392
b2ddeb11	393	if (!(session->flags & BIT(CMTP_LOOPBACK))) {
1da177e4	394	err = cmtp_attach_device(session);
687beaa0 PH	395	if (err < 0) {
	396	atomic_inc(&session->terminate);
	397	wake_up_process(session->task);
	398	up_write(&cmtp_session_sem);
	399	return err;
	400	}
1da177e4 LT	401	}
	402
	403	up_write(&cmtp_session_sem);
	404	return 0;
	405
1da177e4 LT	406	unlink:
	407	__cmtp_unlink_session(session);
	408
	409	failed:
	410	up_write(&cmtp_session_sem);
	411	kfree(session);
	412	return err;
	413	}
	414
	415	int cmtp_del_connection(struct cmtp_conndel_req *req)
	416	{
8bf17a36	417	u32 valid_flags = 0;
1da177e4 LT	418	struct cmtp_session *session;
	419	int err = 0;
	420
	421	BT_DBG("");
	422
8bf17a36 MH	423	if (req->flags & ~valid_flags)
	424	return -EINVAL;
	425
1da177e4 LT	426	down_read(&cmtp_session_sem);
	427
	428	session = __cmtp_get_session(&req->bdaddr);
	429	if (session) {
	430	/* Flush the transmit queue */
	431	skb_queue_purge(&session->transmit);
	432
fada4ac3	433	/* Stop session thread */
7176522c PH	434	atomic_inc(&session->terminate);
7176522c PH	435	wake_up_process(session->task);
1da177e4 LT	436	} else
	437	err = -ENOENT;
	438
	439	up_read(&cmtp_session_sem);
	440	return err;
	441	}
	442
	443	int cmtp_get_connlist(struct cmtp_connlist_req *req)
	444	{
8035ded4	445	struct cmtp_session *session;
1da177e4 LT	446	int err = 0, n = 0;
	447
	448	BT_DBG("");
	449
	450	down_read(&cmtp_session_sem);
	451
8035ded4	452	list_for_each_entry(session, &cmtp_session_list, list) {
1da177e4 LT	453	struct cmtp_conninfo ci;
1da177e4 LT	454
1da177e4 LT	455	__cmtp_copy_session(session, &ci);
	456
	457	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
	458	err = -EFAULT;
	459	break;
	460	}
	461
	462	if (++n >= req->cnum)
	463	break;
	464
	465	req->ci++;
	466	}
	467	req->cnum = n;
	468
	469	up_read(&cmtp_session_sem);
	470	return err;
	471	}
	472
	473	int cmtp_get_conninfo(struct cmtp_conninfo *ci)
	474	{
	475	struct cmtp_session *session;
	476	int err = 0;
	477
	478	down_read(&cmtp_session_sem);
	479
	480	session = __cmtp_get_session(&ci->bdaddr);
	481	if (session)
	482	__cmtp_copy_session(session, ci);
	483	else
	484	err = -ENOENT;
	485
	486	up_read(&cmtp_session_sem);
	487	return err;
	488	}
	489
	490
	491	static int __init cmtp_init(void)
	492	{
1da177e4 LT	493	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
	494
	495	cmtp_init_sockets();
	496
	497	return 0;
	498	}
	499
	500	static void __exit cmtp_exit(void)
	501	{
	502	cmtp_cleanup_sockets();
	503	}
	504
	505	module_init(cmtp_init);
	506	module_exit(cmtp_exit);
	507
	508	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	509	MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
	510	MODULE_VERSION(VERSION);
	511	MODULE_LICENSE("GPL");
	512	MODULE_ALIAS("bt-proto-5");