Robin Mueller
09299802f0
This refactoring keeps the TCP connection opened until the client closes it. It also increased the robustness of the TCP reception. Because TCP is stream based and usually applied to newline separated data, a special way to handle binary space packets is required. The new SpacePacketParser class takes care of this by taking TC packet IDs as as optional start markers to parse for space packets in a given buffer. The refactored TCP server uses a ring buffer, a reception buffer and the new parser to extract space packets from a stream in a safer way.
97 lines
3.6 KiB
C++
97 lines
3.6 KiB
C++
#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
|
|
#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
|
|
|
|
#include "fsfw/container/DynamicFIFO.h"
|
|
#include "fsfw/returnvalues/FwClassIds.h"
|
|
|
|
#include <utility>
|
|
#include <cstdint>
|
|
|
|
/**
|
|
* @brief This small helper class scans a given buffer for PUS packets.
|
|
* Can be used if PUS packets are serialized in a tightly packed frame.
|
|
* @details
|
|
* The parser uses the length field field of the space packets to find
|
|
* the respective space packet sizes.
|
|
*
|
|
* The parser parses a buffer by taking a pointer and the maximum size to scan.
|
|
* If space packets are found, they are stored in a FIFO which stores pairs
|
|
* consisting of the index in the buffer and the respective packet sizes.
|
|
*
|
|
* If the parser detects split packets (which means that the size of the
|
|
* next packet is larger than the remaining size to scan), it can either
|
|
* store that split packet or throw away the packet.
|
|
* @author R. Mueller
|
|
*/
|
|
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.
|
|
using IndexSizePair = std::pair<size_t, size_t>;
|
|
|
|
static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
|
|
static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
|
|
static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
|
|
|
|
/**
|
|
* @brief Parser constructor.
|
|
* @param maxExpectedPusPackets
|
|
* Maximum expected number of PUS packets. A good estimate is to divide
|
|
* the frame size by the minimum size of a PUS packet (12 bytes)
|
|
* @param storeSplitPackets
|
|
* Specifies whether split packets are also stored inside the FIFO,
|
|
* with the size being the remaining frame size.
|
|
*/
|
|
SpacePacketParser(std::vector<uint16_t> validPacketIds);
|
|
|
|
/**
|
|
* Parse a given frame for PUS packets
|
|
* @param frame
|
|
* @param frameSize
|
|
* @param foundPackets The number of found packets will be stored here
|
|
* @return
|
|
* -@c NO_PACKET_FOUND if no packet was found
|
|
* -@c SPLIT_PACKET if splitting is enabled and a split packet was found
|
|
* -@c RETURN_OK if a packet was found. The index and sizes are stored in the internal FIFO
|
|
*/
|
|
ReturnValue_t parseSpacePackets(const uint8_t* buffer, const size_t maxSize,
|
|
size_t& startIndex, size_t& foundSize);
|
|
|
|
ReturnValue_t parseSpacePackets(const uint8_t **buffer, const size_t maxSize,
|
|
size_t& startIndex, size_t& foundSize, size_t& readLen);
|
|
/**
|
|
* Accessor function to get a reference to the internal FIFO which
|
|
* stores pairs of index and packet sizes. This FIFO is filled
|
|
* by the #parsePusPackets function.
|
|
* @return
|
|
*/
|
|
//DynamicFIFO<IndexSizePair>& fifo();
|
|
|
|
/**
|
|
* Retrieve the next index and packet size pair from the FIFO.
|
|
* This also removes it from the FIFO. Please note that if the FIFO
|
|
* is empty, an empty pair will be returned.
|
|
* @return
|
|
*/
|
|
//IndexSizePair getNextFifoPair();
|
|
|
|
private:
|
|
/**
|
|
* A FIFO is used to store information about multiple PUS packets
|
|
* inside the receive buffer. The maximum number of entries is defined
|
|
* by the first constructor argument.
|
|
*/
|
|
//DynamicFIFO<IndexSizePair> indexSizePairFIFO;
|
|
|
|
std::vector<uint16_t> validPacketIds;
|
|
|
|
//bool storeSplitPackets = false;
|
|
|
|
// ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
|
|
// size_t startIndex, uint32_t& foundPackets);
|
|
// ReturnValue_t readNextPacket(const uint8_t *frame,
|
|
// size_t frameSize, size_t& startIndex, uint32_t& foundPackets);
|
|
};
|
|
|
|
#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */
|