linux/net/bluetooth/sco.c
<<
>>
Prefs
   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
  35static bool disable_esco;
  36
  37static const struct proto_ops sco_sock_ops;
  38
  39static struct bt_sock_list sco_sk_list = {
  40        .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  41};
  42
  43static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  44static void sco_chan_del(struct sock *sk, int err);
  45
  46static void sco_sock_close(struct sock *sk);
  47static void sco_sock_kill(struct sock *sk);
  48
  49/* ---- SCO timers ---- */
  50static 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
  65static 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
  71static 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 ---- */
  78static 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
 108static 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
 117static 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
 142static 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
 157static 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("%s -> %s", batostr(src), batostr(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_put(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
 208done:
 209        hci_dev_unlock(hdev);
 210        hci_dev_put(hdev);
 211        return err;
 212}
 213
 214static 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
 240static 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
 255drop:
 256        kfree_skb(skb);
 257}
 258
 259/* -------- Socket interface ---------- */
 260static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
 261{
 262        struct hlist_node *node;
 263        struct sock *sk;
 264
 265        sk_for_each(sk, node, &sco_sk_list.head) {
 266                if (sk->sk_state != BT_LISTEN)
 267                        continue;
 268
 269                if (!bacmp(&bt_sk(sk)->src, ba))
 270                        return sk;
 271        }
 272
 273        return NULL;
 274}
 275
 276/* Find socket listening on source bdaddr.
 277 * Returns closest match.
 278 */
 279static struct sock *sco_get_sock_listen(bdaddr_t *src)
 280{
 281        struct sock *sk = NULL, *sk1 = NULL;
 282        struct hlist_node *node;
 283
 284        read_lock(&sco_sk_list.lock);
 285
 286        sk_for_each(sk, node, &sco_sk_list.head) {
 287                if (sk->sk_state != BT_LISTEN)
 288                        continue;
 289
 290                /* Exact match. */
 291                if (!bacmp(&bt_sk(sk)->src, src))
 292                        break;
 293
 294                /* Closest match */
 295                if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 296                        sk1 = sk;
 297        }
 298
 299        read_unlock(&sco_sk_list.lock);
 300
 301        return node ? sk : sk1;
 302}
 303
 304static void sco_sock_destruct(struct sock *sk)
 305{
 306        BT_DBG("sk %p", sk);
 307
 308        skb_queue_purge(&sk->sk_receive_queue);
 309        skb_queue_purge(&sk->sk_write_queue);
 310}
 311
 312static void sco_sock_cleanup_listen(struct sock *parent)
 313{
 314        struct sock *sk;
 315
 316        BT_DBG("parent %p", parent);
 317
 318        /* Close not yet accepted channels */
 319        while ((sk = bt_accept_dequeue(parent, NULL))) {
 320                sco_sock_close(sk);
 321                sco_sock_kill(sk);
 322        }
 323
 324        parent->sk_state  = BT_CLOSED;
 325        sock_set_flag(parent, SOCK_ZAPPED);
 326}
 327
 328/* Kill socket (only if zapped and orphan)
 329 * Must be called on unlocked socket.
 330 */
 331static void sco_sock_kill(struct sock *sk)
 332{
 333        if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 334                return;
 335
 336        BT_DBG("sk %p state %d", sk, sk->sk_state);
 337
 338        /* Kill poor orphan */
 339        bt_sock_unlink(&sco_sk_list, sk);
 340        sock_set_flag(sk, SOCK_DEAD);
 341        sock_put(sk);
 342}
 343
 344static void __sco_sock_close(struct sock *sk)
 345{
 346        BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 347
 348        switch (sk->sk_state) {
 349        case BT_LISTEN:
 350                sco_sock_cleanup_listen(sk);
 351                break;
 352
 353        case BT_CONNECTED:
 354        case BT_CONFIG:
 355                if (sco_pi(sk)->conn) {
 356                        sk->sk_state = BT_DISCONN;
 357                        sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 358                        hci_conn_put(sco_pi(sk)->conn->hcon);
 359                        sco_pi(sk)->conn->hcon = NULL;
 360                } else
 361                        sco_chan_del(sk, ECONNRESET);
 362                break;
 363
 364        case BT_CONNECT:
 365        case BT_DISCONN:
 366                sco_chan_del(sk, ECONNRESET);
 367                break;
 368
 369        default:
 370                sock_set_flag(sk, SOCK_ZAPPED);
 371                break;
 372        }
 373}
 374
 375/* Must be called on unlocked socket. */
 376static void sco_sock_close(struct sock *sk)
 377{
 378        sco_sock_clear_timer(sk);
 379        lock_sock(sk);
 380        __sco_sock_close(sk);
 381        release_sock(sk);
 382        sco_sock_kill(sk);
 383}
 384
 385static void sco_sock_init(struct sock *sk, struct sock *parent)
 386{
 387        BT_DBG("sk %p", sk);
 388
 389        if (parent) {
 390                sk->sk_type = parent->sk_type;
 391                security_sk_clone(parent, sk);
 392        }
 393}
 394
 395static struct proto sco_proto = {
 396        .name           = "SCO",
 397        .owner          = THIS_MODULE,
 398        .obj_size       = sizeof(struct sco_pinfo)
 399};
 400
 401static 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
 426static 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
 448static 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 %s", sk, batostr(&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
 475done:
 476        release_sock(sk);
 477        return err;
 478}
 479
 480static 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
 511done:
 512        release_sock(sk);
 513        return err;
 514}
 515
 516static 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
 548unlock:
 549        write_unlock(&sco_sk_list.lock);
 550
 551done:
 552        release_sock(sk);
 553        return err;
 554}
 555
 556static 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
 607done:
 608        release_sock(sk);
 609        return err;
 610}
 611
 612static 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
 630static 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
 656static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 657{
 658        struct sock *sk = sock->sk;
 659        int err = 0;
 660
 661        BT_DBG("sk %p", sk);
 662
 663        lock_sock(sk);
 664
 665        switch (optname) {
 666        default:
 667                err = -ENOPROTOOPT;
 668                break;
 669        }
 670
 671        release_sock(sk);
 672        return err;
 673}
 674
 675static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 676{
 677        struct sock *sk = sock->sk;
 678        struct sco_options opts;
 679        struct sco_conninfo cinfo;
 680        int len, err = 0;
 681
 682        BT_DBG("sk %p", sk);
 683
 684        if (get_user(len, optlen))
 685                return -EFAULT;
 686
 687        lock_sock(sk);
 688
 689        switch (optname) {
 690        case SCO_OPTIONS:
 691                if (sk->sk_state != BT_CONNECTED) {
 692                        err = -ENOTCONN;
 693                        break;
 694                }
 695
 696                opts.mtu = sco_pi(sk)->conn->mtu;
 697
 698                BT_DBG("mtu %d", opts.mtu);
 699
 700                len = min_t(unsigned int, len, sizeof(opts));
 701                if (copy_to_user(optval, (char *)&opts, len))
 702                        err = -EFAULT;
 703
 704                break;
 705
 706        case SCO_CONNINFO:
 707                if (sk->sk_state != BT_CONNECTED) {
 708                        err = -ENOTCONN;
 709                        break;
 710                }
 711
 712                memset(&cinfo, 0, sizeof(cinfo));
 713                cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 714                memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 715
 716                len = min_t(unsigned int, len, sizeof(cinfo));
 717                if (copy_to_user(optval, (char *)&cinfo, len))
 718                        err = -EFAULT;
 719
 720                break;
 721
 722        default:
 723                err = -ENOPROTOOPT;
 724                break;
 725        }
 726
 727        release_sock(sk);
 728        return err;
 729}
 730
 731static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 732{
 733        struct sock *sk = sock->sk;
 734        int len, err = 0;
 735
 736        BT_DBG("sk %p", sk);
 737
 738        if (level == SOL_SCO)
 739                return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 740
 741        if (get_user(len, optlen))
 742                return -EFAULT;
 743
 744        lock_sock(sk);
 745
 746        switch (optname) {
 747        default:
 748                err = -ENOPROTOOPT;
 749                break;
 750        }
 751
 752        release_sock(sk);
 753        return err;
 754}
 755
 756static int sco_sock_shutdown(struct socket *sock, int how)
 757{
 758        struct sock *sk = sock->sk;
 759        int err = 0;
 760
 761        BT_DBG("sock %p, sk %p", sock, sk);
 762
 763        if (!sk)
 764                return 0;
 765
 766        lock_sock(sk);
 767        if (!sk->sk_shutdown) {
 768                sk->sk_shutdown = SHUTDOWN_MASK;
 769                sco_sock_clear_timer(sk);
 770                __sco_sock_close(sk);
 771
 772                if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 773                        err = bt_sock_wait_state(sk, BT_CLOSED,
 774                                                 sk->sk_lingertime);
 775        }
 776        release_sock(sk);
 777        return err;
 778}
 779
 780static int sco_sock_release(struct socket *sock)
 781{
 782        struct sock *sk = sock->sk;
 783        int err = 0;
 784
 785        BT_DBG("sock %p, sk %p", sock, sk);
 786
 787        if (!sk)
 788                return 0;
 789
 790        sco_sock_close(sk);
 791
 792        if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 793                lock_sock(sk);
 794                err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 795                release_sock(sk);
 796        }
 797
 798        sock_orphan(sk);
 799        sco_sock_kill(sk);
 800        return err;
 801}
 802
 803static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 804{
 805        BT_DBG("conn %p", conn);
 806
 807        sco_pi(sk)->conn = conn;
 808        conn->sk = sk;
 809
 810        if (parent)
 811                bt_accept_enqueue(parent, sk);
 812}
 813
 814/* Delete channel.
 815 * Must be called on the locked socket. */
 816static void sco_chan_del(struct sock *sk, int err)
 817{
 818        struct sco_conn *conn;
 819
 820        conn = sco_pi(sk)->conn;
 821
 822        BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 823
 824        if (conn) {
 825                sco_conn_lock(conn);
 826                conn->sk = NULL;
 827                sco_pi(sk)->conn = NULL;
 828                sco_conn_unlock(conn);
 829
 830                if (conn->hcon)
 831                        hci_conn_put(conn->hcon);
 832        }
 833
 834        sk->sk_state = BT_CLOSED;
 835        sk->sk_err   = err;
 836        sk->sk_state_change(sk);
 837
 838        sock_set_flag(sk, SOCK_ZAPPED);
 839}
 840
 841static void sco_conn_ready(struct sco_conn *conn)
 842{
 843        struct sock *parent;
 844        struct sock *sk = conn->sk;
 845
 846        BT_DBG("conn %p", conn);
 847
 848        sco_conn_lock(conn);
 849
 850        if (sk) {
 851                sco_sock_clear_timer(sk);
 852                bh_lock_sock(sk);
 853                sk->sk_state = BT_CONNECTED;
 854                sk->sk_state_change(sk);
 855                bh_unlock_sock(sk);
 856        } else {
 857                parent = sco_get_sock_listen(conn->src);
 858                if (!parent)
 859                        goto done;
 860
 861                bh_lock_sock(parent);
 862
 863                sk = sco_sock_alloc(sock_net(parent), NULL,
 864                                    BTPROTO_SCO, GFP_ATOMIC);
 865                if (!sk) {
 866                        bh_unlock_sock(parent);
 867                        goto done;
 868                }
 869
 870                sco_sock_init(sk, parent);
 871
 872                bacpy(&bt_sk(sk)->src, conn->src);
 873                bacpy(&bt_sk(sk)->dst, conn->dst);
 874
 875                hci_conn_hold(conn->hcon);
 876                __sco_chan_add(conn, sk, parent);
 877
 878                sk->sk_state = BT_CONNECTED;
 879
 880                /* Wake up parent */
 881                parent->sk_data_ready(parent, 1);
 882
 883                bh_unlock_sock(parent);
 884        }
 885
 886done:
 887        sco_conn_unlock(conn);
 888}
 889
 890/* ----- SCO interface with lower layer (HCI) ----- */
 891int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr)
 892{
 893        struct sock *sk;
 894        struct hlist_node *node;
 895        int lm = 0;
 896
 897        BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 898
 899        /* Find listening sockets */
 900        read_lock(&sco_sk_list.lock);
 901        sk_for_each(sk, node, &sco_sk_list.head) {
 902                if (sk->sk_state != BT_LISTEN)
 903                        continue;
 904
 905                if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 906                    !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 907                        lm |= HCI_LM_ACCEPT;
 908                        break;
 909                }
 910        }
 911        read_unlock(&sco_sk_list.lock);
 912
 913        return lm;
 914}
 915
 916void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 917{
 918        BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 919        if (!status) {
 920                struct sco_conn *conn;
 921
 922                conn = sco_conn_add(hcon);
 923                if (conn)
 924                        sco_conn_ready(conn);
 925        } else
 926                sco_conn_del(hcon, bt_to_errno(status));
 927}
 928
 929void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 930{
 931        BT_DBG("hcon %p reason %d", hcon, reason);
 932
 933        sco_conn_del(hcon, bt_to_errno(reason));
 934}
 935
 936int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 937{
 938        struct sco_conn *conn = hcon->sco_data;
 939
 940        if (!conn)
 941                goto drop;
 942
 943        BT_DBG("conn %p len %d", conn, skb->len);
 944
 945        if (skb->len) {
 946                sco_recv_frame(conn, skb);
 947                return 0;
 948        }
 949
 950drop:
 951        kfree_skb(skb);
 952        return 0;
 953}
 954
 955static int sco_debugfs_show(struct seq_file *f, void *p)
 956{
 957        struct sock *sk;
 958        struct hlist_node *node;
 959
 960        read_lock(&sco_sk_list.lock);
 961
 962        sk_for_each(sk, node, &sco_sk_list.head) {
 963                seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
 964                           batostr(&bt_sk(sk)->dst), sk->sk_state);
 965        }
 966
 967        read_unlock(&sco_sk_list.lock);
 968
 969        return 0;
 970}
 971
 972static int sco_debugfs_open(struct inode *inode, struct file *file)
 973{
 974        return single_open(file, sco_debugfs_show, inode->i_private);
 975}
 976
 977static const struct file_operations sco_debugfs_fops = {
 978        .open           = sco_debugfs_open,
 979        .read           = seq_read,
 980        .llseek         = seq_lseek,
 981        .release        = single_release,
 982};
 983
 984static struct dentry *sco_debugfs;
 985
 986static const struct proto_ops sco_sock_ops = {
 987        .family         = PF_BLUETOOTH,
 988        .owner          = THIS_MODULE,
 989        .release        = sco_sock_release,
 990        .bind           = sco_sock_bind,
 991        .connect        = sco_sock_connect,
 992        .listen         = sco_sock_listen,
 993        .accept         = sco_sock_accept,
 994        .getname        = sco_sock_getname,
 995        .sendmsg        = sco_sock_sendmsg,
 996        .recvmsg        = bt_sock_recvmsg,
 997        .poll           = bt_sock_poll,
 998        .ioctl          = bt_sock_ioctl,
 999        .mmap           = sock_no_mmap,
1000        .socketpair     = sock_no_socketpair,
1001        .shutdown       = sco_sock_shutdown,
1002        .setsockopt     = sco_sock_setsockopt,
1003        .getsockopt     = sco_sock_getsockopt
1004};
1005
1006static const struct net_proto_family sco_sock_family_ops = {
1007        .family = PF_BLUETOOTH,
1008        .owner  = THIS_MODULE,
1009        .create = sco_sock_create,
1010};
1011
1012int __init sco_init(void)
1013{
1014        int err;
1015
1016        err = proto_register(&sco_proto, 0);
1017        if (err < 0)
1018                return err;
1019
1020        err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1021        if (err < 0) {
1022                BT_ERR("SCO socket registration failed");
1023                goto error;
1024        }
1025
1026        err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1027        if (err < 0) {
1028                BT_ERR("Failed to create SCO proc file");
1029                bt_sock_unregister(BTPROTO_SCO);
1030                goto error;
1031        }
1032
1033        if (bt_debugfs) {
1034                sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1035                                                  NULL, &sco_debugfs_fops);
1036                if (!sco_debugfs)
1037                        BT_ERR("Failed to create SCO debug file");
1038        }
1039
1040        BT_INFO("SCO socket layer initialized");
1041
1042        return 0;
1043
1044error:
1045        proto_unregister(&sco_proto);
1046        return err;
1047}
1048
1049void __exit sco_exit(void)
1050{
1051        bt_procfs_cleanup(&init_net, "sco");
1052
1053        debugfs_remove(sco_debugfs);
1054
1055        if (bt_sock_unregister(BTPROTO_SCO) < 0)
1056                BT_ERR("SCO socket unregistration failed");
1057
1058        proto_unregister(&sco_proto);
1059}
1060
1061module_param(disable_esco, bool, 0644);
1062MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1063
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.