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