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/config.h>
24 #include <linux/module.h>
26 #include <linux/types.h>
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/major.h>
30 #include <linux/sched.h>
31 #include <linux/slab.h>
32 #include <linux/poll.h>
33 #include <linux/fcntl.h>
34 #include <linux/skbuff.h>
35 #include <linux/socket.h>
36 #include <linux/ioctl.h>
37 #include <linux/file.h>
38 #include <linux/init.h>
41 #include <linux/isdn/capilli.h>
43 #include <net/bluetooth/bluetooth.h>
44 #include <net/bluetooth/l2cap.h>
48 #ifndef CONFIG_BT_CMTP_DEBUG
55 static DECLARE_RWSEM(cmtp_session_sem);
56 static LIST_HEAD(cmtp_session_list);
58 static struct cmtp_session *__cmtp_get_session(bdaddr_t *bdaddr)
60 struct cmtp_session *session;
65 list_for_each(p, &cmtp_session_list) {
66 session = list_entry(p, struct cmtp_session, list);
67 if (!bacmp(bdaddr, &session->bdaddr))
73 static void __cmtp_link_session(struct cmtp_session *session)
75 __module_get(THIS_MODULE);
76 list_add(&session->list, &cmtp_session_list);
79 static void __cmtp_unlink_session(struct cmtp_session *session)
81 list_del(&session->list);
82 module_put(THIS_MODULE);
85 static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
87 bacpy(&ci->bdaddr, &session->bdaddr);
89 ci->flags = session->flags;
90 ci->state = session->state;
92 ci->num = session->num;
96 static inline int cmtp_alloc_block_id(struct cmtp_session *session)
100 for (i = 0; i < 16; i++)
101 if (!test_and_set_bit(i, &session->blockids)) {
109 static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
111 clear_bit(id, &session->blockids);
114 static inline void cmtp_add_msgpart(struct cmtp_session *session, int id, const unsigned char *buf, int count)
116 struct sk_buff *skb = session->reassembly[id], *nskb;
119 BT_DBG("session %p buf %p count %d", session, buf, count);
121 size = (skb) ? skb->len + count : count;
123 if (!(nskb = alloc_skb(size, GFP_ATOMIC))) {
124 BT_ERR("Can't allocate memory for CAPI message");
128 if (skb && (skb->len > 0))
129 memcpy(skb_put(nskb, skb->len), skb->data, skb->len);
131 memcpy(skb_put(nskb, count), buf, count);
133 session->reassembly[id] = nskb;
139 static inline int cmtp_recv_frame(struct cmtp_session *session, struct sk_buff *skb)
141 __u8 hdr, hdrlen, id;
144 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
146 while (skb->len > 0) {
149 switch (hdr & 0xc0) {
156 len = skb->data[1] | (skb->data[2] << 8);
164 id = (hdr & 0x3c) >> 2;
166 BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);
168 if (hdrlen + len > skb->len) {
169 BT_ERR("Wrong size or header information in CMTP frame");
174 skb_pull(skb, hdrlen);
178 switch (hdr & 0x03) {
180 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
181 cmtp_recv_capimsg(session, session->reassembly[id]);
182 session->reassembly[id] = NULL;
185 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
188 if (session->reassembly[id] != NULL)
189 kfree_skb(session->reassembly[id]);
190 session->reassembly[id] = NULL;
194 skb_pull(skb, hdrlen + len);
201 static int cmtp_send_frame(struct cmtp_session *session, unsigned char *data, int len)
203 struct socket *sock = session->sock;
204 struct iovec iv = { data, len };
207 BT_DBG("session %p data %p len %d", session, data, len);
212 memset(&msg, 0, sizeof(msg));
216 return sock_sendmsg(sock, &msg, len);
219 static int cmtp_process_transmit(struct cmtp_session *session)
221 struct sk_buff *skb, *nskb;
223 unsigned int size, tail;
225 BT_DBG("session %p", session);
227 if (!(nskb = alloc_skb(session->mtu, GFP_ATOMIC))) {
228 BT_ERR("Can't allocate memory for new frame");
232 while ((skb = skb_dequeue(&session->transmit))) {
233 struct cmtp_scb *scb = (void *) skb->cb;
235 if ((tail = (session->mtu - nskb->len)) < 5) {
236 cmtp_send_frame(session, nskb->data, nskb->len);
241 size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
243 if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
244 skb_queue_head(&session->transmit, skb);
249 hdr = skb_put(nskb, 2);
251 | ((scb->id << 2) & 0x3c)
252 | ((skb->len == size) ? 0x00 : 0x01);
255 hdr = skb_put(nskb, 3);
257 | ((scb->id << 2) & 0x3c)
258 | ((skb->len == size) ? 0x00 : 0x01);
259 hdr[1] = size & 0xff;
263 memcpy(skb_put(nskb, size), skb->data, size);
267 skb_queue_head(&session->transmit, skb);
269 cmtp_free_block_id(session, scb->id);
271 cmtp_send_frame(session, nskb->data, nskb->len);
278 cmtp_send_frame(session, nskb->data, nskb->len);
282 return skb_queue_len(&session->transmit);
285 static int cmtp_session(void *arg)
287 struct cmtp_session *session = arg;
288 struct sock *sk = session->sock->sk;
292 BT_DBG("session %p", session);
294 daemonize("kcmtpd_ctr_%d", session->num);
295 set_user_nice(current, -15);
296 current->flags |= PF_NOFREEZE;
300 init_waitqueue_entry(&wait, current);
301 add_wait_queue(sk->sk_sleep, &wait);
302 while (!atomic_read(&session->terminate)) {
303 set_current_state(TASK_INTERRUPTIBLE);
305 if (sk->sk_state != BT_CONNECTED)
308 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
310 cmtp_recv_frame(session, skb);
313 cmtp_process_transmit(session);
317 set_current_state(TASK_RUNNING);
318 remove_wait_queue(sk->sk_sleep, &wait);
320 down_write(&cmtp_session_sem);
322 if (!(session->flags & (1 << CMTP_LOOPBACK)))
323 cmtp_detach_device(session);
325 fput(session->sock->file);
327 __cmtp_unlink_session(session);
329 up_write(&cmtp_session_sem);
335 int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
337 struct cmtp_session *session, *s;
343 baswap(&src, &bt_sk(sock->sk)->src);
344 baswap(&dst, &bt_sk(sock->sk)->dst);
346 session = kmalloc(sizeof(struct cmtp_session), GFP_KERNEL);
349 memset(session, 0, sizeof(struct cmtp_session));
351 down_write(&cmtp_session_sem);
353 s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
354 if (s && s->state == BT_CONNECTED) {
359 bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
361 session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);
363 BT_DBG("mtu %d", session->mtu);
365 sprintf(session->name, "%s", batostr(&dst));
367 session->sock = sock;
368 session->state = BT_CONFIG;
370 init_waitqueue_head(&session->wait);
372 session->msgnum = CMTP_INITIAL_MSGNUM;
374 INIT_LIST_HEAD(&session->applications);
376 skb_queue_head_init(&session->transmit);
378 for (i = 0; i < 16; i++)
379 session->reassembly[i] = NULL;
381 session->flags = req->flags;
383 __cmtp_link_session(session);
385 err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
389 if (!(session->flags & (1 << CMTP_LOOPBACK))) {
390 err = cmtp_attach_device(session);
395 up_write(&cmtp_session_sem);
399 cmtp_detach_device(session);
402 __cmtp_unlink_session(session);
405 up_write(&cmtp_session_sem);
410 int cmtp_del_connection(struct cmtp_conndel_req *req)
412 struct cmtp_session *session;
417 down_read(&cmtp_session_sem);
419 session = __cmtp_get_session(&req->bdaddr);
421 /* Flush the transmit queue */
422 skb_queue_purge(&session->transmit);
424 /* Kill session thread */
425 atomic_inc(&session->terminate);
426 cmtp_schedule(session);
430 up_read(&cmtp_session_sem);
434 int cmtp_get_connlist(struct cmtp_connlist_req *req)
441 down_read(&cmtp_session_sem);
443 list_for_each(p, &cmtp_session_list) {
444 struct cmtp_session *session;
445 struct cmtp_conninfo ci;
447 session = list_entry(p, struct cmtp_session, list);
449 __cmtp_copy_session(session, &ci);
451 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
456 if (++n >= req->cnum)
463 up_read(&cmtp_session_sem);
467 int cmtp_get_conninfo(struct cmtp_conninfo *ci)
469 struct cmtp_session *session;
472 down_read(&cmtp_session_sem);
474 session = __cmtp_get_session(&ci->bdaddr);
476 __cmtp_copy_session(session, ci);
480 up_read(&cmtp_session_sem);
485 static int __init cmtp_init(void)
489 BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
496 static void __exit cmtp_exit(void)
498 cmtp_cleanup_sockets();
501 module_init(cmtp_init);
502 module_exit(cmtp_exit);
504 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
505 MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
506 MODULE_VERSION(VERSION);
507 MODULE_LICENSE("GPL");
508 MODULE_ALIAS("bt-proto-5");