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