[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 <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 dst;
	int i, err;

	BT_DBG("");

	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 <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS("bt-proto-5");
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	CMTP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License version 2 as
	7	published by the Free Software Foundation;
	8
	9	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	10	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	11	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	12	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	13	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	14	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	15	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	16	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	17
8e87d142 YH	18	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	19	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	20	SOFTWARE IS DISCLAIMED.
	21	*/
	22
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/types.h>
	26	#include <linux/errno.h>
	27	#include <linux/kernel.h>
1da177e4 LT	28	#include <linux/sched.h>
	29	#include <linux/slab.h>
	30	#include <linux/poll.h>
	31	#include <linux/fcntl.h>
83144186	32	#include <linux/freezer.h>
1da177e4 LT	33	#include <linux/skbuff.h>
	34	#include <linux/socket.h>
	35	#include <linux/ioctl.h>
	36	#include <linux/file.h>
	37	#include <linux/init.h>
	38	#include <net/sock.h>
	39
	40	#include <linux/isdn/capilli.h>
	41
	42	#include <net/bluetooth/bluetooth.h>
	43	#include <net/bluetooth/l2cap.h>
	44
	45	#include "cmtp.h"
	46
1da177e4 LT	47	#define VERSION "1.0"
	48
	49	static DECLARE_RWSEM(cmtp_session_sem);
	50	static LIST_HEAD(cmtp_session_list);
	51
	52	static struct cmtp_session __cmtp_get_session(bdaddr_t bdaddr)
	53	{
	54	struct cmtp_session *session;
	55	struct list_head *p;
	56
	57	BT_DBG("");
	58
	59	list_for_each(p, &cmtp_session_list) {
	60	session = list_entry(p, struct cmtp_session, list);
	61	if (!bacmp(bdaddr, &session->bdaddr))
	62	return session;
	63	}
	64	return NULL;
	65	}
	66
	67	static void __cmtp_link_session(struct cmtp_session *session)
	68	{
	69	__module_get(THIS_MODULE);
	70	list_add(&session->list, &cmtp_session_list);
	71	}
	72
	73	static void __cmtp_unlink_session(struct cmtp_session *session)
	74	{
	75	list_del(&session->list);
	76	module_put(THIS_MODULE);
	77	}
	78
	79	static void __cmtp_copy_session(struct cmtp_session session, struct cmtp_conninfo ci)
	80	{
	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;
cb810a18	324	bdaddr_t dst;
1da177e4 LT	325	int i, err;
	326
	327	BT_DBG("");
	328
1da177e4 LT	329	baswap(&dst, &bt_sk(sock->sk)->dst);
1da177e4 LT	330
25ea6db0	331	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
8e87d142	332	if (!session)
1da177e4	333	return -ENOMEM;
1da177e4 LT	334
	335	down_write(&cmtp_session_sem);
	336
	337	s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
	338	if (s && s->state == BT_CONNECTED) {
	339	err = -EEXIST;
	340	goto failed;
	341	}
	342
	343	bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
	344
	345	session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);
	346
	347	BT_DBG("mtu %d", session->mtu);
	348
	349	sprintf(session->name, "%s", batostr(&dst));
	350
	351	session->sock = sock;
	352	session->state = BT_CONFIG;
	353
	354	init_waitqueue_head(&session->wait);
	355
	356	session->msgnum = CMTP_INITIAL_MSGNUM;
	357
	358	INIT_LIST_HEAD(&session->applications);
	359
	360	skb_queue_head_init(&session->transmit);
	361
	362	for (i = 0; i < 16; i++)
	363	session->reassembly[i] = NULL;
	364
	365	session->flags = req->flags;
	366
	367	__cmtp_link_session(session);
	368
	369	err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
	370	if (err < 0)
	371	goto unlink;
	372
	373	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
	374	err = cmtp_attach_device(session);
	375	if (err < 0)
	376	goto detach;
	377	}
	378
	379	up_write(&cmtp_session_sem);
	380	return 0;
	381
	382	detach:
	383	cmtp_detach_device(session);
	384
	385	unlink:
	386	__cmtp_unlink_session(session);
	387
	388	failed:
	389	up_write(&cmtp_session_sem);
	390	kfree(session);
	391	return err;
	392	}
	393
	394	int cmtp_del_connection(struct cmtp_conndel_req *req)
	395	{
	396	struct cmtp_session *session;
	397	int err = 0;
398
399	BT_DBG("");
400
401	down_read(&cmtp_session_sem);
402
403	session = __cmtp_get_session(&req->bdaddr);
404	if (session) {
405	/* Flush the transmit queue */
406	skb_queue_purge(&session->transmit);
407
408	/* Kill session thread */
409	atomic_inc(&session->terminate);
410	cmtp_schedule(session);
411	} else
412	err = -ENOENT;
413
414	up_read(&cmtp_session_sem);
415	return err;
416	}
417
418	int cmtp_get_connlist(struct cmtp_connlist_req *req)
419	{
420	struct list_head *p;
421	int err = 0, n = 0;
422
423	BT_DBG("");
424
425	down_read(&cmtp_session_sem);
426
427	list_for_each(p, &cmtp_session_list) {
428	struct cmtp_session *session;
429	struct cmtp_conninfo ci;
430
431	session = list_entry(p, struct cmtp_session, list);
432
433	__cmtp_copy_session(session, &ci);
434
435	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
436	err = -EFAULT;
437	break;
438	}
439
440	if (++n >= req->cnum)
441	break;
442
443	req->ci++;
444	}
445	req->cnum = n;
446
447	up_read(&cmtp_session_sem);
448	return err;
449	}
450
451	int cmtp_get_conninfo(struct cmtp_conninfo *ci)
452	{
453	struct cmtp_session *session;
454	int err = 0;
455
456	down_read(&cmtp_session_sem);
457
458	session = __cmtp_get_session(&ci->bdaddr);
459	if (session)
460	__cmtp_copy_session(session, ci);
461	else
462	err = -ENOENT;
463
464	up_read(&cmtp_session_sem);
465	return err;
466	}
467
468
469	static int __init cmtp_init(void)
470	{
471	l2cap_load();
472
473	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
474
475	cmtp_init_sockets();
476
477	return 0;
478	}
479
480	static void __exit cmtp_exit(void)
481	{
482	cmtp_cleanup_sockets();
483	}
484
485	module_init(cmtp_init);
486	module_exit(cmtp_exit);
487
488	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
489	MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
490	MODULE_VERSION(VERSION);
491	MODULE_LICENSE("GPL");
492	MODULE_ALIAS("bt-proto-5");