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