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 __u16 pkt_type = sco_pi(sk)->pkt_type;
162 struct sco_conn *conn;
163 struct hci_conn *hcon;
164 struct hci_dev *hdev;
165 int err, type;
167 BT_DBG("%pMR -> %pMR", src, dst);
169 hdev = hci_get_route(dst, src);
170 if (!hdev)
171 return -EHOSTUNREACH;
173 hci_dev_lock(hdev);
175 if (lmp_esco_capable(hdev) && !disable_esco)
176 type = ESCO_LINK;
177 else {
178 type = SCO_LINK;
179 pkt_type &= SCO_ESCO_MASK;
180 }
182 hcon = hci_connect(hdev, type, pkt_type, dst, BDADDR_BREDR,
183 BT_SECURITY_LOW, HCI_AT_NO_BONDING);
184 if (IS_ERR(hcon)) {
185 err = PTR_ERR(hcon);
186 goto done;
187 }
189 conn = sco_conn_add(hcon);
190 if (!conn) {
191 hci_conn_put(hcon);
192 err = -ENOMEM;
193 goto done;
194 }
196 /* Update source addr of the socket */
197 bacpy(src, conn->src);
199 err = sco_chan_add(conn, sk, NULL);
200 if (err)
201 goto done;
203 if (hcon->state == BT_CONNECTED) {
204 sco_sock_clear_timer(sk);
205 sk->sk_state = BT_CONNECTED;
206 } else {
207 sk->sk_state = BT_CONNECT;
208 sco_sock_set_timer(sk, sk->sk_sndtimeo);
209 }
211 done:
212 hci_dev_unlock(hdev);
213 hci_dev_put(hdev);
214 return err;
215 }
217 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
218 {
219 struct sco_conn *conn = sco_pi(sk)->conn;
220 struct sk_buff *skb;
221 int err;
223 /* Check outgoing MTU */
224 if (len > conn->mtu)
225 return -EINVAL;
227 BT_DBG("sk %p len %d", sk, len);
229 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
230 if (!skb)
231 return err;
233 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
234 kfree_skb(skb);
235 return -EFAULT;
236 }
238 hci_send_sco(conn->hcon, skb);
240 return len;
241 }
243 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
244 {
245 struct sock *sk = sco_chan_get(conn);
247 if (!sk)
248 goto drop;
250 BT_DBG("sk %p len %d", sk, skb->len);
252 if (sk->sk_state != BT_CONNECTED)
253 goto drop;
255 if (!sock_queue_rcv_skb(sk, skb))
256 return;
258 drop:
259 kfree_skb(skb);
260 }
262 /* -------- Socket interface ---------- */
263 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
264 {
265 struct hlist_node *node;
266 struct sock *sk;
268 sk_for_each(sk, node, &sco_sk_list.head) {
269 if (sk->sk_state != BT_LISTEN)
270 continue;
272 if (!bacmp(&bt_sk(sk)->src, ba))
273 return sk;
274 }
276 return NULL;
277 }
279 /* Find socket listening on source bdaddr.
280 * Returns closest match.
281 */
282 static struct sock *sco_get_sock_listen(bdaddr_t *src)
283 {
284 struct sock *sk = NULL, *sk1 = NULL;
285 struct hlist_node *node;
287 read_lock(&sco_sk_list.lock);
289 sk_for_each(sk, node, &sco_sk_list.head) {
290 if (sk->sk_state != BT_LISTEN)
291 continue;
293 /* Exact match. */
294 if (!bacmp(&bt_sk(sk)->src, src))
295 break;
297 /* Closest match */
298 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
299 sk1 = sk;
300 }
302 read_unlock(&sco_sk_list.lock);
304 return node ? sk : sk1;
305 }
307 static void sco_sock_destruct(struct sock *sk)
308 {
309 BT_DBG("sk %p", sk);
311 skb_queue_purge(&sk->sk_receive_queue);
312 skb_queue_purge(&sk->sk_write_queue);
313 }
315 static void sco_sock_cleanup_listen(struct sock *parent)
316 {
317 struct sock *sk;
319 BT_DBG("parent %p", parent);
321 /* Close not yet accepted channels */
322 while ((sk = bt_accept_dequeue(parent, NULL))) {
323 sco_sock_close(sk);
324 sco_sock_kill(sk);
325 }
327 parent->sk_state = BT_CLOSED;
328 sock_set_flag(parent, SOCK_ZAPPED);
329 }
331 /* Kill socket (only if zapped and orphan)
332 * Must be called on unlocked socket.
333 */
334 static void sco_sock_kill(struct sock *sk)
335 {
336 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
337 return;
339 BT_DBG("sk %p state %d", sk, sk->sk_state);
341 /* Kill poor orphan */
342 bt_sock_unlink(&sco_sk_list, sk);
343 sock_set_flag(sk, SOCK_DEAD);
344 sock_put(sk);
345 }
347 static void __sco_sock_close(struct sock *sk)
348 {
349 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
351 switch (sk->sk_state) {
352 case BT_LISTEN:
353 sco_sock_cleanup_listen(sk);
354 break;
356 case BT_CONNECTED:
357 case BT_CONFIG:
358 if (sco_pi(sk)->conn->hcon) {
359 sk->sk_state = BT_DISCONN;
360 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
361 hci_conn_put(sco_pi(sk)->conn->hcon);
362 sco_pi(sk)->conn->hcon = NULL;
363 } else
364 sco_chan_del(sk, ECONNRESET);
365 break;
367 case BT_CONNECT2:
368 case BT_CONNECT:
369 case BT_DISCONN:
370 sco_chan_del(sk, ECONNRESET);
371 break;
373 default:
374 sock_set_flag(sk, SOCK_ZAPPED);
375 break;
376 }
377 }
379 /* Must be called on unlocked socket. */
380 static void sco_sock_close(struct sock *sk)
381 {
382 sco_sock_clear_timer(sk);
383 lock_sock(sk);
384 __sco_sock_close(sk);
385 release_sock(sk);
386 sco_sock_kill(sk);
387 }
389 static void sco_sock_init(struct sock *sk, struct sock *parent)
390 {
391 BT_DBG("sk %p", sk);
393 if (parent) {
394 sk->sk_type = parent->sk_type;
395 bt_sk(sk)->flags = bt_sk(parent)->flags;
396 security_sk_clone(parent, sk);
397 }
398 }
400 static struct proto sco_proto = {
401 .name = "SCO",
402 .owner = THIS_MODULE,
403 .obj_size = sizeof(struct sco_pinfo)
404 };
406 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
407 {
408 struct sock *sk;
410 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
411 if (!sk)
412 return NULL;
414 sock_init_data(sock, sk);
415 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
417 sk->sk_destruct = sco_sock_destruct;
418 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
420 sock_reset_flag(sk, SOCK_ZAPPED);
422 sk->sk_protocol = proto;
423 sk->sk_state = BT_OPEN;
425 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
427 bt_sock_link(&sco_sk_list, sk);
428 return sk;
429 }
431 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
432 int kern)
433 {
434 struct sock *sk;
436 BT_DBG("sock %p", sock);
438 sock->state = SS_UNCONNECTED;
440 if (sock->type != SOCK_SEQPACKET)
441 return -ESOCKTNOSUPPORT;
443 sock->ops = &sco_sock_ops;
445 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
446 if (!sk)
447 return -ENOMEM;
449 sco_sock_init(sk, NULL);
450 return 0;
451 }
453 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
454 {
455 struct sockaddr_sco sa;
456 struct sock *sk = sock->sk;
457 int len, err = 0;
459 BT_DBG("sk %p %pMR", sk, &sa.sco_bdaddr);
461 if (!addr || addr->sa_family != AF_BLUETOOTH)
462 return -EINVAL;
464 memset(&sa, 0, sizeof(sa));
465 len = min_t(unsigned int, sizeof(sa), alen);
466 memcpy(&sa, addr, len);
468 lock_sock(sk);
470 if (sk->sk_state != BT_OPEN) {
471 err = -EBADFD;
472 goto done;
473 }
475 if (sk->sk_type != SOCK_SEQPACKET) {
476 err = -EINVAL;
477 goto done;
478 }
480 bacpy(&bt_sk(sk)->src, &sa.sco_bdaddr);
481 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
483 sk->sk_state = BT_BOUND;
485 done:
486 release_sock(sk);
487 return err;
488 }
490 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
491 {
492 struct sock *sk = sock->sk;
493 struct sockaddr_sco sa;
494 int len, err = 0;
496 BT_DBG("sk %p", sk);
498 if (!addr || addr->sa_family != AF_BLUETOOTH)
499 return -EINVAL;
501 memset(&sa, 0, sizeof(sa));
502 len = min_t(unsigned int, sizeof(sa), alen);
503 memcpy(&sa, addr, len);
505 lock_sock(sk);
507 if (sk->sk_type != SOCK_SEQPACKET) {
508 err = -EINVAL;
509 goto done;
510 }
512 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
513 err = -EBADFD;
514 goto done;
515 }
517 /* Set destination address and psm */
518 bacpy(&bt_sk(sk)->dst, &sa.sco_bdaddr);
519 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
521 err = sco_connect(sk);
522 if (err)
523 goto done;
525 err = bt_sock_wait_state(sk, BT_CONNECTED,
526 sock_sndtimeo(sk, flags & O_NONBLOCK));
528 done:
529 release_sock(sk);
530 return err;
531 }
533 static int sco_sock_listen(struct socket *sock, int backlog)
534 {
535 struct sock *sk = sock->sk;
536 bdaddr_t *src = &bt_sk(sk)->src;
537 int err = 0;
539 BT_DBG("sk %p backlog %d", sk, backlog);
541 lock_sock(sk);
543 if (sk->sk_state != BT_BOUND) {
544 err = -EBADFD;
545 goto done;
546 }
548 if (sk->sk_type != SOCK_SEQPACKET) {
549 err = -EINVAL;
550 goto done;
551 }
553 write_lock(&sco_sk_list.lock);
555 if (__sco_get_sock_listen_by_addr(src)) {
556 err = -EADDRINUSE;
557 goto unlock;
558 }
560 sk->sk_max_ack_backlog = backlog;
561 sk->sk_ack_backlog = 0;
563 sk->sk_state = BT_LISTEN;
565 unlock:
566 write_unlock(&sco_sk_list.lock);
568 done:
569 release_sock(sk);
570 return err;
571 }
573 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
574 {
575 DECLARE_WAITQUEUE(wait, current);
576 struct sock *sk = sock->sk, *ch;
577 long timeo;
578 int err = 0;
580 lock_sock(sk);
582 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
584 BT_DBG("sk %p timeo %ld", sk, timeo);
586 /* Wait for an incoming connection. (wake-one). */
587 add_wait_queue_exclusive(sk_sleep(sk), &wait);
588 while (1) {
589 set_current_state(TASK_INTERRUPTIBLE);
591 if (sk->sk_state != BT_LISTEN) {
592 err = -EBADFD;
593 break;
594 }
596 ch = bt_accept_dequeue(sk, newsock);
597 if (ch)
598 break;
600 if (!timeo) {
601 err = -EAGAIN;
602 break;
603 }
605 if (signal_pending(current)) {
606 err = sock_intr_errno(timeo);
607 break;
608 }
610 release_sock(sk);
611 timeo = schedule_timeout(timeo);
612 lock_sock(sk);
613 }
614 __set_current_state(TASK_RUNNING);
615 remove_wait_queue(sk_sleep(sk), &wait);
617 if (err)
618 goto done;
620 newsock->state = SS_CONNECTED;
622 BT_DBG("new socket %p", ch);
624 done:
625 release_sock(sk);
626 return err;
627 }
629 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
630 {
631 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
632 struct sock *sk = sock->sk;
634 BT_DBG("sock %p, sk %p", sock, sk);
636 addr->sa_family = AF_BLUETOOTH;
637 *len = sizeof(struct sockaddr_sco);
639 if (peer)
640 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
641 else
642 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
643 sa->sco_pkt_type = sco_pi(sk)->pkt_type;
645 return 0;
646 }
648 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
649 struct msghdr *msg, size_t len)
650 {
651 struct sock *sk = sock->sk;
652 int err;
654 BT_DBG("sock %p, sk %p", sock, sk);
656 err = sock_error(sk);
657 if (err)
658 return err;
660 if (msg->msg_flags & MSG_OOB)
661 return -EOPNOTSUPP;
663 lock_sock(sk);
665 if (sk->sk_state == BT_CONNECTED)
666 err = sco_send_frame(sk, msg, len);
667 else
668 err = -ENOTCONN;
670 release_sock(sk);
671 return err;
672 }
674 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
675 struct msghdr *msg, size_t len, int flags)
676 {
677 struct sock *sk = sock->sk;
678 struct sco_pinfo *pi = sco_pi(sk);
680 lock_sock(sk);
682 if (sk->sk_state == BT_CONNECT2 &&
683 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
684 hci_conn_accept(pi->conn->hcon, 0);
685 sk->sk_state = BT_CONFIG;
687 release_sock(sk);
688 return 0;
689 }
691 release_sock(sk);
693 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
694 }
696 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
697 {
698 struct sock *sk = sock->sk;
699 int err = 0;
700 u32 opt;
702 BT_DBG("sk %p", sk);
704 lock_sock(sk);
706 switch (optname) {
708 case BT_DEFER_SETUP:
709 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
710 err = -EINVAL;
711 break;
712 }
714 if (get_user(opt, (u32 __user *) optval)) {
715 err = -EFAULT;
716 break;
717 }
719 if (opt)
720 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
721 else
722 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
723 break;
725 default:
726 err = -ENOPROTOOPT;
727 break;
728 }
730 release_sock(sk);
731 return err;
732 }
734 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
735 {
736 struct sock *sk = sock->sk;
737 struct sco_options opts;
738 struct sco_conninfo cinfo;
739 int len, err = 0;
741 BT_DBG("sk %p", sk);
743 if (get_user(len, optlen))
744 return -EFAULT;
746 lock_sock(sk);
748 switch (optname) {
749 case SCO_OPTIONS:
750 if (sk->sk_state != BT_CONNECTED) {
751 err = -ENOTCONN;
752 break;
753 }
755 opts.mtu = sco_pi(sk)->conn->mtu;
757 BT_DBG("mtu %d", opts.mtu);
759 len = min_t(unsigned int, len, sizeof(opts));
760 if (copy_to_user(optval, (char *)&opts, len))
761 err = -EFAULT;
763 break;
765 case SCO_CONNINFO:
766 if (sk->sk_state != BT_CONNECTED) {
767 err = -ENOTCONN;
768 break;
769 }
771 memset(&cinfo, 0, sizeof(cinfo));
772 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
773 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
775 len = min_t(unsigned int, len, sizeof(cinfo));
776 if (copy_to_user(optval, (char *)&cinfo, len))
777 err = -EFAULT;
779 break;
781 default:
782 err = -ENOPROTOOPT;
783 break;
784 }
786 release_sock(sk);
787 return err;
788 }
790 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
791 {
792 struct sock *sk = sock->sk;
793 int len, err = 0;
795 BT_DBG("sk %p", sk);
797 if (level == SOL_SCO)
798 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
800 if (get_user(len, optlen))
801 return -EFAULT;
803 lock_sock(sk);
805 switch (optname) {
807 case BT_DEFER_SETUP:
808 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
809 err = -EINVAL;
810 break;
811 }
813 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
814 (u32 __user *) optval))
815 err = -EFAULT;
817 break;
819 default:
820 err = -ENOPROTOOPT;
821 break;
822 }
824 release_sock(sk);
825 return err;
826 }
828 static int sco_sock_shutdown(struct socket *sock, int how)
829 {
830 struct sock *sk = sock->sk;
831 int err = 0;
833 BT_DBG("sock %p, sk %p", sock, sk);
835 if (!sk)
836 return 0;
838 lock_sock(sk);
839 if (!sk->sk_shutdown) {
840 sk->sk_shutdown = SHUTDOWN_MASK;
841 sco_sock_clear_timer(sk);
842 __sco_sock_close(sk);
844 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
845 err = bt_sock_wait_state(sk, BT_CLOSED,
846 sk->sk_lingertime);
847 }
848 release_sock(sk);
849 return err;
850 }
852 static int sco_sock_release(struct socket *sock)
853 {
854 struct sock *sk = sock->sk;
855 int err = 0;
857 BT_DBG("sock %p, sk %p", sock, sk);
859 if (!sk)
860 return 0;
862 sco_sock_close(sk);
864 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
865 lock_sock(sk);
866 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
867 release_sock(sk);
868 }
870 sock_orphan(sk);
871 sco_sock_kill(sk);
872 return err;
873 }
875 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
876 {
877 BT_DBG("conn %p", conn);
879 sco_pi(sk)->conn = conn;
880 conn->sk = sk;
882 if (parent)
883 bt_accept_enqueue(parent, sk);
884 }
886 /* Delete channel.
887 * Must be called on the locked socket. */
888 static void sco_chan_del(struct sock *sk, int err)
889 {
890 struct sco_conn *conn;
892 conn = sco_pi(sk)->conn;
894 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
896 if (conn) {
897 sco_conn_lock(conn);
898 conn->sk = NULL;
899 sco_pi(sk)->conn = NULL;
900 sco_conn_unlock(conn);
902 if (conn->hcon)
903 hci_conn_put(conn->hcon);
904 }
906 sk->sk_state = BT_CLOSED;
907 sk->sk_err = err;
908 sk->sk_state_change(sk);
910 sock_set_flag(sk, SOCK_ZAPPED);
911 }
913 static void sco_conn_ready(struct sco_conn *conn)
914 {
915 struct sock *parent;
916 struct sock *sk = conn->sk;
918 BT_DBG("conn %p", conn);
920 if (sk) {
921 sco_sock_clear_timer(sk);
922 bh_lock_sock(sk);
923 sk->sk_state = BT_CONNECTED;
924 sk->sk_state_change(sk);
925 bh_unlock_sock(sk);
926 } else {
927 sco_conn_lock(conn);
929 parent = sco_get_sock_listen(conn->src);
930 if (!parent) {
931 sco_conn_unlock(conn);
932 return;
933 }
935 bh_lock_sock(parent);
937 sk = sco_sock_alloc(sock_net(parent), NULL,
938 BTPROTO_SCO, GFP_ATOMIC);
939 if (!sk) {
940 bh_unlock_sock(parent);
941 sco_conn_unlock(conn);
942 return;
943 }
945 sco_sock_init(sk, parent);
947 bacpy(&bt_sk(sk)->src, conn->src);
948 bacpy(&bt_sk(sk)->dst, conn->dst);
950 hci_conn_hold(conn->hcon);
951 __sco_chan_add(conn, sk, parent);
953 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
954 sk->sk_state = BT_CONNECT2;
955 else
956 sk->sk_state = BT_CONNECTED;
958 /* Wake up parent */
959 parent->sk_data_ready(parent, 1);
961 bh_unlock_sock(parent);
963 sco_conn_unlock(conn);
964 }
965 }
967 /* ----- SCO interface with lower layer (HCI) ----- */
968 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
969 {
970 struct sock *sk;
971 struct hlist_node *node;
972 int lm = 0;
974 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
976 /* Find listening sockets */
977 read_lock(&sco_sk_list.lock);
978 sk_for_each(sk, node, &sco_sk_list.head) {
979 if (sk->sk_state != BT_LISTEN)
980 continue;
982 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
983 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
984 lm |= HCI_LM_ACCEPT;
986 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
987 *flags |= HCI_PROTO_DEFER;
988 break;
989 }
990 }
991 read_unlock(&sco_sk_list.lock);
993 return lm;
994 }
996 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
997 {
998 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
999 if (!status) {
1000 struct sco_conn *conn;
1002 conn = sco_conn_add(hcon);
1003 if (conn)
1004 sco_conn_ready(conn);
1005 } else
1006 sco_conn_del(hcon, bt_to_errno(status));
1007 }
1009 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1010 {
1011 BT_DBG("hcon %p reason %d", hcon, reason);
1013 sco_conn_del(hcon, bt_to_errno(reason));
1014 }
1016 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1017 {
1018 struct sco_conn *conn = hcon->sco_data;
1020 if (!conn)
1021 goto drop;
1023 BT_DBG("conn %p len %d", conn, skb->len);
1025 if (skb->len) {
1026 sco_recv_frame(conn, skb);
1027 return 0;
1028 }
1030 drop:
1031 kfree_skb(skb);
1032 return 0;
1033 }
1035 static int sco_debugfs_show(struct seq_file *f, void *p)
1036 {
1037 struct sock *sk;
1038 struct hlist_node *node;
1040 read_lock(&sco_sk_list.lock);
1042 sk_for_each(sk, node, &sco_sk_list.head) {
1043 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1044 &bt_sk(sk)->dst, sk->sk_state);
1045 }
1047 read_unlock(&sco_sk_list.lock);
1049 return 0;
1050 }
1052 static int sco_debugfs_open(struct inode *inode, struct file *file)
1053 {
1054 return single_open(file, sco_debugfs_show, inode->i_private);
1055 }
1057 static const struct file_operations sco_debugfs_fops = {
1058 .open = sco_debugfs_open,
1059 .read = seq_read,
1060 .llseek = seq_lseek,
1061 .release = single_release,
1062 };
1064 static struct dentry *sco_debugfs;
1066 static const struct proto_ops sco_sock_ops = {
1067 .family = PF_BLUETOOTH,
1068 .owner = THIS_MODULE,
1069 .release = sco_sock_release,
1070 .bind = sco_sock_bind,
1071 .connect = sco_sock_connect,
1072 .listen = sco_sock_listen,
1073 .accept = sco_sock_accept,
1074 .getname = sco_sock_getname,
1075 .sendmsg = sco_sock_sendmsg,
1076 .recvmsg = sco_sock_recvmsg,
1077 .poll = bt_sock_poll,
1078 .ioctl = bt_sock_ioctl,
1079 .mmap = sock_no_mmap,
1080 .socketpair = sock_no_socketpair,
1081 .shutdown = sco_sock_shutdown,
1082 .setsockopt = sco_sock_setsockopt,
1083 .getsockopt = sco_sock_getsockopt
1084 };
1086 static const struct net_proto_family sco_sock_family_ops = {
1087 .family = PF_BLUETOOTH,
1088 .owner = THIS_MODULE,
1089 .create = sco_sock_create,
1090 };
1092 int __init sco_init(void)
1093 {
1094 int err;
1096 err = proto_register(&sco_proto, 0);
1097 if (err < 0)
1098 return err;
1100 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1101 if (err < 0) {
1102 BT_ERR("SCO socket registration failed");
1103 goto error;
1104 }
1106 err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1107 if (err < 0) {
1108 BT_ERR("Failed to create SCO proc file");
1109 bt_sock_unregister(BTPROTO_SCO);
1110 goto error;
1111 }
1113 if (bt_debugfs) {
1114 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1115 NULL, &sco_debugfs_fops);
1116 if (!sco_debugfs)
1117 BT_ERR("Failed to create SCO debug file");
1118 }
1120 BT_INFO("SCO socket layer initialized");
1122 return 0;
1124 error:
1125 proto_unregister(&sco_proto);
1126 return err;
1127 }
1129 void __exit sco_exit(void)
1130 {
1131 bt_procfs_cleanup(&init_net, "sco");
1133 debugfs_remove(sco_debugfs);
1135 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1136 BT_ERR("SCO socket unregistration failed");
1138 proto_unregister(&sco_proto);
1139 }
1141 module_param(disable_esco, bool, 0644);
1142 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");