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 bool 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 int err; 187 188 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr))) 189 return -EFAULT; 190 191 hci_dev_lock(hdev); 192 193 err = hci_blacklist_add(hdev, &bdaddr); 194 195 hci_dev_unlock(hdev); 196 197 return err; 198 } 199 200 static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg) 201 { 202 bdaddr_t bdaddr; 203 int err; 204 205 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr))) 206 return -EFAULT; 207 208 hci_dev_lock(hdev); 209 210 err = hci_blacklist_del(hdev, &bdaddr); 211 212 hci_dev_unlock(hdev); 213 214 return err; 215 } 216 217 /* Ioctls that require bound socket */ 218 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg) 219 { 220 struct hci_dev *hdev = hci_pi(sk)->hdev; 221 222 if (!hdev) 223 return -EBADFD; 224 225 switch (cmd) { 226 case HCISETRAW: 227 if (!capable(CAP_NET_ADMIN)) 228 return -EACCES; 229 230 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 231 return -EPERM; 232 233 if (arg) 234 set_bit(HCI_RAW, &hdev->flags); 235 else 236 clear_bit(HCI_RAW, &hdev->flags); 237 238 return 0; 239 240 case HCIGETCONNINFO: 241 return hci_get_conn_info(hdev, (void __user *) arg); 242 243 case HCIGETAUTHINFO: 244 return hci_get_auth_info(hdev, (void __user *) arg); 245 246 case HCIBLOCKADDR: 247 if (!capable(CAP_NET_ADMIN)) 248 return -EACCES; 249 return hci_sock_blacklist_add(hdev, (void __user *) arg); 250 251 case HCIUNBLOCKADDR: 252 if (!capable(CAP_NET_ADMIN)) 253 return -EACCES; 254 return hci_sock_blacklist_del(hdev, (void __user *) arg); 255 256 default: 257 if (hdev->ioctl) 258 return hdev->ioctl(hdev, cmd, arg); 259 return -EINVAL; 260 } 261 } 262 263 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 264 { 265 struct sock *sk = sock->sk; 266 void __user *argp = (void __user *) arg; 267 int err; 268 269 BT_DBG("cmd %x arg %lx", cmd, arg); 270 271 switch (cmd) { 272 case HCIGETDEVLIST: 273 return hci_get_dev_list(argp); 274 275 case HCIGETDEVINFO: 276 return hci_get_dev_info(argp); 277 278 case HCIGETCONNLIST: 279 return hci_get_conn_list(argp); 280 281 case HCIDEVUP: 282 if (!capable(CAP_NET_ADMIN)) 283 return -EACCES; 284 return hci_dev_open(arg); 285 286 case HCIDEVDOWN: 287 if (!capable(CAP_NET_ADMIN)) 288 return -EACCES; 289 return hci_dev_close(arg); 290 291 case HCIDEVRESET: 292 if (!capable(CAP_NET_ADMIN)) 293 return -EACCES; 294 return hci_dev_reset(arg); 295 296 case HCIDEVRESTAT: 297 if (!capable(CAP_NET_ADMIN)) 298 return -EACCES; 299 return hci_dev_reset_stat(arg); 300 301 case HCISETSCAN: 302 case HCISETAUTH: 303 case HCISETENCRYPT: 304 case HCISETPTYPE: 305 case HCISETLINKPOL: 306 case HCISETLINKMODE: 307 case HCISETACLMTU: 308 case HCISETSCOMTU: 309 if (!capable(CAP_NET_ADMIN)) 310 return -EACCES; 311 return hci_dev_cmd(cmd, argp); 312 313 case HCIINQUIRY: 314 return hci_inquiry(argp); 315 316 default: 317 lock_sock(sk); 318 err = hci_sock_bound_ioctl(sk, cmd, arg); 319 release_sock(sk); 320 return err; 321 } 322 } 323 324 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) 325 { 326 struct sockaddr_hci haddr; 327 struct sock *sk = sock->sk; 328 struct hci_dev *hdev = NULL; 329 int len, err = 0; 330 331 BT_DBG("sock %p sk %p", sock, sk); 332 333 if (!addr) 334 return -EINVAL; 335 336 memset(&haddr, 0, sizeof(haddr)); 337 len = min_t(unsigned int, sizeof(haddr), addr_len); 338 memcpy(&haddr, addr, len); 339 340 if (haddr.hci_family != AF_BLUETOOTH) 341 return -EINVAL; 342 343 if (haddr.hci_channel > HCI_CHANNEL_CONTROL) 344 return -EINVAL; 345 346 if (haddr.hci_channel == HCI_CHANNEL_CONTROL) { 347 if (!enable_mgmt) 348 return -EINVAL; 349 set_bit(HCI_PI_MGMT_INIT, &hci_pi(sk)->flags); 350 } 351 352 lock_sock(sk); 353 354 if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) { 355 err = -EALREADY; 356 goto done; 357 } 358 359 if (haddr.hci_dev != HCI_DEV_NONE) { 360 hdev = hci_dev_get(haddr.hci_dev); 361 if (!hdev) { 362 err = -ENODEV; 363 goto done; 364 } 365 366 atomic_inc(&hdev->promisc); 367 } 368 369 hci_pi(sk)->channel = haddr.hci_channel; 370 hci_pi(sk)->hdev = hdev; 371 sk->sk_state = BT_BOUND; 372 373 done: 374 release_sock(sk); 375 return err; 376 } 377 378 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer) 379 { 380 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr; 381 struct sock *sk = sock->sk; 382 struct hci_dev *hdev = hci_pi(sk)->hdev; 383 384 BT_DBG("sock %p sk %p", sock, sk); 385 386 if (!hdev) 387 return -EBADFD; 388 389 lock_sock(sk); 390 391 *addr_len = sizeof(*haddr); 392 haddr->hci_family = AF_BLUETOOTH; 393 haddr->hci_dev = hdev->id; 394 395 release_sock(sk); 396 return 0; 397 } 398 399 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb) 400 { 401 __u32 mask = hci_pi(sk)->cmsg_mask; 402 403 if (mask & HCI_CMSG_DIR) { 404 int incoming = bt_cb(skb)->incoming; 405 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming); 406 } 407 408 if (mask & HCI_CMSG_TSTAMP) { 409 #ifdef CONFIG_COMPAT 410 struct compat_timeval ctv; 411 #endif 412 struct timeval tv; 413 void *data; 414 int len; 415 416 skb_get_timestamp(skb, &tv); 417 418 data = &tv; 419 len = sizeof(tv); 420 #ifdef CONFIG_COMPAT 421 if (msg->msg_flags & MSG_CMSG_COMPAT) { 422 ctv.tv_sec = tv.tv_sec; 423 ctv.tv_usec = tv.tv_usec; 424 data = &ctv; 425 len = sizeof(ctv); 426 } 427 #endif 428 429 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); 430 } 431 } 432 433 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 434 struct msghdr *msg, size_t len, int flags) 435 { 436 int noblock = flags & MSG_DONTWAIT; 437 struct sock *sk = sock->sk; 438 struct sk_buff *skb; 439 int copied, err; 440 441 BT_DBG("sock %p, sk %p", sock, sk); 442 443 if (flags & (MSG_OOB)) 444 return -EOPNOTSUPP; 445 446 if (sk->sk_state == BT_CLOSED) 447 return 0; 448 449 skb = skb_recv_datagram(sk, flags, noblock, &err); 450 if (!skb) 451 return err; 452 453 msg->msg_namelen = 0; 454 455 copied = skb->len; 456 if (len < copied) { 457 msg->msg_flags |= MSG_TRUNC; 458 copied = len; 459 } 460 461 skb_reset_transport_header(skb); 462 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 463 464 hci_sock_cmsg(sk, msg, skb); 465 466 skb_free_datagram(sk, skb); 467 468 return err ? : copied; 469 } 470 471 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 472 struct msghdr *msg, size_t len) 473 { 474 struct sock *sk = sock->sk; 475 struct hci_dev *hdev; 476 struct sk_buff *skb; 477 int err; 478 479 BT_DBG("sock %p sk %p", sock, sk); 480 481 if (msg->msg_flags & MSG_OOB) 482 return -EOPNOTSUPP; 483 484 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE)) 485 return -EINVAL; 486 487 if (len < 4 || len > HCI_MAX_FRAME_SIZE) 488 return -EINVAL; 489 490 lock_sock(sk); 491 492 switch (hci_pi(sk)->channel) { 493 case HCI_CHANNEL_RAW: 494 break; 495 case HCI_CHANNEL_CONTROL: 496 err = mgmt_control(sk, msg, len); 497 goto done; 498 default: 499 err = -EINVAL; 500 goto done; 501 } 502 503 hdev = hci_pi(sk)->hdev; 504 if (!hdev) { 505 err = -EBADFD; 506 goto done; 507 } 508 509 if (!test_bit(HCI_UP, &hdev->flags)) { 510 err = -ENETDOWN; 511 goto done; 512 } 513 514 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err); 515 if (!skb) 516 goto done; 517 518 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 519 err = -EFAULT; 520 goto drop; 521 } 522 523 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data); 524 skb_pull(skb, 1); 525 skb->dev = (void *) hdev; 526 527 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) { 528 u16 opcode = get_unaligned_le16(skb->data); 529 u16 ogf = hci_opcode_ogf(opcode); 530 u16 ocf = hci_opcode_ocf(opcode); 531 532 if (((ogf > HCI_SFLT_MAX_OGF) || 533 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) && 534 !capable(CAP_NET_RAW)) { 535 err = -EPERM; 536 goto drop; 537 } 538 539 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) { 540 skb_queue_tail(&hdev->raw_q, skb); 541 queue_work(hdev->workqueue, &hdev->tx_work); 542 } else { 543 skb_queue_tail(&hdev->cmd_q, skb); 544 queue_work(hdev->workqueue, &hdev->cmd_work); 545 } 546 } else { 547 if (!capable(CAP_NET_RAW)) { 548 err = -EPERM; 549 goto drop; 550 } 551 552 skb_queue_tail(&hdev->raw_q, skb); 553 queue_work(hdev->workqueue, &hdev->tx_work); 554 } 555 556 err = len; 557 558 done: 559 release_sock(sk); 560 return err; 561 562 drop: 563 kfree_skb(skb); 564 goto done; 565 } 566 567 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len) 568 { 569 struct hci_ufilter uf = { .opcode = 0 }; 570 struct sock *sk = sock->sk; 571 int err = 0, opt = 0; 572 573 BT_DBG("sk %p, opt %d", sk, optname); 574 575 lock_sock(sk); 576 577 switch (optname) { 578 case HCI_DATA_DIR: 579 if (get_user(opt, (int __user *)optval)) { 580 err = -EFAULT; 581 break; 582 } 583 584 if (opt) 585 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR; 586 else 587 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR; 588 break; 589 590 case HCI_TIME_STAMP: 591 if (get_user(opt, (int __user *)optval)) { 592 err = -EFAULT; 593 break; 594 } 595 596 if (opt) 597 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP; 598 else 599 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP; 600 break; 601 602 case HCI_FILTER: 603 { 604 struct hci_filter *f = &hci_pi(sk)->filter; 605 606 uf.type_mask = f->type_mask; 607 uf.opcode = f->opcode; 608 uf.event_mask[0] = *((u32 *) f->event_mask + 0); 609 uf.event_mask[1] = *((u32 *) f->event_mask + 1); 610 } 611 612 len = min_t(unsigned int, len, sizeof(uf)); 613 if (copy_from_user(&uf, optval, len)) { 614 err = -EFAULT; 615 break; 616 } 617 618 if (!capable(CAP_NET_RAW)) { 619 uf.type_mask &= hci_sec_filter.type_mask; 620 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0); 621 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1); 622 } 623 624 { 625 struct hci_filter *f = &hci_pi(sk)->filter; 626 627 f->type_mask = uf.type_mask; 628 f->opcode = uf.opcode; 629 *((u32 *) f->event_mask + 0) = uf.event_mask[0]; 630 *((u32 *) f->event_mask + 1) = uf.event_mask[1]; 631 } 632 break; 633 634 default: 635 err = -ENOPROTOOPT; 636 break; 637 } 638 639 release_sock(sk); 640 return err; 641 } 642 643 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 644 { 645 struct hci_ufilter uf; 646 struct sock *sk = sock->sk; 647 int len, opt; 648 649 if (get_user(len, optlen)) 650 return -EFAULT; 651 652 switch (optname) { 653 case HCI_DATA_DIR: 654 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR) 655 opt = 1; 656 else 657 opt = 0; 658 659 if (put_user(opt, optval)) 660 return -EFAULT; 661 break; 662 663 case HCI_TIME_STAMP: 664 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP) 665 opt = 1; 666 else 667 opt = 0; 668 669 if (put_user(opt, optval)) 670 return -EFAULT; 671 break; 672 673 case HCI_FILTER: 674 { 675 struct hci_filter *f = &hci_pi(sk)->filter; 676 677 uf.type_mask = f->type_mask; 678 uf.opcode = f->opcode; 679 uf.event_mask[0] = *((u32 *) f->event_mask + 0); 680 uf.event_mask[1] = *((u32 *) f->event_mask + 1); 681 } 682 683 len = min_t(unsigned int, len, sizeof(uf)); 684 if (copy_to_user(optval, &uf, len)) 685 return -EFAULT; 686 break; 687 688 default: 689 return -ENOPROTOOPT; 690 break; 691 } 692 693 return 0; 694 } 695 696 static const struct proto_ops hci_sock_ops = { 697 .family = PF_BLUETOOTH, 698 .owner = THIS_MODULE, 699 .release = hci_sock_release, 700 .bind = hci_sock_bind, 701 .getname = hci_sock_getname, 702 .sendmsg = hci_sock_sendmsg, 703 .recvmsg = hci_sock_recvmsg, 704 .ioctl = hci_sock_ioctl, 705 .poll = datagram_poll, 706 .listen = sock_no_listen, 707 .shutdown = sock_no_shutdown, 708 .setsockopt = hci_sock_setsockopt, 709 .getsockopt = hci_sock_getsockopt, 710 .connect = sock_no_connect, 711 .socketpair = sock_no_socketpair, 712 .accept = sock_no_accept, 713 .mmap = sock_no_mmap 714 }; 715 716 static struct proto hci_sk_proto = { 717 .name = "HCI", 718 .owner = THIS_MODULE, 719 .obj_size = sizeof(struct hci_pinfo) 720 }; 721 722 static int hci_sock_create(struct net *net, struct socket *sock, int protocol, 723 int kern) 724 { 725 struct sock *sk; 726 727 BT_DBG("sock %p", sock); 728 729 if (sock->type != SOCK_RAW) 730 return -ESOCKTNOSUPPORT; 731 732 sock->ops = &hci_sock_ops; 733 734 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto); 735 if (!sk) 736 return -ENOMEM; 737 738 sock_init_data(sock, sk); 739 740 sock_reset_flag(sk, SOCK_ZAPPED); 741 742 sk->sk_protocol = protocol; 743 744 sock->state = SS_UNCONNECTED; 745 sk->sk_state = BT_OPEN; 746 747 bt_sock_link(&hci_sk_list, sk); 748 return 0; 749 } 750 751 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr) 752 { 753 struct hci_dev *hdev = (struct hci_dev *) ptr; 754 struct hci_ev_si_device ev; 755 756 BT_DBG("hdev %s event %ld", hdev->name, event); 757 758 /* Send event to sockets */ 759 ev.event = event; 760 ev.dev_id = hdev->id; 761 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev); 762 763 if (event == HCI_DEV_UNREG) { 764 struct sock *sk; 765 struct hlist_node *node; 766 767 /* Detach sockets from device */ 768 read_lock(&hci_sk_list.lock); 769 sk_for_each(sk, node, &hci_sk_list.head) { 770 bh_lock_sock_nested(sk); 771 if (hci_pi(sk)->hdev == hdev) { 772 hci_pi(sk)->hdev = NULL; 773 sk->sk_err = EPIPE; 774 sk->sk_state = BT_OPEN; 775 sk->sk_state_change(sk); 776 777 hci_dev_put(hdev); 778 } 779 bh_unlock_sock(sk); 780 } 781 read_unlock(&hci_sk_list.lock); 782 } 783 784 return NOTIFY_DONE; 785 } 786 787 static const struct net_proto_family hci_sock_family_ops = { 788 .family = PF_BLUETOOTH, 789 .owner = THIS_MODULE, 790 .create = hci_sock_create, 791 }; 792 793 static struct notifier_block hci_sock_nblock = { 794 .notifier_call = hci_sock_dev_event 795 }; 796 797 int __init hci_sock_init(void) 798 { 799 int err; 800 801 err = proto_register(&hci_sk_proto, 0); 802 if (err < 0) 803 return err; 804 805 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops); 806 if (err < 0) 807 goto error; 808 809 hci_register_notifier(&hci_sock_nblock); 810 811 BT_INFO("HCI socket layer initialized"); 812 813 return 0; 814 815 error: 816 BT_ERR("HCI socket registration failed"); 817 proto_unregister(&hci_sk_proto); 818 return err; 819 } 820 821 void hci_sock_cleanup(void) 822 { 823 if (bt_sock_unregister(BTPROTO_HCI) < 0) 824 BT_ERR("HCI socket unregistration failed"); 825 826 hci_unregister_notifier(&hci_sock_nblock); 827 828 proto_unregister(&hci_sk_proto); 829 } 830 831 module_param(enable_mgmt, bool, 0644); 832 MODULE_PARM_DESC(enable_mgmt, "Enable Management interface"); 833