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