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