2 CMTP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
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;
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
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
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
23 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/poll.h>
31 #include <linux/fcntl.h>
32 #include <linux/freezer.h>
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 <linux/kthread.h>
41 #include <linux/isdn/capilli.h>
43 #include <net/bluetooth/bluetooth.h>
44 #include <net/bluetooth/l2cap.h>
50 static DECLARE_RWSEM(cmtp_session_sem);
51 static LIST_HEAD(cmtp_session_list);
53 static struct cmtp_session *__cmtp_get_session(bdaddr_t *bdaddr)
55 struct cmtp_session *session;
60 list_for_each(p, &cmtp_session_list) {
61 session = list_entry(p, struct cmtp_session, list);
62 if (!bacmp(bdaddr, &session->bdaddr))
68 static void __cmtp_link_session(struct cmtp_session *session)
70 list_add(&session->list, &cmtp_session_list);
73 static void __cmtp_unlink_session(struct cmtp_session *session)
75 list_del(&session->list);
78 static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
80 memset(ci, 0, sizeof(*ci));
81 bacpy(&ci->bdaddr, &session->bdaddr);
83 ci->flags = session->flags;
84 ci->state = session->state;
86 ci->num = session->num;
90 static inline int cmtp_alloc_block_id(struct cmtp_session *session)
94 for (i = 0; i < 16; i++)
95 if (!test_and_set_bit(i, &session->blockids)) {
103 static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
105 clear_bit(id, &session->blockids);
108 static inline void cmtp_add_msgpart(struct cmtp_session *session, int id, const unsigned char *buf, int count)
110 struct sk_buff *skb = session->reassembly[id], *nskb;
113 BT_DBG("session %p buf %p count %d", session, buf, count);
115 size = (skb) ? skb->len + count : count;
117 nskb = alloc_skb(size, GFP_ATOMIC);
119 BT_ERR("Can't allocate memory for CAPI message");
123 if (skb && (skb->len > 0))
124 skb_copy_from_linear_data(skb, skb_put(nskb, skb->len), skb->len);
126 memcpy(skb_put(nskb, count), buf, count);
128 session->reassembly[id] = nskb;
133 static inline int cmtp_recv_frame(struct cmtp_session *session, struct sk_buff *skb)
135 __u8 hdr, hdrlen, id;
138 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
140 while (skb->len > 0) {
143 switch (hdr & 0xc0) {
150 len = skb->data[1] | (skb->data[2] << 8);
158 id = (hdr & 0x3c) >> 2;
160 BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);
162 if (hdrlen + len > skb->len) {
163 BT_ERR("Wrong size or header information in CMTP frame");
168 skb_pull(skb, hdrlen);
172 switch (hdr & 0x03) {
174 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
175 cmtp_recv_capimsg(session, session->reassembly[id]);
176 session->reassembly[id] = NULL;
179 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
182 if (session->reassembly[id] != NULL)
183 kfree_skb(session->reassembly[id]);
184 session->reassembly[id] = NULL;
188 skb_pull(skb, hdrlen + len);
195 static int cmtp_send_frame(struct cmtp_session *session, unsigned char *data, int len)
197 struct socket *sock = session->sock;
198 struct kvec iv = { data, len };
201 BT_DBG("session %p data %p len %d", session, data, len);
206 memset(&msg, 0, sizeof(msg));
208 return kernel_sendmsg(sock, &msg, &iv, 1, len);
211 static void cmtp_process_transmit(struct cmtp_session *session)
213 struct sk_buff *skb, *nskb;
215 unsigned int size, tail;
217 BT_DBG("session %p", session);
219 nskb = alloc_skb(session->mtu, GFP_ATOMIC);
221 BT_ERR("Can't allocate memory for new frame");
225 while ((skb = skb_dequeue(&session->transmit))) {
226 struct cmtp_scb *scb = (void *) skb->cb;
228 tail = session->mtu - nskb->len;
230 cmtp_send_frame(session, nskb->data, nskb->len);
235 size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
238 scb->id = cmtp_alloc_block_id(session);
240 skb_queue_head(&session->transmit, skb);
246 hdr = skb_put(nskb, 2);
248 | ((scb->id << 2) & 0x3c)
249 | ((skb->len == size) ? 0x00 : 0x01);
252 hdr = skb_put(nskb, 3);
254 | ((scb->id << 2) & 0x3c)
255 | ((skb->len == size) ? 0x00 : 0x01);
256 hdr[1] = size & 0xff;
260 skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
264 skb_queue_head(&session->transmit, skb);
266 cmtp_free_block_id(session, scb->id);
268 cmtp_send_frame(session, nskb->data, nskb->len);
275 cmtp_send_frame(session, nskb->data, nskb->len);
280 static int cmtp_session(void *arg)
282 struct cmtp_session *session = arg;
283 struct sock *sk = session->sock->sk;
287 BT_DBG("session %p", session);
289 set_user_nice(current, -15);
291 init_waitqueue_entry(&wait, current);
292 add_wait_queue(sk_sleep(sk), &wait);
294 set_current_state(TASK_INTERRUPTIBLE);
296 if (atomic_read(&session->terminate))
298 if (sk->sk_state != BT_CONNECTED)
301 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
303 if (!skb_linearize(skb))
304 cmtp_recv_frame(session, skb);
309 cmtp_process_transmit(session);
313 __set_current_state(TASK_RUNNING);
314 remove_wait_queue(sk_sleep(sk), &wait);
316 down_write(&cmtp_session_sem);
318 if (!(session->flags & (1 << CMTP_LOOPBACK)))
319 cmtp_detach_device(session);
321 fput(session->sock->file);
323 __cmtp_unlink_session(session);
325 up_write(&cmtp_session_sem);
328 module_put_and_exit(0);
332 int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
334 struct cmtp_session *session, *s;
339 session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
343 down_write(&cmtp_session_sem);
345 s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
346 if (s && s->state == BT_CONNECTED) {
351 bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
353 session->mtu = min_t(uint, l2cap_pi(sock->sk)->chan->omtu,
354 l2cap_pi(sock->sk)->chan->imtu);
356 BT_DBG("mtu %d", session->mtu);
358 sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));
360 session->sock = sock;
361 session->state = BT_CONFIG;
363 init_waitqueue_head(&session->wait);
365 session->msgnum = CMTP_INITIAL_MSGNUM;
367 INIT_LIST_HEAD(&session->applications);
369 skb_queue_head_init(&session->transmit);
371 for (i = 0; i < 16; i++)
372 session->reassembly[i] = NULL;
374 session->flags = req->flags;
376 __cmtp_link_session(session);
378 __module_get(THIS_MODULE);
379 session->task = kthread_run(cmtp_session, session, "kcmtpd_ctr_%d",
381 if (IS_ERR(session->task)) {
382 module_put(THIS_MODULE);
383 err = PTR_ERR(session->task);
387 if (!(session->flags & (1 << CMTP_LOOPBACK))) {
388 err = cmtp_attach_device(session);
390 atomic_inc(&session->terminate);
391 wake_up_process(session->task);
392 up_write(&cmtp_session_sem);
397 up_write(&cmtp_session_sem);
401 __cmtp_unlink_session(session);
404 up_write(&cmtp_session_sem);
409 int cmtp_del_connection(struct cmtp_conndel_req *req)
411 struct cmtp_session *session;
416 down_read(&cmtp_session_sem);
418 session = __cmtp_get_session(&req->bdaddr);
420 /* Flush the transmit queue */
421 skb_queue_purge(&session->transmit);
423 /* Stop session thread */
424 atomic_inc(&session->terminate);
425 wake_up_process(session->task);
429 up_read(&cmtp_session_sem);
433 int cmtp_get_connlist(struct cmtp_connlist_req *req)
440 down_read(&cmtp_session_sem);
442 list_for_each(p, &cmtp_session_list) {
443 struct cmtp_session *session;
444 struct cmtp_conninfo ci;
446 session = list_entry(p, struct cmtp_session, list);
448 __cmtp_copy_session(session, &ci);
450 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
455 if (++n >= req->cnum)
462 up_read(&cmtp_session_sem);
466 int cmtp_get_conninfo(struct cmtp_conninfo *ci)
468 struct cmtp_session *session;
471 down_read(&cmtp_session_sem);
473 session = __cmtp_get_session(&ci->bdaddr);
475 __cmtp_copy_session(session, ci);
479 up_read(&cmtp_session_sem);
484 static int __init cmtp_init(void)
486 BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
493 static void __exit cmtp_exit(void)
495 cmtp_cleanup_sockets();
498 module_init(cmtp_init);
499 module_exit(cmtp_exit);
501 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
502 MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
503 MODULE_VERSION(VERSION);
504 MODULE_LICENSE("GPL");
505 MODULE_ALIAS("bt-proto-5");