Pileus Git - ~andy/linux/blob - 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                     test_bit(BT_DEFER_SETUP, &bt_sk(parent)->flags)) {
 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                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
 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,
 422                           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 (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && 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);