]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - net/bluetooth/l2cap_sock.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Use LE buffers for LE traffic
[mirror_ubuntu-jammy-kernel.git] / net / bluetooth / l2cap_sock.c
CommitLineData
bb58f747
GP		 1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4 Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
5 Copyright (C) 2010 Google Inc.
6
7 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 2 as
11 published by the Free Software Foundation;
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
16 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
17 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
18 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
22 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
23 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
24 SOFTWARE IS DISCLAIMED.
25*/
26
27/* Bluetooth L2CAP sockets. */
28
29#include <net/bluetooth/bluetooth.h>
33575df7 30#include <net/bluetooth/hci_core.h>
bb58f747
GP		 31#include <net/bluetooth/l2cap.h>
32
6ddc0485 33/* ---- L2CAP timers ---- */
bb58f747
GP		 34static void l2cap_sock_timeout(unsigned long arg)
35{
36 struct sock *sk = (struct sock *) arg;
37 int reason;
38
39 BT_DBG("sock %p state %d", sk, sk->sk_state);
40
41 bh_lock_sock(sk);
42
43 if (sock_owned_by_user(sk)) {
44 /* sk is owned by user. Try again later */
45 l2cap_sock_set_timer(sk, HZ / 5);
46 bh_unlock_sock(sk);
47 sock_put(sk);
48 return;
49 }
50
51 if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONFIG)
52 reason = ECONNREFUSED;
53 else if (sk->sk_state == BT_CONNECT &&
54 l2cap_pi(sk)->sec_level != BT_SECURITY_SDP)
55 reason = ECONNREFUSED;
56 else
57 reason = ETIMEDOUT;
58
59 __l2cap_sock_close(sk, reason);
60
61 bh_unlock_sock(sk);
62
63 l2cap_sock_kill(sk);
64 sock_put(sk);
65}
66
6ddc0485
GP		 67void l2cap_sock_set_timer(struct sock *sk, long timeout)
68{
69 BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);
70 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
71}
72
73void l2cap_sock_clear_timer(struct sock *sk)
74{
75 BT_DBG("sock %p state %d", sk, sk->sk_state);
76 sk_stop_timer(sk, &sk->sk_timer);
77}
78
af6bcd82
GP		 79static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
80{
81 struct sock *sk;
82 struct hlist_node *node;
83 sk_for_each(sk, node, &l2cap_sk_list.head)
84 if (l2cap_pi(sk)->sport == psm && !bacmp(&bt_sk(sk)->src, src))
85 goto found;
86 sk = NULL;
87found:
88 return sk;
89}
90
91static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
92{
93 struct sock *sk = sock->sk;
94 struct sockaddr_l2 la;
95 int len, err = 0;
96
97 BT_DBG("sk %p", sk);
98
99 if (!addr || addr->sa_family != AF_BLUETOOTH)
100 return -EINVAL;
101
102 memset(&la, 0, sizeof(la));
103 len = min_t(unsigned int, sizeof(la), alen);
104 memcpy(&la, addr, len);
105
106 if (la.l2_cid)
107 return -EINVAL;
108
109 lock_sock(sk);
110
111 if (sk->sk_state != BT_OPEN) {
112 err = -EBADFD;
113 goto done;
114 }
115
116 if (la.l2_psm) {
117 __u16 psm = __le16_to_cpu(la.l2_psm);
118
119 /* PSM must be odd and lsb of upper byte must be 0 */
120 if ((psm & 0x0101) != 0x0001) {
121 err = -EINVAL;
122 goto done;
123 }
124
125 /* Restrict usage of well-known PSMs */
126 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
127 err = -EACCES;
128 goto done;
129 }
130 }
131
132 write_lock_bh(&l2cap_sk_list.lock);
133
134 if (la.l2_psm && __l2cap_get_sock_by_addr(la.l2_psm, &la.l2_bdaddr)) {
135 err = -EADDRINUSE;
136 } else {
137 /* Save source address */
138 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
139 l2cap_pi(sk)->psm = la.l2_psm;
140 l2cap_pi(sk)->sport = la.l2_psm;
141 sk->sk_state = BT_BOUND;
142
143 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
144 __le16_to_cpu(la.l2_psm) == 0x0003)
145 l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
146 }
147
148 write_unlock_bh(&l2cap_sk_list.lock);
149
150done:
151 release_sock(sk);
152 return err;
153}
154
4e34c50b
GP		 155static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
156{
157 struct sock *sk = sock->sk;
158 struct sockaddr_l2 la;
159 int len, err = 0;
160
161 BT_DBG("sk %p", sk);
162
163 if (!addr || alen < sizeof(addr->sa_family) ||
164 addr->sa_family != AF_BLUETOOTH)
165 return -EINVAL;
166
167 memset(&la, 0, sizeof(la));
168 len = min_t(unsigned int, sizeof(la), alen);
169 memcpy(&la, addr, len);
170
171 if (la.l2_cid)
172 return -EINVAL;
173
174 lock_sock(sk);
175
176 if ((sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM)
177 && !la.l2_psm) {
178 err = -EINVAL;
179 goto done;
180 }
181
182 switch (l2cap_pi(sk)->mode) {
183 case L2CAP_MODE_BASIC:
184 break;
185 case L2CAP_MODE_ERTM:
186 case L2CAP_MODE_STREAMING:
187 if (!disable_ertm)
188 break;
189 /* fall through */
190 default:
191 err = -ENOTSUPP;
192 goto done;
193 }
194
195 switch (sk->sk_state) {
196 case BT_CONNECT:
197 case BT_CONNECT2:
198 case BT_CONFIG:
199 /* Already connecting */
200 goto wait;
201
202 case BT_CONNECTED:
203 /* Already connected */
204 err = -EISCONN;
205 goto done;
206
207 case BT_OPEN:
208 case BT_BOUND:
209 /* Can connect */
210 break;
211
212 default:
213 err = -EBADFD;
214 goto done;
215 }
216
217 /* PSM must be odd and lsb of upper byte must be 0 */
218 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 &&
219 sk->sk_type != SOCK_RAW) {
220 err = -EINVAL;
221 goto done;
222 }
223
224 /* Set destination address and psm */
225 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
226 l2cap_pi(sk)->psm = la.l2_psm;
227
228 err = l2cap_do_connect(sk);
229 if (err)
230 goto done;
231
232wait:
233 err = bt_sock_wait_state(sk, BT_CONNECTED,
234 sock_sndtimeo(sk, flags & O_NONBLOCK));
235done:
236 release_sock(sk);
237 return err;
238}
239
af6bcd82
GP		 240static int l2cap_sock_listen(struct socket *sock, int backlog)
241{
242 struct sock *sk = sock->sk;
243 int err = 0;
244
245 BT_DBG("sk %p backlog %d", sk, backlog);
246
247 lock_sock(sk);
248
249 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
250 || sk->sk_state != BT_BOUND) {
251 err = -EBADFD;
252 goto done;
253 }
254
255 switch (l2cap_pi(sk)->mode) {
256 case L2CAP_MODE_BASIC:
257 break;
258 case L2CAP_MODE_ERTM:
259 case L2CAP_MODE_STREAMING:
260 if (!disable_ertm)
261 break;
262 /* fall through */
263 default:
264 err = -ENOTSUPP;
265 goto done;
266 }
267
268 if (!l2cap_pi(sk)->psm) {
269 bdaddr_t *src = &bt_sk(sk)->src;
270 u16 psm;
271
272 err = -EINVAL;
273
274 write_lock_bh(&l2cap_sk_list.lock);
275
276 for (psm = 0x1001; psm < 0x1100; psm += 2)
277 if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm), src)) {
278 l2cap_pi(sk)->psm = cpu_to_le16(psm);
279 l2cap_pi(sk)->sport = cpu_to_le16(psm);
280 err = 0;
281 break;
282 }
283
284 write_unlock_bh(&l2cap_sk_list.lock);
285
286 if (err < 0)
287 goto done;
288 }
289
290 sk->sk_max_ack_backlog = backlog;
291 sk->sk_ack_backlog = 0;
292 sk->sk_state = BT_LISTEN;
293
294done:
295 release_sock(sk);
296 return err;
297}
298
c47b7c72
GP		 299static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
300{
301 DECLARE_WAITQUEUE(wait, current);
302 struct sock *sk = sock->sk, *nsk;
303 long timeo;
304 int err = 0;
305
306 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
307
308 if (sk->sk_state != BT_LISTEN) {
309 err = -EBADFD;
310 goto done;
311 }
312
313 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
314
315 BT_DBG("sk %p timeo %ld", sk, timeo);
316
317 /* Wait for an incoming connection. (wake-one). */
318 add_wait_queue_exclusive(sk_sleep(sk), &wait);
319 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
320 set_current_state(TASK_INTERRUPTIBLE);
321 if (!timeo) {
322 err = -EAGAIN;
323 break;
324 }
325
326 release_sock(sk);
327 timeo = schedule_timeout(timeo);
328 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
329
330 if (sk->sk_state != BT_LISTEN) {
331 err = -EBADFD;
332 break;
333 }
334
335 if (signal_pending(current)) {
336 err = sock_intr_errno(timeo);
337 break;
338 }
339 }
340 set_current_state(TASK_RUNNING);
341 remove_wait_queue(sk_sleep(sk), &wait);
342
343 if (err)
344 goto done;
345
346 newsock->state = SS_CONNECTED;
347
348 BT_DBG("new socket %p", nsk);
349
350done:
351 release_sock(sk);
352 return err;
353}
354
d7175d55
GP		 355static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
356{
357 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
358 struct sock *sk = sock->sk;
359
360 BT_DBG("sock %p, sk %p", sock, sk);
361
362 addr->sa_family = AF_BLUETOOTH;
363 *len = sizeof(struct sockaddr_l2);
364
365 if (peer) {
366 la->l2_psm = l2cap_pi(sk)->psm;
367 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
368 la->l2_cid = cpu_to_le16(l2cap_pi(sk)->dcid);
369 } else {
370 la->l2_psm = l2cap_pi(sk)->sport;
371 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
372 la->l2_cid = cpu_to_le16(l2cap_pi(sk)->scid);
373 }
374
375 return 0;
376}
377
99f4808d
GP		 378static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
379{
380 struct sock *sk = sock->sk;
381 struct l2cap_options opts;
382 struct l2cap_conninfo cinfo;
383 int len, err = 0;
384 u32 opt;
385
386 BT_DBG("sk %p", sk);
387
388 if (get_user(len, optlen))
389 return -EFAULT;
390
391 lock_sock(sk);
392
393 switch (optname) {
394 case L2CAP_OPTIONS:
e3fb592b 395 memset(&opts, 0, sizeof(opts));
99f4808d
GP		 396 opts.imtu = l2cap_pi(sk)->imtu;
397 opts.omtu = l2cap_pi(sk)->omtu;
398 opts.flush_to = l2cap_pi(sk)->flush_to;
399 opts.mode = l2cap_pi(sk)->mode;
400 opts.fcs = l2cap_pi(sk)->fcs;
401 opts.max_tx = l2cap_pi(sk)->max_tx;
402 opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
403
404 len = min_t(unsigned int, len, sizeof(opts));
405 if (copy_to_user(optval, (char *) &opts, len))
406 err = -EFAULT;
407
408 break;
409
410 case L2CAP_LM:
411 switch (l2cap_pi(sk)->sec_level) {
412 case BT_SECURITY_LOW:
413 opt = L2CAP_LM_AUTH;
414 break;
415 case BT_SECURITY_MEDIUM:
416 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
417 break;
418 case BT_SECURITY_HIGH:
419 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
420 L2CAP_LM_SECURE;
421 break;
422 default:
423 opt = 0;
424 break;
425 }
426
427 if (l2cap_pi(sk)->role_switch)
428 opt |= L2CAP_LM_MASTER;
429
430 if (l2cap_pi(sk)->force_reliable)
431 opt |= L2CAP_LM_RELIABLE;
432
433 if (put_user(opt, (u32 __user *) optval))
434 err = -EFAULT;
435 break;
436
437 case L2CAP_CONNINFO:
438 if (sk->sk_state != BT_CONNECTED &&
439 !(sk->sk_state == BT_CONNECT2 &&
440 bt_sk(sk)->defer_setup)) {
441 err = -ENOTCONN;
442 break;
443 }
444
445 cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
446 memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
447
448 len = min_t(unsigned int, len, sizeof(cinfo));
449 if (copy_to_user(optval, (char *) &cinfo, len))
450 err = -EFAULT;
451
452 break;
453
454 default:
455 err = -ENOPROTOOPT;
456 break;
457 }
458
459 release_sock(sk);
460 return err;
461}
462
463static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
464{
465 struct sock *sk = sock->sk;
466 struct bt_security sec;
467 int len, err = 0;
468
469 BT_DBG("sk %p", sk);
470
471 if (level == SOL_L2CAP)
472 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
473
474 if (level != SOL_BLUETOOTH)
475 return -ENOPROTOOPT;
476
477 if (get_user(len, optlen))
478 return -EFAULT;
479
480 lock_sock(sk);
481
482 switch (optname) {
483 case BT_SECURITY:
484 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
485 && sk->sk_type != SOCK_RAW) {
486 err = -EINVAL;
487 break;
488 }
489
490 sec.level = l2cap_pi(sk)->sec_level;
491
492 len = min_t(unsigned int, len, sizeof(sec));
493 if (copy_to_user(optval, (char *) &sec, len))
494 err = -EFAULT;
495
496 break;
497
498 case BT_DEFER_SETUP:
499 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
500 err = -EINVAL;
501 break;
502 }
503
504 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
505 err = -EFAULT;
506
507 break;
508
509 case BT_FLUSHABLE:
510 if (put_user(l2cap_pi(sk)->flushable, (u32 __user *) optval))
511 err = -EFAULT;
512
513 break;
514
515 default:
516 err = -ENOPROTOOPT;
517 break;
518 }
519
520 release_sock(sk);
521 return err;
522}
523
33575df7
GP		 524static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
525{
526 struct sock *sk = sock->sk;
527 struct l2cap_options opts;
528 int len, err = 0;
529 u32 opt;
530
531 BT_DBG("sk %p", sk);
532
533 lock_sock(sk);
534
535 switch (optname) {
536 case L2CAP_OPTIONS:
537 if (sk->sk_state == BT_CONNECTED) {
538 err = -EINVAL;
539 break;
540 }
541
542 opts.imtu = l2cap_pi(sk)->imtu;
543 opts.omtu = l2cap_pi(sk)->omtu;
544 opts.flush_to = l2cap_pi(sk)->flush_to;
545 opts.mode = l2cap_pi(sk)->mode;
546 opts.fcs = l2cap_pi(sk)->fcs;
547 opts.max_tx = l2cap_pi(sk)->max_tx;
548 opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
549
550 len = min_t(unsigned int, sizeof(opts), optlen);
551 if (copy_from_user((char *) &opts, optval, len)) {
552 err = -EFAULT;
553 break;
554 }
555
556 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
557 err = -EINVAL;
558 break;
559 }
560
561 l2cap_pi(sk)->mode = opts.mode;
562 switch (l2cap_pi(sk)->mode) {
563 case L2CAP_MODE_BASIC:
564 l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
565 break;
566 case L2CAP_MODE_ERTM:
567 case L2CAP_MODE_STREAMING:
568 if (!disable_ertm)
569 break;
570 /* fall through */
571 default:
572 err = -EINVAL;
573 break;
574 }
575
576 l2cap_pi(sk)->imtu = opts.imtu;
577 l2cap_pi(sk)->omtu = opts.omtu;
578 l2cap_pi(sk)->fcs = opts.fcs;
579 l2cap_pi(sk)->max_tx = opts.max_tx;
580 l2cap_pi(sk)->tx_win = (__u8)opts.txwin_size;
581 break;
582
583 case L2CAP_LM:
584 if (get_user(opt, (u32 __user *) optval)) {
585 err = -EFAULT;
586 break;
587 }
588
589 if (opt & L2CAP_LM_AUTH)
590 l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;
591 if (opt & L2CAP_LM_ENCRYPT)
592 l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
593 if (opt & L2CAP_LM_SECURE)
594 l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;
595
596 l2cap_pi(sk)->role_switch = (opt & L2CAP_LM_MASTER);
597 l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);
598 break;
599
600 default:
601 err = -ENOPROTOOPT;
602 break;
603 }
604
605 release_sock(sk);
606 return err;
607}
608
609static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
610{
611 struct sock *sk = sock->sk;
612 struct bt_security sec;
613 int len, err = 0;
614 u32 opt;
615
616 BT_DBG("sk %p", sk);
617
618 if (level == SOL_L2CAP)
619 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
620
621 if (level != SOL_BLUETOOTH)
622 return -ENOPROTOOPT;
623
624 lock_sock(sk);
625
626 switch (optname) {
627 case BT_SECURITY:
628 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
629 && sk->sk_type != SOCK_RAW) {
630 err = -EINVAL;
631 break;
632 }
633
634 sec.level = BT_SECURITY_LOW;
635
636 len = min_t(unsigned int, sizeof(sec), optlen);
637 if (copy_from_user((char *) &sec, optval, len)) {
638 err = -EFAULT;
639 break;
640 }
641
642 if (sec.level < BT_SECURITY_LOW ||
643 sec.level > BT_SECURITY_HIGH) {
644 err = -EINVAL;
645 break;
646 }
647
648 l2cap_pi(sk)->sec_level = sec.level;
649 break;
650
651 case BT_DEFER_SETUP:
652 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
653 err = -EINVAL;
654 break;
655 }
656
657 if (get_user(opt, (u32 __user *) optval)) {
658 err = -EFAULT;
659 break;
660 }
661
662 bt_sk(sk)->defer_setup = opt;
663 break;
664
665 case BT_FLUSHABLE:
666 if (get_user(opt, (u32 __user *) optval)) {
667 err = -EFAULT;
668 break;
669 }
670
671 if (opt > BT_FLUSHABLE_ON) {
672 err = -EINVAL;
673 break;
674 }
675
676 if (opt == BT_FLUSHABLE_OFF) {
677 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
678 /* proceed futher only when we have l2cap_conn and
679 No Flush support in the LM */
680 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
681 err = -EINVAL;
682 break;
683 }
684 }
685
686 l2cap_pi(sk)->flushable = opt;
687 break;
688
689 default:
690 err = -ENOPROTOOPT;
691 break;
692 }
693
694 release_sock(sk);
695 return err;
696}
fd83ccdb
GP		 697
698static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
699{
700 struct sock *sk = sock->sk;
701 struct l2cap_pinfo *pi = l2cap_pi(sk);
702 struct sk_buff *skb;
703 u16 control;
704 int err;
705
706 BT_DBG("sock %p, sk %p", sock, sk);
707
708 err = sock_error(sk);
709 if (err)
710 return err;
711
712 if (msg->msg_flags & MSG_OOB)
713 return -EOPNOTSUPP;
714
715 lock_sock(sk);
716
717 if (sk->sk_state != BT_CONNECTED) {
718 err = -ENOTCONN;
719 goto done;
720 }
721
722 /* Connectionless channel */
723 if (sk->sk_type == SOCK_DGRAM) {
724 skb = l2cap_create_connless_pdu(sk, msg, len);
725 if (IS_ERR(skb)) {
726 err = PTR_ERR(skb);
727 } else {
728 l2cap_do_send(sk, skb);
729 err = len;
730 }
731 goto done;
732 }
733
734 switch (pi->mode) {
735 case L2CAP_MODE_BASIC:
736 /* Check outgoing MTU */
737 if (len > pi->omtu) {
738 err = -EMSGSIZE;
739 goto done;
740 }
741
742 /* Create a basic PDU */
743 skb = l2cap_create_basic_pdu(sk, msg, len);
744 if (IS_ERR(skb)) {
745 err = PTR_ERR(skb);
746 goto done;
747 }
748
749 l2cap_do_send(sk, skb);
750 err = len;
751 break;
752
753 case L2CAP_MODE_ERTM:
754 case L2CAP_MODE_STREAMING:
755 /* Entire SDU fits into one PDU */
756 if (len <= pi->remote_mps) {
757 control = L2CAP_SDU_UNSEGMENTED;
758 skb = l2cap_create_iframe_pdu(sk, msg, len, control, 0);
759 if (IS_ERR(skb)) {
760 err = PTR_ERR(skb);
761 goto done;
762 }
763 __skb_queue_tail(TX_QUEUE(sk), skb);
764
765 if (sk->sk_send_head == NULL)
766 sk->sk_send_head = skb;
767
768 } else {
769 /* Segment SDU into multiples PDUs */
770 err = l2cap_sar_segment_sdu(sk, msg, len);
771 if (err < 0)
772 goto done;
773 }
774
775 if (pi->mode == L2CAP_MODE_STREAMING) {
776 l2cap_streaming_send(sk);
777 } else {
778 if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
779 (pi->conn_state & L2CAP_CONN_WAIT_F)) {
780 err = len;
781 break;
782 }
783 err = l2cap_ertm_send(sk);
784 }
785
786 if (err >= 0)
787 err = len;
788 break;
789
790 default:
791 BT_DBG("bad state %1.1x", pi->mode);
792 err = -EBADFD;
793 }
794
795done:
796 release_sock(sk);
797 return err;
798}
33575df7 799
68983259
GP		 800static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
801{
802 struct sock *sk = sock->sk;
803
804 lock_sock(sk);
805
806 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
807 struct l2cap_conn_rsp rsp;
808 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
809 u8 buf[128];
810
811 sk->sk_state = BT_CONFIG;
812
813 rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
814 rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
815 rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
816 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
817 l2cap_send_cmd(l2cap_pi(sk)->conn, l2cap_pi(sk)->ident,
818 L2CAP_CONN_RSP, sizeof(rsp), &rsp);
819
820 if (l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT) {
821 release_sock(sk);
822 return 0;
823 }
824
825 l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
826 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
827 l2cap_build_conf_req(sk, buf), buf);
828 l2cap_pi(sk)->num_conf_req++;
829
830 release_sock(sk);
831 return 0;
832 }
833
834 release_sock(sk);
835
836 if (sock->type == SOCK_STREAM)
837 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
838
839 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
840}
841
05fc1576
GP		 842/* Kill socket (only if zapped and orphan)
843 * Must be called on unlocked socket.
844 */
845void l2cap_sock_kill(struct sock *sk)
846{
847 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
848 return;
849
850 BT_DBG("sk %p state %d", sk, sk->sk_state);
851
852 /* Kill poor orphan */
853 bt_sock_unlink(&l2cap_sk_list, sk);
854 sock_set_flag(sk, SOCK_DEAD);
855 sock_put(sk);
856}
857
6de0702b
GP		 858/* Must be called on unlocked socket. */
859static void l2cap_sock_close(struct sock *sk)
860{
861 l2cap_sock_clear_timer(sk);
862 lock_sock(sk);
863 __l2cap_sock_close(sk, ECONNRESET);
864 release_sock(sk);
865 l2cap_sock_kill(sk);
866}
867
868static void l2cap_sock_cleanup_listen(struct sock *parent)
869{
870 struct sock *sk;
871
872 BT_DBG("parent %p", parent);
873
874 /* Close not yet accepted channels */
875 while ((sk = bt_accept_dequeue(parent, NULL)))
876 l2cap_sock_close(sk);
877
878 parent->sk_state = BT_CLOSED;
879 sock_set_flag(parent, SOCK_ZAPPED);
880}
881
882void __l2cap_sock_close(struct sock *sk, int reason)
883{
884 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
885
886 switch (sk->sk_state) {
887 case BT_LISTEN:
888 l2cap_sock_cleanup_listen(sk);
889 break;
890
891 case BT_CONNECTED:
892 case BT_CONFIG:
893 if (sk->sk_type == SOCK_SEQPACKET ||
894 sk->sk_type == SOCK_STREAM) {
895 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
896
897 l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
898 l2cap_send_disconn_req(conn, sk, reason);
899 } else
900 l2cap_chan_del(sk, reason);
901 break;
902
903 case BT_CONNECT2:
904 if (sk->sk_type == SOCK_SEQPACKET ||
905 sk->sk_type == SOCK_STREAM) {
906 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
907 struct l2cap_conn_rsp rsp;
908 __u16 result;
909
910 if (bt_sk(sk)->defer_setup)
911 result = L2CAP_CR_SEC_BLOCK;
912 else
913 result = L2CAP_CR_BAD_PSM;
914
915 rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
916 rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
917 rsp.result = cpu_to_le16(result);
918 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
919 l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
920 L2CAP_CONN_RSP, sizeof(rsp), &rsp);
921 } else
922 l2cap_chan_del(sk, reason);
923 break;
924
925 case BT_CONNECT:
926 case BT_DISCONN:
927 l2cap_chan_del(sk, reason);
928 break;
929
930 default:
931 sock_set_flag(sk, SOCK_ZAPPED);
932 break;
933 }
934}
935
dcba0dba
GP		 936static int l2cap_sock_shutdown(struct socket *sock, int how)
937{
938 struct sock *sk = sock->sk;
939 int err = 0;
940
941 BT_DBG("sock %p, sk %p", sock, sk);
942
943 if (!sk)
944 return 0;
945
946 lock_sock(sk);
947 if (!sk->sk_shutdown) {
948 if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM)
949 err = __l2cap_wait_ack(sk);
950
951 sk->sk_shutdown = SHUTDOWN_MASK;
952 l2cap_sock_clear_timer(sk);
953 __l2cap_sock_close(sk, 0);
954
955 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
956 err = bt_sock_wait_state(sk, BT_CLOSED,
957 sk->sk_lingertime);
958 }
959
960 if (!err && sk->sk_err)
961 err = -sk->sk_err;
962
963 release_sock(sk);
964 return err;
965}
966
554f05bb
GP		 967static int l2cap_sock_release(struct socket *sock)
968{
969 struct sock *sk = sock->sk;
970 int err;
971
972 BT_DBG("sock %p, sk %p", sock, sk);
973
974 if (!sk)
975 return 0;
976
977 err = l2cap_sock_shutdown(sock, 2);
978
979 sock_orphan(sk);
980 l2cap_sock_kill(sk);
981 return err;
982}
983
bb58f747
GP		 984static void l2cap_sock_destruct(struct sock *sk)
985{
986 BT_DBG("sk %p", sk);
987
988 skb_queue_purge(&sk->sk_receive_queue);
989 skb_queue_purge(&sk->sk_write_queue);
990}
991
992void l2cap_sock_init(struct sock *sk, struct sock *parent)
993{
994 struct l2cap_pinfo *pi = l2cap_pi(sk);
995
996 BT_DBG("sk %p", sk);
997
998 if (parent) {
999 sk->sk_type = parent->sk_type;
1000 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
1001
1002 pi->imtu = l2cap_pi(parent)->imtu;
1003 pi->omtu = l2cap_pi(parent)->omtu;
1004 pi->conf_state = l2cap_pi(parent)->conf_state;
1005 pi->mode = l2cap_pi(parent)->mode;
1006 pi->fcs = l2cap_pi(parent)->fcs;
1007 pi->max_tx = l2cap_pi(parent)->max_tx;
1008 pi->tx_win = l2cap_pi(parent)->tx_win;
1009 pi->sec_level = l2cap_pi(parent)->sec_level;
1010 pi->role_switch = l2cap_pi(parent)->role_switch;
1011 pi->force_reliable = l2cap_pi(parent)->force_reliable;
1012 pi->flushable = l2cap_pi(parent)->flushable;
1013 } else {
1014 pi->imtu = L2CAP_DEFAULT_MTU;
1015 pi->omtu = 0;
1016 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1017 pi->mode = L2CAP_MODE_ERTM;
1018 pi->conf_state |= L2CAP_CONF_STATE2_DEVICE;
1019 } else {
1020 pi->mode = L2CAP_MODE_BASIC;
1021 }
1022 pi->max_tx = L2CAP_DEFAULT_MAX_TX;
1023 pi->fcs = L2CAP_FCS_CRC16;
1024 pi->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1025 pi->sec_level = BT_SECURITY_LOW;
1026 pi->role_switch = 0;
1027 pi->force_reliable = 0;
1028 pi->flushable = BT_FLUSHABLE_OFF;
1029 }
1030
1031 /* Default config options */
1032 pi->conf_len = 0;
1033 pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1034 skb_queue_head_init(TX_QUEUE(sk));
1035 skb_queue_head_init(SREJ_QUEUE(sk));
1036 skb_queue_head_init(BUSY_QUEUE(sk));
1037 INIT_LIST_HEAD(SREJ_LIST(sk));
1038}
1039
1040static struct proto l2cap_proto = {
1041 .name = "L2CAP",
1042 .owner = THIS_MODULE,
1043 .obj_size = sizeof(struct l2cap_pinfo)
1044};
1045
1046struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1047{
1048 struct sock *sk;
1049
1050 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1051 if (!sk)
1052 return NULL;
1053
1054 sock_init_data(sock, sk);
1055 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1056
1057 sk->sk_destruct = l2cap_sock_destruct;
1058 sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
1059
1060 sock_reset_flag(sk, SOCK_ZAPPED);
1061
1062 sk->sk_protocol = proto;
1063 sk->sk_state = BT_OPEN;
1064
1065 setup_timer(&sk->sk_timer, l2cap_sock_timeout, (unsigned long) sk);
1066
1067 bt_sock_link(&l2cap_sk_list, sk);
1068 return sk;
1069}
1070
1071static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1072 int kern)
1073{
1074 struct sock *sk;
1075
1076 BT_DBG("sock %p", sock);
1077
1078 sock->state = SS_UNCONNECTED;
1079
1080 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1081 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1082 return -ESOCKTNOSUPPORT;
1083
1084 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1085 return -EPERM;
1086
1087 sock->ops = &l2cap_sock_ops;
1088
1089 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1090 if (!sk)
1091 return -ENOMEM;
1092
1093 l2cap_sock_init(sk, NULL);
1094 return 0;
1095}
1096
65390587
GP		 1097const struct proto_ops l2cap_sock_ops = {
1098 .family = PF_BLUETOOTH,
1099 .owner = THIS_MODULE,
1100 .release = l2cap_sock_release,
1101 .bind = l2cap_sock_bind,
1102 .connect = l2cap_sock_connect,
1103 .listen = l2cap_sock_listen,
1104 .accept = l2cap_sock_accept,
1105 .getname = l2cap_sock_getname,
1106 .sendmsg = l2cap_sock_sendmsg,
1107 .recvmsg = l2cap_sock_recvmsg,
1108 .poll = bt_sock_poll,
1109 .ioctl = bt_sock_ioctl,
1110 .mmap = sock_no_mmap,
1111 .socketpair = sock_no_socketpair,
1112 .shutdown = l2cap_sock_shutdown,
1113 .setsockopt = l2cap_sock_setsockopt,
1114 .getsockopt = l2cap_sock_getsockopt
1115};
1116
bb58f747
GP		 1117static const struct net_proto_family l2cap_sock_family_ops = {
1118 .family = PF_BLUETOOTH,
1119 .owner = THIS_MODULE,
1120 .create = l2cap_sock_create,
1121};
1122
1123int __init l2cap_init_sockets(void)
1124{
1125 int err;
1126
1127 err = proto_register(&l2cap_proto, 0);
1128 if (err < 0)
1129 return err;
1130
1131 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1132 if (err < 0)
1133 goto error;
1134
1135 BT_INFO("L2CAP socket layer initialized");
1136
1137 return 0;
1138
1139error:
1140 BT_ERR("L2CAP socket registration failed");
1141 proto_unregister(&l2cap_proto);
1142 return err;
1143}
1144
1145void l2cap_cleanup_sockets(void)
1146{
1147 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1148 BT_ERR("L2CAP socket unregistration failed");
1149
1150 proto_unregister(&l2cap_proto);
1151}
Ubuntu Jammy Linux kernel mirror