net/bluetooth/sco.c

   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         sk = sco_sock_alloc(sock, protocol, GFP_ATOMIC);
 456         if (!sk)
 457                 return -ENOMEM;
 458
 459         sco_sock_init(sk, NULL);
 460         return 0;
 461 }
 462
 463 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 464 {
 465         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 466         struct sock *sk = sock->sk;
 467         bdaddr_t *src = &sa->sco_bdaddr;
 468         int err = 0;
 469
 470         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 471
 472         if (!addr || addr->sa_family != AF_BLUETOOTH)
 473                 return -EINVAL;
 474
 475         lock_sock(sk);
 476
 477         if (sk->sk_state != BT_OPEN) {
 478                 err = -EBADFD;
 479                 goto done;
 480         }
 481
 482         write_lock_bh(&sco_sk_list.lock);
 483
 484         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 485                 err = -EADDRINUSE;
 486         } else {
 487                 /* Save source address */
 488                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 489                 sk->sk_state = BT_BOUND;
 490         }
 491
 492         write_unlock_bh(&sco_sk_list.lock);
 493
 494 done:
 495         release_sock(sk);
 496         return err;
 497 }
 498
 499 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 500 {
 501         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 502         struct sock *sk = sock->sk;
 503         int err = 0;
 504
 505
 506         BT_DBG("sk %p", sk);
 507
 508         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 509                 return -EINVAL;
 510
 511         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 512                 return -EBADFD;
 513
 514         if (sk->sk_type != SOCK_SEQPACKET)
 515                 return -EINVAL;
 516
 517         lock_sock(sk);
 518
 519         /* Set destination address and psm */
 520         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 521
 522         if ((err = sco_connect(sk)))
 523                 goto done;
 524
 525         err = bt_sock_wait_state(sk, BT_CONNECTED,
 526                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 527
 528 done:
 529         release_sock(sk);
 530         return err;
 531 }
 532
 533 static int sco_sock_listen(struct socket *sock, int backlog)
 534 {
 535         struct sock *sk = sock->sk;
 536         int err = 0;
 537
 538         BT_DBG("sk %p backlog %d", sk, backlog);
 539
 540         lock_sock(sk);
 541
 542         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 543                 err = -EBADFD;
 544                 goto done;
 545         }
 546
 547         sk->sk_max_ack_backlog = backlog;
 548         sk->sk_ack_backlog = 0;
 549         sk->sk_state = BT_LISTEN;
 550
 551 done:
 552         release_sock(sk);
 553         return err;
 554 }
 555
 556 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 557 {
 558         DECLARE_WAITQUEUE(wait, current);
 559         struct sock *sk = sock->sk, *ch;
 560         long timeo;
 561         int err = 0;
 562
 563         lock_sock(sk);
 564
 565         if (sk->sk_state != BT_LISTEN) {
 566                 err = -EBADFD;
 567                 goto done;
 568         }
 569
 570         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 571
 572         BT_DBG("sk %p timeo %ld", sk, timeo);
 573
 574         /* Wait for an incoming connection. (wake-one). */
 575         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 576         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 577                 set_current_state(TASK_INTERRUPTIBLE);
 578                 if (!timeo) {
 579                         err = -EAGAIN;
 580                         break;
 581                 }
 582
 583                 release_sock(sk);
 584                 timeo = schedule_timeout(timeo);
 585                 lock_sock(sk);
 586
 587                 if (sk->sk_state != BT_LISTEN) {
 588                         err = -EBADFD;
 589                         break;
 590                 }
 591
 592                 if (signal_pending(current)) {
 593                         err = sock_intr_errno(timeo);
 594                         break;
 595                 }
 596         }
 597         set_current_state(TASK_RUNNING);
 598         remove_wait_queue(sk->sk_sleep, &wait);
 599
 600         if (err)
 601                 goto done;
 602
 603         newsock->state = SS_CONNECTED;
 604
 605         BT_DBG("new socket %p", ch);
 606
 607 done:
 608         release_sock(sk);
 609         return err;
 610 }
 611
 612 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 613 {
 614         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 615         struct sock *sk = sock->sk;
 616
 617         BT_DBG("sock %p, sk %p", sock, sk);
 618
 619         addr->sa_family = AF_BLUETOOTH;
 620         *len = sizeof(struct sockaddr_sco);
 621
 622         if (peer)
 623                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 624         else
 625                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 626
 627         return 0;
 628 }
 629
 630 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 631                             struct msghdr *msg, size_t len)
 632 {
 633         struct sock *sk = sock->sk;
 634         int err = 0;
 635
 636         BT_DBG("sock %p, sk %p", sock, sk);
 637
 638         err = sock_error(sk);
 639         if (err)
 640                 return err;
 641
 642         if (msg->msg_flags & MSG_OOB)
 643                 return -EOPNOTSUPP;
 644
 645         lock_sock(sk);
 646
 647         if (sk->sk_state == BT_CONNECTED)
 648                 err = sco_send_frame(sk, msg, len);
 649         else
 650                 err = -ENOTCONN;
 651
 652         release_sock(sk);
 653         return err;
 654 }
 655
 656 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 657 {
 658         struct sock *sk = sock->sk;
 659         int err = 0;
 660
 661         BT_DBG("sk %p", sk);
 662
 663         lock_sock(sk);
 664
 665         switch (optname) {
 666         default:
 667                 err = -ENOPROTOOPT;
 668                 break;
 669         }
 670
 671         release_sock(sk);
 672         return err;
 673 }
 674
 675 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 676 {
 677         struct sock *sk = sock->sk;
 678         struct sco_options opts;
 679         struct sco_conninfo cinfo;
 680         int len, err = 0;
 681
 682         BT_DBG("sk %p", sk);
 683
 684         if (get_user(len, optlen))
 685                 return -EFAULT;
 686
 687         lock_sock(sk);
 688
 689         switch (optname) {
 690         case SCO_OPTIONS:
 691                 if (sk->sk_state != BT_CONNECTED) {
 692                         err = -ENOTCONN;
 693                         break;
 694                 }
 695
 696                 opts.mtu = sco_pi(sk)->conn->mtu;
 697
 698                 BT_DBG("mtu %d", opts.mtu);
 699
 700                 len = min_t(unsigned int, len, sizeof(opts));
 701                 if (copy_to_user(optval, (char *)&opts, len))
 702                         err = -EFAULT;
 703
 704                 break;
 705
 706         case SCO_CONNINFO:
 707                 if (sk->sk_state != BT_CONNECTED) {
 708                         err = -ENOTCONN;
 709                         break;
 710                 }
 711
 712                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 713                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 714
 715                 len = min_t(unsigned int, len, sizeof(cinfo));
 716                 if (copy_to_user(optval, (char *)&cinfo, len))
 717                         err = -EFAULT;
 718
 719                 break;
 720
 721         default:
 722                 err = -ENOPROTOOPT;
 723                 break;
 724         }
 725
 726         release_sock(sk);
 727         return err;
 728 }
 729
 730 static int sco_sock_release(struct socket *sock)
 731 {
 732         struct sock *sk = sock->sk;
 733         int err = 0;
 734
 735         BT_DBG("sock %p, sk %p", sock, sk);
 736
 737         if (!sk)
 738                 return 0;
 739
 740         sco_sock_close(sk);
 741
 742         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 743                 lock_sock(sk);
 744                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 745                 release_sock(sk);
 746         }
 747
 748         sock_orphan(sk);
 749         sco_sock_kill(sk);
 750         return err;
 751 }
 752
 753 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 754 {
 755         BT_DBG("conn %p", conn);
 756
 757         sco_pi(sk)->conn = conn;
 758         conn->sk = sk;
 759
 760         if (parent)
 761                 bt_accept_enqueue(parent, sk);
 762 }
 763
 764 /* Delete channel.
 765  * Must be called on the locked socket. */
 766 static void sco_chan_del(struct sock *sk, int err)
 767 {
 768         struct sco_conn *conn;
 769
 770         conn = sco_pi(sk)->conn;
 771
 772         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 773
 774         if (conn) {
 775                 sco_conn_lock(conn);
 776                 conn->sk = NULL;
 777                 sco_pi(sk)->conn = NULL;
 778                 sco_conn_unlock(conn);
 779                 hci_conn_put(conn->hcon);
 780         }
 781
 782         sk->sk_state = BT_CLOSED;
 783         sk->sk_err   = err;
 784         sk->sk_state_change(sk);
 785
 786         sock_set_flag(sk, SOCK_ZAPPED);
 787 }
 788
 789 static void sco_conn_ready(struct sco_conn *conn)
 790 {
 791         struct sock *parent, *sk;
 792
 793         BT_DBG("conn %p", conn);
 794
 795         sco_conn_lock(conn);
 796
 797         if ((sk = conn->sk)) {
 798                 sco_sock_clear_timer(sk);
 799                 bh_lock_sock(sk);
 800                 sk->sk_state = BT_CONNECTED;
 801                 sk->sk_state_change(sk);
 802                 bh_unlock_sock(sk);
 803         } else {
 804                 parent = sco_get_sock_listen(conn->src);
 805                 if (!parent)
 806                         goto done;
 807
 808                 bh_lock_sock(parent);
 809
 810                 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
 811                 if (!sk) {
 812                         bh_unlock_sock(parent);
 813                         goto done;
 814                 }
 815
 816                 sco_sock_init(sk, parent);
 817
 818                 bacpy(&bt_sk(sk)->src, conn->src);
 819                 bacpy(&bt_sk(sk)->dst, conn->dst);
 820
 821                 hci_conn_hold(conn->hcon);
 822                 __sco_chan_add(conn, sk, parent);
 823
 824                 sk->sk_state = BT_CONNECTED;
 825
 826                 /* Wake up parent */
 827                 parent->sk_data_ready(parent, 1);
 828
 829                 bh_unlock_sock(parent);
 830         }
 831
 832 done:
 833         sco_conn_unlock(conn);
 834 }
 835
 836 /* ----- SCO interface with lower layer (HCI) ----- */
 837 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 838 {
 839         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 840
 841         /* Always accept connection */
 842         return HCI_LM_ACCEPT;
 843 }
 844
 845 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 846 {
 847         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 848
 849         if (hcon->type != SCO_LINK)
 850                 return 0;
 851
 852         if (!status) {
 853                 struct sco_conn *conn;
 854
 855                 conn = sco_conn_add(hcon, status);
 856                 if (conn)
 857                         sco_conn_ready(conn);
 858         } else
 859                 sco_conn_del(hcon, bt_err(status));
 860
 861         return 0;
 862 }
 863
 864 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
 865 {
 866         BT_DBG("hcon %p reason %d", hcon, reason);
 867
 868         if (hcon->type != SCO_LINK)
 869                 return 0;
 870
 871         sco_conn_del(hcon, bt_err(reason));
 872         return 0;
 873 }
 874
 875 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 876 {
 877         struct sco_conn *conn = hcon->sco_data;
 878
 879         if (!conn)
 880                 goto drop;
 881
 882         BT_DBG("conn %p len %d", conn, skb->len);
 883
 884         if (skb->len) {
 885                 sco_recv_frame(conn, skb);
 886                 return 0;
 887         }
 888
 889 drop:
 890         kfree_skb(skb);
 891         return 0;
 892 }
 893
 894 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
 895 {
 896         struct sock *sk;
 897         struct hlist_node *node;
 898         char *str = buf;
 899
 900         read_lock_bh(&sco_sk_list.lock);
 901
 902         sk_for_each(sk, node, &sco_sk_list.head) {
 903                 str += sprintf(str, "%s %s %d\n",
 904                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 905                                 sk->sk_state);
 906         }
 907
 908         read_unlock_bh(&sco_sk_list.lock);
 909
 910         return (str - buf);
 911 }
 912
 913 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
 914
 915 static const struct proto_ops sco_sock_ops = {
 916         .family         = PF_BLUETOOTH,
 917         .owner          = THIS_MODULE,
 918         .release        = sco_sock_release,
 919         .bind           = sco_sock_bind,
 920         .connect        = sco_sock_connect,
 921         .listen         = sco_sock_listen,
 922         .accept         = sco_sock_accept,
 923         .getname        = sco_sock_getname,
 924         .sendmsg        = sco_sock_sendmsg,
 925         .recvmsg        = bt_sock_recvmsg,
 926         .poll           = bt_sock_poll,
 927         .ioctl          = sock_no_ioctl,
 928         .mmap           = sock_no_mmap,
 929         .socketpair     = sock_no_socketpair,
 930         .shutdown       = sock_no_shutdown,
 931         .setsockopt     = sco_sock_setsockopt,
 932         .getsockopt     = sco_sock_getsockopt
 933 };
 934
 935 static struct net_proto_family sco_sock_family_ops = {
 936         .family = PF_BLUETOOTH,
 937         .owner  = THIS_MODULE,
 938         .create = sco_sock_create,
 939 };
 940
 941 static struct hci_proto sco_hci_proto = {
 942         .name           = "SCO",
 943         .id             = HCI_PROTO_SCO,
 944         .connect_ind    = sco_connect_ind,
 945         .connect_cfm    = sco_connect_cfm,
 946         .disconn_ind    = sco_disconn_ind,
 947         .recv_scodata   = sco_recv_scodata
 948 };
 949
 950 static int __init sco_init(void)
 951 {
 952         int err;
 953
 954         err = proto_register(&sco_proto, 0);
 955         if (err < 0)
 956                 return err;
 957
 958         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
 959         if (err < 0) {
 960                 BT_ERR("SCO socket registration failed");
 961                 goto error;
 962         }
 963
 964         err = hci_register_proto(&sco_hci_proto);
 965         if (err < 0) {
 966                 BT_ERR("SCO protocol registration failed");
 967                 bt_sock_unregister(BTPROTO_SCO);
 968                 goto error;
 969         }
 970
 971         if (class_create_file(bt_class, &class_attr_sco) < 0)
 972                 BT_ERR("Failed to create SCO info file");
 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");