net/bluetooth/hci_sock.c

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