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, 0x0000300c }, 70 /* Commands */ 71 { 72 { 0x0 }, 73 /* OGF_LINK_CTL */ 74 { 0xbe000006, 0x00000001, 0x0000, 0x00 }, 75 /* OGF_LINK_POLICY */ 76 { 0x00005200, 0x00000000, 0x0000, 0x00 }, 77 /* OGF_HOST_CTL */ 78 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 }, 79 /* OGF_INFO_PARAM */ 80 { 0x000002be, 0x00000000, 0x0000, 0x00 }, 81 /* OGF_STATUS_PARAM */ 82 { 0x000000ea, 0x00000000, 0x0000, 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((skb->pkt_type == HCI_VENDOR_PKT) ? 114 0 : (skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask)) 115 continue; 116 117 if (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), &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 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bt_cb(skb)->incoming); 332 333 if (mask & HCI_CMSG_TSTAMP) 334 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp); 335 } 336 337 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 338 struct msghdr *msg, size_t len, int flags) 339 { 340 int noblock = flags & MSG_DONTWAIT; 341 struct sock *sk = sock->sk; 342 struct sk_buff *skb; 343 int copied, err; 344 345 BT_DBG("sock %p, sk %p", sock, sk); 346 347 if (flags & (MSG_OOB)) 348 return -EOPNOTSUPP; 349 350 if (sk->sk_state == BT_CLOSED) 351 return 0; 352 353 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) 354 return err; 355 356 msg->msg_namelen = 0; 357 358 copied = skb->len; 359 if (len < copied) { 360 msg->msg_flags |= MSG_TRUNC; 361 copied = len; 362 } 363 364 skb->h.raw = skb->data; 365 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 366 367 hci_sock_cmsg(sk, msg, skb); 368 369 skb_free_datagram(sk, skb); 370 371 return err ? : copied; 372 } 373 374 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 375 struct msghdr *msg, size_t len) 376 { 377 struct sock *sk = sock->sk; 378 struct hci_dev *hdev; 379 struct sk_buff *skb; 380 int err; 381 382 BT_DBG("sock %p sk %p", sock, sk); 383 384 if (msg->msg_flags & MSG_OOB) 385 return -EOPNOTSUPP; 386 387 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE)) 388 return -EINVAL; 389 390 if (len < 4 || len > HCI_MAX_FRAME_SIZE) 391 return -EINVAL; 392 393 lock_sock(sk); 394 395 if (!(hdev = hci_pi(sk)->hdev)) { 396 err = -EBADFD; 397 goto done; 398 } 399 400 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err))) 401 goto done; 402 403 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 404 err = -EFAULT; 405 goto drop; 406 } 407 408 skb->pkt_type = *((unsigned char *) skb->data); 409 skb_pull(skb, 1); 410 skb->dev = (void *) hdev; 411 412 if (skb->pkt_type == HCI_COMMAND_PKT) { 413 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data)); 414 u16 ogf = hci_opcode_ogf(opcode); 415 u16 ocf = hci_opcode_ocf(opcode); 416 417 if (((ogf > HCI_SFLT_MAX_OGF) || 418 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) && 419 !capable(CAP_NET_RAW)) { 420 err = -EPERM; 421 goto drop; 422 } 423 424 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) { 425 skb_queue_tail(&hdev->raw_q, skb); 426 hci_sched_tx(hdev); 427 } else { 428 skb_queue_tail(&hdev->cmd_q, skb); 429 hci_sched_cmd(hdev); 430 } 431 } else { 432 if (!capable(CAP_NET_RAW)) { 433 err = -EPERM; 434 goto drop; 435 } 436 437 skb_queue_tail(&hdev->raw_q, skb); 438 hci_sched_tx(hdev); 439 } 440 441 err = len; 442 443 done: 444 release_sock(sk); 445 return err; 446 447 drop: 448 kfree_skb(skb); 449 goto done; 450 } 451 452 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len) 453 { 454 struct hci_ufilter uf = { .opcode = 0 }; 455 struct sock *sk = sock->sk; 456 int err = 0, opt = 0; 457 458 BT_DBG("sk %p, opt %d", sk, optname); 459 460 lock_sock(sk); 461 462 switch (optname) { 463 case HCI_DATA_DIR: 464 if (get_user(opt, (int __user *)optval)) { 465 err = -EFAULT; 466 break; 467 } 468 469 if (opt) 470 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR; 471 else 472 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR; 473 break; 474 475 case HCI_TIME_STAMP: 476 if (get_user(opt, (int __user *)optval)) { 477 err = -EFAULT; 478 break; 479 } 480 481 if (opt) 482 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP; 483 else 484 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP; 485 break; 486 487 case HCI_FILTER: 488 len = min_t(unsigned int, len, sizeof(uf)); 489 if (copy_from_user(&uf, optval, len)) { 490 err = -EFAULT; 491 break; 492 } 493 494 if (!capable(CAP_NET_RAW)) { 495 uf.type_mask &= hci_sec_filter.type_mask; 496 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0); 497 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1); 498 } 499 500 { 501 struct hci_filter *f = &hci_pi(sk)->filter; 502 503 f->type_mask = uf.type_mask; 504 f->opcode = uf.opcode; 505 *((u32 *) f->event_mask + 0) = uf.event_mask[0]; 506 *((u32 *) f->event_mask + 1) = uf.event_mask[1]; 507 } 508 break; 509 510 default: 511 err = -ENOPROTOOPT; 512 break; 513 } 514 515 release_sock(sk); 516 return err; 517 } 518 519 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 520 { 521 struct hci_ufilter uf; 522 struct sock *sk = sock->sk; 523 int len, opt; 524 525 if (get_user(len, optlen)) 526 return -EFAULT; 527 528 switch (optname) { 529 case HCI_DATA_DIR: 530 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR) 531 opt = 1; 532 else 533 opt = 0; 534 535 if (put_user(opt, optval)) 536 return -EFAULT; 537 break; 538 539 case HCI_TIME_STAMP: 540 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP) 541 opt = 1; 542 else 543 opt = 0; 544 545 if (put_user(opt, optval)) 546 return -EFAULT; 547 break; 548 549 case HCI_FILTER: 550 { 551 struct hci_filter *f = &hci_pi(sk)->filter; 552 553 uf.type_mask = f->type_mask; 554 uf.opcode = f->opcode; 555 uf.event_mask[0] = *((u32 *) f->event_mask + 0); 556 uf.event_mask[1] = *((u32 *) f->event_mask + 1); 557 } 558 559 len = min_t(unsigned int, len, sizeof(uf)); 560 if (copy_to_user(optval, &uf, len)) 561 return -EFAULT; 562 break; 563 564 default: 565 return -ENOPROTOOPT; 566 break; 567 } 568 569 return 0; 570 } 571 572 static struct proto_ops hci_sock_ops = { 573 .family = PF_BLUETOOTH, 574 .owner = THIS_MODULE, 575 .release = hci_sock_release, 576 .bind = hci_sock_bind, 577 .getname = hci_sock_getname, 578 .sendmsg = hci_sock_sendmsg, 579 .recvmsg = hci_sock_recvmsg, 580 .ioctl = hci_sock_ioctl, 581 .poll = datagram_poll, 582 .listen = sock_no_listen, 583 .shutdown = sock_no_shutdown, 584 .setsockopt = hci_sock_setsockopt, 585 .getsockopt = hci_sock_getsockopt, 586 .connect = sock_no_connect, 587 .socketpair = sock_no_socketpair, 588 .accept = sock_no_accept, 589 .mmap = sock_no_mmap 590 }; 591 592 static struct proto hci_sk_proto = { 593 .name = "HCI", 594 .owner = THIS_MODULE, 595 .obj_size = sizeof(struct hci_pinfo) 596 }; 597 598 static int hci_sock_create(struct socket *sock, int protocol) 599 { 600 struct sock *sk; 601 602 BT_DBG("sock %p", sock); 603 604 if (sock->type != SOCK_RAW) 605 return -ESOCKTNOSUPPORT; 606 607 sock->ops = &hci_sock_ops; 608 609 sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hci_sk_proto, 1); 610 if (!sk) 611 return -ENOMEM; 612 613 sock_init_data(sock, sk); 614 615 sock_reset_flag(sk, SOCK_ZAPPED); 616 617 sk->sk_protocol = protocol; 618 619 sock->state = SS_UNCONNECTED; 620 sk->sk_state = BT_OPEN; 621 622 bt_sock_link(&hci_sk_list, sk); 623 return 0; 624 } 625 626 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr) 627 { 628 struct hci_dev *hdev = (struct hci_dev *) ptr; 629 struct hci_ev_si_device ev; 630 631 BT_DBG("hdev %s event %ld", hdev->name, event); 632 633 /* Send event to sockets */ 634 ev.event = event; 635 ev.dev_id = hdev->id; 636 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev); 637 638 if (event == HCI_DEV_UNREG) { 639 struct sock *sk; 640 struct hlist_node *node; 641 642 /* Detach sockets from device */ 643 read_lock(&hci_sk_list.lock); 644 sk_for_each(sk, node, &hci_sk_list.head) { 645 bh_lock_sock(sk); 646 if (hci_pi(sk)->hdev == hdev) { 647 hci_pi(sk)->hdev = NULL; 648 sk->sk_err = EPIPE; 649 sk->sk_state = BT_OPEN; 650 sk->sk_state_change(sk); 651 652 hci_dev_put(hdev); 653 } 654 bh_unlock_sock(sk); 655 } 656 read_unlock(&hci_sk_list.lock); 657 } 658 659 return NOTIFY_DONE; 660 } 661 662 static struct net_proto_family hci_sock_family_ops = { 663 .family = PF_BLUETOOTH, 664 .owner = THIS_MODULE, 665 .create = hci_sock_create, 666 }; 667 668 static struct notifier_block hci_sock_nblock = { 669 .notifier_call = hci_sock_dev_event 670 }; 671 672 int __init hci_sock_init(void) 673 { 674 int err; 675 676 err = proto_register(&hci_sk_proto, 0); 677 if (err < 0) 678 return err; 679 680 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops); 681 if (err < 0) 682 goto error; 683 684 hci_register_notifier(&hci_sock_nblock); 685 686 BT_INFO("HCI socket layer initialized"); 687 688 return 0; 689 690 error: 691 BT_ERR("HCI socket registration failed"); 692 proto_unregister(&hci_sk_proto); 693 return err; 694 } 695 696 int __exit hci_sock_cleanup(void) 697 { 698 if (bt_sock_unregister(BTPROTO_HCI) < 0) 699 BT_ERR("HCI socket unregistration failed"); 700 701 hci_unregister_notifier(&hci_sock_nblock); 702 703 proto_unregister(&hci_sk_proto); 704 705 return 0; 706 } 707