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