Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 15ba8b21 authored by Hui Peng's avatar Hui Peng Committed by Gerrit Code Review
Browse files

Merge "[Invisalign2] Separate security related fields from bta_dm_cb" into main

parents 8321af27 2a2692d2

system/bta/dm/bta_dm_act.cc

+10 −6
Original line number Diff line number Diff line
@@ -199,6 +199,8 @@ void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback, 
static void bta_dm_init_cb(void) {

  bta_dm_cb = {};

  bta_dm_acl_cb = {};

  bta_dm_sec_cb = {};



  bta_dm_cb.disable_timer = alarm_new("bta_dm.disable_timer");

  bta_dm_cb.switch_delay_timer = alarm_new("bta_dm.switch_delay_timer");

  for (size_t i = 0; i < BTA_DM_NUM_PM_TIMER; i++) {
@@ -232,6 +234,7 @@ static void bta_dm_deinit_cb(void) { 
  }

  bta_dm_cb = {};

  bta_dm_acl_cb = {};

  bta_dm_sec_cb = {};

}



void BTA_dm_on_hw_off() {
@@ -257,13 +260,14 @@ void BTA_dm_on_hw_on() { 
  tBTA_BLE_LOCAL_ID_KEYS id_key;



  /* save callbacks */

  temp_sec_cback = bta_dm_cb.p_sec_cback;

  temp_sec_cback = bta_dm_sec_cb.p_sec_cback;

  temp_acl_cback = bta_dm_acl_cb.p_acl_cback;



  /* make sure the control block is properly initialized */

  bta_dm_init_cb();



  /* and restore the callbacks */

  bta_dm_cb.p_sec_cback = temp_sec_cback;

  bta_dm_sec_cb.p_sec_cback = temp_sec_cback;

  bta_dm_acl_cb.p_acl_cback = temp_acl_cback;
@@ -488,10 +492,10 @@ void bta_dm_process_remove_device(const RawAddress& bd_addr) { 
  /* Conclude service search if it was pending */

  bta_dm_disc_remove_device(bd_addr);



  if (bta_dm_cb.p_sec_cback) {

  if (bta_dm_sec_cb.p_sec_cback) {

    tBTA_DM_SEC sec_event;

    sec_event.dev_unpair.bd_addr = bd_addr;

    bta_dm_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &sec_event);

    bta_dm_sec_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &sec_event);

  }

}
@@ -874,12 +878,12 @@ static void bta_dm_acl_down(const RawAddress& bd_addr, 
  }



  // TODO: reorganize and factor out the following logic

  if (issue_unpair_cb && bta_dm_cb.p_sec_cback) {

  if (issue_unpair_cb && bta_dm_sec_cb.p_sec_cback) {

    tBTA_DM_SEC conn{};

    conn.dev_unpair.bd_addr = bd_addr;

    conn.dev_unpair.transport_link_type = transport;



    bta_dm_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &conn);

    bta_dm_sec_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &conn);

  }



  bta_dm_adjust_roles(true);

system/bta/dm/bta_dm_int.h

+0 −44
Original line number Diff line number Diff line
@@ -109,27 +109,6 @@ typedef struct { 
  BT_HDR_RIGID hdr;

} tBTA_DM_API_DISCOVERY_CANCEL;



typedef struct {

  RawAddress bd_addr;

  bool accept;

  uint8_t pin_len;

  uint8_t p_pin[PIN_CODE_LEN];

} tBTA_DM_API_PIN_REPLY;



typedef struct {

  BT_HDR_RIGID hdr;

  RawAddress bd_addr;

  tBTM_IO_CAP io_cap;

  tBTM_OOB_DATA oob_data;

  tBTM_AUTH_REQ auth_req;

} tBTA_DM_CI_IO_REQ;



typedef struct {

  RawAddress bd_addr;

  Octet16 c;

  Octet16 r;

  bool accept;

} tBTA_DM_CI_RMT_OOB;



typedef struct {

  BT_HDR_RIGID hdr;
@@ -156,16 +135,6 @@ typedef struct { 
  tSDP_RESULT sdp_result;

} tBTA_DM_SDP_RESULT;



typedef struct {

  RawAddress bd_addr;

  DEV_CLASS dc;

  LinkKey link_key;

  uint8_t key_type;

  bool link_key_known;

  bool dc_known;

  BD_NAME bd_name;

  uint8_t pin_length;

} tBTA_DM_API_ADD_DEVICE;



typedef struct {

  BT_HDR_RIGID hdr;
@@ -353,8 +322,6 @@ typedef struct { 
/* DM control block */

typedef struct {

  tBTA_DM_ACTIVE_LINK device_list;

  tBTA_DM_SEC_CBACK* p_sec_cback;

  tBTA_DM_SEC_CBACK* p_sec_sirk_cback;

  tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback;

  bool disabling;

  alarm_t* disable_timer;
@@ -362,17 +329,6 @@ typedef struct { 
  tBTA_PM_TIMER pm_timer[BTA_DM_NUM_PM_TIMER];

  uint8_t cur_av_count;   /* current AV connecions */



  /* Storage for pin code request parameters */

  RawAddress pin_bd_addr;

  DEV_CLASS pin_dev_class;

  tBTA_DM_SEC_EVT pin_evt;

  tBTM_IO_CAP loc_io_caps;    /* IO Capabilities of local device */

  tBTM_IO_CAP rmt_io_caps;    /* IO Capabilities of remote device */

  tBTM_AUTH_REQ loc_auth_req; /* Authentication required for local device */

  tBTM_AUTH_REQ rmt_auth_req;

  uint32_t num_val; /* the numeric value for comparison. If just_works, do not

                       show this number to UI */

  bool just_works;  /* true, if "Just Works" association model */

#if (BTA_EIR_CANNED_UUID_LIST != TRUE)

  /* store UUID list for EIR */

  uint32_t eir_uuid[BTM_EIR_SERVICE_ARRAY_SIZE];

system/bta/dm/bta_dm_main.cc

+3 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 


#include "bt_trace.h"

#include "bta/dm/bta_dm_disc.h"

#include "bta/dm/bta_dm_sec.h"

#include "bta/dm/bta_dm_gatt_client.h"

#include "bta/dm/bta_dm_int.h"

#include "gd/common/circular_buffer.h"
@@ -39,6 +40,8 @@ tBTA_DM_ACL_CB bta_dm_acl_cb; 
tBTA_DM_CB bta_dm_cb;

tBTA_DM_DI_CB bta_dm_di_cb;



tBTA_DM_SEC_CB bta_dm_sec_cb;



#define DUMPSYS_TAG "shim::legacy::bta::dm"

void DumpsysBtaDm(int fd) {

  LOG_DUMPSYS_TITLE(fd, DUMPSYS_TAG);

system/bta/dm/bta_dm_sec.cc

+66 −63
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 


#include <cstdint>



#include "bta/dm/bta_dm_sec.h"



#include "bta/dm/bta_dm_act.h"

#include "bta/dm/bta_dm_disc.h"

#include "bta/dm/bta_dm_int.h"
@@ -77,7 +79,7 @@ void bta_dm_ble_sirk_sec_cb_register(tBTA_DM_SEC_CBACK* p_cback) { 
  /* Save the callback to be called when a request of member validation will be

   * needed. */

  LOG_DEBUG("");

  bta_dm_cb.p_sec_sirk_cback = p_cback;

  bta_dm_sec_cb.p_sec_sirk_cback = p_cback;

}



void bta_dm_ble_sirk_confirm_device_reply(const RawAddress& bd_addr,
@@ -108,7 +110,7 @@ void bta_dm_sec_enable(tBTA_DM_SEC_CBACK* p_sec_cback) { 
  /* make sure security callback is saved - if no callback, do not erase the

  previous one,

  it could be an error recovery mechanism */

  if (p_sec_cback != NULL) bta_dm_cb.p_sec_cback = p_sec_cback;

  if (p_sec_cback != NULL) bta_dm_sec_cb.p_sec_cback = p_sec_cback;



  btm_local_io_caps = btif_storage_get_local_io_caps();

}
@@ -153,7 +155,7 @@ void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 
  tBTM_STATUS status = get_btm_client_interface().security.BTM_SecBond(

      bd_addr, addr_type, transport, device_type, 0, NULL);



  if (bta_dm_cb.p_sec_cback && (status != BTM_CMD_STARTED)) {

  if (bta_dm_sec_cb.p_sec_cback && (status != BTM_CMD_STARTED)) {

    memset(&sec_event, 0, sizeof(tBTA_DM_SEC));

    sec_event.auth_cmpl.bd_addr = bd_addr;

    p_name = get_btm_client_interface().security.BTM_SecReadDevName(bd_addr);
@@ -173,7 +175,7 @@ void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 
      /* delete this device entry from Sec Dev DB */

      bta_dm_remove_sec_dev_entry(bd_addr);

    }

    bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

    bta_dm_sec_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

  }

}
@@ -186,11 +188,11 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) { 


  status = get_btm_client_interface().security.BTM_SecBondCancel(bd_addr);



  if (bta_dm_cb.p_sec_cback &&

  if (bta_dm_sec_cb.p_sec_cback &&

      (status != BTM_CMD_STARTED && status != BTM_SUCCESS)) {

    sec_event.bond_cancel_cmpl.result = BTA_FAILURE;



    bta_dm_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);

    bta_dm_sec_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);

  }

}
@@ -231,12 +233,12 @@ static void bta_dm_pinname_cback(const tBTM_REMOTE_DEV_NAME* p_data) { 
  tBTM_REMOTE_DEV_NAME* p_result = (tBTM_REMOTE_DEV_NAME*)p_data;

  tBTA_DM_SEC sec_event;

  uint32_t bytes_to_copy;

  tBTA_DM_SEC_EVT event = bta_dm_cb.pin_evt;

  tBTA_DM_SEC_EVT event = bta_dm_sec_cb.pin_evt;



  if (BTA_DM_SP_CFM_REQ_EVT == event) {

    /* Retrieved saved device class and bd_addr */

    sec_event.cfm_req.bd_addr = bta_dm_cb.pin_bd_addr;

    BTA_COPY_DEVICE_CLASS(sec_event.cfm_req.dev_class, bta_dm_cb.pin_dev_class);

    sec_event.cfm_req.bd_addr = bta_dm_sec_cb.pin_bd_addr;

    BTA_COPY_DEVICE_CLASS(sec_event.cfm_req.dev_class, bta_dm_sec_cb.pin_dev_class);



    if (p_result && p_result->status == BTM_SUCCESS) {

      bytes_to_copy =
@@ -248,20 +250,20 @@ static void bta_dm_pinname_cback(const tBTM_REMOTE_DEV_NAME* p_data) { 
      sec_event.cfm_req.bd_name[0] = 0;



    sec_event.key_notif.passkey =

        bta_dm_cb.num_val; /* get PIN code numeric number */

        bta_dm_sec_cb.num_val; /* get PIN code numeric number */



    /* 1 additional event data fields for this event */

    sec_event.cfm_req.just_works = bta_dm_cb.just_works;

    sec_event.cfm_req.just_works = bta_dm_sec_cb.just_works;

    /* retrieve the loc and rmt caps */

    sec_event.cfm_req.loc_io_caps = bta_dm_cb.loc_io_caps;

    sec_event.cfm_req.rmt_io_caps = bta_dm_cb.rmt_io_caps;

    sec_event.cfm_req.loc_auth_req = bta_dm_cb.loc_auth_req;

    sec_event.cfm_req.rmt_auth_req = bta_dm_cb.rmt_auth_req;

    sec_event.cfm_req.loc_io_caps = bta_dm_sec_cb.loc_io_caps;

    sec_event.cfm_req.rmt_io_caps = bta_dm_sec_cb.rmt_io_caps;

    sec_event.cfm_req.loc_auth_req = bta_dm_sec_cb.loc_auth_req;

    sec_event.cfm_req.rmt_auth_req = bta_dm_sec_cb.rmt_auth_req;



  } else {

    /* Retrieved saved device class and bd_addr */

    sec_event.pin_req.bd_addr = bta_dm_cb.pin_bd_addr;

    BTA_COPY_DEVICE_CLASS(sec_event.pin_req.dev_class, bta_dm_cb.pin_dev_class);

    sec_event.pin_req.bd_addr = bta_dm_sec_cb.pin_bd_addr;

    BTA_COPY_DEVICE_CLASS(sec_event.pin_req.dev_class, bta_dm_sec_cb.pin_dev_class);



    if (p_result && p_result->status == BTM_SUCCESS) {

      bytes_to_copy = (p_result->length < BD_NAME_LEN) ? p_result->length
@@ -272,12 +274,12 @@ static void bta_dm_pinname_cback(const tBTM_REMOTE_DEV_NAME* p_data) { 
    } else /* No name found */

      sec_event.pin_req.bd_name[0] = 0;



    event = bta_dm_cb.pin_evt;

    event = bta_dm_sec_cb.pin_evt;

    sec_event.key_notif.passkey =

        bta_dm_cb.num_val; /* get PIN code numeric number */

        bta_dm_sec_cb.num_val; /* get PIN code numeric number */

  }



  if (bta_dm_cb.p_sec_cback) bta_dm_cb.p_sec_cback(event, &sec_event);

  if (bta_dm_sec_cb.p_sec_cback) bta_dm_sec_cb.p_sec_cback(event, &sec_event);

}



/*******************************************************************************
@@ -291,14 +293,14 @@ static void bta_dm_pinname_cback(const tBTM_REMOTE_DEV_NAME* p_data) { 
 ******************************************************************************/

static uint8_t bta_dm_pin_cback(const RawAddress& bd_addr, DEV_CLASS dev_class,

                                const tBTM_BD_NAME bd_name, bool min_16_digit) {

  if (!bta_dm_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

  if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;



  /* If the device name is not known, save bdaddr and devclass and initiate a

   * name request */

  if (bd_name[0] == 0) {

    bta_dm_cb.pin_evt = BTA_DM_PIN_REQ_EVT;

    bta_dm_cb.pin_bd_addr = bd_addr;

    BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, dev_class);

    bta_dm_sec_cb.pin_evt = BTA_DM_PIN_REQ_EVT;

    bta_dm_sec_cb.pin_bd_addr = bd_addr;

    BTA_COPY_DEVICE_CLASS(bta_dm_sec_cb.pin_dev_class, dev_class);

    if ((get_btm_client_interface().peer.BTM_ReadRemoteDeviceName(

            bd_addr, bta_dm_pinname_cback, BT_TRANSPORT_BR_EDR)) ==

        BTM_CMD_STARTED)
@@ -315,7 +317,7 @@ static uint8_t bta_dm_pin_cback(const RawAddress& bd_addr, DEV_CLASS dev_class, 
  strlcpy((char*)sec_event.pin_req.bd_name, (char*)bd_name, BD_NAME_LEN + 1);

  sec_event.pin_req.min_16_digit = min_16_digit;



  bta_dm_cb.p_sec_cback(BTA_DM_PIN_REQ_EVT, &sec_event);

  bta_dm_sec_cb.p_sec_cback(BTA_DM_PIN_REQ_EVT, &sec_event);

  return BTM_CMD_STARTED;

}
@@ -356,7 +358,7 @@ static uint8_t bta_dm_new_link_key_cback(const RawAddress& bd_addr, 
  // Report the BR link key based on the BR/EDR address and type

  get_btm_client_interface().peer.BTM_ReadDevInfo(

      bd_addr, &sec_event.auth_cmpl.dev_type, &sec_event.auth_cmpl.addr_type);

  if (bta_dm_cb.p_sec_cback) bta_dm_cb.p_sec_cback(event, &sec_event);

  if (bta_dm_sec_cb.p_sec_cback) bta_dm_sec_cb.p_sec_cback(event, &sec_event);



  // Setting remove_dev_pending flag to false, where it will avoid deleting

  // the
@@ -381,7 +383,7 @@ static void bta_dm_authentication_complete_cback( 
    const RawAddress& bd_addr, UNUSED_ATTR DEV_CLASS dev_class,

    tBTM_BD_NAME bd_name, tHCI_REASON reason) {

  if (reason != HCI_SUCCESS) {

    if (bta_dm_cb.p_sec_cback) {

    if (bta_dm_sec_cb.p_sec_cback) {

      // Build out the security event data structure

      tBTA_DM_SEC sec_event = {

          .auth_cmpl =
@@ -398,7 +400,7 @@ static void bta_dm_authentication_complete_cback( 
          &sec_event.auth_cmpl.addr_type);

      sec_event.auth_cmpl.fail_reason = reason;



      bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

    }



    switch (reason) {
@@ -435,7 +437,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 
  tBTA_DM_SEC_EVT pin_evt = BTA_DM_SP_KEY_NOTIF_EVT;



  APPL_TRACE_EVENT("bta_dm_sp_cback: %d", event);

  if (!bta_dm_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

  if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;



  bool sp_rmt_result = false;

  /* TODO_SP */
@@ -458,7 +460,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 


    case BTM_SP_CFM_REQ_EVT:

      pin_evt = BTA_DM_SP_CFM_REQ_EVT;

      bta_dm_cb.just_works = sec_event.cfm_req.just_works =

      bta_dm_sec_cb.just_works = sec_event.cfm_req.just_works =

          p_data->cfm_req.just_works;

      sec_event.cfm_req.loc_auth_req = p_data->cfm_req.loc_auth_req;

      sec_event.cfm_req.rmt_auth_req = p_data->cfm_req.rmt_auth_req;
@@ -478,7 +480,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 


      // TODO PleaseFix: This assignment only works with event

      // BTM_SP_KEY_NOTIF_EVT

      bta_dm_cb.num_val = sec_event.key_notif.passkey =

      bta_dm_sec_cb.num_val = sec_event.key_notif.passkey =

          p_data->key_notif.passkey;



      if (BTM_SP_CFM_REQ_EVT == event) {
@@ -492,14 +494,14 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 
        /* Due to the switch case falling through below to BTM_SP_KEY_NOTIF_EVT,

           call remote name request using values from cfm_req */

        if (p_data->cfm_req.bd_name[0] == 0) {

          bta_dm_cb.pin_evt = pin_evt;

          bta_dm_cb.pin_bd_addr = p_data->cfm_req.bd_addr;

          bta_dm_cb.rmt_io_caps = sec_event.cfm_req.rmt_io_caps;

          bta_dm_cb.loc_io_caps = sec_event.cfm_req.loc_io_caps;

          bta_dm_cb.rmt_auth_req = sec_event.cfm_req.rmt_auth_req;

          bta_dm_cb.loc_auth_req = sec_event.cfm_req.loc_auth_req;



          dev_class_copy(bta_dm_cb.pin_dev_class, p_data->cfm_req.dev_class);

          bta_dm_sec_cb.pin_evt = pin_evt;

          bta_dm_sec_cb.pin_bd_addr = p_data->cfm_req.bd_addr;

          bta_dm_sec_cb.rmt_io_caps = sec_event.cfm_req.rmt_io_caps;

          bta_dm_sec_cb.loc_io_caps = sec_event.cfm_req.loc_io_caps;

          bta_dm_sec_cb.rmt_auth_req = sec_event.cfm_req.rmt_auth_req;

          bta_dm_sec_cb.loc_auth_req = sec_event.cfm_req.loc_auth_req;



          dev_class_copy(bta_dm_sec_cb.pin_dev_class, p_data->cfm_req.dev_class);

          {

            const tBTM_STATUS btm_status = BTM_ReadRemoteDeviceName(

                p_data->cfm_req.bd_addr, bta_dm_pinname_cback,
@@ -520,9 +522,9 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 
        /* If the device name is not known, save bdaddr and devclass

           and initiate a name request with values from key_notif */

        if (p_data->key_notif.bd_name[0] == 0) {

          bta_dm_cb.pin_evt = pin_evt;

          bta_dm_cb.pin_bd_addr = p_data->key_notif.bd_addr;

          BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class,

          bta_dm_sec_cb.pin_evt = pin_evt;

          bta_dm_sec_cb.pin_bd_addr = p_data->key_notif.bd_addr;

          BTA_COPY_DEVICE_CLASS(bta_dm_sec_cb.pin_dev_class,

                                p_data->key_notif.dev_class);

          if ((BTM_ReadRemoteDeviceName(

                  p_data->key_notif.bd_addr, bta_dm_pinname_cback,
@@ -540,7 +542,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 
        }

      }



      bta_dm_cb.p_sec_cback(pin_evt, &sec_event);

      bta_dm_sec_cb.p_sec_cback(pin_evt, &sec_event);



      break;
@@ -653,8 +655,8 @@ static void bta_dm_bond_cancel_complete_cback(tBTM_STATUS result) { 
  else

    sec_event.bond_cancel_cmpl.result = BTA_FAILURE;



  if (bta_dm_cb.p_sec_cback) {

    bta_dm_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);

  if (bta_dm_sec_cb.p_sec_cback) {

    bta_dm_sec_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);

  }

}
@@ -713,7 +715,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
  tBTA_DM_SEC sec_event;

  const char* p_name = NULL;



  if (!bta_dm_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

  if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;



  memset(&sec_event, 0, sizeof(tBTA_DM_SEC));

  switch (event) {
@@ -732,7 +734,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
        strlcpy((char*)sec_event.ble_req.bd_name, p_name, BD_NAME_LEN);

      else

        sec_event.ble_req.bd_name[0] = 0;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_CONSENT_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_CONSENT_REQ_EVT, &sec_event);

      break;



    case BTM_LE_SEC_REQUEST_EVT:
@@ -742,7 +744,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
        strlcpy((char*)sec_event.ble_req.bd_name, p_name, BD_NAME_LEN + 1);

      else

        sec_event.ble_req.bd_name[0] = 0;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_SEC_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_SEC_REQ_EVT, &sec_event);

      break;



    case BTM_LE_KEY_NOTIF_EVT:
@@ -753,30 +755,31 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
      else

        sec_event.key_notif.bd_name[0] = 0;

      sec_event.key_notif.passkey = p_data->key_notif;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_NOTIF_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_NOTIF_EVT, &sec_event);

      break;



    case BTM_LE_KEY_REQ_EVT:

      sec_event.ble_req.bd_addr = bda;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_REQ_EVT, &sec_event);

      break;



    case BTM_LE_OOB_REQ_EVT:

      sec_event.ble_req.bd_addr = bda;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_OOB_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_OOB_REQ_EVT, &sec_event);

      break;



    case BTM_LE_NC_REQ_EVT:

      sec_event.key_notif.bd_addr = bda;

      // TODO: get rid of this

      strlcpy((char*)sec_event.key_notif.bd_name, bta_dm_get_remname(),

              (BD_NAME_LEN + 1));

      sec_event.key_notif.passkey = p_data->key_notif;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_NC_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_NC_REQ_EVT, &sec_event);

      break;



    case BTM_LE_SC_OOB_REQ_EVT:

      sec_event.ble_req.bd_addr = bda;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_SC_OOB_REQ_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_SC_OOB_REQ_EVT, &sec_event);

      break;



    case BTM_LE_SC_LOC_OOB_EVT:
@@ -784,14 +787,14 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
      local_oob_data.local_oob_c = p_data->local_oob_data.commitment;

      local_oob_data.local_oob_r = p_data->local_oob_data.randomizer;

      sec_event.local_oob_data = local_oob_data;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_SC_CR_LOC_OOB_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_SC_CR_LOC_OOB_EVT, &sec_event);

      break;



    case BTM_LE_KEY_EVT:

      sec_event.ble_key.bd_addr = bda;

      sec_event.ble_key.key_type = p_data->key.key_type;

      sec_event.ble_key.p_key_value = p_data->key.p_key_value;

      bta_dm_cb.p_sec_cback(BTA_DM_BLE_KEY_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_KEY_EVT, &sec_event);

      break;



    case BTM_LE_COMPLT_EVT:
@@ -830,16 +833,16 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
          GATT_ConfigServiceChangeCCC(bda, true, BT_TRANSPORT_LE);

      }



      if (bta_dm_cb.p_sec_cback) {

        // bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

        bta_dm_cb.p_sec_cback(BTA_DM_BLE_AUTH_CMPL_EVT, &sec_event);

      if (bta_dm_sec_cb.p_sec_cback) {

        // bta_dm_sec_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);

        bta_dm_sec_cb.p_sec_cback(BTA_DM_BLE_AUTH_CMPL_EVT, &sec_event);

      }

      break;



    case BTM_LE_ADDR_ASSOC_EVT:

      sec_event.proc_id_addr.pairing_bda = bda;

      sec_event.proc_id_addr.id_addr = p_data->id_addr;

      bta_dm_cb.p_sec_cback(BTA_DM_LE_ADDR_ASSOC_EVT, &sec_event);

      bta_dm_sec_cb.p_sec_cback(BTA_DM_LE_ADDR_ASSOC_EVT, &sec_event);

      break;



    default:
@@ -969,7 +972,7 @@ static void bta_dm_ble_id_key_cback(uint8_t key_type, 
  switch (key_type) {

    case BTM_BLE_KEY_TYPE_ID:

    case BTM_BLE_KEY_TYPE_ER:

      if (bta_dm_cb.p_sec_cback) {

      if (bta_dm_sec_cb.p_sec_cback) {

        tBTA_DM_SEC dm_key = {

            .ble_id_keys = {},

        };
@@ -978,7 +981,7 @@ static void bta_dm_ble_id_key_cback(uint8_t key_type, 
        tBTA_DM_SEC_EVT evt = (key_type == BTM_BLE_KEY_TYPE_ID)

                                  ? BTA_DM_BLE_LOCAL_IR_EVT

                                  : BTA_DM_BLE_LOCAL_ER_EVT;

        bta_dm_cb.p_sec_cback(evt, &dm_key);

        bta_dm_sec_cb.p_sec_cback(evt, &dm_key);

      }

      break;
@@ -1003,9 +1006,9 @@ static uint8_t bta_dm_sirk_verifiction_cback(const RawAddress& bd_addr) { 
                               .bd_addr = bd_addr,

                           }};



  if (bta_dm_cb.p_sec_sirk_cback) {

  if (bta_dm_sec_cb.p_sec_sirk_cback) {

    LOG_DEBUG("callback called");

    bta_dm_cb.p_sec_sirk_cback(BTA_DM_SIRK_VERIFICATION_REQ_EVT, &sec_event);

    bta_dm_sec_cb.p_sec_sirk_cback(BTA_DM_SIRK_VERIFICATION_REQ_EVT, &sec_event);

    return BTM_CMD_STARTED;

  }

system/bta/dm/bta_dm_sec.h

+51 −1
Original line number Diff line number Diff line
@@ -18,10 +18,60 @@ 


#include <memory>



#include "bta/dm/bta_dm_int.h"

#include "bta/include/bta_api.h"

#include "osi/include/osi.h"  // UNUSED_ATTR



typedef struct {

  RawAddress bd_addr;

  bool accept;

  uint8_t pin_len;

  uint8_t p_pin[PIN_CODE_LEN];

} tBTA_DM_API_PIN_REPLY;



typedef struct {

  BT_HDR_RIGID hdr;

  RawAddress bd_addr;

  tBTM_IO_CAP io_cap;

  tBTM_OOB_DATA oob_data;

  tBTM_AUTH_REQ auth_req;

} tBTA_DM_CI_IO_REQ;



typedef struct {

  RawAddress bd_addr;

  Octet16 c;

  Octet16 r;

  bool accept;

} tBTA_DM_CI_RMT_OOB;



typedef struct {

  RawAddress bd_addr;

  DEV_CLASS dc;

  LinkKey link_key;

  uint8_t key_type;

  bool link_key_known;

  bool dc_known;

  BD_NAME bd_name;

  uint8_t pin_length;

} tBTA_DM_API_ADD_DEVICE;



typedef struct {

  tBTA_DM_SEC_CBACK* p_sec_cback;

  tBTA_DM_SEC_CBACK* p_sec_sirk_cback;

/* Storage for pin code request parameters */

  RawAddress pin_bd_addr;

  DEV_CLASS pin_dev_class;

  tBTA_DM_SEC_EVT pin_evt;

  tBTM_IO_CAP loc_io_caps;    /* IO Capabilities of local device */

  tBTM_IO_CAP rmt_io_caps;    /* IO Capabilities of remote device */

  tBTM_AUTH_REQ loc_auth_req; /* Authentication required for local device */

  tBTM_AUTH_REQ rmt_auth_req;

  uint32_t num_val; /* the numeric value for comparison. If just_works, do not

                       show this number to UI */

  bool just_works;  /* true, if "Just Works" association model */

} tBTA_DM_SEC_CB;



extern tBTA_DM_SEC_CB bta_dm_sec_cb;



void bta_dm_sec_enable(tBTA_DM_SEC_CBACK* p_sec_cback);



void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,