net/bluetooth/rfcomm/sock.c

   1 /*
   2    RFCOMM implementation for Linux Bluetooth stack (BlueZ).
   3    Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
   4    Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License version 2 as
   8    published by the Free Software Foundation;
   9
  10    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  12    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  13    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  14    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  15    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18
  19    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  20    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  21    SOFTWARE IS DISCLAIMED.
  22 */
  23
  24 /*
  25  * RFCOMM sockets.
  26  *
  27  * $Id: sock.c,v 1.24 2002/10/03 01:00:34 maxk Exp $
  28  */
  29
  30 #include <linux/config.h>
  31 #include <linux/module.h>
  32
  33 #include <linux/types.h>
  34 #include <linux/errno.h>
  35 #include <linux/kernel.h>
  36 #include <linux/major.h>
  37 #include <linux/sched.h>
  38 #include <linux/slab.h>
  39 #include <linux/poll.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/init.h>
  42 #include <linux/interrupt.h>
  43 #include <linux/socket.h>
  44 #include <linux/skbuff.h>
  45 #include <linux/list.h>
  46 #include <linux/proc_fs.h>
  47 #include <linux/seq_file.h>
  48 #include <net/sock.h>
  49
  50 #include <asm/system.h>
  51 #include <asm/uaccess.h>
  52
  53 #include <net/bluetooth/bluetooth.h>
  54 #include <net/bluetooth/rfcomm.h>
  55
  56 #ifndef CONFIG_BT_RFCOMM_DEBUG
  57 #undef  BT_DBG
  58 #define BT_DBG(D...)
  59 #endif
  60
  61 static struct proto_ops rfcomm_sock_ops;
  62
  63 static struct bt_sock_list rfcomm_sk_list = {
  64         .lock = RW_LOCK_UNLOCKED
  65 };
  66
  67 static void rfcomm_sock_close(struct sock *sk);
  68 static void rfcomm_sock_kill(struct sock *sk);
  69
  70 /* ---- DLC callbacks ----
  71  *
  72  * called under rfcomm_dlc_lock()
  73  */
  74 static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
  75 {
  76         struct sock *sk = d->owner;
  77         if (!sk)
  78                 return;
  79
  80         atomic_add(skb->len, &sk->sk_rmem_alloc);
  81         skb_queue_tail(&sk->sk_receive_queue, skb);
  82         sk->sk_data_ready(sk, skb->len);
  83
  84         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
  85                 rfcomm_dlc_throttle(d);
  86 }
  87
  88 static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
  89 {
  90         struct sock *sk = d->owner, *parent;
  91         if (!sk)
  92                 return;
  93
  94         BT_DBG("dlc %p state %ld err %d", d, d->state, err);
  95
  96         bh_lock_sock(sk);
  97
  98         if (err)
  99                 sk->sk_err = err;
 100         sk->sk_state = d->state;
 101
 102         parent = bt_sk(sk)->parent;
 103         if (!parent) {
 104                 if (d->state == BT_CONNECTED)
 105                         rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
 106                 sk->sk_state_change(sk);
 107         } else
 108                 parent->sk_data_ready(parent, 0);
 109
 110         bh_unlock_sock(sk);
 111 }
 112
 113 /* ---- Socket functions ---- */
 114 static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
 115 {
 116         struct sock *sk = NULL;
 117         struct hlist_node *node;
 118
 119         sk_for_each(sk, node, &rfcomm_sk_list.head) {
 120                 if (rfcomm_pi(sk)->channel == channel &&
 121                                 !bacmp(&bt_sk(sk)->src, src))
 122                         break;
 123         }
 124
 125         return node ? sk : NULL;
 126 }
 127
 128 /* Find socket with channel and source bdaddr.
 129  * Returns closest match.
 130  */
 131 static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
 132 {
 133         struct sock *sk = NULL, *sk1 = NULL;
 134         struct hlist_node *node;
 135
 136         sk_for_each(sk, node, &rfcomm_sk_list.head) {
 137                 if (state && sk->sk_state != state)
 138                         continue;
 139
 140                 if (rfcomm_pi(sk)->channel == channel) {
 141                         /* Exact match. */
 142                         if (!bacmp(&bt_sk(sk)->src, src))
 143                                 break;
 144
 145                         /* Closest match */
 146                         if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 147                                 sk1 = sk;
 148                 }
 149         }
 150         return node ? sk : sk1;
 151 }
 152
 153 /* Find socket with given address (channel, src).
 154  * Returns locked socket */
 155 static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
 156 {
 157         struct sock *s;
 158         read_lock(&rfcomm_sk_list.lock);
 159         s = __rfcomm_get_sock_by_channel(state, channel, src);
 160         if (s) bh_lock_sock(s);
 161         read_unlock(&rfcomm_sk_list.lock);
 162         return s;
 163 }
 164
 165 static void rfcomm_sock_destruct(struct sock *sk)
 166 {
 167         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
 168
 169         BT_DBG("sk %p dlc %p", sk, d);
 170
 171         skb_queue_purge(&sk->sk_receive_queue);
 172         skb_queue_purge(&sk->sk_write_queue);
 173
 174         rfcomm_dlc_lock(d);
 175         rfcomm_pi(sk)->dlc = NULL;
 176
 177         /* Detach DLC if it's owned by this socket */
 178         if (d->owner == sk)
 179                 d->owner = NULL;
 180         rfcomm_dlc_unlock(d);
 181
 182         rfcomm_dlc_put(d);
 183
 184         if (sk->sk_protinfo)
 185                 kfree(sk->sk_protinfo);
 186 }
 187
 188 static void rfcomm_sock_cleanup_listen(struct sock *parent)
 189 {
 190         struct sock *sk;
 191
 192         BT_DBG("parent %p", parent);
 193
 194         /* Close not yet accepted dlcs */
 195         while ((sk = bt_accept_dequeue(parent, NULL))) {
 196                 rfcomm_sock_close(sk);
 197                 rfcomm_sock_kill(sk);
 198         }
 199
 200         parent->sk_state  = BT_CLOSED;
 201         parent->sk_zapped = 1;
 202 }
 203
 204 /* Kill socket (only if zapped and orphan)
 205  * Must be called on unlocked socket.
 206  */
 207 static void rfcomm_sock_kill(struct sock *sk)
 208 {
 209         if (!sk->sk_zapped || sk->sk_socket)
 210                 return;
 211
 212         BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
 213
 214         /* Kill poor orphan */
 215         bt_sock_unlink(&rfcomm_sk_list, sk);
 216         sock_set_flag(sk, SOCK_DEAD);
 217         sock_put(sk);
 218 }
 219
 220 static void __rfcomm_sock_close(struct sock *sk)
 221 {
 222         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
 223
 224         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 225
 226         switch (sk->sk_state) {
 227         case BT_LISTEN:
 228                 rfcomm_sock_cleanup_listen(sk);
 229                 break;
 230
 231         case BT_CONNECT:
 232         case BT_CONNECT2:
 233         case BT_CONFIG:
 234         case BT_CONNECTED:
 235                 rfcomm_dlc_close(d, 0);
 236
 237         default:
 238                 sk->sk_zapped = 1;
 239                 break;
 240         }
 241 }
 242
 243 /* Close socket.
 244  * Must be called on unlocked socket.
 245  */
 246 static void rfcomm_sock_close(struct sock *sk)
 247 {
 248         lock_sock(sk);
 249         __rfcomm_sock_close(sk);
 250         release_sock(sk);
 251 }
 252
 253 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
 254 {
 255         BT_DBG("sk %p", sk);
 256
 257         if (parent)
 258                 sk->sk_type = parent->sk_type;
 259 }
 260
 261 static struct sock *rfcomm_sock_alloc(struct socket *sock, int proto, int prio)
 262 {
 263         struct rfcomm_dlc *d;
 264         struct sock *sk;
 265
 266         sk = bt_sock_alloc(sock, BTPROTO_RFCOMM, sizeof(struct rfcomm_pinfo), prio);
 267         if (!sk)
 268                 return NULL;
 269
 270         sk_set_owner(sk, THIS_MODULE);
 271
 272         d = rfcomm_dlc_alloc(prio);
 273         if (!d) {
 274                 sk_free(sk);
 275                 return NULL;
 276         }
 277         d->data_ready   = rfcomm_sk_data_ready;
 278         d->state_change = rfcomm_sk_state_change;
 279
 280         rfcomm_pi(sk)->dlc = d;
 281         d->owner = sk;
 282
 283         sk->sk_destruct = rfcomm_sock_destruct;
 284         sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
 285
 286         sk->sk_sndbuf   = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
 287         sk->sk_rcvbuf   = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
 288
 289         sk->sk_protocol = proto;
 290         sk->sk_state    = BT_OPEN;
 291
 292         bt_sock_link(&rfcomm_sk_list, sk);
 293
 294         BT_DBG("sk %p", sk);
 295         return sk;
 296 }
 297
 298 static int rfcomm_sock_create(struct socket *sock, int protocol)
 299 {
 300         struct sock *sk;
 301
 302         BT_DBG("sock %p", sock);
 303
 304         sock->state = SS_UNCONNECTED;
 305
 306         if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
 307                 return -ESOCKTNOSUPPORT;
 308
 309         sock->ops = &rfcomm_sock_ops;
 310
 311         if (!(sk = rfcomm_sock_alloc(sock, protocol, GFP_KERNEL)))
 312                 return -ENOMEM;
 313
 314         rfcomm_sock_init(sk, NULL);
 315         return 0;
 316 }
 317
 318 static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 319 {
 320         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
 321         struct sock *sk = sock->sk;
 322         int err = 0;
 323
 324         BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
 325
 326         if (!addr || addr->sa_family != AF_BLUETOOTH)
 327                 return -EINVAL;
 328
 329         lock_sock(sk);
 330
 331         if (sk->sk_state != BT_OPEN) {
 332                 err = -EBADFD;
 333                 goto done;
 334         }
 335
 336         write_lock_bh(&rfcomm_sk_list.lock);
 337
 338         if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
 339                 err = -EADDRINUSE;
 340         } else {
 341                 /* Save source address */
 342                 bacpy(&bt_sk(sk)->src, &sa->rc_bdaddr);
 343                 rfcomm_pi(sk)->channel = sa->rc_channel;
 344                 sk->sk_state = BT_BOUND;
 345         }
 346
 347         write_unlock_bh(&rfcomm_sk_list.lock);
 348
 349 done:
 350         release_sock(sk);
 351         return err;
 352 }
 353
 354 static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 355 {
 356         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
 357         struct sock *sk = sock->sk;
 358         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
 359         int err = 0;
 360
 361         BT_DBG("sk %p", sk);
 362
 363         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
 364                 return -EINVAL;
 365
 366         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 367                 return -EBADFD;
 368
 369         if (sk->sk_type != SOCK_STREAM)
 370                 return -EINVAL;
 371
 372         lock_sock(sk);
 373
 374         sk->sk_state = BT_CONNECT;
 375         bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
 376         rfcomm_pi(sk)->channel = sa->rc_channel;
 377
 378         err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
 379         if (!err)
 380                 err = bt_sock_wait_state(sk, BT_CONNECTED,
 381                                 sock_sndtimeo(sk, flags & O_NONBLOCK));
 382
 383         release_sock(sk);
 384         return err;
 385 }
 386
 387 int rfcomm_sock_listen(struct socket *sock, int backlog)
 388 {
 389         struct sock *sk = sock->sk;
 390         int err = 0;
 391
 392         BT_DBG("sk %p backlog %d", sk, backlog);
 393
 394         lock_sock(sk);
 395
 396         if (sk->sk_state != BT_BOUND) {
 397                 err = -EBADFD;
 398                 goto done;
 399         }
 400
 401         sk->sk_max_ack_backlog = backlog;
 402         sk->sk_ack_backlog = 0;
 403         sk->sk_state = BT_LISTEN;
 404
 405 done:
 406         release_sock(sk);
 407         return err;
 408 }
 409
 410 int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 411 {
 412         DECLARE_WAITQUEUE(wait, current);
 413         struct sock *sk = sock->sk, *nsk;
 414         long timeo;
 415         int err = 0;
 416
 417         lock_sock(sk);
 418
 419         if (sk->sk_state != BT_LISTEN) {
 420                 err = -EBADFD;
 421                 goto done;
 422         }
 423
 424         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 425
 426         BT_DBG("sk %p timeo %ld", sk, timeo);
 427
 428         /* Wait for an incoming connection. (wake-one). */
 429         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 430         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
 431                 set_current_state(TASK_INTERRUPTIBLE);
 432                 if (!timeo) {
 433                         err = -EAGAIN;
 434                         break;
 435                 }
 436
 437                 release_sock(sk);
 438                 timeo = schedule_timeout(timeo);
 439                 lock_sock(sk);
 440
 441                 if (sk->sk_state != BT_LISTEN) {
 442                         err = -EBADFD;
 443                         break;
 444                 }
 445
 446                 if (signal_pending(current)) {
 447                         err = sock_intr_errno(timeo);
 448                         break;
 449                 }
 450         }
 451         set_current_state(TASK_RUNNING);
 452         remove_wait_queue(sk->sk_sleep, &wait);
 453
 454         if (err)
 455                 goto done;
 456
 457         newsock->state = SS_CONNECTED;
 458
 459         BT_DBG("new socket %p", nsk);
 460
 461 done:
 462         release_sock(sk);
 463         return err;
 464 }
 465
 466 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 467 {
 468         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
 469         struct sock *sk = sock->sk;
 470
 471         BT_DBG("sock %p, sk %p", sock, sk);
 472
 473         sa->rc_family  = AF_BLUETOOTH;
 474         sa->rc_channel = rfcomm_pi(sk)->channel;
 475         if (peer)
 476                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
 477         else
 478                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
 479
 480         *len = sizeof(struct sockaddr_rc);
 481         return 0;
 482 }
 483
 484 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 485                                struct msghdr *msg, size_t len)
 486 {
 487         struct sock *sk = sock->sk;
 488         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
 489         struct sk_buff *skb;
 490         int err;
 491         int sent = 0;
 492
 493         if (msg->msg_flags & MSG_OOB)
 494                 return -EOPNOTSUPP;
 495
 496         if (sk->sk_shutdown & SEND_SHUTDOWN)
 497                 return -EPIPE;
 498
 499         BT_DBG("sock %p, sk %p", sock, sk);
 500
 501         lock_sock(sk);
 502
 503         while (len) {
 504                 size_t size = min_t(size_t, len, d->mtu);
 505
 506                 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
 507                                 msg->msg_flags & MSG_DONTWAIT, &err);
 508                 if (!skb)
 509                         break;
 510                 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
 511
 512                 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
 513                 if (err) {
 514                         kfree_skb(skb);
 515                         sent = err;
 516                         break;
 517                 }
 518
 519                 err = rfcomm_dlc_send(d, skb);
 520                 if (err < 0) {
 521                         kfree_skb(skb);
 522                         break;
 523                 }
 524
 525                 sent += size;
 526                 len  -= size;
 527         }
 528
 529         release_sock(sk);
 530
 531         return sent ? sent : err;
 532 }
 533
 534 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
 535 {
 536         DECLARE_WAITQUEUE(wait, current);
 537
 538         add_wait_queue(sk->sk_sleep, &wait);
 539         for (;;) {
 540                 set_current_state(TASK_INTERRUPTIBLE);
 541
 542                 if (skb_queue_len(&sk->sk_receive_queue) || sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN) ||
 543                                 signal_pending(current) || !timeo)
 544                         break;
 545
 546                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 547                 release_sock(sk);
 548                 timeo = schedule_timeout(timeo);
 549                 lock_sock(sk);
 550                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 551         }
 552
 553         __set_current_state(TASK_RUNNING);
 554         remove_wait_queue(sk->sk_sleep, &wait);
 555         return timeo;
 556 }
 557
 558 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 559                                struct msghdr *msg, size_t size, int flags)
 560 {
 561         struct sock *sk = sock->sk;
 562         int err = 0;
 563         size_t target, copied = 0;
 564         long timeo;
 565
 566         if (flags & MSG_OOB)
 567                 return -EOPNOTSUPP;
 568
 569         msg->msg_namelen = 0;
 570
 571         BT_DBG("sk %p size %d", sk, size);
 572
 573         lock_sock(sk);
 574
 575         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 576         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 577
 578         do {
 579                 struct sk_buff *skb;
 580                 int chunk;
 581
 582                 skb = skb_dequeue(&sk->sk_receive_queue);
 583                 if (!skb) {
 584                         if (copied >= target)
 585                                 break;
 586
 587                         if ((err = sock_error(sk)) != 0)
 588                                 break;
 589                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 590                                 break;
 591
 592                         err = -EAGAIN;
 593                         if (!timeo)
 594                                 break;
 595
 596                         timeo = rfcomm_sock_data_wait(sk, timeo);
 597
 598                         if (signal_pending(current)) {
 599                                 err = sock_intr_errno(timeo);
 600                                 goto out;
 601                         }
 602                         continue;
 603                 }
 604
 605                 chunk = min_t(unsigned int, skb->len, size);
 606                 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
 607                         skb_queue_head(&sk->sk_receive_queue, skb);
 608                         if (!copied)
 609                                 copied = -EFAULT;
 610                         break;
 611                 }
 612                 copied += chunk;
 613                 size   -= chunk;
 614
 615                 if (!(flags & MSG_PEEK)) {
 616                         atomic_sub(chunk, &sk->sk_rmem_alloc);
 617
 618                         skb_pull(skb, chunk);
 619                         if (skb->len) {
 620                                 skb_queue_head(&sk->sk_receive_queue, skb);
 621                                 break;
 622                         }
 623                         kfree_skb(skb);
 624
 625                 } else {
 626                         /* put message back and return */
 627                         skb_queue_head(&sk->sk_receive_queue, skb);
 628                         break;
 629                 }
 630         } while (size);
 631
 632 out:
 633         if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
 634                 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
 635
 636         release_sock(sk);
 637         return copied ? : err;
 638 }
 639
 640 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
 641 {
 642         struct sock *sk = sock->sk;
 643         int err = 0;
 644
 645         BT_DBG("sk %p", sk);
 646
 647         lock_sock(sk);
 648
 649         switch (optname) {
 650         default:
 651                 err = -ENOPROTOOPT;
 652                 break;
 653         }
 654
 655         release_sock(sk);
 656         return err;
 657 }
 658
 659 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
 660 {
 661         struct sock *sk = sock->sk;
 662         int len, err = 0;
 663
 664         BT_DBG("sk %p", sk);
 665
 666         if (get_user(len, optlen))
 667                 return -EFAULT;
 668
 669         lock_sock(sk);
 670
 671         switch (optname) {
 672         default:
 673                 err = -ENOPROTOOPT;
 674                 break;
 675         };
 676
 677         release_sock(sk);
 678         return err;
 679 }
 680
 681 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 682 {
 683         struct sock *sk = sock->sk;
 684         int err;
 685
 686         lock_sock(sk);
 687
 688 #ifdef CONFIG_BT_RFCOMM_TTY
 689         err = rfcomm_dev_ioctl(sk, cmd, arg);
 690 #else
 691         err = -EOPNOTSUPP;
 692 #endif
 693
 694         release_sock(sk);
 695         return err;
 696 }
 697
 698 static int rfcomm_sock_shutdown(struct socket *sock, int how)
 699 {
 700         struct sock *sk = sock->sk;
 701         int err = 0;
 702
 703         BT_DBG("sock %p, sk %p", sock, sk);
 704
 705         if (!sk) return 0;
 706
 707         lock_sock(sk);
 708         if (!sk->sk_shutdown) {
 709                 sk->sk_shutdown = SHUTDOWN_MASK;
 710                 __rfcomm_sock_close(sk);
 711
 712                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 713                         err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 714         }
 715         release_sock(sk);
 716         return err;
 717 }
 718
 719 static int rfcomm_sock_release(struct socket *sock)
 720 {
 721         struct sock *sk = sock->sk;
 722         int err;
 723
 724         BT_DBG("sock %p, sk %p", sock, sk);
 725
 726         if (!sk)
 727                 return 0;
 728
 729         err = rfcomm_sock_shutdown(sock, 2);
 730
 731         sock_orphan(sk);
 732         rfcomm_sock_kill(sk);
 733         return err;
 734 }
 735
 736 /* ---- RFCOMM core layer callbacks ----
 737  *
 738  * called under rfcomm_lock()
 739  */
 740 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
 741 {
 742         struct sock *sk, *parent;
 743         bdaddr_t src, dst;
 744         int result = 0;
 745
 746         BT_DBG("session %p channel %d", s, channel);
 747
 748         rfcomm_session_getaddr(s, &src, &dst);
 749
 750         /* Check if we have socket listening on channel */
 751         parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
 752         if (!parent)
 753                 return 0;
 754
 755         /* Check for backlog size */
 756         if (parent->sk_ack_backlog > parent->sk_max_ack_backlog) {
 757                 BT_DBG("backlog full %d", parent->sk_ack_backlog);
 758                 goto done;
 759         }
 760
 761         sk = rfcomm_sock_alloc(NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
 762         if (!sk)
 763                 goto done;
 764
 765         rfcomm_sock_init(sk, parent);
 766         bacpy(&bt_sk(sk)->src, &src);
 767         bacpy(&bt_sk(sk)->dst, &dst);
 768         rfcomm_pi(sk)->channel = channel;
 769
 770         sk->sk_state = BT_CONFIG;
 771         bt_accept_enqueue(parent, sk);
 772
 773         /* Accept connection and return socket DLC */
 774         *d = rfcomm_pi(sk)->dlc;
 775         result = 1;
 776
 777 done:
 778         bh_unlock_sock(parent);
 779         return result;
 780 }
 781
 782 /* ---- Proc fs support ---- */
 783 #ifdef CONFIG_PROC_FS
 784 static void *rfcomm_seq_start(struct seq_file *seq, loff_t *pos)
 785 {
 786         struct sock *sk;
 787         struct hlist_node *node;
 788         loff_t l = *pos;
 789
 790         read_lock_bh(&rfcomm_sk_list.lock);
 791
 792         sk_for_each(sk, node, &rfcomm_sk_list.head)
 793                 if (!l--)
 794                         return sk;
 795         return NULL;
 796 }
 797
 798 static void *rfcomm_seq_next(struct seq_file *seq, void *e, loff_t *pos)
 799 {
 800         struct sock *sk = e;
 801         (*pos)++;
 802         return sk_next(sk);
 803 }
 804
 805 static void rfcomm_seq_stop(struct seq_file *seq, void *e)
 806 {
 807         read_unlock_bh(&rfcomm_sk_list.lock);
 808 }
 809
 810 static int  rfcomm_seq_show(struct seq_file *seq, void *e)
 811 {
 812         struct sock *sk = e;
 813         seq_printf(seq, "%s %s %d %d\n",
 814                         batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 815                         sk->sk_state, rfcomm_pi(sk)->channel);
 816         return 0;
 817 }
 818
 819 static struct seq_operations rfcomm_seq_ops = {
 820         .start  = rfcomm_seq_start,
 821         .next   = rfcomm_seq_next,
 822         .stop   = rfcomm_seq_stop,
 823         .show   = rfcomm_seq_show
 824 };
 825
 826 static int rfcomm_seq_open(struct inode *inode, struct file *file)
 827 {
 828         return seq_open(file, &rfcomm_seq_ops);
 829 }
 830
 831 static struct file_operations rfcomm_seq_fops = {
 832         .owner   = THIS_MODULE,
 833         .open    = rfcomm_seq_open,
 834         .read    = seq_read,
 835         .llseek  = seq_lseek,
 836         .release = seq_release,
 837 };
 838
 839 static int  __init rfcomm_sock_proc_init(void)
 840 {
 841         struct proc_dir_entry *p = create_proc_entry("sock", S_IRUGO, proc_bt_rfcomm);
 842         if (!p)
 843                 return -ENOMEM;
 844         p->proc_fops = &rfcomm_seq_fops;
 845         return 0;
 846 }
 847
 848 static void __exit rfcomm_sock_proc_cleanup(void)
 849 {
 850         remove_proc_entry("sock", proc_bt_rfcomm);
 851 }
 852
 853 #else /* CONFIG_PROC_FS */
 854
 855 static int  __init rfcomm_sock_proc_init(void)
 856 {
 857         return 0;
 858 }
 859
 860 static void __exit rfcomm_sock_proc_cleanup(void)
 861 {
 862         return;
 863 }
 864 #endif /* CONFIG_PROC_FS */
 865
 866 static struct proto_ops rfcomm_sock_ops = {
 867         .family         = PF_BLUETOOTH,
 868         .owner          = THIS_MODULE,
 869         .release        = rfcomm_sock_release,
 870         .bind           = rfcomm_sock_bind,
 871         .connect        = rfcomm_sock_connect,
 872         .listen         = rfcomm_sock_listen,
 873         .accept         = rfcomm_sock_accept,
 874         .getname        = rfcomm_sock_getname,
 875         .sendmsg        = rfcomm_sock_sendmsg,
 876         .recvmsg        = rfcomm_sock_recvmsg,
 877         .shutdown       = rfcomm_sock_shutdown,
 878         .setsockopt     = rfcomm_sock_setsockopt,
 879         .getsockopt     = rfcomm_sock_getsockopt,
 880         .ioctl          = rfcomm_sock_ioctl,
 881         .poll           = bt_sock_poll,
 882         .socketpair     = sock_no_socketpair,
 883         .mmap           = sock_no_mmap
 884 };
 885
 886 static struct net_proto_family rfcomm_sock_family_ops = {
 887         .family         = PF_BLUETOOTH,
 888         .owner          = THIS_MODULE,
 889         .create         = rfcomm_sock_create
 890 };
 891
 892 int  __init rfcomm_init_sockets(void)
 893 {
 894         int err;
 895
 896         if ((err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops))) {
 897                 BT_ERR("RFCOMM socket layer registration failed. %d", err);
 898                 return err;
 899         }
 900
 901         rfcomm_sock_proc_init();
 902
 903         BT_INFO("RFCOMM socket layer initialized");
 904         return 0;
 905 }
 906
 907 void __exit rfcomm_cleanup_sockets(void)
 908 {
 909         int err;
 910
 911         rfcomm_sock_proc_cleanup();
 912
 913         /* Unregister socket, protocol and notifier */
 914         if ((err = bt_sock_unregister(BTPROTO_RFCOMM)))
 915                 BT_ERR("RFCOMM socket layer unregistration failed. %d", err);
 916 }