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, struct sk_buff *skb)
 283 {
 284         struct sco_conn *conn = sco_pi(sk)->conn;
 285         int len = skb->len;
 286
 287         /* Check outgoing MTU */
 288         if (len > conn->mtu)
 289                 return -EINVAL;
 290
 291         BT_DBG("sk %p len %d", sk, len);
 292
 293         hci_send_sco(conn->hcon, skb);
 294
 295         return len;
 296 }
 297
 298 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 299 {
 300         struct sock *sk;
 301
 302         sco_conn_lock(conn);
 303         sk = conn->sk;
 304         sco_conn_unlock(conn);
 305
 306         if (!sk)
 307                 goto drop;
 308
 309         BT_DBG("sk %p len %d", sk, skb->len);
 310
 311         if (sk->sk_state != BT_CONNECTED)
 312                 goto drop;
 313
 314         if (!sock_queue_rcv_skb(sk, skb))
 315                 return;
 316
 317 drop:
 318         kfree_skb(skb);
 319 }
 320
 321 /* -------- Socket interface ---------- */
 322 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
 323 {
 324         struct sock *sk;
 325
 326         sk_for_each(sk, &sco_sk_list.head) {
 327                 if (sk->sk_state != BT_LISTEN)
 328                         continue;
 329
 330                 if (!bacmp(&sco_pi(sk)->src, ba))
 331                         return sk;
 332         }
 333
 334         return NULL;
 335 }
 336
 337 /* Find socket listening on source bdaddr.
 338  * Returns closest match.
 339  */
 340 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 341 {
 342         struct sock *sk = NULL, *sk1 = NULL;
 343
 344         read_lock(&sco_sk_list.lock);
 345
 346         sk_for_each(sk, &sco_sk_list.head) {
 347                 if (sk->sk_state != BT_LISTEN)
 348                         continue;
 349
 350                 /* Exact match. */
 351                 if (!bacmp(&sco_pi(sk)->src, src))
 352                         break;
 353
 354                 /* Closest match */
 355                 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
 356                         sk1 = sk;
 357         }
 358
 359         read_unlock(&sco_sk_list.lock);
 360
 361         return sk ? sk : sk1;
 362 }
 363
 364 static void sco_sock_destruct(struct sock *sk)
 365 {
 366         BT_DBG("sk %p", sk);
 367
 368         skb_queue_purge(&sk->sk_receive_queue);
 369         skb_queue_purge(&sk->sk_write_queue);
 370 }
 371
 372 static void sco_sock_cleanup_listen(struct sock *parent)
 373 {
 374         struct sock *sk;
 375
 376         BT_DBG("parent %p", parent);
 377
 378         /* Close not yet accepted channels */
 379         while ((sk = bt_accept_dequeue(parent, NULL))) {
 380                 sco_sock_close(sk);
 381                 sco_sock_kill(sk);
 382         }
 383
 384         parent->sk_state  = BT_CLOSED;
 385         sock_set_flag(parent, SOCK_ZAPPED);
 386 }
 387
 388 /* Kill socket (only if zapped and orphan)
 389  * Must be called on unlocked socket.
 390  */
 391 static void sco_sock_kill(struct sock *sk)
 392 {
 393         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 394                 return;
 395
 396         BT_DBG("sk %p state %d", sk, sk->sk_state);
 397
 398         /* Kill poor orphan */
 399         bt_sock_unlink(&sco_sk_list, sk);
 400         sock_set_flag(sk, SOCK_DEAD);
 401         sock_put(sk);
 402 }
 403
 404 static void __sco_sock_close(struct sock *sk)
 405 {
 406         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 407
 408         switch (sk->sk_state) {
 409         case BT_LISTEN:
 410                 sco_sock_cleanup_listen(sk);
 411                 break;
 412
 413         case BT_CONNECTED:
 414         case BT_CONFIG:
 415                 if (sco_pi(sk)->conn->hcon) {
 416                         sk->sk_state = BT_DISCONN;
 417                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 418                         sco_conn_lock(sco_pi(sk)->conn);
 419                         hci_conn_drop(sco_pi(sk)->conn->hcon);
 420                         sco_pi(sk)->conn->hcon = NULL;
 421                         sco_conn_unlock(sco_pi(sk)->conn);
 422                 } else
 423                         sco_chan_del(sk, ECONNRESET);
 424                 break;
 425
 426         case BT_CONNECT2:
 427         case BT_CONNECT:
 428         case BT_DISCONN:
 429                 sco_chan_del(sk, ECONNRESET);
 430                 break;
 431
 432         default:
 433                 sock_set_flag(sk, SOCK_ZAPPED);
 434                 break;
 435         }
 436 }
 437
 438 /* Must be called on unlocked socket. */
 439 static void sco_sock_close(struct sock *sk)
 440 {
 441         sco_sock_clear_timer(sk);
 442         lock_sock(sk);
 443         __sco_sock_close(sk);
 444         release_sock(sk);
 445 }
 446
 447 static void sco_sock_init(struct sock *sk, struct sock *parent)
 448 {
 449         BT_DBG("sk %p", sk);
 450
 451         if (parent) {
 452                 sk->sk_type = parent->sk_type;
 453                 bt_sk(sk)->flags = bt_sk(parent)->flags;
 454                 security_sk_clone(parent, sk);
 455         }
 456 }
 457
 458 static struct proto sco_proto = {
 459         .name           = "SCO",
 460         .owner          = THIS_MODULE,
 461         .obj_size       = sizeof(struct sco_pinfo)
 462 };
 463
 464 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
 465                                    int proto, gfp_t prio, int kern)
 466 {
 467         struct sock *sk;
 468
 469         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
 470         if (!sk)
 471                 return NULL;
 472
 473         sock_init_data(sock, sk);
 474         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 475
 476         sk->sk_destruct = sco_sock_destruct;
 477         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 478
 479         sock_reset_flag(sk, SOCK_ZAPPED);
 480
 481         sk->sk_protocol = proto;
 482         sk->sk_state    = BT_OPEN;
 483
 484         sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
 485
 486         bt_sock_link(&sco_sk_list, sk);
 487         return sk;
 488 }
 489
 490 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 491                            int kern)
 492 {
 493         struct sock *sk;
 494
 495         BT_DBG("sock %p", sock);
 496
 497         sock->state = SS_UNCONNECTED;
 498
 499         if (sock->type != SOCK_SEQPACKET)
 500                 return -ESOCKTNOSUPPORT;
 501
 502         sock->ops = &sco_sock_ops;
 503
 504         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
 505         if (!sk)
 506                 return -ENOMEM;
 507
 508         sco_sock_init(sk, NULL);
 509         return 0;
 510 }
 511
 512 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
 513                          int addr_len)
 514 {
 515         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 516         struct sock *sk = sock->sk;
 517         int err = 0;
 518
 519         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 520
 521         if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
 522             addr->sa_family != AF_BLUETOOTH)
 523                 return -EINVAL;
 524
 525         lock_sock(sk);
 526
 527         if (sk->sk_state != BT_OPEN) {
 528                 err = -EBADFD;
 529                 goto done;
 530         }
 531
 532         if (sk->sk_type != SOCK_SEQPACKET) {
 533                 err = -EINVAL;
 534                 goto done;
 535         }
 536
 537         bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
 538
 539         sk->sk_state = BT_BOUND;
 540
 541 done:
 542         release_sock(sk);
 543         return err;
 544 }
 545
 546 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 547 {
 548         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 549         struct sock *sk = sock->sk;
 550         struct hci_dev  *hdev;
 551         int err;
 552
 553         BT_DBG("sk %p", sk);
 554
 555         if (alen < sizeof(struct sockaddr_sco) ||
 556             addr->sa_family != AF_BLUETOOTH)
 557                 return -EINVAL;
 558
 559         lock_sock(sk);
 560         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
 561                 err = -EBADFD;
 562                 goto done;
 563         }
 564
 565         if (sk->sk_type != SOCK_SEQPACKET) {
 566                 err = -EINVAL;
 567                 goto done;
 568         }
 569
 570         hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
 571         if (!hdev) {
 572                 err = -EHOSTUNREACH;
 573                 goto done;
 574         }
 575         hci_dev_lock(hdev);
 576
 577         /* Set destination address and psm */
 578         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
 579
 580         err = sco_connect(hdev, sk);
 581         hci_dev_unlock(hdev);
 582         hci_dev_put(hdev);
 583         if (err)
 584                 goto done;
 585
 586         err = bt_sock_wait_state(sk, BT_CONNECTED,
 587                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 588
 589 done:
 590         release_sock(sk);
 591         return err;
 592 }
 593
 594 static int sco_sock_listen(struct socket *sock, int backlog)
 595 {
 596         struct sock *sk = sock->sk;
 597         bdaddr_t *src = &sco_pi(sk)->src;
 598         int err = 0;
 599
 600         BT_DBG("sk %p backlog %d", sk, backlog);
 601
 602         lock_sock(sk);
 603
 604         if (sk->sk_state != BT_BOUND) {
 605                 err = -EBADFD;
 606                 goto done;
 607         }
 608
 609         if (sk->sk_type != SOCK_SEQPACKET) {
 610                 err = -EINVAL;
 611                 goto done;
 612         }
 613
 614         write_lock(&sco_sk_list.lock);
 615
 616         if (__sco_get_sock_listen_by_addr(src)) {
 617                 err = -EADDRINUSE;
 618                 goto unlock;
 619         }
 620
 621         sk->sk_max_ack_backlog = backlog;
 622         sk->sk_ack_backlog = 0;
 623
 624         sk->sk_state = BT_LISTEN;
 625
 626 unlock:
 627         write_unlock(&sco_sk_list.lock);
 628
 629 done:
 630         release_sock(sk);
 631         return err;
 632 }
 633
 634 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
 635                            int flags, bool kern)
 636 {
 637         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 638         struct sock *sk = sock->sk, *ch;
 639         long timeo;
 640         int err = 0;
 641
 642         lock_sock(sk);
 643
 644         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 645
 646         BT_DBG("sk %p timeo %ld", sk, timeo);
 647
 648         /* Wait for an incoming connection. (wake-one). */
 649         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 650         while (1) {
 651                 if (sk->sk_state != BT_LISTEN) {
 652                         err = -EBADFD;
 653                         break;
 654                 }
 655
 656                 ch = bt_accept_dequeue(sk, newsock);
 657                 if (ch)
 658                         break;
 659
 660                 if (!timeo) {
 661                         err = -EAGAIN;
 662                         break;
 663                 }
 664
 665                 if (signal_pending(current)) {
 666                         err = sock_intr_errno(timeo);
 667                         break;
 668                 }
 669
 670                 release_sock(sk);
 671
 672                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 673                 lock_sock(sk);
 674         }
 675         remove_wait_queue(sk_sleep(sk), &wait);
 676
 677         if (err)
 678                 goto done;
 679
 680         newsock->state = SS_CONNECTED;
 681
 682         BT_DBG("new socket %p", ch);
 683
 684 done:
 685         release_sock(sk);
 686         return err;
 687 }
 688
 689 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
 690                             int *len, int peer)
 691 {
 692         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 693         struct sock *sk = sock->sk;
 694
 695         BT_DBG("sock %p, sk %p", sock, sk);
 696
 697         addr->sa_family = AF_BLUETOOTH;
 698         *len = sizeof(struct sockaddr_sco);
 699
 700         if (peer)
 701                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
 702         else
 703                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
 704
 705         return 0;
 706 }
 707
 708 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 709                             size_t len)
 710 {
 711         struct sock *sk = sock->sk;
 712         struct sk_buff *skb;
 713         int err;
 714
 715         BT_DBG("sock %p, sk %p", sock, sk);
 716
 717         err = sock_error(sk);
 718         if (err)
 719                 return err;
 720
 721         if (msg->msg_flags & MSG_OOB)
 722                 return -EOPNOTSUPP;
 723
 724         skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
 725         if (IS_ERR(skb))
 726                 return PTR_ERR(skb);
 727
 728         lock_sock(sk);
 729
 730         if (sk->sk_state == BT_CONNECTED)
 731                 err = sco_send_frame(sk, skb);
 732         else
 733                 err = -ENOTCONN;
 734
 735         release_sock(sk);
 736
 737         if (err < 0)
 738                 kfree_skb(skb);
 739         return err;
 740 }
 741
 742 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
 743 {
 744         struct hci_dev *hdev = conn->hdev;
 745
 746         BT_DBG("conn %p", conn);
 747
 748         conn->state = BT_CONFIG;
 749
 750         if (!lmp_esco_capable(hdev)) {
 751                 struct hci_cp_accept_conn_req cp;
 752
 753                 bacpy(&cp.bdaddr, &conn->dst);
 754                 cp.role = 0x00; /* Ignored */
 755
 756                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 757         } else {
 758                 struct hci_cp_accept_sync_conn_req cp;
 759
 760                 bacpy(&cp.bdaddr, &conn->dst);
 761                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
 762
 763                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 764                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 765                 cp.content_format = cpu_to_le16(setting);
 766
 767                 switch (setting & SCO_AIRMODE_MASK) {
 768                 case SCO_AIRMODE_TRANSP:
 769                         if (conn->pkt_type & ESCO_2EV3)
 770                                 cp.max_latency = cpu_to_le16(0x0008);
 771                         else
 772                                 cp.max_latency = cpu_to_le16(0x000D);
 773                         cp.retrans_effort = 0x02;
 774                         break;
 775                 case SCO_AIRMODE_CVSD:
 776                         cp.max_latency = cpu_to_le16(0xffff);
 777                         cp.retrans_effort = 0xff;
 778                         break;
 779                 default:
 780                         /* use CVSD settings as fallback */
 781                         cp.max_latency = cpu_to_le16(0xffff);
 782                         cp.retrans_effort = 0xff;
 783                         break;
 784                 }
 785
 786                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 787                              sizeof(cp), &cp);
 788         }
 789 }
 790
 791 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 792                             size_t len, int flags)
 793 {
 794         struct sock *sk = sock->sk;
 795         struct sco_pinfo *pi = sco_pi(sk);
 796
 797         lock_sock(sk);
 798
 799         if (sk->sk_state == BT_CONNECT2 &&
 800             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 801                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
 802                 sk->sk_state = BT_CONFIG;
 803
 804                 release_sock(sk);
 805                 return 0;
 806         }
 807
 808         release_sock(sk);
 809
 810         return bt_sock_recvmsg(sock, msg, len, flags);
 811 }
 812
 813 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
 814                                char __user *optval, unsigned int optlen)
 815 {
 816         struct sock *sk = sock->sk;
 817         int len, err = 0;
 818         struct bt_voice voice;
 819         u32 opt;
 820
 821         BT_DBG("sk %p", sk);
 822
 823         lock_sock(sk);
 824
 825         switch (optname) {
 826
 827         case BT_DEFER_SETUP:
 828                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 829                         err = -EINVAL;
 830                         break;
 831                 }
 832
 833                 if (get_user(opt, (u32 __user *) optval)) {
 834                         err = -EFAULT;
 835                         break;
 836                 }
 837
 838                 if (opt)
 839                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 840                 else
 841                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 842                 break;
 843
 844         case BT_VOICE:
 845                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
 846                     sk->sk_state != BT_CONNECT2) {
 847                         err = -EINVAL;
 848                         break;
 849                 }
 850
 851                 voice.setting = sco_pi(sk)->setting;
 852
 853                 len = min_t(unsigned int, sizeof(voice), optlen);
 854                 if (copy_from_user((char *)&voice, optval, len)) {
 855                         err = -EFAULT;
 856                         break;
 857                 }
 858
 859                 /* Explicitly check for these values */
 860                 if (voice.setting != BT_VOICE_TRANSPARENT &&
 861                     voice.setting != BT_VOICE_CVSD_16BIT) {
 862                         err = -EINVAL;
 863                         break;
 864                 }
 865
 866                 sco_pi(sk)->setting = voice.setting;
 867                 break;
 868
 869         default:
 870                 err = -ENOPROTOOPT;
 871                 break;
 872         }
 873
 874         release_sock(sk);
 875         return err;
 876 }
 877
 878 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
 879                                    char __user *optval, int __user *optlen)
 880 {
 881         struct sock *sk = sock->sk;
 882         struct sco_options opts;
 883         struct sco_conninfo cinfo;
 884         int len, err = 0;
 885
 886         BT_DBG("sk %p", sk);
 887
 888         if (get_user(len, optlen))
 889                 return -EFAULT;
 890
 891         lock_sock(sk);
 892
 893         switch (optname) {
 894         case SCO_OPTIONS:
 895                 if (sk->sk_state != BT_CONNECTED &&
 896                     !(sk->sk_state == BT_CONNECT2 &&
 897                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 898                         err = -ENOTCONN;
 899                         break;
 900                 }
 901
 902                 opts.mtu = sco_pi(sk)->conn->mtu;
 903
 904                 BT_DBG("mtu %d", opts.mtu);
 905
 906                 len = min_t(unsigned int, len, sizeof(opts));
 907                 if (copy_to_user(optval, (char *)&opts, len))
 908                         err = -EFAULT;
 909
 910                 break;
 911
 912         case SCO_CONNINFO:
 913                 if (sk->sk_state != BT_CONNECTED &&
 914                     !(sk->sk_state == BT_CONNECT2 &&
 915                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 916                         err = -ENOTCONN;
 917                         break;
 918                 }
 919
 920                 memset(&cinfo, 0, sizeof(cinfo));
 921                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 922                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 923
 924                 len = min_t(unsigned int, len, sizeof(cinfo));
 925                 if (copy_to_user(optval, (char *)&cinfo, len))
 926                         err = -EFAULT;
 927
 928                 break;
 929
 930         default:
 931                 err = -ENOPROTOOPT;
 932                 break;
 933         }
 934
 935         release_sock(sk);
 936         return err;
 937 }
 938
 939 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
 940                                char __user *optval, int __user *optlen)
 941 {
 942         struct sock *sk = sock->sk;
 943         int len, err = 0;
 944         struct bt_voice voice;
 945
 946         BT_DBG("sk %p", sk);
 947
 948         if (level == SOL_SCO)
 949                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 950
 951         if (get_user(len, optlen))
 952                 return -EFAULT;
 953
 954         lock_sock(sk);
 955
 956         switch (optname) {
 957
 958         case BT_DEFER_SETUP:
 959                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 960                         err = -EINVAL;
 961                         break;
 962                 }
 963
 964                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 965                              (u32 __user *)optval))
 966                         err = -EFAULT;
 967
 968                 break;
 969
 970         case BT_VOICE:
 971                 voice.setting = sco_pi(sk)->setting;
 972
 973                 len = min_t(unsigned int, len, sizeof(voice));
 974                 if (copy_to_user(optval, (char *)&voice, len))
 975                         err = -EFAULT;
 976
 977                 break;
 978
 979         default:
 980                 err = -ENOPROTOOPT;
 981                 break;
 982         }
 983
 984         release_sock(sk);
 985         return err;
 986 }
 987
 988 static int sco_sock_shutdown(struct socket *sock, int how)
 989 {
 990         struct sock *sk = sock->sk;
 991         int err = 0;
 992
 993         BT_DBG("sock %p, sk %p", sock, sk);
 994
 995         if (!sk)
 996                 return 0;
 997
 998         sock_hold(sk);
 999         lock_sock(sk);
1000
1001         if (!sk->sk_shutdown) {
1002                 sk->sk_shutdown = SHUTDOWN_MASK;
1003                 sco_sock_clear_timer(sk);
1004                 __sco_sock_close(sk);
1005
1006                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1007                     !(current->flags & PF_EXITING))
1008                         err = bt_sock_wait_state(sk, BT_CLOSED,
1009                                                  sk->sk_lingertime);
1010         }
1011
1012         release_sock(sk);
1013         sock_put(sk);
1014
1015         return err;
1016 }
1017
1018 static int sco_sock_release(struct socket *sock)
1019 {
1020         struct sock *sk = sock->sk;
1021         int err = 0;
1022
1023         BT_DBG("sock %p, sk %p", sock, sk);
1024
1025         if (!sk)
1026                 return 0;
1027
1028         sco_sock_close(sk);
1029
1030         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1031             !(current->flags & PF_EXITING)) {
1032                 lock_sock(sk);
1033                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1034                 release_sock(sk);
1035         }
1036
1037         sock_orphan(sk);
1038         sco_sock_kill(sk);
1039         return err;
1040 }
1041
1042 static void sco_conn_ready(struct sco_conn *conn)
1043 {
1044         struct sock *parent;
1045         struct sock *sk = conn->sk;
1046
1047         BT_DBG("conn %p", conn);
1048
1049         if (sk) {
1050                 sco_sock_clear_timer(sk);
1051                 bh_lock_sock(sk);
1052                 sk->sk_state = BT_CONNECTED;
1053                 sk->sk_state_change(sk);
1054                 bh_unlock_sock(sk);
1055         } else {
1056                 sco_conn_lock(conn);
1057
1058                 if (!conn->hcon) {
1059                         sco_conn_unlock(conn);
1060                         return;
1061                 }
1062
1063                 parent = sco_get_sock_listen(&conn->hcon->src);
1064                 if (!parent) {
1065                         sco_conn_unlock(conn);
1066                         return;
1067                 }
1068
1069                 bh_lock_sock(parent);
1070
1071                 sk = sco_sock_alloc(sock_net(parent), NULL,
1072                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1073                 if (!sk) {
1074                         bh_unlock_sock(parent);
1075                         sco_conn_unlock(conn);
1076                         return;
1077                 }
1078
1079                 sco_sock_init(sk, parent);
1080
1081                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1082                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1083
1084                 hci_conn_hold(conn->hcon);
1085                 __sco_chan_add(conn, sk, parent);
1086
1087                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1088                         sk->sk_state = BT_CONNECT2;
1089                 else
1090                         sk->sk_state = BT_CONNECTED;
1091
1092                 /* Wake up parent */
1093                 parent->sk_data_ready(parent);
1094
1095                 bh_unlock_sock(parent);
1096
1097                 sco_conn_unlock(conn);
1098         }
1099 }
1100
1101 /* ----- SCO interface with lower layer (HCI) ----- */
1102 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1103 {
1104         struct sock *sk;
1105         int lm = 0;
1106
1107         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1108
1109         /* Find listening sockets */
1110         read_lock(&sco_sk_list.lock);
1111         sk_for_each(sk, &sco_sk_list.head) {
1112                 if (sk->sk_state != BT_LISTEN)
1113                         continue;
1114
1115                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1116                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1117                         lm |= HCI_LM_ACCEPT;
1118
1119                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1120                                 *flags |= HCI_PROTO_DEFER;
1121                         break;
1122                 }
1123         }
1124         read_unlock(&sco_sk_list.lock);
1125
1126         return lm;
1127 }
1128
1129 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1130 {
1131         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1132                 return;
1133
1134         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1135
1136         if (!status) {
1137                 struct sco_conn *conn;
1138
1139                 conn = sco_conn_add(hcon);
1140                 if (conn)
1141                         sco_conn_ready(conn);
1142         } else
1143                 sco_conn_del(hcon, bt_to_errno(status));
1144 }
1145
1146 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1147 {
1148         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1149                 return;
1150
1151         BT_DBG("hcon %p reason %d", hcon, reason);
1152
1153         sco_conn_del(hcon, bt_to_errno(reason));
1154 }
1155
1156 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1157 {
1158         struct sco_conn *conn = hcon->sco_data;
1159
1160         if (!conn)
1161                 goto drop;
1162
1163         BT_DBG("conn %p len %d", conn, skb->len);
1164
1165         if (skb->len) {
1166                 sco_recv_frame(conn, skb);
1167                 return;
1168         }
1169
1170 drop:
1171         kfree_skb(skb);
1172 }
1173
1174 static struct hci_cb sco_cb = {
1175         .name           = "SCO",
1176         .connect_cfm    = sco_connect_cfm,
1177         .disconn_cfm    = sco_disconn_cfm,
1178 };
1179
1180 static int sco_debugfs_show(struct seq_file *f, void *p)
1181 {
1182         struct sock *sk;
1183
1184         read_lock(&sco_sk_list.lock);
1185
1186         sk_for_each(sk, &sco_sk_list.head) {
1187                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1188                            &sco_pi(sk)->dst, sk->sk_state);
1189         }
1190
1191         read_unlock(&sco_sk_list.lock);
1192
1193         return 0;
1194 }
1195
1196 static int sco_debugfs_open(struct inode *inode, struct file *file)
1197 {
1198         return single_open(file, sco_debugfs_show, inode->i_private);
1199 }
1200
1201 static const struct file_operations sco_debugfs_fops = {
1202         .open           = sco_debugfs_open,
1203         .read           = seq_read,
1204         .llseek         = seq_lseek,
1205         .release        = single_release,
1206 };
1207
1208 static struct dentry *sco_debugfs;
1209
1210 static const struct proto_ops sco_sock_ops = {
1211         .family         = PF_BLUETOOTH,
1212         .owner          = THIS_MODULE,
1213         .release        = sco_sock_release,
1214         .bind           = sco_sock_bind,
1215         .connect        = sco_sock_connect,
1216         .listen         = sco_sock_listen,
1217         .accept         = sco_sock_accept,
1218         .getname        = sco_sock_getname,
1219         .sendmsg        = sco_sock_sendmsg,
1220         .recvmsg        = sco_sock_recvmsg,
1221         .poll           = bt_sock_poll,
1222         .ioctl          = bt_sock_ioctl,
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");