net/bluetooth_mgmt/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 /* ----- 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                                                         struct sock *skip_sk)
  88 {
  89         struct sock *sk;
  90         struct hlist_node *node;
  91
  92         BT_DBG("hdev %p len %d", hdev, skb->len);
  93
  94         read_lock(&hci_sk_list.lock);
  95         sk_for_each(sk, node, &hci_sk_list.head) {
  96                 struct hci_filter *flt;
  97                 struct sk_buff *nskb;
  98
  99                 if (sk == skip_sk)
 100                         continue;
 101
 102                 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
 103                         continue;
 104
 105                 /* Don't send frame to the socket it came from */
 106                 if (skb->sk == sk)
 107                         continue;
 108
 109                 if (bt_cb(skb)->channel != hci_pi(sk)->channel)
 110                         continue;
 111
 112                 if (bt_cb(skb)->channel == HCI_CHANNEL_CONTROL)
 113                         goto clone;
 114
 115                 /* Apply filter */
 116                 flt = &hci_pi(sk)->filter;
 117
 118                 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
 119                                 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
 120                         continue;
 121
 122                 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
 123                         register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
 124
 125                         if (!hci_test_bit(evt, &flt->event_mask))
 126                                 continue;
 127
 128                         if (flt->opcode &&
 129                             ((evt == HCI_EV_CMD_COMPLETE &&
 130                               flt->opcode !=
 131                               get_unaligned((__le16 *)(skb->data + 3))) ||
 132                              (evt == HCI_EV_CMD_STATUS &&
 133                               flt->opcode !=
 134                               get_unaligned((__le16 *)(skb->data + 4)))))
 135                                 continue;
 136                 }
 137
 138 clone:
 139                 nskb = skb_clone(skb, GFP_ATOMIC);
 140                 if (!nskb)
 141                         continue;
 142
 143                 /* Put type byte before the data */
 144                 if (bt_cb(skb)->channel == HCI_CHANNEL_RAW)
 145                         memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
 146
 147                 if (sock_queue_rcv_skb(sk, nskb))
 148                         kfree_skb(nskb);
 149         }
 150         read_unlock(&hci_sk_list.lock);
 151 }
 152
 153 static int hci_sock_release(struct socket *sock)
 154 {
 155         struct sock *sk = sock->sk;
 156         struct hci_dev *hdev;
 157
 158         BT_DBG("sock %p sk %p", sock, sk);
 159
 160         if (!sk)
 161                 return 0;
 162
 163         hdev = hci_pi(sk)->hdev;
 164
 165         bt_sock_unlink(&hci_sk_list, sk);
 166
 167         if (hdev) {
 168                 atomic_dec(&hdev->promisc);
 169                 hci_dev_put(hdev);
 170         }
 171
 172         sock_orphan(sk);
 173
 174         skb_queue_purge(&sk->sk_receive_queue);
 175         skb_queue_purge(&sk->sk_write_queue);
 176
 177         sock_put(sk);
 178         return 0;
 179 }
 180
 181 /* sync from bluez git */
 182 static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
 183 {
 184         bdaddr_t bdaddr;
 185         int err;
 186
 187         if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
 188                 return -EFAULT;
 189
 190         hci_dev_lock(hdev);
 191
 192         err = hci_blacklist_add(hdev, &bdaddr, 0);
 193
 194         hci_dev_unlock(hdev);
 195
 196         return err;
 197 }
 198
 199 /* sync from bluez git */
 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, 0);
 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                 set_bit(HCI_PI_MGMT_INIT, &hci_pi(sk)->flags);
 348         }
 349
 350         lock_sock(sk);
 351
 352         if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) {
 353                 err = -EALREADY;
 354                 goto done;
 355         }
 356
 357         if (haddr.hci_dev != HCI_DEV_NONE) {
 358                 hdev = hci_dev_get(haddr.hci_dev);
 359                 if (!hdev) {
 360                         err = -ENODEV;
 361                         goto done;
 362                 }
 363
 364                 atomic_inc(&hdev->promisc);
 365         }
 366
 367         hci_pi(sk)->channel = haddr.hci_channel;
 368         hci_pi(sk)->hdev = hdev;
 369         sk->sk_state = BT_BOUND;
 370
 371 done:
 372         release_sock(sk);
 373         return err;
 374 }
 375
 376 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
 377 {
 378         struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
 379         struct sock *sk = sock->sk;
 380         struct hci_dev *hdev = hci_pi(sk)->hdev;
 381
 382         BT_DBG("sock %p sk %p", sock, sk);
 383
 384         if (!hdev)
 385                 return -EBADFD;
 386
 387         lock_sock(sk);
 388
 389         *addr_len = sizeof(*haddr);
 390         haddr->hci_family = AF_BLUETOOTH;
 391         haddr->hci_dev    = hdev->id;
 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         msg->msg_namelen = 0;
 452
 453         copied = skb->len;
 454         if (len < copied) {
 455                 msg->msg_flags |= MSG_TRUNC;
 456                 copied = len;
 457         }
 458
 459         skb_reset_transport_header(skb);
 460         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 461
 462         hci_sock_cmsg(sk, msg, skb);
 463
 464         skb_free_datagram(sk, skb);
 465
 466         return err ? : copied;
 467 }
 468
 469 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 470                             struct msghdr *msg, size_t len)
 471 {
 472         struct sock *sk = sock->sk;
 473         struct hci_dev *hdev;
 474         struct sk_buff *skb;
 475         int err;
 476
 477         BT_DBG("sock %p sk %p", sock, sk);
 478
 479         if (msg->msg_flags & MSG_OOB)
 480                 return -EOPNOTSUPP;
 481
 482         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
 483                 return -EINVAL;
 484
 485         if (len < 4 || len > HCI_MAX_FRAME_SIZE)
 486                 return -EINVAL;
 487
 488         lock_sock(sk);
 489
 490         switch (hci_pi(sk)->channel) {
 491         case HCI_CHANNEL_RAW:
 492                 break;
 493         case HCI_CHANNEL_CONTROL:
 494                 err = mgmt_control(sk, msg, len);
 495                 goto done;
 496         default:
 497                 err = -EINVAL;
 498                 goto done;
 499         }
 500
 501         hdev = hci_pi(sk)->hdev;
 502         if (!hdev) {
 503                 err = -EBADFD;
 504                 goto done;
 505         }
 506
 507         if (!test_bit(HCI_UP, &hdev->flags)) {
 508                 err = -ENETDOWN;
 509                 goto done;
 510         }
 511
 512         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
 513         if (!skb)
 514                 goto done;
 515
 516         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
 517                 err = -EFAULT;
 518                 goto drop;
 519         }
 520
 521         bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
 522         skb_pull(skb, 1);
 523         skb->dev = (void *) hdev;
 524
 525         if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
 526                 u16 opcode = get_unaligned_le16(skb->data);
 527                 u16 ogf = hci_opcode_ogf(opcode);
 528                 u16 ocf = hci_opcode_ocf(opcode);
 529
 530                 if (((ogf > HCI_SFLT_MAX_OGF) ||
 531                                 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
 532                                         !capable(CAP_NET_RAW)) {
 533                         err = -EPERM;
 534                         goto drop;
 535                 }
 536
 537                 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
 538                         skb_queue_tail(&hdev->raw_q, skb);
 539                         tasklet_schedule(&hdev->tx_task);
 540                 } else {
 541                         skb_queue_tail(&hdev->cmd_q, skb);
 542                         tasklet_schedule(&hdev->cmd_task);
 543                 }
 544         } else {
 545                 if (!capable(CAP_NET_RAW)) {
 546                         err = -EPERM;
 547                         goto drop;
 548                 }
 549
 550                 skb_queue_tail(&hdev->raw_q, skb);
 551                 tasklet_schedule(&hdev->tx_task);
 552         }
 553
 554         err = len;
 555
 556 done:
 557         release_sock(sk);
 558         return err;
 559
 560 drop:
 561         kfree_skb(skb);
 562         goto done;
 563 }
 564
 565 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
 566 {
 567         struct hci_ufilter uf = { .opcode = 0 };
 568         struct sock *sk = sock->sk;
 569         int err = 0, opt = 0;
 570
 571         BT_DBG("sk %p, opt %d", sk, optname);
 572
 573         lock_sock(sk);
 574
 575         switch (optname) {
 576         case HCI_DATA_DIR:
 577                 if (get_user(opt, (int __user *)optval)) {
 578                         err = -EFAULT;
 579                         break;
 580                 }
 581
 582                 if (opt)
 583                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
 584                 else
 585                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
 586                 break;
 587
 588         case HCI_TIME_STAMP:
 589                 if (get_user(opt, (int __user *)optval)) {
 590                         err = -EFAULT;
 591                         break;
 592                 }
 593
 594                 if (opt)
 595                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
 596                 else
 597                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
 598                 break;
 599
 600         case HCI_FILTER:
 601                 {
 602                         struct hci_filter *f = &hci_pi(sk)->filter;
 603
 604                         uf.type_mask = f->type_mask;
 605                         uf.opcode    = f->opcode;
 606                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 607                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 608                 }
 609
 610                 len = min_t(unsigned int, len, sizeof(uf));
 611                 if (copy_from_user(&uf, optval, len)) {
 612                         err = -EFAULT;
 613                         break;
 614                 }
 615
 616                 if (!capable(CAP_NET_RAW)) {
 617                         uf.type_mask &= hci_sec_filter.type_mask;
 618                         uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
 619                         uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
 620                 }
 621
 622                 {
 623                         struct hci_filter *f = &hci_pi(sk)->filter;
 624
 625                         f->type_mask = uf.type_mask;
 626                         f->opcode    = uf.opcode;
 627                         *((u32 *) f->event_mask + 0) = uf.event_mask[0];
 628                         *((u32 *) f->event_mask + 1) = uf.event_mask[1];
 629                 }
 630                 break;
 631
 632         default:
 633                 err = -ENOPROTOOPT;
 634                 break;
 635         }
 636
 637         release_sock(sk);
 638         return err;
 639 }
 640
 641 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 642 {
 643         struct hci_ufilter uf;
 644         struct sock *sk = sock->sk;
 645         int len, opt;
 646
 647         if (get_user(len, optlen))
 648                 return -EFAULT;
 649
 650         switch (optname) {
 651         case HCI_DATA_DIR:
 652                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
 653                         opt = 1;
 654                 else
 655                         opt = 0;
 656
 657                 if (put_user(opt, optval))
 658                         return -EFAULT;
 659                 break;
 660
 661         case HCI_TIME_STAMP:
 662                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
 663                         opt = 1;
 664                 else
 665                         opt = 0;
 666
 667                 if (put_user(opt, optval))
 668                         return -EFAULT;
 669                 break;
 670
 671         case HCI_FILTER:
 672                 {
 673                         struct hci_filter *f = &hci_pi(sk)->filter;
 674
 675                         uf.type_mask = f->type_mask;
 676                         uf.opcode    = f->opcode;
 677                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 678                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 679                 }
 680
 681                 len = min_t(unsigned int, len, sizeof(uf));
 682                 if (copy_to_user(optval, &uf, len))
 683                         return -EFAULT;
 684                 break;
 685
 686         default:
 687                 return -ENOPROTOOPT;
 688                 break;
 689         }
 690
 691         return 0;
 692 }
 693
 694 static const struct proto_ops hci_sock_ops = {
 695         .family         = PF_BLUETOOTH,
 696         .owner          = THIS_MODULE,
 697         .release        = hci_sock_release,
 698         .bind           = hci_sock_bind,
 699         .getname        = hci_sock_getname,
 700         .sendmsg        = hci_sock_sendmsg,
 701         .recvmsg        = hci_sock_recvmsg,
 702         .ioctl          = hci_sock_ioctl,
 703         .poll           = datagram_poll,
 704         .listen         = sock_no_listen,
 705         .shutdown       = sock_no_shutdown,
 706         .setsockopt     = hci_sock_setsockopt,
 707         .getsockopt     = hci_sock_getsockopt,
 708         .connect        = sock_no_connect,
 709         .socketpair     = sock_no_socketpair,
 710         .accept         = sock_no_accept,
 711         .mmap           = sock_no_mmap
 712 };
 713
 714 static struct proto hci_sk_proto = {
 715         .name           = "HCI",
 716         .owner          = THIS_MODULE,
 717         .obj_size       = sizeof(struct hci_pinfo)
 718 };
 719
 720 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
 721                            int kern)
 722 {
 723         struct sock *sk;
 724
 725         BT_DBG("sock %p", sock);
 726
 727         if (sock->type != SOCK_RAW)
 728                 return -ESOCKTNOSUPPORT;
 729
 730         sock->ops = &hci_sock_ops;
 731
 732         sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
 733         if (!sk)
 734                 return -ENOMEM;
 735
 736         sock_init_data(sock, sk);
 737
 738         sock_reset_flag(sk, SOCK_ZAPPED);
 739
 740         sk->sk_protocol = protocol;
 741
 742         sock->state = SS_UNCONNECTED;
 743         sk->sk_state = BT_OPEN;
 744
 745         bt_sock_link(&hci_sk_list, sk);
 746         return 0;
 747 }
 748
 749 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
 750 {
 751         struct hci_dev *hdev = (struct hci_dev *) ptr;
 752         struct hci_ev_si_device ev;
 753
 754         BT_DBG("hdev %s event %ld", hdev->name, event);
 755
 756         /* Send event to sockets */
 757         ev.event  = event;
 758         ev.dev_id = hdev->id;
 759         hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
 760
 761         if (event == HCI_DEV_UNREG) {
 762                 struct sock *sk;
 763                 struct hlist_node *node;
 764
 765                 /* Detach sockets from device */
 766                 read_lock(&hci_sk_list.lock);
 767                 sk_for_each(sk, node, &hci_sk_list.head) {
 768                         local_bh_disable();
 769                         bh_lock_sock_nested(sk);
 770                         if (hci_pi(sk)->hdev == hdev) {
 771                                 hci_pi(sk)->hdev = NULL;
 772                                 sk->sk_err = EPIPE;
 773                                 sk->sk_state = BT_OPEN;
 774                                 sk->sk_state_change(sk);
 775
 776                                 hci_dev_put(hdev);
 777                         }
 778                         bh_unlock_sock(sk);
 779                         local_bh_enable();
 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 }