1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23 */
25 /* Bluetooth SCO sockets. */
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <net/bluetooth/hci_core.h>
33 #include <net/bluetooth/sco.h>
35 static bool disable_esco;
37 static const struct proto_ops sco_sock_ops;
39 static struct bt_sock_list sco_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
41 };
43 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
44 static void sco_chan_del(struct sock *sk, int err);
46 static void sco_sock_close(struct sock *sk);
47 static void sco_sock_kill(struct sock *sk);
49 /* ---- SCO timers ---- */
50 static void sco_sock_timeout(unsigned long arg)
51 {
52 struct sock *sk = (struct sock *) arg;
54 BT_DBG("sock %p state %d", sk, sk->sk_state);
56 bh_lock_sock(sk);
57 sk->sk_err = ETIMEDOUT;
58 sk->sk_state_change(sk);
59 bh_unlock_sock(sk);
61 sco_sock_kill(sk);
62 sock_put(sk);
63 }
65 static 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 }
71 static 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 }
77 /* ---- SCO connections ---- */
78 static 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;
83 if (conn)
84 return conn;
86 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
87 if (!conn)
88 return NULL;
90 spin_lock_init(&conn->lock);
92 hcon->sco_data = conn;
93 conn->hcon = hcon;
95 conn->src = &hdev->bdaddr;
96 conn->dst = &hcon->dst;
98 if (hdev->sco_mtu > 0)
99 conn->mtu = hdev->sco_mtu;
100 else
101 conn->mtu = 60;
103 BT_DBG("hcon %p conn %p", hcon, conn);
105 return conn;
106 }
108 static 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 }
117 static int sco_conn_del(struct hci_conn *hcon, int err)
118 {
119 struct sco_conn *conn = hcon->sco_data;
120 struct sock *sk;
122 if (!conn)
123 return 0;
125 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
127 /* Kill socket */
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 }
137 hcon->sco_data = NULL;
138 kfree(conn);
139 return 0;
140 }
142 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
143 struct sock *parent)
144 {
145 int err = 0;
147 sco_conn_lock(conn);
148 if (conn->sk)
149 err = -EBUSY;
150 else
151 __sco_chan_add(conn, sk, parent);
153 sco_conn_unlock(conn);
154 return err;
155 }
157 static 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;
166 BT_DBG("%pMR -> %pMR", src, dst);
168 hdev = hci_get_route(dst, src);
169 if (!hdev)
170 return -EHOSTUNREACH;
172 hci_dev_lock(hdev);
174 if (lmp_esco_capable(hdev) && !disable_esco)
175 type = ESCO_LINK;
176 else
177 type = SCO_LINK;
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 }
186 conn = sco_conn_add(hcon);
187 if (!conn) {
188 hci_conn_put(hcon);
189 err = -ENOMEM;
190 goto done;
191 }
193 /* Update source addr of the socket */
194 bacpy(src, conn->src);
196 err = sco_chan_add(conn, sk, NULL);
197 if (err)
198 goto done;
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 }
208 done:
209 hci_dev_unlock(hdev);
210 hci_dev_put(hdev);
211 return err;
212 }
214 static 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;
220 /* Check outgoing MTU */
221 if (len > conn->mtu)
222 return -EINVAL;
224 BT_DBG("sk %p len %d", sk, len);
226 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
227 if (!skb)
228 return err;
230 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
231 kfree_skb(skb);
232 return -EFAULT;
233 }
235 hci_send_sco(conn->hcon, skb);
237 return len;
238 }
240 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
241 {
242 struct sock *sk = sco_chan_get(conn);
244 if (!sk)
245 goto drop;
247 BT_DBG("sk %p len %d", sk, skb->len);
249 if (sk->sk_state != BT_CONNECTED)
250 goto drop;
252 if (!sock_queue_rcv_skb(sk, skb))
253 return;
255 drop:
256 kfree_skb(skb);
257 }
259 /* -------- Socket interface ---------- */
260 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
261 {
262 struct hlist_node *node;
263 struct sock *sk;
265 sk_for_each(sk, node, &sco_sk_list.head) {
266 if (sk->sk_state != BT_LISTEN)
267 continue;
269 if (!bacmp(&bt_sk(sk)->src, ba))
270 return sk;
271 }
273 return NULL;
274 }
276 /* Find socket listening on source bdaddr.
277 * Returns closest match.
278 */
279 static struct sock *sco_get_sock_listen(bdaddr_t *src)
280 {
281 struct sock *sk = NULL, *sk1 = NULL;
282 struct hlist_node *node;
284 read_lock(&sco_sk_list.lock);
286 sk_for_each(sk, node, &sco_sk_list.head) {
287 if (sk->sk_state != BT_LISTEN)
288 continue;
290 /* Exact match. */
291 if (!bacmp(&bt_sk(sk)->src, src))
292 break;
294 /* Closest match */
295 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
296 sk1 = sk;
297 }
299 read_unlock(&sco_sk_list.lock);
301 return node ? sk : sk1;
302 }
304 static void sco_sock_destruct(struct sock *sk)
305 {
306 BT_DBG("sk %p", sk);
308 skb_queue_purge(&sk->sk_receive_queue);
309 skb_queue_purge(&sk->sk_write_queue);
310 }
312 static void sco_sock_cleanup_listen(struct sock *parent)
313 {
314 struct sock *sk;
316 BT_DBG("parent %p", parent);
318 /* Close not yet accepted channels */
319 while ((sk = bt_accept_dequeue(parent, NULL))) {
320 sco_sock_close(sk);
321 sco_sock_kill(sk);
322 }
324 parent->sk_state = BT_CLOSED;
325 sock_set_flag(parent, SOCK_ZAPPED);
326 }
328 /* Kill socket (only if zapped and orphan)
329 * Must be called on unlocked socket.
330 */
331 static void sco_sock_kill(struct sock *sk)
332 {
333 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
334 return;
336 BT_DBG("sk %p state %d", sk, sk->sk_state);
338 /* Kill poor orphan */
339 bt_sock_unlink(&sco_sk_list, sk);
340 sock_set_flag(sk, SOCK_DEAD);
341 sock_put(sk);
342 }
344 static void __sco_sock_close(struct sock *sk)
345 {
346 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
348 switch (sk->sk_state) {
349 case BT_LISTEN:
350 sco_sock_cleanup_listen(sk);
351 break;
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;
364 case BT_CONNECT2:
365 case BT_CONNECT:
366 case BT_DISCONN:
367 sco_chan_del(sk, ECONNRESET);
368 break;
370 default:
371 sock_set_flag(sk, SOCK_ZAPPED);
372 break;
373 }
374 }
376 /* Must be called on unlocked socket. */
377 static void sco_sock_close(struct sock *sk)
378 {
379 sco_sock_clear_timer(sk);
380 lock_sock(sk);
381 __sco_sock_close(sk);
382 release_sock(sk);
383 sco_sock_kill(sk);
384 }
386 static void sco_sock_init(struct sock *sk, struct sock *parent)
387 {
388 BT_DBG("sk %p", sk);
390 if (parent) {
391 sk->sk_type = parent->sk_type;
392 bt_sk(sk)->flags = bt_sk(parent)->flags;
393 security_sk_clone(parent, sk);
394 }
395 }
397 static struct proto sco_proto = {
398 .name = "SCO",
399 .owner = THIS_MODULE,
400 .obj_size = sizeof(struct sco_pinfo)
401 };
403 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
404 {
405 struct sock *sk;
407 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
408 if (!sk)
409 return NULL;
411 sock_init_data(sock, sk);
412 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
414 sk->sk_destruct = sco_sock_destruct;
415 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
417 sock_reset_flag(sk, SOCK_ZAPPED);
419 sk->sk_protocol = proto;
420 sk->sk_state = BT_OPEN;
422 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
424 bt_sock_link(&sco_sk_list, sk);
425 return sk;
426 }
428 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
429 int kern)
430 {
431 struct sock *sk;
433 BT_DBG("sock %p", sock);
435 sock->state = SS_UNCONNECTED;
437 if (sock->type != SOCK_SEQPACKET)
438 return -ESOCKTNOSUPPORT;
440 sock->ops = &sco_sock_ops;
442 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
443 if (!sk)
444 return -ENOMEM;
446 sco_sock_init(sk, NULL);
447 return 0;
448 }
450 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
451 {
452 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
453 struct sock *sk = sock->sk;
454 int err = 0;
456 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
458 if (!addr || addr->sa_family != AF_BLUETOOTH)
459 return -EINVAL;
461 lock_sock(sk);
463 if (sk->sk_state != BT_OPEN) {
464 err = -EBADFD;
465 goto done;
466 }
468 if (sk->sk_type != SOCK_SEQPACKET) {
469 err = -EINVAL;
470 goto done;
471 }
473 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
475 sk->sk_state = BT_BOUND;
477 done:
478 release_sock(sk);
479 return err;
480 }
482 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
483 {
484 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
485 struct sock *sk = sock->sk;
486 int err = 0;
489 BT_DBG("sk %p", sk);
491 if (alen < sizeof(struct sockaddr_sco) ||
492 addr->sa_family != AF_BLUETOOTH)
493 return -EINVAL;
495 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
496 return -EBADFD;
498 if (sk->sk_type != SOCK_SEQPACKET)
499 return -EINVAL;
501 lock_sock(sk);
503 /* Set destination address and psm */
504 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
506 err = sco_connect(sk);
507 if (err)
508 goto done;
510 err = bt_sock_wait_state(sk, BT_CONNECTED,
511 sock_sndtimeo(sk, flags & O_NONBLOCK));
513 done:
514 release_sock(sk);
515 return err;
516 }
518 static int sco_sock_listen(struct socket *sock, int backlog)
519 {
520 struct sock *sk = sock->sk;
521 bdaddr_t *src = &bt_sk(sk)->src;
522 int err = 0;
524 BT_DBG("sk %p backlog %d", sk, backlog);
526 lock_sock(sk);
528 if (sk->sk_state != BT_BOUND) {
529 err = -EBADFD;
530 goto done;
531 }
533 if (sk->sk_type != SOCK_SEQPACKET) {
534 err = -EINVAL;
535 goto done;
536 }
538 write_lock(&sco_sk_list.lock);
540 if (__sco_get_sock_listen_by_addr(src)) {
541 err = -EADDRINUSE;
542 goto unlock;
543 }
545 sk->sk_max_ack_backlog = backlog;
546 sk->sk_ack_backlog = 0;
548 sk->sk_state = BT_LISTEN;
550 unlock:
551 write_unlock(&sco_sk_list.lock);
553 done:
554 release_sock(sk);
555 return err;
556 }
558 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
559 {
560 DECLARE_WAITQUEUE(wait, current);
561 struct sock *sk = sock->sk, *ch;
562 long timeo;
563 int err = 0;
565 lock_sock(sk);
567 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
569 BT_DBG("sk %p timeo %ld", sk, timeo);
571 /* Wait for an incoming connection. (wake-one). */
572 add_wait_queue_exclusive(sk_sleep(sk), &wait);
573 while (1) {
574 set_current_state(TASK_INTERRUPTIBLE);
576 if (sk->sk_state != BT_LISTEN) {
577 err = -EBADFD;
578 break;
579 }
581 ch = bt_accept_dequeue(sk, newsock);
582 if (ch)
583 break;
585 if (!timeo) {
586 err = -EAGAIN;
587 break;
588 }
590 if (signal_pending(current)) {
591 err = sock_intr_errno(timeo);
592 break;
593 }
595 release_sock(sk);
596 timeo = schedule_timeout(timeo);
597 lock_sock(sk);
598 }
599 __set_current_state(TASK_RUNNING);
600 remove_wait_queue(sk_sleep(sk), &wait);
602 if (err)
603 goto done;
605 newsock->state = SS_CONNECTED;
607 BT_DBG("new socket %p", ch);
609 done:
610 release_sock(sk);
611 return err;
612 }
614 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
615 {
616 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
617 struct sock *sk = sock->sk;
619 BT_DBG("sock %p, sk %p", sock, sk);
621 addr->sa_family = AF_BLUETOOTH;
622 *len = sizeof(struct sockaddr_sco);
624 if (peer)
625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
626 else
627 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
629 return 0;
630 }
632 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
633 struct msghdr *msg, size_t len)
634 {
635 struct sock *sk = sock->sk;
636 int err;
638 BT_DBG("sock %p, sk %p", sock, sk);
640 err = sock_error(sk);
641 if (err)
642 return err;
644 if (msg->msg_flags & MSG_OOB)
645 return -EOPNOTSUPP;
647 lock_sock(sk);
649 if (sk->sk_state == BT_CONNECTED)
650 err = sco_send_frame(sk, msg, len);
651 else
652 err = -ENOTCONN;
654 release_sock(sk);
655 return err;
656 }
658 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
659 struct msghdr *msg, size_t len, int flags)
660 {
661 struct sock *sk = sock->sk;
662 struct sco_pinfo *pi = sco_pi(sk);
664 lock_sock(sk);
666 if (sk->sk_state == BT_CONNECT2 &&
667 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
668 hci_conn_accept(pi->conn->hcon, 0);
669 sk->sk_state = BT_CONFIG;
671 release_sock(sk);
672 return 0;
673 }
675 release_sock(sk);
677 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
678 }
680 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
681 {
682 struct sock *sk = sock->sk;
683 int err = 0;
684 u32 opt;
686 BT_DBG("sk %p", sk);
688 lock_sock(sk);
690 switch (optname) {
692 case BT_DEFER_SETUP:
693 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
694 err = -EINVAL;
695 break;
696 }
698 if (get_user(opt, (u32 __user *) optval)) {
699 err = -EFAULT;
700 break;
701 }
703 if (opt)
704 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
705 else
706 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
707 break;
709 default:
710 err = -ENOPROTOOPT;
711 break;
712 }
714 release_sock(sk);
715 return err;
716 }
718 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
719 {
720 struct sock *sk = sock->sk;
721 struct sco_options opts;
722 struct sco_conninfo cinfo;
723 int len, err = 0;
725 BT_DBG("sk %p", sk);
727 if (get_user(len, optlen))
728 return -EFAULT;
730 lock_sock(sk);
732 switch (optname) {
733 case SCO_OPTIONS:
734 if (sk->sk_state != BT_CONNECTED) {
735 err = -ENOTCONN;
736 break;
737 }
739 opts.mtu = sco_pi(sk)->conn->mtu;
741 BT_DBG("mtu %d", opts.mtu);
743 len = min_t(unsigned int, len, sizeof(opts));
744 if (copy_to_user(optval, (char *)&opts, len))
745 err = -EFAULT;
747 break;
749 case SCO_CONNINFO:
750 if (sk->sk_state != BT_CONNECTED) {
751 err = -ENOTCONN;
752 break;
753 }
755 memset(&cinfo, 0, sizeof(cinfo));
756 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
757 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
759 len = min_t(unsigned int, len, sizeof(cinfo));
760 if (copy_to_user(optval, (char *)&cinfo, len))
761 err = -EFAULT;
763 break;
765 default:
766 err = -ENOPROTOOPT;
767 break;
768 }
770 release_sock(sk);
771 return err;
772 }
774 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
775 {
776 struct sock *sk = sock->sk;
777 int len, err = 0;
779 BT_DBG("sk %p", sk);
781 if (level == SOL_SCO)
782 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
784 if (get_user(len, optlen))
785 return -EFAULT;
787 lock_sock(sk);
789 switch (optname) {
791 case BT_DEFER_SETUP:
792 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
793 err = -EINVAL;
794 break;
795 }
797 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
798 (u32 __user *) optval))
799 err = -EFAULT;
801 break;
803 default:
804 err = -ENOPROTOOPT;
805 break;
806 }
808 release_sock(sk);
809 return err;
810 }
812 static int sco_sock_shutdown(struct socket *sock, int how)
813 {
814 struct sock *sk = sock->sk;
815 int err = 0;
817 BT_DBG("sock %p, sk %p", sock, sk);
819 if (!sk)
820 return 0;
822 lock_sock(sk);
823 if (!sk->sk_shutdown) {
824 sk->sk_shutdown = SHUTDOWN_MASK;
825 sco_sock_clear_timer(sk);
826 __sco_sock_close(sk);
828 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
829 err = bt_sock_wait_state(sk, BT_CLOSED,
830 sk->sk_lingertime);
831 }
832 release_sock(sk);
833 return err;
834 }
836 static int sco_sock_release(struct socket *sock)
837 {
838 struct sock *sk = sock->sk;
839 int err = 0;
841 BT_DBG("sock %p, sk %p", sock, sk);
843 if (!sk)
844 return 0;
846 sco_sock_close(sk);
848 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
849 lock_sock(sk);
850 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
851 release_sock(sk);
852 }
854 sock_orphan(sk);
855 sco_sock_kill(sk);
856 return err;
857 }
859 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
860 {
861 BT_DBG("conn %p", conn);
863 sco_pi(sk)->conn = conn;
864 conn->sk = sk;
866 if (parent)
867 bt_accept_enqueue(parent, sk);
868 }
870 /* Delete channel.
871 * Must be called on the locked socket. */
872 static void sco_chan_del(struct sock *sk, int err)
873 {
874 struct sco_conn *conn;
876 conn = sco_pi(sk)->conn;
878 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
880 if (conn) {
881 sco_conn_lock(conn);
882 conn->sk = NULL;
883 sco_pi(sk)->conn = NULL;
884 sco_conn_unlock(conn);
886 if (conn->hcon)
887 hci_conn_put(conn->hcon);
888 }
890 sk->sk_state = BT_CLOSED;
891 sk->sk_err = err;
892 sk->sk_state_change(sk);
894 sock_set_flag(sk, SOCK_ZAPPED);
895 }
897 static void sco_conn_ready(struct sco_conn *conn)
898 {
899 struct sock *parent;
900 struct sock *sk = conn->sk;
902 BT_DBG("conn %p", conn);
904 if (sk) {
905 sco_sock_clear_timer(sk);
906 bh_lock_sock(sk);
907 sk->sk_state = BT_CONNECTED;
908 sk->sk_state_change(sk);
909 bh_unlock_sock(sk);
910 } else {
911 sco_conn_lock(conn);
913 parent = sco_get_sock_listen(conn->src);
914 if (!parent) {
915 sco_conn_unlock(conn);
916 return;
917 }
919 bh_lock_sock(parent);
921 sk = sco_sock_alloc(sock_net(parent), NULL,
922 BTPROTO_SCO, GFP_ATOMIC);
923 if (!sk) {
924 bh_unlock_sock(parent);
925 sco_conn_unlock(conn);
926 return;
927 }
929 sco_sock_init(sk, parent);
931 bacpy(&bt_sk(sk)->src, conn->src);
932 bacpy(&bt_sk(sk)->dst, conn->dst);
934 hci_conn_hold(conn->hcon);
935 __sco_chan_add(conn, sk, parent);
937 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
938 sk->sk_state = BT_CONNECT2;
939 else
940 sk->sk_state = BT_CONNECTED;
942 /* Wake up parent */
943 parent->sk_data_ready(parent, 1);
945 bh_unlock_sock(parent);
947 sco_conn_unlock(conn);
948 }
949 }
951 /* ----- SCO interface with lower layer (HCI) ----- */
952 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
953 {
954 struct sock *sk;
955 struct hlist_node *node;
956 int lm = 0;
958 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
960 /* Find listening sockets */
961 read_lock(&sco_sk_list.lock);
962 sk_for_each(sk, node, &sco_sk_list.head) {
963 if (sk->sk_state != BT_LISTEN)
964 continue;
966 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
967 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
968 lm |= HCI_LM_ACCEPT;
970 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
971 *flags |= HCI_PROTO_DEFER;
972 break;
973 }
974 }
975 read_unlock(&sco_sk_list.lock);
977 return lm;
978 }
980 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
981 {
982 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
983 if (!status) {
984 struct sco_conn *conn;
986 conn = sco_conn_add(hcon);
987 if (conn)
988 sco_conn_ready(conn);
989 } else
990 sco_conn_del(hcon, bt_to_errno(status));
991 }
993 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
994 {
995 BT_DBG("hcon %p reason %d", hcon, reason);
997 sco_conn_del(hcon, bt_to_errno(reason));
998 }
1000 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1001 {
1002 struct sco_conn *conn = hcon->sco_data;
1004 if (!conn)
1005 goto drop;
1007 BT_DBG("conn %p len %d", conn, skb->len);
1009 if (skb->len) {
1010 sco_recv_frame(conn, skb);
1011 return 0;
1012 }
1014 drop:
1015 kfree_skb(skb);
1016 return 0;
1017 }
1019 static int sco_debugfs_show(struct seq_file *f, void *p)
1020 {
1021 struct sock *sk;
1022 struct hlist_node *node;
1024 read_lock(&sco_sk_list.lock);
1026 sk_for_each(sk, node, &sco_sk_list.head) {
1027 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1028 &bt_sk(sk)->dst, sk->sk_state);
1029 }
1031 read_unlock(&sco_sk_list.lock);
1033 return 0;
1034 }
1036 static int sco_debugfs_open(struct inode *inode, struct file *file)
1037 {
1038 return single_open(file, sco_debugfs_show, inode->i_private);
1039 }
1041 static const struct file_operations sco_debugfs_fops = {
1042 .open = sco_debugfs_open,
1043 .read = seq_read,
1044 .llseek = seq_lseek,
1045 .release = single_release,
1046 };
1048 static struct dentry *sco_debugfs;
1050 static const struct proto_ops sco_sock_ops = {
1051 .family = PF_BLUETOOTH,
1052 .owner = THIS_MODULE,
1053 .release = sco_sock_release,
1054 .bind = sco_sock_bind,
1055 .connect = sco_sock_connect,
1056 .listen = sco_sock_listen,
1057 .accept = sco_sock_accept,
1058 .getname = sco_sock_getname,
1059 .sendmsg = sco_sock_sendmsg,
1060 .recvmsg = sco_sock_recvmsg,
1061 .poll = bt_sock_poll,
1062 .ioctl = bt_sock_ioctl,
1063 .mmap = sock_no_mmap,
1064 .socketpair = sock_no_socketpair,
1065 .shutdown = sco_sock_shutdown,
1066 .setsockopt = sco_sock_setsockopt,
1067 .getsockopt = sco_sock_getsockopt
1068 };
1070 static const struct net_proto_family sco_sock_family_ops = {
1071 .family = PF_BLUETOOTH,
1072 .owner = THIS_MODULE,
1073 .create = sco_sock_create,
1074 };
1076 int __init sco_init(void)
1077 {
1078 int err;
1080 err = proto_register(&sco_proto, 0);
1081 if (err < 0)
1082 return err;
1084 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1085 if (err < 0) {
1086 BT_ERR("SCO socket registration failed");
1087 goto error;
1088 }
1090 err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1091 if (err < 0) {
1092 BT_ERR("Failed to create SCO proc file");
1093 bt_sock_unregister(BTPROTO_SCO);
1094 goto error;
1095 }
1097 if (bt_debugfs) {
1098 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1099 NULL, &sco_debugfs_fops);
1100 if (!sco_debugfs)
1101 BT_ERR("Failed to create SCO debug file");
1102 }
1104 BT_INFO("SCO socket layer initialized");
1106 return 0;
1108 error:
1109 proto_unregister(&sco_proto);
1110 return err;
1111 }
1113 void __exit sco_exit(void)
1114 {
1115 bt_procfs_cleanup(&init_net, "sco");
1117 debugfs_remove(sco_debugfs);
1119 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1120 BT_ERR("SCO socket unregistration failed");
1122 proto_unregister(&sco_proto);
1123 }
1125 module_param(disable_esco, bool, 0644);
1126 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");