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
 687                 release_sock(sk);
 688                 return 0;
 689         }
 690
 691         release_sock(sk);
 692
 693         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 694 }
 695
 696 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 697 {
 698         struct sock *sk = sock->sk;
 699         int err = 0;
 700         u32 opt;
 701
 702         BT_DBG("sk %p", sk);
 703
 704         lock_sock(sk);
 705
 706         switch (optname) {
 707
 708         case BT_DEFER_SETUP:
 709                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 710                         err = -EINVAL;
 711                         break;
 712                 }
 713
 714                 if (get_user(opt, (u32 __user *) optval)) {
 715                         err = -EFAULT;
 716                         break;
 717                 }
 718
 719                 if (opt)
 720                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 721                 else
 722                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 723                 break;
 724
 725         default:
 726                 err = -ENOPROTOOPT;
 727                 break;
 728         }
 729
 730         release_sock(sk);
 731         return err;
 732 }
 733
 734 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 735 {
 736         struct sock *sk = sock->sk;
 737         struct sco_options opts;
 738         struct sco_conninfo cinfo;
 739         int len, err = 0;
 740
 741         BT_DBG("sk %p", sk);
 742
 743         if (get_user(len, optlen))
 744                 return -EFAULT;
 745
 746         lock_sock(sk);
 747
 748         switch (optname) {
 749         case SCO_OPTIONS:
 750                 if (sk->sk_state != BT_CONNECTED) {
 751                         err = -ENOTCONN;
 752                         break;
 753                 }
 754
 755                 opts.mtu = sco_pi(sk)->conn->mtu;
 756
 757                 BT_DBG("mtu %d", opts.mtu);
 758
 759                 len = min_t(unsigned int, len, sizeof(opts));
 760                 if (copy_to_user(optval, (char *)&opts, len))
 761                         err = -EFAULT;
 762
 763                 break;
 764
 765         case SCO_CONNINFO:
 766                 if (sk->sk_state != BT_CONNECTED) {
 767                         err = -ENOTCONN;
 768                         break;
 769                 }
 770
 771                 memset(&cinfo, 0, sizeof(cinfo));
 772                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 773                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 774
 775                 len = min_t(unsigned int, len, sizeof(cinfo));
 776                 if (copy_to_user(optval, (char *)&cinfo, len))
 777                         err = -EFAULT;
 778
 779                 break;
 780
 781         default:
 782                 err = -ENOPROTOOPT;
 783                 break;
 784         }
 785
 786         release_sock(sk);
 787         return err;
 788 }
 789
 790 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 791 {
 792         struct sock *sk = sock->sk;
 793         int len, err = 0;
 794
 795         BT_DBG("sk %p", sk);
 796
 797         if (level == SOL_SCO)
 798                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 799
 800         if (get_user(len, optlen))
 801                 return -EFAULT;
 802
 803         lock_sock(sk);
 804
 805         switch (optname) {
 806
 807         case BT_DEFER_SETUP:
 808                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 809                         err = -EINVAL;
 810                         break;
 811                 }
 812
 813                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 814                              (u32 __user *) optval))
 815                         err = -EFAULT;
 816
 817                 break;
 818
 819         default:
 820                 err = -ENOPROTOOPT;
 821                 break;
 822         }
 823
 824         release_sock(sk);
 825         return err;
 826 }
 827
 828 static int sco_sock_shutdown(struct socket *sock, int how)
 829 {
 830         struct sock *sk = sock->sk;
 831         int err = 0;
 832
 833         BT_DBG("sock %p, sk %p", sock, sk);
 834
 835         if (!sk)
 836                 return 0;
 837
 838         lock_sock(sk);
 839         if (!sk->sk_shutdown) {
 840                 sk->sk_shutdown = SHUTDOWN_MASK;
 841                 sco_sock_clear_timer(sk);
 842                 __sco_sock_close(sk);
 843
 844                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 845                         err = bt_sock_wait_state(sk, BT_CLOSED,
 846                                                  sk->sk_lingertime);
 847         }
 848         release_sock(sk);
 849         return err;
 850 }
 851
 852 static int sco_sock_release(struct socket *sock)
 853 {
 854         struct sock *sk = sock->sk;
 855         int err = 0;
 856
 857         BT_DBG("sock %p, sk %p", sock, sk);
 858
 859         if (!sk)
 860                 return 0;
 861
 862         sco_sock_close(sk);
 863
 864         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 865                 lock_sock(sk);
 866                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 867                 release_sock(sk);
 868         }
 869
 870         sock_orphan(sk);
 871         sco_sock_kill(sk);
 872         return err;
 873 }
 874
 875 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 876 {
 877         BT_DBG("conn %p", conn);
 878
 879         sco_pi(sk)->conn = conn;
 880         conn->sk = sk;
 881
 882         if (parent)
 883                 bt_accept_enqueue(parent, sk);
 884 }
 885
 886 /* Delete channel.
 887  * Must be called on the locked socket. */
 888 static void sco_chan_del(struct sock *sk, int err)
 889 {
 890         struct sco_conn *conn;
 891
 892         conn = sco_pi(sk)->conn;
 893
 894         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 895
 896         if (conn) {
 897                 sco_conn_lock(conn);
 898                 conn->sk = NULL;
 899                 sco_pi(sk)->conn = NULL;
 900                 sco_conn_unlock(conn);
 901
 902                 if (conn->hcon)
 903                         hci_conn_put(conn->hcon);
 904         }
 905
 906         sk->sk_state = BT_CLOSED;
 907         sk->sk_err   = err;
 908         sk->sk_state_change(sk);
 909
 910         sock_set_flag(sk, SOCK_ZAPPED);
 911 }
 912
 913 static void sco_conn_ready(struct sco_conn *conn)
 914 {
 915         struct sock *parent;
 916         struct sock *sk = conn->sk;
 917
 918         BT_DBG("conn %p", conn);
 919
 920         if (sk) {
 921                 sco_sock_clear_timer(sk);
 922                 bh_lock_sock(sk);
 923                 sk->sk_state = BT_CONNECTED;
 924                 sk->sk_state_change(sk);
 925                 bh_unlock_sock(sk);
 926         } else {
 927                 sco_conn_lock(conn);
 928
 929                 parent = sco_get_sock_listen(conn->src);
 930                 if (!parent) {
 931                         sco_conn_unlock(conn);
 932                         return;
 933                 }
 934
 935                 bh_lock_sock(parent);
 936
 937                 sk = sco_sock_alloc(sock_net(parent), NULL,
 938                                     BTPROTO_SCO, GFP_ATOMIC);
 939                 if (!sk) {
 940                         bh_unlock_sock(parent);
 941                         sco_conn_unlock(conn);
 942                         return;
 943                 }
 944
 945                 sco_sock_init(sk, parent);
 946
 947                 bacpy(&bt_sk(sk)->src, conn->src);
 948                 bacpy(&bt_sk(sk)->dst, conn->dst);
 949
 950                 hci_conn_hold(conn->hcon);
 951                 __sco_chan_add(conn, sk, parent);
 952
 953                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
 954                         sk->sk_state = BT_CONNECT2;
 955                 else
 956                         sk->sk_state = BT_CONNECTED;
 957
 958                 /* Wake up parent */
 959                 parent->sk_data_ready(parent, 1);
 960
 961                 bh_unlock_sock(parent);
 962
 963                 sco_conn_unlock(conn);
 964         }
 965 }
 966
 967 /* ----- SCO interface with lower layer (HCI) ----- */
 968 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
 969 {
 970         struct sock *sk;
 971         struct hlist_node *node;
 972         int lm = 0;
 973
 974         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
 975
 976         /* Find listening sockets */
 977         read_lock(&sco_sk_list.lock);
 978         sk_for_each(sk, node, &sco_sk_list.head) {
 979                 if (sk->sk_state != BT_LISTEN)
 980                         continue;
 981
 982                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 983                     !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 984                         lm |= HCI_LM_ACCEPT;
 985
 986                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
 987                                 *flags |= HCI_PROTO_DEFER;
 988                         break;
 989                 }
 990         }
 991         read_unlock(&sco_sk_list.lock);
 992
 993         return lm;
 994 }
 995
 996 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 997 {
 998         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
 999         if (!status) {
1000                 struct sco_conn *conn;
1001
1002                 conn = sco_conn_add(hcon);
1003                 if (conn)
1004                         sco_conn_ready(conn);
1005         } else
1006                 sco_conn_del(hcon, bt_to_errno(status));
1007 }
1008
1009 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1010 {
1011         BT_DBG("hcon %p reason %d", hcon, reason);
1012
1013         sco_conn_del(hcon, bt_to_errno(reason));
1014 }
1015
1016 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1017 {
1018         struct sco_conn *conn = hcon->sco_data;
1019
1020         if (!conn)
1021                 goto drop;
1022
1023         BT_DBG("conn %p len %d", conn, skb->len);
1024
1025         if (skb->len) {
1026                 sco_recv_frame(conn, skb);
1027                 return 0;
1028         }
1029
1030 drop:
1031         kfree_skb(skb);
1032         return 0;
1033 }
1034
1035 static int sco_debugfs_show(struct seq_file *f, void *p)
1036 {
1037         struct sock *sk;
1038         struct hlist_node *node;
1039
1040         read_lock(&sco_sk_list.lock);
1041
1042         sk_for_each(sk, node, &sco_sk_list.head) {
1043                 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1044                            &bt_sk(sk)->dst, sk->sk_state);
1045         }
1046
1047         read_unlock(&sco_sk_list.lock);
1048
1049         return 0;
1050 }
1051
1052 static int sco_debugfs_open(struct inode *inode, struct file *file)
1053 {
1054         return single_open(file, sco_debugfs_show, inode->i_private);
1055 }
1056
1057 static const struct file_operations sco_debugfs_fops = {
1058         .open           = sco_debugfs_open,
1059         .read           = seq_read,
1060         .llseek         = seq_lseek,
1061         .release        = single_release,
1062 };
1063
1064 static struct dentry *sco_debugfs;
1065
1066 static const struct proto_ops sco_sock_ops = {
1067         .family         = PF_BLUETOOTH,
1068         .owner          = THIS_MODULE,
1069         .release        = sco_sock_release,
1070         .bind           = sco_sock_bind,
1071         .connect        = sco_sock_connect,
1072         .listen         = sco_sock_listen,
1073         .accept         = sco_sock_accept,
1074         .getname        = sco_sock_getname,
1075         .sendmsg        = sco_sock_sendmsg,
1076         .recvmsg        = sco_sock_recvmsg,
1077         .poll           = bt_sock_poll,
1078         .ioctl          = bt_sock_ioctl,
1079         .mmap           = sock_no_mmap,
1080         .socketpair     = sock_no_socketpair,
1081         .shutdown       = sco_sock_shutdown,
1082         .setsockopt     = sco_sock_setsockopt,
1083         .getsockopt     = sco_sock_getsockopt
1084 };
1085
1086 static const struct net_proto_family sco_sock_family_ops = {
1087         .family = PF_BLUETOOTH,
1088         .owner  = THIS_MODULE,
1089         .create = sco_sock_create,
1090 };
1091
1092 int __init sco_init(void)
1093 {
1094         int err;
1095
1096         err = proto_register(&sco_proto, 0);
1097         if (err < 0)
1098                 return err;
1099
1100         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1101         if (err < 0) {
1102                 BT_ERR("SCO socket registration failed");
1103                 goto error;
1104         }
1105
1106         err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1107         if (err < 0) {
1108                 BT_ERR("Failed to create SCO proc file");
1109                 bt_sock_unregister(BTPROTO_SCO);
1110                 goto error;
1111         }
1112
1113         if (bt_debugfs) {
1114                 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1115                                                   NULL, &sco_debugfs_fops);
1116                 if (!sco_debugfs)
1117                         BT_ERR("Failed to create SCO debug file");
1118         }
1119
1120         BT_INFO("SCO socket layer initialized");
1121
1122         return 0;
1123
1124 error:
1125         proto_unregister(&sco_proto);
1126         return err;
1127 }
1128
1129 void __exit sco_exit(void)
1130 {
1131         bt_procfs_cleanup(&init_net, "sco");
1132
1133         debugfs_remove(sco_debugfs);
1134
1135         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1136                 BT_ERR("SCO socket unregistration failed");
1137
1138         proto_unregister(&sco_proto);
1139 }
1140
1141 module_param(disable_esco, bool, 0644);
1142 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");