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