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/skbuff.h> 35 #include <linux/init.h> 36 #include <linux/poll.h> 37 #include <net/sock.h> 38 #include <asm/ioctls.h> 39 #include <linux/kmod.h> 40 41 #include <net/bluetooth/bluetooth.h> 42 43 #define VERSION "2.15" 44 45 /* Bluetooth sockets */ 46 #define BT_MAX_PROTO 8 47 static const struct net_proto_family *bt_proto[BT_MAX_PROTO]; 48 static DEFINE_RWLOCK(bt_proto_lock); 49 50 static struct lock_class_key bt_lock_key[BT_MAX_PROTO]; 51 static const char *const bt_key_strings[BT_MAX_PROTO] = { 52 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP", 53 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI", 54 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO", 55 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM", 56 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP", 57 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP", 58 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP", 59 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP", 60 }; 61 62 static struct lock_class_key bt_slock_key[BT_MAX_PROTO]; 63 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = { 64 "slock-AF_BLUETOOTH-BTPROTO_L2CAP", 65 "slock-AF_BLUETOOTH-BTPROTO_HCI", 66 "slock-AF_BLUETOOTH-BTPROTO_SCO", 67 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM", 68 "slock-AF_BLUETOOTH-BTPROTO_BNEP", 69 "slock-AF_BLUETOOTH-BTPROTO_CMTP", 70 "slock-AF_BLUETOOTH-BTPROTO_HIDP", 71 "slock-AF_BLUETOOTH-BTPROTO_AVDTP", 72 }; 73 74 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto) 75 { 76 struct sock *sk = sock->sk; 77 78 if (!sk) 79 return; 80 81 BUG_ON(sock_owned_by_user(sk)); 82 83 sock_lock_init_class_and_name(sk, 84 bt_slock_key_strings[proto], &bt_slock_key[proto], 85 bt_key_strings[proto], &bt_lock_key[proto]); 86 } 87 88 int bt_sock_register(int proto, const struct net_proto_family *ops) 89 { 90 int err = 0; 91 92 if (proto < 0 || proto >= BT_MAX_PROTO) 93 return -EINVAL; 94 95 write_lock(&bt_proto_lock); 96 97 if (bt_proto[proto]) 98 err = -EEXIST; 99 else 100 bt_proto[proto] = ops; 101 102 write_unlock(&bt_proto_lock); 103 104 return err; 105 } 106 EXPORT_SYMBOL(bt_sock_register); 107 108 int bt_sock_unregister(int proto) 109 { 110 int err = 0; 111 112 if (proto < 0 || proto >= BT_MAX_PROTO) 113 return -EINVAL; 114 115 write_lock(&bt_proto_lock); 116 117 if (!bt_proto[proto]) 118 err = -ENOENT; 119 else 120 bt_proto[proto] = NULL; 121 122 write_unlock(&bt_proto_lock); 123 124 return err; 125 } 126 EXPORT_SYMBOL(bt_sock_unregister); 127 128 static int bt_sock_create(struct net *net, struct socket *sock, int proto, 129 int kern) 130 { 131 int err; 132 133 if (net != &init_net) 134 return -EAFNOSUPPORT; 135 136 if (proto < 0 || proto >= BT_MAX_PROTO) 137 return -EINVAL; 138 139 if (!bt_proto[proto]) 140 request_module("bt-proto-%d", proto); 141 142 err = -EPROTONOSUPPORT; 143 144 read_lock(&bt_proto_lock); 145 146 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) { 147 err = bt_proto[proto]->create(net, sock, proto, kern); 148 bt_sock_reclassify_lock(sock, proto); 149 module_put(bt_proto[proto]->owner); 150 } 151 152 read_unlock(&bt_proto_lock); 153 154 return err; 155 } 156 157 void bt_sock_link(struct bt_sock_list *l, struct sock *sk) 158 { 159 write_lock_bh(&l->lock); 160 sk_add_node(sk, &l->head); 161 write_unlock_bh(&l->lock); 162 } 163 EXPORT_SYMBOL(bt_sock_link); 164 165 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk) 166 { 167 write_lock_bh(&l->lock); 168 sk_del_node_init(sk); 169 write_unlock_bh(&l->lock); 170 } 171 EXPORT_SYMBOL(bt_sock_unlink); 172 173 void bt_accept_enqueue(struct sock *parent, struct sock *sk) 174 { 175 BT_DBG("parent %p, sk %p", parent, sk); 176 177 sock_hold(sk); 178 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q); 179 bt_sk(sk)->parent = parent; 180 parent->sk_ack_backlog++; 181 } 182 EXPORT_SYMBOL(bt_accept_enqueue); 183 184 void bt_accept_unlink(struct sock *sk) 185 { 186 BT_DBG("sk %p state %d", sk, sk->sk_state); 187 188 list_del_init(&bt_sk(sk)->accept_q); 189 bt_sk(sk)->parent->sk_ack_backlog--; 190 bt_sk(sk)->parent = NULL; 191 sock_put(sk); 192 } 193 EXPORT_SYMBOL(bt_accept_unlink); 194 195 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock) 196 { 197 struct list_head *p, *n; 198 struct sock *sk; 199 200 BT_DBG("parent %p", parent); 201 202 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 203 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 204 205 lock_sock(sk); 206 207 /* FIXME: Is this check still needed */ 208 if (sk->sk_state == BT_CLOSED) { 209 release_sock(sk); 210 bt_accept_unlink(sk); 211 continue; 212 } 213 214 if (sk->sk_state == BT_CONNECTED || !newsock || 215 bt_sk(parent)->defer_setup) { 216 bt_accept_unlink(sk); 217 if (newsock) 218 sock_graft(sk, newsock); 219 release_sock(sk); 220 return sk; 221 } 222 223 release_sock(sk); 224 } 225 return NULL; 226 } 227 EXPORT_SYMBOL(bt_accept_dequeue); 228 229 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 230 struct msghdr *msg, size_t len, int flags) 231 { 232 int noblock = flags & MSG_DONTWAIT; 233 struct sock *sk = sock->sk; 234 struct sk_buff *skb; 235 size_t copied; 236 int err; 237 238 BT_DBG("sock %p sk %p len %zu", sock, sk, len); 239 240 if (flags & (MSG_OOB)) 241 return -EOPNOTSUPP; 242 243 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) { 244 if (sk->sk_shutdown & RCV_SHUTDOWN) 245 return 0; 246 return err; 247 } 248 249 msg->msg_namelen = 0; 250 251 copied = skb->len; 252 if (len < copied) { 253 msg->msg_flags |= MSG_TRUNC; 254 copied = len; 255 } 256 257 skb_reset_transport_header(skb); 258 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 259 if (err == 0) 260 sock_recv_ts_and_drops(msg, sk, skb); 261 262 skb_free_datagram(sk, skb); 263 264 return err ? : copied; 265 } 266 EXPORT_SYMBOL(bt_sock_recvmsg); 267 268 static long bt_sock_data_wait(struct sock *sk, long timeo) 269 { 270 DECLARE_WAITQUEUE(wait, current); 271 272 add_wait_queue(sk_sleep(sk), &wait); 273 for (;;) { 274 set_current_state(TASK_INTERRUPTIBLE); 275 276 if (!skb_queue_empty(&sk->sk_receive_queue)) 277 break; 278 279 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN)) 280 break; 281 282 if (signal_pending(current) || !timeo) 283 break; 284 285 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 286 release_sock(sk); 287 timeo = schedule_timeout(timeo); 288 lock_sock(sk); 289 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 290 } 291 292 __set_current_state(TASK_RUNNING); 293 remove_wait_queue(sk_sleep(sk), &wait); 294 return timeo; 295 } 296 297 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock, 298 struct msghdr *msg, size_t size, int flags) 299 { 300 struct sock *sk = sock->sk; 301 int err = 0; 302 size_t target, copied = 0; 303 long timeo; 304 305 if (flags & MSG_OOB) 306 return -EOPNOTSUPP; 307 308 msg->msg_namelen = 0; 309 310 BT_DBG("sk %p size %zu", sk, size); 311 312 lock_sock(sk); 313 314 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size); 315 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 316 317 do { 318 struct sk_buff *skb; 319 int chunk; 320 321 skb = skb_dequeue(&sk->sk_receive_queue); 322 if (!skb) { 323 if (copied >= target) 324 break; 325 326 if ((err = sock_error(sk)) != 0) 327 break; 328 if (sk->sk_shutdown & RCV_SHUTDOWN) 329 break; 330 331 err = -EAGAIN; 332 if (!timeo) 333 break; 334 335 timeo = bt_sock_data_wait(sk, timeo); 336 337 if (signal_pending(current)) { 338 err = sock_intr_errno(timeo); 339 goto out; 340 } 341 continue; 342 } 343 344 chunk = min_t(unsigned int, skb->len, size); 345 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) { 346 skb_queue_head(&sk->sk_receive_queue, skb); 347 if (!copied) 348 copied = -EFAULT; 349 break; 350 } 351 copied += chunk; 352 size -= chunk; 353 354 sock_recv_ts_and_drops(msg, sk, skb); 355 356 if (!(flags & MSG_PEEK)) { 357 skb_pull(skb, chunk); 358 if (skb->len) { 359 skb_queue_head(&sk->sk_receive_queue, skb); 360 break; 361 } 362 kfree_skb(skb); 363 364 } else { 365 /* put message back and return */ 366 skb_queue_head(&sk->sk_receive_queue, skb); 367 break; 368 } 369 } while (size); 370 371 out: 372 release_sock(sk); 373 return copied ? : err; 374 } 375 EXPORT_SYMBOL(bt_sock_stream_recvmsg); 376 377 static inline unsigned int bt_accept_poll(struct sock *parent) 378 { 379 struct list_head *p, *n; 380 struct sock *sk; 381 382 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 383 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 384 if (sk->sk_state == BT_CONNECTED || 385 (bt_sk(parent)->defer_setup && 386 sk->sk_state == BT_CONNECT2)) 387 return POLLIN | POLLRDNORM; 388 } 389 390 return 0; 391 } 392 393 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait) 394 { 395 struct sock *sk = sock->sk; 396 unsigned int mask = 0; 397 398 BT_DBG("sock %p, sk %p", sock, sk); 399 400 poll_wait(file, sk_sleep(sk), wait); 401 402 if (sk->sk_state == BT_LISTEN) 403 return bt_accept_poll(sk); 404 405 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 406 mask |= POLLERR; 407 408 if (sk->sk_shutdown & RCV_SHUTDOWN) 409 mask |= POLLRDHUP | POLLIN | POLLRDNORM; 410 411 if (sk->sk_shutdown == SHUTDOWN_MASK) 412 mask |= POLLHUP; 413 414 if (!skb_queue_empty(&sk->sk_receive_queue)) 415 mask |= POLLIN | POLLRDNORM; 416 417 if (sk->sk_state == BT_CLOSED) 418 mask |= POLLHUP; 419 420 if (sk->sk_state == BT_CONNECT || 421 sk->sk_state == BT_CONNECT2 || 422 sk->sk_state == BT_CONFIG) 423 return mask; 424 425 if (sock_writeable(sk)) 426 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 427 else 428 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 429 430 return mask; 431 } 432 EXPORT_SYMBOL(bt_sock_poll); 433 434 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 435 { 436 struct sock *sk = sock->sk; 437 struct sk_buff *skb; 438 long amount; 439 int err; 440 441 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg); 442 443 switch (cmd) { 444 case TIOCOUTQ: 445 if (sk->sk_state == BT_LISTEN) 446 return -EINVAL; 447 448 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 449 if (amount < 0) 450 amount = 0; 451 err = put_user(amount, (int __user *) arg); 452 break; 453 454 case TIOCINQ: 455 if (sk->sk_state == BT_LISTEN) 456 return -EINVAL; 457 458 lock_sock(sk); 459 skb = skb_peek(&sk->sk_receive_queue); 460 amount = skb ? skb->len : 0; 461 release_sock(sk); 462 err = put_user(amount, (int __user *) arg); 463 break; 464 465 case SIOCGSTAMP: 466 err = sock_get_timestamp(sk, (struct timeval __user *) arg); 467 break; 468 469 case SIOCGSTAMPNS: 470 err = sock_get_timestampns(sk, (struct timespec __user *) arg); 471 break; 472 473 default: 474 err = -ENOIOCTLCMD; 475 break; 476 } 477 478 return err; 479 } 480 EXPORT_SYMBOL(bt_sock_ioctl); 481 482 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) 483 { 484 DECLARE_WAITQUEUE(wait, current); 485 int err = 0; 486 487 BT_DBG("sk %p", sk); 488 489 add_wait_queue(sk_sleep(sk), &wait); 490 while (sk->sk_state != state) { 491 set_current_state(TASK_INTERRUPTIBLE); 492 493 if (!timeo) { 494 err = -EINPROGRESS; 495 break; 496 } 497 498 if (signal_pending(current)) { 499 err = sock_intr_errno(timeo); 500 break; 501 } 502 503 release_sock(sk); 504 timeo = schedule_timeout(timeo); 505 lock_sock(sk); 506 507 err = sock_error(sk); 508 if (err) 509 break; 510 } 511 set_current_state(TASK_RUNNING); 512 remove_wait_queue(sk_sleep(sk), &wait); 513 return err; 514 } 515 EXPORT_SYMBOL(bt_sock_wait_state); 516 517 static struct net_proto_family bt_sock_family_ops = { 518 .owner = THIS_MODULE, 519 .family = PF_BLUETOOTH, 520 .create = bt_sock_create, 521 }; 522 523 static int __init bt_init(void) 524 { 525 int err; 526 527 BT_INFO("Core ver %s", VERSION); 528 529 err = bt_sysfs_init(); 530 if (err < 0) 531 return err; 532 533 err = sock_register(&bt_sock_family_ops); 534 if (err < 0) { 535 bt_sysfs_cleanup(); 536 return err; 537 } 538 539 BT_INFO("HCI device and connection manager initialized"); 540 541 hci_sock_init(); 542 543 return 0; 544 } 545 546 static void __exit bt_exit(void) 547 { 548 hci_sock_cleanup(); 549 550 sock_unregister(PF_BLUETOOTH); 551 552 bt_sysfs_cleanup(); 553 } 554 555 subsys_initcall(bt_init); 556 module_exit(bt_exit); 557 558 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 559 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 560 MODULE_VERSION(VERSION); 561 MODULE_LICENSE("GPL"); 562 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 563