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