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         if (!rfcomm_pi(sk)->channel) {
 402                 bdaddr_t *src = &bt_sk(sk)->src;
 403                 u8 channel;
 404
 405                 err = -EINVAL;
 406
 407                 write_lock_bh(&rfcomm_sk_list.lock);
 408
 409                 for (channel = 1; channel < 31; channel++)
 410                         if (!__rfcomm_get_sock_by_addr(channel, src)) {
 411                                 rfcomm_pi(sk)->channel = channel;
 412                                 err = 0;
 413                                 break;
 414                         }
 415
 416                 write_unlock_bh(&rfcomm_sk_list.lock);
 417
 418                 if (err < 0)
 419                         goto done;
 420         }
 421
 422         sk->sk_max_ack_backlog = backlog;
 423         sk->sk_ack_backlog = 0;
 424         sk->sk_state = BT_LISTEN;
 425
 426 done:
 427         release_sock(sk);
 428         return err;
 429 }
 430
 431 int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 432 {
 433         DECLARE_WAITQUEUE(wait, current);
 434         struct sock *sk = sock->sk, *nsk;
 435         long timeo;
 436         int err = 0;
 437
 438         lock_sock(sk);
 439
 440         if (sk->sk_state != BT_LISTEN) {
 441                 err = -EBADFD;
 442                 goto done;
 443         }
 444
 445         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 446
 447         BT_DBG("sk %p timeo %ld", sk, timeo);
 448
 449         /* Wait for an incoming connection. (wake-one). */
 450         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 451         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
 452                 set_current_state(TASK_INTERRUPTIBLE);
 453                 if (!timeo) {
 454                         err = -EAGAIN;
 455                         break;
 456                 }
 457
 458                 release_sock(sk);
 459                 timeo = schedule_timeout(timeo);
 460                 lock_sock(sk);
 461
 462                 if (sk->sk_state != BT_LISTEN) {
 463                         err = -EBADFD;
 464                         break;
 465                 }
 466
 467                 if (signal_pending(current)) {
 468                         err = sock_intr_errno(timeo);
 469                         break;
 470                 }
 471         }
 472         set_current_state(TASK_RUNNING);
 473         remove_wait_queue(sk->sk_sleep, &wait);
 474
 475         if (err)
 476                 goto done;
 477
 478         newsock->state = SS_CONNECTED;
 479
 480         BT_DBG("new socket %p", nsk);
 481
 482 done:
 483         release_sock(sk);
 484         return err;
 485 }
 486
 487 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 488 {
 489         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
 490         struct sock *sk = sock->sk;
 491
 492         BT_DBG("sock %p, sk %p", sock, sk);
 493
 494         sa->rc_family  = AF_BLUETOOTH;
 495         sa->rc_channel = rfcomm_pi(sk)->channel;
 496         if (peer)
 497                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
 498         else
 499                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
 500
 501         *len = sizeof(struct sockaddr_rc);
 502         return 0;
 503 }
 504
 505 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 506                                struct msghdr *msg, size_t len)
 507 {
 508         struct sock *sk = sock->sk;
 509         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
 510         struct sk_buff *skb;
 511         int err;
 512         int sent = 0;
 513
 514         if (msg->msg_flags & MSG_OOB)
 515                 return -EOPNOTSUPP;
 516
 517         if (sk->sk_shutdown & SEND_SHUTDOWN)
 518                 return -EPIPE;
 519
 520         BT_DBG("sock %p, sk %p", sock, sk);
 521
 522         lock_sock(sk);
 523
 524         while (len) {
 525                 size_t size = min_t(size_t, len, d->mtu);
 526
 527                 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
 528                                 msg->msg_flags & MSG_DONTWAIT, &err);
 529                 if (!skb)
 530                         break;
 531                 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
 532
 533                 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
 534                 if (err) {
 535                         kfree_skb(skb);
 536                         sent = err;
 537                         break;
 538                 }
 539
 540                 err = rfcomm_dlc_send(d, skb);
 541                 if (err < 0) {
 542                         kfree_skb(skb);
 543                         break;
 544                 }
 545
 546                 sent += size;
 547                 len  -= size;
 548         }
 549
 550         release_sock(sk);
 551
 552         return sent ? sent : err;
 553 }
 554
 555 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
 556 {
 557         DECLARE_WAITQUEUE(wait, current);
 558
 559         add_wait_queue(sk->sk_sleep, &wait);
 560         for (;;) {
 561                 set_current_state(TASK_INTERRUPTIBLE);
 562
 563                 if (skb_queue_len(&sk->sk_receive_queue) || sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN) ||
 564                                 signal_pending(current) || !timeo)
 565                         break;
 566
 567                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 568                 release_sock(sk);
 569                 timeo = schedule_timeout(timeo);
 570                 lock_sock(sk);
 571                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 572         }
 573
 574         __set_current_state(TASK_RUNNING);
 575         remove_wait_queue(sk->sk_sleep, &wait);
 576         return timeo;
 577 }
 578
 579 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 580                                struct msghdr *msg, size_t size, int flags)
 581 {
 582         struct sock *sk = sock->sk;
 583         int err = 0;
 584         size_t target, copied = 0;
 585         long timeo;
 586
 587         if (flags & MSG_OOB)
 588                 return -EOPNOTSUPP;
 589
 590         msg->msg_namelen = 0;
 591
 592         BT_DBG("sk %p size %d", sk, size);
 593
 594         lock_sock(sk);
 595
 596         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 597         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 598
 599         do {
 600                 struct sk_buff *skb;
 601                 int chunk;
 602
 603                 skb = skb_dequeue(&sk->sk_receive_queue);
 604                 if (!skb) {
 605                         if (copied >= target)
 606                                 break;
 607
 608                         if ((err = sock_error(sk)) != 0)
 609                                 break;
 610                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 611                                 break;
 612
 613                         err = -EAGAIN;
 614                         if (!timeo)
 615                                 break;
 616
 617                         timeo = rfcomm_sock_data_wait(sk, timeo);
 618
 619                         if (signal_pending(current)) {
 620                                 err = sock_intr_errno(timeo);
 621                                 goto out;
 622                         }
 623                         continue;
 624                 }
 625
 626                 chunk = min_t(unsigned int, skb->len, size);
 627                 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
 628                         skb_queue_head(&sk->sk_receive_queue, skb);
 629                         if (!copied)
 630                                 copied = -EFAULT;
 631                         break;
 632                 }
 633                 copied += chunk;
 634                 size   -= chunk;
 635
 636                 if (!(flags & MSG_PEEK)) {
 637                         atomic_sub(chunk, &sk->sk_rmem_alloc);
 638
 639                         skb_pull(skb, chunk);
 640                         if (skb->len) {
 641                                 skb_queue_head(&sk->sk_receive_queue, skb);
 642                                 break;
 643                         }
 644                         kfree_skb(skb);
 645
 646                 } else {
 647                         /* put message back and return */
 648                         skb_queue_head(&sk->sk_receive_queue, skb);
 649                         break;
 650                 }
 651         } while (size);
 652
 653 out:
 654         if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
 655                 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
 656
 657         release_sock(sk);
 658         return copied ? : err;
 659 }
 660
 661 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 662 {
 663         struct sock *sk = sock->sk;
 664         int err = 0;
 665
 666         BT_DBG("sk %p", sk);
 667
 668         lock_sock(sk);
 669
 670         switch (optname) {
 671         default:
 672                 err = -ENOPROTOOPT;
 673                 break;
 674         }
 675
 676         release_sock(sk);
 677         return err;
 678 }
 679
 680 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 681 {
 682         struct sock *sk = sock->sk;
 683         int len, err = 0;
 684
 685         BT_DBG("sk %p", sk);
 686
 687         if (get_user(len, optlen))
 688                 return -EFAULT;
 689
 690         lock_sock(sk);
 691
 692         switch (optname) {
 693         default:
 694                 err = -ENOPROTOOPT;
 695                 break;
 696         };
 697
 698         release_sock(sk);
 699         return err;
 700 }
 701
 702 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 703 {
 704         struct sock *sk = sock->sk;
 705         int err;
 706
 707         lock_sock(sk);
 708
 709 #ifdef CONFIG_BT_RFCOMM_TTY
 710         err = rfcomm_dev_ioctl(sk, cmd, (void __user *)arg);
 711 #else
 712         err = -EOPNOTSUPP;
 713 #endif
 714
 715         release_sock(sk);
 716         return err;
 717 }
 718
 719 static int rfcomm_sock_shutdown(struct socket *sock, int how)
 720 {
 721         struct sock *sk = sock->sk;
 722         int err = 0;
 723
 724         BT_DBG("sock %p, sk %p", sock, sk);
 725
 726         if (!sk) return 0;
 727
 728         lock_sock(sk);
 729         if (!sk->sk_shutdown) {
 730                 sk->sk_shutdown = SHUTDOWN_MASK;
 731                 __rfcomm_sock_close(sk);
 732
 733                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 734                         err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 735         }
 736         release_sock(sk);
 737         return err;
 738 }
 739
 740 static int rfcomm_sock_release(struct socket *sock)
 741 {
 742         struct sock *sk = sock->sk;
 743         int err;
 744
 745         BT_DBG("sock %p, sk %p", sock, sk);
 746
 747         if (!sk)
 748                 return 0;
 749
 750         err = rfcomm_sock_shutdown(sock, 2);
 751
 752         sock_orphan(sk);
 753         rfcomm_sock_kill(sk);
 754         return err;
 755 }
 756
 757 /* ---- RFCOMM core layer callbacks ----
 758  *
 759  * called under rfcomm_lock()
 760  */
 761 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
 762 {
 763         struct sock *sk, *parent;
 764         bdaddr_t src, dst;
 765         int result = 0;
 766
 767         BT_DBG("session %p channel %d", s, channel);
 768
 769         rfcomm_session_getaddr(s, &src, &dst);
 770
 771         /* Check if we have socket listening on channel */
 772         parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
 773         if (!parent)
 774                 return 0;
 775
 776         /* Check for backlog size */
 777         if (parent->sk_ack_backlog > parent->sk_max_ack_backlog) {
 778                 BT_DBG("backlog full %d", parent->sk_ack_backlog);
 779                 goto done;
 780         }
 781
 782         sk = rfcomm_sock_alloc(NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
 783         if (!sk)
 784                 goto done;
 785
 786         rfcomm_sock_init(sk, parent);
 787         bacpy(&bt_sk(sk)->src, &src);
 788         bacpy(&bt_sk(sk)->dst, &dst);
 789         rfcomm_pi(sk)->channel = channel;
 790
 791         sk->sk_state = BT_CONFIG;
 792         bt_accept_enqueue(parent, sk);
 793
 794         /* Accept connection and return socket DLC */
 795         *d = rfcomm_pi(sk)->dlc;
 796         result = 1;
 797
 798 done:
 799         bh_unlock_sock(parent);
 800         return result;
 801 }
 802
 803 /* ---- Proc fs support ---- */
 804 #ifdef CONFIG_PROC_FS
 805 static void *rfcomm_seq_start(struct seq_file *seq, loff_t *pos)
 806 {
 807         struct sock *sk;
 808         struct hlist_node *node;
 809         loff_t l = *pos;
 810
 811         read_lock_bh(&rfcomm_sk_list.lock);
 812
 813         sk_for_each(sk, node, &rfcomm_sk_list.head)
 814                 if (!l--)
 815                         return sk;
 816         return NULL;
 817 }
 818
 819 static void *rfcomm_seq_next(struct seq_file *seq, void *e, loff_t *pos)
 820 {
 821         struct sock *sk = e;
 822         (*pos)++;
 823         return sk_next(sk);
 824 }
 825
 826 static void rfcomm_seq_stop(struct seq_file *seq, void *e)
 827 {
 828         read_unlock_bh(&rfcomm_sk_list.lock);
 829 }
 830
 831 static int  rfcomm_seq_show(struct seq_file *seq, void *e)
 832 {
 833         struct sock *sk = e;
 834         seq_printf(seq, "%s %s %d %d\n",
 835                         batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 836                         sk->sk_state, rfcomm_pi(sk)->channel);
 837         return 0;
 838 }
 839
 840 static struct seq_operations rfcomm_seq_ops = {
 841         .start  = rfcomm_seq_start,
 842         .next   = rfcomm_seq_next,
 843         .stop   = rfcomm_seq_stop,
 844         .show   = rfcomm_seq_show
 845 };
 846
 847 static int rfcomm_seq_open(struct inode *inode, struct file *file)
 848 {
 849         return seq_open(file, &rfcomm_seq_ops);
 850 }
 851
 852 static struct file_operations rfcomm_seq_fops = {
 853         .owner   = THIS_MODULE,
 854         .open    = rfcomm_seq_open,
 855         .read    = seq_read,
 856         .llseek  = seq_lseek,
 857         .release = seq_release,
 858 };
 859
 860 static int  __init rfcomm_sock_proc_init(void)
 861 {
 862         struct proc_dir_entry *p = create_proc_entry("sock", S_IRUGO, proc_bt_rfcomm);
 863         if (!p)
 864                 return -ENOMEM;
 865         p->proc_fops = &rfcomm_seq_fops;
 866         return 0;
 867 }
 868
 869 static void __exit rfcomm_sock_proc_cleanup(void)
 870 {
 871         remove_proc_entry("sock", proc_bt_rfcomm);
 872 }
 873
 874 #else /* CONFIG_PROC_FS */
 875
 876 static int  __init rfcomm_sock_proc_init(void)
 877 {
 878         return 0;
 879 }
 880
 881 static void __exit rfcomm_sock_proc_cleanup(void)
 882 {
 883         return;
 884 }
 885 #endif /* CONFIG_PROC_FS */
 886
 887 static struct proto_ops rfcomm_sock_ops = {
 888         .family         = PF_BLUETOOTH,
 889         .owner          = THIS_MODULE,
 890         .release        = rfcomm_sock_release,
 891         .bind           = rfcomm_sock_bind,
 892         .connect        = rfcomm_sock_connect,
 893         .listen         = rfcomm_sock_listen,
 894         .accept         = rfcomm_sock_accept,
 895         .getname        = rfcomm_sock_getname,
 896         .sendmsg        = rfcomm_sock_sendmsg,
 897         .recvmsg        = rfcomm_sock_recvmsg,
 898         .shutdown       = rfcomm_sock_shutdown,
 899         .setsockopt     = rfcomm_sock_setsockopt,
 900         .getsockopt     = rfcomm_sock_getsockopt,
 901         .ioctl          = rfcomm_sock_ioctl,
 902         .poll           = bt_sock_poll,
 903         .socketpair     = sock_no_socketpair,
 904         .mmap           = sock_no_mmap
 905 };
 906
 907 static struct net_proto_family rfcomm_sock_family_ops = {
 908         .family         = PF_BLUETOOTH,
 909         .owner          = THIS_MODULE,
 910         .create         = rfcomm_sock_create
 911 };
 912
 913 int  __init rfcomm_init_sockets(void)
 914 {
 915         int err;
 916
 917         if ((err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops))) {
 918                 BT_ERR("RFCOMM socket layer registration failed. %d", err);
 919                 return err;
 920         }
 921
 922         rfcomm_sock_proc_init();
 923
 924         BT_INFO("RFCOMM socket layer initialized");
 925         return 0;
 926 }
 927
 928 void __exit rfcomm_cleanup_sockets(void)
 929 {
 930         int err;
 931
 932         rfcomm_sock_proc_cleanup();
 933
 934         /* Unregister socket, protocol and notifier */
 935         if ((err = bt_sock_unregister(BTPROTO_RFCOMM)))
 936                 BT_ERR("RFCOMM socket layer unregistration failed. %d", err);
 937 }