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)),
|
|
|
|
metadataOnly(true),
|
|
|
|
msgsToUsersTotalSize(msgsToUserTotalSize),
|
|
|
|
msgsToUserStartPtr(msgsToUser),
|
|
|
|
fsRequestsTotalSize(fsRequestsSize),
|
|
|
|
fsRequestStartPtr(fsRequests) {}
|
|
|
|
|
2023-07-26 17:47:27 +02:00
|
|
|
cfdp::PutRequest::PutRequest(cfdp::EntityId destId, cfdp::StringLv &sourceName,
|
|
|
|
cfdp::StringLv &destName)
|
|
|
|
: destId(std::move(destId)), sourceName(sourceName), destName(destName) {}
|
|
|
|
|
2023-07-24 11:15:50 +02:00
|
|
|
[[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-26 16:58:58 +02:00
|
|
|
if (buffer == nullptr or size == nullptr) {
|
2023-07-26 16:25:42 +02:00
|
|
|
return FAILED;
|
2023-07-24 10:52:38 +02:00
|
|
|
}
|
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-26 16:58:58 +02:00
|
|
|
ReturnValue_t result = destId.serializeAsLv(buffer, size, maxSize);
|
2023-07-26 16:25:42 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
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) {
|
2023-07-26 17:17:51 +02:00
|
|
|
result = sourceName.serialize(buffer, size, maxSize, streamEndianness);
|
2023-07-24 10:52:38 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-26 17:17:51 +02:00
|
|
|
result = destName.serialize(buffer, size, maxSize, streamEndianness);
|
2023-07-24 10:52:38 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
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-26 16:58:58 +02:00
|
|
|
if (buffer == nullptr or size == nullptr) {
|
|
|
|
return FAILED;
|
2023-07-24 11:33:37 +02:00
|
|
|
}
|
2023-07-26 16:58:58 +02:00
|
|
|
ReturnValue_t result = destId.deSerializeFromLv(buffer, size);
|
2023-07-24 11:33:37 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
result = SerializeAdapter::deSerialize(&metadataOnly, buffer, size, streamEndianness);
|
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
if (!metadataOnly) {
|
2023-07-26 17:17:51 +02:00
|
|
|
result = sourceName.deSerialize(buffer, size, streamEndianness);
|
2023-07-24 11:33:37 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-26 17:17:51 +02:00
|
|
|
result = destName.deSerialize(buffer, size, streamEndianness);
|
2023-07-24 16:38:11 +02:00
|
|
|
if (result != OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2023-07-26 18:20:32 +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 {
|
2023-07-26 16:58:58 +02:00
|
|
|
// Entity ID LV (1 leading size byte) and the metadata only flag.
|
|
|
|
size_t baseSize = 1 + destId.getSerializedSize() + 1;
|
2023-07-24 11:05:11 +02:00
|
|
|
if (!metadataOnly) {
|
2023-07-26 18:20:32 +02:00
|
|
|
baseSize += sourceName.getSerializedSize() + destName.getSerializedSize() + 4;
|
2023-07-24 11:05:11 +02:00
|
|
|
}
|
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_) {
|
2023-07-26 17:17:51 +02:00
|
|
|
this->sourceName = sourceName_;
|
|
|
|
this->destName = destName_;
|
2023-07-24 16:38:11 +02:00
|
|
|
}
|
2023-07-26 17:17:51 +02:00
|
|
|
|
|
|
|
const cfdp::StringLv &cfdp::PutRequest::getSourceName() const { return sourceName; }
|
|
|
|
|
|
|
|
const cfdp::StringLv &cfdp::PutRequest::getDestName() const { return destName; }
|
|
|
|
|
|
|
|
const cfdp::EntityId &cfdp::PutRequest::getDestId() const { return destId; }
|
|
|
|
|
|
|
|
void cfdp::PutRequest::setDestId(cfdp::EntityId id) { destId = std::move(id); }
|
2023-07-26 17:47:27 +02:00
|
|
|
|
|
|
|
void cfdp::PutRequest::setTransmissionMode(cfdp::TransmissionMode transmissionMode_) {
|
|
|
|
this->transmissionMode = transmissionMode_;
|
|
|
|
hasTransmissionMode = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void cfdp::PutRequest::clearTransmissionMode() { hasTransmissionMode = false; }
|
|
|
|
|
|
|
|
void cfdp::PutRequest::clearClosureRequest() { hasClosureRequested = false; }
|
|
|
|
|
|
|
|
void cfdp::PutRequest::setClosureRequest(bool closureRequested_) {
|
|
|
|
this->closureRequested = closureRequested_;
|
|
|
|
hasClosureRequested = true;
|
|
|
|
}
|
2023-07-26 18:20:32 +02:00
|
|
|
|
|
|
|
const uint8_t *cfdp::PutRequest::getMessagesToUser(size_t &totalSize) {
|
|
|
|
totalSize = this->msgsToUsersTotalSize;
|
|
|
|
return msgsToUserStartPtr;
|
|
|
|
}
|