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