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