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