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 <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");