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