btif/src/btif_dm.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2009-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /************************************************************************************
  20  *
  21  *  Filename:      btif_dm.c
  22  *
  23  *  Description:   Contains Device Management (DM) related functionality
  24  *
  25  *
  26  ***********************************************************************************/
  27
  28 #define LOG_TAG "bt_btif_dm"
  29
  30 #include "btif_dm.h"
  31
  32 #include <assert.h>
  33 #include <pthread.h>
  34 #include <signal.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <sys/types.h>
  39 #include <time.h>
  40 #include <unistd.h>
  41
  42 #include <hardware/bluetooth.h>
  43
  44 #include "bdaddr.h"
  45 #include "bta_gatt_api.h"
  46 #include "btif_api.h"
  47 #include "btif_config.h"
  48 #include "btif_hh.h"
  49 #include "btif_sdp.h"
  50 #include "btif_storage.h"
  51 #include "btif_util.h"
  52 #include "btu.h"
  53 #include "bt_common.h"
  54 #include "bta_gatt_api.h"
  55 #include "device/include/interop.h"
  56 #include "include/stack_config.h"
  57 #include "osi/include/allocator.h"
  58 #include "osi/include/log.h"
  59 #include "osi/include/metrics.h"
  60 #include "osi/include/properties.h"
  61 #include "stack_config.h"
  62 #include "stack/btm/btm_int.h"
  63
  64 /******************************************************************************
  65 **  Constants & Macros
  66 ******************************************************************************/
  67
  68 #define COD_MASK                            0x07FF
  69
  70 #define COD_UNCLASSIFIED ((0x1F) << 8)
  71 #define COD_HID_KEYBOARD                    0x0540
  72 #define COD_HID_POINTING                    0x0580
  73 #define COD_HID_COMBO                       0x05C0
  74 #define COD_HID_MAJOR                       0x0500
  75 #define COD_HID_MASK                        0x0700
  76 #define COD_AV_HEADSETS                     0x0404
  77 #define COD_AV_HANDSFREE                    0x0408
  78 #define COD_AV_HEADPHONES                   0x0418
  79 #define COD_AV_PORTABLE_AUDIO               0x041C
  80 #define COD_AV_HIFI_AUDIO                   0x0428
  81
  82 #define BTIF_DM_DEFAULT_INQ_MAX_RESULTS     0
  83 #define BTIF_DM_DEFAULT_INQ_MAX_DURATION    10
  84 #define BTIF_DM_MAX_SDP_ATTEMPTS_AFTER_PAIRING 2
  85
  86 #define NUM_TIMEOUT_RETRIES                 5
  87
  88 #define PROPERTY_PRODUCT_MODEL "ro.product.model"
  89 #define DEFAULT_LOCAL_NAME_MAX  31
  90 #if (DEFAULT_LOCAL_NAME_MAX > BTM_MAX_LOC_BD_NAME_LEN)
  91     #error "default btif local name size exceeds stack supported length"
  92 #endif
  93
  94 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
  95 #define BTIF_DM_INTERLEAVE_DURATION_BR_ONE    2
  96 #define BTIF_DM_INTERLEAVE_DURATION_LE_ONE    2
  97 #define BTIF_DM_INTERLEAVE_DURATION_BR_TWO    3
  98 #define BTIF_DM_INTERLEAVE_DURATION_LE_TWO    4
  99 #endif
 100
 101 #define MAX_SDP_BL_ENTRIES 3
 102
 103 #define ENCRYPTED_BREDR       2
 104 #define ENCRYPTED_LE          4
 105
 106 typedef struct
 107 {
 108     bt_bond_state_t state;
 109     bt_bdaddr_t static_bdaddr;
 110     BD_ADDR bd_addr;
 111     tBTM_BOND_TYPE bond_type;
 112     UINT8 pin_code_len;
 113     UINT8 is_ssp;
 114     UINT8 auth_req;
 115     UINT8 io_cap;
 116     UINT8 autopair_attempts;
 117     UINT8 timeout_retries;
 118     UINT8 is_local_initiated;
 119     UINT8 sdp_attempts;
 120 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
 121     BOOLEAN is_le_only;
 122     BOOLEAN is_le_nc; /* LE Numeric comparison */
 123     btif_dm_ble_cb_t ble;
 124 #endif
 125 } btif_dm_pairing_cb_t;
 126
 127 typedef struct
 128 {
 129     UINT8       ir[BT_OCTET16_LEN];
 130     UINT8       irk[BT_OCTET16_LEN];
 131     UINT8       dhk[BT_OCTET16_LEN];
 132 }btif_dm_local_key_id_t;
 133
 134 typedef struct
 135 {
 136     BOOLEAN                 is_er_rcvd;
 137     UINT8                   er[BT_OCTET16_LEN];
 138     BOOLEAN                 is_id_keys_rcvd;
 139     btif_dm_local_key_id_t  id_keys;  /* ID kyes */
 140
 141 }btif_dm_local_key_cb_t;
 142
 143 typedef struct
 144 {
 145     BD_ADDR bd_addr;
 146     BD_NAME bd_name;
 147 } btif_dm_remote_name_t;
 148
 149 /* this structure holds optional OOB data for remote device */
 150 typedef struct
 151 {
 152     BD_ADDR  bdaddr;    /* peer bdaddr */
 153     bt_out_of_band_data_t oob_data;
 154 } btif_dm_oob_cb_t;
 155
 156 typedef struct
 157 {
 158     bt_bdaddr_t  bdaddr;
 159     UINT8        transport; /* 0=Unknown, 1=BR/EDR, 2=LE */
 160 } btif_dm_create_bond_cb_t;
 161
 162 typedef struct
 163 {
 164     uint8_t  status;
 165     uint8_t  ctrl_state;
 166     uint64_t tx_time;
 167     uint64_t rx_time;
 168     uint64_t idle_time;
 169     uint64_t energy_used;
 170 } btif_activity_energy_info_cb_t;
 171
 172 typedef struct
 173 {
 174     unsigned int   manufact_id;
 175 }skip_sdp_entry_t;
 176
 177 typedef enum
 178 {
 179     BTIF_DM_FUNC_CREATE_BOND,
 180     BTIF_DM_FUNC_CANCEL_BOND,
 181     BTIF_DM_FUNC_REMOVE_BOND,
 182     BTIF_DM_FUNC_BOND_STATE_CHANGED,
 183 } bt_bond_function_t;
 184
 185 typedef struct
 186 {
 187     bt_bdaddr_t bd_addr;
 188     bt_bond_function_t function;
 189     bt_bond_state_t state;
 190     struct timespec timestamp;
 191 } btif_bond_event_t;
 192
 193 #define BTA_SERVICE_ID_TO_SERVICE_MASK(id)       (1 << (id))
 194
 195 #define MAX_SDP_BL_ENTRIES 3
 196 #define UUID_HUMAN_INTERFACE_DEVICE "00001124-0000-1000-8000-00805f9b34fb"
 197
 198 #define MAX_BTIF_BOND_EVENT_ENTRIES 15
 199
 200 static skip_sdp_entry_t sdp_blacklist[] = {{76}}; //Apple Mouse and Keyboard
 201
 202 /* This flag will be true if HCI_Inquiry is in progress */
 203 static BOOLEAN btif_dm_inquiry_in_progress = FALSE;
 204
 205 /************************************************************************************
 206 **  Static variables
 207 ************************************************************************************/
 208 static char btif_default_local_name[DEFAULT_LOCAL_NAME_MAX+1] = {'\0'};
 209 static uid_set_t* uid_set = NULL;
 210
 211 /* A circular array to keep track of the most recent bond events */
 212 static btif_bond_event_t btif_dm_bond_events[MAX_BTIF_BOND_EVENT_ENTRIES + 1];
 213
 214 static pthread_mutex_t bond_event_lock;
 215
 216 /* |btif_num_bond_events| keeps track of the total number of events and can be
 217    greater than |MAX_BTIF_BOND_EVENT_ENTRIES| */
 218 static size_t btif_num_bond_events = 0;
 219 static size_t btif_events_start_index = 0;
 220 static size_t btif_events_end_index = 0;
 221
 222 /******************************************************************************
 223 **  Static functions
 224 ******************************************************************************/
 225 static btif_dm_pairing_cb_t pairing_cb;
 226 static btif_dm_oob_cb_t     oob_cb;
 227 static void btif_dm_generic_evt(UINT16 event, char* p_param);
 228 static void btif_dm_cb_create_bond(bt_bdaddr_t *bd_addr, tBTA_TRANSPORT transport);
 229 static void btif_dm_cb_hid_remote_name(tBTM_REMOTE_DEV_NAME *p_remote_name);
 230 static void btif_update_remote_properties(BD_ADDR bd_addr, BD_NAME bd_name,
 231                                           DEV_CLASS dev_class, tBT_DEVICE_TYPE dev_type);
 232 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
 233 static btif_dm_local_key_cb_t ble_local_key_cb;
 234 static void btif_dm_ble_key_notif_evt(tBTA_DM_SP_KEY_NOTIF *p_ssp_key_notif);
 235 static void btif_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl);
 236 static void btif_dm_ble_passkey_req_evt(tBTA_DM_PIN_REQ *p_pin_req);
 237 static void btif_dm_ble_key_nc_req_evt(tBTA_DM_SP_KEY_NOTIF *p_notif_req) ;
 238 static void btif_dm_ble_oob_req_evt(tBTA_DM_SP_RMT_OOB *req_oob_type);
 239 #endif
 240
 241 static void bte_scan_filt_param_cfg_evt(UINT8 action_type,
 242                                            tBTA_DM_BLE_PF_AVBL_SPACE avbl_space,
 243                                            tBTA_DM_BLE_REF_VALUE ref_value,
 244                                            tBTA_STATUS status);
 245
 246 static char* btif_get_default_local_name();
 247
 248 static void btif_stats_add_bond_event(const bt_bdaddr_t *bd_addr,
 249                                       bt_bond_function_t function,
 250                                       bt_bond_state_t state);
 251
 252 /******************************************************************************
 253 **  Externs
 254 ******************************************************************************/
 255 extern UINT16 bta_service_id_to_uuid_lkup_tbl [BTA_MAX_SERVICE_ID];
 256 extern bt_status_t btif_hf_execute_service(BOOLEAN b_enable);
 257 extern bt_status_t btif_av_execute_service(BOOLEAN b_enable);
 258 extern bt_status_t btif_av_sink_execute_service(BOOLEAN b_enable);
 259 extern bt_status_t btif_hh_execute_service(BOOLEAN b_enable);
 260 extern bt_status_t btif_hf_client_execute_service(BOOLEAN b_enable);
 261 extern bt_status_t btif_sdp_execute_service(BOOLEAN b_enable);
 262 extern int btif_hh_connect(bt_bdaddr_t *bd_addr);
 263 extern void bta_gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT16 uuid_16);
 264
 265 /******************************************************************************
 266 **  Functions
 267 ******************************************************************************/
 268
 269 static bool is_empty_128bit(uint8_t *data)
 270 {
 271     static const uint8_t zero[16] = { 0 };
 272     return !memcmp(zero, data, sizeof(zero));
 273 }
 274
 275 static void btif_dm_data_copy(uint16_t event, char *dst, char *src)
 276 {
 277     tBTA_DM_SEC *dst_dm_sec = (tBTA_DM_SEC*)dst;
 278     tBTA_DM_SEC *src_dm_sec = (tBTA_DM_SEC*)src;
 279
 280     if (!src_dm_sec)
 281         return;
 282
 283     assert(dst_dm_sec);
 284     maybe_non_aligned_memcpy(dst_dm_sec, src_dm_sec, sizeof(*src_dm_sec));
 285
 286     if (event == BTA_DM_BLE_KEY_EVT)
 287     {
 288         dst_dm_sec->ble_key.p_key_value = osi_malloc(sizeof(tBTM_LE_KEY_VALUE));
 289         assert(src_dm_sec->ble_key.p_key_value);
 290         memcpy(dst_dm_sec->ble_key.p_key_value, src_dm_sec->ble_key.p_key_value, sizeof(tBTM_LE_KEY_VALUE));
 291     }
 292 }
 293
 294 static void btif_dm_data_free(uint16_t event, tBTA_DM_SEC *dm_sec)
 295 {
 296     if (event == BTA_DM_BLE_KEY_EVT)
 297         osi_free_and_reset((void **)&dm_sec->ble_key.p_key_value);
 298 }
 299
 300 void btif_dm_init(uid_set_t* set)
 301 {
 302     uid_set = set;
 303     pthread_mutex_init(&bond_event_lock, NULL);
 304 }
 305
 306 void btif_dm_cleanup(void)
 307 {
 308     if (uid_set) {
 309         uid_set_destroy(uid_set);
 310         uid_set = NULL;
 311     }
 312     pthread_mutex_destroy(&bond_event_lock);
 313 }
 314
 315 bt_status_t btif_in_execute_service_request(tBTA_SERVICE_ID service_id,
 316                                                 BOOLEAN b_enable)
 317 {
 318     BTIF_TRACE_DEBUG("%s service_id: %d", __FUNCTION__, service_id);
 319     /* Check the service_ID and invoke the profile's BT state changed API */
 320     switch (service_id)
 321     {
 322          case BTA_HFP_SERVICE_ID:
 323          case BTA_HSP_SERVICE_ID:
 324          {
 325               btif_hf_execute_service(b_enable);
 326          }break;
 327          case BTA_A2DP_SOURCE_SERVICE_ID:
 328          {
 329               btif_av_execute_service(b_enable);
 330          }break;
 331          case BTA_A2DP_SINK_SERVICE_ID:
 332          {
 333             btif_av_sink_execute_service(b_enable);
 334          }break;
 335          case BTA_HID_SERVICE_ID:
 336          {
 337               btif_hh_execute_service(b_enable);
 338          }break;
 339          case BTA_HFP_HS_SERVICE_ID:
 340          {
 341              btif_hf_client_execute_service(b_enable);
 342          }break;
 343          case BTA_SDP_SERVICE_ID:
 344          {
 345              btif_sdp_execute_service(b_enable);
 346          }break;
 347          default:
 348               BTIF_TRACE_ERROR("%s: Unknown service being enabled", __FUNCTION__);
 349               return BT_STATUS_FAIL;
 350     }
 351     return BT_STATUS_SUCCESS;
 352 }
 353
 354 /*******************************************************************************
 355 **
 356 ** Function         check_eir_remote_name
 357 **
 358 ** Description      Check if remote name is in the EIR data
 359 **
 360 ** Returns          TRUE if remote name found
 361 **                  Populate p_remote_name, if provided and remote name found
 362 **
 363 *******************************************************************************/
 364 static BOOLEAN check_eir_remote_name(tBTA_DM_SEARCH *p_search_data,
 365                             UINT8 *p_remote_name, UINT8 *p_remote_name_len)
 366 {
 367     UINT8 *p_eir_remote_name = NULL;
 368     UINT8 remote_name_len = 0;
 369
 370     /* Check EIR for remote name and services */
 371     if (p_search_data->inq_res.p_eir)
 372     {
 373         p_eir_remote_name = BTM_CheckEirData(p_search_data->inq_res.p_eir,
 374                 BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
 375         if (!p_eir_remote_name)
 376         {
 377             p_eir_remote_name = BTM_CheckEirData(p_search_data->inq_res.p_eir,
 378                     BTM_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
 379         }
 380
 381         if (p_eir_remote_name)
 382         {
 383             if (remote_name_len > BD_NAME_LEN)
 384                 remote_name_len = BD_NAME_LEN;
 385
 386             if (p_remote_name && p_remote_name_len)
 387             {
 388                 memcpy(p_remote_name, p_eir_remote_name, remote_name_len);
 389                 *(p_remote_name + remote_name_len) = 0;
 390                 *p_remote_name_len = remote_name_len;
 391             }
 392
 393             return TRUE;
 394         }
 395     }
 396
 397     return FALSE;
 398
 399 }
 400
 401 /*******************************************************************************
 402 **
 403 ** Function         check_cached_remote_name
 404 **
 405 ** Description      Check if remote name is in the NVRAM cache
 406 **
 407 ** Returns          TRUE if remote name found
 408 **                  Populate p_remote_name, if provided and remote name found
 409 **
 410 *******************************************************************************/
 411 static BOOLEAN check_cached_remote_name(tBTA_DM_SEARCH *p_search_data,
 412                                 UINT8 *p_remote_name, UINT8 *p_remote_name_len)
 413 {
 414     bt_bdname_t bdname;
 415     bt_bdaddr_t remote_bdaddr;
 416     bt_property_t prop_name;
 417
 418     /* check if we already have it in our btif_storage cache */
 419     bdcpy(remote_bdaddr.address, p_search_data->inq_res.bd_addr);
 420     BTIF_STORAGE_FILL_PROPERTY(&prop_name, BT_PROPERTY_BDNAME,
 421                                sizeof(bt_bdname_t), &bdname);
 422     if (btif_storage_get_remote_device_property(
 423         &remote_bdaddr, &prop_name) == BT_STATUS_SUCCESS)
 424     {
 425         if (p_remote_name && p_remote_name_len)
 426         {
 427             strcpy((char *)p_remote_name, (char *)bdname.name);
 428             *p_remote_name_len = strlen((char *)p_remote_name);
 429         }
 430         return TRUE;
 431     }
 432
 433     return FALSE;
 434 }
 435
 436 static uint32_t get_cod(const bt_bdaddr_t *remote_bdaddr) {
 437     uint32_t    remote_cod;
 438     bt_property_t prop_name;
 439
 440     /* check if we already have it in our btif_storage cache */
 441     BTIF_STORAGE_FILL_PROPERTY(&prop_name, BT_PROPERTY_CLASS_OF_DEVICE,
 442                                sizeof(uint32_t), &remote_cod);
 443     if (btif_storage_get_remote_device_property((bt_bdaddr_t *)remote_bdaddr, &prop_name) == BT_STATUS_SUCCESS)
 444     {
 445         LOG_INFO(LOG_TAG, "%s remote_cod = 0x%08x", __func__, remote_cod);
 446         return remote_cod & COD_MASK;
 447     }
 448
 449     return 0;
 450 }
 451
 452 BOOLEAN check_cod(const bt_bdaddr_t *remote_bdaddr, uint32_t cod)
 453 {
 454     return get_cod(remote_bdaddr) == cod;
 455 }
 456
 457 BOOLEAN check_cod_hid(const bt_bdaddr_t *remote_bdaddr)
 458 {
 459     return (get_cod(remote_bdaddr) & COD_HID_MASK) == COD_HID_MAJOR;
 460 }
 461
 462 BOOLEAN check_hid_le(const bt_bdaddr_t *remote_bdaddr)
 463 {
 464     uint32_t    remote_dev_type;
 465     bt_property_t prop_name;
 466
 467     /* check if we already have it in our btif_storage cache */
 468     BTIF_STORAGE_FILL_PROPERTY(&prop_name,BT_PROPERTY_TYPE_OF_DEVICE,
 469                                sizeof(uint32_t), &remote_dev_type);
 470     if (btif_storage_get_remote_device_property((bt_bdaddr_t *)remote_bdaddr,
 471                                 &prop_name) == BT_STATUS_SUCCESS)
 472     {
 473         if (remote_dev_type == BT_DEVICE_DEVTYPE_BLE)
 474         {
 475             bdstr_t bdstr;
 476             bdaddr_to_string(remote_bdaddr, bdstr, sizeof(bdstr));
 477             if(btif_config_exist(bdstr, "HidAppId"))
 478                 return TRUE;
 479         }
 480     }
 481     return FALSE;
 482 }
 483
 484 /*****************************************************************************
 485 **
 486 ** Function        check_sdp_bl
 487 **
 488 ** Description     Checks if a given device is blacklisted to skip sdp
 489 **
 490 ** Parameters     skip_sdp_entry
 491 **
 492 ** Returns         TRUE if the device is present in blacklist, else FALSE
 493 **
 494 *******************************************************************************/
 495 BOOLEAN check_sdp_bl(const bt_bdaddr_t *remote_bdaddr)
 496 {
 497     UINT16 manufacturer = 0;
 498     UINT8 lmp_ver = 0;
 499     UINT16 lmp_subver = 0;
 500     bt_property_t prop_name;
 501     bt_remote_version_t info;
 502
 503     if (remote_bdaddr == NULL)
 504         return FALSE;
 505
 506 /* fetch additional info about remote device used in iop query */
 507     BTM_ReadRemoteVersion(*(BD_ADDR*)remote_bdaddr, &lmp_ver,
 508                     &manufacturer, &lmp_subver);
 509
 510  /* if not available yet, try fetching from config database */
 511     BTIF_STORAGE_FILL_PROPERTY(&prop_name, BT_PROPERTY_REMOTE_VERSION_INFO,
 512                             sizeof(bt_remote_version_t), &info);
 513
 514     if (btif_storage_get_remote_device_property((bt_bdaddr_t *)remote_bdaddr,
 515                                               &prop_name) != BT_STATUS_SUCCESS)
 516     {
 517
 518         return FALSE;
 519     }
 520     manufacturer = info.manufacturer;
 521
 522     for (int i = 0; i < MAX_SDP_BL_ENTRIES; i++)
 523     {
 524         if (manufacturer == sdp_blacklist[i].manufact_id)
 525             return TRUE;
 526     }
 527     return FALSE;
 528 }
 529
 530 static void bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr, bt_bond_state_t state)
 531 {
 532
 533     btif_stats_add_bond_event(bd_addr, BTIF_DM_FUNC_BOND_STATE_CHANGED, state);
 534
 535     // Send bonding state only once - based on outgoing/incoming we may receive duplicates
 536     if ((pairing_cb.state == state) && (state == BT_BOND_STATE_BONDING))
 537     {
 538         // Cross key pairing so send callback for static address
 539         if (!bdaddr_is_empty(&pairing_cb.static_bdaddr))
 540         {
 541             HAL_CBACK(bt_hal_cbacks, bond_state_changed_cb, status, bd_addr, state);
 542         }
 543         return;
 544     }
 545
 546     if (pairing_cb.bond_type == BOND_TYPE_TEMPORARY)
 547         state = BT_BOND_STATE_NONE;
 548
 549     BTIF_TRACE_DEBUG("%s: state=%d, prev_state=%d, sdp_attempts = %d", __func__,
 550                       state, pairing_cb.state, pairing_cb.sdp_attempts);
 551
 552     HAL_CBACK(bt_hal_cbacks, bond_state_changed_cb, status, bd_addr, state);
 553
 554     if (state == BT_BOND_STATE_BONDING)
 555     {
 556         pairing_cb.state = state;
 557         bdcpy(pairing_cb.bd_addr, bd_addr->address);
 558     } else {
 559         if (!pairing_cb.sdp_attempts)
 560             memset(&pairing_cb, 0, sizeof(pairing_cb));
 561         else
 562             BTIF_TRACE_DEBUG("%s: BR-EDR service discovery active", __func__);
 563     }
 564 }
 565
 566 /* store remote version in bt config to always have access
 567    to it post pairing*/
 568 static void btif_update_remote_version_property(bt_bdaddr_t *p_bd)
 569 {
 570     bt_property_t property;
 571     UINT8 lmp_ver = 0;
 572     UINT16 lmp_subver = 0;
 573     UINT16 mfct_set = 0;
 574     tBTM_STATUS btm_status;
 575     bt_remote_version_t info;
 576     bt_status_t status;
 577     bdstr_t bdstr;
 578
 579     btm_status = BTM_ReadRemoteVersion(*(BD_ADDR*)p_bd, &lmp_ver,
 580                           &mfct_set, &lmp_subver);
 581
 582     LOG_DEBUG(LOG_TAG, "remote version info [%s]: %x, %x, %x", bdaddr_to_string(p_bd, bdstr, sizeof(bdstr)),
 583                lmp_ver, mfct_set, lmp_subver);
 584
 585     if (btm_status == BTM_SUCCESS)
 586     {
 587         // Always update cache to ensure we have availability whenever BTM API is not populated
 588         info.manufacturer = mfct_set;
 589         info.sub_ver = lmp_subver;
 590         info.version = lmp_ver;
 591         BTIF_STORAGE_FILL_PROPERTY(&property,
 592                             BT_PROPERTY_REMOTE_VERSION_INFO, sizeof(bt_remote_version_t),
 593                             &info);
 594         status = btif_storage_set_remote_device_property(p_bd, &property);
 595         ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote version", status);
 596     }
 597 }
 598
 599 static void btif_update_remote_properties(BD_ADDR bd_addr, BD_NAME bd_name,
 600                                           DEV_CLASS dev_class, tBT_DEVICE_TYPE device_type)
 601 {
 602     int num_properties = 0;
 603     bt_property_t properties[3];
 604     bt_bdaddr_t bdaddr;
 605     bt_status_t status;
 606     UINT32 cod;
 607     bt_device_type_t dev_type;
 608
 609     memset(properties, 0, sizeof(properties));
 610     bdcpy(bdaddr.address, bd_addr);
 611
 612     /* remote name */
 613     if (strlen((const char *) bd_name))
 614     {
 615         BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
 616                             BT_PROPERTY_BDNAME, strlen((char *)bd_name), bd_name);
 617         status = btif_storage_set_remote_device_property(&bdaddr, &properties[num_properties]);
 618         ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device name", status);
 619         num_properties++;
 620     }
 621
 622     /* class of device */
 623     cod = devclass2uint(dev_class);
 624     BTIF_TRACE_DEBUG("%s cod is 0x%06x", __func__, cod);
 625     if ( cod == 0) {
 626        /* Try to retrieve cod from storage */
 627         BTIF_TRACE_DEBUG("%s cod is 0, checking cod from storage", __func__);
 628         BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
 629             BT_PROPERTY_CLASS_OF_DEVICE, sizeof(cod), &cod);
 630         status = btif_storage_get_remote_device_property(&bdaddr, &properties[num_properties]);
 631         BTIF_TRACE_DEBUG("%s cod retrieved from storage is 0x%06x", __func__, cod);
 632         if ( cod == 0) {
 633             BTIF_TRACE_DEBUG("%s cod is again 0, set as unclassified", __func__);
 634             cod = COD_UNCLASSIFIED;
 635         }
 636     }
 637
 638     BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
 639                         BT_PROPERTY_CLASS_OF_DEVICE, sizeof(cod), &cod);
 640     status = btif_storage_set_remote_device_property(&bdaddr, &properties[num_properties]);
 641     ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device class", status);
 642     num_properties++;
 643
 644     /* device type */
 645     bt_property_t prop_name;
 646     uint8_t remote_dev_type;
 647     BTIF_STORAGE_FILL_PROPERTY(&prop_name, BT_PROPERTY_TYPE_OF_DEVICE,
 648                                 sizeof(uint8_t), &remote_dev_type);
 649     if (btif_storage_get_remote_device_property(&bdaddr, &prop_name) == BT_STATUS_SUCCESS)
 650          dev_type = remote_dev_type | device_type;
 651     else
 652          dev_type = device_type;
 653
 654     BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
 655                         BT_PROPERTY_TYPE_OF_DEVICE, sizeof(dev_type), &dev_type);
 656     status = btif_storage_set_remote_device_property(&bdaddr, &properties[num_properties]);
 657     ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device type", status);
 658     num_properties++;
 659
 660     HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
 661                      status, &bdaddr, num_properties, properties);
 662 }
 663
 664 /*******************************************************************************
 665 **
 666 ** Function         btif_dm_cb_hid_remote_name
 667 **
 668 ** Description      Remote name callback for HID device. Called in btif context
 669 **                  Special handling for HID devices
 670 **
 671 ** Returns          void
 672 **
 673 *******************************************************************************/
 674 static void btif_dm_cb_hid_remote_name(tBTM_REMOTE_DEV_NAME *p_remote_name)
 675 {
 676     BTIF_TRACE_DEBUG("%s: status=%d pairing_cb.state=%d", __FUNCTION__, p_remote_name->status, pairing_cb.state);
 677     if (pairing_cb.state == BT_BOND_STATE_BONDING)
 678     {
 679         bt_bdaddr_t remote_bd;
 680
 681         bdcpy(remote_bd.address, pairing_cb.bd_addr);
 682
 683         if (p_remote_name->status == BTM_SUCCESS)
 684         {
 685             bond_state_changed(BT_STATUS_SUCCESS, &remote_bd, BT_BOND_STATE_BONDED);
 686         }
 687         else
 688             bond_state_changed(BT_STATUS_FAIL, &remote_bd, BT_BOND_STATE_NONE);
 689     }
 690 }
 691
 692 /*******************************************************************************
 693 **
 694 ** Function         btif_dm_cb_create_bond
 695 **
 696 ** Description      Create bond initiated from the BTIF thread context
 697 **                  Special handling for HID devices
 698 **
 699 ** Returns          void
 700 **
 701 *******************************************************************************/
 702 static void btif_dm_cb_create_bond(bt_bdaddr_t *bd_addr, tBTA_TRANSPORT transport)
 703 {
 704     BOOLEAN is_hid = check_cod(bd_addr, COD_HID_POINTING);
 705     bond_state_changed(BT_STATUS_SUCCESS, bd_addr, BT_BOND_STATE_BONDING);
 706
 707 #if BLE_INCLUDED == TRUE
 708     int device_type;
 709     int addr_type;
 710     bdstr_t bdstr;
 711     bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr));
 712     if (transport == BT_TRANSPORT_LE)
 713     {
 714         if (!btif_config_get_int((char const *)&bdstr,"DevType", &device_type))
 715         {
 716             btif_config_set_int(bdstr, "DevType", BT_DEVICE_TYPE_BLE);
 717         }
 718         if (btif_storage_get_remote_addr_type(bd_addr, &addr_type) != BT_STATUS_SUCCESS)
 719         {
 720             btif_storage_set_remote_addr_type(bd_addr, BLE_ADDR_PUBLIC);
 721         }
 722     }
 723     if((btif_config_get_int((char const *)&bdstr,"DevType", &device_type) &&
 724        (btif_storage_get_remote_addr_type(bd_addr, &addr_type) == BT_STATUS_SUCCESS) &&
 725        (device_type & BT_DEVICE_TYPE_BLE) == BT_DEVICE_TYPE_BLE) || (transport == BT_TRANSPORT_LE))
 726     {
 727         BTA_DmAddBleDevice(bd_addr->address, addr_type, device_type);
 728     }
 729 #endif
 730
 731 #if BLE_INCLUDED == TRUE
 732     if(is_hid && (device_type & BT_DEVICE_TYPE_BLE) == 0)
 733 #else
 734     if(is_hid)
 735 #endif
 736     {
 737         int status;
 738         status = btif_hh_connect(bd_addr);
 739         if(status != BT_STATUS_SUCCESS)
 740             bond_state_changed(status, bd_addr, BT_BOND_STATE_NONE);
 741     }
 742     else
 743     {
 744         BTA_DmBondByTransport((UINT8 *)bd_addr->address, transport);
 745     }
 746     /*  Track  originator of bond creation  */
 747     pairing_cb.is_local_initiated = TRUE;
 748
 749 }
 750
 751 /*******************************************************************************
 752 **
 753 ** Function         btif_dm_cb_remove_bond
 754 **
 755 ** Description      remove bond initiated from the BTIF thread context
 756 **                  Special handling for HID devices
 757 **
 758 ** Returns          void
 759 **
 760 *******************************************************************************/
 761 void btif_dm_cb_remove_bond(bt_bdaddr_t *bd_addr)
 762 {
 763      /*special handling for HID devices */
 764      /*  VUP needs to be sent if its a HID Device. The HID HOST module will check if there
 765      is a valid hid connection with this bd_addr. If yes VUP will be issued.*/
 766 #if (defined(BTA_HH_INCLUDED) && (BTA_HH_INCLUDED == TRUE))
 767     if (btif_hh_virtual_unplug(bd_addr) != BT_STATUS_SUCCESS)
 768 #endif
 769     {
 770          BTIF_TRACE_DEBUG("%s: Removing HH device", __func__);
 771          BTA_DmRemoveDevice((UINT8 *)bd_addr->address);
 772     }
 773 }
 774
 775 /*******************************************************************************
 776 **
 777 ** Function         btif_dm_get_connection_state
 778 **
 779 ** Description      Returns whether the remote device is currently connected
 780 **                  and whether encryption is active for the connection
 781 **
 782 ** Returns          0 if not connected; 1 if connected and > 1 if connection is
 783 **                  encrypted
 784 **
 785 *******************************************************************************/
 786 uint16_t btif_dm_get_connection_state(const bt_bdaddr_t *bd_addr)
 787 {
 788     uint8_t *bda = (uint8_t*)bd_addr->address;
 789     uint16_t rc = BTA_DmGetConnectionState(bda);
 790
 791     if (rc != 0)
 792     {
 793         uint8_t flags = 0;
 794
 795         BTM_GetSecurityFlagsByTransport(bda, &flags, BT_TRANSPORT_BR_EDR);
 796         BTIF_TRACE_DEBUG("%s: security flags (BR/EDR)=0x%02x", __FUNCTION__, flags);
 797         if (flags & BTM_SEC_FLAG_ENCRYPTED)
 798             rc |= ENCRYPTED_BREDR;
 799
 800         BTM_GetSecurityFlagsByTransport(bda, &flags, BT_TRANSPORT_LE);
 801         BTIF_TRACE_DEBUG("%s: security flags (LE)=0x%02x", __FUNCTION__, flags);
 802         if (flags & BTM_SEC_FLAG_ENCRYPTED)
 803             rc |= ENCRYPTED_LE;
 804     }
 805
 806     return rc;
 807 }
 808
 809 /*******************************************************************************
 810 **
 811 ** Function         search_devices_copy_cb
 812 **
 813 ** Description      Deep copy callback for search devices event
 814 **
 815 ** Returns          void
 816 **
 817 *******************************************************************************/
 818 static void search_devices_copy_cb(UINT16 event, char *p_dest, char *p_src)
 819 {
 820     tBTA_DM_SEARCH *p_dest_data =  (tBTA_DM_SEARCH *) p_dest;
 821     tBTA_DM_SEARCH *p_src_data =  (tBTA_DM_SEARCH *) p_src;
 822
 823     if (!p_src)
 824         return;
 825
 826     BTIF_TRACE_DEBUG("%s: event=%s", __FUNCTION__, dump_dm_search_event(event));
 827     maybe_non_aligned_memcpy(p_dest_data, p_src_data, sizeof(*p_src_data));
 828     switch (event)
 829     {
 830         case BTA_DM_INQ_RES_EVT:
 831         {
 832             if (p_src_data->inq_res.p_eir)
 833             {
 834                 p_dest_data->inq_res.p_eir = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
 835                 memcpy(p_dest_data->inq_res.p_eir, p_src_data->inq_res.p_eir, HCI_EXT_INQ_RESPONSE_LEN);
 836             }
 837         }
 838         break;
 839
 840         case BTA_DM_DISC_RES_EVT:
 841         {
 842             if (p_src_data->disc_res.raw_data_size && p_src_data->disc_res.p_raw_data)
 843             {
 844                 p_dest_data->disc_res.p_raw_data = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
 845                 memcpy(p_dest_data->disc_res.p_raw_data,
 846                     p_src_data->disc_res.p_raw_data, p_src_data->disc_res.raw_data_size);
 847             }
 848         }
 849         break;
 850     }
 851 }
 852
 853 static void search_services_copy_cb(UINT16 event, char *p_dest, char *p_src)
 854 {
 855     tBTA_DM_SEARCH *p_dest_data =  (tBTA_DM_SEARCH *) p_dest;
 856     tBTA_DM_SEARCH *p_src_data =  (tBTA_DM_SEARCH *) p_src;
 857
 858     if (!p_src)
 859         return;
 860     maybe_non_aligned_memcpy(p_dest_data, p_src_data, sizeof(*p_src_data));
 861     switch (event)
 862     {
 863          case BTA_DM_DISC_RES_EVT:
 864          {
 865               if (p_src_data->disc_res.result == BTA_SUCCESS)
 866               {
 867                   if (p_src_data->disc_res.num_uuids > 0)
 868                   {
 869                        p_dest_data->disc_res.p_uuid_list =
 870                                                         (UINT8*)(p_dest + sizeof(tBTA_DM_SEARCH));
 871                        memcpy(p_dest_data->disc_res.p_uuid_list, p_src_data->disc_res.p_uuid_list,
 872                               p_src_data->disc_res.num_uuids*MAX_UUID_SIZE);
 873                        osi_free_and_reset((void **)&p_src_data->disc_res.p_uuid_list);
 874                   }
 875                   osi_free_and_reset((void **)&p_src_data->disc_res.p_raw_data);
 876               }
 877          } break;
 878     }
 879 }
 880 /******************************************************************************
 881 **
 882 **  BTIF DM callback events
 883 **
 884 *****************************************************************************/
 885
 886 /*******************************************************************************
 887 **
 888 ** Function         btif_dm_pin_req_evt
 889 **
 890 ** Description      Executes pin request event in btif context
 891 **
 892 ** Returns          void
 893 **
 894 *******************************************************************************/
 895 static void btif_dm_pin_req_evt(tBTA_DM_PIN_REQ *p_pin_req)
 896 {
 897     bt_bdaddr_t bd_addr;
 898     bt_bdname_t bd_name;
 899     UINT32 cod;
 900     bt_pin_code_t pin_code;
 901     int dev_type;
 902
 903     /* Remote properties update */
 904     if (!btif_get_device_type(p_pin_req->bd_addr, &dev_type))
 905     {
 906         dev_type = BT_DEVICE_TYPE_BREDR;
 907     }
 908     btif_update_remote_properties(p_pin_req->bd_addr, p_pin_req->bd_name,
 909                                   p_pin_req->dev_class, (tBT_DEVICE_TYPE) dev_type);
 910
 911     bdcpy(bd_addr.address, p_pin_req->bd_addr);
 912     memcpy(bd_name.name, p_pin_req->bd_name, BD_NAME_LEN);
 913
 914     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
 915
 916     cod = devclass2uint(p_pin_req->dev_class);
 917
 918     if (cod == 0) {
 919         BTIF_TRACE_DEBUG("%s cod is 0, set as unclassified", __func__);
 920         cod = COD_UNCLASSIFIED;
 921     }
 922
 923     /* check for auto pair possiblity only if bond was initiated by local device */
 924     if (pairing_cb.is_local_initiated && (p_pin_req->min_16_digit == FALSE))
 925     {
 926         if (check_cod(&bd_addr, COD_AV_HEADSETS) ||
 927             check_cod(&bd_addr, COD_AV_HANDSFREE) ||
 928             check_cod(&bd_addr, COD_AV_HEADPHONES) ||
 929             check_cod(&bd_addr, COD_AV_PORTABLE_AUDIO) ||
 930             check_cod(&bd_addr, COD_AV_HIFI_AUDIO) ||
 931             check_cod(&bd_addr, COD_HID_POINTING))
 932         {
 933             /*  Check if this device can be auto paired  */
 934             if (!interop_match_addr(INTEROP_DISABLE_AUTO_PAIRING, &bd_addr) &&
 935                 !interop_match_name(INTEROP_DISABLE_AUTO_PAIRING, (const char *)bd_name.name) &&
 936                 (pairing_cb.autopair_attempts == 0))
 937             {
 938                 BTIF_TRACE_DEBUG("%s() Attempting auto pair", __FUNCTION__);
 939                 pin_code.pin[0] = 0x30;
 940                 pin_code.pin[1] = 0x30;
 941                 pin_code.pin[2] = 0x30;
 942                 pin_code.pin[3] = 0x30;
 943
 944                 pairing_cb.autopair_attempts++;
 945                 BTA_DmPinReply( (UINT8*)bd_addr.address, TRUE, 4, pin_code.pin);
 946                 return;
 947             }
 948         }
 949         else if (check_cod(&bd_addr, COD_HID_KEYBOARD) ||
 950                  check_cod(&bd_addr, COD_HID_COMBO))
 951         {
 952             if ((interop_match_addr(INTEROP_KEYBOARD_REQUIRES_FIXED_PIN, &bd_addr) == TRUE) &&
 953                 (pairing_cb.autopair_attempts == 0))
 954             {
 955                 BTIF_TRACE_DEBUG("%s() Attempting auto pair", __FUNCTION__);
 956                 pin_code.pin[0] = 0x30;
 957                 pin_code.pin[1] = 0x30;
 958                 pin_code.pin[2] = 0x30;
 959                 pin_code.pin[3] = 0x30;
 960
 961                 pairing_cb.autopair_attempts++;
 962                 BTA_DmPinReply( (UINT8*)bd_addr.address, TRUE, 4, pin_code.pin);
 963                 return;
 964             }
 965         }
 966     }
 967     HAL_CBACK(bt_hal_cbacks, pin_request_cb,
 968                      &bd_addr, &bd_name, cod, p_pin_req->min_16_digit);
 969 }
 970
 971 /*******************************************************************************
 972 **
 973 ** Function         btif_dm_ssp_cfm_req_evt
 974 **
 975 ** Description      Executes SSP confirm request event in btif context
 976 **
 977 ** Returns          void
 978 **
 979 *******************************************************************************/
 980 static void btif_dm_ssp_cfm_req_evt(tBTA_DM_SP_CFM_REQ *p_ssp_cfm_req)
 981 {
 982     bt_bdaddr_t bd_addr;
 983     bt_bdname_t bd_name;
 984     UINT32 cod;
 985     BOOLEAN is_incoming = !(pairing_cb.state == BT_BOND_STATE_BONDING);
 986     int dev_type;
 987
 988     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
 989
 990     /* Remote properties update */
 991     if (!btif_get_device_type(p_ssp_cfm_req->bd_addr, &dev_type))
 992     {
 993         dev_type = BT_DEVICE_TYPE_BREDR;
 994     }
 995     btif_update_remote_properties(p_ssp_cfm_req->bd_addr, p_ssp_cfm_req->bd_name,
 996                                   p_ssp_cfm_req->dev_class, (tBT_DEVICE_TYPE) dev_type);
 997
 998     bdcpy(bd_addr.address, p_ssp_cfm_req->bd_addr);
 999     memcpy(bd_name.name, p_ssp_cfm_req->bd_name, BD_NAME_LEN);
1000
1001     /* Set the pairing_cb based on the local & remote authentication requirements */
1002     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
1003
1004     /* if just_works and bonding bit is not set treat this as temporary */
1005     if (p_ssp_cfm_req->just_works && !(p_ssp_cfm_req->loc_auth_req & BTM_AUTH_BONDS) &&
1006         !(p_ssp_cfm_req->rmt_auth_req & BTM_AUTH_BONDS) &&
1007         !(check_cod((bt_bdaddr_t*)&p_ssp_cfm_req->bd_addr, COD_HID_POINTING)))
1008         pairing_cb.bond_type = BOND_TYPE_TEMPORARY;
1009     else
1010         pairing_cb.bond_type = BOND_TYPE_PERSISTENT;
1011
1012     btm_set_bond_type_dev(p_ssp_cfm_req->bd_addr, pairing_cb.bond_type);
1013
1014     pairing_cb.is_ssp = TRUE;
1015
1016     /* If JustWorks auto-accept */
1017     if (p_ssp_cfm_req->just_works)
1018     {
1019         /* Pairing consent for JustWorks needed if:
1020          * 1. Incoming (non-temporary) pairing is detected AND
1021          * 2. local IO capabilities are DisplayYesNo AND
1022          * 3. remote IO capabiltiies are DisplayOnly or NoInputNoOutput;
1023          */
1024         if (is_incoming && pairing_cb.bond_type != BOND_TYPE_TEMPORARY &&
1025                ((p_ssp_cfm_req->loc_io_caps == HCI_IO_CAP_DISPLAY_YESNO) &&
1026                 (p_ssp_cfm_req->rmt_io_caps == HCI_IO_CAP_DISPLAY_ONLY ||
1027                  p_ssp_cfm_req->rmt_io_caps == HCI_IO_CAP_NO_IO)))
1028         {
1029             BTIF_TRACE_EVENT("%s: User consent needed for incoming pairing request. loc_io_caps: %d, rmt_io_caps: %d",
1030                 __FUNCTION__, p_ssp_cfm_req->loc_io_caps, p_ssp_cfm_req->rmt_io_caps);
1031         }
1032         else
1033         {
1034             BTIF_TRACE_EVENT("%s: Auto-accept JustWorks pairing", __FUNCTION__);
1035             btif_dm_ssp_reply(&bd_addr, BT_SSP_VARIANT_CONSENT, TRUE, 0);
1036             return;
1037         }
1038     }
1039
1040     cod = devclass2uint(p_ssp_cfm_req->dev_class);
1041
1042     if (cod == 0) {
1043         LOG_DEBUG(LOG_TAG, "%s cod is 0, set as unclassified", __func__);
1044         cod = COD_UNCLASSIFIED;
1045     }
1046
1047     pairing_cb.sdp_attempts = 0;
1048     HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, &bd_name, cod,
1049                      (p_ssp_cfm_req->just_works ? BT_SSP_VARIANT_CONSENT : BT_SSP_VARIANT_PASSKEY_CONFIRMATION),
1050                      p_ssp_cfm_req->num_val);
1051 }
1052
1053 static void btif_dm_ssp_key_notif_evt(tBTA_DM_SP_KEY_NOTIF *p_ssp_key_notif)
1054 {
1055     bt_bdaddr_t bd_addr;
1056     bt_bdname_t bd_name;
1057     UINT32 cod;
1058     int dev_type;
1059
1060     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
1061
1062     /* Remote properties update */
1063     if (!btif_get_device_type(p_ssp_key_notif->bd_addr, &dev_type))
1064     {
1065         dev_type = BT_DEVICE_TYPE_BREDR;
1066     }
1067     btif_update_remote_properties(p_ssp_key_notif->bd_addr, p_ssp_key_notif->bd_name,
1068                                   p_ssp_key_notif->dev_class, (tBT_DEVICE_TYPE) dev_type);
1069
1070     bdcpy(bd_addr.address, p_ssp_key_notif->bd_addr);
1071     memcpy(bd_name.name, p_ssp_key_notif->bd_name, BD_NAME_LEN);
1072
1073     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
1074     pairing_cb.is_ssp = TRUE;
1075     cod = devclass2uint(p_ssp_key_notif->dev_class);
1076
1077     if (cod == 0) {
1078         LOG_DEBUG(LOG_TAG, "%s cod is 0, set as unclassified", __func__);
1079         cod = COD_UNCLASSIFIED;
1080     }
1081
1082     HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, &bd_name,
1083                      cod, BT_SSP_VARIANT_PASSKEY_NOTIFICATION,
1084                      p_ssp_key_notif->passkey);
1085 }
1086 /*******************************************************************************
1087 **
1088 ** Function         btif_dm_auth_cmpl_evt
1089 **
1090 ** Description      Executes authentication complete event in btif context
1091 **
1092 ** Returns          void
1093 **
1094 *******************************************************************************/
1095 static void btif_dm_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
1096 {
1097     /* Save link key, if not temporary */
1098     bt_bdaddr_t bd_addr;
1099     bt_status_t status = BT_STATUS_FAIL;
1100     bt_bond_state_t state = BT_BOND_STATE_NONE;
1101     BOOLEAN skip_sdp = FALSE;
1102
1103     BTIF_TRACE_DEBUG("%s: bond state=%d", __func__, pairing_cb.state);
1104
1105     bdcpy(bd_addr.address, p_auth_cmpl->bd_addr);
1106     if ( (p_auth_cmpl->success == TRUE) && (p_auth_cmpl->key_present) )
1107     {
1108         if ((p_auth_cmpl->key_type < HCI_LKEY_TYPE_DEBUG_COMB) ||
1109             (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB) ||
1110             (p_auth_cmpl->key_type == HCI_LKEY_TYPE_CHANGED_COMB) ||
1111             (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB_P_256) ||
1112             pairing_cb.bond_type == BOND_TYPE_PERSISTENT)
1113         {
1114             bt_status_t ret;
1115             BTIF_TRACE_DEBUG("%s: Storing link key. key_type=0x%x, bond_type=%d",
1116                 __FUNCTION__, p_auth_cmpl->key_type, pairing_cb.bond_type);
1117             ret = btif_storage_add_bonded_device(&bd_addr,
1118                                 p_auth_cmpl->key, p_auth_cmpl->key_type,
1119                                 pairing_cb.pin_code_len);
1120             ASSERTC(ret == BT_STATUS_SUCCESS, "storing link key failed", ret);
1121         }
1122         else
1123         {
1124             BTIF_TRACE_DEBUG("%s: Temporary key. Not storing. key_type=0x%x, bond_type=%d",
1125                 __FUNCTION__, p_auth_cmpl->key_type, pairing_cb.bond_type);
1126             if(pairing_cb.bond_type == BOND_TYPE_TEMPORARY)
1127             {
1128                 BTIF_TRACE_DEBUG("%s: sending BT_BOND_STATE_NONE for Temp pairing",
1129                         __FUNCTION__);
1130                 btif_storage_remove_bonded_device(&bd_addr);
1131                 bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_NONE);
1132                 return;
1133             }
1134         }
1135     }
1136
1137     // We could have received a new link key without going through the pairing flow.
1138     // If so, we don't want to perform SDP or any other operations on the authenticated
1139     // device.
1140     if (bdcmp(p_auth_cmpl->bd_addr, pairing_cb.bd_addr) != 0) {
1141       char address[32];
1142       bt_bdaddr_t bt_bdaddr;
1143
1144       memcpy(bt_bdaddr.address, p_auth_cmpl->bd_addr,
1145              sizeof(bt_bdaddr.address));
1146       bdaddr_to_string(&bt_bdaddr, address, sizeof(address));
1147       LOG_INFO(LOG_TAG, "%s skipping SDP since we did not initiate pairing to %s.", __func__, address);
1148       return;
1149     }
1150
1151     // Skip SDP for certain  HID Devices
1152     if (p_auth_cmpl->success)
1153     {
1154 #if BLE_INCLUDED == TRUE
1155         btif_storage_set_remote_addr_type(&bd_addr, p_auth_cmpl->addr_type);
1156 #endif
1157         btif_update_remote_properties(p_auth_cmpl->bd_addr,
1158                                       p_auth_cmpl->bd_name, NULL, p_auth_cmpl->dev_type);
1159         pairing_cb.timeout_retries = 0;
1160         status = BT_STATUS_SUCCESS;
1161         state = BT_BOND_STATE_BONDED;
1162         bdcpy(bd_addr.address, p_auth_cmpl->bd_addr);
1163
1164         if (check_sdp_bl(&bd_addr) && check_cod_hid(&bd_addr))
1165         {
1166             LOG_WARN(LOG_TAG, "%s:skip SDP", __FUNCTION__);
1167             skip_sdp = TRUE;
1168         }
1169         if(!pairing_cb.is_local_initiated && skip_sdp)
1170         {
1171             bond_state_changed(status, &bd_addr, state);
1172
1173             LOG_WARN(LOG_TAG, "%s: Incoming HID Connection",__FUNCTION__);
1174             bt_property_t prop;
1175             bt_bdaddr_t bd_addr;
1176             bt_uuid_t  uuid;
1177             char uuid_str[128] = UUID_HUMAN_INTERFACE_DEVICE;
1178
1179             string_to_uuid(uuid_str, &uuid);
1180
1181             prop.type = BT_PROPERTY_UUIDS;
1182             prop.val = uuid.uu;
1183             prop.len = MAX_UUID_SIZE;
1184
1185             /* Send the event to the BTIF */
1186             HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1187                              BT_STATUS_SUCCESS, &bd_addr, 1, &prop);
1188         }
1189         else
1190         {
1191             /* Trigger SDP on the device */
1192             pairing_cb.sdp_attempts = 1;;
1193
1194 #if BLE_INCLUDED == TRUE
1195             /* If bonded due to cross-key, save the static address too*/
1196             if(pairing_cb.state == BT_BOND_STATE_BONDING &&
1197               (bdcmp(p_auth_cmpl->bd_addr, pairing_cb.bd_addr) != 0))
1198             {
1199                 BTIF_TRACE_DEBUG("%s: bonding initiated due to cross key, adding static address",
1200                                  __func__);
1201                 bdcpy(pairing_cb.static_bdaddr.address, p_auth_cmpl->bd_addr);
1202             }
1203 #endif
1204
1205             // Ensure inquiry is stopped before attempting service discovery
1206             btif_dm_cancel_discovery();
1207
1208             btif_dm_get_remote_services(&bd_addr);
1209         }
1210         // Do not call bond_state_changed_cb yet. Wait until remote service discovery is complete
1211     }
1212     else
1213     {
1214         // Map the HCI fail reason  to  bt status
1215         switch(p_auth_cmpl->fail_reason)
1216         {
1217             case HCI_ERR_PAGE_TIMEOUT:
1218                 if (interop_match_addr(INTEROP_AUTO_RETRY_PAIRING, &bd_addr)
1219                     && pairing_cb.timeout_retries)
1220                 {
1221                     BTIF_TRACE_WARNING("%s() - Pairing timeout; retrying (%d) ...", __FUNCTION__, pairing_cb.timeout_retries);
1222                     --pairing_cb.timeout_retries;
1223                     btif_dm_cb_create_bond (&bd_addr, BTA_TRANSPORT_UNKNOWN);
1224                     return;
1225                 }
1226                 /* Fall-through */
1227             case HCI_ERR_CONNECTION_TOUT:
1228                 status =  BT_STATUS_RMT_DEV_DOWN;
1229                 break;
1230
1231             case HCI_ERR_PAIRING_NOT_ALLOWED:
1232                 status = BT_STATUS_AUTH_REJECTED;
1233                 break;
1234
1235             case HCI_ERR_LMP_RESPONSE_TIMEOUT:
1236                 status =  BT_STATUS_AUTH_FAILURE;
1237                 break;
1238
1239             /* map the auth failure codes, so we can retry pairing if necessary */
1240             case HCI_ERR_AUTH_FAILURE:
1241             case HCI_ERR_KEY_MISSING:
1242                 btif_storage_remove_bonded_device(&bd_addr);
1243             case HCI_ERR_HOST_REJECT_SECURITY:
1244             case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
1245             case HCI_ERR_UNIT_KEY_USED:
1246             case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
1247             case HCI_ERR_INSUFFCIENT_SECURITY:
1248             case HCI_ERR_PEER_USER:
1249             case HCI_ERR_UNSPECIFIED:
1250                 BTIF_TRACE_DEBUG(" %s() Authentication fail reason %d",
1251                     __FUNCTION__, p_auth_cmpl->fail_reason);
1252                 if (pairing_cb.autopair_attempts  == 1)
1253                 {
1254                     /* Create the Bond once again */
1255                     BTIF_TRACE_WARNING("%s() auto pair failed. Reinitiate Bond", __FUNCTION__);
1256                     btif_dm_cb_create_bond (&bd_addr, BTA_TRANSPORT_UNKNOWN);
1257                     return;
1258                 }
1259                 else
1260                 {
1261                     /* if autopair attempts are more than 1, or not attempted */
1262                     status =  BT_STATUS_AUTH_FAILURE;
1263                 }
1264                 break;
1265
1266             default:
1267                 status =  BT_STATUS_FAIL;
1268         }
1269         /* Special Handling for HID Devices */
1270         if (check_cod(&bd_addr, COD_HID_POINTING)) {
1271             /* Remove Device as bonded in nvram as authentication failed */
1272             BTIF_TRACE_DEBUG("%s(): removing hid pointing device from nvram", __FUNCTION__);
1273             btif_storage_remove_bonded_device(&bd_addr);
1274         }
1275         bond_state_changed(status, &bd_addr, state);
1276     }
1277 }
1278
1279 /******************************************************************************
1280 **
1281 ** Function         btif_dm_search_devices_evt
1282 **
1283 ** Description      Executes search devices callback events in btif context
1284 **
1285 ** Returns          void
1286 **
1287 ******************************************************************************/
1288 static void btif_dm_search_devices_evt (UINT16 event, char *p_param)
1289 {
1290     tBTA_DM_SEARCH *p_search_data;
1291     BTIF_TRACE_EVENT("%s event=%s", __FUNCTION__, dump_dm_search_event(event));
1292
1293     switch (event)
1294     {
1295         case BTA_DM_DISC_RES_EVT:
1296         {
1297             p_search_data = (tBTA_DM_SEARCH *)p_param;
1298             /* Remote name update */
1299             if (strlen((const char *) p_search_data->disc_res.bd_name))
1300             {
1301                 bt_property_t properties[1];
1302                 bt_bdaddr_t bdaddr;
1303                 bt_status_t status;
1304
1305                 properties[0].type = BT_PROPERTY_BDNAME;
1306                 properties[0].val = p_search_data->disc_res.bd_name;
1307                 properties[0].len = strlen((char *)p_search_data->disc_res.bd_name);
1308                 bdcpy(bdaddr.address, p_search_data->disc_res.bd_addr);
1309
1310                 status = btif_storage_set_remote_device_property(&bdaddr, &properties[0]);
1311                 ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device property", status);
1312                 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1313                                  status, &bdaddr, 1, properties);
1314             }
1315             /* TODO: Services? */
1316         }
1317         break;
1318
1319         case BTA_DM_INQ_RES_EVT:
1320         {
1321             /* inquiry result */
1322             UINT32 cod;
1323             bt_bdname_t bdname;
1324             bt_bdaddr_t bdaddr;
1325             UINT8 remote_name_len;
1326             tBTA_SERVICE_MASK services = 0;
1327             bdstr_t bdstr;
1328
1329             p_search_data = (tBTA_DM_SEARCH *)p_param;
1330             bdcpy(bdaddr.address, p_search_data->inq_res.bd_addr);
1331
1332             BTIF_TRACE_DEBUG("%s() %s device_type = 0x%x\n", __FUNCTION__, bdaddr_to_string(&bdaddr, bdstr, sizeof(bdstr)),
1333 #if (BLE_INCLUDED == TRUE)
1334                     p_search_data->inq_res.device_type);
1335 #else
1336                     BT_DEVICE_TYPE_BREDR);
1337 #endif
1338             bdname.name[0] = 0;
1339
1340             cod = devclass2uint (p_search_data->inq_res.dev_class);
1341
1342             if (cod == 0) {
1343                 LOG_DEBUG(LOG_TAG, "%s cod is 0, set as unclassified", __func__);
1344                 cod = COD_UNCLASSIFIED;
1345             }
1346
1347             if (!check_eir_remote_name(p_search_data, bdname.name, &remote_name_len))
1348                 check_cached_remote_name(p_search_data, bdname.name, &remote_name_len);
1349
1350             /* Check EIR for remote name and services */
1351             if (p_search_data->inq_res.p_eir)
1352             {
1353                 BTA_GetEirService(p_search_data->inq_res.p_eir, &services);
1354                 BTIF_TRACE_DEBUG("%s()EIR BTA services = %08X", __FUNCTION__, (UINT32)services);
1355                 /* TODO:  Get the service list and check to see which uuids we got and send it back to the client. */
1356             }
1357
1358             {
1359                 bt_property_t properties[5];
1360                 bt_device_type_t dev_type;
1361                 uint32_t num_properties = 0;
1362                 bt_status_t status;
1363                 int addr_type = 0;
1364
1365                 memset(properties, 0, sizeof(properties));
1366                 /* BD_ADDR */
1367                 BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
1368                                     BT_PROPERTY_BDADDR, sizeof(bdaddr), &bdaddr);
1369                 num_properties++;
1370                 /* BD_NAME */
1371                 /* Don't send BDNAME if it is empty */
1372                 if (bdname.name[0])
1373                 {
1374                     BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
1375                                                BT_PROPERTY_BDNAME,
1376                                                strlen((char *)bdname.name), &bdname);
1377                     num_properties++;
1378                 }
1379
1380                 /* DEV_CLASS */
1381                 BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
1382                                     BT_PROPERTY_CLASS_OF_DEVICE, sizeof(cod), &cod);
1383                 num_properties++;
1384                 /* DEV_TYPE */
1385 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1386                 /* FixMe: Assumption is that bluetooth.h and BTE enums match */
1387
1388                 /* Verify if the device is dual mode in NVRAM */
1389                 int stored_device_type = 0;
1390                 if (btif_get_device_type(bdaddr.address, &stored_device_type) &&
1391                     ((stored_device_type != BT_DEVICE_TYPE_BREDR &&
1392                         p_search_data->inq_res.device_type == BT_DEVICE_TYPE_BREDR) ||
1393                      (stored_device_type != BT_DEVICE_TYPE_BLE &&
1394                         p_search_data->inq_res.device_type == BT_DEVICE_TYPE_BLE))) {
1395                     dev_type = BT_DEVICE_TYPE_DUMO;
1396                 } else {
1397                     dev_type = p_search_data->inq_res.device_type;
1398                 }
1399
1400                 if (p_search_data->inq_res.device_type == BT_DEVICE_TYPE_BLE)
1401                     addr_type = p_search_data->inq_res.ble_addr_type;
1402 #else
1403                 dev_type = BT_DEVICE_TYPE_BREDR;
1404 #endif
1405                 BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
1406                                     BT_PROPERTY_TYPE_OF_DEVICE, sizeof(dev_type), &dev_type);
1407                 num_properties++;
1408                 /* RSSI */
1409                 BTIF_STORAGE_FILL_PROPERTY(&properties[num_properties],
1410                                     BT_PROPERTY_REMOTE_RSSI, sizeof(int8_t),
1411                                     &(p_search_data->inq_res.rssi));
1412                 num_properties++;
1413
1414                 status = btif_storage_add_remote_device(&bdaddr, num_properties, properties);
1415                 ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device (inquiry)", status);
1416 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1417                 status = btif_storage_set_remote_addr_type(&bdaddr, addr_type);
1418                 ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote addr type (inquiry)", status);
1419 #endif
1420                 /* Callback to notify upper layer of device */
1421                 HAL_CBACK(bt_hal_cbacks, device_found_cb,
1422                                  num_properties, properties);
1423             }
1424         }
1425         break;
1426
1427         case BTA_DM_INQ_CMPL_EVT:
1428         {
1429 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1430             tBTA_DM_BLE_PF_FILT_PARAMS adv_filt_param;
1431             memset(&adv_filt_param, 0, sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
1432             BTA_DmBleScanFilterSetup(BTA_DM_BLE_SCAN_COND_DELETE, 0, &adv_filt_param, NULL,
1433                                      bte_scan_filt_param_cfg_evt, 0);
1434 #endif
1435         }
1436         break;
1437         case BTA_DM_DISC_CMPL_EVT:
1438         {
1439             HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, BT_DISCOVERY_STOPPED);
1440         }
1441         break;
1442         case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
1443         {
1444            /* if inquiry is not in progress and we get a cancel event, then
1445             * it means we are done with inquiry, but remote_name fetches are in
1446             * progress
1447             *
1448             * if inquiry  is in progress, then we don't want to act on this cancel_cmpl_evt
1449             * but instead wait for the cancel_cmpl_evt via the Busy Level
1450             *
1451             */
1452            if (btif_dm_inquiry_in_progress == FALSE)
1453            {
1454 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1455                tBTA_DM_BLE_PF_FILT_PARAMS adv_filt_param;
1456                memset(&adv_filt_param, 0, sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
1457                BTA_DmBleScanFilterSetup(BTA_DM_BLE_SCAN_COND_DELETE, 0, &adv_filt_param, NULL,
1458                                         bte_scan_filt_param_cfg_evt, 0);
1459 #endif
1460                HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, BT_DISCOVERY_STOPPED);
1461            }
1462         }
1463         break;
1464     }
1465 }
1466
1467 /*******************************************************************************
1468 **
1469 ** Function         btif_dm_search_services_evt
1470 **
1471 ** Description      Executes search services event in btif context
1472 **
1473 ** Returns          void
1474 **
1475 *******************************************************************************/
1476 static void btif_dm_search_services_evt(UINT16 event, char *p_param)
1477 {
1478     tBTA_DM_SEARCH *p_data = (tBTA_DM_SEARCH*)p_param;
1479
1480     BTIF_TRACE_EVENT("%s:  event = %d", __FUNCTION__, event);
1481     switch (event)
1482     {
1483         case BTA_DM_DISC_RES_EVT:
1484         {
1485             bt_property_t prop;
1486             uint32_t i = 0;
1487             bt_bdaddr_t bd_addr;
1488             bt_status_t ret;
1489
1490             bdcpy(bd_addr.address, p_data->disc_res.bd_addr);
1491
1492             BTIF_TRACE_DEBUG("%s:(result=0x%x, services 0x%x)", __FUNCTION__,
1493                     p_data->disc_res.result, p_data->disc_res.services);
1494             if  ((p_data->disc_res.result != BTA_SUCCESS) &&
1495                  (pairing_cb.state == BT_BOND_STATE_BONDING ) &&
1496                  (pairing_cb.sdp_attempts < BTIF_DM_MAX_SDP_ATTEMPTS_AFTER_PAIRING))
1497             {
1498                 BTIF_TRACE_WARNING("%s:SDP failed after bonding re-attempting", __FUNCTION__);
1499                 pairing_cb.sdp_attempts++;
1500                 btif_dm_get_remote_services(&bd_addr);
1501                 return;
1502             }
1503             prop.type = BT_PROPERTY_UUIDS;
1504             prop.len = 0;
1505             if ((p_data->disc_res.result == BTA_SUCCESS) && (p_data->disc_res.num_uuids > 0))
1506             {
1507                  prop.val = p_data->disc_res.p_uuid_list;
1508                  prop.len = p_data->disc_res.num_uuids * MAX_UUID_SIZE;
1509                  for (i=0; i < p_data->disc_res.num_uuids; i++)
1510                  {
1511                       char temp[256];
1512                       uuid_to_string_legacy((bt_uuid_t*)(p_data->disc_res.p_uuid_list + (i*MAX_UUID_SIZE)), temp);
1513                       LOG_INFO(LOG_TAG, "%s index:%d uuid:%s", __func__, i, temp);
1514                  }
1515             }
1516
1517             /* onUuidChanged requires getBondedDevices to be populated.
1518             ** bond_state_changed needs to be sent prior to remote_device_property
1519             */
1520             if ((pairing_cb.state == BT_BOND_STATE_BONDING) &&
1521                 ((bdcmp(p_data->disc_res.bd_addr, pairing_cb.bd_addr) == 0) ||
1522                  (bdcmp(p_data->disc_res.bd_addr, pairing_cb.static_bdaddr.address) == 0)) &&
1523                   pairing_cb.sdp_attempts > 0)
1524             {
1525                  BTIF_TRACE_DEBUG("%s Remote Service SDP done. Call bond_state_changed_cb BONDED",
1526                                    __FUNCTION__);
1527                  pairing_cb.sdp_attempts  = 0;
1528
1529                  // If bonding occured due to cross-key pairing, send bonding callback
1530                  // for static address now
1531                  if (bdcmp(p_data->disc_res.bd_addr, pairing_cb.static_bdaddr.address) == 0)
1532                     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
1533
1534                  bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDED);
1535             }
1536
1537             if (p_data->disc_res.num_uuids != 0)
1538             {
1539                 /* Also write this to the NVRAM */
1540                 ret = btif_storage_set_remote_device_property(&bd_addr, &prop);
1541                 ASSERTC(ret == BT_STATUS_SUCCESS, "storing remote services failed", ret);
1542                 /* Send the event to the BTIF */
1543                 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1544                                  BT_STATUS_SUCCESS, &bd_addr, 1, &prop);
1545             }
1546         }
1547         break;
1548
1549         case BTA_DM_DISC_CMPL_EVT:
1550             /* fixme */
1551         break;
1552
1553 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1554         case BTA_DM_DISC_BLE_RES_EVT:
1555              BTIF_TRACE_DEBUG("%s:, services 0x%x)", __FUNCTION__,
1556                                 p_data->disc_ble_res.service.uu.uuid16);
1557              bt_uuid_t  uuid;
1558              int i = 0;
1559              int j = 15;
1560              if (p_data->disc_ble_res.service.uu.uuid16 == UUID_SERVCLASS_LE_HID)
1561              {
1562                 BTIF_TRACE_DEBUG("%s: Found HOGP UUID",__FUNCTION__);
1563                 bt_property_t prop;
1564                 bt_bdaddr_t bd_addr;
1565                 char temp[256];
1566                 bt_status_t ret;
1567
1568                 bta_gatt_convert_uuid16_to_uuid128(uuid.uu,p_data->disc_ble_res.service.uu.uuid16);
1569
1570                 while(i < j )
1571                 {
1572                     unsigned char c = uuid.uu[j];
1573                     uuid.uu[j] = uuid.uu[i];
1574                     uuid.uu[i] = c;
1575                     i++;
1576                     j--;
1577                 }
1578
1579                 uuid_to_string_legacy(&uuid, temp);
1580                 LOG_INFO(LOG_TAG, "%s uuid:%s", __func__, temp);
1581
1582                 bdcpy(bd_addr.address, p_data->disc_ble_res.bd_addr);
1583                 prop.type = BT_PROPERTY_UUIDS;
1584                 prop.val = uuid.uu;
1585                 prop.len = MAX_UUID_SIZE;
1586
1587                 /* Also write this to the NVRAM */
1588                 ret = btif_storage_set_remote_device_property(&bd_addr, &prop);
1589                 ASSERTC(ret == BT_STATUS_SUCCESS, "storing remote services failed", ret);
1590
1591                 /* Send the event to the BTIF */
1592                 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1593                                  BT_STATUS_SUCCESS, &bd_addr, 1, &prop);
1594
1595             }
1596         break;
1597 #endif /* BLE_INCLUDED */
1598
1599         default:
1600         {
1601             ASSERTC(0, "unhandled search services event", event);
1602         }
1603         break;
1604     }
1605 }
1606
1607 /*******************************************************************************
1608 **
1609 ** Function         btif_dm_remote_service_record_evt
1610 **
1611 ** Description      Executes search service record event in btif context
1612 **
1613 ** Returns          void
1614 **
1615 *******************************************************************************/
1616 static void btif_dm_remote_service_record_evt(UINT16 event, char *p_param)
1617 {
1618     tBTA_DM_SEARCH *p_data = (tBTA_DM_SEARCH*)p_param;
1619
1620     BTIF_TRACE_EVENT("%s:  event = %d", __FUNCTION__, event);
1621     switch (event)
1622     {
1623         case BTA_DM_DISC_RES_EVT:
1624         {
1625             bt_service_record_t rec;
1626             bt_property_t prop;
1627             bt_bdaddr_t bd_addr;
1628
1629             memset(&rec, 0, sizeof(bt_service_record_t));
1630             bdcpy(bd_addr.address, p_data->disc_res.bd_addr);
1631
1632             BTIF_TRACE_DEBUG("%s:(result=0x%x, services 0x%x)", __FUNCTION__,
1633                     p_data->disc_res.result, p_data->disc_res.services);
1634             prop.type = BT_PROPERTY_SERVICE_RECORD;
1635             prop.val = (void*)&rec;
1636             prop.len = sizeof(rec);
1637
1638             /* disc_res.result is overloaded with SCN. Cannot check result */
1639             p_data->disc_res.services &= ~BTA_USER_SERVICE_MASK;
1640             /* TODO: Get the UUID as well */
1641             rec.channel = p_data->disc_res.result - 3;
1642             /* TODO: Need to get the service name using p_raw_data */
1643             rec.name[0] = 0;
1644
1645             HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1646                              BT_STATUS_SUCCESS, &bd_addr, 1, &prop);
1647         }
1648         break;
1649
1650         default:
1651         {
1652            ASSERTC(0, "unhandled remote service record event", event);
1653         }
1654         break;
1655     }
1656 }
1657
1658 /*******************************************************************************
1659 **
1660 ** Function         btif_dm_upstreams_cback
1661 **
1662 ** Description      Executes UPSTREAMS events in btif context
1663 **
1664 ** Returns          void
1665 **
1666 *******************************************************************************/
1667 static void btif_dm_upstreams_evt(UINT16 event, char* p_param)
1668 {
1669     tBTA_DM_SEC *p_data = (tBTA_DM_SEC*)p_param;
1670     tBTA_SERVICE_MASK service_mask;
1671     uint32_t i;
1672     bt_bdaddr_t bd_addr;
1673
1674     BTIF_TRACE_EVENT("btif_dm_upstreams_cback  ev: %s", dump_dm_event(event));
1675
1676     switch (event)
1677     {
1678         case BTA_DM_ENABLE_EVT:
1679         {
1680              BD_NAME bdname;
1681              bt_status_t status;
1682              bt_property_t prop;
1683              prop.type = BT_PROPERTY_BDNAME;
1684              prop.len = BD_NAME_LEN;
1685              prop.val = (void*)bdname;
1686
1687              status = btif_storage_get_adapter_property(&prop);
1688              if (status == BT_STATUS_SUCCESS)
1689              {
1690                  /* A name exists in the storage. Make this the device name */
1691                  BTA_DmSetDeviceName((char*)prop.val);
1692              }
1693              else
1694              {
1695                  /* Storage does not have a name yet.
1696                   * Use the default name and write it to the chip
1697                   */
1698                  BTA_DmSetDeviceName(btif_get_default_local_name());
1699              }
1700
1701 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1702              /* Enable local privacy */
1703              BTA_DmBleConfigLocalPrivacy(BLE_LOCAL_PRIVACY_ENABLED);
1704 #endif
1705
1706              /* for each of the enabled services in the mask, trigger the profile
1707               * enable */
1708              service_mask = btif_get_enabled_services_mask();
1709              for (i=0; i <= BTA_MAX_SERVICE_ID; i++)
1710              {
1711                  if (service_mask &
1712                      (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(i)))
1713                  {
1714                      btif_in_execute_service_request(i, TRUE);
1715                  }
1716              }
1717              /* clear control blocks */
1718              memset(&pairing_cb, 0, sizeof(btif_dm_pairing_cb_t));
1719              pairing_cb.bond_type = BOND_TYPE_PERSISTENT;
1720
1721              /* This function will also trigger the adapter_properties_cb
1722              ** and bonded_devices_info_cb
1723              */
1724              btif_storage_load_bonded_devices();
1725
1726              btif_enable_bluetooth_evt(p_data->enable.status);
1727         }
1728         break;
1729
1730         case BTA_DM_DISABLE_EVT:
1731             /* for each of the enabled services in the mask, trigger the profile
1732              * disable */
1733             service_mask = btif_get_enabled_services_mask();
1734             for (i=0; i <= BTA_MAX_SERVICE_ID; i++)
1735             {
1736                 if (service_mask &
1737                     (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(i)))
1738                 {
1739                     btif_in_execute_service_request(i, FALSE);
1740                 }
1741             }
1742             btif_disable_bluetooth_evt();
1743             break;
1744
1745         case BTA_DM_PIN_REQ_EVT:
1746             btif_dm_pin_req_evt(&p_data->pin_req);
1747             break;
1748
1749         case BTA_DM_AUTH_CMPL_EVT:
1750             btif_dm_auth_cmpl_evt(&p_data->auth_cmpl);
1751             break;
1752
1753         case BTA_DM_BOND_CANCEL_CMPL_EVT:
1754             if (pairing_cb.state == BT_BOND_STATE_BONDING)
1755             {
1756                 bdcpy(bd_addr.address, pairing_cb.bd_addr);
1757                 btm_set_bond_type_dev(pairing_cb.bd_addr, BOND_TYPE_UNKNOWN);
1758                 bond_state_changed(p_data->bond_cancel_cmpl.result, &bd_addr, BT_BOND_STATE_NONE);
1759             }
1760             break;
1761
1762         case BTA_DM_SP_CFM_REQ_EVT:
1763             btif_dm_ssp_cfm_req_evt(&p_data->cfm_req);
1764             break;
1765         case BTA_DM_SP_KEY_NOTIF_EVT:
1766             btif_dm_ssp_key_notif_evt(&p_data->key_notif);
1767             break;
1768
1769         case BTA_DM_DEV_UNPAIRED_EVT:
1770             bdcpy(bd_addr.address, p_data->link_down.bd_addr);
1771             btm_set_bond_type_dev(p_data->link_down.bd_addr, BOND_TYPE_UNKNOWN);
1772
1773             /*special handling for HID devices */
1774             #if (defined(BTA_HH_INCLUDED) && (BTA_HH_INCLUDED == TRUE))
1775             btif_hh_remove_device(bd_addr);
1776             #endif
1777             btif_storage_remove_bonded_device(&bd_addr);
1778             bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_NONE);
1779             break;
1780
1781         case BTA_DM_BUSY_LEVEL_EVT:
1782         {
1783
1784             if (p_data->busy_level.level_flags & BTM_BL_INQUIRY_PAGING_MASK)
1785             {
1786                 if (p_data->busy_level.level_flags == BTM_BL_INQUIRY_STARTED)
1787                 {
1788                        HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb,
1789                                                 BT_DISCOVERY_STARTED);
1790                        btif_dm_inquiry_in_progress = TRUE;
1791                 }
1792                 else if (p_data->busy_level.level_flags == BTM_BL_INQUIRY_CANCELLED)
1793                 {
1794                        HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb,
1795                                                 BT_DISCOVERY_STOPPED);
1796                        btif_dm_inquiry_in_progress = FALSE;
1797                 }
1798                 else if (p_data->busy_level.level_flags == BTM_BL_INQUIRY_COMPLETE)
1799                 {
1800                        btif_dm_inquiry_in_progress = FALSE;
1801                 }
1802             }
1803         }break;
1804
1805         case BTA_DM_LINK_UP_EVT:
1806             bdcpy(bd_addr.address, p_data->link_up.bd_addr);
1807             BTIF_TRACE_DEBUG("BTA_DM_LINK_UP_EVT. Sending BT_ACL_STATE_CONNECTED");
1808
1809             btif_update_remote_version_property(&bd_addr);
1810
1811             HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, BT_STATUS_SUCCESS,
1812                       &bd_addr, BT_ACL_STATE_CONNECTED);
1813             break;
1814
1815         case BTA_DM_LINK_DOWN_EVT:
1816             bdcpy(bd_addr.address, p_data->link_down.bd_addr);
1817             btm_set_bond_type_dev(p_data->link_down.bd_addr, BOND_TYPE_UNKNOWN);
1818             BTIF_TRACE_DEBUG("BTA_DM_LINK_DOWN_EVT. Sending BT_ACL_STATE_DISCONNECTED");
1819             HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, BT_STATUS_SUCCESS,
1820                       &bd_addr, BT_ACL_STATE_DISCONNECTED);
1821             break;
1822
1823         case BTA_DM_HW_ERROR_EVT:
1824             BTIF_TRACE_ERROR("Received H/W Error. ");
1825             /* Flush storage data */
1826             btif_config_flush();
1827             usleep(100000); /* 100milliseconds */
1828             /* Killing the process to force a restart as part of fault tolerance */
1829             kill(getpid(), SIGKILL);
1830             break;
1831
1832 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
1833         case BTA_DM_BLE_KEY_EVT:
1834             BTIF_TRACE_DEBUG("BTA_DM_BLE_KEY_EVT key_type=0x%02x ", p_data->ble_key.key_type);
1835
1836             /* If this pairing is by-product of local initiated GATT client Read or Write,
1837             BTA would not have sent BTA_DM_BLE_SEC_REQ_EVT event and Bond state would not
1838             have setup properly. Setup pairing_cb and notify App about Bonding state now*/
1839             if (pairing_cb.state != BT_BOND_STATE_BONDING)
1840             {
1841                 BTIF_TRACE_DEBUG("Bond state not sent to App so far.Notify the app now");
1842                 bond_state_changed(BT_STATUS_SUCCESS, (bt_bdaddr_t*)p_data->ble_key.bd_addr,
1843                                    BT_BOND_STATE_BONDING);
1844             }
1845             else if (memcmp (pairing_cb.bd_addr, p_data->ble_key.bd_addr, BD_ADDR_LEN)!=0)
1846             {
1847                 BTIF_TRACE_ERROR("BD mismatch discard BLE key_type=%d ",p_data->ble_key.key_type);
1848                 break;
1849             }
1850
1851             switch (p_data->ble_key.key_type)
1852             {
1853                 case BTA_LE_KEY_PENC:
1854                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_PENC");
1855                     pairing_cb.ble.is_penc_key_rcvd = TRUE;
1856                     pairing_cb.ble.penc_key = p_data->ble_key.p_key_value->penc_key;
1857                     break;
1858
1859                 case BTA_LE_KEY_PID:
1860                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_PID");
1861                     pairing_cb.ble.is_pid_key_rcvd = TRUE;
1862                     pairing_cb.ble.pid_key = p_data->ble_key.p_key_value->pid_key;
1863                     break;
1864
1865                 case BTA_LE_KEY_PCSRK:
1866                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_PCSRK");
1867                     pairing_cb.ble.is_pcsrk_key_rcvd = TRUE;
1868                     pairing_cb.ble.pcsrk_key = p_data->ble_key.p_key_value->pcsrk_key;
1869                     break;
1870
1871                 case BTA_LE_KEY_LENC:
1872                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_LENC");
1873                     pairing_cb.ble.is_lenc_key_rcvd = TRUE;
1874                     pairing_cb.ble.lenc_key = p_data->ble_key.p_key_value->lenc_key;
1875                     break;
1876
1877                 case BTA_LE_KEY_LCSRK:
1878                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_LCSRK");
1879                     pairing_cb.ble.is_lcsrk_key_rcvd = TRUE;
1880                     pairing_cb.ble.lcsrk_key = p_data->ble_key.p_key_value->lcsrk_key;
1881                     break;
1882
1883                 case BTA_LE_KEY_LID:
1884                     BTIF_TRACE_DEBUG("Rcv BTA_LE_KEY_LID");
1885                     pairing_cb.ble.is_lidk_key_rcvd =  TRUE;
1886                     break;
1887
1888                 default:
1889                     BTIF_TRACE_ERROR("unknown BLE key type (0x%02x)", p_data->ble_key.key_type);
1890                     break;
1891             }
1892             break;
1893         case BTA_DM_BLE_SEC_REQ_EVT:
1894             BTIF_TRACE_DEBUG("BTA_DM_BLE_SEC_REQ_EVT. ");
1895             btif_dm_ble_sec_req_evt(&p_data->ble_req);
1896             break;
1897         case BTA_DM_BLE_PASSKEY_NOTIF_EVT:
1898             BTIF_TRACE_DEBUG("BTA_DM_BLE_PASSKEY_NOTIF_EVT. ");
1899             btif_dm_ble_key_notif_evt(&p_data->key_notif);
1900             break;
1901         case BTA_DM_BLE_PASSKEY_REQ_EVT:
1902             BTIF_TRACE_DEBUG("BTA_DM_BLE_PASSKEY_REQ_EVT. ");
1903             btif_dm_ble_passkey_req_evt(&p_data->pin_req);
1904             break;
1905         case BTA_DM_BLE_NC_REQ_EVT:
1906             BTIF_TRACE_DEBUG("BTA_DM_BLE_PASSKEY_REQ_EVT. ");
1907             btif_dm_ble_key_nc_req_evt(&p_data->key_notif);
1908             break;
1909         case BTA_DM_BLE_OOB_REQ_EVT:
1910             BTIF_TRACE_DEBUG("BTA_DM_BLE_OOB_REQ_EVT. ");
1911             btif_dm_ble_oob_req_evt(&p_data->rmt_oob);
1912             break;
1913         case BTA_DM_BLE_LOCAL_IR_EVT:
1914             BTIF_TRACE_DEBUG("BTA_DM_BLE_LOCAL_IR_EVT. ");
1915             ble_local_key_cb.is_id_keys_rcvd = TRUE;
1916             memcpy(&ble_local_key_cb.id_keys.irk[0],
1917                    &p_data->ble_id_keys.irk[0], sizeof(BT_OCTET16));
1918             memcpy(&ble_local_key_cb.id_keys.ir[0],
1919                    &p_data->ble_id_keys.ir[0], sizeof(BT_OCTET16));
1920             memcpy(&ble_local_key_cb.id_keys.dhk[0],
1921                    &p_data->ble_id_keys.dhk[0], sizeof(BT_OCTET16));
1922             btif_storage_add_ble_local_key( (char *)&ble_local_key_cb.id_keys.irk[0],
1923                                             BTIF_DM_LE_LOCAL_KEY_IRK,
1924                                             BT_OCTET16_LEN);
1925             btif_storage_add_ble_local_key( (char *)&ble_local_key_cb.id_keys.ir[0],
1926                                             BTIF_DM_LE_LOCAL_KEY_IR,
1927                                             BT_OCTET16_LEN);
1928             btif_storage_add_ble_local_key( (char *)&ble_local_key_cb.id_keys.dhk[0],
1929                                             BTIF_DM_LE_LOCAL_KEY_DHK,
1930                                             BT_OCTET16_LEN);
1931             break;
1932         case BTA_DM_BLE_LOCAL_ER_EVT:
1933             BTIF_TRACE_DEBUG("BTA_DM_BLE_LOCAL_ER_EVT. ");
1934             ble_local_key_cb.is_er_rcvd = TRUE;
1935             memcpy(&ble_local_key_cb.er[0], &p_data->ble_er[0], sizeof(BT_OCTET16));
1936             btif_storage_add_ble_local_key( (char *)&ble_local_key_cb.er[0],
1937                                             BTIF_DM_LE_LOCAL_KEY_ER,
1938                                             BT_OCTET16_LEN);
1939             break;
1940
1941         case BTA_DM_BLE_AUTH_CMPL_EVT:
1942             BTIF_TRACE_DEBUG("BTA_DM_BLE_AUTH_CMPL_EVT. ");
1943             btif_dm_ble_auth_cmpl_evt(&p_data->auth_cmpl);
1944             break;
1945
1946         case BTA_DM_LE_FEATURES_READ:
1947         {
1948             tBTM_BLE_VSC_CB cmn_vsc_cb;
1949             bt_local_le_features_t local_le_features;
1950             char buf[512];
1951             bt_property_t prop;
1952             prop.type = BT_PROPERTY_LOCAL_LE_FEATURES;
1953             prop.val = (void*)buf;
1954             prop.len = sizeof(buf);
1955
1956            /* LE features are not stored in storage. Should be retrived from stack */
1957             BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
1958             local_le_features.local_privacy_enabled = BTM_BleLocalPrivacyEnabled();
1959
1960             prop.len = sizeof (bt_local_le_features_t);
1961             if (cmn_vsc_cb.filter_support == 1)
1962                 local_le_features.max_adv_filter_supported = cmn_vsc_cb.max_filter;
1963              else
1964                 local_le_features.max_adv_filter_supported = 0;
1965             local_le_features.max_adv_instance = cmn_vsc_cb.adv_inst_max;
1966             local_le_features.max_irk_list_size = cmn_vsc_cb.max_irk_list_sz;
1967             local_le_features.rpa_offload_supported = cmn_vsc_cb.rpa_offloading;
1968             local_le_features.activity_energy_info_supported = cmn_vsc_cb.energy_support;
1969             local_le_features.scan_result_storage_size = cmn_vsc_cb.tot_scan_results_strg;
1970             local_le_features.version_supported = cmn_vsc_cb.version_supported;
1971             local_le_features.total_trackable_advertisers =
1972                         cmn_vsc_cb.total_trackable_advertisers;
1973
1974             local_le_features.extended_scan_support = cmn_vsc_cb.extended_scan_support > 0;
1975             local_le_features.debug_logging_supported = cmn_vsc_cb.debug_logging_supported > 0;
1976
1977             memcpy(prop.val, &local_le_features, prop.len);
1978             HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1, &prop);
1979             break;
1980          }
1981
1982         case BTA_DM_ENER_INFO_READ:
1983         {
1984             btif_activity_energy_info_cb_t *p_ener_data = (btif_activity_energy_info_cb_t*) p_param;
1985             bt_activity_energy_info energy_info;
1986             energy_info.status = p_ener_data->status;
1987             energy_info.ctrl_state = p_ener_data->ctrl_state;
1988             energy_info.rx_time = p_ener_data->rx_time;
1989             energy_info.tx_time = p_ener_data->tx_time;
1990             energy_info.idle_time = p_ener_data->idle_time;
1991             energy_info.energy_used = p_ener_data->energy_used;
1992
1993             bt_uid_traffic_t* data = uid_set_read_and_clear(uid_set);
1994             HAL_CBACK(bt_hal_cbacks, energy_info_cb, &energy_info, data);
1995             osi_free(data);
1996             break;
1997         }
1998 #endif
1999
2000         case BTA_DM_AUTHORIZE_EVT:
2001         case BTA_DM_SIG_STRENGTH_EVT:
2002         case BTA_DM_SP_RMT_OOB_EVT:
2003         case BTA_DM_SP_KEYPRESS_EVT:
2004         case BTA_DM_ROLE_CHG_EVT:
2005
2006         default:
2007             BTIF_TRACE_WARNING( "btif_dm_cback : unhandled event (%d)", event );
2008             break;
2009     }
2010
2011     btif_dm_data_free(event, p_data);
2012 }
2013
2014 /*******************************************************************************
2015 **
2016 ** Function         btif_dm_generic_evt
2017 **
2018 ** Description      Executes non-BTA upstream events in BTIF context
2019 **
2020 ** Returns          void
2021 **
2022 *******************************************************************************/
2023 static void btif_dm_generic_evt(UINT16 event, char* p_param)
2024 {
2025     BTIF_TRACE_EVENT("%s: event=%d", __FUNCTION__, event);
2026     switch(event)
2027     {
2028         case BTIF_DM_CB_DISCOVERY_STARTED:
2029         {
2030             HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, BT_DISCOVERY_STARTED);
2031         }
2032         break;
2033
2034         case BTIF_DM_CB_CREATE_BOND:
2035         {
2036             pairing_cb.timeout_retries = NUM_TIMEOUT_RETRIES;
2037             btif_dm_create_bond_cb_t *create_bond_cb = (btif_dm_create_bond_cb_t*)p_param;
2038             btif_dm_cb_create_bond(&create_bond_cb->bdaddr, create_bond_cb->transport);
2039         }
2040         break;
2041
2042         case BTIF_DM_CB_REMOVE_BOND:
2043         {
2044             btif_dm_cb_remove_bond((bt_bdaddr_t *)p_param);
2045         }
2046         break;
2047
2048         case BTIF_DM_CB_HID_REMOTE_NAME:
2049         {
2050             btif_dm_cb_hid_remote_name((tBTM_REMOTE_DEV_NAME *)p_param);
2051         }
2052         break;
2053
2054         case BTIF_DM_CB_BOND_STATE_BONDING:
2055             {
2056                 bond_state_changed(BT_STATUS_SUCCESS, (bt_bdaddr_t *)p_param, BT_BOND_STATE_BONDING);
2057             }
2058             break;
2059         case BTIF_DM_CB_LE_TX_TEST:
2060         case BTIF_DM_CB_LE_RX_TEST:
2061             {
2062                 uint8_t status;
2063                 STREAM_TO_UINT8(status, p_param);
2064                 HAL_CBACK(bt_hal_cbacks, le_test_mode_cb,
2065                       (status == 0) ? BT_STATUS_SUCCESS : BT_STATUS_FAIL, 0);
2066             }
2067             break;
2068         case BTIF_DM_CB_LE_TEST_END:
2069             {
2070                 uint8_t status;
2071                 uint16_t count = 0;
2072                 STREAM_TO_UINT8(status, p_param);
2073                 if (status == 0)
2074                     STREAM_TO_UINT16(count, p_param);
2075                 HAL_CBACK(bt_hal_cbacks, le_test_mode_cb,
2076                       (status == 0) ? BT_STATUS_SUCCESS : BT_STATUS_FAIL, count);
2077             }
2078             break;
2079         default:
2080         {
2081             BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __FUNCTION__, event);
2082         }
2083         break;
2084     }
2085 }
2086
2087 /*******************************************************************************
2088 **
2089 ** Function         bte_dm_evt
2090 **
2091 ** Description      Switches context from BTE to BTIF for all DM events
2092 **
2093 ** Returns          void
2094 **
2095 *******************************************************************************/
2096
2097 void bte_dm_evt(tBTA_DM_SEC_EVT event, tBTA_DM_SEC *p_data)
2098 {
2099     /* switch context to btif task context (copy full union size for convenience) */
2100     bt_status_t status = btif_transfer_context(btif_dm_upstreams_evt, (uint16_t)event,
2101                                 (void*)p_data, sizeof(tBTA_DM_SEC), btif_dm_data_copy);
2102
2103     /* catch any failed context transfers */
2104     ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
2105 }
2106
2107 /*******************************************************************************
2108 **
2109 ** Function         bte_search_devices_evt
2110 **
2111 ** Description      Switches context from BTE to BTIF for DM search events
2112 **
2113 ** Returns          void
2114 **
2115 *******************************************************************************/
2116 static void bte_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
2117 {
2118     UINT16 param_len = 0;
2119
2120     if (p_data)
2121         param_len += sizeof(tBTA_DM_SEARCH);
2122     /* Allocate buffer to hold the pointers (deep copy). The pointers will point to the end of the tBTA_DM_SEARCH */
2123     switch (event)
2124     {
2125         case BTA_DM_INQ_RES_EVT:
2126         {
2127             if (p_data->inq_res.p_eir)
2128                 param_len += HCI_EXT_INQ_RESPONSE_LEN;
2129         }
2130         break;
2131
2132         case BTA_DM_DISC_RES_EVT:
2133         {
2134             if (p_data->disc_res.raw_data_size && p_data->disc_res.p_raw_data)
2135                 param_len += p_data->disc_res.raw_data_size;
2136         }
2137         break;
2138     }
2139     BTIF_TRACE_DEBUG("%s event=%s param_len=%d", __FUNCTION__, dump_dm_search_event(event), param_len);
2140
2141     /* if remote name is available in EIR, set teh flag so that stack doesnt trigger RNR */
2142     if (event == BTA_DM_INQ_RES_EVT)
2143         p_data->inq_res.remt_name_not_required = check_eir_remote_name(p_data, NULL, NULL);
2144
2145     btif_transfer_context (btif_dm_search_devices_evt , (UINT16) event, (void *)p_data, param_len,
2146         (param_len > sizeof(tBTA_DM_SEARCH)) ? search_devices_copy_cb : NULL);
2147 }
2148
2149 /*******************************************************************************
2150 **
2151 ** Function         bte_dm_search_services_evt
2152 **
2153 ** Description      Switches context from BTE to BTIF for DM search services
2154 **                  event
2155 **
2156 ** Returns          void
2157 **
2158 *******************************************************************************/
2159 static void bte_dm_search_services_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
2160 {
2161     UINT16 param_len = 0;
2162    if (p_data)
2163        param_len += sizeof(tBTA_DM_SEARCH);
2164    switch (event)
2165    {
2166          case BTA_DM_DISC_RES_EVT:
2167          {
2168              if ((p_data->disc_res.result == BTA_SUCCESS) && (p_data->disc_res.num_uuids > 0)) {
2169                   param_len += (p_data->disc_res.num_uuids * MAX_UUID_SIZE);
2170              }
2171          } break;
2172    }
2173    /* TODO: The only other member that needs a deep copy is the p_raw_data. But not sure
2174     * if raw_data is needed. */
2175    btif_transfer_context(btif_dm_search_services_evt, event, (char*)p_data, param_len,
2176          (param_len > sizeof(tBTA_DM_SEARCH)) ? search_services_copy_cb : NULL);
2177 }
2178
2179 /*******************************************************************************
2180 **
2181 ** Function         bte_dm_remote_service_record_evt
2182 **
2183 ** Description      Switches context from BTE to BTIF for DM search service
2184 **                  record event
2185 **
2186 ** Returns          void
2187 **
2188 *******************************************************************************/
2189 static void bte_dm_remote_service_record_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
2190 {
2191    /* TODO: The only member that needs a deep copy is the p_raw_data. But not sure yet if this is needed. */
2192    btif_transfer_context(btif_dm_remote_service_record_evt, event, (char*)p_data, sizeof(tBTA_DM_SEARCH), NULL);
2193 }
2194
2195 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2196 /*******************************************************************************
2197 **
2198 ** Function         bta_energy_info_cb
2199 **
2200 ** Description      Switches context from BTE to BTIF for DM energy info event
2201 **
2202 ** Returns          void
2203 **
2204 *******************************************************************************/
2205 static void bta_energy_info_cb(tBTA_DM_BLE_TX_TIME_MS tx_time, tBTA_DM_BLE_RX_TIME_MS rx_time,
2206                                     tBTA_DM_BLE_IDLE_TIME_MS idle_time,
2207                                     tBTA_DM_BLE_ENERGY_USED energy_used,
2208                                     tBTA_DM_CONTRL_STATE ctrl_state, tBTA_STATUS status)
2209 {
2210     BTIF_TRACE_DEBUG("energy_info_cb-Status:%d,state=%d,tx_t=%ld, rx_t=%ld, idle_time=%ld,used=%ld",
2211         status, ctrl_state, tx_time, rx_time, idle_time, energy_used);
2212
2213     btif_activity_energy_info_cb_t btif_cb;
2214     btif_cb.status = status;
2215     btif_cb.ctrl_state = ctrl_state;
2216     btif_cb.tx_time = (uint64_t) tx_time;
2217     btif_cb.rx_time = (uint64_t) rx_time;
2218     btif_cb.idle_time =(uint64_t) idle_time;
2219     btif_cb.energy_used =(uint64_t) energy_used;
2220     btif_transfer_context(btif_dm_upstreams_evt, BTA_DM_ENER_INFO_READ,
2221                           (char*) &btif_cb, sizeof(btif_activity_energy_info_cb_t), NULL);
2222 }
2223 #endif
2224
2225 /*******************************************************************************
2226 **
2227 ** Function         bte_scan_filt_param_cfg_evt
2228 **
2229 ** Description      Scan filter param config event
2230 **
2231 ** Returns          void
2232 **
2233 *******************************************************************************/
2234 static void bte_scan_filt_param_cfg_evt(UINT8 action_type,
2235                                         tBTA_DM_BLE_PF_AVBL_SPACE avbl_space,
2236                                         tBTA_DM_BLE_REF_VALUE ref_value, tBTA_STATUS status)
2237 {
2238     /* This event occurs on calling BTA_DmBleCfgFilterCondition internally,
2239     ** and that is why there is no HAL callback
2240     */
2241     if(BTA_SUCCESS != status)
2242     {
2243         BTIF_TRACE_ERROR("%s, %d", __FUNCTION__, status);
2244     }
2245     else
2246     {
2247         BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2248     }
2249 }
2250
2251 /*****************************************************************************
2252 **
2253 **   btif api functions (no context switch)
2254 **
2255 *****************************************************************************/
2256
2257 /*******************************************************************************
2258 **
2259 ** Function         btif_dm_start_discovery
2260 **
2261 ** Description      Start device discovery/inquiry
2262 **
2263 ** Returns          bt_status_t
2264 **
2265 *******************************************************************************/
2266 bt_status_t btif_dm_start_discovery(void)
2267 {
2268     tBTA_DM_INQ inq_params;
2269     tBTA_SERVICE_MASK services = 0;
2270     tBTA_DM_BLE_PF_FILT_PARAMS adv_filt_param;
2271
2272     BTIF_TRACE_EVENT("%s", __FUNCTION__);
2273
2274 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2275     memset(&adv_filt_param, 0, sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
2276     /* Cleanup anything remaining on index 0 */
2277     BTA_DmBleScanFilterSetup(BTA_DM_BLE_SCAN_COND_DELETE, 0, &adv_filt_param, NULL,
2278                              bte_scan_filt_param_cfg_evt, 0);
2279
2280     /* Add an allow-all filter on index 0*/
2281     adv_filt_param.dely_mode = IMMEDIATE_DELY_MODE;
2282     adv_filt_param.feat_seln = ALLOW_ALL_FILTER;
2283     adv_filt_param.filt_logic_type = BTA_DM_BLE_PF_FILT_LOGIC_OR;
2284     adv_filt_param.list_logic_type = BTA_DM_BLE_PF_LIST_LOGIC_OR;
2285     adv_filt_param.rssi_low_thres = LOWEST_RSSI_VALUE;
2286     adv_filt_param.rssi_high_thres = LOWEST_RSSI_VALUE;
2287     BTA_DmBleScanFilterSetup(BTA_DM_BLE_SCAN_COND_ADD, 0, &adv_filt_param, NULL,
2288                              bte_scan_filt_param_cfg_evt, 0);
2289
2290     /* TODO: Do we need to handle multiple inquiries at the same time? */
2291
2292     /* Set inquiry params and call API */
2293     inq_params.mode = BTA_DM_GENERAL_INQUIRY|BTA_BLE_GENERAL_INQUIRY;
2294 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
2295     inq_params.intl_duration[0]= BTIF_DM_INTERLEAVE_DURATION_BR_ONE;
2296     inq_params.intl_duration[1]= BTIF_DM_INTERLEAVE_DURATION_LE_ONE;
2297     inq_params.intl_duration[2]= BTIF_DM_INTERLEAVE_DURATION_BR_TWO;
2298     inq_params.intl_duration[3]= BTIF_DM_INTERLEAVE_DURATION_LE_TWO;
2299 #endif
2300 #else
2301     inq_params.mode = BTA_DM_GENERAL_INQUIRY;
2302 #endif
2303     inq_params.duration = BTIF_DM_DEFAULT_INQ_MAX_DURATION;
2304
2305     inq_params.max_resps = BTIF_DM_DEFAULT_INQ_MAX_RESULTS;
2306     inq_params.report_dup = TRUE;
2307
2308     inq_params.filter_type = BTA_DM_INQ_CLR;
2309     /* TODO: Filter device by BDA needs to be implemented here */
2310
2311     /* Will be enabled to TRUE once inquiry busy level has been received */
2312     btif_dm_inquiry_in_progress = FALSE;
2313     /* find nearby devices */
2314     BTA_DmSearch(&inq_params, services, bte_search_devices_evt);
2315
2316     return BT_STATUS_SUCCESS;
2317 }
2318
2319 /*******************************************************************************
2320 **
2321 ** Function         btif_dm_cancel_discovery
2322 **
2323 ** Description      Cancels search
2324 **
2325 ** Returns          bt_status_t
2326 **
2327 *******************************************************************************/
2328 bt_status_t btif_dm_cancel_discovery(void)
2329 {
2330     BTIF_TRACE_EVENT("%s", __FUNCTION__);
2331     BTA_DmSearchCancel();
2332     return BT_STATUS_SUCCESS;
2333 }
2334
2335 /*******************************************************************************
2336 **
2337 ** Function         btif_dm_create_bond
2338 **
2339 ** Description      Initiate bonding with the specified device
2340 **
2341 ** Returns          bt_status_t
2342 **
2343 *******************************************************************************/
2344 bt_status_t btif_dm_create_bond(const bt_bdaddr_t *bd_addr, int transport)
2345 {
2346     btif_dm_create_bond_cb_t create_bond_cb;
2347     create_bond_cb.transport = transport;
2348     bdcpy(create_bond_cb.bdaddr.address, bd_addr->address);
2349
2350     bdstr_t bdstr;
2351     BTIF_TRACE_EVENT("%s: bd_addr=%s, transport=%d", __FUNCTION__, bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr)), transport);
2352     if (pairing_cb.state != BT_BOND_STATE_NONE)
2353         return BT_STATUS_BUSY;
2354
2355     btif_stats_add_bond_event(bd_addr, BTIF_DM_FUNC_CREATE_BOND, pairing_cb.state);
2356
2357     btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_CREATE_BOND,
2358                           (char *)&create_bond_cb, sizeof(btif_dm_create_bond_cb_t), NULL);
2359
2360     return BT_STATUS_SUCCESS;
2361 }
2362
2363 /*******************************************************************************
2364 **
2365 ** Function         btif_dm_create_bond_out_of_band
2366 **
2367 ** Description      Initiate bonding with the specified device using out of band data
2368 **
2369 ** Returns          bt_status_t
2370 **
2371 *******************************************************************************/
2372 bt_status_t btif_dm_create_bond_out_of_band(const bt_bdaddr_t *bd_addr, int transport, const bt_out_of_band_data_t *oob_data)
2373 {
2374     bdcpy(oob_cb.bdaddr, bd_addr->address);
2375     memcpy(&oob_cb.oob_data, oob_data, sizeof(bt_out_of_band_data_t));
2376
2377     bdstr_t bdstr;
2378     BTIF_TRACE_EVENT("%s: bd_addr=%s, transport=%d", __FUNCTION__, bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr)), transport);
2379     return btif_dm_create_bond(bd_addr, transport);
2380 }
2381
2382 /*******************************************************************************
2383 **
2384 ** Function         btif_dm_cancel_bond
2385 **
2386 ** Description      Initiate bonding with the specified device
2387 **
2388 ** Returns          bt_status_t
2389 **
2390 *******************************************************************************/
2391
2392 bt_status_t btif_dm_cancel_bond(const bt_bdaddr_t *bd_addr)
2393 {
2394     bdstr_t bdstr;
2395
2396     BTIF_TRACE_EVENT("%s: bd_addr=%s", __FUNCTION__, bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr)));
2397
2398     btif_stats_add_bond_event(bd_addr, BTIF_DM_FUNC_CANCEL_BOND, pairing_cb.state);
2399
2400     /* TODO:
2401     **  1. Restore scan modes
2402     **  2. special handling for HID devices
2403     */
2404     if (pairing_cb.state == BT_BOND_STATE_BONDING)
2405     {
2406
2407 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2408
2409         if (pairing_cb.is_ssp)
2410         {
2411             if (pairing_cb.is_le_only)
2412             {
2413                 BTA_DmBleSecurityGrant((UINT8 *)bd_addr->address,BTA_DM_SEC_PAIR_NOT_SPT);
2414             }
2415             else
2416             {
2417                 BTA_DmConfirm( (UINT8 *)bd_addr->address, FALSE);
2418                 BTA_DmBondCancel ((UINT8 *)bd_addr->address);
2419                 btif_storage_remove_bonded_device((bt_bdaddr_t *)bd_addr);
2420             }
2421         }
2422         else
2423         {
2424             if (pairing_cb.is_le_only)
2425             {
2426                 BTA_DmBondCancel ((UINT8 *)bd_addr->address);
2427             }
2428             else
2429             {
2430                 BTA_DmPinReply( (UINT8 *)bd_addr->address, FALSE, 0, NULL);
2431             }
2432         /* Cancel bonding, in case it is in ACL connection setup state */
2433         BTA_DmBondCancel ((UINT8 *)bd_addr->address);
2434         }
2435
2436 #else
2437         if (pairing_cb.is_ssp)
2438         {
2439             BTA_DmConfirm( (UINT8 *)bd_addr->address, FALSE);
2440         }
2441         else
2442         {
2443             BTA_DmPinReply( (UINT8 *)bd_addr->address, FALSE, 0, NULL);
2444         }
2445         /* Cancel bonding, in case it is in ACL connection setup state */
2446         BTA_DmBondCancel ((UINT8 *)bd_addr->address);
2447         btif_storage_remove_bonded_device((bt_bdaddr_t *)bd_addr);
2448 #endif
2449     }
2450
2451     return BT_STATUS_SUCCESS;
2452 }
2453
2454 /*******************************************************************************
2455 **
2456 ** Function         btif_dm_hh_open_failed
2457 **
2458 ** Description      informs the upper layers if the HH have failed during bonding
2459 **
2460 ** Returns          none
2461 **
2462 *******************************************************************************/
2463
2464 void btif_dm_hh_open_failed(bt_bdaddr_t *bdaddr)
2465 {
2466     if (pairing_cb.state == BT_BOND_STATE_BONDING &&
2467             bdcmp(bdaddr->address, pairing_cb.bd_addr) == 0)
2468     {
2469         bond_state_changed(BT_STATUS_FAIL, bdaddr, BT_BOND_STATE_NONE);
2470     }
2471 }
2472
2473 /*******************************************************************************
2474 **
2475 ** Function         btif_dm_remove_bond
2476 **
2477 ** Description      Removes bonding with the specified device
2478 **
2479 ** Returns          bt_status_t
2480 **
2481 *******************************************************************************/
2482
2483 bt_status_t btif_dm_remove_bond(const bt_bdaddr_t *bd_addr)
2484 {
2485     bdstr_t bdstr;
2486
2487     BTIF_TRACE_EVENT("%s: bd_addr=%s", __FUNCTION__, bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr)));
2488
2489     btif_stats_add_bond_event(bd_addr, BTIF_DM_FUNC_REMOVE_BOND, pairing_cb.state);
2490
2491     btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_REMOVE_BOND,
2492                           (char *)bd_addr, sizeof(bt_bdaddr_t), NULL);
2493
2494     return BT_STATUS_SUCCESS;
2495 }
2496
2497 /*******************************************************************************
2498 **
2499 ** Function         btif_dm_pin_reply
2500 **
2501 ** Description      BT legacy pairing - PIN code reply
2502 **
2503 ** Returns          bt_status_t
2504 **
2505 *******************************************************************************/
2506
2507 bt_status_t btif_dm_pin_reply( const bt_bdaddr_t *bd_addr, uint8_t accept,
2508                                uint8_t pin_len, bt_pin_code_t *pin_code)
2509 {
2510     BTIF_TRACE_EVENT("%s: accept=%d", __FUNCTION__, accept);
2511     if (pin_code == NULL || pin_len > PIN_CODE_LEN)
2512         return BT_STATUS_FAIL;
2513 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2514
2515     if (pairing_cb.is_le_only)
2516     {
2517         int i;
2518         UINT32 passkey = 0;
2519         int multi[] = {100000, 10000, 1000, 100, 10,1};
2520         BD_ADDR remote_bd_addr;
2521         bdcpy(remote_bd_addr, bd_addr->address);
2522         for (i = 0; i < 6; i++)
2523         {
2524             passkey += (multi[i] * (pin_code->pin[i] - '0'));
2525         }
2526         BTIF_TRACE_DEBUG("btif_dm_pin_reply: passkey: %d", passkey);
2527         BTA_DmBlePasskeyReply(remote_bd_addr, accept, passkey);
2528
2529     }
2530     else
2531     {
2532         BTA_DmPinReply( (UINT8 *)bd_addr->address, accept, pin_len, pin_code->pin);
2533         if (accept)
2534             pairing_cb.pin_code_len = pin_len;
2535     }
2536 #else
2537     BTA_DmPinReply( (UINT8 *)bd_addr->address, accept, pin_len, pin_code->pin);
2538
2539     if (accept)
2540         pairing_cb.pin_code_len = pin_len;
2541 #endif
2542     return BT_STATUS_SUCCESS;
2543 }
2544
2545 /*******************************************************************************
2546 **
2547 ** Function         btif_dm_ssp_reply
2548 **
2549 ** Description      BT SSP Reply - Just Works, Numeric Comparison & Passkey Entry
2550 **
2551 ** Returns          bt_status_t
2552 **
2553 *******************************************************************************/
2554 bt_status_t btif_dm_ssp_reply(const bt_bdaddr_t *bd_addr,
2555                                  bt_ssp_variant_t variant, uint8_t accept,
2556                                  uint32_t passkey)
2557 {
2558     UNUSED(passkey);
2559
2560     if (variant == BT_SSP_VARIANT_PASSKEY_ENTRY)
2561     {
2562         /* This is not implemented in the stack.
2563          * For devices with display, this is not needed
2564         */
2565         BTIF_TRACE_WARNING("%s: Not implemented", __FUNCTION__);
2566         return BT_STATUS_FAIL;
2567     }
2568     /* BT_SSP_VARIANT_CONSENT & BT_SSP_VARIANT_PASSKEY_CONFIRMATION supported */
2569     BTIF_TRACE_EVENT("%s: accept=%d", __FUNCTION__, accept);
2570 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2571     if (pairing_cb.is_le_only)
2572     {
2573         if(pairing_cb.is_le_nc)
2574         {
2575             BTA_DmBleConfirmReply((UINT8 *)bd_addr->address,accept);
2576         } else {
2577             if (accept)
2578                 BTA_DmBleSecurityGrant((UINT8 *)bd_addr->address,BTA_DM_SEC_GRANTED);
2579             else
2580                 BTA_DmBleSecurityGrant((UINT8 *)bd_addr->address,BTA_DM_SEC_PAIR_NOT_SPT);
2581         }
2582     } else {
2583         BTA_DmConfirm( (UINT8 *)bd_addr->address, accept);
2584     }
2585 #else
2586     BTA_DmConfirm( (UINT8 *)bd_addr->address, accept);
2587 #endif
2588     return BT_STATUS_SUCCESS;
2589 }
2590
2591 /*******************************************************************************
2592 **
2593 ** Function         btif_dm_get_adapter_property
2594 **
2595 ** Description     Queries the BTA for the adapter property
2596 **
2597 ** Returns          bt_status_t
2598 **
2599 *******************************************************************************/
2600 bt_status_t btif_dm_get_adapter_property(bt_property_t *prop)
2601 {
2602     BTIF_TRACE_EVENT("%s: type=0x%x", __FUNCTION__, prop->type);
2603     switch (prop->type)
2604     {
2605         case BT_PROPERTY_BDNAME:
2606         {
2607             bt_bdname_t *bd_name = (bt_bdname_t*)prop->val;
2608             strncpy((char *)bd_name->name, (char *)btif_get_default_local_name(),
2609                    sizeof(bd_name->name) - 1);
2610             bd_name->name[sizeof(bd_name->name) - 1] = 0;
2611             prop->len = strlen((char *)bd_name->name);
2612         }
2613         break;
2614
2615         case BT_PROPERTY_ADAPTER_SCAN_MODE:
2616         {
2617             /* if the storage does not have it. Most likely app never set it. Default is NONE */
2618             bt_scan_mode_t *mode = (bt_scan_mode_t*)prop->val;
2619             *mode = BT_SCAN_MODE_NONE;
2620             prop->len = sizeof(bt_scan_mode_t);
2621         }
2622         break;
2623
2624         case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
2625         {
2626             uint32_t *tmt = (uint32_t*)prop->val;
2627             *tmt = 120; /* default to 120s, if not found in NV */
2628             prop->len = sizeof(uint32_t);
2629         }
2630         break;
2631
2632         default:
2633             prop->len = 0;
2634             return BT_STATUS_FAIL;
2635     }
2636     return BT_STATUS_SUCCESS;
2637 }
2638
2639 /*******************************************************************************
2640 **
2641 ** Function         btif_dm_get_remote_services
2642 **
2643 ** Description      Start SDP to get remote services
2644 **
2645 ** Returns          bt_status_t
2646 **
2647 *******************************************************************************/
2648 bt_status_t btif_dm_get_remote_services(bt_bdaddr_t *remote_addr)
2649 {
2650     bdstr_t bdstr;
2651
2652     BTIF_TRACE_EVENT("%s: remote_addr=%s", __FUNCTION__, bdaddr_to_string(remote_addr, bdstr, sizeof(bdstr)));
2653
2654     BTA_DmDiscover(remote_addr->address, BTA_ALL_SERVICE_MASK,
2655                    bte_dm_search_services_evt, TRUE);
2656
2657     return BT_STATUS_SUCCESS;
2658 }
2659
2660 /*******************************************************************************
2661 **
2662 ** Function         btif_dm_get_remote_services_transport
2663 **
2664 ** Description      Start SDP to get remote services by transport
2665 **
2666 ** Returns          bt_status_t
2667 **
2668 *******************************************************************************/
2669 bt_status_t btif_dm_get_remote_services_by_transport(bt_bdaddr_t *remote_addr, const int transport)
2670 {
2671     BTIF_TRACE_EVENT("%s", __func__);
2672
2673     /* Set the mask extension */
2674     tBTA_SERVICE_MASK_EXT mask_ext;
2675     mask_ext.num_uuid = 0;
2676     mask_ext.p_uuid = NULL;
2677     mask_ext.srvc_mask = BTA_ALL_SERVICE_MASK;
2678
2679     BTA_DmDiscoverByTransport(remote_addr->address, &mask_ext,
2680                    bte_dm_search_services_evt, TRUE, transport);
2681
2682     return BT_STATUS_SUCCESS;
2683 }
2684
2685 /*******************************************************************************
2686 **
2687 ** Function         btif_dm_get_remote_service_record
2688 **
2689 ** Description      Start SDP to get remote service record
2690 **
2691 **
2692 ** Returns          bt_status_t
2693 *******************************************************************************/
2694 bt_status_t btif_dm_get_remote_service_record(bt_bdaddr_t *remote_addr,
2695                                                     bt_uuid_t *uuid)
2696 {
2697     tSDP_UUID sdp_uuid;
2698     bdstr_t bdstr;
2699
2700     BTIF_TRACE_EVENT("%s: remote_addr=%s", __FUNCTION__, bdaddr_to_string(remote_addr, bdstr, sizeof(bdstr)));
2701
2702     sdp_uuid.len = MAX_UUID_SIZE;
2703     memcpy(sdp_uuid.uu.uuid128, uuid->uu, MAX_UUID_SIZE);
2704
2705     BTA_DmDiscoverUUID(remote_addr->address, &sdp_uuid,
2706                        bte_dm_remote_service_record_evt, TRUE);
2707
2708     return BT_STATUS_SUCCESS;
2709 }
2710
2711 void btif_dm_execute_service_request(UINT16 event, char *p_param)
2712 {
2713     BOOLEAN b_enable = FALSE;
2714     bt_status_t status;
2715     if (event == BTIF_DM_ENABLE_SERVICE)
2716     {
2717         b_enable = TRUE;
2718     }
2719     status = btif_in_execute_service_request(*((tBTA_SERVICE_ID*)p_param), b_enable);
2720     if (status == BT_STATUS_SUCCESS)
2721     {
2722         bt_property_t property;
2723         bt_uuid_t local_uuids[BT_MAX_NUM_UUIDS];
2724
2725         /* Now send the UUID_PROPERTY_CHANGED event to the upper layer */
2726         BTIF_STORAGE_FILL_PROPERTY(&property, BT_PROPERTY_UUIDS,
2727                                     sizeof(local_uuids), local_uuids);
2728         btif_storage_get_adapter_property(&property);
2729         HAL_CBACK(bt_hal_cbacks, adapter_properties_cb,
2730                           BT_STATUS_SUCCESS, 1, &property);
2731     }
2732     return;
2733 }
2734
2735 void btif_dm_proc_io_req(BD_ADDR bd_addr, tBTA_IO_CAP *p_io_cap, tBTA_OOB_DATA *p_oob_data,
2736                       tBTA_AUTH_REQ *p_auth_req, BOOLEAN is_orig)
2737 {
2738     UINT8   yes_no_bit = BTA_AUTH_SP_YES & *p_auth_req;
2739     /* if local initiated:
2740     **      1. set DD + MITM
2741     ** if remote initiated:
2742     **      1. Copy over the auth_req from peer's io_rsp
2743     **      2. Set the MITM if peer has it set or if peer has DisplayYesNo (iPhone)
2744     ** as a fallback set MITM+GB if peer had MITM set
2745     */
2746     UNUSED (bd_addr);
2747     UNUSED (p_io_cap);
2748     UNUSED (p_oob_data);
2749
2750     BTIF_TRACE_DEBUG("+%s: p_auth_req=%d", __FUNCTION__, *p_auth_req);
2751     if(pairing_cb.is_local_initiated)
2752     {
2753         /* if initing/responding to a dedicated bonding, use dedicate bonding bit */
2754         *p_auth_req = BTA_AUTH_DD_BOND | BTA_AUTH_SP_YES;
2755     }
2756     else if (!is_orig)
2757     {
2758         /* peer initiated paring. They probably know what they want.
2759         ** Copy the mitm from peer device.
2760         */
2761         BTIF_TRACE_DEBUG("%s: setting p_auth_req to peer's: %d",
2762                 __FUNCTION__, pairing_cb.auth_req);
2763         *p_auth_req = (pairing_cb.auth_req & BTA_AUTH_BONDS);
2764
2765         /* copy over the MITM bit as well. In addition if the peer has DisplayYesNo, force MITM */
2766         if ((yes_no_bit) || (pairing_cb.io_cap & BTM_IO_CAP_IO) )
2767             *p_auth_req |= BTA_AUTH_SP_YES;
2768     }
2769     else if (yes_no_bit)
2770     {
2771         /* set the general bonding bit for stored device */
2772         *p_auth_req = BTA_AUTH_GEN_BOND | yes_no_bit;
2773     }
2774     BTIF_TRACE_DEBUG("-%s: p_auth_req=%d", __FUNCTION__, *p_auth_req);
2775 }
2776
2777 void btif_dm_proc_io_rsp(BD_ADDR bd_addr, tBTA_IO_CAP io_cap,
2778                       tBTA_OOB_DATA oob_data, tBTA_AUTH_REQ auth_req)
2779 {
2780     UNUSED (bd_addr);
2781     UNUSED (oob_data);
2782
2783     if(auth_req & BTA_AUTH_BONDS)
2784     {
2785         BTIF_TRACE_DEBUG("%s auth_req:%d", __FUNCTION__, auth_req);
2786         pairing_cb.auth_req = auth_req;
2787         pairing_cb.io_cap = io_cap;
2788     }
2789 }
2790
2791 void btif_dm_set_oob_for_io_req(tBTA_OOB_DATA  *p_has_oob_data)
2792 {
2793     if (is_empty_128bit(oob_cb.oob_data.c192))
2794     {
2795         *p_has_oob_data = FALSE;
2796     }
2797     else
2798     {
2799         *p_has_oob_data = TRUE;
2800     }
2801     BTIF_TRACE_DEBUG("%s: *p_has_oob_data=%d", __func__, *p_has_oob_data);
2802 }
2803
2804 void btif_dm_set_oob_for_le_io_req(BD_ADDR bd_addr, tBTA_OOB_DATA  *p_has_oob_data,
2805                                    tBTA_LE_AUTH_REQ *p_auth_req)
2806 {
2807
2808     /* We currently support only Security Manager TK as OOB data for LE transport.
2809        If it's not present mark no OOB data.
2810      */
2811     if (!is_empty_128bit(oob_cb.oob_data.sm_tk))
2812     {
2813         /* make sure OOB data is for this particular device */
2814         if (memcmp(bd_addr, oob_cb.bdaddr, BD_ADDR_LEN) == 0) {
2815             // When using OOB with TK, SC Secure Connections bit must be disabled.
2816             tBTA_LE_AUTH_REQ mask = ~BTM_LE_AUTH_REQ_SC_ONLY;
2817             *p_auth_req = ((*p_auth_req) & mask);
2818
2819             *p_has_oob_data = TRUE;
2820         }
2821         else
2822         {
2823             *p_has_oob_data = FALSE;
2824             BTIF_TRACE_WARNING("%s: remote address didn't match OOB data address",
2825                                __func__);
2826         }
2827     }
2828     else
2829     {
2830         *p_has_oob_data = FALSE;
2831     }
2832     BTIF_TRACE_DEBUG("%s *p_has_oob_data=%d", __func__, *p_has_oob_data);
2833 }
2834
2835 #ifdef BTIF_DM_OOB_TEST
2836 void btif_dm_load_local_oob(void)
2837 {
2838     char prop_oob[PROPERTY_VALUE_MAX];
2839     osi_property_get("service.brcm.bt.oob", prop_oob, "3");
2840     BTIF_TRACE_DEBUG("%s: prop_oob = %s", __func__, prop_oob);
2841     if (prop_oob[0] != '3')
2842     {
2843         if (is_empty_128bit(oob_cb.oob_data.c192))
2844         {
2845             BTIF_TRACE_DEBUG("%s: read OOB, call BTA_DmLocalOob()", __func__);
2846             BTA_DmLocalOob();
2847         }
2848     }
2849 }
2850
2851 void btif_dm_proc_loc_oob(BOOLEAN valid, BT_OCTET16 c, BT_OCTET16 r)
2852 {
2853     FILE *fp;
2854     char *path_a = "/data/misc/bluedroid/LOCAL/a.key";
2855     char *path_b = "/data/misc/bluedroid/LOCAL/b.key";
2856     char *path = NULL;
2857     char prop_oob[PROPERTY_VALUE_MAX];
2858     BTIF_TRACE_DEBUG("%s: valid=%d", __func__, valid);
2859     if (is_empty_128bit(oob_cb.oob_data.c192) && valid)
2860     {
2861         BTIF_TRACE_DEBUG("save local OOB data in memory");
2862         memcpy(oob_cb.oob_data.c192, c, BT_OCTET16_LEN);
2863         memcpy(oob_cb.oob_data.r192, r, BT_OCTET16_LEN);
2864         osi_property_get("service.brcm.bt.oob", prop_oob, "3");
2865         BTIF_TRACE_DEBUG("%s: prop_oob = %s", __func__, prop_oob);
2866         if (prop_oob[0] == '1')
2867             path = path_a;
2868         else if (prop_oob[0] == '2')
2869             path = path_b;
2870         if (path)
2871         {
2872             fp = fopen(path, "wb+");
2873             if (fp == NULL)
2874             {
2875                 BTIF_TRACE_DEBUG("%s: failed to save local OOB data to %s", __func__, path);
2876             }
2877             else
2878             {
2879                 BTIF_TRACE_DEBUG("%s: save local OOB data into file %s", __func__, path);
2880                 fwrite (c , 1 , BT_OCTET16_LEN , fp );
2881                 fwrite (r , 1 , BT_OCTET16_LEN , fp );
2882                 fclose(fp);
2883             }
2884         }
2885     }
2886 }
2887
2888 BOOLEAN btif_dm_proc_rmt_oob(BD_ADDR bd_addr,  BT_OCTET16 p_c, BT_OCTET16 p_r)
2889 {
2890     char t[128];
2891     FILE *fp;
2892     char *path_a = "/data/misc/bluedroid/LOCAL/a.key";
2893     char *path_b = "/data/misc/bluedroid/LOCAL/b.key";
2894     char *path = NULL;
2895     char prop_oob[PROPERTY_VALUE_MAX];
2896     BOOLEAN result = FALSE;
2897     bt_bdaddr_t bt_bd_addr;
2898     bdcpy(oob_cb.bdaddr, bd_addr);
2899     osi_property_get("service.brcm.bt.oob", prop_oob, "3");
2900     BTIF_TRACE_DEBUG("%s: prop_oob = %s", __func__, prop_oob);
2901     if (prop_oob[0] == '1')
2902         path = path_b;
2903     else if (prop_oob[0] == '2')
2904         path = path_a;
2905     if (path)
2906     {
2907         fp = fopen(path, "rb");
2908         if (fp == NULL)
2909         {
2910             BTIF_TRACE_DEBUG("%s: failed to read OOB keys from %s", __func__, path);
2911             return FALSE;
2912         }
2913         else
2914         {
2915             BTIF_TRACE_DEBUG("%s: read OOB data from %s", __func__, path);
2916             fread (p_c , 1 , BT_OCTET16_LEN , fp );
2917             fread (p_r , 1 , BT_OCTET16_LEN , fp );
2918             fclose(fp);
2919         }
2920         BTIF_TRACE_DEBUG("----%s: TRUE", __func__);
2921         sprintf(t, "%02x:%02x:%02x:%02x:%02x:%02x",
2922                 oob_cb.bdaddr[0], oob_cb.bdaddr[1], oob_cb.bdaddr[2],
2923                 oob_cb.bdaddr[3], oob_cb.bdaddr[4], oob_cb.bdaddr[5]);
2924         BTIF_TRACE_DEBUG("----%s: peer_bdaddr = %s", __func__, t);
2925         sprintf(t, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
2926                 p_c[0], p_c[1], p_c[2],  p_c[3],  p_c[4],  p_c[5],  p_c[6],  p_c[7],
2927                 p_c[8], p_c[9], p_c[10], p_c[11], p_c[12], p_c[13], p_c[14], p_c[15]);
2928         BTIF_TRACE_DEBUG("----%s: c = %s", __func__, t);
2929         sprintf(t, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
2930                 p_r[0], p_r[1], p_r[2],  p_r[3],  p_r[4],  p_r[5],  p_r[6],  p_r[7],
2931                 p_r[8], p_r[9], p_r[10], p_r[11], p_r[12], p_r[13], p_r[14], p_r[15]);
2932         BTIF_TRACE_DEBUG("----%s: r = %s", __func__, t);
2933         bdcpy(bt_bd_addr.address, bd_addr);
2934         btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_BOND_STATE_BONDING,
2935                               (char *)&bt_bd_addr, sizeof(bt_bdaddr_t), NULL);
2936         result = TRUE;
2937     }
2938     BTIF_TRACE_DEBUG("%s: result=%d", __func__, result);
2939     return result;
2940 }
2941 #endif /*  BTIF_DM_OOB_TEST */
2942 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
2943
2944 static void btif_dm_ble_key_notif_evt(tBTA_DM_SP_KEY_NOTIF *p_ssp_key_notif)
2945 {
2946     bt_bdaddr_t bd_addr;
2947     bt_bdname_t bd_name;
2948     UINT32 cod;
2949     int dev_type;
2950
2951     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2952
2953     /* Remote name update */
2954     if (!btif_get_device_type(p_ssp_key_notif->bd_addr, &dev_type))
2955     {
2956         dev_type = BT_DEVICE_TYPE_BLE;
2957     }
2958     btif_dm_update_ble_remote_properties(p_ssp_key_notif->bd_addr , p_ssp_key_notif->bd_name,
2959                                          (tBT_DEVICE_TYPE) dev_type);
2960     bdcpy(bd_addr.address, p_ssp_key_notif->bd_addr);
2961     memcpy(bd_name.name, p_ssp_key_notif->bd_name, BD_NAME_LEN);
2962
2963     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
2964     pairing_cb.is_ssp = FALSE;
2965     cod = COD_UNCLASSIFIED;
2966
2967     HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, &bd_name,
2968               cod, BT_SSP_VARIANT_PASSKEY_NOTIFICATION,
2969               p_ssp_key_notif->passkey);
2970 }
2971
2972 /*******************************************************************************
2973 **
2974 ** Function         btif_dm_ble_auth_cmpl_evt
2975 **
2976 ** Description      Executes authentication complete event in btif context
2977 **
2978 ** Returns          void
2979 **
2980 *******************************************************************************/
2981 static void btif_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
2982 {
2983     /* Save link key, if not temporary */
2984     bt_bdaddr_t bd_addr;
2985     bt_status_t status = BT_STATUS_FAIL;
2986     bt_bond_state_t state = BT_BOND_STATE_NONE;
2987
2988     bdcpy(bd_addr.address, p_auth_cmpl->bd_addr);
2989
2990     /* Clear OOB data */
2991     memset(&oob_cb, 0, sizeof(oob_cb));
2992
2993     if ( (p_auth_cmpl->success == TRUE) && (p_auth_cmpl->key_present) )
2994     {
2995         /* store keys */
2996     }
2997     if (p_auth_cmpl->success)
2998     {
2999         status = BT_STATUS_SUCCESS;
3000         state = BT_BOND_STATE_BONDED;
3001         int addr_type;
3002         bt_bdaddr_t bdaddr;
3003         bdcpy(bdaddr.address, p_auth_cmpl->bd_addr);
3004         if (btif_storage_get_remote_addr_type(&bdaddr, &addr_type) != BT_STATUS_SUCCESS)
3005             btif_storage_set_remote_addr_type(&bdaddr, p_auth_cmpl->addr_type);
3006
3007         /* Test for temporary bonding */
3008         if (btm_get_bond_type_dev(p_auth_cmpl->bd_addr) == BOND_TYPE_TEMPORARY) {
3009             BTIF_TRACE_DEBUG("%s: sending BT_BOND_STATE_NONE for Temp pairing",
3010                              __func__);
3011             btif_storage_remove_bonded_device(&bdaddr);
3012             state = BT_BOND_STATE_NONE;
3013         } else {
3014             btif_dm_save_ble_bonding_keys();
3015             BTA_GATTC_Refresh(bd_addr.address);
3016             btif_dm_get_remote_services_by_transport(&bd_addr, BTA_GATT_TRANSPORT_LE);
3017         }
3018     }
3019     else
3020     {
3021         /*Map the HCI fail reason  to  bt status  */
3022         switch (p_auth_cmpl->fail_reason)
3023         {
3024             case BTA_DM_AUTH_SMP_PAIR_AUTH_FAIL:
3025             case BTA_DM_AUTH_SMP_CONFIRM_VALUE_FAIL:
3026                 btif_dm_remove_ble_bonding_keys();
3027                 status = BT_STATUS_AUTH_FAILURE;
3028                 break;
3029             case BTA_DM_AUTH_SMP_PAIR_NOT_SUPPORT:
3030                 status = BT_STATUS_AUTH_REJECTED;
3031                 break;
3032             default:
3033                 btif_dm_remove_ble_bonding_keys();
3034                 status =  BT_STATUS_FAIL;
3035                 break;
3036         }
3037     }
3038     bond_state_changed(status, &bd_addr, state);
3039 }
3040
3041 void    btif_dm_load_ble_local_keys(void)
3042 {
3043     memset(&ble_local_key_cb, 0, sizeof(btif_dm_local_key_cb_t));
3044
3045     if (btif_storage_get_ble_local_key(BTIF_DM_LE_LOCAL_KEY_ER,(char*)&ble_local_key_cb.er[0],
3046                                        BT_OCTET16_LEN)== BT_STATUS_SUCCESS)
3047     {
3048         ble_local_key_cb.is_er_rcvd = TRUE;
3049         BTIF_TRACE_DEBUG("%s BLE ER key loaded",__FUNCTION__ );
3050     }
3051
3052     if ((btif_storage_get_ble_local_key(BTIF_DM_LE_LOCAL_KEY_IR,(char*)&ble_local_key_cb.id_keys.ir[0],
3053                                         BT_OCTET16_LEN)== BT_STATUS_SUCCESS )&&
3054         (btif_storage_get_ble_local_key(BTIF_DM_LE_LOCAL_KEY_IRK, (char*)&ble_local_key_cb.id_keys.irk[0],
3055                                         BT_OCTET16_LEN)== BT_STATUS_SUCCESS)&&
3056         (btif_storage_get_ble_local_key(BTIF_DM_LE_LOCAL_KEY_DHK,(char*)&ble_local_key_cb.id_keys.dhk[0],
3057                                         BT_OCTET16_LEN)== BT_STATUS_SUCCESS))
3058     {
3059         ble_local_key_cb.is_id_keys_rcvd = TRUE;
3060         BTIF_TRACE_DEBUG("%s BLE ID keys loaded",__FUNCTION__ );
3061     }
3062
3063 }
3064 void    btif_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
3065                                    tBTA_BLE_LOCAL_ID_KEYS *p_id_keys)
3066 {
3067     if (ble_local_key_cb.is_er_rcvd )
3068     {
3069         memcpy(&er[0], &ble_local_key_cb.er[0], sizeof(BT_OCTET16));
3070         *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ER;
3071     }
3072
3073     if (ble_local_key_cb.is_id_keys_rcvd)
3074     {
3075         memcpy(&p_id_keys->ir[0], &ble_local_key_cb.id_keys.ir[0], sizeof(BT_OCTET16));
3076         memcpy(&p_id_keys->irk[0],  &ble_local_key_cb.id_keys.irk[0], sizeof(BT_OCTET16));
3077         memcpy(&p_id_keys->dhk[0],  &ble_local_key_cb.id_keys.dhk[0], sizeof(BT_OCTET16));
3078         *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ID;
3079     }
3080     BTIF_TRACE_DEBUG("%s  *p_key_mask=0x%02x",__FUNCTION__,   *p_key_mask);
3081 }
3082
3083 void btif_dm_save_ble_bonding_keys(void)
3084 {
3085
3086     bt_bdaddr_t bd_addr;
3087
3088     BTIF_TRACE_DEBUG("%s",__FUNCTION__ );
3089
3090     bdcpy(bd_addr.address, pairing_cb.bd_addr);
3091
3092     if (pairing_cb.ble.is_penc_key_rcvd)
3093     {
3094         btif_storage_add_ble_bonding_key(&bd_addr,
3095                                          (char *) &pairing_cb.ble.penc_key,
3096                                          BTIF_DM_LE_KEY_PENC,
3097                                          sizeof(tBTM_LE_PENC_KEYS));
3098     }
3099
3100     if (pairing_cb.ble.is_pid_key_rcvd)
3101     {
3102         btif_storage_add_ble_bonding_key(&bd_addr,
3103                                          (char *) &pairing_cb.ble.pid_key,
3104                                          BTIF_DM_LE_KEY_PID,
3105                                          sizeof(tBTM_LE_PID_KEYS));
3106     }
3107
3108     if (pairing_cb.ble.is_pcsrk_key_rcvd)
3109     {
3110         btif_storage_add_ble_bonding_key(&bd_addr,
3111                                          (char *) &pairing_cb.ble.pcsrk_key,
3112                                          BTIF_DM_LE_KEY_PCSRK,
3113                                          sizeof(tBTM_LE_PCSRK_KEYS));
3114     }
3115
3116     if (pairing_cb.ble.is_lenc_key_rcvd)
3117     {
3118         btif_storage_add_ble_bonding_key(&bd_addr,
3119                                          (char *) &pairing_cb.ble.lenc_key,
3120                                          BTIF_DM_LE_KEY_LENC,
3121                                          sizeof(tBTM_LE_LENC_KEYS));
3122     }
3123
3124     if (pairing_cb.ble.is_lcsrk_key_rcvd)
3125     {
3126         btif_storage_add_ble_bonding_key(&bd_addr,
3127                                          (char *) &pairing_cb.ble.lcsrk_key,
3128                                          BTIF_DM_LE_KEY_LCSRK,
3129                                          sizeof(tBTM_LE_LCSRK_KEYS));
3130     }
3131
3132     if (pairing_cb.ble.is_lidk_key_rcvd)
3133     {
3134         btif_storage_add_ble_bonding_key(&bd_addr,
3135                                          NULL,
3136                                          BTIF_DM_LE_KEY_LID,
3137                                          0);
3138     }
3139
3140 }
3141
3142 void btif_dm_remove_ble_bonding_keys(void)
3143 {
3144     bt_bdaddr_t bd_addr;
3145
3146     BTIF_TRACE_DEBUG("%s",__FUNCTION__ );
3147
3148     bdcpy(bd_addr.address, pairing_cb.bd_addr);
3149     btif_storage_remove_ble_bonding_keys(&bd_addr);
3150 }
3151
3152 /*******************************************************************************
3153 **
3154 ** Function         btif_dm_ble_sec_req_evt
3155 **
3156 ** Description      Eprocess security request event in btif context
3157 **
3158 ** Returns          void
3159 **
3160 *******************************************************************************/
3161 void btif_dm_ble_sec_req_evt(tBTA_DM_BLE_SEC_REQ *p_ble_req)
3162 {
3163     bt_bdaddr_t bd_addr;
3164     bt_bdname_t bd_name;
3165     UINT32 cod;
3166     int dev_type;
3167
3168     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3169
3170     if (pairing_cb.state == BT_BOND_STATE_BONDING)
3171     {
3172         BTIF_TRACE_DEBUG("%s Discard security request", __FUNCTION__);
3173         return;
3174     }
3175
3176     /* Remote name update */
3177     if (!btif_get_device_type(p_ble_req->bd_addr, &dev_type))
3178     {
3179         dev_type = BT_DEVICE_TYPE_BLE;
3180     }
3181     btif_dm_update_ble_remote_properties(p_ble_req->bd_addr, p_ble_req->bd_name,
3182                                          (tBT_DEVICE_TYPE) dev_type);
3183
3184     bdcpy(bd_addr.address, p_ble_req->bd_addr);
3185     memcpy(bd_name.name, p_ble_req->bd_name, BD_NAME_LEN);
3186
3187     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
3188
3189     pairing_cb.bond_type = BOND_TYPE_PERSISTENT;
3190     pairing_cb.is_le_only = TRUE;
3191     pairing_cb.is_le_nc = FALSE;
3192     pairing_cb.is_ssp = TRUE;
3193     btm_set_bond_type_dev(p_ble_req->bd_addr, pairing_cb.bond_type);
3194
3195     cod = COD_UNCLASSIFIED;
3196
3197     HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, &bd_name, cod,
3198               BT_SSP_VARIANT_CONSENT, 0);
3199 }
3200
3201 /*******************************************************************************
3202 **
3203 ** Function         btif_dm_ble_passkey_req_evt
3204 **
3205 ** Description      Executes pin request event in btif context
3206 **
3207 ** Returns          void
3208 **
3209 *******************************************************************************/
3210 static void btif_dm_ble_passkey_req_evt(tBTA_DM_PIN_REQ *p_pin_req)
3211 {
3212     bt_bdaddr_t bd_addr;
3213     bt_bdname_t bd_name;
3214     UINT32 cod;
3215     int dev_type;
3216
3217     /* Remote name update */
3218     if (!btif_get_device_type(p_pin_req->bd_addr, &dev_type))
3219     {
3220         dev_type = BT_DEVICE_TYPE_BLE;
3221     }
3222     btif_dm_update_ble_remote_properties(p_pin_req->bd_addr,p_pin_req->bd_name,
3223                                          (tBT_DEVICE_TYPE) dev_type);
3224
3225     bdcpy(bd_addr.address, p_pin_req->bd_addr);
3226     memcpy(bd_name.name, p_pin_req->bd_name, BD_NAME_LEN);
3227
3228     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
3229     pairing_cb.is_le_only = TRUE;
3230
3231     cod = COD_UNCLASSIFIED;
3232
3233     HAL_CBACK(bt_hal_cbacks, pin_request_cb,
3234               &bd_addr, &bd_name, cod, FALSE);
3235 }
3236 static void btif_dm_ble_key_nc_req_evt(tBTA_DM_SP_KEY_NOTIF *p_notif_req)
3237 {
3238     /* TODO implement key notification for numeric comparison */
3239     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3240
3241     /* Remote name update */
3242     btif_update_remote_properties(p_notif_req->bd_addr , p_notif_req->bd_name,
3243                                           NULL, BT_DEVICE_TYPE_BLE);
3244
3245     bt_bdaddr_t bd_addr;
3246     bdcpy(bd_addr.address, p_notif_req->bd_addr);
3247
3248     bt_bdname_t bd_name;
3249     memcpy(bd_name.name, p_notif_req->bd_name, BD_NAME_LEN);
3250
3251     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
3252     pairing_cb.is_ssp = FALSE;
3253     pairing_cb.is_le_only = TRUE;
3254     pairing_cb.is_le_nc = TRUE;
3255
3256     HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, &bd_name,
3257               COD_UNCLASSIFIED, BT_SSP_VARIANT_PASSKEY_CONFIRMATION,
3258               p_notif_req->passkey);
3259 }
3260
3261 static void btif_dm_ble_oob_req_evt(tBTA_DM_SP_RMT_OOB *req_oob_type)
3262 {
3263     BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3264
3265     bt_bdaddr_t bd_addr;
3266     bdcpy(bd_addr.address, req_oob_type->bd_addr);
3267
3268     /* We currently support only Security Manager TK as OOB data. We already
3269      * checked if it's present in btif_dm_set_oob_for_le_io_req, but check here
3270      * again. If it's not present do nothing, pairing will timeout.
3271      */
3272     if (is_empty_128bit(oob_cb.oob_data.sm_tk)) {
3273         return;
3274     }
3275
3276     /* make sure OOB data is for this particular device */
3277     if (memcmp(req_oob_type->bd_addr, oob_cb.bdaddr, BD_ADDR_LEN) != 0) {
3278         BTIF_TRACE_WARNING("%s: remote address didn't match OOB data address", __func__);
3279         return;
3280     }
3281
3282     /* Remote name update */
3283     btif_update_remote_properties(req_oob_type->bd_addr , req_oob_type->bd_name,
3284                                           NULL, BT_DEVICE_TYPE_BLE);
3285
3286     bond_state_changed(BT_STATUS_SUCCESS, &bd_addr, BT_BOND_STATE_BONDING);
3287     pairing_cb.is_ssp = FALSE;
3288     pairing_cb.is_le_only = TRUE;
3289     pairing_cb.is_le_nc = FALSE;
3290
3291     BTM_BleOobDataReply(req_oob_type->bd_addr, 0, 16, oob_cb.oob_data.sm_tk);
3292 }
3293
3294 void btif_dm_update_ble_remote_properties( BD_ADDR bd_addr, BD_NAME bd_name,
3295                                            tBT_DEVICE_TYPE dev_type)
3296 {
3297    btif_update_remote_properties(bd_addr,bd_name,NULL,dev_type);
3298 }
3299
3300 static void btif_dm_ble_tx_test_cback(void *p)
3301 {
3302     btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_LE_TX_TEST,
3303                           (char *)p, 1, NULL);
3304 }
3305
3306 static void btif_dm_ble_rx_test_cback(void *p)
3307 {
3308     btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_LE_RX_TEST,
3309                           (char *)p, 1, NULL);
3310 }
3311
3312 static void btif_dm_ble_test_end_cback(void *p)
3313 {
3314     btif_transfer_context(btif_dm_generic_evt, BTIF_DM_CB_LE_TEST_END,
3315                           (char *)p, 3, NULL);
3316 }
3317 /*******************************************************************************
3318 **
3319 ** Function         btif_le_test_mode
3320 **
3321 ** Description     Sends a HCI BLE Test command to the Controller
3322 **
3323 ** Returns          BT_STATUS_SUCCESS on success
3324 **
3325 *******************************************************************************/
3326 bt_status_t btif_le_test_mode(uint16_t opcode, uint8_t *buf, uint8_t len)
3327 {
3328      switch (opcode) {
3329          case HCI_BLE_TRANSMITTER_TEST:
3330              if (len != 3) return BT_STATUS_PARM_INVALID;
3331              BTM_BleTransmitterTest(buf[0],buf[1],buf[2], btif_dm_ble_tx_test_cback);
3332              break;
3333          case HCI_BLE_RECEIVER_TEST:
3334              if (len != 1) return BT_STATUS_PARM_INVALID;
3335              BTM_BleReceiverTest(buf[0], btif_dm_ble_rx_test_cback);
3336              break;
3337          case HCI_BLE_TEST_END:
3338              BTM_BleTestEnd((tBTM_CMPL_CB*) btif_dm_ble_test_end_cback);
3339              break;
3340          default:
3341              BTIF_TRACE_ERROR("%s: Unknown LE Test Mode Command 0x%x", __FUNCTION__, opcode);
3342              return BT_STATUS_UNSUPPORTED;
3343      }
3344      return BT_STATUS_SUCCESS;
3345 }
3346 #endif
3347
3348 void btif_dm_on_disable()
3349 {
3350     /* cancel any pending pairing requests */
3351     if (pairing_cb.state == BT_BOND_STATE_BONDING)
3352     {
3353         bt_bdaddr_t bd_addr;
3354
3355         BTIF_TRACE_DEBUG("%s: Cancel pending pairing request", __FUNCTION__);
3356         bdcpy(bd_addr.address, pairing_cb.bd_addr);
3357         btif_dm_cancel_bond(&bd_addr);
3358     }
3359 }
3360
3361 /*******************************************************************************
3362 **
3363 ** Function         btif_dm_read_energy_info
3364 **
3365 ** Description     Reads the energy info from controller
3366 **
3367 ** Returns         void
3368 **
3369 *******************************************************************************/
3370 void btif_dm_read_energy_info()
3371 {
3372 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
3373     BTA_DmBleGetEnergyInfo(bta_energy_info_cb);
3374 #endif
3375 }
3376
3377 static char* btif_get_default_local_name() {
3378     if (btif_default_local_name[0] == '\0')
3379     {
3380         int max_len = sizeof(btif_default_local_name) - 1;
3381         if (BTM_DEF_LOCAL_NAME[0] != '\0')
3382         {
3383             strncpy(btif_default_local_name, BTM_DEF_LOCAL_NAME, max_len);
3384         }
3385         else
3386         {
3387             char prop_model[PROPERTY_VALUE_MAX];
3388             osi_property_get(PROPERTY_PRODUCT_MODEL, prop_model, "");
3389             strncpy(btif_default_local_name, prop_model, max_len);
3390         }
3391         btif_default_local_name[max_len] = '\0';
3392     }
3393     return btif_default_local_name;
3394 }
3395
3396 static void btif_stats_add_bond_event(const bt_bdaddr_t *bd_addr,
3397                                       bt_bond_function_t function,
3398                                       bt_bond_state_t state) {
3399     pthread_mutex_lock(&bond_event_lock);
3400
3401     btif_bond_event_t* event = &btif_dm_bond_events[btif_events_end_index];
3402     memcpy(&event->bd_addr, bd_addr, sizeof(bt_bdaddr_t));
3403     event->function = function;
3404     event->state = state;
3405     clock_gettime(CLOCK_REALTIME, &event->timestamp);
3406
3407     btif_num_bond_events++;
3408     btif_events_end_index = (btif_events_end_index + 1) % (MAX_BTIF_BOND_EVENT_ENTRIES + 1);
3409     if (btif_events_end_index == btif_events_start_index) {
3410         btif_events_start_index = (btif_events_start_index + 1) % (MAX_BTIF_BOND_EVENT_ENTRIES + 1);
3411     }
3412
3413     int type;
3414     btif_get_device_type(bd_addr->address, &type);
3415
3416     device_type_t device_type;
3417     switch (type) {
3418         case BT_DEVICE_TYPE_BREDR:
3419             device_type = DEVICE_TYPE_BREDR;
3420             break;
3421         case BT_DEVICE_TYPE_BLE:
3422             device_type = DEVICE_TYPE_LE;
3423             break;
3424         case BT_DEVICE_TYPE_DUMO:
3425             device_type = DEVICE_TYPE_DUMO;
3426             break;
3427         default:
3428             device_type = DEVICE_TYPE_UNKNOWN;
3429             break;
3430     }
3431
3432     uint32_t cod = get_cod(bd_addr);
3433     uint64_t ts = event->timestamp.tv_sec * 1000 +
3434                   event->timestamp.tv_nsec / 1000000;
3435     metrics_pair_event(0, ts, cod, device_type);
3436
3437     pthread_mutex_unlock(&bond_event_lock);
3438 }
3439
3440 void btif_debug_bond_event_dump(int fd) {
3441     pthread_mutex_lock(&bond_event_lock);
3442     dprintf(fd, "\nBond Events: \n");
3443     dprintf(fd, "  Total Number of events: %zu\n", btif_num_bond_events);
3444     if (btif_num_bond_events > 0)
3445         dprintf(fd, "  Time          BD_ADDR            Function             State\n");
3446
3447     for (size_t i = btif_events_start_index; i != btif_events_end_index;
3448          i = (i + 1) % (MAX_BTIF_BOND_EVENT_ENTRIES + 1)) {
3449         btif_bond_event_t* event = &btif_dm_bond_events[i];
3450
3451         char eventtime[15];
3452         struct tm *tstamp = localtime(&event->timestamp.tv_sec);
3453         strftime(eventtime, sizeof(eventtime), "%H:%M:%S.%%03u", tstamp);
3454         snprintf(eventtime, sizeof(eventtime), eventtime, (event->timestamp.tv_nsec) / 1000000);
3455
3456         char bdaddr[18];
3457         bdaddr_to_string(&event->bd_addr, bdaddr, sizeof(bdaddr));
3458
3459         char* func_name;
3460         switch (event->function) {
3461             case BTIF_DM_FUNC_CREATE_BOND:
3462                 func_name = "btif_dm_create_bond";
3463                 break;
3464             case BTIF_DM_FUNC_REMOVE_BOND:
3465                 func_name = "btif_dm_remove_bond";
3466                 break;
3467             case BTIF_DM_FUNC_BOND_STATE_CHANGED:
3468                 func_name = "bond_state_changed ";
3469                 break;
3470             default:
3471                 func_name = "Invalid value      ";
3472                 break;
3473         }
3474
3475         char* bond_state;
3476         switch (event->state) {
3477             case BT_BOND_STATE_NONE:
3478                 bond_state = "BOND_STATE_NONE";
3479                 break;
3480             case BT_BOND_STATE_BONDING:
3481                 bond_state = "BOND_STATE_BONDING";
3482                 break;
3483             case BT_BOND_STATE_BONDED:
3484                 bond_state = "BOND_STATE_BONDED";
3485                 break;
3486             default:
3487                 bond_state = "Invalid bond state";
3488                 break;
3489         }
3490         dprintf(fd, "  %s  %s  %s  %s\n", eventtime, bdaddr, func_name, bond_state);
3491     }
3492     pthread_mutex_unlock(&bond_event_lock);
3493 }