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

/*
   CMTP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2002-2003 Marcel Holtmann <[email protected]>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

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

	if (!(nskb = alloc_skb(size, GFP_ATOMIC))) {
		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);

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

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

		if ((tail = (session->mtu - nskb->len)) < 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;
	bdaddr_t src, dst;
	int i, err;

	BT_DBG("");

	baswap(&src, &bt_sk(sock->sk)->src);
	baswap(&dst, &bt_sk(sock->sk)->dst);

	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(&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 <[email protected]>");
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 <[email protected]>
	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	{
	81	bacpy(&ci->bdaddr, &session->bdaddr);
	82
	83	ci->flags = session->flags;
	84	ci->state = session->state;
	85
	86	ci->num = session->num;
	87	}
	88
	89
	90	static inline int cmtp_alloc_block_id(struct cmtp_session *session)
	91	{
	92	int i, id = -1;
	93
	94	for (i = 0; i < 16; i++)
	95	if (!test_and_set_bit(i, &session->blockids)) {
	96	id = i;
	97	break;
	98	}
	99
	100	return id;
	101	}
	102
	103	static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
	104	{
	105	clear_bit(id, &session->blockids);
	106	}
	107
	108	static inline void cmtp_add_msgpart(struct cmtp_session session, int id, const unsigned char buf, int count)
	109	{
	110	struct sk_buff skb = session->reassembly[id], nskb;
111	int size;
112
113	BT_DBG("session %p buf %p count %d", session, buf, count);
114
115	size = (skb) ? skb->len + count : count;
116
117	if (!(nskb = alloc_skb(size, GFP_ATOMIC))) {
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
	218	if (!(nskb = alloc_skb(session->mtu, GFP_ATOMIC))) {
	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
	226	if ((tail = (session->mtu - nskb->len)) < 5) {
	227	cmtp_send_frame(session, nskb->data, nskb->len);
	228	skb_trim(nskb, 0);
	229	tail = session->mtu;
	230	}
	231
	232	size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
	233
	234	if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
	235	skb_queue_head(&session->transmit, skb);
	236	break;
	237	}
	238
	239	if (size < 256) {
	240	hdr = skb_put(nskb, 2);
	241	hdr[0] = 0x40
	242	\| ((scb->id << 2) & 0x3c)
	243	\| ((skb->len == size) ? 0x00 : 0x01);
	244	hdr[1] = size;
	245	} else {
	246	hdr = skb_put(nskb, 3);
	247	hdr[0] = 0x80
	248	\| ((scb->id << 2) & 0x3c)
	249	\| ((skb->len == size) ? 0x00 : 0x01);
	250	hdr[1] = size & 0xff;
	251	hdr[2] = size >> 8;
	252	}
	253
d626f62b	254	skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
1da177e4 LT	255	skb_pull(skb, size);
	256
	257	if (skb->len > 0) {
	258	skb_queue_head(&session->transmit, skb);
	259	} else {
	260	cmtp_free_block_id(session, scb->id);
	261	if (scb->data) {
	262	cmtp_send_frame(session, nskb->data, nskb->len);
	263	skb_trim(nskb, 0);
	264	}
	265	kfree_skb(skb);
	266	}
	267	}
	268
	269	cmtp_send_frame(session, nskb->data, nskb->len);
	270
	271	kfree_skb(nskb);
1da177e4 LT	272	}
	273
	274	static int cmtp_session(void *arg)
	275	{
	276	struct cmtp_session *session = arg;
	277	struct sock *sk = session->sock->sk;
	278	struct sk_buff *skb;
	279	wait_queue_t wait;
	280
	281	BT_DBG("session %p", session);
	282
	283	daemonize("kcmtpd_ctr_%d", session->num);
	284	set_user_nice(current, -15);
1da177e4 LT	285
1da177e4 LT	286	init_waitqueue_entry(&wait, current);
aa395145	287	add_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	288	while (!atomic_read(&session->terminate)) {
	289	set_current_state(TASK_INTERRUPTIBLE);
	290
	291	if (sk->sk_state != BT_CONNECTED)
	292	break;
	293
	294	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
	295	skb_orphan(skb);
	296	cmtp_recv_frame(session, skb);
	297	}
	298
	299	cmtp_process_transmit(session);
	300
	301	schedule();
	302	}
	303	set_current_state(TASK_RUNNING);
aa395145	304	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	305
	306	down_write(&cmtp_session_sem);
	307
	308	if (!(session->flags & (1 << CMTP_LOOPBACK)))
	309	cmtp_detach_device(session);
	310
	311	fput(session->sock->file);
	312
	313	__cmtp_unlink_session(session);
	314
	315	up_write(&cmtp_session_sem);
	316
	317	kfree(session);
	318	return 0;
	319	}
	320
	321	int cmtp_add_connection(struct cmtp_connadd_req req, struct socket sock)
	322	{
	323	struct cmtp_session session, s;
	324	bdaddr_t src, dst;
	325	int i, err;
	326
	327	BT_DBG("");
	328
	329	baswap(&src, &bt_sk(sock->sk)->src);
	330	baswap(&dst, &bt_sk(sock->sk)->dst);
	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
	350	sprintf(session->name, "%s", batostr(&dst));
	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 <[email protected]>");
490	MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
491	MODULE_VERSION(VERSION);
492	MODULE_LICENSE("GPL");
493	MODULE_ALIAS("bt-proto-5");