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