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.11"
  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         int err;
 339
 340         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 341
 342         switch (cmd) {
 343         case SIOCGSTAMP:
 344                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 345                 break;
 346
 347         case SIOCGSTAMPNS:
 348                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 349                 break;
 350
 351         default:
 352                 err = -ENOIOCTLCMD;
 353                 break;
 354         }
 355
 356         return err;
 357 }
 358 EXPORT_SYMBOL(bt_sock_ioctl);
 359
 360 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 361 {
 362         DECLARE_WAITQUEUE(wait, current);
 363         int err = 0;
 364
 365         BT_DBG("sk %p", sk);
 366
 367         add_wait_queue(sk->sk_sleep, &wait);
 368         while (sk->sk_state != state) {
 369                 set_current_state(TASK_INTERRUPTIBLE);
 370
 371                 if (!timeo) {
 372                         err = -EINPROGRESS;
 373                         break;
 374                 }
 375
 376                 if (signal_pending(current)) {
 377                         err = sock_intr_errno(timeo);
 378                         break;
 379                 }
 380
 381                 release_sock(sk);
 382                 timeo = schedule_timeout(timeo);
 383                 lock_sock(sk);
 384
 385                 err = sock_error(sk);
 386                 if (err)
 387                         break;
 388         }
 389         set_current_state(TASK_RUNNING);
 390         remove_wait_queue(sk->sk_sleep, &wait);
 391         return err;
 392 }
 393 EXPORT_SYMBOL(bt_sock_wait_state);
 394
 395 static struct net_proto_family bt_sock_family_ops = {
 396         .owner  = THIS_MODULE,
 397         .family = PF_BLUETOOTH,
 398         .create = bt_sock_create,
 399 };
 400
 401 static int __init bt_init(void)
 402 {
 403         int err;
 404
 405         BT_INFO("Core ver %s", VERSION);
 406
 407         err = bt_sysfs_init();
 408         if (err < 0)
 409                 return err;
 410
 411         err = sock_register(&bt_sock_family_ops);
 412         if (err < 0) {
 413                 bt_sysfs_cleanup();
 414                 return err;
 415         }
 416
 417         BT_INFO("HCI device and connection manager initialized");
 418
 419         hci_sock_init();
 420
 421         return 0;
 422 }
 423
 424 static void __exit bt_exit(void)
 425 {
 426         hci_sock_cleanup();
 427
 428         sock_unregister(PF_BLUETOOTH);
 429
 430         bt_sysfs_cleanup();
 431 }
 432
 433 subsys_initcall(bt_init);
 434 module_exit(bt_exit);
 435
 436 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
 437 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 438 MODULE_VERSION(VERSION);
 439 MODULE_LICENSE("GPL");
 440 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);