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