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.15"
  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 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
  52 static const char *bt_key_strings[BT_MAX_PROTO] = {
  53         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
  54         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
  55         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
  56         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  57         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
  58         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
  59         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
  60         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
  61 };
  62
  63 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
  64 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
  65         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
  66         "slock-AF_BLUETOOTH-BTPROTO_HCI",
  67         "slock-AF_BLUETOOTH-BTPROTO_SCO",
  68         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  69         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
  70         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
  71         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
  72         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
  73 };
  74
  75 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
  76 {
  77         struct sock *sk = sock->sk;
  78
  79         if (!sk)
  80                 return;
  81
  82         BUG_ON(sock_owned_by_user(sk));
  83
  84         sock_lock_init_class_and_name(sk,
  85                         bt_slock_key_strings[proto], &bt_slock_key[proto],
  86                                 bt_key_strings[proto], &bt_lock_key[proto]);
  87 }
  88
  89 int bt_sock_register(int proto, struct net_proto_family *ops)
  90 {
  91         int err = 0;
  92
  93         if (proto < 0 || proto >= BT_MAX_PROTO)
  94                 return -EINVAL;
  95
  96         write_lock(&bt_proto_lock);
  97
  98         if (bt_proto[proto])
  99                 err = -EEXIST;
 100         else
 101                 bt_proto[proto] = ops;
 102
 103         write_unlock(&bt_proto_lock);
 104
 105         return err;
 106 }
 107 EXPORT_SYMBOL(bt_sock_register);
 108
 109 int bt_sock_unregister(int proto)
 110 {
 111         int err = 0;
 112
 113         if (proto < 0 || proto >= BT_MAX_PROTO)
 114                 return -EINVAL;
 115
 116         write_lock(&bt_proto_lock);
 117
 118         if (!bt_proto[proto])
 119                 err = -ENOENT;
 120         else
 121                 bt_proto[proto] = NULL;
 122
 123         write_unlock(&bt_proto_lock);
 124
 125         return err;
 126 }
 127 EXPORT_SYMBOL(bt_sock_unregister);
 128
 129 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
 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);
 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_timestamp(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 inline unsigned int bt_accept_poll(struct sock *parent)
 269 {
 270         struct list_head *p, *n;
 271         struct sock *sk;
 272
 273         if (bt_sk(parent)->defer_setup)
 274                 return POLLIN | POLLRDNORM;
 275
 276         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 277                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 278                 if (sk->sk_state == BT_CONNECTED)
 279                         return POLLIN | POLLRDNORM;
 280         }
 281
 282         return 0;
 283 }
 284
 285 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 286 {
 287         struct sock *sk = sock->sk;
 288         unsigned int mask = 0;
 289
 290         BT_DBG("sock %p, sk %p", sock, sk);
 291
 292         poll_wait(file, sk->sk_sleep, wait);
 293
 294         if (sk->sk_state == BT_LISTEN)
 295                 return bt_accept_poll(sk);
 296
 297         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 298                 mask |= POLLERR;
 299
 300         if (sk->sk_shutdown & RCV_SHUTDOWN)
 301                 mask |= POLLRDHUP;
 302
 303         if (sk->sk_shutdown == SHUTDOWN_MASK)
 304                 mask |= POLLHUP;
 305
 306         if (!skb_queue_empty(&sk->sk_receive_queue) ||
 307                         (sk->sk_shutdown & RCV_SHUTDOWN))
 308                 mask |= POLLIN | POLLRDNORM;
 309
 310         if (sk->sk_state == BT_CLOSED)
 311                 mask |= POLLHUP;
 312
 313         if (sk->sk_state == BT_CONNECT ||
 314                         sk->sk_state == BT_CONNECT2 ||
 315                         sk->sk_state == BT_CONFIG)
 316                 return mask;
 317
 318         if (sock_writeable(sk))
 319                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 320         else
 321                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 322
 323         return mask;
 324 }
 325 EXPORT_SYMBOL(bt_sock_poll);
 326
 327 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 328 {
 329         struct sock *sk = sock->sk;
 330         struct sk_buff *skb;
 331         long amount;
 332         int err;
 333
 334         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 335
 336         switch (cmd) {
 337         case TIOCOUTQ:
 338                 if (sk->sk_state == BT_LISTEN)
 339                         return -EINVAL;
 340
 341                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
 342                 if (amount < 0)
 343                         amount = 0;
 344                 err = put_user(amount, (int __user *) arg);
 345                 break;
 346
 347         case TIOCINQ:
 348                 if (sk->sk_state == BT_LISTEN)
 349                         return -EINVAL;
 350
 351                 lock_sock(sk);
 352                 skb = skb_peek(&sk->sk_receive_queue);
 353                 amount = skb ? skb->len : 0;
 354                 release_sock(sk);
 355                 err = put_user(amount, (int __user *) arg);
 356                 break;
 357
 358         case SIOCGSTAMP:
 359                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 360                 break;
 361
 362         case SIOCGSTAMPNS:
 363                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 364                 break;
 365
 366         default:
 367                 err = -ENOIOCTLCMD;
 368                 break;
 369         }
 370
 371         return err;
 372 }
 373 EXPORT_SYMBOL(bt_sock_ioctl);
 374
 375 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 376 {
 377         DECLARE_WAITQUEUE(wait, current);
 378         int err = 0;
 379
 380         BT_DBG("sk %p", sk);
 381
 382         add_wait_queue(sk->sk_sleep, &wait);
 383         while (sk->sk_state != state) {
 384                 set_current_state(TASK_INTERRUPTIBLE);
 385
 386                 if (!timeo) {
 387                         err = -EINPROGRESS;
 388                         break;
 389                 }
 390
 391                 if (signal_pending(current)) {
 392                         err = sock_intr_errno(timeo);
 393                         break;
 394                 }
 395
 396                 release_sock(sk);
 397                 timeo = schedule_timeout(timeo);
 398                 lock_sock(sk);
 399
 400                 err = sock_error(sk);
 401                 if (err)
 402                         break;
 403         }
 404         set_current_state(TASK_RUNNING);
 405         remove_wait_queue(sk->sk_sleep, &wait);
 406         return err;
 407 }
 408 EXPORT_SYMBOL(bt_sock_wait_state);
 409
 410 static struct net_proto_family bt_sock_family_ops = {
 411         .owner  = THIS_MODULE,
 412         .family = PF_BLUETOOTH,
 413         .create = bt_sock_create,
 414 };
 415
 416 static int __init bt_init(void)
 417 {
 418         int err;
 419
 420         BT_INFO("Core ver %s", VERSION);
 421
 422         err = bt_sysfs_init();
 423         if (err < 0)
 424                 return err;
 425
 426         err = sock_register(&bt_sock_family_ops);
 427         if (err < 0) {
 428                 bt_sysfs_cleanup();
 429                 return err;
 430         }
 431
 432         BT_INFO("HCI device and connection manager initialized");
 433
 434         hci_sock_init();
 435
 436         return 0;
 437 }
 438
 439 static void __exit bt_exit(void)
 440 {
 441         hci_sock_cleanup();
 442
 443         sock_unregister(PF_BLUETOOTH);
 444
 445         bt_sysfs_cleanup();
 446 }
 447
 448 subsys_initcall(bt_init);
 449 module_exit(bt_exit);
 450
 451 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 452 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 453 MODULE_VERSION(VERSION);
 454 MODULE_LICENSE("GPL");
 455 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);