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         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 (memcpy_toiovec(msg->msg_iov, skb->data, 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                         skb_pull(skb, chunk);
 360                         if (skb->len) {
 361                                 skb_queue_head(&sk->sk_receive_queue, skb);
 362                                 break;
 363                         }
 364                         kfree_skb(skb);
 365
 366                 } else {
 367                         /* put message back and return */
 368                         skb_queue_head(&sk->sk_receive_queue, skb);
 369                         break;
 370                 }
 371         } while (size);
 372
 373 out:
 374         release_sock(sk);
 375         return copied ? : err;
 376 }
 377 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 378
 379 static inline unsigned int bt_accept_poll(struct sock *parent)
 380 {
 381         struct list_head *p, *n;
 382         struct sock *sk;
 383
 384         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 385                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 386                 if (sk->sk_state == BT_CONNECTED ||
 387                                         (bt_sk(parent)->defer_setup &&
 388                                                 sk->sk_state == BT_CONNECT2))
 389                         return POLLIN | POLLRDNORM;
 390         }
 391
 392         return 0;
 393 }
 394
 395 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 396 {
 397         struct sock *sk = sock->sk;
 398         unsigned int mask = 0;
 399
 400         BT_DBG("sock %p, sk %p", sock, sk);
 401
 402         poll_wait(file, sk_sleep(sk), wait);
 403
 404         if (sk->sk_state == BT_LISTEN)
 405                 return bt_accept_poll(sk);
 406
 407         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 408                 mask |= POLLERR;
 409
 410         if (sk->sk_shutdown & RCV_SHUTDOWN)
 411                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 412
 413         if (sk->sk_shutdown == SHUTDOWN_MASK)
 414                 mask |= POLLHUP;
 415
 416         if (!skb_queue_empty(&sk->sk_receive_queue))
 417                 mask |= POLLIN | POLLRDNORM;
 418
 419         if (sk->sk_state == BT_CLOSED)
 420                 mask |= POLLHUP;
 421
 422         if (sk->sk_state == BT_CONNECT ||
 423                         sk->sk_state == BT_CONNECT2 ||
 424                         sk->sk_state == BT_CONFIG)
 425                 return mask;
 426
 427         if (sock_writeable(sk))
 428                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 429         else
 430                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 431
 432         return mask;
 433 }
 434 EXPORT_SYMBOL(bt_sock_poll);
 435
 436 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 437 {
 438         struct sock *sk = sock->sk;
 439         struct sk_buff *skb;
 440         long amount;
 441         int err;
 442
 443         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 444
 445         switch (cmd) {
 446         case TIOCOUTQ:
 447                 if (sk->sk_state == BT_LISTEN)
 448                         return -EINVAL;
 449
 450                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 451                 if (amount < 0)
 452                         amount = 0;
 453                 err = put_user(amount, (int __user *) arg);
 454                 break;
 455
 456         case TIOCINQ:
 457                 if (sk->sk_state == BT_LISTEN)
 458                         return -EINVAL;
 459
 460                 lock_sock(sk);
 461                 skb = skb_peek(&sk->sk_receive_queue);
 462                 amount = skb ? skb->len : 0;
 463                 release_sock(sk);
 464                 err = put_user(amount, (int __user *) arg);
 465                 break;
 466
 467         case SIOCGSTAMP:
 468                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 469                 break;
 470
 471         case SIOCGSTAMPNS:
 472                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 473                 break;
 474
 475         default:
 476                 err = -ENOIOCTLCMD;
 477                 break;
 478         }
 479
 480         return err;
 481 }
 482 EXPORT_SYMBOL(bt_sock_ioctl);
 483
 484 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 485 {
 486         DECLARE_WAITQUEUE(wait, current);
 487         int err = 0;
 488
 489         BT_DBG("sk %p", sk);
 490
 491         add_wait_queue(sk_sleep(sk), &wait);
 492         while (sk->sk_state != state) {
 493                 set_current_state(TASK_INTERRUPTIBLE);
 494
 495                 if (!timeo) {
 496                         err = -EINPROGRESS;
 497                         break;
 498                 }
 499
 500                 if (signal_pending(current)) {
 501                         err = sock_intr_errno(timeo);
 502                         break;
 503                 }
 504
 505                 release_sock(sk);
 506                 timeo = schedule_timeout(timeo);
 507                 lock_sock(sk);
 508
 509                 err = sock_error(sk);
 510                 if (err)
 511                         break;
 512         }
 513         set_current_state(TASK_RUNNING);
 514         remove_wait_queue(sk_sleep(sk), &wait);
 515         return err;
 516 }
 517 EXPORT_SYMBOL(bt_sock_wait_state);
 518
 519 static struct net_proto_family bt_sock_family_ops = {
 520         .owner  = THIS_MODULE,
 521         .family = PF_BLUETOOTH,
 522         .create = bt_sock_create,
 523 };
 524
 525 static int __init bt_init(void)
 526 {
 527         int err;
 528
 529         BT_INFO("Core ver %s", VERSION);
 530
 531         err = bt_sysfs_init();
 532         if (err < 0)
 533                 return err;
 534
 535         err = sock_register(&bt_sock_family_ops);
 536         if (err < 0) {
 537                 bt_sysfs_cleanup();
 538                 return err;
 539         }
 540
 541         BT_INFO("HCI device and connection manager initialized");
 542
 543         hci_sock_init();
 544
 545         return 0;
 546 }
 547
 548 static void __exit bt_exit(void)
 549 {
 550         hci_sock_cleanup();
 551
 552         sock_unregister(PF_BLUETOOTH);
 553
 554         bt_sysfs_cleanup();
 555 }
 556
 557 subsys_initcall(bt_init);
 558 module_exit(bt_exit);
 559
 560 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 561 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 562 MODULE_VERSION(VERSION);
 563 MODULE_LICENSE("GPL");
 564 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);