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 <asm/uaccess.h>
  48
  49 #include <net/bluetooth/bluetooth.h>
  50 #include <net/bluetooth/hci_core.h>
  51 #include <net/bluetooth/sco.h>
  52
  53 #define VERSION "0.6"
  54
  55 static int disable_esco = 0;
  56
  57 static const struct proto_ops sco_sock_ops;
  58
  59 static struct bt_sock_list sco_sk_list = {
  60         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  61 };
  62
  63 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  64 static void sco_chan_del(struct sock *sk, int err);
  65
  66 static int  sco_conn_del(struct hci_conn *conn, int err);
  67
  68 static void sco_sock_close(struct sock *sk);
  69 static void sco_sock_kill(struct sock *sk);
  70
  71 /* ---- SCO timers ---- */
  72 static void sco_sock_timeout(unsigned long arg)
  73 {
  74         struct sock *sk = (struct sock *) arg;
  75
  76         BT_DBG("sock %p state %d", sk, sk->sk_state);
  77
  78         bh_lock_sock(sk);
  79         sk->sk_err = ETIMEDOUT;
  80         sk->sk_state_change(sk);
  81         bh_unlock_sock(sk);
  82
  83         sco_sock_kill(sk);
  84         sock_put(sk);
  85 }
  86
  87 static void sco_sock_set_timer(struct sock *sk, long timeout)
  88 {
  89         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  90         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  91 }
  92
  93 static void sco_sock_clear_timer(struct sock *sk)
  94 {
  95         BT_DBG("sock %p state %d", sk, sk->sk_state);
  96         sk_stop_timer(sk, &sk->sk_timer);
  97 }
  98
  99 /* ---- SCO connections ---- */
 100 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
 101 {
 102         struct hci_dev *hdev = hcon->hdev;
 103         struct sco_conn *conn = hcon->sco_data;
 104
 105         if (conn || status)
 106                 return conn;
 107
 108         conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
 109         if (!conn)
 110                 return NULL;
 111
 112         spin_lock_init(&conn->lock);
 113
 114         hcon->sco_data = conn;
 115         conn->hcon = hcon;
 116
 117         conn->src = &hdev->bdaddr;
 118         conn->dst = &hcon->dst;
 119
 120         if (hdev->sco_mtu > 0)
 121                 conn->mtu = hdev->sco_mtu;
 122         else
 123                 conn->mtu = 60;
 124
 125         BT_DBG("hcon %p conn %p", hcon, conn);
 126
 127         return conn;
 128 }
 129
 130 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 131 {
 132         struct sock *sk = NULL;
 133         sco_conn_lock(conn);
 134         sk = conn->sk;
 135         sco_conn_unlock(conn);
 136         return sk;
 137 }
 138
 139 static int sco_conn_del(struct hci_conn *hcon, int err)
 140 {
 141         struct sco_conn *conn;
 142         struct sock *sk;
 143
 144         if (!(conn = hcon->sco_data))
 145                 return 0;
 146
 147         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 148
 149         /* Kill socket */
 150         if ((sk = sco_chan_get(conn))) {
 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         if (!(hdev = hci_get_route(dst, src)))
 189                 return -EHOSTUNREACH;
 190
 191         hci_dev_lock_bh(hdev);
 192
 193         err = -ENOMEM;
 194
 195         if (lmp_esco_capable(hdev) && !disable_esco)
 196                 type = ESCO_LINK;
 197         else
 198                 type = SCO_LINK;
 199
 200         hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
 201         if (!hcon)
 202                 goto done;
 203
 204         conn = sco_conn_add(hcon, 0);
 205         if (!conn) {
 206                 hci_conn_put(hcon);
 207                 goto done;
 208         }
 209
 210         /* Update source addr of the socket */
 211         bacpy(src, conn->src);
 212
 213         err = sco_chan_add(conn, sk, NULL);
 214         if (err)
 215                 goto done;
 216
 217         if (hcon->state == BT_CONNECTED) {
 218                 sco_sock_clear_timer(sk);
 219                 sk->sk_state = BT_CONNECTED;
 220         } else {
 221                 sk->sk_state = BT_CONNECT;
 222                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 223         }
 224
 225 done:
 226         hci_dev_unlock_bh(hdev);
 227         hci_dev_put(hdev);
 228         return err;
 229 }
 230
 231 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 232 {
 233         struct sco_conn *conn = sco_pi(sk)->conn;
 234         struct sk_buff *skb;
 235         int err, count;
 236
 237         /* Check outgoing MTU */
 238         if (len > conn->mtu)
 239                 return -EINVAL;
 240
 241         BT_DBG("sk %p len %d", sk, len);
 242
 243         count = min_t(unsigned int, conn->mtu, len);
 244         if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
 245                 return err;
 246
 247         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 248                 err = -EFAULT;
 249                 goto fail;
 250         }
 251
 252         if ((err = hci_send_sco(conn->hcon, skb)) < 0)
 253                 return err;
 254
 255         return count;
 256
 257 fail:
 258         kfree_skb(skb);
 259         return err;
 260 }
 261
 262 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 263 {
 264         struct sock *sk = sco_chan_get(conn);
 265
 266         if (!sk)
 267                 goto drop;
 268
 269         BT_DBG("sk %p len %d", sk, skb->len);
 270
 271         if (sk->sk_state != BT_CONNECTED)
 272                 goto drop;
 273
 274         if (!sock_queue_rcv_skb(sk, skb))
 275                 return;
 276
 277 drop:
 278         kfree_skb(skb);
 279         return;
 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         case BT_CONNECT:
 376         case BT_DISCONN:
 377                 sco_chan_del(sk, ECONNRESET);
 378                 break;
 379
 380         default:
 381                 sock_set_flag(sk, SOCK_ZAPPED);
 382                 break;
 383         }
 384 }
 385
 386 /* Must be called on unlocked socket. */
 387 static void sco_sock_close(struct sock *sk)
 388 {
 389         sco_sock_clear_timer(sk);
 390         lock_sock(sk);
 391         __sco_sock_close(sk);
 392         release_sock(sk);
 393         sco_sock_kill(sk);
 394 }
 395
 396 static void sco_sock_init(struct sock *sk, struct sock *parent)
 397 {
 398         BT_DBG("sk %p", sk);
 399
 400         if (parent)
 401                 sk->sk_type = parent->sk_type;
 402 }
 403
 404 static struct proto sco_proto = {
 405         .name           = "SCO",
 406         .owner          = THIS_MODULE,
 407         .obj_size       = sizeof(struct sco_pinfo)
 408 };
 409
 410 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 411 {
 412         struct sock *sk;
 413
 414         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
 415         if (!sk)
 416                 return NULL;
 417
 418         sock_init_data(sock, sk);
 419         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 420
 421         sk->sk_destruct = sco_sock_destruct;
 422         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 423
 424         sock_reset_flag(sk, SOCK_ZAPPED);
 425
 426         sk->sk_protocol = proto;
 427         sk->sk_state    = BT_OPEN;
 428
 429         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
 430
 431         bt_sock_link(&sco_sk_list, sk);
 432         return sk;
 433 }
 434
 435 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 436                            int kern)
 437 {
 438         struct sock *sk;
 439
 440         BT_DBG("sock %p", sock);
 441
 442         sock->state = SS_UNCONNECTED;
 443
 444         if (sock->type != SOCK_SEQPACKET)
 445                 return -ESOCKTNOSUPPORT;
 446
 447         sock->ops = &sco_sock_ops;
 448
 449         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 450         if (!sk)
 451                 return -ENOMEM;
 452
 453         sco_sock_init(sk, NULL);
 454         return 0;
 455 }
 456
 457 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 458 {
 459         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 460         struct sock *sk = sock->sk;
 461         bdaddr_t *src = &sa->sco_bdaddr;
 462         int err = 0;
 463
 464         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 465
 466         if (!addr || addr->sa_family != AF_BLUETOOTH)
 467                 return -EINVAL;
 468
 469         lock_sock(sk);
 470
 471         if (sk->sk_state != BT_OPEN) {
 472                 err = -EBADFD;
 473                 goto done;
 474         }
 475
 476         write_lock_bh(&sco_sk_list.lock);
 477
 478         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 479                 err = -EADDRINUSE;
 480         } else {
 481                 /* Save source address */
 482                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 483                 sk->sk_state = BT_BOUND;
 484         }
 485
 486         write_unlock_bh(&sco_sk_list.lock);
 487
 488 done:
 489         release_sock(sk);
 490         return err;
 491 }
 492
 493 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 494 {
 495         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 496         struct sock *sk = sock->sk;
 497         int err = 0;
 498
 499
 500         BT_DBG("sk %p", sk);
 501
 502         if (alen < sizeof(struct sockaddr_sco) ||
 503             addr->sa_family != AF_BLUETOOTH)
 504                 return -EINVAL;
 505
 506         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 507                 return -EBADFD;
 508
 509         if (sk->sk_type != SOCK_SEQPACKET)
 510                 return -EINVAL;
 511
 512         lock_sock(sk);
 513
 514         /* Set destination address and psm */
 515         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 516
 517         if ((err = sco_connect(sk)))
 518                 goto done;
 519
 520         err = bt_sock_wait_state(sk, BT_CONNECTED,
 521                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 522
 523 done:
 524         release_sock(sk);
 525         return err;
 526 }
 527
 528 static int sco_sock_listen(struct socket *sock, int backlog)
 529 {
 530         struct sock *sk = sock->sk;
 531         int err = 0;
 532
 533         BT_DBG("sk %p backlog %d", sk, backlog);
 534
 535         lock_sock(sk);
 536
 537         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 538                 err = -EBADFD;
 539                 goto done;
 540         }
 541
 542         sk->sk_max_ack_backlog = backlog;
 543         sk->sk_ack_backlog = 0;
 544         sk->sk_state = BT_LISTEN;
 545
 546 done:
 547         release_sock(sk);
 548         return err;
 549 }
 550
 551 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 552 {
 553         DECLARE_WAITQUEUE(wait, current);
 554         struct sock *sk = sock->sk, *ch;
 555         long timeo;
 556         int err = 0;
 557
 558         lock_sock(sk);
 559
 560         if (sk->sk_state != BT_LISTEN) {
 561                 err = -EBADFD;
 562                 goto done;
 563         }
 564
 565         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 566
 567         BT_DBG("sk %p timeo %ld", sk, timeo);
 568
 569         /* Wait for an incoming connection. (wake-one). */
 570         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 571         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 572                 set_current_state(TASK_INTERRUPTIBLE);
 573                 if (!timeo) {
 574                         err = -EAGAIN;
 575                         break;
 576                 }
 577
 578                 release_sock(sk);
 579                 timeo = schedule_timeout(timeo);
 580                 lock_sock(sk);
 581
 582                 if (sk->sk_state != BT_LISTEN) {
 583                         err = -EBADFD;
 584                         break;
 585                 }
 586
 587                 if (signal_pending(current)) {
 588                         err = sock_intr_errno(timeo);
 589                         break;
 590                 }
 591         }
 592         set_current_state(TASK_RUNNING);
 593         remove_wait_queue(sk->sk_sleep, &wait);
 594
 595         if (err)
 596                 goto done;
 597
 598         newsock->state = SS_CONNECTED;
 599
 600         BT_DBG("new socket %p", ch);
 601
 602 done:
 603         release_sock(sk);
 604         return err;
 605 }
 606
 607 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 608 {
 609         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 610         struct sock *sk = sock->sk;
 611
 612         BT_DBG("sock %p, sk %p", sock, sk);
 613
 614         addr->sa_family = AF_BLUETOOTH;
 615         *len = sizeof(struct sockaddr_sco);
 616
 617         if (peer)
 618                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 619         else
 620                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 621
 622         return 0;
 623 }
 624
 625 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 626                             struct msghdr *msg, size_t len)
 627 {
 628         struct sock *sk = sock->sk;
 629         int err = 0;
 630
 631         BT_DBG("sock %p, sk %p", sock, sk);
 632
 633         err = sock_error(sk);
 634         if (err)
 635                 return err;
 636
 637         if (msg->msg_flags & MSG_OOB)
 638                 return -EOPNOTSUPP;
 639
 640         lock_sock(sk);
 641
 642         if (sk->sk_state == BT_CONNECTED)
 643                 err = sco_send_frame(sk, msg, len);
 644         else
 645                 err = -ENOTCONN;
 646
 647         release_sock(sk);
 648         return err;
 649 }
 650
 651 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 652 {
 653         struct sock *sk = sock->sk;
 654         int err = 0;
 655
 656         BT_DBG("sk %p", sk);
 657
 658         lock_sock(sk);
 659
 660         switch (optname) {
 661         default:
 662                 err = -ENOPROTOOPT;
 663                 break;
 664         }
 665
 666         release_sock(sk);
 667         return err;
 668 }
 669
 670 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 671 {
 672         struct sock *sk = sock->sk;
 673         struct sco_options opts;
 674         struct sco_conninfo cinfo;
 675         int len, err = 0;
 676
 677         BT_DBG("sk %p", sk);
 678
 679         if (get_user(len, optlen))
 680                 return -EFAULT;
 681
 682         lock_sock(sk);
 683
 684         switch (optname) {
 685         case SCO_OPTIONS:
 686                 if (sk->sk_state != BT_CONNECTED) {
 687                         err = -ENOTCONN;
 688                         break;
 689                 }
 690
 691                 opts.mtu = sco_pi(sk)->conn->mtu;
 692
 693                 BT_DBG("mtu %d", opts.mtu);
 694
 695                 len = min_t(unsigned int, len, sizeof(opts));
 696                 if (copy_to_user(optval, (char *)&opts, len))
 697                         err = -EFAULT;
 698
 699                 break;
 700
 701         case SCO_CONNINFO:
 702                 if (sk->sk_state != BT_CONNECTED) {
 703                         err = -ENOTCONN;
 704                         break;
 705                 }
 706
 707                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 708                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 709
 710                 len = min_t(unsigned int, len, sizeof(cinfo));
 711                 if (copy_to_user(optval, (char *)&cinfo, len))
 712                         err = -EFAULT;
 713
 714                 break;
 715
 716         default:
 717                 err = -ENOPROTOOPT;
 718                 break;
 719         }
 720
 721         release_sock(sk);
 722         return err;
 723 }
 724
 725 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 726 {
 727         struct sock *sk = sock->sk;
 728         int len, err = 0;
 729
 730         BT_DBG("sk %p", sk);
 731
 732         if (level == SOL_SCO)
 733                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 734
 735         if (get_user(len, optlen))
 736                 return -EFAULT;
 737
 738         lock_sock(sk);
 739
 740         switch (optname) {
 741         default:
 742                 err = -ENOPROTOOPT;
 743                 break;
 744         }
 745
 746         release_sock(sk);
 747         return err;
 748 }
 749
 750 static int sco_sock_shutdown(struct socket *sock, int how)
 751 {
 752         struct sock *sk = sock->sk;
 753         int err = 0;
 754
 755         BT_DBG("sock %p, sk %p", sock, sk);
 756
 757         if (!sk)
 758                 return 0;
 759
 760         lock_sock(sk);
 761         if (!sk->sk_shutdown) {
 762                 sk->sk_shutdown = SHUTDOWN_MASK;
 763                 sco_sock_clear_timer(sk);
 764                 __sco_sock_close(sk);
 765
 766                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 767                         err = bt_sock_wait_state(sk, BT_CLOSED,
 768                                                         sk->sk_lingertime);
 769         }
 770         release_sock(sk);
 771         return err;
 772 }
 773
 774 static int sco_sock_release(struct socket *sock)
 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         sco_sock_close(sk);
 785
 786         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 787                 lock_sock(sk);
 788                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 789                 release_sock(sk);
 790         }
 791
 792         sock_orphan(sk);
 793         sco_sock_kill(sk);
 794         return err;
 795 }
 796
 797 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 798 {
 799         BT_DBG("conn %p", conn);
 800
 801         sco_pi(sk)->conn = conn;
 802         conn->sk = sk;
 803
 804         if (parent)
 805                 bt_accept_enqueue(parent, sk);
 806 }
 807
 808 /* Delete channel.
 809  * Must be called on the locked socket. */
 810 static void sco_chan_del(struct sock *sk, int err)
 811 {
 812         struct sco_conn *conn;
 813
 814         conn = sco_pi(sk)->conn;
 815
 816         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 817
 818         if (conn) {
 819                 sco_conn_lock(conn);
 820                 conn->sk = NULL;
 821                 sco_pi(sk)->conn = NULL;
 822                 sco_conn_unlock(conn);
 823                 hci_conn_put(conn->hcon);
 824         }
 825
 826         sk->sk_state = BT_CLOSED;
 827         sk->sk_err   = err;
 828         sk->sk_state_change(sk);
 829
 830         sock_set_flag(sk, SOCK_ZAPPED);
 831 }
 832
 833 static void sco_conn_ready(struct sco_conn *conn)
 834 {
 835         struct sock *parent, *sk;
 836
 837         BT_DBG("conn %p", conn);
 838
 839         sco_conn_lock(conn);
 840
 841         if ((sk = conn->sk)) {
 842                 sco_sock_clear_timer(sk);
 843                 bh_lock_sock(sk);
 844                 sk->sk_state = BT_CONNECTED;
 845                 sk->sk_state_change(sk);
 846                 bh_unlock_sock(sk);
 847         } else {
 848                 parent = sco_get_sock_listen(conn->src);
 849                 if (!parent)
 850                         goto done;
 851
 852                 bh_lock_sock(parent);
 853
 854                 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
 855                 if (!sk) {
 856                         bh_unlock_sock(parent);
 857                         goto done;
 858                 }
 859
 860                 sco_sock_init(sk, parent);
 861
 862                 bacpy(&bt_sk(sk)->src, conn->src);
 863                 bacpy(&bt_sk(sk)->dst, conn->dst);
 864
 865                 hci_conn_hold(conn->hcon);
 866                 __sco_chan_add(conn, sk, parent);
 867
 868                 sk->sk_state = BT_CONNECTED;
 869
 870                 /* Wake up parent */
 871                 parent->sk_data_ready(parent, 1);
 872
 873                 bh_unlock_sock(parent);
 874         }
 875
 876 done:
 877         sco_conn_unlock(conn);
 878 }
 879
 880 /* ----- SCO interface with lower layer (HCI) ----- */
 881 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 882 {
 883         register struct sock *sk;
 884         struct hlist_node *node;
 885         int lm = 0;
 886
 887         if (type != SCO_LINK && type != ESCO_LINK)
 888                 return 0;
 889
 890         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 891
 892         /* Find listening sockets */
 893         read_lock(&sco_sk_list.lock);
 894         sk_for_each(sk, node, &sco_sk_list.head) {
 895                 if (sk->sk_state != BT_LISTEN)
 896                         continue;
 897
 898                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
 899                                 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 900                         lm |= HCI_LM_ACCEPT;
 901                         break;
 902                 }
 903         }
 904         read_unlock(&sco_sk_list.lock);
 905
 906         return lm;
 907 }
 908
 909 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 910 {
 911         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 912
 913         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 914                 return 0;
 915
 916         if (!status) {
 917                 struct sco_conn *conn;
 918
 919                 conn = sco_conn_add(hcon, status);
 920                 if (conn)
 921                         sco_conn_ready(conn);
 922         } else
 923                 sco_conn_del(hcon, bt_err(status));
 924
 925         return 0;
 926 }
 927
 928 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 929 {
 930         BT_DBG("hcon %p reason %d", hcon, reason);
 931
 932         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 933                 return 0;
 934
 935         sco_conn_del(hcon, bt_err(reason));
 936
 937         return 0;
 938 }
 939
 940 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 941 {
 942         struct sco_conn *conn = hcon->sco_data;
 943
 944         if (!conn)
 945                 goto drop;
 946
 947         BT_DBG("conn %p len %d", conn, skb->len);
 948
 949         if (skb->len) {
 950                 sco_recv_frame(conn, skb);
 951                 return 0;
 952         }
 953
 954 drop:
 955         kfree_skb(skb);
 956         return 0;
 957 }
 958
 959 static int sco_debugfs_show(struct seq_file *f, void *p)
 960 {
 961         struct sock *sk;
 962         struct hlist_node *node;
 963
 964         read_lock_bh(&sco_sk_list.lock);
 965
 966         sk_for_each(sk, node, &sco_sk_list.head) {
 967                 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
 968                                 batostr(&bt_sk(sk)->dst), sk->sk_state);
 969         }
 970
 971         read_unlock_bh(&sco_sk_list.lock);
 972
 973         return 0;
 974 }
 975
 976 static int sco_debugfs_open(struct inode *inode, struct file *file)
 977 {
 978         return single_open(file, sco_debugfs_show, inode->i_private);
 979 }
 980
 981 static const struct file_operations sco_debugfs_fops = {
 982         .open           = sco_debugfs_open,
 983         .read           = seq_read,
 984         .llseek         = seq_lseek,
 985         .release        = single_release,
 986 };
 987
 988 static struct dentry *sco_debugfs;
 989
 990 static const struct proto_ops sco_sock_ops = {
 991         .family         = PF_BLUETOOTH,
 992         .owner          = THIS_MODULE,
 993         .release        = sco_sock_release,
 994         .bind           = sco_sock_bind,
 995         .connect        = sco_sock_connect,
 996         .listen         = sco_sock_listen,
 997         .accept         = sco_sock_accept,
 998         .getname        = sco_sock_getname,
 999         .sendmsg        = sco_sock_sendmsg,
1000         .recvmsg        = bt_sock_recvmsg,
1001         .poll           = bt_sock_poll,
1002         .ioctl          = bt_sock_ioctl,
1003         .mmap           = sock_no_mmap,
1004         .socketpair     = sock_no_socketpair,
1005         .shutdown       = sco_sock_shutdown,
1006         .setsockopt     = sco_sock_setsockopt,
1007         .getsockopt     = sco_sock_getsockopt
1008 };
1009
1010 static const struct net_proto_family sco_sock_family_ops = {
1011         .family = PF_BLUETOOTH,
1012         .owner  = THIS_MODULE,
1013         .create = sco_sock_create,
1014 };
1015
1016 static struct hci_proto sco_hci_proto = {
1017         .name           = "SCO",
1018         .id             = HCI_PROTO_SCO,
1019         .connect_ind    = sco_connect_ind,
1020         .connect_cfm    = sco_connect_cfm,
1021         .disconn_cfm    = sco_disconn_cfm,
1022         .recv_scodata   = sco_recv_scodata
1023 };
1024
1025 static int __init sco_init(void)
1026 {
1027         int err;
1028
1029         err = proto_register(&sco_proto, 0);
1030         if (err < 0)
1031                 return err;
1032
1033         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1034         if (err < 0) {
1035                 BT_ERR("SCO socket registration failed");
1036                 goto error;
1037         }
1038
1039         err = hci_register_proto(&sco_hci_proto);
1040         if (err < 0) {
1041                 BT_ERR("SCO protocol registration failed");
1042                 bt_sock_unregister(BTPROTO_SCO);
1043                 goto error;
1044         }
1045
1046         if (bt_debugfs) {
1047                 sco_debugfs = debugfs_create_file("sco", 0444,
1048                                         bt_debugfs, NULL, &sco_debugfs_fops);
1049                 if (!sco_debugfs)
1050                         BT_ERR("Failed to create SCO debug file");
1051         }
1052
1053         BT_INFO("SCO (Voice Link) ver %s", VERSION);
1054         BT_INFO("SCO socket layer initialized");
1055
1056         return 0;
1057
1058 error:
1059         proto_unregister(&sco_proto);
1060         return err;
1061 }
1062
1063 static void __exit sco_exit(void)
1064 {
1065         debugfs_remove(sco_debugfs);
1066
1067         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1068                 BT_ERR("SCO socket unregistration failed");
1069
1070         if (hci_unregister_proto(&sco_hci_proto) < 0)
1071                 BT_ERR("SCO protocol unregistration failed");
1072
1073         proto_unregister(&sco_proto);
1074 }
1075
1076 module_init(sco_init);
1077 module_exit(sco_exit);
1078
1079 module_param(disable_esco, bool, 0644);
1080 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1081
1082 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1083 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1084 MODULE_VERSION(VERSION);
1085 MODULE_LICENSE("GPL");
1086 MODULE_ALIAS("bt-proto-2");