1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24
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 <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
47#ifndef CONFIG_BT_CMTP_DEBUG
48#undef BT_DBG
49#define BT_DBG(D...)
50#endif
51
52#define VERSION "1.0"
53
54static DECLARE_RWSEM(cmtp_session_sem);
55static LIST_HEAD(cmtp_session_list);
56
57static struct cmtp_session *__cmtp_get_session(bdaddr_t *bdaddr)
58{
59 struct cmtp_session *session;
60 struct list_head *p;
61
62 BT_DBG("");
63
64 list_for_each(p, &cmtp_session_list) {
65 session = list_entry(p, struct cmtp_session, list);
66 if (!bacmp(bdaddr, &session->bdaddr))
67 return session;
68 }
69 return NULL;
70}
71
72static void __cmtp_link_session(struct cmtp_session *session)
73{
74 __module_get(THIS_MODULE);
75 list_add(&session->list, &cmtp_session_list);
76}
77
78static void __cmtp_unlink_session(struct cmtp_session *session)
79{
80 list_del(&session->list);
81 module_put(THIS_MODULE);
82}
83
84static void __cmtp_copy_session(struct cmtp_session *session, struct cmtp_conninfo *ci)
85{
86 bacpy(&ci->bdaddr, &session->bdaddr);
87
88 ci->flags = session->flags;
89 ci->state = session->state;
90
91 ci->num = session->num;
92}
93
94
95static inline int cmtp_alloc_block_id(struct cmtp_session *session)
96{
97 int i, id = -1;
98
99 for (i = 0; i < 16; i++)
100 if (!test_and_set_bit(i, &session->blockids)) {
101 id = i;
102 break;
103 }
104
105 return id;
106}
107
108static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
109{
110 clear_bit(id, &session->blockids);
111}
112
113static inline void cmtp_add_msgpart(struct cmtp_session *session, int id, const unsigned char *buf, int count)
114{
115 struct sk_buff *skb = session->reassembly[id], *nskb;
116 int size;
117
118 BT_DBG("session %p buf %p count %d", session, buf, count);
119
120 size = (skb) ? skb->len + count : count;
121
122 if (!(nskb = alloc_skb(size, GFP_ATOMIC))) {
123 BT_ERR("Can't allocate memory for CAPI message");
124 return;
125 }
126
127 if (skb && (skb->len > 0))
128 skb_copy_from_linear_data(skb, skb_put(nskb, skb->len), skb->len);
129
130 memcpy(skb_put(nskb, count), buf, count);
131
132 session->reassembly[id] = nskb;
133
134 if (skb)
135 kfree_skb(skb);
136}
137
138static inline int cmtp_recv_frame(struct cmtp_session *session, struct sk_buff *skb)
139{
140 __u8 hdr, hdrlen, id;
141 __u16 len;
142
143 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
144
145 while (skb->len > 0) {
146 hdr = skb->data[0];
147
148 switch (hdr & 0xc0) {
149 case 0x40:
150 hdrlen = 2;
151 len = skb->data[1];
152 break;
153 case 0x80:
154 hdrlen = 3;
155 len = skb->data[1] | (skb->data[2] << 8);
156 break;
157 default:
158 hdrlen = 1;
159 len = 0;
160 break;
161 }
162
163 id = (hdr & 0x3c) >> 2;
164
165 BT_DBG("hdr 0x%02x hdrlen %d len %d id %d", hdr, hdrlen, len, id);
166
167 if (hdrlen + len > skb->len) {
168 BT_ERR("Wrong size or header information in CMTP frame");
169 break;
170 }
171
172 if (len == 0) {
173 skb_pull(skb, hdrlen);
174 continue;
175 }
176
177 switch (hdr & 0x03) {
178 case 0x00:
179 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
180 cmtp_recv_capimsg(session, session->reassembly[id]);
181 session->reassembly[id] = NULL;
182 break;
183 case 0x01:
184 cmtp_add_msgpart(session, id, skb->data + hdrlen, len);
185 break;
186 default:
187 if (session->reassembly[id] != NULL)
188 kfree_skb(session->reassembly[id]);
189 session->reassembly[id] = NULL;
190 break;
191 }
192
193 skb_pull(skb, hdrlen + len);
194 }
195
196 kfree_skb(skb);
197 return 0;
198}
199
200static int cmtp_send_frame(struct cmtp_session *session, unsigned char *data, int len)
201{
202 struct socket *sock = session->sock;
203 struct kvec iv = { data, len };
204 struct msghdr msg;
205
206 BT_DBG("session %p data %p len %d", session, data, len);
207
208 if (!len)
209 return 0;
210
211 memset(&msg, 0, sizeof(msg));
212
213 return kernel_sendmsg(sock, &msg, &iv, 1, len);
214}
215
216static void cmtp_process_transmit(struct cmtp_session *session)
217{
218 struct sk_buff *skb, *nskb;
219 unsigned char *hdr;
220 unsigned int size, tail;
221
222 BT_DBG("session %p", session);
223
224 if (!(nskb = alloc_skb(session->mtu, GFP_ATOMIC))) {
225 BT_ERR("Can't allocate memory for new frame");
226 return;
227 }
228
229 while ((skb = skb_dequeue(&session->transmit))) {
230 struct cmtp_scb *scb = (void *) skb->cb;
231
232 if ((tail = (session->mtu - nskb->len)) < 5) {
233 cmtp_send_frame(session, nskb->data, nskb->len);
234 skb_trim(nskb, 0);
235 tail = session->mtu;
236 }
237
238 size = min_t(uint, ((tail < 258) ? (tail - 2) : (tail - 3)), skb->len);
239
240 if ((scb->id < 0) && ((scb->id = cmtp_alloc_block_id(session)) < 0)) {
241 skb_queue_head(&session->transmit, skb);
242 break;
243 }
244
245 if (size < 256) {
246 hdr = skb_put(nskb, 2);
247 hdr[0] = 0x40
248 | ((scb->id << 2) & 0x3c)
249 | ((skb->len == size) ? 0x00 : 0x01);
250 hdr[1] = size;
251 } else {
252 hdr = skb_put(nskb, 3);
253 hdr[0] = 0x80
254 | ((scb->id << 2) & 0x3c)
255 | ((skb->len == size) ? 0x00 : 0x01);
256 hdr[1] = size & 0xff;
257 hdr[2] = size >> 8;
258 }
259
260 skb_copy_from_linear_data(skb, skb_put(nskb, size), size);
261 skb_pull(skb, size);
262
263 if (skb->len > 0) {
264 skb_queue_head(&session->transmit, skb);
265 } else {
266 cmtp_free_block_id(session, scb->id);
267 if (scb->data) {
268 cmtp_send_frame(session, nskb->data, nskb->len);
269 skb_trim(nskb, 0);
270 }
271 kfree_skb(skb);
272 }
273 }
274
275 cmtp_send_frame(session, nskb->data, nskb->len);
276
277 kfree_skb(nskb);
278}
279
280static int cmtp_session(void *arg)
281{
282 struct cmtp_session *session = arg;
283 struct sock *sk = session->sock->sk;
284 struct sk_buff *skb;
285 wait_queue_t wait;
286
287 BT_DBG("session %p", session);
288
289 daemonize("kcmtpd_ctr_%d", session->num);
290 set_user_nice(current, -15);
291
292 init_waitqueue_entry(&wait, current);
293 add_wait_queue(sk->sk_sleep, &wait);
294 while (!atomic_read(&session->terminate)) {
295 set_current_state(TASK_INTERRUPTIBLE);
296
297 if (sk->sk_state != BT_CONNECTED)
298 break;
299
300 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
301 skb_orphan(skb);
302 cmtp_recv_frame(session, skb);
303 }
304
305 cmtp_process_transmit(session);
306
307 schedule();
308 }
309 set_current_state(TASK_RUNNING);
310 remove_wait_queue(sk->sk_sleep, &wait);
311
312 down_write(&cmtp_session_sem);
313
314 if (!(session->flags & (1 << CMTP_LOOPBACK)))
315 cmtp_detach_device(session);
316
317 fput(session->sock->file);
318
319 __cmtp_unlink_session(session);
320
321 up_write(&cmtp_session_sem);
322
323 kfree(session);
324 return 0;
325}
326
327int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
328{
329 struct cmtp_session *session, *s;
330 bdaddr_t src, dst;
331 int i, err;
332
333 BT_DBG("");
334
335 baswap(&src, &bt_sk(sock->sk)->src);
336 baswap(&dst, &bt_sk(sock->sk)->dst);
337
338 session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
339 if (!session)
340 return -ENOMEM;
341
342 down_write(&cmtp_session_sem);
343
344 s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
345 if (s && s->state == BT_CONNECTED) {
346 err = -EEXIST;
347 goto failed;
348 }
349
350 bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
351
352 session->mtu = min_t(uint, l2cap_pi(sock->sk)->omtu, l2cap_pi(sock->sk)->imtu);
353
354 BT_DBG("mtu %d", session->mtu);
355
356 sprintf(session->name, "%s", batostr(&dst));
357
358 session->sock = sock;
359 session->state = BT_CONFIG;
360
361 init_waitqueue_head(&session->wait);
362
363 session->msgnum = CMTP_INITIAL_MSGNUM;
364
365 INIT_LIST_HEAD(&session->applications);
366
367 skb_queue_head_init(&session->transmit);
368
369 for (i = 0; i < 16; i++)
370 session->reassembly[i] = NULL;
371
372 session->flags = req->flags;
373
374 __cmtp_link_session(session);
375
376 err = kernel_thread(cmtp_session, session, CLONE_KERNEL);
377 if (err < 0)
378 goto unlink;
379
380 if (!(session->flags & (1 << CMTP_LOOPBACK))) {
381 err = cmtp_attach_device(session);
382 if (err < 0)
383 goto detach;
384 }
385
386 up_write(&cmtp_session_sem);
387 return 0;
388
389detach:
390 cmtp_detach_device(session);
391
392unlink:
393 __cmtp_unlink_session(session);
394
395failed:
396 up_write(&cmtp_session_sem);
397 kfree(session);
398 return err;
399}
400
401int cmtp_del_connection(struct cmtp_conndel_req *req)
402{
403 struct cmtp_session *session;
404 int err = 0;
405
406 BT_DBG("");
407
408 down_read(&cmtp_session_sem);
409
410 session = __cmtp_get_session(&req->bdaddr);
411 if (session) {
412
413 skb_queue_purge(&session->transmit);
414
415
416 atomic_inc(&session->terminate);
417 cmtp_schedule(session);
418 } else
419 err = -ENOENT;
420
421 up_read(&cmtp_session_sem);
422 return err;
423}
424
425int cmtp_get_connlist(struct cmtp_connlist_req *req)
426{
427 struct list_head *p;
428 int err = 0, n = 0;
429
430 BT_DBG("");
431
432 down_read(&cmtp_session_sem);
433
434 list_for_each(p, &cmtp_session_list) {
435 struct cmtp_session *session;
436 struct cmtp_conninfo ci;
437
438 session = list_entry(p, struct cmtp_session, list);
439
440 __cmtp_copy_session(session, &ci);
441
442 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
443 err = -EFAULT;
444 break;
445 }
446
447 if (++n >= req->cnum)
448 break;
449
450 req->ci++;
451 }
452 req->cnum = n;
453
454 up_read(&cmtp_session_sem);
455 return err;
456}
457
458int cmtp_get_conninfo(struct cmtp_conninfo *ci)
459{
460 struct cmtp_session *session;
461 int err = 0;
462
463 down_read(&cmtp_session_sem);
464
465 session = __cmtp_get_session(&ci->bdaddr);
466 if (session)
467 __cmtp_copy_session(session, ci);
468 else
469 err = -ENOENT;
470
471 up_read(&cmtp_session_sem);
472 return err;
473}
474
475
476static int __init cmtp_init(void)
477{
478 l2cap_load();
479
480 BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
481
482 cmtp_init_sockets();
483
484 return 0;
485}
486
487static void __exit cmtp_exit(void)
488{
489 cmtp_cleanup_sockets();
490}
491
492module_init(cmtp_init);
493module_exit(cmtp_exit);
494
495MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
496MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
497MODULE_VERSION(VERSION);
498MODULE_LICENSE("GPL");
499MODULE_ALIAS("bt-proto-5");
500
