diff options
14 files changed, 364 insertions, 11 deletions
diff --git a/src/appMain/smartDeviceLink.ini b/src/appMain/smartDeviceLink.ini index c5cd4dab8e..ea75352ec5 100644 --- a/src/appMain/smartDeviceLink.ini +++ b/src/appMain/smartDeviceLink.ini @@ -222,6 +222,22 @@ AppIconsFolderMaxSize = 104857600 ; Amount of oldest icons to remove in case of max folder size was reached AppIconsAmountToRemove = 1 +[SDL5] +; Enables SDL protocol 5.0 support +EnableProtocol5 = true +; Control service packet with payload bigger than this value will be marked as a malformed, +; if not specified, this value will default to MaxPayloadSize +;MaximumControlPayloadSize = 131072 +; RPC service packet with payload bigger than this value will be marked as a malformed, +; if not specified, this value will default to MaxPayloadSize +;MaximumRpcPayloadSize = 131072 +; Audio service packet with payload bigger than this value will be marked as a malformed, +; if not specified, this value will default to MaxPayloadSize +;MaximumAudioPayloadSize = 131072 +; Video service packet with payloadbigger than this value will be marked as a malformed, +; if not specified, this value will default to MaxPayloadSize +;MaximumVideoPayloadSize = 131072 + [Resumption] ; Timeout in milliseconds for resumption Application HMILevel ; and resolving conflicts in case if multiple applications initiate resumption diff --git a/src/components/config_profile/include/config_profile/profile.h b/src/components/config_profile/include/config_profile/profile.h index 42b0d10ceb..b9b162bcb1 100644 --- a/src/components/config_profile/include/config_profile/profile.h +++ b/src/components/config_profile/include/config_profile/profile.h @@ -130,6 +130,19 @@ class Profile : public protocol_handler::ProtocolHandlerSettings, const uint32_t& app_icons_amount_to_remove() const OVERRIDE; /** + * @brief Returns true, if SDL protocol v5 is enabled + */ + bool enable_protocol_5() const OVERRIDE; + + size_t maximum_control_payload_size() const OVERRIDE; + + size_t maximum_rpc_payload_size() const OVERRIDE; + + size_t maximum_audio_payload_size() const OVERRIDE; + + size_t maximum_video_payload_size() const OVERRIDE; + + /** * @brief Returns the path to the config file */ const std::string& config_file_name() const; @@ -763,6 +776,11 @@ class Profile : public protocol_handler::ProtocolHandlerSettings, std::string app_icons_folder_; uint32_t app_icons_folder_max_size_; uint32_t app_icons_amount_to_remove_; + bool enable_protocol_5_; + size_t maximum_control_payload_size_; + size_t maximum_rpc_payload_size_; + size_t maximum_audio_payload_size_; + size_t maximum_video_payload_size_; std::string config_file_name_; std::string server_address_; uint16_t server_port_; diff --git a/src/components/config_profile/src/profile.cc b/src/components/config_profile/src/profile.cc index beabc6afa8..09af180f2d 100644 --- a/src/components/config_profile/src/profile.cc +++ b/src/components/config_profile/src/profile.cc @@ -85,6 +85,7 @@ const char* kFilesystemRestrictionsSection = "FILESYSTEM RESTRICTIONS"; const char* kIAPSection = "IAP"; const char* kProtocolHandlerSection = "ProtocolHandler"; const char* kSDL4Section = "SDL4"; +const char* kSDL5Section = "SDL5"; const char* kResumptionSection = "Resumption"; const char* kAppLaunchSection = "AppLaunch"; @@ -104,6 +105,11 @@ const char* kEnableProtocol4Key = "EnableProtocol4"; const char* kAppIconsFolderKey = "AppIconsFolder"; const char* kAppIconsFolderMaxSizeKey = "AppIconsFolderMaxSize"; const char* kAppIconsAmountToRemoveKey = "AppIconsAmountToRemove"; +const char* kEnableProtocol5Key = "EnableProtocol5"; +const char* kMaximumControlPayloadSizeKey = "MaximumControlPayloadSize"; +const char* kMaximumRpcPayloadSizeKey = "MaximumRpcPayloadSize"; +const char* kMaximumAudioPayloadSizeKey = "MaximumAudioPayloadSize"; +const char* kMaximumVideoPayloadSizeKey = "MaximumVideoPayloadSize"; const char* kLaunchHMIKey = "LaunchHMI"; const char* kDefaultSDLVersion = ""; #ifdef WEB_HMI @@ -286,6 +292,10 @@ const uint16_t kDefaultOpenAttemptTimeoutMs = 500; const uint32_t kDefaultAppIconsFolderMaxSize = 104857600; const uint32_t kDefaultAppIconsAmountToRemove = 1; const uint16_t kDefaultAttemptsToOpenResumptionDB = 5; +const size_t kDefaultMaximumControlPayloadSize = 0; +const size_t kDefaultMaximumRpcPayloadSize = 0; +const size_t kDefaultMaximumAudioPayloadSize = 0; +const size_t kDefaultMaximumVideoPayloadSize = 0; const uint16_t kDefaultOpenAttemptTimeoutMsResumptionDB = 500; const uint16_t kDefaultAppLaunchWaitTime = 5000; const uint16_t kDefaultAppLaunchMaxRetryAttempt = 3; @@ -317,6 +327,11 @@ Profile::Profile() , app_icons_folder_() , app_icons_folder_max_size_(kDefaultAppIconsFolderMaxSize) , app_icons_amount_to_remove_(kDefaultAppIconsAmountToRemove) + , enable_protocol_5_(false) + , maximum_control_payload_size_(kDefaultMaximumControlPayloadSize) + , maximum_rpc_payload_size_(kDefaultMaximumRpcPayloadSize) + , maximum_audio_payload_size_(kDefaultMaximumAudioPayloadSize) + , maximum_video_payload_size_(kDefaultMaximumVideoPayloadSize) , config_file_name_(kDefaultConfigFileName) , server_address_(kDefaultServerAddress) , server_port_(kDefaultServerPort) @@ -454,6 +469,26 @@ const uint32_t& Profile::app_icons_amount_to_remove() const { return app_icons_amount_to_remove_; } +bool Profile::enable_protocol_5() const { + return enable_protocol_5_; +} + +size_t Profile::maximum_control_payload_size() const { + return maximum_control_payload_size_; +} + +size_t Profile::maximum_rpc_payload_size() const { + return maximum_rpc_payload_size_; +} + +size_t Profile::maximum_audio_payload_size() const { + return maximum_audio_payload_size_; +} + +size_t Profile::maximum_video_payload_size() const { + return maximum_video_payload_size_; +} + const std::string& Profile::hmi_capabilities_file_name() const { return hmi_capabilities_file_name_; } @@ -1053,6 +1088,50 @@ void Profile::UpdateValues() { LOG_UPDATED_VALUE( app_icons_amount_to_remove_, kAppIconsAmountToRemoveKey, kSDL4Section); + // Enable protocol ver.4 parameter + std::string enable_protocol_5_value; + if (ReadValue(&enable_protocol_5_value, kSDL5Section, kEnableProtocol5Key) && + 0 == strcmp("true", enable_protocol_5_value.c_str())) { + enable_protocol_5_ = true; + } else { + enable_protocol_5_ = false; + } + + LOG_UPDATED_BOOL_VALUE(enable_protocol_5_, kEnableProtocol5Key, kSDL5Section); + + ReadUIntValue(&maximum_control_payload_size_, + kDefaultMaximumPayloadSize, + kSDL5Section, + kMaximumControlPayloadSizeKey); + + LOG_UPDATED_VALUE(maximum_control_payload_size_, + kMaximumControlPayloadSizeKey, + kSDL5Section); + + ReadUIntValue(&maximum_rpc_payload_size_, + kDefaultMaximumPayloadSize, + kSDL5Section, + kMaximumRpcPayloadSizeKey); + + LOG_UPDATED_VALUE( + maximum_rpc_payload_size_, kMaximumRpcPayloadSizeKey, kSDL5Section); + + ReadUIntValue(&maximum_audio_payload_size_, + kDefaultMaximumPayloadSize, + kSDL5Section, + kMaximumAudioPayloadSizeKey); + + LOG_UPDATED_VALUE( + maximum_audio_payload_size_, kMaximumAudioPayloadSizeKey, kSDL5Section); + + ReadUIntValue(&maximum_video_payload_size_, + kDefaultMaximumPayloadSize, + kSDL5Section, + kMaximumVideoPayloadSizeKey); + + LOG_UPDATED_VALUE( + maximum_video_payload_size_, kMaximumVideoPayloadSizeKey, kSDL5Section); + // Application info file name ReadStringValue(&app_info_storage_, kDefaultAppInfoFileName, diff --git a/src/components/connection_handler/src/connection.cc b/src/components/connection_handler/src/connection.cc index 7bb54d4493..202736e612 100644 --- a/src/components/connection_handler/src/connection.cc +++ b/src/components/connection_handler/src/connection.cc @@ -352,8 +352,7 @@ bool Connection::SupportHeartBeat(uint8_t session_id) { } Session& session = session_it->second; return ( - (::protocol_handler::PROTOCOL_VERSION_3 == session.protocol_version || - ::protocol_handler::PROTOCOL_VERSION_4 == session.protocol_version) && + (session.protocol_version >= ::protocol_handler::PROTOCOL_VERSION_3) && (0 != heartbeat_timeout_)); } diff --git a/src/components/connection_handler/test/connection_test.cc b/src/components/connection_handler/test/connection_test.cc index 85f43f3785..4582cc10ee 100644 --- a/src/components/connection_handler/test/connection_test.cc +++ b/src/components/connection_handler/test/connection_test.cc @@ -201,6 +201,32 @@ TEST_F(ConnectionTest, HeartBeat_Protocol4_ZeroHeartBeat_NotSupported) { EXPECT_FALSE(connection_->SupportHeartBeat(session_id)); } +TEST_F(ConnectionTest, HeartBeat_Protocol5_PositiveHeartBeat_Supported) { + // Arrange + StartSession(); + // Check execution if protocol version is 5 + const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_5); + connection_->UpdateProtocolVersionSession(session_id, protocol_version); + EXPECT_TRUE(connection_->SupportHeartBeat(session_id)); +} + +TEST_F(ConnectionTest, HeartBeat_Protocol5_ZeroHeartBeat_NotSupported) { + // Correctc of connection (need connection with heartbeat=0) + delete connection_; + connection_ = 0; + + const ConnectionHandle connectionHandle = 0; + const DeviceHandle device_handle = 0u; + const uint32_t heart_beat = 0u; + connection_ = new Connection( + connectionHandle, device_handle, connection_handler_, heart_beat); + StartSession(); + // Check execution if protocol version is 5 + const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_5); + connection_->UpdateProtocolVersionSession(session_id, protocol_version); + EXPECT_FALSE(connection_->SupportHeartBeat(session_id)); +} + // Try to add service without session TEST_F(ConnectionTest, Session_AddNewServiceWithoutSession) { EXPECT_EQ(connection_->AddNewService(session_id, kAudio, true), diff --git a/src/components/include/protocol/common.h b/src/components/include/protocol/common.h index ce4c4adf6f..2904f383de 100644 --- a/src/components/include/protocol/common.h +++ b/src/components/include/protocol/common.h @@ -85,6 +85,12 @@ enum { */ PROTOCOL_VERSION_4 = 0x04, /** + *@brief Constant: number of protocol version (5). + * Supports constructed payloads for protocol packets + * SDL4.4 feature. + */ + PROTOCOL_VERSION_5 = 0x05, + /** *\brief Maximum value of packet version field (size 4-bit) specified AppLink *Protocol v.7 */ diff --git a/src/components/include/protocol_handler/protocol_handler_settings.h b/src/components/include/protocol_handler/protocol_handler_settings.h index 987b0ac449..fc37d4af58 100644 --- a/src/components/include/protocol_handler/protocol_handler_settings.h +++ b/src/components/include/protocol_handler/protocol_handler_settings.h @@ -15,6 +15,10 @@ class ProtocolHandlerSettings { virtual ~ProtocolHandlerSettings() {} virtual size_t maximum_payload_size() const = 0; + virtual size_t maximum_control_payload_size() const = 0; + virtual size_t maximum_rpc_payload_size() const = 0; + virtual size_t maximum_audio_payload_size() const = 0; + virtual size_t maximum_video_payload_size() const = 0; virtual size_t message_frequency_count() const = 0; virtual size_t message_frequency_time() const = 0; virtual bool malformed_message_filtering() const = 0; @@ -30,6 +34,7 @@ class ProtocolHandlerSettings { * @brief Protocol version, from .ini file. */ virtual bool enable_protocol_4() const = 0; + virtual bool enable_protocol_5() const = 0; virtual uint32_t multiframe_waiting_timeout() const = 0; #ifdef ENABLE_SECURITY diff --git a/src/components/include/test/protocol_handler/mock_protocol_handler_settings.h b/src/components/include/test/protocol_handler/mock_protocol_handler_settings.h index d12e7899e0..43af035f0b 100644 --- a/src/components/include/test/protocol_handler/mock_protocol_handler_settings.h +++ b/src/components/include/test/protocol_handler/mock_protocol_handler_settings.h @@ -43,6 +43,10 @@ class MockProtocolHandlerSettings : public protocol_handler::ProtocolHandlerSettings { public: MOCK_CONST_METHOD0(maximum_payload_size, size_t()); + MOCK_CONST_METHOD0(maximum_control_payload_size, size_t()); + MOCK_CONST_METHOD0(maximum_rpc_payload_size, size_t()); + MOCK_CONST_METHOD0(maximum_audio_payload_size, size_t()); + MOCK_CONST_METHOD0(maximum_video_payload_size, size_t()); MOCK_CONST_METHOD0(message_frequency_count, size_t()); MOCK_CONST_METHOD0(message_frequency_time, size_t()); MOCK_CONST_METHOD0(malformed_message_filtering, bool()); @@ -51,6 +55,7 @@ class MockProtocolHandlerSettings MOCK_CONST_METHOD0(heart_beat_timeout, uint32_t()); MOCK_CONST_METHOD0(max_supported_protocol_version, uint16_t()); MOCK_CONST_METHOD0(enable_protocol_4, bool()); + MOCK_CONST_METHOD0(enable_protocol_5, bool()); MOCK_CONST_METHOD0(multiframe_waiting_timeout, uint32_t()); #ifdef ENABLE_SECURITY MOCK_CONST_METHOD0(force_protected_service, const std::vector<int>&()); diff --git a/src/components/protocol_handler/include/protocol_handler/protocol_packet.h b/src/components/protocol_handler/include/protocol_handler/protocol_packet.h index f8696c46a0..276c416d59 100644 --- a/src/components/protocol_handler/include/protocol_handler/protocol_packet.h +++ b/src/components/protocol_handler/include/protocol_handler/protocol_packet.h @@ -99,7 +99,19 @@ class ProtocolPacket { * \brief Setter/getter maximum payload size of packets */ void set_max_payload_size(const size_t max_payload_size); + void set_max_control_payload_size(const size_t max_payload_size); + void set_max_rpc_payload_size(const size_t max_payload_size); + void set_max_audio_payload_size(const size_t max_payload_size); + void set_max_video_payload_size(const size_t max_payload_size); + size_t max_payload_size() const; + size_t max_control_payload_size() const; + size_t max_rpc_payload_size() const; + size_t max_audio_payload_size() const; + size_t max_video_payload_size() const; + + size_t max_payload_size_by_service_type(const ServiceType type) const; + /** * \brief Check ProtocolHeader according to protocol requiements */ @@ -107,6 +119,10 @@ class ProtocolPacket { private: size_t max_payload_size_; + size_t max_control_payload_size_; + size_t max_rpc_payload_size_; + size_t max_audio_payload_size_; + size_t max_video_payload_size_; }; /** diff --git a/src/components/protocol_handler/src/incoming_data_handler.cc b/src/components/protocol_handler/src/incoming_data_handler.cc index e1d08a6ada..4944ea9cc7 100644 --- a/src/components/protocol_handler/src/incoming_data_handler.cc +++ b/src/components/protocol_handler/src/incoming_data_handler.cc @@ -126,6 +126,7 @@ uint32_t IncomingDataHandler::GetPacketSize( case PROTOCOL_VERSION_2: case PROTOCOL_VERSION_3: case PROTOCOL_VERSION_4: + case PROTOCOL_VERSION_5: return header.dataSize + PROTOCOL_HEADER_V2_SIZE; default: LOG4CXX_WARN(logger_, diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index aa2910722d..1fd49222f0 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -85,6 +85,14 @@ ProtocolHandlerImpl::ProtocolHandlerImpl( LOG4CXX_AUTO_TRACE(logger_); protocol_header_validator_.set_max_payload_size( get_settings().maximum_payload_size()); + protocol_header_validator_.set_max_control_payload_size( + get_settings().maximum_control_payload_size()); + protocol_header_validator_.set_max_rpc_payload_size( + get_settings().maximum_rpc_payload_size()); + protocol_header_validator_.set_max_audio_payload_size( + get_settings().maximum_audio_payload_size()); + protocol_header_validator_.set_max_video_payload_size( + get_settings().maximum_video_payload_size()); incoming_data_handler_.set_validator(&protocol_header_validator_); const size_t& message_frequency_count = @@ -1173,8 +1181,7 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageHeartBeat( if (session_observer_.ProtocolVersionUsed( connection_id, packet.session_id(), protocol_version)) { // TODO(EZamakhov): investigate message_id for HeartBeatAck - if (PROTOCOL_VERSION_3 == protocol_version || - PROTOCOL_VERSION_4 == protocol_version) { + if (protocol_version >= PROTOCOL_VERSION_3) { return SendHeartBeatAck( connection_id, packet.session_id(), packet.message_id()); } else { @@ -1508,7 +1515,11 @@ uint8_t ProtocolHandlerImpl::SupportedSDLProtocolVersion() const { bool heart_beat_support = (0 != get_settings().heart_beat_timeout()); bool sdl4_support = get_settings().enable_protocol_4(); + bool sdl5_support = get_settings().enable_protocol_5(); + if (sdl5_support) { + return PROTOCOL_VERSION_5; + } if (sdl4_support) { return PROTOCOL_VERSION_4; } diff --git a/src/components/protocol_handler/src/protocol_packet.cc b/src/components/protocol_handler/src/protocol_packet.cc index d766cf18c4..d4daffe1d7 100644 --- a/src/components/protocol_handler/src/protocol_packet.cc +++ b/src/components/protocol_handler/src/protocol_packet.cc @@ -114,7 +114,8 @@ void ProtocolPacket::ProtocolHeader::deserialize(const uint8_t* message, switch (version) { case PROTOCOL_VERSION_2: case PROTOCOL_VERSION_3: - case PROTOCOL_VERSION_4: { + case PROTOCOL_VERSION_4: + case PROTOCOL_VERSION_5: { if (messageSize < PROTOCOL_HEADER_V2_SIZE) { LOG4CXX_DEBUG(logger_, "Message size less " << PROTOCOL_HEADER_V2_SIZE @@ -131,7 +132,11 @@ void ProtocolPacket::ProtocolHeader::deserialize(const uint8_t* message, } ProtocolPacket::ProtocolHeaderValidator::ProtocolHeaderValidator() - : max_payload_size_(std::numeric_limits<size_t>::max()) {} + : max_payload_size_(std::numeric_limits<size_t>::max()) + , max_control_payload_size_(0) + , max_rpc_payload_size_(0) + , max_audio_payload_size_(0) + , max_video_payload_size_(0) {} void ProtocolPacket::ProtocolHeaderValidator::set_max_payload_size( const size_t max_payload_size) { @@ -139,15 +144,92 @@ void ProtocolPacket::ProtocolHeaderValidator::set_max_payload_size( max_payload_size_ = max_payload_size; } +void ProtocolPacket::ProtocolHeaderValidator::set_max_control_payload_size( + const size_t max_payload_size) { + LOG4CXX_DEBUG(logger_, + "New maximum RPC payload size is " << max_payload_size); + max_control_payload_size_ = max_payload_size; +} + +void ProtocolPacket::ProtocolHeaderValidator::set_max_rpc_payload_size( + const size_t max_payload_size) { + LOG4CXX_DEBUG(logger_, + "New maximum RPC payload size is " << max_payload_size); + max_rpc_payload_size_ = max_payload_size; +} + +void ProtocolPacket::ProtocolHeaderValidator::set_max_audio_payload_size( + const size_t max_payload_size) { + LOG4CXX_DEBUG(logger_, + "New maximum audio payload size is " << max_payload_size); + max_audio_payload_size_ = max_payload_size; +} + +void ProtocolPacket::ProtocolHeaderValidator::set_max_video_payload_size( + const size_t max_payload_size) { + LOG4CXX_DEBUG(logger_, + "New maximum video payload size is " << max_payload_size); + max_video_payload_size_ = max_payload_size; +} + size_t ProtocolPacket::ProtocolHeaderValidator::max_payload_size() const { return max_payload_size_; } +size_t ProtocolPacket::ProtocolHeaderValidator::max_control_payload_size() + const { + return max_control_payload_size_; +} + +size_t ProtocolPacket::ProtocolHeaderValidator::max_rpc_payload_size() const { + return max_rpc_payload_size_; +} + +size_t ProtocolPacket::ProtocolHeaderValidator::max_audio_payload_size() const { + return max_audio_payload_size_; +} + +size_t ProtocolPacket::ProtocolHeaderValidator::max_video_payload_size() const { + return max_video_payload_size_; +} + +size_t +ProtocolPacket::ProtocolHeaderValidator::max_payload_size_by_service_type( + const ServiceType type) const { + size_t payload_size = 0; + switch (type) { + case kControl: + // Default to the generic MTU if specific MTU is not set + payload_size = max_control_payload_size_ == 0 ? max_payload_size_ + : max_control_payload_size_; + break; + case kBulk: + case kRpc: + // Default to the generic MTU if specific MTU is not set + payload_size = max_rpc_payload_size_ == 0 ? max_payload_size_ + : max_rpc_payload_size_; + break; + case kAudio: + // Default to the generic MTU if specific MTU is not set + payload_size = max_audio_payload_size_ == 0 ? max_payload_size_ + : max_audio_payload_size_; + break; + case kMobileNav: + // Default to the generic MTU if specific MTU is not set + payload_size = max_video_payload_size_ == 0 ? max_payload_size_ + : max_video_payload_size_; + break; + case kInvalidServiceType: + LOG4CXX_WARN(logger_, "Invalid service type" << static_cast<int>(type)); + } + return payload_size; +} + RESULT_CODE ProtocolPacket::ProtocolHeaderValidator::validate( const ProtocolHeader& header) const { LOG4CXX_DEBUG(logger_, "Validating header - " << header); // expected payload size will be calculated depending - // on used protocol version + // on used protocol version and service type size_t payload_size = MAXIMUM_FRAME_DATA_V2_SIZE; // Protocol version shall be from 1 to 4 switch (header.version) { @@ -160,6 +242,10 @@ RESULT_CODE ProtocolPacket::ProtocolHeaderValidator::validate( ? max_payload_size_ : MAXIMUM_FRAME_DATA_V2_SIZE; break; + case PROTOCOL_VERSION_5: + payload_size = max_payload_size_by_service_type( + ServiceTypeFromByte(header.serviceType)); + break; default: LOG4CXX_WARN(logger_, "Unknown version:" << static_cast<int>(header.version)); diff --git a/src/components/protocol_handler/test/incoming_data_handler_test.cc b/src/components/protocol_handler/test/incoming_data_handler_test.cc index 66f5aea712..d0a311583c 100644 --- a/src/components/protocol_handler/test/incoming_data_handler_test.cc +++ b/src/components/protocol_handler/test/incoming_data_handler_test.cc @@ -262,7 +262,7 @@ TEST_F(IncomingDataHandlerTest, MalformedPacket_Version) { FrameList malformed_packets; std::vector<uint8_t> malformed_versions; malformed_versions.push_back(0); - for (uint8_t version = PROTOCOL_VERSION_4 + 1; + for (uint8_t version = PROTOCOL_VERSION_5 + 1; version <= PROTOCOL_VERSION_MAX; ++version) { malformed_versions.push_back(version); diff --git a/src/components/protocol_handler/test/protocol_header_validator_test.cc b/src/components/protocol_handler/test/protocol_header_validator_test.cc index 40b0f34846..3f1414aeab 100644 --- a/src/components/protocol_handler/test/protocol_header_validator_test.cc +++ b/src/components/protocol_handler/test/protocol_header_validator_test.cc @@ -57,7 +57,7 @@ class ProtocolHeaderValidatorTest : public ::testing::Test { uint32_t some_session_id; }; -// Protocol version shall be from 1 to 3 +// Protocol version shall be from 1 to 5 TEST_F(ProtocolHeaderValidatorTest, MaxPayloadSizeSetGet) { EXPECT_EQ(std::numeric_limits<size_t>::max(), header_validator.max_payload_size()); @@ -67,11 +67,96 @@ TEST_F(ProtocolHeaderValidatorTest, MaxPayloadSizeSetGet) { } } -// Protocol version shall be from 1 to 4 +TEST_F(ProtocolHeaderValidatorTest, MaxControlPayloadSizeSetGet) { + EXPECT_EQ(0, header_validator.max_control_payload_size()); + for (size_t value = 0; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_control_payload_size(value); + EXPECT_EQ(value, header_validator.max_control_payload_size()); + } +} + +TEST_F(ProtocolHeaderValidatorTest, MaxRpcPayloadSizeSetGet) { + EXPECT_EQ(0, header_validator.max_rpc_payload_size()); + for (size_t value = 0; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_rpc_payload_size(value); + EXPECT_EQ(value, header_validator.max_rpc_payload_size()); + } +} + +TEST_F(ProtocolHeaderValidatorTest, MaxAudioPayloadSizeSetGet) { + EXPECT_EQ(0, header_validator.max_audio_payload_size()); + for (size_t value = 0; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_audio_payload_size(value); + EXPECT_EQ(value, header_validator.max_audio_payload_size()); + } +} + +TEST_F(ProtocolHeaderValidatorTest, MaxVideoPayloadSizeSetGet) { + EXPECT_EQ(0, header_validator.max_video_payload_size()); + for (size_t value = 0; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_video_payload_size(value); + EXPECT_EQ(value, header_validator.max_video_payload_size()); + } +} + +TEST_F(ProtocolHeaderValidatorTest, GetMaxPayloadSizeByServiceType_Control) { + size_t payload_size = MAXIMUM_FRAME_DATA_V2_SIZE; + header_validator.set_max_payload_size(payload_size); + // Default to max_payload_size if a specific MTU is not set + EXPECT_EQ(payload_size, + header_validator.max_payload_size_by_service_type(kControl)); + for (size_t value = 1; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_control_payload_size(value); + EXPECT_EQ(value, + header_validator.max_payload_size_by_service_type(kControl)); + } +} + +TEST_F(ProtocolHeaderValidatorTest, GetMaxPayloadSizeByServiceType_Rpc) { + size_t payload_size = MAXIMUM_FRAME_DATA_V2_SIZE; + header_validator.set_max_payload_size(payload_size); + // Default to max_payload_size if a specific MTU is not set + EXPECT_EQ(payload_size, + header_validator.max_payload_size_by_service_type(kRpc)); + EXPECT_EQ(payload_size, + header_validator.max_payload_size_by_service_type(kBulk)); + for (size_t value = 1; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_rpc_payload_size(value); + EXPECT_EQ(value, header_validator.max_payload_size_by_service_type(kRpc)); + EXPECT_EQ(value, header_validator.max_payload_size_by_service_type(kBulk)); + } +} + +TEST_F(ProtocolHeaderValidatorTest, GetMaxPayloadSizeByServiceType_Audio) { + size_t payload_size = MAXIMUM_FRAME_DATA_V2_SIZE; + header_validator.set_max_payload_size(payload_size); + // Default to max_payload_size if a specific MTU is not set + EXPECT_EQ(payload_size, + header_validator.max_payload_size_by_service_type(kAudio)); + for (size_t value = 1; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_audio_payload_size(value); + EXPECT_EQ(value, header_validator.max_payload_size_by_service_type(kAudio)); + } +} + +TEST_F(ProtocolHeaderValidatorTest, GetMaxPayloadSizeByServiceType_Video) { + size_t payload_size = MAXIMUM_FRAME_DATA_V2_SIZE; + header_validator.set_max_payload_size(payload_size); + // Default to max_payload_size if a specific MTU is not set + EXPECT_EQ(payload_size, + header_validator.max_payload_size_by_service_type(kMobileNav)); + for (size_t value = 1; value < MAXIMUM_FRAME_DATA_V3_SIZE * 2; ++value) { + header_validator.set_max_video_payload_size(value); + EXPECT_EQ(value, + header_validator.max_payload_size_by_service_type(kMobileNav)); + } +} + +// Protocol version shall be from 1 to 5 TEST_F(ProtocolHeaderValidatorTest, Malformed_Version) { std::vector<uint8_t> malformed_versions; malformed_versions.push_back(0); - for (uint8_t version = PROTOCOL_VERSION_4 + 1; + for (uint8_t version = PROTOCOL_VERSION_5 + 1; version <= PROTOCOL_VERSION_MAX; ++version) { malformed_versions.push_back(version); |