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/config.h>
  28 #include <linux/module.h>
  29
  30 #include <linux/types.h>
  31 #include <linux/list.h>
  32 #include <linux/errno.h>
  33 #include <linux/kernel.h>
  34 #include <linux/major.h>
  35 #include <linux/sched.h>
  36 #include <linux/slab.h>
  37 #include <linux/skbuff.h>
  38 #include <linux/init.h>
  39 #include <linux/poll.h>
  40 #include <linux/proc_fs.h>
  41 #include <net/sock.h>
  42
  43 #if defined(CONFIG_KMOD)
  44 #include <linux/kmod.h>
  45 #endif
  46
  47 #include <net/bluetooth/bluetooth.h>
  48
  49 #ifndef CONFIG_BT_SOCK_DEBUG
  50 #undef  BT_DBG
  51 #define BT_DBG(D...)
  52 #endif
  53
  54 #define VERSION "2.7"
  55
  56 struct proc_dir_entry *proc_bt;
  57 EXPORT_SYMBOL(proc_bt);
  58
  59 /* Bluetooth sockets */
  60 #define BT_MAX_PROTO    8
  61 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
  62
  63 static kmem_cache_t *bt_sock_cache;
  64
  65 int bt_sock_register(int proto, struct net_proto_family *ops)
  66 {
  67         if (proto < 0 || proto >= BT_MAX_PROTO)
  68                 return -EINVAL;
  69
  70         if (bt_proto[proto])
  71                 return -EEXIST;
  72
  73         bt_proto[proto] = ops;
  74         return 0;
  75 }
  76 EXPORT_SYMBOL(bt_sock_register);
  77
  78 int bt_sock_unregister(int proto)
  79 {
  80         if (proto < 0 || proto >= BT_MAX_PROTO)
  81                 return -EINVAL;
  82
  83         if (!bt_proto[proto])
  84                 return -ENOENT;
  85
  86         bt_proto[proto] = NULL;
  87         return 0;
  88 }
  89 EXPORT_SYMBOL(bt_sock_unregister);
  90
  91 static int bt_sock_create(struct socket *sock, int proto)
  92 {
  93         int err = 0;
  94
  95         if (proto < 0 || 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 EXPORT_SYMBOL(bt_sock_alloc);
 140
 141 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 142 {
 143         write_lock_bh(&l->lock);
 144         sk_add_node(sk, &l->head);
 145         write_unlock_bh(&l->lock);
 146 }
 147 EXPORT_SYMBOL(bt_sock_link);
 148
 149 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 150 {
 151         write_lock_bh(&l->lock);
 152         sk_del_node_init(sk);
 153         write_unlock_bh(&l->lock);
 154 }
 155 EXPORT_SYMBOL(bt_sock_unlink);
 156
 157 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 158 {
 159         BT_DBG("parent %p, sk %p", parent, sk);
 160
 161         sock_hold(sk);
 162         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 163         bt_sk(sk)->parent = parent;
 164         parent->sk_ack_backlog++;
 165 }
 166 EXPORT_SYMBOL(bt_accept_enqueue);
 167
 168 void bt_accept_unlink(struct sock *sk)
 169 {
 170         BT_DBG("sk %p state %d", sk, sk->sk_state);
 171
 172         list_del_init(&bt_sk(sk)->accept_q);
 173         bt_sk(sk)->parent->sk_ack_backlog--;
 174         bt_sk(sk)->parent = NULL;
 175         sock_put(sk);
 176 }
 177 EXPORT_SYMBOL(bt_accept_unlink);
 178
 179 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 180 {
 181         struct list_head *p, *n;
 182         struct sock *sk;
 183
 184         BT_DBG("parent %p", parent);
 185
 186         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 187                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 188
 189                 lock_sock(sk);
 190
 191                 /* FIXME: Is this check still needed */
 192                 if (sk->sk_state == BT_CLOSED) {
 193                         release_sock(sk);
 194                         bt_accept_unlink(sk);
 195                         continue;
 196                 }
 197
 198                 if (sk->sk_state == BT_CONNECTED || !newsock) {
 199                         bt_accept_unlink(sk);
 200                         if (newsock)
 201                                 sock_graft(sk, newsock);
 202                         release_sock(sk);
 203                         return sk;
 204                 }
 205
 206                 release_sock(sk);
 207         }
 208         return NULL;
 209 }
 210 EXPORT_SYMBOL(bt_accept_dequeue);
 211
 212 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 213         struct msghdr *msg, size_t len, int flags)
 214 {
 215         int noblock = flags & MSG_DONTWAIT;
 216         struct sock *sk = sock->sk;
 217         struct sk_buff *skb;
 218         size_t copied;
 219         int err;
 220
 221         BT_DBG("sock %p sk %p len %d", sock, sk, len);
 222
 223         if (flags & (MSG_OOB))
 224                 return -EOPNOTSUPP;
 225
 226         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
 227                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 228                         return 0;
 229                 return err;
 230         }
 231
 232         msg->msg_namelen = 0;
 233
 234         copied = skb->len;
 235         if (len < copied) {
 236                 msg->msg_flags |= MSG_TRUNC;
 237                 copied = len;
 238         }
 239
 240         skb->h.raw = skb->data;
 241         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 242
 243         skb_free_datagram(sk, skb);
 244
 245         return err ? : copied;
 246 }
 247 EXPORT_SYMBOL(bt_sock_recvmsg);
 248
 249 static inline unsigned int bt_accept_poll(struct sock *parent)
 250 {
 251         struct list_head *p, *n;
 252         struct sock *sk;
 253
 254         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 255                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 256                 if (sk->sk_state == BT_CONNECTED)
 257                         return POLLIN | POLLRDNORM;
 258         }
 259
 260         return 0;
 261 }
 262
 263 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 264 {
 265         struct sock *sk = sock->sk;
 266         unsigned int mask = 0;
 267
 268         BT_DBG("sock %p, sk %p", sock, sk);
 269
 270         poll_wait(file, sk->sk_sleep, wait);
 271
 272         if (sk->sk_state == BT_LISTEN)
 273                 return bt_accept_poll(sk);
 274
 275         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 276                 mask |= POLLERR;
 277
 278         if (sk->sk_shutdown == SHUTDOWN_MASK)
 279                 mask |= POLLHUP;
 280
 281         if (!skb_queue_empty(&sk->sk_receive_queue) ||
 282                         (sk->sk_shutdown & RCV_SHUTDOWN))
 283                 mask |= POLLIN | POLLRDNORM;
 284
 285         if (sk->sk_state == BT_CLOSED)
 286                 mask |= POLLHUP;
 287
 288         if (sk->sk_state == BT_CONNECT ||
 289                         sk->sk_state == BT_CONNECT2 ||
 290                         sk->sk_state == BT_CONFIG)
 291                 return mask;
 292
 293         if (sock_writeable(sk))
 294                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 295         else
 296                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 297
 298         return mask;
 299 }
 300 EXPORT_SYMBOL(bt_sock_poll);
 301
 302 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 303 {
 304         DECLARE_WAITQUEUE(wait, current);
 305         int err = 0;
 306
 307         BT_DBG("sk %p", sk);
 308
 309         add_wait_queue(sk->sk_sleep, &wait);
 310         while (sk->sk_state != state) {
 311                 set_current_state(TASK_INTERRUPTIBLE);
 312
 313                 if (!timeo) {
 314                         err = -EAGAIN;
 315                         break;
 316                 }
 317
 318                 if (signal_pending(current)) {
 319                         err = sock_intr_errno(timeo);
 320                         break;
 321                 }
 322
 323                 release_sock(sk);
 324                 timeo = schedule_timeout(timeo);
 325                 lock_sock(sk);
 326
 327                 if (sk->sk_err) {
 328                         err = sock_error(sk);
 329                         break;
 330                 }
 331         }
 332         set_current_state(TASK_RUNNING);
 333         remove_wait_queue(sk->sk_sleep, &wait);
 334         return err;
 335 }
 336 EXPORT_SYMBOL(bt_sock_wait_state);
 337
 338 static struct net_proto_family bt_sock_family_ops = {
 339         .owner  = THIS_MODULE,
 340         .family = PF_BLUETOOTH,
 341         .create = bt_sock_create,
 342 };
 343
 344 extern int hci_sock_init(void);
 345 extern int hci_sock_cleanup(void);
 346
 347 extern int bt_sysfs_init(void);
 348 extern int bt_sysfs_cleanup(void);
 349
 350 static int __init bt_init(void)
 351 {
 352         BT_INFO("Core ver %s", VERSION);
 353
 354         proc_bt = proc_mkdir("bluetooth", NULL);
 355         if (proc_bt)
 356                 proc_bt->owner = THIS_MODULE;
 357
 358         /* Init socket cache */
 359         bt_sock_cache = kmem_cache_create("bt_sock",
 360                         sizeof(struct bt_sock), 0,
 361                         SLAB_HWCACHE_ALIGN, NULL, NULL);
 362
 363         if (!bt_sock_cache) {
 364                 BT_ERR("Socket cache creation failed");
 365                 return -ENOMEM;
 366         }
 367
 368         sock_register(&bt_sock_family_ops);
 369
 370         BT_INFO("HCI device and connection manager initialized");
 371
 372         bt_sysfs_init();
 373
 374         hci_sock_init();
 375
 376         return 0;
 377 }
 378
 379 static void __exit bt_exit(void)
 380 {
 381         hci_sock_cleanup();
 382
 383         bt_sysfs_cleanup();
 384
 385         sock_unregister(PF_BLUETOOTH);
 386         kmem_cache_destroy(bt_sock_cache);
 387
 388         remove_proc_entry("bluetooth", NULL);
 389 }
 390
 391 subsys_initcall(bt_init);
 392 module_exit(bt_exit);
 393
 394 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
 395 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 396 MODULE_VERSION(VERSION);
 397 MODULE_LICENSE("GPL");
 398 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);