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