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