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

Commit ee42c3c1 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 5821394 from beeb32dd to rvc-release 

Change-Id: Iead571737e891157ae22e3188125dcd8be8f8cbd
parents 93133d2d beeb32dd

system/gd/common/address.h

+1 −0
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ namespace std { 
template <>

struct hash<bluetooth::common::Address> {

  std::size_t operator()(const bluetooth::common::Address& val) const {

    static_assert(sizeof(uint64_t) >= bluetooth::common::Address::kLength);

    uint64_t int_addr = 0;

    memcpy(reinterpret_cast<uint8_t*>(&int_addr), val.address, bluetooth::common::Address::kLength);

    return std::hash<uint64_t>{}(int_addr);

system/gd/common/testing/bind_test_util.h

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

 * Copyright 2019 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.

 */



#pragma once



#include "base/test/bind_test_util.h"



namespace bluetooth {

namespace common {

namespace testing {



using base::BindLambdaForTesting;



}  // namespace testing

}  // namespace common

}  // namespace bluetooth

system/gd/hci/cert/cert.cc

+2 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include "common/blocking_queue.h"

#include "grpc/grpc_event_stream.h"

#include "hci/cert/api.grpc.pb.h"

#include "hci/classic_security_manager.h"

#include "hci/controller.h"

#include "hci/hci_layer.h"

#include "hci/hci_packets.h"
@@ -321,6 +322,7 @@ void AclManagerCertModule::ListDependencies(ModuleList* list) { 
  ::bluetooth::grpc::GrpcFacadeModule::ListDependencies(list);

  list->add<Controller>();

  list->add<HciLayer>();

  list->add<ClassicSecurityManager>();

}



void AclManagerCertModule::Start() {

system/gd/hci/classic_security_manager.cc

+19 −8
Original line number Diff line number Diff line
@@ -39,10 +39,15 @@ struct ClassicSecurityManager::impl { 
    hci_layer_ = classic_security_manager_.GetDependency<HciLayer>();

    handler_ = classic_security_manager_.GetHandler();

    hci_layer_->RegisterEventHandler(EventCode::IO_CAPABILITY_REQUEST,

                                     Bind(&impl::on_io_capbility_request, common::Unretained(this)), handler_);



                                     Bind(&impl::on_request_event, common::Unretained(this)), handler_);

    hci_layer_->RegisterEventHandler(EventCode::AUTHENTICATION_COMPLETE,

                                     Bind(&impl::on_authentication_complete, common::Unretained(this)), handler_);

    hci_layer_->RegisterEventHandler(EventCode::LINK_KEY_REQUEST,

                                     Bind(&impl::on_request_event, common::Unretained(this)), handler_);

    hci_layer_->RegisterEventHandler(EventCode::PIN_CODE_REQUEST,

                                     Bind(&impl::on_request_event, common::Unretained(this)), handler_);

    hci_layer_->RegisterEventHandler(EventCode::ENCRYPTION_KEY_REFRESH_COMPLETE,

                                     Bind(&impl::on_complete_event, common::Unretained(this)), handler_);

  }



  void Stop() {
@@ -174,9 +179,8 @@ struct ClassicSecurityManager::impl { 


  void refresh_encryption_key(uint16_t connection_handle) {

    std::unique_ptr<RefreshEncryptionKeyBuilder> packet = RefreshEncryptionKeyBuilder::Create(connection_handle);

    // TODO wait for CommandStatusView

    hci_layer_->EnqueueCommand(std::move(packet),

                               common::BindOnce(&impl::on_command_complete, common::Unretained(this)), handler_);

    hci_layer_->EnqueueCommand(std::move(packet), common::BindOnce([](CommandStatusView status) { /* TODO: check? */ }),

                               handler_);

  }



  void read_simple_pairing_mode() {
@@ -225,13 +229,20 @@ struct ClassicSecurityManager::impl { 
  }



  // TODO remove

  void on_io_capbility_request(EventPacketView packet) {

    LOG_DEBUG("CYDBG on_io_capbility_request");

  void on_request_event(EventPacketView packet) {

    EventCode event_code = packet.GetEventCode();

    LOG_DEBUG("receive request %d", (uint8_t)event_code);

  }



  // TODO remove

  void on_complete_event(EventPacketView packet) {

    EventCode event_code = packet.GetEventCode();

    LOG_DEBUG("receive complete event %d", (uint8_t)event_code);

  }



  // TODO remove

  void on_authentication_complete(EventPacketView packet) {

    LOG_DEBUG("CYDBG on_authentication_complete");

    LOG_DEBUG("on_authentication_complete");

  }



  void on_command_complete(CommandCompleteView status) {

system/gd/hci/classic_security_manager_test.cc

+41 −22
Original line number Diff line number Diff line
@@ -76,6 +76,7 @@ class TestHciLayer : public HciLayer { 
  }



  std::unique_ptr<CommandQueueEntry> GetLastCommand() {

    EXPECT_FALSE(command_queue_.empty());

    auto last = std::move(command_queue_.front());

    command_queue_.pop();

    return last;
@@ -121,6 +122,9 @@ class ClassicSecurityManagerTest : public ::testing::Test, public ::bluetooth::h 
    test_hci_layer_->RegisterEventHandler(

        EventCode::COMMAND_COMPLETE, base::Bind(&ClassicSecurityManagerTest::ExpectCommand, common::Unretained(this)),

        nullptr);

    test_hci_layer_->RegisterEventHandler(

        EventCode::COMMAND_STATUS,

        base::Bind(&ClassicSecurityManagerTest::ExpectCommandStatus, common::Unretained(this)), nullptr);



    Address::FromString("A1:A2:A3:A4:A5:A6", remote);

  }
@@ -154,6 +158,21 @@ class ClassicSecurityManagerTest : public ::testing::Test, public ::bluetooth::h 
    command_complete_ = true;

  }



  void ExpectCommandStatus(EventPacketView packet) {

    CommandStatusView command_status_view = CommandStatusView::Create(std::move(packet));

    auto last_command_queue_entry = test_hci_layer_->GetLastCommand();

    auto last_command = std::move(last_command_queue_entry->command);

    auto command_packet = GetPacketView(std::move(last_command));

    CommandPacketView command_packet_view = CommandPacketView::Create(command_packet);



    // verify command complete event match last command opcode

    EXPECT_TRUE(command_packet_view.IsValid());

    EXPECT_TRUE(command_status_view.IsValid());

    EXPECT_EQ(command_packet_view.GetOpCode(), command_status_view.GetCommandOpCode());



    command_complete_ = true;

  }



  void OnCommandComplete(CommandCompleteView status) override {

    callback_done.notify_one();

  }
@@ -175,7 +194,7 @@ TEST_F(ClassicSecurityManagerTest, send_link_key_request_reply) { 
  common::LinkKey link_key;

  common::LinkKey::FromString("4c68384139f574d836bcf34e9dfb01bf\0", link_key);

  classic_security_manager_->LinkKeyRequestReply(remote, link_key);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -185,7 +204,7 @@ TEST_F(ClassicSecurityManagerTest, send_link_key_request_reply) { 


TEST_F(ClassicSecurityManagerTest, send_link_key_request_negative_reply) {

  classic_security_manager_->LinkKeyRequestNegativeReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -195,7 +214,7 @@ TEST_F(ClassicSecurityManagerTest, send_link_key_request_negative_reply) { 


TEST_F(ClassicSecurityManagerTest, send_pin_code_request_reply) {

  classic_security_manager_->PinCodeRequestReply(remote, 6, "123456");

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -205,7 +224,7 @@ TEST_F(ClassicSecurityManagerTest, send_pin_code_request_reply) { 


TEST_F(ClassicSecurityManagerTest, send_pin_code_request_negative_reply) {

  classic_security_manager_->PinCodeRequestNegativeReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -218,7 +237,7 @@ TEST_F(ClassicSecurityManagerTest, send_io_capability_request_reply) { 
  OobDataPresent oob_present = (OobDataPresent)0x00;

  AuthenticationRequirements authentication_requirements = (AuthenticationRequirements)0x00;

  classic_security_manager_->IoCapabilityRequestReply(remote, io_capability, oob_present, authentication_requirements);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -229,7 +248,7 @@ TEST_F(ClassicSecurityManagerTest, send_io_capability_request_reply) { 
TEST_F(ClassicSecurityManagerTest, send_io_capability_request_negative_reply) {

  ErrorCode reason = (ErrorCode)0x01;

  classic_security_manager_->IoCapabilityRequestNegativeReply(remote, reason);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -239,7 +258,7 @@ TEST_F(ClassicSecurityManagerTest, send_io_capability_request_negative_reply) { 


TEST_F(ClassicSecurityManagerTest, send_user_confirmation_request_reply) {

  classic_security_manager_->UserConfirmationRequestReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -249,7 +268,7 @@ TEST_F(ClassicSecurityManagerTest, send_user_confirmation_request_reply) { 


TEST_F(ClassicSecurityManagerTest, send_user_confirmation_request_negative_reply) {

  classic_security_manager_->UserConfirmationRequestNegativeReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -259,7 +278,7 @@ TEST_F(ClassicSecurityManagerTest, send_user_confirmation_request_negative_reply 


TEST_F(ClassicSecurityManagerTest, send_user_passkey_request_reply) {

  classic_security_manager_->UserPasskeyRequestReply(remote, 999999);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -269,7 +288,7 @@ TEST_F(ClassicSecurityManagerTest, send_user_passkey_request_reply) { 


TEST_F(ClassicSecurityManagerTest, send_user_passkey_request_negative_reply) {

  classic_security_manager_->UserPasskeyRequestNegativeReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -285,7 +304,7 @@ TEST_F(ClassicSecurityManagerTest, send_remote_oob_data_request_reply) { 
    r[i] = (uint8_t)i + 16;

  }

  classic_security_manager_->RemoteOobDataRequestReply(remote, c, r);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -295,7 +314,7 @@ TEST_F(ClassicSecurityManagerTest, send_remote_oob_data_request_reply) { 


TEST_F(ClassicSecurityManagerTest, send_remote_oob_data_request_negative_reply) {

  classic_security_manager_->RemoteOobDataRequestNegativeReply(remote);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -306,7 +325,7 @@ TEST_F(ClassicSecurityManagerTest, send_remote_oob_data_request_negative_reply) 
TEST_F(ClassicSecurityManagerTest, send_read_stored_link_key) {

  ReadStoredLinkKeyReadAllFlag read_all_flag = (ReadStoredLinkKeyReadAllFlag)0x01;

  classic_security_manager_->ReadStoredLinkKey(remote, read_all_flag);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -317,7 +336,7 @@ TEST_F(ClassicSecurityManagerTest, send_read_stored_link_key) { 
TEST_F(ClassicSecurityManagerTest, send_delete_stored_link_key) {

  DeleteStoredLinkKeyDeleteAllFlag delete_all_flag = (DeleteStoredLinkKeyDeleteAllFlag)0x01;

  classic_security_manager_->DeleteStoredLinkKey(remote, delete_all_flag);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -327,17 +346,17 @@ TEST_F(ClassicSecurityManagerTest, send_delete_stored_link_key) { 


TEST_F(ClassicSecurityManagerTest, send_refresh_encryption_key) {

  classic_security_manager_->RefreshEncryptionKey(0x01);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(

      CommandCompleteBuilder::Create(0x01, OpCode::REFRESH_ENCRYPTION_KEY, std::move(payload)));

      CommandStatusBuilder::Create(ErrorCode::SUCCESS, 0x01, OpCode::REFRESH_ENCRYPTION_KEY, std::move(payload)));

  EXPECT_TRUE(command_complete_);

}



TEST_F(ClassicSecurityManagerTest, send_read_simple_pairing_mode) {

  classic_security_manager_->ReadSimplePairingMode();

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -348,7 +367,7 @@ TEST_F(ClassicSecurityManagerTest, send_read_simple_pairing_mode) { 
TEST_F(ClassicSecurityManagerTest, send_write_simple_pairing_mode) {

  Enable simple_pairing_mode = (Enable)0x01;

  classic_security_manager_->WriteSimplePairingMode(simple_pairing_mode);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -358,7 +377,7 @@ TEST_F(ClassicSecurityManagerTest, send_write_simple_pairing_mode) { 


TEST_F(ClassicSecurityManagerTest, send_read_local_oob_data) {

  classic_security_manager_->ReadLocalOobData();

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(CommandCompleteBuilder::Create(0x01, OpCode::READ_LOCAL_OOB_DATA, std::move(payload)));
@@ -368,7 +387,7 @@ TEST_F(ClassicSecurityManagerTest, send_read_local_oob_data) { 
TEST_F(ClassicSecurityManagerTest, send_keypress_notification) {

  KeypressNotificationType notification_type = (KeypressNotificationType)0x01;

  classic_security_manager_->SendKeypressNotification(remote, notification_type);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -378,7 +397,7 @@ TEST_F(ClassicSecurityManagerTest, send_keypress_notification) { 


TEST_F(ClassicSecurityManagerTest, send_read_local_oob_extended_data) {

  classic_security_manager_->ReadLocalOobExtendedData();

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(
@@ -388,7 +407,7 @@ TEST_F(ClassicSecurityManagerTest, send_read_local_oob_extended_data) { 


TEST_F(ClassicSecurityManagerTest, send_read_encryption_key_size) {

  classic_security_manager_->ReadEncryptionKeySize(0x01);

  fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));

  EXPECT_TRUE(fake_registry_.SynchronizeModuleHandler(&ClassicSecurityManager::Factory, std::chrono::milliseconds(20)));



  auto payload = std::make_unique<RawBuilder>();

  test_hci_layer_->IncomingEvent(