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