hciops.c revision 3af792e57b7ccb82d3139748a2b3c6b44d2e7ce2
1/* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org> 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 as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 20 * 21 */ 22 23#ifdef HAVE_CONFIG_H 24#include <config.h> 25#endif 26 27#include <stdio.h> 28#include <errno.h> 29#include <unistd.h> 30#include <stdlib.h> 31#include <sys/types.h> 32#include <sys/ioctl.h> 33#include <sys/wait.h> 34 35#include <bluetooth/bluetooth.h> 36#include <bluetooth/hci.h> 37#include <bluetooth/hci_lib.h> 38 39#include <glib.h> 40 41#include "hcid.h" 42#include "sdpd.h" 43#include "adapter.h" 44#include "plugin.h" 45#include "log.h" 46#include "manager.h" 47 48static int child_pipe[2] = { -1, -1 }; 49 50static guint child_io_id = 0; 51static guint ctl_io_id = 0; 52 53static gboolean child_exit(GIOChannel *io, GIOCondition cond, void *user_data) 54{ 55 int status, fd = g_io_channel_unix_get_fd(io); 56 pid_t child_pid; 57 58 if (read(fd, &child_pid, sizeof(child_pid)) != sizeof(child_pid)) { 59 error("child_exit: unable to read child pid from pipe"); 60 return TRUE; 61 } 62 63 if (waitpid(child_pid, &status, 0) != child_pid) 64 error("waitpid(%d) failed", child_pid); 65 else 66 DBG("child %d exited", child_pid); 67 68 return TRUE; 69} 70 71static void at_child_exit(void) 72{ 73 pid_t pid = getpid(); 74 75 if (write(child_pipe[1], &pid, sizeof(pid)) != sizeof(pid)) 76 error("unable to write to child pipe"); 77} 78 79static void device_devup_setup(int index) 80{ 81 struct hci_dev_info di; 82 uint16_t policy; 83 int dd; 84 85 if (hci_devinfo(index, &di) < 0) 86 return; 87 88 if (ignore_device(&di)) 89 return; 90 91 dd = hci_open_dev(index); 92 if (dd < 0) { 93 error("Can't open device hci%d: %s (%d)", index, 94 strerror(errno), errno); 95 return; 96 } 97 98 /* Set page timeout */ 99 if ((main_opts.flags & (1 << HCID_SET_PAGETO))) { 100 write_page_timeout_cp cp; 101 102 cp.timeout = htobs(main_opts.pageto); 103 hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_PAGE_TIMEOUT, 104 WRITE_PAGE_TIMEOUT_CP_SIZE, &cp); 105 } 106 107 /* Set default link policy */ 108 policy = htobs(main_opts.link_policy); 109 hci_send_cmd(dd, OGF_LINK_POLICY, OCF_WRITE_DEFAULT_LINK_POLICY, 110 2, &policy); 111 112 hci_close_dev(dd); 113 114 start_security_manager(index); 115 116 /* Return value 1 means ioctl(DEVDOWN) was performed */ 117 if (manager_start_adapter(index) == 1) 118 stop_security_manager(index); 119} 120 121static void init_device(int index) 122{ 123 struct hci_dev_req dr; 124 struct hci_dev_info di; 125 pid_t pid; 126 int dd; 127 128 /* Do initialization in the separate process */ 129 pid = fork(); 130 switch (pid) { 131 case 0: 132 atexit(at_child_exit); 133 break; 134 case -1: 135 error("Fork failed. Can't init device hci%d: %s (%d)", 136 index, strerror(errno), errno); 137 default: 138 DBG("child %d forked", pid); 139 return; 140 } 141 142 dd = hci_open_dev(index); 143 if (dd < 0) { 144 error("Can't open device hci%d: %s (%d)", 145 index, strerror(errno), errno); 146 exit(1); 147 } 148 149 memset(&dr, 0, sizeof(dr)); 150 dr.dev_id = index; 151 152 /* Set link mode */ 153 dr.dev_opt = main_opts.link_mode; 154 if (ioctl(dd, HCISETLINKMODE, (unsigned long) &dr) < 0) 155 error("Can't set link mode on hci%d: %s (%d)", 156 index, strerror(errno), errno); 157 158 /* Set link policy for BR/EDR HCI devices */ 159 if (hci_devinfo(index, &di) < 0) 160 goto fail; 161 162 if (!ignore_device(&di)) { 163 dr.dev_opt = main_opts.link_policy; 164 if (ioctl(dd, HCISETLINKPOL, (unsigned long) &dr) < 0 && 165 errno != ENETDOWN) { 166 error("Can't set link policy on hci%d: %s (%d)", 167 index, strerror(errno), errno); 168 } 169 } 170 171 /* Start HCI device */ 172 if (ioctl(dd, HCIDEVUP, index) < 0 && errno != EALREADY) { 173 error("Can't init device hci%d: %s (%d)", 174 index, strerror(errno), errno); 175 goto fail; 176 } 177 178 hci_close_dev(dd); 179 exit(0); 180 181fail: 182 hci_close_dev(dd); 183 exit(1); 184} 185 186static void device_devreg_setup(int index) 187{ 188 struct hci_dev_info di; 189 gboolean devup; 190 191 init_device(index); 192 193 memset(&di, 0, sizeof(di)); 194 195 if (hci_devinfo(index, &di) < 0) 196 return; 197 198 devup = hci_test_bit(HCI_UP, &di.flags); 199 200 if (!ignore_device(&di)) 201 manager_register_adapter(index, devup); 202} 203 204static void device_event(int event, int index) 205{ 206 switch (event) { 207 case HCI_DEV_REG: 208 info("HCI dev %d registered", index); 209 device_devreg_setup(index); 210 break; 211 212 case HCI_DEV_UNREG: 213 info("HCI dev %d unregistered", index); 214 manager_unregister_adapter(index); 215 break; 216 217 case HCI_DEV_UP: 218 info("HCI dev %d up", index); 219 device_devup_setup(index); 220 break; 221 222 case HCI_DEV_DOWN: 223 info("HCI dev %d down", index); 224 manager_stop_adapter(index); 225 stop_security_manager(index); 226 break; 227 } 228} 229 230static int init_known_adapters(int ctl) 231{ 232 struct hci_dev_list_req *dl; 233 struct hci_dev_req *dr; 234 int i, err; 235 size_t req_size; 236 237 req_size = HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t); 238 239 dl = g_try_malloc0(req_size); 240 if (!dl) { 241 error("Can't allocate devlist buffer"); 242 return -ENOMEM; 243 } 244 245 dl->dev_num = HCI_MAX_DEV; 246 dr = dl->dev_req; 247 248 if (ioctl(ctl, HCIGETDEVLIST, dl) < 0) { 249 err = -errno; 250 error("Can't get device list: %s (%d)", strerror(-err), -err); 251 g_free(dl); 252 return err; 253 } 254 255 for (i = 0; i < dl->dev_num; i++, dr++) { 256 device_event(HCI_DEV_REG, dr->dev_id); 257 258 if (hci_test_bit(HCI_UP, &dr->dev_opt)) 259 device_event(HCI_DEV_UP, dr->dev_id); 260 } 261 262 g_free(dl); 263 return 0; 264} 265 266static gboolean io_stack_event(GIOChannel *chan, GIOCondition cond, 267 gpointer data) 268{ 269 unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr; 270 evt_stack_internal *si; 271 evt_si_device *sd; 272 hci_event_hdr *eh; 273 int type; 274 size_t len; 275 GIOError err; 276 277 ptr = buf; 278 279 err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len); 280 if (err) { 281 if (err == G_IO_ERROR_AGAIN) 282 return TRUE; 283 284 error("Read from control socket failed: %s (%d)", 285 strerror(errno), errno); 286 return FALSE; 287 } 288 289 type = *ptr++; 290 291 if (type != HCI_EVENT_PKT) 292 return TRUE; 293 294 eh = (hci_event_hdr *) ptr; 295 if (eh->evt != EVT_STACK_INTERNAL) 296 return TRUE; 297 298 ptr += HCI_EVENT_HDR_SIZE; 299 300 si = (evt_stack_internal *) ptr; 301 switch (si->type) { 302 case EVT_SI_DEVICE: 303 sd = (void *) &si->data; 304 device_event(sd->event, sd->dev_id); 305 break; 306 } 307 308 return TRUE; 309} 310 311static int hciops_setup(void) 312{ 313 struct sockaddr_hci addr; 314 struct hci_filter flt; 315 GIOChannel *ctl_io, *child_io; 316 int sock, err; 317 318 if (child_pipe[0] != -1) 319 return -EALREADY; 320 321 if (pipe(child_pipe) < 0) { 322 err = -errno; 323 error("pipe(): %s (%d)", strerror(-err), -err); 324 return err; 325 } 326 327 child_io = g_io_channel_unix_new(child_pipe[0]); 328 g_io_channel_set_close_on_unref(child_io, TRUE); 329 child_io_id = g_io_add_watch(child_io, 330 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, 331 child_exit, NULL); 332 g_io_channel_unref(child_io); 333 334 /* Create and bind HCI socket */ 335 sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 336 if (sock < 0) { 337 err = -errno; 338 error("Can't open HCI socket: %s (%d)", strerror(-err), 339 -err); 340 return err; 341 } 342 343 /* Set filter */ 344 hci_filter_clear(&flt); 345 hci_filter_set_ptype(HCI_EVENT_PKT, &flt); 346 hci_filter_set_event(EVT_STACK_INTERNAL, &flt); 347 if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt, 348 sizeof(flt)) < 0) { 349 err = -errno; 350 error("Can't set filter: %s (%d)", strerror(-err), -err); 351 return err; 352 } 353 354 memset(&addr, 0, sizeof(addr)); 355 addr.hci_family = AF_BLUETOOTH; 356 addr.hci_dev = HCI_DEV_NONE; 357 if (bind(sock, (struct sockaddr *) &addr, 358 sizeof(addr)) < 0) { 359 err = -errno; 360 error("Can't bind HCI socket: %s (%d)", 361 strerror(-err), -err); 362 return err; 363 } 364 365 ctl_io = g_io_channel_unix_new(sock); 366 g_io_channel_set_close_on_unref(ctl_io, TRUE); 367 368 ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL); 369 370 g_io_channel_unref(ctl_io); 371 372 /* Initialize already connected devices */ 373 return init_known_adapters(sock); 374} 375 376static void hciops_cleanup(void) 377{ 378 if (child_io_id) { 379 g_source_remove(child_io_id); 380 child_io_id = 0; 381 } 382 383 if (ctl_io_id) { 384 g_source_remove(ctl_io_id); 385 ctl_io_id = 0; 386 } 387 388 if (child_pipe[0] >= 0) { 389 close(child_pipe[0]); 390 child_pipe[0] = -1; 391 } 392 393 if (child_pipe[1] >= 0) { 394 close(child_pipe[1]); 395 child_pipe[1] = -1; 396 } 397} 398 399static int hciops_start(int index) 400{ 401 int dd; 402 int err = 0; 403 404 dd = hci_open_dev(index); 405 if (dd < 0) 406 return -EIO; 407 408 if (ioctl(dd, HCIDEVUP, index) == 0) 409 goto done; /* on success */ 410 411 if (errno != EALREADY) { 412 err = -errno; 413 error("Can't init device hci%d: %s (%d)", 414 index, strerror(-err), -err); 415 } 416 417done: 418 hci_close_dev(dd); 419 return err; 420} 421 422static int hciops_stop(int index) 423{ 424 int dd; 425 int err = 0; 426 427 dd = hci_open_dev(index); 428 if (dd < 0) 429 return -EIO; 430 431 if (ioctl(dd, HCIDEVDOWN, index) == 0) 432 goto done; /* on success */ 433 434 if (errno != EALREADY) { 435 err = -errno; 436 error("Can't stop device hci%d: %s (%d)", 437 index, strerror(-err), -err); 438 } 439 440done: 441 hci_close_dev(dd); 442 return err; 443} 444 445static int hciops_powered(int index, gboolean powered) 446{ 447 int dd, err; 448 uint8_t mode = SCAN_DISABLED; 449 450 if (powered) 451 return hciops_start(index); 452 453 dd = hci_open_dev(index); 454 if (dd < 0) 455 return -EIO; 456 457 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 458 1, &mode); 459 if (err < 0) { 460 err = -errno; 461 hci_close_dev(dd); 462 return err; 463 } 464 465 hci_close_dev(dd); 466 467 return hciops_stop(index); 468} 469 470static int hciops_connectable(int index) 471{ 472 int dd, err; 473 uint8_t mode = SCAN_PAGE; 474 475 dd = hci_open_dev(index); 476 if (dd < 0) 477 return -EIO; 478 479 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 480 1, &mode); 481 if (err < 0) 482 err = -errno; 483 484 hci_close_dev(dd); 485 486 return err; 487} 488 489static int hciops_discoverable(int index) 490{ 491 int dd, err; 492 uint8_t mode = (SCAN_PAGE | SCAN_INQUIRY); 493 494 dd = hci_open_dev(index); 495 if (dd < 0) 496 return -EIO; 497 498 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 499 1, &mode); 500 if (err < 0) 501 err = -errno; 502 503 hci_close_dev(dd); 504 505 return err; 506} 507 508static int hciops_set_class(int index, uint32_t class) 509{ 510 int dd, err; 511 write_class_of_dev_cp cp; 512 513 dd = hci_open_dev(index); 514 if (dd < 0) 515 return -EIO; 516 517 memcpy(cp.dev_class, &class, 3); 518 519 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV, 520 WRITE_CLASS_OF_DEV_CP_SIZE, &cp); 521 522 if (err < 0) 523 err = -errno; 524 525 hci_close_dev(dd); 526 527 return err; 528} 529 530static int hciops_set_limited_discoverable(int index, uint32_t class, 531 gboolean limited) 532{ 533 int dd, err; 534 int num = (limited ? 2 : 1); 535 uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e }; 536 write_current_iac_lap_cp cp; 537 538 /* 539 * 1: giac 540 * 2: giac + liac 541 */ 542 dd = hci_open_dev(index); 543 if (dd < 0) 544 return -EIO; 545 546 memset(&cp, 0, sizeof(cp)); 547 cp.num_current_iac = num; 548 memcpy(&cp.lap, lap, num * 3); 549 550 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_CURRENT_IAC_LAP, 551 (num * 3 + 1), &cp); 552 if (err < 0) { 553 err = -errno; 554 goto fail; 555 } 556 557 err = hciops_set_class(index, class); 558 559fail: 560 hci_close_dev(dd); 561 return err; 562} 563 564static int hciops_start_inquiry(int index, uint8_t length, gboolean periodic) 565{ 566 uint8_t lap[3] = { 0x33, 0x8b, 0x9e }; 567 int dd, err; 568 569 dd = hci_open_dev(index); 570 if (dd < 0) 571 return -EIO; 572 573 if (periodic) { 574 periodic_inquiry_cp cp; 575 576 memset(&cp, 0, sizeof(cp)); 577 memcpy(&cp.lap, lap, 3); 578 cp.max_period = htobs(24); 579 cp.min_period = htobs(16); 580 cp.length = length; 581 cp.num_rsp = 0x00; 582 583 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_PERIODIC_INQUIRY, 584 PERIODIC_INQUIRY_CP_SIZE, &cp); 585 } else { 586 inquiry_cp inq_cp; 587 588 memset(&inq_cp, 0, sizeof(inq_cp)); 589 memcpy(&inq_cp.lap, lap, 3); 590 inq_cp.length = length; 591 inq_cp.num_rsp = 0x00; 592 593 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_INQUIRY, 594 INQUIRY_CP_SIZE, &inq_cp); 595 } 596 597 if (err < 0) 598 err = -errno; 599 600 hci_close_dev(dd); 601 602 return err; 603} 604 605static int hciops_stop_inquiry(int index) 606{ 607 struct hci_dev_info di; 608 int dd, err; 609 610 if (hci_devinfo(index, &di) < 0) 611 return -errno; 612 613 dd = hci_open_dev(index); 614 if (dd < 0) 615 return -EIO; 616 617 if (hci_test_bit(HCI_INQUIRY, &di.flags)) 618 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_INQUIRY_CANCEL, 0, 0); 619 else 620 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY, 621 0, 0); 622 if (err < 0) 623 err = -errno; 624 625 hci_close_dev(dd); 626 627 return err; 628} 629 630static int hciops_start_scanning(int index) 631{ 632 int dd, err = 0; 633 634 dd = hci_open_dev(index); 635 if (dd < 0) 636 return -errno; 637 638 if (hci_le_set_scan_parameters(dd, 0x01, htobs(0x0010), 639 htobs(0x0010), 0x00, 0x00) < 0) { 640 err = -errno; 641 goto fail; 642 } 643 644 if (hci_le_set_scan_enable(dd, 0x01, 0x00) < 0) 645 err = -errno; 646 647fail: 648 hci_close_dev(dd); 649 650 return err; 651} 652 653static int hciops_stop_scanning(int index) 654{ 655 int dd, err = 0; 656 657 dd = hci_open_dev(index); 658 if (dd < 0) 659 return -errno; 660 661 if (hci_le_set_scan_enable(dd, 0x00, 0x00) < 0) 662 err = -errno; 663 664 hci_close_dev(dd); 665 666 return err; 667} 668 669static int hciops_resolve_name(int index, bdaddr_t *bdaddr) 670{ 671 remote_name_req_cp cp; 672 int dd, err; 673 674 dd = hci_open_dev(index); 675 if (dd < 0) 676 return -EIO; 677 678 memset(&cp, 0, sizeof(cp)); 679 bacpy(&cp.bdaddr, bdaddr); 680 cp.pscan_rep_mode = 0x02; 681 682 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ, 683 REMOTE_NAME_REQ_CP_SIZE, &cp); 684 if (err < 0) 685 err = -errno; 686 687 hci_close_dev(dd); 688 689 return err; 690} 691 692static int hciops_set_name(int index, const char *name) 693{ 694 change_local_name_cp cp; 695 int dd, err; 696 697 dd = hci_open_dev(index); 698 if (dd < 0) 699 return -EIO; 700 701 memset(&cp, 0, sizeof(cp)); 702 strncpy((char *) cp.name, name, sizeof(cp.name)); 703 704 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME, 705 CHANGE_LOCAL_NAME_CP_SIZE, &cp); 706 if (err < 0) 707 err = -errno; 708 709 hci_close_dev(dd); 710 711 return err; 712} 713 714static int hciops_read_name(int index) 715{ 716 int dd, err; 717 718 dd = hci_open_dev(index); 719 if (dd < 0) 720 return -EIO; 721 722 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_READ_LOCAL_NAME, 0, 0); 723 if (err < 0) 724 err = -errno; 725 726 hci_close_dev(dd); 727 728 return err; 729} 730 731static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr) 732{ 733 remote_name_req_cancel_cp cp; 734 int dd, err; 735 736 dd = hci_open_dev(index); 737 if (dd < 0) 738 return -EIO; 739 740 memset(&cp, 0, sizeof(cp)); 741 bacpy(&cp.bdaddr, bdaddr); 742 743 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL, 744 REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp); 745 if (err < 0) 746 err = -errno; 747 748 hci_close_dev(dd); 749 750 return err; 751} 752 753static int hciops_fast_connectable(int index, gboolean enable) 754{ 755 int dd, err = 0; 756 write_page_activity_cp cp; 757 uint8_t type; 758 759 if (enable) { 760 type = PAGE_SCAN_TYPE_INTERLACED; 761 cp.interval = 0x0024; /* 22.5 msec page scan interval */ 762 } else { 763 type = PAGE_SCAN_TYPE_STANDARD; /* default */ 764 cp.interval = 0x0800; /* default 1.28 sec page scan */ 765 } 766 767 cp.window = 0x0012; /* default 11.25 msec page scan window */ 768 769 dd = hci_open_dev(index); 770 if (dd < 0) 771 return -EIO; 772 773 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_PAGE_ACTIVITY, 774 WRITE_PAGE_ACTIVITY_CP_SIZE, &cp) < 0) 775 err = -errno; 776 else if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_PAGE_SCAN_TYPE, 777 1, &type) < 0) 778 err = -errno; 779 780 hci_close_dev(dd); 781 782 return err; 783} 784 785static int hciops_read_clock(int index, int handle, int which, int timeout, 786 uint32_t *clock, uint16_t *accuracy) 787{ 788 int dd, err = 0; 789 790 dd = hci_open_dev(index); 791 if (dd < 0) 792 return -EIO; 793 794 if (hci_read_clock(dd, handle, which, clock, accuracy, timeout) < 0) 795 err = -errno; 796 797 hci_close_dev(dd); 798 799 return err; 800} 801 802static int hciops_conn_handle(int index, const bdaddr_t *bdaddr, int *handle) 803{ 804 struct hci_conn_info_req *cr; 805 int dd, err = 0; 806 807 dd = hci_open_dev(index); 808 if (dd < 0) 809 return -EIO; 810 811 cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info)); 812 bacpy(&cr->bdaddr, bdaddr); 813 cr->type = ACL_LINK; 814 815 if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) { 816 err = -errno; 817 goto fail; 818 } 819 820 *handle = htobs(cr->conn_info->handle); 821 822fail: 823 hci_close_dev(dd); 824 g_free(cr); 825 return err; 826} 827 828static int hciops_write_eir_data(int index, uint8_t *data) 829{ 830 write_ext_inquiry_response_cp cp; 831 int err, dd; 832 833 dd = hci_open_dev(index); 834 if (dd < 0) 835 return -errno; 836 837 memset(&cp, 0, sizeof(cp)); 838 memcpy(cp.data, data, 240); 839 840 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_EXT_INQUIRY_RESPONSE, 841 WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE, &cp) < 0) 842 err = -errno; 843 else 844 err = 0; 845 846 hci_close_dev(dd); 847 848 return err; 849} 850 851static int hciops_read_bdaddr(int index, bdaddr_t *bdaddr) 852{ 853 int dd, err; 854 855 dd = hci_open_dev(index); 856 if (dd < 0) 857 return -errno; 858 859 if (hci_read_bd_addr(dd, bdaddr, HCI_REQ_TIMEOUT) < 0) 860 err = -errno; 861 else 862 err = 0; 863 864 hci_close_dev(dd); 865 866 return err; 867} 868 869static int hciops_set_event_mask(int index, uint8_t *events, size_t count) 870{ 871 int dd, err; 872 873 dd = hci_open_dev(index); 874 if (dd < 0) 875 return -errno; 876 877 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_SET_EVENT_MASK, 878 count, events) < 0) 879 err = -errno; 880 else 881 err = 0; 882 883 hci_close_dev(dd); 884 885 return err; 886} 887 888static int hciops_write_inq_mode(int index, uint8_t mode) 889{ 890 write_inquiry_mode_cp cp; 891 int dd, err; 892 893 dd = hci_open_dev(index); 894 if (dd < 0) 895 return -errno; 896 897 memset(&cp, 0, sizeof(cp)); 898 cp.mode = mode; 899 900 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_INQUIRY_MODE, 901 WRITE_INQUIRY_MODE_CP_SIZE, &cp) < 0) 902 err = -errno; 903 else 904 err = 0; 905 906 hci_close_dev(dd); 907 908 return err; 909} 910 911static int hciops_read_inq_tx_pwr(int index) 912{ 913 int dd, err; 914 915 dd = hci_open_dev(index); 916 if (dd < 0) 917 return -errno; 918 919 if (hci_send_cmd(dd, OGF_HOST_CTL, 920 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL, 0, NULL) < 0) 921 err = -errno; 922 else 923 err = 0; 924 925 hci_close_dev(dd); 926 927 return err; 928} 929 930static int hciops_block_device(int index, bdaddr_t *bdaddr) 931{ 932 int dd, err; 933 934 dd = hci_open_dev(index); 935 if (dd < 0) 936 return -errno; 937 938 if (ioctl(dd, HCIBLOCKADDR, bdaddr) < 0) 939 err = -errno; 940 else 941 err = 0; 942 943 hci_close_dev(dd); 944 945 return err; 946} 947 948static int hciops_unblock_device(int index, bdaddr_t *bdaddr) 949{ 950 int dd, err; 951 952 dd = hci_open_dev(index); 953 if (dd < 0) 954 return -errno; 955 956 if (ioctl(dd, HCIUNBLOCKADDR, bdaddr) < 0) 957 err = -errno; 958 else 959 err = 0; 960 961 hci_close_dev(dd); 962 963 return err; 964} 965 966static int hciops_get_conn_list(int index, GSList **conns) 967{ 968 struct hci_conn_list_req *cl; 969 struct hci_conn_info *ci; 970 int dd, err, i; 971 972 dd = hci_open_dev(index); 973 if (dd < 0) 974 return -errno; 975 976 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); 977 978 cl->dev_id = index; 979 cl->conn_num = 10; 980 ci = cl->conn_info; 981 982 if (ioctl(dd, HCIGETCONNLIST, cl) < 0) { 983 err = -errno; 984 goto fail; 985 } 986 987 err = 0; 988 *conns = NULL; 989 990 for (i = 0; i < cl->conn_num; i++, ci++) 991 *conns = g_slist_append(*conns, g_memdup(ci, sizeof(*ci))); 992 993fail: 994 hci_close_dev(dd); 995 g_free(cl); 996 return err; 997} 998 999static int hciops_read_local_version(int index, struct hci_version *ver) 1000{ 1001 int dd, err; 1002 1003 dd = hci_open_dev(index); 1004 if (dd < 0) 1005 return -errno; 1006 1007 if (hci_read_local_version(dd, ver, HCI_REQ_TIMEOUT) < 0) 1008 err = -errno; 1009 else 1010 err = 0; 1011 1012 hci_close_dev(dd); 1013 1014 return err; 1015} 1016 1017static int hciops_read_local_features(int index, uint8_t *features) 1018{ 1019 int dd, err; 1020 1021 dd = hci_open_dev(index); 1022 if (dd < 0) 1023 return -errno; 1024 1025 if (hci_read_local_features(dd, features, HCI_REQ_TIMEOUT) < 0) 1026 err = -errno; 1027 else 1028 err = 0; 1029 1030 hci_close_dev(dd); 1031 1032 return err; 1033} 1034 1035static int hciops_init_ssp_mode(int index, uint8_t *mode) 1036{ 1037 write_simple_pairing_mode_cp cp; 1038 int dd, err; 1039 1040 dd = hci_open_dev(index); 1041 if (dd < 0) 1042 return -errno; 1043 1044 if (ioctl(dd, HCIGETAUTHINFO, NULL) < 0 && errno == EINVAL) { 1045 err = 0; 1046 goto done; 1047 } 1048 1049 memset(&cp, 0, sizeof(cp)); 1050 cp.mode = 0x01; 1051 1052 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SIMPLE_PAIRING_MODE, 1053 WRITE_SIMPLE_PAIRING_MODE_CP_SIZE, &cp) < 0) 1054 err = -errno; 1055 else 1056 err = 0; 1057 1058done: 1059 hci_close_dev(dd); 1060 return err; 1061} 1062 1063static int hciops_read_link_policy(int index) 1064{ 1065 int dd, err; 1066 1067 dd = hci_open_dev(index); 1068 if (dd < 0) 1069 return -errno; 1070 1071 if (hci_send_cmd(dd, OGF_LINK_POLICY, OCF_READ_DEFAULT_LINK_POLICY, 1072 0, NULL) < 0) 1073 err = -errno; 1074 else 1075 err = 0; 1076 1077 hci_close_dev(dd); 1078 1079 return err; 1080} 1081 1082static int hciops_disconnect(int index, uint16_t handle) 1083{ 1084 int dd, err; 1085 disconnect_cp cp; 1086 1087 dd = hci_open_dev(index); 1088 if (dd < 0) 1089 return -errno; 1090 1091 memset(&cp, 0, sizeof(cp)); 1092 cp.handle = htobs(handle); 1093 cp.reason = HCI_OE_USER_ENDED_CONNECTION; 1094 1095 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_DISCONNECT, 1096 DISCONNECT_CP_SIZE, &cp) < 0) 1097 err = -errno; 1098 else 1099 err = 0; 1100 1101 hci_close_dev(dd); 1102 1103 return err; 1104} 1105 1106static int hciops_remove_bonding(int index, bdaddr_t *bdaddr) 1107{ 1108 delete_stored_link_key_cp cp; 1109 int dd, err; 1110 1111 dd = hci_open_dev(index); 1112 if (dd < 0) 1113 return -errno; 1114 1115 memset(&cp, 0, sizeof(cp)); 1116 bacpy(&cp.bdaddr, bdaddr); 1117 1118 /* Delete the link key from the Bluetooth chip */ 1119 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_DELETE_STORED_LINK_KEY, 1120 DELETE_STORED_LINK_KEY_CP_SIZE, &cp) < 0) 1121 err = -errno; 1122 else 1123 err = 0; 1124 1125 hci_close_dev(dd); 1126 1127 return err; 1128} 1129 1130static int hciops_request_authentication(int index, uint16_t handle, 1131 uint8_t *status) 1132{ 1133 struct hci_request rq; 1134 auth_requested_cp cp; 1135 evt_cmd_status rp; 1136 int dd, err; 1137 1138 dd = hci_open_dev(index); 1139 if (dd < 0) 1140 return -errno; 1141 1142 memset(&rp, 0, sizeof(rp)); 1143 1144 memset(&cp, 0, sizeof(cp)); 1145 cp.handle = htobs(handle); 1146 1147 memset(&rq, 0, sizeof(rq)); 1148 rq.ogf = OGF_LINK_CTL; 1149 rq.ocf = OCF_AUTH_REQUESTED; 1150 rq.cparam = &cp; 1151 rq.clen = AUTH_REQUESTED_CP_SIZE; 1152 rq.rparam = &rp; 1153 rq.rlen = EVT_CMD_STATUS_SIZE; 1154 rq.event = EVT_CMD_STATUS; 1155 1156 if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) { 1157 err = -errno; 1158 goto fail; 1159 } 1160 1161 if (status) 1162 *status = rp.status; 1163 1164 err = 0; 1165 1166fail: 1167 hci_close_dev(dd); 1168 return err; 1169} 1170 1171static int hciops_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin) 1172{ 1173 int dd, err; 1174 1175 dd = hci_open_dev(index); 1176 if (dd < 0) 1177 return -errno; 1178 1179 if (pin) { 1180 pin_code_reply_cp pr; 1181 size_t len = strlen(pin); 1182 1183 memset(&pr, 0, sizeof(pr)); 1184 bacpy(&pr.bdaddr, bdaddr); 1185 memcpy(pr.pin_code, pin, len); 1186 pr.pin_len = len; 1187 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_PIN_CODE_REPLY, 1188 PIN_CODE_REPLY_CP_SIZE, &pr); 1189 } else 1190 err = hci_send_cmd(dd, OGF_LINK_CTL, 1191 OCF_PIN_CODE_NEG_REPLY, 6, bdaddr); 1192 1193 hci_close_dev(dd); 1194 1195 return err; 1196} 1197 1198static int hciops_confirm_reply(int index, bdaddr_t *bdaddr, gboolean success) 1199{ 1200 int dd, err; 1201 user_confirm_reply_cp cp; 1202 1203 dd = hci_open_dev(index); 1204 if (dd < 0) 1205 return -errno; 1206 1207 memset(&cp, 0, sizeof(cp)); 1208 bacpy(&cp.bdaddr, bdaddr); 1209 1210 if (success) 1211 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_CONFIRM_REPLY, 1212 USER_CONFIRM_REPLY_CP_SIZE, &cp); 1213 else 1214 err = hci_send_cmd(dd, OGF_LINK_CTL, 1215 OCF_USER_CONFIRM_NEG_REPLY, 1216 USER_CONFIRM_REPLY_CP_SIZE, &cp); 1217 1218 hci_close_dev(dd); 1219 1220 return err; 1221} 1222 1223static int hciops_passkey_reply(int index, bdaddr_t *bdaddr, uint32_t passkey) 1224{ 1225 int dd, err; 1226 1227 dd = hci_open_dev(index); 1228 if (dd < 0) 1229 return -errno; 1230 1231 if (passkey != INVALID_PASSKEY) { 1232 user_passkey_reply_cp cp; 1233 1234 memset(&cp, 0, sizeof(cp)); 1235 bacpy(&cp.bdaddr, bdaddr); 1236 cp.passkey = passkey; 1237 1238 err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_PASSKEY_REPLY, 1239 USER_PASSKEY_REPLY_CP_SIZE, &cp); 1240 } else 1241 err = hci_send_cmd(dd, OGF_LINK_CTL, 1242 OCF_USER_PASSKEY_NEG_REPLY, 6, bdaddr); 1243 1244 hci_close_dev(dd); 1245 1246 return err; 1247} 1248 1249static int hciops_get_auth_info(int index, bdaddr_t *bdaddr, uint8_t *auth) 1250{ 1251 struct hci_auth_info_req req; 1252 int err, dd; 1253 1254 dd = hci_open_dev(index); 1255 if (dd < 0) 1256 return -errno; 1257 1258 memset(&req, 0, sizeof(req)); 1259 bacpy(&req.bdaddr, bdaddr); 1260 1261 if (ioctl(dd, HCIGETAUTHINFO, (unsigned long) &req) < 0) { 1262 err = -errno; 1263 goto fail; 1264 } 1265 1266 err = 0; 1267 1268 if (auth) 1269 *auth = req.type; 1270 1271fail: 1272 hci_close_dev(dd); 1273 return err; 1274} 1275 1276static int hciops_read_scan_enable(int index) 1277{ 1278 int err, dd; 1279 1280 dd = hci_open_dev(index); 1281 if (dd < 0) 1282 return -errno; 1283 1284 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_READ_SCAN_ENABLE, 0, NULL) < 0) 1285 err = -errno; 1286 else 1287 err = 0; 1288 1289 hci_close_dev(dd); 1290 1291 return err; 1292} 1293 1294static int hciops_read_ssp_mode(int index) 1295{ 1296 int dd, err; 1297 1298 dd = hci_open_dev(index); 1299 if (dd < 0) 1300 return -errno; 1301 1302 if (hci_send_cmd(dd, OGF_HOST_CTL, OCF_READ_SIMPLE_PAIRING_MODE, 1303 0, NULL) < 0) 1304 err = -errno; 1305 else 1306 err = 0; 1307 1308 hci_close_dev(dd); 1309 1310 return err; 1311} 1312 1313static int hciops_write_le_host(int index, uint8_t le, uint8_t simul) 1314{ 1315 write_le_host_supported_cp cp; 1316 int dd, err; 1317 1318 dd = hci_open_dev(index); 1319 if (dd < 0) 1320 return -errno; 1321 1322 memset(&cp, 0, sizeof(cp)); 1323 cp.le = le; 1324 cp.simul = simul; 1325 1326 err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_LE_HOST_SUPPORTED, 1327 WRITE_LE_HOST_SUPPORTED_CP_SIZE, &cp); 1328 if (err < 0) 1329 err = -errno; 1330 1331 hci_close_dev(dd); 1332 1333 return err; 1334} 1335 1336static struct btd_adapter_ops hci_ops = { 1337 .setup = hciops_setup, 1338 .cleanup = hciops_cleanup, 1339 .start = hciops_start, 1340 .stop = hciops_stop, 1341 .set_powered = hciops_powered, 1342 .set_connectable = hciops_connectable, 1343 .set_discoverable = hciops_discoverable, 1344 .set_limited_discoverable = hciops_set_limited_discoverable, 1345 .start_inquiry = hciops_start_inquiry, 1346 .stop_inquiry = hciops_stop_inquiry, 1347 .start_scanning = hciops_start_scanning, 1348 .stop_scanning = hciops_stop_scanning, 1349 .resolve_name = hciops_resolve_name, 1350 .cancel_resolve_name = hciops_cancel_resolve_name, 1351 .set_name = hciops_set_name, 1352 .read_name = hciops_read_name, 1353 .set_class = hciops_set_class, 1354 .set_fast_connectable = hciops_fast_connectable, 1355 .read_clock = hciops_read_clock, 1356 .get_conn_handle = hciops_conn_handle, 1357 .write_eir_data = hciops_write_eir_data, 1358 .read_bdaddr = hciops_read_bdaddr, 1359 .set_event_mask = hciops_set_event_mask, 1360 .write_inq_mode = hciops_write_inq_mode, 1361 .read_inq_tx_pwr = hciops_read_inq_tx_pwr, 1362 .block_device = hciops_block_device, 1363 .unblock_device = hciops_unblock_device, 1364 .get_conn_list = hciops_get_conn_list, 1365 .read_local_version = hciops_read_local_version, 1366 .read_local_features = hciops_read_local_features, 1367 .init_ssp_mode = hciops_init_ssp_mode, 1368 .read_link_policy = hciops_read_link_policy, 1369 .disconnect = hciops_disconnect, 1370 .remove_bonding = hciops_remove_bonding, 1371 .request_authentication = hciops_request_authentication, 1372 .pincode_reply = hciops_pincode_reply, 1373 .confirm_reply = hciops_confirm_reply, 1374 .passkey_reply = hciops_passkey_reply, 1375 .get_auth_info = hciops_get_auth_info, 1376 .read_scan_enable = hciops_read_scan_enable, 1377 .read_ssp_mode = hciops_read_ssp_mode, 1378 .write_le_host = hciops_write_le_host, 1379}; 1380 1381static int hciops_init(void) 1382{ 1383 return btd_register_adapter_ops(&hci_ops); 1384} 1385static void hciops_exit(void) 1386{ 1387 btd_adapter_cleanup_ops(&hci_ops); 1388} 1389 1390BLUETOOTH_PLUGIN_DEFINE(hciops, VERSION, 1391 BLUETOOTH_PLUGIN_PRIORITY_LOW, hciops_init, hciops_exit) 1392