gd/btaa/linux_generic/hci_processor.cc - platform/system/bt - Git at Google

 /*
  * Copyright 2021 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 "btaa/hci_processor.h"

 #include "os/log.h"

 namespace bluetooth {
 namespace activity_attribution {

 void DeviceParser::match_handle_with_address(uint16_t connection_handle, hci::Address& address) {
   if (connection_handle && !address.IsEmpty()) {
     connection_lookup_table_[connection_handle] = address;
   } else if (connection_handle) {
     if (connection_lookup_table_.find(connection_handle) != connection_lookup_table_.end()) {
       address = connection_lookup_table_[connection_handle];
     }
   }
 }

 void HciProcessor::process_le_event(
     std::vector<BtaaHciPacket>& btaa_hci_packets, int16_t byte_count, hci::EventView& event) {
   uint16_t connection_handle_value = 0;
   hci::Address address_value;

   auto le_packet_view = hci::LeMetaEventView::Create(event);
   if (!le_packet_view.IsValid()) {
     return;
   }

   auto subevent_code = le_packet_view.GetSubeventCode();
   auto le_event_info = lookup_le_event(subevent_code);

   if (le_event_info.activity != Activity::UNKNOWN) {
     // lookup_le_event returns all simple classic event which does not require additional processing.
     if (le_event_info.connection_handle_pos) {
       auto connection_handle_it = event.begin() + le_event_info.connection_handle_pos;
       connection_handle_value = connection_handle_it.extract<uint16_t>();
     }
     if (le_event_info.address_pos) {
       auto address_value_it = event.begin() + le_event_info.address_pos;
       address_value = address_value_it.extract<hci::Address>();
     }
     device_parser_.match_handle_with_address(connection_handle_value, address_value);
     btaa_hci_packets.push_back(BtaaHciPacket(le_event_info.activity, address_value, byte_count));
   }
 }

 void HciProcessor::process_special_event(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     hci::EventCode event_code,
     uint16_t byte_count,
     hci::EventView& event) {
   uint16_t avg_byte_count;
   hci::Address address_value;

   switch (event_code) {
     case hci::EventCode::INQUIRY_RESULT:
     case hci::EventCode::INQUIRY_RESULT_WITH_RSSI: {
       auto packet_view = hci::InquiryResultView::Create(event);
       if (!packet_view.IsValid()) {
         return;
       }
       auto inquiry_results = packet_view.GetInquiryResults();
       avg_byte_count = byte_count / inquiry_results.size();
       for (auto& inquiry_result : inquiry_results) {
         btaa_hci_packets.push_back(BtaaHciPacket(Activity::SCAN, inquiry_result.bd_addr_, avg_byte_count));
       }
     } break;

     case hci::EventCode::NUMBER_OF_COMPLETED_PACKETS: {
       auto packet_view = hci::NumberOfCompletedPacketsView::Create(event);
       if (!packet_view.IsValid()) {
         return;
       }
       auto completed_packets = packet_view.GetCompletedPackets();
       avg_byte_count = byte_count / completed_packets.size();
       for (auto& completed_packet : completed_packets) {
         device_parser_.match_handle_with_address(completed_packet.connection_handle_, address_value);
         btaa_hci_packets.push_back(BtaaHciPacket(Activity::CONNECT, address_value, avg_byte_count));
       }
     } break;

     case hci::EventCode::RETURN_LINK_KEYS: {
       auto packet_view = hci::ReturnLinkKeysView::Create(event);
       if (!packet_view.IsValid()) {
         return;
       }
       auto keys_and_addresses = packet_view.GetKeys();
       avg_byte_count = byte_count / keys_and_addresses.size();
       for (auto& key_and_address : keys_and_addresses) {
         btaa_hci_packets.push_back(BtaaHciPacket(Activity::CONNECT, key_and_address.address_, avg_byte_count));
       }
     } break;

     default: {
       btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
     } break;
   }
 }

 void HciProcessor::process_command(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     packet::PacketView<packet::kLittleEndian>& packet_view,
     uint16_t byte_count) {
   hci::CommandView command = hci::CommandView::Create(packet_view);
   if (!command.IsValid()) {
     return;
   }

   uint16_t connection_handle_value = 0;
   hci::Address address_value;
   auto opcode = command.GetOpCode();
   auto cmd_info = lookup_cmd(opcode);

   if (cmd_info.connection_handle_pos) {
     auto connection_handle_it = command.begin() + cmd_info.connection_handle_pos;
     connection_handle_value = connection_handle_it.extract<uint16_t>();
   }
   if (cmd_info.address_pos) {
     auto address_value_it = command.begin() + cmd_info.address_pos;
     address_value = address_value_it.extract<hci::Address>();
   }
   device_parser_.match_handle_with_address(connection_handle_value, address_value);
   pending_command_.btaa_hci_packet = BtaaHciPacket(cmd_info.activity, address_value, byte_count);

   pending_command_.opcode = opcode;
 }

 void HciProcessor::process_event(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     packet::PacketView<packet::kLittleEndian>& packet_view,
     uint16_t byte_count) {
   hci::EventView event = hci::EventView::Create(packet_view);
   if (!event.IsValid()) {
     return;
   }

   uint16_t connection_handle_value = 0;
   hci::Address address_value;
   auto event_code = event.GetEventCode();
   auto event_info = lookup_event(event_code);

   if (event_info.activity != Activity::UNKNOWN) {
     // lookup_event returns all simple classic event which does not require additional processing.
     if (event_info.connection_handle_pos) {
       auto connection_handle_it = event.begin() + event_info.connection_handle_pos;
       connection_handle_value = connection_handle_it.extract<uint16_t>();
     }
     if (event_info.address_pos) {
       auto address_value_it = event.begin() + event_info.address_pos;
       address_value = address_value_it.extract<hci::Address>();
     }
     device_parser_.match_handle_with_address(connection_handle_value, address_value);
     btaa_hci_packets.push_back(BtaaHciPacket(event_info.activity, address_value, byte_count));
   } else {
     // The event requires additional processing.
     switch (event_code) {
       case hci::EventCode::COMMAND_COMPLETE: {
         auto packet_view = hci::CommandCompleteView::Create(event);
         if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {
           pending_command_.btaa_hci_packet.byte_count += byte_count;
           btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));
         } else {
           btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
         }
       } break;
       case hci::EventCode::COMMAND_STATUS: {
         auto packet_view = hci::CommandStatusView::Create(event);
         if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {
           pending_command_.btaa_hci_packet.byte_count += byte_count;
           btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));
         } else {
           btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
         }
         break;
       }
       case hci::EventCode::LE_META_EVENT:
         process_le_event(btaa_hci_packets, byte_count, event);
         break;
       case hci::EventCode::VENDOR_SPECIFIC:
         btaa_hci_packets.push_back(BtaaHciPacket(Activity::VENDOR, address_value, byte_count));
         break;
       default:
         process_special_event(btaa_hci_packets, event_code, byte_count, event);
         break;
     }
   }
 }

 void HciProcessor::process_acl(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     packet::PacketView<packet::kLittleEndian>& packet_view,
     uint16_t byte_count) {
   hci::AclView acl = hci::AclView::Create(packet_view);
   auto connection_handle = acl.begin();
   // Connection handle is extracted from the 12 least significant bit.
   uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
   hci::Address address_value;
   device_parser_.match_handle_with_address(connection_handle_value, address_value);
   btaa_hci_packets.push_back(BtaaHciPacket(Activity::ACL, address_value, byte_count));
 }

 void HciProcessor::process_sco(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     packet::PacketView<packet::kLittleEndian>& packet_view,
     uint16_t byte_count) {
   hci::ScoView sco = hci::ScoView::Create(packet_view);
   auto connection_handle = sco.begin();
   // Connection handle is extracted from the 12 least significant bit.
   uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
   hci::Address address_value;
   device_parser_.match_handle_with_address(connection_handle_value, address_value);
   btaa_hci_packets.push_back(BtaaHciPacket(Activity::HFP, address_value, byte_count));
 }

 void HciProcessor::process_iso(
     std::vector<BtaaHciPacket>& btaa_hci_packets,
     packet::PacketView<packet::kLittleEndian>& packet_view,
     uint16_t byte_count) {
   hci::IsoView iso = hci::IsoView::Create(packet_view);
   auto connection_handle = iso.begin();
   // Connection handle is extracted from the 12 least significant bit.
   uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
   hci::Address address_value;
   device_parser_.match_handle_with_address(connection_handle_value, address_value);
   btaa_hci_packets.push_back(BtaaHciPacket(Activity::ISO, address_value, byte_count));
 }

 std::vector<BtaaHciPacket> HciProcessor::OnHciPacket(
     hal::HciPacket packet, hal::SnoopLogger::PacketType type, uint16_t length) {
   std::vector<BtaaHciPacket> btaa_hci_packets;
   auto packet_view = packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(packet));
   switch (type) {
     case hal::SnoopLogger::PacketType::CMD:
       process_command(btaa_hci_packets, packet_view, length);
       break;
     case hal::SnoopLogger::PacketType::EVT:
       process_event(btaa_hci_packets, packet_view, length);
       break;
     case hal::SnoopLogger::PacketType::ACL:
       process_acl(btaa_hci_packets, packet_view, length);
       break;
     case hal::SnoopLogger::PacketType::SCO:
       process_sco(btaa_hci_packets, packet_view, length);
       break;
     case hal::SnoopLogger::PacketType::ISO:
       process_iso(btaa_hci_packets, packet_view, length);
       break;
   }
   return btaa_hci_packets;
 }

 }  // namespace activity_attribution
 }  // namespace bluetooth
	/*
	* Copyright 2021 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 "btaa/hci_processor.h"

	#include "os/log.h"

	namespace bluetooth {
	namespace activity_attribution {

	void DeviceParser::match_handle_with_address(uint16_t connection_handle, hci::Address& address) {
	if (connection_handle && !address.IsEmpty()) {
	connection_lookup_table_[connection_handle] = address;
	} else if (connection_handle) {
	if (connection_lookup_table_.find(connection_handle) != connection_lookup_table_.end()) {
	address = connection_lookup_table_[connection_handle];
	}
	}
	}

	void HciProcessor::process_le_event(
	std::vector<BtaaHciPacket>& btaa_hci_packets, int16_t byte_count, hci::EventView& event) {
	uint16_t connection_handle_value = 0;
	hci::Address address_value;

	auto le_packet_view = hci::LeMetaEventView::Create(event);
	if (!le_packet_view.IsValid()) {
	return;
	}

	auto subevent_code = le_packet_view.GetSubeventCode();
	auto le_event_info = lookup_le_event(subevent_code);

	if (le_event_info.activity != Activity::UNKNOWN) {
	// lookup_le_event returns all simple classic event which does not require additional processing.
	if (le_event_info.connection_handle_pos) {
	auto connection_handle_it = event.begin() + le_event_info.connection_handle_pos;
	connection_handle_value = connection_handle_it.extract<uint16_t>();
	}
	if (le_event_info.address_pos) {
	auto address_value_it = event.begin() + le_event_info.address_pos;
	address_value = address_value_it.extract<hci::Address>();
	}
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(le_event_info.activity, address_value, byte_count));
	}
	}

	void HciProcessor::process_special_event(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	hci::EventCode event_code,
	uint16_t byte_count,
	hci::EventView& event) {
	uint16_t avg_byte_count;
	hci::Address address_value;

	switch (event_code) {
	case hci::EventCode::INQUIRY_RESULT:
	case hci::EventCode::INQUIRY_RESULT_WITH_RSSI: {
	auto packet_view = hci::InquiryResultView::Create(event);
	if (!packet_view.IsValid()) {
	return;
	}
	auto inquiry_results = packet_view.GetInquiryResults();
	avg_byte_count = byte_count / inquiry_results.size();
	for (auto& inquiry_result : inquiry_results) {
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::SCAN, inquiry_result.bd_addr_, avg_byte_count));
	}
	} break;

	case hci::EventCode::NUMBER_OF_COMPLETED_PACKETS: {
	auto packet_view = hci::NumberOfCompletedPacketsView::Create(event);
	if (!packet_view.IsValid()) {
	return;
	}
	auto completed_packets = packet_view.GetCompletedPackets();
	avg_byte_count = byte_count / completed_packets.size();
	for (auto& completed_packet : completed_packets) {
	device_parser_.match_handle_with_address(completed_packet.connection_handle_, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::CONNECT, address_value, avg_byte_count));
	}
	} break;

	case hci::EventCode::RETURN_LINK_KEYS: {
	auto packet_view = hci::ReturnLinkKeysView::Create(event);
	if (!packet_view.IsValid()) {
	return;
	}
	auto keys_and_addresses = packet_view.GetKeys();
	avg_byte_count = byte_count / keys_and_addresses.size();
	for (auto& key_and_address : keys_and_addresses) {
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::CONNECT, key_and_address.address_, avg_byte_count));
	}
	} break;

	default: {
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
	} break;
	}
	}

	void HciProcessor::process_command(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	packet::PacketView<packet::kLittleEndian>& packet_view,
	uint16_t byte_count) {
	hci::CommandView command = hci::CommandView::Create(packet_view);
	if (!command.IsValid()) {
	return;
	}

	uint16_t connection_handle_value = 0;
	hci::Address address_value;
	auto opcode = command.GetOpCode();
	auto cmd_info = lookup_cmd(opcode);

	if (cmd_info.connection_handle_pos) {
	auto connection_handle_it = command.begin() + cmd_info.connection_handle_pos;
	connection_handle_value = connection_handle_it.extract<uint16_t>();
	}
	if (cmd_info.address_pos) {
	auto address_value_it = command.begin() + cmd_info.address_pos;
	address_value = address_value_it.extract<hci::Address>();
	}
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	pending_command_.btaa_hci_packet = BtaaHciPacket(cmd_info.activity, address_value, byte_count);

	pending_command_.opcode = opcode;
	}

	void HciProcessor::process_event(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	packet::PacketView<packet::kLittleEndian>& packet_view,
	uint16_t byte_count) {
	hci::EventView event = hci::EventView::Create(packet_view);
	if (!event.IsValid()) {
	return;
	}

	uint16_t connection_handle_value = 0;
	hci::Address address_value;
	auto event_code = event.GetEventCode();
	auto event_info = lookup_event(event_code);

	if (event_info.activity != Activity::UNKNOWN) {
	// lookup_event returns all simple classic event which does not require additional processing.
	if (event_info.connection_handle_pos) {
	auto connection_handle_it = event.begin() + event_info.connection_handle_pos;
	connection_handle_value = connection_handle_it.extract<uint16_t>();
	}
	if (event_info.address_pos) {
	auto address_value_it = event.begin() + event_info.address_pos;
	address_value = address_value_it.extract<hci::Address>();
	}
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(event_info.activity, address_value, byte_count));
	} else {
	// The event requires additional processing.
	switch (event_code) {
	case hci::EventCode::COMMAND_COMPLETE: {
	auto packet_view = hci::CommandCompleteView::Create(event);
	if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {
	pending_command_.btaa_hci_packet.byte_count += byte_count;
	btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));
	} else {
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
	}
	} break;
	case hci::EventCode::COMMAND_STATUS: {
	auto packet_view = hci::CommandStatusView::Create(event);
	if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {
	pending_command_.btaa_hci_packet.byte_count += byte_count;
	btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));
	} else {
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));
	}
	break;
	}
	case hci::EventCode::LE_META_EVENT:
	process_le_event(btaa_hci_packets, byte_count, event);
	break;
	case hci::EventCode::VENDOR_SPECIFIC:
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::VENDOR, address_value, byte_count));
	break;
	default:
	process_special_event(btaa_hci_packets, event_code, byte_count, event);
	break;
	}
	}
	}

	void HciProcessor::process_acl(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	packet::PacketView<packet::kLittleEndian>& packet_view,
	uint16_t byte_count) {
	hci::AclView acl = hci::AclView::Create(packet_view);
	auto connection_handle = acl.begin();
	// Connection handle is extracted from the 12 least significant bit.
	uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
	hci::Address address_value;
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::ACL, address_value, byte_count));
	}

	void HciProcessor::process_sco(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	packet::PacketView<packet::kLittleEndian>& packet_view,
	uint16_t byte_count) {
	hci::ScoView sco = hci::ScoView::Create(packet_view);
	auto connection_handle = sco.begin();
	// Connection handle is extracted from the 12 least significant bit.
	uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
	hci::Address address_value;
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::HFP, address_value, byte_count));
	}

	void HciProcessor::process_iso(
	std::vector<BtaaHciPacket>& btaa_hci_packets,
	packet::PacketView<packet::kLittleEndian>& packet_view,
	uint16_t byte_count) {
	hci::IsoView iso = hci::IsoView::Create(packet_view);
	auto connection_handle = iso.begin();
	// Connection handle is extracted from the 12 least significant bit.
	uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;
	hci::Address address_value;
	device_parser_.match_handle_with_address(connection_handle_value, address_value);
	btaa_hci_packets.push_back(BtaaHciPacket(Activity::ISO, address_value, byte_count));
	}

	std::vector<BtaaHciPacket> HciProcessor::OnHciPacket(
	hal::HciPacket packet, hal::SnoopLogger::PacketType type, uint16_t length) {
	std::vector<BtaaHciPacket> btaa_hci_packets;
	auto packet_view = packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(packet));
	switch (type) {
	case hal::SnoopLogger::PacketType::CMD:
	process_command(btaa_hci_packets, packet_view, length);
	break;
	case hal::SnoopLogger::PacketType::EVT:
	process_event(btaa_hci_packets, packet_view, length);
	break;
	case hal::SnoopLogger::PacketType::ACL:
	process_acl(btaa_hci_packets, packet_view, length);
	break;
	case hal::SnoopLogger::PacketType::SCO:
	process_sco(btaa_hci_packets, packet_view, length);
	break;
	case hal::SnoopLogger::PacketType::ISO:
	process_iso(btaa_hci_packets, packet_view, length);
	break;
	}
	return btaa_hci_packets;
	}

	} // namespace activity_attribution
	} // namespace bluetooth