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.5"
  55
  56 struct proc_dir_entry *proc_bt;
  57 EXPORT_SYMBOL(proc_bt);
  58
  59 /* Bluetooth sockets */
  60 #define BT_MAX_PROTO    7
  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 >= 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 >= 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 >= 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 static 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
 178 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 179 {
 180         struct list_head *p, *n;
 181         struct sock *sk;
 182
 183         BT_DBG("parent %p", parent);
 184
 185         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 186                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 187
 188                 lock_sock(sk);
 189                 if (sk->sk_state == BT_CLOSED) {
 190                         release_sock(sk);
 191                         bt_accept_unlink(sk);
 192                         continue;
 193                 }
 194
 195                 if (sk->sk_state == BT_CONNECTED || !newsock) {
 196                         bt_accept_unlink(sk);
 197                         if (newsock)
 198                                 sock_graft(sk, newsock);
 199                         release_sock(sk);
 200                         return sk;
 201                 }
 202                 release_sock(sk);
 203         }
 204         return NULL;
 205 }
 206 EXPORT_SYMBOL(bt_accept_dequeue);
 207
 208 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 209         struct msghdr *msg, size_t len, int flags)
 210 {
 211         int noblock = flags & MSG_DONTWAIT;
 212         struct sock *sk = sock->sk;
 213         struct sk_buff *skb;
 214         size_t copied;
 215         int err;
 216
 217         BT_DBG("sock %p sk %p len %d", sock, sk, len);
 218
 219         if (flags & (MSG_OOB))
 220                 return -EOPNOTSUPP;
 221
 222         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
 223                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 224                         return 0;
 225                 return err;
 226         }
 227
 228         msg->msg_namelen = 0;
 229
 230         copied = skb->len;
 231         if (len < copied) {
 232                 msg->msg_flags |= MSG_TRUNC;
 233                 copied = len;
 234         }
 235
 236         skb->h.raw = skb->data;
 237         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 238
 239         skb_free_datagram(sk, skb);
 240
 241         return err ? : copied;
 242 }
 243 EXPORT_SYMBOL(bt_sock_recvmsg);
 244
 245 static inline unsigned int bt_accept_poll(struct sock *parent)
 246 {
 247         struct list_head *p, *n;
 248         struct sock *sk;
 249
 250         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 251                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 252                 if (sk->sk_state == BT_CONNECTED)
 253                         return POLLIN | POLLRDNORM;
 254         }
 255
 256         return 0;
 257 }
 258
 259 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
 260 {
 261         struct sock *sk = sock->sk;
 262         unsigned int mask = 0;
 263
 264         BT_DBG("sock %p, sk %p", sock, sk);
 265
 266         poll_wait(file, sk->sk_sleep, wait);
 267
 268         if (sk->sk_state == BT_LISTEN)
 269                 return bt_accept_poll(sk);
 270
 271         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 272                 mask |= POLLERR;
 273
 274         if (sk->sk_shutdown == SHUTDOWN_MASK)
 275                 mask |= POLLHUP;
 276
 277         if (!skb_queue_empty(&sk->sk_receive_queue) ||
 278                         (sk->sk_shutdown & RCV_SHUTDOWN))
 279                 mask |= POLLIN | POLLRDNORM;
 280
 281         if (sk->sk_state == BT_CLOSED)
 282                 mask |= POLLHUP;
 283
 284         if (sk->sk_state == BT_CONNECT ||
 285                         sk->sk_state == BT_CONNECT2 ||
 286                         sk->sk_state == BT_CONFIG)
 287                 return mask;
 288
 289         if (sock_writeable(sk))
 290                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 291         else
 292                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 293
 294         return mask;
 295 }
 296 EXPORT_SYMBOL(bt_sock_poll);
 297
 298 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 299 {
 300         DECLARE_WAITQUEUE(wait, current);
 301         int err = 0;
 302
 303         BT_DBG("sk %p", sk);
 304
 305         add_wait_queue(sk->sk_sleep, &wait);
 306         while (sk->sk_state != state) {
 307                 set_current_state(TASK_INTERRUPTIBLE);
 308
 309                 if (!timeo) {
 310                         err = -EAGAIN;
 311                         break;
 312                 }
 313
 314                 if (signal_pending(current)) {
 315                         err = sock_intr_errno(timeo);
 316                         break;
 317                 }
 318
 319                 release_sock(sk);
 320                 timeo = schedule_timeout(timeo);
 321                 lock_sock(sk);
 322
 323                 if (sk->sk_err) {
 324                         err = sock_error(sk);
 325                         break;
 326                 }
 327         }
 328         set_current_state(TASK_RUNNING);
 329         remove_wait_queue(sk->sk_sleep, &wait);
 330         return err;
 331 }
 332 EXPORT_SYMBOL(bt_sock_wait_state);
 333
 334 static struct net_proto_family bt_sock_family_ops = {
 335         .owner  = THIS_MODULE,
 336         .family = PF_BLUETOOTH,
 337         .create = bt_sock_create,
 338 };
 339
 340 extern int hci_sock_init(void);
 341 extern int hci_sock_cleanup(void);
 342
 343 extern int bt_sysfs_init(void);
 344 extern int bt_sysfs_cleanup(void);
 345
 346 static int __init bt_init(void)
 347 {
 348         BT_INFO("Core ver %s", VERSION);
 349
 350         proc_bt = proc_mkdir("bluetooth", NULL);
 351         if (proc_bt)
 352                 proc_bt->owner = THIS_MODULE;
 353
 354         /* Init socket cache */
 355         bt_sock_cache = kmem_cache_create("bt_sock",
 356                         sizeof(struct bt_sock), 0,
 357                         SLAB_HWCACHE_ALIGN, 0, 0);
 358
 359         if (!bt_sock_cache) {
 360                 BT_ERR("Socket cache creation failed");
 361                 return -ENOMEM;
 362         }
 363
 364         sock_register(&bt_sock_family_ops);
 365
 366         BT_INFO("HCI device and connection manager initialized");
 367
 368         bt_sysfs_init();
 369
 370         hci_sock_init();
 371
 372         return 0;
 373 }
 374
 375 static void __exit bt_exit(void)
 376 {
 377         hci_sock_cleanup();
 378
 379         bt_sysfs_cleanup();
 380
 381         sock_unregister(PF_BLUETOOTH);
 382         kmem_cache_destroy(bt_sock_cache);
 383
 384         remove_proc_entry("bluetooth", NULL);
 385 }
 386
 387 subsys_initcall(bt_init);
 388 module_exit(bt_exit);
 389
 390 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
 391 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 392 MODULE_VERSION(VERSION);
 393 MODULE_LICENSE("GPL");
 394 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);