hciops.c revision 28c405b17a3131494c11599705885ae630c52ee2
1/* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 20 * 21 */ 22 23#ifdef HAVE_CONFIG_H 24#include <config.h> 25#endif 26 27#include <stdio.h> 28#include <errno.h> 29#include <unistd.h> 30#include <stdlib.h> 31#include <sys/types.h> 32#include <sys/ioctl.h> 33#include <sys/wait.h> 34 35#include <bluetooth/bluetooth.h> 36#include <bluetooth/hci.h> 37#include <bluetooth/hci_lib.h> 38 39#include <glib.h> 40 41#include "hcid.h" 42#include "sdpd.h" 43#include "adapter.h" 44#include "plugin.h" 45#include "log.h" 46#include "storage.h" 47#include "event.h" 48#include "device.h" 49#include "manager.h" 50 51#define HCI_REQ_TIMEOUT 5000 52 53static int child_pipe[2] = { -1, -1 }; 54 55static guint child_io_id = 0; 56static guint ctl_io_id = 0; 57 58#define SK(index) devs[(index)].sk 59#define BDADDR(index) devs[(index)].bdaddr 60#define UP(index) devs[(index)].up 61#define READY(index) devs[(index)].ready 62#define CHANNEL(index) devs[(index)].channel 63#define WATCH_ID(index) devs[(index)].watch_id 64#define PIN_LENGTH(index) devs[(index)].pin_length 65 66static int max_dev = -1; 67static struct dev_info { 68 int sk; 69 bdaddr_t bdaddr; 70 gboolean up; 71 gboolean ready; 72 73 GIOChannel *channel; 74 guint watch_id; 75 int pin_length; 76} *devs = NULL; 77 78static int ignore_device(struct hci_dev_info *di) 79{ 80 return hci_test_bit(HCI_RAW, &di->flags) || di->type >> 4 != HCI_BREDR; 81} 82 83static void init_dev_info(int index, int sk) 84{ 85 memset(&devs[index], 0, sizeof(struct dev_info)); 86 SK(index) = sk; 87 PIN_LENGTH(index) = -1; 88} 89 90/* Async HCI command handling with callback support */ 91 92struct hci_cmd_data { 93 bt_hci_result_t cb; 94 uint16_t handle; 95 uint16_t ocf; 96 gpointer caller_data; 97}; 98 99static gboolean hci_event_watch(GIOChannel *io, 100 GIOCondition cond, gpointer user_data) 101{ 102 unsigned char buf[HCI_MAX_EVENT_SIZE], *body; 103 struct hci_cmd_data *cmd = user_data; 104 evt_cmd_status *evt_status; 105 evt_auth_complete *evt_auth; 106 evt_encrypt_change *evt_enc; 107 hci_event_hdr *hdr; 108 set_conn_encrypt_cp cp; 109 int dd; 110 uint16_t ocf; 111 uint8_t status = HCI_OE_POWER_OFF; 112 113 if (cond & G_IO_NVAL) { 114 cmd->cb(status, cmd->caller_data); 115 return FALSE; 116 } 117 118 if (cond & (G_IO_ERR | G_IO_HUP)) 119 goto failed; 120 121 dd = g_io_channel_unix_get_fd(io); 122 123 if (read(dd, buf, sizeof(buf)) < 0) 124 goto failed; 125 126 hdr = (hci_event_hdr *) (buf + 1); 127 body = buf + (1 + HCI_EVENT_HDR_SIZE); 128 129 switch (hdr->evt) { 130 case EVT_CMD_STATUS: 131 evt_status = (evt_cmd_status *) body; 132 ocf = cmd_opcode_ocf(evt_status->opcode); 133 if (ocf != cmd->ocf) 134 return TRUE; 135 switch (ocf) { 136 case OCF_AUTH_REQUESTED: 137 case OCF_SET_CONN_ENCRYPT: 138 if (evt_status->status != 0) { 139 /* Baseband rejected command */ 140 status = evt_status->status; 141 goto failed; 142 } 143 break; 144 default: 145 return TRUE; 146 } 147 /* Wait for the next event */ 148 return TRUE; 149 case EVT_AUTH_COMPLETE: 150 evt_auth = (evt_auth_complete *) body; 151 if (evt_auth->handle != cmd->handle) { 152 /* Skipping */ 153 return TRUE; 154 } 155 156 if (evt_auth->status != 0x00) { 157 status = evt_auth->status; 158 /* Abort encryption */ 159 goto failed; 160 } 161 162 memset(&cp, 0, sizeof(cp)); 163 cp.handle = cmd->handle; 164 cp.encrypt = 1; 165 166 cmd->ocf = OCF_SET_CONN_ENCRYPT; 167 168 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, 169 SET_CONN_ENCRYPT_CP_SIZE, &cp) < 0) { 170 status = HCI_COMMAND_DISALLOWED; 171 goto failed; 172 } 173 /* Wait for encrypt change event */ 174 return TRUE; 175 case EVT_ENCRYPT_CHANGE: 176 evt_enc = (evt_encrypt_change *) body; 177 if (evt_enc->handle != cmd->handle) 178 return TRUE; 179 180 /* Procedure finished: reporting status */ 181 status = evt_enc->status; 182 break; 183 default: 184 /* Skipping */ 185 return TRUE; 186 } 187 188failed: 189 cmd->cb(status, cmd->caller_data); 190 g_io_channel_shutdown(io, TRUE, NULL); 191 192 return FALSE; 193} 194 195static int hciops_encrypt_link(int index, bdaddr_t *dst, bt_hci_result_t cb, 196 gpointer user_data) 197{ 198 GIOChannel *io; 199 struct hci_cmd_data *cmd; 200 struct hci_conn_info_req *cr; 201 auth_requested_cp cp; 202 struct hci_filter nf; 203 int dd, err; 204 uint32_t link_mode; 205 uint16_t handle; 206 207 cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info)); 208 cr->type = ACL_LINK; 209 bacpy(&cr->bdaddr, dst); 210 211 err = ioctl(SK(index), HCIGETCONNINFO, cr); 212 link_mode = cr->conn_info->link_mode; 213 handle = cr->conn_info->handle; 214 g_free(cr); 215 216 if (err < 0) 217 return -errno; 218 219 if (link_mode & HCI_LM_ENCRYPT) 220 return -EALREADY; 221 222 memset(&cp, 0, sizeof(cp)); 223 cp.handle = htobs(handle); 224 225 if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_AUTH_REQUESTED, 226 AUTH_REQUESTED_CP_SIZE, &cp) < 0) 227 return -errno; 228 229 dd = dup(SK(index)); 230 if (dd < 0) 231 return -errno; 232 233 cmd = g_new0(struct hci_cmd_data, 1); 234 cmd->handle = handle; 235 cmd->ocf = OCF_AUTH_REQUESTED; 236 cmd->cb = cb; 237 cmd->caller_data = user_data; 238 239 hci_filter_clear(&nf); 240 hci_filter_set_ptype(HCI_EVENT_PKT, &nf); 241 hci_filter_set_event(EVT_CMD_STATUS, &nf); 242 hci_filter_set_event(EVT_AUTH_COMPLETE, &nf); 243 hci_filter_set_event(EVT_ENCRYPT_CHANGE, &nf); 244 245 if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) { 246 err = -errno; 247 g_free(cmd); 248 close(dd); 249 return -err; 250 } 251 252 io = g_io_channel_unix_new(dup(SK(index))); 253 g_io_channel_set_close_on_unref(io, FALSE); 254 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, 255 G_IO_HUP | G_IO_ERR | G_IO_NVAL | G_IO_IN, 256 hci_event_watch, cmd, g_free); 257 g_io_channel_unref(io); 258 259 return 0; 260} 261 262/* End async HCI command handling */ 263 264/* Start of HCI event callbacks */ 265 266static int get_handle(int index, bdaddr_t *dba, uint16_t *handle) 267{ 268 struct hci_conn_list_req *cl; 269 struct hci_conn_info *ci; 270 int i; 271 272 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); 273 274 cl->dev_id = index; 275 cl->conn_num = 10; 276 ci = cl->conn_info; 277 278 if (ioctl(SK(index), HCIGETCONNLIST, (void *) cl) < 0) { 279 g_free(cl); 280 return -EIO; 281 } 282 283 for (i = 0; i < cl->conn_num; i++, ci++) { 284 if (bacmp(&ci->bdaddr, dba) == 0) { 285 *handle = ci->handle; 286 g_free(cl); 287 return 0; 288 } 289 } 290 291 g_free(cl); 292 293 return -ENOENT; 294} 295 296static inline int get_bdaddr(int index, uint16_t handle, bdaddr_t *dba) 297{ 298 struct hci_conn_list_req *cl; 299 struct hci_conn_info *ci; 300 int i; 301 302 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); 303 304 cl->dev_id = index; 305 cl->conn_num = 10; 306 ci = cl->conn_info; 307 308 if (ioctl(SK(index), HCIGETCONNLIST, (void *) cl) < 0) { 309 g_free(cl); 310 return -EIO; 311 } 312 313 for (i = 0; i < cl->conn_num; i++, ci++) 314 if (ci->handle == handle) { 315 bacpy(dba, &ci->bdaddr); 316 g_free(cl); 317 return 0; 318 } 319 320 g_free(cl); 321 322 return -ENOENT; 323} 324 325static inline void update_lastseen(bdaddr_t *sba, bdaddr_t *dba) 326{ 327 time_t t; 328 struct tm *tm; 329 330 t = time(NULL); 331 tm = gmtime(&t); 332 333 write_lastseen_info(sba, dba, tm); 334} 335 336static inline void update_lastused(bdaddr_t *sba, bdaddr_t *dba) 337{ 338 time_t t; 339 struct tm *tm; 340 341 t = time(NULL); 342 tm = gmtime(&t); 343 344 write_lastused_info(sba, dba, tm); 345} 346 347/* Link Key handling */ 348 349static void link_key_request(int index, bdaddr_t *dba) 350{ 351 struct btd_adapter *adapter; 352 struct btd_device *device; 353 struct hci_auth_info_req req; 354 unsigned char key[16]; 355 char sa[18], da[18]; 356 uint8_t type; 357 int err; 358 359 ba2str(&BDADDR(index), sa); ba2str(dba, da); 360 info("link_key_request (sba=%s, dba=%s)", sa, da); 361 362 adapter = manager_find_adapter(&BDADDR(index)); 363 if (adapter) 364 device = adapter_find_device(adapter, da); 365 else 366 device = NULL; 367 368 memset(&req, 0, sizeof(req)); 369 bacpy(&req.bdaddr, dba); 370 371 err = ioctl(SK(index), HCIGETAUTHINFO, (unsigned long) &req); 372 if (err < 0) { 373 if (errno != EINVAL) 374 DBG("HCIGETAUTHINFO failed %s (%d)", 375 strerror(errno), errno); 376 req.type = 0x00; 377 } 378 379 DBG("kernel auth requirements = 0x%02x", req.type); 380 381 if (main_opts.debug_keys && device && 382 device_get_debug_key(device, key)) 383 type = 0x03; 384 else if (read_link_key(&BDADDR(index), dba, key, &type) < 0 || 385 type == 0x03) { 386 /* Link key not found */ 387 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY, 388 6, dba); 389 return; 390 } 391 392 /* Link key found */ 393 394 DBG("link key type = 0x%02x", type); 395 396 /* Don't use unauthenticated combination keys if MITM is 397 * required */ 398 if (type == 0x04 && req.type != 0xff && (req.type & 0x01)) 399 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY, 400 6, dba); 401 else { 402 link_key_reply_cp lr; 403 404 memcpy(lr.link_key, key, 16); 405 bacpy(&lr.bdaddr, dba); 406 407 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_REPLY, 408 LINK_KEY_REPLY_CP_SIZE, &lr); 409 } 410} 411 412static void link_key_notify(int index, void *ptr) 413{ 414 evt_link_key_notify *evt = ptr; 415 bdaddr_t *dba = &evt->bdaddr; 416 char sa[18], da[18]; 417 int err; 418 unsigned char old_key[16]; 419 uint8_t old_key_type; 420 421 ba2str(&BDADDR(index), sa); ba2str(dba, da); 422 info("link_key_notify (sba=%s, dba=%s, type=%d)", sa, da, 423 evt->key_type); 424 425 err = read_link_key(&BDADDR(index), dba, old_key, &old_key_type); 426 if (err < 0) 427 old_key_type = 0xff; 428 429 err = btd_event_link_key_notify(&BDADDR(index), dba, evt->link_key, 430 evt->key_type, PIN_LENGTH(index), 431 old_key_type); 432 PIN_LENGTH(index) = -1; 433 434 if (err < 0) { 435 uint16_t handle; 436 437 if (err == -ENODEV) 438 btd_event_bonding_process_complete(&BDADDR(index), dba, 439 HCI_OE_LOW_RESOURCES); 440 else 441 btd_event_bonding_process_complete(&BDADDR(index), dba, 442 HCI_MEMORY_FULL); 443 444 if (get_handle(index, dba, &handle) == 0) { 445 disconnect_cp cp; 446 447 memset(&cp, 0, sizeof(cp)); 448 cp.handle = htobs(handle); 449 cp.reason = HCI_OE_LOW_RESOURCES; 450 451 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_DISCONNECT, 452 DISCONNECT_CP_SIZE, &cp); 453 } 454 } 455} 456 457static void return_link_keys(int index, void *ptr) 458{ 459 evt_return_link_keys *evt = ptr; 460 uint8_t num = evt->num_keys; 461 unsigned char key[16]; 462 char sa[18], da[18]; 463 bdaddr_t dba; 464 int i; 465 466 ba2str(&BDADDR(index), sa); 467 ptr++; 468 469 for (i = 0; i < num; i++) { 470 bacpy(&dba, ptr); ba2str(&dba, da); 471 memcpy(key, ptr + 6, 16); 472 473 info("return_link_keys (sba=%s, dba=%s)", sa, da); 474 475 btd_event_returned_link_key(&BDADDR(index), &dba); 476 477 ptr += 22; 478 } 479} 480 481/* Simple Pairing handling */ 482 483static void user_confirm_request(int index, void *ptr) 484{ 485 evt_user_confirm_request *req = ptr; 486 487 if (btd_event_user_confirm(&BDADDR(index), &req->bdaddr, 488 btohl(req->passkey)) < 0) 489 hci_send_cmd(SK(index), OGF_LINK_CTL, 490 OCF_USER_CONFIRM_NEG_REPLY, 6, ptr); 491} 492 493static void user_passkey_request(int index, void *ptr) 494{ 495 evt_user_passkey_request *req = ptr; 496 497 if (btd_event_user_passkey(&BDADDR(index), &req->bdaddr) < 0) 498 hci_send_cmd(SK(index), OGF_LINK_CTL, 499 OCF_USER_PASSKEY_NEG_REPLY, 6, ptr); 500} 501 502static void user_passkey_notify(int index, void *ptr) 503{ 504 evt_user_passkey_notify *req = ptr; 505 506 btd_event_user_notify(&BDADDR(index), &req->bdaddr, 507 btohl(req->passkey)); 508} 509 510static void remote_oob_data_request(int index, void *ptr) 511{ 512 hci_send_cmd(SK(index), OGF_LINK_CTL, 513 OCF_REMOTE_OOB_DATA_NEG_REPLY, 6, ptr); 514} 515 516static void io_capa_request(int index, void *ptr) 517{ 518 bdaddr_t *dba = ptr; 519 char sa[18], da[18]; 520 uint8_t cap, auth; 521 522 ba2str(&BDADDR(index), sa); ba2str(dba, da); 523 info("io_capa_request (sba=%s, dba=%s)", sa, da); 524 525 if (btd_event_get_io_cap(&BDADDR(index), dba, &cap, &auth) < 0) { 526 io_capability_neg_reply_cp cp; 527 memset(&cp, 0, sizeof(cp)); 528 bacpy(&cp.bdaddr, dba); 529 cp.reason = HCI_PAIRING_NOT_ALLOWED; 530 hci_send_cmd(SK(index), OGF_LINK_CTL, 531 OCF_IO_CAPABILITY_NEG_REPLY, 532 IO_CAPABILITY_NEG_REPLY_CP_SIZE, &cp); 533 } else { 534 io_capability_reply_cp cp; 535 memset(&cp, 0, sizeof(cp)); 536 bacpy(&cp.bdaddr, dba); 537 cp.capability = cap; 538 cp.oob_data = 0x00; 539 cp.authentication = auth; 540 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_IO_CAPABILITY_REPLY, 541 IO_CAPABILITY_REPLY_CP_SIZE, &cp); 542 } 543} 544 545static void io_capa_response(int index, void *ptr) 546{ 547 evt_io_capability_response *evt = ptr; 548 char sa[18], da[18]; 549 550 ba2str(&BDADDR(index), sa); ba2str(&evt->bdaddr, da); 551 info("io_capa_response (sba=%s, dba=%s)", sa, da); 552 553 btd_event_set_io_cap(&BDADDR(index), &evt->bdaddr, 554 evt->capability, evt->authentication); 555} 556 557/* PIN code handling */ 558 559static void pin_code_request(int index, bdaddr_t *dba) 560{ 561 pin_code_reply_cp pr; 562 struct hci_conn_info_req *cr; 563 struct hci_conn_info *ci; 564 char sa[18], da[18], pin[17]; 565 int pinlen; 566 567 memset(&pr, 0, sizeof(pr)); 568 bacpy(&pr.bdaddr, dba); 569 570 ba2str(&BDADDR(index), sa); ba2str(dba, da); 571 info("pin_code_request (sba=%s, dba=%s)", sa, da); 572 573 cr = g_malloc0(sizeof(*cr) + sizeof(*ci)); 574 575 bacpy(&cr->bdaddr, dba); 576 cr->type = ACL_LINK; 577 if (ioctl(SK(index), HCIGETCONNINFO, (unsigned long) cr) < 0) { 578 error("Can't get conn info: %s (%d)", strerror(errno), errno); 579 goto reject; 580 } 581 ci = cr->conn_info; 582 583 memset(pin, 0, sizeof(pin)); 584 pinlen = read_pin_code(&BDADDR(index), dba, pin); 585 586 if (pinlen > 0) { 587 PIN_LENGTH(index) = pinlen; 588 memcpy(pr.pin_code, pin, pinlen); 589 pr.pin_len = pinlen; 590 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_PIN_CODE_REPLY, 591 PIN_CODE_REPLY_CP_SIZE, &pr); 592 } else { 593 /* Request PIN from passkey agent */ 594 if (btd_event_request_pin(&BDADDR(index), ci) < 0) 595 goto reject; 596 } 597 598 g_free(cr); 599 600 return; 601 602reject: 603 g_free(cr); 604 605 hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_PIN_CODE_NEG_REPLY, 6, dba); 606} 607 608static void start_inquiry(bdaddr_t *local, uint8_t status, gboolean periodic) 609{ 610 struct btd_adapter *adapter; 611 int state; 612 613 /* Don't send the signal if the cmd failed */ 614 if (status) { 615 error("Inquiry Failed with status 0x%02x", status); 616 return; 617 } 618 619 adapter = manager_find_adapter(local); 620 if (!adapter) { 621 error("Unable to find matching adapter"); 622 return; 623 } 624 625 state = adapter_get_state(adapter); 626 627 if (periodic) 628 state |= STATE_PINQ; 629 else 630 state |= STATE_STDINQ; 631 632 adapter_set_state(adapter, state); 633} 634 635static void inquiry_complete(bdaddr_t *local, uint8_t status, 636 gboolean periodic) 637{ 638 struct btd_adapter *adapter; 639 int state; 640 641 /* Don't send the signal if the cmd failed */ 642 if (status) { 643 error("Inquiry Failed with status 0x%02x", status); 644 return; 645 } 646 647 adapter = manager_find_adapter(local); 648 if (!adapter) { 649 error("Unable to find matching adapter"); 650 return; 651 } 652 653 state = adapter_get_state(adapter); 654 state &= ~(STATE_STDINQ | STATE_PINQ); 655 adapter_set_state(adapter, state); 656} 657 658static inline void remote_features_notify(int index, void *ptr) 659{ 660 evt_remote_host_features_notify *evt = ptr; 661 662 if (evt->features[0] & 0x01) 663 btd_event_set_legacy_pairing(&BDADDR(index), &evt->bdaddr, 664 FALSE); 665 else 666 btd_event_set_legacy_pairing(&BDADDR(index), &evt->bdaddr, 667 TRUE); 668 669 write_features_info(&BDADDR(index), &evt->bdaddr, NULL, evt->features); 670} 671 672static void write_le_host_complete(bdaddr_t *sba, uint8_t status) 673{ 674 struct btd_adapter *adapter; 675 676 if (status) 677 return; 678 679 adapter = manager_find_adapter(sba); 680 if (!adapter) { 681 error("No matching adapter found"); 682 return; 683 } 684 685 btd_adapter_read_local_ext_features(adapter); 686} 687 688static void read_local_ext_features_complete(bdaddr_t *sba, 689 const read_local_ext_features_rp *rp) 690{ 691 struct btd_adapter *adapter; 692 693 if (rp->status) 694 return; 695 696 adapter = manager_find_adapter(sba); 697 if (!adapter) { 698 error("No matching adapter found"); 699 return; 700 } 701 702 /* Local Extended feature page number is 1 */ 703 if (rp->page_num != 1) 704 return; 705 706 btd_adapter_update_local_ext_features(adapter, rp->features); 707} 708 709static void read_bd_addr_complete(int index, read_bd_addr_rp *rp) 710{ 711 if (rp->status) 712 return; 713 714 bacpy(&BDADDR(index), &rp->bdaddr); 715 716 if (READY(index)) 717 return; 718 719 READY(index) = TRUE; 720 721 DBG("Got bdaddr for hci%d", index); 722 723 if (UP(index)) 724 manager_start_adapter(index); 725} 726 727static inline void cmd_status(int index, void *ptr) 728{ 729 evt_cmd_status *evt = ptr; 730 uint16_t opcode = btohs(evt->opcode); 731 732 if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY)) 733 start_inquiry(&BDADDR(index), evt->status, FALSE); 734} 735 736static void read_scan_complete(int index, uint8_t status, void *ptr) 737{ 738 struct btd_adapter *adapter; 739 read_scan_enable_rp *rp = ptr; 740 741 adapter = manager_find_adapter(&BDADDR(index)); 742 743 if (!adapter) { 744 error("Unable to find matching adapter"); 745 return; 746 } 747 748 adapter_mode_changed(adapter, rp->enable); 749} 750 751static inline void cmd_complete(int index, void *ptr) 752{ 753 evt_cmd_complete *evt = ptr; 754 uint16_t opcode = btohs(evt->opcode); 755 uint8_t status = *((uint8_t *) ptr + EVT_CMD_COMPLETE_SIZE); 756 757 switch (opcode) { 758 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_EXT_FEATURES): 759 ptr += sizeof(evt_cmd_complete); 760 read_local_ext_features_complete(&BDADDR(index), ptr); 761 break; 762 case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_BD_ADDR): 763 ptr += sizeof(evt_cmd_complete); 764 read_bd_addr_complete(index, ptr); 765 break; 766 case cmd_opcode_pack(OGF_LINK_CTL, OCF_PERIODIC_INQUIRY): 767 start_inquiry(&BDADDR(index), status, TRUE); 768 break; 769 case cmd_opcode_pack(OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY): 770 inquiry_complete(&BDADDR(index), status, TRUE); 771 break; 772 case cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY_CANCEL): 773 inquiry_complete(&BDADDR(index), status, FALSE); 774 break; 775 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_LE_HOST_SUPPORTED): 776 write_le_host_complete(&BDADDR(index), status); 777 break; 778 case cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE): 779 btd_event_le_set_scan_enable_complete(&BDADDR(index), status); 780 break; 781 case cmd_opcode_pack(OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME): 782 adapter_setname_complete(&BDADDR(index), status); 783 break; 784 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE): 785 btd_event_setscan_enable_complete(&BDADDR(index)); 786 break; 787 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SCAN_ENABLE): 788 ptr += sizeof(evt_cmd_complete); 789 read_scan_complete(index, status, ptr); 790 break; 791 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV): 792 adapter_set_class_complete(&BDADDR(index), status); 793 break; 794 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SIMPLE_PAIRING_MODE): 795 btd_event_write_simple_pairing_mode_complete(&BDADDR(index)); 796 break; 797 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SIMPLE_PAIRING_MODE): 798 ptr += sizeof(evt_cmd_complete); 799 btd_event_read_simple_pairing_mode_complete(&BDADDR(index), 800 ptr); 801 break; 802 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_LOCAL_NAME): 803 ptr += sizeof(evt_cmd_complete); 804 adapter_update_local_name(&BDADDR(index), status, ptr); 805 break; 806 case cmd_opcode_pack(OGF_HOST_CTL, 807 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL): 808 ptr += sizeof(evt_cmd_complete); 809 adapter_update_tx_power(&BDADDR(index), status, ptr); 810 break; 811 }; 812} 813 814static inline void remote_name_information(int index, void *ptr) 815{ 816 evt_remote_name_req_complete *evt = ptr; 817 char name[MAX_NAME_LENGTH + 1]; 818 819 memset(name, 0, sizeof(name)); 820 821 if (!evt->status) 822 memcpy(name, evt->name, MAX_NAME_LENGTH); 823 824 btd_event_remote_name(&BDADDR(index), &evt->bdaddr, evt->status, name); 825} 826 827static inline void remote_version_information(int index, void *ptr) 828{ 829 evt_read_remote_version_complete *evt = ptr; 830 bdaddr_t dba; 831 832 if (evt->status) 833 return; 834 835 if (get_bdaddr(index, btohs(evt->handle), &dba) < 0) 836 return; 837 838 write_version_info(&BDADDR(index), &dba, btohs(evt->manufacturer), 839 evt->lmp_ver, btohs(evt->lmp_subver)); 840} 841 842static inline void inquiry_result(int index, int plen, void *ptr) 843{ 844 uint8_t num = *(uint8_t *) ptr++; 845 int i; 846 847 for (i = 0; i < num; i++) { 848 inquiry_info *info = ptr; 849 uint32_t class = info->dev_class[0] | 850 (info->dev_class[1] << 8) | 851 (info->dev_class[2] << 16); 852 853 btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, class, 854 0, NULL); 855 856 update_lastseen(&BDADDR(index), &info->bdaddr); 857 858 ptr += INQUIRY_INFO_SIZE; 859 } 860} 861 862static inline void inquiry_result_with_rssi(int index, int plen, void *ptr) 863{ 864 uint8_t num = *(uint8_t *) ptr++; 865 int i; 866 867 if (!num) 868 return; 869 870 if ((plen - 1) / num == INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE) { 871 for (i = 0; i < num; i++) { 872 inquiry_info_with_rssi_and_pscan_mode *info = ptr; 873 uint32_t class = info->dev_class[0] 874 | (info->dev_class[1] << 8) 875 | (info->dev_class[2] << 16); 876 877 btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, 878 class, info->rssi, NULL); 879 880 update_lastseen(&BDADDR(index), &info->bdaddr); 881 882 ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE; 883 } 884 } else { 885 for (i = 0; i < num; i++) { 886 inquiry_info_with_rssi *info = ptr; 887 uint32_t class = info->dev_class[0] 888 | (info->dev_class[1] << 8) 889 | (info->dev_class[2] << 16); 890 891 btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, 892 class, info->rssi, NULL); 893 894 update_lastseen(&BDADDR(index), &info->bdaddr); 895 896 ptr += INQUIRY_INFO_WITH_RSSI_SIZE; 897 } 898 } 899} 900 901static inline void extended_inquiry_result(int index, int plen, void *ptr) 902{ 903 uint8_t num = *(uint8_t *) ptr++; 904 int i; 905 906 for (i = 0; i < num; i++) { 907 extended_inquiry_info *info = ptr; 908 uint32_t class = info->dev_class[0] 909 | (info->dev_class[1] << 8) 910 | (info->dev_class[2] << 16); 911 912 btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, class, 913 info->rssi, info->data); 914 915 update_lastseen(&BDADDR(index), &info->bdaddr); 916 917 ptr += EXTENDED_INQUIRY_INFO_SIZE; 918 } 919} 920 921static inline void remote_features_information(int index, void *ptr) 922{ 923 evt_read_remote_features_complete *evt = ptr; 924 bdaddr_t dba; 925 926 if (evt->status) 927 return; 928 929 if (get_bdaddr(index, btohs(evt->handle), &dba) < 0) 930 return; 931 932 write_features_info(&BDADDR(index), &dba, evt->features, NULL); 933} 934 935static inline void conn_complete(int index, void *ptr) 936{ 937 evt_conn_complete *evt = ptr; 938 char filename[PATH_MAX]; 939 char local_addr[18], peer_addr[18], *str; 940 struct btd_adapter *adapter; 941 942 adapter = manager_find_adapter(&BDADDR(index)); 943 if (!adapter) { 944 error("Unable to find matching adapter"); 945 return; 946 } 947 948 if (evt->link_type != ACL_LINK) 949 return; 950 951 btd_event_conn_complete(&BDADDR(index), evt->status, 952 btohs(evt->handle), &evt->bdaddr); 953 954 if (evt->status) 955 return; 956 957 update_lastused(&BDADDR(index), &evt->bdaddr); 958 959 /* check if the remote version needs be requested */ 960 ba2str(&BDADDR(index), local_addr); 961 ba2str(&evt->bdaddr, peer_addr); 962 963 create_name(filename, sizeof(filename), STORAGEDIR, local_addr, 964 "manufacturers"); 965 966 str = textfile_get(filename, peer_addr); 967 if (!str) 968 btd_adapter_get_remote_version(adapter, btohs(evt->handle), 969 TRUE); 970 else 971 free(str); 972} 973 974static inline void disconn_complete(int index, void *ptr) 975{ 976 evt_disconn_complete *evt = ptr; 977 978 btd_event_disconn_complete(&BDADDR(index), evt->status, 979 btohs(evt->handle), evt->reason); 980} 981 982static inline void auth_complete(int index, void *ptr) 983{ 984 evt_auth_complete *evt = ptr; 985 bdaddr_t dba; 986 987 if (get_bdaddr(index, btohs(evt->handle), &dba) < 0) 988 return; 989 990 btd_event_bonding_process_complete(&BDADDR(index), &dba, evt->status); 991} 992 993static inline void simple_pairing_complete(int index, void *ptr) 994{ 995 evt_simple_pairing_complete *evt = ptr; 996 997 btd_event_simple_pairing_complete(&BDADDR(index), &evt->bdaddr, 998 evt->status); 999} 1000 1001static inline void conn_request(int index, void *ptr) 1002{ 1003 evt_conn_request *evt = ptr; 1004 uint32_t class = evt->dev_class[0] | (evt->dev_class[1] << 8) 1005 | (evt->dev_class[2] << 16); 1006 1007 btd_event_remote_class(&BDADDR(index), &evt->bdaddr, class); 1008} 1009 1010static inline void le_metaevent(int index, void *ptr) 1011{ 1012 evt_le_meta_event *meta = ptr; 1013 le_advertising_info *info; 1014 uint8_t *rssi, num, i; 1015 1016 DBG("LE Meta Event"); 1017 1018 if (meta->subevent != EVT_LE_ADVERTISING_REPORT) 1019 return; 1020 1021 num = meta->data[0]; 1022 info = (le_advertising_info *) (meta->data + 1); 1023 1024 for (i = 0; i < num; i++) { 1025 /* RSSI is last byte of the advertising report event */ 1026 rssi = info->data + info->length; 1027 btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, 0, 1028 *rssi, NULL); 1029 info = (le_advertising_info *) (rssi + 1); 1030 } 1031} 1032 1033static void stop_hci_dev(int index) 1034{ 1035 GIOChannel *chan = CHANNEL(index); 1036 1037 if (!chan) 1038 return; 1039 1040 info("Stopping hci%d event socket", index); 1041 1042 g_source_remove(WATCH_ID(index)); 1043 g_io_channel_unref(CHANNEL(index)); 1044 hci_close_dev(SK(index)); 1045 init_dev_info(index, -1); 1046} 1047 1048static gboolean io_security_event(GIOChannel *chan, GIOCondition cond, 1049 gpointer data) 1050{ 1051 unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr = buf; 1052 int type, index = GPOINTER_TO_INT(data); 1053 struct hci_dev_info di; 1054 size_t len; 1055 hci_event_hdr *eh; 1056 GIOError err; 1057 evt_cmd_status *evt; 1058 1059 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) { 1060 stop_hci_dev(index); 1061 return FALSE; 1062 } 1063 1064 if ((err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len))) { 1065 if (err == G_IO_ERROR_AGAIN) 1066 return TRUE; 1067 stop_hci_dev(index); 1068 return FALSE; 1069 } 1070 1071 type = *ptr++; 1072 1073 if (type != HCI_EVENT_PKT) 1074 return TRUE; 1075 1076 eh = (hci_event_hdr *) ptr; 1077 ptr += HCI_EVENT_HDR_SIZE; 1078 1079 memset(&di, 0, sizeof(di)); 1080 if (hci_devinfo(index, &di) == 0) { 1081 bacpy(&BDADDR(index), &di.bdaddr); 1082 1083 if (ignore_device(&di)) 1084 return TRUE; 1085 } 1086 1087 switch (eh->evt) { 1088 case EVT_CMD_STATUS: 1089 cmd_status(index, ptr); 1090 break; 1091 1092 case EVT_CMD_COMPLETE: 1093 cmd_complete(index, ptr); 1094 break; 1095 1096 case EVT_REMOTE_NAME_REQ_COMPLETE: 1097 remote_name_information(index, ptr); 1098 break; 1099 1100 case EVT_READ_REMOTE_VERSION_COMPLETE: 1101 remote_version_information(index, ptr); 1102 break; 1103 1104 case EVT_READ_REMOTE_FEATURES_COMPLETE: 1105 remote_features_information(index, ptr); 1106 break; 1107 1108 case EVT_REMOTE_HOST_FEATURES_NOTIFY: 1109 remote_features_notify(index, ptr); 1110 break; 1111 1112 case EVT_INQUIRY_COMPLETE: 1113 evt = (evt_cmd_status *) ptr; 1114 inquiry_complete(&BDADDR(index), evt->status, FALSE); 1115 break; 1116 1117 case EVT_INQUIRY_RESULT: 1118 inquiry_result(index, eh->plen, ptr); 1119 break; 1120 1121 case EVT_INQUIRY_RESULT_WITH_RSSI: 1122 inquiry_result_with_rssi(index, eh->plen, ptr); 1123 break; 1124 1125 case EVT_EXTENDED_INQUIRY_RESULT: 1126 extended_inquiry_result(index, eh->plen, ptr); 1127 break; 1128 1129 case EVT_CONN_COMPLETE: 1130 conn_complete(index, ptr); 1131 break; 1132 1133 case EVT_DISCONN_COMPLETE: 1134 disconn_complete(index, ptr); 1135 break; 1136 1137 case EVT_AUTH_COMPLETE: 1138 auth_complete(index, ptr); 1139 break; 1140 1141 case EVT_SIMPLE_PAIRING_COMPLETE: 1142 simple_pairing_complete(index, ptr); 1143 break; 1144 1145 case EVT_CONN_REQUEST: 1146 conn_request(index, ptr); 1147 break; 1148 case EVT_LE_META_EVENT: 1149 le_metaevent(index, ptr); 1150 break; 1151 case EVT_PIN_CODE_REQ: 1152 pin_code_request(index, (bdaddr_t *) ptr); 1153 break; 1154 1155 case EVT_LINK_KEY_REQ: 1156 link_key_request(index, (bdaddr_t *) ptr); 1157 break; 1158 1159 case EVT_LINK_KEY_NOTIFY: 1160 link_key_notify(index, ptr); 1161 break; 1162 1163 case EVT_RETURN_LINK_KEYS: 1164 return_link_keys(index, ptr); 1165 break; 1166 1167 case EVT_IO_CAPABILITY_REQUEST: 1168 io_capa_request(index, ptr); 1169 break; 1170 1171 case EVT_IO_CAPABILITY_RESPONSE: 1172 io_capa_response(index, ptr); 1173 break; 1174 1175 case EVT_USER_CONFIRM_REQUEST: 1176 user_confirm_request(index, ptr); 1177 break; 1178 1179 case EVT_USER_PASSKEY_REQUEST: 1180 user_passkey_request(index, ptr); 1181 break; 1182 1183 case EVT_USER_PASSKEY_NOTIFY: 1184 user_passkey_notify(index, ptr); 1185 break; 1186 1187 case EVT_REMOTE_OOB_DATA_REQUEST: 1188 remote_oob_data_request(index, ptr); 1189 break; 1190 } 1191 1192 return TRUE; 1193} 1194 1195static void start_hci_dev(int index) 1196{ 1197 GIOChannel *chan = CHANNEL(index); 1198 GIOCondition cond; 1199 struct hci_filter flt; 1200 1201 if (chan) 1202 return; 1203 1204 info("Listening for HCI events on hci%d", index); 1205 1206 /* Set filter */ 1207 hci_filter_clear(&flt); 1208 hci_filter_set_ptype(HCI_EVENT_PKT, &flt); 1209 hci_filter_set_event(EVT_CMD_STATUS, &flt); 1210 hci_filter_set_event(EVT_CMD_COMPLETE, &flt); 1211 hci_filter_set_event(EVT_PIN_CODE_REQ, &flt); 1212 hci_filter_set_event(EVT_LINK_KEY_REQ, &flt); 1213 hci_filter_set_event(EVT_LINK_KEY_NOTIFY, &flt); 1214 hci_filter_set_event(EVT_RETURN_LINK_KEYS, &flt); 1215 hci_filter_set_event(EVT_IO_CAPABILITY_REQUEST, &flt); 1216 hci_filter_set_event(EVT_IO_CAPABILITY_RESPONSE, &flt); 1217 hci_filter_set_event(EVT_USER_CONFIRM_REQUEST, &flt); 1218 hci_filter_set_event(EVT_USER_PASSKEY_REQUEST, &flt); 1219 hci_filter_set_event(EVT_REMOTE_OOB_DATA_REQUEST, &flt); 1220 hci_filter_set_event(EVT_USER_PASSKEY_NOTIFY, &flt); 1221 hci_filter_set_event(EVT_KEYPRESS_NOTIFY, &flt); 1222 hci_filter_set_event(EVT_SIMPLE_PAIRING_COMPLETE, &flt); 1223 hci_filter_set_event(EVT_AUTH_COMPLETE, &flt); 1224 hci_filter_set_event(EVT_REMOTE_NAME_REQ_COMPLETE, &flt); 1225 hci_filter_set_event(EVT_READ_REMOTE_VERSION_COMPLETE, &flt); 1226 hci_filter_set_event(EVT_READ_REMOTE_FEATURES_COMPLETE, &flt); 1227 hci_filter_set_event(EVT_REMOTE_HOST_FEATURES_NOTIFY, &flt); 1228 hci_filter_set_event(EVT_INQUIRY_COMPLETE, &flt); 1229 hci_filter_set_event(EVT_INQUIRY_RESULT, &flt); 1230 hci_filter_set_event(EVT_INQUIRY_RESULT_WITH_RSSI, &flt); 1231 hci_filter_set_event(EVT_EXTENDED_INQUIRY_RESULT, &flt); 1232 hci_filter_set_event(EVT_CONN_REQUEST, &flt); 1233 hci_filter_set_event(EVT_CONN_COMPLETE, &flt); 1234 hci_filter_set_event(EVT_DISCONN_COMPLETE, &flt); 1235 hci_filter_set_event(EVT_LE_META_EVENT, &flt); 1236 if (setsockopt(SK(index), SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) { 1237 error("Can't set filter on hci%d: %s (%d)", 1238 index, strerror(errno), errno); 1239 return; 1240 } 1241 1242 chan = g_io_channel_unix_new(SK(index)); 1243 cond = G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR; 1244 WATCH_ID(index) = g_io_add_watch_full(chan, G_PRIORITY_LOW, cond, 1245 io_security_event, 1246 GINT_TO_POINTER(index), NULL); 1247 CHANNEL(index) = chan; 1248 PIN_LENGTH(index) = -1; 1249 1250} 1251 1252/* End of HCI event callbacks */ 1253 1254static gboolean child_exit(GIOChannel *io, GIOCondition cond, void *user_data) 1255{ 1256 int status, fd = g_io_channel_unix_get_fd(io); 1257 pid_t child_pid; 1258 1259 if (read(fd, &child_pid, sizeof(child_pid)) != sizeof(child_pid)) { 1260 error("child_exit: unable to read child pid from pipe"); 1261 return TRUE; 1262 } 1263 1264 if (waitpid(child_pid, &status, 0) != child_pid) 1265 error("waitpid(%d) failed", child_pid); 1266 else 1267 DBG("child %d exited", child_pid); 1268 1269 return TRUE; 1270} 1271 1272static void at_child_exit(void) 1273{ 1274 pid_t pid = getpid(); 1275 1276 if (write(child_pipe[1], &pid, sizeof(pid)) != sizeof(pid)) 1277 error("unable to write to child pipe"); 1278} 1279 1280static void device_devup_setup(int index) 1281{ 1282 struct hci_dev_info di; 1283 uint16_t policy; 1284 read_stored_link_key_cp cp; 1285 1286 if (hci_devinfo(index, &di) < 0) 1287 return; 1288 1289 if (ignore_device(&di)) 1290 return; 1291 1292 bacpy(&BDADDR(index), &di.bdaddr); 1293 1294 /* Set page timeout */ 1295 if ((main_opts.flags & (1 << HCID_SET_PAGETO))) { 1296 write_page_timeout_cp cp; 1297 1298 cp.timeout = htobs(main_opts.pageto); 1299 hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_PAGE_TIMEOUT, 1300 WRITE_PAGE_TIMEOUT_CP_SIZE, &cp); 1301 } 1302 1303 /* Set default link policy */ 1304 policy = htobs(main_opts.link_policy); 1305 hci_send_cmd(SK(index), OGF_LINK_POLICY, 1306 OCF_WRITE_DEFAULT_LINK_POLICY, 2, &policy); 1307 1308 bacpy(&cp.bdaddr, BDADDR_ANY); 1309 cp.read_all = 1; 1310 hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY, 1311 READ_STORED_LINK_KEY_CP_SIZE, (void *) &cp); 1312 1313 if (READY(index)) 1314 manager_start_adapter(index); 1315} 1316 1317static void init_device(int index) 1318{ 1319 struct hci_dev_req dr; 1320 struct hci_dev_info di; 1321 int dd; 1322 pid_t pid; 1323 1324 dd = hci_open_dev(index); 1325 if (dd < 0) { 1326 error("Unable to open hci%d: %s (%d)", index, 1327 strerror(errno), errno); 1328 return; 1329 } 1330 1331 if (index > max_dev) { 1332 max_dev = index; 1333 devs = g_realloc(devs, sizeof(devs[0]) * (max_dev + 1)); 1334 } 1335 1336 init_dev_info(index, dd); 1337 start_hci_dev(index); 1338 1339 /* Do initialization in the separate process */ 1340 pid = fork(); 1341 switch (pid) { 1342 case 0: 1343 atexit(at_child_exit); 1344 break; 1345 case -1: 1346 error("Fork failed. Can't init device hci%d: %s (%d)", 1347 index, strerror(errno), errno); 1348 default: 1349 DBG("child %d forked", pid); 1350 return; 1351 } 1352 1353 memset(&dr, 0, sizeof(dr)); 1354 dr.dev_id = index; 1355 1356 /* Set link mode */ 1357 dr.dev_opt = main_opts.link_mode; 1358 if (ioctl(dd, HCISETLINKMODE, (unsigned long) &dr) < 0) 1359 error("Can't set link mode on hci%d: %s (%d)", 1360 index, strerror(errno), errno); 1361 1362 /* Set link policy for BR/EDR HCI devices */ 1363 if (hci_devinfo(index, &di) < 0) 1364 goto fail; 1365 1366 if (!ignore_device(&di)) { 1367 dr.dev_opt = main_opts.link_policy; 1368 if (ioctl(dd, HCISETLINKPOL, (unsigned long) &dr) < 0 && 1369 errno != ENETDOWN) { 1370 error("Can't set link policy on hci%d: %s (%d)", 1371 index, strerror(errno), errno); 1372 } 1373 } 1374 1375 /* Start HCI device */ 1376 if (ioctl(dd, HCIDEVUP, index) < 0 && errno != EALREADY) { 1377 error("Can't init device hci%d: %s (%d)", 1378 index, strerror(errno), errno); 1379 goto fail; 1380 } 1381 1382 hci_close_dev(dd); 1383 exit(0); 1384 1385fail: 1386 hci_close_dev(dd); 1387 exit(1); 1388} 1389 1390static void device_devreg_setup(int index) 1391{ 1392 struct hci_dev_info di; 1393 gboolean devup; 1394 1395 init_device(index); 1396 1397 memset(&di, 0, sizeof(di)); 1398 1399 if (hci_devinfo(index, &di) < 0) 1400 return; 1401 1402 devup = hci_test_bit(HCI_UP, &di.flags); 1403 1404 if (!ignore_device(&di)) 1405 manager_register_adapter(index, devup); 1406} 1407 1408static void device_event(int event, int index) 1409{ 1410 switch (event) { 1411 case HCI_DEV_REG: 1412 info("HCI dev %d registered", index); 1413 device_devreg_setup(index); 1414 break; 1415 1416 case HCI_DEV_UNREG: 1417 info("HCI dev %d unregistered", index); 1418 stop_hci_dev(index); 1419 manager_unregister_adapter(index); 1420 break; 1421 1422 case HCI_DEV_UP: 1423 info("HCI dev %d up", index); 1424 UP(index) = TRUE; 1425 device_devup_setup(index); 1426 break; 1427 1428 case HCI_DEV_DOWN: 1429 info("HCI dev %d down", index); 1430 UP(index) = FALSE; 1431 if (READY(index)) { 1432 manager_stop_adapter(index); 1433 READY(index) = FALSE; 1434 } 1435 break; 1436 } 1437} 1438 1439static gboolean init_known_adapters(gpointer user_data) 1440{ 1441 struct hci_dev_list_req *dl; 1442 struct hci_dev_req *dr; 1443 int i, err, ctl = GPOINTER_TO_INT(user_data); 1444 size_t req_size; 1445 1446 req_size = HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t); 1447 1448 dl = g_try_malloc0(req_size); 1449 if (!dl) { 1450 error("Can't allocate devlist buffer"); 1451 return FALSE; 1452 } 1453 1454 dl->dev_num = HCI_MAX_DEV; 1455 dr = dl->dev_req; 1456 1457 if (ioctl(ctl, HCIGETDEVLIST, dl) < 0) { 1458 err = -errno; 1459 error("Can't get device list: %s (%d)", strerror(-err), -err); 1460 g_free(dl); 1461 return FALSE; 1462 } 1463 1464 for (i = 0; i < dl->dev_num; i++, dr++) { 1465 device_event(HCI_DEV_REG, dr->dev_id); 1466 1467 if (hci_test_bit(HCI_UP, &dr->dev_opt)) 1468 device_event(HCI_DEV_UP, dr->dev_id); 1469 } 1470 1471 g_free(dl); 1472 1473 return FALSE; 1474} 1475 1476static gboolean io_stack_event(GIOChannel *chan, GIOCondition cond, 1477 gpointer data) 1478{ 1479 unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr; 1480 evt_stack_internal *si; 1481 evt_si_device *sd; 1482 hci_event_hdr *eh; 1483 int type; 1484 size_t len; 1485 GIOError err; 1486 1487 ptr = buf; 1488 1489 err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len); 1490 if (err) { 1491 if (err == G_IO_ERROR_AGAIN) 1492 return TRUE; 1493 1494 error("Read from control socket failed: %s (%d)", 1495 strerror(errno), errno); 1496 return FALSE; 1497 } 1498 1499 type = *ptr++; 1500 1501 if (type != HCI_EVENT_PKT) 1502 return TRUE; 1503 1504 eh = (hci_event_hdr *) ptr; 1505 if (eh->evt != EVT_STACK_INTERNAL) 1506 return TRUE; 1507 1508 ptr += HCI_EVENT_HDR_SIZE; 1509 1510 si = (evt_stack_internal *) ptr; 1511 switch (si->type) { 1512 case EVT_SI_DEVICE: 1513 sd = (void *) &si->data; 1514 device_event(sd->event, sd->dev_id); 1515 break; 1516 } 1517 1518 return TRUE; 1519} 1520 1521static int hciops_setup(void) 1522{ 1523 struct sockaddr_hci addr; 1524 struct hci_filter flt; 1525 GIOChannel *ctl_io, *child_io; 1526 int sock, err; 1527 1528 if (child_pipe[0] != -1) 1529 return -EALREADY; 1530 1531 if (pipe(child_pipe) < 0) { 1532 err = -errno; 1533 error("pipe(): %s (%d)", strerror(-err), -err); 1534 return err; 1535 } 1536 1537 child_io = g_io_channel_unix_new(child_pipe[0]); 1538 g_io_channel_set_close_on_unref(child_io, TRUE); 1539 child_io_id = g_io_add_watch(child_io, 1540 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, 1541 child_exit, NULL); 1542 g_io_channel_unref(child_io); 1543 1544 /* Create and bind HCI socket */ 1545 sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 1546 if (sock < 0) { 1547 err = -errno; 1548 error("Can't open HCI socket: %s (%d)", strerror(-err), 1549 -err); 1550 return err; 1551 } 1552 1553 /* Set filter */ 1554 hci_filter_clear(&flt); 1555 hci_filter_set_ptype(HCI_EVENT_PKT, &flt); 1556 hci_filter_set_event(EVT_STACK_INTERNAL, &flt); 1557 if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) { 1558 err = -errno; 1559 error("Can't set filter: %s (%d)", strerror(-err), -err); 1560 return err; 1561 } 1562 1563 memset(&addr, 0, sizeof(addr)); 1564 addr.hci_family = AF_BLUETOOTH; 1565 addr.hci_dev = HCI_DEV_NONE; 1566 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1567 err = -errno; 1568 error("Can't bind HCI socket: %s (%d)", strerror(-err), -err); 1569 return err; 1570 } 1571 1572 ctl_io = g_io_channel_unix_new(sock); 1573 g_io_channel_set_close_on_unref(ctl_io, TRUE); 1574 1575 ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL); 1576 1577 g_io_channel_unref(ctl_io); 1578 1579 g_idle_add(init_known_adapters, GINT_TO_POINTER(sock)); 1580 1581 return 0; 1582} 1583 1584static void hciops_cleanup(void) 1585{ 1586 int i; 1587 1588 for (i = 0; i <= max_dev; i++) { 1589 if (SK(i) >= 0) 1590 hci_close_dev(SK(i)); 1591 } 1592 1593 g_free(devs); 1594 devs = NULL; 1595 max_dev = -1; 1596 1597 if (child_io_id) { 1598 g_source_remove(child_io_id); 1599 child_io_id = 0; 1600 } 1601 1602 if (ctl_io_id) { 1603 g_source_remove(ctl_io_id); 1604 ctl_io_id = 0; 1605 } 1606 1607 if (child_pipe[0] >= 0) { 1608 close(child_pipe[0]); 1609 child_pipe[0] = -1; 1610 } 1611 1612 if (child_pipe[1] >= 0) { 1613 close(child_pipe[1]); 1614 child_pipe[1] = -1; 1615 } 1616} 1617 1618static int hciops_start(int index) 1619{ 1620 int err; 1621 1622 if (ioctl(SK(index), HCIDEVUP, index) == 0) 1623 return 0; 1624 1625 if (errno == EALREADY) 1626 return 0; 1627 1628 err = -errno; 1629 error("Can't init device hci%d: %s (%d)", 1630 index, strerror(-err), -err); 1631 1632 return err; 1633} 1634 1635static int hciops_stop(int index) 1636{ 1637 int err = 0; 1638 1639 if (ioctl(SK(index), HCIDEVDOWN, index) == 0) 1640 goto done; /* on success */ 1641 1642 if (errno != EALREADY) { 1643 err = -errno; 1644 error("Can't stop device hci%d: %s (%d)", 1645 index, strerror(-err), -err); 1646 } 1647 1648done: 1649 return err; 1650} 1651 1652static int hciops_powered(int index, gboolean powered) 1653{ 1654 uint8_t mode = SCAN_DISABLED; 1655 1656 if (powered) 1657 return hciops_start(index); 1658 1659 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 1660 OCF_WRITE_SCAN_ENABLE, 1, &mode) < 0) 1661 return -errno; 1662 1663 return hciops_stop(index); 1664} 1665 1666static int hciops_connectable(int index) 1667{ 1668 uint8_t mode = SCAN_PAGE; 1669 1670 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 1671 OCF_WRITE_SCAN_ENABLE, 1, &mode) < 0) 1672 return -errno; 1673 1674 return 0; 1675} 1676 1677static int hciops_discoverable(int index) 1678{ 1679 uint8_t mode = (SCAN_PAGE | SCAN_INQUIRY); 1680 1681 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 1682 1, &mode) < 0) 1683 return -errno; 1684 1685 return 0; 1686} 1687 1688static int hciops_set_class(int index, uint32_t class) 1689{ 1690 write_class_of_dev_cp cp; 1691 1692 memcpy(cp.dev_class, &class, 3); 1693 1694 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV, 1695 WRITE_CLASS_OF_DEV_CP_SIZE, &cp) < 0) 1696 return -errno; 1697 1698 return 0; 1699} 1700 1701static int hciops_set_limited_discoverable(int index, uint32_t class, 1702 gboolean limited) 1703{ 1704 int num = (limited ? 2 : 1); 1705 uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e }; 1706 write_current_iac_lap_cp cp; 1707 1708 /* 1709 * 1: giac 1710 * 2: giac + liac 1711 */ 1712 memset(&cp, 0, sizeof(cp)); 1713 cp.num_current_iac = num; 1714 memcpy(&cp.lap, lap, num * 3); 1715 1716 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_CURRENT_IAC_LAP, 1717 (num * 3 + 1), &cp) < 0) 1718 return -errno; 1719 1720 return hciops_set_class(index, class); 1721} 1722 1723static int hciops_start_inquiry(int index, uint8_t length, gboolean periodic) 1724{ 1725 uint8_t lap[3] = { 0x33, 0x8b, 0x9e }; 1726 int err; 1727 1728 if (periodic) { 1729 periodic_inquiry_cp cp; 1730 1731 memset(&cp, 0, sizeof(cp)); 1732 memcpy(&cp.lap, lap, 3); 1733 cp.max_period = htobs(24); 1734 cp.min_period = htobs(16); 1735 cp.length = length; 1736 cp.num_rsp = 0x00; 1737 1738 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 1739 OCF_PERIODIC_INQUIRY, 1740 PERIODIC_INQUIRY_CP_SIZE, &cp); 1741 } else { 1742 inquiry_cp inq_cp; 1743 1744 memset(&inq_cp, 0, sizeof(inq_cp)); 1745 memcpy(&inq_cp.lap, lap, 3); 1746 inq_cp.length = length; 1747 inq_cp.num_rsp = 0x00; 1748 1749 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 1750 OCF_INQUIRY, INQUIRY_CP_SIZE, &inq_cp); 1751 } 1752 1753 if (err < 0) 1754 err = -errno; 1755 1756 return err; 1757} 1758 1759static int hciops_stop_inquiry(int index) 1760{ 1761 struct hci_dev_info di; 1762 int err; 1763 1764 if (hci_devinfo(index, &di) < 0) 1765 return -errno; 1766 1767 if (hci_test_bit(HCI_INQUIRY, &di.flags)) 1768 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 1769 OCF_INQUIRY_CANCEL, 0, 0); 1770 else 1771 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 1772 OCF_EXIT_PERIODIC_INQUIRY, 0, 0); 1773 if (err < 0) 1774 err = -errno; 1775 1776 return err; 1777} 1778 1779static int hciops_start_scanning(int index) 1780{ 1781 if (hci_le_set_scan_parameters(SK(index), 0x01, htobs(0x0010), 1782 htobs(0x0010), 0x00, 0x00) < 0) 1783 return -errno; 1784 1785 if (hci_le_set_scan_enable(SK(index), 0x01, 0x00) < 0) 1786 return -errno; 1787 1788 return 0; 1789} 1790 1791static int hciops_stop_scanning(int index) 1792{ 1793 if (hci_le_set_scan_enable(SK(index), 0x00, 0x00) < 0) 1794 return -errno; 1795 1796 return 0; 1797} 1798 1799static int hciops_resolve_name(int index, bdaddr_t *bdaddr) 1800{ 1801 remote_name_req_cp cp; 1802 1803 memset(&cp, 0, sizeof(cp)); 1804 bacpy(&cp.bdaddr, bdaddr); 1805 cp.pscan_rep_mode = 0x02; 1806 1807 if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_REMOTE_NAME_REQ, 1808 REMOTE_NAME_REQ_CP_SIZE, &cp) < 0) 1809 return -errno; 1810 1811 return 0; 1812} 1813 1814static int hciops_set_name(int index, const char *name) 1815{ 1816 change_local_name_cp cp; 1817 1818 memset(&cp, 0, sizeof(cp)); 1819 strncpy((char *) cp.name, name, sizeof(cp.name)); 1820 1821 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME, 1822 CHANGE_LOCAL_NAME_CP_SIZE, &cp) < 0) 1823 return -errno; 1824 1825 return 0; 1826} 1827 1828static int hciops_read_name(int index) 1829{ 1830 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_READ_LOCAL_NAME, 1831 0, 0) < 0) 1832 return -errno; 1833 1834 return 0; 1835} 1836 1837static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr) 1838{ 1839 remote_name_req_cancel_cp cp; 1840 1841 memset(&cp, 0, sizeof(cp)); 1842 bacpy(&cp.bdaddr, bdaddr); 1843 1844 if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL, 1845 REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp) < 0) 1846 return -errno; 1847 1848 return 0; 1849} 1850 1851static int hciops_fast_connectable(int index, gboolean enable) 1852{ 1853 write_page_activity_cp cp; 1854 uint8_t type; 1855 1856 if (enable) { 1857 type = PAGE_SCAN_TYPE_INTERLACED; 1858 cp.interval = 0x0024; /* 22.5 msec page scan interval */ 1859 } else { 1860 type = PAGE_SCAN_TYPE_STANDARD; /* default */ 1861 cp.interval = 0x0800; /* default 1.28 sec page scan */ 1862 } 1863 1864 cp.window = 0x0012; /* default 11.25 msec page scan window */ 1865 1866 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_PAGE_ACTIVITY, 1867 WRITE_PAGE_ACTIVITY_CP_SIZE, &cp) < 0) 1868 return -errno; 1869 else if (hci_send_cmd(SK(index), OGF_HOST_CTL, 1870 OCF_WRITE_PAGE_SCAN_TYPE, 1, &type) < 0) 1871 return -errno; 1872 1873 return 0; 1874} 1875 1876static int hciops_read_clock(int index, int handle, int which, int timeout, 1877 uint32_t *clock, uint16_t *accuracy) 1878{ 1879 if (hci_read_clock(SK(index), handle, which, clock, accuracy, 1880 timeout) < 0) 1881 return -errno; 1882 1883 return 0; 1884} 1885 1886static int hciops_conn_handle(int index, const bdaddr_t *bdaddr, int *handle) 1887{ 1888 int err; 1889 struct hci_conn_info_req *cr; 1890 1891 cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info)); 1892 bacpy(&cr->bdaddr, bdaddr); 1893 cr->type = ACL_LINK; 1894 1895 if (ioctl(SK(index), HCIGETCONNINFO, (unsigned long) cr) < 0) { 1896 err = -errno; 1897 goto fail; 1898 } 1899 1900 err = 0; 1901 *handle = htobs(cr->conn_info->handle); 1902 1903fail: 1904 g_free(cr); 1905 return err; 1906} 1907 1908static int hciops_write_eir_data(int index, uint8_t *data) 1909{ 1910 write_ext_inquiry_response_cp cp; 1911 1912 memset(&cp, 0, sizeof(cp)); 1913 memcpy(cp.data, data, 240); 1914 1915 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 1916 OCF_WRITE_EXT_INQUIRY_RESPONSE, 1917 WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE, &cp) < 0) 1918 return -errno; 1919 1920 return 0; 1921} 1922 1923static int hciops_read_bdaddr(int index, bdaddr_t *bdaddr) 1924{ 1925 bacpy(bdaddr, &BDADDR(index)); 1926 return 0; 1927} 1928 1929static int hciops_set_event_mask(int index, uint8_t *events, size_t count) 1930{ 1931 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_SET_EVENT_MASK, 1932 count, events) < 0) 1933 return -errno; 1934 1935 return 0; 1936} 1937 1938static int hciops_write_inq_mode(int index, uint8_t mode) 1939{ 1940 write_inquiry_mode_cp cp; 1941 1942 memset(&cp, 0, sizeof(cp)); 1943 cp.mode = mode; 1944 1945 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_INQUIRY_MODE, 1946 WRITE_INQUIRY_MODE_CP_SIZE, &cp) < 0) 1947 return -errno; 1948 1949 return 0; 1950} 1951 1952static int hciops_read_inq_tx_pwr(int index) 1953{ 1954 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 1955 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL, 0, NULL) < 0) 1956 return -errno; 1957 1958 return 0; 1959} 1960 1961static int hciops_block_device(int index, bdaddr_t *bdaddr) 1962{ 1963 if (ioctl(SK(index), HCIBLOCKADDR, bdaddr) < 0) 1964 return -errno; 1965 1966 return 0; 1967} 1968 1969static int hciops_unblock_device(int index, bdaddr_t *bdaddr) 1970{ 1971 if (ioctl(SK(index), HCIUNBLOCKADDR, bdaddr) < 0) 1972 return -errno; 1973 1974 return 0; 1975} 1976 1977static int hciops_get_conn_list(int index, GSList **conns) 1978{ 1979 struct hci_conn_list_req *cl; 1980 struct hci_conn_info *ci; 1981 int err, i; 1982 1983 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); 1984 1985 cl->dev_id = index; 1986 cl->conn_num = 10; 1987 ci = cl->conn_info; 1988 1989 if (ioctl(SK(index), HCIGETCONNLIST, cl) < 0) { 1990 err = -errno; 1991 goto fail; 1992 } 1993 1994 err = 0; 1995 *conns = NULL; 1996 1997 for (i = 0; i < cl->conn_num; i++, ci++) 1998 *conns = g_slist_append(*conns, g_memdup(ci, sizeof(*ci))); 1999 2000fail: 2001 g_free(cl); 2002 return err; 2003} 2004 2005static int hciops_read_local_version(int index, struct hci_version *ver) 2006{ 2007 if (hci_read_local_version(SK(index), ver, HCI_REQ_TIMEOUT) < 0) 2008 return -errno; 2009 2010 return 0; 2011} 2012 2013static int hciops_read_local_features(int index, uint8_t *features) 2014{ 2015 if (hci_read_local_features(SK(index), features, HCI_REQ_TIMEOUT) < 0) 2016 return -errno; 2017 2018 return 0; 2019} 2020 2021static int hciops_read_local_ext_features(int index) 2022{ 2023 uint8_t page_num = 1; 2024 2025 if (hci_send_cmd(SK(index), OGF_INFO_PARAM, 2026 OCF_READ_LOCAL_EXT_FEATURES, 1, &page_num) < 0) 2027 return -errno; 2028 2029 return 0; 2030} 2031 2032static int hciops_init_ssp_mode(int index, uint8_t *mode) 2033{ 2034 write_simple_pairing_mode_cp cp; 2035 2036 if (ioctl(SK(index), HCIGETAUTHINFO, NULL) < 0 && errno == EINVAL) 2037 return 0; 2038 2039 memset(&cp, 0, sizeof(cp)); 2040 cp.mode = 0x01; 2041 2042 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 2043 OCF_WRITE_SIMPLE_PAIRING_MODE, 2044 WRITE_SIMPLE_PAIRING_MODE_CP_SIZE, &cp) < 0) 2045 return -errno; 2046 2047 return 0; 2048} 2049 2050static int hciops_read_link_policy(int index) 2051{ 2052 if (hci_send_cmd(SK(index), OGF_LINK_POLICY, 2053 OCF_READ_DEFAULT_LINK_POLICY, 0, NULL) < 0) 2054 return -errno; 2055 2056 return 0; 2057} 2058 2059static int hciops_disconnect(int index, uint16_t handle) 2060{ 2061 disconnect_cp cp; 2062 2063 memset(&cp, 0, sizeof(cp)); 2064 cp.handle = htobs(handle); 2065 cp.reason = HCI_OE_USER_ENDED_CONNECTION; 2066 2067 if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_DISCONNECT, 2068 DISCONNECT_CP_SIZE, &cp) < 0) 2069 return -errno; 2070 2071 return 0; 2072} 2073 2074static int hciops_remove_bonding(int index, bdaddr_t *bdaddr) 2075{ 2076 delete_stored_link_key_cp cp; 2077 2078 memset(&cp, 0, sizeof(cp)); 2079 bacpy(&cp.bdaddr, bdaddr); 2080 2081 /* Delete the link key from the Bluetooth chip */ 2082 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_DELETE_STORED_LINK_KEY, 2083 DELETE_STORED_LINK_KEY_CP_SIZE, &cp) < 0) 2084 return -errno; 2085 2086 return 0; 2087} 2088 2089static int hciops_request_authentication(int index, uint16_t handle, 2090 uint8_t *status) 2091{ 2092 struct hci_request rq; 2093 auth_requested_cp cp; 2094 evt_cmd_status rp; 2095 2096 memset(&rp, 0, sizeof(rp)); 2097 2098 memset(&cp, 0, sizeof(cp)); 2099 cp.handle = htobs(handle); 2100 2101 memset(&rq, 0, sizeof(rq)); 2102 rq.ogf = OGF_LINK_CTL; 2103 rq.ocf = OCF_AUTH_REQUESTED; 2104 rq.cparam = &cp; 2105 rq.clen = AUTH_REQUESTED_CP_SIZE; 2106 rq.rparam = &rp; 2107 rq.rlen = EVT_CMD_STATUS_SIZE; 2108 rq.event = EVT_CMD_STATUS; 2109 2110 if (hci_send_req(SK(index), &rq, HCI_REQ_TIMEOUT) < 0) 2111 return -errno; 2112 2113 if (status) 2114 *status = rp.status; 2115 2116 return 0; 2117} 2118 2119static int hciops_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin) 2120{ 2121 int err; 2122 2123 if (pin) { 2124 pin_code_reply_cp pr; 2125 size_t len = strlen(pin); 2126 2127 PIN_LENGTH(index) = len; 2128 2129 memset(&pr, 0, sizeof(pr)); 2130 bacpy(&pr.bdaddr, bdaddr); 2131 memcpy(pr.pin_code, pin, len); 2132 pr.pin_len = len; 2133 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2134 OCF_PIN_CODE_REPLY, 2135 PIN_CODE_REPLY_CP_SIZE, &pr); 2136 } else 2137 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2138 OCF_PIN_CODE_NEG_REPLY, 6, bdaddr); 2139 2140 if (err < 0) 2141 err = -errno; 2142 2143 return err; 2144} 2145 2146static int hciops_confirm_reply(int index, bdaddr_t *bdaddr, gboolean success) 2147{ 2148 int err; 2149 user_confirm_reply_cp cp; 2150 2151 memset(&cp, 0, sizeof(cp)); 2152 bacpy(&cp.bdaddr, bdaddr); 2153 2154 if (success) 2155 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2156 OCF_USER_CONFIRM_REPLY, 2157 USER_CONFIRM_REPLY_CP_SIZE, &cp); 2158 else 2159 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2160 OCF_USER_CONFIRM_NEG_REPLY, 2161 USER_CONFIRM_REPLY_CP_SIZE, &cp); 2162 2163 if (err < 0) 2164 err = -errno; 2165 2166 return err; 2167} 2168 2169static int hciops_passkey_reply(int index, bdaddr_t *bdaddr, uint32_t passkey) 2170{ 2171 int err; 2172 2173 if (passkey != INVALID_PASSKEY) { 2174 user_passkey_reply_cp cp; 2175 2176 memset(&cp, 0, sizeof(cp)); 2177 bacpy(&cp.bdaddr, bdaddr); 2178 cp.passkey = passkey; 2179 2180 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2181 OCF_USER_PASSKEY_REPLY, 2182 USER_PASSKEY_REPLY_CP_SIZE, &cp); 2183 } else 2184 err = hci_send_cmd(SK(index), OGF_LINK_CTL, 2185 OCF_USER_PASSKEY_NEG_REPLY, 6, bdaddr); 2186 2187 if (err < 0) 2188 err = -errno; 2189 2190 return err; 2191} 2192 2193static int hciops_get_auth_info(int index, bdaddr_t *bdaddr, uint8_t *auth) 2194{ 2195 struct hci_auth_info_req req; 2196 2197 memset(&req, 0, sizeof(req)); 2198 bacpy(&req.bdaddr, bdaddr); 2199 2200 if (ioctl(SK(index), HCIGETAUTHINFO, (unsigned long) &req) < 0) 2201 return -errno; 2202 2203 if (auth) 2204 *auth = req.type; 2205 2206 return 0; 2207} 2208 2209static int hciops_read_scan_enable(int index) 2210{ 2211 if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_READ_SCAN_ENABLE, 2212 0, NULL) < 0) 2213 return -errno; 2214 2215 return 0; 2216} 2217 2218static int hciops_read_ssp_mode(int index) 2219{ 2220 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 2221 OCF_READ_SIMPLE_PAIRING_MODE, 0, NULL) < 0) 2222 return -errno; 2223 2224 return 0; 2225} 2226 2227static int hciops_write_le_host(int index, uint8_t le, uint8_t simul) 2228{ 2229 write_le_host_supported_cp cp; 2230 2231 memset(&cp, 0, sizeof(cp)); 2232 cp.le = le; 2233 cp.simul = simul; 2234 2235 if (hci_send_cmd(SK(index), OGF_HOST_CTL, 2236 OCF_WRITE_LE_HOST_SUPPORTED, 2237 WRITE_LE_HOST_SUPPORTED_CP_SIZE, &cp) < 0) 2238 return -errno; 2239 2240 return 0; 2241} 2242 2243struct remote_version_req { 2244 int index; 2245 uint16_t handle; 2246}; 2247 2248static gboolean get_remote_version(gpointer user_data) 2249{ 2250 struct remote_version_req *req = user_data; 2251 read_remote_version_cp cp; 2252 2253 memset(&cp, 0, sizeof(cp)); 2254 cp.handle = htobs(req->handle); 2255 2256 hci_send_cmd(SK(req->index), OGF_LINK_CTL, OCF_READ_REMOTE_VERSION, 2257 READ_REMOTE_VERSION_CP_SIZE, &cp); 2258 2259 return FALSE; 2260} 2261 2262static int hciops_get_remote_version(int index, uint16_t handle, 2263 gboolean delayed) 2264{ 2265 struct remote_version_req *req; 2266 2267 req = g_new0(struct remote_version_req, 1); 2268 req->handle = handle; 2269 req->index = index; 2270 2271 if (!delayed) { 2272 get_remote_version(req); 2273 g_free(req); 2274 return 0; 2275 } 2276 2277 g_timeout_add_seconds_full(G_PRIORITY_DEFAULT, 1, get_remote_version, 2278 req, g_free); 2279 2280 return 0; 2281} 2282 2283static struct btd_adapter_ops hci_ops = { 2284 .setup = hciops_setup, 2285 .cleanup = hciops_cleanup, 2286 .start = hciops_start, 2287 .stop = hciops_stop, 2288 .set_powered = hciops_powered, 2289 .set_connectable = hciops_connectable, 2290 .set_discoverable = hciops_discoverable, 2291 .set_limited_discoverable = hciops_set_limited_discoverable, 2292 .start_inquiry = hciops_start_inquiry, 2293 .stop_inquiry = hciops_stop_inquiry, 2294 .start_scanning = hciops_start_scanning, 2295 .stop_scanning = hciops_stop_scanning, 2296 .resolve_name = hciops_resolve_name, 2297 .cancel_resolve_name = hciops_cancel_resolve_name, 2298 .set_name = hciops_set_name, 2299 .read_name = hciops_read_name, 2300 .set_class = hciops_set_class, 2301 .set_fast_connectable = hciops_fast_connectable, 2302 .read_clock = hciops_read_clock, 2303 .get_conn_handle = hciops_conn_handle, 2304 .write_eir_data = hciops_write_eir_data, 2305 .read_bdaddr = hciops_read_bdaddr, 2306 .set_event_mask = hciops_set_event_mask, 2307 .write_inq_mode = hciops_write_inq_mode, 2308 .read_inq_tx_pwr = hciops_read_inq_tx_pwr, 2309 .block_device = hciops_block_device, 2310 .unblock_device = hciops_unblock_device, 2311 .get_conn_list = hciops_get_conn_list, 2312 .read_local_version = hciops_read_local_version, 2313 .read_local_features = hciops_read_local_features, 2314 .read_local_ext_features = hciops_read_local_ext_features, 2315 .init_ssp_mode = hciops_init_ssp_mode, 2316 .read_link_policy = hciops_read_link_policy, 2317 .disconnect = hciops_disconnect, 2318 .remove_bonding = hciops_remove_bonding, 2319 .request_authentication = hciops_request_authentication, 2320 .pincode_reply = hciops_pincode_reply, 2321 .confirm_reply = hciops_confirm_reply, 2322 .passkey_reply = hciops_passkey_reply, 2323 .get_auth_info = hciops_get_auth_info, 2324 .read_scan_enable = hciops_read_scan_enable, 2325 .read_ssp_mode = hciops_read_ssp_mode, 2326 .write_le_host = hciops_write_le_host, 2327 .get_remote_version = hciops_get_remote_version, 2328 .encrypt_link = hciops_encrypt_link, 2329}; 2330 2331static int hciops_init(void) 2332{ 2333 return btd_register_adapter_ops(&hci_ops, FALSE); 2334} 2335 2336static void hciops_exit(void) 2337{ 2338 btd_adapter_cleanup_ops(&hci_ops); 2339} 2340 2341BLUETOOTH_PLUGIN_DEFINE(hciops, VERSION, 2342 BLUETOOTH_PLUGIN_PRIORITY_LOW, hciops_init, hciops_exit) 2343