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