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