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
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/kernel.h>
  32 #include <linux/sched.h>
  33 #include <linux/slab.h>
  34 #include <linux/poll.h>
  35 #include <linux/fcntl.h>
  36 #include <linux/init.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/socket.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/device.h>
  41 #include <linux/list.h>
  42 #include <net/sock.h>
  43
  44 #include <asm/system.h>
  45 #include <asm/uaccess.h>
  46
  47 #include <net/bluetooth/bluetooth.h>
  48 #include <net/bluetooth/hci_core.h>
  49 #include <net/bluetooth/sco.h>
  50
  51 #define VERSION "0.6"
  52
  53 static int disable_esco = 0;
  54
  55 static const struct proto_ops sco_sock_ops;
  56
  57 static struct bt_sock_list sco_sk_list = {
  58         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  59 };
  60
  61 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  62 static void sco_chan_del(struct sock *sk, int err);
  63
  64 static int  sco_conn_del(struct hci_conn *conn, int err);
  65
  66 static void sco_sock_close(struct sock *sk);
  67 static void sco_sock_kill(struct sock *sk);
  68
  69 /* ---- SCO timers ---- */
  70 static void sco_sock_timeout(unsigned long arg)
  71 {
  72         struct sock *sk = (struct sock *) arg;
  73
  74         BT_DBG("sock %p state %d", sk, sk->sk_state);
  75
  76         bh_lock_sock(sk);
  77         sk->sk_err = ETIMEDOUT;
  78         sk->sk_state_change(sk);
  79         bh_unlock_sock(sk);
  80
  81         sco_sock_kill(sk);
  82         sock_put(sk);
  83 }
  84
  85 static void sco_sock_set_timer(struct sock *sk, long timeout)
  86 {
  87         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  88         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  89 }
  90
  91 static void sco_sock_clear_timer(struct sock *sk)
  92 {
  93         BT_DBG("sock %p state %d", sk, sk->sk_state);
  94         sk_stop_timer(sk, &sk->sk_timer);
  95 }
  96
  97 /* ---- SCO connections ---- */
  98 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
  99 {
 100         struct hci_dev *hdev = hcon->hdev;
 101         struct sco_conn *conn = hcon->sco_data;
 102
 103         if (conn || status)
 104                 return conn;
 105
 106         conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
 107         if (!conn)
 108                 return NULL;
 109
 110         spin_lock_init(&conn->lock);
 111
 112         hcon->sco_data = conn;
 113         conn->hcon = hcon;
 114
 115         conn->src = &hdev->bdaddr;
 116         conn->dst = &hcon->dst;
 117
 118         if (hdev->sco_mtu > 0)
 119                 conn->mtu = hdev->sco_mtu;
 120         else
 121                 conn->mtu = 60;
 122
 123         BT_DBG("hcon %p conn %p", hcon, conn);
 124
 125         return conn;
 126 }
 127
 128 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 129 {
 130         struct sock *sk = NULL;
 131         sco_conn_lock(conn);
 132         sk = conn->sk;
 133         sco_conn_unlock(conn);
 134         return sk;
 135 }
 136
 137 static int sco_conn_del(struct hci_conn *hcon, int err)
 138 {
 139         struct sco_conn *conn;
 140         struct sock *sk;
 141
 142         if (!(conn = hcon->sco_data))
 143                 return 0;
 144
 145         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 146
 147         /* Kill socket */
 148         if ((sk = sco_chan_get(conn))) {
 149                 bh_lock_sock(sk);
 150                 sco_sock_clear_timer(sk);
 151                 sco_chan_del(sk, err);
 152                 bh_unlock_sock(sk);
 153                 sco_sock_kill(sk);
 154         }
 155
 156         hcon->sco_data = NULL;
 157         kfree(conn);
 158         return 0;
 159 }
 160
 161 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 162 {
 163         int err = 0;
 164
 165         sco_conn_lock(conn);
 166         if (conn->sk) {
 167                 err = -EBUSY;
 168         } else {
 169                 __sco_chan_add(conn, sk, parent);
 170         }
 171         sco_conn_unlock(conn);
 172         return err;
 173 }
 174
 175 static int sco_connect(struct sock *sk)
 176 {
 177         bdaddr_t *src = &bt_sk(sk)->src;
 178         bdaddr_t *dst = &bt_sk(sk)->dst;
 179         struct sco_conn *conn;
 180         struct hci_conn *hcon;
 181         struct hci_dev  *hdev;
 182         int err, type;
 183
 184         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 185
 186         if (!(hdev = hci_get_route(dst, src)))
 187                 return -EHOSTUNREACH;
 188
 189         hci_dev_lock_bh(hdev);
 190
 191         err = -ENOMEM;
 192
 193         if (lmp_esco_capable(hdev) && !disable_esco)
 194                 type = ESCO_LINK;
 195         else
 196                 type = SCO_LINK;
 197
 198         hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
 199         if (!hcon)
 200                 goto done;
 201
 202         conn = sco_conn_add(hcon, 0);
 203         if (!conn) {
 204                 hci_conn_put(hcon);
 205                 goto done;
 206         }
 207
 208         /* Update source addr of the socket */
 209         bacpy(src, conn->src);
 210
 211         err = sco_chan_add(conn, sk, NULL);
 212         if (err)
 213                 goto done;
 214
 215         if (hcon->state == BT_CONNECTED) {
 216                 sco_sock_clear_timer(sk);
 217                 sk->sk_state = BT_CONNECTED;
 218         } else {
 219                 sk->sk_state = BT_CONNECT;
 220                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 221         }
 222
 223 done:
 224         hci_dev_unlock_bh(hdev);
 225         hci_dev_put(hdev);
 226         return err;
 227 }
 228
 229 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 230 {
 231         struct sco_conn *conn = sco_pi(sk)->conn;
 232         struct sk_buff *skb;
 233         int err, count;
 234
 235         /* Check outgoing MTU */
 236         if (len > conn->mtu)
 237                 return -EINVAL;
 238
 239         BT_DBG("sk %p len %d", sk, len);
 240
 241         count = min_t(unsigned int, conn->mtu, len);
 242         if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
 243                 return err;
 244
 245         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 246                 err = -EFAULT;
 247                 goto fail;
 248         }
 249
 250         if ((err = hci_send_sco(conn->hcon, skb)) < 0)
 251                 return err;
 252
 253         return count;
 254
 255 fail:
 256         kfree_skb(skb);
 257         return err;
 258 }
 259
 260 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 261 {
 262         struct sock *sk = sco_chan_get(conn);
 263
 264         if (!sk)
 265                 goto drop;
 266
 267         BT_DBG("sk %p len %d", sk, skb->len);
 268
 269         if (sk->sk_state != BT_CONNECTED)
 270                 goto drop;
 271
 272         if (!sock_queue_rcv_skb(sk, skb))
 273                 return;
 274
 275 drop:
 276         kfree_skb(skb);
 277         return;
 278 }
 279
 280 /* -------- Socket interface ---------- */
 281 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
 282 {
 283         struct sock *sk;
 284         struct hlist_node *node;
 285
 286         sk_for_each(sk, node, &sco_sk_list.head)
 287                 if (!bacmp(&bt_sk(sk)->src, ba))
 288                         goto found;
 289         sk = NULL;
 290 found:
 291         return sk;
 292 }
 293
 294 /* Find socket listening on source bdaddr.
 295  * Returns closest match.
 296  */
 297 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 298 {
 299         struct sock *sk = NULL, *sk1 = NULL;
 300         struct hlist_node *node;
 301
 302         read_lock(&sco_sk_list.lock);
 303
 304         sk_for_each(sk, node, &sco_sk_list.head) {
 305                 if (sk->sk_state != BT_LISTEN)
 306                         continue;
 307
 308                 /* Exact match. */
 309                 if (!bacmp(&bt_sk(sk)->src, src))
 310                         break;
 311
 312                 /* Closest match */
 313                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 314                         sk1 = sk;
 315         }
 316
 317         read_unlock(&sco_sk_list.lock);
 318
 319         return node ? sk : sk1;
 320 }
 321
 322 static void sco_sock_destruct(struct sock *sk)
 323 {
 324         BT_DBG("sk %p", sk);
 325
 326         skb_queue_purge(&sk->sk_receive_queue);
 327         skb_queue_purge(&sk->sk_write_queue);
 328 }
 329
 330 static void sco_sock_cleanup_listen(struct sock *parent)
 331 {
 332         struct sock *sk;
 333
 334         BT_DBG("parent %p", parent);
 335
 336         /* Close not yet accepted channels */
 337         while ((sk = bt_accept_dequeue(parent, NULL))) {
 338                 sco_sock_close(sk);
 339                 sco_sock_kill(sk);
 340         }
 341
 342         parent->sk_state  = BT_CLOSED;
 343         sock_set_flag(parent, SOCK_ZAPPED);
 344 }
 345
 346 /* Kill socket (only if zapped and orphan)
 347  * Must be called on unlocked socket.
 348  */
 349 static void sco_sock_kill(struct sock *sk)
 350 {
 351         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 352                 return;
 353
 354         BT_DBG("sk %p state %d", sk, sk->sk_state);
 355
 356         /* Kill poor orphan */
 357         bt_sock_unlink(&sco_sk_list, sk);
 358         sock_set_flag(sk, SOCK_DEAD);
 359         sock_put(sk);
 360 }
 361
 362 static void __sco_sock_close(struct sock *sk)
 363 {
 364         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 365
 366         switch (sk->sk_state) {
 367         case BT_LISTEN:
 368                 sco_sock_cleanup_listen(sk);
 369                 break;
 370
 371         case BT_CONNECTED:
 372         case BT_CONFIG:
 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 }
 401
 402 static struct proto sco_proto = {
 403         .name           = "SCO",
 404         .owner          = THIS_MODULE,
 405         .obj_size       = sizeof(struct sco_pinfo)
 406 };
 407
 408 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 409 {
 410         struct sock *sk;
 411
 412         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
 413         if (!sk)
 414                 return NULL;
 415
 416         sock_init_data(sock, sk);
 417         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 418
 419         sk->sk_destruct = sco_sock_destruct;
 420         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 421
 422         sock_reset_flag(sk, SOCK_ZAPPED);
 423
 424         sk->sk_protocol = proto;
 425         sk->sk_state    = BT_OPEN;
 426
 427         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
 428
 429         bt_sock_link(&sco_sk_list, sk);
 430         return sk;
 431 }
 432
 433 static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
 434 {
 435         struct sock *sk;
 436
 437         BT_DBG("sock %p", sock);
 438
 439         sock->state = SS_UNCONNECTED;
 440
 441         if (sock->type != SOCK_SEQPACKET)
 442                 return -ESOCKTNOSUPPORT;
 443
 444         sock->ops = &sco_sock_ops;
 445
 446         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 447         if (!sk)
 448                 return -ENOMEM;
 449
 450         sco_sock_init(sk, NULL);
 451         return 0;
 452 }
 453
 454 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 455 {
 456         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 457         struct sock *sk = sock->sk;
 458         bdaddr_t *src = &sa->sco_bdaddr;
 459         int err = 0;
 460
 461         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 462
 463         if (!addr || addr->sa_family != AF_BLUETOOTH)
 464                 return -EINVAL;
 465
 466         lock_sock(sk);
 467
 468         if (sk->sk_state != BT_OPEN) {
 469                 err = -EBADFD;
 470                 goto done;
 471         }
 472
 473         write_lock_bh(&sco_sk_list.lock);
 474
 475         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 476                 err = -EADDRINUSE;
 477         } else {
 478                 /* Save source address */
 479                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 480                 sk->sk_state = BT_BOUND;
 481         }
 482
 483         write_unlock_bh(&sco_sk_list.lock);
 484
 485 done:
 486         release_sock(sk);
 487         return err;
 488 }
 489
 490 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 491 {
 492         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 493         struct sock *sk = sock->sk;
 494         int err = 0;
 495
 496
 497         BT_DBG("sk %p", sk);
 498
 499         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 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         if ((err = sco_connect(sk)))
 514                 goto done;
 515
 516         err = bt_sock_wait_state(sk, BT_CONNECTED,
 517                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 518
 519 done:
 520         release_sock(sk);
 521         return err;
 522 }
 523
 524 static int sco_sock_listen(struct socket *sock, int backlog)
 525 {
 526         struct sock *sk = sock->sk;
 527         int err = 0;
 528
 529         BT_DBG("sk %p backlog %d", sk, backlog);
 530
 531         lock_sock(sk);
 532
 533         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 534                 err = -EBADFD;
 535                 goto done;
 536         }
 537
 538         sk->sk_max_ack_backlog = backlog;
 539         sk->sk_ack_backlog = 0;
 540         sk->sk_state = BT_LISTEN;
 541
 542 done:
 543         release_sock(sk);
 544         return err;
 545 }
 546
 547 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 548 {
 549         DECLARE_WAITQUEUE(wait, current);
 550         struct sock *sk = sock->sk, *ch;
 551         long timeo;
 552         int err = 0;
 553
 554         lock_sock(sk);
 555
 556         if (sk->sk_state != BT_LISTEN) {
 557                 err = -EBADFD;
 558                 goto done;
 559         }
 560
 561         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 562
 563         BT_DBG("sk %p timeo %ld", sk, timeo);
 564
 565         /* Wait for an incoming connection. (wake-one). */
 566         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 567         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 568                 set_current_state(TASK_INTERRUPTIBLE);
 569                 if (!timeo) {
 570                         err = -EAGAIN;
 571                         break;
 572                 }
 573
 574                 release_sock(sk);
 575                 timeo = schedule_timeout(timeo);
 576                 lock_sock(sk);
 577
 578                 if (sk->sk_state != BT_LISTEN) {
 579                         err = -EBADFD;
 580                         break;
 581                 }
 582
 583                 if (signal_pending(current)) {
 584                         err = sock_intr_errno(timeo);
 585                         break;
 586                 }
 587         }
 588         set_current_state(TASK_RUNNING);
 589         remove_wait_queue(sk->sk_sleep, &wait);
 590
 591         if (err)
 592                 goto done;
 593
 594         newsock->state = SS_CONNECTED;
 595
 596         BT_DBG("new socket %p", ch);
 597
 598 done:
 599         release_sock(sk);
 600         return err;
 601 }
 602
 603 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 604 {
 605         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 606         struct sock *sk = sock->sk;
 607
 608         BT_DBG("sock %p, sk %p", sock, sk);
 609
 610         addr->sa_family = AF_BLUETOOTH;
 611         *len = sizeof(struct sockaddr_sco);
 612
 613         if (peer)
 614                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 615         else
 616                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 617
 618         return 0;
 619 }
 620
 621 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 622                             struct msghdr *msg, size_t len)
 623 {
 624         struct sock *sk = sock->sk;
 625         int err = 0;
 626
 627         BT_DBG("sock %p, sk %p", sock, sk);
 628
 629         err = sock_error(sk);
 630         if (err)
 631                 return err;
 632
 633         if (msg->msg_flags & MSG_OOB)
 634                 return -EOPNOTSUPP;
 635
 636         lock_sock(sk);
 637
 638         if (sk->sk_state == BT_CONNECTED)
 639                 err = sco_send_frame(sk, msg, len);
 640         else
 641                 err = -ENOTCONN;
 642
 643         release_sock(sk);
 644         return err;
 645 }
 646
 647 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 648 {
 649         struct sock *sk = sock->sk;
 650         int err = 0;
 651
 652         BT_DBG("sk %p", sk);
 653
 654         lock_sock(sk);
 655
 656         switch (optname) {
 657         default:
 658                 err = -ENOPROTOOPT;
 659                 break;
 660         }
 661
 662         release_sock(sk);
 663         return err;
 664 }
 665
 666 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 667 {
 668         struct sock *sk = sock->sk;
 669         struct sco_options opts;
 670         struct sco_conninfo cinfo;
 671         int len, err = 0;
 672
 673         BT_DBG("sk %p", sk);
 674
 675         if (get_user(len, optlen))
 676                 return -EFAULT;
 677
 678         lock_sock(sk);
 679
 680         switch (optname) {
 681         case SCO_OPTIONS:
 682                 if (sk->sk_state != BT_CONNECTED) {
 683                         err = -ENOTCONN;
 684                         break;
 685                 }
 686
 687                 opts.mtu = sco_pi(sk)->conn->mtu;
 688
 689                 BT_DBG("mtu %d", opts.mtu);
 690
 691                 len = min_t(unsigned int, len, sizeof(opts));
 692                 if (copy_to_user(optval, (char *)&opts, len))
 693                         err = -EFAULT;
 694
 695                 break;
 696
 697         case SCO_CONNINFO:
 698                 if (sk->sk_state != BT_CONNECTED) {
 699                         err = -ENOTCONN;
 700                         break;
 701                 }
 702
 703                 memset(&cinfo, 0, sizeof(cinfo));
 704                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 705                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 706
 707                 len = min_t(unsigned int, len, sizeof(cinfo));
 708                 if (copy_to_user(optval, (char *)&cinfo, len))
 709                         err = -EFAULT;
 710
 711                 break;
 712
 713         default:
 714                 err = -ENOPROTOOPT;
 715                 break;
 716         }
 717
 718         release_sock(sk);
 719         return err;
 720 }
 721
 722 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 723 {
 724         struct sock *sk = sock->sk;
 725         int len, err = 0;
 726
 727         BT_DBG("sk %p", sk);
 728
 729         if (level == SOL_SCO)
 730                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 731
 732         if (get_user(len, optlen))
 733                 return -EFAULT;
 734
 735         lock_sock(sk);
 736
 737         switch (optname) {
 738         default:
 739                 err = -ENOPROTOOPT;
 740                 break;
 741         }
 742
 743         release_sock(sk);
 744         return err;
 745 }
 746
 747 static int sco_sock_shutdown(struct socket *sock, int how)
 748 {
 749         struct sock *sk = sock->sk;
 750         int err = 0;
 751
 752         BT_DBG("sock %p, sk %p", sock, sk);
 753
 754         if (!sk)
 755                 return 0;
 756
 757         lock_sock(sk);
 758         if (!sk->sk_shutdown) {
 759                 sk->sk_shutdown = SHUTDOWN_MASK;
 760                 sco_sock_clear_timer(sk);
 761                 __sco_sock_close(sk);
 762
 763                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 764                         err = bt_sock_wait_state(sk, BT_CLOSED,
 765                                                         sk->sk_lingertime);
 766         }
 767         release_sock(sk);
 768         return err;
 769 }
 770
 771 static int sco_sock_release(struct socket *sock)
 772 {
 773         struct sock *sk = sock->sk;
 774         int err = 0;
 775
 776         BT_DBG("sock %p, sk %p", sock, sk);
 777
 778         if (!sk)
 779                 return 0;
 780
 781         sco_sock_close(sk);
 782
 783         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 784                 lock_sock(sk);
 785                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 786                 release_sock(sk);
 787         }
 788
 789         sock_orphan(sk);
 790         sco_sock_kill(sk);
 791         return err;
 792 }
 793
 794 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 795 {
 796         BT_DBG("conn %p", conn);
 797
 798         sco_pi(sk)->conn = conn;
 799         conn->sk = sk;
 800
 801         if (parent)
 802                 bt_accept_enqueue(parent, sk);
 803 }
 804
 805 /* Delete channel.
 806  * Must be called on the locked socket. */
 807 static void sco_chan_del(struct sock *sk, int err)
 808 {
 809         struct sco_conn *conn;
 810
 811         conn = sco_pi(sk)->conn;
 812
 813         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 814
 815         if (conn) {
 816                 sco_conn_lock(conn);
 817                 conn->sk = NULL;
 818                 sco_pi(sk)->conn = NULL;
 819                 sco_conn_unlock(conn);
 820                 hci_conn_put(conn->hcon);
 821         }
 822
 823         sk->sk_state = BT_CLOSED;
 824         sk->sk_err   = err;
 825         sk->sk_state_change(sk);
 826
 827         sock_set_flag(sk, SOCK_ZAPPED);
 828 }
 829
 830 static void sco_conn_ready(struct sco_conn *conn)
 831 {
 832         struct sock *parent, *sk;
 833
 834         BT_DBG("conn %p", conn);
 835
 836         sco_conn_lock(conn);
 837
 838         if ((sk = conn->sk)) {
 839                 sco_sock_clear_timer(sk);
 840                 bh_lock_sock(sk);
 841                 sk->sk_state = BT_CONNECTED;
 842                 sk->sk_state_change(sk);
 843                 bh_unlock_sock(sk);
 844         } else {
 845                 parent = sco_get_sock_listen(conn->src);
 846                 if (!parent)
 847                         goto done;
 848
 849                 bh_lock_sock(parent);
 850
 851                 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
 852                 if (!sk) {
 853                         bh_unlock_sock(parent);
 854                         goto done;
 855                 }
 856
 857                 sco_sock_init(sk, parent);
 858
 859                 bacpy(&bt_sk(sk)->src, conn->src);
 860                 bacpy(&bt_sk(sk)->dst, conn->dst);
 861
 862                 hci_conn_hold(conn->hcon);
 863                 __sco_chan_add(conn, sk, parent);
 864
 865                 sk->sk_state = BT_CONNECTED;
 866
 867                 /* Wake up parent */
 868                 parent->sk_data_ready(parent, 1);
 869
 870                 bh_unlock_sock(parent);
 871         }
 872
 873 done:
 874         sco_conn_unlock(conn);
 875 }
 876
 877 /* ----- SCO interface with lower layer (HCI) ----- */
 878 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 879 {
 880         register struct sock *sk;
 881         struct hlist_node *node;
 882         int lm = 0;
 883
 884         if (type != SCO_LINK && type != ESCO_LINK)
 885                 return 0;
 886
 887         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 888
 889         /* Find listening sockets */
 890         read_lock(&sco_sk_list.lock);
 891         sk_for_each(sk, node, &sco_sk_list.head) {
 892                 if (sk->sk_state != BT_LISTEN)
 893                         continue;
 894
 895                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 896                                 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 897                         lm |= HCI_LM_ACCEPT;
 898                         break;
 899                 }
 900         }
 901         read_unlock(&sco_sk_list.lock);
 902
 903         return lm;
 904 }
 905
 906 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 907 {
 908         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 909
 910         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 911                 return 0;
 912
 913         if (!status) {
 914                 struct sco_conn *conn;
 915
 916                 conn = sco_conn_add(hcon, status);
 917                 if (conn)
 918                         sco_conn_ready(conn);
 919         } else
 920                 sco_conn_del(hcon, bt_err(status));
 921
 922         return 0;
 923 }
 924
 925 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 926 {
 927         BT_DBG("hcon %p reason %d", hcon, reason);
 928
 929         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 930                 return 0;
 931
 932         sco_conn_del(hcon, bt_err(reason));
 933
 934         return 0;
 935 }
 936
 937 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 938 {
 939         struct sco_conn *conn = hcon->sco_data;
 940
 941         if (!conn)
 942                 goto drop;
 943
 944         BT_DBG("conn %p len %d", conn, skb->len);
 945
 946         if (skb->len) {
 947                 sco_recv_frame(conn, skb);
 948                 return 0;
 949         }
 950
 951 drop:
 952         kfree_skb(skb);
 953         return 0;
 954 }
 955
 956 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
 957 {
 958         struct sock *sk;
 959         struct hlist_node *node;
 960         char *str = buf;
 961         int size = PAGE_SIZE;
 962
 963         read_lock_bh(&sco_sk_list.lock);
 964
 965         sk_for_each(sk, node, &sco_sk_list.head) {
 966                 int len;
 967
 968                 len = snprintf(str, size, "%s %s %d\n",
 969                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 970                                 sk->sk_state);
 971
 972                 size -= len;
 973                 if (size <= 0)
 974                         break;
 975
 976                 str += len;
 977         }
 978
 979         read_unlock_bh(&sco_sk_list.lock);
 980
 981         return (str - buf);
 982 }
 983
 984 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
 985
 986 static 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
1006 static struct net_proto_family sco_sock_family_ops = {
1007         .family = PF_BLUETOOTH,
1008         .owner  = THIS_MODULE,
1009         .create = sco_sock_create,
1010 };
1011
1012 static struct hci_proto sco_hci_proto = {
1013         .name           = "SCO",
1014         .id             = HCI_PROTO_SCO,
1015         .connect_ind    = sco_connect_ind,
1016         .connect_cfm    = sco_connect_cfm,
1017         .disconn_cfm    = sco_disconn_cfm,
1018         .recv_scodata   = sco_recv_scodata
1019 };
1020
1021 static int __init sco_init(void)
1022 {
1023         int err;
1024
1025         err = proto_register(&sco_proto, 0);
1026         if (err < 0)
1027                 return err;
1028
1029         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1030         if (err < 0) {
1031                 BT_ERR("SCO socket registration failed");
1032                 goto error;
1033         }
1034
1035         err = hci_register_proto(&sco_hci_proto);
1036         if (err < 0) {
1037                 BT_ERR("SCO protocol registration failed");
1038                 bt_sock_unregister(BTPROTO_SCO);
1039                 goto error;
1040         }
1041
1042         if (class_create_file(bt_class, &class_attr_sco) < 0)
1043                 BT_ERR("Failed to create SCO info file");
1044
1045         BT_INFO("SCO (Voice Link) ver %s", VERSION);
1046         BT_INFO("SCO socket layer initialized");
1047
1048         return 0;
1049
1050 error:
1051         proto_unregister(&sco_proto);
1052         return err;
1053 }
1054
1055 static void __exit sco_exit(void)
1056 {
1057         class_remove_file(bt_class, &class_attr_sco);
1058
1059         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1060                 BT_ERR("SCO socket unregistration failed");
1061
1062         if (hci_unregister_proto(&sco_hci_proto) < 0)
1063                 BT_ERR("SCO protocol unregistration failed");
1064
1065         proto_unregister(&sco_proto);
1066 }
1067
1068 module_init(sco_init);
1069 module_exit(sco_exit);
1070
1071 module_param(disable_esco, bool, 0644);
1072 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1073
1074 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1075 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1076 MODULE_VERSION(VERSION);
1077 MODULE_LICENSE("GPL");
1078 MODULE_ALIAS("bt-proto-2");