You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
303 lines
12 KiB
303 lines
12 KiB
/*
|
|
* Copyright 2020 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 "hal/snoop_logger.h"
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
namespace testing {
|
|
|
|
namespace {
|
|
std::vector<uint8_t> kInformationRequest = {
|
|
0xfe,
|
|
0x2e,
|
|
0x0a,
|
|
0x00,
|
|
0x06,
|
|
0x00,
|
|
0x01,
|
|
0x00,
|
|
0x0a,
|
|
0x02,
|
|
0x02,
|
|
0x00,
|
|
0x02,
|
|
0x00,
|
|
};
|
|
|
|
std::vector<uint8_t> kSdpConnectionRequest = {
|
|
0x08, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x02, 0x0c, 0x04, 0x00, 0x01, 0x00, 0x44, 0x00};
|
|
|
|
std::vector<uint8_t> kAvdtpSuspend = {0x02, 0x02, 0x00, 0x07, 0x00, 0x03, 0x00, 0x8d, 0x00, 0x90, 0x09, 0x04};
|
|
|
|
std::vector<uint8_t> kHfpAtNrec0 = {0x02, 0x02, 0x20, 0x13, 0x00, 0x0f, 0x00, 0x41, 0x00, 0x09, 0xff, 0x15,
|
|
0x01, 0x41, 0x54, 0x2b, 0x4e, 0x52, 0x45, 0x43, 0x3d, 0x30, 0x0d, 0x5c};
|
|
|
|
} // namespace
|
|
|
|
using bluetooth::TestModuleRegistry;
|
|
using bluetooth::hal::SnoopLogger;
|
|
|
|
// Expose protected constructor for test
|
|
class TestSnoopLoggerModule : public SnoopLogger {
|
|
public:
|
|
TestSnoopLoggerModule(
|
|
std::string snoop_log_path,
|
|
std::string snooz_log_path,
|
|
size_t max_packets_per_file,
|
|
const std::string& btsnoop_mode)
|
|
: SnoopLogger(std::move(snoop_log_path), std::move(snooz_log_path), max_packets_per_file, btsnoop_mode) {}
|
|
|
|
std::string ToString() const override {
|
|
return std::string("TestSnoopLoggerModule");
|
|
}
|
|
};
|
|
|
|
class SnoopLoggerModuleTest : public Test {
|
|
protected:
|
|
void SetUp() override {
|
|
temp_dir_ = std::filesystem::temp_directory_path();
|
|
temp_snoop_log_ = temp_dir_ / "btsnoop_hci.log";
|
|
temp_snoop_log_last_ = temp_dir_ / "btsnoop_hci.log.last";
|
|
temp_snooz_log_ = temp_dir_ / "btsnooz_hci.log";
|
|
temp_snooz_log_last_ = temp_dir_ / "btsnooz_hci.log.last";
|
|
DeleteSnoopLogFiles();
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snooz_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snooz_log_last_));
|
|
}
|
|
|
|
void TearDown() override {
|
|
DeleteSnoopLogFiles();
|
|
}
|
|
|
|
void DeleteSnoopLogFiles() {
|
|
if (std::filesystem::exists(temp_snoop_log_)) {
|
|
ASSERT_TRUE(std::filesystem::remove(temp_snoop_log_));
|
|
}
|
|
if (std::filesystem::exists(temp_snoop_log_last_)) {
|
|
ASSERT_TRUE(std::filesystem::remove(temp_snoop_log_last_));
|
|
}
|
|
if (std::filesystem::exists(temp_snooz_log_)) {
|
|
ASSERT_TRUE(std::filesystem::remove(temp_snooz_log_));
|
|
}
|
|
if (std::filesystem::exists(temp_snooz_log_last_)) {
|
|
ASSERT_TRUE(std::filesystem::remove(temp_snooz_log_last_));
|
|
}
|
|
}
|
|
|
|
std::filesystem::path temp_dir_;
|
|
std::filesystem::path temp_snoop_log_;
|
|
std::filesystem::path temp_snoop_log_last_;
|
|
std::filesystem::path temp_snooz_log_;
|
|
std::filesystem::path temp_snooz_log_last_;
|
|
};
|
|
|
|
TEST_F(SnoopLoggerModuleTest, empty_snoop_log_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeFull);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_EQ(std::filesystem::file_size(temp_snoop_log_), sizeof(SnoopLogger::FileHeaderType));
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, disable_snoop_log_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeDisabled);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snooz_log_));
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, capture_one_packet_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeFull);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size());
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, capture_hci_cmd_btsnooz_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeDisabled);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snooz_log_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snooz_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size());
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, capture_l2cap_signal_packet_btsnooz_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeDisabled);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
snoop_looger->Capture(kSdpConnectionRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::ACL);
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snooz_log_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snooz_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kSdpConnectionRequest.size());
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, capture_l2cap_short_data_packet_btsnooz_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeDisabled);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
snoop_looger->Capture(kAvdtpSuspend, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::ACL);
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snooz_log_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snooz_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kAvdtpSuspend.size());
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, capture_l2cap_long_data_packet_btsnooz_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeDisabled);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
snoop_looger->Capture(kHfpAtNrec0, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::ACL);
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snooz_log_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snooz_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + 14);
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, rotate_file_at_new_session_test) {
|
|
// Start once
|
|
{
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeFull);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
test_registry.StopAll();
|
|
}
|
|
|
|
// Verify states after test
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_FALSE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size());
|
|
|
|
// Start again
|
|
{
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeFull);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
test_registry.StopAll();
|
|
}
|
|
|
|
// Verify states after test
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + (sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size()) * 2);
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_last_),
|
|
sizeof(SnoopLogger::FileHeaderType) + sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size());
|
|
}
|
|
|
|
TEST_F(SnoopLoggerModuleTest, rotate_file_after_full_test) {
|
|
// Actual test
|
|
auto* snoop_looger = new TestSnoopLoggerModule(
|
|
temp_snoop_log_.string(), temp_snooz_log_.string(), 10, SnoopLogger::kBtSnoopLogModeFull);
|
|
TestModuleRegistry test_registry;
|
|
test_registry.InjectTestModule(&SnoopLogger::Factory, snoop_looger);
|
|
|
|
for (int i = 0; i < 11; i++) {
|
|
snoop_looger->Capture(kInformationRequest, SnoopLogger::Direction::OUTGOING, SnoopLogger::PacketType::CMD);
|
|
}
|
|
|
|
test_registry.StopAll();
|
|
|
|
// Verify states after test
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_));
|
|
ASSERT_TRUE(std::filesystem::exists(temp_snoop_log_last_));
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_),
|
|
sizeof(SnoopLogger::FileHeaderType) + (sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size()) * 1);
|
|
ASSERT_EQ(
|
|
std::filesystem::file_size(temp_snoop_log_last_),
|
|
sizeof(SnoopLogger::FileHeaderType) + (sizeof(SnoopLogger::PacketHeaderType) + kInformationRequest.size()) * 10);
|
|
}
|
|
|
|
} // namespace testing
|