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         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");