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