1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/module.h>
28#include <linux/debugfs.h>
29#include <linux/seq_file.h>
30
31#include <net/bluetooth/bluetooth.h>
32#include <net/bluetooth/hci_core.h>
33#include <net/bluetooth/sco.h>
34
35static bool disable_esco;
36
37static const struct proto_ops sco_sock_ops;
38
39static struct bt_sock_list sco_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
41};
42
43static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
44static void sco_chan_del(struct sock *sk, int err);
45
46static void sco_sock_close(struct sock *sk);
47static void sco_sock_kill(struct sock *sk);
48
49
50static void sco_sock_timeout(unsigned long arg)
51{
52 struct sock *sk = (struct sock *) arg;
53
54 BT_DBG("sock %p state %d", sk, sk->sk_state);
55
56 bh_lock_sock(sk);
57 sk->sk_err = ETIMEDOUT;
58 sk->sk_state_change(sk);
59 bh_unlock_sock(sk);
60
61 sco_sock_kill(sk);
62 sock_put(sk);
63}
64
65static void sco_sock_set_timer(struct sock *sk, long timeout)
66{
67 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
68 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
69}
70
71static void sco_sock_clear_timer(struct sock *sk)
72{
73 BT_DBG("sock %p state %d", sk, sk->sk_state);
74 sk_stop_timer(sk, &sk->sk_timer);
75}
76
77
78static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
79{
80 struct hci_dev *hdev = hcon->hdev;
81 struct sco_conn *conn = hcon->sco_data;
82
83 if (conn)
84 return conn;
85
86 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
87 if (!conn)
88 return NULL;
89
90 spin_lock_init(&conn->lock);
91
92 hcon->sco_data = conn;
93 conn->hcon = hcon;
94
95 conn->src = &hdev->bdaddr;
96 conn->dst = &hcon->dst;
97
98 if (hdev->sco_mtu > 0)
99 conn->mtu = hdev->sco_mtu;
100 else
101 conn->mtu = 60;
102
103 BT_DBG("hcon %p conn %p", hcon, conn);
104
105 return conn;
106}
107
108static struct sock *sco_chan_get(struct sco_conn *conn)
109{
110 struct sock *sk = NULL;
111 sco_conn_lock(conn);
112 sk = conn->sk;
113 sco_conn_unlock(conn);
114 return sk;
115}
116
117static int sco_conn_del(struct hci_conn *hcon, int err)
118{
119 struct sco_conn *conn = hcon->sco_data;
120 struct sock *sk;
121
122 if (!conn)
123 return 0;
124
125 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
126
127
128 sk = sco_chan_get(conn);
129 if (sk) {
130 bh_lock_sock(sk);
131 sco_sock_clear_timer(sk);
132 sco_chan_del(sk, err);
133 bh_unlock_sock(sk);
134 sco_sock_kill(sk);
135 }
136
137 hcon->sco_data = NULL;
138 kfree(conn);
139 return 0;
140}
141
142static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
143 struct sock *parent)
144{
145 int err = 0;
146
147 sco_conn_lock(conn);
148 if (conn->sk)
149 err = -EBUSY;
150 else
151 __sco_chan_add(conn, sk, parent);
152
153 sco_conn_unlock(conn);
154 return err;
155}
156
157static int sco_connect(struct sock *sk)
158{
159 bdaddr_t *src = &bt_sk(sk)->src;
160 bdaddr_t *dst = &bt_sk(sk)->dst;
161 struct sco_conn *conn;
162 struct hci_conn *hcon;
163 struct hci_dev *hdev;
164 int err, type;
165
166 BT_DBG("%pMR -> %pMR", src, dst);
167
168 hdev = hci_get_route(dst, src);
169 if (!hdev)
170 return -EHOSTUNREACH;
171
172 hci_dev_lock(hdev);
173
174 if (lmp_esco_capable(hdev) && !disable_esco)
175 type = ESCO_LINK;
176 else
177 type = SCO_LINK;
178
179 hcon = hci_connect(hdev, type, dst, BDADDR_BREDR, BT_SECURITY_LOW,
180 HCI_AT_NO_BONDING);
181 if (IS_ERR(hcon)) {
182 err = PTR_ERR(hcon);
183 goto done;
184 }
185
186 conn = sco_conn_add(hcon);
187 if (!conn) {
188 hci_conn_put(hcon);
189 err = -ENOMEM;
190 goto done;
191 }
192
193
194 bacpy(src, conn->src);
195
196 err = sco_chan_add(conn, sk, NULL);
197 if (err)
198 goto done;
199
200 if (hcon->state == BT_CONNECTED) {
201 sco_sock_clear_timer(sk);
202 sk->sk_state = BT_CONNECTED;
203 } else {
204 sk->sk_state = BT_CONNECT;
205 sco_sock_set_timer(sk, sk->sk_sndtimeo);
206 }
207
208done:
209 hci_dev_unlock(hdev);
210 hci_dev_put(hdev);
211 return err;
212}
213
214static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
215{
216 struct sco_conn *conn = sco_pi(sk)->conn;
217 struct sk_buff *skb;
218 int err;
219
220
221 if (len > conn->mtu)
222 return -EINVAL;
223
224 BT_DBG("sk %p len %d", sk, len);
225
226 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
227 if (!skb)
228 return err;
229
230 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
231 kfree_skb(skb);
232 return -EFAULT;
233 }
234
235 hci_send_sco(conn->hcon, skb);
236
237 return len;
238}
239
240static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
241{
242 struct sock *sk = sco_chan_get(conn);
243
244 if (!sk)
245 goto drop;
246
247 BT_DBG("sk %p len %d", sk, skb->len);
248
249 if (sk->sk_state != BT_CONNECTED)
250 goto drop;
251
252 if (!sock_queue_rcv_skb(sk, skb))
253 return;
254
255drop:
256 kfree_skb(skb);
257}
258
259
260static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
261{
262 struct hlist_node *node;
263 struct sock *sk;
264
265 sk_for_each(sk, node, &sco_sk_list.head) {
266 if (sk->sk_state != BT_LISTEN)
267 continue;
268
269 if (!bacmp(&bt_sk(sk)->src, ba))
270 return sk;
271 }
272
273 return NULL;
274}
275
276
277
278
279static struct sock *sco_get_sock_listen(bdaddr_t *src)
280{
281 struct sock *sk = NULL, *sk1 = NULL;
282 struct hlist_node *node;
283
284 read_lock(&sco_sk_list.lock);
285
286 sk_for_each(sk, node, &sco_sk_list.head) {
287 if (sk->sk_state != BT_LISTEN)
288 continue;
289
290
291 if (!bacmp(&bt_sk(sk)->src, src))
292 break;
293
294
295 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
296 sk1 = sk;
297 }
298
299 read_unlock(&sco_sk_list.lock);
300
301 return node ? sk : sk1;
302}
303
304static void sco_sock_destruct(struct sock *sk)
305{
306 BT_DBG("sk %p", sk);
307
308 skb_queue_purge(&sk->sk_receive_queue);
309 skb_queue_purge(&sk->sk_write_queue);
310}
311
312static void sco_sock_cleanup_listen(struct sock *parent)
313{
314 struct sock *sk;
315
316 BT_DBG("parent %p", parent);
317
318
319 while ((sk = bt_accept_dequeue(parent, NULL))) {
320 sco_sock_close(sk);
321 sco_sock_kill(sk);
322 }
323
324 parent->sk_state = BT_CLOSED;
325 sock_set_flag(parent, SOCK_ZAPPED);
326}
327
328
329
330
331static void sco_sock_kill(struct sock *sk)
332{
333 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
334 return;
335
336 BT_DBG("sk %p state %d", sk, sk->sk_state);
337
338
339 bt_sock_unlink(&sco_sk_list, sk);
340 sock_set_flag(sk, SOCK_DEAD);
341 sock_put(sk);
342}
343
344static void __sco_sock_close(struct sock *sk)
345{
346 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
347
348 switch (sk->sk_state) {
349 case BT_LISTEN:
350 sco_sock_cleanup_listen(sk);
351 break;
352
353 case BT_CONNECTED:
354 case BT_CONFIG:
355 if (sco_pi(sk)->conn->hcon) {
356 sk->sk_state = BT_DISCONN;
357 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
358 hci_conn_put(sco_pi(sk)->conn->hcon);
359 sco_pi(sk)->conn->hcon = NULL;
360 } else
361 sco_chan_del(sk, ECONNRESET);
362 break;
363
364 case BT_CONNECT:
365 case BT_DISCONN:
366 sco_chan_del(sk, ECONNRESET);
367 break;
368
369 default:
370 sock_set_flag(sk, SOCK_ZAPPED);
371 break;
372 }
373}
374
375
376static void sco_sock_close(struct sock *sk)
377{
378 sco_sock_clear_timer(sk);
379 lock_sock(sk);
380 __sco_sock_close(sk);
381 release_sock(sk);
382 sco_sock_kill(sk);
383}
384
385static void sco_sock_init(struct sock *sk, struct sock *parent)
386{
387 BT_DBG("sk %p", sk);
388
389 if (parent) {
390 sk->sk_type = parent->sk_type;
391 bt_sk(sk)->flags = bt_sk(parent)->flags;
392 security_sk_clone(parent, sk);
393 }
394}
395
396static struct proto sco_proto = {
397 .name = "SCO",
398 .owner = THIS_MODULE,
399 .obj_size = sizeof(struct sco_pinfo)
400};
401
402static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
403{
404 struct sock *sk;
405
406 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
407 if (!sk)
408 return NULL;
409
410 sock_init_data(sock, sk);
411 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
412
413 sk->sk_destruct = sco_sock_destruct;
414 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
415
416 sock_reset_flag(sk, SOCK_ZAPPED);
417
418 sk->sk_protocol = proto;
419 sk->sk_state = BT_OPEN;
420
421 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
422
423 bt_sock_link(&sco_sk_list, sk);
424 return sk;
425}
426
427static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
428 int kern)
429{
430 struct sock *sk;
431
432 BT_DBG("sock %p", sock);
433
434 sock->state = SS_UNCONNECTED;
435
436 if (sock->type != SOCK_SEQPACKET)
437 return -ESOCKTNOSUPPORT;
438
439 sock->ops = &sco_sock_ops;
440
441 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
442 if (!sk)
443 return -ENOMEM;
444
445 sco_sock_init(sk, NULL);
446 return 0;
447}
448
449static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
450{
451 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
452 struct sock *sk = sock->sk;
453 int err = 0;
454
455 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
456
457 if (!addr || addr->sa_family != AF_BLUETOOTH)
458 return -EINVAL;
459
460 lock_sock(sk);
461
462 if (sk->sk_state != BT_OPEN) {
463 err = -EBADFD;
464 goto done;
465 }
466
467 if (sk->sk_type != SOCK_SEQPACKET) {
468 err = -EINVAL;
469 goto done;
470 }
471
472 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
473
474 sk->sk_state = BT_BOUND;
475
476done:
477 release_sock(sk);
478 return err;
479}
480
481static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
482{
483 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
484 struct sock *sk = sock->sk;
485 int err = 0;
486
487
488 BT_DBG("sk %p", sk);
489
490 if (alen < sizeof(struct sockaddr_sco) ||
491 addr->sa_family != AF_BLUETOOTH)
492 return -EINVAL;
493
494 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
495 return -EBADFD;
496
497 if (sk->sk_type != SOCK_SEQPACKET)
498 return -EINVAL;
499
500 lock_sock(sk);
501
502
503 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
504
505 err = sco_connect(sk);
506 if (err)
507 goto done;
508
509 err = bt_sock_wait_state(sk, BT_CONNECTED,
510 sock_sndtimeo(sk, flags & O_NONBLOCK));
511
512done:
513 release_sock(sk);
514 return err;
515}
516
517static int sco_sock_listen(struct socket *sock, int backlog)
518{
519 struct sock *sk = sock->sk;
520 bdaddr_t *src = &bt_sk(sk)->src;
521 int err = 0;
522
523 BT_DBG("sk %p backlog %d", sk, backlog);
524
525 lock_sock(sk);
526
527 if (sk->sk_state != BT_BOUND) {
528 err = -EBADFD;
529 goto done;
530 }
531
532 if (sk->sk_type != SOCK_SEQPACKET) {
533 err = -EINVAL;
534 goto done;
535 }
536
537 write_lock(&sco_sk_list.lock);
538
539 if (__sco_get_sock_listen_by_addr(src)) {
540 err = -EADDRINUSE;
541 goto unlock;
542 }
543
544 sk->sk_max_ack_backlog = backlog;
545 sk->sk_ack_backlog = 0;
546
547 sk->sk_state = BT_LISTEN;
548
549unlock:
550 write_unlock(&sco_sk_list.lock);
551
552done:
553 release_sock(sk);
554 return err;
555}
556
557static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
558{
559 DECLARE_WAITQUEUE(wait, current);
560 struct sock *sk = sock->sk, *ch;
561 long timeo;
562 int err = 0;
563
564 lock_sock(sk);
565
566 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
567
568 BT_DBG("sk %p timeo %ld", sk, timeo);
569
570
571 add_wait_queue_exclusive(sk_sleep(sk), &wait);
572 while (1) {
573 set_current_state(TASK_INTERRUPTIBLE);
574
575 if (sk->sk_state != BT_LISTEN) {
576 err = -EBADFD;
577 break;
578 }
579
580 ch = bt_accept_dequeue(sk, newsock);
581 if (ch)
582 break;
583
584 if (!timeo) {
585 err = -EAGAIN;
586 break;
587 }
588
589 if (signal_pending(current)) {
590 err = sock_intr_errno(timeo);
591 break;
592 }
593
594 release_sock(sk);
595 timeo = schedule_timeout(timeo);
596 lock_sock(sk);
597 }
598 __set_current_state(TASK_RUNNING);
599 remove_wait_queue(sk_sleep(sk), &wait);
600
601 if (err)
602 goto done;
603
604 newsock->state = SS_CONNECTED;
605
606 BT_DBG("new socket %p", ch);
607
608done:
609 release_sock(sk);
610 return err;
611}
612
613static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
614{
615 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
616 struct sock *sk = sock->sk;
617
618 BT_DBG("sock %p, sk %p", sock, sk);
619
620 addr->sa_family = AF_BLUETOOTH;
621 *len = sizeof(struct sockaddr_sco);
622
623 if (peer)
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
625 else
626 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
627
628 return 0;
629}
630
631static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
632 struct msghdr *msg, size_t len)
633{
634 struct sock *sk = sock->sk;
635 int err;
636
637 BT_DBG("sock %p, sk %p", sock, sk);
638
639 err = sock_error(sk);
640 if (err)
641 return err;
642
643 if (msg->msg_flags & MSG_OOB)
644 return -EOPNOTSUPP;
645
646 lock_sock(sk);
647
648 if (sk->sk_state == BT_CONNECTED)
649 err = sco_send_frame(sk, msg, len);
650 else
651 err = -ENOTCONN;
652
653 release_sock(sk);
654 return err;
655}
656
657static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
658 struct msghdr *msg, size_t len, int flags)
659{
660 struct sock *sk = sock->sk;
661 struct sco_pinfo *pi = sco_pi(sk);
662
663 lock_sock(sk);
664
665 if (sk->sk_state == BT_CONNECT2 &&
666 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
667 hci_conn_accept(pi->conn->hcon, 0);
668 sk->sk_state = BT_CONFIG;
669
670 release_sock(sk);
671 return 0;
672 }
673
674 release_sock(sk);
675
676 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
677}
678
679static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
680{
681 struct sock *sk = sock->sk;
682 int err = 0;
683 u32 opt;
684
685 BT_DBG("sk %p", sk);
686
687 lock_sock(sk);
688
689 switch (optname) {
690
691 case BT_DEFER_SETUP:
692 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
693 err = -EINVAL;
694 break;
695 }
696
697 if (get_user(opt, (u32 __user *) optval)) {
698 err = -EFAULT;
699 break;
700 }
701
702 if (opt)
703 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
704 else
705 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
706 break;
707
708 default:
709 err = -ENOPROTOOPT;
710 break;
711 }
712
713 release_sock(sk);
714 return err;
715}
716
717static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
718{
719 struct sock *sk = sock->sk;
720 struct sco_options opts;
721 struct sco_conninfo cinfo;
722 int len, err = 0;
723
724 BT_DBG("sk %p", sk);
725
726 if (get_user(len, optlen))
727 return -EFAULT;
728
729 lock_sock(sk);
730
731 switch (optname) {
732 case SCO_OPTIONS:
733 if (sk->sk_state != BT_CONNECTED) {
734 err = -ENOTCONN;
735 break;
736 }
737
738 opts.mtu = sco_pi(sk)->conn->mtu;
739
740 BT_DBG("mtu %d", opts.mtu);
741
742 len = min_t(unsigned int, len, sizeof(opts));
743 if (copy_to_user(optval, (char *)&opts, len))
744 err = -EFAULT;
745
746 break;
747
748 case SCO_CONNINFO:
749 if (sk->sk_state != BT_CONNECTED) {
750 err = -ENOTCONN;
751 break;
752 }
753
754 memset(&cinfo, 0, sizeof(cinfo));
755 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
756 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
757
758 len = min_t(unsigned int, len, sizeof(cinfo));
759 if (copy_to_user(optval, (char *)&cinfo, len))
760 err = -EFAULT;
761
762 break;
763
764 default:
765 err = -ENOPROTOOPT;
766 break;
767 }
768
769 release_sock(sk);
770 return err;
771}
772
773static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
774{
775 struct sock *sk = sock->sk;
776 int len, err = 0;
777
778 BT_DBG("sk %p", sk);
779
780 if (level == SOL_SCO)
781 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
782
783 if (get_user(len, optlen))
784 return -EFAULT;
785
786 lock_sock(sk);
787
788 switch (optname) {
789
790 case BT_DEFER_SETUP:
791 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
792 err = -EINVAL;
793 break;
794 }
795
796 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
797 (u32 __user *) optval))
798 err = -EFAULT;
799
800 break;
801
802 default:
803 err = -ENOPROTOOPT;
804 break;
805 }
806
807 release_sock(sk);
808 return err;
809}
810
811static int sco_sock_shutdown(struct socket *sock, int how)
812{
813 struct sock *sk = sock->sk;
814 int err = 0;
815
816 BT_DBG("sock %p, sk %p", sock, sk);
817
818 if (!sk)
819 return 0;
820
821 lock_sock(sk);
822 if (!sk->sk_shutdown) {
823 sk->sk_shutdown = SHUTDOWN_MASK;
824 sco_sock_clear_timer(sk);
825 __sco_sock_close(sk);
826
827 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
828 err = bt_sock_wait_state(sk, BT_CLOSED,
829 sk->sk_lingertime);
830 }
831 release_sock(sk);
832 return err;
833}
834
835static int sco_sock_release(struct socket *sock)
836{
837 struct sock *sk = sock->sk;
838 int err = 0;
839
840 BT_DBG("sock %p, sk %p", sock, sk);
841
842 if (!sk)
843 return 0;
844
845 sco_sock_close(sk);
846
847 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
848 lock_sock(sk);
849 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
850 release_sock(sk);
851 }
852
853 sock_orphan(sk);
854 sco_sock_kill(sk);
855 return err;
856}
857
858static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
859{
860 BT_DBG("conn %p", conn);
861
862 sco_pi(sk)->conn = conn;
863 conn->sk = sk;
864
865 if (parent)
866 bt_accept_enqueue(parent, sk);
867}
868
869
870
871static void sco_chan_del(struct sock *sk, int err)
872{
873 struct sco_conn *conn;
874
875 conn = sco_pi(sk)->conn;
876
877 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
878
879 if (conn) {
880 sco_conn_lock(conn);
881 conn->sk = NULL;
882 sco_pi(sk)->conn = NULL;
883 sco_conn_unlock(conn);
884
885 if (conn->hcon)
886 hci_conn_put(conn->hcon);
887 }
888
889 sk->sk_state = BT_CLOSED;
890 sk->sk_err = err;
891 sk->sk_state_change(sk);
892
893 sock_set_flag(sk, SOCK_ZAPPED);
894}
895
896static void sco_conn_ready(struct sco_conn *conn)
897{
898 struct sock *parent;
899 struct sock *sk = conn->sk;
900
901 BT_DBG("conn %p", conn);
902
903 sco_conn_lock(conn);
904
905 if (sk) {
906 sco_sock_clear_timer(sk);
907 bh_lock_sock(sk);
908 sk->sk_state = BT_CONNECTED;
909 sk->sk_state_change(sk);
910 bh_unlock_sock(sk);
911 } else {
912 parent = sco_get_sock_listen(conn->src);
913 if (!parent)
914 goto done;
915
916 bh_lock_sock(parent);
917
918 sk = sco_sock_alloc(sock_net(parent), NULL,
919 BTPROTO_SCO, GFP_ATOMIC);
920 if (!sk) {
921 bh_unlock_sock(parent);
922 goto done;
923 }
924
925 sco_sock_init(sk, parent);
926
927 bacpy(&bt_sk(sk)->src, conn->src);
928 bacpy(&bt_sk(sk)->dst, conn->dst);
929
930 hci_conn_hold(conn->hcon);
931 __sco_chan_add(conn, sk, parent);
932
933 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
934 sk->sk_state = BT_CONNECT2;
935 else
936 sk->sk_state = BT_CONNECTED;
937
938
939 parent->sk_data_ready(parent, 1);
940
941 bh_unlock_sock(parent);
942 }
943
944done:
945 sco_conn_unlock(conn);
946}
947
948
949int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
950{
951 struct sock *sk;
952 struct hlist_node *node;
953 int lm = 0;
954
955 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
956
957
958 read_lock(&sco_sk_list.lock);
959 sk_for_each(sk, node, &sco_sk_list.head) {
960 if (sk->sk_state != BT_LISTEN)
961 continue;
962
963 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
964 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
965 lm |= HCI_LM_ACCEPT;
966
967 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
968 *flags |= HCI_PROTO_DEFER;
969 break;
970 }
971 }
972 read_unlock(&sco_sk_list.lock);
973
974 return lm;
975}
976
977void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
978{
979 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
980 if (!status) {
981 struct sco_conn *conn;
982
983 conn = sco_conn_add(hcon);
984 if (conn)
985 sco_conn_ready(conn);
986 } else
987 sco_conn_del(hcon, bt_to_errno(status));
988}
989
990void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
991{
992 BT_DBG("hcon %p reason %d", hcon, reason);
993
994 sco_conn_del(hcon, bt_to_errno(reason));
995}
996
997int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
998{
999 struct sco_conn *conn = hcon->sco_data;
1000
1001 if (!conn)
1002 goto drop;
1003
1004 BT_DBG("conn %p len %d", conn, skb->len);
1005
1006 if (skb->len) {
1007 sco_recv_frame(conn, skb);
1008 return 0;
1009 }
1010
1011drop:
1012 kfree_skb(skb);
1013 return 0;
1014}
1015
1016static int sco_debugfs_show(struct seq_file *f, void *p)
1017{
1018 struct sock *sk;
1019 struct hlist_node *node;
1020
1021 read_lock(&sco_sk_list.lock);
1022
1023 sk_for_each(sk, node, &sco_sk_list.head) {
1024 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1025 &bt_sk(sk)->dst, sk->sk_state);
1026 }
1027
1028 read_unlock(&sco_sk_list.lock);
1029
1030 return 0;
1031}
1032
1033static int sco_debugfs_open(struct inode *inode, struct file *file)
1034{
1035 return single_open(file, sco_debugfs_show, inode->i_private);
1036}
1037
1038static const struct file_operations sco_debugfs_fops = {
1039 .open = sco_debugfs_open,
1040 .read = seq_read,
1041 .llseek = seq_lseek,
1042 .release = single_release,
1043};
1044
1045static struct dentry *sco_debugfs;
1046
1047static const struct proto_ops sco_sock_ops = {
1048 .family = PF_BLUETOOTH,
1049 .owner = THIS_MODULE,
1050 .release = sco_sock_release,
1051 .bind = sco_sock_bind,
1052 .connect = sco_sock_connect,
1053 .listen = sco_sock_listen,
1054 .accept = sco_sock_accept,
1055 .getname = sco_sock_getname,
1056 .sendmsg = sco_sock_sendmsg,
1057 .recvmsg = sco_sock_recvmsg,
1058 .poll = bt_sock_poll,
1059 .ioctl = bt_sock_ioctl,
1060 .mmap = sock_no_mmap,
1061 .socketpair = sock_no_socketpair,
1062 .shutdown = sco_sock_shutdown,
1063 .setsockopt = sco_sock_setsockopt,
1064 .getsockopt = sco_sock_getsockopt
1065};
1066
1067static const struct net_proto_family sco_sock_family_ops = {
1068 .family = PF_BLUETOOTH,
1069 .owner = THIS_MODULE,
1070 .create = sco_sock_create,
1071};
1072
1073int __init sco_init(void)
1074{
1075 int err;
1076
1077 err = proto_register(&sco_proto, 0);
1078 if (err < 0)
1079 return err;
1080
1081 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1082 if (err < 0) {
1083 BT_ERR("SCO socket registration failed");
1084 goto error;
1085 }
1086
1087 err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1088 if (err < 0) {
1089 BT_ERR("Failed to create SCO proc file");
1090 bt_sock_unregister(BTPROTO_SCO);
1091 goto error;
1092 }
1093
1094 if (bt_debugfs) {
1095 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1096 NULL, &sco_debugfs_fops);
1097 if (!sco_debugfs)
1098 BT_ERR("Failed to create SCO debug file");
1099 }
1100
1101 BT_INFO("SCO socket layer initialized");
1102
1103 return 0;
1104
1105error:
1106 proto_unregister(&sco_proto);
1107 return err;
1108}
1109
1110void __exit sco_exit(void)
1111{
1112 bt_procfs_cleanup(&init_net, "sco");
1113
1114 debugfs_remove(sco_debugfs);
1115
1116 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1117 BT_ERR("SCO socket unregistration failed");
1118
1119 proto_unregister(&sco_proto);
1120}
1121
1122module_param(disable_esco, bool, 0644);
1123MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1124
