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