1 /* 2 BlueZ - Bluetooth protocol stack for Linux 3 Copyright (C) 2000-2001 Qualcomm Incorporated 4 5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 6 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; 10 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. 19 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 */ 24 25 /* Bluetooth SCO sockets. */ 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 35 static bool disable_esco; 36 37 static const struct proto_ops sco_sock_ops; 38 39 static struct bt_sock_list sco_sk_list = { 40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock) 41 }; 42 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); 45 46 static void sco_sock_close(struct sock *sk); 47 static void sco_sock_kill(struct sock *sk); 48 49 /* ---- SCO timers ---- */ 50 static 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 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 } 70 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 } 76 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; 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 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 } 116 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; 121 122 if (!conn) 123 return 0; 124 125 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 126 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 } 136 137 hcon->sco_data = NULL; 138 kfree(conn); 139 return 0; 140 } 141 142 static 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 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; 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 /* Update source addr of the socket */ 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 208 done: 209 hci_dev_unlock(hdev); 210 hci_dev_put(hdev); 211 return err; 212 } 213 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; 219 220 /* Check outgoing MTU */ 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 240 static 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 255 drop: 256 kfree_skb(skb); 257 } 258 259 /* -------- Socket interface ---------- */ 260 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba) 261 { 262 struct sock *sk; 263 264 sk_for_each(sk, &sco_sk_list.head) { 265 if (sk->sk_state != BT_LISTEN) 266 continue; 267 268 if (!bacmp(&bt_sk(sk)->src, ba)) 269 return sk; 270 } 271 272 return NULL; 273 } 274 275 /* Find socket listening on source bdaddr. 276 * Returns closest match. 277 */ 278 static struct sock *sco_get_sock_listen(bdaddr_t *src) 279 { 280 struct sock *sk = NULL, *sk1 = NULL; 281 282 read_lock(&sco_sk_list.lock); 283 284 sk_for_each(sk, &sco_sk_list.head) { 285 if (sk->sk_state != BT_LISTEN) 286 continue; 287 288 /* Exact match. */ 289 if (!bacmp(&bt_sk(sk)->src, src)) 290 break; 291 292 /* Closest match */ 293 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) 294 sk1 = sk; 295 } 296 297 read_unlock(&sco_sk_list.lock); 298 299 return sk ? sk : sk1; 300 } 301 302 static void sco_sock_destruct(struct sock *sk) 303 { 304 BT_DBG("sk %p", sk); 305 306 skb_queue_purge(&sk->sk_receive_queue); 307 skb_queue_purge(&sk->sk_write_queue); 308 } 309 310 static void sco_sock_cleanup_listen(struct sock *parent) 311 { 312 struct sock *sk; 313 314 BT_DBG("parent %p", parent); 315 316 /* Close not yet accepted channels */ 317 while ((sk = bt_accept_dequeue(parent, NULL))) { 318 sco_sock_close(sk); 319 sco_sock_kill(sk); 320 } 321 322 parent->sk_state = BT_CLOSED; 323 sock_set_flag(parent, SOCK_ZAPPED); 324 } 325 326 /* Kill socket (only if zapped and orphan) 327 * Must be called on unlocked socket. 328 */ 329 static void sco_sock_kill(struct sock *sk) 330 { 331 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket) 332 return; 333 334 BT_DBG("sk %p state %d", sk, sk->sk_state); 335 336 /* Kill poor orphan */ 337 bt_sock_unlink(&sco_sk_list, sk); 338 sock_set_flag(sk, SOCK_DEAD); 339 sock_put(sk); 340 } 341 342 static void __sco_sock_close(struct sock *sk) 343 { 344 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket); 345 346 switch (sk->sk_state) { 347 case BT_LISTEN: 348 sco_sock_cleanup_listen(sk); 349 break; 350 351 case BT_CONNECTED: 352 case BT_CONFIG: 353 if (sco_pi(sk)->conn->hcon) { 354 sk->sk_state = BT_DISCONN; 355 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT); 356 hci_conn_put(sco_pi(sk)->conn->hcon); 357 sco_pi(sk)->conn->hcon = NULL; 358 } else 359 sco_chan_del(sk, ECONNRESET); 360 break; 361 362 case BT_CONNECT2: 363 case BT_CONNECT: 364 case BT_DISCONN: 365 sco_chan_del(sk, ECONNRESET); 366 break; 367 368 default: 369 sock_set_flag(sk, SOCK_ZAPPED); 370 break; 371 } 372 } 373 374 /* Must be called on unlocked socket. */ 375 static void sco_sock_close(struct sock *sk) 376 { 377 sco_sock_clear_timer(sk); 378 lock_sock(sk); 379 __sco_sock_close(sk); 380 release_sock(sk); 381 sco_sock_kill(sk); 382 } 383 384 static void sco_sock_init(struct sock *sk, struct sock *parent) 385 { 386 BT_DBG("sk %p", sk); 387 388 if (parent) { 389 sk->sk_type = parent->sk_type; 390 bt_sk(sk)->flags = bt_sk(parent)->flags; 391 security_sk_clone(parent, sk); 392 } 393 } 394 395 static struct proto sco_proto = { 396 .name = "SCO", 397 .owner = THIS_MODULE, 398 .obj_size = sizeof(struct sco_pinfo) 399 }; 400 401 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio) 402 { 403 struct sock *sk; 404 405 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto); 406 if (!sk) 407 return NULL; 408 409 sock_init_data(sock, sk); 410 INIT_LIST_HEAD(&bt_sk(sk)->accept_q); 411 412 sk->sk_destruct = sco_sock_destruct; 413 sk->sk_sndtimeo = SCO_CONN_TIMEOUT; 414 415 sock_reset_flag(sk, SOCK_ZAPPED); 416 417 sk->sk_protocol = proto; 418 sk->sk_state = BT_OPEN; 419 420 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk); 421 422 bt_sock_link(&sco_sk_list, sk); 423 return sk; 424 } 425 426 static int sco_sock_create(struct net *net, struct socket *sock, int protocol, 427 int kern) 428 { 429 struct sock *sk; 430 431 BT_DBG("sock %p", sock); 432 433 sock->state = SS_UNCONNECTED; 434 435 if (sock->type != SOCK_SEQPACKET) 436 return -ESOCKTNOSUPPORT; 437 438 sock->ops = &sco_sock_ops; 439 440 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC); 441 if (!sk) 442 return -ENOMEM; 443 444 sco_sock_init(sk, NULL); 445 return 0; 446 } 447 448 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) 449 { 450 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 451 struct sock *sk = sock->sk; 452 int err = 0; 453 454 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr); 455 456 if (!addr || addr->sa_family != AF_BLUETOOTH) 457 return -EINVAL; 458 459 lock_sock(sk); 460 461 if (sk->sk_state != BT_OPEN) { 462 err = -EBADFD; 463 goto done; 464 } 465 466 if (sk->sk_type != SOCK_SEQPACKET) { 467 err = -EINVAL; 468 goto done; 469 } 470 471 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr); 472 473 sk->sk_state = BT_BOUND; 474 475 done: 476 release_sock(sk); 477 return err; 478 } 479 480 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags) 481 { 482 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 483 struct sock *sk = sock->sk; 484 int err = 0; 485 486 487 BT_DBG("sk %p", sk); 488 489 if (alen < sizeof(struct sockaddr_sco) || 490 addr->sa_family != AF_BLUETOOTH) 491 return -EINVAL; 492 493 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) 494 return -EBADFD; 495 496 if (sk->sk_type != SOCK_SEQPACKET) 497 return -EINVAL; 498 499 lock_sock(sk); 500 501 /* Set destination address and psm */ 502 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr); 503 504 err = sco_connect(sk); 505 if (err) 506 goto done; 507 508 err = bt_sock_wait_state(sk, BT_CONNECTED, 509 sock_sndtimeo(sk, flags & O_NONBLOCK)); 510 511 done: 512 release_sock(sk); 513 return err; 514 } 515 516 static int sco_sock_listen(struct socket *sock, int backlog) 517 { 518 struct sock *sk = sock->sk; 519 bdaddr_t *src = &bt_sk(sk)->src; 520 int err = 0; 521 522 BT_DBG("sk %p backlog %d", sk, backlog); 523 524 lock_sock(sk); 525 526 if (sk->sk_state != BT_BOUND) { 527 err = -EBADFD; 528 goto done; 529 } 530 531 if (sk->sk_type != SOCK_SEQPACKET) { 532 err = -EINVAL; 533 goto done; 534 } 535 536 write_lock(&sco_sk_list.lock); 537 538 if (__sco_get_sock_listen_by_addr(src)) { 539 err = -EADDRINUSE; 540 goto unlock; 541 } 542 543 sk->sk_max_ack_backlog = backlog; 544 sk->sk_ack_backlog = 0; 545 546 sk->sk_state = BT_LISTEN; 547 548 unlock: 549 write_unlock(&sco_sk_list.lock); 550 551 done: 552 release_sock(sk); 553 return err; 554 } 555 556 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags) 557 { 558 DECLARE_WAITQUEUE(wait, current); 559 struct sock *sk = sock->sk, *ch; 560 long timeo; 561 int err = 0; 562 563 lock_sock(sk); 564 565 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 566 567 BT_DBG("sk %p timeo %ld", sk, timeo); 568 569 /* Wait for an incoming connection. (wake-one). */ 570 add_wait_queue_exclusive(sk_sleep(sk), &wait); 571 while (1) { 572 set_current_state(TASK_INTERRUPTIBLE); 573 574 if (sk->sk_state != BT_LISTEN) { 575 err = -EBADFD; 576 break; 577 } 578 579 ch = bt_accept_dequeue(sk, newsock); 580 if (ch) 581 break; 582 583 if (!timeo) { 584 err = -EAGAIN; 585 break; 586 } 587 588 if (signal_pending(current)) { 589 err = sock_intr_errno(timeo); 590 break; 591 } 592 593 release_sock(sk); 594 timeo = schedule_timeout(timeo); 595 lock_sock(sk); 596 } 597 __set_current_state(TASK_RUNNING); 598 remove_wait_queue(sk_sleep(sk), &wait); 599 600 if (err) 601 goto done; 602 603 newsock->state = SS_CONNECTED; 604 605 BT_DBG("new socket %p", ch); 606 607 done: 608 release_sock(sk); 609 return err; 610 } 611 612 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer) 613 { 614 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 615 struct sock *sk = sock->sk; 616 617 BT_DBG("sock %p, sk %p", sock, sk); 618 619 addr->sa_family = AF_BLUETOOTH; 620 *len = sizeof(struct sockaddr_sco); 621 622 if (peer) 623 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst); 624 else 625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src); 626 627 return 0; 628 } 629 630 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 631 struct msghdr *msg, size_t len) 632 { 633 struct sock *sk = sock->sk; 634 int err; 635 636 BT_DBG("sock %p, sk %p", sock, sk); 637 638 err = sock_error(sk); 639 if (err) 640 return err; 641 642 if (msg->msg_flags & MSG_OOB) 643 return -EOPNOTSUPP; 644 645 lock_sock(sk); 646 647 if (sk->sk_state == BT_CONNECTED) 648 err = sco_send_frame(sk, msg, len); 649 else 650 err = -ENOTCONN; 651 652 release_sock(sk); 653 return err; 654 } 655 656 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 657 struct msghdr *msg, size_t len, int flags) 658 { 659 struct sock *sk = sock->sk; 660 struct sco_pinfo *pi = sco_pi(sk); 661 662 lock_sock(sk); 663 664 if (sk->sk_state == BT_CONNECT2 && 665 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 666 hci_conn_accept(pi->conn->hcon, 0); 667 sk->sk_state = BT_CONFIG; 668 669 release_sock(sk); 670 return 0; 671 } 672 673 release_sock(sk); 674 675 return bt_sock_recvmsg(iocb, sock, msg, len, flags); 676 } 677 678 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen) 679 { 680 struct sock *sk = sock->sk; 681 int err = 0; 682 u32 opt; 683 684 BT_DBG("sk %p", sk); 685 686 lock_sock(sk); 687 688 switch (optname) { 689 690 case BT_DEFER_SETUP: 691 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) { 692 err = -EINVAL; 693 break; 694 } 695 696 if (get_user(opt, (u32 __user *) optval)) { 697 err = -EFAULT; 698 break; 699 } 700 701 if (opt) 702 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags); 703 else 704 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags); 705 break; 706 707 default: 708 err = -ENOPROTOOPT; 709 break; 710 } 711 712 release_sock(sk); 713 return err; 714 } 715 716 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen) 717 { 718 struct sock *sk = sock->sk; 719 struct sco_options opts; 720 struct sco_conninfo cinfo; 721 int len, err = 0; 722 723 BT_DBG("sk %p", sk); 724 725 if (get_user(len, optlen)) 726 return -EFAULT; 727 728 lock_sock(sk); 729 730 switch (optname) { 731 case SCO_OPTIONS: 732 if (sk->sk_state != BT_CONNECTED) { 733 err = -ENOTCONN; 734 break; 735 } 736 737 opts.mtu = sco_pi(sk)->conn->mtu; 738 739 BT_DBG("mtu %d", opts.mtu); 740 741 len = min_t(unsigned int, len, sizeof(opts)); 742 if (copy_to_user(optval, (char *)&opts, len)) 743 err = -EFAULT; 744 745 break; 746 747 case SCO_CONNINFO: 748 if (sk->sk_state != BT_CONNECTED) { 749 err = -ENOTCONN; 750 break; 751 } 752 753 memset(&cinfo, 0, sizeof(cinfo)); 754 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle; 755 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3); 756 757 len = min_t(unsigned int, len, sizeof(cinfo)); 758 if (copy_to_user(optval, (char *)&cinfo, len)) 759 err = -EFAULT; 760 761 break; 762 763 default: 764 err = -ENOPROTOOPT; 765 break; 766 } 767 768 release_sock(sk); 769 return err; 770 } 771 772 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 773 { 774 struct sock *sk = sock->sk; 775 int len, err = 0; 776 777 BT_DBG("sk %p", sk); 778 779 if (level == SOL_SCO) 780 return sco_sock_getsockopt_old(sock, optname, optval, optlen); 781 782 if (get_user(len, optlen)) 783 return -EFAULT; 784 785 lock_sock(sk); 786 787 switch (optname) { 788 789 case BT_DEFER_SETUP: 790 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) { 791 err = -EINVAL; 792 break; 793 } 794 795 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags), 796 (u32 __user *) optval)) 797 err = -EFAULT; 798 799 break; 800 801 default: 802 err = -ENOPROTOOPT; 803 break; 804 } 805 806 release_sock(sk); 807 return err; 808 } 809 810 static int sco_sock_shutdown(struct socket *sock, int how) 811 { 812 struct sock *sk = sock->sk; 813 int err = 0; 814 815 BT_DBG("sock %p, sk %p", sock, sk); 816 817 if (!sk) 818 return 0; 819 820 lock_sock(sk); 821 if (!sk->sk_shutdown) { 822 sk->sk_shutdown = SHUTDOWN_MASK; 823 sco_sock_clear_timer(sk); 824 __sco_sock_close(sk); 825 826 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) 827 err = bt_sock_wait_state(sk, BT_CLOSED, 828 sk->sk_lingertime); 829 } 830 release_sock(sk); 831 return err; 832 } 833 834 static int sco_sock_release(struct socket *sock) 835 { 836 struct sock *sk = sock->sk; 837 int err = 0; 838 839 BT_DBG("sock %p, sk %p", sock, sk); 840 841 if (!sk) 842 return 0; 843 844 sco_sock_close(sk); 845 846 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) { 847 lock_sock(sk); 848 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime); 849 release_sock(sk); 850 } 851 852 sock_orphan(sk); 853 sco_sock_kill(sk); 854 return err; 855 } 856 857 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent) 858 { 859 BT_DBG("conn %p", conn); 860 861 sco_pi(sk)->conn = conn; 862 conn->sk = sk; 863 864 if (parent) 865 bt_accept_enqueue(parent, sk); 866 } 867 868 /* Delete channel. 869 * Must be called on the locked socket. */ 870 static void sco_chan_del(struct sock *sk, int err) 871 { 872 struct sco_conn *conn; 873 874 conn = sco_pi(sk)->conn; 875 876 BT_DBG("sk %p, conn %p, err %d", sk, conn, err); 877 878 if (conn) { 879 sco_conn_lock(conn); 880 conn->sk = NULL; 881 sco_pi(sk)->conn = NULL; 882 sco_conn_unlock(conn); 883 884 if (conn->hcon) 885 hci_conn_put(conn->hcon); 886 } 887 888 sk->sk_state = BT_CLOSED; 889 sk->sk_err = err; 890 sk->sk_state_change(sk); 891 892 sock_set_flag(sk, SOCK_ZAPPED); 893 } 894 895 static void sco_conn_ready(struct sco_conn *conn) 896 { 897 struct sock *parent; 898 struct sock *sk = conn->sk; 899 900 BT_DBG("conn %p", conn); 901 902 if (sk) { 903 sco_sock_clear_timer(sk); 904 bh_lock_sock(sk); 905 sk->sk_state = BT_CONNECTED; 906 sk->sk_state_change(sk); 907 bh_unlock_sock(sk); 908 } else { 909 sco_conn_lock(conn); 910 911 parent = sco_get_sock_listen(conn->src); 912 if (!parent) { 913 sco_conn_unlock(conn); 914 return; 915 } 916 917 bh_lock_sock(parent); 918 919 sk = sco_sock_alloc(sock_net(parent), NULL, 920 BTPROTO_SCO, GFP_ATOMIC); 921 if (!sk) { 922 bh_unlock_sock(parent); 923 sco_conn_unlock(conn); 924 return; 925 } 926 927 sco_sock_init(sk, parent); 928 929 bacpy(&bt_sk(sk)->src, conn->src); 930 bacpy(&bt_sk(sk)->dst, conn->dst); 931 932 hci_conn_hold(conn->hcon); 933 __sco_chan_add(conn, sk, parent); 934 935 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) 936 sk->sk_state = BT_CONNECT2; 937 else 938 sk->sk_state = BT_CONNECTED; 939 940 /* Wake up parent */ 941 parent->sk_data_ready(parent, 1); 942 943 bh_unlock_sock(parent); 944 945 sco_conn_unlock(conn); 946 } 947 } 948 949 /* ----- SCO interface with lower layer (HCI) ----- */ 950 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags) 951 { 952 struct sock *sk; 953 int lm = 0; 954 955 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 956 957 /* Find listening sockets */ 958 read_lock(&sco_sk_list.lock); 959 sk_for_each(sk, &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 977 void 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 990 void 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 997 int 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 1011 drop: 1012 kfree_skb(skb); 1013 return 0; 1014 } 1015 1016 static int sco_debugfs_show(struct seq_file *f, void *p) 1017 { 1018 struct sock *sk; 1019 1020 read_lock(&sco_sk_list.lock); 1021 1022 sk_for_each(sk, &sco_sk_list.head) { 1023 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src, 1024 &bt_sk(sk)->dst, sk->sk_state); 1025 } 1026 1027 read_unlock(&sco_sk_list.lock); 1028 1029 return 0; 1030 } 1031 1032 static int sco_debugfs_open(struct inode *inode, struct file *file) 1033 { 1034 return single_open(file, sco_debugfs_show, inode->i_private); 1035 } 1036 1037 static const struct file_operations sco_debugfs_fops = { 1038 .open = sco_debugfs_open, 1039 .read = seq_read, 1040 .llseek = seq_lseek, 1041 .release = single_release, 1042 }; 1043 1044 static struct dentry *sco_debugfs; 1045 1046 static const struct proto_ops sco_sock_ops = { 1047 .family = PF_BLUETOOTH, 1048 .owner = THIS_MODULE, 1049 .release = sco_sock_release, 1050 .bind = sco_sock_bind, 1051 .connect = sco_sock_connect, 1052 .listen = sco_sock_listen, 1053 .accept = sco_sock_accept, 1054 .getname = sco_sock_getname, 1055 .sendmsg = sco_sock_sendmsg, 1056 .recvmsg = sco_sock_recvmsg, 1057 .poll = bt_sock_poll, 1058 .ioctl = bt_sock_ioctl, 1059 .mmap = sock_no_mmap, 1060 .socketpair = sock_no_socketpair, 1061 .shutdown = sco_sock_shutdown, 1062 .setsockopt = sco_sock_setsockopt, 1063 .getsockopt = sco_sock_getsockopt 1064 }; 1065 1066 static const struct net_proto_family sco_sock_family_ops = { 1067 .family = PF_BLUETOOTH, 1068 .owner = THIS_MODULE, 1069 .create = sco_sock_create, 1070 }; 1071 1072 int __init sco_init(void) 1073 { 1074 int err; 1075 1076 err = proto_register(&sco_proto, 0); 1077 if (err < 0) 1078 return err; 1079 1080 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops); 1081 if (err < 0) { 1082 BT_ERR("SCO socket registration failed"); 1083 goto error; 1084 } 1085 1086 err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL); 1087 if (err < 0) { 1088 BT_ERR("Failed to create SCO proc file"); 1089 bt_sock_unregister(BTPROTO_SCO); 1090 goto error; 1091 } 1092 1093 if (bt_debugfs) { 1094 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs, 1095 NULL, &sco_debugfs_fops); 1096 if (!sco_debugfs) 1097 BT_ERR("Failed to create SCO debug file"); 1098 } 1099 1100 BT_INFO("SCO socket layer initialized"); 1101 1102 return 0; 1103 1104 error: 1105 proto_unregister(&sco_proto); 1106 return err; 1107 } 1108 1109 void __exit sco_exit(void) 1110 { 1111 bt_procfs_cleanup(&init_net, "sco"); 1112 1113 debugfs_remove(sco_debugfs); 1114 1115 if (bt_sock_unregister(BTPROTO_SCO) < 0) 1116 BT_ERR("SCO socket unregistration failed"); 1117 1118 proto_unregister(&sco_proto); 1119 } 1120 1121 module_param(disable_esco, bool, 0644); 1122 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation"); 1123