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 err = sock_error(sk); 291 if (err) 292 break; 293 } 294 set_current_state(TASK_RUNNING); 295 remove_wait_queue(sk->sk_sleep, &wait); 296 return err; 297 } 298 EXPORT_SYMBOL(bt_sock_wait_state); 299 300 static struct net_proto_family bt_sock_family_ops = { 301 .owner = THIS_MODULE, 302 .family = PF_BLUETOOTH, 303 .create = bt_sock_create, 304 }; 305 306 static int __init bt_init(void) 307 { 308 BT_INFO("Core ver %s", VERSION); 309 310 sock_register(&bt_sock_family_ops); 311 312 BT_INFO("HCI device and connection manager initialized"); 313 314 bt_sysfs_init(); 315 316 hci_sock_init(); 317 318 return 0; 319 } 320 321 static void __exit bt_exit(void) 322 { 323 hci_sock_cleanup(); 324 325 bt_sysfs_cleanup(); 326 327 sock_unregister(PF_BLUETOOTH); 328 } 329 330 subsys_initcall(bt_init); 331 module_exit(bt_exit); 332 333 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>"); 334 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 335 MODULE_VERSION(VERSION); 336 MODULE_LICENSE("GPL"); 337 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 338