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