2023-07-21 16:35:05 +02:00
|
|
|
#include "PutRequest.h"
|
|
|
|
|
2023-07-24 10:52:38 +02:00
|
|
|
using namespace returnvalue;
|
2023-07-24 10:58:18 +02:00
|
|
|
|
2023-07-24 11:15:50 +02:00
|
|
|
cfdp::PutRequest::PutRequest(cfdp::EntityId destId, const uint8_t *msgsToUser,
|
|
|
|
size_t msgsToUserTotalSize, const uint8_t *fsRequests,
|
|
|
|
size_t fsRequestsSize)
|
|
|
|
: destId(std::move(destId)),
|
2023-07-24 11:33:37 +02:00
|
|
|
destIdWidth(destId.getWidth()),
|
2023-07-24 11:15:50 +02:00
|
|
|
metadataOnly(true),
|
|
|
|
msgsToUsersTotalSize(msgsToUserTotalSize),
|
|
|
|
msgsToUserStartPtr(msgsToUser),
|
|
|
|
fsRequestsTotalSize(fsRequestsSize),
|
|
|
|
fsRequestStartPtr(fsRequests) {}
|
|
|
|
|
|
|
|
[[nodiscard]] bool cfdp::PutRequest::isMetadataOnly() const { return metadataOnly; }
|
|
|
|
|
2023-07-24 10:11:16 +02:00
|
|
|
ReturnValue_t cfdp::PutRequest::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
|
|
|
|
SerializeIF::Endianness streamEndianness) const {
|
2023-07-24 10:52:38 +02:00
|
|
|
ReturnValue_t result = destId.serialize(buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:05:11 +02:00
|
|
|
if (*size + getSerializedSize() > maxSize) {
|
2023-07-24 10:52:38 +02:00
|
|
|
return SerializeIF::BUFFER_TOO_SHORT;
|
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
result = SerializeAdapter::serialize(&metadataOnly, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 10:52:38 +02:00
|
|
|
if (!metadataOnly) {
|
|
|
|
result = SerializeAdapter::serialize(&sourceNameSize, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
std::memcpy(*buffer, sourceName, sourceNameSize);
|
|
|
|
*buffer += sourceNameSize;
|
|
|
|
*size += sourceNameSize;
|
|
|
|
result = SerializeAdapter::serialize(&destNameSize, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
std::memcpy(*buffer, destName, destNameSize);
|
|
|
|
*buffer += destNameSize;
|
|
|
|
*size += destNameSize;
|
2023-07-24 16:38:11 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&hasTransmissionMode, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&transmissionMode, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
2023-07-24 10:52:38 +02:00
|
|
|
}
|
2023-07-24 16:38:11 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&hasClosureRequested, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&closureRequested, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
2023-07-24 10:52:38 +02:00
|
|
|
}
|
|
|
|
}
|
2023-07-24 10:58:18 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&msgsToUsersTotalSize, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:15:50 +02:00
|
|
|
std::memcpy(*buffer, msgsToUserStartPtr, msgsToUsersTotalSize);
|
2023-07-24 10:58:18 +02:00
|
|
|
*buffer += msgsToUsersTotalSize;
|
|
|
|
*size += msgsToUsersTotalSize;
|
2023-07-24 10:52:38 +02:00
|
|
|
|
2023-07-24 10:58:18 +02:00
|
|
|
result =
|
|
|
|
SerializeAdapter::serialize(&fsRequestsTotalSize, buffer, size, maxSize, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:15:50 +02:00
|
|
|
std::memcpy(*buffer, fsRequestStartPtr, fsRequestsTotalSize);
|
2023-07-24 10:58:18 +02:00
|
|
|
*buffer += fsRequestsTotalSize;
|
|
|
|
*size += fsRequestsTotalSize;
|
|
|
|
return OK;
|
2023-07-24 10:11:16 +02:00
|
|
|
}
|
2023-07-24 10:58:18 +02:00
|
|
|
|
2023-07-24 10:11:16 +02:00
|
|
|
ReturnValue_t cfdp::PutRequest::deSerialize(const uint8_t **buffer, size_t *size,
|
|
|
|
SerializeIF::Endianness streamEndianness) {
|
2023-07-24 11:33:37 +02:00
|
|
|
ReturnValue_t result =
|
|
|
|
SerializeAdapter::deSerialize(&destIdWidth, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = destId.deSerialize(static_cast<cfdp::WidthInBytes>(destIdWidth), buffer, size,
|
|
|
|
streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
result = SerializeAdapter::deSerialize(&metadataOnly, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
if (!metadataOnly) {
|
|
|
|
result = SerializeAdapter::deSerialize(&sourceNameSize, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
sourceName = reinterpret_cast<const char *>(*buffer);
|
|
|
|
*buffer += sourceNameSize;
|
|
|
|
*size += sourceNameSize;
|
|
|
|
result = SerializeAdapter::deSerialize(&destNameSize, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
destName = reinterpret_cast<const char *>(*buffer);
|
|
|
|
*buffer += destNameSize;
|
|
|
|
*size += destNameSize;
|
2023-07-24 16:38:11 +02:00
|
|
|
result = SerializeAdapter::deSerialize(&hasTransmissionMode, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
result = SerializeAdapter::deSerialize(&transmissionMode, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 16:38:11 +02:00
|
|
|
result = SerializeAdapter::deSerialize(&hasClosureRequested, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
result = SerializeAdapter::deSerialize(&closureRequested, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result = SerializeAdapter::deSerialize(&msgsToUsersTotalSize, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
msgsToUserStartPtr = *buffer;
|
|
|
|
*buffer += msgsToUsersTotalSize;
|
|
|
|
*size += msgsToUsersTotalSize;
|
|
|
|
|
|
|
|
result = SerializeAdapter::deSerialize(&fsRequestsTotalSize, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
fsRequestStartPtr = *buffer;
|
|
|
|
*buffer += fsRequestsTotalSize;
|
|
|
|
*size += fsRequestsTotalSize;
|
2023-07-24 10:58:18 +02:00
|
|
|
return OK;
|
2023-07-24 10:11:16 +02:00
|
|
|
}
|
2023-07-24 11:33:37 +02:00
|
|
|
|
2023-07-24 11:05:11 +02:00
|
|
|
size_t cfdp::PutRequest::getSerializedSize() const {
|
|
|
|
size_t baseSize = destId.getSerializedSize() + 1;
|
|
|
|
if (!metadataOnly) {
|
|
|
|
baseSize += sizeof(sourceNameSize) + sourceNameSize + sizeof(destNameSize) + destNameSize + 2;
|
|
|
|
}
|
2023-07-24 11:15:50 +02:00
|
|
|
baseSize += sizeof(msgsToUsersTotalSize) + msgsToUsersTotalSize + sizeof(fsRequestsTotalSize) +
|
|
|
|
fsRequestsTotalSize;
|
2023-07-24 11:05:11 +02:00
|
|
|
return baseSize;
|
|
|
|
}
|
2023-07-24 16:38:11 +02:00
|
|
|
|
|
|
|
void cfdp::PutRequest::setSourceAndDestName(cfdp::StringLv &sourceName_,
|
|
|
|
cfdp::StringLv &destName_) {
|
|
|
|
this->sourceName = sourceName_.getString(sourceNameSize);
|
|
|
|
this->destName = destName_.getString(sourceNameSize);
|
|
|
|
}
|