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