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