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