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 /*
  26  *  Bluetooth address family and sockets.
  27  *
  28  * $Id: af_bluetooth.c,v 1.3 2002/04/17 17:37:15 maxk Exp $
  29  */
  30 #define VERSION "2.4"
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34
  35 #include <linux/types.h>
  36 #include <linux/list.h>
  37 #include <linux/errno.h>
  38 #include <linux/kernel.h>
  39 #include <linux/major.h>
  40 #include <linux/sched.h>
  41 #include <linux/slab.h>
  42 #include <linux/skbuff.h>
  43 #include <linux/init.h>
  44 #include <linux/poll.h>
  45 #include <linux/proc_fs.h>
  46 #include <net/sock.h>
  47
  48 #if defined(CONFIG_KMOD)
  49 #include <linux/kmod.h>
  50 #endif
  51
  52 #include <net/bluetooth/bluetooth.h>
  53
  54 #ifndef CONFIG_BT_SOCK_DEBUG
  55 #undef  BT_DBG
  56 #define BT_DBG( A... )
  57 #endif
  58
  59 struct proc_dir_entry *proc_bt;
  60
  61 /* Bluetooth sockets */
  62 #define BT_MAX_PROTO    6
  63 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
  64
  65 static kmem_cache_t *bt_sock_cache;
  66
  67 int bt_sock_register(int proto, struct net_proto_family *ops)
  68 {
  69         if (proto >= BT_MAX_PROTO)
  70                 return -EINVAL;
  71
  72         if (bt_proto[proto])
  73                 return -EEXIST;
  74
  75         bt_proto[proto] = ops;
  76         return 0;
  77 }
  78
  79 int bt_sock_unregister(int proto)
  80 {
  81         if (proto >= BT_MAX_PROTO)
  82                 return -EINVAL;
  83
  84         if (!bt_proto[proto])
  85                 return -ENOENT;
  86
  87         bt_proto[proto] = NULL;
  88         return 0;
  89 }
  90
  91 static int bt_sock_create(struct socket *sock, int proto)
  92 {
  93         int err = 0;
  94
  95         if (proto >= BT_MAX_PROTO)
  96                 return -EINVAL;
  97
  98 #if defined(CONFIG_KMOD)
  99         if (!bt_proto[proto]) {
 100                 request_module("bt-proto-%d", proto);
 101         }
 102 #endif
 103         err = -EPROTONOSUPPORT;
 104         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 105                 err = bt_proto[proto]->create(sock, proto);
 106                 module_put(bt_proto[proto]->owner);
 107         }
 108         return err;
 109 }
 110
 111 struct sock *bt_sock_alloc(struct socket *sock, int proto, int pi_size, int prio)
 112 {
 113         struct sock *sk;
 114         void *pi;
 115
 116         sk = sk_alloc(PF_BLUETOOTH, prio, sizeof(struct bt_sock), bt_sock_cache);
 117         if (!sk)
 118                 return NULL;
 119
 120         if (pi_size) {
 121                 pi = kmalloc(pi_size, prio);
 122                 if (!pi) {
 123                         sk_free(sk);
 124                         return NULL;
 125                 }
 126                 memset(pi, 0, pi_size);
 127                 sk->sk_protinfo = pi;
 128         }
 129
 130         sock_init_data(sock, sk);
 131         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 132
 133         sk->sk_zapped   = 0;
 134         sk->sk_protocol = proto;
 135         sk->sk_state    = BT_OPEN;
 136
 137         return sk;
 138 }
 139
 140 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 141 {
 142         write_lock_bh(&l->lock);
 143         sk_add_node(sk, &l->head);
 144         write_unlock_bh(&l->lock);
 145 }
 146
 147 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 148 {
 149         write_lock_bh(&l->lock);
 150         sk_del_node_init(sk);
 151         write_unlock_bh(&l->lock);
 152 }
 153
 154 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 155 {
 156         BT_DBG("parent %p, sk %p", parent, sk);
 157
 158         sock_hold(sk);
 159         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 160         bt_sk(sk)->parent = parent;
 161         parent->sk_ack_backlog++;
 162 }
 163
 164 static void bt_accept_unlink(struct sock *sk)
 165 {
 166         BT_DBG("sk %p state %d", sk, sk->sk_state);
 167
 168         list_del_init(&bt_sk(sk)->accept_q);
 169         bt_sk(sk)->parent->sk_ack_backlog--;
 170         bt_sk(sk)->parent = NULL;
 171         sock_put(sk);
 172 }
 173
 174 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 175 {
 176         struct list_head *p, *n;
 177         struct sock *sk;
 178
 179         BT_DBG("parent %p", parent);
 180
 181         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 182                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 183
 184                 lock_sock(sk);
 185                 if (sk->sk_state == BT_CLOSED) {
 186                         release_sock(sk);
 187                         bt_accept_unlink(sk);
 188                         continue;
 189                 }
 190
 191                 if (sk->sk_state == BT_CONNECTED || !newsock) {
 192                         bt_accept_unlink(sk);
 193                         if (newsock)
 194                                 sock_graft(sk, newsock);
 195                         release_sock(sk);
 196                         return sk;
 197                 }
 198                 release_sock(sk);
 199         }
 200         return NULL;
 201 }
 202
 203 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 204         struct msghdr *msg, size_t len, int flags)
 205 {
 206         int noblock = flags & MSG_DONTWAIT;
 207         struct sock *sk = sock->sk;
 208         struct sk_buff *skb;
 209         size_t copied;
 210         int err;
 211
 212         BT_DBG("sock %p sk %p len %d", sock, sk, len);
 213
 214         if (flags & (MSG_OOB))
 215                 return -EOPNOTSUPP;
 216
 217         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
 218                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 219                         return 0;
 220                 return err;
 221         }
 222
 223         msg->msg_namelen = 0;
 224
 225         copied = skb->len;
 226         if (len < copied) {
 227                 msg->msg_flags |= MSG_TRUNC;
 228                 copied = len;
 229         }
 230
 231         skb->h.raw = skb->data;
 232         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 233
 234         skb_free_datagram(sk, skb);
 235
 236         return err ? : copied;
 237 }
 238
 239 static inline unsigned int bt_accept_poll(struct sock *parent)
 240 {
 241         struct list_head *p, *n;
 242         struct sock *sk;
 243
 244         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 245                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 246                 if (sk->sk_state == BT_CONNECTED)
 247                         return POLLIN | POLLRDNORM;
 248         }
 249
 250         return 0;
 251 }
 252
 253 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 254 {
 255         struct sock *sk = sock->sk;
 256         unsigned int mask = 0;
 257
 258         BT_DBG("sock %p, sk %p", sock, sk);
 259
 260         poll_wait(file, sk->sk_sleep, wait);
 261
 262         if (sk->sk_state == BT_LISTEN)
 263                 return bt_accept_poll(sk);
 264
 265         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 266                 mask |= POLLERR;
 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
 291 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 292 {
 293         DECLARE_WAITQUEUE(wait, current);
 294         int err = 0;
 295
 296         BT_DBG("sk %p", sk);
 297
 298         add_wait_queue(sk->sk_sleep, &wait);
 299         while (sk->sk_state != state) {
 300                 set_current_state(TASK_INTERRUPTIBLE);
 301
 302                 if (!timeo) {
 303                         err = -EAGAIN;
 304                         break;
 305                 }
 306
 307                 if (signal_pending(current)) {
 308                         err = sock_intr_errno(timeo);
 309                         break;
 310                 }
 311
 312                 release_sock(sk);
 313                 timeo = schedule_timeout(timeo);
 314                 lock_sock(sk);
 315
 316                 if (sk->sk_err) {
 317                         err = sock_error(sk);
 318                         break;
 319                 }
 320         }
 321         set_current_state(TASK_RUNNING);
 322         remove_wait_queue(sk->sk_sleep, &wait);
 323         return err;
 324 }
 325
 326 static struct net_proto_family bt_sock_family_ops = {
 327         .owner  = THIS_MODULE,
 328         .family = PF_BLUETOOTH,
 329         .create = bt_sock_create,
 330 };
 331
 332 extern int hci_sock_init(void);
 333 extern int hci_sock_cleanup(void);
 334
 335 extern int bt_sysfs_init(void);
 336 extern int bt_sysfs_cleanup(void);
 337
 338 static int __init bt_init(void)
 339 {
 340         BT_INFO("Core ver %s", VERSION);
 341
 342         proc_bt = proc_mkdir("bluetooth", NULL);
 343         if (proc_bt)
 344                 proc_bt->owner = THIS_MODULE;
 345
 346         /* Init socket cache */
 347         bt_sock_cache = kmem_cache_create("bt_sock",
 348                         sizeof(struct bt_sock), 0,
 349                         SLAB_HWCACHE_ALIGN, 0, 0);
 350
 351         if (!bt_sock_cache) {
 352                 BT_ERR("Socket cache creation failed");
 353                 return -ENOMEM;
 354         }
 355
 356         sock_register(&bt_sock_family_ops);
 357
 358         BT_INFO("HCI device and connection manager initialized");
 359
 360         bt_sysfs_init();
 361
 362         hci_sock_init();
 363
 364         return 0;
 365 }
 366
 367 static void __exit bt_exit(void)
 368 {
 369         hci_sock_cleanup();
 370
 371         bt_sysfs_cleanup();
 372
 373         sock_unregister(PF_BLUETOOTH);
 374         kmem_cache_destroy(bt_sock_cache);
 375
 376         remove_proc_entry("bluetooth", NULL);
 377 }
 378
 379 subsys_initcall(bt_init);
 380 module_exit(bt_exit);
 381
 382 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
 383 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 384 MODULE_VERSION(VERSION);
 385 MODULE_LICENSE("GPL");
 386 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);