net/bluetooth/af_bluetooth.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /* Bluetooth address family and sockets. */
  26
  27 #include <linux/module.h>
  28
  29 #include <linux/types.h>
  30 #include <linux/list.h>
  31 #include <linux/errno.h>
  32 #include <linux/kernel.h>
  33 #include <linux/sched.h>
  34 #include <linux/skbuff.h>
  35 #include <linux/init.h>
  36 #include <linux/poll.h>
  37 #include <net/sock.h>
  38 #include <asm/ioctls.h>
  39 #include <linux/kmod.h>
  40
  41 #include <net/bluetooth/bluetooth.h>
  42
  43 #define VERSION "2.16"
  44
  45 /* Bluetooth sockets */
  46 #define BT_MAX_PROTO    8
  47 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
  48 static DEFINE_RWLOCK(bt_proto_lock);
  49
  50 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
  51 static const char *const bt_key_strings[BT_MAX_PROTO] = {
  52         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
  53         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
  54         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
  55         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  56         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
  57         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
  58         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
  59         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
  60 };
  61
  62 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
  63 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
  64         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
  65         "slock-AF_BLUETOOTH-BTPROTO_HCI",
  66         "slock-AF_BLUETOOTH-BTPROTO_SCO",
  67         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  68         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
  69         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
  70         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
  71         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
  72 };
  73
  74 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
  75 {
  76         struct sock *sk = sock->sk;
  77
  78         if (!sk)
  79                 return;
  80
  81         BUG_ON(sock_owned_by_user(sk));
  82
  83         sock_lock_init_class_and_name(sk,
  84                         bt_slock_key_strings[proto], &bt_slock_key[proto],
  85                                 bt_key_strings[proto], &bt_lock_key[proto]);
  86 }
  87
  88 int bt_sock_register(int proto, const struct net_proto_family *ops)
  89 {
  90         int err = 0;
  91
  92         if (proto < 0 || proto >= BT_MAX_PROTO)
  93                 return -EINVAL;
  94
  95         write_lock(&bt_proto_lock);
  96
  97         if (bt_proto[proto])
  98                 err = -EEXIST;
  99         else
 100                 bt_proto[proto] = ops;
 101
 102         write_unlock(&bt_proto_lock);
 103
 104         return err;
 105 }
 106 EXPORT_SYMBOL(bt_sock_register);
 107
 108 int bt_sock_unregister(int proto)
 109 {
 110         int err = 0;
 111
 112         if (proto < 0 || proto >= BT_MAX_PROTO)
 113                 return -EINVAL;
 114
 115         write_lock(&bt_proto_lock);
 116
 117         if (!bt_proto[proto])
 118                 err = -ENOENT;
 119         else
 120                 bt_proto[proto] = NULL;
 121
 122         write_unlock(&bt_proto_lock);
 123
 124         return err;
 125 }
 126 EXPORT_SYMBOL(bt_sock_unregister);
 127
 128 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
 129                           int kern)
 130 {
 131         int err;
 132
 133         if (net != &init_net)
 134                 return -EAFNOSUPPORT;
 135
 136         if (proto < 0 || proto >= BT_MAX_PROTO)
 137                 return -EINVAL;
 138
 139         if (!bt_proto[proto])
 140                 request_module("bt-proto-%d", proto);
 141
 142         err = -EPROTONOSUPPORT;
 143
 144         read_lock(&bt_proto_lock);
 145
 146         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 147                 err = bt_proto[proto]->create(net, sock, proto, kern);
 148                 bt_sock_reclassify_lock(sock, proto);
 149                 module_put(bt_proto[proto]->owner);
 150         }
 151
 152         read_unlock(&bt_proto_lock);
 153
 154         return err;
 155 }
 156
 157 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 158 {
 159         write_lock_bh(&l->lock);
 160         sk_add_node(sk, &l->head);
 161         write_unlock_bh(&l->lock);
 162 }
 163 EXPORT_SYMBOL(bt_sock_link);
 164
 165 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 166 {
 167         write_lock_bh(&l->lock);
 168         sk_del_node_init(sk);
 169         write_unlock_bh(&l->lock);
 170 }
 171 EXPORT_SYMBOL(bt_sock_unlink);
 172
 173 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 174 {
 175         BT_DBG("parent %p, sk %p", parent, sk);
 176
 177         sock_hold(sk);
 178         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 179         bt_sk(sk)->parent = parent;
 180         parent->sk_ack_backlog++;
 181 }
 182 EXPORT_SYMBOL(bt_accept_enqueue);
 183
 184 void bt_accept_unlink(struct sock *sk)
 185 {
 186         BT_DBG("sk %p state %d", sk, sk->sk_state);
 187
 188         list_del_init(&bt_sk(sk)->accept_q);
 189         bt_sk(sk)->parent->sk_ack_backlog--;
 190         bt_sk(sk)->parent = NULL;
 191         sock_put(sk);
 192 }
 193 EXPORT_SYMBOL(bt_accept_unlink);
 194
 195 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 196 {
 197         struct list_head *p, *n;
 198         struct sock *sk;
 199
 200         BT_DBG("parent %p", parent);
 201
 202         local_bh_disable();
 203         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 204                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 205
 206                 bh_lock_sock(sk);
 207
 208                 /* FIXME: Is this check still needed */
 209                 if (sk->sk_state == BT_CLOSED) {
 210                         bh_unlock_sock(sk);
 211                         bt_accept_unlink(sk);
 212                         continue;
 213                 }
 214
 215                 if (sk->sk_state == BT_CONNECTED || !newsock ||
 216                                                 bt_sk(parent)->defer_setup) {
 217                         bt_accept_unlink(sk);
 218                         if (newsock)
 219                                 sock_graft(sk, newsock);
 220
 221                         bh_unlock_sock(sk);
 222                         local_bh_enable();
 223                         return sk;
 224                 }
 225
 226                 bh_unlock_sock(sk);
 227         }
 228         local_bh_enable();
 229
 230         return NULL;
 231 }
 232 EXPORT_SYMBOL(bt_accept_dequeue);
 233
 234 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 235                                 struct msghdr *msg, size_t len, int flags)
 236 {
 237         int noblock = flags & MSG_DONTWAIT;
 238         struct sock *sk = sock->sk;
 239         struct sk_buff *skb;
 240         size_t copied;
 241         int err;
 242
 243         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
 244
 245         if (flags & (MSG_OOB))
 246                 return -EOPNOTSUPP;
 247
 248         skb = skb_recv_datagram(sk, flags, noblock, &err);
 249         if (!skb) {
 250                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 251                         return 0;
 252                 return err;
 253         }
 254
 255         copied = skb->len;
 256         if (len < copied) {
 257                 msg->msg_flags |= MSG_TRUNC;
 258                 copied = len;
 259         }
 260
 261         skb_reset_transport_header(skb);
 262         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 263         if (err == 0)
 264                 sock_recv_ts_and_drops(msg, sk, skb);
 265
 266         skb_free_datagram(sk, skb);
 267
 268         return err ? : copied;
 269 }
 270 EXPORT_SYMBOL(bt_sock_recvmsg);
 271
 272 static long bt_sock_data_wait(struct sock *sk, long timeo)
 273 {
 274         DECLARE_WAITQUEUE(wait, current);
 275
 276         add_wait_queue(sk_sleep(sk), &wait);
 277         for (;;) {
 278                 set_current_state(TASK_INTERRUPTIBLE);
 279
 280                 if (!skb_queue_empty(&sk->sk_receive_queue))
 281                         break;
 282
 283                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
 284                         break;
 285
 286                 if (signal_pending(current) || !timeo)
 287                         break;
 288
 289                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 290                 release_sock(sk);
 291                 timeo = schedule_timeout(timeo);
 292                 lock_sock(sk);
 293                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 294         }
 295
 296         __set_current_state(TASK_RUNNING);
 297         remove_wait_queue(sk_sleep(sk), &wait);
 298         return timeo;
 299 }
 300
 301 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
 302                                struct msghdr *msg, size_t size, int flags)
 303 {
 304         struct sock *sk = sock->sk;
 305         int err = 0;
 306         size_t target, copied = 0;
 307         long timeo;
 308
 309         if (flags & MSG_OOB)
 310                 return -EOPNOTSUPP;
 311
 312         BT_DBG("sk %p size %zu", sk, size);
 313
 314         lock_sock(sk);
 315
 316         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 317         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 318
 319         do {
 320                 struct sk_buff *skb;
 321                 int chunk;
 322
 323                 skb = skb_dequeue(&sk->sk_receive_queue);
 324                 if (!skb) {
 325                         if (copied >= target)
 326                                 break;
 327
 328                         err = sock_error(sk);
 329                         if (err)
 330                                 break;
 331                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 332                                 break;
 333
 334                         err = -EAGAIN;
 335                         if (!timeo)
 336                                 break;
 337
 338                         timeo = bt_sock_data_wait(sk, timeo);
 339
 340                         if (signal_pending(current)) {
 341                                 err = sock_intr_errno(timeo);
 342                                 goto out;
 343                         }
 344                         continue;
 345                 }
 346
 347                 chunk = min_t(unsigned int, skb->len, size);
 348                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
 349                         skb_queue_head(&sk->sk_receive_queue, skb);
 350                         if (!copied)
 351                                 copied = -EFAULT;
 352                         break;
 353                 }
 354                 copied += chunk;
 355                 size   -= chunk;
 356
 357                 sock_recv_ts_and_drops(msg, sk, skb);
 358
 359                 if (!(flags & MSG_PEEK)) {
 360                         int skb_len = skb_headlen(skb);
 361
 362                         if (chunk <= skb_len) {
 363                                 __skb_pull(skb, chunk);
 364                         } else {
 365                                 struct sk_buff *frag;
 366
 367                                 __skb_pull(skb, skb_len);
 368                                 chunk -= skb_len;
 369
 370                                 skb_walk_frags(skb, frag) {
 371                                         if (chunk <= frag->len) {
 372                                                 /* Pulling partial data */
 373                                                 skb->len -= chunk;
 374                                                 skb->data_len -= chunk;
 375                                                 __skb_pull(frag, chunk);
 376                                                 break;
 377                                         } else if (frag->len) {
 378                                                 /* Pulling all frag data */
 379                                                 chunk -= frag->len;
 380                                                 skb->len -= frag->len;
 381                                                 skb->data_len -= frag->len;
 382                                                 __skb_pull(frag, frag->len);
 383                                         }
 384                                 }
 385                         }
 386
 387                         if (skb->len) {
 388                                 skb_queue_head(&sk->sk_receive_queue, skb);
 389                                 break;
 390                         }
 391                         kfree_skb(skb);
 392
 393                 } else {
 394                         /* put message back and return */
 395                         skb_queue_head(&sk->sk_receive_queue, skb);
 396                         break;
 397                 }
 398         } while (size);
 399
 400 out:
 401         release_sock(sk);
 402         return copied ? : err;
 403 }
 404 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 405
 406 static inline unsigned int bt_accept_poll(struct sock *parent)
 407 {
 408         struct list_head *p, *n;
 409         struct sock *sk;
 410
 411         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 412                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 413                 if (sk->sk_state == BT_CONNECTED ||
 414                                         (bt_sk(parent)->defer_setup &&
 415                                                 sk->sk_state == BT_CONNECT2))
 416                         return POLLIN | POLLRDNORM;
 417         }
 418
 419         return 0;
 420 }
 421
 422 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
 423 {
 424         struct sock *sk = sock->sk;
 425         unsigned int mask = 0;
 426
 427         BT_DBG("sock %p, sk %p", sock, sk);
 428
 429         poll_wait(file, sk_sleep(sk), wait);
 430
 431         if (sk->sk_state == BT_LISTEN)
 432                 return bt_accept_poll(sk);
 433
 434         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 435                 mask |= POLLERR;
 436
 437         if (sk->sk_shutdown & RCV_SHUTDOWN)
 438                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 439
 440         if (sk->sk_shutdown == SHUTDOWN_MASK)
 441                 mask |= POLLHUP;
 442
 443         if (!skb_queue_empty(&sk->sk_receive_queue))
 444                 mask |= POLLIN | POLLRDNORM;
 445
 446         if (sk->sk_state == BT_CLOSED)
 447                 mask |= POLLHUP;
 448
 449         if (sk->sk_state == BT_CONNECT ||
 450                         sk->sk_state == BT_CONNECT2 ||
 451                         sk->sk_state == BT_CONFIG)
 452                 return mask;
 453
 454         if (sock_writeable(sk))
 455                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 456         else
 457                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 458
 459         return mask;
 460 }
 461 EXPORT_SYMBOL(bt_sock_poll);
 462
 463 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 464 {
 465         struct sock *sk = sock->sk;
 466         struct sk_buff *skb;
 467         long amount;
 468         int err;
 469
 470         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 471
 472         switch (cmd) {
 473         case TIOCOUTQ:
 474                 if (sk->sk_state == BT_LISTEN)
 475                         return -EINVAL;
 476
 477                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 478                 if (amount < 0)
 479                         amount = 0;
 480                 err = put_user(amount, (int __user *) arg);
 481                 break;
 482
 483         case TIOCINQ:
 484                 if (sk->sk_state == BT_LISTEN)
 485                         return -EINVAL;
 486
 487                 lock_sock(sk);
 488                 skb = skb_peek(&sk->sk_receive_queue);
 489                 amount = skb ? skb->len : 0;
 490                 release_sock(sk);
 491                 err = put_user(amount, (int __user *) arg);
 492                 break;
 493
 494         case SIOCGSTAMP:
 495                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 496                 break;
 497
 498         case SIOCGSTAMPNS:
 499                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 500                 break;
 501
 502         default:
 503                 err = -ENOIOCTLCMD;
 504                 break;
 505         }
 506
 507         return err;
 508 }
 509 EXPORT_SYMBOL(bt_sock_ioctl);
 510
 511 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 512 {
 513         DECLARE_WAITQUEUE(wait, current);
 514         int err = 0;
 515
 516         BT_DBG("sk %p", sk);
 517
 518         add_wait_queue(sk_sleep(sk), &wait);
 519         set_current_state(TASK_INTERRUPTIBLE);
 520         while (sk->sk_state != state) {
 521                 if (!timeo) {
 522                         err = -EINPROGRESS;
 523                         break;
 524                 }
 525
 526                 if (signal_pending(current)) {
 527                         err = sock_intr_errno(timeo);
 528                         break;
 529                 }
 530
 531                 release_sock(sk);
 532                 timeo = schedule_timeout(timeo);
 533                 lock_sock(sk);
 534                 set_current_state(TASK_INTERRUPTIBLE);
 535
 536                 err = sock_error(sk);
 537                 if (err)
 538                         break;
 539         }
 540         __set_current_state(TASK_RUNNING);
 541         remove_wait_queue(sk_sleep(sk), &wait);
 542         return err;
 543 }
 544 EXPORT_SYMBOL(bt_sock_wait_state);
 545
 546 static struct net_proto_family bt_sock_family_ops = {
 547         .owner  = THIS_MODULE,
 548         .family = PF_BLUETOOTH,
 549         .create = bt_sock_create,
 550 };
 551
 552 static int __init bt_init(void)
 553 {
 554         int err;
 555
 556         BT_INFO("Core ver %s", VERSION);
 557
 558         err = bt_sysfs_init();
 559         if (err < 0)
 560                 return err;
 561
 562         err = sock_register(&bt_sock_family_ops);
 563         if (err < 0) {
 564                 bt_sysfs_cleanup();
 565                 return err;
 566         }
 567
 568         BT_INFO("HCI device and connection manager initialized");
 569
 570         err = hci_sock_init();
 571         if (err < 0)
 572                 goto error;
 573
 574         err = l2cap_init();
 575         if (err < 0)
 576                 goto sock_err;
 577
 578         err = sco_init();
 579         if (err < 0) {
 580                 l2cap_exit();
 581                 goto sock_err;
 582         }
 583
 584         return 0;
 585
 586 sock_err:
 587         hci_sock_cleanup();
 588
 589 error:
 590         sock_unregister(PF_BLUETOOTH);
 591         bt_sysfs_cleanup();
 592
 593         return err;
 594 }
 595
 596 static void __exit bt_exit(void)
 597 {
 598
 599         sco_exit();
 600
 601         l2cap_exit();
 602
 603         hci_sock_cleanup();
 604
 605         sock_unregister(PF_BLUETOOTH);
 606
 607         bt_sysfs_cleanup();
 608 }
 609
 610 subsys_initcall(bt_init);
 611 module_exit(bt_exit);
 612
 613 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 614 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 615 MODULE_VERSION(VERSION);
 616 MODULE_LICENSE("GPL");
 617 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);