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