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