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

Commit 9e14742a authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Add Shadow Address Resolution list" am: 19ed873f am: e4b176d9 

Original change: https://android-review.googlesource.com/c/platform/system/bt/+/1870528

Change-Id: Icb46f4bc2a6d2753508223855fd9b23c44317af4
parents dc44d5d9 e4b176d9

system/main/shim/acl.cc

+115 −6
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ 
#include "stack/include/btm_status.h"

#include "stack/include/sec_hci_link_interface.h"

#include "stack/l2cap/l2c_int.h"

#include "types/ble_address_with_type.h"

#include "types/raw_address.h"



extern tBTM_CB btm_cb;
@@ -128,6 +129,51 @@ class ShadowAcceptlist { 
  std::unordered_set<hci::AddressWithType> acceptlist_set_;

};



class ShadowAddressResolutionList {

 public:

  ShadowAddressResolutionList(uint8_t max_address_resolution_size)

      : max_address_resolution_size_(max_address_resolution_size) {}



  bool Add(const hci::AddressWithType& address_with_type) {

    if (address_resolution_set_.size() == max_address_resolution_size_) {

      LOG_ERROR("Address Resolution is full size:%zu",

                address_resolution_set_.size());

      return false;

    }

    if (!address_resolution_set_.insert(address_with_type).second) {

      LOG_WARN("Attempted to add duplicate le address to address_resolution:%s",

               PRIVATE_ADDRESS(address_with_type));

    }

    return true;

  }



  bool Remove(const hci::AddressWithType& address_with_type) {

    auto iter = address_resolution_set_.find(address_with_type);

    if (iter == address_resolution_set_.end()) {

      LOG_WARN("Unknown device being removed from address_resolution:%s",

               PRIVATE_ADDRESS(address_with_type));

      return false;

    }

    address_resolution_set_.erase(iter);

    return true;

  }



  std::unordered_set<hci::AddressWithType> GetCopy() const {

    return address_resolution_set_;

  }



  bool IsFull() const {

    return address_resolution_set_.size() ==

           static_cast<size_t>(max_address_resolution_size_);

  }



  void Clear() { address_resolution_set_.clear(); }



 private:

  uint8_t max_address_resolution_size_{0};

  std::unordered_set<hci::AddressWithType> address_resolution_set_;

};



struct ConnectionDescriptor {

  CreationTime creation_time_;

  TeardownTime teardown_time_;
@@ -676,8 +722,10 @@ class LeShimAclConnection 
};



struct shim::legacy::Acl::impl {

  impl(uint8_t max_acceptlist_size)

      : shadow_acceptlist_(ShadowAcceptlist(max_acceptlist_size)) {}

  impl(uint8_t max_acceptlist_size, uint8_t max_address_resolution_size)

      : shadow_acceptlist_(ShadowAcceptlist(max_acceptlist_size)),

        shadow_address_resolution_list_(

            ShadowAddressResolutionList(max_address_resolution_size)) {}



  std::map<HciHandle, std::unique_ptr<ClassicShimAclConnection>>

      handle_to_classic_connection_map_;
@@ -688,6 +736,7 @@ struct shim::legacy::Acl::impl { 
      FixedQueue<std::unique_ptr<ConnectionDescriptor>>(kConnectionHistorySize);



  ShadowAcceptlist shadow_acceptlist_;

  ShadowAddressResolutionList shadow_address_resolution_list_;



  bool IsClassicAcl(HciHandle handle) {

    return handle_to_classic_connection_map_.find(handle) !=
@@ -858,6 +907,35 @@ struct shim::legacy::Acl::impl { 
    LOG_DEBUG("Cleared entire Le address acceptlist count:%zu", count);

  }



  void AddToAddressResolution(const hci::AddressWithType& address_with_type,

                              const std::array<uint8_t, 16>& peer_irk,

                              const std::array<uint8_t, 16>& local_irk) {

    if (shadow_address_resolution_list_.IsFull()) {

      LOG_WARN("Le Address Resolution list is full");

      return;

    }

    // TODO This should really be added upon successful completion

    shadow_address_resolution_list_.Add(address_with_type);

    GetAclManager()->AddDeviceToResolvingList(address_with_type, peer_irk,

                                              local_irk);

  }



  void RemoveFromAddressResolution(

      const hci::AddressWithType& address_with_type) {

    // TODO This should really be removed upon successful removal

    if (!shadow_address_resolution_list_.Remove(address_with_type)) {

      LOG_WARN("Unable to remove from Le Address Resolution list device:%s",

               PRIVATE_ADDRESS(address_with_type));

    }

    GetAclManager()->RemoveDeviceFromResolvingList(address_with_type);

  }



  void ClearResolvingList() {

    GetAclManager()->ClearResolvingList();

    // TODO This should really be cleared after successful clear status

    shadow_address_resolution_list_.Clear();

  }



  void DumpConnectionHistory() const {

    std::vector<std::string> history =

        connection_history_.ReadElementsAsString();
@@ -882,12 +960,23 @@ struct shim::legacy::Acl::impl { 
    }

    auto acceptlist = shadow_acceptlist_.GetCopy();

    LOG_DUMPSYS(fd,

                "Shadow le accept list  size:%-3zu controller_max_size:%hhu",

                "Shadow le accept list              size:%-3zu "

                "controller_max_size:%hhu",

                acceptlist.size(),

                controller_get_interface()->get_ble_acceptlist_size());

    unsigned cnt = 0;

    for (auto& entry : acceptlist) {

      LOG_DUMPSYS(fd, "%03u le acceptlist:%s", ++cnt, entry.ToString().c_str());

      LOG_DUMPSYS(fd, "  %03u %s", ++cnt, entry.ToString().c_str());

    }

    auto address_resolution_list = shadow_address_resolution_list_.GetCopy();

    LOG_DUMPSYS(fd,

                "Shadow le address resolution list  size:%-3zu "

                "controller_max_size:%hhu",

                address_resolution_list.size(),

                controller_get_interface()->get_ble_resolving_list_max_size());

    cnt = 0;

    for (auto& entry : address_resolution_list) {

      LOG_DUMPSYS(fd, "  %03u %s", ++cnt, entry.ToString().c_str());

    }

  }

#undef DUMPSYS_TAG
@@ -1046,11 +1135,13 @@ void shim::legacy::Acl::Dump(int fd) const { 


shim::legacy::Acl::Acl(os::Handler* handler,

                       const acl_interface_t& acl_interface,

                       uint8_t max_acceptlist_size)

                       uint8_t max_acceptlist_size,

                       uint8_t max_address_resolution_size)

    : handler_(handler), acl_interface_(acl_interface) {

  ASSERT(handler_ != nullptr);

  ValidateAclInterface(acl_interface_);

  pimpl_ = std::make_unique<Acl::impl>(max_acceptlist_size);

  pimpl_ = std::make_unique<Acl::impl>(max_acceptlist_size,

                                       max_address_resolution_size);

  GetAclManager()->RegisterCallbacks(this, handler_);

  GetAclManager()->RegisterLeCallbacks(this, handler_);

  GetController()->RegisterCompletedMonitorAclPacketsCallback(
@@ -1451,3 +1542,21 @@ void shim::legacy::Acl::FinalShutdown() { 
void shim::legacy::Acl::ClearAcceptList() {

  handler_->CallOn(pimpl_.get(), &Acl::impl::clear_acceptlist);

}



void shim::legacy::Acl::AddToAddressResolution(

    const hci::AddressWithType& address_with_type,

    const std::array<uint8_t, 16>& peer_irk,

    const std::array<uint8_t, 16>& local_irk) {

  handler_->CallOn(pimpl_.get(), &Acl::impl::AddToAddressResolution,

                   address_with_type, peer_irk, local_irk);

}



void shim::legacy::Acl::RemoveFromAddressResolution(

    const hci::AddressWithType& address_with_type) {

  handler_->CallOn(pimpl_.get(), &Acl::impl::RemoveFromAddressResolution,

                   address_with_type);

}



void shim::legacy::Acl::ClearAddressResolution() {

  handler_->CallOn(pimpl_.get(), &Acl::impl::ClearResolvingList);

}

system/main/shim/acl.h

+9 −1
Original line number Diff line number Diff line
@@ -42,7 +42,7 @@ class Acl : public hci::acl_manager::ConnectionCallbacks, 
            public LinkPolicyInterface {

 public:

  Acl(os::Handler* handler, const acl_interface_t& acl_interface,

      uint8_t max_acceptlist_size);

      uint8_t max_acceptlist_size, uint8_t max_address_resolution_size);

  ~Acl();



  // hci::acl_manager::ConnectionCallbacks
@@ -75,6 +75,14 @@ class Acl : public hci::acl_manager::ConnectionCallbacks, 
  void DisconnectClassic(uint16_t handle, tHCI_REASON reason) override;

  void DisconnectLe(uint16_t handle, tHCI_REASON reason) override;



  // Address Resolution List

  void AddToAddressResolution(const hci::AddressWithType& address_with_type,

                              const std::array<uint8_t, 16>& peer_irk,

                              const std::array<uint8_t, 16>& local_irk);

  void RemoveFromAddressResolution(

      const hci::AddressWithType& address_with_type);

  void ClearAddressResolution();



  // LinkPolicyInterface

  bool HoldMode(uint16_t hci_handle, uint16_t max_interval,

                uint16_t min_interval) override;

system/main/shim/stack.cc

+2 −1
Original line number Diff line number Diff line
@@ -179,7 +179,8 @@ void Stack::StartEverything() { 
    if (!common::init_flags::gd_core_is_enabled()) {

      acl_ = new legacy::Acl(

          stack_handler_, legacy::GetAclInterface(),

          controller_get_interface()->get_ble_acceptlist_size());

          controller_get_interface()->get_ble_acceptlist_size(),

          controller_get_interface()->get_ble_resolving_list_max_size());

    }

  }

  if (!common::init_flags::gd_core_is_enabled()) {

system/main/test/main_shim_test.cc

+4 −1
Original line number Diff line number Diff line
@@ -61,6 +61,8 @@ using namespace testing; 
namespace test = bluetooth::hci::testing;



const uint8_t kMaxLeAcceptlistSize = 16;

const uint8_t kMaxAddressResolutionSize = kMaxLeAcceptlistSize;



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

tL2C_CB l2cb;

tBTM_CB btm_cb;
@@ -304,7 +306,8 @@ class MainShimTest : public testing::Test { 
                UnregisterCompletedMonitorAclPacketsCallback)

        .Times(1);

    return std::make_unique<shim::legacy::Acl>(handler_, GetMockAclInterface(),

                                               kMaxLeAcceptlistSize);

                                               kMaxLeAcceptlistSize,

                                               kMaxAddressResolutionSize);

  }

};