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