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