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/config.h>
  28 #include <linux/module.h>
  29
  30 #include <linux/types.h>
  31 #include <linux/errno.h>
  32 #include <linux/kernel.h>
  33 #include <linux/sched.h>
  34 #include <linux/slab.h>
  35 #include <linux/poll.h>
  36 #include <linux/fcntl.h>
  37 #include <linux/init.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/socket.h>
  40 #include <linux/skbuff.h>
  41 #include <linux/device.h>
  42 #include <linux/list.h>
  43 #include <net/sock.h>
  44
  45 #include <asm/system.h>
  46 #include <asm/uaccess.h>
  47
  48 #include <net/bluetooth/bluetooth.h>
  49 #include <net/bluetooth/hci_core.h>
  50 #include <net/bluetooth/sco.h>
  51
  52 #ifndef CONFIG_BT_SCO_DEBUG
  53 #undef  BT_DBG
  54 #define BT_DBG(D...)
  55 #endif
  56
  57 #define VERSION "0.5"
  58
  59 static struct proto_ops sco_sock_ops;
  60
  61 static struct bt_sock_list sco_sk_list = {
  62         .lock = RW_LOCK_UNLOCKED
  63 };
  64
  65 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  66 static void sco_chan_del(struct sock *sk, int err);
  67
  68 static int  sco_conn_del(struct hci_conn *conn, int err);
  69
  70 static void sco_sock_close(struct sock *sk);
  71 static void sco_sock_kill(struct sock *sk);
  72
  73 /* ---- SCO timers ---- */
  74 static void sco_sock_timeout(unsigned long arg)
  75 {
  76         struct sock *sk = (struct sock *) arg;
  77
  78         BT_DBG("sock %p state %d", sk, sk->sk_state);
  79
  80         bh_lock_sock(sk);
  81         sk->sk_err = ETIMEDOUT;
  82         sk->sk_state_change(sk);
  83         bh_unlock_sock(sk);
  84
  85         sco_sock_kill(sk);
  86         sock_put(sk);
  87 }
  88
  89 static void sco_sock_set_timer(struct sock *sk, long timeout)
  90 {
  91         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  92         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  93 }
  94
  95 static void sco_sock_clear_timer(struct sock *sk)
  96 {
  97         BT_DBG("sock %p state %d", sk, sk->sk_state);
  98         sk_stop_timer(sk, &sk->sk_timer);
  99 }
 100
 101 static void sco_sock_init_timer(struct sock *sk)
 102 {
 103         init_timer(&sk->sk_timer);
 104         sk->sk_timer.function = sco_sock_timeout;
 105         sk->sk_timer.data = (unsigned long)sk;
 106 }
 107
 108 /* ---- SCO connections ---- */
 109 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
 110 {
 111         struct hci_dev *hdev = hcon->hdev;
 112         struct sco_conn *conn;
 113
 114         if ((conn = hcon->sco_data))
 115                 return conn;
 116
 117         if (status)
 118                 return conn;
 119
 120         if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
 121                 return NULL;
 122         memset(conn, 0, sizeof(struct sco_conn));
 123
 124         spin_lock_init(&conn->lock);
 125
 126         hcon->sco_data = conn;
 127         conn->hcon = hcon;
 128
 129         conn->src = &hdev->bdaddr;
 130         conn->dst = &hcon->dst;
 131
 132         if (hdev->sco_mtu > 0)
 133                 conn->mtu = hdev->sco_mtu;
 134         else
 135                 conn->mtu = 60;
 136
 137         BT_DBG("hcon %p conn %p", hcon, conn);
 138         return conn;
 139 }
 140
 141 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 142 {
 143         struct sock *sk = NULL;
 144         sco_conn_lock(conn);
 145         sk = conn->sk;
 146         sco_conn_unlock(conn);
 147         return sk;
 148 }
 149
 150 static int sco_conn_del(struct hci_conn *hcon, int err)
 151 {
 152         struct sco_conn *conn;
 153         struct sock *sk;
 154
 155         if (!(conn = hcon->sco_data))
 156                 return 0;
 157
 158         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 159
 160         /* Kill socket */
 161         if ((sk = sco_chan_get(conn))) {
 162                 bh_lock_sock(sk);
 163                 sco_sock_clear_timer(sk);
 164                 sco_chan_del(sk, err);
 165                 bh_unlock_sock(sk);
 166                 sco_sock_kill(sk);
 167         }
 168
 169         hcon->sco_data = NULL;
 170         kfree(conn);
 171         return 0;
 172 }
 173
 174 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 175 {
 176         int err = 0;
 177
 178         sco_conn_lock(conn);
 179         if (conn->sk) {
 180                 err = -EBUSY;
 181         } else {
 182                 __sco_chan_add(conn, sk, parent);
 183         }
 184         sco_conn_unlock(conn);
 185         return err;
 186 }
 187
 188 static int sco_connect(struct sock *sk)
 189 {
 190         bdaddr_t *src = &bt_sk(sk)->src;
 191         bdaddr_t *dst = &bt_sk(sk)->dst;
 192         struct sco_conn *conn;
 193         struct hci_conn *hcon;
 194         struct hci_dev  *hdev;
 195         int err = 0;
 196
 197         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 198
 199         if (!(hdev = hci_get_route(dst, src)))
 200                 return -EHOSTUNREACH;
 201
 202         hci_dev_lock_bh(hdev);
 203
 204         err = -ENOMEM;
 205
 206         hcon = hci_connect(hdev, SCO_LINK, dst);
 207         if (!hcon)
 208                 goto done;
 209
 210         conn = sco_conn_add(hcon, 0);
 211         if (!conn) {
 212                 hci_conn_put(hcon);
 213                 goto done;
 214         }
 215
 216         /* Update source addr of the socket */
 217         bacpy(src, conn->src);
 218
 219         err = sco_chan_add(conn, sk, NULL);
 220         if (err)
 221                 goto done;
 222
 223         if (hcon->state == BT_CONNECTED) {
 224                 sco_sock_clear_timer(sk);
 225                 sk->sk_state = BT_CONNECTED;
 226         } else {
 227                 sk->sk_state = BT_CONNECT;
 228                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 229         }
 230 done:
 231         hci_dev_unlock_bh(hdev);
 232         hci_dev_put(hdev);
 233         return err;
 234 }
 235
 236 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 237 {
 238         struct sco_conn *conn = sco_pi(sk)->conn;
 239         struct sk_buff *skb;
 240         int err, count;
 241
 242         /* Check outgoing MTU */
 243         if (len > conn->mtu)
 244                 return -EINVAL;
 245
 246         BT_DBG("sk %p len %d", sk, len);
 247
 248         count = min_t(unsigned int, conn->mtu, len);
 249         if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
 250                 return err;
 251
 252         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 253                 err = -EFAULT;
 254                 goto fail;
 255         }
 256
 257         if ((err = hci_send_sco(conn->hcon, skb)) < 0)
 258                 goto fail;
 259
 260         return count;
 261
 262 fail:
 263         kfree_skb(skb);
 264         return err;
 265 }
 266
 267 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 268 {
 269         struct sock *sk = sco_chan_get(conn);
 270
 271         if (!sk)
 272                 goto drop;
 273
 274         BT_DBG("sk %p len %d", sk, skb->len);
 275
 276         if (sk->sk_state != BT_CONNECTED)
 277                 goto drop;
 278
 279         if (!sock_queue_rcv_skb(sk, skb))
 280                 return;
 281
 282 drop:
 283         kfree_skb(skb);
 284         return;
 285 }
 286
 287 /* -------- Socket interface ---------- */
 288 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
 289 {
 290         struct sock *sk;
 291         struct hlist_node *node;
 292
 293         sk_for_each(sk, node, &sco_sk_list.head)
 294                 if (!bacmp(&bt_sk(sk)->src, ba))
 295                         goto found;
 296         sk = NULL;
 297 found:
 298         return sk;
 299 }
 300
 301 /* Find socket listening on source bdaddr.
 302  * Returns closest match.
 303  */
 304 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 305 {
 306         struct sock *sk = NULL, *sk1 = NULL;
 307         struct hlist_node *node;
 308
 309         read_lock(&sco_sk_list.lock);
 310
 311         sk_for_each(sk, node, &sco_sk_list.head) {
 312                 if (sk->sk_state != BT_LISTEN)
 313                         continue;
 314
 315                 /* Exact match. */
 316                 if (!bacmp(&bt_sk(sk)->src, src))
 317                         break;
 318
 319                 /* Closest match */
 320                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 321                         sk1 = sk;
 322         }
 323
 324         read_unlock(&sco_sk_list.lock);
 325
 326         return node ? sk : sk1;
 327 }
 328
 329 static void sco_sock_destruct(struct sock *sk)
 330 {
 331         BT_DBG("sk %p", sk);
 332
 333         skb_queue_purge(&sk->sk_receive_queue);
 334         skb_queue_purge(&sk->sk_write_queue);
 335 }
 336
 337 static void sco_sock_cleanup_listen(struct sock *parent)
 338 {
 339         struct sock *sk;
 340
 341         BT_DBG("parent %p", parent);
 342
 343         /* Close not yet accepted channels */
 344         while ((sk = bt_accept_dequeue(parent, NULL))) {
 345                 sco_sock_close(sk);
 346                 sco_sock_kill(sk);
 347         }
 348
 349         parent->sk_state  = BT_CLOSED;
 350         sock_set_flag(parent, SOCK_ZAPPED);
 351 }
 352
 353 /* Kill socket (only if zapped and orphan)
 354  * Must be called on unlocked socket.
 355  */
 356 static void sco_sock_kill(struct sock *sk)
 357 {
 358         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 359                 return;
 360
 361         BT_DBG("sk %p state %d", sk, sk->sk_state);
 362
 363         /* Kill poor orphan */
 364         bt_sock_unlink(&sco_sk_list, sk);
 365         sock_set_flag(sk, SOCK_DEAD);
 366         sock_put(sk);
 367 }
 368
 369 /* Close socket.
 370  * Must be called on unlocked socket.
 371  */
 372 static void sco_sock_close(struct sock *sk)
 373 {
 374         struct sco_conn *conn;
 375
 376         sco_sock_clear_timer(sk);
 377
 378         lock_sock(sk);
 379
 380         conn = sco_pi(sk)->conn;
 381
 382         BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
 383
 384         switch (sk->sk_state) {
 385         case BT_LISTEN:
 386                 sco_sock_cleanup_listen(sk);
 387                 break;
 388
 389         case BT_CONNECTED:
 390         case BT_CONFIG:
 391         case BT_CONNECT:
 392         case BT_DISCONN:
 393                 sco_chan_del(sk, ECONNRESET);
 394                 break;
 395
 396         default:
 397                 sock_set_flag(sk, SOCK_ZAPPED);
 398                 break;
 399         };
 400
 401         release_sock(sk);
 402
 403         sco_sock_kill(sk);
 404 }
 405
 406 static void sco_sock_init(struct sock *sk, struct sock *parent)
 407 {
 408         BT_DBG("sk %p", sk);
 409
 410         if (parent)
 411                 sk->sk_type = parent->sk_type;
 412 }
 413
 414 static struct proto sco_proto = {
 415         .name           = "SCO",
 416         .owner          = THIS_MODULE,
 417         .obj_size       = sizeof(struct sco_pinfo)
 418 };
 419
 420 static struct sock *sco_sock_alloc(struct socket *sock, int proto, gfp_t prio)
 421 {
 422         struct sock *sk;
 423
 424         sk = sk_alloc(PF_BLUETOOTH, prio, &sco_proto, 1);
 425         if (!sk)
 426                 return NULL;
 427
 428         sock_init_data(sock, sk);
 429         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 430
 431         sk->sk_destruct = sco_sock_destruct;
 432         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 433
 434         sock_reset_flag(sk, SOCK_ZAPPED);
 435
 436         sk->sk_protocol = proto;
 437         sk->sk_state    = BT_OPEN;
 438
 439         sco_sock_init_timer(sk);
 440
 441         bt_sock_link(&sco_sk_list, sk);
 442         return sk;
 443 }
 444
 445 static int sco_sock_create(struct socket *sock, int protocol)
 446 {
 447         struct sock *sk;
 448
 449         BT_DBG("sock %p", sock);
 450
 451         sock->state = SS_UNCONNECTED;
 452
 453         if (sock->type != SOCK_SEQPACKET)
 454                 return -ESOCKTNOSUPPORT;
 455
 456         sock->ops = &sco_sock_ops;
 457
 458         if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
 459                 return -ENOMEM;
 460
 461         sco_sock_init(sk, NULL);
 462         return 0;
 463 }
 464
 465 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 466 {
 467         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 468         struct sock *sk = sock->sk;
 469         bdaddr_t *src = &sa->sco_bdaddr;
 470         int err = 0;
 471
 472         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 473
 474         if (!addr || addr->sa_family != AF_BLUETOOTH)
 475                 return -EINVAL;
 476
 477         lock_sock(sk);
 478
 479         if (sk->sk_state != BT_OPEN) {
 480                 err = -EBADFD;
 481                 goto done;
 482         }
 483
 484         write_lock_bh(&sco_sk_list.lock);
 485
 486         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 487                 err = -EADDRINUSE;
 488         } else {
 489                 /* Save source address */
 490                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 491                 sk->sk_state = BT_BOUND;
 492         }
 493
 494         write_unlock_bh(&sco_sk_list.lock);
 495
 496 done:
 497         release_sock(sk);
 498         return err;
 499 }
 500
 501 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 502 {
 503         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 504         struct sock *sk = sock->sk;
 505         int err = 0;
 506
 507
 508         BT_DBG("sk %p", sk);
 509
 510         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 511                 return -EINVAL;
 512
 513         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 514                 return -EBADFD;
 515
 516         if (sk->sk_type != SOCK_SEQPACKET)
 517                 return -EINVAL;
 518
 519         lock_sock(sk);
 520
 521         /* Set destination address and psm */
 522         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 523
 524         if ((err = sco_connect(sk)))
 525                 goto done;
 526
 527         err = bt_sock_wait_state(sk, BT_CONNECTED,
 528                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 529
 530 done:
 531         release_sock(sk);
 532         return err;
 533 }
 534
 535 static int sco_sock_listen(struct socket *sock, int backlog)
 536 {
 537         struct sock *sk = sock->sk;
 538         int err = 0;
 539
 540         BT_DBG("sk %p backlog %d", sk, backlog);
 541
 542         lock_sock(sk);
 543
 544         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 545                 err = -EBADFD;
 546                 goto done;
 547         }
 548
 549         sk->sk_max_ack_backlog = backlog;
 550         sk->sk_ack_backlog = 0;
 551         sk->sk_state = BT_LISTEN;
 552
 553 done:
 554         release_sock(sk);
 555         return err;
 556 }
 557
 558 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 559 {
 560         DECLARE_WAITQUEUE(wait, current);
 561         struct sock *sk = sock->sk, *ch;
 562         long timeo;
 563         int err = 0;
 564
 565         lock_sock(sk);
 566
 567         if (sk->sk_state != BT_LISTEN) {
 568                 err = -EBADFD;
 569                 goto done;
 570         }
 571
 572         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 573
 574         BT_DBG("sk %p timeo %ld", sk, timeo);
 575
 576         /* Wait for an incoming connection. (wake-one). */
 577         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 578         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 579                 set_current_state(TASK_INTERRUPTIBLE);
 580                 if (!timeo) {
 581                         err = -EAGAIN;
 582                         break;
 583                 }
 584
 585                 release_sock(sk);
 586                 timeo = schedule_timeout(timeo);
 587                 lock_sock(sk);
 588
 589                 if (sk->sk_state != BT_LISTEN) {
 590                         err = -EBADFD;
 591                         break;
 592                 }
 593
 594                 if (signal_pending(current)) {
 595                         err = sock_intr_errno(timeo);
 596                         break;
 597                 }
 598         }
 599         set_current_state(TASK_RUNNING);
 600         remove_wait_queue(sk->sk_sleep, &wait);
 601
 602         if (err)
 603                 goto done;
 604
 605         newsock->state = SS_CONNECTED;
 606
 607         BT_DBG("new socket %p", ch);
 608
 609 done:
 610         release_sock(sk);
 611         return err;
 612 }
 613
 614 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 615 {
 616         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 617         struct sock *sk = sock->sk;
 618
 619         BT_DBG("sock %p, sk %p", sock, sk);
 620
 621         addr->sa_family = AF_BLUETOOTH;
 622         *len = sizeof(struct sockaddr_sco);
 623
 624         if (peer)
 625                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 626         else
 627                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 628
 629         return 0;
 630 }
 631
 632 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 633                             struct msghdr *msg, size_t len)
 634 {
 635         struct sock *sk = sock->sk;
 636         int err = 0;
 637
 638         BT_DBG("sock %p, sk %p", sock, sk);
 639
 640         if (sk->sk_err)
 641                 return sock_error(sk);
 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 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");