diff --git a/include/rde/rde_handler.hpp b/include/rde/rde_handler.hpp
new file mode 100644
index 0000000..65e9361
--- /dev/null
+++ b/include/rde/rde_handler.hpp
@@ -0,0 +1,219 @@
+#pragma once
+
+#include "bej_decoder_json.hpp"
+#include "external_storer_interface.hpp"
+#include "rde_dictionary_manager.hpp"
+
+#include <cstdint>
+#include <span>
+#include <string_view>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+/**
+ * @brief Supported RDE commands.
+ *
+ * The values used are the same as what BIOS uses.
+ */
+enum class RdeCommandType : char
+{
+    // Used for RDE BEJ dictionary transfer.
+    RdeMultiPartReceiveResponse = 1,
+    // Used for RDE BEJ encoded data.
+    RdeOperationInitRequest = 2,
+};
+
+/**
+ * @brief Used to keep track of RdeMultiPartReceiveResponse START flag
+ * reception.
+ */
+enum class RdeDictTransferFlagState
+{
+    RdeStateIdle,
+    RdeStateStartRecvd,
+};
+
+/**
+ * @brief Status of RDE command processing.
+ */
+enum class RdeDecodeStatus
+{
+    RdeOk,
+    RdeInvalidCommand,
+    RdeUnsupportedOperation,
+    RdeNoDictionary,
+    RdePayloadOverflow,
+    RdeBejDecodingError,
+    RdeInvalidPktOrder,
+    RdeDictionaryError,
+    RdeFileCreationFailed,
+    RdeExternalStorerError,
+    // This implies that the stop flag has been received.
+    RdeInvalidChecksum,
+    // This implies that the checksum is correct.
+    RdeStopFlagReceived,
+};
+
+/**
+ * @brief Handles RDE messages from the BIOS - BMC circular buffer and updates
+ * ExternalStorer.
+ */
+class RdeCommandHandler
+{
+  public:
+    /**
+     * @brief Constructor for RdeExternalStorer.
+     *
+     * @param[in] exStorer - valid ExternalStorerInterface. This class will take
+     * the ownership of this object.
+     */
+    explicit RdeCommandHandler(
+        std::unique_ptr<ExternalStorerInterface> exStorer);
+
+    /**
+     * @brief Decode a RDE command.
+     *
+     * @param[in] rdeCommand - RDE command.
+     * @param[in] type - RDE command type.
+     * @return RdeDecodeStatus code.
+     */
+    RdeDecodeStatus decodeRdeCommand(std::span<const uint8_t> rdeCommand,
+                                     RdeCommandType type);
+
+    /**
+     * @brief Get the number of complete dictionaries received.
+     *
+     * @return number of complete dictionaries.
+     */
+    uint32_t getDictionaryCount();
+
+  private:
+    /**
+     * @brief This keeps track of whether we received the dictionary start flag
+     * or not.
+     */
+    RdeDictTransferFlagState flagState;
+
+    std::unique_ptr<ExternalStorerInterface> exStorer;
+
+    /**
+     * @brief We are using the prevDictResourceId to detect a new dictionary.
+     *
+     * BIOS-BMC buffer uses RdeMultiPartReceiveResponse START flag to indicate
+     * the first dictionary data chunk. BMC will not receive this flag at start
+     * of every new dictionary but only for the first data chunk. Therefore
+     * difference between resource ID is used to identify a new dictionary
+     * start. prevDictResourceId keeps track of the resource ID of the last
+     * dictionary data chunk.
+     */
+    uint32_t prevDictResourceId;
+
+    DictionaryManager dictionaryManager;
+    libbej::BejDecoderJson decoder;
+
+    uint32_t crc;
+    std::array<uint32_t, UINT8_MAX + 1> crcTable;
+
+    /**
+     * @brief Handles OperationInit request messages.
+     *
+     * @param[in] rdeCommand - RDE command.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus operationInitRequest(std::span<const uint8_t> rdeCommand);
+
+    /**
+     * @brief Handles MultiPartReceive response messages.
+     *
+     * @param[in] rdeCommand - RDE command.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus multiPartReceiveResp(std::span<const uint8_t> rdeCommand);
+
+    /**
+     * @brief Initializes the CRC table.
+     */
+    void calcCrcTable();
+
+    /**
+     * @brief Update the existing CRC using the provided byte stream.
+     *
+     * According to the RDE BEJ specification: "32-bit CRC for the entire block
+     * of data (all parts concatenated together, excluding this checksum)".
+     * Therefore when calculating the CRC whole RDEMultipartReceive Response
+     * data packet is considered, not just the dictionary data contained within
+     * it.
+     *
+     * @param[in] stream - a byte stream.
+     */
+    void updateCrc(std::span<const uint8_t> stream);
+
+    /**
+     * @brief Get the final checksum value.
+     *
+     * @return uint32_t - final checksum value.
+     */
+    uint32_t finalChecksum();
+
+    /**
+     * @brief Process received CRC field from a multi receive response command.
+     * END or START_AND_END flag should be set in the command.
+     *
+     * @param multiReceiveRespCmd - payload with a checksum field populated.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus handleCrc(std::span<const uint8_t> multiReceiveRespCmd);
+
+    /**
+     * @brief Handle dictionary data with flag Start.
+     *
+     * @param[in] header -  RDE header portion of the RDE command.
+     * @param[in] data - data portion of the RDE command.
+     * @param[in] resourceId - PDR resource ID of the dictionary.
+     */
+    void handleFlagStart(const MultipartReceiveResHeader* header,
+                         const uint8_t* data, uint32_t resourceId);
+
+    /**
+     * @brief Handle dictionary data with flag Middle.
+     *
+     * @param[in] header -  RDE header portion of the RDE command.
+     * @param[in] data - data portion of the RDE command.
+     * @param[in] resourceId - PDR resource ID of the dictionary.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus handleFlagMiddle(const MultipartReceiveResHeader* header,
+                                     const uint8_t* data, uint32_t resourceId);
+    /**
+     * @brief Handle dictionary data with flag End.
+     *
+     * @param[in] rdeCommand - RDE command.
+     * @param[in] header -  RDE header portion of the RDE command.
+     * @param[in] data - data portion of the RDE command.
+     * @param[in] resourceId - PDR resource ID of the dictionary.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus handleFlagEnd(std::span<const uint8_t> rdeCommand,
+                                  const MultipartReceiveResHeader* header,
+                                  const uint8_t* data, uint32_t resourceId);
+
+    /**
+     * @brief Handle dictionary data with flag StartAndEnd.
+     *
+     * @param[in] rdeCommand - RDE command.
+     * @param[in] header -  RDE header portion of the RDE command.
+     * @param[in] data - data portion of the RDE command.
+     * @param[in] resourceId - PDR resource ID of the dictionary.
+     * @return RdeDecodeStatus
+     */
+    RdeDecodeStatus
+        handleFlagStartAndEnd(std::span<const uint8_t> rdeCommand,
+                              const MultipartReceiveResHeader* header,
+                              const uint8_t* data, uint32_t resourceId);
+};
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/src/rde/meson.build b/src/rde/meson.build
index 482e9ff..c6831e2 100644
--- a/src/rde/meson.build
+++ b/src/rde/meson.build
@@ -1,9 +1,17 @@
+libbej_dep = dependency('libbej')
+
+rde_pre = declare_dependency(
+  include_directories: [rde_inc],
+  dependencies: [libbej_dep])
+
 rde_lib = static_library(
   'rde',
   'rde_dictionary_manager.cpp',
   'external_storer_file.cpp',
-  include_directories : rde_inc,
-  implicit_include_directories: false)
+  'rde_handler.cpp',
+  implicit_include_directories: false,
+  dependencies: rde_pre)
 
 rde_dep = declare_dependency(
-  link_with: rde_lib)
+  link_with: rde_lib,
+  dependencies: rde_pre)
diff --git a/src/rde/rde_handler.cpp b/src/rde/rde_handler.cpp
new file mode 100644
index 0000000..e5100e2
--- /dev/null
+++ b/src/rde/rde_handler.cpp
@@ -0,0 +1,334 @@
+#include "rde/rde_handler.hpp"
+
+#include <fmt/format.h>
+
+#include <iostream>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+/**
+ * @brief CRC-32 divisor.
+ *
+ * This is equivalent to the one used by IEEE802.3.
+ */
+constexpr uint32_t crcDevisor = 0xedb88320;
+
+RdeCommandHandler::RdeCommandHandler(
+    std::unique_ptr<ExternalStorerInterface> exStorer) :
+    flagState(RdeDictTransferFlagState::RdeStateIdle),
+    exStorer(std::move(exStorer))
+{
+    // Initialize CRC table.
+    calcCrcTable();
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::decodeRdeCommand(std::span<const uint8_t> rdeCommand,
+                                        RdeCommandType type)
+{
+    if (type == RdeCommandType::RdeMultiPartReceiveResponse)
+    {
+        return multiPartReceiveResp(rdeCommand);
+    }
+    if (type == RdeCommandType::RdeOperationInitRequest)
+    {
+        return operationInitRequest(rdeCommand);
+    }
+
+    fmt::print(stderr, "Invalid command type\n");
+    return RdeDecodeStatus::RdeInvalidCommand;
+}
+
+uint32_t RdeCommandHandler::getDictionaryCount()
+{
+    return dictionaryManager.getDictionaryCount();
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::operationInitRequest(std::span<const uint8_t> rdeCommand)
+{
+    const RdeOperationInitReqHeader* header =
+        reinterpret_cast<const RdeOperationInitReqHeader*>(rdeCommand.data());
+    // Check if there is a payload. If not, we are not doing anything.
+    if (!header->containsRequestPayload)
+    {
+        return RdeDecodeStatus::RdeOk;
+    }
+
+    if (header->operationType != rdeOpInitOperationUpdate)
+    {
+        fmt::print(stderr, "Operation not supported\n");
+        return RdeDecodeStatus::RdeUnsupportedOperation;
+    }
+
+    // OperationInit payload overflows are not suported.
+    if (header->sendDataTransferHandle != 0)
+    {
+        fmt::print(stderr, "Payload should fit in within the request\n");
+        return RdeDecodeStatus::RdePayloadOverflow;
+    }
+
+    auto schemaDictOrErr = dictionaryManager.getDictionary(header->resourceID);
+    if (!schemaDictOrErr)
+    {
+        fmt::print(stderr, "Schema Dictionary not found for resourceId: {}\n",
+                   header->resourceID);
+        return RdeDecodeStatus::RdeNoDictionary;
+    }
+
+    auto annotationDictOrErr = dictionaryManager.getAnnotationDictionary();
+    if (!annotationDictOrErr)
+    {
+        fmt::print(stderr, "Annotation dictionary not found\n");
+        return RdeDecodeStatus::RdeNoDictionary;
+    }
+
+    BejDictionaries dictionaries = {
+        .schemaDictionary = (*schemaDictOrErr).data(),
+        .annotationDictionary = (*annotationDictOrErr).data(),
+        // We do not use the error dictionary.
+        .errorDictionary = nullptr,
+    };
+
+    // Soon after header, we have bejLocator field. Then we have the encoded
+    // data.
+    const uint8_t* encodedPldmBlock = rdeCommand.data() +
+                                      sizeof(RdeOperationInitReqHeader) +
+                                      header->operationLocatorLength;
+
+    // Decoded the data.
+    if (decoder.decode(dictionaries, std::span(encodedPldmBlock,
+                                               header->requestPayloadLength)) !=
+        0)
+    {
+        fmt::print(stderr, "BEJ decoding failed.\n");
+        return RdeDecodeStatus::RdeBejDecodingError;
+    }
+
+    // Post the output.
+    if (!exStorer->publishJson(decoder.getOutput()))
+    {
+        fmt::print(stderr, "Failed to write to ExternalStorer.\n");
+        return RdeDecodeStatus::RdeExternalStorerError;
+    }
+    return RdeDecodeStatus::RdeOk;
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::multiPartReceiveResp(std::span<const uint8_t> rdeCommand)
+{
+    const MultipartReceiveResHeader* header =
+        reinterpret_cast<const MultipartReceiveResHeader*>(rdeCommand.data());
+
+    // This is a hack to get the resource ID for the dictionary data. Even
+    // though nextDataTransferHandle field is supposed to be used for something
+    // else, BIOS is using it to specify the resource ID corresponding to the
+    // dictionary data.
+    uint32_t resourceId = header->nextDataTransferHandle;
+
+    // data points to the payload of the MultipartReceive.
+    const uint8_t* data = rdeCommand.data() + sizeof(MultipartReceiveResHeader);
+    RdeDecodeStatus ret = RdeDecodeStatus::RdeOk;
+
+    switch (header->transferFlag)
+    {
+        case rdeMRecFlagStart:
+            handleFlagStart(header, data, resourceId);
+            break;
+        case rdeMRecFlagMiddle:
+            ret = handleFlagMiddle(header, data, resourceId);
+            break;
+        case rdeMRecFlagEnd:
+            ret = handleFlagEnd(rdeCommand, header, data, resourceId);
+            break;
+        case rdeMRecFlagStartAndEnd:
+            ret = handleFlagStartAndEnd(rdeCommand, header, data, resourceId);
+            break;
+        default:
+            fmt::print(stderr, "Invalid transfer flag: {}\n",
+                       header->transferFlag);
+            ret = RdeDecodeStatus::RdeInvalidCommand;
+    }
+
+    // If there is a failure, this assignment is not useful. So we can do it
+    // even if there is a failure.
+    prevDictResourceId = resourceId;
+    return ret;
+}
+
+void RdeCommandHandler::calcCrcTable()
+{
+    for (uint32_t i = 0; i < UINT8_MAX + 1; ++i)
+    {
+        uint32_t rem = i;
+        for (uint8_t k = 0; k < 8; ++k)
+        {
+            rem = (rem & 1) ? (rem >> 1) ^ crcDevisor : rem >> 1;
+        }
+        crcTable[i] = rem;
+    }
+}
+
+void RdeCommandHandler::updateCrc(std::span<const uint8_t> stream)
+{
+    for (uint32_t i = 0; i < stream.size_bytes(); ++i)
+    {
+        crc = crcTable[(crc ^ stream[i]) & 0xff] ^ (crc >> 8);
+    }
+}
+
+uint32_t RdeCommandHandler::finalChecksum()
+{
+    return (crc ^ 0xFFFFFFFF);
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::handleCrc(std::span<const uint8_t> multiReceiveRespCmd)
+{
+    const MultipartReceiveResHeader* header =
+        reinterpret_cast<const MultipartReceiveResHeader*>(
+            multiReceiveRespCmd.data());
+    const uint8_t* checksumPtr = multiReceiveRespCmd.data() +
+                                 sizeof(MultipartReceiveResHeader) +
+                                 header->dataLengthBytes;
+    uint32_t checksum = checksumPtr[0] | (checksumPtr[1] << 8) |
+                        (checksumPtr[2] << 16) | (checksumPtr[3] << 24);
+
+    if (finalChecksum() != checksum)
+    {
+        fmt::print(stderr, "Checksum failed. Ex: {} Calculated: {}\n", checksum,
+                   finalChecksum());
+        dictionaryManager.invalidateDictionaries();
+        return RdeDecodeStatus::RdeInvalidChecksum;
+    }
+    return RdeDecodeStatus::RdeOk;
+}
+
+void RdeCommandHandler::handleFlagStart(const MultipartReceiveResHeader* header,
+                                        const uint8_t* data,
+                                        uint32_t resourceId)
+{
+    // This is a beginning of a dictionary. Reset CRC.
+    crc = 0xFFFFFFFF;
+    std::span dataS(data, header->dataLengthBytes);
+    dictionaryManager.startDictionaryEntry(resourceId, dataS);
+    // Start checksum calculation only for the data portion.
+    updateCrc(dataS);
+    flagState = RdeDictTransferFlagState::RdeStateStartRecvd;
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::handleFlagMiddle(const MultipartReceiveResHeader* header,
+                                        const uint8_t* data,
+                                        uint32_t resourceId)
+{
+    if (flagState != RdeDictTransferFlagState::RdeStateStartRecvd)
+    {
+        fmt::print(
+            stderr,
+            "Invalid dictionary packet order. Need start before middle.\n");
+        return RdeDecodeStatus::RdeInvalidPktOrder;
+    }
+
+    std::span dataS(data, header->dataLengthBytes);
+    if (prevDictResourceId != resourceId)
+    {
+        // Start of a new dictionary. Mark previous dictionary as
+        // complete.
+        dictionaryManager.markDataComplete(prevDictResourceId);
+        dictionaryManager.startDictionaryEntry(resourceId, dataS);
+    }
+    else
+    {
+        // Not a new dictionary. Add the received data to the existing
+        // dictionary.
+        if (!dictionaryManager.addDictionaryData(resourceId, dataS))
+        {
+            fmt::print(stderr,
+                       "Failed to add dictionary data: ResourceId: {}\n",
+                       resourceId);
+            return RdeDecodeStatus::RdeDictionaryError;
+        }
+    }
+    // Continue checksum calculation only for the data portion.
+    updateCrc(dataS);
+    return RdeDecodeStatus::RdeOk;
+}
+
+RdeDecodeStatus
+    RdeCommandHandler::handleFlagEnd(std::span<const uint8_t> rdeCommand,
+                                     const MultipartReceiveResHeader* header,
+                                     const uint8_t* data, uint32_t resourceId)
+{
+    if (flagState != RdeDictTransferFlagState::RdeStateStartRecvd)
+    {
+        fmt::print(
+            stderr,
+            "Invalid dictionary packet order. Need start before middle.\n");
+        return RdeDecodeStatus::RdeInvalidPktOrder;
+    }
+    flagState = RdeDictTransferFlagState::RdeStateIdle;
+
+    std::span dataS(data, header->dataLengthBytes);
+    if (prevDictResourceId != resourceId)
+    {
+        // Start of a new dictionary. Mark previous dictionary as
+        // complete.
+        dictionaryManager.markDataComplete(prevDictResourceId);
+        dictionaryManager.startDictionaryEntry(resourceId, dataS);
+    }
+    else
+    {
+        if (!dictionaryManager.addDictionaryData(resourceId, dataS))
+        {
+            fmt::print(stderr,
+                       "Failed to add dictionary data: ResourceId: {}\n",
+                       resourceId);
+            return RdeDecodeStatus::RdeDictionaryError;
+        }
+    }
+    dictionaryManager.markDataComplete(resourceId);
+
+    // Continue checksum calculation only for the data portion. At the end of
+    // data, we will have the DataIntegrityChecksum field. So omit that when
+    // calculating checksum.
+    updateCrc(dataS);
+    auto ret = handleCrc(rdeCommand);
+    if (ret != RdeDecodeStatus::RdeOk)
+    {
+        return ret;
+    }
+    return RdeDecodeStatus::RdeStopFlagReceived;
+}
+
+RdeDecodeStatus RdeCommandHandler::handleFlagStartAndEnd(
+    std::span<const uint8_t> rdeCommand,
+    const MultipartReceiveResHeader* header, const uint8_t* data,
+    uint32_t resourceId)
+{
+    // This is a beginning of a dictionary. Reset CRC.
+    crc = 0xFFFFFFFF;
+    // This is a beginning and end of a dictionary.
+    dictionaryManager.startDictionaryEntry(
+        resourceId, std::span(data, header->dataLengthBytes));
+    dictionaryManager.markDataComplete(resourceId);
+    flagState = RdeDictTransferFlagState::RdeStateIdle;
+
+    // Do checksum calculation only for the data portion. At the end of data, we
+    // will have the DataIntegrityChecksum field. So omit that when calculating
+    // checksum.
+    updateCrc(std::span(data, header->dataLengthBytes));
+
+    auto ret = handleCrc(rdeCommand);
+    if (ret != RdeDecodeStatus::RdeOk)
+    {
+        return ret;
+    }
+    return RdeDecodeStatus::RdeStopFlagReceived;
+}
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/subprojects/libbej.wrap b/subprojects/libbej.wrap
new file mode 100644
index 0000000..4c03659
--- /dev/null
+++ b/subprojects/libbej.wrap
@@ -0,0 +1,6 @@
+[wrap-git]
+url = https://github.com/openbmc/libbej
+revision = HEAD
+
+[provide]
+libbej = libbej
diff --git a/test/meson.build b/test/meson.build
index 01a92a2..6528b92 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -27,6 +27,7 @@
   'rde_dictionary_manager',
   'buffer',
   'external_storer_file',
+  'rde_handler',
 ]
 foreach t : gtests
   test(t, executable(t.underscorify(), t + '_test.cpp',
diff --git a/test/rde_handler_test.cpp b/test/rde_handler_test.cpp
new file mode 100644
index 0000000..ef0574d
--- /dev/null
+++ b/test/rde_handler_test.cpp
@@ -0,0 +1,320 @@
+#include "nlohmann/json.hpp"
+#include "rde/external_storer_interface.hpp"
+#include "rde/rde_handler.hpp"
+
+#include <memory>
+#include <span>
+
+#include <gmock/gmock-matchers.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+using ::testing::Return;
+
+/**
+ * @brief Dummy values for annotation dictionary. We do not need the annotation
+ * dictionary. So this contains a dictionary with some dummy values. But the RDE
+ * header is correct.
+ */
+constexpr std::array<uint8_t, 38> mRcvDummyAnnotation{
+    {0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+     0x0,  0x0,  0xc,  0x0,  0x0,  0xf0, 0xf0, 0xf1, 0x17, 0x1,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x16, 0x0,  0x5,  0x0,  0xc,
+     0x84, 0x0,  0x14, 0x0,  0x30, 0xa8, 0xc3, 0x3c}};
+
+constexpr std::array<uint8_t, 38> mRcvDummyInvalidChecksum{
+    {0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+     0x0,  0x0,  0xc,  0x0,  0x0,  0xf0, 0xf0, 0xf1, 0x17, 0x1,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x16, 0x0,  0x5,  0x0,  0xc,
+     0x84, 0x0,  0x14, 0x0,  0x17, 0x86, 0x00, 0x00}};
+
+/**
+ * @brief MultipartReceive command with START_AND_END flag set.
+ */
+constexpr std::array<uint8_t, 293> mRcvInput0StartAndEnd{
+    {0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00, 0x0,  0x0,
+     0xc,  0x0,  0x0,  0xf0, 0xf0, 0xf1, 0x17, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x16, 0x0,  0x5,  0x0,  0xc,  0x84, 0x0,  0x14, 0x0,  0x0,  0x48,
+     0x0,  0x1,  0x0,  0x13, 0x90, 0x0,  0x56, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x3,  0xa3, 0x0,  0x74, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16,
+     0xa6, 0x0,  0x34, 0x3,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16, 0xbc, 0x0,
+     0x64, 0x4,  0x0,  0x0,  0x0,  0x0,  0x0,  0x13, 0xd2, 0x0,  0x0,  0x0,
+     0x0,  0x52, 0x0,  0x2,  0x0,  0x0,  0x0,  0x0,  0x74, 0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0xf,  0xe5, 0x0,  0x46, 0x1,  0x0,  0x66, 0x0,  0x3,
+     0x0,  0xb,  0xf4, 0x0,  0x50, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x9,
+     0xff, 0x0,  0x50, 0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0x8,  0x1,
+     0x50, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0xf,  0x1,  0x44, 0x75,
+     0x6d, 0x6d, 0x79, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x0,  0x43, 0x68,
+     0x69, 0x6c, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x70,
+     0x65, 0x72, 0x74, 0x79, 0x0,  0x49, 0x64, 0x0,  0x53, 0x61, 0x6d, 0x70,
+     0x6c, 0x65, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x50, 0x72, 0x6f,
+     0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+     0x49, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65,
+     0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65,
+     0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x41,
+     0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61,
+     0x6e, 0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+     0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x44, 0x6f, 0x77, 0x6e, 0x0,  0x4c, 0x69,
+     0x6e, 0x6b, 0x55, 0x70, 0x0,  0x4e, 0x6f, 0x4c, 0x69, 0x6e, 0x6b, 0x0,
+     0x0,  0x8c, 0x87, 0xed, 0x74}};
+
+/**
+ * @brief MultipartReceive command with START flag set.
+ */
+constexpr std::array<uint8_t, 166> mRcvInput1Start{
+    {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x0,  0x0,
+     0xc,  0x0,  0x0,  0xf0, 0xf0, 0xf1, 0x17, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x16, 0x0,  0x5,  0x0,  0xc,  0x84, 0x0,  0x14, 0x0,  0x0,  0x48,
+     0x0,  0x1,  0x0,  0x13, 0x90, 0x0,  0x56, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x3,  0xa3, 0x0,  0x74, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16,
+     0xa6, 0x0,  0x34, 0x3,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16, 0xbc, 0x0,
+     0x64, 0x4,  0x0,  0x0,  0x0,  0x0,  0x0,  0x13, 0xd2, 0x0,  0x0,  0x0,
+     0x0,  0x52, 0x0,  0x2,  0x0,  0x0,  0x0,  0x0,  0x74, 0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0xf,  0xe5, 0x0,  0x46, 0x1,  0x0,  0x66, 0x0,  0x3,
+     0x0,  0xb,  0xf4, 0x0,  0x50, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x9,
+     0xff, 0x0,  0x50, 0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0x8,  0x1,
+     0x50, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0xf,  0x1,  0x44, 0x75,
+     0x6d, 0x6d, 0x79, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x0,  0x43, 0x68,
+     0x69, 0x6c, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72}};
+
+/**
+ * @brief MultipartReceive command with END flag set.
+ */
+constexpr std::array<uint8_t, 137> mRcvInput1End{
+    {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x6f, 0x70,
+     0x65, 0x72, 0x74, 0x79, 0x0,  0x49, 0x64, 0x0,  0x53, 0x61, 0x6d, 0x70,
+     0x6c, 0x65, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x50, 0x72, 0x6f,
+     0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+     0x49, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65,
+     0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65,
+     0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x41,
+     0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61,
+     0x6e, 0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+     0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x44, 0x6f, 0x77, 0x6e, 0x0,  0x4c, 0x69,
+     0x6e, 0x6b, 0x55, 0x70, 0x0,  0x4e, 0x6f, 0x4c, 0x69, 0x6e, 0x6b, 0x0,
+     0x0,  0x8c, 0x87, 0xed, 0x74}};
+
+/**
+ * @brief MultipartReceive command with START flag set.
+ */
+constexpr std::array<uint8_t, 106> mRcvInput2Start{
+    {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x60, 0x0,  0x00, 0x00, 0x0,  0x0,
+     0xc,  0x0,  0x0,  0xf0, 0xf0, 0xf1, 0x17, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x16, 0x0,  0x5,  0x0,  0xc,  0x84, 0x0,  0x14, 0x0,  0x0,  0x48,
+     0x0,  0x1,  0x0,  0x13, 0x90, 0x0,  0x56, 0x1,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x3,  0xa3, 0x0,  0x74, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16,
+     0xa6, 0x0,  0x34, 0x3,  0x0,  0x0,  0x0,  0x0,  0x0,  0x16, 0xbc, 0x0,
+     0x64, 0x4,  0x0,  0x0,  0x0,  0x0,  0x0,  0x13, 0xd2, 0x0,  0x0,  0x0,
+     0x0,  0x52, 0x0,  0x2,  0x0,  0x0,  0x0,  0x0,  0x74, 0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0xf,  0xe5, 0x0,  0x46, 0x1,  0x0,  0x66}};
+
+/**
+ * @brief MultipartReceive command with MIDDLE flag set.
+ */
+constexpr std::array<uint8_t, 106> mRcvInput2Mid{
+    {0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x60, 0x0,  0x00, 0x00, 0x0,  0x3,
+     0x0,  0xb,  0xf4, 0x0,  0x50, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x9,
+     0xff, 0x0,  0x50, 0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0x8,  0x1,
+     0x50, 0x2,  0x0,  0x0,  0x0,  0x0,  0x0,  0x7,  0xf,  0x1,  0x44, 0x75,
+     0x6d, 0x6d, 0x79, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x0,  0x43, 0x68,
+     0x69, 0x6c, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x70,
+     0x65, 0x72, 0x74, 0x79, 0x0,  0x49, 0x64, 0x0,  0x53, 0x61, 0x6d, 0x70,
+     0x6c, 0x65, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x50, 0x72, 0x6f,
+     0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70}};
+
+/**
+ * @brief MultipartReceive command with END flag set.
+ */
+constexpr std::array<uint8_t, 101> mRcvInput2End{
+    {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x57, 0x0,  0x00, 0x00, 0x6c, 0x65,
+     0x49, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65,
+     0x72, 0x74, 0x79, 0x0,  0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65,
+     0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x0,  0x41,
+     0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61,
+     0x6e, 0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+     0x0,  0x4c, 0x69, 0x6e, 0x6b, 0x44, 0x6f, 0x77, 0x6e, 0x0,  0x4c, 0x69,
+     0x6e, 0x6b, 0x55, 0x70, 0x0,  0x4e, 0x6f, 0x4c, 0x69, 0x6e, 0x6b, 0x0,
+     0x0,  0x8c, 0x87, 0xed, 0x74}};
+
+/**
+ * @brief RDEOperationInit command with encoded json/dummysimple.json as the
+ * payload.
+ */
+constexpr std::array<uint8_t, 113> mInitOp{
+    {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00,
+     0x00, 0x60, 0x00, 0x00, 0x00, 0x0,  0xf0, 0xf0, 0xf1, 0x0,  0x0,  0x0,
+     0x1,  0x0,  0x0,  0x1,  0x54, 0x1,  0x5,  0x1,  0x2,  0x50, 0x1,  0x9,
+     0x44, 0x75, 0x6d, 0x6d, 0x79, 0x20, 0x49, 0x44, 0x0,  0x1,  0x6,  0x20,
+     0x1,  0x0,  0x1,  0x8,  0x60, 0x1,  0xb,  0x1,  0x2,  0x38, 0xea, 0x1,
+     0x0,  0x2,  0xa3, 0x23, 0x1,  0x0,  0x1,  0x4,  0x70, 0x1,  0x1,  0x0,
+     0x1,  0x0,  0x10, 0x1,  0x24, 0x1,  0x2,  0x1,  0x0,  0x0,  0x1,  0xf,
+     0x1,  0x2,  0x1,  0x0,  0x70, 0x1,  0x1,  0x1,  0x1,  0x2,  0x40, 0x1,
+     0x2,  0x1,  0x2,  0x1,  0x2,  0x0,  0x1,  0x9,  0x1,  0x1,  0x1,  0x2,
+     0x40, 0x1,  0x2,  0x1,  0x2}};
+
+class MockExternalStorer : public ExternalStorerInterface
+{
+  public:
+    MOCK_METHOD(bool, publishJson, (std::string_view jsonStr), (override));
+};
+
+class RdeHandlerTest : public ::testing::Test
+{
+  public:
+    RdeHandlerTest() : mockExStorer(std::make_unique<MockExternalStorer>())
+    {
+        mockExStorerPtr = dynamic_cast<MockExternalStorer*>(mockExStorer.get());
+        rdeH = std::make_unique<RdeCommandHandler>(std::move(mockExStorer));
+    }
+
+  protected:
+    std::unique_ptr<ExternalStorerInterface> mockExStorer;
+    std::unique_ptr<RdeCommandHandler> rdeH;
+    MockExternalStorer* mockExStorerPtr;
+    const std::string exJson =
+        R"({"Id":"Dummy ID","SampleIntegerProperty":null,"SampleRealProperty":-5576.9123,"SampleEnabledProperty":false,"ChildArrayProperty":[{"AnotherBoolean":true,"LinkStatus":"NoLink"},{"LinkStatus":"NoLink"}]})";
+};
+
+TEST_F(RdeHandlerTest, DictionaryStartAndEndTest)
+{
+    // Send a payload with START_AND_END flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput0StartAndEnd),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 1);
+    // Send annotation dictionary.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvDummyAnnotation),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 2);
+
+    // Send the encoded payload.
+    EXPECT_CALL(*mockExStorerPtr, publishJson(exJson)).WillOnce(Return(true));
+    EXPECT_THAT(rdeH->decodeRdeCommand(std::span(mInitOp),
+                                       RdeCommandType::RdeOperationInitRequest),
+                RdeDecodeStatus::RdeOk);
+}
+
+TEST_F(RdeHandlerTest, DictionaryStartThenEndTest)
+{
+    // Send a payload with START flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput1Start),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeOk);
+    // We didn't send END. So dictionary count should be 0.
+    EXPECT_THAT(rdeH->getDictionaryCount(), 0);
+    // Send a payload with END flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput1End),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 1);
+    // Send annotation dictionary.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvDummyAnnotation),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 2);
+
+    // Send the encoded payload.
+    EXPECT_CALL(*mockExStorerPtr, publishJson(exJson)).WillOnce(Return(true));
+    EXPECT_THAT(rdeH->decodeRdeCommand(std::span(mInitOp),
+                                       RdeCommandType::RdeOperationInitRequest),
+                RdeDecodeStatus::RdeOk);
+
+    // Sending the START again for same resource ID should decrease the
+    // dictionary count.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput1Start),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeOk);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 1);
+}
+
+TEST_F(RdeHandlerTest, DictionaryStartMidEndTest)
+{
+    // Send a payload with START flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput2Start),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeOk);
+    // We didn't send END. So dictionary count should be 0.
+    EXPECT_THAT(rdeH->getDictionaryCount(), 0);
+    // Send a payload with MIDDLE flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput2Mid),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeOk);
+    // We didn't send END. So dictionary count should be 0.
+    EXPECT_THAT(rdeH->getDictionaryCount(), 0);
+    // Send a payload with END flag.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput2End),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 1);
+
+    // Send annotation dictionary.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvDummyAnnotation),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->getDictionaryCount(), 2);
+
+    // Send the encoded payload.
+    EXPECT_CALL(*mockExStorerPtr, publishJson(exJson)).WillOnce(Return(true));
+    EXPECT_THAT(rdeH->decodeRdeCommand(std::span(mInitOp),
+                                       RdeCommandType::RdeOperationInitRequest),
+                RdeDecodeStatus::RdeOk);
+}
+
+TEST_F(RdeHandlerTest, InvalidDictionaryFlowTest)
+{
+    // Send a payload with MIDDLE flag before START and it should fail.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput2Mid),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeInvalidPktOrder);
+    // Send a payload with END flag before START and it should fail.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvInput2End),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeInvalidPktOrder);
+}
+
+TEST_F(RdeHandlerTest, MissingDictionaryTest)
+{
+    // Try decoding without any dictionaries.
+    EXPECT_THAT(rdeH->decodeRdeCommand(std::span(mInitOp),
+                                       RdeCommandType::RdeOperationInitRequest),
+                RdeDecodeStatus::RdeNoDictionary);
+
+    // Try decoding just with annotation dictionary.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvDummyAnnotation),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeStopFlagReceived);
+    EXPECT_THAT(rdeH->decodeRdeCommand(std::span(mInitOp),
+                                       RdeCommandType::RdeOperationInitRequest),
+                RdeDecodeStatus::RdeNoDictionary);
+}
+
+TEST_F(RdeHandlerTest, InvalidDictionaryChecksumTest)
+{
+    // Send a dictionary with an invalid checksum.
+    EXPECT_THAT(
+        rdeH->decodeRdeCommand(std::span(mRcvDummyInvalidChecksum),
+                               RdeCommandType::RdeMultiPartReceiveResponse),
+        RdeDecodeStatus::RdeInvalidChecksum);
+}
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger