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