git.oblomov.eu Git - linux-2.6/blob - net/bluetooth/sco.c

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