2022-08-03 16:00:48 +02:00
|
|
|
#include "FileDataCreator.h"
|
2022-02-02 10:29:30 +01:00
|
|
|
|
2021-12-03 15:37:49 +01:00
|
|
|
#include <cstring>
|
|
|
|
|
2022-08-03 16:00:48 +02:00
|
|
|
FileDataCreator::FileDataCreator(PduConfig& conf, FileDataInfo& info)
|
2022-09-15 18:41:15 +02:00
|
|
|
: HeaderCreator(conf, cfdp::PduType::FILE_DATA, 0, info.getSegmentMetadataFlag()), info(info) {
|
2022-02-02 10:29:30 +01:00
|
|
|
update();
|
2021-12-03 15:37:49 +01:00
|
|
|
}
|
|
|
|
|
2022-08-03 16:00:48 +02:00
|
|
|
void FileDataCreator::update() {
|
2022-02-02 10:29:30 +01:00
|
|
|
this->setSegmentMetadataFlag(info.getSegmentMetadataFlag());
|
|
|
|
this->setSegmentationControl(info.getSegmentationControl());
|
|
|
|
setPduDataFieldLen(info.getSerializedSize(this->getLargeFileFlag()));
|
2021-12-03 15:37:49 +01:00
|
|
|
}
|
|
|
|
|
2022-08-03 16:00:48 +02:00
|
|
|
ReturnValue_t FileDataCreator::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
|
|
|
|
Endianness streamEndianness) const {
|
2022-09-06 15:45:51 +02:00
|
|
|
if (buffer == nullptr or size == nullptr) {
|
|
|
|
return returnvalue::FAILED;
|
|
|
|
}
|
|
|
|
if (*size + getSerializedSize() > maxSize) {
|
|
|
|
return SerializeIF::BUFFER_TOO_SHORT;
|
|
|
|
}
|
2022-08-03 15:22:39 +02:00
|
|
|
ReturnValue_t result = HeaderCreator::serialize(buffer, size, maxSize, streamEndianness);
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
2022-09-06 15:45:51 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
const uint8_t* readOnlyPtr = nullptr;
|
|
|
|
if (this->hasSegmentMetadataFlag()) {
|
|
|
|
size_t segmentMetadataLen = info.getSegmentMetadataLen();
|
|
|
|
**buffer = info.getRecordContinuationState() << 6 | segmentMetadataLen;
|
|
|
|
*buffer += 1;
|
|
|
|
*size += 1;
|
|
|
|
readOnlyPtr = info.getSegmentMetadata();
|
|
|
|
std::memcpy(*buffer, readOnlyPtr, segmentMetadataLen);
|
|
|
|
*buffer += segmentMetadataLen;
|
|
|
|
*size += segmentMetadataLen;
|
|
|
|
}
|
|
|
|
cfdp::FileSize& offset = info.getOffset();
|
|
|
|
result = offset.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
size_t fileSize = 0;
|
|
|
|
readOnlyPtr = info.getFileData(&fileSize);
|
|
|
|
if (*size + fileSize > maxSize) {
|
|
|
|
return SerializeIF::BUFFER_TOO_SHORT;
|
|
|
|
}
|
|
|
|
std::memcpy(*buffer, readOnlyPtr, fileSize);
|
|
|
|
*buffer += fileSize;
|
|
|
|
*size += fileSize;
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2021-12-03 15:37:49 +01:00
|
|
|
}
|
|
|
|
|
2022-08-03 16:00:48 +02:00
|
|
|
size_t FileDataCreator::getSerializedSize() const {
|
2022-08-03 15:22:39 +02:00
|
|
|
return HeaderCreator::getSerializedSize() + info.getSerializedSize(this->getLargeFileFlag());
|
2021-12-03 15:37:49 +01:00
|
|
|
}
|