projects/linux·blob master · refs

3004 lines · 64.9 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2022 Intel Corporation
6 * Copyright 2023-2024 NXP
7 */
8
9#include <linux/module.h>
10#include <linux/debugfs.h>
11#include <linux/seq_file.h>
12#include <linux/sched/signal.h>
13#include <linux/uio.h>
14
15#include <net/bluetooth/bluetooth.h>
16#include <net/bluetooth/hci_core.h>
17#include <net/bluetooth/iso.h>
18#include "eir.h"
19
20static const struct proto_ops iso_sock_ops;
21
22static struct bt_sock_list iso_sk_list = {
23 .lock = __RW_LOCK_UNLOCKED(iso_sk_list.lock)
24};
25
26/* ---- ISO connections ---- */
27enum {
28 ISO_CONN_DROPPED,
29 __ISO_CONN_NUM_FLAGS
30};
31
32struct iso_conn {
33 struct hci_conn *hcon;
34 DECLARE_BITMAP(flags, __ISO_CONN_NUM_FLAGS);
35
36 /* @lock: spinlock protecting changes to iso_conn fields */
37 spinlock_t lock;
38 struct sock *sk;
39
40 struct sk_buff *rx_skb;
41 __u32 rx_len;
42 __u16 tx_sn;
43 struct kref ref;
44};
45
46#define iso_conn_lock(c) spin_lock(&(c)->lock)
47#define iso_conn_unlock(c) spin_unlock(&(c)->lock)
48
49static void iso_sock_close(struct sock *sk);
50static void iso_sock_kill(struct sock *sk);
51
52/* ----- ISO socket info ----- */
53#define iso_pi(sk) ((struct iso_pinfo *)sk)
54
55#define EIR_SERVICE_DATA_LENGTH 4
56#define BASE_MAX_LENGTH (HCI_MAX_PER_AD_LENGTH - EIR_SERVICE_DATA_LENGTH)
57#define EIR_BAA_SERVICE_UUID 0x1851
58
59/* iso_pinfo flags values */
60enum {
61 BT_SK_BIG_SYNC,
62 BT_SK_PA_SYNC,
63 BT_SK_KILLED,
64 BT_SK_CONNECTING,
65};
66
67struct iso_pinfo {
68 struct bt_sock bt;
69 bdaddr_t src;
70 __u8 src_type;
71 bdaddr_t dst;
72 __u8 dst_type;
73 __u8 bc_sid;
74 __u8 bc_num_bis;
75 __u8 bc_bis[ISO_MAX_NUM_BIS];
76 __u16 sync_handle;
77 unsigned long flags;
78 struct bt_iso_qos qos;
79 bool qos_user_set;
80 __u8 base_len;
81 __u8 base[BASE_MAX_LENGTH];
82 struct iso_conn *conn;
83 struct delayed_work timeout_work;
84};
85
86static struct bt_iso_qos default_qos;
87
88static bool check_ucast_qos(struct bt_iso_qos *qos);
89static bool check_bcast_qos(struct bt_iso_qos *qos);
90static bool iso_match_sid(struct sock *sk, void *data);
91static bool iso_match_sid_past(struct sock *sk, void *data);
92static bool iso_match_sync_handle(struct sock *sk, void *data);
93static bool iso_match_sync_handle_pa_report(struct sock *sk, void *data);
94static void iso_sock_disconn(struct sock *sk);
95
96typedef bool (*iso_sock_match_t)(struct sock *sk, void *data);
97
98static struct sock *iso_get_sock(struct hci_dev *hdev, bdaddr_t *src,
99 bdaddr_t *dst, enum bt_sock_state state,
100 iso_sock_match_t match, void *data);
101
102/* ---- ISO timers ---- */
103#define ISO_CONN_TIMEOUT secs_to_jiffies(20)
104#define ISO_DISCONN_TIMEOUT secs_to_jiffies(2)
105
106static void iso_conn_free(struct kref *ref)
107{
108 struct iso_conn *conn = container_of(ref, struct iso_conn, ref);
109
110 BT_DBG("conn %p", conn);
111
112 if (conn->hcon) {
113 spin_lock(&conn->hcon->proto_lock);
114
115 /* Check we are not racing with iso_conn_add */
116 if (conn->hcon->iso_data == conn) {
117 conn->hcon->iso_data = NULL;
118 if (!test_and_set_bit(ISO_CONN_DROPPED, conn->flags))
119 hci_conn_drop(conn->hcon);
120 }
121
122 spin_unlock(&conn->hcon->proto_lock);
123 }
124
125 kfree_skb(conn->rx_skb);
126
127 kfree(conn);
128}
129
130static void iso_conn_put(struct iso_conn *conn)
131{
132 if (!conn)
133 return;
134
135 BT_DBG("conn %p refcnt %d", conn, kref_read(&conn->ref));
136
137 /* The following race vs. iso_conn_del() is possible:
138 *
139 * 1. conn->hcon != NULL here
140 * 2. kref_put puts the last reference
141 * 3. concurrent iso_conn_del() gets iso_conn_hold_unless_zero() -> NULL
142 * and returns immediately, so conn->hcon is not cleared
143 * 4. iso_conn_free() dereferences conn->hcon
144 *
145 * To avoid UAF in step 4, take RCU before decrementing the refcount.
146 */
147 rcu_read_lock();
148
149 kref_put(&conn->ref, iso_conn_free);
150
151 rcu_read_unlock();
152}
153
154static struct iso_conn *iso_conn_hold_unless_zero(struct iso_conn *conn)
155{
156 if (!conn)
157 return NULL;
158
159 BT_DBG("conn %p refcnt %u", conn, kref_read(&conn->ref));
160
161 if (!kref_get_unless_zero(&conn->ref))
162 return NULL;
163
164 return conn;
165}
166
167static struct iso_conn *iso_conn_hold(struct iso_conn *conn)
168{
169 BT_DBG("conn %p refcnt %u", conn, kref_read(&conn->ref));
170
171 kref_get(&conn->ref);
172 return conn;
173}
174
175static struct sock *iso_sock_hold(struct iso_conn *conn)
176{
177 if (!conn || !bt_sock_linked(&iso_sk_list, conn->sk))
178 return NULL;
179
180 sock_hold(conn->sk);
181
182 return conn->sk;
183}
184
185static void iso_sock_timeout(struct work_struct *work)
186{
187 struct iso_pinfo *pi = container_of(work, struct iso_pinfo,
188 timeout_work.work);
189 struct sock *sk = &pi->bt.sk;
190
191 BT_DBG("sock %p state %d", sk, sk->sk_state);
192
193 lock_sock(sk);
194 if (!sock_flag(sk, SOCK_ZAPPED)) {
195 sk->sk_err = ETIMEDOUT;
196 sk->sk_state_change(sk);
197 }
198 release_sock(sk);
199}
200
201static void iso_sock_set_timer(struct sock *sk, long timeout)
202{
203 lockdep_assert(lockdep_sock_is_held(sk));
204
205 cancel_delayed_work(&iso_pi(sk)->timeout_work);
206
207 if (!iso_pi(sk)->conn)
208 return;
209
210 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
211 schedule_delayed_work(&iso_pi(sk)->timeout_work, timeout);
212}
213
214static void iso_sock_clear_timer(struct sock *sk)
215{
216 BT_DBG("sock %p state %d", sk, sk->sk_state);
217 cancel_delayed_work(&iso_pi(sk)->timeout_work);
218}
219
220static void iso_sock_disable_timer(struct sock *sk)
221{
222 lockdep_assert(!lockdep_sock_is_held(sk));
223
224 BT_DBG("sock %p state %d", sk, sk->sk_state);
225 disable_delayed_work_sync(&iso_pi(sk)->timeout_work);
226}
227
228/* ---- ISO connections ---- */
229static struct iso_conn *iso_conn_add(struct hci_conn *hcon)
230 __must_hold(&hcon->hdev->lock)
231{
232 struct iso_conn *conn;
233
234 spin_lock(&hcon->proto_lock);
235
236 conn = iso_conn_hold_unless_zero(hcon->iso_data);
237 if (conn) {
238 if (!conn->hcon) {
239 iso_conn_lock(conn);
240 conn->hcon = hcon;
241 iso_conn_unlock(conn);
242 }
243 spin_unlock(&hcon->proto_lock);
244 return conn;
245 }
246
247 conn = kzalloc_obj(*conn, GFP_ATOMIC);
248 if (!conn) {
249 spin_unlock(&hcon->proto_lock);
250 return NULL;
251 }
252
253 kref_init(&conn->ref);
254 spin_lock_init(&conn->lock);
255
256 hcon->iso_data = conn;
257 conn->hcon = hcon;
258 conn->tx_sn = 0;
259
260 spin_unlock(&hcon->proto_lock);
261
262 BT_DBG("hcon %p conn %p", hcon, conn);
263
264 return conn;
265}
266
267/* Delete channel. Must be called on the locked socket. */
268static void iso_chan_del(struct sock *sk, int err)
269{
270 struct iso_conn *conn;
271 struct sock *parent;
272
273 conn = iso_pi(sk)->conn;
274 iso_pi(sk)->conn = NULL;
275
276 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
277
278 if (conn) {
279 iso_conn_lock(conn);
280 conn->sk = NULL;
281 iso_conn_unlock(conn);
282 iso_conn_put(conn);
283 }
284
285 sk->sk_state = BT_CLOSED;
286 sk->sk_err = err;
287
288 parent = bt_sk(sk)->parent;
289 if (parent) {
290 bt_accept_unlink(sk);
291 parent->sk_data_ready(parent);
292 } else {
293 sk->sk_state_change(sk);
294 }
295
296 sock_set_flag(sk, SOCK_ZAPPED);
297}
298
299static void iso_conn_del(struct hci_conn *hcon, int err)
300 __must_hold(&hcon->hdev->lock)
301{
302 struct iso_conn *conn;
303 struct sock *sk;
304
305 spin_lock(&hcon->proto_lock);
306 conn = iso_conn_hold_unless_zero(hcon->iso_data);
307 spin_unlock(&hcon->proto_lock);
308 if (!conn)
309 return;
310
311 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
312
313 /* Kill socket */
314 iso_conn_lock(conn);
315 sk = iso_sock_hold(conn);
316 iso_conn_unlock(conn);
317
318 if (!sk)
319 goto done;
320
321 iso_sock_disable_timer(sk);
322
323 lock_sock(sk);
324 iso_chan_del(sk, err);
325 release_sock(sk);
326 iso_sock_kill(sk);
327 sock_put(sk);
328
329done:
330 /* No sk access to conn->hcon any more (lock_sock + hdev->lock) */
331 spin_lock(&hcon->proto_lock);
332 iso_conn_lock(conn);
333 conn->hcon = NULL;
334 hcon->iso_data = NULL;
335 iso_conn_unlock(conn);
336 spin_unlock(&hcon->proto_lock);
337
338 iso_conn_put(conn);
339}
340
341static int __iso_chan_add(struct iso_conn *conn, struct sock *sk,
342 struct sock *parent)
343{
344 BT_DBG("conn %p", conn);
345
346 if (iso_pi(sk)->conn == conn && conn->sk == sk)
347 return 0;
348
349 if (conn->sk) {
350 BT_ERR("conn->sk already set");
351 return -EBUSY;
352 }
353
354 if (iso_pi(sk)->conn)
355 return -EISCONN;
356
357 if (!conn->hcon) {
358 BT_ERR("conn->hcon missing");
359 return -EIO;
360 }
361
362 iso_pi(sk)->conn = iso_conn_hold(conn);
363 conn->sk = sk;
364 clear_bit(ISO_CONN_DROPPED, conn->flags);
365
366 if (parent)
367 bt_accept_enqueue(parent, sk, true);
368
369 return 0;
370}
371
372static int iso_chan_add(struct iso_conn *conn, struct sock *sk,
373 struct sock *parent)
374{
375 int err;
376
377 iso_conn_lock(conn);
378 err = __iso_chan_add(conn, sk, parent);
379 iso_conn_unlock(conn);
380
381 return err;
382}
383
384static inline u8 le_addr_type(u8 bdaddr_type)
385{
386 if (bdaddr_type == BDADDR_LE_PUBLIC)
387 return ADDR_LE_DEV_PUBLIC;
388 else
389 return ADDR_LE_DEV_RANDOM;
390}
391
392static int iso_connect_bis(struct sock *sk)
393{
394 struct iso_conn *conn;
395 struct hci_conn *hcon;
396 struct hci_dev *hdev;
397 bdaddr_t src, dst;
398 u8 src_type, bc_sid;
399 int err;
400
401 lock_sock(sk);
402 bacpy(&src, &iso_pi(sk)->src);
403 bacpy(&dst, &iso_pi(sk)->dst);
404 src_type = iso_pi(sk)->src_type;
405 bc_sid = iso_pi(sk)->bc_sid;
406 release_sock(sk);
407
408 BT_DBG("%pMR (SID 0x%2.2x)", &src, bc_sid);
409
410 hdev = hci_get_route(&dst, &src, src_type);
411 if (!hdev)
412 return -EHOSTUNREACH;
413
414 hci_dev_lock(hdev);
415 lock_sock(sk);
416
417 if (iso_pi(sk)->conn) {
418 err = -EISCONN;
419 goto unlock;
420 }
421
422 if (!bis_capable(hdev)) {
423 err = -EOPNOTSUPP;
424 goto unlock;
425 }
426
427 /* Fail if user set invalid QoS */
428 if (iso_pi(sk)->qos_user_set && !check_bcast_qos(&iso_pi(sk)->qos)) {
429 iso_pi(sk)->qos = default_qos;
430 err = -EINVAL;
431 goto unlock;
432 }
433
434 /* Fail if out PHYs are marked as disabled */
435 if (!iso_pi(sk)->qos.bcast.out.phys) {
436 err = -EINVAL;
437 goto unlock;
438 }
439
440 /* Just bind if DEFER_SETUP has been set */
441 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
442 hcon = hci_bind_bis(hdev, &iso_pi(sk)->dst, iso_pi(sk)->bc_sid,
443 &iso_pi(sk)->qos, iso_pi(sk)->base_len,
444 iso_pi(sk)->base,
445 READ_ONCE(sk->sk_sndtimeo));
446 if (IS_ERR(hcon)) {
447 err = PTR_ERR(hcon);
448 goto unlock;
449 }
450 } else {
451 hcon = hci_connect_bis(hdev, &iso_pi(sk)->dst,
452 le_addr_type(iso_pi(sk)->dst_type),
453 iso_pi(sk)->bc_sid, &iso_pi(sk)->qos,
454 iso_pi(sk)->base_len, iso_pi(sk)->base,
455 READ_ONCE(sk->sk_sndtimeo));
456 if (IS_ERR(hcon)) {
457 err = PTR_ERR(hcon);
458 goto unlock;
459 }
460
461 /* Update SID if it was not set */
462 if (iso_pi(sk)->bc_sid == HCI_SID_INVALID)
463 iso_pi(sk)->bc_sid = hcon->sid;
464 }
465
466 lockdep_assert_held(&hcon->hdev->lock);
467
468 conn = iso_conn_add(hcon);
469 if (!conn) {
470 hci_conn_drop(hcon);
471 err = -ENOMEM;
472 goto unlock;
473 }
474
475 err = iso_chan_add(conn, sk, NULL);
476 iso_conn_put(conn);
477 if (err)
478 goto unlock;
479
480 /* Update source addr of the socket */
481 bacpy(&iso_pi(sk)->src, &hcon->src);
482
483 if (hcon->state == BT_CONNECTED) {
484 iso_sock_clear_timer(sk);
485 sk->sk_state = BT_CONNECTED;
486 } else if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
487 iso_sock_clear_timer(sk);
488 sk->sk_state = BT_CONNECT;
489 } else {
490 sk->sk_state = BT_CONNECT;
491 iso_sock_set_timer(sk, READ_ONCE(sk->sk_sndtimeo));
492 }
493
494unlock:
495 release_sock(sk);
496 hci_dev_unlock(hdev);
497 hci_dev_put(hdev);
498 return err;
499}
500
501static int iso_connect_cis(struct sock *sk)
502{
503 struct iso_conn *conn;
504 struct hci_conn *hcon;
505 struct hci_dev *hdev;
506 bdaddr_t src, dst;
507 u8 src_type;
508 bool already_attached;
509 int err;
510
511 lock_sock(sk);
512 bacpy(&src, &iso_pi(sk)->src);
513 bacpy(&dst, &iso_pi(sk)->dst);
514 src_type = iso_pi(sk)->src_type;
515 release_sock(sk);
516
517 BT_DBG("%pMR -> %pMR", &src, &dst);
518
519 hdev = hci_get_route(&dst, &src, src_type);
520 if (!hdev)
521 return -EHOSTUNREACH;
522
523 hci_dev_lock(hdev);
524 lock_sock(sk);
525
526 if (!cis_central_capable(hdev)) {
527 err = -EOPNOTSUPP;
528 goto unlock;
529 }
530
531 /* Fail if user set invalid QoS */
532 if (iso_pi(sk)->qos_user_set && !check_ucast_qos(&iso_pi(sk)->qos)) {
533 iso_pi(sk)->qos = default_qos;
534 err = -EINVAL;
535 goto unlock;
536 }
537
538 /* Fail if either PHYs are marked as disabled */
539 if (!iso_pi(sk)->qos.ucast.in.phys && !iso_pi(sk)->qos.ucast.out.phys) {
540 err = -EINVAL;
541 goto unlock;
542 }
543
544 /* Check if there are available buffers for output/TX. */
545 if (iso_pi(sk)->qos.ucast.out.sdu && !hci_iso_count(hdev) &&
546 (hdev->iso_pkts && !hdev->iso_cnt)) {
547 err = -ENOBUFS;
548 goto unlock;
549 }
550
551 /* Just bind if DEFER_SETUP has been set */
552 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
553 hcon = hci_bind_cis(hdev, &iso_pi(sk)->dst,
554 le_addr_type(iso_pi(sk)->dst_type),
555 &iso_pi(sk)->qos,
556 READ_ONCE(sk->sk_sndtimeo));
557 if (IS_ERR(hcon)) {
558 err = PTR_ERR(hcon);
559 goto unlock;
560 }
561 } else {
562 hcon = hci_connect_cis(hdev, &iso_pi(sk)->dst,
563 le_addr_type(iso_pi(sk)->dst_type),
564 &iso_pi(sk)->qos,
565 READ_ONCE(sk->sk_sndtimeo));
566 if (IS_ERR(hcon)) {
567 err = PTR_ERR(hcon);
568 goto unlock;
569 }
570 }
571
572 lockdep_assert_held(&hcon->hdev->lock);
573
574 /* The socket lock keeps the current attachment and its hcon stable. */
575 if (iso_pi(sk)->conn && iso_pi(sk)->conn->hcon != hcon) {
576 hci_conn_drop(hcon);
577 err = -EISCONN;
578 goto unlock;
579 }
580
581 conn = iso_conn_add(hcon);
582 if (!conn) {
583 hci_conn_drop(hcon);
584 err = -ENOMEM;
585 goto unlock;
586 }
587
588 iso_conn_lock(conn);
589 already_attached = iso_pi(sk)->conn == conn && conn->sk == sk;
590 iso_conn_unlock(conn);
591
592 err = iso_chan_add(conn, sk, NULL);
593 iso_conn_put(conn);
594 if (already_attached || err == -EBUSY)
595 hci_conn_drop(hcon);
596 if (err)
597 goto unlock;
598
599 /* Update source addr of the socket */
600 bacpy(&iso_pi(sk)->src, &hcon->src);
601
602 if (hcon->state == BT_CONNECTED) {
603 iso_sock_clear_timer(sk);
604 sk->sk_state = BT_CONNECTED;
605 } else if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
606 iso_sock_clear_timer(sk);
607 sk->sk_state = BT_CONNECT;
608 } else {
609 sk->sk_state = BT_CONNECT;
610 iso_sock_set_timer(sk, READ_ONCE(sk->sk_sndtimeo));
611 }
612
613unlock:
614 release_sock(sk);
615 hci_dev_unlock(hdev);
616 hci_dev_put(hdev);
617 return err;
618}
619
620static struct bt_iso_qos *iso_sock_get_qos(struct sock *sk)
621{
622 if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONNECT2)
623 return &iso_pi(sk)->conn->hcon->iso_qos;
624
625 return &iso_pi(sk)->qos;
626}
627
628static int iso_send_frame(struct sock *sk, struct sk_buff *skb,
629 const struct sockcm_cookie *sockc)
630{
631 struct iso_conn *conn = iso_pi(sk)->conn;
632 struct bt_iso_qos *qos = iso_sock_get_qos(sk);
633 struct hci_iso_data_hdr *hdr;
634 int len = 0;
635
636 BT_DBG("sk %p len %d", sk, skb->len);
637
638 if (skb->len > qos->ucast.out.sdu)
639 return -EMSGSIZE;
640
641 len = skb->len;
642
643 /* Push ISO data header */
644 hdr = skb_push(skb, HCI_ISO_DATA_HDR_SIZE);
645 hdr->sn = cpu_to_le16(conn->tx_sn++);
646 hdr->slen = cpu_to_le16(hci_iso_data_len_pack(len,
647 HCI_ISO_STATUS_VALID));
648
649 if (sk->sk_state == BT_CONNECTED) {
650 hci_setup_tx_timestamp(skb, 1, sockc);
651 hci_send_iso(conn->hcon, skb);
652 } else {
653 len = -ENOTCONN;
654 }
655
656 return len;
657}
658
659static void iso_recv_frame(struct iso_conn *conn, struct sk_buff *skb)
660{
661 struct sock *sk;
662
663 iso_conn_lock(conn);
664 sk = iso_sock_hold(conn);
665 iso_conn_unlock(conn);
666
667 if (!sk)
668 goto drop;
669
670 BT_DBG("sk %p len %d", sk, skb->len);
671
672 if (sk->sk_state != BT_CONNECTED)
673 goto drop_put;
674
675 if (!sock_queue_rcv_skb(sk, skb)) {
676 sock_put(sk);
677 return;
678 }
679
680drop_put:
681 sock_put(sk);
682drop:
683 kfree_skb(skb);
684}
685
686/* -------- Socket interface ---------- */
687static struct sock *__iso_get_sock_listen_by_addr(bdaddr_t *src, bdaddr_t *dst)
688{
689 struct sock *sk;
690
691 sk_for_each(sk, &iso_sk_list.head) {
692 if (sk->sk_state != BT_LISTEN)
693 continue;
694
695 if (bacmp(&iso_pi(sk)->dst, dst))
696 continue;
697
698 if (!bacmp(&iso_pi(sk)->src, src))
699 return sk;
700 }
701
702 return NULL;
703}
704
705static struct sock *__iso_get_sock_listen_by_sid(bdaddr_t *ba, bdaddr_t *bc,
706 __u8 sid)
707{
708 struct sock *sk;
709
710 sk_for_each(sk, &iso_sk_list.head) {
711 if (sk->sk_state != BT_LISTEN)
712 continue;
713
714 if (bacmp(&iso_pi(sk)->src, ba))
715 continue;
716
717 if (bacmp(&iso_pi(sk)->dst, bc))
718 continue;
719
720 if (iso_pi(sk)->bc_sid == sid)
721 return sk;
722 }
723
724 return NULL;
725}
726
727/* Find socket in given state:
728 * source bdaddr (Unicast)
729 * destination bdaddr (Broadcast only)
730 * match func - pass NULL to ignore
731 * match func data - pass -1 to ignore
732 * Returns closest match.
733 */
734static struct sock *iso_get_sock(struct hci_dev *hdev, bdaddr_t *src,
735 bdaddr_t *dst, enum bt_sock_state state,
736 iso_sock_match_t match, void *data)
737{
738 struct sock *sk = NULL, *sk1 = NULL;
739
740 read_lock(&iso_sk_list.lock);
741
742 sk_for_each(sk, &iso_sk_list.head) {
743 if (sk->sk_state != state)
744 continue;
745
746 /* Match Broadcast destination */
747 if (bacmp(dst, BDADDR_ANY) && bacmp(&iso_pi(sk)->dst, dst)) {
748 struct smp_irk *irk1, *irk2;
749
750 /* Check if destination is an RPA that we can resolve */
751 irk1 = hci_find_irk_by_rpa(hdev, dst);
752 if (!irk1)
753 continue;
754
755 /* Match with identity address */
756 if (bacmp(&iso_pi(sk)->dst, &irk1->bdaddr)) {
757 /* Check if socket destination address is also
758 * an RPA and if the IRK matches.
759 */
760 irk2 = hci_find_irk_by_rpa(hdev,
761 &iso_pi(sk)->dst);
762 if (!irk2 || irk1 != irk2)
763 continue;
764 }
765 }
766
767 /* Use Match function if provided */
768 if (match && !match(sk, data))
769 continue;
770
771 /* Exact match. */
772 if (!bacmp(&iso_pi(sk)->src, src)) {
773 sock_hold(sk);
774 break;
775 }
776
777 /* Closest match */
778 if (!bacmp(&iso_pi(sk)->src, BDADDR_ANY)) {
779 if (sk1)
780 sock_put(sk1);
781
782 sk1 = sk;
783 sock_hold(sk1);
784 }
785 }
786
787 if (sk && sk1)
788 sock_put(sk1);
789
790 read_unlock(&iso_sk_list.lock);
791
792 return sk ? sk : sk1;
793}
794
795static struct sock *iso_get_sock_big(struct sock *match_sk, bdaddr_t *src,
796 bdaddr_t *dst, uint8_t big)
797{
798 struct sock *sk = NULL;
799
800 read_lock(&iso_sk_list.lock);
801
802 sk_for_each(sk, &iso_sk_list.head) {
803 if (match_sk == sk)
804 continue;
805
806 /* Look for sockets that have already been
807 * connected to the BIG
808 */
809 if (sk->sk_state != BT_CONNECTED &&
810 sk->sk_state != BT_CONNECT)
811 continue;
812
813 /* Match Broadcast destination */
814 if (bacmp(&iso_pi(sk)->dst, dst))
815 continue;
816
817 /* Match BIG handle */
818 if (iso_pi(sk)->qos.bcast.big != big)
819 continue;
820
821 /* Match source address */
822 if (bacmp(&iso_pi(sk)->src, src))
823 continue;
824
825 sock_hold(sk);
826 break;
827 }
828
829 read_unlock(&iso_sk_list.lock);
830
831 return sk;
832}
833
834static void iso_sock_destruct(struct sock *sk)
835{
836 BT_DBG("sk %p", sk);
837
838 iso_conn_put(iso_pi(sk)->conn);
839
840 skb_queue_purge(&sk->sk_receive_queue);
841 skb_queue_purge(&sk->sk_write_queue);
842 skb_queue_purge(&sk->sk_error_queue);
843}
844
845/* Close not yet accepted channels */
846static void iso_sock_flush_accept_q(struct sock *parent)
847{
848 struct sock *sk;
849
850 while ((sk = bt_accept_dequeue(parent, NULL))) {
851 iso_sock_close(sk);
852 iso_sock_kill(sk);
853 /* Drop the reference handed back by bt_accept_dequeue(). */
854 sock_put(sk);
855 }
856}
857
858static void iso_sock_cleanup_listen(struct sock *parent)
859{
860 BT_DBG("parent %p", parent);
861
862 iso_sock_flush_accept_q(parent);
863
864 /* If listening socket has a hcon, properly disconnect it */
865 if (iso_pi(parent)->conn && iso_pi(parent)->conn->hcon) {
866 iso_sock_disconn(parent);
867 return;
868 }
869
870 parent->sk_state = BT_CLOSED;
871 sock_set_flag(parent, SOCK_ZAPPED);
872}
873
874/* Kill socket (only if zapped and orphan)
875 * Must be called on unlocked socket.
876 */
877static void iso_sock_kill(struct sock *sk)
878{
879 iso_sock_disable_timer(sk);
880
881 lock_sock(sk);
882
883 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket ||
884 test_bit(BT_SK_KILLED, &iso_pi(sk)->flags)) {
885 release_sock(sk);
886 return;
887 }
888
889 BT_DBG("sk %p state %d", sk, sk->sk_state);
890
891 /* Sock is dead, so set conn->sk to NULL to avoid possible UAF */
892 if (iso_pi(sk)->conn) {
893 iso_conn_lock(iso_pi(sk)->conn);
894 iso_pi(sk)->conn->sk = NULL;
895 iso_conn_unlock(iso_pi(sk)->conn);
896 }
897
898 /* Kill poor orphan */
899 bt_sock_unlink(&iso_sk_list, sk);
900 sock_set_flag(sk, SOCK_DEAD);
901 set_bit(BT_SK_KILLED, &iso_pi(sk)->flags);
902
903 release_sock(sk);
904 sock_put(sk);
905}
906
907static void iso_sock_disconn(struct sock *sk)
908{
909 struct sock *bis_sk;
910 struct hci_conn *hcon = iso_pi(sk)->conn->hcon;
911
912 if (test_bit(HCI_CONN_BIG_CREATED, &hcon->flags)) {
913 bis_sk = iso_get_sock_big(sk, &iso_pi(sk)->src,
914 &iso_pi(sk)->dst,
915 iso_pi(sk)->qos.bcast.big);
916
917 /* If there are any other connected sockets for the
918 * same BIG, just delete the sk and leave the bis
919 * hcon active, in case later rebinding is needed.
920 */
921 if (bis_sk) {
922 hcon->state = BT_OPEN;
923 set_bit(ISO_CONN_DROPPED, iso_pi(sk)->conn->flags);
924
925 iso_sock_clear_timer(sk);
926 iso_chan_del(sk, bt_to_errno(hcon->abort_reason));
927 sock_put(bis_sk);
928 return;
929 }
930 }
931
932 sk->sk_state = BT_DISCONN;
933 if (!test_and_set_bit(ISO_CONN_DROPPED, iso_pi(sk)->conn->flags))
934 hci_conn_drop(iso_pi(sk)->conn->hcon);
935}
936
937static void __iso_sock_close(struct sock *sk)
938{
939 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
940
941 switch (sk->sk_state) {
942 case BT_LISTEN:
943 iso_sock_cleanup_listen(sk);
944 break;
945
946 case BT_CONNECT:
947 case BT_CONNECTED:
948 case BT_CONFIG:
949 if (iso_pi(sk)->conn->hcon)
950 iso_sock_disconn(sk);
951 else
952 iso_chan_del(sk, ECONNRESET);
953 break;
954
955 case BT_CONNECT2:
956 if (iso_pi(sk)->conn->hcon &&
957 (test_bit(HCI_CONN_PA_SYNC, &iso_pi(sk)->conn->hcon->flags) ||
958 test_bit(HCI_CONN_PA_SYNC_FAILED, &iso_pi(sk)->conn->hcon->flags)))
959 iso_sock_disconn(sk);
960 else
961 iso_chan_del(sk, ECONNRESET);
962 break;
963 case BT_DISCONN:
964 iso_chan_del(sk, ECONNRESET);
965 break;
966
967 default:
968 sock_set_flag(sk, SOCK_ZAPPED);
969 break;
970 }
971}
972
973/* Must be called on unlocked socket. */
974static void iso_sock_close(struct sock *sk)
975{
976 iso_sock_disable_timer(sk);
977
978 lock_sock(sk);
979 __iso_sock_close(sk);
980 release_sock(sk);
981}
982
983static void iso_sock_init(struct sock *sk, struct sock *parent)
984{
985 BT_DBG("sk %p", sk);
986
987 if (parent) {
988 sk->sk_type = parent->sk_type;
989 bt_sk(sk)->flags = bt_sk(parent)->flags;
990 security_sk_clone(parent, sk);
991 }
992}
993
994static struct proto iso_proto = {
995 .name = "ISO",
996 .owner = THIS_MODULE,
997 .obj_size = sizeof(struct iso_pinfo)
998};
999
1000#define DEFAULT_IO_QOS \
1001{ \
1002 .interval = 10000u, \
1003 .latency = 10u, \
1004 .sdu = 40u, \
1005 .phys = BT_ISO_PHY_2M, \
1006 .rtn = 2u, \
1007}
1008
1009static struct bt_iso_qos default_qos = {
1010 .bcast = {
1011 .big = BT_ISO_QOS_BIG_UNSET,
1012 .bis = BT_ISO_QOS_BIS_UNSET,
1013 .sync_factor = 0x01,
1014 .packing = 0x00,
1015 .framing = 0x00,
1016 .in = DEFAULT_IO_QOS,
1017 .out = DEFAULT_IO_QOS,
1018 .encryption = 0x00,
1019 .bcode = {0x00},
1020 .options = 0x00,
1021 .skip = 0x0000,
1022 .sync_timeout = BT_ISO_SYNC_TIMEOUT,
1023 .sync_cte_type = 0x00,
1024 .mse = 0x00,
1025 .timeout = BT_ISO_SYNC_TIMEOUT,
1026 },
1027};
1028
1029static struct sock *iso_sock_alloc(struct net *net, struct socket *sock,
1030 int proto, gfp_t prio, int kern)
1031{
1032 struct sock *sk;
1033
1034 sk = bt_sock_alloc(net, sock, &iso_proto, proto, prio, kern);
1035 if (!sk)
1036 return NULL;
1037
1038 sk->sk_destruct = iso_sock_destruct;
1039 sk->sk_sndtimeo = ISO_CONN_TIMEOUT;
1040
1041 /* Set address type as public as default src address is BDADDR_ANY */
1042 iso_pi(sk)->src_type = BDADDR_LE_PUBLIC;
1043
1044 iso_pi(sk)->qos = default_qos;
1045 iso_pi(sk)->sync_handle = -1;
1046
1047 INIT_DELAYED_WORK(&iso_pi(sk)->timeout_work, iso_sock_timeout);
1048
1049 bt_sock_link(&iso_sk_list, sk);
1050 return sk;
1051}
1052
1053static int iso_sock_create(struct net *net, struct socket *sock, int protocol,
1054 int kern)
1055{
1056 struct sock *sk;
1057
1058 BT_DBG("sock %p", sock);
1059
1060 sock->state = SS_UNCONNECTED;
1061
1062 if (sock->type != SOCK_SEQPACKET)
1063 return -ESOCKTNOSUPPORT;
1064
1065 sock->ops = &iso_sock_ops;
1066
1067 sk = iso_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1068 if (!sk)
1069 return -ENOMEM;
1070
1071 iso_sock_init(sk, NULL);
1072 return 0;
1073}
1074
1075static int iso_sock_bind_bc(struct socket *sock, struct sockaddr_unsized *addr,
1076 int addr_len)
1077{
1078 struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
1079 struct sock *sk = sock->sk;
1080 int i;
1081
1082 BT_DBG("sk %p bc_sid %u bc_num_bis %u", sk, sa->iso_bc->bc_sid,
1083 sa->iso_bc->bc_num_bis);
1084
1085 if (addr_len != sizeof(*sa) + sizeof(*sa->iso_bc))
1086 return -EINVAL;
1087
1088 bacpy(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr);
1089
1090 /* Check if the address type is of LE type */
1091 if (!bdaddr_type_is_le(sa->iso_bc->bc_bdaddr_type))
1092 return -EINVAL;
1093
1094 iso_pi(sk)->dst_type = sa->iso_bc->bc_bdaddr_type;
1095
1096 if (sa->iso_bc->bc_sid > 0x0f && sa->iso_bc->bc_sid != HCI_SID_INVALID)
1097 return -EINVAL;
1098
1099 iso_pi(sk)->bc_sid = sa->iso_bc->bc_sid;
1100
1101 if (sa->iso_bc->bc_num_bis > ISO_MAX_NUM_BIS)
1102 return -EINVAL;
1103
1104 iso_pi(sk)->bc_num_bis = sa->iso_bc->bc_num_bis;
1105
1106 for (i = 0; i < iso_pi(sk)->bc_num_bis; i++)
1107 if (sa->iso_bc->bc_bis[i] < 0x01 ||
1108 sa->iso_bc->bc_bis[i] > 0x1f)
1109 return -EINVAL;
1110
1111 memcpy(iso_pi(sk)->bc_bis, sa->iso_bc->bc_bis,
1112 iso_pi(sk)->bc_num_bis);
1113
1114 return 0;
1115}
1116
1117/* Must be called on the locked socket. */
1118static int iso_sock_rebind_bis(struct sock *sk, struct sockaddr_iso *sa,
1119 int addr_len)
1120{
1121 int err = 0;
1122
1123 if (!test_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags))
1124 return -EBADFD;
1125
1126 if (sa->iso_bc->bc_num_bis > ISO_MAX_NUM_BIS) {
1127 err = -EINVAL;
1128 goto done;
1129 }
1130
1131 for (int i = 0; i < sa->iso_bc->bc_num_bis; i++)
1132 if (sa->iso_bc->bc_bis[i] < 0x01 ||
1133 sa->iso_bc->bc_bis[i] > 0x1f) {
1134 err = -EINVAL;
1135 goto done;
1136 }
1137
1138 iso_pi(sk)->bc_num_bis = sa->iso_bc->bc_num_bis;
1139
1140 memcpy(iso_pi(sk)->bc_bis, sa->iso_bc->bc_bis,
1141 iso_pi(sk)->bc_num_bis);
1142
1143done:
1144 return err;
1145}
1146
1147static struct hci_dev *iso_conn_get_hdev(struct iso_conn *conn)
1148{
1149 struct hci_dev *hdev = NULL;
1150
1151 iso_conn_lock(conn);
1152 if (conn->hcon)
1153 hdev = hci_dev_hold(conn->hcon->hdev);
1154 iso_conn_unlock(conn);
1155
1156 return hdev;
1157}
1158
1159/* Must be called on the locked socket. */
1160static int iso_sock_rebind_bc(struct sock *sk, struct sockaddr_iso *sa,
1161 int addr_len)
1162{
1163 struct hci_dev *hdev;
1164 struct hci_conn *bis;
1165 int err;
1166
1167 if (sk->sk_type != SOCK_SEQPACKET || !iso_pi(sk)->conn)
1168 return -EINVAL;
1169
1170 /* Check if it is really a Broadcast address being requested */
1171 if (addr_len != sizeof(*sa) + sizeof(*sa->iso_bc))
1172 return -EINVAL;
1173
1174 /* Check if the address hasn't changed then perhaps only the number of
1175 * bis has changed.
1176 */
1177 if (!bacmp(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr) ||
1178 !bacmp(&sa->iso_bc->bc_bdaddr, BDADDR_ANY))
1179 return iso_sock_rebind_bis(sk, sa, addr_len);
1180
1181 /* Check if the address type is of LE type */
1182 if (!bdaddr_type_is_le(sa->iso_bc->bc_bdaddr_type))
1183 return -EINVAL;
1184
1185 hdev = iso_conn_get_hdev(iso_pi(sk)->conn);
1186 if (!hdev)
1187 return -EINVAL;
1188
1189 bis = iso_pi(sk)->conn->hcon;
1190
1191 /* Release the socket before lookups since that requires hci_dev_lock
1192 * which shall not be acquired while holding sock_lock for proper
1193 * ordering.
1194 */
1195 release_sock(sk);
1196 hci_dev_lock(hdev);
1197 lock_sock(sk);
1198
1199 if (!iso_pi(sk)->conn || iso_pi(sk)->conn->hcon != bis) {
1200 /* raced with iso_conn_del() or iso_disconn_sock() */
1201 err = -ENOTCONN;
1202 goto unlock;
1203 }
1204
1205 BT_DBG("sk %p %pMR type %u", sk, &sa->iso_bc->bc_bdaddr,
1206 sa->iso_bc->bc_bdaddr_type);
1207
1208 err = hci_past_bis(bis, &sa->iso_bc->bc_bdaddr,
1209 le_addr_type(sa->iso_bc->bc_bdaddr_type));
1210
1211unlock:
1212 hci_dev_unlock(hdev);
1213 hci_dev_put(hdev);
1214
1215 return err;
1216}
1217
1218static int iso_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
1219 int addr_len)
1220{
1221 struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
1222 struct sock *sk = sock->sk;
1223 int err = 0;
1224
1225 BT_DBG("sk %p %pMR type %u", sk, &sa->iso_bdaddr, sa->iso_bdaddr_type);
1226
1227 if (!addr || addr_len < sizeof(struct sockaddr_iso) ||
1228 addr->sa_family != AF_BLUETOOTH)
1229 return -EINVAL;
1230
1231 lock_sock(sk);
1232
1233 if ((sk->sk_state == BT_CONNECT2 || sk->sk_state == BT_CONNECTED) &&
1234 addr_len > sizeof(*sa)) {
1235 /* Allow the user to rebind to a different address using
1236 * PAST procedures.
1237 */
1238 err = iso_sock_rebind_bc(sk, sa, addr_len);
1239 goto done;
1240 }
1241
1242 if (sk->sk_state != BT_OPEN) {
1243 err = -EBADFD;
1244 goto done;
1245 }
1246
1247 if (sk->sk_type != SOCK_SEQPACKET) {
1248 err = -EINVAL;
1249 goto done;
1250 }
1251
1252 /* Check if the address type is of LE type */
1253 if (!bdaddr_type_is_le(sa->iso_bdaddr_type)) {
1254 err = -EINVAL;
1255 goto done;
1256 }
1257
1258 bacpy(&iso_pi(sk)->src, &sa->iso_bdaddr);
1259 iso_pi(sk)->src_type = sa->iso_bdaddr_type;
1260
1261 /* Check for Broadcast address */
1262 if (addr_len > sizeof(*sa)) {
1263 err = iso_sock_bind_bc(sock, addr, addr_len);
1264 if (err)
1265 goto done;
1266 }
1267
1268 sk->sk_state = BT_BOUND;
1269
1270done:
1271 release_sock(sk);
1272 return err;
1273}
1274
1275static int iso_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
1276 int alen, int flags)
1277{
1278 struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
1279 struct sock *sk = sock->sk;
1280 int err;
1281
1282 BT_DBG("sk %p", sk);
1283
1284 if (alen < sizeof(struct sockaddr_iso) ||
1285 addr->sa_family != AF_BLUETOOTH)
1286 return -EINVAL;
1287
1288 lock_sock(sk);
1289
1290 if ((sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) ||
1291 test_bit(BT_SK_CONNECTING, &iso_pi(sk)->flags)) {
1292 err = -EBADFD;
1293 goto done;
1294 }
1295
1296 if (sk->sk_type != SOCK_SEQPACKET) {
1297 err = -EINVAL;
1298 goto done;
1299 }
1300
1301 /* Check if the address type is of LE type */
1302 if (!bdaddr_type_is_le(sa->iso_bdaddr_type)) {
1303 err = -EINVAL;
1304 goto done;
1305 }
1306
1307 set_bit(BT_SK_CONNECTING, &iso_pi(sk)->flags);
1308
1309 bacpy(&iso_pi(sk)->dst, &sa->iso_bdaddr);
1310 iso_pi(sk)->dst_type = sa->iso_bdaddr_type;
1311
1312 release_sock(sk);
1313
1314 if (bacmp(&sa->iso_bdaddr, BDADDR_ANY))
1315 err = iso_connect_cis(sk);
1316 else
1317 err = iso_connect_bis(sk);
1318
1319 lock_sock(sk);
1320
1321 clear_bit(BT_SK_CONNECTING, &iso_pi(sk)->flags);
1322 if (err)
1323 goto done;
1324
1325 if (!test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
1326 err = bt_sock_wait_state(sk, BT_CONNECTED,
1327 sock_sndtimeo(sk, flags & O_NONBLOCK));
1328 }
1329
1330done:
1331 release_sock(sk);
1332 return err;
1333}
1334
1335static int iso_listen_bis(struct sock *sk)
1336{
1337 struct iso_conn *conn;
1338 struct hci_conn *hcon;
1339 struct hci_dev *hdev;
1340 bdaddr_t src, dst;
1341 u8 src_type, bc_sid;
1342 int err = 0;
1343
1344 lock_sock(sk);
1345 bacpy(&src, &iso_pi(sk)->src);
1346 bacpy(&dst, &iso_pi(sk)->dst);
1347 src_type = iso_pi(sk)->src_type;
1348 bc_sid = iso_pi(sk)->bc_sid;
1349 release_sock(sk);
1350
1351 BT_DBG("%pMR -> %pMR (SID 0x%2.2x)", &src, &dst, bc_sid);
1352
1353 write_lock(&iso_sk_list.lock);
1354
1355 if (__iso_get_sock_listen_by_sid(&src, &dst, bc_sid))
1356 err = -EADDRINUSE;
1357
1358 write_unlock(&iso_sk_list.lock);
1359
1360 if (err)
1361 return err;
1362
1363 hdev = hci_get_route(&dst, &src, src_type);
1364 if (!hdev)
1365 return -EHOSTUNREACH;
1366
1367 hci_dev_lock(hdev);
1368 lock_sock(sk);
1369
1370 if (sk->sk_state != BT_BOUND || iso_pi(sk)->conn) {
1371 err = -EBADFD;
1372 goto unlock;
1373 }
1374
1375 /* Fail if user set invalid QoS */
1376 if (iso_pi(sk)->qos_user_set && !check_bcast_qos(&iso_pi(sk)->qos)) {
1377 iso_pi(sk)->qos = default_qos;
1378 err = -EINVAL;
1379 goto unlock;
1380 }
1381
1382 hcon = hci_pa_create_sync(hdev, &iso_pi(sk)->dst,
1383 le_addr_type(iso_pi(sk)->dst_type),
1384 iso_pi(sk)->bc_sid, &iso_pi(sk)->qos);
1385 if (IS_ERR(hcon)) {
1386 err = PTR_ERR(hcon);
1387 goto unlock;
1388 }
1389
1390 lockdep_assert_held(&hcon->hdev->lock);
1391
1392 conn = iso_conn_add(hcon);
1393 if (!conn) {
1394 hci_conn_drop(hcon);
1395 err = -ENOMEM;
1396 goto unlock;
1397 }
1398
1399 err = iso_chan_add(conn, sk, NULL);
1400 iso_conn_put(conn);
1401 if (err)
1402 goto unlock;
1403
1404unlock:
1405 release_sock(sk);
1406 hci_dev_unlock(hdev);
1407 hci_dev_put(hdev);
1408 return err;
1409}
1410
1411static int iso_listen_cis(struct sock *sk)
1412{
1413 int err = 0;
1414
1415 BT_DBG("%pMR", &iso_pi(sk)->src);
1416
1417 write_lock(&iso_sk_list.lock);
1418
1419 if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src, &iso_pi(sk)->dst))
1420 err = -EADDRINUSE;
1421
1422 write_unlock(&iso_sk_list.lock);
1423
1424 return err;
1425}
1426
1427static int iso_sock_listen(struct socket *sock, int backlog)
1428{
1429 struct sock *sk = sock->sk;
1430 int err = 0;
1431
1432 BT_DBG("sk %p backlog %d", sk, backlog);
1433
1434 sock_hold(sk);
1435 lock_sock(sk);
1436
1437 if (sk->sk_state != BT_BOUND) {
1438 err = -EBADFD;
1439 goto done;
1440 }
1441
1442 if (sk->sk_type != SOCK_SEQPACKET) {
1443 err = -EINVAL;
1444 goto done;
1445 }
1446
1447 if (!bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) {
1448 err = iso_listen_cis(sk);
1449 } else {
1450 /* Drop sock lock to avoid potential
1451 * deadlock with the hdev lock.
1452 */
1453 release_sock(sk);
1454 err = iso_listen_bis(sk);
1455 lock_sock(sk);
1456 }
1457
1458 if (err)
1459 goto done;
1460
1461 sk->sk_max_ack_backlog = backlog;
1462 sk->sk_ack_backlog = 0;
1463
1464 sk->sk_state = BT_LISTEN;
1465
1466done:
1467 release_sock(sk);
1468 sock_put(sk);
1469 return err;
1470}
1471
1472static int iso_sock_accept(struct socket *sock, struct socket *newsock,
1473 struct proto_accept_arg *arg)
1474{
1475 DEFINE_WAIT_FUNC(wait, woken_wake_function);
1476 struct sock *sk = sock->sk, *ch;
1477 long timeo;
1478 int err = 0;
1479
1480 /* Use explicit nested locking to avoid lockdep warnings generated
1481 * because the parent socket and the child socket are locked on the
1482 * same thread.
1483 */
1484 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1485
1486 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
1487
1488 BT_DBG("sk %p timeo %ld", sk, timeo);
1489
1490 /* Wait for an incoming connection. (wake-one). */
1491 add_wait_queue_exclusive(sk_sleep(sk), &wait);
1492 while (1) {
1493 if (sk->sk_state != BT_LISTEN) {
1494 err = -EBADFD;
1495 break;
1496 }
1497
1498 ch = bt_accept_dequeue(sk, newsock);
1499 if (ch) {
1500 /* Drop the bridging ref from bt_accept_dequeue();
1501 * the grafted socket keeps ch alive from here.
1502 */
1503 sock_put(ch);
1504 break;
1505 }
1506
1507 if (!timeo) {
1508 err = -EAGAIN;
1509 break;
1510 }
1511
1512 if (signal_pending(current)) {
1513 err = sock_intr_errno(timeo);
1514 break;
1515 }
1516
1517 release_sock(sk);
1518
1519 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
1520 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1521 }
1522 remove_wait_queue(sk_sleep(sk), &wait);
1523
1524 if (err)
1525 goto done;
1526
1527 newsock->state = SS_CONNECTED;
1528
1529 BT_DBG("new socket %p", ch);
1530
1531 /* A Broadcast Sink might require BIG sync to be terminated
1532 * and re-established multiple times, while keeping the same
1533 * PA sync handle active. To allow this, once all BIS
1534 * connections have been accepted on a PA sync parent socket,
1535 * "reset" socket state, to allow future BIG re-sync procedures.
1536 */
1537 if (test_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags)) {
1538 /* Iterate through the list of bound BIS indices
1539 * and clear each BIS as they are accepted by the
1540 * user space, one by one.
1541 */
1542 for (int i = 0; i < iso_pi(sk)->bc_num_bis; i++) {
1543 if (iso_pi(sk)->bc_bis[i] > 0) {
1544 iso_pi(sk)->bc_bis[i] = 0;
1545 iso_pi(sk)->bc_num_bis--;
1546 break;
1547 }
1548 }
1549
1550 if (iso_pi(sk)->bc_num_bis == 0) {
1551 /* Once the last BIS was accepted, reset parent
1552 * socket parameters to mark that the listening
1553 * process for BIS connections has been completed:
1554 *
1555 * 1. Reset the DEFER setup flag on the parent sk.
1556 * 2. Clear the flag marking that the BIG create
1557 * sync command is pending.
1558 * 3. Transition socket state from BT_LISTEN to
1559 * BT_CONNECTED.
1560 */
1561 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
1562 clear_bit(BT_SK_BIG_SYNC, &iso_pi(sk)->flags);
1563 sk->sk_state = BT_CONNECTED;
1564 }
1565 }
1566
1567done:
1568 release_sock(sk);
1569 return err;
1570}
1571
1572static int iso_sock_getname(struct socket *sock, struct sockaddr *addr,
1573 int peer)
1574{
1575 struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
1576 struct sock *sk = sock->sk;
1577 int len = sizeof(struct sockaddr_iso);
1578
1579 BT_DBG("sock %p, sk %p", sock, sk);
1580
1581 lock_sock(sk);
1582
1583 memset(sa, 0, sizeof(struct sockaddr_iso));
1584 addr->sa_family = AF_BLUETOOTH;
1585
1586 if (peer) {
1587 struct hci_conn *hcon = iso_pi(sk)->conn ?
1588 iso_pi(sk)->conn->hcon : NULL;
1589
1590 bacpy(&sa->iso_bdaddr, &iso_pi(sk)->dst);
1591 sa->iso_bdaddr_type = iso_pi(sk)->dst_type;
1592
1593 if (hcon && (hcon->type == BIS_LINK || hcon->type == PA_LINK)) {
1594 memset(sa->iso_bc, 0, sizeof(struct sockaddr_iso_bc));
1595 sa->iso_bc->bc_sid = iso_pi(sk)->bc_sid;
1596 sa->iso_bc->bc_num_bis = iso_pi(sk)->bc_num_bis;
1597 memcpy(sa->iso_bc->bc_bis, iso_pi(sk)->bc_bis,
1598 ISO_MAX_NUM_BIS);
1599 len += sizeof(struct sockaddr_iso_bc);
1600 }
1601 } else {
1602 bacpy(&sa->iso_bdaddr, &iso_pi(sk)->src);
1603 sa->iso_bdaddr_type = iso_pi(sk)->src_type;
1604 }
1605
1606 release_sock(sk);
1607
1608 return len;
1609}
1610
1611static int iso_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1612 size_t len)
1613{
1614 struct sock *sk = sock->sk;
1615 struct sk_buff *skb, **frag;
1616 struct sockcm_cookie sockc;
1617 size_t mtu;
1618 int err;
1619
1620 BT_DBG("sock %p, sk %p", sock, sk);
1621
1622 err = sock_error(sk);
1623 if (err)
1624 return err;
1625
1626 if (msg->msg_flags & MSG_OOB)
1627 return -EOPNOTSUPP;
1628
1629 hci_sockcm_init(&sockc, sk);
1630
1631 if (msg->msg_controllen) {
1632 err = sock_cmsg_send(sk, msg, &sockc);
1633 if (err)
1634 return err;
1635 }
1636
1637 lock_sock(sk);
1638
1639 if (sk->sk_state != BT_CONNECTED) {
1640 release_sock(sk);
1641 return -ENOTCONN;
1642 }
1643
1644 mtu = iso_pi(sk)->conn->hcon->mtu;
1645
1646 release_sock(sk);
1647
1648 skb = bt_skb_sendmsg(sk, msg, len, mtu, HCI_ISO_DATA_HDR_SIZE, 0);
1649 if (IS_ERR(skb))
1650 return PTR_ERR(skb);
1651
1652 len -= skb->len;
1653
1654 BT_DBG("skb %p len %d", sk, skb->len);
1655
1656 /* Continuation fragments */
1657 frag = &skb_shinfo(skb)->frag_list;
1658 while (len) {
1659 struct sk_buff *tmp;
1660
1661 tmp = bt_skb_sendmsg(sk, msg, len, mtu, 0, 0);
1662 if (IS_ERR(tmp)) {
1663 kfree_skb(skb);
1664 return PTR_ERR(tmp);
1665 }
1666
1667 *frag = tmp;
1668
1669 len -= tmp->len;
1670
1671 skb->len += tmp->len;
1672 skb->data_len += tmp->len;
1673
1674 BT_DBG("frag %p len %d", *frag, tmp->len);
1675
1676 frag = &(*frag)->next;
1677 }
1678
1679 lock_sock(sk);
1680
1681 if (sk->sk_state == BT_CONNECTED)
1682 err = iso_send_frame(sk, skb, &sockc);
1683 else
1684 err = -ENOTCONN;
1685
1686 release_sock(sk);
1687
1688 if (err < 0)
1689 kfree_skb(skb);
1690 return err;
1691}
1692
1693static void iso_conn_defer_accept(struct hci_conn *conn)
1694{
1695 struct hci_cp_le_accept_cis cp;
1696 struct hci_dev *hdev = conn->hdev;
1697
1698 BT_DBG("conn %p", conn);
1699
1700 conn->state = BT_CONFIG;
1701
1702 cp.handle = cpu_to_le16(conn->handle);
1703
1704 hci_send_cmd(hdev, HCI_OP_LE_ACCEPT_CIS, sizeof(cp), &cp);
1705}
1706
1707static int iso_conn_big_sync(struct sock *sk)
1708{
1709 int err = 0;
1710 struct hci_dev *hdev;
1711 struct iso_conn *conn;
1712 bdaddr_t src, dst;
1713 u8 src_type;
1714
1715 lock_sock(sk);
1716 bacpy(&src, &iso_pi(sk)->src);
1717 bacpy(&dst, &iso_pi(sk)->dst);
1718 src_type = iso_pi(sk)->src_type;
1719 release_sock(sk);
1720
1721 hdev = hci_get_route(&dst, &src, src_type);
1722
1723 if (!hdev)
1724 return -EHOSTUNREACH;
1725
1726 /* hci_le_big_create_sync requires hdev lock to be held, since
1727 * it enqueues the HCI LE BIG Create Sync command via
1728 * hci_cmd_sync_queue_once, which checks hdev flags that might
1729 * change.
1730 */
1731 hci_dev_lock(hdev);
1732 lock_sock(sk);
1733
1734 /* The socket lock was dropped for hci_get_route(), so the connection
1735 * may have been torn down meanwhile: iso_chan_del() clears conn and
1736 * the broadcast teardown path can clear conn->hcon on its own. Check
1737 * both before dereferencing conn->hcon.
1738 */
1739 conn = iso_pi(sk)->conn;
1740 if (!conn || !conn->hcon) {
1741 err = -ENOTCONN;
1742 goto unlock;
1743 }
1744
1745 if (!test_and_set_bit(BT_SK_BIG_SYNC, &iso_pi(sk)->flags)) {
1746 err = hci_conn_big_create_sync(hdev, conn->hcon,
1747 &iso_pi(sk)->qos,
1748 iso_pi(sk)->sync_handle,
1749 iso_pi(sk)->bc_num_bis,
1750 iso_pi(sk)->bc_bis);
1751 if (err)
1752 bt_dev_err(hdev, "hci_big_create_sync: %d", err);
1753 }
1754
1755unlock:
1756 release_sock(sk);
1757 hci_dev_unlock(hdev);
1758 hci_dev_put(hdev);
1759
1760 return err;
1761}
1762
1763static int iso_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1764 size_t len, int flags)
1765{
1766 struct sock *sk = sock->sk;
1767 struct iso_pinfo *pi = iso_pi(sk);
1768 bool early_ret = false;
1769 int err = 0;
1770
1771 BT_DBG("sk %p", sk);
1772
1773 if (unlikely(flags & MSG_ERRQUEUE))
1774 return sock_recv_errqueue(sk, msg, len, SOL_BLUETOOTH,
1775 BT_SCM_ERROR);
1776
1777 if (test_and_clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
1778 sock_hold(sk);
1779 lock_sock(sk);
1780
1781 switch (sk->sk_state) {
1782 case BT_CONNECT2:
1783 if (test_bit(BT_SK_PA_SYNC, &pi->flags)) {
1784 /* Move to BT_LISTEN before requesting the BIG
1785 * sync: the BIS connections are matched to a
1786 * parent socket in BT_LISTEN state, and they
1787 * may be notified before the request returns.
1788 */
1789 sk->sk_state = BT_LISTEN;
1790
1791 release_sock(sk);
1792 err = iso_conn_big_sync(sk);
1793 lock_sock(sk);
1794
1795 /* The socket lock was dropped, so the
1796 * connection may have been torn down
1797 * meanwhile and iso_chan_del() may have
1798 * already moved the socket to BT_CLOSED.
1799 * Only move back if the BIG sync could not be
1800 * started and nothing else has changed the
1801 * state.
1802 */
1803 if (err && sk->sk_state == BT_LISTEN) {
1804 /* Discard any child socket that may
1805 * have been queued while the socket
1806 * was in BT_LISTEN, as the cleanup of
1807 * BT_CONNECT2 doesn't drain the
1808 * accept queue.
1809 */
1810 iso_sock_flush_accept_q(sk);
1811 sk->sk_state = BT_CONNECT2;
1812 }
1813 } else {
1814 iso_conn_defer_accept(pi->conn->hcon);
1815 sk->sk_state = BT_CONFIG;
1816 }
1817
1818 early_ret = true;
1819 break;
1820 case BT_CONNECTED:
1821 if (test_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags)) {
1822 /* As above, the BIS connections may be
1823 * notified before the request returns.
1824 */
1825 sk->sk_state = BT_LISTEN;
1826
1827 release_sock(sk);
1828 err = iso_conn_big_sync(sk);
1829 lock_sock(sk);
1830
1831 if (err && sk->sk_state == BT_LISTEN) {
1832 /* As above, don't leave any child
1833 * socket behind in the accept queue.
1834 */
1835 iso_sock_flush_accept_q(sk);
1836 sk->sk_state = BT_CONNECTED;
1837 }
1838 early_ret = true;
1839 }
1840
1841 break;
1842 case BT_CONNECT:
1843 release_sock(sk);
1844 err = iso_connect_cis(sk);
1845 lock_sock(sk);
1846
1847 early_ret = true;
1848 break;
1849 default:
1850 break;
1851 }
1852
1853 release_sock(sk);
1854 sock_put(sk);
1855
1856 if (early_ret)
1857 return err;
1858 }
1859
1860 return bt_sock_recvmsg(sock, msg, len, flags);
1861}
1862
1863static bool check_io_qos(struct bt_iso_io_qos *qos)
1864{
1865 /* If no PHY is enable SDU must be 0 */
1866 if (!qos->phys && qos->sdu)
1867 return false;
1868
1869 if (qos->interval && (qos->interval < 0xff || qos->interval > 0xfffff))
1870 return false;
1871
1872 if (qos->latency && (qos->latency < 0x05 || qos->latency > 0xfa0))
1873 return false;
1874
1875 if (qos->phys > BT_ISO_PHY_ANY)
1876 return false;
1877
1878 return true;
1879}
1880
1881static bool check_ucast_qos(struct bt_iso_qos *qos)
1882{
1883 if (qos->ucast.cig > 0xef && qos->ucast.cig != BT_ISO_QOS_CIG_UNSET)
1884 return false;
1885
1886 if (qos->ucast.cis > 0xef && qos->ucast.cis != BT_ISO_QOS_CIS_UNSET)
1887 return false;
1888
1889 if (qos->ucast.sca > 0x07)
1890 return false;
1891
1892 if (qos->ucast.packing > 0x01)
1893 return false;
1894
1895 if (qos->ucast.framing > 0x01)
1896 return false;
1897
1898 if (!check_io_qos(&qos->ucast.in))
1899 return false;
1900
1901 if (!check_io_qos(&qos->ucast.out))
1902 return false;
1903
1904 return true;
1905}
1906
1907static bool check_bcast_qos(struct bt_iso_qos *qos)
1908{
1909 if (!qos->bcast.sync_factor)
1910 qos->bcast.sync_factor = 0x01;
1911
1912 if (qos->bcast.packing > 0x01)
1913 return false;
1914
1915 if (qos->bcast.framing > 0x01)
1916 return false;
1917
1918 if (!check_io_qos(&qos->bcast.in))
1919 return false;
1920
1921 if (!check_io_qos(&qos->bcast.out))
1922 return false;
1923
1924 if (qos->bcast.encryption > 0x01)
1925 return false;
1926
1927 if (qos->bcast.options > 0x07)
1928 return false;
1929
1930 if (qos->bcast.skip > 0x01f3)
1931 return false;
1932
1933 if (!qos->bcast.sync_timeout)
1934 qos->bcast.sync_timeout = BT_ISO_SYNC_TIMEOUT;
1935
1936 if (qos->bcast.sync_timeout < 0x000a || qos->bcast.sync_timeout > 0x4000)
1937 return false;
1938
1939 if (qos->bcast.sync_cte_type > 0x1f)
1940 return false;
1941
1942 if (qos->bcast.mse > 0x1f)
1943 return false;
1944
1945 if (!qos->bcast.timeout)
1946 qos->bcast.timeout = BT_ISO_SYNC_TIMEOUT;
1947
1948 if (qos->bcast.timeout < 0x000a || qos->bcast.timeout > 0x4000)
1949 return false;
1950
1951 return true;
1952}
1953
1954static int iso_sock_setsockopt(struct socket *sock, int level, int optname,
1955 sockptr_t optval, unsigned int optlen)
1956{
1957 struct sock *sk = sock->sk;
1958 int err = 0;
1959 struct bt_iso_qos qos = default_qos;
1960 u32 opt;
1961
1962 BT_DBG("sk %p", sk);
1963
1964 lock_sock(sk);
1965
1966 switch (optname) {
1967 case BT_DEFER_SETUP:
1968 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1969 err = -EINVAL;
1970 break;
1971 }
1972
1973 err = copy_safe_from_sockptr(&opt, sizeof(opt), optval, optlen);
1974 if (err)
1975 break;
1976
1977 if (opt)
1978 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
1979 else
1980 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
1981 break;
1982
1983 case BT_PKT_STATUS:
1984 err = copy_safe_from_sockptr(&opt, sizeof(opt), optval, optlen);
1985 if (err)
1986 break;
1987
1988 if (opt)
1989 set_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
1990 else
1991 clear_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
1992 break;
1993
1994 case BT_PKT_SEQNUM:
1995 err = copy_safe_from_sockptr(&opt, sizeof(opt), optval, optlen);
1996 if (err)
1997 break;
1998
1999 if (opt)
2000 set_bit(BT_SK_PKT_SEQNUM, &bt_sk(sk)->flags);
2001 else
2002 clear_bit(BT_SK_PKT_SEQNUM, &bt_sk(sk)->flags);
2003 break;
2004
2005 case BT_ISO_QOS:
2006 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
2007 sk->sk_state != BT_CONNECT2 &&
2008 (!test_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags) ||
2009 sk->sk_state != BT_CONNECTED)) {
2010 err = -EINVAL;
2011 break;
2012 }
2013
2014 err = copy_safe_from_sockptr(&qos, sizeof(qos), optval, optlen);
2015 if (err)
2016 break;
2017
2018 iso_pi(sk)->qos = qos;
2019 iso_pi(sk)->qos_user_set = true;
2020
2021 break;
2022
2023 case BT_ISO_BASE:
2024 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
2025 sk->sk_state != BT_CONNECT2) {
2026 err = -EINVAL;
2027 break;
2028 }
2029
2030 if (optlen > sizeof(iso_pi(sk)->base)) {
2031 err = -EINVAL;
2032 break;
2033 }
2034
2035 err = copy_safe_from_sockptr(iso_pi(sk)->base, optlen, optval,
2036 optlen);
2037 if (err)
2038 break;
2039
2040 iso_pi(sk)->base_len = optlen;
2041
2042 break;
2043
2044 default:
2045 err = -ENOPROTOOPT;
2046 break;
2047 }
2048
2049 release_sock(sk);
2050 return err;
2051}
2052
2053static int iso_sock_getsockopt(struct socket *sock, int level, int optname,
2054 sockopt_t *opt)
2055{
2056 struct sock *sk = sock->sk;
2057 struct bt_iso_qos *qos;
2058 int len, val, err = 0;
2059 u8 base_len;
2060 u8 *base;
2061
2062 BT_DBG("sk %p", sk);
2063
2064 len = opt->optlen;
2065
2066 lock_sock(sk);
2067
2068 switch (optname) {
2069 case BT_DEFER_SETUP:
2070 if (sk->sk_state == BT_CONNECTED) {
2071 err = -EINVAL;
2072 break;
2073 }
2074
2075 val = test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
2076 if (copy_to_iter(&val, sizeof(val), &opt->iter_out) !=
2077 sizeof(val))
2078 err = -EFAULT;
2079
2080 break;
2081
2082 case BT_PKT_STATUS:
2083 val = test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
2084 if (copy_to_iter(&val, sizeof(val), &opt->iter_out) !=
2085 sizeof(val))
2086 err = -EFAULT;
2087 break;
2088
2089 case BT_ISO_QOS:
2090 qos = iso_sock_get_qos(sk);
2091
2092 len = min_t(unsigned int, len, sizeof(*qos));
2093 if (copy_to_iter(qos, len, &opt->iter_out) != len)
2094 err = -EFAULT;
2095
2096 break;
2097
2098 case BT_ISO_BASE:
2099 if (sk->sk_state == BT_CONNECTED &&
2100 !bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) {
2101 base_len = iso_pi(sk)->conn->hcon->le_per_adv_data_len;
2102 base = iso_pi(sk)->conn->hcon->le_per_adv_data;
2103 } else {
2104 base_len = iso_pi(sk)->base_len;
2105 base = iso_pi(sk)->base;
2106 }
2107
2108 len = min_t(unsigned int, len, base_len);
2109 opt->optlen = len;
2110 if (copy_to_iter(base, len, &opt->iter_out) != len)
2111 err = -EFAULT;
2112
2113 break;
2114
2115 default:
2116 err = -ENOPROTOOPT;
2117 break;
2118 }
2119
2120 release_sock(sk);
2121 return err;
2122}
2123
2124static int iso_sock_shutdown(struct socket *sock, int how)
2125{
2126 struct sock *sk = sock->sk;
2127 int err = 0;
2128
2129 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
2130
2131 if (!sk)
2132 return 0;
2133
2134 sock_hold(sk);
2135 lock_sock(sk);
2136
2137 switch (how) {
2138 case SHUT_RD:
2139 if (sk->sk_shutdown & RCV_SHUTDOWN)
2140 goto unlock;
2141 sk->sk_shutdown |= RCV_SHUTDOWN;
2142 break;
2143 case SHUT_WR:
2144 if (sk->sk_shutdown & SEND_SHUTDOWN)
2145 goto unlock;
2146 sk->sk_shutdown |= SEND_SHUTDOWN;
2147 break;
2148 case SHUT_RDWR:
2149 if (sk->sk_shutdown & SHUTDOWN_MASK)
2150 goto unlock;
2151 sk->sk_shutdown |= SHUTDOWN_MASK;
2152 break;
2153 }
2154
2155 iso_sock_clear_timer(sk);
2156 __iso_sock_close(sk);
2157
2158 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
2159 !(current->flags & PF_EXITING))
2160 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
2161
2162unlock:
2163 release_sock(sk);
2164 sock_put(sk);
2165
2166 return err;
2167}
2168
2169static int iso_sock_release(struct socket *sock)
2170{
2171 struct sock *sk = sock->sk;
2172 int err = 0;
2173
2174 BT_DBG("sock %p, sk %p", sock, sk);
2175
2176 if (!sk)
2177 return 0;
2178
2179 iso_sock_close(sk);
2180
2181 if (sock_flag(sk, SOCK_LINGER) && READ_ONCE(sk->sk_lingertime) &&
2182 !(current->flags & PF_EXITING)) {
2183 lock_sock(sk);
2184 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
2185 release_sock(sk);
2186 }
2187
2188 /* Make sure sk is valid even if iso_conn_del() is concurrent */
2189 sock_hold(sk);
2190
2191 lock_sock(sk);
2192 sock_orphan(sk);
2193 release_sock(sk);
2194
2195 iso_sock_kill(sk);
2196
2197 sock_put(sk);
2198 return err;
2199}
2200
2201static void iso_sock_ready(struct sock *sk)
2202{
2203 BT_DBG("sk %p", sk);
2204
2205 lockdep_assert(lockdep_sock_is_held(sk));
2206
2207 switch (sk->sk_state) {
2208 case BT_DISCONN:
2209 case BT_CLOSED:
2210 return;
2211 }
2212
2213 iso_sock_clear_timer(sk);
2214 sk->sk_state = BT_CONNECTED;
2215 sk->sk_state_change(sk);
2216}
2217
2218static bool iso_match_big(struct sock *sk, void *data)
2219{
2220 struct hci_evt_le_big_sync_established *ev = data;
2221
2222 return ev->handle == iso_pi(sk)->qos.bcast.big;
2223}
2224
2225static bool iso_match_big_hcon(struct sock *sk, void *data)
2226{
2227 struct hci_conn *hcon = data;
2228
2229 return hcon->iso_qos.bcast.big == iso_pi(sk)->qos.bcast.big;
2230}
2231
2232static bool iso_match_pa_sync_flag(struct sock *sk, void *data)
2233{
2234 return test_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags);
2235}
2236
2237static bool iso_match_dst(struct sock *sk, void *data)
2238{
2239 return !bacmp(&iso_pi(sk)->dst, (bdaddr_t *)data);
2240}
2241
2242static void iso_conn_ready(struct iso_conn *conn)
2243{
2244 struct sock *parent = NULL;
2245 struct sock *sk;
2246 struct hci_ev_le_big_sync_established *ev = NULL;
2247 struct hci_ev_le_pa_sync_established *ev2 = NULL;
2248 struct hci_ev_le_per_adv_report *ev3 = NULL;
2249 struct hci_conn *hcon;
2250 struct hci_dev *hdev;
2251
2252 BT_DBG("conn %p", conn);
2253
2254 iso_conn_lock(conn);
2255 sk = iso_sock_hold(conn);
2256 iso_conn_unlock(conn);
2257
2258 if (sk) {
2259 lock_sock(sk);
2260
2261 /* conn->sk may have become NULL if racing with sk close, but
2262 * due to held hdev->lock, it can't become different sk.
2263 */
2264 if (!conn->sk) {
2265 release_sock(sk);
2266 sock_put(sk);
2267 return;
2268 }
2269
2270 /* Attempt to update source address in case of BIS Sender if
2271 * the advertisement is using a random address.
2272 */
2273 if (conn->hcon->type == BIS_LINK &&
2274 conn->hcon->role == HCI_ROLE_MASTER &&
2275 !bacmp(&conn->hcon->dst, BDADDR_ANY)) {
2276 struct hci_conn *bis = conn->hcon;
2277 struct adv_info *adv;
2278
2279 adv = hci_find_adv_instance(bis->hdev,
2280 bis->iso_qos.bcast.bis);
2281 if (adv && bacmp(&adv->random_addr, BDADDR_ANY)) {
2282 iso_pi(sk)->src_type = BDADDR_LE_RANDOM;
2283 bacpy(&iso_pi(sk)->src, &adv->random_addr);
2284 }
2285 }
2286
2287 iso_sock_ready(sk);
2288
2289 release_sock(sk);
2290 sock_put(sk);
2291 } else {
2292 hcon = conn->hcon;
2293 if (!hcon)
2294 return;
2295
2296 hdev = hcon->hdev;
2297
2298 if (test_bit(HCI_CONN_BIG_SYNC, &hcon->flags)) {
2299 /* A BIS slave hcon is notified to the ISO layer
2300 * after the Command Complete for the LE Setup
2301 * ISO Data Path command is received. Get the
2302 * parent socket that matches the hcon BIG handle.
2303 */
2304 parent = iso_get_sock(hdev, &hcon->src, &hcon->dst,
2305 BT_LISTEN, iso_match_big_hcon,
2306 hcon);
2307 } else if (test_bit(HCI_CONN_BIG_SYNC_FAILED, &hcon->flags)) {
2308 ev = hci_recv_event_data(hcon->hdev,
2309 HCI_EVT_LE_BIG_SYNC_ESTABLISHED);
2310
2311 /* Get reference to PA sync parent socket, if it exists */
2312 parent = iso_get_sock(hdev, &hcon->src, &hcon->dst,
2313 BT_LISTEN,
2314 iso_match_pa_sync_flag,
2315 NULL);
2316 if (!parent && ev)
2317 parent = iso_get_sock(hdev, &hcon->src,
2318 &hcon->dst,
2319 BT_LISTEN,
2320 iso_match_big, ev);
2321 } else if (test_bit(HCI_CONN_PA_SYNC_FAILED, &hcon->flags)) {
2322 ev2 = hci_recv_event_data(hcon->hdev,
2323 HCI_EV_LE_PA_SYNC_ESTABLISHED);
2324 if (ev2)
2325 parent = iso_get_sock(hdev, &hcon->src,
2326 &hcon->dst,
2327 BT_LISTEN,
2328 iso_match_sid, ev2);
2329 } else if (test_bit(HCI_CONN_PA_SYNC, &hcon->flags)) {
2330 ev3 = hci_recv_event_data(hcon->hdev,
2331 HCI_EV_LE_PER_ADV_REPORT);
2332 if (ev3)
2333 parent = iso_get_sock(hdev, &hcon->src,
2334 &hcon->dst,
2335 BT_LISTEN,
2336 iso_match_sync_handle_pa_report,
2337 ev3);
2338 }
2339
2340 if (!parent)
2341 parent = iso_get_sock(hdev, &hcon->src, BDADDR_ANY,
2342 BT_LISTEN, iso_match_dst, BDADDR_ANY);
2343
2344 if (!parent)
2345 return;
2346
2347 lock_sock(parent);
2348
2349 /* The listener may have been closed concurrently. */
2350 if (parent->sk_state != BT_LISTEN ||
2351 sock_flag(parent, SOCK_ZAPPED)) {
2352 release_sock(parent);
2353 sock_put(parent);
2354 return;
2355 }
2356
2357 sk = iso_sock_alloc(sock_net(parent), NULL,
2358 BTPROTO_ISO, GFP_ATOMIC, 0);
2359 if (!sk) {
2360 release_sock(parent);
2361 sock_put(parent);
2362 return;
2363 }
2364
2365 iso_sock_init(sk, parent);
2366
2367 bacpy(&iso_pi(sk)->src, &hcon->src);
2368
2369 /* Convert from HCI to three-value type */
2370 if (hcon->src_type == ADDR_LE_DEV_PUBLIC)
2371 iso_pi(sk)->src_type = BDADDR_LE_PUBLIC;
2372 else
2373 iso_pi(sk)->src_type = BDADDR_LE_RANDOM;
2374
2375 /* If hcon has no destination address (BDADDR_ANY) it means it
2376 * was created by HCI_EV_LE_BIG_SYNC_ESTABILISHED or
2377 * HCI_EV_LE_PA_SYNC_ESTABLISHED so we need to initialize using
2378 * the parent socket destination address.
2379 */
2380 if (!bacmp(&hcon->dst, BDADDR_ANY)) {
2381 bacpy(&hcon->dst, &iso_pi(parent)->dst);
2382 hcon->dst_type = le_addr_type(iso_pi(parent)->dst_type);
2383 }
2384
2385 if (test_bit(HCI_CONN_PA_SYNC, &hcon->flags)) {
2386 iso_pi(sk)->qos = iso_pi(parent)->qos;
2387 hcon->iso_qos = iso_pi(sk)->qos;
2388 iso_pi(sk)->bc_sid = iso_pi(parent)->bc_sid;
2389 iso_pi(sk)->bc_num_bis = iso_pi(parent)->bc_num_bis;
2390 memcpy(iso_pi(sk)->bc_bis, iso_pi(parent)->bc_bis,
2391 ISO_MAX_NUM_BIS);
2392 set_bit(BT_SK_PA_SYNC, &iso_pi(sk)->flags);
2393 }
2394
2395 bacpy(&iso_pi(sk)->dst, &hcon->dst);
2396
2397 /* Convert from HCI to three-value type */
2398 if (hcon->dst_type == ADDR_LE_DEV_PUBLIC)
2399 iso_pi(sk)->dst_type = BDADDR_LE_PUBLIC;
2400 else
2401 iso_pi(sk)->dst_type = BDADDR_LE_RANDOM;
2402
2403 iso_pi(sk)->sync_handle = iso_pi(parent)->sync_handle;
2404 memcpy(iso_pi(sk)->base, iso_pi(parent)->base, iso_pi(parent)->base_len);
2405 iso_pi(sk)->base_len = iso_pi(parent)->base_len;
2406
2407 hci_conn_hold(hcon);
2408 iso_chan_add(conn, sk, parent);
2409
2410 if ((ev && ((struct hci_evt_le_big_sync_established *)ev)->status) ||
2411 (ev2 && ev2->status)) {
2412 /* Trigger error signal on child socket */
2413 sk->sk_err = ECONNREFUSED;
2414 sk->sk_error_report(sk);
2415 }
2416
2417 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
2418 sk->sk_state = BT_CONNECT2;
2419 else
2420 sk->sk_state = BT_CONNECTED;
2421
2422 /* Wake up parent */
2423 parent->sk_data_ready(parent);
2424
2425 release_sock(parent);
2426 sock_put(parent);
2427 }
2428}
2429
2430static bool iso_match_sid(struct sock *sk, void *data)
2431{
2432 struct hci_ev_le_pa_sync_established *ev = data;
2433
2434 if (iso_pi(sk)->bc_sid == HCI_SID_INVALID)
2435 return true;
2436
2437 return ev->sid == iso_pi(sk)->bc_sid;
2438}
2439
2440static bool iso_match_sid_past(struct sock *sk, void *data)
2441{
2442 struct hci_ev_le_past_received *ev = data;
2443
2444 if (iso_pi(sk)->bc_sid == HCI_SID_INVALID)
2445 return true;
2446
2447 return ev->sid == iso_pi(sk)->bc_sid;
2448}
2449
2450static bool iso_match_sync_handle(struct sock *sk, void *data)
2451{
2452 struct hci_evt_le_big_info_adv_report *ev = data;
2453
2454 return le16_to_cpu(ev->sync_handle) == iso_pi(sk)->sync_handle;
2455}
2456
2457static bool iso_match_sync_handle_pa_report(struct sock *sk, void *data)
2458{
2459 struct hci_ev_le_per_adv_report *ev = data;
2460
2461 return le16_to_cpu(ev->sync_handle) == iso_pi(sk)->sync_handle;
2462}
2463
2464/* ----- ISO interface with lower layer (HCI) ----- */
2465
2466int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
2467{
2468 struct hci_ev_le_pa_sync_established *ev1;
2469 struct hci_ev_le_past_received *ev1a;
2470 struct hci_evt_le_big_info_adv_report *ev2;
2471 struct hci_ev_le_per_adv_report *ev3;
2472 struct sock *sk;
2473
2474 bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
2475
2476 /* Broadcast receiver requires handling of some events before it can
2477 * proceed to establishing a BIG sync:
2478 *
2479 * 1. HCI_EV_LE_PA_SYNC_ESTABLISHED: The socket may specify a specific
2480 * SID to listen to and once sync is established its handle needs to
2481 * be stored in iso_pi(sk)->sync_handle so it can be matched once
2482 * receiving the BIG Info.
2483 * 1a. HCI_EV_LE_PAST_RECEIVED: alternative to 1.
2484 * 2. HCI_EVT_LE_BIG_INFO_ADV_REPORT: When connect_ind is triggered by a
2485 * a BIG Info it attempts to check if there any listening socket with
2486 * the same sync_handle and if it does then attempt to create a sync.
2487 * 3. HCI_EV_LE_PER_ADV_REPORT: When a PA report is received, it is stored
2488 * in iso_pi(sk)->base so it can be passed up to user, in the case of a
2489 * broadcast sink.
2490 */
2491 ev1 = hci_recv_event_data(hdev, HCI_EV_LE_PA_SYNC_ESTABLISHED);
2492 if (ev1) {
2493 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr, BT_LISTEN,
2494 iso_match_sid, ev1);
2495 if (sk && !ev1->status) {
2496 lock_sock(sk);
2497 iso_pi(sk)->sync_handle = le16_to_cpu(ev1->handle);
2498 iso_pi(sk)->bc_sid = ev1->sid;
2499 release_sock(sk);
2500 }
2501
2502 goto done;
2503 }
2504
2505 ev1a = hci_recv_event_data(hdev, HCI_EV_LE_PAST_RECEIVED);
2506 if (ev1a) {
2507 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr, BT_LISTEN,
2508 iso_match_sid_past, ev1a);
2509 if (sk && !ev1a->status) {
2510 lock_sock(sk);
2511 iso_pi(sk)->sync_handle = le16_to_cpu(ev1a->sync_handle);
2512 iso_pi(sk)->bc_sid = ev1a->sid;
2513 release_sock(sk);
2514 }
2515
2516 goto done;
2517 }
2518
2519 ev2 = hci_recv_event_data(hdev, HCI_EVT_LE_BIG_INFO_ADV_REPORT);
2520 if (ev2) {
2521 /* Check if BIGInfo report has already been handled */
2522 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr, BT_CONNECTED,
2523 iso_match_sync_handle, ev2);
2524 if (sk) {
2525 sock_put(sk);
2526 sk = NULL;
2527 goto done;
2528 }
2529
2530 /* Try to get PA sync socket, if it exists */
2531 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr, BT_CONNECT2,
2532 iso_match_sync_handle, ev2);
2533 if (!sk)
2534 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr,
2535 BT_LISTEN,
2536 iso_match_sync_handle,
2537 ev2);
2538
2539 if (sk) {
2540 int err = 0;
2541 bool big_sync;
2542 struct hci_conn *hcon;
2543
2544 lock_sock(sk);
2545
2546 hcon = iso_pi(sk)->conn ? iso_pi(sk)->conn->hcon : NULL;
2547 iso_pi(sk)->qos.bcast.encryption = ev2->encryption;
2548
2549 if (ev2->num_bis < iso_pi(sk)->bc_num_bis)
2550 iso_pi(sk)->bc_num_bis = ev2->num_bis;
2551
2552 big_sync = !test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags) &&
2553 !test_and_set_bit(BT_SK_BIG_SYNC, &iso_pi(sk)->flags);
2554
2555 if (big_sync)
2556 err = hci_conn_big_create_sync(hdev, hcon,
2557 &iso_pi(sk)->qos,
2558 iso_pi(sk)->sync_handle,
2559 iso_pi(sk)->bc_num_bis,
2560 iso_pi(sk)->bc_bis);
2561
2562 release_sock(sk);
2563
2564 if (big_sync && err) {
2565 bt_dev_err(hdev, "hci_le_big_create_sync: %d",
2566 err);
2567 sock_put(sk);
2568 sk = NULL;
2569 }
2570 }
2571
2572 goto done;
2573 }
2574
2575 ev3 = hci_recv_event_data(hdev, HCI_EV_LE_PER_ADV_REPORT);
2576 if (ev3) {
2577 size_t base_len = 0;
2578 u8 *base;
2579 struct hci_conn *hcon;
2580
2581 sk = iso_get_sock(hdev, &hdev->bdaddr, bdaddr, BT_LISTEN,
2582 iso_match_sync_handle_pa_report, ev3);
2583 if (!sk)
2584 goto done;
2585
2586 lock_sock(sk);
2587
2588 hcon = iso_pi(sk)->conn ? iso_pi(sk)->conn->hcon : NULL;
2589 if (!hcon)
2590 goto release3;
2591
2592 if (ev3->data_status == LE_PA_DATA_TRUNCATED) {
2593 /* The controller was unable to retrieve PA data. */
2594 memset(hcon->le_per_adv_data, 0,
2595 HCI_MAX_PER_AD_TOT_LEN);
2596 hcon->le_per_adv_data_len = 0;
2597 hcon->le_per_adv_data_offset = 0;
2598 goto release3;
2599 }
2600
2601 if (hcon->le_per_adv_data_offset + ev3->length >
2602 HCI_MAX_PER_AD_TOT_LEN)
2603 goto release3;
2604
2605 memcpy(hcon->le_per_adv_data + hcon->le_per_adv_data_offset,
2606 ev3->data, ev3->length);
2607 hcon->le_per_adv_data_offset += ev3->length;
2608
2609 if (ev3->data_status == LE_PA_DATA_COMPLETE) {
2610 /* All PA data has been received. */
2611 hcon->le_per_adv_data_len =
2612 hcon->le_per_adv_data_offset;
2613 hcon->le_per_adv_data_offset = 0;
2614
2615 /* Extract BASE */
2616 base = eir_get_service_data(hcon->le_per_adv_data,
2617 hcon->le_per_adv_data_len,
2618 EIR_BAA_SERVICE_UUID,
2619 &base_len);
2620
2621 if (!base || base_len > BASE_MAX_LENGTH)
2622 goto release3;
2623
2624 memcpy(iso_pi(sk)->base, base, base_len);
2625 iso_pi(sk)->base_len = base_len;
2626 } else {
2627 /* This is a PA data fragment. Keep pa_data_len set to 0
2628 * until all data has been reassembled.
2629 */
2630 hcon->le_per_adv_data_len = 0;
2631 }
2632
2633release3:
2634 release_sock(sk);
2635 } else {
2636 sk = iso_get_sock(hdev, &hdev->bdaddr, BDADDR_ANY,
2637 BT_LISTEN, iso_match_dst, BDADDR_ANY);
2638 }
2639
2640done:
2641 if (!sk)
2642 return 0;
2643
2644 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
2645 *flags |= HCI_PROTO_DEFER;
2646
2647 sock_put(sk);
2648
2649 return HCI_LM_ACCEPT;
2650}
2651
2652static void iso_connect_cfm(struct hci_conn *hcon, __u8 status)
2653 __must_hold(&hcon->hdev->lock)
2654{
2655 if (hcon->type != CIS_LINK && hcon->type != BIS_LINK &&
2656 hcon->type != PA_LINK) {
2657 if (hcon->type != LE_LINK)
2658 return;
2659
2660 /* Check if LE link has failed */
2661 if (status) {
2662 struct hci_link *link, *t;
2663
2664 list_for_each_entry_safe(link, t, &hcon->link_list,
2665 list) {
2666 lockdep_assert_held(&link->conn->hdev->lock);
2667 iso_conn_del(link->conn, bt_to_errno(status));
2668 }
2669
2670 return;
2671 }
2672
2673 /* Create CIS if pending */
2674 hci_le_create_cis_pending(hcon->hdev);
2675 return;
2676 }
2677
2678 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
2679
2680 /* Similar to the success case, if HCI_CONN_BIG_SYNC_FAILED or
2681 * HCI_CONN_PA_SYNC_FAILED is set, queue the failed connection
2682 * into the accept queue of the listening socket and wake up
2683 * userspace, to inform the user about the event.
2684 */
2685 if (!status || test_bit(HCI_CONN_BIG_SYNC_FAILED, &hcon->flags) ||
2686 test_bit(HCI_CONN_PA_SYNC_FAILED, &hcon->flags)) {
2687 struct iso_conn *conn;
2688
2689 conn = iso_conn_add(hcon);
2690 if (conn) {
2691 iso_conn_ready(conn);
2692 iso_conn_put(conn);
2693 }
2694 } else {
2695 iso_conn_del(hcon, bt_to_errno(status));
2696 }
2697}
2698
2699static void iso_disconn_cfm(struct hci_conn *hcon, __u8 reason)
2700 __must_hold(&hcon->hdev->lock)
2701{
2702 if (hcon->type != CIS_LINK && hcon->type != BIS_LINK &&
2703 hcon->type != PA_LINK)
2704 return;
2705
2706 BT_DBG("hcon %p reason %d", hcon, reason);
2707
2708 iso_conn_del(hcon, bt_to_errno(reason));
2709}
2710
2711int iso_recv(struct hci_dev *hdev, u16 handle, struct sk_buff *skb, u16 flags)
2712{
2713 struct hci_conn *hcon;
2714 struct iso_conn *conn;
2715 struct skb_shared_hwtstamps *hwts;
2716 __u16 pb, ts, len, sn;
2717
2718 hci_dev_lock(hdev);
2719
2720 hcon = hci_conn_hash_lookup_handle(hdev, handle);
2721 if (!hcon) {
2722 hci_dev_unlock(hdev);
2723 kfree_skb(skb);
2724 return -ENOENT;
2725 }
2726
2727 spin_lock(&hcon->proto_lock);
2728 conn = iso_conn_hold_unless_zero(hcon->iso_data);
2729 spin_unlock(&hcon->proto_lock);
2730
2731 hcon = NULL;
2732
2733 hci_dev_unlock(hdev);
2734
2735 if (!conn) {
2736 kfree_skb(skb);
2737 return -EINVAL;
2738 }
2739
2740 pb = hci_iso_flags_pb(flags);
2741 ts = hci_iso_flags_ts(flags);
2742
2743 BT_DBG("conn %p len %d pb 0x%x ts 0x%x", conn, skb->len, pb, ts);
2744
2745 switch (pb) {
2746 case ISO_START:
2747 case ISO_SINGLE:
2748 if (conn->rx_skb || conn->rx_len) {
2749 BT_ERR("Unexpected start frame (len %d)", skb->len);
2750 kfree_skb(conn->rx_skb);
2751 conn->rx_skb = NULL;
2752 conn->rx_len = 0;
2753 }
2754
2755 if (ts) {
2756 struct hci_iso_ts_data_hdr *hdr;
2757
2758 hdr = skb_pull_data(skb, HCI_ISO_TS_DATA_HDR_SIZE);
2759 if (!hdr) {
2760 BT_ERR("Frame is too short (len %d)", skb->len);
2761 goto drop;
2762 }
2763
2764 /* Record the timestamp to skb */
2765 hwts = skb_hwtstamps(skb);
2766 hwts->hwtstamp = us_to_ktime(le32_to_cpu(hdr->ts));
2767
2768 sn = __le16_to_cpu(hdr->sn);
2769 len = __le16_to_cpu(hdr->slen);
2770 } else {
2771 struct hci_iso_data_hdr *hdr;
2772
2773 hdr = skb_pull_data(skb, HCI_ISO_DATA_HDR_SIZE);
2774 if (!hdr) {
2775 BT_ERR("Frame is too short (len %d)", skb->len);
2776 goto drop;
2777 }
2778
2779 sn = __le16_to_cpu(hdr->sn);
2780 len = __le16_to_cpu(hdr->slen);
2781 }
2782
2783 flags = hci_iso_data_flags(len);
2784 len = hci_iso_data_len(len);
2785
2786 BT_DBG("Start: total len %d, frag len %d flags 0x%4.4x sn %d",
2787 len, skb->len, flags, sn);
2788
2789 if (len == skb->len) {
2790 /* Complete frame received */
2791 hci_skb_pkt_status(skb) = flags & 0x03;
2792 hci_skb_pkt_seqnum(skb) = sn;
2793 iso_recv_frame(conn, skb);
2794 goto done;
2795 }
2796
2797 if (pb == ISO_SINGLE) {
2798 BT_ERR("Frame malformed (len %d, expected len %d)",
2799 skb->len, len);
2800 goto drop;
2801 }
2802
2803 if (skb->len > len) {
2804 BT_ERR("Frame is too long (len %d, expected len %d)",
2805 skb->len, len);
2806 goto drop;
2807 }
2808
2809 /* Allocate skb for the complete frame (with header) */
2810 conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL);
2811 if (!conn->rx_skb)
2812 goto drop;
2813
2814 hci_skb_pkt_status(conn->rx_skb) = flags & 0x03;
2815 hci_skb_pkt_seqnum(conn->rx_skb) = sn;
2816 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2817 skb->len);
2818 conn->rx_len = len - skb->len;
2819
2820 /* Copy hw timestamp from skb to rx_skb if present */
2821 if (ts) {
2822 hwts = skb_hwtstamps(conn->rx_skb);
2823 hwts->hwtstamp = skb_hwtstamps(skb)->hwtstamp;
2824 }
2825
2826 break;
2827
2828 case ISO_CONT:
2829 case ISO_END:
2830 BT_DBG("%s: frag len %d (expecting %d)",
2831 (pb == ISO_END) ? "End" : "Cont", skb->len,
2832 conn->rx_len);
2833
2834 if (!conn->rx_skb) {
2835 BT_ERR("Unexpected ISO %s frame (len %d)",
2836 (pb == ISO_END) ? "End" : "Cont", skb->len);
2837 goto drop;
2838 }
2839
2840 if (skb->len > conn->rx_len) {
2841 BT_ERR("Fragment is too long (len %d, expected %d)",
2842 skb->len, conn->rx_len);
2843 kfree_skb(conn->rx_skb);
2844 conn->rx_skb = NULL;
2845 conn->rx_len = 0;
2846 goto drop;
2847 }
2848
2849 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2850 skb->len);
2851 conn->rx_len -= skb->len;
2852
2853 if (pb == ISO_CONT)
2854 break;
2855
2856 if (!conn->rx_len) {
2857 struct sk_buff *rx_skb = conn->rx_skb;
2858
2859 /* Complete frame received. iso_recv_frame
2860 * takes ownership of the skb so set the global
2861 * rx_skb pointer to NULL first.
2862 */
2863 conn->rx_skb = NULL;
2864 iso_recv_frame(conn, rx_skb);
2865 } else {
2866 BT_ERR("ISO fragment incomplete (len %d, expected %d)",
2867 skb->len, conn->rx_len);
2868 kfree_skb(conn->rx_skb);
2869 conn->rx_skb = NULL;
2870 conn->rx_len = 0;
2871 goto drop;
2872 }
2873 break;
2874 }
2875
2876drop:
2877 kfree_skb(skb);
2878done:
2879 iso_conn_put(conn);
2880 return 0;
2881}
2882
2883static struct hci_cb iso_cb = {
2884 .name = "ISO",
2885 .connect_cfm = iso_connect_cfm,
2886 .disconn_cfm = iso_disconn_cfm,
2887};
2888
2889static int iso_debugfs_show(struct seq_file *f, void *p)
2890{
2891 struct sock *sk;
2892
2893 read_lock(&iso_sk_list.lock);
2894
2895 sk_for_each(sk, &iso_sk_list.head) {
2896 seq_printf(f, "%pMR %pMR %d\n", &iso_pi(sk)->src,
2897 &iso_pi(sk)->dst, sk->sk_state);
2898 }
2899
2900 read_unlock(&iso_sk_list.lock);
2901
2902 return 0;
2903}
2904
2905DEFINE_SHOW_ATTRIBUTE(iso_debugfs);
2906
2907static struct dentry *iso_debugfs;
2908
2909static const struct proto_ops iso_sock_ops = {
2910 .family = PF_BLUETOOTH,
2911 .owner = THIS_MODULE,
2912 .release = iso_sock_release,
2913 .bind = iso_sock_bind,
2914 .connect = iso_sock_connect,
2915 .listen = iso_sock_listen,
2916 .accept = iso_sock_accept,
2917 .getname = iso_sock_getname,
2918 .sendmsg = iso_sock_sendmsg,
2919 .recvmsg = iso_sock_recvmsg,
2920 .poll = bt_sock_poll,
2921 .ioctl = bt_sock_ioctl,
2922 .mmap = sock_no_mmap,
2923 .socketpair = sock_no_socketpair,
2924 .shutdown = iso_sock_shutdown,
2925 .setsockopt = iso_sock_setsockopt,
2926 .getsockopt_iter = iso_sock_getsockopt
2927};
2928
2929static const struct net_proto_family iso_sock_family_ops = {
2930 .family = PF_BLUETOOTH,
2931 .owner = THIS_MODULE,
2932 .create = iso_sock_create,
2933};
2934
2935static bool inited;
2936
2937bool iso_inited(void)
2938{
2939 return inited;
2940}
2941
2942int iso_init(void)
2943{
2944 int err;
2945
2946 BUILD_BUG_ON(sizeof(struct sockaddr_iso) > sizeof(struct sockaddr));
2947
2948 if (inited)
2949 return -EALREADY;
2950
2951 err = proto_register(&iso_proto, 0);
2952 if (err < 0)
2953 return err;
2954
2955 err = bt_sock_register(BTPROTO_ISO, &iso_sock_family_ops);
2956 if (err < 0) {
2957 BT_ERR("ISO socket registration failed");
2958 goto error;
2959 }
2960
2961 err = bt_procfs_init(&init_net, "iso", &iso_sk_list, NULL);
2962 if (err < 0) {
2963 BT_ERR("Failed to create ISO proc file");
2964 bt_sock_unregister(BTPROTO_ISO);
2965 goto error;
2966 }
2967
2968 BT_INFO("ISO socket layer initialized");
2969
2970 hci_register_cb(&iso_cb);
2971
2972 if (!IS_ERR_OR_NULL(bt_debugfs))
2973 iso_debugfs = debugfs_create_file("iso", 0444, bt_debugfs,
2974 NULL, &iso_debugfs_fops);
2975
2976 inited = true;
2977
2978 return 0;
2979
2980error:
2981 proto_unregister(&iso_proto);
2982 return err;
2983}
2984
2985int iso_exit(void)
2986{
2987 if (!inited)
2988 return -EALREADY;
2989
2990 bt_procfs_cleanup(&init_net, "iso");
2991
2992 debugfs_remove(iso_debugfs);
2993 iso_debugfs = NULL;
2994
2995 hci_unregister_cb(&iso_cb);
2996
2997 bt_sock_unregister(BTPROTO_ISO);
2998
2999 proto_unregister(&iso_proto);
3000
3001 inited = false;
3002
3003 return 0;
3004}