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/debugfs.h>
  42 #include <linux/seq_file.h>
  43 #include <linux/list.h>
  44 #include <linux/security.h>
  45 #include <net/sock.h>
  46
  47 #include <asm/system.h>
  48 #include <linux/uaccess.h>
  49
  50 #include <net/bluetooth/bluetooth.h>
  51 #include <net/bluetooth/hci_core.h>
  52 #include <net/bluetooth/sco.h>
  53
  54 static int disable_esco;
  55
  56 static const struct proto_ops sco_sock_ops;
  57
  58 static struct bt_sock_list sco_sk_list = {
  59         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  60 };
  61
  62 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  63 static void sco_chan_del(struct sock *sk, int err);
  64
  65 static int  sco_conn_del(struct hci_conn *conn, int err);
  66
  67 static void sco_sock_close(struct sock *sk);
  68 static void sco_sock_kill(struct sock *sk);
  69
  70 /* ---- SCO timers ---- */
  71 static void sco_sock_timeout(unsigned long arg)
  72 {
  73         struct sock *sk = (struct sock *) arg;
  74
  75         BT_DBG("sock %p state %d", sk, sk->sk_state);
  76
  77         bh_lock_sock(sk);
  78         sk->sk_err = ETIMEDOUT;
  79         sk->sk_state_change(sk);
  80         bh_unlock_sock(sk);
  81
  82         sco_sock_kill(sk);
  83         sock_put(sk);
  84 }
  85
  86 static void sco_sock_set_timer(struct sock *sk, long timeout)
  87 {
  88         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  89         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  90 }
  91
  92 static void sco_sock_clear_timer(struct sock *sk)
  93 {
  94         BT_DBG("sock %p state %d", sk, sk->sk_state);
  95         sk_stop_timer(sk, &sk->sk_timer);
  96 }
  97
  98 /* ---- SCO connections ---- */
  99 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
 100 {
 101         struct hci_dev *hdev = hcon->hdev;
 102         struct sco_conn *conn = hcon->sco_data;
 103
 104         if (conn || status)
 105                 return conn;
 106
 107         conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
 108         if (!conn)
 109                 return NULL;
 110
 111         spin_lock_init(&conn->lock);
 112
 113         hcon->sco_data = conn;
 114         conn->hcon = hcon;
 115
 116         conn->src = &hdev->bdaddr;
 117         conn->dst = &hcon->dst;
 118
 119         if (hdev->sco_mtu > 0)
 120                 conn->mtu = hdev->sco_mtu;
 121         else
 122                 conn->mtu = 60;
 123
 124         BT_DBG("hcon %p conn %p", hcon, conn);
 125
 126         return conn;
 127 }
 128
 129 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 130 {
 131         struct sock *sk = NULL;
 132         sco_conn_lock(conn);
 133         sk = conn->sk;
 134         sco_conn_unlock(conn);
 135         return sk;
 136 }
 137
 138 static int sco_conn_del(struct hci_conn *hcon, int err)
 139 {
 140         struct sco_conn *conn = hcon->sco_data;
 141         struct sock *sk;
 142
 143         if (!conn)
 144                 return 0;
 145
 146         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 147
 148         /* Kill socket */
 149         sk = sco_chan_get(conn);
 150         if (sk) {
 151                 bh_lock_sock(sk);
 152                 sco_sock_clear_timer(sk);
 153                 sco_chan_del(sk, err);
 154                 bh_unlock_sock(sk);
 155                 sco_sock_kill(sk);
 156         }
 157
 158         hcon->sco_data = NULL;
 159         kfree(conn);
 160         return 0;
 161 }
 162
 163 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 164 {
 165         int err = 0;
 166
 167         sco_conn_lock(conn);
 168         if (conn->sk)
 169                 err = -EBUSY;
 170         else
 171                 __sco_chan_add(conn, sk, parent);
 172
 173         sco_conn_unlock(conn);
 174         return err;
 175 }
 176
 177 static int sco_connect(struct sock *sk)
 178 {
 179         bdaddr_t *src = &bt_sk(sk)->src;
 180         bdaddr_t *dst = &bt_sk(sk)->dst;
 181         struct sco_conn *conn;
 182         struct hci_conn *hcon;
 183         struct hci_dev  *hdev;
 184         int err, type;
 185
 186         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 187
 188         hdev = hci_get_route(dst, src);
 189         if (!hdev)
 190                 return -EHOSTUNREACH;
 191
 192         hci_dev_lock_bh(hdev);
 193
 194         if (lmp_esco_capable(hdev) && !disable_esco)
 195                 type = ESCO_LINK;
 196         else
 197                 type = SCO_LINK;
 198
 199         hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
 200         if (IS_ERR(hcon)) {
 201                 err = PTR_ERR(hcon);
 202                 goto done;
 203         }
 204
 205         conn = sco_conn_add(hcon, 0);
 206         if (!conn) {
 207                 hci_conn_put(hcon);
 208                 err = -ENOMEM;
 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         skb = bt_skb_send_alloc(sk, count,
 247                         msg->msg_flags & MSG_DONTWAIT, &err);
 248         if (!skb)
 249                 return err;
 250
 251         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 252                 kfree_skb(skb);
 253                 return -EFAULT;
 254         }
 255
 256         hci_send_sco(conn->hcon, skb);
 257
 258         return count;
 259 }
 260
 261 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 262 {
 263         struct sock *sk = sco_chan_get(conn);
 264
 265         if (!sk)
 266                 goto drop;
 267
 268         BT_DBG("sk %p len %d", sk, skb->len);
 269
 270         if (sk->sk_state != BT_CONNECTED)
 271                 goto drop;
 272
 273         if (!sock_queue_rcv_skb(sk, skb))
 274                 return;
 275
 276 drop:
 277         kfree_skb(skb);
 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                 if (sco_pi(sk)->conn) {
 374                         sk->sk_state = BT_DISCONN;
 375                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 376                         hci_conn_put(sco_pi(sk)->conn->hcon);
 377                         sco_pi(sk)->conn->hcon = NULL;
 378                 } else
 379                         sco_chan_del(sk, ECONNRESET);
 380                 break;
 381
 382         case BT_CONNECT:
 383         case BT_DISCONN:
 384                 sco_chan_del(sk, ECONNRESET);
 385                 break;
 386
 387         default:
 388                 sock_set_flag(sk, SOCK_ZAPPED);
 389                 break;
 390         }
 391 }
 392
 393 /* Must be called on unlocked socket. */
 394 static void sco_sock_close(struct sock *sk)
 395 {
 396         sco_sock_clear_timer(sk);
 397         lock_sock(sk);
 398         __sco_sock_close(sk);
 399         release_sock(sk);
 400         sco_sock_kill(sk);
 401 }
 402
 403 static void sco_sock_init(struct sock *sk, struct sock *parent)
 404 {
 405         BT_DBG("sk %p", sk);
 406
 407         if (parent) {
 408                 sk->sk_type = parent->sk_type;
 409                 security_sk_clone(parent, sk);
 410         }
 411 }
 412
 413 static struct proto sco_proto = {
 414         .name           = "SCO",
 415         .owner          = THIS_MODULE,
 416         .obj_size       = sizeof(struct sco_pinfo)
 417 };
 418
 419 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 420 {
 421         struct sock *sk;
 422
 423         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
 424         if (!sk)
 425                 return NULL;
 426
 427         sock_init_data(sock, sk);
 428         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 429
 430         sk->sk_destruct = sco_sock_destruct;
 431         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 432
 433         sock_reset_flag(sk, SOCK_ZAPPED);
 434
 435         sk->sk_protocol = proto;
 436         sk->sk_state    = BT_OPEN;
 437
 438         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
 439
 440         bt_sock_link(&sco_sk_list, sk);
 441         return sk;
 442 }
 443
 444 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 445                            int kern)
 446 {
 447         struct sock *sk;
 448
 449         BT_DBG("sock %p", sock);
 450
 451         sock->state = SS_UNCONNECTED;
 452
 453         if (sock->type != SOCK_SEQPACKET)
 454                 return -ESOCKTNOSUPPORT;
 455
 456         sock->ops = &sco_sock_ops;
 457
 458         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 459         if (!sk)
 460                 return -ENOMEM;
 461
 462         sco_sock_init(sk, NULL);
 463         return 0;
 464 }
 465
 466 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 467 {
 468         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 469         struct sock *sk = sock->sk;
 470         bdaddr_t *src = &sa->sco_bdaddr;
 471         int err = 0;
 472
 473         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 474
 475         if (!addr || addr->sa_family != AF_BLUETOOTH)
 476                 return -EINVAL;
 477
 478         if (addr_len < sizeof(struct sockaddr_sco))
 479                 return -EINVAL;
 480
 481         lock_sock(sk);
 482
 483         if (sk->sk_state != BT_OPEN) {
 484                 err = -EBADFD;
 485                 goto done;
 486         }
 487
 488         write_lock_bh(&sco_sk_list.lock);
 489
 490         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 491                 err = -EADDRINUSE;
 492         } else {
 493                 /* Save source address */
 494                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 495                 sk->sk_state = BT_BOUND;
 496         }
 497
 498         write_unlock_bh(&sco_sk_list.lock);
 499
 500 done:
 501         release_sock(sk);
 502         return err;
 503 }
 504
 505 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 506 {
 507         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 508         struct sock *sk = sock->sk;
 509         int err = 0;
 510
 511
 512         BT_DBG("sk %p", sk);
 513
 514         if (alen < sizeof(struct sockaddr_sco) ||
 515             addr->sa_family != AF_BLUETOOTH)
 516                 return -EINVAL;
 517
 518         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 519                 return -EBADFD;
 520
 521         if (sk->sk_type != SOCK_SEQPACKET)
 522                 return -EINVAL;
 523
 524         lock_sock(sk);
 525
 526         /* Set destination address and psm */
 527         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 528
 529         err = sco_connect(sk);
 530         if (err)
 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         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 574
 575         BT_DBG("sk %p timeo %ld", sk, timeo);
 576
 577         /* Wait for an incoming connection. (wake-one). */
 578         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 579         while (1) {
 580                 set_current_state(TASK_INTERRUPTIBLE);
 581
 582                 if (sk->sk_state != BT_LISTEN) {
 583                         err = -EBADFD;
 584                         break;
 585                 }
 586
 587                 ch = bt_accept_dequeue(sk, newsock);
 588                 if (ch)
 589                         break;
 590
 591                 if (!timeo) {
 592                         err = -EAGAIN;
 593                         break;
 594                 }
 595
 596                 if (signal_pending(current)) {
 597                         err = sock_intr_errno(timeo);
 598                         break;
 599                 }
 600
 601                 release_sock(sk);
 602                 timeo = schedule_timeout(timeo);
 603                 lock_sock(sk);
 604         }
 605         __set_current_state(TASK_RUNNING);
 606         remove_wait_queue(sk_sleep(sk), &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
 635         return 0;
 636 }
 637
 638 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 639                             struct msghdr *msg, size_t len)
 640 {
 641         struct sock *sk = sock->sk;
 642         int err;
 643
 644         BT_DBG("sock %p, sk %p", sock, sk);
 645
 646         err = sock_error(sk);
 647         if (err)
 648                 return err;
 649
 650         if (msg->msg_flags & MSG_OOB)
 651                 return -EOPNOTSUPP;
 652
 653         lock_sock(sk);
 654
 655         if (sk->sk_state == BT_CONNECTED)
 656                 err = sco_send_frame(sk, msg, len);
 657         else
 658                 err = -ENOTCONN;
 659
 660         release_sock(sk);
 661         return err;
 662 }
 663
 664 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 665 {
 666         struct sock *sk = sock->sk;
 667         int err = 0;
 668
 669         BT_DBG("sk %p", sk);
 670
 671         lock_sock(sk);
 672
 673         switch (optname) {
 674         default:
 675                 err = -ENOPROTOOPT;
 676                 break;
 677         }
 678
 679         release_sock(sk);
 680         return err;
 681 }
 682
 683 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 684 {
 685         struct sock *sk = sock->sk;
 686         struct sco_options opts;
 687         struct sco_conninfo cinfo;
 688         int len, err = 0;
 689
 690         BT_DBG("sk %p", sk);
 691
 692         if (get_user(len, optlen))
 693                 return -EFAULT;
 694
 695         lock_sock(sk);
 696
 697         switch (optname) {
 698         case SCO_OPTIONS:
 699                 if (sk->sk_state != BT_CONNECTED) {
 700                         err = -ENOTCONN;
 701                         break;
 702                 }
 703
 704                 opts.mtu = sco_pi(sk)->conn->mtu;
 705
 706                 BT_DBG("mtu %d", opts.mtu);
 707
 708                 len = min_t(unsigned int, len, sizeof(opts));
 709                 if (copy_to_user(optval, (char *)&opts, len))
 710                         err = -EFAULT;
 711
 712                 break;
 713
 714         case SCO_CONNINFO:
 715                 if (sk->sk_state != BT_CONNECTED) {
 716                         err = -ENOTCONN;
 717                         break;
 718                 }
 719
 720                 memset(&cinfo, 0, sizeof(cinfo));
 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                     !(current->flags & PF_EXITING))
 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             !(current->flags & PF_EXITING)) {
 803                 lock_sock(sk);
 804                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 805                 release_sock(sk);
 806         }
 807
 808         sock_orphan(sk);
 809         sco_sock_kill(sk);
 810         return err;
 811 }
 812
 813 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 814 {
 815         BT_DBG("conn %p", conn);
 816
 817         sco_pi(sk)->conn = conn;
 818         conn->sk = sk;
 819
 820         if (parent)
 821                 bt_accept_enqueue(parent, sk);
 822 }
 823
 824 /* Delete channel.
 825  * Must be called on the locked socket. */
 826 static void sco_chan_del(struct sock *sk, int err)
 827 {
 828         struct sco_conn *conn;
 829
 830         conn = sco_pi(sk)->conn;
 831
 832         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 833
 834         if (conn) {
 835                 sco_conn_lock(conn);
 836                 conn->sk = NULL;
 837                 sco_pi(sk)->conn = NULL;
 838                 sco_conn_unlock(conn);
 839
 840                 if (conn->hcon)
 841                         hci_conn_put(conn->hcon);
 842         }
 843
 844         sk->sk_state = BT_CLOSED;
 845         sk->sk_err   = err;
 846         sk->sk_state_change(sk);
 847
 848         sock_set_flag(sk, SOCK_ZAPPED);
 849 }
 850
 851 static void sco_conn_ready(struct sco_conn *conn)
 852 {
 853         struct sock *parent;
 854         struct sock *sk = conn->sk;
 855
 856         BT_DBG("conn %p", conn);
 857
 858         sco_conn_lock(conn);
 859
 860         if (sk) {
 861                 sco_sock_clear_timer(sk);
 862                 bh_lock_sock(sk);
 863                 sk->sk_state = BT_CONNECTED;
 864                 sk->sk_state_change(sk);
 865                 bh_unlock_sock(sk);
 866         } else {
 867                 parent = sco_get_sock_listen(conn->src);
 868                 if (!parent)
 869                         goto done;
 870
 871                 bh_lock_sock(parent);
 872
 873                 sk = sco_sock_alloc(sock_net(parent), NULL,
 874                                 BTPROTO_SCO, GFP_ATOMIC);
 875                 if (!sk) {
 876                         bh_unlock_sock(parent);
 877                         goto done;
 878                 }
 879
 880                 sco_sock_init(sk, parent);
 881
 882                 bacpy(&bt_sk(sk)->src, conn->src);
 883                 bacpy(&bt_sk(sk)->dst, conn->dst);
 884
 885                 hci_conn_hold(conn->hcon);
 886                 __sco_chan_add(conn, sk, parent);
 887
 888                 sk->sk_state = BT_CONNECTED;
 889
 890                 /* Wake up parent */
 891                 parent->sk_data_ready(parent, 1);
 892
 893                 bh_unlock_sock(parent);
 894         }
 895
 896 done:
 897         sco_conn_unlock(conn);
 898 }
 899
 900 /* ----- SCO interface with lower layer (HCI) ----- */
 901 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 902 {
 903         register struct sock *sk;
 904         struct hlist_node *node;
 905         int lm = 0;
 906
 907         if (type != SCO_LINK && type != ESCO_LINK)
 908                 return -EINVAL;
 909
 910         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 911
 912         /* Find listening sockets */
 913         read_lock(&sco_sk_list.lock);
 914         sk_for_each(sk, node, &sco_sk_list.head) {
 915                 if (sk->sk_state != BT_LISTEN)
 916                         continue;
 917
 918                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 919                                 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 920                         lm |= HCI_LM_ACCEPT;
 921                         break;
 922                 }
 923         }
 924         read_unlock(&sco_sk_list.lock);
 925
 926         return lm;
 927 }
 928
 929 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 930 {
 931         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 932
 933         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 934                 return -EINVAL;
 935
 936         if (!status) {
 937                 struct sco_conn *conn;
 938
 939                 conn = sco_conn_add(hcon, status);
 940                 if (conn)
 941                         sco_conn_ready(conn);
 942         } else
 943                 sco_conn_del(hcon, bt_to_errno(status));
 944
 945         return 0;
 946 }
 947
 948 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 949 {
 950         BT_DBG("hcon %p reason %d", hcon, reason);
 951
 952         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 953                 return -EINVAL;
 954
 955         sco_conn_del(hcon, bt_to_errno(reason));
 956
 957         return 0;
 958 }
 959
 960 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 961 {
 962         struct sco_conn *conn = hcon->sco_data;
 963
 964         if (!conn)
 965                 goto drop;
 966
 967         BT_DBG("conn %p len %d", conn, skb->len);
 968
 969         if (skb->len) {
 970                 sco_recv_frame(conn, skb);
 971                 return 0;
 972         }
 973
 974 drop:
 975         kfree_skb(skb);
 976         return 0;
 977 }
 978
 979 static int sco_debugfs_show(struct seq_file *f, void *p)
 980 {
 981         struct sock *sk;
 982         struct hlist_node *node;
 983
 984         read_lock_bh(&sco_sk_list.lock);
 985
 986         sk_for_each(sk, node, &sco_sk_list.head) {
 987                 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
 988                                 batostr(&bt_sk(sk)->dst), sk->sk_state);
 989         }
 990
 991         read_unlock_bh(&sco_sk_list.lock);
 992
 993         return 0;
 994 }
 995
 996 static int sco_debugfs_open(struct inode *inode, struct file *file)
 997 {
 998         return single_open(file, sco_debugfs_show, inode->i_private);
 999 }
1000
1001 static const struct file_operations sco_debugfs_fops = {
1002         .open           = sco_debugfs_open,
1003         .read           = seq_read,
1004         .llseek         = seq_lseek,
1005         .release        = single_release,
1006 };
1007
1008 static struct dentry *sco_debugfs;
1009
1010 static const struct proto_ops sco_sock_ops = {
1011         .family         = PF_BLUETOOTH,
1012         .owner          = THIS_MODULE,
1013         .release        = sco_sock_release,
1014         .bind           = sco_sock_bind,
1015         .connect        = sco_sock_connect,
1016         .listen         = sco_sock_listen,
1017         .accept         = sco_sock_accept,
1018         .getname        = sco_sock_getname,
1019         .sendmsg        = sco_sock_sendmsg,
1020         .recvmsg        = bt_sock_recvmsg,
1021         .poll           = bt_sock_poll,
1022         .ioctl          = bt_sock_ioctl,
1023         .mmap           = sock_no_mmap,
1024         .socketpair     = sock_no_socketpair,
1025         .shutdown       = sco_sock_shutdown,
1026         .setsockopt     = sco_sock_setsockopt,
1027         .getsockopt     = sco_sock_getsockopt
1028 };
1029
1030 static const struct net_proto_family sco_sock_family_ops = {
1031         .family = PF_BLUETOOTH,
1032         .owner  = THIS_MODULE,
1033         .create = sco_sock_create,
1034 };
1035
1036 static struct hci_proto sco_hci_proto = {
1037         .name           = "SCO",
1038         .id             = HCI_PROTO_SCO,
1039         .connect_ind    = sco_connect_ind,
1040         .connect_cfm    = sco_connect_cfm,
1041         .disconn_cfm    = sco_disconn_cfm,
1042         .recv_scodata   = sco_recv_scodata
1043 };
1044
1045 int __init sco_init(void)
1046 {
1047         int err;
1048
1049         err = proto_register(&sco_proto, 0);
1050         if (err < 0)
1051                 return err;
1052
1053         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1054         if (err < 0) {
1055                 BT_ERR("SCO socket registration failed");
1056                 goto error;
1057         }
1058
1059         err = hci_register_proto(&sco_hci_proto);
1060         if (err < 0) {
1061                 BT_ERR("SCO protocol registration failed");
1062                 bt_sock_unregister(BTPROTO_SCO);
1063                 goto error;
1064         }
1065
1066         if (bt_debugfs) {
1067                 sco_debugfs = debugfs_create_file("sco", 0444,
1068                                         bt_debugfs, NULL, &sco_debugfs_fops);
1069                 if (!sco_debugfs)
1070                         BT_ERR("Failed to create SCO debug file");
1071         }
1072
1073         BT_INFO("SCO socket layer initialized");
1074
1075         return 0;
1076
1077 error:
1078         proto_unregister(&sco_proto);
1079         return err;
1080 }
1081
1082 void __exit sco_exit(void)
1083 {
1084         debugfs_remove(sco_debugfs);
1085
1086         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1087                 BT_ERR("SCO socket unregistration failed");
1088
1089         if (hci_unregister_proto(&sco_hci_proto) < 0)
1090                 BT_ERR("SCO protocol unregistration failed");
1091
1092         proto_unregister(&sco_proto);
1093 }
1094
1095 module_param(disable_esco, bool, 0644);
1096 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");