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