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                 memset(&cinfo, 0, sizeof(cinfo));
 722                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 723                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 724
 725                 len = min_t(unsigned int, len, sizeof(cinfo));
 726                 if (copy_to_user(optval, (char *)&cinfo, len))
 727                         err = -EFAULT;
 728
 729                 break;
 730
 731         default:
 732                 err = -ENOPROTOOPT;
 733                 break;
 734         }
 735
 736         release_sock(sk);
 737         return err;
 738 }
 739
 740 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 741 {
 742         struct sock *sk = sock->sk;
 743         int len, err = 0;
 744
 745         BT_DBG("sk %p", sk);
 746
 747         if (level == SOL_SCO)
 748                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 749
 750         if (get_user(len, optlen))
 751                 return -EFAULT;
 752
 753         lock_sock(sk);
 754
 755         switch (optname) {
 756         default:
 757                 err = -ENOPROTOOPT;
 758                 break;
 759         }
 760
 761         release_sock(sk);
 762         return err;
 763 }
 764
 765 static int sco_sock_shutdown(struct socket *sock, int how)
 766 {
 767         struct sock *sk = sock->sk;
 768         int err = 0;
 769
 770         BT_DBG("sock %p, sk %p", sock, sk);
 771
 772         if (!sk)
 773                 return 0;
 774
 775         lock_sock(sk);
 776         if (!sk->sk_shutdown) {
 777                 sk->sk_shutdown = SHUTDOWN_MASK;
 778                 sco_sock_clear_timer(sk);
 779                 __sco_sock_close(sk);
 780
 781                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 782                         err = bt_sock_wait_state(sk, BT_CLOSED,
 783                                                         sk->sk_lingertime);
 784         }
 785         release_sock(sk);
 786         return err;
 787 }
 788
 789 static int sco_sock_release(struct socket *sock)
 790 {
 791         struct sock *sk = sock->sk;
 792         int err = 0;
 793
 794         BT_DBG("sock %p, sk %p", sock, sk);
 795
 796         if (!sk)
 797                 return 0;
 798
 799         sco_sock_close(sk);
 800
 801         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 802                 lock_sock(sk);
 803                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 804                 release_sock(sk);
 805         }
 806
 807         sock_orphan(sk);
 808         sco_sock_kill(sk);
 809         return err;
 810 }
 811
 812 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 813 {
 814         BT_DBG("conn %p", conn);
 815
 816         sco_pi(sk)->conn = conn;
 817         conn->sk = sk;
 818
 819         if (parent)
 820                 bt_accept_enqueue(parent, sk);
 821 }
 822
 823 /* Delete channel.
 824  * Must be called on the locked socket. */
 825 static void sco_chan_del(struct sock *sk, int err)
 826 {
 827         struct sco_conn *conn;
 828
 829         conn = sco_pi(sk)->conn;
 830
 831         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 832
 833         if (conn) {
 834                 sco_conn_lock(conn);
 835                 conn->sk = NULL;
 836                 sco_pi(sk)->conn = NULL;
 837                 sco_conn_unlock(conn);
 838                 hci_conn_put(conn->hcon);
 839         }
 840
 841         sk->sk_state = BT_CLOSED;
 842         sk->sk_err   = err;
 843         sk->sk_state_change(sk);
 844
 845         sock_set_flag(sk, SOCK_ZAPPED);
 846 }
 847
 848 static void sco_conn_ready(struct sco_conn *conn)
 849 {
 850         struct sock *parent, *sk;
 851
 852         BT_DBG("conn %p", conn);
 853
 854         sco_conn_lock(conn);
 855
 856         if ((sk = conn->sk)) {
 857                 sco_sock_clear_timer(sk);
 858                 bh_lock_sock(sk);
 859                 sk->sk_state = BT_CONNECTED;
 860                 sk->sk_state_change(sk);
 861                 bh_unlock_sock(sk);
 862         } else {
 863                 parent = sco_get_sock_listen(conn->src);
 864                 if (!parent)
 865                         goto done;
 866
 867                 bh_lock_sock(parent);
 868
 869                 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
 870                 if (!sk) {
 871                         bh_unlock_sock(parent);
 872                         goto done;
 873                 }
 874
 875                 sco_sock_init(sk, parent);
 876
 877                 bacpy(&bt_sk(sk)->src, conn->src);
 878                 bacpy(&bt_sk(sk)->dst, conn->dst);
 879
 880                 hci_conn_hold(conn->hcon);
 881                 __sco_chan_add(conn, sk, parent);
 882
 883                 sk->sk_state = BT_CONNECTED;
 884
 885                 /* Wake up parent */
 886                 parent->sk_data_ready(parent, 1);
 887
 888                 bh_unlock_sock(parent);
 889         }
 890
 891 done:
 892         sco_conn_unlock(conn);
 893 }
 894
 895 /* ----- SCO interface with lower layer (HCI) ----- */
 896 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 897 {
 898         register struct sock *sk;
 899         struct hlist_node *node;
 900         int lm = 0;
 901
 902         if (type != SCO_LINK && type != ESCO_LINK)
 903                 return 0;
 904
 905         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 906
 907         /* Find listening sockets */
 908         read_lock(&sco_sk_list.lock);
 909         sk_for_each(sk, node, &sco_sk_list.head) {
 910                 if (sk->sk_state != BT_LISTEN)
 911                         continue;
 912
 913                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 914                                 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 915                         lm |= HCI_LM_ACCEPT;
 916                         break;
 917                 }
 918         }
 919         read_unlock(&sco_sk_list.lock);
 920
 921         return lm;
 922 }
 923
 924 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 925 {
 926         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 927
 928         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 929                 return 0;
 930
 931         if (!status) {
 932                 struct sco_conn *conn;
 933
 934                 conn = sco_conn_add(hcon, status);
 935                 if (conn)
 936                         sco_conn_ready(conn);
 937         } else
 938                 sco_conn_del(hcon, bt_err(status));
 939
 940         return 0;
 941 }
 942
 943 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 944 {
 945         BT_DBG("hcon %p reason %d", hcon, reason);
 946
 947         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 948                 return 0;
 949
 950         sco_conn_del(hcon, bt_err(reason));
 951
 952         return 0;
 953 }
 954
 955 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 956 {
 957         struct sco_conn *conn = hcon->sco_data;
 958
 959         if (!conn)
 960                 goto drop;
 961
 962         BT_DBG("conn %p len %d", conn, skb->len);
 963
 964         if (skb->len) {
 965                 sco_recv_frame(conn, skb);
 966                 return 0;
 967         }
 968
 969 drop:
 970         kfree_skb(skb);
 971         return 0;
 972 }
 973
 974 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
 975 {
 976         struct sock *sk;
 977         struct hlist_node *node;
 978         char *str = buf;
 979         int size = PAGE_SIZE;
 980
 981         read_lock_bh(&sco_sk_list.lock);
 982
 983         sk_for_each(sk, node, &sco_sk_list.head) {
 984                 int len;
 985
 986                 len = snprintf(str, size, "%s %s %d\n",
 987                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 988                                 sk->sk_state);
 989
 990                 size -= len;
 991                 if (size <= 0)
 992                         break;
 993
 994                 str += len;
 995         }
 996
 997         read_unlock_bh(&sco_sk_list.lock);
 998
 999         return (str - buf);
1000 }
1001
1002 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
1003
1004 static const struct proto_ops sco_sock_ops = {
1005         .family         = PF_BLUETOOTH,
1006         .owner          = THIS_MODULE,
1007         .release        = sco_sock_release,
1008         .bind           = sco_sock_bind,
1009         .connect        = sco_sock_connect,
1010         .listen         = sco_sock_listen,
1011         .accept         = sco_sock_accept,
1012         .getname        = sco_sock_getname,
1013         .sendmsg        = sco_sock_sendmsg,
1014         .recvmsg        = bt_sock_recvmsg,
1015         .poll           = bt_sock_poll,
1016         .ioctl          = bt_sock_ioctl,
1017         .mmap           = sock_no_mmap,
1018         .socketpair     = sock_no_socketpair,
1019         .shutdown       = sco_sock_shutdown,
1020         .setsockopt     = sco_sock_setsockopt,
1021         .getsockopt     = sco_sock_getsockopt
1022 };
1023
1024 static struct net_proto_family sco_sock_family_ops = {
1025         .family = PF_BLUETOOTH,
1026         .owner  = THIS_MODULE,
1027         .create = sco_sock_create,
1028 };
1029
1030 static struct hci_proto sco_hci_proto = {
1031         .name           = "SCO",
1032         .id             = HCI_PROTO_SCO,
1033         .connect_ind    = sco_connect_ind,
1034         .connect_cfm    = sco_connect_cfm,
1035         .disconn_cfm    = sco_disconn_cfm,
1036         .recv_scodata   = sco_recv_scodata
1037 };
1038
1039 static int __init sco_init(void)
1040 {
1041         int err;
1042
1043         err = proto_register(&sco_proto, 0);
1044         if (err < 0)
1045                 return err;
1046
1047         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1048         if (err < 0) {
1049                 BT_ERR("SCO socket registration failed");
1050                 goto error;
1051         }
1052
1053         err = hci_register_proto(&sco_hci_proto);
1054         if (err < 0) {
1055                 BT_ERR("SCO protocol registration failed");
1056                 bt_sock_unregister(BTPROTO_SCO);
1057                 goto error;
1058         }
1059
1060         if (class_create_file(bt_class, &class_attr_sco) < 0)
1061                 BT_ERR("Failed to create SCO info file");
1062
1063         BT_INFO("SCO (Voice Link) ver %s", VERSION);
1064         BT_INFO("SCO socket layer initialized");
1065
1066         return 0;
1067
1068 error:
1069         proto_unregister(&sco_proto);
1070         return err;
1071 }
1072
1073 static void __exit sco_exit(void)
1074 {
1075         class_remove_file(bt_class, &class_attr_sco);
1076
1077         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1078                 BT_ERR("SCO socket unregistration failed");
1079
1080         if (hci_unregister_proto(&sco_hci_proto) < 0)
1081                 BT_ERR("SCO protocol unregistration failed");
1082
1083         proto_unregister(&sco_proto);
1084 }
1085
1086 module_init(sco_init);
1087 module_exit(sco_exit);
1088
1089 module_param(disable_esco, bool, 0644);
1090 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1091
1092 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1093 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1094 MODULE_VERSION(VERSION);
1095 MODULE_LICENSE("GPL");
1096 MODULE_ALIAS("bt-proto-2");