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

Commit 17cb9d4c authored by Chris Manton's avatar Chris Manton Committed by Automerger Merge Worker
Browse files

Use get_btm_client_interface for security calls am: b914dd51 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2786422



Change-Id: Ibcb7316e675b086745b576bf2f6177ff8e35863c
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 79ac3421 b914dd51

system/bta/dm/bta_dm_act.cc

+50 −35
Original line number Diff line number Diff line
@@ -711,13 +711,13 @@ void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 
  tBTA_DM_SEC sec_event;

  const char* p_name;



  tBTM_STATUS status =

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

  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)) {

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

    sec_event.auth_cmpl.bd_addr = bd_addr;

    p_name = BTM_SecReadDevName(bd_addr);

    p_name = get_btm_client_interface().security.BTM_SecReadDevName(bd_addr);

    if (p_name != NULL) {

      memcpy(sec_event.auth_cmpl.bd_name, p_name, BD_NAME_LEN);

      sec_event.auth_cmpl.bd_name[BD_NAME_LEN] = 0;
@@ -745,7 +745,7 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) { 


  APPL_TRACE_EVENT(" bta_dm_bond_cancel ");



  status = BTM_SecBondCancel(bd_addr);

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



  if (bta_dm_cb.p_sec_cback &&

      (status != BTM_CMD_STARTED && status != BTM_SUCCESS)) {
@@ -758,21 +758,25 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) { 
/** Send the pin_reply to a request from BTM */

void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {

  if (msg->accept) {

    BTM_PINCodeReply(msg->bd_addr, BTM_SUCCESS, msg->pin_len, msg->p_pin);

    get_btm_client_interface().security.BTM_PINCodeReply(

        msg->bd_addr, BTM_SUCCESS, msg->pin_len, msg->p_pin);

  } else {

    BTM_PINCodeReply(msg->bd_addr, BTM_NOT_AUTHORIZED, 0, NULL);

    get_btm_client_interface().security.BTM_PINCodeReply(

        msg->bd_addr, BTM_NOT_AUTHORIZED, 0, NULL);

  }

}



/** Send the user confirm request reply in response to a request from BTM */

void bta_dm_confirm(const RawAddress& bd_addr, bool accept) {

  BTM_ConfirmReqReply(accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, bd_addr);

  get_btm_client_interface().security.BTM_ConfirmReqReply(

      accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, bd_addr);

}



/** respond to the OOB data request for the remote device from BTM */

void bta_dm_ci_rmt_oob_act(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {

  BTM_RemoteOobDataReply(msg->accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED,

                         msg->bd_addr, msg->c, msg->r);

  get_btm_client_interface().security.BTM_RemoteOobDataReply(

      msg->accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, msg->bd_addr, msg->c,

      msg->r);

}



/*******************************************************************************
@@ -856,8 +860,9 @@ static uint8_t bta_dm_pin_cback(const RawAddress& bd_addr, DEV_CLASS dev_class, 
    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);

    if ((BTM_ReadRemoteDeviceName(bd_addr, bta_dm_pinname_cback,

                                  BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)

    if ((get_btm_client_interface().peer.BTM_ReadRemoteDeviceName(

            bd_addr, bta_dm_pinname_cback, BT_TRANSPORT_BR_EDR)) ==

        BTM_CMD_STARTED)

      return BTM_CMD_STARTED;



    APPL_TRACE_WARNING(
@@ -910,8 +915,8 @@ static uint8_t bta_dm_new_link_key_cback(const RawAddress& bd_addr, 
  sec_event.auth_cmpl.fail_reason = HCI_SUCCESS;



  // Report the BR link key based on the BR/EDR address and type

  BTM_ReadDevInfo(bd_addr, &sec_event.auth_cmpl.dev_type,

                  &sec_event.auth_cmpl.addr_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);



  // Setting remove_dev_pending flag to false, where it will avoid deleting
@@ -949,7 +954,8 @@ static void bta_dm_authentication_complete_cback( 
      sec_event.auth_cmpl.bd_name[BD_NAME_LEN] = 0;



      // Report the BR link key based on the BR/EDR address and type

      BTM_ReadDevInfo(bd_addr, &sec_event.auth_cmpl.dev_type,

      get_btm_client_interface().peer.BTM_ReadDevInfo(

          bd_addr, &sec_event.auth_cmpl.dev_type,

          &sec_event.auth_cmpl.addr_type);

      sec_event.auth_cmpl.fail_reason = reason;
@@ -1055,7 +1061,8 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 


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

          {

            const tBTM_STATUS btm_status = BTM_ReadRemoteDeviceName(

            const tBTM_STATUS btm_status =

                get_btm_client_interface().peer.BTM_ReadRemoteDeviceName(

                    p_data->cfm_req.bd_addr, bta_dm_pinname_cback,

                    BT_TRANSPORT_BR_EDR);

            switch (btm_status) {
@@ -1078,7 +1085,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event, 
          bta_dm_cb.pin_bd_addr = p_data->key_notif.bd_addr;

          BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class,

                                p_data->key_notif.dev_class);

          if ((BTM_ReadRemoteDeviceName(

          if ((get_btm_client_interface().peer.BTM_ReadRemoteDeviceName(

                  p_data->key_notif.bd_addr, bta_dm_pinname_cback,

                  BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)

            return BTM_CMD_STARTED;
@@ -1558,12 +1565,15 @@ static void bta_dm_reset_sec_dev_pending(const RawAddress& remote_bd_addr) { 
 *

 ******************************************************************************/

static void bta_dm_remove_sec_dev_entry(const RawAddress& remote_bd_addr) {

  if (BTM_IsAclConnectionUp(remote_bd_addr, BT_TRANSPORT_LE) ||

      BTM_IsAclConnectionUp(remote_bd_addr, BT_TRANSPORT_BR_EDR)) {

  if (get_btm_client_interface().peer.BTM_IsAclConnectionUp(remote_bd_addr,

                                                            BT_TRANSPORT_LE) ||

      get_btm_client_interface().peer.BTM_IsAclConnectionUp(

          remote_bd_addr, BT_TRANSPORT_BR_EDR)) {

    APPL_TRACE_DEBUG(

        "%s ACL is not down. Schedule for  Dev Removal when ACL closes",

        __func__);

    BTM_SecClearSecurityFlags(remote_bd_addr);

    get_btm_client_interface().security.BTM_SecClearSecurityFlags(

        remote_bd_addr);

    for (int i = 0; i < bta_dm_cb.device_list.count; i++) {

      auto& dev = bta_dm_cb.device_list.peer_device[i];

      if (dev.peer_bdaddr == remote_bd_addr) {
@@ -2155,8 +2165,9 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport, 
    return;

  }



  if (BTM_SetEncryption(bd_addr, transport, bta_dm_encrypt_cback, NULL,

                        sec_act) == BTM_CMD_STARTED) {

  if (get_btm_client_interface().security.BTM_SetEncryption(

          bd_addr, transport, bta_dm_encrypt_cback, NULL, sec_act) ==

      BTM_CMD_STARTED) {

    device->p_encrypt_cback = p_callback;

    LOG_DEBUG("Started encryption peer:%s transport:%s",

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bt_transport_text(transport).c_str());
@@ -2251,7 +2262,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 


    case BTM_LE_CONSENT_REQ_EVT:

      sec_event.ble_req.bd_addr = bda;

      p_name = BTM_SecReadDevName(bda);

      p_name = get_btm_client_interface().security.BTM_SecReadDevName(bda);

      if (p_name != NULL)

        strlcpy((char*)sec_event.ble_req.bd_name, p_name, BD_NAME_LEN);

      else
@@ -2261,7 +2272,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 


    case BTM_LE_SEC_REQUEST_EVT:

      sec_event.ble_req.bd_addr = bda;

      p_name = BTM_SecReadDevName(bda);

      p_name = get_btm_client_interface().security.BTM_SecReadDevName(bda);

      if (p_name != NULL)

        strlcpy((char*)sec_event.ble_req.bd_name, p_name, BD_NAME_LEN + 1);

      else
@@ -2271,7 +2282,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 


    case BTM_LE_KEY_NOTIF_EVT:

      sec_event.key_notif.bd_addr = bda;

      p_name = BTM_SecReadDevName(bda);

      p_name = get_btm_client_interface().security.BTM_SecReadDevName(bda);

      if (p_name != NULL)

        strlcpy((char*)sec_event.key_notif.bd_name, p_name, BD_NAME_LEN + 1);

      else
@@ -2328,7 +2339,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda, 
      sec_event.auth_cmpl.bd_addr = bda;

      BTM_ReadDevInfo(bda, &sec_event.auth_cmpl.dev_type,

                      &sec_event.auth_cmpl.addr_type);

      p_name = BTM_SecReadDevName(bda);

      p_name = get_btm_client_interface().security.BTM_SecReadDevName(bda);

      if (p_name != NULL)

        strlcpy((char*)sec_event.auth_cmpl.bd_name, p_name, (BD_NAME_LEN + 1));

      else
@@ -2454,7 +2465,8 @@ static uint8_t bta_dm_sirk_verifiction_cback(const RawAddress& bd_addr) { 
 ******************************************************************************/

void bta_dm_add_blekey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,

                       tBTM_LE_KEY_TYPE key_type) {

  BTM_SecAddBleKey(bd_addr, (tBTM_LE_KEY_VALUE*)&blekey, key_type);

  get_btm_client_interface().security.BTM_SecAddBleKey(

      bd_addr, (tBTM_LE_KEY_VALUE*)&blekey, key_type);

}



/*******************************************************************************
@@ -2471,7 +2483,8 @@ void bta_dm_add_blekey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey, 
 ******************************************************************************/

void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,

                           tBT_DEVICE_TYPE dev_type) {

  BTM_SecAddBleDevice(bd_addr, dev_type, addr_type);

  get_btm_client_interface().security.BTM_SecAddBleDevice(bd_addr, dev_type,

                                                          addr_type);

}



/*******************************************************************************
@@ -2488,14 +2501,15 @@ void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 
 ******************************************************************************/

void bta_dm_ble_passkey_reply(const RawAddress& bd_addr, bool accept,

                              uint32_t passkey) {

  BTM_BlePasskeyReply(bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED,

                      passkey);

  get_btm_client_interface().ble.BTM_BlePasskeyReply(

      bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, passkey);

}



/** This is response to SM numeric comparison request submitted to application.

 */

void bta_dm_ble_confirm_reply(const RawAddress& bd_addr, bool accept) {

  BTM_BleConfirmReply(bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED);

  get_btm_client_interface().ble.BTM_BleConfirmReply(

      bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED);

}



/** This function set the preferred connection parameters */
@@ -2506,8 +2520,9 @@ void bta_dm_ble_set_conn_params(const RawAddress& bd_addr, 
  L2CA_AdjustConnectionIntervals(&conn_int_min, &conn_int_max,

                                 BTM_BLE_CONN_INT_MIN);



  BTM_BleSetPrefConnParams(bd_addr, conn_int_min, conn_int_max,

                           peripheral_latency, supervision_tout);

  get_btm_client_interface().ble.BTM_BleSetPrefConnParams(

      bd_addr, conn_int_min, conn_int_max, peripheral_latency,

      supervision_tout);

}



/** This function update LE connection parameters */

system/bta/test/bta_dm_test.cc

+19 −12
Original line number Diff line number Diff line
@@ -261,10 +261,11 @@ TEST_F(BtaDmTest, bta_dm_set_encryption) { 
  device->p_encrypt_cback = nullptr;



  // Setup a device that fails encryption

  test::mock::stack_btm_sec::BTM_SetEncryption.body =

  btm_client_interface.security.BTM_SetEncryption =

      [](const RawAddress& bd_addr, tBT_TRANSPORT transport,

         tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,

         tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {

    inc_func_call_count("BTM_SetEncryption");

    return BTM_MODE_UNSUPPORTED;

  };
@@ -274,17 +275,19 @@ TEST_F(BtaDmTest, bta_dm_set_encryption) { 
  device->p_encrypt_cback = nullptr;



  // Setup a device that successfully starts encryption

  test::mock::stack_btm_sec::BTM_SetEncryption.body =

  btm_client_interface.security.BTM_SetEncryption =

      [](const RawAddress& bd_addr, tBT_TRANSPORT transport,

         tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,

         tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS { return BTM_CMD_STARTED; };

         tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {

    inc_func_call_count("BTM_SetEncryption");

    return BTM_CMD_STARTED;

  };



  bta_dm_set_encryption(kRawAddress, transport, BTA_DM_ENCRYPT_CBACK, sec_act);

  ASSERT_EQ(2, get_func_call_count("BTM_SetEncryption"));

  ASSERT_EQ(0UL, BTA_DM_ENCRYPT_CBACK_queue.size());

  ASSERT_NE(nullptr, device->p_encrypt_cback);



  test::mock::stack_btm_sec::BTM_SetEncryption = {};

  BTA_DM_ENCRYPT_CBACK_queue = {};

}
@@ -578,6 +581,10 @@ TEST_F(BtaDmTest, bta_dm_remote_name_cmpl) { 
TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithName) {

  constexpr uint32_t kNumVal = 1234;

  static bool callback_sent = false;

  btm_client_interface.peer.BTM_ReadRemoteDeviceName =

      [](const RawAddress& remote_bda, tBTM_NAME_CMPL_CB* p_cb,

         tBT_TRANSPORT transport) -> tBTM_STATUS { return BTM_CMD_STARTED; };



  static tBTA_DM_SP_CFM_REQ cfm_req{};

  bta_dm_enable([](tBTA_DM_SEC_EVT event, tBTA_DM_SEC* p_data) {

    callback_sent = true;
@@ -625,9 +632,9 @@ TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithName) { 
TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRSuccess) {

  constexpr uint32_t kNumVal = 1234;

  static bool callback_sent = false;

  test::mock::stack_btm_inq::BTM_ReadRemoteDeviceName.body =

  btm_client_interface.peer.BTM_ReadRemoteDeviceName =

      [](const RawAddress& remote_bda, tBTM_NAME_CMPL_CB* p_cb,

         tBT_TRANSPORT transport) { return BTM_CMD_STARTED; };

         tBT_TRANSPORT transport) -> tBTM_STATUS { return BTM_CMD_STARTED; };



  static tBTA_DM_SP_CFM_REQ cfm_req{};

  bta_dm_enable([](tBTA_DM_SEC_EVT event, tBTA_DM_SEC* p_data) {
@@ -659,16 +666,14 @@ TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRSuccess) { 
                BTM_SP_CFM_REQ_EVT, &data)));

  ASSERT_EQ(kNumVal, bta_dm_cb.num_val);

  ASSERT_FALSE(callback_sent);



  test::mock::stack_btm_inq::BTM_ReadRemoteDeviceName = {};

}



TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRFail) {

  constexpr uint32_t kNumVal = 1234;

  static bool callback_sent = false;

  test::mock::stack_btm_inq::BTM_ReadRemoteDeviceName.body =

  btm_client_interface.peer.BTM_ReadRemoteDeviceName =

      [](const RawAddress& remote_bda, tBTM_NAME_CMPL_CB* p_cb,

         tBT_TRANSPORT transport) { return BTM_SUCCESS; };

         tBT_TRANSPORT transport) -> tBTM_STATUS { return BTM_SUCCESS; };



  static tBTA_DM_SP_CFM_REQ cfm_req{};

  bta_dm_enable([](tBTA_DM_SEC_EVT event, tBTA_DM_SEC* p_data) {
@@ -710,13 +715,15 @@ TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRFail) { 
  ASSERT_EQ(BTM_AUTH_SP_YES, cfm_req.rmt_auth_req);

  ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.loc_io_caps);

  ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.rmt_io_caps);



  test::mock::stack_btm_inq::BTM_ReadRemoteDeviceName = {};

}



TEST_F(BtaDmTest, bta_dm_sp_cback__BTM_SP_KEY_NOTIF_EVT) {

  constexpr uint32_t kPassKey = 1234;

  static bool callback_sent = false;

  btm_client_interface.peer.BTM_ReadRemoteDeviceName =

      [](const RawAddress& remote_bda, tBTM_NAME_CMPL_CB* p_cb,

         tBT_TRANSPORT transport) -> tBTM_STATUS { return BTM_CMD_STARTED; };



  static tBTA_DM_SP_KEY_NOTIF key_notif{};

  bta_dm_enable([](tBTA_DM_SEC_EVT event, tBTA_DM_SEC* p_data) {

    callback_sent = true;