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