SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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_sk(parent)->defer_setup) {
 222                         bt_accept_unlink(sk);
 223                         if (newsock)
 224                                 sock_graft(sk, newsock);
 225                         release_sock(sk);
 226                         return sk;
 227                 }
 228
 229                 release_sock(sk);
 230         }
 231         return NULL;
 232 }
 233 EXPORT_SYMBOL(bt_accept_dequeue);
 234
 235 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 236                                 struct msghdr *msg, size_t len, int flags)
 237 {
 238         int noblock = flags & MSG_DONTWAIT;
 239         struct sock *sk = sock->sk;
 240         struct sk_buff *skb;
 241         size_t copied;
 242         int err;
 243
 244         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
 245
 246         if (flags & (MSG_OOB))
 247                 return -EOPNOTSUPP;
 248
 249         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
 250                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 251                         return 0;
 252                 return err;
 253         }
 254
 255         msg->msg_namelen = 0;
 256
 257         copied = skb->len;
 258         if (len < copied) {
 259                 msg->msg_flags |= MSG_TRUNC;
 260                 copied = len;
 261         }
 262
 263         skb_reset_transport_header(skb);
 264         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 265         if (err == 0)
 266                 sock_recv_timestamp(msg, sk, skb);
 267
 268         skb_free_datagram(sk, skb);
 269
 270         return err ? : copied;
 271 }
 272 EXPORT_SYMBOL(bt_sock_recvmsg);
 273
 274 static inline unsigned int bt_accept_poll(struct sock *parent)
 275 {
 276         struct list_head *p, *n;
 277         struct sock *sk;
 278
 279         if (bt_sk(parent)->defer_setup)
 280                 return POLLIN | POLLRDNORM;
 281
 282         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 283                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 284                 if (sk->sk_state == BT_CONNECTED)
 285                         return POLLIN | POLLRDNORM;
 286         }
 287
 288         return 0;
 289 }
 290
 291 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 292 {
 293         struct sock *sk = sock->sk;
 294         unsigned int mask = 0;
 295
 296         BT_DBG("sock %p, sk %p", sock, sk);
 297
 298         poll_wait(file, sk->sk_sleep, wait);
 299
 300         if (sk->sk_state == BT_LISTEN)
 301                 return bt_accept_poll(sk);
 302
 303         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 304                 mask |= POLLERR;
 305
 306         if (sk->sk_shutdown & RCV_SHUTDOWN)
 307                 mask |= POLLRDHUP;
 308
 309         if (sk->sk_shutdown == SHUTDOWN_MASK)
 310                 mask |= POLLHUP;
 311
 312         if (!skb_queue_empty(&sk->sk_receive_queue) ||
 313                         (sk->sk_shutdown & RCV_SHUTDOWN))
 314                 mask |= POLLIN | POLLRDNORM;
 315
 316         if (sk->sk_state == BT_CLOSED)
 317                 mask |= POLLHUP;
 318
 319         if (sk->sk_state == BT_CONNECT ||
 320                         sk->sk_state == BT_CONNECT2 ||
 321                         sk->sk_state == BT_CONFIG)
 322                 return mask;
 323
 324         if (sock_writeable(sk))
 325                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 326         else
 327                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 328
 329         return mask;
 330 }
 331 EXPORT_SYMBOL(bt_sock_poll);
 332
 333 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 334 {
 335         struct sock *sk = sock->sk;
 336         struct sk_buff *skb;
 337         long amount;
 338         int err;
 339
 340         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 341
 342         switch (cmd) {
 343         case TIOCOUTQ:
 344                 if (sk->sk_state == BT_LISTEN)
 345                         return -EINVAL;
 346
 347                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
 348                 if (amount < 0)
 349                         amount = 0;
 350                 err = put_user(amount, (int __user *) arg);
 351                 break;
 352
 353         case TIOCINQ:
 354                 if (sk->sk_state == BT_LISTEN)
 355                         return -EINVAL;
 356
 357                 lock_sock(sk);
 358                 skb = skb_peek(&sk->sk_receive_queue);
 359                 amount = skb ? skb->len : 0;
 360                 release_sock(sk);
 361                 err = put_user(amount, (int __user *) arg);
 362                 break;
 363
 364         case SIOCGSTAMP:
 365                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 366                 break;
 367
 368         case SIOCGSTAMPNS:
 369                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 370                 break;
 371
 372         default:
 373                 err = -ENOIOCTLCMD;
 374                 break;
 375         }
 376
 377         return err;
 378 }
 379 EXPORT_SYMBOL(bt_sock_ioctl);
 380
 381 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 382 {
 383         DECLARE_WAITQUEUE(wait, current);
 384         int err = 0;
 385
 386         BT_DBG("sk %p", sk);
 387
 388         add_wait_queue(sk->sk_sleep, &wait);
 389         while (sk->sk_state != state) {
 390                 set_current_state(TASK_INTERRUPTIBLE);
 391
 392                 if (!timeo) {
 393                         err = -EINPROGRESS;
 394                         break;
 395                 }
 396
 397                 if (signal_pending(current)) {
 398                         err = sock_intr_errno(timeo);
 399                         break;
 400                 }
 401
 402                 release_sock(sk);
 403                 timeo = schedule_timeout(timeo);
 404                 lock_sock(sk);
 405
 406                 err = sock_error(sk);
 407                 if (err)
 408                         break;
 409         }
 410         set_current_state(TASK_RUNNING);
 411         remove_wait_queue(sk->sk_sleep, &wait);
 412         return err;
 413 }
 414 EXPORT_SYMBOL(bt_sock_wait_state);
 415
 416 static struct net_proto_family bt_sock_family_ops = {
 417         .owner  = THIS_MODULE,
 418         .family = PF_BLUETOOTH,
 419         .create = bt_sock_create,
 420 };
 421
 422 static int __init bt_init(void)
 423 {
 424         int err;
 425
 426         BT_INFO("Core ver %s", VERSION);
 427
 428         err = bt_sysfs_init();
 429         if (err < 0)
 430                 return err;
 431
 432         err = sock_register(&bt_sock_family_ops);
 433         if (err < 0) {
 434                 bt_sysfs_cleanup();
 435                 return err;
 436         }
 437
 438         BT_INFO("HCI device and connection manager initialized");
 439
 440         hci_sock_init();
 441
 442         return 0;
 443 }
 444
 445 static void __exit bt_exit(void)
 446 {
 447         hci_sock_cleanup();
 448
 449         sock_unregister(PF_BLUETOOTH);
 450
 451         bt_sysfs_cleanup();
 452 }
 453
 454 subsys_initcall(bt_init);
 455 module_exit(bt_exit);
 456
 457 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 458 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 459 MODULE_VERSION(VERSION);
 460 MODULE_LICENSE("GPL");
 461 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);