xref: /openbmc/linux/net/bluetooth/cmtp/core.c (revision 9c1f8594) 
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 	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 
68 static void __cmtp_link_session(struct cmtp_session *session)
69 {
70 	__module_get(THIS_MODULE);
71 	list_add(&session->list, &cmtp_session_list);
72 }
73 
74 static void __cmtp_unlink_session(struct cmtp_session *session)
75 {
76 	list_del(&session->list);
77 	module_put(THIS_MODULE);
78 }
79 
80 static 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 
92 static 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 
105 static inline void cmtp_free_block_id(struct cmtp_session *session, int id)
106 {
107 	clear_bit(id, &session->blockids);
108 }
109 
110 static 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 
135 static 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 
197 static 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 
213 static 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 
282 static 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 			cmtp_recv_frame(session, 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 & (1 << 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 	return 0;
328 }
329 
330 int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
331 {
332 	struct cmtp_session *session, *s;
333 	int i, err;
334 
335 	BT_DBG("");
336 
337 	session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
338 	if (!session)
339 		return -ENOMEM;
340 
341 	down_write(&cmtp_session_sem);
342 
343 	s = __cmtp_get_session(&bt_sk(sock->sk)->dst);
344 	if (s && s->state == BT_CONNECTED) {
345 		err = -EEXIST;
346 		goto failed;
347 	}
348 
349 	bacpy(&session->bdaddr, &bt_sk(sock->sk)->dst);
350 
351 	session->mtu = min_t(uint, l2cap_pi(sock->sk)->chan->omtu,
352 					l2cap_pi(sock->sk)->chan->imtu);
353 
354 	BT_DBG("mtu %d", session->mtu);
355 
356 	sprintf(session->name, "%s", batostr(&bt_sk(sock->sk)->dst));
357 
358 	session->sock  = sock;
359 	session->state = BT_CONFIG;
360 
361 	init_waitqueue_head(&session->wait);
362 
363 	session->msgnum = CMTP_INITIAL_MSGNUM;
364 
365 	INIT_LIST_HEAD(&session->applications);
366 
367 	skb_queue_head_init(&session->transmit);
368 
369 	for (i = 0; i < 16; i++)
370 		session->reassembly[i] = NULL;
371 
372 	session->flags = req->flags;
373 
374 	__cmtp_link_session(session);
375 
376 	session->task = kthread_run(cmtp_session, session, "kcmtpd_ctr_%d",
377 								session->num);
378 	if (IS_ERR(session->task)) {
379 		err = PTR_ERR(session->task);
380 		goto unlink;
381 	}
382 
383 	if (!(session->flags & (1 << CMTP_LOOPBACK))) {
384 		err = cmtp_attach_device(session);
385 		if (err < 0) {
386 			atomic_inc(&session->terminate);
387 			wake_up_process(session->task);
388 			up_write(&cmtp_session_sem);
389 			return err;
390 		}
391 	}
392 
393 	up_write(&cmtp_session_sem);
394 	return 0;
395 
396 unlink:
397 	__cmtp_unlink_session(session);
398 
399 failed:
400 	up_write(&cmtp_session_sem);
401 	kfree(session);
402 	return err;
403 }
404 
405 int cmtp_del_connection(struct cmtp_conndel_req *req)
406 {
407 	struct cmtp_session *session;
408 	int err = 0;
409 
410 	BT_DBG("");
411 
412 	down_read(&cmtp_session_sem);
413 
414 	session = __cmtp_get_session(&req->bdaddr);
415 	if (session) {
416 		/* Flush the transmit queue */
417 		skb_queue_purge(&session->transmit);
418 
419 		/* Stop session thread */
420 		atomic_inc(&session->terminate);
421 		wake_up_process(session->task);
422 	} else
423 		err = -ENOENT;
424 
425 	up_read(&cmtp_session_sem);
426 	return err;
427 }
428 
429 int cmtp_get_connlist(struct cmtp_connlist_req *req)
430 {
431 	struct list_head *p;
432 	int err = 0, n = 0;
433 
434 	BT_DBG("");
435 
436 	down_read(&cmtp_session_sem);
437 
438 	list_for_each(p, &cmtp_session_list) {
439 		struct cmtp_session *session;
440 		struct cmtp_conninfo ci;
441 
442 		session = list_entry(p, struct cmtp_session, list);
443 
444 		__cmtp_copy_session(session, &ci);
445 
446 		if (copy_to_user(req->ci, &ci, sizeof(ci))) {
447 			err = -EFAULT;
448 			break;
449 		}
450 
451 		if (++n >= req->cnum)
452 			break;
453 
454 		req->ci++;
455 	}
456 	req->cnum = n;
457 
458 	up_read(&cmtp_session_sem);
459 	return err;
460 }
461 
462 int cmtp_get_conninfo(struct cmtp_conninfo *ci)
463 {
464 	struct cmtp_session *session;
465 	int err = 0;
466 
467 	down_read(&cmtp_session_sem);
468 
469 	session = __cmtp_get_session(&ci->bdaddr);
470 	if (session)
471 		__cmtp_copy_session(session, ci);
472 	else
473 		err = -ENOENT;
474 
475 	up_read(&cmtp_session_sem);
476 	return err;
477 }
478 
479 
480 static int __init cmtp_init(void)
481 {
482 	BT_INFO("CMTP (CAPI Emulation) ver %s", VERSION);
483 
484 	cmtp_init_sockets();
485 
486 	return 0;
487 }
488 
489 static void __exit cmtp_exit(void)
490 {
491 	cmtp_cleanup_sockets();
492 }
493 
494 module_init(cmtp_init);
495 module_exit(cmtp_exit);
496 
497 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
498 MODULE_DESCRIPTION("Bluetooth CMTP ver " VERSION);
499 MODULE_VERSION(VERSION);
500 MODULE_LICENSE("GPL");
501 MODULE_ALIAS("bt-proto-5");
502