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 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32))
 434 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 435                            int kern)
 436 #else
 437 static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
 438 #endif
 439 {
 440         struct sock *sk;
 441
 442         BT_DBG("sock %p", sock);
 443
 444         sock->state = SS_UNCONNECTED;
 445
 446         if (sock->type != SOCK_SEQPACKET)
 447                 return -ESOCKTNOSUPPORT;
 448
 449         sock->ops = &sco_sock_ops;
 450
 451         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 452         if (!sk)
 453                 return -ENOMEM;
 454
 455         sco_sock_init(sk, NULL);
 456         return 0;
 457 }
 458
 459 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 460 {
 461         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 462         struct sock *sk = sock->sk;
 463         bdaddr_t *src = &sa->sco_bdaddr;
 464         int err = 0;
 465
 466         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 467
 468         if (!addr || addr->sa_family != AF_BLUETOOTH)
 469                 return -EINVAL;
 470
 471         lock_sock(sk);
 472
 473         if (sk->sk_state != BT_OPEN) {
 474                 err = -EBADFD;
 475                 goto done;
 476         }
 477
 478         write_lock_bh(&sco_sk_list.lock);
 479
 480         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 481                 err = -EADDRINUSE;
 482         } else {
 483                 /* Save source address */
 484                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 485                 sk->sk_state = BT_BOUND;
 486         }
 487
 488         write_unlock_bh(&sco_sk_list.lock);
 489
 490 done:
 491         release_sock(sk);
 492         return err;
 493 }
 494
 495 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 496 {
 497         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 498         struct sock *sk = sock->sk;
 499         int err = 0;
 500
 501
 502         BT_DBG("sk %p", sk);
 503
 504         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 505                 return -EINVAL;
 506
 507         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 508                 return -EBADFD;
 509
 510         if (sk->sk_type != SOCK_SEQPACKET)
 511                 return -EINVAL;
 512
 513         lock_sock(sk);
 514
 515         /* Set destination address and psm */
 516         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 517
 518         if ((err = sco_connect(sk)))
 519                 goto done;
 520
 521         err = bt_sock_wait_state(sk, BT_CONNECTED,
 522                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 523
 524 done:
 525         release_sock(sk);
 526         return err;
 527 }
 528
 529 static int sco_sock_listen(struct socket *sock, int backlog)
 530 {
 531         struct sock *sk = sock->sk;
 532         int err = 0;
 533
 534         BT_DBG("sk %p backlog %d", sk, backlog);
 535
 536         lock_sock(sk);
 537
 538         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 539                 err = -EBADFD;
 540                 goto done;
 541         }
 542
 543         sk->sk_max_ack_backlog = backlog;
 544         sk->sk_ack_backlog = 0;
 545         sk->sk_state = BT_LISTEN;
 546
 547 done:
 548         release_sock(sk);
 549         return err;
 550 }
 551
 552 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 553 {
 554         DECLARE_WAITQUEUE(wait, current);
 555         struct sock *sk = sock->sk, *ch;
 556         long timeo;
 557         int err = 0;
 558
 559         lock_sock(sk);
 560
 561         if (sk->sk_state != BT_LISTEN) {
 562                 err = -EBADFD;
 563                 goto done;
 564         }
 565
 566         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 567
 568         BT_DBG("sk %p timeo %ld", sk, timeo);
 569
 570         /* Wait for an incoming connection. (wake-one). */
 571         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 572         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 573                 set_current_state(TASK_INTERRUPTIBLE);
 574                 if (!timeo) {
 575                         err = -EAGAIN;
 576                         break;
 577                 }
 578
 579                 release_sock(sk);
 580                 timeo = schedule_timeout(timeo);
 581                 lock_sock(sk);
 582
 583                 if (sk->sk_state != BT_LISTEN) {
 584                         err = -EBADFD;
 585                         break;
 586                 }
 587
 588                 if (signal_pending(current)) {
 589                         err = sock_intr_errno(timeo);
 590                         break;
 591                 }
 592         }
 593         set_current_state(TASK_RUNNING);
 594         remove_wait_queue(sk->sk_sleep, &wait);
 595
 596         if (err)
 597                 goto done;
 598
 599         newsock->state = SS_CONNECTED;
 600
 601         BT_DBG("new socket %p", ch);
 602
 603 done:
 604         release_sock(sk);
 605         return err;
 606 }
 607
 608 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 609 {
 610         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 611         struct sock *sk = sock->sk;
 612
 613         BT_DBG("sock %p, sk %p", sock, sk);
 614
 615         addr->sa_family = AF_BLUETOOTH;
 616         *len = sizeof(struct sockaddr_sco);
 617
 618         if (peer)
 619                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 620         else
 621                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 622
 623         return 0;
 624 }
 625
 626 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 627                             struct msghdr *msg, size_t len)
 628 {
 629         struct sock *sk = sock->sk;
 630         int err = 0;
 631
 632         BT_DBG("sock %p, sk %p", sock, sk);
 633
 634         err = sock_error(sk);
 635         if (err)
 636                 return err;
 637
 638         if (msg->msg_flags & MSG_OOB)
 639                 return -EOPNOTSUPP;
 640
 641         lock_sock(sk);
 642
 643         if (sk->sk_state == BT_CONNECTED)
 644                 err = sco_send_frame(sk, msg, len);
 645         else
 646                 err = -ENOTCONN;
 647
 648         release_sock(sk);
 649         return err;
 650 }
 651
 652 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 653 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 654 #else
 655 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 656 #endif
 657 {
 658         struct sock *sk = sock->sk;
 659         int err = 0;
 660
 661         BT_DBG("sk %p", sk);
 662
 663         lock_sock(sk);
 664
 665         switch (optname) {
 666         default:
 667                 err = -ENOPROTOOPT;
 668                 break;
 669         }
 670
 671         release_sock(sk);
 672         return err;
 673 }
 674
 675 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 676 {
 677         struct sock *sk = sock->sk;
 678         struct sco_options opts;
 679         struct sco_conninfo cinfo;
 680         int len, err = 0;
 681
 682         BT_DBG("sk %p", sk);
 683
 684         if (get_user(len, optlen))
 685                 return -EFAULT;
 686
 687         lock_sock(sk);
 688
 689         switch (optname) {
 690         case SCO_OPTIONS:
 691                 if (sk->sk_state != BT_CONNECTED) {
 692                         err = -ENOTCONN;
 693                         break;
 694                 }
 695
 696                 opts.mtu = sco_pi(sk)->conn->mtu;
 697
 698                 BT_DBG("mtu %d", opts.mtu);
 699
 700                 len = min_t(unsigned int, len, sizeof(opts));
 701                 if (copy_to_user(optval, (char *)&opts, len))
 702                         err = -EFAULT;
 703
 704                 break;
 705
 706         case SCO_CONNINFO:
 707                 if (sk->sk_state != BT_CONNECTED) {
 708                         err = -ENOTCONN;
 709                         break;
 710                 }
 711
 712                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 713                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 714
 715                 len = min_t(unsigned int, len, sizeof(cinfo));
 716                 if (copy_to_user(optval, (char *)&cinfo, len))
 717                         err = -EFAULT;
 718
 719                 break;
 720
 721         default:
 722                 err = -ENOPROTOOPT;
 723                 break;
 724         }
 725
 726         release_sock(sk);
 727         return err;
 728 }
 729
 730 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 731 {
 732         struct sock *sk = sock->sk;
 733         int len, err = 0;
 734
 735         BT_DBG("sk %p", sk);
 736
 737         if (level == SOL_SCO)
 738                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 739
 740         if (get_user(len, optlen))
 741                 return -EFAULT;
 742
 743         lock_sock(sk);
 744
 745         switch (optname) {
 746         default:
 747                 err = -ENOPROTOOPT;
 748                 break;
 749         }
 750
 751         release_sock(sk);
 752         return err;
 753 }
 754
 755 static int sco_sock_shutdown(struct socket *sock, int how)
 756 {
 757         struct sock *sk = sock->sk;
 758         int err = 0;
 759
 760         BT_DBG("sock %p, sk %p", sock, sk);
 761
 762         if (!sk)
 763                 return 0;
 764
 765         lock_sock(sk);
 766         if (!sk->sk_shutdown) {
 767                 sk->sk_shutdown = SHUTDOWN_MASK;
 768                 sco_sock_clear_timer(sk);
 769                 __sco_sock_close(sk);
 770
 771                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 772                         err = bt_sock_wait_state(sk, BT_CLOSED,
 773                                                         sk->sk_lingertime);
 774         }
 775         release_sock(sk);
 776         return err;
 777 }
 778
 779 static int sco_sock_release(struct socket *sock)
 780 {
 781         struct sock *sk = sock->sk;
 782         int err = 0;
 783
 784         BT_DBG("sock %p, sk %p", sock, sk);
 785
 786         if (!sk)
 787                 return 0;
 788
 789         sco_sock_close(sk);
 790
 791         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 792                 lock_sock(sk);
 793                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 794                 release_sock(sk);
 795         }
 796
 797         sock_orphan(sk);
 798         sco_sock_kill(sk);
 799         return err;
 800 }
 801
 802 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 803 {
 804         BT_DBG("conn %p", conn);
 805
 806         sco_pi(sk)->conn = conn;
 807         conn->sk = sk;
 808
 809         if (parent)
 810                 bt_accept_enqueue(parent, sk);
 811 }
 812
 813 /* Delete channel.
 814  * Must be called on the locked socket. */
 815 static void sco_chan_del(struct sock *sk, int err)
 816 {
 817         struct sco_conn *conn;
 818
 819         conn = sco_pi(sk)->conn;
 820
 821         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 822
 823         if (conn) {
 824                 sco_conn_lock(conn);
 825                 conn->sk = NULL;
 826                 sco_pi(sk)->conn = NULL;
 827                 sco_conn_unlock(conn);
 828                 hci_conn_put(conn->hcon);
 829         }
 830
 831         sk->sk_state = BT_CLOSED;
 832         sk->sk_err   = err;
 833         sk->sk_state_change(sk);
 834
 835         sock_set_flag(sk, SOCK_ZAPPED);
 836 }
 837
 838 static void sco_conn_ready(struct sco_conn *conn)
 839 {
 840         struct sock *parent, *sk;
 841
 842         BT_DBG("conn %p", conn);
 843
 844         sco_conn_lock(conn);
 845
 846         if ((sk = conn->sk)) {
 847                 sco_sock_clear_timer(sk);
 848                 bh_lock_sock(sk);
 849                 sk->sk_state = BT_CONNECTED;
 850                 sk->sk_state_change(sk);
 851                 bh_unlock_sock(sk);
 852         } else {
 853                 parent = sco_get_sock_listen(conn->src);
 854                 if (!parent)
 855                         goto done;
 856
 857                 bh_lock_sock(parent);
 858
 859                 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
 860                 if (!sk) {
 861                         bh_unlock_sock(parent);
 862                         goto done;
 863                 }
 864
 865                 sco_sock_init(sk, parent);
 866
 867                 bacpy(&bt_sk(sk)->src, conn->src);
 868                 bacpy(&bt_sk(sk)->dst, conn->dst);
 869
 870                 hci_conn_hold(conn->hcon);
 871                 __sco_chan_add(conn, sk, parent);
 872
 873                 sk->sk_state = BT_CONNECTED;
 874
 875                 /* Wake up parent */
 876                 parent->sk_data_ready(parent, 1);
 877
 878                 bh_unlock_sock(parent);
 879         }
 880
 881 done:
 882         sco_conn_unlock(conn);
 883 }
 884
 885 /* ----- SCO interface with lower layer (HCI) ----- */
 886 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 887 {
 888         register struct sock *sk;
 889         struct hlist_node *node;
 890         int lm = 0;
 891
 892         if (type != SCO_LINK && type != ESCO_LINK)
 893                 return 0;
 894
 895         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 896
 897         /* Find listening sockets */
 898         read_lock(&sco_sk_list.lock);
 899         sk_for_each(sk, node, &sco_sk_list.head) {
 900                 if (sk->sk_state != BT_LISTEN)
 901                         continue;
 902
 903                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 904                                 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 905                         lm |= HCI_LM_ACCEPT;
 906                         break;
 907                 }
 908         }
 909         read_unlock(&sco_sk_list.lock);
 910
 911         return lm;
 912 }
 913
 914 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 915 {
 916         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 917
 918         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 919                 return 0;
 920
 921         if (!status) {
 922                 struct sco_conn *conn;
 923
 924                 conn = sco_conn_add(hcon, status);
 925                 if (conn)
 926                         sco_conn_ready(conn);
 927         } else
 928                 sco_conn_del(hcon, bt_err(status));
 929
 930         return 0;
 931 }
 932
 933 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 934 {
 935         BT_DBG("hcon %p reason %d", hcon, reason);
 936
 937         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 938                 return 0;
 939
 940         sco_conn_del(hcon, bt_err(reason));
 941
 942         return 0;
 943 }
 944
 945 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 946 {
 947         struct sco_conn *conn = hcon->sco_data;
 948
 949         if (!conn)
 950                 goto drop;
 951
 952         BT_DBG("conn %p len %d", conn, skb->len);
 953
 954         if (skb->len) {
 955                 sco_recv_frame(conn, skb);
 956                 return 0;
 957         }
 958
 959 drop:
 960         kfree_skb(skb);
 961         return 0;
 962 }
 963
 964 static ssize_t sco_sysfs_show(struct class *dev,
 965                                 struct class_attribute *attr,
 966                                 char *buf)
 967 {
 968         struct sock *sk;
 969         struct hlist_node *node;
 970         char *str = buf;
 971
 972         read_lock_bh(&sco_sk_list.lock);
 973
 974         sk_for_each(sk, node, &sco_sk_list.head) {
 975                 str += sprintf(str, "%s %s %d\n",
 976                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 977                                 sk->sk_state);
 978         }
 979
 980         read_unlock_bh(&sco_sk_list.lock);
 981
 982         return (str - buf);
 983 }
 984
 985 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
 986
 987 static const struct proto_ops sco_sock_ops = {
 988         .family         = PF_BLUETOOTH,
 989         .owner          = THIS_MODULE,
 990         .release        = sco_sock_release,
 991         .bind           = sco_sock_bind,
 992         .connect        = sco_sock_connect,
 993         .listen         = sco_sock_listen,
 994         .accept         = sco_sock_accept,
 995         .getname        = sco_sock_getname,
 996         .sendmsg        = sco_sock_sendmsg,
 997         .recvmsg        = bt_sock_recvmsg,
 998         .poll           = bt_sock_poll,
 999         .ioctl          = bt_sock_ioctl,
1000         .mmap           = sock_no_mmap,
1001         .socketpair     = sock_no_socketpair,
1002         .shutdown       = sco_sock_shutdown,
1003         .setsockopt     = sco_sock_setsockopt,
1004         .getsockopt     = sco_sock_getsockopt
1005 };
1006
1007 static const struct net_proto_family sco_sock_family_ops = {
1008         .family = PF_BLUETOOTH,
1009         .owner  = THIS_MODULE,
1010         .create = sco_sock_create,
1011 };
1012
1013 static struct hci_proto sco_hci_proto = {
1014         .name           = "SCO",
1015         .id             = HCI_PROTO_SCO,
1016         .connect_ind    = sco_connect_ind,
1017         .connect_cfm    = sco_connect_cfm,
1018         .disconn_cfm    = sco_disconn_cfm,
1019         .recv_scodata   = sco_recv_scodata
1020 };
1021
1022 static int __init sco_init(void)
1023 {
1024         int err;
1025
1026         err = proto_register(&sco_proto, 0);
1027         if (err < 0)
1028                 return err;
1029
1030         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1031         if (err < 0) {
1032                 BT_ERR("SCO socket registration failed");
1033                 goto error;
1034         }
1035
1036         err = hci_register_proto(&sco_hci_proto);
1037         if (err < 0) {
1038                 BT_ERR("SCO protocol registration failed");
1039                 bt_sock_unregister(BTPROTO_SCO);
1040                 goto error;
1041         }
1042
1043         if (class_create_file(bt_class, &class_attr_sco) < 0)
1044                 BT_ERR("Failed to create SCO info file");
1045
1046         BT_INFO("SCO (Voice Link) ver %s", VERSION);
1047         BT_INFO("SCO socket layer initialized");
1048
1049         return 0;
1050
1051 error:
1052         proto_unregister(&sco_proto);
1053         return err;
1054 }
1055
1056 static void __exit sco_exit(void)
1057 {
1058         class_remove_file(bt_class, &class_attr_sco);
1059
1060         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1061                 BT_ERR("SCO socket unregistration failed");
1062
1063         if (hci_unregister_proto(&sco_hci_proto) < 0)
1064                 BT_ERR("SCO protocol unregistration failed");
1065
1066         proto_unregister(&sco_proto);
1067 }
1068
1069 module_init(sco_init);
1070 module_exit(sco_exit);
1071
1072 module_param(disable_esco, bool, 0644);
1073 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1074
1075 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1076 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1077 MODULE_VERSION(VERSION);
1078 MODULE_LICENSE("GPL");
1079 MODULE_ALIAS("bt-proto-2");