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