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