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