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 net *net, struct socket *sock, int proto) 99 { 100 int err; 101 102 if (net != &init_net) 103 return -EAFNOSUPPORT; 104 105 if (proto < 0 || proto >= BT_MAX_PROTO) 106 return -EINVAL; 107 108 #if defined(CONFIG_KMOD) 109 if (!bt_proto[proto]) { 110 request_module("bt-proto-%d", proto); 111 } 112 #endif 113 114 err = -EPROTONOSUPPORT; 115 116 read_lock(&bt_proto_lock); 117 118 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) { 119 err = bt_proto[proto]->create(net, sock, proto); 120 module_put(bt_proto[proto]->owner); 121 } 122 123 read_unlock(&bt_proto_lock); 124 125 return err; 126 } 127 128 void bt_sock_link(struct bt_sock_list *l, struct sock *sk) 129 { 130 write_lock_bh(&l->lock); 131 sk_add_node(sk, &l->head); 132 write_unlock_bh(&l->lock); 133 } 134 EXPORT_SYMBOL(bt_sock_link); 135 136 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk) 137 { 138 write_lock_bh(&l->lock); 139 sk_del_node_init(sk); 140 write_unlock_bh(&l->lock); 141 } 142 EXPORT_SYMBOL(bt_sock_unlink); 143 144 void bt_accept_enqueue(struct sock *parent, struct sock *sk) 145 { 146 BT_DBG("parent %p, sk %p", parent, sk); 147 148 sock_hold(sk); 149 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q); 150 bt_sk(sk)->parent = parent; 151 parent->sk_ack_backlog++; 152 } 153 EXPORT_SYMBOL(bt_accept_enqueue); 154 155 void bt_accept_unlink(struct sock *sk) 156 { 157 BT_DBG("sk %p state %d", sk, sk->sk_state); 158 159 list_del_init(&bt_sk(sk)->accept_q); 160 bt_sk(sk)->parent->sk_ack_backlog--; 161 bt_sk(sk)->parent = NULL; 162 sock_put(sk); 163 } 164 EXPORT_SYMBOL(bt_accept_unlink); 165 166 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock) 167 { 168 struct list_head *p, *n; 169 struct sock *sk; 170 171 BT_DBG("parent %p", parent); 172 173 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 174 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 175 176 lock_sock(sk); 177 178 /* FIXME: Is this check still needed */ 179 if (sk->sk_state == BT_CLOSED) { 180 release_sock(sk); 181 bt_accept_unlink(sk); 182 continue; 183 } 184 185 if (sk->sk_state == BT_CONNECTED || !newsock) { 186 bt_accept_unlink(sk); 187 if (newsock) 188 sock_graft(sk, newsock); 189 release_sock(sk); 190 return sk; 191 } 192 193 release_sock(sk); 194 } 195 return NULL; 196 } 197 EXPORT_SYMBOL(bt_accept_dequeue); 198 199 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 200 struct msghdr *msg, size_t len, int flags) 201 { 202 int noblock = flags & MSG_DONTWAIT; 203 struct sock *sk = sock->sk; 204 struct sk_buff *skb; 205 size_t copied; 206 int err; 207 208 BT_DBG("sock %p sk %p len %d", sock, sk, len); 209 210 if (flags & (MSG_OOB)) 211 return -EOPNOTSUPP; 212 213 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) { 214 if (sk->sk_shutdown & RCV_SHUTDOWN) 215 return 0; 216 return err; 217 } 218 219 msg->msg_namelen = 0; 220 221 copied = skb->len; 222 if (len < copied) { 223 msg->msg_flags |= MSG_TRUNC; 224 copied = len; 225 } 226 227 skb_reset_transport_header(skb); 228 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 229 230 skb_free_datagram(sk, skb); 231 232 return err ? : copied; 233 } 234 EXPORT_SYMBOL(bt_sock_recvmsg); 235 236 static inline unsigned int bt_accept_poll(struct sock *parent) 237 { 238 struct list_head *p, *n; 239 struct sock *sk; 240 241 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 242 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 243 if (sk->sk_state == BT_CONNECTED) 244 return POLLIN | POLLRDNORM; 245 } 246 247 return 0; 248 } 249 250 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait) 251 { 252 struct sock *sk = sock->sk; 253 unsigned int mask = 0; 254 255 BT_DBG("sock %p, sk %p", sock, sk); 256 257 poll_wait(file, sk->sk_sleep, wait); 258 259 if (sk->sk_state == BT_LISTEN) 260 return bt_accept_poll(sk); 261 262 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 263 mask |= POLLERR; 264 265 if (sk->sk_shutdown & RCV_SHUTDOWN) 266 mask |= POLLRDHUP; 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 EXPORT_SYMBOL(bt_sock_poll); 291 292 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) 293 { 294 DECLARE_WAITQUEUE(wait, current); 295 int err = 0; 296 297 BT_DBG("sk %p", sk); 298 299 add_wait_queue(sk->sk_sleep, &wait); 300 while (sk->sk_state != state) { 301 set_current_state(TASK_INTERRUPTIBLE); 302 303 if (!timeo) { 304 err = -EINPROGRESS; 305 break; 306 } 307 308 if (signal_pending(current)) { 309 err = sock_intr_errno(timeo); 310 break; 311 } 312 313 release_sock(sk); 314 timeo = schedule_timeout(timeo); 315 lock_sock(sk); 316 317 err = sock_error(sk); 318 if (err) 319 break; 320 } 321 set_current_state(TASK_RUNNING); 322 remove_wait_queue(sk->sk_sleep, &wait); 323 return err; 324 } 325 EXPORT_SYMBOL(bt_sock_wait_state); 326 327 static struct net_proto_family bt_sock_family_ops = { 328 .owner = THIS_MODULE, 329 .family = PF_BLUETOOTH, 330 .create = bt_sock_create, 331 }; 332 333 static int __init bt_init(void) 334 { 335 int err; 336 337 BT_INFO("Core ver %s", VERSION); 338 339 err = bt_sysfs_init(); 340 if (err < 0) 341 return err; 342 343 err = sock_register(&bt_sock_family_ops); 344 if (err < 0) { 345 bt_sysfs_cleanup(); 346 return err; 347 } 348 349 BT_INFO("HCI device and connection manager initialized"); 350 351 hci_sock_init(); 352 353 return 0; 354 } 355 356 static void __exit bt_exit(void) 357 { 358 hci_sock_cleanup(); 359 360 sock_unregister(PF_BLUETOOTH); 361 362 bt_sysfs_cleanup(); 363 } 364 365 subsys_initcall(bt_init); 366 module_exit(bt_exit); 367 368 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>"); 369 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 370 MODULE_VERSION(VERSION); 371 MODULE_LICENSE("GPL"); 372 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 373