From 7d713219c553aea2de3917c142174ee719d3ec6d Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Fri, 30 Jun 2023 11:59:22 +0200 Subject: [PATCH] continue source handler --- src/fsfw/cfdp/handler/DestHandler.cpp | 229 +++++++++++---------- src/fsfw/cfdp/handler/DestHandler.h | 30 +-- src/fsfw/cfdp/handler/SourceHandler.cpp | 2 +- src/fsfw/cfdp/handler/SourceHandler.h | 15 +- src/fsfw/cfdp/handler/defs.h | 17 ++ unittests/cfdp/handler/testDestHandler.cpp | 2 +- 6 files changed, 161 insertions(+), 134 deletions(-) diff --git a/src/fsfw/cfdp/handler/DestHandler.cpp b/src/fsfw/cfdp/handler/DestHandler.cpp index 4ffa797f..76beb855 100644 --- a/src/fsfw/cfdp/handler/DestHandler.cpp +++ b/src/fsfw/cfdp/handler/DestHandler.cpp @@ -14,13 +14,13 @@ using namespace returnvalue; -cfdp::DestHandler::DestHandler(DestHandlerParams params, FsfwParams fsfwParams) +cfdp::DestHandler::DestHandler(DestHandlerParams params, FsfwDestParams fsfwParams) : tlvVec(params.maxTlvsInOnePdu), userTlvVec(params.maxTlvsInOnePdu), - dp(std::move(params)), - fp(fsfwParams), - tp(params.maxFilenameLen) { - tp.pduConf.direction = cfdp::Direction::TOWARDS_SENDER; + destParams(std::move(params)), + fsfwParams(fsfwParams), + transactionParams(params.maxFilenameLen) { + transactionParams.pduConf.direction = cfdp::Direction::TOWARDS_SENDER; } const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() { @@ -28,13 +28,14 @@ const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() { uint8_t errorIdx = 0; fsmRes.resetOfIteration(); if (fsmRes.step == TransactionStep::IDLE) { - for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) { + for (auto infoIter = destParams.packetListRef.begin(); + infoIter != destParams.packetListRef.end();) { if (infoIter->pduType == PduType::FILE_DIRECTIVE and infoIter->directiveType == FileDirective::METADATA) { result = handleMetadataPdu(*infoIter); checkAndHandleError(result, errorIdx); // Store data was deleted in PDU handler because a store guard is used - dp.packetListRef.erase(infoIter++); + destParams.packetListRef.erase(infoIter++); } else { infoIter++; } @@ -42,11 +43,12 @@ const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() { if (fsmRes.step == TransactionStep::IDLE) { // To decrease the already high complexity of the software, all packets arriving before // a metadata PDU are deleted. - for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) { - fp.tcStore->deleteData(infoIter->storeId); + for (auto infoIter = destParams.packetListRef.begin(); + infoIter != destParams.packetListRef.end();) { + fsfwParams.tcStore->deleteData(infoIter->storeId); infoIter++; } - dp.packetListRef.clear(); + destParams.packetListRef.clear(); } if (fsmRes.step != TransactionStep::IDLE) { @@ -56,19 +58,20 @@ const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() { } if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) { if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) { - for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) { + for (auto infoIter = destParams.packetListRef.begin(); + infoIter != destParams.packetListRef.end();) { if (infoIter->pduType == PduType::FILE_DATA) { result = handleFileDataPdu(*infoIter); checkAndHandleError(result, errorIdx); // Store data was deleted in PDU handler because a store guard is used - dp.packetListRef.erase(infoIter++); + destParams.packetListRef.erase(infoIter++); } else if (infoIter->pduType == PduType::FILE_DIRECTIVE and infoIter->directiveType == FileDirective::EOF_DIRECTIVE) { // TODO: Support for check timer missing result = handleEofPdu(*infoIter); checkAndHandleError(result, errorIdx); // Store data was deleted in PDU handler because a store guard is used - dp.packetListRef.erase(infoIter++); + destParams.packetListRef.erase(infoIter++); } else { infoIter++; } @@ -95,29 +98,29 @@ const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() { } ReturnValue_t cfdp::DestHandler::passPacket(PacketInfo packet) { - if (dp.packetListRef.full()) { + if (destParams.packetListRef.full()) { return FAILED; } - dp.packetListRef.push_back(packet); + destParams.packetListRef.push_back(packet); return OK; } ReturnValue_t cfdp::DestHandler::initialize() { - if (fp.tmStore == nullptr) { - fp.tmStore = ObjectManager::instance()->get(objects::TM_STORE); - if (fp.tmStore == nullptr) { + if (fsfwParams.tmStore == nullptr) { + fsfwParams.tmStore = ObjectManager::instance()->get(objects::TM_STORE); + if (fsfwParams.tmStore == nullptr) { return FAILED; } } - if (fp.tcStore == nullptr) { - fp.tcStore = ObjectManager::instance()->get(objects::TC_STORE); - if (fp.tcStore == nullptr) { + if (fsfwParams.tcStore == nullptr) { + fsfwParams.tcStore = ObjectManager::instance()->get(objects::TC_STORE); + if (fsfwParams.tcStore == nullptr) { return FAILED; } } - if (fp.msgQueue == nullptr) { + if (fsfwParams.msgQueue == nullptr) { return FAILED; } return OK; @@ -125,14 +128,14 @@ ReturnValue_t cfdp::DestHandler::initialize() { ReturnValue_t cfdp::DestHandler::handleMetadataPdu(const PacketInfo& info) { // Process metadata PDU - auto constAccessorPair = fp.tcStore->getData(info.storeId); + auto constAccessorPair = fsfwParams.tcStore->getData(info.storeId); if (constAccessorPair.first != OK) { // TODO: This is not a CFDP error. Event and/or warning? return constAccessorPair.first; } cfdp::StringLv sourceFileName; cfdp::StringLv destFileName; - MetadataInfo metadataInfo(tp.fileSize, sourceFileName, destFileName); + MetadataInfo metadataInfo(transactionParams.fileSize, sourceFileName, destFileName); cfdp::Tlv* tlvArrayAsPtr = tlvVec.data(); metadataInfo.setOptionsArray(&tlvArrayAsPtr, std::nullopt, tlvVec.size()); MetadataPduReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(), @@ -150,7 +153,7 @@ ReturnValue_t cfdp::DestHandler::handleMetadataPdu(const PacketInfo& info) { ReturnValue_t cfdp::DestHandler::handleFileDataPdu(const cfdp::PacketInfo& info) { // Process file data PDU - auto constAccessorPair = fp.tcStore->getData(info.storeId); + auto constAccessorPair = fsfwParams.tcStore->getData(info.storeId); if (constAccessorPair.first != OK) { // TODO: This is not a CFDP error. Event and/or warning? return constAccessorPair.first; @@ -164,46 +167,46 @@ ReturnValue_t cfdp::DestHandler::handleFileDataPdu(const cfdp::PacketInfo& info) } size_t fileSegmentLen = 0; const uint8_t* fileData = fdInfo.getFileData(&fileSegmentLen); - FileOpParams fileOpParams(tp.destName.data(), fileSegmentLen); + FileOpParams fileOpParams(transactionParams.destName.data(), fileSegmentLen); fileOpParams.offset = offset.value(); - if (dp.cfg.indicCfg.fileSegmentRecvIndicRequired) { + if (destParams.cfg.indicCfg.fileSegmentRecvIndicRequired) { FileSegmentRecvdParams segParams; segParams.offset = offset.value(); - segParams.id = tp.transactionId; + segParams.id = transactionParams.transactionId; segParams.length = fileSegmentLen; segParams.recContState = fdInfo.getRecordContinuationState(); size_t segmentMetadatLen = 0; auto* segMetadata = fdInfo.getSegmentMetadata(&segmentMetadatLen); segParams.segmentMetadata = {segMetadata, segmentMetadatLen}; - dp.user.fileSegmentRecvdIndication(segParams); + destParams.user.fileSegmentRecvdIndication(segParams); } - result = dp.user.vfs.writeToFile(fileOpParams, fileData); + result = destParams.user.vfs.writeToFile(fileOpParams, fileData); if (result != returnvalue::OK) { // TODO: Proper Error handling #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::error << "cfdp::DestHandler: VFS file write error with code 0x" << std::hex << std::setw(2) << result << std::endl; #endif - tp.vfsErrorCount++; - if (tp.vfsErrorCount < 3) { + transactionParams.vfsErrorCount++; + if (transactionParams.vfsErrorCount < 3) { // TODO: Provide execution step as parameter - fp.eventReporter->forwardEvent(events::FILESTORE_ERROR, static_cast(fsmRes.step), - result); + fsfwParams.eventReporter->forwardEvent(events::FILESTORE_ERROR, + static_cast(fsmRes.step), result); } return result; } else { - tp.deliveryStatus = FileDeliveryStatus::RETAINED_IN_FILESTORE; - tp.vfsErrorCount = 0; + transactionParams.deliveryStatus = FileDeliveryStatus::RETAINED_IN_FILESTORE; + transactionParams.vfsErrorCount = 0; } - if (offset.value() + fileSegmentLen > tp.progress) { - tp.progress = offset.value() + fileSegmentLen; + if (offset.value() + fileSegmentLen > transactionParams.progress) { + transactionParams.progress = offset.value() + fileSegmentLen; } return result; } ReturnValue_t cfdp::DestHandler::handleEofPdu(const cfdp::PacketInfo& info) { // Process EOF PDU - auto constAccessorPair = fp.tcStore->getData(info.storeId); + auto constAccessorPair = fsfwParams.tcStore->getData(info.storeId); if (constAccessorPair.first != OK) { // TODO: This is not a CFDP error. Event and/or warning? return constAccessorPair.first; @@ -216,16 +219,16 @@ ReturnValue_t cfdp::DestHandler::handleEofPdu(const cfdp::PacketInfo& info) { } // TODO: Error handling if (eofInfo.getConditionCode() == ConditionCode::NO_ERROR) { - tp.crc = eofInfo.getChecksum(); + transactionParams.crc = eofInfo.getChecksum(); uint64_t fileSizeFromEof = eofInfo.getFileSize().value(); // CFDP 4.6.1.2.9: Declare file size error if progress exceeds file size - if (fileSizeFromEof > tp.progress) { + if (fileSizeFromEof > transactionParams.progress) { // TODO: File size error } - tp.fileSize.setFileSize(fileSizeFromEof, std::nullopt); + transactionParams.fileSize.setFileSize(fileSizeFromEof, std::nullopt); } - if (dp.cfg.indicCfg.eofRecvIndicRequired) { - dp.user.eofRecvIndication(getTransactionId()); + if (destParams.cfg.indicCfg.eofRecvIndicRequired) { + destParams.user.eofRecvIndication(getTransactionId()); } if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) { if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) { @@ -260,7 +263,7 @@ ReturnValue_t cfdp::DestHandler::handleMetadataParseError(ReturnValue_t result, cfdp::EntityId destId; headerReader.getDestId(destId); RemoteEntityCfg* remoteCfg; - if (not dp.remoteCfgTable.getRemoteCfg(destId, &remoteCfg)) { + if (not destParams.remoteCfgTable.getRemoteCfg(destId, &remoteCfg)) { // TODO: No remote config for dest ID. I consider this a configuration error, which is not // covered by the standard. // Warning or error, yield or cache appropriate returnvalue @@ -283,42 +286,42 @@ ReturnValue_t cfdp::DestHandler::startTransaction(MetadataPduReader& reader, Met size_t sourceNameSize = 0; const uint8_t* sourceNamePtr = info.getSourceFileName().getValue(&sourceNameSize); - if (sourceNameSize + 1 > tp.sourceName.size()) { + if (sourceNameSize + 1 > transactionParams.sourceName.size()) { fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "source filename too large"); return FAILED; } - std::memcpy(tp.sourceName.data(), sourceNamePtr, sourceNameSize); - tp.sourceName[sourceNameSize] = '\0'; + std::memcpy(transactionParams.sourceName.data(), sourceNamePtr, sourceNameSize); + transactionParams.sourceName[sourceNameSize] = '\0'; size_t destNameSize = 0; const uint8_t* destNamePtr = info.getDestFileName().getValue(&destNameSize); - if (destNameSize + 1 > tp.destName.size()) { + if (destNameSize + 1 > transactionParams.destName.size()) { fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "dest filename too large"); return FAILED; } - std::memcpy(tp.destName.data(), destNamePtr, destNameSize); - tp.destName[destNameSize] = '\0'; + std::memcpy(transactionParams.destName.data(), destNamePtr, destNameSize); + transactionParams.destName[destNameSize] = '\0'; // If both dest name size and source name size are 0, we are dealing with a metadata only PDU, // so there is no need to create a file or truncate an existing file if (destNameSize > 0 and sourceNameSize > 0) { - FilesystemParams fparams(tp.destName.data()); + FilesystemParams fparams(transactionParams.destName.data()); // handling to allow only specifying target directory. Example: // Source path /test/hello.txt, dest path /tmp -> dest path /tmp/hello.txt - if (dp.user.vfs.isDirectory(tp.destName.data())) { + if (destParams.user.vfs.isDirectory(transactionParams.destName.data())) { result = tryBuildingAbsoluteDestName(destNameSize); if (result != OK) { return result; } } - if (dp.user.vfs.fileExists(fparams)) { - result = dp.user.vfs.truncateFile(fparams); + if (destParams.user.vfs.fileExists(fparams)) { + result = destParams.user.vfs.truncateFile(fparams); if (result != returnvalue::OK) { fileErrorHandler(events::FILESTORE_ERROR, result, "file truncation error"); return FAILED; // TODO: Relevant for filestore rejection error? } } else { - result = dp.user.vfs.createFile(fparams); + result = destParams.user.vfs.createFile(fparams); if (result != OK) { fileErrorHandler(events::FILESTORE_ERROR, result, "file creation error"); return FAILED; @@ -328,7 +331,7 @@ ReturnValue_t cfdp::DestHandler::startTransaction(MetadataPduReader& reader, Met } EntityId sourceId; reader.getSourceId(sourceId); - if (not dp.remoteCfgTable.getRemoteCfg(sourceId, &tp.remoteCfg)) { + if (not destParams.remoteCfgTable.getRemoteCfg(sourceId, &transactionParams.remoteCfg)) { // TODO: Warning, event etc. #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "cfdp::DestHandler" << __func__ @@ -343,20 +346,20 @@ ReturnValue_t cfdp::DestHandler::startTransaction(MetadataPduReader& reader, Met } else if (reader.getTransmissionMode() == TransmissionMode::ACKNOWLEDGED) { fsmRes.state = CfdpStates::BUSY_CLASS_2_ACKED; } - tp.checksumType = info.getChecksumType(); - tp.closureRequested = info.isClosureRequested(); - reader.fillConfig(tp.pduConf); - tp.pduConf.direction = Direction::TOWARDS_SENDER; - tp.transactionId.entityId = tp.pduConf.sourceId; - tp.transactionId.seqNum = tp.pduConf.seqNum; + transactionParams.checksumType = info.getChecksumType(); + transactionParams.closureRequested = info.isClosureRequested(); + reader.fillConfig(transactionParams.pduConf); + transactionParams.pduConf.direction = Direction::TOWARDS_SENDER; + transactionParams.transactionId.entityId = transactionParams.pduConf.sourceId; + transactionParams.transactionId.seqNum = transactionParams.pduConf.seqNum; fsmRes.step = TransactionStep::RECEIVING_FILE_DATA_PDUS; - MetadataRecvdParams params(tp.transactionId, tp.pduConf.sourceId); - params.fileSize = tp.fileSize.getSize(); - params.destFileName = tp.destName.data(); - params.sourceFileName = tp.sourceName.data(); + MetadataRecvdParams params(transactionParams.transactionId, transactionParams.pduConf.sourceId); + params.fileSize = transactionParams.fileSize.getSize(); + params.destFileName = transactionParams.destName.data(); + params.sourceFileName = transactionParams.sourceName.data(); params.msgsToUserArray = dynamic_cast(userTlvVec.data()); params.msgsToUserLen = info.getOptionsLen(); - dp.user.metadataRecvdIndication(params); + destParams.user.metadataRecvdIndication(params); return result; } @@ -364,19 +367,19 @@ cfdp::CfdpStates cfdp::DestHandler::getCfdpState() const { return fsmRes.state; ReturnValue_t cfdp::DestHandler::handleTransferCompletion() { ReturnValue_t result; - if (tp.checksumType != ChecksumType::NULL_CHECKSUM) { + if (transactionParams.checksumType != ChecksumType::NULL_CHECKSUM) { result = checksumVerification(); if (result != OK) { // TODO: Warning / error handling? } } else { - tp.conditionCode = ConditionCode::NO_ERROR; + transactionParams.conditionCode = ConditionCode::NO_ERROR; } result = noticeOfCompletion(); if (result != OK) { } if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) { - if (tp.closureRequested) { + if (transactionParams.closureRequested) { fsmRes.step = TransactionStep::SENDING_FINISHED_PDU; } else { finish(); @@ -388,39 +391,41 @@ ReturnValue_t cfdp::DestHandler::handleTransferCompletion() { } ReturnValue_t cfdp::DestHandler::tryBuildingAbsoluteDestName(size_t destNameSize) { - char baseNameBuf[tp.destName.size()]{}; - FilesystemParams fparamsSrc(tp.sourceName.data()); + // A path may only have a maximum of 256 characters in CFDP, so this buffer should be sufficient + // for all use-cases. + char baseNameBuf[512]{}; + FilesystemParams fparamsSrc(transactionParams.sourceName.data()); size_t baseNameLen = 0; - ReturnValue_t result = - dp.user.vfs.getBaseFilename(fparamsSrc, baseNameBuf, sizeof(baseNameBuf), baseNameLen); + ReturnValue_t result = destParams.user.vfs.getBaseFilename(fparamsSrc, baseNameBuf, + sizeof(baseNameBuf), baseNameLen); if (result != returnvalue::OK or baseNameLen == 0) { fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "error retrieving source base name"); return FAILED; } // Destination name + slash + base name + null termination - if (destNameSize + 1 + baseNameLen + 1 > tp.destName.size()) { + if (destNameSize + 1 + baseNameLen + 1 > transactionParams.destName.size()) { fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "dest filename too large after adding source base name"); return FAILED; } - tp.destName[destNameSize++] = '/'; - std::memcpy(tp.destName.data() + destNameSize, baseNameBuf, baseNameLen); + transactionParams.destName[destNameSize++] = '/'; + std::memcpy(transactionParams.destName.data() + destNameSize, baseNameBuf, baseNameLen); destNameSize += baseNameLen; - tp.destName[destNameSize++] = '\0'; + transactionParams.destName[destNameSize++] = '\0'; return OK; } void cfdp::DestHandler::fileErrorHandler(Event event, ReturnValue_t result, const char* info) { - fp.eventReporter->forwardEvent(events::FILENAME_TOO_LARGE_ERROR, - static_cast(fsmRes.step), result); + fsfwParams.eventReporter->forwardEvent(events::FILENAME_TOO_LARGE_ERROR, + static_cast(fsmRes.step), result); #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "cfdp::DestHandler: " << info << std::endl; #endif } void cfdp::DestHandler::finish() { - tp.reset(); - dp.packetListRef.clear(); + transactionParams.reset(); + destParams.packetListRef.clear(); fsmRes.state = CfdpStates::IDLE; fsmRes.step = TransactionStep::IDLE; } @@ -430,18 +435,18 @@ ReturnValue_t cfdp::DestHandler::checksumVerification() { // TODO: Checksum verification and notice of completion etl::crc32 crcCalc; uint64_t currentOffset = 0; - FileOpParams params(tp.destName.data(), tp.fileSize.value()); - while (currentOffset < tp.fileSize.value()) { + FileOpParams params(transactionParams.destName.data(), transactionParams.fileSize.value()); + while (currentOffset < transactionParams.fileSize.value()) { uint64_t readLen; - if (currentOffset + buf.size() > tp.fileSize.value()) { - readLen = tp.fileSize.value() - currentOffset; + if (currentOffset + buf.size() > transactionParams.fileSize.value()) { + readLen = transactionParams.fileSize.value() - currentOffset; } else { readLen = buf.size(); } if (readLen > 0) { params.offset = currentOffset; params.size = readLen; - auto result = dp.user.vfs.readFromFile(params, buf.data(), buf.size()); + auto result = destParams.user.vfs.readFromFile(params, buf.data(), buf.size()); if (result != OK) { // TODO: I think this is a case for a filestore rejection, but it might sense to print // a warning or trigger an event because this should generally not happen @@ -453,40 +458,42 @@ ReturnValue_t cfdp::DestHandler::checksumVerification() { } uint32_t value = crcCalc.value(); - if (value == tp.crc) { - tp.conditionCode = ConditionCode::NO_ERROR; - tp.deliveryCode = FileDeliveryCode::DATA_COMPLETE; + if (value == transactionParams.crc) { + transactionParams.conditionCode = ConditionCode::NO_ERROR; + transactionParams.deliveryCode = FileDeliveryCode::DATA_COMPLETE; } else { // TODO: Proper error handling #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "CRC check for file " << tp.destName.data() << " failed" << std::endl; #endif - tp.conditionCode = ConditionCode::FILE_CHECKSUM_FAILURE; + transactionParams.conditionCode = ConditionCode::FILE_CHECKSUM_FAILURE; } return OK; } ReturnValue_t cfdp::DestHandler::noticeOfCompletion() { - if (dp.cfg.indicCfg.transactionFinishedIndicRequired) { - TransactionFinishedParams params(tp.transactionId, tp.conditionCode, tp.deliveryCode, - tp.deliveryStatus); - dp.user.transactionFinishedIndication(params); + if (destParams.cfg.indicCfg.transactionFinishedIndicRequired) { + TransactionFinishedParams params( + transactionParams.transactionId, transactionParams.conditionCode, + transactionParams.deliveryCode, transactionParams.deliveryStatus); + destParams.user.transactionFinishedIndication(params); } return OK; } ReturnValue_t cfdp::DestHandler::sendFinishedPdu() { - FinishedInfo info(tp.conditionCode, tp.deliveryCode, tp.deliveryStatus); - FinishPduCreator finishedPdu(tp.pduConf, info); + FinishedInfo info(transactionParams.conditionCode, transactionParams.deliveryCode, + transactionParams.deliveryStatus); + FinishPduCreator finishedPdu(transactionParams.pduConf, info); store_address_t storeId; uint8_t* dataPtr = nullptr; ReturnValue_t result = - fp.tmStore->getFreeElement(&storeId, finishedPdu.getSerializedSize(), &dataPtr); + fsfwParams.tmStore->getFreeElement(&storeId, finishedPdu.getSerializedSize(), &dataPtr); if (result != OK) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "cfdp::DestHandler:sendFinishedPdu: Getting store slot failed" << std::endl; #endif - fp.eventReporter->forwardEvent(events::STORE_ERROR, result, 0); + fsfwParams.eventReporter->forwardEvent(events::STORE_ERROR, result, 0); return result; } size_t serLen = 0; @@ -496,16 +503,16 @@ ReturnValue_t cfdp::DestHandler::sendFinishedPdu() { sif::warning << "cfdp::DestHandler::sendFinishedPdu: Serializing Finished PDU failed" << std::endl; #endif - fp.eventReporter->forwardEvent(events::SERIALIZATION_ERROR, result, 0); + fsfwParams.eventReporter->forwardEvent(events::SERIALIZATION_ERROR, result, 0); return result; } TmTcMessage msg(storeId); - result = fp.msgQueue->sendMessage(fp.packetDest.getReportReceptionQueue(), &msg); + result = fsfwParams.msgQueue->sendMessage(fsfwParams.packetDest.getReportReceptionQueue(), &msg); if (result != OK) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "cfdp::DestHandler::sendFinishedPdu: Sending PDU failed" << std::endl; #endif - fp.eventReporter->forwardEvent(events::MSG_QUEUE_ERROR, result, 0); + fsfwParams.eventReporter->forwardEvent(events::MSG_QUEUE_ERROR, result, 0); return result; } fsmRes.packetsSent++; @@ -525,7 +532,9 @@ const cfdp::DestHandler::FsmResult& cfdp::DestHandler::updateFsmRes(uint8_t erro return fsmRes; } -const cfdp::TransactionId& cfdp::DestHandler::getTransactionId() const { return tp.transactionId; } +const cfdp::TransactionId& cfdp::DestHandler::getTransactionId() const { + return transactionParams.transactionId; +} void cfdp::DestHandler::checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx) { if (result != OK and errorIdx < 3) { @@ -534,13 +543,15 @@ void cfdp::DestHandler::checkAndHandleError(ReturnValue_t result, uint8_t& error } } -void cfdp::DestHandler::setMsgQueue(MessageQueueIF& queue) { fp.msgQueue = &queue; } +void cfdp::DestHandler::setMsgQueue(MessageQueueIF& queue) { fsfwParams.msgQueue = &queue; } void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) { - fp.eventReporter = &reporter; + fsfwParams.eventReporter = &reporter; } -const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const { return dp; } +const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const { + return destParams; +} -StorageManagerIF* cfdp::DestHandler::getTmStore() const { return fp.tmStore; } -StorageManagerIF* cfdp::DestHandler::getTcStore() const { return fp.tcStore; } +StorageManagerIF* cfdp::DestHandler::getTmStore() const { return fsfwParams.tmStore; } +StorageManagerIF* cfdp::DestHandler::getTcStore() const { return fsfwParams.tcStore; } diff --git a/src/fsfw/cfdp/handler/DestHandler.h b/src/fsfw/cfdp/handler/DestHandler.h index ba4e27f4..fb7cd880 100644 --- a/src/fsfw/cfdp/handler/DestHandler.h +++ b/src/fsfw/cfdp/handler/DestHandler.h @@ -20,23 +20,9 @@ namespace cfdp { -struct PacketInfo { - PacketInfo(PduType type, store_address_t storeId, - std::optional directive = std::nullopt) - : pduType(type), directiveType(directive), storeId(storeId) {} - - PduType pduType = PduType::FILE_DATA; - std::optional directiveType = FileDirective::INVALID_DIRECTIVE; - store_address_t storeId = store_address_t::invalid(); - PacketInfo() = default; -}; - template using LostSegmentsList = etl::set, SIZE>; -template -using PacketInfoList = etl::list; using LostSegmentsListBase = etl::iset>; -using PacketInfoListBase = etl::ilist; struct DestHandlerParams { DestHandlerParams(LocalEntityCfg cfg, UserBase& user, RemoteConfigTableIF& remoteCfgTable, @@ -63,15 +49,15 @@ struct DestHandlerParams { struct FsfwDestParams { FsfwDestParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue, - EventReportingProxyIF* eventReporter, StorageManagerIF& tcStore, - StorageManagerIF& tmStore) - : FsfwParams(packetDest, msgQueue, eventReporter) { + EventReportingProxyIF* eventReporter, StorageManagerIF& tcStore, + StorageManagerIF& tmStore) + : FsfwDestParams(packetDest, msgQueue, eventReporter) { this->tcStore = &tcStore; this->tmStore = &tmStore; } FsfwDestParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue, - EventReportingProxyIF* eventReporter) + EventReportingProxyIF* eventReporter) : packetDest(packetDest), msgQueue(msgQueue), eventReporter(eventReporter) {} AcceptsTelemetryIF& packetDest; MessageQueueIF* msgQueue; @@ -115,7 +101,7 @@ class DestHandler { */ ReturnValue_t PARTIAL_SUCCESS = returnvalue::makeCode(0, 2); ReturnValue_t FAILURE = returnvalue::makeCode(0, 3); - explicit DestHandler(DestHandlerParams handlerParams, FsfwParams fsfwParams); + explicit DestHandler(DestHandlerParams handlerParams, FsfwDestParams fsfwParams); /** * @@ -179,9 +165,9 @@ class DestHandler { std::vector tlvVec; std::vector userTlvVec; - DestHandlerParams dp; - FsfwParams fp; - TransactionParams tp; + DestHandlerParams destParams; + FsfwDestParams fsfwParams; + TransactionParams transactionParams; FsmResult fsmRes; ReturnValue_t startTransaction(MetadataPduReader& reader, MetadataInfo& info); diff --git a/src/fsfw/cfdp/handler/SourceHandler.cpp b/src/fsfw/cfdp/handler/SourceHandler.cpp index 37be1844..eb3722d1 100644 --- a/src/fsfw/cfdp/handler/SourceHandler.cpp +++ b/src/fsfw/cfdp/handler/SourceHandler.cpp @@ -1,3 +1,3 @@ #include "SourceHandler.h" -SourceHandler::SourceHandler(SourceHandlerParams params) {} +SourceHandler::SourceHandler(SourceHandlerParams params, FsfwSourceParams fsfwParams) {} diff --git a/src/fsfw/cfdp/handler/SourceHandler.h b/src/fsfw/cfdp/handler/SourceHandler.h index 1295f348..75f2f1e0 100644 --- a/src/fsfw/cfdp/handler/SourceHandler.h +++ b/src/fsfw/cfdp/handler/SourceHandler.h @@ -1,11 +1,24 @@ #ifndef FSFW_CFDP_CFDPSOURCEHANDLER_H #define FSFW_CFDP_CFDPSOURCEHANDLER_H +#include + +#include "fsfw/events/EventReportingProxyIF.h" +#include "fsfw/storagemanager/StorageManagerIF.h" + struct SourceHandlerParams {}; +struct FsfwSourceParams { + FsfwSourceParams(EventReportingProxyIF* eventReporter, StorageManagerIF& tcStore) + : tcStore(&tcStore){}; + + EventReportingProxyIF* eventReporter = nullptr; + StorageManagerIF* tcStore = nullptr; +}; + class SourceHandler { public: - SourceHandler(SourceHandlerParams params); + SourceHandler(SourceHandlerParams params, FsfwSourceParams fsfwParams); private: enum class TransactionStep : uint8_t { diff --git a/src/fsfw/cfdp/handler/defs.h b/src/fsfw/cfdp/handler/defs.h index 5f17ca2d..29fe360e 100644 --- a/src/fsfw/cfdp/handler/defs.h +++ b/src/fsfw/cfdp/handler/defs.h @@ -1,12 +1,29 @@ #ifndef FSFW_CFDP_HANDLER_DEFS_H #define FSFW_CFDP_HANDLER_DEFS_H +#include "fsfw/storagemanager/storeAddress.h" + namespace cfdp { enum class CfdpStates { IDLE, BUSY_CLASS_1_NACKED, BUSY_CLASS_2_ACKED, SUSPENDED }; static constexpr uint8_t SSID = SUBSYSTEM_ID::CFDP; +struct PacketInfo { + PacketInfo(PduType type, store_address_t storeId, + std::optional directive = std::nullopt) + : pduType(type), directiveType(directive), storeId(storeId) {} + + PduType pduType = PduType::FILE_DATA; + std::optional directiveType = FileDirective::INVALID_DIRECTIVE; + store_address_t storeId = store_address_t::invalid(); + PacketInfo() = default; +}; + +template +using PacketInfoList = etl::list; +using PacketInfoListBase = etl::ilist; + namespace events { static constexpr Event STORE_ERROR = event::makeEvent(SSID, 0, severity::LOW); diff --git a/unittests/cfdp/handler/testDestHandler.cpp b/unittests/cfdp/handler/testDestHandler.cpp index 0224a20b..a1fa5b8b 100644 --- a/unittests/cfdp/handler/testDestHandler.cpp +++ b/unittests/cfdp/handler/testDestHandler.cpp @@ -38,7 +38,7 @@ TEST_CASE("CFDP Dest Handler", "[cfdp]") { LocalPool::LocalPoolConfig storeCfg = {{10, 32}, {10, 64}, {10, 128}, {10, 1024}}; StorageManagerMock tcStore(2, storeCfg); StorageManagerMock tmStore(3, storeCfg); - FsfwParams fp(tmReceiver, &mqMock, &eventReporterMock); + FsfwDestParams fp(tmReceiver, &mqMock, &eventReporterMock); RemoteEntityCfg cfg(remoteId); remoteCfgTableMock.addRemoteConfig(cfg); fp.tcStore = &tcStore;