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