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         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 203                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 204
 205                 lock_sock(sk);
 206
 207                 /* FIXME: Is this check still needed */
 208                 if (sk->sk_state == BT_CLOSED) {
 209                         release_sock(sk);
 210                         bt_accept_unlink(sk);
 211                         continue;
 212                 }
 213
 214                 if (sk->sk_state == BT_CONNECTED || !newsock ||
 215                                                 bt_sk(parent)->defer_setup) {
 216                         bt_accept_unlink(sk);
 217                         if (newsock)
 218                                 sock_graft(sk, newsock);
 219
 220                         release_sock(sk);
 221                         return sk;
 222                 }
 223
 224                 release_sock(sk);
 225         }
 226
 227         return NULL;
 228 }
 229 EXPORT_SYMBOL(bt_accept_dequeue);
 230
 231 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 232                                 struct msghdr *msg, size_t len, int flags)
 233 {
 234         int noblock = flags & MSG_DONTWAIT;
 235         struct sock *sk = sock->sk;
 236         struct sk_buff *skb;
 237         size_t copied;
 238         int err;
 239
 240         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
 241
 242         if (flags & (MSG_OOB))
 243                 return -EOPNOTSUPP;
 244
 245         skb = skb_recv_datagram(sk, flags, noblock, &err);
 246         if (!skb) {
 247                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 248                         return 0;
 249                 return err;
 250         }
 251
 252         msg->msg_namelen = 0;
 253
 254         copied = skb->len;
 255         if (len < copied) {
 256                 msg->msg_flags |= MSG_TRUNC;
 257                 copied = len;
 258         }
 259
 260         skb_reset_transport_header(skb);
 261         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 262         if (err == 0)
 263                 sock_recv_ts_and_drops(msg, sk, skb);
 264
 265         skb_free_datagram(sk, skb);
 266
 267         return err ? : copied;
 268 }
 269 EXPORT_SYMBOL(bt_sock_recvmsg);
 270
 271 static long bt_sock_data_wait(struct sock *sk, long timeo)
 272 {
 273         DECLARE_WAITQUEUE(wait, current);
 274
 275         add_wait_queue(sk_sleep(sk), &wait);
 276         for (;;) {
 277                 set_current_state(TASK_INTERRUPTIBLE);
 278
 279                 if (!skb_queue_empty(&sk->sk_receive_queue))
 280                         break;
 281
 282                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
 283                         break;
 284
 285                 if (signal_pending(current) || !timeo)
 286                         break;
 287
 288                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 289                 release_sock(sk);
 290                 timeo = schedule_timeout(timeo);
 291                 lock_sock(sk);
 292                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 293         }
 294
 295         __set_current_state(TASK_RUNNING);
 296         remove_wait_queue(sk_sleep(sk), &wait);
 297         return timeo;
 298 }
 299
 300 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
 301                                struct msghdr *msg, size_t size, int flags)
 302 {
 303         struct sock *sk = sock->sk;
 304         int err = 0;
 305         size_t target, copied = 0;
 306         long timeo;
 307
 308         if (flags & MSG_OOB)
 309                 return -EOPNOTSUPP;
 310
 311         msg->msg_namelen = 0;
 312
 313         BT_DBG("sk %p size %zu", sk, size);
 314
 315         lock_sock(sk);
 316
 317         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 318         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 319
 320         do {
 321                 struct sk_buff *skb;
 322                 int chunk;
 323
 324                 skb = skb_dequeue(&sk->sk_receive_queue);
 325                 if (!skb) {
 326                         if (copied >= target)
 327                                 break;
 328
 329                         err = sock_error(sk);
 330                         if (err)
 331                                 break;
 332                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 333                                 break;
 334
 335                         err = -EAGAIN;
 336                         if (!timeo)
 337                                 break;
 338
 339                         timeo = bt_sock_data_wait(sk, timeo);
 340
 341                         if (signal_pending(current)) {
 342                                 err = sock_intr_errno(timeo);
 343                                 goto out;
 344                         }
 345                         continue;
 346                 }
 347
 348                 chunk = min_t(unsigned int, skb->len, size);
 349                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
 350                         skb_queue_head(&sk->sk_receive_queue, skb);
 351                         if (!copied)
 352                                 copied = -EFAULT;
 353                         break;
 354                 }
 355                 copied += chunk;
 356                 size   -= chunk;
 357
 358                 sock_recv_ts_and_drops(msg, sk, skb);
 359
 360                 if (!(flags & MSG_PEEK)) {
 361                         int skb_len = skb_headlen(skb);
 362
 363                         if (chunk <= skb_len) {
 364                                 __skb_pull(skb, chunk);
 365                         } else {
 366                                 struct sk_buff *frag;
 367
 368                                 __skb_pull(skb, skb_len);
 369                                 chunk -= skb_len;
 370
 371                                 skb_walk_frags(skb, frag) {
 372                                         if (chunk <= frag->len) {
 373                                                 /* Pulling partial data */
 374                                                 skb->len -= chunk;
 375                                                 skb->data_len -= chunk;
 376                                                 __skb_pull(frag, chunk);
 377                                                 break;
 378                                         } else if (frag->len) {
 379                                                 /* Pulling all frag data */
 380                                                 chunk -= frag->len;
 381                                                 skb->len -= frag->len;
 382                                                 skb->data_len -= frag->len;
 383                                                 __skb_pull(frag, frag->len);
 384                                         }
 385                                 }
 386                         }
 387
 388                         if (skb->len) {
 389                                 skb_queue_head(&sk->sk_receive_queue, skb);
 390                                 break;
 391                         }
 392                         kfree_skb(skb);
 393
 394                 } else {
 395                         /* put message back and return */
 396                         skb_queue_head(&sk->sk_receive_queue, skb);
 397                         break;
 398                 }
 399         } while (size);
 400
 401 out:
 402         release_sock(sk);
 403         return copied ? : err;
 404 }
 405 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 406
 407 static inline unsigned int bt_accept_poll(struct sock *parent)
 408 {
 409         struct list_head *p, *n;
 410         struct sock *sk;
 411
 412         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 413                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 414                 if (sk->sk_state == BT_CONNECTED ||
 415                                         (bt_sk(parent)->defer_setup &&
 416                                                 sk->sk_state == BT_CONNECT2))
 417                         return POLLIN | POLLRDNORM;
 418         }
 419
 420         return 0;
 421 }
 422
 423 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
 424 {
 425         struct sock *sk = sock->sk;
 426         unsigned int mask = 0;
 427
 428         BT_DBG("sock %p, sk %p", sock, sk);
 429
 430         poll_wait(file, sk_sleep(sk), wait);
 431
 432         if (sk->sk_state == BT_LISTEN)
 433                 return bt_accept_poll(sk);
 434
 435         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 436                 mask |= POLLERR;
 437
 438         if (sk->sk_shutdown & RCV_SHUTDOWN)
 439                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 440
 441         if (sk->sk_shutdown == SHUTDOWN_MASK)
 442                 mask |= POLLHUP;
 443
 444         if (!skb_queue_empty(&sk->sk_receive_queue))
 445                 mask |= POLLIN | POLLRDNORM;
 446
 447         if (sk->sk_state == BT_CLOSED)
 448                 mask |= POLLHUP;
 449
 450         if (sk->sk_state == BT_CONNECT ||
 451                         sk->sk_state == BT_CONNECT2 ||
 452                         sk->sk_state == BT_CONFIG)
 453                 return mask;
 454
 455         if (sock_writeable(sk))
 456                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 457         else
 458                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 459
 460         return mask;
 461 }
 462 EXPORT_SYMBOL(bt_sock_poll);
 463
 464 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 465 {
 466         struct sock *sk = sock->sk;
 467         struct sk_buff *skb;
 468         long amount;
 469         int err;
 470
 471         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 472
 473         switch (cmd) {
 474         case TIOCOUTQ:
 475                 if (sk->sk_state == BT_LISTEN)
 476                         return -EINVAL;
 477
 478                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 479                 if (amount < 0)
 480                         amount = 0;
 481                 err = put_user(amount, (int __user *) arg);
 482                 break;
 483
 484         case TIOCINQ:
 485                 if (sk->sk_state == BT_LISTEN)
 486                         return -EINVAL;
 487
 488                 lock_sock(sk);
 489                 skb = skb_peek(&sk->sk_receive_queue);
 490                 amount = skb ? skb->len : 0;
 491                 release_sock(sk);
 492                 err = put_user(amount, (int __user *) arg);
 493                 break;
 494
 495         case SIOCGSTAMP:
 496                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 497                 break;
 498
 499         case SIOCGSTAMPNS:
 500                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 501                 break;
 502
 503         default:
 504                 err = -ENOIOCTLCMD;
 505                 break;
 506         }
 507
 508         return err;
 509 }
 510 EXPORT_SYMBOL(bt_sock_ioctl);
 511
 512 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 513 {
 514         DECLARE_WAITQUEUE(wait, current);
 515         int err = 0;
 516
 517         BT_DBG("sk %p", sk);
 518
 519         add_wait_queue(sk_sleep(sk), &wait);
 520         set_current_state(TASK_INTERRUPTIBLE);
 521         while (sk->sk_state != state) {
 522                 if (!timeo) {
 523                         err = -EINPROGRESS;
 524                         break;
 525                 }
 526
 527                 if (signal_pending(current)) {
 528                         err = sock_intr_errno(timeo);
 529                         break;
 530                 }
 531
 532                 release_sock(sk);
 533                 timeo = schedule_timeout(timeo);
 534                 lock_sock(sk);
 535                 set_current_state(TASK_INTERRUPTIBLE);
 536
 537                 err = sock_error(sk);
 538                 if (err)
 539                         break;
 540         }
 541         __set_current_state(TASK_RUNNING);
 542         remove_wait_queue(sk_sleep(sk), &wait);
 543         return err;
 544 }
 545 EXPORT_SYMBOL(bt_sock_wait_state);
 546
 547 static struct net_proto_family bt_sock_family_ops = {
 548         .owner  = THIS_MODULE,
 549         .family = PF_BLUETOOTH,
 550         .create = bt_sock_create,
 551 };
 552
 553 static int __init bt_init(void)
 554 {
 555         int err;
 556
 557         BT_INFO("Core ver %s", VERSION);
 558
 559         err = bt_sysfs_init();
 560         if (err < 0)
 561                 return err;
 562
 563         err = sock_register(&bt_sock_family_ops);
 564         if (err < 0) {
 565                 bt_sysfs_cleanup();
 566                 return err;
 567         }
 568
 569         BT_INFO("HCI device and connection manager initialized");
 570
 571         err = hci_sock_init();
 572         if (err < 0)
 573                 goto error;
 574
 575         err = l2cap_init();
 576         if (err < 0)
 577                 goto sock_err;
 578
 579         err = sco_init();
 580         if (err < 0) {
 581                 l2cap_exit();
 582                 goto sock_err;
 583         }
 584
 585         return 0;
 586
 587 sock_err:
 588         hci_sock_cleanup();
 589
 590 error:
 591         sock_unregister(PF_BLUETOOTH);
 592         bt_sysfs_cleanup();
 593
 594         return err;
 595 }
 596
 597 static void __exit bt_exit(void)
 598 {
 599
 600         sco_exit();
 601
 602         l2cap_exit();
 603
 604         hci_sock_cleanup();
 605
 606         sock_unregister(PF_BLUETOOTH);
 607
 608         bt_sysfs_cleanup();
 609 }
 610
 611 subsys_initcall(bt_init);
 612 module_exit(bt_exit);
 613
 614 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 615 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 616 MODULE_VERSION(VERSION);
 617 MODULE_LICENSE("GPL");
 618 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);