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         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 527
 528         if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
 529             addr->sa_family != AF_BLUETOOTH)
 530                 return -EINVAL;
 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         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 567                 return -EBADFD;
 568
 569         if (sk->sk_type != SOCK_SEQPACKET)
 570                 return -EINVAL;
 571
 572         hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
 573         if (!hdev)
 574                 return -EHOSTUNREACH;
 575         hci_dev_lock(hdev);
 576
 577         lock_sock(sk);
 578
 579         /* Set destination address and psm */
 580         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
 581
 582         err = sco_connect(hdev, sk);
 583         hci_dev_unlock(hdev);
 584         hci_dev_put(hdev);
 585         if (err)
 586                 goto done;
 587
 588         err = bt_sock_wait_state(sk, BT_CONNECTED,
 589                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 590
 591 done:
 592         release_sock(sk);
 593         return err;
 594 }
 595
 596 static int sco_sock_listen(struct socket *sock, int backlog)
 597 {
 598         struct sock *sk = sock->sk;
 599         bdaddr_t *src = &sco_pi(sk)->src;
 600         int err = 0;
 601
 602         BT_DBG("sk %p backlog %d", sk, backlog);
 603
 604         lock_sock(sk);
 605
 606         if (sk->sk_state != BT_BOUND) {
 607                 err = -EBADFD;
 608                 goto done;
 609         }
 610
 611         if (sk->sk_type != SOCK_SEQPACKET) {
 612                 err = -EINVAL;
 613                 goto done;
 614         }
 615
 616         write_lock(&sco_sk_list.lock);
 617
 618         if (__sco_get_sock_listen_by_addr(src)) {
 619                 err = -EADDRINUSE;
 620                 goto unlock;
 621         }
 622
 623         sk->sk_max_ack_backlog = backlog;
 624         sk->sk_ack_backlog = 0;
 625
 626         sk->sk_state = BT_LISTEN;
 627
 628 unlock:
 629         write_unlock(&sco_sk_list.lock);
 630
 631 done:
 632         release_sock(sk);
 633         return err;
 634 }
 635
 636 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
 637                            int flags, bool kern)
 638 {
 639         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 640         struct sock *sk = sock->sk, *ch;
 641         long timeo;
 642         int err = 0;
 643
 644         lock_sock(sk);
 645
 646         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 647
 648         BT_DBG("sk %p timeo %ld", sk, timeo);
 649
 650         /* Wait for an incoming connection. (wake-one). */
 651         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 652         while (1) {
 653                 if (sk->sk_state != BT_LISTEN) {
 654                         err = -EBADFD;
 655                         break;
 656                 }
 657
 658                 ch = bt_accept_dequeue(sk, newsock);
 659                 if (ch)
 660                         break;
 661
 662                 if (!timeo) {
 663                         err = -EAGAIN;
 664                         break;
 665                 }
 666
 667                 if (signal_pending(current)) {
 668                         err = sock_intr_errno(timeo);
 669                         break;
 670                 }
 671
 672                 release_sock(sk);
 673
 674                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 675                 lock_sock(sk);
 676         }
 677         remove_wait_queue(sk_sleep(sk), &wait);
 678
 679         if (err)
 680                 goto done;
 681
 682         newsock->state = SS_CONNECTED;
 683
 684         BT_DBG("new socket %p", ch);
 685
 686 done:
 687         release_sock(sk);
 688         return err;
 689 }
 690
 691 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
 692                             int *len, int peer)
 693 {
 694         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 695         struct sock *sk = sock->sk;
 696
 697         BT_DBG("sock %p, sk %p", sock, sk);
 698
 699         addr->sa_family = AF_BLUETOOTH;
 700         *len = sizeof(struct sockaddr_sco);
 701
 702         if (peer)
 703                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
 704         else
 705                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
 706
 707         return 0;
 708 }
 709
 710 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 711                             size_t len)
 712 {
 713         struct sock *sk = sock->sk;
 714         void *buf;
 715         int err;
 716
 717         BT_DBG("sock %p, sk %p", sock, sk);
 718
 719         err = sock_error(sk);
 720         if (err)
 721                 return err;
 722
 723         if (msg->msg_flags & MSG_OOB)
 724                 return -EOPNOTSUPP;
 725
 726         buf = kmalloc(len, GFP_KERNEL);
 727         if (!buf)
 728                 return -ENOMEM;
 729
 730         if (memcpy_from_msg(buf, msg, len)) {
 731                 kfree(buf);
 732                 return -EFAULT;
 733         }
 734
 735         lock_sock(sk);
 736
 737         if (sk->sk_state == BT_CONNECTED)
 738                 err = sco_send_frame(sk, buf, len, msg->msg_flags);
 739         else
 740                 err = -ENOTCONN;
 741
 742         release_sock(sk);
 743         kfree(buf);
 744         return err;
 745 }
 746
 747 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
 748 {
 749         struct hci_dev *hdev = conn->hdev;
 750
 751         BT_DBG("conn %p", conn);
 752
 753         conn->state = BT_CONFIG;
 754
 755         if (!lmp_esco_capable(hdev)) {
 756                 struct hci_cp_accept_conn_req cp;
 757
 758                 bacpy(&cp.bdaddr, &conn->dst);
 759                 cp.role = 0x00; /* Ignored */
 760
 761                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 762         } else {
 763                 struct hci_cp_accept_sync_conn_req cp;
 764
 765                 bacpy(&cp.bdaddr, &conn->dst);
 766                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
 767
 768                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 769                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 770                 cp.content_format = cpu_to_le16(setting);
 771
 772                 switch (setting & SCO_AIRMODE_MASK) {
 773                 case SCO_AIRMODE_TRANSP:
 774                         if (conn->pkt_type & ESCO_2EV3)
 775                                 cp.max_latency = cpu_to_le16(0x0008);
 776                         else
 777                                 cp.max_latency = cpu_to_le16(0x000D);
 778                         cp.retrans_effort = 0x02;
 779                         break;
 780                 case SCO_AIRMODE_CVSD:
 781                         cp.max_latency = cpu_to_le16(0xffff);
 782                         cp.retrans_effort = 0xff;
 783                         break;
 784                 default:
 785                         /* use CVSD settings as fallback */
 786                         cp.max_latency = cpu_to_le16(0xffff);
 787                         cp.retrans_effort = 0xff;
 788                         break;
 789                 }
 790
 791                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 792                              sizeof(cp), &cp);
 793         }
 794 }
 795
 796 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 797                             size_t len, int flags)
 798 {
 799         struct sock *sk = sock->sk;
 800         struct sco_pinfo *pi = sco_pi(sk);
 801
 802         lock_sock(sk);
 803
 804         if (sk->sk_state == BT_CONNECT2 &&
 805             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 806                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
 807                 sk->sk_state = BT_CONFIG;
 808
 809                 release_sock(sk);
 810                 return 0;
 811         }
 812
 813         release_sock(sk);
 814
 815         return bt_sock_recvmsg(sock, msg, len, flags);
 816 }
 817
 818 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
 819                                char __user *optval, unsigned int optlen)
 820 {
 821         struct sock *sk = sock->sk;
 822         int len, err = 0;
 823         struct bt_voice voice;
 824         u32 opt;
 825
 826         BT_DBG("sk %p", sk);
 827
 828         lock_sock(sk);
 829
 830         switch (optname) {
 831
 832         case BT_DEFER_SETUP:
 833                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 834                         err = -EINVAL;
 835                         break;
 836                 }
 837
 838                 if (get_user(opt, (u32 __user *) optval)) {
 839                         err = -EFAULT;
 840                         break;
 841                 }
 842
 843                 if (opt)
 844                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 845                 else
 846                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 847                 break;
 848
 849         case BT_VOICE:
 850                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
 851                     sk->sk_state != BT_CONNECT2) {
 852                         err = -EINVAL;
 853                         break;
 854                 }
 855
 856                 voice.setting = sco_pi(sk)->setting;
 857
 858                 len = min_t(unsigned int, sizeof(voice), optlen);
 859                 if (copy_from_user((char *)&voice, optval, len)) {
 860                         err = -EFAULT;
 861                         break;
 862                 }
 863
 864                 /* Explicitly check for these values */
 865                 if (voice.setting != BT_VOICE_TRANSPARENT &&
 866                     voice.setting != BT_VOICE_CVSD_16BIT) {
 867                         err = -EINVAL;
 868                         break;
 869                 }
 870
 871                 sco_pi(sk)->setting = voice.setting;
 872                 break;
 873
 874         default:
 875                 err = -ENOPROTOOPT;
 876                 break;
 877         }
 878
 879         release_sock(sk);
 880         return err;
 881 }
 882
 883 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
 884                                    char __user *optval, int __user *optlen)
 885 {
 886         struct sock *sk = sock->sk;
 887         struct sco_options opts;
 888         struct sco_conninfo cinfo;
 889         int len, err = 0;
 890
 891         BT_DBG("sk %p", sk);
 892
 893         if (get_user(len, optlen))
 894                 return -EFAULT;
 895
 896         lock_sock(sk);
 897
 898         switch (optname) {
 899         case SCO_OPTIONS:
 900                 if (sk->sk_state != BT_CONNECTED &&
 901                     !(sk->sk_state == BT_CONNECT2 &&
 902                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 903                         err = -ENOTCONN;
 904                         break;
 905                 }
 906
 907                 opts.mtu = sco_pi(sk)->conn->mtu;
 908
 909                 BT_DBG("mtu %d", opts.mtu);
 910
 911                 len = min_t(unsigned int, len, sizeof(opts));
 912                 if (copy_to_user(optval, (char *)&opts, len))
 913                         err = -EFAULT;
 914
 915                 break;
 916
 917         case SCO_CONNINFO:
 918                 if (sk->sk_state != BT_CONNECTED &&
 919                     !(sk->sk_state == BT_CONNECT2 &&
 920                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 921                         err = -ENOTCONN;
 922                         break;
 923                 }
 924
 925                 memset(&cinfo, 0, sizeof(cinfo));
 926                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 927                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 928
 929                 len = min_t(unsigned int, len, sizeof(cinfo));
 930                 if (copy_to_user(optval, (char *)&cinfo, len))
 931                         err = -EFAULT;
 932
 933                 break;
 934
 935         default:
 936                 err = -ENOPROTOOPT;
 937                 break;
 938         }
 939
 940         release_sock(sk);
 941         return err;
 942 }
 943
 944 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
 945                                char __user *optval, int __user *optlen)
 946 {
 947         struct sock *sk = sock->sk;
 948         int len, err = 0;
 949         struct bt_voice voice;
 950
 951         BT_DBG("sk %p", sk);
 952
 953         if (level == SOL_SCO)
 954                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 955
 956         if (get_user(len, optlen))
 957                 return -EFAULT;
 958
 959         lock_sock(sk);
 960
 961         switch (optname) {
 962
 963         case BT_DEFER_SETUP:
 964                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 965                         err = -EINVAL;
 966                         break;
 967                 }
 968
 969                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 970                              (u32 __user *)optval))
 971                         err = -EFAULT;
 972
 973                 break;
 974
 975         case BT_VOICE:
 976                 voice.setting = sco_pi(sk)->setting;
 977
 978                 len = min_t(unsigned int, len, sizeof(voice));
 979                 if (copy_to_user(optval, (char *)&voice, len))
 980                         err = -EFAULT;
 981
 982                 break;
 983
 984         default:
 985                 err = -ENOPROTOOPT;
 986                 break;
 987         }
 988
 989         release_sock(sk);
 990         return err;
 991 }
 992
 993 static int sco_sock_shutdown(struct socket *sock, int how)
 994 {
 995         struct sock *sk = sock->sk;
 996         int err = 0;
 997
 998         BT_DBG("sock %p, sk %p", sock, sk);
 999
1000         if (!sk)
1001                 return 0;
1002
1003         sock_hold(sk);
1004         lock_sock(sk);
1005
1006         if (!sk->sk_shutdown) {
1007                 sk->sk_shutdown = SHUTDOWN_MASK;
1008                 sco_sock_clear_timer(sk);
1009                 __sco_sock_close(sk);
1010
1011                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1012                     !(current->flags & PF_EXITING))
1013                         err = bt_sock_wait_state(sk, BT_CLOSED,
1014                                                  sk->sk_lingertime);
1015         }
1016
1017         release_sock(sk);
1018         sock_put(sk);
1019
1020         return err;
1021 }
1022
1023 static int sco_sock_release(struct socket *sock)
1024 {
1025         struct sock *sk = sock->sk;
1026         int err = 0;
1027
1028         BT_DBG("sock %p, sk %p", sock, sk);
1029
1030         if (!sk)
1031                 return 0;
1032
1033         sco_sock_close(sk);
1034
1035         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1036             !(current->flags & PF_EXITING)) {
1037                 lock_sock(sk);
1038                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1039                 release_sock(sk);
1040         }
1041
1042         sock_orphan(sk);
1043         sco_sock_kill(sk);
1044         return err;
1045 }
1046
1047 static void sco_conn_ready(struct sco_conn *conn)
1048 {
1049         struct sock *parent;
1050         struct sock *sk = conn->sk;
1051
1052         BT_DBG("conn %p", conn);
1053
1054         if (sk) {
1055                 sco_sock_clear_timer(sk);
1056                 bh_lock_sock(sk);
1057                 sk->sk_state = BT_CONNECTED;
1058                 sk->sk_state_change(sk);
1059                 bh_unlock_sock(sk);
1060         } else {
1061                 sco_conn_lock(conn);
1062
1063                 if (!conn->hcon) {
1064                         sco_conn_unlock(conn);
1065                         return;
1066                 }
1067
1068                 parent = sco_get_sock_listen(&conn->hcon->src);
1069                 if (!parent) {
1070                         sco_conn_unlock(conn);
1071                         return;
1072                 }
1073
1074                 bh_lock_sock(parent);
1075
1076                 sk = sco_sock_alloc(sock_net(parent), NULL,
1077                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1078                 if (!sk) {
1079                         bh_unlock_sock(parent);
1080                         sco_conn_unlock(conn);
1081                         return;
1082                 }
1083
1084                 sco_sock_init(sk, parent);
1085
1086                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1087                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1088
1089                 hci_conn_hold(conn->hcon);
1090                 __sco_chan_add(conn, sk, parent);
1091
1092                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1093                         sk->sk_state = BT_CONNECT2;
1094                 else
1095                         sk->sk_state = BT_CONNECTED;
1096
1097                 /* Wake up parent */
1098                 parent->sk_data_ready(parent);
1099
1100                 bh_unlock_sock(parent);
1101
1102                 sco_conn_unlock(conn);
1103         }
1104 }
1105
1106 /* ----- SCO interface with lower layer (HCI) ----- */
1107 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1108 {
1109         struct sock *sk;
1110         int lm = 0;
1111
1112         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1113
1114         /* Find listening sockets */
1115         read_lock(&sco_sk_list.lock);
1116         sk_for_each(sk, &sco_sk_list.head) {
1117                 if (sk->sk_state != BT_LISTEN)
1118                         continue;
1119
1120                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1121                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1122                         lm |= HCI_LM_ACCEPT;
1123
1124                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1125                                 *flags |= HCI_PROTO_DEFER;
1126                         break;
1127                 }
1128         }
1129         read_unlock(&sco_sk_list.lock);
1130
1131         return lm;
1132 }
1133
1134 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1135 {
1136         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1137                 return;
1138
1139         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1140
1141         if (!status) {
1142                 struct sco_conn *conn;
1143
1144                 conn = sco_conn_add(hcon);
1145                 if (conn)
1146                         sco_conn_ready(conn);
1147         } else
1148                 sco_conn_del(hcon, bt_to_errno(status));
1149 }
1150
1151 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1152 {
1153         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1154                 return;
1155
1156         BT_DBG("hcon %p reason %d", hcon, reason);
1157
1158         sco_conn_del(hcon, bt_to_errno(reason));
1159 }
1160
1161 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1162 {
1163         struct sco_conn *conn = hcon->sco_data;
1164
1165         if (!conn)
1166                 goto drop;
1167
1168         BT_DBG("conn %p len %d", conn, skb->len);
1169
1170         if (skb->len) {
1171                 sco_recv_frame(conn, skb);
1172                 return;
1173         }
1174
1175 drop:
1176         kfree_skb(skb);
1177 }
1178
1179 static struct hci_cb sco_cb = {
1180         .name           = "SCO",
1181         .connect_cfm    = sco_connect_cfm,
1182         .disconn_cfm    = sco_disconn_cfm,
1183 };
1184
1185 static int sco_debugfs_show(struct seq_file *f, void *p)
1186 {
1187         struct sock *sk;
1188
1189         read_lock(&sco_sk_list.lock);
1190
1191         sk_for_each(sk, &sco_sk_list.head) {
1192                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1193                            &sco_pi(sk)->dst, sk->sk_state);
1194         }
1195
1196         read_unlock(&sco_sk_list.lock);
1197
1198         return 0;
1199 }
1200
1201 static int sco_debugfs_open(struct inode *inode, struct file *file)
1202 {
1203         return single_open(file, sco_debugfs_show, inode->i_private);
1204 }
1205
1206 static const struct file_operations sco_debugfs_fops = {
1207         .open           = sco_debugfs_open,
1208         .read           = seq_read,
1209         .llseek         = seq_lseek,
1210         .release        = single_release,
1211 };
1212
1213 static struct dentry *sco_debugfs;
1214
1215 static const struct proto_ops sco_sock_ops = {
1216         .family         = PF_BLUETOOTH,
1217         .owner          = THIS_MODULE,
1218         .release        = sco_sock_release,
1219         .bind           = sco_sock_bind,
1220         .connect        = sco_sock_connect,
1221         .listen         = sco_sock_listen,
1222         .accept         = sco_sock_accept,
1223         .getname        = sco_sock_getname,
1224         .sendmsg        = sco_sock_sendmsg,
1225         .recvmsg        = sco_sock_recvmsg,
1226         .poll           = bt_sock_poll,
1227         .ioctl          = bt_sock_ioctl,
1228         .mmap           = sock_no_mmap,
1229         .socketpair     = sock_no_socketpair,
1230         .shutdown       = sco_sock_shutdown,
1231         .setsockopt     = sco_sock_setsockopt,
1232         .getsockopt     = sco_sock_getsockopt
1233 };
1234
1235 static const struct net_proto_family sco_sock_family_ops = {
1236         .family = PF_BLUETOOTH,
1237         .owner  = THIS_MODULE,
1238         .create = sco_sock_create,
1239 };
1240
1241 int __init sco_init(void)
1242 {
1243         int err;
1244
1245         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1246
1247         err = proto_register(&sco_proto, 0);
1248         if (err < 0)
1249                 return err;
1250
1251         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1252         if (err < 0) {
1253                 BT_ERR("SCO socket registration failed");
1254                 goto error;
1255         }
1256
1257         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1258         if (err < 0) {
1259                 BT_ERR("Failed to create SCO proc file");
1260                 bt_sock_unregister(BTPROTO_SCO);
1261                 goto error;
1262         }
1263
1264         BT_INFO("SCO socket layer initialized");
1265
1266         hci_register_cb(&sco_cb);
1267
1268         if (IS_ERR_OR_NULL(bt_debugfs))
1269                 return 0;
1270
1271         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1272                                           NULL, &sco_debugfs_fops);
1273
1274         return 0;
1275
1276 error:
1277         proto_unregister(&sco_proto);
1278         return err;
1279 }
1280
1281 void sco_exit(void)
1282 {
1283         bt_procfs_cleanup(&init_net, "sco");
1284
1285         debugfs_remove(sco_debugfs);
1286
1287         hci_unregister_cb(&sco_cb);
1288
1289         bt_sock_unregister(BTPROTO_SCO);
1290
1291         proto_unregister(&sco_proto);
1292 }
1293
1294 module_param(disable_esco, bool, 0644);
1295 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");