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