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