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 == SHUTDOWN_MASK) 242 mask |= POLLHUP; 243 244 if (!skb_queue_empty(&sk->sk_receive_queue) || 245 (sk->sk_shutdown & RCV_SHUTDOWN)) 246 mask |= POLLIN | POLLRDNORM; 247 248 if (sk->sk_state == BT_CLOSED) 249 mask |= POLLHUP; 250 251 if (sk->sk_state == BT_CONNECT || 252 sk->sk_state == BT_CONNECT2 || 253 sk->sk_state == BT_CONFIG) 254 return mask; 255 256 if (sock_writeable(sk)) 257 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 258 else 259 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 260 261 return mask; 262 } 263 EXPORT_SYMBOL(bt_sock_poll); 264 265 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) 266 { 267 DECLARE_WAITQUEUE(wait, current); 268 int err = 0; 269 270 BT_DBG("sk %p", sk); 271 272 add_wait_queue(sk->sk_sleep, &wait); 273 while (sk->sk_state != state) { 274 set_current_state(TASK_INTERRUPTIBLE); 275 276 if (!timeo) { 277 err = -EAGAIN; 278 break; 279 } 280 281 if (signal_pending(current)) { 282 err = sock_intr_errno(timeo); 283 break; 284 } 285 286 release_sock(sk); 287 timeo = schedule_timeout(timeo); 288 lock_sock(sk); 289 290 if (sk->sk_err) { 291 err = sock_error(sk); 292 break; 293 } 294 } 295 set_current_state(TASK_RUNNING); 296 remove_wait_queue(sk->sk_sleep, &wait); 297 return err; 298 } 299 EXPORT_SYMBOL(bt_sock_wait_state); 300 301 static struct net_proto_family bt_sock_family_ops = { 302 .owner = THIS_MODULE, 303 .family = PF_BLUETOOTH, 304 .create = bt_sock_create, 305 }; 306 307 static int __init bt_init(void) 308 { 309 BT_INFO("Core ver %s", VERSION); 310 311 sock_register(&bt_sock_family_ops); 312 313 BT_INFO("HCI device and connection manager initialized"); 314 315 bt_sysfs_init(); 316 317 hci_sock_init(); 318 319 return 0; 320 } 321 322 static void __exit bt_exit(void) 323 { 324 hci_sock_cleanup(); 325 326 bt_sysfs_cleanup(); 327 328 sock_unregister(PF_BLUETOOTH); 329 } 330 331 subsys_initcall(bt_init); 332 module_exit(bt_exit); 333 334 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>"); 335 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 336 MODULE_VERSION(VERSION); 337 MODULE_LICENSE("GPL"); 338 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 339