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 = 0;
 485
 486
 487         BT_DBG("sk %p", sk);
 488
 489         if (alen < sizeof(struct sockaddr_sco) ||
 490             addr->sa_family != AF_BLUETOOTH)
 491                 return -EINVAL;
 492
 493         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 494                 return -EBADFD;
 495
 496         if (sk->sk_type != SOCK_SEQPACKET)
 497                 return -EINVAL;
 498
 499         lock_sock(sk);
 500
 501         /* Set destination address and psm */
 502         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 503
 504         err = sco_connect(sk);
 505         if (err)
 506                 goto done;
 507
 508         err = bt_sock_wait_state(sk, BT_CONNECTED,
 509                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 510
 511 done:
 512         release_sock(sk);
 513         return err;
 514 }
 515
 516 static int sco_sock_listen(struct socket *sock, int backlog)
 517 {
 518         struct sock *sk = sock->sk;
 519         bdaddr_t *src = &bt_sk(sk)->src;
 520         int err = 0;
 521
 522         BT_DBG("sk %p backlog %d", sk, backlog);
 523
 524         lock_sock(sk);
 525
 526         if (sk->sk_state != BT_BOUND) {
 527                 err = -EBADFD;
 528                 goto done;
 529         }
 530
 531         if (sk->sk_type != SOCK_SEQPACKET) {
 532                 err = -EINVAL;
 533                 goto done;
 534         }
 535
 536         write_lock(&sco_sk_list.lock);
 537
 538         if (__sco_get_sock_listen_by_addr(src)) {
 539                 err = -EADDRINUSE;
 540                 goto unlock;
 541         }
 542
 543         sk->sk_max_ack_backlog = backlog;
 544         sk->sk_ack_backlog = 0;
 545
 546         sk->sk_state = BT_LISTEN;
 547
 548 unlock:
 549         write_unlock(&sco_sk_list.lock);
 550
 551 done:
 552         release_sock(sk);
 553         return err;
 554 }
 555
 556 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 557 {
 558         DECLARE_WAITQUEUE(wait, current);
 559         struct sock *sk = sock->sk, *ch;
 560         long timeo;
 561         int err = 0;
 562
 563         lock_sock(sk);
 564
 565         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 566
 567         BT_DBG("sk %p timeo %ld", sk, timeo);
 568
 569         /* Wait for an incoming connection. (wake-one). */
 570         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 571         while (1) {
 572                 set_current_state(TASK_INTERRUPTIBLE);
 573
 574                 if (sk->sk_state != BT_LISTEN) {
 575                         err = -EBADFD;
 576                         break;
 577                 }
 578
 579                 ch = bt_accept_dequeue(sk, newsock);
 580                 if (ch)
 581                         break;
 582
 583                 if (!timeo) {
 584                         err = -EAGAIN;
 585                         break;
 586                 }
 587
 588                 if (signal_pending(current)) {
 589                         err = sock_intr_errno(timeo);
 590                         break;
 591                 }
 592
 593                 release_sock(sk);
 594                 timeo = schedule_timeout(timeo);
 595                 lock_sock(sk);
 596         }
 597         __set_current_state(TASK_RUNNING);
 598         remove_wait_queue(sk_sleep(sk), &wait);
 599
 600         if (err)
 601                 goto done;
 602
 603         newsock->state = SS_CONNECTED;
 604
 605         BT_DBG("new socket %p", ch);
 606
 607 done:
 608         release_sock(sk);
 609         return err;
 610 }
 611
 612 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 613 {
 614         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 615         struct sock *sk = sock->sk;
 616
 617         BT_DBG("sock %p, sk %p", sock, sk);
 618
 619         addr->sa_family = AF_BLUETOOTH;
 620         *len = sizeof(struct sockaddr_sco);
 621
 622         if (peer)
 623                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 624         else
 625                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 626
 627         return 0;
 628 }
 629
 630 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 631                             struct msghdr *msg, size_t len)
 632 {
 633         struct sock *sk = sock->sk;
 634         int err;
 635
 636         BT_DBG("sock %p, sk %p", sock, sk);
 637
 638         err = sock_error(sk);
 639         if (err)
 640                 return err;
 641
 642         if (msg->msg_flags & MSG_OOB)
 643                 return -EOPNOTSUPP;
 644
 645         lock_sock(sk);
 646
 647         if (sk->sk_state == BT_CONNECTED)
 648                 err = sco_send_frame(sk, msg, len);
 649         else
 650                 err = -ENOTCONN;
 651
 652         release_sock(sk);
 653         return err;
 654 }
 655
 656 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 657                             struct msghdr *msg, size_t len, int flags)
 658 {
 659         struct sock *sk = sock->sk;
 660         struct sco_pinfo *pi = sco_pi(sk);
 661
 662         lock_sock(sk);
 663
 664         if (sk->sk_state == BT_CONNECT2 &&
 665             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 666                 hci_conn_accept(pi->conn->hcon, 0);
 667                 sk->sk_state = BT_CONFIG;
 668
 669                 release_sock(sk);
 670                 return 0;
 671         }
 672
 673         release_sock(sk);
 674
 675         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 676 }
 677
 678 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 679 {
 680         struct sock *sk = sock->sk;
 681         int err = 0;
 682         u32 opt;
 683
 684         BT_DBG("sk %p", sk);
 685
 686         lock_sock(sk);
 687
 688         switch (optname) {
 689
 690         case BT_DEFER_SETUP:
 691                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 692                         err = -EINVAL;
 693                         break;
 694                 }
 695
 696                 if (get_user(opt, (u32 __user *) optval)) {
 697                         err = -EFAULT;
 698                         break;
 699                 }
 700
 701                 if (opt)
 702                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 703                 else
 704                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 705                 break;
 706
 707         default:
 708                 err = -ENOPROTOOPT;
 709                 break;
 710         }
 711
 712         release_sock(sk);
 713         return err;
 714 }
 715
 716 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 717 {
 718         struct sock *sk = sock->sk;
 719         struct sco_options opts;
 720         struct sco_conninfo cinfo;
 721         int len, err = 0;
 722
 723         BT_DBG("sk %p", sk);
 724
 725         if (get_user(len, optlen))
 726                 return -EFAULT;
 727
 728         lock_sock(sk);
 729
 730         switch (optname) {
 731         case SCO_OPTIONS:
 732                 if (sk->sk_state != BT_CONNECTED) {
 733                         err = -ENOTCONN;
 734                         break;
 735                 }
 736
 737                 opts.mtu = sco_pi(sk)->conn->mtu;
 738
 739                 BT_DBG("mtu %d", opts.mtu);
 740
 741                 len = min_t(unsigned int, len, sizeof(opts));
 742                 if (copy_to_user(optval, (char *)&opts, len))
 743                         err = -EFAULT;
 744
 745                 break;
 746
 747         case SCO_CONNINFO:
 748                 if (sk->sk_state != BT_CONNECTED) {
 749                         err = -ENOTCONN;
 750                         break;
 751                 }
 752
 753                 memset(&cinfo, 0, sizeof(cinfo));
 754                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 755                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 756
 757                 len = min_t(unsigned int, len, sizeof(cinfo));
 758                 if (copy_to_user(optval, (char *)&cinfo, len))
 759                         err = -EFAULT;
 760
 761                 break;
 762
 763         default:
 764                 err = -ENOPROTOOPT;
 765                 break;
 766         }
 767
 768         release_sock(sk);
 769         return err;
 770 }
 771
 772 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 773 {
 774         struct sock *sk = sock->sk;
 775         int len, err = 0;
 776
 777         BT_DBG("sk %p", sk);
 778
 779         if (level == SOL_SCO)
 780                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 781
 782         if (get_user(len, optlen))
 783                 return -EFAULT;
 784
 785         lock_sock(sk);
 786
 787         switch (optname) {
 788
 789         case BT_DEFER_SETUP:
 790                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 791                         err = -EINVAL;
 792                         break;
 793                 }
 794
 795                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 796                              (u32 __user *) optval))
 797                         err = -EFAULT;
 798
 799                 break;
 800
 801         default:
 802                 err = -ENOPROTOOPT;
 803                 break;
 804         }
 805
 806         release_sock(sk);
 807         return err;
 808 }
 809
 810 static int sco_sock_shutdown(struct socket *sock, int how)
 811 {
 812         struct sock *sk = sock->sk;
 813         int err = 0;
 814
 815         BT_DBG("sock %p, sk %p", sock, sk);
 816
 817         if (!sk)
 818                 return 0;
 819
 820         lock_sock(sk);
 821         if (!sk->sk_shutdown) {
 822                 sk->sk_shutdown = SHUTDOWN_MASK;
 823                 sco_sock_clear_timer(sk);
 824                 __sco_sock_close(sk);
 825
 826                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 827                         err = bt_sock_wait_state(sk, BT_CLOSED,
 828                                                  sk->sk_lingertime);
 829         }
 830         release_sock(sk);
 831         return err;
 832 }
 833
 834 static int sco_sock_release(struct socket *sock)
 835 {
 836         struct sock *sk = sock->sk;
 837         int err = 0;
 838
 839         BT_DBG("sock %p, sk %p", sock, sk);
 840
 841         if (!sk)
 842                 return 0;
 843
 844         sco_sock_close(sk);
 845
 846         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 847                 lock_sock(sk);
 848                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 849                 release_sock(sk);
 850         }
 851
 852         sock_orphan(sk);
 853         sco_sock_kill(sk);
 854         return err;
 855 }
 856
 857 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 858 {
 859         BT_DBG("conn %p", conn);
 860
 861         sco_pi(sk)->conn = conn;
 862         conn->sk = sk;
 863
 864         if (parent)
 865                 bt_accept_enqueue(parent, sk);
 866 }
 867
 868 /* Delete channel.
 869  * Must be called on the locked socket. */
 870 static void sco_chan_del(struct sock *sk, int err)
 871 {
 872         struct sco_conn *conn;
 873
 874         conn = sco_pi(sk)->conn;
 875
 876         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 877
 878         if (conn) {
 879                 sco_conn_lock(conn);
 880                 conn->sk = NULL;
 881                 sco_pi(sk)->conn = NULL;
 882                 sco_conn_unlock(conn);
 883
 884                 if (conn->hcon)
 885                         hci_conn_drop(conn->hcon);
 886         }
 887
 888         sk->sk_state = BT_CLOSED;
 889         sk->sk_err   = err;
 890         sk->sk_state_change(sk);
 891
 892         sock_set_flag(sk, SOCK_ZAPPED);
 893 }
 894
 895 static void sco_conn_ready(struct sco_conn *conn)
 896 {
 897         struct sock *parent;
 898         struct sock *sk = conn->sk;
 899
 900         BT_DBG("conn %p", conn);
 901
 902         if (sk) {
 903                 sco_sock_clear_timer(sk);
 904                 bh_lock_sock(sk);
 905                 sk->sk_state = BT_CONNECTED;
 906                 sk->sk_state_change(sk);
 907                 bh_unlock_sock(sk);
 908         } else {
 909                 sco_conn_lock(conn);
 910
 911                 parent = sco_get_sock_listen(conn->src);
 912                 if (!parent) {
 913                         sco_conn_unlock(conn);
 914                         return;
 915                 }
 916
 917                 bh_lock_sock(parent);
 918
 919                 sk = sco_sock_alloc(sock_net(parent), NULL,
 920                                     BTPROTO_SCO, GFP_ATOMIC);
 921                 if (!sk) {
 922                         bh_unlock_sock(parent);
 923                         sco_conn_unlock(conn);
 924                         return;
 925                 }
 926
 927                 sco_sock_init(sk, parent);
 928
 929                 bacpy(&bt_sk(sk)->src, conn->src);
 930                 bacpy(&bt_sk(sk)->dst, conn->dst);
 931
 932                 hci_conn_hold(conn->hcon);
 933                 __sco_chan_add(conn, sk, parent);
 934
 935                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
 936                         sk->sk_state = BT_CONNECT2;
 937                 else
 938                         sk->sk_state = BT_CONNECTED;
 939
 940                 /* Wake up parent */
 941                 parent->sk_data_ready(parent, 1);
 942
 943                 bh_unlock_sock(parent);
 944
 945                 sco_conn_unlock(conn);
 946         }
 947 }
 948
 949 /* ----- SCO interface with lower layer (HCI) ----- */
 950 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
 951 {
 952         struct sock *sk;
 953         int lm = 0;
 954
 955         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
 956
 957         /* Find listening sockets */
 958         read_lock(&sco_sk_list.lock);
 959         sk_for_each(sk, &sco_sk_list.head) {
 960                 if (sk->sk_state != BT_LISTEN)
 961                         continue;
 962
 963                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 964                     !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 965                         lm |= HCI_LM_ACCEPT;
 966
 967                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
 968                                 *flags |= HCI_PROTO_DEFER;
 969                         break;
 970                 }
 971         }
 972         read_unlock(&sco_sk_list.lock);
 973
 974         return lm;
 975 }
 976
 977 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 978 {
 979         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
 980         if (!status) {
 981                 struct sco_conn *conn;
 982
 983                 conn = sco_conn_add(hcon);
 984                 if (conn)
 985                         sco_conn_ready(conn);
 986         } else
 987                 sco_conn_del(hcon, bt_to_errno(status));
 988 }
 989
 990 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 991 {
 992         BT_DBG("hcon %p reason %d", hcon, reason);
 993
 994         sco_conn_del(hcon, bt_to_errno(reason));
 995 }
 996
 997 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 998 {
 999         struct sco_conn *conn = hcon->sco_data;
1000
1001         if (!conn)
1002                 goto drop;
1003
1004         BT_DBG("conn %p len %d", conn, skb->len);
1005
1006         if (skb->len) {
1007                 sco_recv_frame(conn, skb);
1008                 return 0;
1009         }
1010
1011 drop:
1012         kfree_skb(skb);
1013         return 0;
1014 }
1015
1016 static int sco_debugfs_show(struct seq_file *f, void *p)
1017 {
1018         struct sock *sk;
1019
1020         read_lock(&sco_sk_list.lock);
1021
1022         sk_for_each(sk, &sco_sk_list.head) {
1023                 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1024                            &bt_sk(sk)->dst, sk->sk_state);
1025         }
1026
1027         read_unlock(&sco_sk_list.lock);
1028
1029         return 0;
1030 }
1031
1032 static int sco_debugfs_open(struct inode *inode, struct file *file)
1033 {
1034         return single_open(file, sco_debugfs_show, inode->i_private);
1035 }
1036
1037 static const struct file_operations sco_debugfs_fops = {
1038         .open           = sco_debugfs_open,
1039         .read           = seq_read,
1040         .llseek         = seq_lseek,
1041         .release        = single_release,
1042 };
1043
1044 static struct dentry *sco_debugfs;
1045
1046 static const struct proto_ops sco_sock_ops = {
1047         .family         = PF_BLUETOOTH,
1048         .owner          = THIS_MODULE,
1049         .release        = sco_sock_release,
1050         .bind           = sco_sock_bind,
1051         .connect        = sco_sock_connect,
1052         .listen         = sco_sock_listen,
1053         .accept         = sco_sock_accept,
1054         .getname        = sco_sock_getname,
1055         .sendmsg        = sco_sock_sendmsg,
1056         .recvmsg        = sco_sock_recvmsg,
1057         .poll           = bt_sock_poll,
1058         .ioctl          = bt_sock_ioctl,
1059         .mmap           = sock_no_mmap,
1060         .socketpair     = sock_no_socketpair,
1061         .shutdown       = sco_sock_shutdown,
1062         .setsockopt     = sco_sock_setsockopt,
1063         .getsockopt     = sco_sock_getsockopt
1064 };
1065
1066 static const struct net_proto_family sco_sock_family_ops = {
1067         .family = PF_BLUETOOTH,
1068         .owner  = THIS_MODULE,
1069         .create = sco_sock_create,
1070 };
1071
1072 int __init sco_init(void)
1073 {
1074         int err;
1075
1076         err = proto_register(&sco_proto, 0);
1077         if (err < 0)
1078                 return err;
1079
1080         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1081         if (err < 0) {
1082                 BT_ERR("SCO socket registration failed");
1083                 goto error;
1084         }
1085
1086         err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1087         if (err < 0) {
1088                 BT_ERR("Failed to create SCO proc file");
1089                 bt_sock_unregister(BTPROTO_SCO);
1090                 goto error;
1091         }
1092
1093         if (bt_debugfs) {
1094                 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1095                                                   NULL, &sco_debugfs_fops);
1096                 if (!sco_debugfs)
1097                         BT_ERR("Failed to create SCO debug file");
1098         }
1099
1100         BT_INFO("SCO socket layer initialized");
1101
1102         return 0;
1103
1104 error:
1105         proto_unregister(&sco_proto);
1106         return err;
1107 }
1108
1109 void __exit sco_exit(void)
1110 {
1111         bt_procfs_cleanup(&init_net, "sco");
1112
1113         debugfs_remove(sco_debugfs);
1114
1115         bt_sock_unregister(BTPROTO_SCO);
1116
1117         proto_unregister(&sco_proto);
1118 }
1119
1120 module_param(disable_esco, bool, 0644);
1121 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");