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