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 void bt_sock_reclassify_lock(struct sock *sk, int proto)
  75 {
  76         BUG_ON(!sk);
  77         BUG_ON(sock_owned_by_user(sk));
  78
  79         sock_lock_init_class_and_name(sk,
  80                         bt_slock_key_strings[proto], &bt_slock_key[proto],
  81                                 bt_key_strings[proto], &bt_lock_key[proto]);
  82 }
  83 EXPORT_SYMBOL(bt_sock_reclassify_lock);
  84
  85 int bt_sock_register(int proto, const struct net_proto_family *ops)
  86 {
  87         int err = 0;
  88
  89         if (proto < 0 || proto >= BT_MAX_PROTO)
  90                 return -EINVAL;
  91
  92         write_lock(&bt_proto_lock);
  93
  94         if (bt_proto[proto])
  95                 err = -EEXIST;
  96         else
  97                 bt_proto[proto] = ops;
  98
  99         write_unlock(&bt_proto_lock);
 100
 101         return err;
 102 }
 103 EXPORT_SYMBOL(bt_sock_register);
 104
 105 int bt_sock_unregister(int proto)
 106 {
 107         int err = 0;
 108
 109         if (proto < 0 || proto >= BT_MAX_PROTO)
 110                 return -EINVAL;
 111
 112         write_lock(&bt_proto_lock);
 113
 114         if (!bt_proto[proto])
 115                 err = -ENOENT;
 116         else
 117                 bt_proto[proto] = NULL;
 118
 119         write_unlock(&bt_proto_lock);
 120
 121         return err;
 122 }
 123 EXPORT_SYMBOL(bt_sock_unregister);
 124
 125 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
 126                           int kern)
 127 {
 128         int err;
 129
 130         if (net != &init_net)
 131                 return -EAFNOSUPPORT;
 132
 133         if (proto < 0 || proto >= BT_MAX_PROTO)
 134                 return -EINVAL;
 135
 136         if (!bt_proto[proto])
 137                 request_module("bt-proto-%d", proto);
 138
 139         err = -EPROTONOSUPPORT;
 140
 141         read_lock(&bt_proto_lock);
 142
 143         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 144                 err = bt_proto[proto]->create(net, sock, proto, kern);
 145                 if (!err)
 146                         bt_sock_reclassify_lock(sock->sk, proto);
 147                 module_put(bt_proto[proto]->owner);
 148         }
 149
 150         read_unlock(&bt_proto_lock);
 151
 152         return err;
 153 }
 154
 155 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 156 {
 157         write_lock(&l->lock);
 158         sk_add_node(sk, &l->head);
 159         write_unlock(&l->lock);
 160 }
 161 EXPORT_SYMBOL(bt_sock_link);
 162
 163 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 164 {
 165         write_lock(&l->lock);
 166         sk_del_node_init(sk);
 167         write_unlock(&l->lock);
 168 }
 169 EXPORT_SYMBOL(bt_sock_unlink);
 170
 171 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 172 {
 173         BT_DBG("parent %p, sk %p", parent, sk);
 174
 175         sock_hold(sk);
 176         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 177         bt_sk(sk)->parent = parent;
 178         parent->sk_ack_backlog++;
 179 }
 180 EXPORT_SYMBOL(bt_accept_enqueue);
 181
 182 void bt_accept_unlink(struct sock *sk)
 183 {
 184         BT_DBG("sk %p state %d", sk, sk->sk_state);
 185
 186         list_del_init(&bt_sk(sk)->accept_q);
 187         bt_sk(sk)->parent->sk_ack_backlog--;
 188         bt_sk(sk)->parent = NULL;
 189         sock_put(sk);
 190 }
 191 EXPORT_SYMBOL(bt_accept_unlink);
 192
 193 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 194 {
 195         struct list_head *p, *n;
 196         struct sock *sk;
 197
 198         BT_DBG("parent %p", parent);
 199
 200         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 201                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 202
 203                 lock_sock(sk);
 204
 205                 /* FIXME: Is this check still needed */
 206                 if (sk->sk_state == BT_CLOSED) {
 207                         release_sock(sk);
 208                         bt_accept_unlink(sk);
 209                         continue;
 210                 }
 211
 212                 if (sk->sk_state == BT_CONNECTED || !newsock ||
 213                                                 bt_sk(parent)->defer_setup) {
 214                         bt_accept_unlink(sk);
 215                         if (newsock)
 216                                 sock_graft(sk, newsock);
 217
 218                         release_sock(sk);
 219                         return sk;
 220                 }
 221
 222                 release_sock(sk);
 223         }
 224
 225         return NULL;
 226 }
 227 EXPORT_SYMBOL(bt_accept_dequeue);
 228
 229 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 230                                 struct msghdr *msg, size_t len, int flags)
 231 {
 232         int noblock = flags & MSG_DONTWAIT;
 233         struct sock *sk = sock->sk;
 234         struct sk_buff *skb;
 235         size_t copied;
 236         int err;
 237
 238         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
 239
 240         if (flags & (MSG_OOB))
 241                 return -EOPNOTSUPP;
 242
 243         skb = skb_recv_datagram(sk, flags, noblock, &err);
 244         if (!skb) {
 245                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 246                         return 0;
 247                 return err;
 248         }
 249
 250         msg->msg_namelen = 0;
 251
 252         copied = skb->len;
 253         if (len < copied) {
 254                 msg->msg_flags |= MSG_TRUNC;
 255                 copied = len;
 256         }
 257
 258         skb_reset_transport_header(skb);
 259         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 260         if (err == 0)
 261                 sock_recv_ts_and_drops(msg, sk, skb);
 262
 263         skb_free_datagram(sk, skb);
 264
 265         return err ? : copied;
 266 }
 267 EXPORT_SYMBOL(bt_sock_recvmsg);
 268
 269 static long bt_sock_data_wait(struct sock *sk, long timeo)
 270 {
 271         DECLARE_WAITQUEUE(wait, current);
 272
 273         add_wait_queue(sk_sleep(sk), &wait);
 274         for (;;) {
 275                 set_current_state(TASK_INTERRUPTIBLE);
 276
 277                 if (!skb_queue_empty(&sk->sk_receive_queue))
 278                         break;
 279
 280                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
 281                         break;
 282
 283                 if (signal_pending(current) || !timeo)
 284                         break;
 285
 286                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 287                 release_sock(sk);
 288                 timeo = schedule_timeout(timeo);
 289                 lock_sock(sk);
 290                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 291         }
 292
 293         __set_current_state(TASK_RUNNING);
 294         remove_wait_queue(sk_sleep(sk), &wait);
 295         return timeo;
 296 }
 297
 298 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
 299                                struct msghdr *msg, size_t size, int flags)
 300 {
 301         struct sock *sk = sock->sk;
 302         int err = 0;
 303         size_t target, copied = 0;
 304         long timeo;
 305
 306         if (flags & MSG_OOB)
 307                 return -EOPNOTSUPP;
 308
 309         msg->msg_namelen = 0;
 310
 311         BT_DBG("sk %p size %zu", sk, size);
 312
 313         lock_sock(sk);
 314
 315         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 316         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 317
 318         do {
 319                 struct sk_buff *skb;
 320                 int chunk;
 321
 322                 skb = skb_dequeue(&sk->sk_receive_queue);
 323                 if (!skb) {
 324                         if (copied >= target)
 325                                 break;
 326
 327                         err = sock_error(sk);
 328                         if (err)
 329                                 break;
 330                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 331                                 break;
 332
 333                         err = -EAGAIN;
 334                         if (!timeo)
 335                                 break;
 336
 337                         timeo = bt_sock_data_wait(sk, timeo);
 338
 339                         if (signal_pending(current)) {
 340                                 err = sock_intr_errno(timeo);
 341                                 goto out;
 342                         }
 343                         continue;
 344                 }
 345
 346                 chunk = min_t(unsigned int, skb->len, size);
 347                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
 348                         skb_queue_head(&sk->sk_receive_queue, skb);
 349                         if (!copied)
 350                                 copied = -EFAULT;
 351                         break;
 352                 }
 353                 copied += chunk;
 354                 size   -= chunk;
 355
 356                 sock_recv_ts_and_drops(msg, sk, skb);
 357
 358                 if (!(flags & MSG_PEEK)) {
 359                         int skb_len = skb_headlen(skb);
 360
 361                         if (chunk <= skb_len) {
 362                                 __skb_pull(skb, chunk);
 363                         } else {
 364                                 struct sk_buff *frag;
 365
 366                                 __skb_pull(skb, skb_len);
 367                                 chunk -= skb_len;
 368
 369                                 skb_walk_frags(skb, frag) {
 370                                         if (chunk <= frag->len) {
 371                                                 /* Pulling partial data */
 372                                                 skb->len -= chunk;
 373                                                 skb->data_len -= chunk;
 374                                                 __skb_pull(frag, chunk);
 375                                                 break;
 376                                         } else if (frag->len) {
 377                                                 /* Pulling all frag data */
 378                                                 chunk -= frag->len;
 379                                                 skb->len -= frag->len;
 380                                                 skb->data_len -= frag->len;
 381                                                 __skb_pull(frag, frag->len);
 382                                         }
 383                                 }
 384                         }
 385
 386                         if (skb->len) {
 387                                 skb_queue_head(&sk->sk_receive_queue, skb);
 388                                 break;
 389                         }
 390                         kfree_skb(skb);
 391
 392                 } else {
 393                         /* put message back and return */
 394                         skb_queue_head(&sk->sk_receive_queue, skb);
 395                         break;
 396                 }
 397         } while (size);
 398
 399 out:
 400         release_sock(sk);
 401         return copied ? : err;
 402 }
 403 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 404
 405 static inline unsigned int bt_accept_poll(struct sock *parent)
 406 {
 407         struct list_head *p, *n;
 408         struct sock *sk;
 409
 410         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 411                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 412                 if (sk->sk_state == BT_CONNECTED ||
 413                                         (bt_sk(parent)->defer_setup &&
 414                                                 sk->sk_state == BT_CONNECT2))
 415                         return POLLIN | POLLRDNORM;
 416         }
 417
 418         return 0;
 419 }
 420
 421 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
 422 {
 423         struct sock *sk = sock->sk;
 424         unsigned int mask = 0;
 425
 426         BT_DBG("sock %p, sk %p", sock, sk);
 427
 428         poll_wait(file, sk_sleep(sk), wait);
 429
 430         if (sk->sk_state == BT_LISTEN)
 431                 return bt_accept_poll(sk);
 432
 433         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 434                 mask |= POLLERR;
 435
 436         if (sk->sk_shutdown & RCV_SHUTDOWN)
 437                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 438
 439         if (sk->sk_shutdown == SHUTDOWN_MASK)
 440                 mask |= POLLHUP;
 441
 442         if (!skb_queue_empty(&sk->sk_receive_queue))
 443                 mask |= POLLIN | POLLRDNORM;
 444
 445         if (sk->sk_state == BT_CLOSED)
 446                 mask |= POLLHUP;
 447
 448         if (sk->sk_state == BT_CONNECT ||
 449                         sk->sk_state == BT_CONNECT2 ||
 450                         sk->sk_state == BT_CONFIG)
 451                 return mask;
 452
 453         if (sock_writeable(sk))
 454                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 455         else
 456                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 457
 458         return mask;
 459 }
 460 EXPORT_SYMBOL(bt_sock_poll);
 461
 462 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 463 {
 464         struct sock *sk = sock->sk;
 465         struct sk_buff *skb;
 466         long amount;
 467         int err;
 468
 469         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 470
 471         switch (cmd) {
 472         case TIOCOUTQ:
 473                 if (sk->sk_state == BT_LISTEN)
 474                         return -EINVAL;
 475
 476                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 477                 if (amount < 0)
 478                         amount = 0;
 479                 err = put_user(amount, (int __user *) arg);
 480                 break;
 481
 482         case TIOCINQ:
 483                 if (sk->sk_state == BT_LISTEN)
 484                         return -EINVAL;
 485
 486                 lock_sock(sk);
 487                 skb = skb_peek(&sk->sk_receive_queue);
 488                 amount = skb ? skb->len : 0;
 489                 release_sock(sk);
 490                 err = put_user(amount, (int __user *) arg);
 491                 break;
 492
 493         case SIOCGSTAMP:
 494                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 495                 break;
 496
 497         case SIOCGSTAMPNS:
 498                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 499                 break;
 500
 501         default:
 502                 err = -ENOIOCTLCMD;
 503                 break;
 504         }
 505
 506         return err;
 507 }
 508 EXPORT_SYMBOL(bt_sock_ioctl);
 509
 510 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 511 {
 512         DECLARE_WAITQUEUE(wait, current);
 513         int err = 0;
 514
 515         BT_DBG("sk %p", sk);
 516
 517         add_wait_queue(sk_sleep(sk), &wait);
 518         set_current_state(TASK_INTERRUPTIBLE);
 519         while (sk->sk_state != state) {
 520                 if (!timeo) {
 521                         err = -EINPROGRESS;
 522                         break;
 523                 }
 524
 525                 if (signal_pending(current)) {
 526                         err = sock_intr_errno(timeo);
 527                         break;
 528                 }
 529
 530                 release_sock(sk);
 531                 timeo = schedule_timeout(timeo);
 532                 lock_sock(sk);
 533                 set_current_state(TASK_INTERRUPTIBLE);
 534
 535                 err = sock_error(sk);
 536                 if (err)
 537                         break;
 538         }
 539         __set_current_state(TASK_RUNNING);
 540         remove_wait_queue(sk_sleep(sk), &wait);
 541         return err;
 542 }
 543 EXPORT_SYMBOL(bt_sock_wait_state);
 544
 545 static struct net_proto_family bt_sock_family_ops = {
 546         .owner  = THIS_MODULE,
 547         .family = PF_BLUETOOTH,
 548         .create = bt_sock_create,
 549 };
 550
 551 static int __init bt_init(void)
 552 {
 553         int err;
 554
 555         BT_INFO("Core ver %s", VERSION);
 556
 557         err = bt_sysfs_init();
 558         if (err < 0)
 559                 return err;
 560
 561         err = sock_register(&bt_sock_family_ops);
 562         if (err < 0) {
 563                 bt_sysfs_cleanup();
 564                 return err;
 565         }
 566
 567         BT_INFO("HCI device and connection manager initialized");
 568
 569         err = hci_sock_init();
 570         if (err < 0)
 571                 goto error;
 572
 573         err = l2cap_init();
 574         if (err < 0)
 575                 goto sock_err;
 576
 577         err = sco_init();
 578         if (err < 0) {
 579                 l2cap_exit();
 580                 goto sock_err;
 581         }
 582
 583         return 0;
 584
 585 sock_err:
 586         hci_sock_cleanup();
 587
 588 error:
 589         sock_unregister(PF_BLUETOOTH);
 590         bt_sysfs_cleanup();
 591
 592         return err;
 593 }
 594
 595 static void __exit bt_exit(void)
 596 {
 597
 598         sco_exit();
 599
 600         l2cap_exit();
 601
 602         hci_sock_cleanup();
 603
 604         sock_unregister(PF_BLUETOOTH);
 605
 606         bt_sysfs_cleanup();
 607 }
 608
 609 subsys_initcall(bt_init);
 610 module_exit(bt_exit);
 611
 612 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 613 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 614 MODULE_VERSION(VERSION);
 615 MODULE_LICENSE("GPL");
 616 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);