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); 370