hciops.c revision fa41c93fe1dd04c1c25d34956d02c54f19ac3130
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#include <bluetooth/sdp.h> 39#include <bluetooth/sdp_lib.h> 40 41#include <glib.h> 42 43#include "hcid.h" 44#include "sdpd.h" 45#include "btio.h" 46#include "adapter.h" 47#include "device.h" 48#include "plugin.h" 49#include "log.h" 50#include "storage.h" 51#include "event.h" 52#include "manager.h" 53 54static int child_pipe[2] = { -1, -1 }; 55 56static guint child_io_id = 0; 57static guint ctl_io_id = 0; 58 59/* Commands sent by kernel on starting an adapter */ 60enum { 61 PENDING_BDADDR, 62 PENDING_VERSION, 63 PENDING_FEATURES, 64 PENDING_NAME, 65}; 66 67struct uuid_info { 68 uuid_t uuid; 69 uint8_t svc_hint; 70}; 71 72struct bt_conn { 73 struct dev_info *dev; 74 bdaddr_t bdaddr; 75 uint16_t handle; 76 uint8_t loc_cap; 77 uint8_t loc_auth; 78 uint8_t rem_cap; 79 uint8_t rem_auth; 80 gboolean bonding_initiator; 81 gboolean secmode3; 82 GIOChannel *io; /* For raw L2CAP socket (bonding) */ 83}; 84 85static int max_dev = -1; 86static struct dev_info { 87 int id; 88 int sk; 89 bdaddr_t bdaddr; 90 char name[249]; 91 uint8_t eir[240]; 92 uint8_t features[8]; 93 uint8_t ssp_mode; 94 95 int8_t tx_power; 96 97 uint32_t current_cod; 98 uint32_t wanted_cod; 99 uint32_t pending_cod; 100 gboolean cache_enable; 101 gboolean already_up; 102 gboolean registered; 103 gboolean pairable; 104 105 uint8_t io_capability; 106 107 struct hci_version ver; 108 109 uint16_t did_vendor; 110 uint16_t did_product; 111 uint16_t did_version; 112 113 gboolean up; 114 unsigned long pending; 115 116 GIOChannel *io; 117 guint watch_id; 118 119 gboolean debug_keys; 120 GSList *keys; 121 uint8_t pin_length; 122 123 GSList *uuids; 124 125 GSList *connections; 126} *devs = NULL; 127 128static int ignore_device(struct hci_dev_info *di) 129{ 130 return hci_test_bit(HCI_RAW, &di->flags) || di->type >> 4 != HCI_BREDR; 131} 132 133static void init_dev_info(int index, int sk, gboolean registered) 134{ 135 struct dev_info *dev = &devs[index]; 136 137 memset(dev, 0, sizeof(*dev)); 138 139 dev->id = index; 140 dev->sk = sk; 141 dev->cache_enable = TRUE; 142 dev->registered = registered; 143 dev->io_capability = 0x03; /* No Input No Output */ 144} 145 146/* Async HCI command handling with callback support */ 147 148struct hci_cmd_data { 149 bt_hci_result_t cb; 150 uint16_t handle; 151 uint16_t ocf; 152 gpointer caller_data; 153}; 154 155static gboolean hci_event_watch(GIOChannel *io, 156 GIOCondition cond, gpointer user_data) 157{ 158 unsigned char buf[HCI_MAX_EVENT_SIZE], *body; 159 struct hci_cmd_data *cmd = user_data; 160 evt_cmd_status *evt_status; 161 evt_auth_complete *evt_auth; 162 evt_encrypt_change *evt_enc; 163 hci_event_hdr *hdr; 164 set_conn_encrypt_cp cp; 165 int dd; 166 uint16_t ocf; 167 uint8_t status = HCI_OE_POWER_OFF; 168 169 if (cond & G_IO_NVAL) { 170 cmd->cb(status, cmd->caller_data); 171 return FALSE; 172 } 173 174 if (cond & (G_IO_ERR | G_IO_HUP)) 175 goto failed; 176 177 dd = g_io_channel_unix_get_fd(io); 178 179 if (read(dd, buf, sizeof(buf)) < 0) 180 goto failed; 181 182 hdr = (hci_event_hdr *) (buf + 1); 183 body = buf + (1 + HCI_EVENT_HDR_SIZE); 184 185 switch (hdr->evt) { 186 case EVT_CMD_STATUS: 187 evt_status = (evt_cmd_status *) body; 188 ocf = cmd_opcode_ocf(evt_status->opcode); 189 if (ocf != cmd->ocf) 190 return TRUE; 191 switch (ocf) { 192 case OCF_AUTH_REQUESTED: 193 case OCF_SET_CONN_ENCRYPT: 194 if (evt_status->status != 0) { 195 /* Baseband rejected command */ 196 status = evt_status->status; 197 goto failed; 198 } 199 break; 200 default: 201 return TRUE; 202 } 203 /* Wait for the next event */ 204 return TRUE; 205 case EVT_AUTH_COMPLETE: 206 evt_auth = (evt_auth_complete *) body; 207 if (evt_auth->handle != cmd->handle) { 208 /* Skipping */ 209 return TRUE; 210 } 211 212 if (evt_auth->status != 0x00) { 213 status = evt_auth->status; 214 /* Abort encryption */ 215 goto failed; 216 } 217 218 memset(&cp, 0, sizeof(cp)); 219 cp.handle = cmd->handle; 220 cp.encrypt = 1; 221 222 cmd->ocf = OCF_SET_CONN_ENCRYPT; 223 224 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, 225 SET_CONN_ENCRYPT_CP_SIZE, &cp) < 0) { 226 status = HCI_COMMAND_DISALLOWED; 227 goto failed; 228 } 229 /* Wait for encrypt change event */ 230 return TRUE; 231 case EVT_ENCRYPT_CHANGE: 232 evt_enc = (evt_encrypt_change *) body; 233 if (evt_enc->handle != cmd->handle) 234 return TRUE; 235 236 /* Procedure finished: reporting status */ 237 status = evt_enc->status; 238 break; 239 default: 240 /* Skipping */ 241 return TRUE; 242 } 243 244failed: 245 cmd->cb(status, cmd->caller_data); 246 g_io_channel_shutdown(io, TRUE, NULL); 247 248 return FALSE; 249} 250 251static int write_inq_mode(int index, uint8_t mode) 252{ 253 struct dev_info *dev = &devs[index]; 254 write_inquiry_mode_cp cp; 255 256 memset(&cp, 0, sizeof(cp)); 257 cp.mode = mode; 258 259 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_INQUIRY_MODE, 260 WRITE_INQUIRY_MODE_CP_SIZE, &cp) < 0) 261 return -errno; 262 263 return 0; 264} 265 266static uint8_t get_inquiry_mode(int index) 267{ 268 struct dev_info *dev = &devs[index]; 269 270 if (dev->features[6] & LMP_EXT_INQ) 271 return 2; 272 273 if (dev->features[3] & LMP_RSSI_INQ) 274 return 1; 275 276 if (dev->ver.manufacturer == 11 && dev->ver.hci_rev == 0x00 && 277 dev->ver.lmp_subver == 0x0757) 278 return 1; 279 280 if (dev->ver.manufacturer == 15) { 281 if (dev->ver.hci_rev == 0x03 && 282 dev->ver.lmp_subver == 0x6963) 283 return 1; 284 if (dev->ver.hci_rev == 0x09 && 285 dev->ver.lmp_subver == 0x6963) 286 return 1; 287 if (dev->ver.hci_rev == 0x00 && 288 dev->ver.lmp_subver == 0x6965) 289 return 1; 290 } 291 292 if (dev->ver.manufacturer == 31 && dev->ver.hci_rev == 0x2005 && 293 dev->ver.lmp_subver == 0x1805) 294 return 1; 295 296 return 0; 297} 298 299static int init_ssp_mode(int index) 300{ 301 struct dev_info *dev = &devs[index]; 302 write_simple_pairing_mode_cp cp; 303 304 if (ioctl(dev->sk, HCIGETAUTHINFO, NULL) < 0 && errno == EINVAL) 305 return 0; 306 307 memset(&cp, 0, sizeof(cp)); 308 cp.mode = 0x01; 309 310 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, 311 OCF_WRITE_SIMPLE_PAIRING_MODE, 312 WRITE_SIMPLE_PAIRING_MODE_CP_SIZE, &cp) < 0) 313 return -errno; 314 315 return 0; 316} 317 318static int hciops_set_discoverable(int index, gboolean discoverable) 319{ 320 struct dev_info *dev = &devs[index]; 321 uint8_t mode; 322 323 if (discoverable) 324 mode = (SCAN_PAGE | SCAN_INQUIRY); 325 else 326 mode = SCAN_PAGE; 327 328 DBG("hci%d discoverable %d", index, discoverable); 329 330 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 331 1, &mode) < 0) 332 return -errno; 333 334 return 0; 335} 336 337static int hciops_set_pairable(int index, gboolean pairable) 338{ 339 struct btd_adapter *adapter; 340 341 DBG("hci%d pairable %d", index, pairable); 342 343 adapter = manager_find_adapter(&devs[index].bdaddr); 344 if (adapter) 345 btd_adapter_pairable_changed(adapter, pairable); 346 347 devs[index].pairable = pairable; 348 349 return 0; 350} 351 352static int hciops_power_off(int index) 353{ 354 struct dev_info *dev = &devs[index]; 355 356 DBG("hci%d", index); 357 358 if (ioctl(dev->sk, HCIDEVDOWN, index) < 0 && errno != EALREADY) 359 return -errno; 360 361 return 0; 362} 363 364static void set_event_mask(int index) 365{ 366 struct dev_info *dev = &devs[index]; 367 /* The second byte is 0xff instead of 0x9f (two reserved bits 368 * disabled) since a Broadcom 1.2 dongle doesn't respond to the 369 * command otherwise */ 370 uint8_t events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 371 372 /* Events for 1.2 and newer controllers */ 373 if (dev->ver.lmp_ver > 1) { 374 events[4] |= 0x01; /* Flow Specification Complete */ 375 events[4] |= 0x02; /* Inquiry Result with RSSI */ 376 events[4] |= 0x04; /* Read Remote Extended Features Complete */ 377 events[5] |= 0x08; /* Synchronous Connection Complete */ 378 events[5] |= 0x10; /* Synchronous Connection Changed */ 379 } 380 381 if (dev->features[3] & LMP_RSSI_INQ) 382 events[4] |= 0x04; /* Inquiry Result with RSSI */ 383 384 if (dev->features[5] & LMP_SNIFF_SUBR) 385 events[5] |= 0x20; /* Sniff Subrating */ 386 387 if (dev->features[5] & LMP_PAUSE_ENC) 388 events[5] |= 0x80; /* Encryption Key Refresh Complete */ 389 390 if (dev->features[6] & LMP_EXT_INQ) 391 events[5] |= 0x40; /* Extended Inquiry Result */ 392 393 if (dev->features[6] & LMP_NFLUSH_PKTS) 394 events[7] |= 0x01; /* Enhanced Flush Complete */ 395 396 if (dev->features[7] & LMP_LSTO) 397 events[6] |= 0x80; /* Link Supervision Timeout Changed */ 398 399 if (dev->features[6] & LMP_SIMPLE_PAIR) { 400 events[6] |= 0x01; /* IO Capability Request */ 401 events[6] |= 0x02; /* IO Capability Response */ 402 events[6] |= 0x04; /* User Confirmation Request */ 403 events[6] |= 0x08; /* User Passkey Request */ 404 events[6] |= 0x10; /* Remote OOB Data Request */ 405 events[6] |= 0x20; /* Simple Pairing Complete */ 406 events[7] |= 0x04; /* User Passkey Notification */ 407 events[7] |= 0x08; /* Keypress Notification */ 408 events[7] |= 0x10; /* Remote Host Supported 409 * Features Notification */ 410 } 411 412 if (dev->features[4] & LMP_LE) 413 events[7] |= 0x20; /* LE Meta-Event */ 414 415 hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_SET_EVENT_MASK, 416 sizeof(events), events); 417} 418 419static void start_adapter(int index) 420{ 421 struct dev_info *dev = &devs[index]; 422 uint8_t inqmode; 423 uint16_t link_policy; 424 425 set_event_mask(index); 426 427 if (dev->features[6] & LMP_SIMPLE_PAIR) 428 init_ssp_mode(index); 429 430 inqmode = get_inquiry_mode(index); 431 if (inqmode) 432 write_inq_mode(index, inqmode); 433 434 if (dev->features[7] & LMP_INQ_TX_PWR) 435 hci_send_cmd(dev->sk, OGF_HOST_CTL, 436 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL, 0, NULL); 437 438 /* Set default link policy */ 439 link_policy = main_opts.link_policy; 440 441 if (!(dev->features[0] & LMP_RSWITCH)) 442 link_policy &= ~HCI_LP_RSWITCH; 443 if (!(dev->features[0] & LMP_HOLD)) 444 link_policy &= ~HCI_LP_HOLD; 445 if (!(dev->features[0] & LMP_SNIFF)) 446 link_policy &= ~HCI_LP_SNIFF; 447 if (!(dev->features[1] & LMP_PARK)) 448 link_policy &= ~HCI_LP_PARK; 449 450 link_policy = htobs(link_policy); 451 hci_send_cmd(dev->sk, OGF_LINK_POLICY, OCF_WRITE_DEFAULT_LINK_POLICY, 452 sizeof(link_policy), &link_policy); 453 454 dev->current_cod = 0; 455 memset(dev->eir, 0, sizeof(dev->eir)); 456} 457 458static gboolean init_adapter(int index) 459{ 460 struct dev_info *dev = &devs[index]; 461 struct btd_adapter *adapter = NULL; 462 gboolean existing_adapter = dev->registered; 463 uint8_t mode, on_mode; 464 gboolean pairable, discoverable; 465 466 if (!dev->registered) { 467 adapter = btd_manager_register_adapter(index); 468 if (adapter) 469 dev->registered = TRUE; 470 } else { 471 adapter = manager_find_adapter(&dev->bdaddr); 472 /* FIXME: manager_find_adapter should return a new ref */ 473 btd_adapter_ref(adapter); 474 } 475 476 if (adapter == NULL) 477 return FALSE; 478 479 btd_adapter_get_mode(adapter, &mode, &on_mode, &pairable); 480 481 if (existing_adapter) 482 mode = on_mode; 483 484 if (mode == MODE_OFF) { 485 hciops_power_off(index); 486 goto done; 487 } 488 489 start_adapter(index); 490 btd_adapter_start(adapter); 491 492 discoverable = (mode == MODE_DISCOVERABLE); 493 494 hciops_set_discoverable(index, discoverable); 495 hciops_set_pairable(index, pairable); 496 497done: 498 btd_adapter_unref(adapter); 499 return TRUE; 500} 501 502static int hciops_encrypt_link(int index, bdaddr_t *dst, bt_hci_result_t cb, 503 gpointer user_data) 504{ 505 GIOChannel *io; 506 struct hci_cmd_data *cmd; 507 struct hci_conn_info_req *cr; 508 auth_requested_cp cp; 509 struct hci_filter nf; 510 int dd, err; 511 uint32_t link_mode; 512 uint16_t handle; 513 514 dd = hci_open_dev(index); 515 if (dd < 0) 516 return -errno; 517 518 cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info)); 519 cr->type = ACL_LINK; 520 bacpy(&cr->bdaddr, dst); 521 522 err = ioctl(dd, HCIGETCONNINFO, cr); 523 link_mode = cr->conn_info->link_mode; 524 handle = cr->conn_info->handle; 525 g_free(cr); 526 527 if (err < 0) { 528 err = -errno; 529 goto fail; 530 } 531 532 if (link_mode & HCI_LM_ENCRYPT) { 533 err = -EALREADY; 534 goto fail; 535 } 536 537 memset(&cp, 0, sizeof(cp)); 538 cp.handle = htobs(handle); 539 540 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_AUTH_REQUESTED, 541 AUTH_REQUESTED_CP_SIZE, &cp) < 0) { 542 err = -errno; 543 goto fail; 544 } 545 546 cmd = g_new0(struct hci_cmd_data, 1); 547 cmd->handle = handle; 548 cmd->ocf = OCF_AUTH_REQUESTED; 549 cmd->cb = cb; 550 cmd->caller_data = user_data; 551 552 hci_filter_clear(&nf); 553 hci_filter_set_ptype(HCI_EVENT_PKT, &nf); 554 hci_filter_set_event(EVT_CMD_STATUS, &nf); 555 hci_filter_set_event(EVT_AUTH_COMPLETE, &nf); 556 hci_filter_set_event(EVT_ENCRYPT_CHANGE, &nf); 557 558 if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) { 559 err = -errno; 560 g_free(cmd); 561 goto fail; 562 } 563 564 io = g_io_channel_unix_new(dd); 565 g_io_channel_set_close_on_unref(io, FALSE); 566 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, 567 G_IO_HUP | G_IO_ERR | G_IO_NVAL | G_IO_IN, 568 hci_event_watch, cmd, g_free); 569 g_io_channel_unref(io); 570 571 return 0; 572 573fail: 574 close(dd); 575 return err; 576} 577 578static int hciops_set_did(int index, uint16_t vendor, uint16_t product, 579 uint16_t version) 580{ 581 struct dev_info *dev = &devs[index]; 582 583 dev->did_vendor = vendor; 584 dev->did_product = product; 585 dev->did_version = version; 586 587 return 0; 588} 589 590/* End async HCI command handling */ 591 592/* Start of HCI event callbacks */ 593 594static gint conn_handle_cmp(gconstpointer a, gconstpointer b) 595{ 596 const struct bt_conn *conn = a; 597 uint16_t handle = *((const uint16_t *) b); 598 599 return (int) conn->handle - (int) handle; 600} 601 602static struct bt_conn *find_conn_by_handle(struct dev_info *dev, 603 uint16_t handle) 604{ 605 GSList *match; 606 607 match = g_slist_find_custom(dev->connections, &handle, 608 conn_handle_cmp); 609 if (match) 610 return match->data; 611 612 return NULL; 613} 614 615static gint conn_bdaddr_cmp(gconstpointer a, gconstpointer b) 616{ 617 const struct bt_conn *conn = a; 618 const bdaddr_t *bdaddr = b; 619 620 return bacmp(&conn->bdaddr, bdaddr); 621} 622 623static struct bt_conn *find_connection(struct dev_info *dev, bdaddr_t *bdaddr) 624{ 625 GSList *match; 626 627 match = g_slist_find_custom(dev->connections, bdaddr, conn_bdaddr_cmp); 628 if (match) 629 return match->data; 630 631 return NULL; 632} 633 634static struct bt_conn *get_connection(struct dev_info *dev, bdaddr_t *bdaddr) 635{ 636 struct bt_conn *conn; 637 638 conn = find_connection(dev, bdaddr); 639 if (conn) 640 return conn; 641 642 conn = g_new0(struct bt_conn, 1); 643 644 conn->dev = dev; 645 conn->loc_cap = dev->io_capability; 646 conn->loc_auth = 0xff; 647 conn->rem_auth = 0xff; 648 bacpy(&conn->bdaddr, bdaddr); 649 650 dev->connections = g_slist_append(dev->connections, conn); 651 652 return conn; 653} 654 655static int get_handle(int index, bdaddr_t *bdaddr, uint16_t *handle) 656{ 657 struct dev_info *dev = &devs[index]; 658 struct bt_conn *conn; 659 char addr[18]; 660 661 ba2str(bdaddr, addr); 662 DBG("hci%d dba %s", index, addr); 663 664 conn = find_connection(dev, bdaddr); 665 if (conn == NULL) 666 return -ENOENT; 667 668 *handle = conn->handle; 669 670 return 0; 671} 672 673static int disconnect_addr(int index, bdaddr_t *dba, uint8_t reason) 674{ 675 disconnect_cp cp; 676 uint16_t handle; 677 int err; 678 679 err = get_handle(index, dba, &handle); 680 if (err < 0) 681 return err; 682 683 memset(&cp, 0, sizeof(cp)); 684 cp.handle = htobs(handle); 685 cp.reason = reason; 686 687 if (hci_send_cmd(devs[index].sk, OGF_LINK_CTL, OCF_DISCONNECT, 688 DISCONNECT_CP_SIZE, &cp) < 0) 689 return -errno; 690 691 return 0; 692} 693 694static void bonding_complete(struct dev_info *dev, struct bt_conn *conn, 695 uint8_t status) 696{ 697 DBG("status 0x%02x", status); 698 699 if (conn->io != NULL) { 700 g_io_channel_shutdown(conn->io, TRUE, NULL); 701 g_io_channel_unref(conn->io); 702 conn->io = NULL; 703 } 704 705 conn->bonding_initiator = FALSE; 706 707 btd_event_bonding_complete(&dev->bdaddr, &conn->bdaddr, status); 708} 709 710static int get_auth_info(int index, bdaddr_t *bdaddr, uint8_t *auth) 711{ 712 struct dev_info *dev = &devs[index]; 713 struct hci_auth_info_req req; 714 char addr[18]; 715 716 ba2str(bdaddr, addr); 717 DBG("hci%d dba %s", index, addr); 718 719 memset(&req, 0, sizeof(req)); 720 bacpy(&req.bdaddr, bdaddr); 721 722 if (ioctl(dev->sk, HCIGETAUTHINFO, (unsigned long) &req) < 0) 723 return -errno; 724 725 if (auth) 726 *auth = req.type; 727 728 return 0; 729} 730 731/* Link Key handling */ 732 733static void link_key_request(int index, bdaddr_t *dba) 734{ 735 struct dev_info *dev = &devs[index]; 736 struct link_key_info *key_info; 737 struct bt_conn *conn; 738 GSList *match; 739 char da[18]; 740 741 ba2str(dba, da); 742 DBG("hci%d dba %s", index, da); 743 744 conn = get_connection(dev, dba); 745 if (conn->handle == 0) 746 conn->secmode3 = TRUE; 747 748 get_auth_info(index, dba, &conn->loc_auth); 749 750 DBG("kernel auth requirements = 0x%02x", conn->loc_auth); 751 752 match = g_slist_find_custom(dev->keys, dba, (GCompareFunc) bacmp); 753 if (match) 754 key_info = match->data; 755 else 756 key_info = NULL; 757 758 DBG("Matching key %s", key_info ? "found" : "not found"); 759 760 if (key_info == NULL || (!dev->debug_keys && key_info->type == 0x03)) { 761 /* Link key not found */ 762 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY, 763 6, dba); 764 return; 765 } 766 767 /* Link key found */ 768 769 DBG("link key type 0x%02x", key_info->type); 770 771 /* Don't use unauthenticated combination keys if MITM is 772 * required */ 773 if (key_info->type == 0x04 && conn->loc_auth != 0xff && 774 (conn->loc_auth & 0x01)) 775 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY, 776 6, dba); 777 else { 778 link_key_reply_cp lr; 779 780 memcpy(lr.link_key, key_info->key, 16); 781 bacpy(&lr.bdaddr, dba); 782 783 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_LINK_KEY_REPLY, 784 LINK_KEY_REPLY_CP_SIZE, &lr); 785 } 786} 787 788static void link_key_notify(int index, void *ptr) 789{ 790 struct dev_info *dev = &devs[index]; 791 evt_link_key_notify *evt = ptr; 792 bdaddr_t *dba = &evt->bdaddr; 793 struct link_key_info *key_info; 794 uint8_t old_key_type, key_type; 795 struct bt_conn *conn; 796 GSList *match; 797 char da[18]; 798 uint8_t status = 0; 799 800 ba2str(dba, da); 801 DBG("hci%d dba %s type %d", index, da, evt->key_type); 802 803 conn = get_connection(dev, &evt->bdaddr); 804 805 match = g_slist_find_custom(dev->keys, dba, (GCompareFunc) bacmp); 806 if (match) 807 key_info = match->data; 808 else 809 key_info = NULL; 810 811 if (key_info == NULL) { 812 key_info = g_new0(struct link_key_info, 1); 813 bacpy(&key_info->bdaddr, &evt->bdaddr); 814 old_key_type = 0xff; 815 } else { 816 dev->keys = g_slist_remove(dev->keys, key_info); 817 old_key_type = key_info->type; 818 } 819 820 memcpy(key_info->key, evt->link_key, sizeof(evt->link_key)); 821 key_info->type = evt->key_type; 822 key_info->pin_len = dev->pin_length; 823 824 key_type = evt->key_type; 825 826 DBG("key type 0x%02x old key type 0x%02x", key_type, old_key_type); 827 DBG("local auth 0x%02x and remote auth 0x%02x", 828 conn->loc_auth, conn->rem_auth); 829 830 if (key_type == 0x06) { 831 /* Some buggy controller combinations generate a changed 832 * combination key for legacy pairing even when there's no 833 * previous key */ 834 if ((!conn || conn->rem_auth == 0xff) && old_key_type == 0xff) 835 key_type = 0x00; 836 else if (old_key_type != 0xff) 837 key_type = old_key_type; 838 else 839 /* This is Changed Combination Link Key for 840 * a temporary link key.*/ 841 goto done; 842 } 843 844 key_info->type = key_type; 845 846 /* Skip the storage check if this is a debug key */ 847 if (key_type == 0x03) 848 goto done; 849 850 /* Store the link key persistently if one of the following is true: 851 * 1. this is a legacy link key 852 * 2. this is a changed combination key and there was a previously 853 * stored one 854 * 3. neither local nor remote side had no-bonding as a requirement 855 * 4. the local side had dedicated bonding as a requirement 856 * 5. the remote side is using dedicated bonding since in that case 857 * also the local requirements are set to dedicated bonding 858 * If none of the above match only keep the link key around for 859 * this connection and set the temporary flag for the device. 860 */ 861 if (key_type < 0x03 || (key_type == 0x06 && old_key_type != 0xff) || 862 (conn->loc_auth > 0x01 && conn->rem_auth > 0x01) || 863 (conn->loc_auth == 0x02 || conn->loc_auth == 0x03) || 864 (conn->rem_auth == 0x02 || conn->rem_auth == 0x03)) { 865 int err; 866 867 err = btd_event_link_key_notify(&dev->bdaddr, dba, 868 evt->link_key, key_type, 869 dev->pin_length); 870 871 if (err == -ENODEV) 872 status = HCI_OE_LOW_RESOURCES; 873 else if (err < 0) 874 status = HCI_MEMORY_FULL; 875 876 goto done; 877 } 878 879done: 880 dev->pin_length = 0; 881 882 if (status != 0) { 883 g_free(key_info); 884 bonding_complete(dev, conn, status); 885 disconnect_addr(index, dba, status); 886 return; 887 } 888 889 dev->keys = g_slist_prepend(dev->keys, key_info); 890 891 /* If we're connected and not dedicated bonding initiators we're 892 * done with the bonding process */ 893 if (!conn->bonding_initiator && conn->handle != 0) 894 bonding_complete(dev, conn, 0); 895} 896 897static void return_link_keys(int index, void *ptr) 898{ 899 struct dev_info *dev = &devs[index]; 900 evt_return_link_keys *evt = ptr; 901 uint8_t num = evt->num_keys; 902 unsigned char key[16]; 903 char da[18]; 904 bdaddr_t dba; 905 int i; 906 907 DBG("hci%d num_keys %u", index, num); 908 909 ptr++; 910 911 for (i = 0; i < num; i++) { 912 bacpy(&dba, ptr); ba2str(&dba, da); 913 memcpy(key, ptr + 6, 16); 914 915 DBG("hci%d returned key for %s", index, da); 916 917 btd_event_returned_link_key(&dev->bdaddr, &dba); 918 919 ptr += 22; 920 } 921} 922 923/* Simple Pairing handling */ 924 925static void user_confirm_request(int index, void *ptr) 926{ 927 struct dev_info *dev = &devs[index]; 928 evt_user_confirm_request *req = ptr; 929 gboolean loc_mitm, rem_mitm, auto_accept; 930 struct bt_conn *conn; 931 932 DBG("hci%d", index); 933 934 conn = find_connection(dev, &req->bdaddr); 935 if (conn == NULL) 936 return; 937 938 loc_mitm = (conn->loc_auth & 0x01) ? TRUE : FALSE; 939 rem_mitm = (conn->rem_auth & 0x01) ? TRUE : FALSE; 940 941 /* If we require MITM but the remote device can't provide that 942 * (it has NoInputNoOutput) then reject the confirmation 943 * request. The only exception is when we're dedicated bonding 944 * initiators since then we always have the MITM bit set. */ 945 if (!conn->bonding_initiator && loc_mitm && conn->rem_cap == 0x03) { 946 error("Rejecting request: remote device can't provide MITM"); 947 goto fail; 948 } 949 950 /* If no side requires MITM protection; auto-accept */ 951 if ((conn->loc_auth == 0xff || !loc_mitm || conn->rem_cap == 0x03) && 952 (!rem_mitm || conn->loc_cap == 0x03)) { 953 DBG("auto accept of confirmation"); 954 auto_accept = TRUE; 955 } else 956 auto_accept = FALSE; 957 958 if (btd_event_user_confirm(&dev->bdaddr, &req->bdaddr, 959 btohl(req->passkey), auto_accept) == 0) 960 return; 961 962fail: 963 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_USER_CONFIRM_NEG_REPLY, 964 6, ptr); 965} 966 967static void user_passkey_request(int index, void *ptr) 968{ 969 struct dev_info *dev = &devs[index]; 970 evt_user_passkey_request *req = ptr; 971 972 DBG("hci%d", index); 973 974 if (btd_event_user_passkey(&dev->bdaddr, &req->bdaddr) < 0) 975 hci_send_cmd(dev->sk, OGF_LINK_CTL, 976 OCF_USER_PASSKEY_NEG_REPLY, 6, ptr); 977} 978 979static void user_passkey_notify(int index, void *ptr) 980{ 981 struct dev_info *dev = &devs[index]; 982 evt_user_passkey_notify *req = ptr; 983 984 DBG("hci%d", index); 985 986 btd_event_user_notify(&dev->bdaddr, &req->bdaddr, 987 btohl(req->passkey)); 988} 989 990static void remote_oob_data_request(int index, void *ptr) 991{ 992 struct dev_info *dev = &devs[index]; 993 994 DBG("hci%d", index); 995 996 hci_send_cmd(dev->sk, OGF_LINK_CTL, 997 OCF_REMOTE_OOB_DATA_NEG_REPLY, 6, ptr); 998} 999 1000static int get_io_cap(int index, bdaddr_t *bdaddr, uint8_t *cap, uint8_t *auth) 1001{ 1002 struct dev_info *dev = &devs[index]; 1003 struct bt_conn *conn; 1004 int err; 1005 1006 conn = find_connection(dev, bdaddr); 1007 if (conn == NULL) 1008 return -ENOENT; 1009 1010 err = get_auth_info(index, bdaddr, &conn->loc_auth); 1011 if (err < 0) 1012 return err; 1013 1014 DBG("initial authentication requirement is 0x%02x", conn->loc_auth); 1015 1016 if (!dev->pairable && !conn->bonding_initiator) { 1017 if (conn->rem_auth < 0x02) { 1018 DBG("Allowing no bonding in non-bondable mode"); 1019 /* Kernel defaults to general bonding and so 1020 * overwrite for this special case. Otherwise 1021 * non-pairable test cases will fail. */ 1022 conn->loc_auth = conn->rem_auth; 1023 goto done; 1024 } 1025 1026 return -EPERM; 1027 } 1028 1029 /* If the kernel doesn't know the local requirement just mirror 1030 * the remote one */ 1031 if (conn->loc_auth == 0xff) 1032 conn->loc_auth = conn->rem_auth; 1033 1034 if (conn->loc_auth == 0x00 || conn->loc_auth == 0x04) { 1035 /* If remote requests dedicated bonding follow that lead */ 1036 if (conn->rem_auth == 0x02 || conn->rem_auth == 0x03) { 1037 1038 /* If both remote and local IO capabilities allow MITM 1039 * then require it, otherwise don't */ 1040 if (conn->rem_cap == 0x03 || conn->loc_cap == 0x03) 1041 conn->loc_auth = 0x02; 1042 else 1043 conn->loc_auth = 0x03; 1044 } 1045 1046 /* If remote indicates no bonding then follow that. This 1047 * is important since the kernel might give general bonding 1048 * as default. */ 1049 if (conn->rem_auth == 0x00 || conn->rem_auth == 0x01) 1050 conn->loc_auth = 0x00; 1051 1052 /* If remote requires MITM then also require it, unless 1053 * our IO capability is NoInputNoOutput (so some 1054 * just-works security cases can be tested) */ 1055 if (conn->rem_auth != 0xff && (conn->rem_auth & 0x01) && 1056 conn->loc_cap != 0x03) 1057 conn->loc_auth |= 0x01; 1058 } 1059 1060done: 1061 *cap = conn->loc_cap; 1062 *auth = conn->loc_auth; 1063 1064 DBG("final authentication requirement is 0x%02x", *auth); 1065 1066 return 0; 1067} 1068 1069static void io_capa_request(int index, void *ptr) 1070{ 1071 struct dev_info *dev = &devs[index]; 1072 bdaddr_t *dba = ptr; 1073 uint8_t cap, auth = 0xff; 1074 char da[18]; 1075 int err; 1076 1077 ba2str(dba, da); 1078 DBG("hci%d IO capability request for %s", index, da); 1079 1080 err = get_io_cap(index, dba, &cap, &auth); 1081 if (err < 0) { 1082 io_capability_neg_reply_cp cp; 1083 1084 error("Getting IO capability failed: %s (%d)", 1085 strerror(-err), -err); 1086 1087 memset(&cp, 0, sizeof(cp)); 1088 bacpy(&cp.bdaddr, dba); 1089 cp.reason = HCI_PAIRING_NOT_ALLOWED; 1090 hci_send_cmd(dev->sk, OGF_LINK_CTL, 1091 OCF_IO_CAPABILITY_NEG_REPLY, 1092 IO_CAPABILITY_NEG_REPLY_CP_SIZE, &cp); 1093 } else { 1094 io_capability_reply_cp cp; 1095 memset(&cp, 0, sizeof(cp)); 1096 bacpy(&cp.bdaddr, dba); 1097 cp.capability = cap; 1098 cp.oob_data = 0x00; 1099 cp.authentication = auth; 1100 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_IO_CAPABILITY_REPLY, 1101 IO_CAPABILITY_REPLY_CP_SIZE, &cp); 1102 } 1103} 1104 1105static void io_capa_response(int index, void *ptr) 1106{ 1107 struct dev_info *dev = &devs[index]; 1108 evt_io_capability_response *evt = ptr; 1109 struct bt_conn *conn; 1110 char da[18]; 1111 1112 ba2str(&evt->bdaddr, da); 1113 DBG("hci%d IO capability response from %s", index, da); 1114 1115 conn = find_connection(dev, &evt->bdaddr); 1116 if (conn) { 1117 conn->rem_cap = evt->capability; 1118 conn->rem_auth = evt->authentication; 1119 } 1120} 1121 1122/* PIN code handling */ 1123 1124static void pin_code_request(int index, bdaddr_t *dba) 1125{ 1126 struct dev_info *dev = &devs[index]; 1127 struct bt_conn *conn; 1128 char addr[18]; 1129 int err; 1130 1131 ba2str(dba, addr); 1132 DBG("hci%d PIN request for %s", index, addr); 1133 1134 conn = get_connection(dev, dba); 1135 if (conn->handle == 0) 1136 conn->secmode3 = TRUE; 1137 1138 /* Check if the adapter is not pairable and if there isn't a bonding in 1139 * progress */ 1140 if (!dev->pairable && !conn->bonding_initiator) { 1141 DBG("Rejecting PIN request in non-pairable mode"); 1142 goto reject; 1143 } 1144 1145 err = btd_event_request_pin(&dev->bdaddr, dba); 1146 if (err < 0) { 1147 error("PIN code negative reply: %s", strerror(-err)); 1148 goto reject; 1149 } 1150 1151 return; 1152 1153reject: 1154 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_PIN_CODE_NEG_REPLY, 6, dba); 1155} 1156 1157static void start_inquiry(bdaddr_t *local, uint8_t status, gboolean periodic) 1158{ 1159 struct btd_adapter *adapter; 1160 int state; 1161 1162 /* Don't send the signal if the cmd failed */ 1163 if (status) { 1164 error("Inquiry Failed with status 0x%02x", status); 1165 return; 1166 } 1167 1168 adapter = manager_find_adapter(local); 1169 if (!adapter) { 1170 error("Unable to find matching adapter"); 1171 return; 1172 } 1173 1174 state = adapter_get_state(adapter); 1175 1176 if (periodic) 1177 state |= STATE_PINQ; 1178 else 1179 state |= STATE_STDINQ; 1180 1181 adapter_set_state(adapter, state); 1182} 1183 1184static void inquiry_complete(bdaddr_t *local, uint8_t status, 1185 gboolean periodic) 1186{ 1187 struct btd_adapter *adapter; 1188 int state; 1189 1190 /* Don't send the signal if the cmd failed */ 1191 if (status) { 1192 error("Inquiry Failed with status 0x%02x", status); 1193 return; 1194 } 1195 1196 adapter = manager_find_adapter(local); 1197 if (!adapter) { 1198 error("Unable to find matching adapter"); 1199 return; 1200 } 1201 1202 state = adapter_get_state(adapter); 1203 state &= ~(STATE_STDINQ | STATE_PINQ); 1204 adapter_set_state(adapter, state); 1205} 1206 1207static inline void remote_features_notify(int index, void *ptr) 1208{ 1209 struct dev_info *dev = &devs[index]; 1210 evt_remote_host_features_notify *evt = ptr; 1211 1212 if (evt->features[0] & 0x01) 1213 btd_event_set_legacy_pairing(&dev->bdaddr, &evt->bdaddr, 1214 FALSE); 1215 else 1216 btd_event_set_legacy_pairing(&dev->bdaddr, &evt->bdaddr, 1217 TRUE); 1218 1219 write_features_info(&dev->bdaddr, &evt->bdaddr, NULL, evt->features); 1220} 1221 1222static void write_le_host_complete(int index, uint8_t status) 1223{ 1224 struct dev_info *dev = &devs[index]; 1225 uint8_t page_num = 0x01; 1226 1227 if (status) 1228 return; 1229 1230 if (hci_send_cmd(dev->sk, OGF_INFO_PARAM, 1231 OCF_READ_LOCAL_EXT_FEATURES, 1, &page_num) < 0) 1232 error("Unable to read extended local features: %s (%d)", 1233 strerror(errno), errno); 1234} 1235 1236static void read_local_version_complete(int index, 1237 const read_local_version_rp *rp) 1238{ 1239 struct dev_info *dev = &devs[index]; 1240 1241 if (rp->status) 1242 return; 1243 1244 dev->ver.manufacturer = btohs(bt_get_unaligned(&rp->manufacturer)); 1245 dev->ver.hci_ver = rp->hci_ver; 1246 dev->ver.hci_rev = btohs(bt_get_unaligned(&rp->hci_rev)); 1247 dev->ver.lmp_ver = rp->lmp_ver; 1248 dev->ver.lmp_subver = btohs(bt_get_unaligned(&rp->lmp_subver)); 1249 1250 if (!dev->pending) 1251 return; 1252 1253 hci_clear_bit(PENDING_VERSION, &dev->pending); 1254 1255 DBG("Got version for hci%d", index); 1256 1257 if (!dev->pending && dev->up) 1258 init_adapter(index); 1259} 1260 1261static void read_local_features_complete(int index, 1262 const read_local_features_rp *rp) 1263{ 1264 struct dev_info *dev = &devs[index]; 1265 1266 if (rp->status) 1267 return; 1268 1269 memcpy(dev->features, rp->features, 8); 1270 1271 if (!dev->pending) 1272 return; 1273 1274 hci_clear_bit(PENDING_FEATURES, &dev->pending); 1275 1276 DBG("Got features for hci%d", index); 1277 1278 if (!dev->pending && dev->up) 1279 init_adapter(index); 1280} 1281 1282#define SIZEOF_UUID128 16 1283 1284static void eir_generate_uuid128(GSList *list, uint8_t *ptr, uint16_t *eir_len) 1285{ 1286 int i, k, uuid_count = 0; 1287 uint16_t len = *eir_len; 1288 uint8_t *uuid128; 1289 gboolean truncated = FALSE; 1290 1291 /* Store UUIDs in place, skip 2 bytes to write type and length later */ 1292 uuid128 = ptr + 2; 1293 1294 for (; list; list = list->next) { 1295 struct uuid_info *uuid = list->data; 1296 uint8_t *uuid128_data = uuid->uuid.value.uuid128.data; 1297 1298 if (uuid->uuid.type != SDP_UUID128) 1299 continue; 1300 1301 /* Stop if not enough space to put next UUID128 */ 1302 if ((len + 2 + SIZEOF_UUID128) > EIR_DATA_LENGTH) { 1303 truncated = TRUE; 1304 break; 1305 } 1306 1307 /* Check for duplicates, EIR data is Little Endian */ 1308 for (i = 0; i < uuid_count; i++) { 1309 for (k = 0; k < SIZEOF_UUID128; k++) { 1310 if (uuid128[i * SIZEOF_UUID128 + k] != 1311 uuid128_data[SIZEOF_UUID128 - 1 - k]) 1312 break; 1313 } 1314 if (k == SIZEOF_UUID128) 1315 break; 1316 } 1317 1318 if (i < uuid_count) 1319 continue; 1320 1321 /* EIR data is Little Endian */ 1322 for (k = 0; k < SIZEOF_UUID128; k++) 1323 uuid128[uuid_count * SIZEOF_UUID128 + k] = 1324 uuid128_data[SIZEOF_UUID128 - 1 - k]; 1325 1326 len += SIZEOF_UUID128; 1327 uuid_count++; 1328 } 1329 1330 if (uuid_count > 0 || truncated) { 1331 /* EIR Data length */ 1332 ptr[0] = (uuid_count * SIZEOF_UUID128) + 1; 1333 /* EIR Data type */ 1334 ptr[1] = truncated ? EIR_UUID128_SOME : EIR_UUID128_ALL; 1335 len += 2; 1336 *eir_len = len; 1337 } 1338} 1339 1340static void create_ext_inquiry_response(int index, uint8_t *data) 1341{ 1342 struct dev_info *dev = &devs[index]; 1343 GSList *l; 1344 uint8_t *ptr = data; 1345 uint16_t eir_len = 0; 1346 uint16_t uuid16[EIR_DATA_LENGTH / 2]; 1347 int i, uuid_count = 0; 1348 gboolean truncated = FALSE; 1349 size_t name_len; 1350 1351 name_len = strlen(dev->name); 1352 1353 if (name_len > 0) { 1354 /* EIR Data type */ 1355 if (name_len > 48) { 1356 name_len = 48; 1357 ptr[1] = EIR_NAME_SHORT; 1358 } else 1359 ptr[1] = EIR_NAME_COMPLETE; 1360 1361 /* EIR Data length */ 1362 ptr[0] = name_len + 1; 1363 1364 memcpy(ptr + 2, dev->name, name_len); 1365 1366 eir_len += (name_len + 2); 1367 ptr += (name_len + 2); 1368 } 1369 1370 if (dev->tx_power != 0) { 1371 *ptr++ = 2; 1372 *ptr++ = EIR_TX_POWER; 1373 *ptr++ = (uint8_t) dev->tx_power; 1374 eir_len += 3; 1375 } 1376 1377 if (dev->did_vendor != 0x0000) { 1378 uint16_t source = 0x0002; 1379 *ptr++ = 9; 1380 *ptr++ = EIR_DEVICE_ID; 1381 *ptr++ = (source & 0x00ff); 1382 *ptr++ = (source & 0xff00) >> 8; 1383 *ptr++ = (dev->did_vendor & 0x00ff); 1384 *ptr++ = (dev->did_vendor & 0xff00) >> 8; 1385 *ptr++ = (dev->did_product & 0x00ff); 1386 *ptr++ = (dev->did_product & 0xff00) >> 8; 1387 *ptr++ = (dev->did_version & 0x00ff); 1388 *ptr++ = (dev->did_version & 0xff00) >> 8; 1389 eir_len += 10; 1390 } 1391 1392 /* Group all UUID16 types */ 1393 for (l = dev->uuids; l != NULL; l = g_slist_next(l)) { 1394 struct uuid_info *uuid = l->data; 1395 1396 if (uuid->uuid.type != SDP_UUID16) 1397 continue; 1398 1399 if (uuid->uuid.value.uuid16 < 0x1100) 1400 continue; 1401 1402 if (uuid->uuid.value.uuid16 == PNP_INFO_SVCLASS_ID) 1403 continue; 1404 1405 /* Stop if not enough space to put next UUID16 */ 1406 if ((eir_len + 2 + sizeof(uint16_t)) > EIR_DATA_LENGTH) { 1407 truncated = TRUE; 1408 break; 1409 } 1410 1411 /* Check for duplicates */ 1412 for (i = 0; i < uuid_count; i++) 1413 if (uuid16[i] == uuid->uuid.value.uuid16) 1414 break; 1415 1416 if (i < uuid_count) 1417 continue; 1418 1419 uuid16[uuid_count++] = uuid->uuid.value.uuid16; 1420 eir_len += sizeof(uint16_t); 1421 } 1422 1423 if (uuid_count > 0) { 1424 /* EIR Data length */ 1425 ptr[0] = (uuid_count * sizeof(uint16_t)) + 1; 1426 /* EIR Data type */ 1427 ptr[1] = truncated ? EIR_UUID16_SOME : EIR_UUID16_ALL; 1428 1429 ptr += 2; 1430 eir_len += 2; 1431 1432 for (i = 0; i < uuid_count; i++) { 1433 *ptr++ = (uuid16[i] & 0x00ff); 1434 *ptr++ = (uuid16[i] & 0xff00) >> 8; 1435 } 1436 } 1437 1438 /* Group all UUID128 types */ 1439 if (eir_len <= EIR_DATA_LENGTH - 2) 1440 eir_generate_uuid128(dev->uuids, ptr, &eir_len); 1441} 1442 1443static void update_ext_inquiry_response(int index) 1444{ 1445 struct dev_info *dev = &devs[index]; 1446 write_ext_inquiry_response_cp cp; 1447 1448 DBG("hci%d", index); 1449 1450 if (!(dev->features[6] & LMP_EXT_INQ)) 1451 return; 1452 1453 if (dev->ssp_mode == 0) 1454 return; 1455 1456 if (dev->cache_enable) 1457 return; 1458 1459 memset(&cp, 0, sizeof(cp)); 1460 1461 create_ext_inquiry_response(index, cp.data); 1462 1463 if (memcmp(cp.data, dev->eir, sizeof(cp.data)) == 0) 1464 return; 1465 1466 memcpy(dev->eir, cp.data, sizeof(cp.data)); 1467 1468 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, 1469 OCF_WRITE_EXT_INQUIRY_RESPONSE, 1470 WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE, &cp) < 0) 1471 error("Unable to write EIR data: %s (%d)", 1472 strerror(errno), errno); 1473} 1474 1475static void update_name(int index, const char *name) 1476{ 1477 struct btd_adapter *adapter; 1478 1479 adapter = manager_find_adapter_by_id(index); 1480 if (adapter) 1481 adapter_update_local_name(adapter, name); 1482 1483 update_ext_inquiry_response(index); 1484} 1485 1486static void read_local_name_complete(int index, read_local_name_rp *rp) 1487{ 1488 struct dev_info *dev = &devs[index]; 1489 1490 DBG("hci%d status %u", index, rp->status); 1491 1492 if (rp->status) 1493 return; 1494 1495 memcpy(dev->name, rp->name, 248); 1496 1497 if (!dev->pending) { 1498 update_name(index, (char *) rp->name); 1499 return; 1500 } 1501 1502 hci_clear_bit(PENDING_NAME, &dev->pending); 1503 1504 DBG("Got name for hci%d", index); 1505 1506 if (!dev->up) 1507 return; 1508 1509 /* Even though it shouldn't happen (assuming the kernel behaves 1510 * properly) it seems like we might miss the very first 1511 * initialization commands that the kernel sends. So check for 1512 * it here (since read_local_name is one of the last init 1513 * commands) and resend the first ones if we haven't seen 1514 * their results yet */ 1515 1516 if (hci_test_bit(PENDING_FEATURES, &dev->pending)) 1517 hci_send_cmd(dev->sk, OGF_INFO_PARAM, 1518 OCF_READ_LOCAL_FEATURES, 0, NULL); 1519 1520 if (hci_test_bit(PENDING_VERSION, &dev->pending)) 1521 hci_send_cmd(dev->sk, OGF_INFO_PARAM, 1522 OCF_READ_LOCAL_VERSION, 0, NULL); 1523 1524 if (!dev->pending) 1525 init_adapter(index); 1526} 1527 1528static void read_tx_power_complete(int index, void *ptr) 1529{ 1530 struct dev_info *dev = &devs[index]; 1531 1532 read_inq_response_tx_power_level_rp *rp = ptr; 1533 1534 DBG("hci%d status %u", index, rp->status); 1535 1536 if (rp->status) 1537 return; 1538 1539 dev->tx_power = rp->level; 1540 update_ext_inquiry_response(index); 1541} 1542 1543static void read_simple_pairing_mode_complete(int index, void *ptr) 1544{ 1545 struct dev_info *dev = &devs[index]; 1546 read_simple_pairing_mode_rp *rp = ptr; 1547 struct btd_adapter *adapter; 1548 1549 DBG("hci%d status %u", index, rp->status); 1550 1551 if (rp->status) 1552 return; 1553 1554 dev->ssp_mode = rp->mode; 1555 update_ext_inquiry_response(index); 1556 1557 adapter = manager_find_adapter(&dev->bdaddr); 1558 if (!adapter) { 1559 error("No matching adapter found"); 1560 return; 1561 } 1562 1563 adapter_update_ssp_mode(adapter, rp->mode); 1564} 1565 1566static void read_local_ext_features_complete(int index, 1567 const read_local_ext_features_rp *rp) 1568{ 1569 struct btd_adapter *adapter; 1570 1571 DBG("hci%d status %u", index, rp->status); 1572 1573 if (rp->status) 1574 return; 1575 1576 adapter = manager_find_adapter_by_id(index); 1577 if (!adapter) { 1578 error("No matching adapter found"); 1579 return; 1580 } 1581 1582 /* Local Extended feature page number is 1 */ 1583 if (rp->page_num != 1) 1584 return; 1585 1586 btd_adapter_update_local_ext_features(adapter, rp->features); 1587} 1588 1589static void read_bd_addr_complete(int index, read_bd_addr_rp *rp) 1590{ 1591 struct dev_info *dev = &devs[index]; 1592 1593 DBG("hci%d status %u", index, rp->status); 1594 1595 if (rp->status) 1596 return; 1597 1598 bacpy(&dev->bdaddr, &rp->bdaddr); 1599 1600 if (!dev->pending) 1601 return; 1602 1603 hci_clear_bit(PENDING_BDADDR, &dev->pending); 1604 1605 DBG("Got bdaddr for hci%d", index); 1606 1607 if (!dev->pending && dev->up) 1608 init_adapter(index); 1609} 1610 1611static inline void cmd_status(int index, void *ptr) 1612{ 1613 struct dev_info *dev = &devs[index]; 1614 evt_cmd_status *evt = ptr; 1615 uint16_t opcode = btohs(evt->opcode); 1616 1617 if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY)) 1618 start_inquiry(&dev->bdaddr, evt->status, FALSE); 1619} 1620 1621static void read_scan_complete(int index, uint8_t status, void *ptr) 1622{ 1623 struct btd_adapter *adapter; 1624 read_scan_enable_rp *rp = ptr; 1625 1626 DBG("hci%d status %u", index, status); 1627 1628 adapter = manager_find_adapter_by_id(index); 1629 if (!adapter) { 1630 error("Unable to find matching adapter"); 1631 return; 1632 } 1633 1634 adapter_mode_changed(adapter, rp->enable); 1635} 1636 1637static int write_class(int index, uint32_t class) 1638{ 1639 struct dev_info *dev = &devs[index]; 1640 write_class_of_dev_cp cp; 1641 1642 DBG("hci%d class 0x%06x", index, class); 1643 1644 memcpy(cp.dev_class, &class, 3); 1645 1646 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV, 1647 WRITE_CLASS_OF_DEV_CP_SIZE, &cp) < 0) 1648 return -errno; 1649 1650 dev->pending_cod = class; 1651 1652 return 0; 1653} 1654 1655/* Limited Discoverable bit mask in CoD */ 1656#define LIMITED_BIT 0x002000 1657 1658static int hciops_set_limited_discoverable(int index, gboolean limited) 1659{ 1660 struct dev_info *dev = &devs[index]; 1661 int num = (limited ? 2 : 1); 1662 uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e }; 1663 write_current_iac_lap_cp cp; 1664 1665 DBG("hci%d limited %d", index, limited); 1666 1667 /* Check if limited bit needs to be set/reset */ 1668 if (limited) 1669 dev->wanted_cod |= LIMITED_BIT; 1670 else 1671 dev->wanted_cod &= ~LIMITED_BIT; 1672 1673 /* If we dont need the toggling, save an unnecessary CoD write */ 1674 if (dev->pending_cod || dev->wanted_cod == dev->current_cod) 1675 return 0; 1676 1677 /* 1678 * 1: giac 1679 * 2: giac + liac 1680 */ 1681 memset(&cp, 0, sizeof(cp)); 1682 cp.num_current_iac = num; 1683 memcpy(&cp.lap, lap, num * 3); 1684 1685 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_CURRENT_IAC_LAP, 1686 (num * 3 + 1), &cp) < 0) 1687 return -errno; 1688 1689 return write_class(index, dev->wanted_cod); 1690} 1691 1692static void write_class_complete(int index, uint8_t status) 1693{ 1694 struct dev_info *dev = &devs[index]; 1695 struct btd_adapter *adapter; 1696 1697 if (status) 1698 return; 1699 1700 if (dev->pending_cod == 0) 1701 return; 1702 1703 dev->current_cod = dev->pending_cod; 1704 dev->pending_cod = 0; 1705 1706 adapter = manager_find_adapter(&dev->bdaddr); 1707 if (adapter) 1708 btd_adapter_class_changed(adapter, dev->current_cod); 1709 1710 update_ext_inquiry_response(index); 1711 1712 if (dev->wanted_cod == dev->current_cod) 1713 return; 1714 1715 if (dev->wanted_cod & LIMITED_BIT && 1716 !(dev->current_cod & LIMITED_BIT)) 1717 hciops_set_limited_discoverable(index, TRUE); 1718 else if (!(dev->wanted_cod & LIMITED_BIT) && 1719 (dev->current_cod & LIMITED_BIT)) 1720 hciops_set_limited_discoverable(index, FALSE); 1721 else 1722 write_class(index, dev->wanted_cod); 1723} 1724 1725static inline void cmd_complete(int index, void *ptr) 1726{ 1727 struct dev_info *dev = &devs[index]; 1728 evt_cmd_complete *evt = ptr; 1729 uint16_t opcode = btohs(evt->opcode); 1730 uint8_t status = *((uint8_t *) ptr + EVT_CMD_COMPLETE_SIZE); 1731 1732 switch (opcode) { 1733 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION): 1734 ptr += sizeof(evt_cmd_complete); 1735 read_local_version_complete(index, ptr); 1736 break; 1737 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_FEATURES): 1738 ptr += sizeof(evt_cmd_complete); 1739 read_local_features_complete(index, ptr); 1740 break; 1741 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_EXT_FEATURES): 1742 ptr += sizeof(evt_cmd_complete); 1743 read_local_ext_features_complete(index, ptr); 1744 break; 1745 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_BD_ADDR): 1746 ptr += sizeof(evt_cmd_complete); 1747 read_bd_addr_complete(index, ptr); 1748 break; 1749 case cmd_opcode_pack(OGF_LINK_CTL, OCF_PERIODIC_INQUIRY): 1750 start_inquiry(&dev->bdaddr, status, TRUE); 1751 break; 1752 case cmd_opcode_pack(OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY): 1753 inquiry_complete(&dev->bdaddr, status, TRUE); 1754 break; 1755 case cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY_CANCEL): 1756 inquiry_complete(&dev->bdaddr, status, FALSE); 1757 break; 1758 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_LE_HOST_SUPPORTED): 1759 write_le_host_complete(index, status); 1760 break; 1761 case cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE): 1762 btd_event_le_set_scan_enable_complete(&dev->bdaddr, status); 1763 break; 1764 case cmd_opcode_pack(OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME): 1765 if (!status) 1766 hci_send_cmd(dev->sk, OGF_HOST_CTL, 1767 OCF_READ_LOCAL_NAME, 0, 0); 1768 break; 1769 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE): 1770 btd_event_setscan_enable_complete(&dev->bdaddr); 1771 break; 1772 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SCAN_ENABLE): 1773 ptr += sizeof(evt_cmd_complete); 1774 read_scan_complete(index, status, ptr); 1775 break; 1776 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV): 1777 write_class_complete(index, status); 1778 break; 1779 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SIMPLE_PAIRING_MODE): 1780 if (!status) 1781 hci_send_cmd(dev->sk, OGF_HOST_CTL, 1782 OCF_READ_SIMPLE_PAIRING_MODE, 0, NULL); 1783 break; 1784 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SIMPLE_PAIRING_MODE): 1785 ptr += sizeof(evt_cmd_complete); 1786 read_simple_pairing_mode_complete(index, ptr); 1787 break; 1788 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_LOCAL_NAME): 1789 ptr += sizeof(evt_cmd_complete); 1790 read_local_name_complete(index, ptr); 1791 break; 1792 case cmd_opcode_pack(OGF_HOST_CTL, 1793 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL): 1794 ptr += sizeof(evt_cmd_complete); 1795 read_tx_power_complete(index, ptr); 1796 break; 1797 }; 1798} 1799 1800static inline void remote_name_information(int index, void *ptr) 1801{ 1802 struct dev_info *dev = &devs[index]; 1803 evt_remote_name_req_complete *evt = ptr; 1804 char name[MAX_NAME_LENGTH + 1]; 1805 1806 DBG("hci%d status %u", index, evt->status); 1807 1808 memset(name, 0, sizeof(name)); 1809 1810 if (!evt->status) 1811 memcpy(name, evt->name, MAX_NAME_LENGTH); 1812 1813 btd_event_remote_name(&dev->bdaddr, &evt->bdaddr, evt->status, name); 1814} 1815 1816static inline void remote_version_information(int index, void *ptr) 1817{ 1818 struct dev_info *dev = &devs[index]; 1819 evt_read_remote_version_complete *evt = ptr; 1820 struct bt_conn *conn; 1821 1822 DBG("hci%d status %u", index, evt->status); 1823 1824 if (evt->status) 1825 return; 1826 1827 conn = find_conn_by_handle(dev, btohs(evt->handle)); 1828 if (conn == NULL) 1829 return; 1830 1831 write_version_info(&dev->bdaddr, &conn->bdaddr, 1832 btohs(evt->manufacturer), evt->lmp_ver, 1833 btohs(evt->lmp_subver)); 1834} 1835 1836static inline void inquiry_result(int index, int plen, void *ptr) 1837{ 1838 struct dev_info *dev = &devs[index]; 1839 uint8_t num = *(uint8_t *) ptr++; 1840 int i; 1841 1842 for (i = 0; i < num; i++) { 1843 inquiry_info *info = ptr; 1844 uint32_t class = info->dev_class[0] | 1845 (info->dev_class[1] << 8) | 1846 (info->dev_class[2] << 16); 1847 1848 btd_event_device_found(&dev->bdaddr, &info->bdaddr, class, 1849 0, NULL); 1850 ptr += INQUIRY_INFO_SIZE; 1851 } 1852} 1853 1854static inline void inquiry_result_with_rssi(int index, int plen, void *ptr) 1855{ 1856 struct dev_info *dev = &devs[index]; 1857 uint8_t num = *(uint8_t *) ptr++; 1858 int i; 1859 1860 if (!num) 1861 return; 1862 1863 if ((plen - 1) / num == INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE) { 1864 for (i = 0; i < num; i++) { 1865 inquiry_info_with_rssi_and_pscan_mode *info = ptr; 1866 uint32_t class = info->dev_class[0] 1867 | (info->dev_class[1] << 8) 1868 | (info->dev_class[2] << 16); 1869 1870 btd_event_device_found(&dev->bdaddr, &info->bdaddr, 1871 class, info->rssi, NULL); 1872 ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE; 1873 } 1874 } else { 1875 for (i = 0; i < num; i++) { 1876 inquiry_info_with_rssi *info = ptr; 1877 uint32_t class = info->dev_class[0] 1878 | (info->dev_class[1] << 8) 1879 | (info->dev_class[2] << 16); 1880 1881 btd_event_device_found(&dev->bdaddr, &info->bdaddr, 1882 class, info->rssi, NULL); 1883 ptr += INQUIRY_INFO_WITH_RSSI_SIZE; 1884 } 1885 } 1886} 1887 1888static inline void extended_inquiry_result(int index, int plen, void *ptr) 1889{ 1890 struct dev_info *dev = &devs[index]; 1891 uint8_t num = *(uint8_t *) ptr++; 1892 int i; 1893 1894 for (i = 0; i < num; i++) { 1895 extended_inquiry_info *info = ptr; 1896 uint32_t class = info->dev_class[0] 1897 | (info->dev_class[1] << 8) 1898 | (info->dev_class[2] << 16); 1899 1900 btd_event_device_found(&dev->bdaddr, &info->bdaddr, class, 1901 info->rssi, info->data); 1902 ptr += EXTENDED_INQUIRY_INFO_SIZE; 1903 } 1904} 1905 1906static inline void remote_features_information(int index, void *ptr) 1907{ 1908 struct dev_info *dev = &devs[index]; 1909 evt_read_remote_features_complete *evt = ptr; 1910 struct bt_conn *conn; 1911 1912 DBG("hci%d status %u", index, evt->status); 1913 1914 if (evt->status) 1915 return; 1916 1917 conn = find_conn_by_handle(dev, btohs(evt->handle)); 1918 if (conn == NULL) 1919 return; 1920 1921 write_features_info(&dev->bdaddr, &conn->bdaddr, evt->features, NULL); 1922} 1923 1924struct remote_version_req { 1925 int index; 1926 uint16_t handle; 1927}; 1928 1929static gboolean __get_remote_version(gpointer user_data) 1930{ 1931 struct remote_version_req *req = user_data; 1932 struct dev_info *dev = &devs[req->index]; 1933 read_remote_version_cp cp; 1934 1935 DBG("hci%d handle %u", req->index, req->handle); 1936 1937 memset(&cp, 0, sizeof(cp)); 1938 cp.handle = htobs(req->handle); 1939 1940 hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_READ_REMOTE_VERSION, 1941 READ_REMOTE_VERSION_CP_SIZE, &cp); 1942 1943 return FALSE; 1944} 1945 1946static void get_remote_version(int index, uint16_t handle) 1947{ 1948 struct remote_version_req *req; 1949 1950 req = g_new0(struct remote_version_req, 1); 1951 req->handle = handle; 1952 req->index = index; 1953 1954 g_timeout_add_seconds_full(G_PRIORITY_DEFAULT, 1, __get_remote_version, 1955 req, g_free); 1956} 1957 1958static void conn_free(struct bt_conn *conn) 1959{ 1960 if (conn->io != NULL) { 1961 g_io_channel_shutdown(conn->io, TRUE, NULL); 1962 g_io_channel_unref(conn->io); 1963 } 1964 1965 g_free(conn); 1966} 1967 1968static inline void conn_complete(int index, void *ptr) 1969{ 1970 struct dev_info *dev = &devs[index]; 1971 evt_conn_complete *evt = ptr; 1972 char filename[PATH_MAX]; 1973 char local_addr[18], peer_addr[18], *str; 1974 struct bt_conn *conn; 1975 1976 if (evt->link_type != ACL_LINK) 1977 return; 1978 1979 DBG("status 0x%02x", evt->status); 1980 1981 conn = find_connection(dev, &evt->bdaddr); 1982 1983 if (evt->status == 0) { 1984 if (conn == NULL) 1985 conn = get_connection(dev, &evt->bdaddr); 1986 conn->handle = btohs(evt->handle); 1987 } else if (conn != NULL) { 1988 dev->connections = g_slist_remove(dev->connections, conn); 1989 conn_free(conn); 1990 } 1991 1992 btd_event_conn_complete(&dev->bdaddr, evt->status, &evt->bdaddr); 1993 1994 if (evt->status != 0) 1995 return; 1996 1997 if (conn->secmode3) 1998 bonding_complete(dev, conn, 0); 1999 2000 /* check if the remote version needs be requested */ 2001 ba2str(&dev->bdaddr, local_addr); 2002 ba2str(&evt->bdaddr, peer_addr); 2003 2004 create_name(filename, sizeof(filename), STORAGEDIR, local_addr, 2005 "manufacturers"); 2006 2007 str = textfile_get(filename, peer_addr); 2008 if (!str) 2009 get_remote_version(index, btohs(evt->handle)); 2010 else 2011 free(str); 2012} 2013 2014static inline void le_conn_complete(int index, void *ptr) 2015{ 2016 struct dev_info *dev = &devs[index]; 2017 evt_le_connection_complete *evt = ptr; 2018 char filename[PATH_MAX]; 2019 char local_addr[18], peer_addr[18], *str; 2020 2021 if (evt->status == 0) { 2022 struct bt_conn *conn; 2023 2024 conn = get_connection(dev, &evt->peer_bdaddr); 2025 conn->handle = btohs(evt->handle); 2026 } 2027 2028 btd_event_conn_complete(&dev->bdaddr, evt->status, &evt->peer_bdaddr); 2029 2030 if (evt->status) 2031 return; 2032 2033 /* check if the remote version needs be requested */ 2034 ba2str(&dev->bdaddr, local_addr); 2035 ba2str(&evt->peer_bdaddr, peer_addr); 2036 2037 create_name(filename, sizeof(filename), STORAGEDIR, local_addr, 2038 "manufacturers"); 2039 2040 str = textfile_get(filename, peer_addr); 2041 if (!str) 2042 get_remote_version(index, btohs(evt->handle)); 2043 else 2044 free(str); 2045} 2046 2047static inline void disconn_complete(int index, void *ptr) 2048{ 2049 struct dev_info *dev = &devs[index]; 2050 evt_disconn_complete *evt = ptr; 2051 struct bt_conn *conn; 2052 2053 DBG("handle %u status 0x%02x", btohs(evt->handle), evt->status); 2054 2055 if (evt->status != 0) 2056 return; 2057 2058 conn = find_conn_by_handle(dev, btohs(evt->handle)); 2059 if (conn == NULL) 2060 return; 2061 2062 dev->connections = g_slist_remove(dev->connections, conn); 2063 2064 btd_event_disconn_complete(&dev->bdaddr, &conn->bdaddr); 2065 2066 conn_free(conn); 2067} 2068 2069static inline void auth_complete(int index, void *ptr) 2070{ 2071 struct dev_info *dev = &devs[index]; 2072 evt_auth_complete *evt = ptr; 2073 struct bt_conn *conn; 2074 2075 DBG("hci%d status %u", index, evt->status); 2076 2077 conn = find_conn_by_handle(dev, btohs(evt->handle)); 2078 if (conn == NULL) 2079 return; 2080 2081 bonding_complete(dev, conn, evt->status); 2082} 2083 2084static inline void simple_pairing_complete(int index, void *ptr) 2085{ 2086 struct dev_info *dev = &devs[index]; 2087 evt_simple_pairing_complete *evt = ptr; 2088 2089 DBG("hci%d status %u", index, evt->status); 2090 2091 btd_event_simple_pairing_complete(&dev->bdaddr, &evt->bdaddr, 2092 evt->status); 2093} 2094 2095static inline void conn_request(int index, void *ptr) 2096{ 2097 struct dev_info *dev = &devs[index]; 2098 evt_conn_request *evt = ptr; 2099 uint32_t class = evt->dev_class[0] | (evt->dev_class[1] << 8) 2100 | (evt->dev_class[2] << 16); 2101 2102 btd_event_remote_class(&dev->bdaddr, &evt->bdaddr, class); 2103} 2104 2105static inline void le_advertising_report(int index, evt_le_meta_event *meta) 2106{ 2107 struct dev_info *dev = &devs[index]; 2108 le_advertising_info *info; 2109 uint8_t num, i; 2110 2111 num = meta->data[0]; 2112 info = (le_advertising_info *) (meta->data + 1); 2113 2114 for (i = 0; i < num; i++) { 2115 btd_event_advertising_report(&dev->bdaddr, info); 2116 info = (le_advertising_info *) (info->data + info->length + 1); 2117 } 2118} 2119 2120static inline void le_metaevent(int index, void *ptr) 2121{ 2122 evt_le_meta_event *meta = ptr; 2123 2124 DBG("hci%d LE Meta Event %u", index, meta->subevent); 2125 2126 switch (meta->subevent) { 2127 case EVT_LE_ADVERTISING_REPORT: 2128 le_advertising_report(index, meta); 2129 break; 2130 2131 case EVT_LE_CONN_COMPLETE: 2132 le_conn_complete(index, meta->data); 2133 break; 2134 } 2135} 2136 2137static void stop_hci_dev(int index) 2138{ 2139 struct dev_info *dev = &devs[index]; 2140 2141 if (dev->sk < 0) 2142 return; 2143 2144 info("Stopping hci%d event socket", index); 2145 2146 if (dev->watch_id > 0) 2147 g_source_remove(dev->watch_id); 2148 2149 if (dev->io != NULL) 2150 g_io_channel_unref(dev->io); 2151 2152 hci_close_dev(dev->sk); 2153 2154 g_slist_foreach(dev->keys, (GFunc) g_free, NULL); 2155 g_slist_free(dev->keys); 2156 2157 g_slist_foreach(dev->uuids, (GFunc) g_free, NULL); 2158 g_slist_free(dev->uuids); 2159 2160 g_slist_foreach(dev->connections, (GFunc) conn_free, NULL); 2161 g_slist_free(dev->connections); 2162 2163 init_dev_info(index, -1, dev->registered); 2164} 2165 2166static gboolean io_security_event(GIOChannel *chan, GIOCondition cond, 2167 gpointer data) 2168{ 2169 unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr = buf; 2170 int type, index = GPOINTER_TO_INT(data); 2171 struct dev_info *dev = &devs[index]; 2172 struct hci_dev_info di; 2173 ssize_t len; 2174 hci_event_hdr *eh; 2175 evt_cmd_status *evt; 2176 int fd; 2177 2178 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) { 2179 stop_hci_dev(index); 2180 return FALSE; 2181 } 2182 2183 fd = g_io_channel_unix_get_fd(chan); 2184 2185 len = read(fd, buf, sizeof(buf)); 2186 if (len < 0) { 2187 if (errno == EAGAIN) 2188 return TRUE; 2189 stop_hci_dev(index); 2190 return FALSE; 2191 } 2192 2193 type = *ptr++; 2194 2195 if (type != HCI_EVENT_PKT) 2196 return TRUE; 2197 2198 eh = (hci_event_hdr *) ptr; 2199 ptr += HCI_EVENT_HDR_SIZE; 2200 2201 memset(&di, 0, sizeof(di)); 2202 if (hci_devinfo(index, &di) == 0) { 2203 bacpy(&dev->bdaddr, &di.bdaddr); 2204 2205 if (ignore_device(&di)) 2206 return TRUE; 2207 } 2208 2209 switch (eh->evt) { 2210 case EVT_CMD_STATUS: 2211 cmd_status(index, ptr); 2212 break; 2213 2214 case EVT_CMD_COMPLETE: 2215 cmd_complete(index, ptr); 2216 break; 2217 2218 case EVT_REMOTE_NAME_REQ_COMPLETE: 2219 remote_name_information(index, ptr); 2220 break; 2221 2222 case EVT_READ_REMOTE_VERSION_COMPLETE: 2223 remote_version_information(index, ptr); 2224 break; 2225 2226 case EVT_READ_REMOTE_FEATURES_COMPLETE: 2227 remote_features_information(index, ptr); 2228 break; 2229 2230 case EVT_REMOTE_HOST_FEATURES_NOTIFY: 2231 remote_features_notify(index, ptr); 2232 break; 2233 2234 case EVT_INQUIRY_COMPLETE: 2235 evt = (evt_cmd_status *) ptr; 2236 inquiry_complete(&dev->bdaddr, evt->status, FALSE); 2237 break; 2238 2239 case EVT_INQUIRY_RESULT: 2240 inquiry_result(index, eh->plen, ptr); 2241 break; 2242 2243 case EVT_INQUIRY_RESULT_WITH_RSSI: 2244 inquiry_result_with_rssi(index, eh->plen, ptr); 2245 break; 2246 2247 case EVT_EXTENDED_INQUIRY_RESULT: 2248 extended_inquiry_result(index, eh->plen, ptr); 2249 break; 2250 2251 case EVT_CONN_COMPLETE: 2252 conn_complete(index, ptr); 2253 break; 2254 2255 case EVT_DISCONN_COMPLETE: 2256 disconn_complete(index, ptr); 2257 break; 2258 2259 case EVT_AUTH_COMPLETE: 2260 auth_complete(index, ptr); 2261 break; 2262 2263 case EVT_SIMPLE_PAIRING_COMPLETE: 2264 simple_pairing_complete(index, ptr); 2265 break; 2266 2267 case EVT_CONN_REQUEST: 2268 conn_request(index, ptr); 2269 break; 2270 case EVT_LE_META_EVENT: 2271 le_metaevent(index, ptr); 2272 break; 2273 case EVT_PIN_CODE_REQ: 2274 pin_code_request(index, (bdaddr_t *) ptr); 2275 break; 2276 2277 case EVT_LINK_KEY_REQ: 2278 link_key_request(index, (bdaddr_t *) ptr); 2279 break; 2280 2281 case EVT_LINK_KEY_NOTIFY: 2282 link_key_notify(index, ptr); 2283 break; 2284 2285 case EVT_RETURN_LINK_KEYS: 2286 return_link_keys(index, ptr); 2287 break; 2288 2289 case EVT_IO_CAPABILITY_REQUEST: 2290 io_capa_request(index, ptr); 2291 break; 2292 2293 case EVT_IO_CAPABILITY_RESPONSE: 2294 io_capa_response(index, ptr); 2295 break; 2296 2297 case EVT_USER_CONFIRM_REQUEST: 2298 user_confirm_request(index, ptr); 2299 break; 2300 2301 case EVT_USER_PASSKEY_REQUEST: 2302 user_passkey_request(index, ptr); 2303 break; 2304 2305 case EVT_USER_PASSKEY_NOTIFY: 2306 user_passkey_notify(index, ptr); 2307 break; 2308 2309 case EVT_REMOTE_OOB_DATA_REQUEST: 2310 remote_oob_data_request(index, ptr); 2311 break; 2312 } 2313 2314 return TRUE; 2315} 2316 2317static void start_hci_dev(int index) 2318{ 2319 struct dev_info *dev = &devs[index]; 2320 GIOChannel *chan = dev->io; 2321 GIOCondition cond; 2322 struct hci_filter flt; 2323 2324 if (chan) 2325 return; 2326 2327 info("Listening for HCI events on hci%d", index); 2328 2329 /* Set filter */ 2330 hci_filter_clear(&flt); 2331 hci_filter_set_ptype(HCI_EVENT_PKT, &flt); 2332 hci_filter_set_event(EVT_CMD_STATUS, &flt); 2333 hci_filter_set_event(EVT_CMD_COMPLETE, &flt); 2334 hci_filter_set_event(EVT_PIN_CODE_REQ, &flt); 2335 hci_filter_set_event(EVT_LINK_KEY_REQ, &flt); 2336 hci_filter_set_event(EVT_LINK_KEY_NOTIFY, &flt); 2337 hci_filter_set_event(EVT_RETURN_LINK_KEYS, &flt); 2338 hci_filter_set_event(EVT_IO_CAPABILITY_REQUEST, &flt); 2339 hci_filter_set_event(EVT_IO_CAPABILITY_RESPONSE, &flt); 2340 hci_filter_set_event(EVT_USER_CONFIRM_REQUEST, &flt); 2341 hci_filter_set_event(EVT_USER_PASSKEY_REQUEST, &flt); 2342 hci_filter_set_event(EVT_REMOTE_OOB_DATA_REQUEST, &flt); 2343 hci_filter_set_event(EVT_USER_PASSKEY_NOTIFY, &flt); 2344 hci_filter_set_event(EVT_KEYPRESS_NOTIFY, &flt); 2345 hci_filter_set_event(EVT_SIMPLE_PAIRING_COMPLETE, &flt); 2346 hci_filter_set_event(EVT_AUTH_COMPLETE, &flt); 2347 hci_filter_set_event(EVT_REMOTE_NAME_REQ_COMPLETE, &flt); 2348 hci_filter_set_event(EVT_READ_REMOTE_VERSION_COMPLETE, &flt); 2349 hci_filter_set_event(EVT_READ_REMOTE_FEATURES_COMPLETE, &flt); 2350 hci_filter_set_event(EVT_REMOTE_HOST_FEATURES_NOTIFY, &flt); 2351 hci_filter_set_event(EVT_INQUIRY_COMPLETE, &flt); 2352 hci_filter_set_event(EVT_INQUIRY_RESULT, &flt); 2353 hci_filter_set_event(EVT_INQUIRY_RESULT_WITH_RSSI, &flt); 2354 hci_filter_set_event(EVT_EXTENDED_INQUIRY_RESULT, &flt); 2355 hci_filter_set_event(EVT_CONN_REQUEST, &flt); 2356 hci_filter_set_event(EVT_CONN_COMPLETE, &flt); 2357 hci_filter_set_event(EVT_DISCONN_COMPLETE, &flt); 2358 hci_filter_set_event(EVT_LE_META_EVENT, &flt); 2359 if (setsockopt(dev->sk, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) { 2360 error("Can't set filter on hci%d: %s (%d)", 2361 index, strerror(errno), errno); 2362 return; 2363 } 2364 2365 chan = g_io_channel_unix_new(dev->sk); 2366 cond = G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR; 2367 dev->watch_id = g_io_add_watch_full(chan, G_PRIORITY_LOW, cond, 2368 io_security_event, 2369 GINT_TO_POINTER(index), NULL); 2370 dev->io = chan; 2371 dev->pin_length = 0; 2372 2373} 2374 2375/* End of HCI event callbacks */ 2376 2377static gboolean child_exit(GIOChannel *io, GIOCondition cond, void *user_data) 2378{ 2379 int status, fd = g_io_channel_unix_get_fd(io); 2380 pid_t child_pid; 2381 2382 if (read(fd, &child_pid, sizeof(child_pid)) != sizeof(child_pid)) { 2383 error("child_exit: unable to read child pid from pipe"); 2384 return TRUE; 2385 } 2386 2387 if (waitpid(child_pid, &status, 0) != child_pid) 2388 error("waitpid(%d) failed", child_pid); 2389 else 2390 DBG("child %d exited", child_pid); 2391 2392 return TRUE; 2393} 2394 2395static void at_child_exit(void) 2396{ 2397 pid_t pid = getpid(); 2398 2399 if (write(child_pipe[1], &pid, sizeof(pid)) != sizeof(pid)) 2400 error("unable to write to child pipe"); 2401} 2402 2403static void device_devup_setup(int index) 2404{ 2405 struct dev_info *dev = &devs[index]; 2406 struct hci_dev_info di; 2407 read_stored_link_key_cp cp; 2408 2409 DBG("hci%d", index); 2410 2411 if (hci_devinfo(index, &di) < 0) 2412 return; 2413 2414 if (ignore_device(&di)) 2415 return; 2416 2417 bacpy(&dev->bdaddr, &di.bdaddr); 2418 memcpy(dev->features, di.features, 8); 2419 2420 /* Set page timeout */ 2421 if ((main_opts.flags & (1 << HCID_SET_PAGETO))) { 2422 write_page_timeout_cp cp; 2423 2424 cp.timeout = htobs(main_opts.pageto); 2425 hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_PAGE_TIMEOUT, 2426 WRITE_PAGE_TIMEOUT_CP_SIZE, &cp); 2427 } 2428 2429 bacpy(&cp.bdaddr, BDADDR_ANY); 2430 cp.read_all = 1; 2431 hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY, 2432 READ_STORED_LINK_KEY_CP_SIZE, &cp); 2433 2434 if (!dev->pending) 2435 init_adapter(index); 2436} 2437 2438static void init_pending(int index) 2439{ 2440 struct dev_info *dev = &devs[index]; 2441 2442 hci_set_bit(PENDING_BDADDR, &dev->pending); 2443 hci_set_bit(PENDING_VERSION, &dev->pending); 2444 hci_set_bit(PENDING_FEATURES, &dev->pending); 2445 hci_set_bit(PENDING_NAME, &dev->pending); 2446} 2447 2448static void init_device(int index) 2449{ 2450 struct hci_dev_req dr; 2451 int dd; 2452 pid_t pid; 2453 2454 DBG("hci%d", index); 2455 2456 dd = hci_open_dev(index); 2457 if (dd < 0) { 2458 error("Unable to open hci%d: %s (%d)", index, 2459 strerror(errno), errno); 2460 return; 2461 } 2462 2463 if (index > max_dev) { 2464 max_dev = index; 2465 devs = g_realloc(devs, sizeof(devs[0]) * (max_dev + 1)); 2466 } 2467 2468 init_dev_info(index, dd, FALSE); 2469 init_pending(index); 2470 start_hci_dev(index); 2471 2472 /* Do initialization in the separate process */ 2473 pid = fork(); 2474 switch (pid) { 2475 case 0: 2476 atexit(at_child_exit); 2477 break; 2478 case -1: 2479 error("Fork failed. Can't init device hci%d: %s (%d)", 2480 index, strerror(errno), errno); 2481 default: 2482 DBG("child %d forked", pid); 2483 return; 2484 } 2485 2486 memset(&dr, 0, sizeof(dr)); 2487 dr.dev_id = index; 2488 2489 /* Set link mode */ 2490 dr.dev_opt = main_opts.link_mode; 2491 if (ioctl(dd, HCISETLINKMODE, (unsigned long) &dr) < 0) 2492 error("Can't set link mode on hci%d: %s (%d)", 2493 index, strerror(errno), errno); 2494 2495 /* Start HCI device */ 2496 if (ioctl(dd, HCIDEVUP, index) < 0 && errno != EALREADY) { 2497 error("Can't init device hci%d: %s (%d)", 2498 index, strerror(errno), errno); 2499 goto fail; 2500 } 2501 2502 hci_close_dev(dd); 2503 exit(0); 2504 2505fail: 2506 hci_close_dev(dd); 2507 exit(1); 2508} 2509 2510static void init_conn_list(int index) 2511{ 2512 struct dev_info *dev = &devs[index]; 2513 struct hci_conn_list_req *cl; 2514 struct hci_conn_info *ci; 2515 int err, i; 2516 2517 DBG("hci%d", index); 2518 2519 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); 2520 2521 cl->dev_id = index; 2522 cl->conn_num = 10; 2523 ci = cl->conn_info; 2524 2525 if (ioctl(dev->sk, HCIGETCONNLIST, cl) < 0) { 2526 error("Unable to get connection list: %s (%d)", 2527 strerror(errno), errno); 2528 goto failed; 2529 } 2530 2531 for (i = 0; i < cl->conn_num; i++, ci++) { 2532 struct bt_conn *conn; 2533 2534 if (ci->type != ACL_LINK) 2535 continue; 2536 2537 conn = get_connection(dev, &ci->bdaddr); 2538 conn->handle = ci->handle; 2539 } 2540 2541 err = 0; 2542 2543failed: 2544 g_free(cl); 2545} 2546 2547static void device_event(int event, int index) 2548{ 2549 switch (event) { 2550 case HCI_DEV_REG: 2551 info("HCI dev %d registered", index); 2552 init_device(index); 2553 break; 2554 2555 case HCI_DEV_UNREG: 2556 info("HCI dev %d unregistered", index); 2557 stop_hci_dev(index); 2558 if (devs[index].registered) 2559 btd_manager_unregister_adapter(index); 2560 break; 2561 2562 case HCI_DEV_UP: 2563 info("HCI dev %d up", index); 2564 devs[index].up = TRUE; 2565 device_devup_setup(index); 2566 break; 2567 2568 case HCI_DEV_DOWN: 2569 info("HCI dev %d down", index); 2570 devs[index].up = FALSE; 2571 devs[index].pending_cod = 0; 2572 devs[index].cache_enable = TRUE; 2573 if (!devs[index].pending) { 2574 struct btd_adapter *adapter; 2575 2576 adapter = manager_find_adapter_by_id(index); 2577 if (adapter) 2578 btd_adapter_stop(adapter); 2579 2580 init_pending(index); 2581 } 2582 break; 2583 } 2584} 2585 2586static int hciops_stop_inquiry(int index) 2587{ 2588 struct dev_info *dev = &devs[index]; 2589 struct hci_dev_info di; 2590 int err; 2591 2592 DBG("hci%d", index); 2593 2594 if (hci_devinfo(index, &di) < 0) 2595 return -errno; 2596 2597 if (hci_test_bit(HCI_INQUIRY, &di.flags)) 2598 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 2599 OCF_INQUIRY_CANCEL, 0, 0); 2600 else 2601 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 2602 OCF_EXIT_PERIODIC_INQUIRY, 0, 0); 2603 if (err < 0) 2604 err = -errno; 2605 2606 return err; 2607} 2608 2609static gboolean init_known_adapters(gpointer user_data) 2610{ 2611 struct hci_dev_list_req *dl; 2612 struct hci_dev_req *dr; 2613 int i, err, ctl = GPOINTER_TO_INT(user_data); 2614 size_t req_size; 2615 2616 DBG(""); 2617 2618 req_size = HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t); 2619 2620 dl = g_try_malloc0(req_size); 2621 if (!dl) { 2622 error("Can't allocate devlist buffer"); 2623 return FALSE; 2624 } 2625 2626 dl->dev_num = HCI_MAX_DEV; 2627 dr = dl->dev_req; 2628 2629 if (ioctl(ctl, HCIGETDEVLIST, dl) < 0) { 2630 err = -errno; 2631 error("Can't get device list: %s (%d)", strerror(-err), -err); 2632 g_free(dl); 2633 return FALSE; 2634 } 2635 2636 for (i = 0; i < dl->dev_num; i++, dr++) { 2637 struct dev_info *dev; 2638 2639 device_event(HCI_DEV_REG, dr->dev_id); 2640 2641 dev = &devs[dr->dev_id]; 2642 2643 dev->already_up = hci_test_bit(HCI_UP, &dr->dev_opt); 2644 2645 if (!dev->already_up) 2646 continue; 2647 2648 init_conn_list(dr->dev_id); 2649 hciops_stop_inquiry(dr->dev_id); 2650 2651 dev->pending = 0; 2652 hci_set_bit(PENDING_VERSION, &dev->pending); 2653 hci_send_cmd(dev->sk, OGF_INFO_PARAM, 2654 OCF_READ_LOCAL_VERSION, 0, NULL); 2655 device_event(HCI_DEV_UP, dr->dev_id); 2656 } 2657 2658 g_free(dl); 2659 2660 return FALSE; 2661} 2662 2663static gboolean io_stack_event(GIOChannel *chan, GIOCondition cond, 2664 gpointer data) 2665{ 2666 unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr; 2667 evt_stack_internal *si; 2668 evt_si_device *sd; 2669 hci_event_hdr *eh; 2670 int type, fd; 2671 ssize_t len; 2672 2673 ptr = buf; 2674 2675 fd = g_io_channel_unix_get_fd(chan); 2676 2677 len = read(fd, buf, sizeof(buf)); 2678 if (len < 0) { 2679 if (errno == EAGAIN) 2680 return TRUE; 2681 2682 error("Read from control socket failed: %s (%d)", 2683 strerror(errno), errno); 2684 return FALSE; 2685 } 2686 2687 type = *ptr++; 2688 2689 if (type != HCI_EVENT_PKT) 2690 return TRUE; 2691 2692 eh = (hci_event_hdr *) ptr; 2693 if (eh->evt != EVT_STACK_INTERNAL) 2694 return TRUE; 2695 2696 ptr += HCI_EVENT_HDR_SIZE; 2697 2698 si = (evt_stack_internal *) ptr; 2699 switch (si->type) { 2700 case EVT_SI_DEVICE: 2701 sd = (void *) &si->data; 2702 device_event(sd->event, sd->dev_id); 2703 break; 2704 } 2705 2706 return TRUE; 2707} 2708 2709static int hciops_setup(void) 2710{ 2711 struct sockaddr_hci addr; 2712 struct hci_filter flt; 2713 GIOChannel *ctl_io, *child_io; 2714 int sock, err; 2715 2716 DBG(""); 2717 2718 if (child_pipe[0] != -1) 2719 return -EALREADY; 2720 2721 if (pipe(child_pipe) < 0) { 2722 err = -errno; 2723 error("pipe(): %s (%d)", strerror(-err), -err); 2724 return err; 2725 } 2726 2727 child_io = g_io_channel_unix_new(child_pipe[0]); 2728 g_io_channel_set_close_on_unref(child_io, TRUE); 2729 child_io_id = g_io_add_watch(child_io, 2730 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, 2731 child_exit, NULL); 2732 g_io_channel_unref(child_io); 2733 2734 /* Create and bind HCI socket */ 2735 sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 2736 if (sock < 0) { 2737 err = -errno; 2738 error("Can't open HCI socket: %s (%d)", strerror(-err), 2739 -err); 2740 return err; 2741 } 2742 2743 /* Set filter */ 2744 hci_filter_clear(&flt); 2745 hci_filter_set_ptype(HCI_EVENT_PKT, &flt); 2746 hci_filter_set_event(EVT_STACK_INTERNAL, &flt); 2747 if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) { 2748 err = -errno; 2749 error("Can't set filter: %s (%d)", strerror(-err), -err); 2750 return err; 2751 } 2752 2753 memset(&addr, 0, sizeof(addr)); 2754 addr.hci_family = AF_BLUETOOTH; 2755 addr.hci_dev = HCI_DEV_NONE; 2756 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 2757 err = -errno; 2758 error("Can't bind HCI socket: %s (%d)", strerror(-err), -err); 2759 return err; 2760 } 2761 2762 ctl_io = g_io_channel_unix_new(sock); 2763 g_io_channel_set_close_on_unref(ctl_io, TRUE); 2764 2765 ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL); 2766 2767 g_io_channel_unref(ctl_io); 2768 2769 g_idle_add(init_known_adapters, GINT_TO_POINTER(sock)); 2770 2771 return 0; 2772} 2773 2774static void hciops_cleanup(void) 2775{ 2776 int i; 2777 2778 DBG(""); 2779 2780 for (i = 0; i <= max_dev; i++) 2781 stop_hci_dev(i); 2782 2783 g_free(devs); 2784 devs = NULL; 2785 max_dev = -1; 2786 2787 if (child_io_id) { 2788 g_source_remove(child_io_id); 2789 child_io_id = 0; 2790 } 2791 2792 if (ctl_io_id) { 2793 g_source_remove(ctl_io_id); 2794 ctl_io_id = 0; 2795 } 2796 2797 if (child_pipe[0] >= 0) { 2798 close(child_pipe[0]); 2799 child_pipe[0] = -1; 2800 } 2801 2802 if (child_pipe[1] >= 0) { 2803 close(child_pipe[1]); 2804 child_pipe[1] = -1; 2805 } 2806} 2807 2808static int hciops_set_powered(int index, gboolean powered) 2809{ 2810 struct dev_info *dev = &devs[index]; 2811 int err; 2812 2813 DBG("hci%d powered %d", index, powered); 2814 2815 if (powered == FALSE) 2816 return hciops_power_off(index); 2817 2818 if (ioctl(dev->sk, HCIDEVUP, index) == 0) 2819 return 0; 2820 2821 if (errno == EALREADY) 2822 return 0; 2823 2824 err = -errno; 2825 error("Can't init device hci%d: %s (%d)", 2826 index, strerror(-err), -err); 2827 2828 return err; 2829} 2830 2831static int hciops_set_dev_class(int index, uint8_t major, uint8_t minor) 2832{ 2833 struct dev_info *dev = &devs[index]; 2834 int err; 2835 2836 DBG("hci%d major %u minor %u", index, major, minor); 2837 2838 /* Update only the major and minor class bits keeping remaining bits 2839 * intact*/ 2840 dev->wanted_cod &= 0xffe000; 2841 dev->wanted_cod |= ((major & 0x1f) << 8) | minor; 2842 2843 if (dev->wanted_cod == dev->current_cod || 2844 dev->cache_enable || dev->pending_cod) 2845 return 0; 2846 2847 DBG("Changing Major/Minor class to 0x%06x", dev->wanted_cod); 2848 2849 err = write_class(index, dev->wanted_cod); 2850 if (err < 0) 2851 error("Adapter class update failed: %s (%d)", 2852 strerror(-err), -err); 2853 2854 return err; 2855} 2856 2857static int hciops_start_inquiry(int index, uint8_t length, gboolean periodic) 2858{ 2859 struct dev_info *dev = &devs[index]; 2860 uint8_t lap[3] = { 0x33, 0x8b, 0x9e }; 2861 int err; 2862 2863 DBG("hci%d length %u periodic %d", index, length, periodic); 2864 2865 if (periodic) { 2866 periodic_inquiry_cp cp; 2867 2868 memset(&cp, 0, sizeof(cp)); 2869 memcpy(&cp.lap, lap, 3); 2870 cp.max_period = htobs(24); 2871 cp.min_period = htobs(16); 2872 cp.length = length; 2873 cp.num_rsp = 0x00; 2874 2875 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 2876 OCF_PERIODIC_INQUIRY, 2877 PERIODIC_INQUIRY_CP_SIZE, &cp); 2878 } else { 2879 inquiry_cp inq_cp; 2880 2881 memset(&inq_cp, 0, sizeof(inq_cp)); 2882 memcpy(&inq_cp.lap, lap, 3); 2883 inq_cp.length = length; 2884 inq_cp.num_rsp = 0x00; 2885 2886 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 2887 OCF_INQUIRY, INQUIRY_CP_SIZE, &inq_cp); 2888 } 2889 2890 if (err < 0) 2891 err = -errno; 2892 2893 return err; 2894} 2895 2896static int le_set_scan_enable(int index, uint8_t enable) 2897{ 2898 struct dev_info *dev = &devs[index]; 2899 le_set_scan_enable_cp cp; 2900 2901 DBG("hci%d enable %u", index, enable); 2902 2903 memset(&cp, 0, sizeof(cp)); 2904 cp.enable = enable; 2905 cp.filter_dup = 0; 2906 2907 if (hci_send_cmd(dev->sk, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, 2908 LE_SET_SCAN_ENABLE_CP_SIZE, &cp) < 0) 2909 return -errno; 2910 2911 return 0; 2912} 2913 2914static int hciops_start_scanning(int index) 2915{ 2916 struct dev_info *dev = &devs[index]; 2917 le_set_scan_parameters_cp cp; 2918 2919 DBG("hci%d", index); 2920 2921 memset(&cp, 0, sizeof(cp)); 2922 cp.type = 0x01; /* Active scanning */ 2923 /* The recommended value for scan interval and window is 11.25 msec. 2924 * It is calculated by: time = n * 0.625 msec */ 2925 cp.interval = htobs(0x0012); 2926 cp.window = htobs(0x0012); 2927 cp.own_bdaddr_type = 0; /* Public address */ 2928 cp.filter = 0; /* Accept all adv packets */ 2929 2930 if (hci_send_cmd(dev->sk, OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS, 2931 LE_SET_SCAN_PARAMETERS_CP_SIZE, &cp) < 0) 2932 return -errno; 2933 2934 return le_set_scan_enable(index, 1); 2935} 2936 2937static int hciops_stop_scanning(int index) 2938{ 2939 DBG("hci%d", index); 2940 2941 return le_set_scan_enable(index, 0); 2942} 2943 2944static int hciops_resolve_name(int index, bdaddr_t *bdaddr) 2945{ 2946 struct dev_info *dev = &devs[index]; 2947 remote_name_req_cp cp; 2948 char addr[18]; 2949 2950 ba2str(bdaddr, addr); 2951 DBG("hci%d dba %s", index, addr); 2952 2953 memset(&cp, 0, sizeof(cp)); 2954 bacpy(&cp.bdaddr, bdaddr); 2955 cp.pscan_rep_mode = 0x02; 2956 2957 if (hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ, 2958 REMOTE_NAME_REQ_CP_SIZE, &cp) < 0) 2959 return -errno; 2960 2961 return 0; 2962} 2963 2964static int hciops_set_name(int index, const char *name) 2965{ 2966 struct dev_info *dev = &devs[index]; 2967 change_local_name_cp cp; 2968 2969 DBG("hci%d, name %s", index, name); 2970 2971 memset(&cp, 0, sizeof(cp)); 2972 strncpy((char *) cp.name, name, sizeof(cp.name)); 2973 2974 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME, 2975 CHANGE_LOCAL_NAME_CP_SIZE, &cp) < 0) 2976 return -errno; 2977 2978 memcpy(dev->name, cp.name, 248); 2979 update_ext_inquiry_response(index); 2980 2981 return 0; 2982} 2983 2984static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr) 2985{ 2986 struct dev_info *dev = &devs[index]; 2987 remote_name_req_cancel_cp cp; 2988 char addr[18]; 2989 2990 ba2str(bdaddr, addr); 2991 DBG("hci%d dba %s", index, addr); 2992 2993 memset(&cp, 0, sizeof(cp)); 2994 bacpy(&cp.bdaddr, bdaddr); 2995 2996 if (hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL, 2997 REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp) < 0) 2998 return -errno; 2999 3000 return 0; 3001} 3002 3003static int hciops_fast_connectable(int index, gboolean enable) 3004{ 3005 struct dev_info *dev = &devs[index]; 3006 write_page_activity_cp cp; 3007 uint8_t type; 3008 3009 DBG("hci%d enable %d", index, enable); 3010 3011 if (enable) { 3012 type = PAGE_SCAN_TYPE_INTERLACED; 3013 cp.interval = 0x0024; /* 22.5 msec page scan interval */ 3014 } else { 3015 type = PAGE_SCAN_TYPE_STANDARD; /* default */ 3016 cp.interval = 0x0800; /* default 1.28 sec page scan */ 3017 } 3018 3019 cp.window = 0x0012; /* default 11.25 msec page scan window */ 3020 3021 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_WRITE_PAGE_ACTIVITY, 3022 WRITE_PAGE_ACTIVITY_CP_SIZE, &cp) < 0) 3023 return -errno; 3024 else if (hci_send_cmd(dev->sk, OGF_HOST_CTL, 3025 OCF_WRITE_PAGE_SCAN_TYPE, 1, &type) < 0) 3026 return -errno; 3027 3028 return 0; 3029} 3030 3031static int hciops_read_clock(int index, bdaddr_t *bdaddr, int which, 3032 int timeout, uint32_t *clock, 3033 uint16_t *accuracy) 3034{ 3035 struct dev_info *dev = &devs[index]; 3036 uint16_t handle = 0; 3037 char addr[18]; 3038 int ret; 3039 3040 ba2str(bdaddr, addr); 3041 DBG("hci%d addr %s which %d timeout %d", index, addr, which, timeout); 3042 3043 ret = get_handle(index, bdaddr, &handle); 3044 if (ret < 0) 3045 return ret; 3046 3047 if (hci_read_clock(dev->sk, htobs(handle), which, clock, accuracy, 3048 timeout) < 0) 3049 return -errno; 3050 3051 return 0; 3052} 3053 3054static int hciops_read_bdaddr(int index, bdaddr_t *bdaddr) 3055{ 3056 struct dev_info *dev = &devs[index]; 3057 3058 DBG("hci%d", index); 3059 3060 bacpy(bdaddr, &dev->bdaddr); 3061 3062 return 0; 3063} 3064 3065static int hciops_block_device(int index, bdaddr_t *bdaddr) 3066{ 3067 struct dev_info *dev = &devs[index]; 3068 char addr[18]; 3069 3070 ba2str(bdaddr, addr); 3071 DBG("hci%d dba %s", index, addr); 3072 3073 if (ioctl(dev->sk, HCIBLOCKADDR, bdaddr) < 0) 3074 return -errno; 3075 3076 return 0; 3077} 3078 3079static int hciops_unblock_device(int index, bdaddr_t *bdaddr) 3080{ 3081 struct dev_info *dev = &devs[index]; 3082 char addr[18]; 3083 3084 ba2str(bdaddr, addr); 3085 DBG("hci%d dba %s", index, addr); 3086 3087 if (ioctl(dev->sk, HCIUNBLOCKADDR, bdaddr) < 0) 3088 return -errno; 3089 3090 return 0; 3091} 3092 3093static int hciops_get_conn_list(int index, GSList **conns) 3094{ 3095 struct dev_info *dev = &devs[index]; 3096 GSList *l; 3097 3098 DBG("hci%d", index); 3099 3100 *conns = NULL; 3101 3102 for (l = dev->connections; l != NULL; l = g_slist_next(l)) { 3103 struct bt_conn *conn = l->data; 3104 3105 *conns = g_slist_append(*conns, 3106 g_memdup(&conn->bdaddr, sizeof(bdaddr_t))); 3107 } 3108 3109 return 0; 3110} 3111 3112static int hciops_read_local_version(int index, struct hci_version *ver) 3113{ 3114 struct dev_info *dev = &devs[index]; 3115 3116 DBG("hci%d", index); 3117 3118 memcpy(ver, &dev->ver, sizeof(*ver)); 3119 3120 return 0; 3121} 3122 3123static int hciops_read_local_features(int index, uint8_t *features) 3124{ 3125 struct dev_info *dev = &devs[index]; 3126 3127 DBG("hci%d", index); 3128 3129 memcpy(features, dev->features, 8); 3130 3131 return 0; 3132} 3133 3134static int hciops_disconnect(int index, bdaddr_t *bdaddr) 3135{ 3136 DBG("hci%d", index); 3137 3138 return disconnect_addr(index, bdaddr, HCI_OE_USER_ENDED_CONNECTION); 3139} 3140 3141static int hciops_remove_bonding(int index, bdaddr_t *bdaddr) 3142{ 3143 struct dev_info *dev = &devs[index]; 3144 delete_stored_link_key_cp cp; 3145 GSList *match; 3146 char addr[18]; 3147 3148 ba2str(bdaddr, addr); 3149 DBG("hci%d dba %s", index, addr); 3150 3151 match = g_slist_find_custom(dev->keys, bdaddr, (GCompareFunc) bacmp); 3152 if (match) { 3153 g_free(match->data); 3154 dev->keys = g_slist_delete_link(dev->keys, match); 3155 } 3156 3157 memset(&cp, 0, sizeof(cp)); 3158 bacpy(&cp.bdaddr, bdaddr); 3159 3160 /* Delete the link key from the Bluetooth chip */ 3161 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_DELETE_STORED_LINK_KEY, 3162 DELETE_STORED_LINK_KEY_CP_SIZE, &cp) < 0) 3163 return -errno; 3164 3165 return 0; 3166} 3167 3168static int hciops_request_authentication(int index, bdaddr_t *bdaddr) 3169{ 3170 struct dev_info *dev = &devs[index]; 3171 auth_requested_cp cp; 3172 uint16_t handle; 3173 int err; 3174 3175 DBG("hci%d", index); 3176 3177 err = get_handle(index, bdaddr, &handle); 3178 if (err < 0) 3179 return err; 3180 3181 memset(&cp, 0, sizeof(cp)); 3182 cp.handle = htobs(handle); 3183 3184 if (hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_AUTH_REQUESTED, 3185 AUTH_REQUESTED_CP_SIZE, &cp) < 0) 3186 return -errno; 3187 3188 return 0; 3189} 3190 3191static int hciops_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin) 3192{ 3193 struct dev_info *dev = &devs[index]; 3194 char addr[18]; 3195 int err; 3196 3197 ba2str(bdaddr, addr); 3198 DBG("hci%d dba %s", index, addr); 3199 3200 if (pin) { 3201 pin_code_reply_cp pr; 3202 size_t len = strlen(pin); 3203 3204 dev->pin_length = len; 3205 3206 memset(&pr, 0, sizeof(pr)); 3207 bacpy(&pr.bdaddr, bdaddr); 3208 memcpy(pr.pin_code, pin, len); 3209 pr.pin_len = len; 3210 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3211 OCF_PIN_CODE_REPLY, 3212 PIN_CODE_REPLY_CP_SIZE, &pr); 3213 } else 3214 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3215 OCF_PIN_CODE_NEG_REPLY, 6, bdaddr); 3216 3217 if (err < 0) 3218 err = -errno; 3219 3220 return err; 3221} 3222 3223static int hciops_confirm_reply(int index, bdaddr_t *bdaddr, gboolean success) 3224{ 3225 struct dev_info *dev = &devs[index]; 3226 user_confirm_reply_cp cp; 3227 char addr[18]; 3228 int err; 3229 3230 ba2str(bdaddr, addr); 3231 DBG("hci%d dba %s success %d", index, addr, success); 3232 3233 memset(&cp, 0, sizeof(cp)); 3234 bacpy(&cp.bdaddr, bdaddr); 3235 3236 if (success) 3237 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3238 OCF_USER_CONFIRM_REPLY, 3239 USER_CONFIRM_REPLY_CP_SIZE, &cp); 3240 else 3241 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3242 OCF_USER_CONFIRM_NEG_REPLY, 3243 USER_CONFIRM_REPLY_CP_SIZE, &cp); 3244 3245 if (err < 0) 3246 err = -errno; 3247 3248 return err; 3249} 3250 3251static int hciops_passkey_reply(int index, bdaddr_t *bdaddr, uint32_t passkey) 3252{ 3253 struct dev_info *dev = &devs[index]; 3254 char addr[18]; 3255 int err; 3256 3257 ba2str(bdaddr, addr); 3258 DBG("hci%d dba %s", index, addr); 3259 3260 if (passkey != INVALID_PASSKEY) { 3261 user_passkey_reply_cp cp; 3262 3263 memset(&cp, 0, sizeof(cp)); 3264 bacpy(&cp.bdaddr, bdaddr); 3265 cp.passkey = passkey; 3266 3267 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3268 OCF_USER_PASSKEY_REPLY, 3269 USER_PASSKEY_REPLY_CP_SIZE, &cp); 3270 } else 3271 err = hci_send_cmd(dev->sk, OGF_LINK_CTL, 3272 OCF_USER_PASSKEY_NEG_REPLY, 6, bdaddr); 3273 3274 if (err < 0) 3275 err = -errno; 3276 3277 return err; 3278} 3279 3280static int hciops_read_scan_enable(int index) 3281{ 3282 struct dev_info *dev = &devs[index]; 3283 3284 DBG("hci%d", index); 3285 3286 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_READ_SCAN_ENABLE, 3287 0, NULL) < 0) 3288 return -errno; 3289 3290 return 0; 3291} 3292 3293static int hciops_enable_le(int index) 3294{ 3295 struct dev_info *dev = &devs[index]; 3296 write_le_host_supported_cp cp; 3297 3298 DBG("hci%d", index); 3299 3300 if (!(dev->features[4] & LMP_LE)) 3301 return -ENOTSUP; 3302 3303 cp.le = 0x01; 3304 cp.simul = (dev->features[6] & LMP_LE_BREDR) ? 0x01 : 0x00; 3305 3306 if (hci_send_cmd(dev->sk, OGF_HOST_CTL, 3307 OCF_WRITE_LE_HOST_SUPPORTED, 3308 WRITE_LE_HOST_SUPPORTED_CP_SIZE, &cp) < 0) 3309 return -errno; 3310 3311 return 0; 3312} 3313 3314static uint8_t generate_service_class(int index) 3315{ 3316 struct dev_info *dev = &devs[index]; 3317 GSList *l; 3318 uint8_t val = 0; 3319 3320 for (l = dev->uuids; l != NULL; l = g_slist_next(l)) { 3321 struct uuid_info *uuid = l->data; 3322 3323 val |= uuid->svc_hint; 3324 } 3325 3326 return val; 3327} 3328 3329static int update_service_classes(int index) 3330{ 3331 struct dev_info *dev = &devs[index]; 3332 uint8_t value; 3333 int err; 3334 3335 value = generate_service_class(index); 3336 3337 DBG("hci%d value %u", index, value); 3338 3339 /* Update only the service class, keep the limited bit, 3340 * major/minor class bits intact */ 3341 dev->wanted_cod &= 0x00ffff; 3342 dev->wanted_cod |= (value << 16); 3343 3344 /* If the cache is enabled or an existing CoD write is in progress 3345 * just bail out */ 3346 if (dev->cache_enable || dev->pending_cod) 3347 return 0; 3348 3349 /* If we already have the CoD we want, update EIR and return */ 3350 if (dev->current_cod == dev->wanted_cod) { 3351 update_ext_inquiry_response(index); 3352 return 0; 3353 } 3354 3355 DBG("Changing service classes to 0x%06x", dev->wanted_cod); 3356 3357 err = write_class(index, dev->wanted_cod); 3358 if (err < 0) 3359 error("Adapter class update failed: %s (%d)", 3360 strerror(-err), -err); 3361 3362 return err; 3363} 3364 3365static int hciops_add_uuid(int index, uuid_t *uuid, uint8_t svc_hint) 3366{ 3367 struct dev_info *dev = &devs[index]; 3368 struct uuid_info *info; 3369 3370 DBG("hci%d", index); 3371 3372 info = g_new0(struct uuid_info, 1); 3373 memcpy(&info->uuid, uuid, sizeof(*uuid)); 3374 info->svc_hint = svc_hint; 3375 3376 dev->uuids = g_slist_append(dev->uuids, info); 3377 3378 return update_service_classes(index); 3379} 3380 3381static int hciops_remove_uuid(int index, uuid_t *uuid) 3382{ 3383 struct dev_info *dev = &devs[index]; 3384 GSList *match; 3385 3386 match = g_slist_find_custom(dev->uuids, uuid, sdp_uuid_cmp); 3387 if (match) { 3388 g_free(match->data); 3389 dev->uuids = g_slist_delete_link(dev->uuids, match); 3390 } 3391 3392 DBG("hci%d", index); 3393 3394 return update_service_classes(index); 3395} 3396 3397static int hciops_disable_cod_cache(int index) 3398{ 3399 struct dev_info *dev = &devs[index]; 3400 3401 DBG("hci%d cache_enable %d", index, dev->cache_enable); 3402 3403 if (!dev->cache_enable) 3404 return 0; 3405 3406 DBG("hci%d current_cod 0x%06x wanted_cod 0x%06x", index, 3407 dev->current_cod, dev->wanted_cod); 3408 3409 /* Disable and flush svc cache. All successive service class 3410 * updates * will be written to the device */ 3411 dev->cache_enable = FALSE; 3412 3413 if (dev->current_cod == dev->wanted_cod) { 3414 update_ext_inquiry_response(index); 3415 return 0; 3416 } 3417 3418 return write_class(index, dev->wanted_cod); 3419} 3420 3421static int hciops_restore_powered(int index) 3422{ 3423 struct dev_info *dev = &devs[index]; 3424 3425 if (!dev->already_up && dev->up) 3426 return hciops_power_off(index); 3427 3428 return 0; 3429} 3430 3431static int hciops_load_keys(int index, GSList *keys, gboolean debug_keys) 3432{ 3433 struct dev_info *dev = &devs[index]; 3434 3435 DBG("hci%d keys %d debug_keys %d", index, g_slist_length(keys), 3436 debug_keys); 3437 3438 if (dev->keys != NULL) 3439 return -EEXIST; 3440 3441 dev->keys = keys; 3442 dev->debug_keys = debug_keys; 3443 3444 return 0; 3445} 3446 3447static int hciops_set_io_capability(int index, uint8_t io_capability) 3448{ 3449 struct dev_info *dev = &devs[index]; 3450 3451 dev->io_capability = io_capability; 3452 3453 return 0; 3454} 3455 3456static void bonding_connect_cb(GIOChannel *io, GError *err, gpointer user_data) 3457{ 3458 struct bt_conn *conn = user_data; 3459 struct dev_info *dev = conn->dev; 3460 3461 if (!conn->io) { 3462 if (!err) 3463 g_io_channel_shutdown(io, TRUE, NULL); 3464 return; 3465 } 3466 3467 if (err) 3468 /* Wait proper error to be propagated by bonding complete */ 3469 return; 3470 3471 if (hciops_request_authentication(dev->id, &conn->bdaddr) < 0) 3472 goto failed; 3473 3474 return; 3475 3476failed: 3477 bonding_complete(dev, conn, HCI_UNSPECIFIED_ERROR); 3478} 3479 3480static int hciops_create_bonding(int index, bdaddr_t *bdaddr, uint8_t io_cap) 3481{ 3482 struct dev_info *dev = &devs[index]; 3483 BtIOSecLevel sec_level; 3484 struct bt_conn *conn; 3485 GError *err = NULL; 3486 3487 conn = get_connection(dev, bdaddr); 3488 3489 if (conn->io != NULL) 3490 return -EBUSY; 3491 3492 conn->loc_cap = io_cap; 3493 3494 /* If our IO capability is NoInputNoOutput use medium security 3495 * level (i.e. don't require MITM protection) else use high 3496 * security level */ 3497 if (io_cap == 0x03) 3498 sec_level = BT_IO_SEC_MEDIUM; 3499 else 3500 sec_level = BT_IO_SEC_HIGH; 3501 3502 conn->io = bt_io_connect(BT_IO_L2RAW, bonding_connect_cb, conn, 3503 NULL, &err, 3504 BT_IO_OPT_SOURCE_BDADDR, &dev->bdaddr, 3505 BT_IO_OPT_DEST_BDADDR, bdaddr, 3506 BT_IO_OPT_SEC_LEVEL, sec_level, 3507 BT_IO_OPT_INVALID); 3508 if (conn->io == NULL) { 3509 error("bt_io_connect: %s", err->message); 3510 g_error_free(err); 3511 return -EIO; 3512 } 3513 3514 conn->bonding_initiator = TRUE; 3515 3516 return 0; 3517} 3518 3519static int hciops_cancel_bonding(int index, bdaddr_t *bdaddr) 3520{ 3521 struct dev_info *dev = &devs[index]; 3522 struct bt_conn *conn; 3523 3524 conn = find_connection(dev, bdaddr); 3525 if (conn == NULL || conn->io == NULL) 3526 return -ENOTCONN; 3527 3528 g_io_channel_shutdown(conn->io, TRUE, NULL); 3529 g_io_channel_unref(conn->io); 3530 conn->io = NULL; 3531 3532 return 0; 3533} 3534 3535static struct btd_adapter_ops hci_ops = { 3536 .setup = hciops_setup, 3537 .cleanup = hciops_cleanup, 3538 .set_powered = hciops_set_powered, 3539 .set_discoverable = hciops_set_discoverable, 3540 .set_pairable = hciops_set_pairable, 3541 .set_limited_discoverable = hciops_set_limited_discoverable, 3542 .start_inquiry = hciops_start_inquiry, 3543 .stop_inquiry = hciops_stop_inquiry, 3544 .start_scanning = hciops_start_scanning, 3545 .stop_scanning = hciops_stop_scanning, 3546 .resolve_name = hciops_resolve_name, 3547 .cancel_resolve_name = hciops_cancel_resolve_name, 3548 .set_name = hciops_set_name, 3549 .set_dev_class = hciops_set_dev_class, 3550 .set_fast_connectable = hciops_fast_connectable, 3551 .read_clock = hciops_read_clock, 3552 .read_bdaddr = hciops_read_bdaddr, 3553 .block_device = hciops_block_device, 3554 .unblock_device = hciops_unblock_device, 3555 .get_conn_list = hciops_get_conn_list, 3556 .read_local_version = hciops_read_local_version, 3557 .read_local_features = hciops_read_local_features, 3558 .disconnect = hciops_disconnect, 3559 .remove_bonding = hciops_remove_bonding, 3560 .request_authentication = hciops_request_authentication, 3561 .pincode_reply = hciops_pincode_reply, 3562 .confirm_reply = hciops_confirm_reply, 3563 .passkey_reply = hciops_passkey_reply, 3564 .read_scan_enable = hciops_read_scan_enable, 3565 .enable_le = hciops_enable_le, 3566 .encrypt_link = hciops_encrypt_link, 3567 .set_did = hciops_set_did, 3568 .add_uuid = hciops_add_uuid, 3569 .remove_uuid = hciops_remove_uuid, 3570 .disable_cod_cache = hciops_disable_cod_cache, 3571 .restore_powered = hciops_restore_powered, 3572 .load_keys = hciops_load_keys, 3573 .set_io_capability = hciops_set_io_capability, 3574 .create_bonding = hciops_create_bonding, 3575 .cancel_bonding = hciops_cancel_bonding, 3576}; 3577 3578static int hciops_init(void) 3579{ 3580 DBG(""); 3581 return btd_register_adapter_ops(&hci_ops, FALSE); 3582} 3583 3584static void hciops_exit(void) 3585{ 3586 DBG(""); 3587 btd_adapter_cleanup_ops(&hci_ops); 3588} 3589 3590BLUETOOTH_PLUGIN_DEFINE(hciops, VERSION, 3591 BLUETOOTH_PLUGIN_PRIORITY_LOW, hciops_init, hciops_exit) 3592