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