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/slab.h>
  35 #include <linux/skbuff.h>
  36 #include <linux/init.h>
  37 #include <linux/poll.h>
  38 #include <net/sock.h>
  39 #include <asm/ioctls.h>
  40 #include <linux/kmod.h>
  41
  42 #include <net/bluetooth/bluetooth.h>
  43
  44 #ifndef CONFIG_BT_SOCK_DEBUG
  45 #undef  BT_DBG
  46 #define BT_DBG(D...)
  47 #endif
  48
  49 #define VERSION "2.14"
  50
  51 /* Bluetooth sockets */
  52 #define BT_MAX_PROTO    8
  53 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
  54 static DEFINE_RWLOCK(bt_proto_lock);
  55
  56 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  57 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
  58 static const char *bt_key_strings[BT_MAX_PROTO] = {
  59         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
  60         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
  61         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
  62         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  63         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
  64         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
  65         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
  66         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
  67 };
  68
  69 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
  70 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
  71         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
  72         "slock-AF_BLUETOOTH-BTPROTO_HCI",
  73         "slock-AF_BLUETOOTH-BTPROTO_SCO",
  74         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  75         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
  76         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
  77         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
  78         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
  79 };
  80
  81 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
  82 {
  83         struct sock *sk = sock->sk;
  84
  85         if (!sk)
  86                 return;
  87
  88         BUG_ON(sock_owned_by_user(sk));
  89
  90         sock_lock_init_class_and_name(sk,
  91                         bt_slock_key_strings[proto], &bt_slock_key[proto],
  92                                 bt_key_strings[proto], &bt_lock_key[proto]);
  93 }
  94 #else
  95 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
  96 {
  97 }
  98 #endif
  99
 100 int bt_sock_register(int proto, struct net_proto_family *ops)
 101 {
 102         int err = 0;
 103
 104         if (proto < 0 || proto >= BT_MAX_PROTO)
 105                 return -EINVAL;
 106
 107         write_lock(&bt_proto_lock);
 108
 109         if (bt_proto[proto])
 110                 err = -EEXIST;
 111         else
 112                 bt_proto[proto] = ops;
 113
 114         write_unlock(&bt_proto_lock);
 115
 116         return err;
 117 }
 118 EXPORT_SYMBOL(bt_sock_register);
 119
 120 int bt_sock_unregister(int proto)
 121 {
 122         int err = 0;
 123
 124         if (proto < 0 || proto >= BT_MAX_PROTO)
 125                 return -EINVAL;
 126
 127         write_lock(&bt_proto_lock);
 128
 129         if (!bt_proto[proto])
 130                 err = -ENOENT;
 131         else
 132                 bt_proto[proto] = NULL;
 133
 134         write_unlock(&bt_proto_lock);
 135
 136         return err;
 137 }
 138 EXPORT_SYMBOL(bt_sock_unregister);
 139
 140 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
 141 {
 142         int err;
 143
 144         if (net != &init_net)
 145                 return -EAFNOSUPPORT;
 146
 147         if (proto < 0 || proto >= BT_MAX_PROTO)
 148                 return -EINVAL;
 149
 150         if (!bt_proto[proto])
 151                 request_module("bt-proto-%d", proto);
 152
 153         err = -EPROTONOSUPPORT;
 154
 155         read_lock(&bt_proto_lock);
 156
 157         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 158                 err = bt_proto[proto]->create(net, sock, proto);
 159                 bt_sock_reclassify_lock(sock, proto);
 160                 module_put(bt_proto[proto]->owner);
 161         }
 162
 163         read_unlock(&bt_proto_lock);
 164
 165         return err;
 166 }
 167
 168 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 169 {
 170         write_lock_bh(&l->lock);
 171         sk_add_node(sk, &l->head);
 172         write_unlock_bh(&l->lock);
 173 }
 174 EXPORT_SYMBOL(bt_sock_link);
 175
 176 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 177 {
 178         write_lock_bh(&l->lock);
 179         sk_del_node_init(sk);
 180         write_unlock_bh(&l->lock);
 181 }
 182 EXPORT_SYMBOL(bt_sock_unlink);
 183
 184 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 185 {
 186         BT_DBG("parent %p, sk %p", parent, sk);
 187
 188         sock_hold(sk);
 189         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 190         bt_sk(sk)->parent = parent;
 191         parent->sk_ack_backlog++;
 192 }
 193 EXPORT_SYMBOL(bt_accept_enqueue);
 194
 195 void bt_accept_unlink(struct sock *sk)
 196 {
 197         BT_DBG("sk %p state %d", sk, sk->sk_state);
 198
 199         list_del_init(&bt_sk(sk)->accept_q);
 200         bt_sk(sk)->parent->sk_ack_backlog--;
 201         bt_sk(sk)->parent = NULL;
 202         sock_put(sk);
 203 }
 204 EXPORT_SYMBOL(bt_accept_unlink);
 205
 206 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 207 {
 208         struct list_head *p, *n;
 209         struct sock *sk;
 210
 211         BT_DBG("parent %p", parent);
 212
 213         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 214                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 215
 216                 lock_sock(sk);
 217
 218                 /* FIXME: Is this check still needed */
 219                 if (sk->sk_state == BT_CLOSED) {
 220                         release_sock(sk);
 221                         bt_accept_unlink(sk);
 222                         continue;
 223                 }
 224
 225                 if (sk->sk_state == BT_CONNECTED || !newsock) {
 226                         bt_accept_unlink(sk);
 227                         if (newsock)
 228                                 sock_graft(sk, newsock);
 229                         release_sock(sk);
 230                         return sk;
 231                 }
 232
 233                 release_sock(sk);
 234         }
 235         return NULL;
 236 }
 237 EXPORT_SYMBOL(bt_accept_dequeue);
 238
 239 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 240         struct msghdr *msg, size_t len, int flags)
 241 {
 242         int noblock = flags & MSG_DONTWAIT;
 243         struct sock *sk = sock->sk;
 244         struct sk_buff *skb;
 245         size_t copied;
 246         int err;
 247
 248         BT_DBG("sock %p sk %p len %d", sock, sk, len);
 249
 250         if (flags & (MSG_OOB))
 251                 return -EOPNOTSUPP;
 252
 253         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
 254                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 255                         return 0;
 256                 return err;
 257         }
 258
 259         msg->msg_namelen = 0;
 260
 261         copied = skb->len;
 262         if (len < copied) {
 263                 msg->msg_flags |= MSG_TRUNC;
 264                 copied = len;
 265         }
 266
 267         skb_reset_transport_header(skb);
 268         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 269         if (err == 0)
 270                 sock_recv_timestamp(msg, sk, skb);
 271
 272         skb_free_datagram(sk, skb);
 273
 274         return err ? : copied;
 275 }
 276 EXPORT_SYMBOL(bt_sock_recvmsg);
 277
 278 static inline unsigned int bt_accept_poll(struct sock *parent)
 279 {
 280         struct list_head *p, *n;
 281         struct sock *sk;
 282
 283         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 284                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 285                 if (sk->sk_state == BT_CONNECTED)
 286                         return POLLIN | POLLRDNORM;
 287         }
 288
 289         return 0;
 290 }
 291
 292 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 293 {
 294         struct sock *sk = sock->sk;
 295         unsigned int mask = 0;
 296
 297         BT_DBG("sock %p, sk %p", sock, sk);
 298
 299         poll_wait(file, sk->sk_sleep, wait);
 300
 301         if (sk->sk_state == BT_LISTEN)
 302                 return bt_accept_poll(sk);
 303
 304         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 305                 mask |= POLLERR;
 306
 307         if (sk->sk_shutdown & RCV_SHUTDOWN)
 308                 mask |= POLLRDHUP;
 309
 310         if (sk->sk_shutdown == SHUTDOWN_MASK)
 311                 mask |= POLLHUP;
 312
 313         if (!skb_queue_empty(&sk->sk_receive_queue) ||
 314                         (sk->sk_shutdown & RCV_SHUTDOWN))
 315                 mask |= POLLIN | POLLRDNORM;
 316
 317         if (sk->sk_state == BT_CLOSED)
 318                 mask |= POLLHUP;
 319
 320         if (sk->sk_state == BT_CONNECT ||
 321                         sk->sk_state == BT_CONNECT2 ||
 322                         sk->sk_state == BT_CONFIG)
 323                 return mask;
 324
 325         if (sock_writeable(sk))
 326                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 327         else
 328                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 329
 330         return mask;
 331 }
 332 EXPORT_SYMBOL(bt_sock_poll);
 333
 334 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 335 {
 336         struct sock *sk = sock->sk;
 337         struct sk_buff *skb;
 338         long amount;
 339         int err;
 340
 341         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 342
 343         switch (cmd) {
 344         case TIOCOUTQ:
 345                 if (sk->sk_state == BT_LISTEN)
 346                         return -EINVAL;
 347
 348                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
 349                 if (amount < 0)
 350                         amount = 0;
 351                 err = put_user(amount, (int __user *) arg);
 352                 break;
 353
 354         case TIOCINQ:
 355                 if (sk->sk_state == BT_LISTEN)
 356                         return -EINVAL;
 357
 358                 lock_sock(sk);
 359                 skb = skb_peek(&sk->sk_receive_queue);
 360                 amount = skb ? skb->len : 0;
 361                 release_sock(sk);
 362                 err = put_user(amount, (int __user *) arg);
 363                 break;
 364
 365         case SIOCGSTAMP:
 366                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 367                 break;
 368
 369         case SIOCGSTAMPNS:
 370                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 371                 break;
 372
 373         default:
 374                 err = -ENOIOCTLCMD;
 375                 break;
 376         }
 377
 378         return err;
 379 }
 380 EXPORT_SYMBOL(bt_sock_ioctl);
 381
 382 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 383 {
 384         DECLARE_WAITQUEUE(wait, current);
 385         int err = 0;
 386
 387         BT_DBG("sk %p", sk);
 388
 389         add_wait_queue(sk->sk_sleep, &wait);
 390         while (sk->sk_state != state) {
 391                 set_current_state(TASK_INTERRUPTIBLE);
 392
 393                 if (!timeo) {
 394                         err = -EINPROGRESS;
 395                         break;
 396                 }
 397
 398                 if (signal_pending(current)) {
 399                         err = sock_intr_errno(timeo);
 400                         break;
 401                 }
 402
 403                 release_sock(sk);
 404                 timeo = schedule_timeout(timeo);
 405                 lock_sock(sk);
 406
 407                 err = sock_error(sk);
 408                 if (err)
 409                         break;
 410         }
 411         set_current_state(TASK_RUNNING);
 412         remove_wait_queue(sk->sk_sleep, &wait);
 413         return err;
 414 }
 415 EXPORT_SYMBOL(bt_sock_wait_state);
 416
 417 static struct net_proto_family bt_sock_family_ops = {
 418         .owner  = THIS_MODULE,
 419         .family = PF_BLUETOOTH,
 420         .create = bt_sock_create,
 421 };
 422
 423 static int __init bt_init(void)
 424 {
 425         int err;
 426
 427         BT_INFO("Core ver %s", VERSION);
 428
 429         err = bt_sysfs_init();
 430         if (err < 0)
 431                 return err;
 432
 433         err = sock_register(&bt_sock_family_ops);
 434         if (err < 0) {
 435                 bt_sysfs_cleanup();
 436                 return err;
 437         }
 438
 439         BT_INFO("HCI device and connection manager initialized");
 440
 441         hci_sock_init();
 442
 443         return 0;
 444 }
 445
 446 static void __exit bt_exit(void)
 447 {
 448         hci_sock_cleanup();
 449
 450         sock_unregister(PF_BLUETOOTH);
 451
 452         bt_sysfs_cleanup();
 453 }
 454
 455 subsys_initcall(bt_init);
 456 module_exit(bt_exit);
 457
 458 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 459 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 460 MODULE_VERSION(VERSION);
 461 MODULE_LICENSE("GPL");
 462 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);