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>
40 #include <linux/isdn/capilli.h>
42 #include <net/bluetooth/bluetooth.h>
43 #include <net/bluetooth/l2cap.h>
49 static DECLARE_RWSEM(cmtp_session_sem);
50 static LIST_HEAD(cmtp_session_list);
52 static struct cmtp_session *__cmtp_get_session(bdaddr_t *bdaddr)
54 struct cmtp_session *session;
59 list_for_each(p, &cmtp_session_list) {
60 session = list_entry(p, struct cmtp_session, list);
61 if (!bacmp(bdaddr, &session->bdaddr))
67 static void __cmtp_link_session(struct cmtp_session *session)
69 __module_get(THIS_MODULE);
70 list_add(&session->list, &cmtp_session_list);
73 static void __cmtp_unlink_session(struct cmtp_session *session)
75 list_del(&session->list);
76 module_put(THIS_MODULE);
79 static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
81 memset(ci, 0, sizeof(*ci));
82 bacpy(&ci->bdaddr, &session->bdaddr);
84 ci->flags = session->flags;
85 ci->state = session->state;
87 ci->num = session->num;
91 static inline int cmtp_alloc_block_id(struct cmtp_session *session)
95 for (i = 0; i < 16; i++)
96 if (!test_and_set_bit(i, &session->blockids)) {
104 static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
106 clear_bit(id, &session->blockids);
109 static inline void cmtp_add_msgpart(struct cmtp_session *session, int id, const unsigned char *buf, int count)
111 struct sk_buff *skb = session->reassembly[id], *nskb;
114 BT_DBG("session %p buf %p count %d", session, buf, count);
116 size = (skb) ? skb->len + count : count;
118 if (!(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 if (!(nskb = alloc_skb(session->mtu, GFP_ATOMIC))) {
220 BT_ERR("Can't allocate memory for new frame");
224 while ((skb = skb_dequeue(&session->transmit))) {
225 struct cmtp_scb *scb = (void *) skb->cb;
227 if ((tail = (session->mtu - nskb->len)) < 5) {
228 cmtp_send_frame(session, nskb->data, nskb->len);
233 size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
235 if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
236 skb_queue_head(&session->transmit, skb);
241 hdr = skb_put(nskb, 2);
243 | ((scb->id << 2) & 0x3c)
244 | ((skb->len == size) ? 0x00 : 0x01);
247 hdr = skb_put(nskb, 3);
249 | ((scb->id << 2) & 0x3c)
250 | ((skb->len == size) ? 0x00 : 0x01);
251 hdr[1] = size & 0xff;
255 skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
259 skb_queue_head(&session->transmit, skb);
261 cmtp_free_block_id(session, scb->id);
263 cmtp_send_frame(session, nskb->data, nskb->len);
270 cmtp_send_frame(session, nskb->data, nskb->len);
275 static int cmtp_session(void *arg)
277 struct cmtp_session *session = arg;
278 struct sock *sk = session->sock->sk;
282 BT_DBG("session %p", session);
284 daemonize("kcmtpd_ctr_%d", session->num);
285 set_user_nice(current, -15);
287 init_waitqueue_entry(&wait, current);
288 add_wait_queue(sk_sleep(sk), &wait);
289 while (!atomic_read(&session->terminate)) {
290 set_current_state(TASK_INTERRUPTIBLE);
292 if (sk->sk_state != BT_CONNECTED)
295 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
297 cmtp_recv_frame(session, skb);
300 cmtp_process_transmit(session);
304 set_current_state(TASK_RUNNING);
305 remove_wait_queue(sk_sleep(sk), &wait);
307 down_write(&cmtp_session_sem);
309 if (!(session->flags & (1 << CMTP_LOOPBACK)))
310 cmtp_detach_device(session);
312 fput(session->sock->file);
314 __cmtp_unlink_session(session);
316 up_write(&cmtp_session_sem);
322 int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
324 struct cmtp_session *session, *s;
329 session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
333 down_write(&cmtp_session_sem);
335 s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
336 if (s && s->state == BT_CONNECTED) {
341 bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
343 session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);
345 BT_DBG("mtu %d", session->mtu);
347 sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));
349 session->sock = sock;
350 session->state = BT_CONFIG;
352 init_waitqueue_head(&session->wait);
354 session->msgnum = CMTP_INITIAL_MSGNUM;
356 INIT_LIST_HEAD(&session->applications);
358 skb_queue_head_init(&session->transmit);
360 for (i = 0; i < 16; i++)
361 session->reassembly[i] = NULL;
363 session->flags = req->flags;
365 __cmtp_link_session(session);
367 err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
371 if (!(session->flags & (1 << CMTP_LOOPBACK))) {
372 err = cmtp_attach_device(session);
377 up_write(&cmtp_session_sem);
381 cmtp_detach_device(session);
384 __cmtp_unlink_session(session);
387 up_write(&cmtp_session_sem);
392 int cmtp_del_connection(struct cmtp_conndel_req *req)
394 struct cmtp_session *session;
399 down_read(&cmtp_session_sem);
401 session = __cmtp_get_session(&req->bdaddr);
403 /* Flush the transmit queue */
404 skb_queue_purge(&session->transmit);
406 /* Kill session thread */
407 atomic_inc(&session->terminate);
408 cmtp_schedule(session);
412 up_read(&cmtp_session_sem);
416 int cmtp_get_connlist(struct cmtp_connlist_req *req)
423 down_read(&cmtp_session_sem);
425 list_for_each(p, &cmtp_session_list) {
426 struct cmtp_session *session;
427 struct cmtp_conninfo ci;
429 session = list_entry(p, struct cmtp_session, list);
431 __cmtp_copy_session(session, &ci);
433 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
438 if (++n >= req->cnum)
445 up_read(&cmtp_session_sem);
449 int cmtp_get_conninfo(struct cmtp_conninfo *ci)
451 struct cmtp_session *session;
454 down_read(&cmtp_session_sem);
456 session = __cmtp_get_session(&ci->bdaddr);
458 __cmtp_copy_session(session, ci);
462 up_read(&cmtp_session_sem);
467 static int __init cmtp_init(void)
471 BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
478 static void __exit cmtp_exit(void)
480 cmtp_cleanup_sockets();
483 module_init(cmtp_init);
484 module_exit(cmtp_exit);
486 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
487 MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
488 MODULE_VERSION(VERSION);
489 MODULE_LICENSE("GPL");
490 MODULE_ALIAS("bt-proto-5");