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

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

Merge "Streamline bta/dm/bta_dm_act::bta_dm_set_encryption" am: 5d83f84b am: f595403b 

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



Change-Id: I9d80c36230f44622f86db9752e40c2e83e5c7e20
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fd3ae7cd f595403b

system/bta/dm/bta_dm_act.cc

+45 −18
Original line number Diff line number Diff line
@@ -3208,6 +3208,16 @@ void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding) { 
}

#endif



static tBTA_DM_PEER_DEVICE* find_connected_device(

    const RawAddress& bd_addr, UNUSED_ATTR tBT_TRANSPORT transport) {

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

    if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == bd_addr &&

        bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED)

      return &bta_dm_cb.device_list.peer_device[i];

  }

  return nullptr;

}



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

 *

 * Function         bta_dm_encrypt_cback
@@ -3263,29 +3273,35 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport, 
void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,

                           tBTA_DM_ENCRYPT_CBACK* p_callback,

                           tBTM_BLE_SEC_ACT sec_act) {

  uint8_t i;



  APPL_TRACE_DEBUG("bta_dm_set_encryption");  // todo

  if (!p_callback) {

    APPL_TRACE_ERROR("bta_dm_set_encryption callback is not provided");

  if (p_callback == nullptr) {

    LOG_ERROR("bta_dm_set_encryption callback is not provided");

    return;

  }

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

    if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == bd_addr &&

        bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED)

      break;



  tBTA_DM_PEER_DEVICE* device = find_connected_device(bd_addr, transport);

  if (device == nullptr) {

    LOG_ERROR("Unable to find active ACL connection device:%s transport:%s",

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

    return;

  }

  if (i < bta_dm_cb.device_list.count) {

    if (bta_dm_cb.device_list.peer_device[i].p_encrypt_cback) {

      APPL_TRACE_ERROR("earlier enc was not done for same device");



  if (device->p_encrypt_cback) {

    LOG_ERROR(

        "Unable to start encryption as already in progress peer:%s "

        "transport:%s",

        PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

    (*p_callback)(bd_addr, transport, BTA_BUSY);

    return;

  }



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

                        sec_act) == BTM_CMD_STARTED) {

      bta_dm_cb.device_list.peer_device[i].p_encrypt_cback = p_callback;

    }

    device->p_encrypt_cback = p_callback;

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

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

  } else {

    LOG_ERROR("Unable to start encryption process peer:%s transport:%s",

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

  }

}
@@ -4078,3 +4094,14 @@ void bta_dm_process_delete_key_RC_to_unpair(const RawAddress& bd_addr) 
    bta_dm_cb.p_sec_cback(BTA_DM_REPORT_BONDING_EVT, &param);

}



namespace bluetooth {

namespace legacy {

namespace testing {

tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,

                                         tBT_TRANSPORT transport) {

  return ::allocate_device_for(bd_addr, transport);

}



}  // namespace testing

}  // namespace legacy

}  // namespace bluetooth

system/bta/test/bta_dm_test.cc

+97 −0
Original line number Diff line number Diff line
@@ -18,14 +18,21 @@ 
#include <base/location.h>

#include <gtest/gtest.h>



#include <chrono>



#include "bta/dm/bta_dm_int.h"

#include "bta/hf_client/bta_hf_client_int.h"

#include "bta/include/bta_api.h"

#include "bta/include/bta_dm_api.h"

#include "bta/include/bta_hf_client_api.h"

#include "btif/include/stack_manager.h"

#include "common/message_loop_thread.h"

#include "stack/include/btm_status.h"

#include "test/mock/mock_osi_alarm.h"

#include "test/mock/mock_stack_acl.h"

#include "test/mock/mock_stack_btm_sec.h"



using namespace std::chrono_literals;



std::map<std::string, int> mock_function_count_map;
@@ -39,6 +46,12 @@ class MessageLoop; 


namespace {

constexpr uint8_t kUnusedTimer = BTA_ID_MAX;



const char* test_flags[] = {

    "INIT_logging_debug_enabled_for_all=true",

    nullptr,

};



}  // namespace



struct alarm_t {
@@ -50,6 +63,7 @@ class BtaDmTest : public testing::Test { 
 protected:

  void SetUp() override {

    mock_function_count_map.clear();

    bluetooth::common::InitFlags::Load(test_flags);

    test::mock::osi_alarm::alarm_new.body = [](const char* name) -> alarm_t* {

      return new alarm_t(name);

    };
@@ -175,3 +189,86 @@ TEST_F(BtaDmTest, disable_second_pass_with_acl_links) { 
  test::mock::stack_acl::BTM_GetNumAclLinks = {};

  test::mock::osi_alarm::alarm_set_on_mloop = {};

}



namespace {



struct BTA_DM_ENCRYPT_CBACK_parms {

  const RawAddress bd_addr;

  tBT_TRANSPORT transport;

  tBTA_STATUS result;

};



std::queue<BTA_DM_ENCRYPT_CBACK_parms> BTA_DM_ENCRYPT_CBACK_queue;



void BTA_DM_ENCRYPT_CBACK(const RawAddress& bd_addr, tBT_TRANSPORT transport,

                          tBTA_STATUS result) {

  BTA_DM_ENCRYPT_CBACK_queue.push({bd_addr, transport, result});

}



}  // namespace



namespace bluetooth {

namespace legacy {

namespace testing {

tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,

                                         tBT_TRANSPORT transport);

}  // namespace testing

}  // namespace legacy

}  // namespace bluetooth



TEST_F(BtaDmTest, bta_dm_set_encryption) {

  const RawAddress bd_addr{{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}};

  const tBT_TRANSPORT transport{BT_TRANSPORT_LE};

  const tBTM_BLE_SEC_ACT sec_act{BTM_BLE_SEC_NONE};



  // Callback not provided

  bta_dm_set_encryption(bd_addr, transport, nullptr, sec_act);



  // Device connection does not exist

  bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);



  // Setup a connected device

  tBTA_DM_PEER_DEVICE* device =

      bluetooth::legacy::testing::allocate_device_for(bd_addr, transport);

  ASSERT_TRUE(device != nullptr);

  device->conn_state = BTA_DM_CONNECTED;

  device->p_encrypt_cback = nullptr;



  // Setup a device that is busy with another encryption

  // Fake indication that the encryption is in progress with non-null callback

  device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;

  bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);

  ASSERT_EQ(0, mock_function_count_map["BTM_SetEncryption"]);

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

  auto params = BTA_DM_ENCRYPT_CBACK_queue.front();

  BTA_DM_ENCRYPT_CBACK_queue.pop();

  ASSERT_EQ(BTA_BUSY, params.result);

  device->p_encrypt_cback = nullptr;



  // Setup a device that fails encryption

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

      [](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_MODE_UNSUPPORTED;

  };



  bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);

  ASSERT_EQ(1, mock_function_count_map["BTM_SetEncryption"]);

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

  device->p_encrypt_cback = nullptr;



  // Setup a device that successfully starts encryption

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

      [](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; };



  bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);

  ASSERT_EQ(2, mock_function_count_map["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 = {};

}

system/test/mock/mock_stack_btm_sec.cc

+15 −0
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ extern std::map<std::string, int> mock_function_count_map; 
#include "stack/include/btm_status.h"

#include "stack/include/l2cap_security_interface.h"

#include "stack/smp/smp_int.h"

#include "test/mock/mock_stack_btm_sec.h"

#include "types/raw_address.h"



#ifndef UNUSED_ATTR
@@ -146,11 +147,25 @@ tBTM_STATUS BTM_SecBondCancel(const RawAddress& bd_addr) { 
  mock_function_count_map[__func__]++;

  return BTM_SUCCESS;

}

namespace test {

namespace mock {

namespace stack_btm_sec {



struct BTM_SetEncryption BTM_SetEncryption;



}

}  // namespace mock

}  // namespace test



tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,

                              tBT_TRANSPORT transport,

                              tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,

                              tBTM_BLE_SEC_ACT sec_act) {

  mock_function_count_map[__func__]++;

  if (test::mock::stack_btm_sec::BTM_SetEncryption.body) {

    return test::mock::stack_btm_sec::BTM_SetEncryption.body(

        bd_addr, transport, p_callback, p_ref_data, sec_act);

  }

  return BTM_SUCCESS;

}

tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr,

system/test/mock/mock_stack_btm_sec.h

0 → 100644
+42 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <map>

#include <string>



extern std::map<std::string, int> mock_function_count_map;



namespace test {

namespace mock {

namespace stack_btm_sec {



// Function state capture and return values, if needed

struct BTM_SetEncryption {

  std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport,

                            tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,

                            tBTM_BLE_SEC_ACT sec_act)>

      body{};

  tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,

                         tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,

                         tBTM_BLE_SEC_ACT sec_act) {

    return body(bd_addr, transport, p_callback, p_ref_data, sec_act);

  };

};

extern struct BTM_SetEncryption BTM_SetEncryption;



}  // namespace stack_btm_sec

}  // namespace mock

}  // namespace test