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 int enable_mgmt;
  53
  54 /* ----- HCI socket interface ----- */
  55
  56 static inline int hci_test_bit(int nr, void *addr)
  57 {
  58         return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
  59 }
  60
  61 /* Security filter */
  62 static struct hci_sec_filter hci_sec_filter = {
  63         /* Packet types */
  64         0x10,
  65         /* Events */
  66         { 0x1000d9fe, 0x0000b00c },
  67         /* Commands */
  68         {
  69                 { 0x0 },
  70                 /* OGF_LINK_CTL */
  71                 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
  72                 /* OGF_LINK_POLICY */
  73                 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
  74                 /* OGF_HOST_CTL */
  75                 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
  76                 /* OGF_INFO_PARAM */
  77                 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
  78                 /* OGF_STATUS_PARAM */
  79                 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
  80         }
  81 };
  82
  83 static struct bt_sock_list hci_sk_list = {
  84         .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
  85 };
  86
  87 /* Send frame to RAW socket */
  88 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
  89                                                         struct sock *skip_sk)
  90 {
  91         struct sock *sk;
  92         struct hlist_node *node;
  93
  94         BT_DBG("hdev %p len %d", hdev, skb->len);
  95
  96         read_lock(&hci_sk_list.lock);
  97         sk_for_each(sk, node, &hci_sk_list.head) {
  98                 struct hci_filter *flt;
  99                 struct sk_buff *nskb;
 100
 101                 if (sk == skip_sk)
 102                         continue;
 103
 104                 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
 105                         continue;
 106
 107                 /* Don't send frame to the socket it came from */
 108                 if (skb->sk == sk)
 109                         continue;
 110
 111                 if (bt_cb(skb)->channel != hci_pi(sk)->channel)
 112                         continue;
 113
 114                 if (bt_cb(skb)->channel == HCI_CHANNEL_CONTROL)
 115                         goto clone;
 116
 117                 /* Apply filter */
 118                 flt = &hci_pi(sk)->filter;
 119
 120                 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
 121                                 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
 122                         continue;
 123
 124                 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
 125                         register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
 126
 127                         if (!hci_test_bit(evt, &flt->event_mask))
 128                                 continue;
 129
 130                         if (flt->opcode &&
 131                             ((evt == HCI_EV_CMD_COMPLETE &&
 132                               flt->opcode !=
 133                               get_unaligned((__le16 *)(skb->data + 3))) ||
 134                              (evt == HCI_EV_CMD_STATUS &&
 135                               flt->opcode !=
 136                               get_unaligned((__le16 *)(skb->data + 4)))))
 137                                 continue;
 138                 }
 139
 140 clone:
 141                 nskb = skb_clone(skb, GFP_ATOMIC);
 142                 if (!nskb)
 143                         continue;
 144
 145                 /* Put type byte before the data */
 146                 if (bt_cb(skb)->channel == HCI_CHANNEL_RAW)
 147                         memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
 148
 149                 if (sock_queue_rcv_skb(sk, nskb))
 150                         kfree_skb(nskb);
 151         }
 152         read_unlock(&hci_sk_list.lock);
 153 }
 154
 155 static int hci_sock_release(struct socket *sock)
 156 {
 157         struct sock *sk = sock->sk;
 158         struct hci_dev *hdev;
 159
 160         BT_DBG("sock %p sk %p", sock, sk);
 161
 162         if (!sk)
 163                 return 0;
 164
 165         hdev = hci_pi(sk)->hdev;
 166
 167         bt_sock_unlink(&hci_sk_list, sk);
 168
 169         if (hdev) {
 170                 atomic_dec(&hdev->promisc);
 171                 hci_dev_put(hdev);
 172         }
 173
 174         sock_orphan(sk);
 175
 176         skb_queue_purge(&sk->sk_receive_queue);
 177         skb_queue_purge(&sk->sk_write_queue);
 178
 179         sock_put(sk);
 180         return 0;
 181 }
 182
 183 static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
 184 {
 185         bdaddr_t bdaddr;
 186         int err;
 187
 188         if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
 189                 return -EFAULT;
 190
 191         hci_dev_lock_bh(hdev);
 192
 193         err = hci_blacklist_add(hdev, &bdaddr);
 194
 195         hci_dev_unlock_bh(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_bh(hdev);
 209
 210         err = hci_blacklist_del(hdev, &bdaddr);
 211
 212         hci_dev_unlock_bh(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 && !enable_mgmt)
 347                 return -EINVAL;
 348
 349         lock_sock(sk);
 350
 351         if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) {
 352                 err = -EALREADY;
 353                 goto done;
 354         }
 355
 356         if (haddr.hci_dev != HCI_DEV_NONE) {
 357                 hdev = hci_dev_get(haddr.hci_dev);
 358                 if (!hdev) {
 359                         err = -ENODEV;
 360                         goto done;
 361                 }
 362
 363                 atomic_inc(&hdev->promisc);
 364         }
 365
 366         hci_pi(sk)->channel = haddr.hci_channel;
 367         hci_pi(sk)->hdev = hdev;
 368         sk->sk_state = BT_BOUND;
 369
 370 done:
 371         release_sock(sk);
 372         return err;
 373 }
 374
 375 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
 376 {
 377         struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
 378         struct sock *sk = sock->sk;
 379         struct hci_dev *hdev = hci_pi(sk)->hdev;
 380
 381         BT_DBG("sock %p sk %p", sock, sk);
 382
 383         if (!hdev)
 384                 return -EBADFD;
 385
 386         lock_sock(sk);
 387
 388         *addr_len = sizeof(*haddr);
 389         haddr->hci_family = AF_BLUETOOTH;
 390         haddr->hci_dev    = hdev->id;
 391         haddr->hci_channel= 0;
 392
 393         release_sock(sk);
 394         return 0;
 395 }
 396
 397 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 398 {
 399         __u32 mask = hci_pi(sk)->cmsg_mask;
 400
 401         if (mask & HCI_CMSG_DIR) {
 402                 int incoming = bt_cb(skb)->incoming;
 403                 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
 404         }
 405
 406         if (mask & HCI_CMSG_TSTAMP) {
 407 #ifdef CONFIG_COMPAT
 408                 struct compat_timeval ctv;
 409 #endif
 410                 struct timeval tv;
 411                 void *data;
 412                 int len;
 413
 414                 skb_get_timestamp(skb, &tv);
 415
 416                 data = &tv;
 417                 len = sizeof(tv);
 418 #ifdef CONFIG_COMPAT
 419                 if (msg->msg_flags & MSG_CMSG_COMPAT) {
 420                         ctv.tv_sec = tv.tv_sec;
 421                         ctv.tv_usec = tv.tv_usec;
 422                         data = &ctv;
 423                         len = sizeof(ctv);
 424                 }
 425 #endif
 426
 427                 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
 428         }
 429 }
 430
 431 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 432                                 struct msghdr *msg, size_t len, int flags)
 433 {
 434         int noblock = flags & MSG_DONTWAIT;
 435         struct sock *sk = sock->sk;
 436         struct sk_buff *skb;
 437         int copied, err;
 438
 439         BT_DBG("sock %p, sk %p", sock, sk);
 440
 441         if (flags & (MSG_OOB))
 442                 return -EOPNOTSUPP;
 443
 444         if (sk->sk_state == BT_CLOSED)
 445                 return 0;
 446
 447         skb = skb_recv_datagram(sk, flags, noblock, &err);
 448         if (!skb)
 449                 return err;
 450
 451         copied = skb->len;
 452         if (len < copied) {
 453                 msg->msg_flags |= MSG_TRUNC;
 454                 copied = len;
 455         }
 456
 457         skb_reset_transport_header(skb);
 458         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 459
 460         hci_sock_cmsg(sk, msg, skb);
 461
 462         skb_free_datagram(sk, skb);
 463
 464         return err ? : copied;
 465 }
 466
 467 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 468                             struct msghdr *msg, size_t len)
 469 {
 470         struct sock *sk = sock->sk;
 471         struct hci_dev *hdev;
 472         struct sk_buff *skb;
 473         int err;
 474
 475         BT_DBG("sock %p sk %p", sock, sk);
 476
 477         if (msg->msg_flags & MSG_OOB)
 478                 return -EOPNOTSUPP;
 479
 480         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
 481                 return -EINVAL;
 482
 483         if (len < 4 || len > HCI_MAX_FRAME_SIZE)
 484                 return -EINVAL;
 485
 486         lock_sock(sk);
 487
 488         switch (hci_pi(sk)->channel) {
 489         case HCI_CHANNEL_RAW:
 490                 break;
 491         case HCI_CHANNEL_CONTROL:
 492                 err = mgmt_control(sk, msg, len);
 493                 goto done;
 494         default:
 495                 err = -EINVAL;
 496                 goto done;
 497         }
 498
 499         hdev = hci_pi(sk)->hdev;
 500         if (!hdev) {
 501                 err = -EBADFD;
 502                 goto done;
 503         }
 504
 505         if (!test_bit(HCI_UP, &hdev->flags)) {
 506                 err = -ENETDOWN;
 507                 goto done;
 508         }
 509
 510         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
 511         if (!skb)
 512                 goto done;
 513
 514         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
 515                 err = -EFAULT;
 516                 goto drop;
 517         }
 518
 519         bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
 520         skb_pull(skb, 1);
 521         skb->dev = (void *) hdev;
 522
 523         if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
 524                 u16 opcode = get_unaligned_le16(skb->data);
 525                 u16 ogf = hci_opcode_ogf(opcode);
 526                 u16 ocf = hci_opcode_ocf(opcode);
 527
 528                 if (((ogf > HCI_SFLT_MAX_OGF) ||
 529                                 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
 530                                         !capable(CAP_NET_RAW)) {
 531                         err = -EPERM;
 532                         goto drop;
 533                 }
 534
 535                 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
 536                         skb_queue_tail(&hdev->raw_q, skb);
 537                         tasklet_schedule(&hdev->tx_task);
 538                 } else {
 539                         skb_queue_tail(&hdev->cmd_q, skb);
 540                         tasklet_schedule(&hdev->cmd_task);
 541                 }
 542         } else {
 543                 if (!capable(CAP_NET_RAW)) {
 544                         err = -EPERM;
 545                         goto drop;
 546                 }
 547
 548                 skb_queue_tail(&hdev->raw_q, skb);
 549                 tasklet_schedule(&hdev->tx_task);
 550         }
 551
 552         err = len;
 553
 554 done:
 555         release_sock(sk);
 556         return err;
 557
 558 drop:
 559         kfree_skb(skb);
 560         goto done;
 561 }
 562
 563 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
 564 {
 565         struct hci_ufilter uf = { .opcode = 0 };
 566         struct sock *sk = sock->sk;
 567         int err = 0, opt = 0;
 568
 569         BT_DBG("sk %p, opt %d", sk, optname);
 570
 571         lock_sock(sk);
 572
 573         switch (optname) {
 574         case HCI_DATA_DIR:
 575                 if (get_user(opt, (int __user *)optval)) {
 576                         err = -EFAULT;
 577                         break;
 578                 }
 579
 580                 if (opt)
 581                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
 582                 else
 583                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
 584                 break;
 585
 586         case HCI_TIME_STAMP:
 587                 if (get_user(opt, (int __user *)optval)) {
 588                         err = -EFAULT;
 589                         break;
 590                 }
 591
 592                 if (opt)
 593                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
 594                 else
 595                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
 596                 break;
 597
 598         case HCI_FILTER:
 599                 {
 600                         struct hci_filter *f = &hci_pi(sk)->filter;
 601
 602                         uf.type_mask = f->type_mask;
 603                         uf.opcode    = f->opcode;
 604                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 605                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 606                 }
 607
 608                 len = min_t(unsigned int, len, sizeof(uf));
 609                 if (copy_from_user(&uf, optval, len)) {
 610                         err = -EFAULT;
 611                         break;
 612                 }
 613
 614                 if (!capable(CAP_NET_RAW)) {
 615                         uf.type_mask &= hci_sec_filter.type_mask;
 616                         uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
 617                         uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
 618                 }
 619
 620                 {
 621                         struct hci_filter *f = &hci_pi(sk)->filter;
 622
 623                         f->type_mask = uf.type_mask;
 624                         f->opcode    = uf.opcode;
 625                         *((u32 *) f->event_mask + 0) = uf.event_mask[0];
 626                         *((u32 *) f->event_mask + 1) = uf.event_mask[1];
 627                 }
 628                 break;
 629
 630         default:
 631                 err = -ENOPROTOOPT;
 632                 break;
 633         }
 634
 635         release_sock(sk);
 636         return err;
 637 }
 638
 639 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 640 {
 641         struct hci_ufilter uf;
 642         struct sock *sk = sock->sk;
 643         int len, opt;
 644
 645         if (get_user(len, optlen))
 646                 return -EFAULT;
 647
 648         switch (optname) {
 649         case HCI_DATA_DIR:
 650                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
 651                         opt = 1;
 652                 else
 653                         opt = 0;
 654
 655                 if (put_user(opt, optval))
 656                         return -EFAULT;
 657                 break;
 658
 659         case HCI_TIME_STAMP:
 660                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
 661                         opt = 1;
 662                 else
 663                         opt = 0;
 664
 665                 if (put_user(opt, optval))
 666                         return -EFAULT;
 667                 break;
 668
 669         case HCI_FILTER:
 670                 {
 671                         struct hci_filter *f = &hci_pi(sk)->filter;
 672
 673                         memset(&uf, 0, sizeof(uf));
 674                         uf.type_mask = f->type_mask;
 675                         uf.opcode    = f->opcode;
 676                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 677                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 678                 }
 679
 680                 len = min_t(unsigned int, len, sizeof(uf));
 681                 if (copy_to_user(optval, &uf, len))
 682                         return -EFAULT;
 683                 break;
 684
 685         default:
 686                 return -ENOPROTOOPT;
 687                 break;
 688         }
 689
 690         return 0;
 691 }
 692
 693 static const struct proto_ops hci_sock_ops = {
 694         .family         = PF_BLUETOOTH,
 695         .owner          = THIS_MODULE,
 696         .release        = hci_sock_release,
 697         .bind           = hci_sock_bind,
 698         .getname        = hci_sock_getname,
 699         .sendmsg        = hci_sock_sendmsg,
 700         .recvmsg        = hci_sock_recvmsg,
 701         .ioctl          = hci_sock_ioctl,
 702         .poll           = datagram_poll,
 703         .listen         = sock_no_listen,
 704         .shutdown       = sock_no_shutdown,
 705         .setsockopt     = hci_sock_setsockopt,
 706         .getsockopt     = hci_sock_getsockopt,
 707         .connect        = sock_no_connect,
 708         .socketpair     = sock_no_socketpair,
 709         .accept         = sock_no_accept,
 710         .mmap           = sock_no_mmap
 711 };
 712
 713 static struct proto hci_sk_proto = {
 714         .name           = "HCI",
 715         .owner          = THIS_MODULE,
 716         .obj_size       = sizeof(struct hci_pinfo)
 717 };
 718
 719 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
 720                            int kern)
 721 {
 722         struct sock *sk;
 723
 724         BT_DBG("sock %p", sock);
 725
 726         if (sock->type != SOCK_RAW)
 727                 return -ESOCKTNOSUPPORT;
 728
 729         sock->ops = &hci_sock_ops;
 730
 731         sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
 732         if (!sk)
 733                 return -ENOMEM;
 734
 735         sock_init_data(sock, sk);
 736
 737         sock_reset_flag(sk, SOCK_ZAPPED);
 738
 739         sk->sk_protocol = protocol;
 740
 741         sock->state = SS_UNCONNECTED;
 742         sk->sk_state = BT_OPEN;
 743
 744         bt_sock_link(&hci_sk_list, sk);
 745         return 0;
 746 }
 747
 748 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
 749 {
 750         struct hci_dev *hdev = (struct hci_dev *) ptr;
 751         struct hci_ev_si_device ev;
 752
 753         BT_DBG("hdev %s event %ld", hdev->name, event);
 754
 755         /* Send event to sockets */
 756         ev.event  = event;
 757         ev.dev_id = hdev->id;
 758         hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
 759
 760         if (event == HCI_DEV_UNREG) {
 761                 struct sock *sk;
 762                 struct hlist_node *node;
 763
 764                 /* Detach sockets from device */
 765                 read_lock(&hci_sk_list.lock);
 766                 sk_for_each(sk, node, &hci_sk_list.head) {
 767                         local_bh_disable();
 768                         bh_lock_sock_nested(sk);
 769                         if (hci_pi(sk)->hdev == hdev) {
 770                                 hci_pi(sk)->hdev = NULL;
 771                                 sk->sk_err = EPIPE;
 772                                 sk->sk_state = BT_OPEN;
 773                                 sk->sk_state_change(sk);
 774
 775                                 hci_dev_put(hdev);
 776                         }
 777                         bh_unlock_sock(sk);
 778                         local_bh_enable();
 779                 }
 780                 read_unlock(&hci_sk_list.lock);
 781         }
 782
 783         return NOTIFY_DONE;
 784 }
 785
 786 static const struct net_proto_family hci_sock_family_ops = {
 787         .family = PF_BLUETOOTH,
 788         .owner  = THIS_MODULE,
 789         .create = hci_sock_create,
 790 };
 791
 792 static struct notifier_block hci_sock_nblock = {
 793         .notifier_call = hci_sock_dev_event
 794 };
 795
 796 int __init hci_sock_init(void)
 797 {
 798         int err;
 799
 800         err = proto_register(&hci_sk_proto, 0);
 801         if (err < 0)
 802                 return err;
 803
 804         err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
 805         if (err < 0)
 806                 goto error;
 807
 808         hci_register_notifier(&hci_sock_nblock);
 809
 810         BT_INFO("HCI socket layer initialized");
 811
 812         return 0;
 813
 814 error:
 815         BT_ERR("HCI socket registration failed");
 816         proto_unregister(&hci_sk_proto);
 817         return err;
 818 }
 819
 820 void hci_sock_cleanup(void)
 821 {
 822         if (bt_sock_unregister(BTPROTO_HCI) < 0)
 823                 BT_ERR("HCI socket unregistration failed");
 824
 825         hci_unregister_notifier(&hci_sock_nblock);
 826
 827         proto_unregister(&hci_sk_proto);
 828 }
 829
 830 module_param(enable_mgmt, bool, 0644);
 831 MODULE_PARM_DESC(enable_mgmt, "Enable Management interface");