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
 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
 151static 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
 166static 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
 217done:
 218        hci_dev_unlock(hdev);
 219        hci_dev_put(hdev);
 220        return err;
 221}
 222
 223static 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
 249static 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
 264drop:
 265        kfree_skb(skb);
 266}
 267
 268/* -------- Socket interface ---------- */
 269static 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 */
 288static 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
 313static 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
 321static 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 */
 340static 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
 353static 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. */
 385static 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
 394static 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
 404static struct proto sco_proto = {
 405        .name           = "SCO",
 406        .owner          = THIS_MODULE,
 407        .obj_size       = sizeof(struct sco_pinfo)
 408};
 409
 410static 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
 435static 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
 457static 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
 484done:
 485        release_sock(sk);
 486        return err;
 487}
 488
 489static 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
 520done:
 521        release_sock(sk);
 522        return err;
 523}
 524
 525static 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
 557unlock:
 558        write_unlock(&sco_sk_list.lock);
 559
 560done:
 561        release_sock(sk);
 562        return err;
 563}
 564
 565static 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
 616done:
 617        release_sock(sk);
 618        return err;
 619}
 620
 621static 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
 639static 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
 665static 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
 684static 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
 740static 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
 765static 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
 789static 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
 812static 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. */
 825static 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
 840static 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
 885done:
 886        sco_conn_unlock(conn);
 887}
 888
 889/* ----- SCO interface with lower layer (HCI) ----- */
 890int 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
 915int 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
 930int 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
 938int 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
 952drop:
 953        kfree_skb(skb);
 954        return 0;
 955}
 956
 957static 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
 974static int sco_debugfs_open(struct inode *inode, struct file *file)
 975{
 976        return single_open(file, sco_debugfs_show, inode->i_private);
 977}
 978
 979static 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
 986static struct dentry *sco_debugfs;
 987
 988static 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
1008static const struct net_proto_family sco_sock_family_ops = {
1009        .family = PF_BLUETOOTH,
1010        .owner  = THIS_MODULE,
1011        .create = sco_sock_create,
1012};
1013
1014int __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
1039error:
1040        proto_unregister(&sco_proto);
1041        return err;
1042}
1043
1044void __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
1054module_param(disable_esco, bool, 0644);
1055MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1056
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.