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/list.h>
  42 #include <net/sock.h>
  43
  44 #include <asm/system.h>
  45 #include <asm/uaccess.h>
  46
  47 #include <net/bluetooth/bluetooth.h>
  48 #include <net/bluetooth/hci_core.h>
  49 #include <net/bluetooth/sco.h>
  50
  51 #ifndef CONFIG_BT_SCO_DEBUG
  52 #undef  BT_DBG
  53 #define BT_DBG(D...)
  54 #endif
  55
  56 #define VERSION "0.5"
  57
  58 static const struct proto_ops sco_sock_ops;
  59
  60 static struct bt_sock_list sco_sk_list = {
  61         .lock = RW_LOCK_UNLOCKED
  62 };
  63
  64 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  65 static void sco_chan_del(struct sock *sk, int err);
  66
  67 static int  sco_conn_del(struct hci_conn *conn, int err);
  68
  69 static void sco_sock_close(struct sock *sk);
  70 static void sco_sock_kill(struct sock *sk);
  71
  72 /* ---- SCO timers ---- */
  73 static void sco_sock_timeout(unsigned long arg)
  74 {
  75         struct sock *sk = (struct sock *) arg;
  76
  77         BT_DBG("sock %p state %d", sk, sk->sk_state);
  78
  79         bh_lock_sock(sk);
  80         sk->sk_err = ETIMEDOUT;
  81         sk->sk_state_change(sk);
  82         bh_unlock_sock(sk);
  83
  84         sco_sock_kill(sk);
  85         sock_put(sk);
  86 }
  87
  88 static void sco_sock_set_timer(struct sock *sk, long timeout)
  89 {
  90         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  91         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  92 }
  93
  94 static void sco_sock_clear_timer(struct sock *sk)
  95 {
  96         BT_DBG("sock %p state %d", sk, sk->sk_state);
  97         sk_stop_timer(sk, &sk->sk_timer);
  98 }
  99
 100 static void sco_sock_init_timer(struct sock *sk)
 101 {
 102         init_timer(&sk->sk_timer);
 103         sk->sk_timer.function = sco_sock_timeout;
 104         sk->sk_timer.data = (unsigned long)sk;
 105 }
 106
 107 /* ---- SCO connections ---- */
 108 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
 109 {
 110         struct hci_dev *hdev = hcon->hdev;
 111         struct sco_conn *conn;
 112
 113         if ((conn = hcon->sco_data))
 114                 return conn;
 115
 116         if (status)
 117                 return conn;
 118
 119         if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
 120                 return NULL;
 121         memset(conn, 0, sizeof(struct sco_conn));
 122
 123         spin_lock_init(&conn->lock);
 124
 125         hcon->sco_data = conn;
 126         conn->hcon = hcon;
 127
 128         conn->src = &hdev->bdaddr;
 129         conn->dst = &hcon->dst;
 130
 131         if (hdev->sco_mtu > 0)
 132                 conn->mtu = hdev->sco_mtu;
 133         else
 134                 conn->mtu = 60;
 135
 136         BT_DBG("hcon %p conn %p", hcon, conn);
 137         return conn;
 138 }
 139
 140 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 141 {
 142         struct sock *sk = NULL;
 143         sco_conn_lock(conn);
 144         sk = conn->sk;
 145         sco_conn_unlock(conn);
 146         return sk;
 147 }
 148
 149 static int sco_conn_del(struct hci_conn *hcon, int err)
 150 {
 151         struct sco_conn *conn;
 152         struct sock *sk;
 153
 154         if (!(conn = hcon->sco_data))
 155                 return 0;
 156
 157         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 158
 159         /* Kill socket */
 160         if ((sk = sco_chan_get(conn))) {
 161                 bh_lock_sock(sk);
 162                 sco_sock_clear_timer(sk);
 163                 sco_chan_del(sk, err);
 164                 bh_unlock_sock(sk);
 165                 sco_sock_kill(sk);
 166         }
 167
 168         hcon->sco_data = NULL;
 169         kfree(conn);
 170         return 0;
 171 }
 172
 173 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 174 {
 175         int err = 0;
 176
 177         sco_conn_lock(conn);
 178         if (conn->sk) {
 179                 err = -EBUSY;
 180         } else {
 181                 __sco_chan_add(conn, sk, parent);
 182         }
 183         sco_conn_unlock(conn);
 184         return err;
 185 }
 186
 187 static int sco_connect(struct sock *sk)
 188 {
 189         bdaddr_t *src = &bt_sk(sk)->src;
 190         bdaddr_t *dst = &bt_sk(sk)->dst;
 191         struct sco_conn *conn;
 192         struct hci_conn *hcon;
 193         struct hci_dev  *hdev;
 194         int err = 0;
 195
 196         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 197
 198         if (!(hdev = hci_get_route(dst, src)))
 199                 return -EHOSTUNREACH;
 200
 201         hci_dev_lock_bh(hdev);
 202
 203         err = -ENOMEM;
 204
 205         hcon = hci_connect(hdev, SCO_LINK, dst);
 206         if (!hcon)
 207                 goto done;
 208
 209         conn = sco_conn_add(hcon, 0);
 210         if (!conn) {
 211                 hci_conn_put(hcon);
 212                 goto done;
 213         }
 214
 215         /* Update source addr of the socket */
 216         bacpy(src, conn->src);
 217
 218         err = sco_chan_add(conn, sk, NULL);
 219         if (err)
 220                 goto done;
 221
 222         if (hcon->state == BT_CONNECTED) {
 223                 sco_sock_clear_timer(sk);
 224                 sk->sk_state = BT_CONNECTED;
 225         } else {
 226                 sk->sk_state = BT_CONNECT;
 227                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 228         }
 229 done:
 230         hci_dev_unlock_bh(hdev);
 231         hci_dev_put(hdev);
 232         return err;
 233 }
 234
 235 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 236 {
 237         struct sco_conn *conn = sco_pi(sk)->conn;
 238         struct sk_buff *skb;
 239         int err, count;
 240
 241         /* Check outgoing MTU */
 242         if (len > conn->mtu)
 243                 return -EINVAL;
 244
 245         BT_DBG("sk %p len %d", sk, len);
 246
 247         count = min_t(unsigned int, conn->mtu, len);
 248         if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
 249                 return err;
 250
 251         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 252                 err = -EFAULT;
 253                 goto fail;
 254         }
 255
 256         if ((err = hci_send_sco(conn->hcon, skb)) < 0)
 257                 return err;
 258
 259         return count;
 260
 261 fail:
 262         kfree_skb(skb);
 263         return err;
 264 }
 265
 266 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 267 {
 268         struct sock *sk = sco_chan_get(conn);
 269
 270         if (!sk)
 271                 goto drop;
 272
 273         BT_DBG("sk %p len %d", sk, skb->len);
 274
 275         if (sk->sk_state != BT_CONNECTED)
 276                 goto drop;
 277
 278         if (!sock_queue_rcv_skb(sk, skb))
 279                 return;
 280
 281 drop:
 282         kfree_skb(skb);
 283         return;
 284 }
 285
 286 /* -------- Socket interface ---------- */
 287 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
 288 {
 289         struct sock *sk;
 290         struct hlist_node *node;
 291
 292         sk_for_each(sk, node, &sco_sk_list.head)
 293                 if (!bacmp(&bt_sk(sk)->src, ba))
 294                         goto found;
 295         sk = NULL;
 296 found:
 297         return sk;
 298 }
 299
 300 /* Find socket listening on source bdaddr.
 301  * Returns closest match.
 302  */
 303 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 304 {
 305         struct sock *sk = NULL, *sk1 = NULL;
 306         struct hlist_node *node;
 307
 308         read_lock(&sco_sk_list.lock);
 309
 310         sk_for_each(sk, node, &sco_sk_list.head) {
 311                 if (sk->sk_state != BT_LISTEN)
 312                         continue;
 313
 314                 /* Exact match. */
 315                 if (!bacmp(&bt_sk(sk)->src, src))
 316                         break;
 317
 318                 /* Closest match */
 319                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 320                         sk1 = sk;
 321         }
 322
 323         read_unlock(&sco_sk_list.lock);
 324
 325         return node ? sk : sk1;
 326 }
 327
 328 static void sco_sock_destruct(struct sock *sk)
 329 {
 330         BT_DBG("sk %p", sk);
 331
 332         skb_queue_purge(&sk->sk_receive_queue);
 333         skb_queue_purge(&sk->sk_write_queue);
 334 }
 335
 336 static void sco_sock_cleanup_listen(struct sock *parent)
 337 {
 338         struct sock *sk;
 339
 340         BT_DBG("parent %p", parent);
 341
 342         /* Close not yet accepted channels */
 343         while ((sk = bt_accept_dequeue(parent, NULL))) {
 344                 sco_sock_close(sk);
 345                 sco_sock_kill(sk);
 346         }
 347
 348         parent->sk_state  = BT_CLOSED;
 349         sock_set_flag(parent, SOCK_ZAPPED);
 350 }
 351
 352 /* Kill socket (only if zapped and orphan)
 353  * Must be called on unlocked socket.
 354  */
 355 static void sco_sock_kill(struct sock *sk)
 356 {
 357         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 358                 return;
 359
 360         BT_DBG("sk %p state %d", sk, sk->sk_state);
 361
 362         /* Kill poor orphan */
 363         bt_sock_unlink(&sco_sk_list, sk);
 364         sock_set_flag(sk, SOCK_DEAD);
 365         sock_put(sk);
 366 }
 367
 368 /* Close socket.
 369  * Must be called on unlocked socket.
 370  */
 371 static void sco_sock_close(struct sock *sk)
 372 {
 373         struct sco_conn *conn;
 374
 375         sco_sock_clear_timer(sk);
 376
 377         lock_sock(sk);
 378
 379         conn = sco_pi(sk)->conn;
 380
 381         BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
 382
 383         switch (sk->sk_state) {
 384         case BT_LISTEN:
 385                 sco_sock_cleanup_listen(sk);
 386                 break;
 387
 388         case BT_CONNECTED:
 389         case BT_CONFIG:
 390         case BT_CONNECT:
 391         case BT_DISCONN:
 392                 sco_chan_del(sk, ECONNRESET);
 393                 break;
 394
 395         default:
 396                 sock_set_flag(sk, SOCK_ZAPPED);
 397                 break;
 398         };
 399
 400         release_sock(sk);
 401
 402         sco_sock_kill(sk);
 403 }
 404
 405 static void sco_sock_init(struct sock *sk, struct sock *parent)
 406 {
 407         BT_DBG("sk %p", sk);
 408
 409         if (parent)
 410                 sk->sk_type = parent->sk_type;
 411 }
 412
 413 static struct proto sco_proto = {
 414         .name           = "SCO",
 415         .owner          = THIS_MODULE,
 416         .obj_size       = sizeof(struct sco_pinfo)
 417 };
 418
 419 static struct sock *sco_sock_alloc(struct socket *sock, int proto, gfp_t prio)
 420 {
 421         struct sock *sk;
 422
 423         sk = sk_alloc(PF_BLUETOOTH, prio, &sco_proto, 1);
 424         if (!sk)
 425                 return NULL;
 426
 427         sock_init_data(sock, sk);
 428         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 429
 430         sk->sk_destruct = sco_sock_destruct;
 431         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 432
 433         sock_reset_flag(sk, SOCK_ZAPPED);
 434
 435         sk->sk_protocol = proto;
 436         sk->sk_state    = BT_OPEN;
 437
 438         sco_sock_init_timer(sk);
 439
 440         bt_sock_link(&sco_sk_list, sk);
 441         return sk;
 442 }
 443
 444 static int sco_sock_create(struct socket *sock, int protocol)
 445 {
 446         struct sock *sk;
 447
 448         BT_DBG("sock %p", sock);
 449
 450         sock->state = SS_UNCONNECTED;
 451
 452         if (sock->type != SOCK_SEQPACKET)
 453                 return -ESOCKTNOSUPPORT;
 454
 455         sock->ops = &sco_sock_ops;
 456
 457         if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
 458                 return -ENOMEM;
 459
 460         sco_sock_init(sk, NULL);
 461         return 0;
 462 }
 463
 464 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 465 {
 466         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 467         struct sock *sk = sock->sk;
 468         bdaddr_t *src = &sa->sco_bdaddr;
 469         int err = 0;
 470
 471         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 472
 473         if (!addr || addr->sa_family != AF_BLUETOOTH)
 474                 return -EINVAL;
 475
 476         lock_sock(sk);
 477
 478         if (sk->sk_state != BT_OPEN) {
 479                 err = -EBADFD;
 480                 goto done;
 481         }
 482
 483         write_lock_bh(&sco_sk_list.lock);
 484
 485         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 486                 err = -EADDRINUSE;
 487         } else {
 488                 /* Save source address */
 489                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 490                 sk->sk_state = BT_BOUND;
 491         }
 492
 493         write_unlock_bh(&sco_sk_list.lock);
 494
 495 done:
 496         release_sock(sk);
 497         return err;
 498 }
 499
 500 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 501 {
 502         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 503         struct sock *sk = sock->sk;
 504         int err = 0;
 505
 506
 507         BT_DBG("sk %p", sk);
 508
 509         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 510                 return -EINVAL;
 511
 512         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 513                 return -EBADFD;
 514
 515         if (sk->sk_type != SOCK_SEQPACKET)
 516                 return -EINVAL;
 517
 518         lock_sock(sk);
 519
 520         /* Set destination address and psm */
 521         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 522
 523         if ((err = sco_connect(sk)))
 524                 goto done;
 525
 526         err = bt_sock_wait_state(sk, BT_CONNECTED,
 527                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 528
 529 done:
 530         release_sock(sk);
 531         return err;
 532 }
 533
 534 static int sco_sock_listen(struct socket *sock, int backlog)
 535 {
 536         struct sock *sk = sock->sk;
 537         int err = 0;
 538
 539         BT_DBG("sk %p backlog %d", sk, backlog);
 540
 541         lock_sock(sk);
 542
 543         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 544                 err = -EBADFD;
 545                 goto done;
 546         }
 547
 548         sk->sk_max_ack_backlog = backlog;
 549         sk->sk_ack_backlog = 0;
 550         sk->sk_state = BT_LISTEN;
 551
 552 done:
 553         release_sock(sk);
 554         return err;
 555 }
 556
 557 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 558 {
 559         DECLARE_WAITQUEUE(wait, current);
 560         struct sock *sk = sock->sk, *ch;
 561         long timeo;
 562         int err = 0;
 563
 564         lock_sock(sk);
 565
 566         if (sk->sk_state != BT_LISTEN) {
 567                 err = -EBADFD;
 568                 goto done;
 569         }
 570
 571         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 572
 573         BT_DBG("sk %p timeo %ld", sk, timeo);
 574
 575         /* Wait for an incoming connection. (wake-one). */
 576         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 577         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 578                 set_current_state(TASK_INTERRUPTIBLE);
 579                 if (!timeo) {
 580                         err = -EAGAIN;
 581                         break;
 582                 }
 583
 584                 release_sock(sk);
 585                 timeo = schedule_timeout(timeo);
 586                 lock_sock(sk);
 587
 588                 if (sk->sk_state != BT_LISTEN) {
 589                         err = -EBADFD;
 590                         break;
 591                 }
 592
 593                 if (signal_pending(current)) {
 594                         err = sock_intr_errno(timeo);
 595                         break;
 596                 }
 597         }
 598         set_current_state(TASK_RUNNING);
 599         remove_wait_queue(sk->sk_sleep, &wait);
 600
 601         if (err)
 602                 goto done;
 603
 604         newsock->state = SS_CONNECTED;
 605
 606         BT_DBG("new socket %p", ch);
 607
 608 done:
 609         release_sock(sk);
 610         return err;
 611 }
 612
 613 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 614 {
 615         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 616         struct sock *sk = sock->sk;
 617
 618         BT_DBG("sock %p, sk %p", sock, sk);
 619
 620         addr->sa_family = AF_BLUETOOTH;
 621         *len = sizeof(struct sockaddr_sco);
 622
 623         if (peer)
 624                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 625         else
 626                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 627
 628         return 0;
 629 }
 630
 631 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 632                             struct msghdr *msg, size_t len)
 633 {
 634         struct sock *sk = sock->sk;
 635         int err = 0;
 636
 637         BT_DBG("sock %p, sk %p", sock, sk);
 638
 639         err = sock_error(sk);
 640         if (err)
 641                 return err;
 642
 643         if (msg->msg_flags & MSG_OOB)
 644                 return -EOPNOTSUPP;
 645
 646         lock_sock(sk);
 647
 648         if (sk->sk_state == BT_CONNECTED)
 649                 err = sco_send_frame(sk, msg, len);
 650         else
 651                 err = -ENOTCONN;
 652
 653         release_sock(sk);
 654         return err;
 655 }
 656
 657 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 658 {
 659         struct sock *sk = sock->sk;
 660         int err = 0;
 661
 662         BT_DBG("sk %p", sk);
 663
 664         lock_sock(sk);
 665
 666         switch (optname) {
 667         default:
 668                 err = -ENOPROTOOPT;
 669                 break;
 670         }
 671
 672         release_sock(sk);
 673         return err;
 674 }
 675
 676 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 677 {
 678         struct sock *sk = sock->sk;
 679         struct sco_options opts;
 680         struct sco_conninfo cinfo;
 681         int len, err = 0;
 682
 683         BT_DBG("sk %p", sk);
 684
 685         if (get_user(len, optlen))
 686                 return -EFAULT;
 687
 688         lock_sock(sk);
 689
 690         switch (optname) {
 691         case SCO_OPTIONS:
 692                 if (sk->sk_state != BT_CONNECTED) {
 693                         err = -ENOTCONN;
 694                         break;
 695                 }
 696
 697                 opts.mtu = sco_pi(sk)->conn->mtu;
 698
 699                 BT_DBG("mtu %d", opts.mtu);
 700
 701                 len = min_t(unsigned int, len, sizeof(opts));
 702                 if (copy_to_user(optval, (char *)&opts, len))
 703                         err = -EFAULT;
 704
 705                 break;
 706
 707         case SCO_CONNINFO:
 708                 if (sk->sk_state != BT_CONNECTED) {
 709                         err = -ENOTCONN;
 710                         break;
 711                 }
 712
 713                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 714                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 715
 716                 len = min_t(unsigned int, len, sizeof(cinfo));
 717                 if (copy_to_user(optval, (char *)&cinfo, len))
 718                         err = -EFAULT;
 719
 720                 break;
 721
 722         default:
 723                 err = -ENOPROTOOPT;
 724                 break;
 725         }
 726
 727         release_sock(sk);
 728         return err;
 729 }
 730
 731 static int sco_sock_release(struct socket *sock)
 732 {
 733         struct sock *sk = sock->sk;
 734         int err = 0;
 735
 736         BT_DBG("sock %p, sk %p", sock, sk);
 737
 738         if (!sk)
 739                 return 0;
 740
 741         sco_sock_close(sk);
 742
 743         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 744                 lock_sock(sk);
 745                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 746                 release_sock(sk);
 747         }
 748
 749         sock_orphan(sk);
 750         sco_sock_kill(sk);
 751         return err;
 752 }
 753
 754 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 755 {
 756         BT_DBG("conn %p", conn);
 757
 758         sco_pi(sk)->conn = conn;
 759         conn->sk = sk;
 760
 761         if (parent)
 762                 bt_accept_enqueue(parent, sk);
 763 }
 764
 765 /* Delete channel.
 766  * Must be called on the locked socket. */
 767 static void sco_chan_del(struct sock *sk, int err)
 768 {
 769         struct sco_conn *conn;
 770
 771         conn = sco_pi(sk)->conn;
 772
 773         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 774
 775         if (conn) {
 776                 sco_conn_lock(conn);
 777                 conn->sk = NULL;
 778                 sco_pi(sk)->conn = NULL;
 779                 sco_conn_unlock(conn);
 780                 hci_conn_put(conn->hcon);
 781         }
 782
 783         sk->sk_state = BT_CLOSED;
 784         sk->sk_err   = err;
 785         sk->sk_state_change(sk);
 786
 787         sock_set_flag(sk, SOCK_ZAPPED);
 788 }
 789
 790 static void sco_conn_ready(struct sco_conn *conn)
 791 {
 792         struct sock *parent, *sk;
 793
 794         BT_DBG("conn %p", conn);
 795
 796         sco_conn_lock(conn);
 797
 798         if ((sk = conn->sk)) {
 799                 sco_sock_clear_timer(sk);
 800                 bh_lock_sock(sk);
 801                 sk->sk_state = BT_CONNECTED;
 802                 sk->sk_state_change(sk);
 803                 bh_unlock_sock(sk);
 804         } else {
 805                 parent = sco_get_sock_listen(conn->src);
 806                 if (!parent)
 807                         goto done;
 808
 809                 bh_lock_sock(parent);
 810
 811                 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
 812                 if (!sk) {
 813                         bh_unlock_sock(parent);
 814                         goto done;
 815                 }
 816
 817                 sco_sock_init(sk, parent);
 818
 819                 bacpy(&bt_sk(sk)->src, conn->src);
 820                 bacpy(&bt_sk(sk)->dst, conn->dst);
 821
 822                 hci_conn_hold(conn->hcon);
 823                 __sco_chan_add(conn, sk, parent);
 824
 825                 sk->sk_state = BT_CONNECTED;
 826
 827                 /* Wake up parent */
 828                 parent->sk_data_ready(parent, 1);
 829
 830                 bh_unlock_sock(parent);
 831         }
 832
 833 done:
 834         sco_conn_unlock(conn);
 835 }
 836
 837 /* ----- SCO interface with lower layer (HCI) ----- */
 838 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 839 {
 840         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 841
 842         /* Always accept connection */
 843         return HCI_LM_ACCEPT;
 844 }
 845
 846 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 847 {
 848         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 849
 850         if (hcon->type != SCO_LINK)
 851                 return 0;
 852
 853         if (!status) {
 854                 struct sco_conn *conn;
 855
 856                 conn = sco_conn_add(hcon, status);
 857                 if (conn)
 858                         sco_conn_ready(conn);
 859         } else
 860                 sco_conn_del(hcon, bt_err(status));
 861
 862         return 0;
 863 }
 864
 865 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
 866 {
 867         BT_DBG("hcon %p reason %d", hcon, reason);
 868
 869         if (hcon->type != SCO_LINK)
 870                 return 0;
 871
 872         sco_conn_del(hcon, bt_err(reason));
 873         return 0;
 874 }
 875
 876 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 877 {
 878         struct sco_conn *conn = hcon->sco_data;
 879
 880         if (!conn)
 881                 goto drop;
 882
 883         BT_DBG("conn %p len %d", conn, skb->len);
 884
 885         if (skb->len) {
 886                 sco_recv_frame(conn, skb);
 887                 return 0;
 888         }
 889
 890 drop:
 891         kfree_skb(skb);
 892         return 0;
 893 }
 894
 895 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
 896 {
 897         struct sock *sk;
 898         struct hlist_node *node;
 899         char *str = buf;
 900
 901         read_lock_bh(&sco_sk_list.lock);
 902
 903         sk_for_each(sk, node, &sco_sk_list.head) {
 904                 str += sprintf(str, "%s %s %d\n",
 905                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 906                                 sk->sk_state);
 907         }
 908
 909         read_unlock_bh(&sco_sk_list.lock);
 910
 911         return (str - buf);
 912 }
 913
 914 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
 915
 916 static const struct proto_ops sco_sock_ops = {
 917         .family         = PF_BLUETOOTH,
 918         .owner          = THIS_MODULE,
 919         .release        = sco_sock_release,
 920         .bind           = sco_sock_bind,
 921         .connect        = sco_sock_connect,
 922         .listen         = sco_sock_listen,
 923         .accept         = sco_sock_accept,
 924         .getname        = sco_sock_getname,
 925         .sendmsg        = sco_sock_sendmsg,
 926         .recvmsg        = bt_sock_recvmsg,
 927         .poll           = bt_sock_poll,
 928         .ioctl          = sock_no_ioctl,
 929         .mmap           = sock_no_mmap,
 930         .socketpair     = sock_no_socketpair,
 931         .shutdown       = sock_no_shutdown,
 932         .setsockopt     = sco_sock_setsockopt,
 933         .getsockopt     = sco_sock_getsockopt
 934 };
 935
 936 static struct net_proto_family sco_sock_family_ops = {
 937         .family = PF_BLUETOOTH,
 938         .owner  = THIS_MODULE,
 939         .create = sco_sock_create,
 940 };
 941
 942 static struct hci_proto sco_hci_proto = {
 943         .name           = "SCO",
 944         .id             = HCI_PROTO_SCO,
 945         .connect_ind    = sco_connect_ind,
 946         .connect_cfm    = sco_connect_cfm,
 947         .disconn_ind    = sco_disconn_ind,
 948         .recv_scodata   = sco_recv_scodata
 949 };
 950
 951 static int __init sco_init(void)
 952 {
 953         int err;
 954
 955         err = proto_register(&sco_proto, 0);
 956         if (err < 0)
 957                 return err;
 958
 959         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
 960         if (err < 0) {
 961                 BT_ERR("SCO socket registration failed");
 962                 goto error;
 963         }
 964
 965         err = hci_register_proto(&sco_hci_proto);
 966         if (err < 0) {
 967                 BT_ERR("SCO protocol registration failed");
 968                 bt_sock_unregister(BTPROTO_SCO);
 969                 goto error;
 970         }
 971
 972         class_create_file(bt_class, &class_attr_sco);
 973
 974         BT_INFO("SCO (Voice Link) ver %s", VERSION);
 975         BT_INFO("SCO socket layer initialized");
 976
 977         return 0;
 978
 979 error:
 980         proto_unregister(&sco_proto);
 981         return err;
 982 }
 983
 984 static void __exit sco_exit(void)
 985 {
 986         class_remove_file(bt_class, &class_attr_sco);
 987
 988         if (bt_sock_unregister(BTPROTO_SCO) < 0)
 989                 BT_ERR("SCO socket unregistration failed");
 990
 991         if (hci_unregister_proto(&sco_hci_proto) < 0)
 992                 BT_ERR("SCO protocol unregistration failed");
 993
 994         proto_unregister(&sco_proto);
 995 }
 996
 997 module_init(sco_init);
 998 module_exit(sco_exit);
 999
1000 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1001 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1002 MODULE_VERSION(VERSION);
1003 MODULE_LICENSE("GPL");
1004 MODULE_ALIAS("bt-proto-2");