Merge pull request 'Bugfix for Space Packet Parser' (#673) from eive/fsfw:mueller/fixes-tmtc-server-sp-parser into development

Reviewed-on: fsfw/fsfw#673

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -161,7 +161,7 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 
   while (true) {
     ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
-                          receptionBuffer.capacity(), tcpConfig.tcpFlags);
+                          receptionBuffer.size(), tcpConfig.tcpFlags);
     if (retval == 0) {
       size_t availableReadData = ringBuffer.getAvailableReadData();
       if (availableReadData > lastRingBufferSize) {
@@ -335,31 +335,27 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
   }
   ringBuffer.readData(receptionBuffer.data(), readAmount, true);
   const uint8_t* bufPtr = receptionBuffer.data();
-  const uint8_t** bufPtrPtr = &bufPtr;
+  SpacePacketParser::FoundPacketInfo info;
-  size_t startIdx = 0;
+  if (spacePacketParser == nullptr) {
-  size_t foundSize = 0;
+    return returnvalue::FAILED;
-  size_t readLen = 0;
+  }
-  while (readLen < readAmount) {
+  spacePacketParser->reset();
-    if (spacePacketParser == nullptr) {
+  while (spacePacketParser->getAmountRead() < readAmount) {
-      return returnvalue::FAILED;
+    result = spacePacketParser->parseSpacePackets(&bufPtr, readAmount, info);
-    }
-    result =
-        spacePacketParser->parseSpacePackets(bufPtrPtr, readAmount, startIdx, foundSize, readLen);
     switch (result) {
       case (SpacePacketParser::NO_PACKET_FOUND):
       case (SpacePacketParser::SPLIT_PACKET): {
         break;
       }
       case (returnvalue::OK): {
-        result = handleTcReception(receptionBuffer.data() + startIdx, foundSize);
+        result = handleTcReception(receptionBuffer.data() + info.startIdx, info.sizeFound);
         if (result != returnvalue::OK) {
           status = result;
         }
       }
     }
-    ringBuffer.deleteData(foundSize);
+    ringBuffer.deleteData(info.sizeFound);
     lastRingBufferSize = ringBuffer.getAvailableReadData();
-    std::memset(receptionBuffer.data() + startIdx, 0, foundSize);
   }
   return status;
 }

src/fsfw/tmtcservices/SpacePacketParser.cpp

@@ -6,17 +6,9 @@
 SpacePacketParser::SpacePacketParser(std::vector<uint16_t> validPacketIds)
     : validPacketIds(validPacketIds) {}
 
-ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t* buffer, const size_t maxSize,
-                                                   size_t& startIndex, size_t& foundSize) {
-  const uint8_t** tempPtr = &buffer;
-  size_t readLen = 0;
-  return parseSpacePackets(tempPtr, maxSize, startIndex, foundSize, readLen);
-}
-
 ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t** buffer, const size_t maxSize,
-                                                   size_t& startIndex, size_t& foundSize,
+                                                   FoundPacketInfo& packetInfo) {
-                                                   size_t& readLen) {
+  if (buffer == nullptr or nextStartIdx > maxSize) {
-  if (buffer == nullptr or maxSize < 5) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "SpacePacketParser::parseSpacePackets: Frame invalid" << std::endl;
 #else
@@ -26,35 +18,32 @@ ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t** buffer, const
   }
   const uint8_t* bufPtr = *buffer;
 
-  auto verifyLengthField = [&](size_t idx) {
+  auto verifyLengthField = [&](size_t localIdx) {
-    uint16_t lengthField = bufPtr[idx + 4] << 8 | bufPtr[idx + 5];
+    uint16_t lengthField = (bufPtr[localIdx + 4] << 8) | bufPtr[localIdx + 5];
     size_t packetSize = lengthField + 7;
-    startIndex = idx;
     ReturnValue_t result = returnvalue::OK;
-    if (lengthField == 0) {
+    if (packetSize + localIdx + amountRead > maxSize) {
-      // Skip whole header for now
-      foundSize = 6;
-      result = NO_PACKET_FOUND;
-    } else if (packetSize + idx > maxSize) {
       // Don't increment buffer and read length here, user has to decide what to do
-      foundSize = packetSize;
+      packetInfo.sizeFound = packetSize;
       return SPLIT_PACKET;
     } else {
-      foundSize = packetSize;
+      packetInfo.sizeFound = packetSize;
     }
-    *buffer += foundSize;
+    *buffer += packetInfo.sizeFound;
-    readLen += idx + foundSize;
+    packetInfo.startIdx = localIdx + amountRead;
+    nextStartIdx = localIdx + amountRead + packetInfo.sizeFound;
+    amountRead = nextStartIdx;
     return result;
   };
 
   size_t idx = 0;
   // Space packet ID as start marker
   if (validPacketIds.size() > 0) {
-    while (idx < maxSize - 5) {
+    while (idx + amountRead < maxSize - 5) {
-      uint16_t currentPacketId = bufPtr[idx] << 8 | bufPtr[idx + 1];
+      uint16_t currentPacketId = (bufPtr[idx] << 8) | bufPtr[idx + 1];
       if (std::find(validPacketIds.begin(), validPacketIds.end(), currentPacketId) !=
           validPacketIds.end()) {
-        if (idx + 5 >= maxSize) {
+        if (idx + amountRead >= maxSize - 5) {
           return SPLIT_PACKET;
         }
         return verifyLengthField(idx);
@@ -62,10 +51,10 @@ ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t** buffer, const
         idx++;
       }
     }
-    startIndex = 0;
+    nextStartIdx = maxSize;
-    foundSize = maxSize;
+    packetInfo.sizeFound = maxSize;
-    *buffer += foundSize;
+    amountRead = maxSize;
-    readLen += foundSize;
+    *buffer += maxSize;
     return NO_PACKET_FOUND;
   }
   // Assume that the user verified a valid start of a space packet

src/fsfw/tmtcservices/SpacePacketParser.h

@@ -17,9 +17,11 @@
  */
 class SpacePacketParser {
  public:
-  //! The first entry is the index inside the buffer while the second index
+
-  //! is the size of the PUS packet starting at that index.
+  struct FoundPacketInfo {
-  using IndexSizePair = std::pair<size_t, size_t>;
+    size_t startIdx = 0;
+    size_t sizeFound = 0;
+  };
 
   static constexpr uint8_t INTERFACE_ID = CLASS_ID::SPACE_PACKET_PARSER;
   static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
@@ -36,44 +38,32 @@ class SpacePacketParser {
   SpacePacketParser(std::vector<uint16_t> validPacketIds);
 
   /**
-   * Parse a given frame for space packets but also increment the given buffer and assign the
+   * Parse a given frame for space packets but also increments the given buffer.
-   * total number of bytes read so far
    * @param buffer        Parser will look for space packets in this buffer
    * @param maxSize       Maximum size of the buffer
-   * @param startIndex    Start index of a found space packet
+   * @param packetInfo    Information about packets found.
-   * @param foundSize     Found size of the space packet
+   *  -@c NO_PACKET_FOUND if no packet was found in the given buffer
-   * @param readLen       Length read so far. This value is incremented by the number of parsed
+   *  -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. packetInfo
-   *                      bytes which also includes the size of a found packet
+   *      will contain the detected packet size and start index.
-   *  -@c NO_PACKET_FOUND if no packet was found in the given buffer or the length field is
+   *  -@c returnvalue::OK if a packet was found. Packet size and start index will be set in
-   *      invalid. foundSize will be set to the size of the space packet header. buffer and
+   *      packetInfo
-   *      readLen will be incremented accordingly.
-   *  -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. foundSize
-   *      will be set to the detected packet size and startIndex will be set to the start of the
-   *      detected packet. buffer and read length will not be incremented but the found length
-   *      will be assigned.
-   *  -@c returnvalue::OK if a packet was found
    */
-  ReturnValue_t parseSpacePackets(const uint8_t** buffer, const size_t maxSize, size_t& startIndex,
+  ReturnValue_t parseSpacePackets(const uint8_t** buffer, const size_t maxSize,
-                                  size_t& foundSize, size_t& readLen);
+                                  FoundPacketInfo& packetInfo);
 
-  /**
+  size_t getAmountRead() {
-   * Parse a given frame for space packets
+    return amountRead;
-   * @param buffer        Parser will look for space packets in this buffer
+  }
-   * @param maxSize       Maximum size of the buffer
+
-   * @param startIndex    Start index of a found space packet
+  void reset() {
-   * @param foundSize     Found size of the space packet
+    nextStartIdx = 0;
-   *  -@c NO_PACKET_FOUND if no packet was found in the given buffer or the length field is
+    amountRead = 0;
-   *      invalid. foundSize will be set to the size of the space packet header
+  }
-   *  -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. foundSize
-   *      will be set to the detected packet size and startIndex will be set to the start of the
-   *      detected packet
-   *  -@c returnvalue::OK if a packet was found
-   */
-  ReturnValue_t parseSpacePackets(const uint8_t* buffer, const size_t maxSize, size_t& startIndex,
-                                  size_t& foundSize);
 
  private:
   std::vector<uint16_t> validPacketIds;
+  size_t nextStartIdx = 0;
+  size_t amountRead = 0;
 };
 
 #endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */