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