Add protocol version 5 with service-specific MTU

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);