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