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 #include <asm/ioctls.h> 29 30 #include <net/bluetooth/bluetooth.h> 31 #include <linux/proc_fs.h> 32 33 #define VERSION "2.16" 34 35 /* Bluetooth sockets */ 36 #define BT_MAX_PROTO 8 37 static const struct net_proto_family *bt_proto[BT_MAX_PROTO]; 38 static DEFINE_RWLOCK(bt_proto_lock); 39 40 static struct lock_class_key bt_lock_key[BT_MAX_PROTO]; 41 static const char *const bt_key_strings[BT_MAX_PROTO] = { 42 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP", 43 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI", 44 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO", 45 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM", 46 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP", 47 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP", 48 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP", 49 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP", 50 }; 51 52 static struct lock_class_key bt_slock_key[BT_MAX_PROTO]; 53 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = { 54 "slock-AF_BLUETOOTH-BTPROTO_L2CAP", 55 "slock-AF_BLUETOOTH-BTPROTO_HCI", 56 "slock-AF_BLUETOOTH-BTPROTO_SCO", 57 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM", 58 "slock-AF_BLUETOOTH-BTPROTO_BNEP", 59 "slock-AF_BLUETOOTH-BTPROTO_CMTP", 60 "slock-AF_BLUETOOTH-BTPROTO_HIDP", 61 "slock-AF_BLUETOOTH-BTPROTO_AVDTP", 62 }; 63 64 void bt_sock_reclassify_lock(struct sock *sk, int proto) 65 { 66 BUG_ON(!sk); 67 BUG_ON(sock_owned_by_user(sk)); 68 69 sock_lock_init_class_and_name(sk, 70 bt_slock_key_strings[proto], &bt_slock_key[proto], 71 bt_key_strings[proto], &bt_lock_key[proto]); 72 } 73 EXPORT_SYMBOL(bt_sock_reclassify_lock); 74 75 int bt_sock_register(int proto, const struct net_proto_family *ops) 76 { 77 int err = 0; 78 79 if (proto < 0 || proto >= BT_MAX_PROTO) 80 return -EINVAL; 81 82 write_lock(&bt_proto_lock); 83 84 if (bt_proto[proto]) 85 err = -EEXIST; 86 else 87 bt_proto[proto] = ops; 88 89 write_unlock(&bt_proto_lock); 90 91 return err; 92 } 93 EXPORT_SYMBOL(bt_sock_register); 94 95 void bt_sock_unregister(int proto) 96 { 97 if (proto < 0 || proto >= BT_MAX_PROTO) 98 return; 99 100 write_lock(&bt_proto_lock); 101 bt_proto[proto] = NULL; 102 write_unlock(&bt_proto_lock); 103 } 104 EXPORT_SYMBOL(bt_sock_unregister); 105 106 static int bt_sock_create(struct net *net, struct socket *sock, int proto, 107 int kern) 108 { 109 int err; 110 111 if (net != &init_net) 112 return -EAFNOSUPPORT; 113 114 if (proto < 0 || proto >= BT_MAX_PROTO) 115 return -EINVAL; 116 117 if (!bt_proto[proto]) 118 request_module("bt-proto-%d", proto); 119 120 err = -EPROTONOSUPPORT; 121 122 read_lock(&bt_proto_lock); 123 124 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) { 125 err = bt_proto[proto]->create(net, sock, proto, kern); 126 if (!err) 127 bt_sock_reclassify_lock(sock->sk, proto); 128 module_put(bt_proto[proto]->owner); 129 } 130 131 read_unlock(&bt_proto_lock); 132 133 return err; 134 } 135 136 void bt_sock_link(struct bt_sock_list *l, struct sock *sk) 137 { 138 write_lock(&l->lock); 139 sk_add_node(sk, &l->head); 140 write_unlock(&l->lock); 141 } 142 EXPORT_SYMBOL(bt_sock_link); 143 144 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk) 145 { 146 write_lock(&l->lock); 147 sk_del_node_init(sk); 148 write_unlock(&l->lock); 149 } 150 EXPORT_SYMBOL(bt_sock_unlink); 151 152 void bt_accept_enqueue(struct sock *parent, struct sock *sk) 153 { 154 BT_DBG("parent %p, sk %p", parent, sk); 155 156 sock_hold(sk); 157 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q); 158 bt_sk(sk)->parent = parent; 159 parent->sk_ack_backlog++; 160 } 161 EXPORT_SYMBOL(bt_accept_enqueue); 162 163 void bt_accept_unlink(struct sock *sk) 164 { 165 BT_DBG("sk %p state %d", sk, sk->sk_state); 166 167 list_del_init(&bt_sk(sk)->accept_q); 168 bt_sk(sk)->parent->sk_ack_backlog--; 169 bt_sk(sk)->parent = NULL; 170 sock_put(sk); 171 } 172 EXPORT_SYMBOL(bt_accept_unlink); 173 174 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock) 175 { 176 struct list_head *p, *n; 177 struct sock *sk; 178 179 BT_DBG("parent %p", parent); 180 181 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 182 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 183 184 lock_sock(sk); 185 186 /* FIXME: Is this check still needed */ 187 if (sk->sk_state == BT_CLOSED) { 188 release_sock(sk); 189 bt_accept_unlink(sk); 190 continue; 191 } 192 193 if (sk->sk_state == BT_CONNECTED || !newsock || 194 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) { 195 bt_accept_unlink(sk); 196 if (newsock) 197 sock_graft(sk, newsock); 198 199 release_sock(sk); 200 return sk; 201 } 202 203 release_sock(sk); 204 } 205 206 return NULL; 207 } 208 EXPORT_SYMBOL(bt_accept_dequeue); 209 210 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 211 struct msghdr *msg, size_t len, int flags) 212 { 213 int noblock = flags & MSG_DONTWAIT; 214 struct sock *sk = sock->sk; 215 struct sk_buff *skb; 216 size_t copied; 217 int err; 218 219 BT_DBG("sock %p sk %p len %zu", sock, sk, len); 220 221 if (flags & (MSG_OOB)) 222 return -EOPNOTSUPP; 223 224 msg->msg_namelen = 0; 225 226 skb = skb_recv_datagram(sk, flags, noblock, &err); 227 if (!skb) { 228 if (sk->sk_shutdown & RCV_SHUTDOWN) 229 return 0; 230 return err; 231 } 232 233 copied = skb->len; 234 if (len < copied) { 235 msg->msg_flags |= MSG_TRUNC; 236 copied = len; 237 } 238 239 skb_reset_transport_header(skb); 240 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 241 if (err == 0) 242 sock_recv_ts_and_drops(msg, sk, skb); 243 244 skb_free_datagram(sk, skb); 245 246 return err ? : copied; 247 } 248 EXPORT_SYMBOL(bt_sock_recvmsg); 249 250 static long bt_sock_data_wait(struct sock *sk, long timeo) 251 { 252 DECLARE_WAITQUEUE(wait, current); 253 254 add_wait_queue(sk_sleep(sk), &wait); 255 for (;;) { 256 set_current_state(TASK_INTERRUPTIBLE); 257 258 if (!skb_queue_empty(&sk->sk_receive_queue)) 259 break; 260 261 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN)) 262 break; 263 264 if (signal_pending(current) || !timeo) 265 break; 266 267 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 268 release_sock(sk); 269 timeo = schedule_timeout(timeo); 270 lock_sock(sk); 271 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 272 } 273 274 __set_current_state(TASK_RUNNING); 275 remove_wait_queue(sk_sleep(sk), &wait); 276 return timeo; 277 } 278 279 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock, 280 struct msghdr *msg, size_t size, int flags) 281 { 282 struct sock *sk = sock->sk; 283 int err = 0; 284 size_t target, copied = 0; 285 long timeo; 286 287 if (flags & MSG_OOB) 288 return -EOPNOTSUPP; 289 290 msg->msg_namelen = 0; 291 292 BT_DBG("sk %p size %zu", sk, size); 293 294 lock_sock(sk); 295 296 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size); 297 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 298 299 do { 300 struct sk_buff *skb; 301 int chunk; 302 303 skb = skb_dequeue(&sk->sk_receive_queue); 304 if (!skb) { 305 if (copied >= target) 306 break; 307 308 err = sock_error(sk); 309 if (err) 310 break; 311 if (sk->sk_shutdown & RCV_SHUTDOWN) 312 break; 313 314 err = -EAGAIN; 315 if (!timeo) 316 break; 317 318 timeo = bt_sock_data_wait(sk, timeo); 319 320 if (signal_pending(current)) { 321 err = sock_intr_errno(timeo); 322 goto out; 323 } 324 continue; 325 } 326 327 chunk = min_t(unsigned int, skb->len, size); 328 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) { 329 skb_queue_head(&sk->sk_receive_queue, skb); 330 if (!copied) 331 copied = -EFAULT; 332 break; 333 } 334 copied += chunk; 335 size -= chunk; 336 337 sock_recv_ts_and_drops(msg, sk, skb); 338 339 if (!(flags & MSG_PEEK)) { 340 int skb_len = skb_headlen(skb); 341 342 if (chunk <= skb_len) { 343 __skb_pull(skb, chunk); 344 } else { 345 struct sk_buff *frag; 346 347 __skb_pull(skb, skb_len); 348 chunk -= skb_len; 349 350 skb_walk_frags(skb, frag) { 351 if (chunk <= frag->len) { 352 /* Pulling partial data */ 353 skb->len -= chunk; 354 skb->data_len -= chunk; 355 __skb_pull(frag, chunk); 356 break; 357 } else if (frag->len) { 358 /* Pulling all frag data */ 359 chunk -= frag->len; 360 skb->len -= frag->len; 361 skb->data_len -= frag->len; 362 __skb_pull(frag, frag->len); 363 } 364 } 365 } 366 367 if (skb->len) { 368 skb_queue_head(&sk->sk_receive_queue, skb); 369 break; 370 } 371 kfree_skb(skb); 372 373 } else { 374 /* put message back and return */ 375 skb_queue_head(&sk->sk_receive_queue, skb); 376 break; 377 } 378 } while (size); 379 380 out: 381 release_sock(sk); 382 return copied ? : err; 383 } 384 EXPORT_SYMBOL(bt_sock_stream_recvmsg); 385 386 static inline unsigned int bt_accept_poll(struct sock *parent) 387 { 388 struct list_head *p, *n; 389 struct sock *sk; 390 391 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 392 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 393 if (sk->sk_state == BT_CONNECTED || 394 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) && 395 sk->sk_state == BT_CONNECT2)) 396 return POLLIN | POLLRDNORM; 397 } 398 399 return 0; 400 } 401 402 unsigned int bt_sock_poll(struct file *file, struct socket *sock, 403 poll_table *wait) 404 { 405 struct sock *sk = sock->sk; 406 unsigned int mask = 0; 407 408 BT_DBG("sock %p, sk %p", sock, sk); 409 410 poll_wait(file, sk_sleep(sk), wait); 411 412 if (sk->sk_state == BT_LISTEN) 413 return bt_accept_poll(sk); 414 415 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 416 mask |= POLLERR | 417 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0); 418 419 if (sk->sk_shutdown & RCV_SHUTDOWN) 420 mask |= POLLRDHUP | POLLIN | POLLRDNORM; 421 422 if (sk->sk_shutdown == SHUTDOWN_MASK) 423 mask |= POLLHUP; 424 425 if (!skb_queue_empty(&sk->sk_receive_queue)) 426 mask |= POLLIN | POLLRDNORM; 427 428 if (sk->sk_state == BT_CLOSED) 429 mask |= POLLHUP; 430 431 if (sk->sk_state == BT_CONNECT || 432 sk->sk_state == BT_CONNECT2 || 433 sk->sk_state == BT_CONFIG) 434 return mask; 435 436 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk)) 437 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 438 else 439 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 440 441 return mask; 442 } 443 EXPORT_SYMBOL(bt_sock_poll); 444 445 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 446 { 447 struct sock *sk = sock->sk; 448 struct sk_buff *skb; 449 long amount; 450 int err; 451 452 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg); 453 454 switch (cmd) { 455 case TIOCOUTQ: 456 if (sk->sk_state == BT_LISTEN) 457 return -EINVAL; 458 459 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 460 if (amount < 0) 461 amount = 0; 462 err = put_user(amount, (int __user *) arg); 463 break; 464 465 case TIOCINQ: 466 if (sk->sk_state == BT_LISTEN) 467 return -EINVAL; 468 469 lock_sock(sk); 470 skb = skb_peek(&sk->sk_receive_queue); 471 amount = skb ? skb->len : 0; 472 release_sock(sk); 473 err = put_user(amount, (int __user *) arg); 474 break; 475 476 case SIOCGSTAMP: 477 err = sock_get_timestamp(sk, (struct timeval __user *) arg); 478 break; 479 480 case SIOCGSTAMPNS: 481 err = sock_get_timestampns(sk, (struct timespec __user *) arg); 482 break; 483 484 default: 485 err = -ENOIOCTLCMD; 486 break; 487 } 488 489 return err; 490 } 491 EXPORT_SYMBOL(bt_sock_ioctl); 492 493 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) 494 { 495 DECLARE_WAITQUEUE(wait, current); 496 int err = 0; 497 498 BT_DBG("sk %p", sk); 499 500 add_wait_queue(sk_sleep(sk), &wait); 501 set_current_state(TASK_INTERRUPTIBLE); 502 while (sk->sk_state != state) { 503 if (!timeo) { 504 err = -EINPROGRESS; 505 break; 506 } 507 508 if (signal_pending(current)) { 509 err = sock_intr_errno(timeo); 510 break; 511 } 512 513 release_sock(sk); 514 timeo = schedule_timeout(timeo); 515 lock_sock(sk); 516 set_current_state(TASK_INTERRUPTIBLE); 517 518 err = sock_error(sk); 519 if (err) 520 break; 521 } 522 __set_current_state(TASK_RUNNING); 523 remove_wait_queue(sk_sleep(sk), &wait); 524 return err; 525 } 526 EXPORT_SYMBOL(bt_sock_wait_state); 527 528 #ifdef CONFIG_PROC_FS 529 struct bt_seq_state { 530 struct bt_sock_list *l; 531 }; 532 533 static void *bt_seq_start(struct seq_file *seq, loff_t *pos) 534 __acquires(seq->private->l->lock) 535 { 536 struct bt_seq_state *s = seq->private; 537 struct bt_sock_list *l = s->l; 538 539 read_lock(&l->lock); 540 return seq_hlist_start_head(&l->head, *pos); 541 } 542 543 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos) 544 { 545 struct bt_seq_state *s = seq->private; 546 struct bt_sock_list *l = s->l; 547 548 return seq_hlist_next(v, &l->head, pos); 549 } 550 551 static void bt_seq_stop(struct seq_file *seq, void *v) 552 __releases(seq->private->l->lock) 553 { 554 struct bt_seq_state *s = seq->private; 555 struct bt_sock_list *l = s->l; 556 557 read_unlock(&l->lock); 558 } 559 560 static int bt_seq_show(struct seq_file *seq, void *v) 561 { 562 struct bt_seq_state *s = seq->private; 563 struct bt_sock_list *l = s->l; 564 565 if (v == SEQ_START_TOKEN) { 566 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent"); 567 568 if (l->custom_seq_show) { 569 seq_putc(seq, ' '); 570 l->custom_seq_show(seq, v); 571 } 572 573 seq_putc(seq, '\n'); 574 } else { 575 struct sock *sk = sk_entry(v); 576 struct bt_sock *bt = bt_sk(sk); 577 578 seq_printf(seq, 579 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu", 580 sk, 581 atomic_read(&sk->sk_refcnt), 582 sk_rmem_alloc_get(sk), 583 sk_wmem_alloc_get(sk), 584 from_kuid(seq_user_ns(seq), sock_i_uid(sk)), 585 sock_i_ino(sk), 586 &bt->src, 587 &bt->dst, 588 bt->parent? sock_i_ino(bt->parent): 0LU); 589 590 if (l->custom_seq_show) { 591 seq_putc(seq, ' '); 592 l->custom_seq_show(seq, v); 593 } 594 595 seq_putc(seq, '\n'); 596 } 597 return 0; 598 } 599 600 static struct seq_operations bt_seq_ops = { 601 .start = bt_seq_start, 602 .next = bt_seq_next, 603 .stop = bt_seq_stop, 604 .show = bt_seq_show, 605 }; 606 607 static int bt_seq_open(struct inode *inode, struct file *file) 608 { 609 struct bt_sock_list *sk_list; 610 struct bt_seq_state *s; 611 612 sk_list = PDE_DATA(inode); 613 s = __seq_open_private(file, &bt_seq_ops, 614 sizeof(struct bt_seq_state)); 615 if (!s) 616 return -ENOMEM; 617 618 s->l = sk_list; 619 return 0; 620 } 621 622 static const struct file_operations bt_fops = { 623 .open = bt_seq_open, 624 .read = seq_read, 625 .llseek = seq_lseek, 626 .release = seq_release_private 627 }; 628 629 int bt_procfs_init(struct net *net, const char *name, 630 struct bt_sock_list* sk_list, 631 int (* seq_show)(struct seq_file *, void *)) 632 { 633 sk_list->custom_seq_show = seq_show; 634 635 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list)) 636 return -ENOMEM; 637 return 0; 638 } 639 640 void bt_procfs_cleanup(struct net *net, const char *name) 641 { 642 remove_proc_entry(name, net->proc_net); 643 } 644 #else 645 int bt_procfs_init(struct net *net, const char *name, 646 struct bt_sock_list* sk_list, 647 int (* seq_show)(struct seq_file *, void *)) 648 { 649 return 0; 650 } 651 652 void bt_procfs_cleanup(struct net *net, const char *name) 653 { 654 } 655 #endif 656 EXPORT_SYMBOL(bt_procfs_init); 657 EXPORT_SYMBOL(bt_procfs_cleanup); 658 659 static struct net_proto_family bt_sock_family_ops = { 660 .owner = THIS_MODULE, 661 .family = PF_BLUETOOTH, 662 .create = bt_sock_create, 663 }; 664 665 static int __init bt_init(void) 666 { 667 int err; 668 669 BT_INFO("Core ver %s", VERSION); 670 671 err = bt_sysfs_init(); 672 if (err < 0) 673 return err; 674 675 err = sock_register(&bt_sock_family_ops); 676 if (err < 0) { 677 bt_sysfs_cleanup(); 678 return err; 679 } 680 681 BT_INFO("HCI device and connection manager initialized"); 682 683 err = hci_sock_init(); 684 if (err < 0) 685 goto error; 686 687 err = l2cap_init(); 688 if (err < 0) 689 goto sock_err; 690 691 err = sco_init(); 692 if (err < 0) { 693 l2cap_exit(); 694 goto sock_err; 695 } 696 697 return 0; 698 699 sock_err: 700 hci_sock_cleanup(); 701 702 error: 703 sock_unregister(PF_BLUETOOTH); 704 bt_sysfs_cleanup(); 705 706 return err; 707 } 708 709 static void __exit bt_exit(void) 710 { 711 712 sco_exit(); 713 714 l2cap_exit(); 715 716 hci_sock_cleanup(); 717 718 sock_unregister(PF_BLUETOOTH); 719 720 bt_sysfs_cleanup(); 721 } 722 723 subsys_initcall(bt_init); 724 module_exit(bt_exit); 725 726 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 727 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 728 MODULE_VERSION(VERSION); 729 MODULE_LICENSE("GPL"); 730 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 731