PduHeader.cpp

Go to the documentation of this file.

// ======================================================================
// \title  PduHeader.cpp
// \author Brian Campuzano
// \brief  cpp file for CFDP PDU Header
// ======================================================================

#include <Fw/Types/Assert.hpp>
#include <Fw/Types/StringUtils.hpp>
#include <Svc/Ccsds/CfdpManager/Types/PduHeader.hpp>
#include <Svc/Ccsds/CfdpManager/Types/Types.hpp>

namespace Svc {
namespace Ccsds {
namespace Cfdp {

void PduHeader::initialize(PduTypeEnum::T type,
                           PduDirection direction,
                           Cfdp::Class::T txmMode,
                           EntityId sourceEid,
                           TransactionSeq transactionSeq,
                           EntityId destEid) {
    this->m_type = type;
    this->m_version = CFDP_VERSION;
    this->m_pduType = (type == PduTypeEnum::FILE_DATA) ? PduType::PDU_TYPE_FILE_DATA : PduType::PDU_TYPE_DIRECTIVE;
    this->m_direction = direction;
    this->m_class = txmMode;
    this->m_crcFlag = CrcFlag::CRC_NOT_PRESENT;                // CRC not currently supported
    this->m_largeFileFlag = LargeFileFlag::LARGE_FILE_32_BIT;  // 32-bit file sizes
    this->m_segmentationControl = 0;
    this->m_segmentMetadataFlag = 0;
    this->m_pduDataLength = 0;  // To be set later
    this->m_sourceEid = sourceEid;
    this->m_transactionSeq = transactionSeq;
    this->m_destEid = destEid;
}

// Helper function to calculate minimum bytes needed to encode a value
U8 PduHeader::getValueEncodedSize(U64 value) {
    U8 minSize;
    U64 limit = 0x100;

    for (minSize = 1; minSize < 8 && value >= limit; ++minSize) {
        limit <<= 8;
    }

    return minSize;
}

// Helper function to encode an integer in variable-length format
static Fw::SerializeStatus encodeIntegerInSize(Fw::SerialBufferBase& serialBuffer, U64 value, U8 encodeSize) {
    // Encode from MSB to LSB (big-endian)
    for (U8 i = 0; i < encodeSize; ++i) {
        U8 shift = static_cast<U8>((encodeSize - 1 - i) * 8);
        U8 byte = static_cast<U8>((value >> shift) & 0xFF);
        Fw::SerializeStatus status = serialBuffer.serializeFrom(byte);
        if (status != Fw::FW_SERIALIZE_OK) {
            return status;
        }
    }
    return Fw::FW_SERIALIZE_OK;
}

// Helper function to decode an integer from variable-length format
static U64 decodeIntegerInSize(Fw::SerialBufferBase& serialBuffer, U8 decodeSize, Fw::SerializeStatus& status) {
    U64 value = 0;

    // Decode from MSB to LSB (big-endian)
    for (U8 i = 0; i < decodeSize; ++i) {
        U8 byte;
        status = serialBuffer.deserializeTo(byte);
        if (status != Fw::FW_SERIALIZE_OK) {
            return 0;
        }
        value = (value << 8) | byte;
    }

    return value;
}

// Helper function to decode a variable-width field into a configured field type, rejecting values that do not fit
template <typename T>
static Fw::SerializeStatus decodeFieldInSize(Fw::SerialBufferBase& serialBuffer, U8 decodeSize, T& field) {
    Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
    const U64 value = decodeIntegerInSize(serialBuffer, decodeSize, status);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }
    if (static_cast<U64>(static_cast<T>(value)) != value) {
        return Fw::FW_DESERIALIZE_FORMAT_ERROR;
    }
    field = static_cast<T>(value);
    return Fw::FW_SERIALIZE_OK;
}

U32 PduHeader::getBufferSize() const {
    // Fixed portion: flags(1) + length(2) + eidTsnLengths(1) = 4 bytes
    U32 size = 4;

    // Variable-size entity IDs and transaction sequence number based on actual values
    U8 eidSize = getValueEncodedSize(this->m_sourceEid > this->m_destEid ? this->m_sourceEid : this->m_destEid);
    U8 tsnSize = getValueEncodedSize(this->m_transactionSeq);

    size += eidSize;  // source EID
    size += tsnSize;  // transaction sequence number
    size += eidSize;  // destination EID

    return size;
}

Fw::SerializeStatus PduHeader::toSerialBuffer(Fw::SerialBufferBase& serialBuffer) const {
    Fw::SerializeStatus status;

    // Variable-size entity IDs and transaction sequence number based on actual values
    U8 eidSize = getValueEncodedSize(this->m_sourceEid > this->m_destEid ? this->m_sourceEid : this->m_destEid);
    U8 tsnSize = getValueEncodedSize(this->m_transactionSeq);

    // Byte 0: flags
    // bits 7-5: version (001b = 1)
    // bit 4: pdu_type (0=directive, 1=file data)
    // bit 3: direction (0=toward receiver, 1=toward sender)
    // bit 2: txm_mode (0=ack, 1=unack)
    // bit 1: crc_flag (0=not present, 1=present)
    // bit 0: large_file_flag (0=32-bit, 1=64-bit)
    U8 flags = 0;
    flags = static_cast<U8>(flags | static_cast<U8>((this->m_version & 0x07U) << 5));
    flags = static_cast<U8>(flags | static_cast<U8>((static_cast<U8>(this->m_pduType) & 0x01U) << 4));
    flags = static_cast<U8>(flags | static_cast<U8>((static_cast<U8>(this->m_direction) & 0x01U) << 3));
    flags = static_cast<U8>(flags | static_cast<U8>((this->m_class & 0x01U) << 2));
    flags = static_cast<U8>(flags | static_cast<U8>((static_cast<U8>(this->m_crcFlag) & 0x01U) << 1));
    flags = static_cast<U8>(flags | (static_cast<U8>(this->m_largeFileFlag) & 0x01U));

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

    // Bytes 1-2: PDU data length (big-endian)
    status = serialBuffer.serializeFrom(static_cast<U16>(this->m_pduDataLength));
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Byte 3: eidTsnLengths
    // bit 7: segmentation_control
    // bits 6-4: eid_length - 1 (3 bits)
    // bit 3: segment_metadata_flag
    // bits 2-0: tsn_length - 1 (3 bits)
    U8 eidTsnLengths = 0;
    eidTsnLengths = static_cast<U8>(eidTsnLengths | static_cast<U8>((this->m_segmentationControl & 0x01U) << 7));
    eidTsnLengths = static_cast<U8>(eidTsnLengths | static_cast<U8>(((eidSize - 1U) & 0x07U) << 4));
    eidTsnLengths = static_cast<U8>(eidTsnLengths | static_cast<U8>((this->m_segmentMetadataFlag & 0x01U) << 3));
    eidTsnLengths = static_cast<U8>(eidTsnLengths | ((tsnSize - 1U) & 0x07U));

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

    // Variable-width fields (size based on actual values)
    status = encodeIntegerInSize(serialBuffer, this->m_sourceEid, eidSize);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    status = encodeIntegerInSize(serialBuffer, this->m_transactionSeq, tsnSize);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    status = encodeIntegerInSize(serialBuffer, this->m_destEid, eidSize);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    return Fw::FW_SERIALIZE_OK;
}

Fw::SerializeStatus PduHeader::fromSerialBuffer(Fw::SerialBufferBase& serialBuffer) {
    Fw::SerializeStatus status;

    // Byte 0: flags
    U8 flags;
    status = serialBuffer.deserializeTo(flags);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    this->m_version = (flags >> 5) & 0x07;
    this->m_pduType = static_cast<PduType>((flags >> 4) & 0x01);
    this->m_direction = static_cast<PduDirection>((flags >> 3) & 0x01);
    this->m_class = static_cast<Cfdp::Class::T>((flags >> 2) & 0x01);
    this->m_crcFlag = static_cast<CrcFlag>((flags >> 1) & 0x01);
    this->m_largeFileFlag = static_cast<LargeFileFlag>(flags & 0x01);

    // Reject headers announcing protocol features the body decoders do not implement:
    // other protocol versions, a trailing CRC, and 64-bit file sizes when FileSize is narrower
    if ((this->m_version != CFDP_VERSION) || (this->m_crcFlag != CrcFlag::CRC_NOT_PRESENT) ||
        ((this->m_largeFileFlag == LargeFileFlag::LARGE_FILE_64_BIT) && (sizeof(FileSize) < sizeof(U64)))) {
        return Fw::FW_DESERIALIZE_FORMAT_ERROR;
    }

    // Bytes 1-2: PDU data length
    status = serialBuffer.deserializeTo(this->m_pduDataLength);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Byte 3: eidTsnLengths
    U8 eidTsnLengths;
    status = serialBuffer.deserializeTo(eidTsnLengths);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    this->m_segmentationControl = (eidTsnLengths >> 7) & 0x01;
    U8 eidSize = static_cast<U8>(((eidTsnLengths >> 4) & 0x07) + 1);
    this->m_segmentMetadataFlag = (eidTsnLengths >> 3) & 0x01;
    U8 tsnSize = static_cast<U8>((eidTsnLengths & 0x07) + 1);

    // Validate that the sizes are within bounds (1-8 bytes)
    FW_ASSERT(eidSize >= 1 && eidSize <= 8, static_cast<FwAssertArgType>(eidSize));
    FW_ASSERT(tsnSize >= 1 && tsnSize <= 8, static_cast<FwAssertArgType>(tsnSize));

    // Variable-width fields (size determined by encoded length). Any wire width up to 8 bytes is
    // accepted, but the decoded value must fit the configured EntityId/TransactionSeq type.
    status = decodeFieldInSize(serialBuffer, eidSize, this->m_sourceEid);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    status = decodeFieldInSize(serialBuffer, tsnSize, this->m_transactionSeq);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    status = decodeFieldInSize(serialBuffer, eidSize, this->m_destEid);
    if (status != Fw::FW_SERIALIZE_OK) {
        return status;
    }

    // Don't set m_type yet - it will be determined by the directive code for directive PDUs
    // or set to FILE_DATA for file data PDUs
    if (this->m_pduType == PduType::PDU_TYPE_FILE_DATA) {
        this->m_type = PduTypeEnum::FILE_DATA;
    } else {
        // For directive PDUs, type will be set when directive code is read
        this->m_type = PduTypeEnum::NONE;
    }

    return Fw::FW_SERIALIZE_OK;
}

PduTypeEnum::T peekPduType(const Fw::Buffer& buffer) {
    PduTypeEnum::T pduTypeEnum = PduTypeEnum::NONE;

    // Check minimum size for a PDU header
    if (buffer.getSize() >= PduHeader::MIN_HEADERSIZE) {
        const U8* data = buffer.getData();
        FW_ASSERT(data != nullptr);

        // Byte 0: flags
        // Bit 4 is PDU type: 0 = FILE_DATA, 1 = FILE_DIRECTIVE
        U8 flags = data[0];
        PduType pduType = static_cast<PduType>((flags >> 4) & 0x01);

        if (pduType == PduType::PDU_TYPE_FILE_DATA) {
            pduTypeEnum = PduTypeEnum::FILE_DATA;
        } else {
            // For directive PDUs, we need to read the directive code
            // Parse byte 3 to get EID and TSN lengths
            U8 eidTsnLengths = data[3];
            U8 eidSize = static_cast<U8>(((eidTsnLengths >> 4) & 0x07) + 1);  // Bits 6-4: EID length - 1
            U8 tsnSize = static_cast<U8>((eidTsnLengths & 0x07) + 1);         // Bits 2-0: TSN length - 1

            // Calculate offset to directive code: 4 (fixed header) + eidSize + tsnSize + eidSize
            U32 directiveCodeOffset = 4 + (2 * eidSize) + tsnSize;

            // Validate offset is within buffer bounds before reading
            if (directiveCodeOffset < buffer.getSize()) {
                // Read directive code
                U8 directiveCode = data[directiveCodeOffset];

                // Map directive code to PduTypeEnum
                switch (directiveCode) {
                    case static_cast<U8>(FileDirective::FILE_DIRECTIVE_METADATA):
                        pduTypeEnum = PduTypeEnum::METADATA;
                        break;
                    case static_cast<U8>(FileDirective::FILE_DIRECTIVE_END_OF_FILE):
                        pduTypeEnum = PduTypeEnum::END_OF_FILE;
                        break;
                    case static_cast<U8>(FileDirective::FILE_DIRECTIVE_FIN):
                        pduTypeEnum = PduTypeEnum::FINISHED;
                        break;
                    case static_cast<U8>(FileDirective::FILE_DIRECTIVE_ACK):
                        pduTypeEnum = PduTypeEnum::ACKNOWLEDGMENT;
                        break;
                    case static_cast<U8>(FileDirective::FILE_DIRECTIVE_NAK):
                        pduTypeEnum = PduTypeEnum::NEGATIVE_ACK;
                        break;
                    default:
                        pduTypeEnum = PduTypeEnum::NONE;  // Unknown directive code
                }
            }
        }
    }
    return pduTypeEnum;
}

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