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 HCI sockets. */ 26 27 #include <linux/config.h> 28 #include <linux/module.h> 29 30 #include <linux/types.h> 31 #include <linux/errno.h> 32 #include <linux/kernel.h> 33 #include <linux/sched.h> 34 #include <linux/slab.h> 35 #include <linux/poll.h> 36 #include <linux/fcntl.h> 37 #include <linux/init.h> 38 #include <linux/skbuff.h> 39 #include <linux/workqueue.h> 40 #include <linux/interrupt.h> 41 #include <linux/socket.h> 42 #include <linux/ioctl.h> 43 #include <net/sock.h> 44 45 #include <asm/system.h> 46 #include <asm/uaccess.h> 47 #include <asm/unaligned.h> 48 49 #include <net/bluetooth/bluetooth.h> 50 #include <net/bluetooth/hci_core.h> 51 52 #ifndef CONFIG_BT_HCI_SOCK_DEBUG 53 #undef BT_DBG 54 #define BT_DBG(D...) 55 #endif 56 57 /* ----- HCI socket interface ----- */ 58 59 static inline int hci_test_bit(int nr, void *addr) 60 { 61 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31)); 62 } 63 64 /* Security filter */ 65 static struct hci_sec_filter hci_sec_filter = { 66 /* Packet types */ 67 0x10, 68 /* Events */ 69 { 0x1000d9fe, 0x0000b00c }, 70 /* Commands */ 71 { 72 { 0x0 }, 73 /* OGF_LINK_CTL */ 74 { 0xbe000006, 0x00000001, 0x000000, 0x00 }, 75 /* OGF_LINK_POLICY */ 76 { 0x00005200, 0x00000000, 0x000000, 0x00 }, 77 /* OGF_HOST_CTL */ 78 { 0xaab00200, 0x2b402aaa, 0x020154, 0x00 }, 79 /* OGF_INFO_PARAM */ 80 { 0x000002be, 0x00000000, 0x000000, 0x00 }, 81 /* OGF_STATUS_PARAM */ 82 { 0x000000ea, 0x00000000, 0x000000, 0x00 } 83 } 84 }; 85 86 static struct bt_sock_list hci_sk_list = { 87 .lock = RW_LOCK_UNLOCKED 88 }; 89 90 /* Send frame to RAW socket */ 91 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb) 92 { 93 struct sock *sk; 94 struct hlist_node *node; 95 96 BT_DBG("hdev %p len %d", hdev, skb->len); 97 98 read_lock(&hci_sk_list.lock); 99 sk_for_each(sk, node, &hci_sk_list.head) { 100 struct hci_filter *flt; 101 struct sk_buff *nskb; 102 103 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev) 104 continue; 105 106 /* Don't send frame to the socket it came from */ 107 if (skb->sk == sk) 108 continue; 109 110 /* Apply filter */ 111 flt = &hci_pi(sk)->filter; 112 113 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ? 114 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask)) 115 continue; 116 117 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) { 118 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS); 119 120 if (!hci_test_bit(evt, &flt->event_mask)) 121 continue; 122 123 if (flt->opcode && ((evt == HCI_EV_CMD_COMPLETE && 124 flt->opcode != *(__u16 *)(skb->data + 3)) || 125 (evt == HCI_EV_CMD_STATUS && 126 flt->opcode != *(__u16 *)(skb->data + 4)))) 127 continue; 128 } 129 130 if (!(nskb = skb_clone(skb, GFP_ATOMIC))) 131 continue; 132 133 /* Put type byte before the data */ 134 memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1); 135 136 if (sock_queue_rcv_skb(sk, nskb)) 137 kfree_skb(nskb); 138 } 139 read_unlock(&hci_sk_list.lock); 140 } 141 142 static int hci_sock_release(struct socket *sock) 143 { 144 struct sock *sk = sock->sk; 145 struct hci_dev *hdev = hci_pi(sk)->hdev; 146 147 BT_DBG("sock %p sk %p", sock, sk); 148 149 if (!sk) 150 return 0; 151 152 bt_sock_unlink(&hci_sk_list, sk); 153 154 if (hdev) { 155 atomic_dec(&hdev->promisc); 156 hci_dev_put(hdev); 157 } 158 159 sock_orphan(sk); 160 161 skb_queue_purge(&sk->sk_receive_queue); 162 skb_queue_purge(&sk->sk_write_queue); 163 164 sock_put(sk); 165 return 0; 166 } 167 168 /* Ioctls that require bound socket */ 169 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg) 170 { 171 struct hci_dev *hdev = hci_pi(sk)->hdev; 172 173 if (!hdev) 174 return -EBADFD; 175 176 switch (cmd) { 177 case HCISETRAW: 178 if (!capable(CAP_NET_ADMIN)) 179 return -EACCES; 180 181 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 182 return -EPERM; 183 184 if (arg) 185 set_bit(HCI_RAW, &hdev->flags); 186 else 187 clear_bit(HCI_RAW, &hdev->flags); 188 189 return 0; 190 191 case HCISETSECMGR: 192 if (!capable(CAP_NET_ADMIN)) 193 return -EACCES; 194 195 if (arg) 196 set_bit(HCI_SECMGR, &hdev->flags); 197 else 198 clear_bit(HCI_SECMGR, &hdev->flags); 199 200 return 0; 201 202 case HCIGETCONNINFO: 203 return hci_get_conn_info(hdev, (void __user *)arg); 204 205 default: 206 if (hdev->ioctl) 207 return hdev->ioctl(hdev, cmd, arg); 208 return -EINVAL; 209 } 210 } 211 212 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 213 { 214 struct sock *sk = sock->sk; 215 void __user *argp = (void __user *)arg; 216 int err; 217 218 BT_DBG("cmd %x arg %lx", cmd, arg); 219 220 switch (cmd) { 221 case HCIGETDEVLIST: 222 return hci_get_dev_list(argp); 223 224 case HCIGETDEVINFO: 225 return hci_get_dev_info(argp); 226 227 case HCIGETCONNLIST: 228 return hci_get_conn_list(argp); 229 230 case HCIDEVUP: 231 if (!capable(CAP_NET_ADMIN)) 232 return -EACCES; 233 return hci_dev_open(arg); 234 235 case HCIDEVDOWN: 236 if (!capable(CAP_NET_ADMIN)) 237 return -EACCES; 238 return hci_dev_close(arg); 239 240 case HCIDEVRESET: 241 if (!capable(CAP_NET_ADMIN)) 242 return -EACCES; 243 return hci_dev_reset(arg); 244 245 case HCIDEVRESTAT: 246 if (!capable(CAP_NET_ADMIN)) 247 return -EACCES; 248 return hci_dev_reset_stat(arg); 249 250 case HCISETSCAN: 251 case HCISETAUTH: 252 case HCISETENCRYPT: 253 case HCISETPTYPE: 254 case HCISETLINKPOL: 255 case HCISETLINKMODE: 256 case HCISETACLMTU: 257 case HCISETSCOMTU: 258 if (!capable(CAP_NET_ADMIN)) 259 return -EACCES; 260 return hci_dev_cmd(cmd, argp); 261 262 case HCIINQUIRY: 263 return hci_inquiry(argp); 264 265 default: 266 lock_sock(sk); 267 err = hci_sock_bound_ioctl(sk, cmd, arg); 268 release_sock(sk); 269 return err; 270 } 271 } 272 273 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) 274 { 275 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr; 276 struct sock *sk = sock->sk; 277 struct hci_dev *hdev = NULL; 278 int err = 0; 279 280 BT_DBG("sock %p sk %p", sock, sk); 281 282 if (!haddr || haddr->hci_family != AF_BLUETOOTH) 283 return -EINVAL; 284 285 lock_sock(sk); 286 287 if (hci_pi(sk)->hdev) { 288 err = -EALREADY; 289 goto done; 290 } 291 292 if (haddr->hci_dev != HCI_DEV_NONE) { 293 if (!(hdev = hci_dev_get(haddr->hci_dev))) { 294 err = -ENODEV; 295 goto done; 296 } 297 298 atomic_inc(&hdev->promisc); 299 } 300 301 hci_pi(sk)->hdev = hdev; 302 sk->sk_state = BT_BOUND; 303 304 done: 305 release_sock(sk); 306 return err; 307 } 308 309 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer) 310 { 311 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr; 312 struct sock *sk = sock->sk; 313 314 BT_DBG("sock %p sk %p", sock, sk); 315 316 lock_sock(sk); 317 318 *addr_len = sizeof(*haddr); 319 haddr->hci_family = AF_BLUETOOTH; 320 haddr->hci_dev = hci_pi(sk)->hdev->id; 321 322 release_sock(sk); 323 return 0; 324 } 325 326 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb) 327 { 328 __u32 mask = hci_pi(sk)->cmsg_mask; 329 330 if (mask & HCI_CMSG_DIR) { 331 int incoming = bt_cb(skb)->incoming; 332 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming); 333 } 334 335 if (mask & HCI_CMSG_TSTAMP) { 336 struct timeval tv; 337 338 skb_get_timestamp(skb, &tv); 339 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(tv), &tv); 340 } 341 } 342 343 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 344 struct msghdr *msg, size_t len, int flags) 345 { 346 int noblock = flags & MSG_DONTWAIT; 347 struct sock *sk = sock->sk; 348 struct sk_buff *skb; 349 int copied, err; 350 351 BT_DBG("sock %p, sk %p", sock, sk); 352 353 if (flags & (MSG_OOB)) 354 return -EOPNOTSUPP; 355 356 if (sk->sk_state == BT_CLOSED) 357 return 0; 358 359 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) 360 return err; 361 362 msg->msg_namelen = 0; 363 364 copied = skb->len; 365 if (len < copied) { 366 msg->msg_flags |= MSG_TRUNC; 367 copied = len; 368 } 369 370 skb->h.raw = skb->data; 371 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 372 373 hci_sock_cmsg(sk, msg, skb); 374 375 skb_free_datagram(sk, skb); 376 377 return err ? : copied; 378 } 379 380 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 381 struct msghdr *msg, size_t len) 382 { 383 struct sock *sk = sock->sk; 384 struct hci_dev *hdev; 385 struct sk_buff *skb; 386 int err; 387 388 BT_DBG("sock %p sk %p", sock, sk); 389 390 if (msg->msg_flags & MSG_OOB) 391 return -EOPNOTSUPP; 392 393 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE)) 394 return -EINVAL; 395 396 if (len < 4 || len > HCI_MAX_FRAME_SIZE) 397 return -EINVAL; 398 399 lock_sock(sk); 400 401 if (!(hdev = hci_pi(sk)->hdev)) { 402 err = -EBADFD; 403 goto done; 404 } 405 406 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err))) 407 goto done; 408 409 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 410 err = -EFAULT; 411 goto drop; 412 } 413 414 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data); 415 skb_pull(skb, 1); 416 skb->dev = (void *) hdev; 417 418 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) { 419 u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data)); 420 u16 ogf = hci_opcode_ogf(opcode); 421 u16 ocf = hci_opcode_ocf(opcode); 422 423 if (((ogf > HCI_SFLT_MAX_OGF) || 424 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) && 425 !capable(CAP_NET_RAW)) { 426 err = -EPERM; 427 goto drop; 428 } 429 430 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) { 431 skb_queue_tail(&hdev->raw_q, skb); 432 hci_sched_tx(hdev); 433 } else { 434 skb_queue_tail(&hdev->cmd_q, skb); 435 hci_sched_cmd(hdev); 436 } 437 } else { 438 if (!capable(CAP_NET_RAW)) { 439 err = -EPERM; 440 goto drop; 441 } 442 443 skb_queue_tail(&hdev->raw_q, skb); 444 hci_sched_tx(hdev); 445 } 446 447 err = len; 448 449 done: 450 release_sock(sk); 451 return err; 452 453 drop: 454 kfree_skb(skb); 455 goto done; 456 } 457 458 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len) 459 { 460 struct hci_ufilter uf = { .opcode = 0 }; 461 struct sock *sk = sock->sk; 462 int err = 0, opt = 0; 463 464 BT_DBG("sk %p, opt %d", sk, optname); 465 466 lock_sock(sk); 467 468 switch (optname) { 469 case HCI_DATA_DIR: 470 if (get_user(opt, (int __user *)optval)) { 471 err = -EFAULT; 472 break; 473 } 474 475 if (opt) 476 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR; 477 else 478 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR; 479 break; 480 481 case HCI_TIME_STAMP: 482 if (get_user(opt, (int __user *)optval)) { 483 err = -EFAULT; 484 break; 485 } 486 487 if (opt) 488 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP; 489 else 490 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP; 491 break; 492 493 case HCI_FILTER: 494 len = min_t(unsigned int, len, sizeof(uf)); 495 if (copy_from_user(&uf, optval, len)) { 496 err = -EFAULT; 497 break; 498 } 499 500 if (!capable(CAP_NET_RAW)) { 501 uf.type_mask &= hci_sec_filter.type_mask; 502 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0); 503 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1); 504 } 505 506 { 507 struct hci_filter *f = &hci_pi(sk)->filter; 508 509 f->type_mask = uf.type_mask; 510 f->opcode = uf.opcode; 511 *((u32 *) f->event_mask + 0) = uf.event_mask[0]; 512 *((u32 *) f->event_mask + 1) = uf.event_mask[1]; 513 } 514 break; 515 516 default: 517 err = -ENOPROTOOPT; 518 break; 519 } 520 521 release_sock(sk); 522 return err; 523 } 524 525 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 526 { 527 struct hci_ufilter uf; 528 struct sock *sk = sock->sk; 529 int len, opt; 530 531 if (get_user(len, optlen)) 532 return -EFAULT; 533 534 switch (optname) { 535 case HCI_DATA_DIR: 536 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR) 537 opt = 1; 538 else 539 opt = 0; 540 541 if (put_user(opt, optval)) 542 return -EFAULT; 543 break; 544 545 case HCI_TIME_STAMP: 546 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP) 547 opt = 1; 548 else 549 opt = 0; 550 551 if (put_user(opt, optval)) 552 return -EFAULT; 553 break; 554 555 case HCI_FILTER: 556 { 557 struct hci_filter *f = &hci_pi(sk)->filter; 558 559 uf.type_mask = f->type_mask; 560 uf.opcode = f->opcode; 561 uf.event_mask[0] = *((u32 *) f->event_mask + 0); 562 uf.event_mask[1] = *((u32 *) f->event_mask + 1); 563 } 564 565 len = min_t(unsigned int, len, sizeof(uf)); 566 if (copy_to_user(optval, &uf, len)) 567 return -EFAULT; 568 break; 569 570 default: 571 return -ENOPROTOOPT; 572 break; 573 } 574 575 return 0; 576 } 577 578 static struct proto_ops hci_sock_ops = { 579 .family = PF_BLUETOOTH, 580 .owner = THIS_MODULE, 581 .release = hci_sock_release, 582 .bind = hci_sock_bind, 583 .getname = hci_sock_getname, 584 .sendmsg = hci_sock_sendmsg, 585 .recvmsg = hci_sock_recvmsg, 586 .ioctl = hci_sock_ioctl, 587 .poll = datagram_poll, 588 .listen = sock_no_listen, 589 .shutdown = sock_no_shutdown, 590 .setsockopt = hci_sock_setsockopt, 591 .getsockopt = hci_sock_getsockopt, 592 .connect = sock_no_connect, 593 .socketpair = sock_no_socketpair, 594 .accept = sock_no_accept, 595 .mmap = sock_no_mmap 596 }; 597 598 static struct proto hci_sk_proto = { 599 .name = "HCI", 600 .owner = THIS_MODULE, 601 .obj_size = sizeof(struct hci_pinfo) 602 }; 603 604 static int hci_sock_create(struct socket *sock, int protocol) 605 { 606 struct sock *sk; 607 608 BT_DBG("sock %p", sock); 609 610 if (sock->type != SOCK_RAW) 611 return -ESOCKTNOSUPPORT; 612 613 sock->ops = &hci_sock_ops; 614 615 sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hci_sk_proto, 1); 616 if (!sk) 617 return -ENOMEM; 618 619 sock_init_data(sock, sk); 620 621 sock_reset_flag(sk, SOCK_ZAPPED); 622 623 sk->sk_protocol = protocol; 624 625 sock->state = SS_UNCONNECTED; 626 sk->sk_state = BT_OPEN; 627 628 bt_sock_link(&hci_sk_list, sk); 629 return 0; 630 } 631 632 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr) 633 { 634 struct hci_dev *hdev = (struct hci_dev *) ptr; 635 struct hci_ev_si_device ev; 636 637 BT_DBG("hdev %s event %ld", hdev->name, event); 638 639 /* Send event to sockets */ 640 ev.event = event; 641 ev.dev_id = hdev->id; 642 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev); 643 644 if (event == HCI_DEV_UNREG) { 645 struct sock *sk; 646 struct hlist_node *node; 647 648 /* Detach sockets from device */ 649 read_lock(&hci_sk_list.lock); 650 sk_for_each(sk, node, &hci_sk_list.head) { 651 bh_lock_sock(sk); 652 if (hci_pi(sk)->hdev == hdev) { 653 hci_pi(sk)->hdev = NULL; 654 sk->sk_err = EPIPE; 655 sk->sk_state = BT_OPEN; 656 sk->sk_state_change(sk); 657 658 hci_dev_put(hdev); 659 } 660 bh_unlock_sock(sk); 661 } 662 read_unlock(&hci_sk_list.lock); 663 } 664 665 return NOTIFY_DONE; 666 } 667 668 static struct net_proto_family hci_sock_family_ops = { 669 .family = PF_BLUETOOTH, 670 .owner = THIS_MODULE, 671 .create = hci_sock_create, 672 }; 673 674 static struct notifier_block hci_sock_nblock = { 675 .notifier_call = hci_sock_dev_event 676 }; 677 678 int __init hci_sock_init(void) 679 { 680 int err; 681 682 err = proto_register(&hci_sk_proto, 0); 683 if (err < 0) 684 return err; 685 686 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops); 687 if (err < 0) 688 goto error; 689 690 hci_register_notifier(&hci_sock_nblock); 691 692 BT_INFO("HCI socket layer initialized"); 693 694 return 0; 695 696 error: 697 BT_ERR("HCI socket registration failed"); 698 proto_unregister(&hci_sk_proto); 699 return err; 700 } 701 702 int __exit hci_sock_cleanup(void) 703 { 704 if (bt_sock_unregister(BTPROTO_HCI) < 0) 705 BT_ERR("HCI socket unregistration failed"); 706 707 hci_unregister_notifier(&hci_sock_nblock); 708 709 proto_unregister(&hci_sk_proto); 710 711 return 0; 712 } 713