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