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/config.h> 28 #include <linux/module.h> 29 30 #include <linux/types.h> 31 #include <linux/errno.h> 32 #include <linux/kernel.h> 33 #include <linux/sched.h> 34 #include <linux/slab.h> 35 #include <linux/poll.h> 36 #include <linux/fcntl.h> 37 #include <linux/init.h> 38 #include <linux/interrupt.h> 39 #include <linux/socket.h> 40 #include <linux/skbuff.h> 41 #include <linux/device.h> 42 #include <linux/list.h> 43 #include <net/sock.h> 44 45 #include <asm/system.h> 46 #include <asm/uaccess.h> 47 48 #include <net/bluetooth/bluetooth.h> 49 #include <net/bluetooth/hci_core.h> 50 #include <net/bluetooth/sco.h> 51 52 #ifndef CONFIG_BT_SCO_DEBUG 53 #undef BT_DBG 54 #define BT_DBG(D...) 55 #endif 56 57 #define VERSION "0.5" 58 59 static struct proto_ops sco_sock_ops; 60 61 static struct bt_sock_list sco_sk_list = { 62 .lock = RW_LOCK_UNLOCKED 63 }; 64 65 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent); 66 static void sco_chan_del(struct sock *sk, int err); 67 68 static int sco_conn_del(struct hci_conn *conn, int err); 69 70 static void sco_sock_close(struct sock *sk); 71 static void sco_sock_kill(struct sock *sk); 72 73 /* ---- SCO timers ---- */ 74 static void sco_sock_timeout(unsigned long arg) 75 { 76 struct sock *sk = (struct sock *) arg; 77 78 BT_DBG("sock %p state %d", sk, sk->sk_state); 79 80 bh_lock_sock(sk); 81 sk->sk_err = ETIMEDOUT; 82 sk->sk_state_change(sk); 83 bh_unlock_sock(sk); 84 85 sco_sock_kill(sk); 86 sock_put(sk); 87 } 88 89 static void sco_sock_set_timer(struct sock *sk, long timeout) 90 { 91 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout); 92 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout); 93 } 94 95 static void sco_sock_clear_timer(struct sock *sk) 96 { 97 BT_DBG("sock %p state %d", sk, sk->sk_state); 98 sk_stop_timer(sk, &sk->sk_timer); 99 } 100 101 static void sco_sock_init_timer(struct sock *sk) 102 { 103 init_timer(&sk->sk_timer); 104 sk->sk_timer.function = sco_sock_timeout; 105 sk->sk_timer.data = (unsigned long)sk; 106 } 107 108 /* ---- SCO connections ---- */ 109 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status) 110 { 111 struct hci_dev *hdev = hcon->hdev; 112 struct sco_conn *conn; 113 114 if ((conn = hcon->sco_data)) 115 return conn; 116 117 if (status) 118 return conn; 119 120 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC))) 121 return NULL; 122 memset(conn, 0, sizeof(struct sco_conn)); 123 124 spin_lock_init(&conn->lock); 125 126 hcon->sco_data = conn; 127 conn->hcon = hcon; 128 129 conn->src = &hdev->bdaddr; 130 conn->dst = &hcon->dst; 131 132 if (hdev->sco_mtu > 0) 133 conn->mtu = hdev->sco_mtu; 134 else 135 conn->mtu = 60; 136 137 BT_DBG("hcon %p conn %p", hcon, conn); 138 return conn; 139 } 140 141 static inline struct sock *sco_chan_get(struct sco_conn *conn) 142 { 143 struct sock *sk = NULL; 144 sco_conn_lock(conn); 145 sk = conn->sk; 146 sco_conn_unlock(conn); 147 return sk; 148 } 149 150 static int sco_conn_del(struct hci_conn *hcon, int err) 151 { 152 struct sco_conn *conn; 153 struct sock *sk; 154 155 if (!(conn = hcon->sco_data)) 156 return 0; 157 158 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 159 160 /* Kill socket */ 161 if ((sk = sco_chan_get(conn))) { 162 bh_lock_sock(sk); 163 sco_sock_clear_timer(sk); 164 sco_chan_del(sk, err); 165 bh_unlock_sock(sk); 166 sco_sock_kill(sk); 167 } 168 169 hcon->sco_data = NULL; 170 kfree(conn); 171 return 0; 172 } 173 174 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent) 175 { 176 int err = 0; 177 178 sco_conn_lock(conn); 179 if (conn->sk) { 180 err = -EBUSY; 181 } else { 182 __sco_chan_add(conn, sk, parent); 183 } 184 sco_conn_unlock(conn); 185 return err; 186 } 187 188 static int sco_connect(struct sock *sk) 189 { 190 bdaddr_t *src = &bt_sk(sk)->src; 191 bdaddr_t *dst = &bt_sk(sk)->dst; 192 struct sco_conn *conn; 193 struct hci_conn *hcon; 194 struct hci_dev *hdev; 195 int err = 0; 196 197 BT_DBG("%s -> %s", batostr(src), batostr(dst)); 198 199 if (!(hdev = hci_get_route(dst, src))) 200 return -EHOSTUNREACH; 201 202 hci_dev_lock_bh(hdev); 203 204 err = -ENOMEM; 205 206 hcon = hci_connect(hdev, SCO_LINK, dst); 207 if (!hcon) 208 goto done; 209 210 conn = sco_conn_add(hcon, 0); 211 if (!conn) { 212 hci_conn_put(hcon); 213 goto done; 214 } 215 216 /* Update source addr of the socket */ 217 bacpy(src, conn->src); 218 219 err = sco_chan_add(conn, sk, NULL); 220 if (err) 221 goto done; 222 223 if (hcon->state == BT_CONNECTED) { 224 sco_sock_clear_timer(sk); 225 sk->sk_state = BT_CONNECTED; 226 } else { 227 sk->sk_state = BT_CONNECT; 228 sco_sock_set_timer(sk, sk->sk_sndtimeo); 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 goto fail; 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 socket *sock, int proto, gfp_t prio) 421 { 422 struct sock *sk; 423 424 sk = sk_alloc(PF_BLUETOOTH, prio, &sco_proto, 1); 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 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 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL))) 459 return -ENOMEM; 460 461 sco_sock_init(sk, NULL); 462 return 0; 463 } 464 465 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) 466 { 467 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 468 struct sock *sk = sock->sk; 469 bdaddr_t *src = &sa->sco_bdaddr; 470 int err = 0; 471 472 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr)); 473 474 if (!addr || addr->sa_family != AF_BLUETOOTH) 475 return -EINVAL; 476 477 lock_sock(sk); 478 479 if (sk->sk_state != BT_OPEN) { 480 err = -EBADFD; 481 goto done; 482 } 483 484 write_lock_bh(&sco_sk_list.lock); 485 486 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) { 487 err = -EADDRINUSE; 488 } else { 489 /* Save source address */ 490 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr); 491 sk->sk_state = BT_BOUND; 492 } 493 494 write_unlock_bh(&sco_sk_list.lock); 495 496 done: 497 release_sock(sk); 498 return err; 499 } 500 501 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags) 502 { 503 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 504 struct sock *sk = sock->sk; 505 int err = 0; 506 507 508 BT_DBG("sk %p", sk); 509 510 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco)) 511 return -EINVAL; 512 513 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) 514 return -EBADFD; 515 516 if (sk->sk_type != SOCK_SEQPACKET) 517 return -EINVAL; 518 519 lock_sock(sk); 520 521 /* Set destination address and psm */ 522 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr); 523 524 if ((err = sco_connect(sk))) 525 goto done; 526 527 err = bt_sock_wait_state(sk, BT_CONNECTED, 528 sock_sndtimeo(sk, flags & O_NONBLOCK)); 529 530 done: 531 release_sock(sk); 532 return err; 533 } 534 535 static int sco_sock_listen(struct socket *sock, int backlog) 536 { 537 struct sock *sk = sock->sk; 538 int err = 0; 539 540 BT_DBG("sk %p backlog %d", sk, backlog); 541 542 lock_sock(sk); 543 544 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) { 545 err = -EBADFD; 546 goto done; 547 } 548 549 sk->sk_max_ack_backlog = backlog; 550 sk->sk_ack_backlog = 0; 551 sk->sk_state = BT_LISTEN; 552 553 done: 554 release_sock(sk); 555 return err; 556 } 557 558 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags) 559 { 560 DECLARE_WAITQUEUE(wait, current); 561 struct sock *sk = sock->sk, *ch; 562 long timeo; 563 int err = 0; 564 565 lock_sock(sk); 566 567 if (sk->sk_state != BT_LISTEN) { 568 err = -EBADFD; 569 goto done; 570 } 571 572 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 573 574 BT_DBG("sk %p timeo %ld", sk, timeo); 575 576 /* Wait for an incoming connection. (wake-one). */ 577 add_wait_queue_exclusive(sk->sk_sleep, &wait); 578 while (!(ch = bt_accept_dequeue(sk, newsock))) { 579 set_current_state(TASK_INTERRUPTIBLE); 580 if (!timeo) { 581 err = -EAGAIN; 582 break; 583 } 584 585 release_sock(sk); 586 timeo = schedule_timeout(timeo); 587 lock_sock(sk); 588 589 if (sk->sk_state != BT_LISTEN) { 590 err = -EBADFD; 591 break; 592 } 593 594 if (signal_pending(current)) { 595 err = sock_intr_errno(timeo); 596 break; 597 } 598 } 599 set_current_state(TASK_RUNNING); 600 remove_wait_queue(sk->sk_sleep, &wait); 601 602 if (err) 603 goto done; 604 605 newsock->state = SS_CONNECTED; 606 607 BT_DBG("new socket %p", ch); 608 609 done: 610 release_sock(sk); 611 return err; 612 } 613 614 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer) 615 { 616 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr; 617 struct sock *sk = sock->sk; 618 619 BT_DBG("sock %p, sk %p", sock, sk); 620 621 addr->sa_family = AF_BLUETOOTH; 622 *len = sizeof(struct sockaddr_sco); 623 624 if (peer) 625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst); 626 else 627 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src); 628 629 return 0; 630 } 631 632 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 633 struct msghdr *msg, size_t len) 634 { 635 struct sock *sk = sock->sk; 636 int err = 0; 637 638 BT_DBG("sock %p, sk %p", sock, sk); 639 640 if (sk->sk_err) 641 return sock_error(sk); 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 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