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 #include <linux/debugfs.h>
  29 #include <linux/seq_file.h>
  30 #include <linux/sched/signal.h>
  31
  32 #include <net/bluetooth/bluetooth.h>
  33 #include <net/bluetooth/hci_core.h>
  34 #include <net/bluetooth/sco.h>
  35
  36 static bool disable_esco;
  37
  38 static const struct proto_ops sco_sock_ops;
  39
  40 static struct bt_sock_list sco_sk_list = {
  41         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  42 };
  43
  44 /* ---- SCO connections ---- */
  45 struct sco_conn {
  46         struct hci_conn *hcon;
  47
  48         spinlock_t      lock;
  49         struct sock     *sk;
  50
  51         struct delayed_work     timeout_work;
  52
  53         unsigned int    mtu;
  54 };
  55
  56 #define sco_conn_lock(c)        spin_lock(&c->lock);
  57 #define sco_conn_unlock(c)      spin_unlock(&c->lock);
  58
  59 static void sco_sock_close(struct sock *sk);
  60 static void sco_sock_kill(struct sock *sk);
  61
  62 /* ----- SCO socket info ----- */
  63 #define sco_pi(sk) ((struct sco_pinfo *) sk)
  64
  65 struct sco_pinfo {
  66         struct bt_sock  bt;
  67         bdaddr_t        src;
  68         bdaddr_t        dst;
  69         __u32           flags;
  70         __u16           setting;
  71         struct sco_conn *conn;
  72 };
  73
  74 /* ---- SCO timers ---- */
  75 #define SCO_CONN_TIMEOUT        (HZ * 40)
  76 #define SCO_DISCONN_TIMEOUT     (HZ * 2)
  77
  78 static void sco_sock_timeout(struct work_struct *work)
  79 {
  80         struct sco_conn *conn = container_of(work, struct sco_conn,
  81                                              timeout_work.work);
  82         struct sock *sk;
  83
  84         sco_conn_lock(conn);
  85         sk = conn->sk;
  86         if (sk)
  87                 sock_hold(sk);
  88         sco_conn_unlock(conn);
  89
  90         if (!sk)
  91                 return;
  92
  93         BT_DBG("sock %p state %d", sk, sk->sk_state);
  94
  95         bh_lock_sock(sk);
  96         sk->sk_err = ETIMEDOUT;
  97         sk->sk_state_change(sk);
  98         bh_unlock_sock(sk);
  99
 100         sock_put(sk);
 101 }
 102
 103 static void sco_sock_set_timer(struct sock *sk, long timeout)
 104 {
 105         if (!sco_pi(sk)->conn)
 106                 return;
 107
 108         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
 109         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
 110         schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
 111 }
 112
 113 static void sco_sock_clear_timer(struct sock *sk)
 114 {
 115         if (!sco_pi(sk)->conn)
 116                 return;
 117
 118         BT_DBG("sock %p state %d", sk, sk->sk_state);
 119         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
 120 }
 121
 122 /* ---- SCO connections ---- */
 123 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
 124 {
 125         struct hci_dev *hdev = hcon->hdev;
 126         struct sco_conn *conn = hcon->sco_data;
 127
 128         if (conn)
 129                 return conn;
 130
 131         conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
 132         if (!conn)
 133                 return NULL;
 134
 135         spin_lock_init(&conn->lock);
 136         INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
 137
 138         hcon->sco_data = conn;
 139         conn->hcon = hcon;
 140
 141         if (hdev->sco_mtu > 0)
 142                 conn->mtu = hdev->sco_mtu;
 143         else
 144                 conn->mtu = 60;
 145
 146         BT_DBG("hcon %p conn %p", hcon, conn);
 147
 148         return conn;
 149 }
 150
 151 /* Delete channel.
 152  * Must be called on the locked socket. */
 153 static void sco_chan_del(struct sock *sk, int err)
 154 {
 155         struct sco_conn *conn;
 156
 157         conn = sco_pi(sk)->conn;
 158
 159         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 160
 161         if (conn) {
 162                 sco_conn_lock(conn);
 163                 conn->sk = NULL;
 164                 sco_pi(sk)->conn = NULL;
 165                 sco_conn_unlock(conn);
 166
 167                 if (conn->hcon)
 168                         hci_conn_drop(conn->hcon);
 169         }
 170
 171         sk->sk_state = BT_CLOSED;
 172         sk->sk_err   = err;
 173         sk->sk_state_change(sk);
 174
 175         sock_set_flag(sk, SOCK_ZAPPED);
 176 }
 177
 178 static void sco_conn_del(struct hci_conn *hcon, int err)
 179 {
 180         struct sco_conn *conn = hcon->sco_data;
 181         struct sock *sk;
 182
 183         if (!conn)
 184                 return;
 185
 186         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 187
 188         /* Kill socket */
 189         sco_conn_lock(conn);
 190         sk = conn->sk;
 191         sco_conn_unlock(conn);
 192
 193         if (sk) {
 194                 sock_hold(sk);
 195                 bh_lock_sock(sk);
 196                 sco_sock_clear_timer(sk);
 197                 sco_chan_del(sk, err);
 198                 bh_unlock_sock(sk);
 199                 sock_put(sk);
 200         }
 201
 202         /* Ensure no more work items will run before freeing conn. */
 203         cancel_delayed_work_sync(&conn->timeout_work);
 204
 205         hcon->sco_data = NULL;
 206         kfree(conn);
 207 }
 208
 209 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
 210                            struct sock *parent)
 211 {
 212         BT_DBG("conn %p", conn);
 213
 214         sco_pi(sk)->conn = conn;
 215         conn->sk = sk;
 216
 217         if (parent)
 218                 bt_accept_enqueue(parent, sk, true);
 219 }
 220
 221 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
 222                         struct sock *parent)
 223 {
 224         int err = 0;
 225
 226         sco_conn_lock(conn);
 227         if (conn->sk)
 228                 err = -EBUSY;
 229         else
 230                 __sco_chan_add(conn, sk, parent);
 231
 232         sco_conn_unlock(conn);
 233         return err;
 234 }
 235
 236 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
 237 {
 238         struct sco_conn *conn;
 239         struct hci_conn *hcon;
 240         int err, type;
 241
 242         BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
 243
 244         if (lmp_esco_capable(hdev) && !disable_esco)
 245                 type = ESCO_LINK;
 246         else
 247                 type = SCO_LINK;
 248
 249         if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
 250             (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
 251                 return -EOPNOTSUPP;
 252
 253         hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
 254                                sco_pi(sk)->setting);
 255         if (IS_ERR(hcon))
 256                 return PTR_ERR(hcon);
 257
 258         conn = sco_conn_add(hcon);
 259         if (!conn) {
 260                 hci_conn_drop(hcon);
 261                 return -ENOMEM;
 262         }
 263
 264         /* Update source addr of the socket */
 265         bacpy(&sco_pi(sk)->src, &hcon->src);
 266
 267         err = sco_chan_add(conn, sk, NULL);
 268         if (err)
 269                 return err;
 270
 271         if (hcon->state == BT_CONNECTED) {
 272                 sco_sock_clear_timer(sk);
 273                 sk->sk_state = BT_CONNECTED;
 274         } else {
 275                 sk->sk_state = BT_CONNECT;
 276                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 277         }
 278
 279         return err;
 280 }
 281
 282 static int sco_send_frame(struct sock *sk, void *buf, int len,
 283                           unsigned int msg_flags)
 284 {
 285         struct sco_conn *conn = sco_pi(sk)->conn;
 286         struct sk_buff *skb;
 287         int err;
 288
 289         /* Check outgoing MTU */
 290         if (len > conn->mtu)
 291                 return -EINVAL;
 292
 293         BT_DBG("sk %p len %d", sk, len);
 294
 295         skb = bt_skb_send_alloc(sk, len, msg_flags & MSG_DONTWAIT, &err);
 296         if (!skb)
 297                 return err;
 298
 299         memcpy(skb_put(skb, len), buf, len);
 300         hci_send_sco(conn->hcon, skb);
 301
 302         return len;
 303 }
 304
 305 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 306 {
 307         struct sock *sk;
 308
 309         sco_conn_lock(conn);
 310         sk = conn->sk;
 311         sco_conn_unlock(conn);
 312
 313         if (!sk)
 314                 goto drop;
 315
 316         BT_DBG("sk %p len %d", sk, skb->len);
 317
 318         if (sk->sk_state != BT_CONNECTED)
 319                 goto drop;
 320
 321         if (!sock_queue_rcv_skb(sk, skb))
 322                 return;
 323
 324 drop:
 325         kfree_skb(skb);
 326 }
 327
 328 /* -------- Socket interface ---------- */
 329 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
 330 {
 331         struct sock *sk;
 332
 333         sk_for_each(sk, &sco_sk_list.head) {
 334                 if (sk->sk_state != BT_LISTEN)
 335                         continue;
 336
 337                 if (!bacmp(&sco_pi(sk)->src, ba))
 338                         return sk;
 339         }
 340
 341         return NULL;
 342 }
 343
 344 /* Find socket listening on source bdaddr.
 345  * Returns closest match.
 346  */
 347 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 348 {
 349         struct sock *sk = NULL, *sk1 = NULL;
 350
 351         read_lock(&sco_sk_list.lock);
 352
 353         sk_for_each(sk, &sco_sk_list.head) {
 354                 if (sk->sk_state != BT_LISTEN)
 355                         continue;
 356
 357                 /* Exact match. */
 358                 if (!bacmp(&sco_pi(sk)->src, src))
 359                         break;
 360
 361                 /* Closest match */
 362                 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
 363                         sk1 = sk;
 364         }
 365
 366         read_unlock(&sco_sk_list.lock);
 367
 368         return sk ? sk : sk1;
 369 }
 370
 371 static void sco_sock_destruct(struct sock *sk)
 372 {
 373         BT_DBG("sk %p", sk);
 374
 375         skb_queue_purge(&sk->sk_receive_queue);
 376         skb_queue_purge(&sk->sk_write_queue);
 377 }
 378
 379 static void sco_sock_cleanup_listen(struct sock *parent)
 380 {
 381         struct sock *sk;
 382
 383         BT_DBG("parent %p", parent);
 384
 385         /* Close not yet accepted channels */
 386         while ((sk = bt_accept_dequeue(parent, NULL))) {
 387                 sco_sock_close(sk);
 388                 sco_sock_kill(sk);
 389         }
 390
 391         parent->sk_state  = BT_CLOSED;
 392         sock_set_flag(parent, SOCK_ZAPPED);
 393 }
 394
 395 /* Kill socket (only if zapped and orphan)
 396  * Must be called on unlocked socket.
 397  */
 398 static void sco_sock_kill(struct sock *sk)
 399 {
 400         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 401                 return;
 402
 403         BT_DBG("sk %p state %d", sk, sk->sk_state);
 404
 405         /* Kill poor orphan */
 406         bt_sock_unlink(&sco_sk_list, sk);
 407         sock_set_flag(sk, SOCK_DEAD);
 408         sock_put(sk);
 409 }
 410
 411 static void __sco_sock_close(struct sock *sk)
 412 {
 413         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 414
 415         switch (sk->sk_state) {
 416         case BT_LISTEN:
 417                 sco_sock_cleanup_listen(sk);
 418                 break;
 419
 420         case BT_CONNECTED:
 421         case BT_CONFIG:
 422                 if (sco_pi(sk)->conn->hcon) {
 423                         sk->sk_state = BT_DISCONN;
 424                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 425                         sco_conn_lock(sco_pi(sk)->conn);
 426                         hci_conn_drop(sco_pi(sk)->conn->hcon);
 427                         sco_pi(sk)->conn->hcon = NULL;
 428                         sco_conn_unlock(sco_pi(sk)->conn);
 429                 } else
 430                         sco_chan_del(sk, ECONNRESET);
 431                 break;
 432
 433         case BT_CONNECT2:
 434         case BT_CONNECT:
 435         case BT_DISCONN:
 436                 sco_chan_del(sk, ECONNRESET);
 437                 break;
 438
 439         default:
 440                 sock_set_flag(sk, SOCK_ZAPPED);
 441                 break;
 442         }
 443 }
 444
 445 /* Must be called on unlocked socket. */
 446 static void sco_sock_close(struct sock *sk)
 447 {
 448         sco_sock_clear_timer(sk);
 449         lock_sock(sk);
 450         __sco_sock_close(sk);
 451         release_sock(sk);
 452 }
 453
 454 static void sco_sock_init(struct sock *sk, struct sock *parent)
 455 {
 456         BT_DBG("sk %p", sk);
 457
 458         if (parent) {
 459                 sk->sk_type = parent->sk_type;
 460                 bt_sk(sk)->flags = bt_sk(parent)->flags;
 461                 security_sk_clone(parent, sk);
 462         }
 463 }
 464
 465 static struct proto sco_proto = {
 466         .name           = "SCO",
 467         .owner          = THIS_MODULE,
 468         .obj_size       = sizeof(struct sco_pinfo)
 469 };
 470
 471 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
 472                                    int proto, gfp_t prio, int kern)
 473 {
 474         struct sock *sk;
 475
 476         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
 477         if (!sk)
 478                 return NULL;
 479
 480         sock_init_data(sock, sk);
 481         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 482
 483         sk->sk_destruct = sco_sock_destruct;
 484         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 485
 486         sock_reset_flag(sk, SOCK_ZAPPED);
 487
 488         sk->sk_protocol = proto;
 489         sk->sk_state    = BT_OPEN;
 490
 491         sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
 492
 493         bt_sock_link(&sco_sk_list, sk);
 494         return sk;
 495 }
 496
 497 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 498                            int kern)
 499 {
 500         struct sock *sk;
 501
 502         BT_DBG("sock %p", sock);
 503
 504         sock->state = SS_UNCONNECTED;
 505
 506         if (sock->type != SOCK_SEQPACKET)
 507                 return -ESOCKTNOSUPPORT;
 508
 509         sock->ops = &sco_sock_ops;
 510
 511         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
 512         if (!sk)
 513                 return -ENOMEM;
 514
 515         sco_sock_init(sk, NULL);
 516         return 0;
 517 }
 518
 519 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
 520                          int addr_len)
 521 {
 522         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 523         struct sock *sk = sock->sk;
 524         int err = 0;
 525
 526         if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
 527             addr->sa_family != AF_BLUETOOTH)
 528                 return -EINVAL;
 529
 530         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 531
 532         lock_sock(sk);
 533
 534         if (sk->sk_state != BT_OPEN) {
 535                 err = -EBADFD;
 536                 goto done;
 537         }
 538
 539         if (sk->sk_type != SOCK_SEQPACKET) {
 540                 err = -EINVAL;
 541                 goto done;
 542         }
 543
 544         bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
 545
 546         sk->sk_state = BT_BOUND;
 547
 548 done:
 549         release_sock(sk);
 550         return err;
 551 }
 552
 553 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 554 {
 555         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 556         struct sock *sk = sock->sk;
 557         struct hci_dev  *hdev;
 558         int err;
 559
 560         BT_DBG("sk %p", sk);
 561
 562         if (alen < sizeof(struct sockaddr_sco) ||
 563             addr->sa_family != AF_BLUETOOTH)
 564                 return -EINVAL;
 565
 566         lock_sock(sk);
 567         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
 568                 err = -EBADFD;
 569                 goto done;
 570         }
 571
 572         if (sk->sk_type != SOCK_SEQPACKET) {
 573                 err = -EINVAL;
 574                 goto done;
 575         }
 576
 577         hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
 578         if (!hdev) {
 579                 err = -EHOSTUNREACH;
 580                 goto done;
 581         }
 582         hci_dev_lock(hdev);
 583
 584         /* Set destination address and psm */
 585         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
 586
 587         err = sco_connect(hdev, sk);
 588         hci_dev_unlock(hdev);
 589         hci_dev_put(hdev);
 590         if (err)
 591                 goto done;
 592
 593         err = bt_sock_wait_state(sk, BT_CONNECTED,
 594                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 595
 596 done:
 597         release_sock(sk);
 598         return err;
 599 }
 600
 601 static int sco_sock_listen(struct socket *sock, int backlog)
 602 {
 603         struct sock *sk = sock->sk;
 604         bdaddr_t *src = &sco_pi(sk)->src;
 605         int err = 0;
 606
 607         BT_DBG("sk %p backlog %d", sk, backlog);
 608
 609         lock_sock(sk);
 610
 611         if (sk->sk_state != BT_BOUND) {
 612                 err = -EBADFD;
 613                 goto done;
 614         }
 615
 616         if (sk->sk_type != SOCK_SEQPACKET) {
 617                 err = -EINVAL;
 618                 goto done;
 619         }
 620
 621         write_lock(&sco_sk_list.lock);
 622
 623         if (__sco_get_sock_listen_by_addr(src)) {
 624                 err = -EADDRINUSE;
 625                 goto unlock;
 626         }
 627
 628         sk->sk_max_ack_backlog = backlog;
 629         sk->sk_ack_backlog = 0;
 630
 631         sk->sk_state = BT_LISTEN;
 632
 633 unlock:
 634         write_unlock(&sco_sk_list.lock);
 635
 636 done:
 637         release_sock(sk);
 638         return err;
 639 }
 640
 641 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
 642                            int flags, bool kern)
 643 {
 644         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 645         struct sock *sk = sock->sk, *ch;
 646         long timeo;
 647         int err = 0;
 648
 649         lock_sock(sk);
 650
 651         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 652
 653         BT_DBG("sk %p timeo %ld", sk, timeo);
 654
 655         /* Wait for an incoming connection. (wake-one). */
 656         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 657         while (1) {
 658                 if (sk->sk_state != BT_LISTEN) {
 659                         err = -EBADFD;
 660                         break;
 661                 }
 662
 663                 ch = bt_accept_dequeue(sk, newsock);
 664                 if (ch)
 665                         break;
 666
 667                 if (!timeo) {
 668                         err = -EAGAIN;
 669                         break;
 670                 }
 671
 672                 if (signal_pending(current)) {
 673                         err = sock_intr_errno(timeo);
 674                         break;
 675                 }
 676
 677                 release_sock(sk);
 678
 679                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 680                 lock_sock(sk);
 681         }
 682         remove_wait_queue(sk_sleep(sk), &wait);
 683
 684         if (err)
 685                 goto done;
 686
 687         newsock->state = SS_CONNECTED;
 688
 689         BT_DBG("new socket %p", ch);
 690
 691 done:
 692         release_sock(sk);
 693         return err;
 694 }
 695
 696 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
 697                             int peer)
 698 {
 699         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 700         struct sock *sk = sock->sk;
 701
 702         BT_DBG("sock %p, sk %p", sock, sk);
 703
 704         addr->sa_family = AF_BLUETOOTH;
 705
 706         if (peer)
 707                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
 708         else
 709                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
 710
 711         return sizeof(struct sockaddr_sco);
 712 }
 713
 714 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 715                             size_t len)
 716 {
 717         struct sock *sk = sock->sk;
 718         void *buf;
 719         int err;
 720
 721         BT_DBG("sock %p, sk %p", sock, sk);
 722
 723         err = sock_error(sk);
 724         if (err)
 725                 return err;
 726
 727         if (msg->msg_flags & MSG_OOB)
 728                 return -EOPNOTSUPP;
 729
 730         buf = kmalloc(len, GFP_KERNEL);
 731         if (!buf)
 732                 return -ENOMEM;
 733
 734         if (memcpy_from_msg(buf, msg, len)) {
 735                 kfree(buf);
 736                 return -EFAULT;
 737         }
 738
 739         lock_sock(sk);
 740
 741         if (sk->sk_state == BT_CONNECTED)
 742                 err = sco_send_frame(sk, buf, len, msg->msg_flags);
 743         else
 744                 err = -ENOTCONN;
 745
 746         release_sock(sk);
 747         kfree(buf);
 748         return err;
 749 }
 750
 751 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
 752 {
 753         struct hci_dev *hdev = conn->hdev;
 754
 755         BT_DBG("conn %p", conn);
 756
 757         conn->state = BT_CONFIG;
 758
 759         if (!lmp_esco_capable(hdev)) {
 760                 struct hci_cp_accept_conn_req cp;
 761
 762                 bacpy(&cp.bdaddr, &conn->dst);
 763                 cp.role = 0x00; /* Ignored */
 764
 765                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 766         } else {
 767                 struct hci_cp_accept_sync_conn_req cp;
 768
 769                 bacpy(&cp.bdaddr, &conn->dst);
 770                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
 771
 772                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 773                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 774                 cp.content_format = cpu_to_le16(setting);
 775
 776                 switch (setting & SCO_AIRMODE_MASK) {
 777                 case SCO_AIRMODE_TRANSP:
 778                         if (conn->pkt_type & ESCO_2EV3)
 779                                 cp.max_latency = cpu_to_le16(0x0008);
 780                         else
 781                                 cp.max_latency = cpu_to_le16(0x000D);
 782                         cp.retrans_effort = 0x02;
 783                         break;
 784                 case SCO_AIRMODE_CVSD:
 785                         cp.max_latency = cpu_to_le16(0xffff);
 786                         cp.retrans_effort = 0xff;
 787                         break;
 788                 default:
 789                         /* use CVSD settings as fallback */
 790                         cp.max_latency = cpu_to_le16(0xffff);
 791                         cp.retrans_effort = 0xff;
 792                         break;
 793                 }
 794
 795                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 796                              sizeof(cp), &cp);
 797         }
 798 }
 799
 800 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 801                             size_t len, int flags)
 802 {
 803         struct sock *sk = sock->sk;
 804         struct sco_pinfo *pi = sco_pi(sk);
 805
 806         lock_sock(sk);
 807
 808         if (sk->sk_state == BT_CONNECT2 &&
 809             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 810                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
 811                 sk->sk_state = BT_CONFIG;
 812
 813                 release_sock(sk);
 814                 return 0;
 815         }
 816
 817         release_sock(sk);
 818
 819         return bt_sock_recvmsg(sock, msg, len, flags);
 820 }
 821
 822 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
 823                                char __user *optval, unsigned int optlen)
 824 {
 825         struct sock *sk = sock->sk;
 826         int len, err = 0;
 827         struct bt_voice voice;
 828         u32 opt;
 829
 830         BT_DBG("sk %p", sk);
 831
 832         lock_sock(sk);
 833
 834         switch (optname) {
 835
 836         case BT_DEFER_SETUP:
 837                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 838                         err = -EINVAL;
 839                         break;
 840                 }
 841
 842                 if (get_user(opt, (u32 __user *) optval)) {
 843                         err = -EFAULT;
 844                         break;
 845                 }
 846
 847                 if (opt)
 848                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 849                 else
 850                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 851                 break;
 852
 853         case BT_VOICE:
 854                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
 855                     sk->sk_state != BT_CONNECT2) {
 856                         err = -EINVAL;
 857                         break;
 858                 }
 859
 860                 voice.setting = sco_pi(sk)->setting;
 861
 862                 len = min_t(unsigned int, sizeof(voice), optlen);
 863                 if (copy_from_user((char *)&voice, optval, len)) {
 864                         err = -EFAULT;
 865                         break;
 866                 }
 867
 868                 /* Explicitly check for these values */
 869                 if (voice.setting != BT_VOICE_TRANSPARENT &&
 870                     voice.setting != BT_VOICE_CVSD_16BIT) {
 871                         err = -EINVAL;
 872                         break;
 873                 }
 874
 875                 sco_pi(sk)->setting = voice.setting;
 876                 break;
 877
 878         default:
 879                 err = -ENOPROTOOPT;
 880                 break;
 881         }
 882
 883         release_sock(sk);
 884         return err;
 885 }
 886
 887 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
 888                                    char __user *optval, int __user *optlen)
 889 {
 890         struct sock *sk = sock->sk;
 891         struct sco_options opts;
 892         struct sco_conninfo cinfo;
 893         int len, err = 0;
 894
 895         BT_DBG("sk %p", sk);
 896
 897         if (get_user(len, optlen))
 898                 return -EFAULT;
 899
 900         lock_sock(sk);
 901
 902         switch (optname) {
 903         case SCO_OPTIONS:
 904                 if (sk->sk_state != BT_CONNECTED &&
 905                     !(sk->sk_state == BT_CONNECT2 &&
 906                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 907                         err = -ENOTCONN;
 908                         break;
 909                 }
 910
 911                 opts.mtu = sco_pi(sk)->conn->mtu;
 912
 913                 BT_DBG("mtu %d", opts.mtu);
 914
 915                 len = min_t(unsigned int, len, sizeof(opts));
 916                 if (copy_to_user(optval, (char *)&opts, len))
 917                         err = -EFAULT;
 918
 919                 break;
 920
 921         case SCO_CONNINFO:
 922                 if (sk->sk_state != BT_CONNECTED &&
 923                     !(sk->sk_state == BT_CONNECT2 &&
 924                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 925                         err = -ENOTCONN;
 926                         break;
 927                 }
 928
 929                 memset(&cinfo, 0, sizeof(cinfo));
 930                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 931                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 932
 933                 len = min_t(unsigned int, len, sizeof(cinfo));
 934                 if (copy_to_user(optval, (char *)&cinfo, len))
 935                         err = -EFAULT;
 936
 937                 break;
 938
 939         default:
 940                 err = -ENOPROTOOPT;
 941                 break;
 942         }
 943
 944         release_sock(sk);
 945         return err;
 946 }
 947
 948 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
 949                                char __user *optval, int __user *optlen)
 950 {
 951         struct sock *sk = sock->sk;
 952         int len, err = 0;
 953         struct bt_voice voice;
 954
 955         BT_DBG("sk %p", sk);
 956
 957         if (level == SOL_SCO)
 958                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 959
 960         if (get_user(len, optlen))
 961                 return -EFAULT;
 962
 963         lock_sock(sk);
 964
 965         switch (optname) {
 966
 967         case BT_DEFER_SETUP:
 968                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 969                         err = -EINVAL;
 970                         break;
 971                 }
 972
 973                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 974                              (u32 __user *)optval))
 975                         err = -EFAULT;
 976
 977                 break;
 978
 979         case BT_VOICE:
 980                 voice.setting = sco_pi(sk)->setting;
 981
 982                 len = min_t(unsigned int, len, sizeof(voice));
 983                 if (copy_to_user(optval, (char *)&voice, len))
 984                         err = -EFAULT;
 985
 986                 break;
 987
 988         default:
 989                 err = -ENOPROTOOPT;
 990                 break;
 991         }
 992
 993         release_sock(sk);
 994         return err;
 995 }
 996
 997 static int sco_sock_shutdown(struct socket *sock, int how)
 998 {
 999         struct sock *sk = sock->sk;
1000         int err = 0;
1001
1002         BT_DBG("sock %p, sk %p", sock, sk);
1003
1004         if (!sk)
1005                 return 0;
1006
1007         sock_hold(sk);
1008         lock_sock(sk);
1009
1010         if (!sk->sk_shutdown) {
1011                 sk->sk_shutdown = SHUTDOWN_MASK;
1012                 sco_sock_clear_timer(sk);
1013                 __sco_sock_close(sk);
1014
1015                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1016                     !(current->flags & PF_EXITING))
1017                         err = bt_sock_wait_state(sk, BT_CLOSED,
1018                                                  sk->sk_lingertime);
1019         }
1020
1021         release_sock(sk);
1022         sock_put(sk);
1023
1024         return err;
1025 }
1026
1027 static int sco_sock_release(struct socket *sock)
1028 {
1029         struct sock *sk = sock->sk;
1030         int err = 0;
1031
1032         BT_DBG("sock %p, sk %p", sock, sk);
1033
1034         if (!sk)
1035                 return 0;
1036
1037         sco_sock_close(sk);
1038
1039         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1040             !(current->flags & PF_EXITING)) {
1041                 lock_sock(sk);
1042                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1043                 release_sock(sk);
1044         }
1045
1046         sock_orphan(sk);
1047         sco_sock_kill(sk);
1048         return err;
1049 }
1050
1051 static void sco_conn_ready(struct sco_conn *conn)
1052 {
1053         struct sock *parent;
1054         struct sock *sk = conn->sk;
1055
1056         BT_DBG("conn %p", conn);
1057
1058         if (sk) {
1059                 sco_sock_clear_timer(sk);
1060                 bh_lock_sock(sk);
1061                 sk->sk_state = BT_CONNECTED;
1062                 sk->sk_state_change(sk);
1063                 bh_unlock_sock(sk);
1064         } else {
1065                 sco_conn_lock(conn);
1066
1067                 if (!conn->hcon) {
1068                         sco_conn_unlock(conn);
1069                         return;
1070                 }
1071
1072                 parent = sco_get_sock_listen(&conn->hcon->src);
1073                 if (!parent) {
1074                         sco_conn_unlock(conn);
1075                         return;
1076                 }
1077
1078                 bh_lock_sock(parent);
1079
1080                 sk = sco_sock_alloc(sock_net(parent), NULL,
1081                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1082                 if (!sk) {
1083                         bh_unlock_sock(parent);
1084                         sco_conn_unlock(conn);
1085                         return;
1086                 }
1087
1088                 sco_sock_init(sk, parent);
1089
1090                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1091                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1092
1093                 hci_conn_hold(conn->hcon);
1094                 __sco_chan_add(conn, sk, parent);
1095
1096                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1097                         sk->sk_state = BT_CONNECT2;
1098                 else
1099                         sk->sk_state = BT_CONNECTED;
1100
1101                 /* Wake up parent */
1102                 parent->sk_data_ready(parent);
1103
1104                 bh_unlock_sock(parent);
1105
1106                 sco_conn_unlock(conn);
1107         }
1108 }
1109
1110 /* ----- SCO interface with lower layer (HCI) ----- */
1111 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1112 {
1113         struct sock *sk;
1114         int lm = 0;
1115
1116         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1117
1118         /* Find listening sockets */
1119         read_lock(&sco_sk_list.lock);
1120         sk_for_each(sk, &sco_sk_list.head) {
1121                 if (sk->sk_state != BT_LISTEN)
1122                         continue;
1123
1124                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1125                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1126                         lm |= HCI_LM_ACCEPT;
1127
1128                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1129                                 *flags |= HCI_PROTO_DEFER;
1130                         break;
1131                 }
1132         }
1133         read_unlock(&sco_sk_list.lock);
1134
1135         return lm;
1136 }
1137
1138 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1139 {
1140         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1141                 return;
1142
1143         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1144
1145         if (!status) {
1146                 struct sco_conn *conn;
1147
1148                 conn = sco_conn_add(hcon);
1149                 if (conn)
1150                         sco_conn_ready(conn);
1151         } else
1152                 sco_conn_del(hcon, bt_to_errno(status));
1153 }
1154
1155 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1156 {
1157         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1158                 return;
1159
1160         BT_DBG("hcon %p reason %d", hcon, reason);
1161
1162         sco_conn_del(hcon, bt_to_errno(reason));
1163 }
1164
1165 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1166 {
1167         struct sco_conn *conn = hcon->sco_data;
1168
1169         if (!conn)
1170                 goto drop;
1171
1172         BT_DBG("conn %p len %d", conn, skb->len);
1173
1174         if (skb->len) {
1175                 sco_recv_frame(conn, skb);
1176                 return;
1177         }
1178
1179 drop:
1180         kfree_skb(skb);
1181 }
1182
1183 static struct hci_cb sco_cb = {
1184         .name           = "SCO",
1185         .connect_cfm    = sco_connect_cfm,
1186         .disconn_cfm    = sco_disconn_cfm,
1187 };
1188
1189 static int sco_debugfs_show(struct seq_file *f, void *p)
1190 {
1191         struct sock *sk;
1192
1193         read_lock(&sco_sk_list.lock);
1194
1195         sk_for_each(sk, &sco_sk_list.head) {
1196                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1197                            &sco_pi(sk)->dst, sk->sk_state);
1198         }
1199
1200         read_unlock(&sco_sk_list.lock);
1201
1202         return 0;
1203 }
1204
1205 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1206
1207 static struct dentry *sco_debugfs;
1208
1209 static const struct proto_ops sco_sock_ops = {
1210         .family         = PF_BLUETOOTH,
1211         .owner          = THIS_MODULE,
1212         .release        = sco_sock_release,
1213         .bind           = sco_sock_bind,
1214         .connect        = sco_sock_connect,
1215         .listen         = sco_sock_listen,
1216         .accept         = sco_sock_accept,
1217         .getname        = sco_sock_getname,
1218         .sendmsg        = sco_sock_sendmsg,
1219         .recvmsg        = sco_sock_recvmsg,
1220         .poll           = bt_sock_poll,
1221         .ioctl          = bt_sock_ioctl,
1222         .gettstamp      = sock_gettstamp,
1223         .mmap           = sock_no_mmap,
1224         .socketpair     = sock_no_socketpair,
1225         .shutdown       = sco_sock_shutdown,
1226         .setsockopt     = sco_sock_setsockopt,
1227         .getsockopt     = sco_sock_getsockopt
1228 };
1229
1230 static const struct net_proto_family sco_sock_family_ops = {
1231         .family = PF_BLUETOOTH,
1232         .owner  = THIS_MODULE,
1233         .create = sco_sock_create,
1234 };
1235
1236 int __init sco_init(void)
1237 {
1238         int err;
1239
1240         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1241
1242         err = proto_register(&sco_proto, 0);
1243         if (err < 0)
1244                 return err;
1245
1246         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1247         if (err < 0) {
1248                 BT_ERR("SCO socket registration failed");
1249                 goto error;
1250         }
1251
1252         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1253         if (err < 0) {
1254                 BT_ERR("Failed to create SCO proc file");
1255                 bt_sock_unregister(BTPROTO_SCO);
1256                 goto error;
1257         }
1258
1259         BT_INFO("SCO socket layer initialized");
1260
1261         hci_register_cb(&sco_cb);
1262
1263         if (IS_ERR_OR_NULL(bt_debugfs))
1264                 return 0;
1265
1266         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1267                                           NULL, &sco_debugfs_fops);
1268
1269         return 0;
1270
1271 error:
1272         proto_unregister(&sco_proto);
1273         return err;
1274 }
1275
1276 void sco_exit(void)
1277 {
1278         bt_procfs_cleanup(&init_net, "sco");
1279
1280         debugfs_remove(sco_debugfs);
1281
1282         hci_unregister_cb(&sco_cb);
1283
1284         bt_sock_unregister(BTPROTO_SCO);
1285
1286         proto_unregister(&sco_proto);
1287 }
1288
1289 module_param(disable_esco, bool, 0644);
1290 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");