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