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