MetadataPdu.cpp

Go to the documentation of this file.

// ======================================================================
// \title  MetadataPdu.cpp
// \author Brian Campuzano
// \brief  cpp file for CFDP Metadata PDU
// ======================================================================

#include <Fw/Types/Assert.hpp>
#include <Fw/Types/StringUtils.hpp>
#include <Svc/Ccsds/CfdpManager/Types/MetadataPdu.hpp>
#include <config/CfdpCfg.hpp>

namespace Svc {
namespace Ccsds {
namespace Cfdp {

void MetadataPdu::initialize(PduDirection direction,
                             Cfdp::Class::T txmMode,
                             EntityId sourceEid,
                             TransactionSeq transactionSeq,
                             EntityId destEid,
                             FileSize fileSize,
                             const Fw::String& sourceFilename,
                             const Fw::String& destFilename,
                             ChecksumType checksumType,
                             U8 closureRequested) {
    this->m_header.initialize(PduTypeEnum::METADATA, direction, txmMode, sourceEid, transactionSeq, destEid);

    this->m_fileSize = fileSize;

    // Enforce MaxFilePathSize for source filename
    FwSizeType srcLen = sourceFilename.length();
    FW_ASSERT(srcLen <= MaxFilePathSize, static_cast<FwAssertArgType>(srcLen), MaxFilePathSize);
    this->m_sourceFilename = sourceFilename;

    // Enforce MaxFilePathSize for destination filename
    FwSizeType dstLen = destFilename.length();
    FW_ASSERT(dstLen <= MaxFilePathSize, static_cast<FwAssertArgType>(dstLen), MaxFilePathSize);
    this->m_destFilename = destFilename;

    this->m_checksumType = checksumType;
    this->m_closureRequested = closureRequested;
}

U32 MetadataPdu::getBufferSize() const {
    U32 size = this->m_header.getBufferSize();

    // Directive code: 1 byte
    // Segmentation control byte (includes closure requested and checksum type): 1 byte
    // File size: variable
    size += static_cast<U32>(sizeof(U8) + sizeof(U8) + sizeof(FileSize));

    // Source filename LV: length(1) + value(n)
    size += 1 + static_cast<U32>(this->m_sourceFilename.length());

    // Dest filename LV: length(1) + value(n)
    size += 1 + static_cast<U32>(this->m_destFilename.length());

    return size;
}

Fw::SerializeStatus MetadataPdu::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
    return this->toSerialBuffer(buffer);
}

Fw::SerializeStatus MetadataPdu::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
    // Deserialize header first
    Fw::SerializeStatus status = this->m_header.fromSerialBuffer(buffer);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Validate this is a directive PDU (not file data)
    if (this->m_header.m_pduType != PduType::PDU_TYPE_DIRECTIVE) {
        return Fw::FW_DESERIALIZE_TYPE_MISMATCH;
    }

    // Validate directive code
    U8 directiveCode;
    status = buffer.deserializeTo(directiveCode);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }
    if (directiveCode != static_cast<U8>(FileDirective::FILE_DIRECTIVE_METADATA)) {
        return Fw::FW_DESERIALIZE_TYPE_MISMATCH;
    }

    // Now set the type to PduTypeEnum::METADATA since we've validated it
    this->m_header.m_type = PduTypeEnum::METADATA;

    // Deserialize the metadata body
    return this->fromSerialBuffer(buffer);
}

Fw::SerializeStatus MetadataPdu::toSerialBuffer(Fw::SerialBufferBase& serialBuffer) const {
    FW_ASSERT(this->m_header.m_type == PduTypeEnum::METADATA);

    // Calculate PDU data length (everything after header)
    U32 dataLength = this->getBufferSize() - this->m_header.getBufferSize();

    // Update header with data length
    PduHeader headerCopy = this->m_header;
    headerCopy.setPduDataLength(static_cast<U16>(dataLength));

    // Serialize header
    Fw::SerializeStatus status = headerCopy.toSerialBuffer(serialBuffer);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Directive code (METADATA = 7)
    U8 directiveCode = static_cast<U8>(FileDirective::FILE_DIRECTIVE_METADATA);
    status = serialBuffer.serializeFrom(directiveCode);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Segmentation control byte
    // bit 7: closure_requested
    // bits 6-4: reserved (000b)
    // bits 3-0: checksum_type
    U8 segmentationControl = 0;
    segmentationControl =
        static_cast<U8>(segmentationControl | static_cast<U8>((this->m_closureRequested & 0x01U) << 7));
    segmentationControl = static_cast<U8>(segmentationControl | (static_cast<U8>(this->m_checksumType) & 0x0FU));

    status = serialBuffer.serializeFrom(segmentationControl);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // File size (FileSize)
    status = serialBuffer.serializeFrom(this->m_fileSize);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Source filename LV
    U8 sourceFilenameLength = static_cast<U8>(this->m_sourceFilename.length());
    status = serialBuffer.serializeFrom(sourceFilenameLength);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Serialize source filename bytes without length prefix
    status = serialBuffer.serializeFrom(reinterpret_cast<const U8*>(this->m_sourceFilename.toChar()),
                                        sourceFilenameLength, Fw::Serialization::OMIT_LENGTH);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Destination filename LV
    U8 destFilenameLength = static_cast<U8>(this->m_destFilename.length());
    status = serialBuffer.serializeFrom(destFilenameLength);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Serialize dest filename bytes without length prefix
    status = serialBuffer.serializeFrom(reinterpret_cast<const U8*>(this->m_destFilename.toChar()), destFilenameLength,
                                        Fw::Serialization::OMIT_LENGTH);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    return Fw::FW_SERIALIZE_OK;
}

Fw::SerializeStatus MetadataPdu::fromSerialBuffer(Fw::SerialBufferBase& serialBuffer) {
    FW_ASSERT(this->m_header.m_type == PduTypeEnum::METADATA);

    // Directive code already read by union wrapper

    // Segmentation control byte
    U8 segmentationControl;
    Fw::SerializeStatus status = serialBuffer.deserializeTo(segmentationControl);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    this->m_closureRequested = (segmentationControl >> 7) & 0x01;
    U8 checksumTypeVal = segmentationControl & 0x0F;
    this->m_checksumType = static_cast<ChecksumType>(checksumTypeVal);

    // File size
    status = serialBuffer.deserializeTo(this->m_fileSize);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Source filename LV
    U8 sourceFilenameLength;
    status = serialBuffer.deserializeTo(sourceFilenameLength);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Validate filename length against MaxFilePathSize
    if (sourceFilenameLength > MaxFilePathSize) {
        return Fw::FW_DESERIALIZE_SIZE_MISMATCH;
    }

    // Validate filename is not empty
    if (sourceFilenameLength == 0) {
        return Fw::FW_DESERIALIZE_SIZE_MISMATCH;
    }

    // Read filename into temporary buffer
    U8 sourceFilenameBuffer[MaxFilePathSize + 1];
    FwSizeType actualLength = sourceFilenameLength;
    status = serialBuffer.deserializeTo(sourceFilenameBuffer, actualLength, Fw::Serialization::OMIT_LENGTH);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }
    // Null-terminate before assigning to Fw::String
    sourceFilenameBuffer[sourceFilenameLength] = '\0';
    this->m_sourceFilename = reinterpret_cast<const CHAR*>(sourceFilenameBuffer);

    // Destination filename LV
    U8 destFilenameLength;
    status = serialBuffer.deserializeTo(destFilenameLength);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Validate filename length against MaxFilePathSize
    if (destFilenameLength > MaxFilePathSize) {
        return Fw::FW_DESERIALIZE_SIZE_MISMATCH;
    }

    // Validate filename is not empty
    if (destFilenameLength == 0) {
        return Fw::FW_DESERIALIZE_SIZE_MISMATCH;
    }

    // Read filename into temporary buffer
    U8 destFilenameBuffer[MaxFilePathSize + 1];
    actualLength = destFilenameLength;
    status = serialBuffer.deserializeTo(destFilenameBuffer, actualLength, Fw::Serialization::OMIT_LENGTH);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }
    // Null-terminate before assigning to Fw::String
    destFilenameBuffer[destFilenameLength] = '\0';
    this->m_destFilename = reinterpret_cast<const CHAR*>(destFilenameBuffer);

    return Fw::FW_SERIALIZE_OK;
}

}  // namespace Cfdp
}  // namespace Ccsds
}  // namespace Svc