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("%s -> %s", batostr(src), batostr(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 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 /* 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; 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 /* Exact match. */ 291 if (!bacmp(&bt_sk(sk)->src, src)) 292 break; 293 294 /* Closest match */ 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 304 static 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 312 static void sco_sock_cleanup_listen(struct sock *parent) 313 { 314 struct sock *sk; 315 316 BT_DBG("parent %p", parent); 317 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 } 323 324 parent->sk_state = BT_CLOSED; 325 sock_set_flag(parent, SOCK_ZAPPED); 326 } 327 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; 335 336 BT_DBG("sk %p state %d", sk, sk->sk_state); 337 338 /* Kill poor orphan */ 339 bt_sock_unlink(&sco_sk_list, sk); 340 sock_set_flag(sk, SOCK_DEAD); 341 sock_put(sk); 342 } 343 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); 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) { 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 /* Must be called on unlocked socket. */ 376 static 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 385 static 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 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 %s", sk, batostr(&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_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen) 657 { 658 struct sock *sk = sock->sk; 659 int err = 0; 660 661 BT_DBG("sk %p", sk); 662 663 lock_sock(sk); 664 665 switch (optname) { 666 default: 667 err = -ENOPROTOOPT; 668 break; 669 } 670 671 release_sock(sk); 672 return err; 673 } 674 675 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen) 676 { 677 struct sock *sk = sock->sk; 678 struct sco_options opts; 679 struct sco_conninfo cinfo; 680 int len, err = 0; 681 682 BT_DBG("sk %p", sk); 683 684 if (get_user(len, optlen)) 685 return -EFAULT; 686 687 lock_sock(sk); 688 689 switch (optname) { 690 case SCO_OPTIONS: 691 if (sk->sk_state != BT_CONNECTED) { 692 err = -ENOTCONN; 693 break; 694 } 695 696 opts.mtu = sco_pi(sk)->conn->mtu; 697 698 BT_DBG("mtu %d", opts.mtu); 699 700 len = min_t(unsigned int, len, sizeof(opts)); 701 if (copy_to_user(optval, (char *)&opts, len)) 702 err = -EFAULT; 703 704 break; 705 706 case SCO_CONNINFO: 707 if (sk->sk_state != BT_CONNECTED) { 708 err = -ENOTCONN; 709 break; 710 } 711 712 memset(&cinfo, 0, sizeof(cinfo)); 713 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle; 714 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3); 715 716 len = min_t(unsigned int, len, sizeof(cinfo)); 717 if (copy_to_user(optval, (char *)&cinfo, len)) 718 err = -EFAULT; 719 720 break; 721 722 default: 723 err = -ENOPROTOOPT; 724 break; 725 } 726 727 release_sock(sk); 728 return err; 729 } 730 731 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 732 { 733 struct sock *sk = sock->sk; 734 int len, err = 0; 735 736 BT_DBG("sk %p", sk); 737 738 if (level == SOL_SCO) 739 return sco_sock_getsockopt_old(sock, optname, optval, optlen); 740 741 if (get_user(len, optlen)) 742 return -EFAULT; 743 744 lock_sock(sk); 745 746 switch (optname) { 747 default: 748 err = -ENOPROTOOPT; 749 break; 750 } 751 752 release_sock(sk); 753 return err; 754 } 755 756 static int sco_sock_shutdown(struct socket *sock, int how) 757 { 758 struct sock *sk = sock->sk; 759 int err = 0; 760 761 BT_DBG("sock %p, sk %p", sock, sk); 762 763 if (!sk) 764 return 0; 765 766 lock_sock(sk); 767 if (!sk->sk_shutdown) { 768 sk->sk_shutdown = SHUTDOWN_MASK; 769 sco_sock_clear_timer(sk); 770 __sco_sock_close(sk); 771 772 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) 773 err = bt_sock_wait_state(sk, BT_CLOSED, 774 sk->sk_lingertime); 775 } 776 release_sock(sk); 777 return err; 778 } 779 780 static int sco_sock_release(struct socket *sock) 781 { 782 struct sock *sk = sock->sk; 783 int err = 0; 784 785 BT_DBG("sock %p, sk %p", sock, sk); 786 787 if (!sk) 788 return 0; 789 790 sco_sock_close(sk); 791 792 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) { 793 lock_sock(sk); 794 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime); 795 release_sock(sk); 796 } 797 798 sock_orphan(sk); 799 sco_sock_kill(sk); 800 return err; 801 } 802 803 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent) 804 { 805 BT_DBG("conn %p", conn); 806 807 sco_pi(sk)->conn = conn; 808 conn->sk = sk; 809 810 if (parent) 811 bt_accept_enqueue(parent, sk); 812 } 813 814 /* Delete channel. 815 * Must be called on the locked socket. */ 816 static void sco_chan_del(struct sock *sk, int err) 817 { 818 struct sco_conn *conn; 819 820 conn = sco_pi(sk)->conn; 821 822 BT_DBG("sk %p, conn %p, err %d", sk, conn, err); 823 824 if (conn) { 825 sco_conn_lock(conn); 826 conn->sk = NULL; 827 sco_pi(sk)->conn = NULL; 828 sco_conn_unlock(conn); 829 830 if (conn->hcon) 831 hci_conn_put(conn->hcon); 832 } 833 834 sk->sk_state = BT_CLOSED; 835 sk->sk_err = err; 836 sk->sk_state_change(sk); 837 838 sock_set_flag(sk, SOCK_ZAPPED); 839 } 840 841 static void sco_conn_ready(struct sco_conn *conn) 842 { 843 struct sock *parent; 844 struct sock *sk = conn->sk; 845 846 BT_DBG("conn %p", conn); 847 848 sco_conn_lock(conn); 849 850 if (sk) { 851 sco_sock_clear_timer(sk); 852 bh_lock_sock(sk); 853 sk->sk_state = BT_CONNECTED; 854 sk->sk_state_change(sk); 855 bh_unlock_sock(sk); 856 } else { 857 parent = sco_get_sock_listen(conn->src); 858 if (!parent) 859 goto done; 860 861 bh_lock_sock(parent); 862 863 sk = sco_sock_alloc(sock_net(parent), NULL, 864 BTPROTO_SCO, GFP_ATOMIC); 865 if (!sk) { 866 bh_unlock_sock(parent); 867 goto done; 868 } 869 870 sco_sock_init(sk, parent); 871 872 bacpy(&bt_sk(sk)->src, conn->src); 873 bacpy(&bt_sk(sk)->dst, conn->dst); 874 875 hci_conn_hold(conn->hcon); 876 __sco_chan_add(conn, sk, parent); 877 878 sk->sk_state = BT_CONNECTED; 879 880 /* Wake up parent */ 881 parent->sk_data_ready(parent, 1); 882 883 bh_unlock_sock(parent); 884 } 885 886 done: 887 sco_conn_unlock(conn); 888 } 889 890 /* ----- SCO interface with lower layer (HCI) ----- */ 891 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 892 { 893 struct sock *sk; 894 struct hlist_node *node; 895 int lm = 0; 896 897 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr)); 898 899 /* Find listening sockets */ 900 read_lock(&sco_sk_list.lock); 901 sk_for_each(sk, node, &sco_sk_list.head) { 902 if (sk->sk_state != BT_LISTEN) 903 continue; 904 905 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) || 906 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 907 lm |= HCI_LM_ACCEPT; 908 break; 909 } 910 } 911 read_unlock(&sco_sk_list.lock); 912 913 return lm; 914 } 915 916 int sco_connect_cfm(struct hci_conn *hcon, __u8 status) 917 { 918 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status); 919 if (!status) { 920 struct sco_conn *conn; 921 922 conn = sco_conn_add(hcon); 923 if (conn) 924 sco_conn_ready(conn); 925 } else 926 sco_conn_del(hcon, bt_to_errno(status)); 927 928 return 0; 929 } 930 931 int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason) 932 { 933 BT_DBG("hcon %p reason %d", hcon, reason); 934 935 sco_conn_del(hcon, bt_to_errno(reason)); 936 return 0; 937 } 938 939 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb) 940 { 941 struct sco_conn *conn = hcon->sco_data; 942 943 if (!conn) 944 goto drop; 945 946 BT_DBG("conn %p len %d", conn, skb->len); 947 948 if (skb->len) { 949 sco_recv_frame(conn, skb); 950 return 0; 951 } 952 953 drop: 954 kfree_skb(skb); 955 return 0; 956 } 957 958 static int sco_debugfs_show(struct seq_file *f, void *p) 959 { 960 struct sock *sk; 961 struct hlist_node *node; 962 963 read_lock(&sco_sk_list.lock); 964 965 sk_for_each(sk, node, &sco_sk_list.head) { 966 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src), 967 batostr(&bt_sk(sk)->dst), sk->sk_state); 968 } 969 970 read_unlock(&sco_sk_list.lock); 971 972 return 0; 973 } 974 975 static int sco_debugfs_open(struct inode *inode, struct file *file) 976 { 977 return single_open(file, sco_debugfs_show, inode->i_private); 978 } 979 980 static const struct file_operations sco_debugfs_fops = { 981 .open = sco_debugfs_open, 982 .read = seq_read, 983 .llseek = seq_lseek, 984 .release = single_release, 985 }; 986 987 static struct dentry *sco_debugfs; 988 989 static const struct proto_ops sco_sock_ops = { 990 .family = PF_BLUETOOTH, 991 .owner = THIS_MODULE, 992 .release = sco_sock_release, 993 .bind = sco_sock_bind, 994 .connect = sco_sock_connect, 995 .listen = sco_sock_listen, 996 .accept = sco_sock_accept, 997 .getname = sco_sock_getname, 998 .sendmsg = sco_sock_sendmsg, 999 .recvmsg = bt_sock_recvmsg, 1000 .poll = bt_sock_poll, 1001 .ioctl = bt_sock_ioctl, 1002 .mmap = sock_no_mmap, 1003 .socketpair = sock_no_socketpair, 1004 .shutdown = sco_sock_shutdown, 1005 .setsockopt = sco_sock_setsockopt, 1006 .getsockopt = sco_sock_getsockopt 1007 }; 1008 1009 static const struct net_proto_family sco_sock_family_ops = { 1010 .family = PF_BLUETOOTH, 1011 .owner = THIS_MODULE, 1012 .create = sco_sock_create, 1013 }; 1014 1015 int __init sco_init(void) 1016 { 1017 int err; 1018 1019 err = proto_register(&sco_proto, 0); 1020 if (err < 0) 1021 return err; 1022 1023 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops); 1024 if (err < 0) { 1025 BT_ERR("SCO socket registration failed"); 1026 goto error; 1027 } 1028 1029 if (bt_debugfs) { 1030 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs, 1031 NULL, &sco_debugfs_fops); 1032 if (!sco_debugfs) 1033 BT_ERR("Failed to create SCO debug file"); 1034 } 1035 1036 BT_INFO("SCO socket layer initialized"); 1037 1038 return 0; 1039 1040 error: 1041 proto_unregister(&sco_proto); 1042 return err; 1043 } 1044 1045 void __exit sco_exit(void) 1046 { 1047 debugfs_remove(sco_debugfs); 1048 1049 if (bt_sock_unregister(BTPROTO_SCO) < 0) 1050 BT_ERR("SCO socket unregistration failed"); 1051 1052 proto_unregister(&sco_proto); 1053 } 1054 1055 module_param(disable_esco, bool, 0644); 1056 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation"); 1057