CMakeLists.txt

@@ -39,7 +39,7 @@ elseif(${CMAKE_CXX_STANDARD} LESS 11)
 endif()
 
 # Backwards comptability
-if(OS_FSFW)
+if(OS_FSFW AND NOT FSFW_OSAL)
     message(WARNING "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
     set(FSFW_OSAL OS_FSFW)
 endif()
@@ -63,35 +63,28 @@ endif()
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
 if(FSFW_OSAL MATCHES host)
-	set(OS_FSFW_NAME "Host")
+    set(OS_FSFW_NAME "Host")
+    set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-	set(OS_FSFW_NAME "Linux")
+    set(OS_FSFW_NAME "Linux")
-	set(FSFW_OSAL_DEFINITION FSFW_OSAL_LINUX)
+    set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-	set(OS_FSFW_NAME "FreeRTOS")
+    set(OS_FSFW_NAME "FreeRTOS")
-	set(FSFW_OSAL_DEFINITION FSFW_OSAL_FREERTOS)
+    set(FSFW_OSAL_FREERTOS ON)
-	target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
         ${LIB_OS_NAME}
-	)
+    )
 elseif(FSFW_OSAL STREQUAL rtems)
-	set(OS_FSFW_NAME "RTEMS")
+    set(OS_FSFW_NAME "RTEMS")
-    set(FSFW_OSAL_DEFINITION FSFW_OSAL_RTEMS)
+    set(FSFW_OSAL_RTEMS ON)
 else()
-	message(WARNING 
+    message(WARNING
-		"Invalid operating system for FSFW specified! Setting to host.."
+        "Invalid operating system for FSFW specified! Setting to host.."
-	)
+    )
-	set(OS_FSFW_NAME "Host")
+    set(OS_FSFW_NAME "Host")
-	set(OS_FSFW "host")
+    set(OS_FSFW "host")
 endif()
 
-target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_OSAL_DEFINITION}
-)
-
-target_compile_definitions(${LIB_FSFW_NAME} INTERFACE
-    ${FSFW_OSAL_DEFINITION}
-)
-
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 add_subdirectory(src)

src/fsfw/FSFW.h.in

@@ -3,6 +3,11 @@
 
 #include "FSFWConfig.h"
 
+#cmakedefine FSFW_OSAL_RTEMS
+#cmakedefine FSFW_OSAL_FREERTOS
+#cmakedefine FSFW_OSAL_LINUX
+#cmakedefine FSFW_OSAL_HOST
+
 #cmakedefine FSFW_ADD_RMAP
 #cmakedefine FSFW_ADD_DATALINKLAYER
 #cmakedefine FSFW_ADD_TMSTORAGE

src/fsfw/FSFWVersion.h

@@ -4,7 +4,7 @@
 const char* const FSFW_VERSION_NAME = "ASTP";
 
 #define FSFW_VERSION        1
-#define	FSFW_SUBVERSION     3
+#define FSFW_SUBVERSION     2
-#define	FSFW_REVISION       0
+#define FSFW_REVISION       0
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/action/ActionHelper.cpp

@@ -32,6 +32,17 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
         setQueueToUse(queueToUse_);
     }
 
+    if(queueToUse == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::initialize: No queue set" << std::endl;
+#else
+        sif::printWarning("ActionHelper::initialize: No queue set\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
     return HasReturnvaluesIF::RETURN_OK;
 }
 

src/fsfw/globalfunctions/DleEncoder.cpp

@@ -1,124 +1,296 @@
 #include "fsfw/globalfunctions/DleEncoder.h"
 
-DleEncoder::DleEncoder() {}
+DleEncoder::DleEncoder(bool escapeStxEtx, bool escapeCr):
+        escapeStxEtx(escapeStxEtx), escapeCr(escapeCr) {}
 
 DleEncoder::~DleEncoder() {}
 
 ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+        size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
-		size_t* encodedLen, bool addStxEtx) {
+        size_t* encodedLen, bool addStxEtx) {
-	if (maxDestLen < 2) {
+    if(escapeStxEtx) {
-		return STREAM_TOO_SHORT;
+        return encodeStreamEscaped(sourceStream, sourceLen,
-	}
+                destStream, maxDestLen, encodedLen, addStxEtx);
-	size_t encodedIndex = 0, sourceIndex = 0;
+    }
-	uint8_t nextByte;
+    else {
-	if (addStxEtx) {
+        return encodeStreamNonEscaped(sourceStream, sourceLen,
-		destStream[0] = STX_CHAR;
+                destStream, maxDestLen, encodedLen, addStxEtx);
-		++encodedIndex;
+    }
-	}
 
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+}
-	{
-		nextByte = sourceStream[sourceIndex];
-		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				/* Escaped byte will be actual byte + 0x40. This prevents
-				 * STX, ETX, and carriage return characters from appearing
-				 * in the encoded data stream at all, so when polling an
-				 * encoded stream, the transmission can be stopped at ETX.
-				 * 0x40 was chosen at random with special requirements:
-				 *  - Prevent going from one control char to another
-				 *  - Prevent overflow for common characters */
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
-		}
-		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE_CHAR) {
-			if (encodedIndex + 1 >= maxDestLen) {
-			    return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE_CHAR;
-			}
-		}
-		else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
 
-	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
+ReturnValue_t DleEncoder::encodeStreamEscaped(const uint8_t *sourceStream, size_t sourceLen,
-		if (addStxEtx) {
+        uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
-			destStream[encodedIndex] = ETX_CHAR;
+        bool addStxEtx) {
-			++encodedIndex;
+    size_t encodedIndex = 0;
-		}
+    size_t sourceIndex = 0;
-		*encodedLen = encodedIndex;
+    uint8_t nextByte = 0;
-		return RETURN_OK;
+    if(addStxEtx) {
-	}
+        if(maxDestLen < 1) {
-	else {
+            return STREAM_TOO_SHORT;
-		return STREAM_TOO_SHORT;
+        }
-	}
+        destStream[encodedIndex++] = STX_CHAR;
+    }
+    while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
+        nextByte = sourceStream[sourceIndex];
+        // STX, ETX and CR characters in the stream need to be escaped with DLE
+        if ((nextByte == STX_CHAR or nextByte == ETX_CHAR) or
+                (this->escapeCr and nextByte == CARRIAGE_RETURN)) {
+            if (encodedIndex + 1 >= maxDestLen) {
+                return STREAM_TOO_SHORT;
+            }
+            else {
+                destStream[encodedIndex] = DLE_CHAR;
+                ++encodedIndex;
+                /* Escaped byte will be actual byte + 0x40. This prevents
+                 * STX, ETX, and carriage return characters from appearing
+                 * in the encoded data stream at all, so when polling an
+                 * encoded stream, the transmission can be stopped at ETX.
+                 * 0x40 was chosen at random with special requirements:
+                 *  - Prevent going from one control char to another
+                 *  - Prevent overflow for common characters */
+                destStream[encodedIndex] = nextByte + 0x40;
+            }
+        }
+        // DLE characters are simply escaped with DLE.
+        else if (nextByte == DLE_CHAR) {
+            if (encodedIndex + 1 >= maxDestLen) {
+                return STREAM_TOO_SHORT;
+            }
+            else {
+                destStream[encodedIndex] = DLE_CHAR;
+                ++encodedIndex;
+                destStream[encodedIndex] = DLE_CHAR;
+            }
+        }
+        else {
+            destStream[encodedIndex] = nextByte;
+        }
+        ++encodedIndex;
+        ++sourceIndex;
+    }
+
+    if (sourceIndex == sourceLen) {
+        if (addStxEtx) {
+            if(encodedIndex + 1 >= maxDestLen) {
+                return STREAM_TOO_SHORT;
+            }
+            destStream[encodedIndex] = ETX_CHAR;
+            ++encodedIndex;
+        }
+        *encodedLen = encodedIndex;
+        return RETURN_OK;
+    }
+    else {
+        return STREAM_TOO_SHORT;
+    }
+}
+
+ReturnValue_t DleEncoder::encodeStreamNonEscaped(const uint8_t *sourceStream, size_t sourceLen,
+        uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+        bool addStxEtx) {
+    size_t encodedIndex = 0;
+    size_t sourceIndex = 0;
+    uint8_t nextByte = 0;
+    if(addStxEtx) {
+        if(maxDestLen < 2) {
+            return STREAM_TOO_SHORT;
+        }
+        destStream[encodedIndex++] = DLE_CHAR;
+        destStream[encodedIndex++] = STX_CHAR;
+    }
+    while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
+        nextByte = sourceStream[sourceIndex];
+        // DLE characters are simply escaped with DLE.
+        if (nextByte == DLE_CHAR) {
+            if (encodedIndex + 1 >= maxDestLen) {
+                return STREAM_TOO_SHORT;
+            }
+            else {
+                destStream[encodedIndex] = DLE_CHAR;
+                ++encodedIndex;
+                destStream[encodedIndex] = DLE_CHAR;
+            }
+        }
+        else {
+            destStream[encodedIndex] = nextByte;
+        }
+        ++encodedIndex;
+        ++sourceIndex;
+    }
+
+    if (sourceIndex == sourceLen) {
+        if (addStxEtx) {
+            if(encodedIndex + 2 >= maxDestLen) {
+                return STREAM_TOO_SHORT;
+            }
+            destStream[encodedIndex++] = DLE_CHAR;
+            destStream[encodedIndex++] = ETX_CHAR;
+        }
+        *encodedLen = encodedIndex;
+        return RETURN_OK;
+    }
+    else {
+        return STREAM_TOO_SHORT;
+    }
 }
 
 ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+        size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-		size_t maxDestStreamlen, size_t *decodedLen) {
+        size_t maxDestStreamlen, size_t *decodedLen) {
-	size_t encodedIndex = 0, decodedIndex = 0;
+    if(escapeStxEtx) {
-	uint8_t nextByte;
+        return decodeStreamEscaped(sourceStream, sourceStreamLen,
-	if (*sourceStream != STX_CHAR) {
+                readLen, destStream, maxDestStreamlen, decodedLen);
-		return DECODING_ERROR;
+    }
-	}
+    else {
-	++encodedIndex;
+        return decodeStreamNonEscaped(sourceStream, sourceStreamLen,
-
+                readLen, destStream, maxDestStreamlen, decodedLen);
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+    }
-			&& (sourceStream[encodedIndex] != ETX_CHAR)
-			&& (sourceStream[encodedIndex] != STX_CHAR)) {
-		if (sourceStream[encodedIndex] == DLE_CHAR) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// The next byte is a DLE character that was escaped by another
-			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE_CHAR) {
-				destStream[decodedIndex] = nextByte;
-			}
-			else {
-			    /* The next byte is a STX, DTX or 0x0D character which
-			     * was escaped by a DLE character. The actual byte was
-				 * also encoded by adding + 0x40 to prevent having control chars,
-				 * in the stream at all, so we convert it back. */
-				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				}
-				else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX_CHAR) {
-		*readLen = ++encodedIndex;
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
 }
 
+ReturnValue_t DleEncoder::decodeStreamEscaped(const uint8_t *sourceStream, size_t sourceStreamLen,
+        size_t *readLen, uint8_t *destStream,
+        size_t maxDestStreamlen, size_t *decodedLen) {
+    size_t encodedIndex = 0;
+    size_t decodedIndex = 0;
+    uint8_t nextByte;
+
+    //init to 0 so that we can just return in the first checks (which do not consume anything from
+    //the source stream)
+    *readLen = 0;
+
+    if(maxDestStreamlen < 1) {
+        return STREAM_TOO_SHORT;
+    }
+    if (sourceStream[encodedIndex++] != STX_CHAR) {
+        return DECODING_ERROR;
+    }
+    while ((encodedIndex < sourceStreamLen)
+            and (decodedIndex < maxDestStreamlen)
+            and (sourceStream[encodedIndex] != ETX_CHAR)
+            and (sourceStream[encodedIndex] != STX_CHAR)) {
+        if (sourceStream[encodedIndex] == DLE_CHAR) {
+            if(encodedIndex + 1 >= sourceStreamLen) {
+                //reached the end of the sourceStream
+                *readLen = sourceStreamLen;
+                return DECODING_ERROR;
+            }
+            nextByte = sourceStream[encodedIndex + 1];
+            // The next byte is a DLE character that was escaped by another
+            // DLE character, so we can write it to the destination stream.
+            if (nextByte == DLE_CHAR) {
+                destStream[decodedIndex] = nextByte;
+            }
+            else {
+                /* The next byte is a STX, DTX or 0x0D character which
+                 * was escaped by a DLE character. The actual byte was
+                 * also encoded by adding + 0x40 to prevent having control chars,
+                 * in the stream at all, so we convert it back. */
+                if ((nextByte == STX_CHAR + 0x40 or nextByte == ETX_CHAR + 0x40) or
+                        (this->escapeCr and nextByte == CARRIAGE_RETURN + 0x40)) {
+                    destStream[decodedIndex] = nextByte - 0x40;
+                }
+                else {
+                    // Set readLen so user can resume parsing after incorrect data
+                    *readLen = encodedIndex + 2;
+                    return DECODING_ERROR;
+                }
+            }
+            ++encodedIndex;
+        }
+        else {
+            destStream[decodedIndex] = sourceStream[encodedIndex];
+        }
+
+        ++encodedIndex;
+        ++decodedIndex;
+    }
+    if (sourceStream[encodedIndex] != ETX_CHAR) {
+        if(decodedIndex == maxDestStreamlen) {
+            //so far we did not find anything wrong here, so let user try again
+            *readLen = 0;
+            return STREAM_TOO_SHORT;
+        }
+        else {
+            *readLen = ++encodedIndex;
+            return DECODING_ERROR;
+        }
+    }
+    else {
+        *readLen = ++encodedIndex;
+        *decodedLen = decodedIndex;
+        return RETURN_OK;
+    }
+}
+
+ReturnValue_t DleEncoder::decodeStreamNonEscaped(const uint8_t *sourceStream,
+        size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+        size_t maxDestStreamlen, size_t *decodedLen) {
+    size_t encodedIndex = 0;
+    size_t decodedIndex = 0;
+    uint8_t nextByte;
+
+    //init to 0 so that we can just return in the first checks (which do not consume anything from
+    //the source stream)
+    *readLen = 0;
+    
+    if(maxDestStreamlen < 2) {
+        return STREAM_TOO_SHORT;
+    }
+    if (sourceStream[encodedIndex++] != DLE_CHAR) {
+        return DECODING_ERROR;
+    }
+    if (sourceStream[encodedIndex++] != STX_CHAR) {
+        *readLen = 1;
+        return DECODING_ERROR;
+    }
+    while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)) {
+        if (sourceStream[encodedIndex] == DLE_CHAR) {
+            if(encodedIndex + 1 >= sourceStreamLen) {
+                *readLen = encodedIndex;
+                return DECODING_ERROR;
+            }
+            nextByte = sourceStream[encodedIndex + 1];
+            if(nextByte == STX_CHAR) {
+                // Set readLen so the DLE/STX char combination is preserved. Could be start of
+                // another frame
+                *readLen = encodedIndex;
+                return DECODING_ERROR;
+            }
+            else if(nextByte == DLE_CHAR) {
+                // The next byte is a DLE character that was escaped by another
+                // DLE character, so we can write it to the destination stream.
+                destStream[decodedIndex] = nextByte;
+                ++encodedIndex;
+            }
+            else if(nextByte == ETX_CHAR) {
+                // End of stream reached
+                *readLen = encodedIndex + 2;
+                *decodedLen = decodedIndex;
+                return RETURN_OK;
+            }
+            else {
+                *readLen = encodedIndex;
+                return DECODING_ERROR;
+            }
+        }
+        else {
+            destStream[decodedIndex] = sourceStream[encodedIndex];
+        }
+        ++encodedIndex;
+        ++decodedIndex;
+    }
+
+    if(decodedIndex == maxDestStreamlen) {
+        //so far we did not find anything wrong here, so let user try again
+        *readLen = 0;
+        return STREAM_TOO_SHORT;
+    } else {
+        *readLen = encodedIndex;
+        return DECODING_ERROR;
+    }
+}
+
+void DleEncoder::setEscapeMode(bool escapeStxEtx) {
+    this->escapeStxEtx = escapeStxEtx;
+}

src/fsfw/globalfunctions/DleEncoder.h

@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 #define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
 /**
@@ -12,52 +12,69 @@
  * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
  *
  * This encoder can be used to achieve a basic transport layer when using
- * char based transmission systems.
+ * char based transmission systems. There are two implemented variants:
- * The passed source strean is converted into a encoded stream by adding
- * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
- * escaped by a DLE character. The encoder also replaces escaped control chars
- * by another char, so STX, ETX and CR should not appear anywhere in the actual
- * encoded data stream.
  *
- * When using a strictly char based reception of packets encoded with DLE,
+ * 1. Escaped variant
+ *
+ * The encoded stream starts with a STX marker and ends with an ETX marker.
+ * STX and ETX occurrences in the stream are escaped and internally encoded as well so the
+ * receiver side can simply check for STX and ETX markers as frame delimiters. When using a
+ * strictly char based reception of packets encoded with DLE,
  * STX can be used to notify a reader that actual data will start to arrive
  * while ETX can be used to notify the reader that the data has ended.
+ *
+ * 2. Non-escaped variant
+ *
+ * The encoded stream starts with DLE STX and ends with DLE ETX. All DLE occurrences in the stream
+ * are escaped with DLE. If the receiver detects a DLE char, it needs to read the next char
+ * to determine whether a start (STX) or end (ETX) of a frame has been detected.
  */
 class DleEncoder: public HasReturnvaluesIF {
-private:
-	DleEncoder();
-	virtual ~DleEncoder();
-
 public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
+    /**
-	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
+     * Create an encoder instance with the given configuration.
-	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
+     * @param escapeStxEtx  Determines whether the algorithm works in escaped or non-escaped mode
+     * @param escapeCr      In escaped mode, escape all CR occurrences as well
+     */
+    DleEncoder(bool escapeStxEtx = true, bool escapeCr = false);
 
-	//! Start Of Text character. First character is encoded stream
+    void setEscapeMode(bool escapeStxEtx);
-	static constexpr uint8_t STX_CHAR = 0x02;
+
-	//! End Of Text character. Last character in encoded stream
+    virtual ~DleEncoder();
-	static constexpr uint8_t ETX_CHAR = 0x03;
+
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
-	//! in the source stream.
+    static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
-	static constexpr uint8_t DLE_CHAR = 0x10;
+    static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
-	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
+
+    //! Start Of Text character. First character is encoded stream
+    static constexpr uint8_t STX_CHAR = 0x02;
+    //! End Of Text character. Last character in encoded stream
+    static constexpr uint8_t ETX_CHAR = 0x03;
+    //! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
+    //! in the source stream.
+    static constexpr uint8_t DLE_CHAR = 0x10;
+    static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
 
     /**
      * Encodes the give data stream by preceding it with the STX marker
-     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * and ending it with an ETX marker. DLE characters inside
-     * the stream are escaped by DLE characters and also replaced by adding
+     * the stream are escaped by DLE characters. STX, ETX and CR characters can be escaped with a
-     * 0x40 (which is reverted in the decoding process).
+     * DLE character as well. The escaped characters are also encoded by adding
+     * 0x40 (which is reverted in the decoding process). This is performed so the source stream
+     * does not have STX/ETX/CR occurrences anymore, so the receiving side can simply parse for
+     * start and end markers
      * @param sourceStream
      * @param sourceLen
      * @param destStream
      * @param maxDestLen
      * @param encodedLen
-     * @param addStxEtx
+     * @param addStxEtx     Adding STX start marker and ETX end marker can be omitted,
-     * Adding STX and ETX can be omitted, if they are added manually.
+     *                      if they are added manually
      * @return
+     *  - RETURN_OK for successful encoding operation
+     *  - STREAM_TOO_SHORT if the destination stream is too short
      */
-    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+    ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
             uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
             bool addStxEtx = true);
 
@@ -70,10 +87,32 @@ public:
      * @param maxDestStreamlen
      * @param decodedLen
      * @return
+     *  - RETURN_OK for successful decode operation
+     *  - DECODE_ERROR if the source stream is invalid
+     *  - STREAM_TOO_SHORT if the destination stream is too short
      */
-	static ReturnValue_t decode(const uint8_t *sourceStream,
+    ReturnValue_t decode(const uint8_t *sourceStream,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+            size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
+            size_t maxDestStreamlen, size_t *decodedLen);
+
+private:
+
+    ReturnValue_t encodeStreamEscaped(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
+
+    ReturnValue_t encodeStreamNonEscaped(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
+
+    ReturnValue_t decodeStreamEscaped(const uint8_t *sourceStream, size_t sourceStreamLen,
+            size_t *readLen, uint8_t *destStream, size_t maxDestStreamlen, size_t *decodedLen);
+
+    ReturnValue_t decodeStreamNonEscaped(const uint8_t *sourceStream, size_t sourceStreamLen,
+            size_t *readLen, uint8_t *destStream, size_t maxDestStreamlen, size_t *decodedLen);
+
+    bool escapeStxEtx;
+    bool escapeCr;
 };
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -20,6 +20,10 @@
 #include <netdb.h>
 #endif
 
+#ifndef FSFW_TCP_RECV_WIRETAPPING_ENABLED
+#define FSFW_TCP_RECV_WIRETAPPING_ENABLED 0
+#endif
+
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,

tests/src/fsfw_tests/unit/CatchFactory.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_CATCHFACTORY_H_
 #define FSFW_CATCHFACTORY_H_
 
-#include "TestConfig.h"
+#include "TestsConfig.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 

tests/src/fsfw_tests/unit/globalfunctions/CMakeLists.txt

@@ -1,2 +1,3 @@
 target_sources(${TARGET_NAME} PRIVATE
+    testDleEncoder.cpp
 )

tests/src/fsfw_tests/unit/globalfunctions/testDleEncoder.cpp

@@ -0,0 +1,222 @@
+#include "fsfw/globalfunctions/DleEncoder.h"
+#include "fsfw_tests/unit/CatchDefinitions.h"
+#include "catch2/catch_test_macros.hpp"
+
+#include <array>
+
+const std::vector<uint8_t> TEST_ARRAY_0 = { 0, 0, 0, 0, 0 };
+const std::vector<uint8_t> TEST_ARRAY_1 = { 0, DleEncoder::DLE_CHAR, 5};
+const std::vector<uint8_t> TEST_ARRAY_2 = { 0, DleEncoder::STX_CHAR, 5};
+const std::vector<uint8_t> TEST_ARRAY_3 = { 0, DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_4 = { DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR,
+        DleEncoder::STX_CHAR };
+
+const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_ESCAPED = {
+        DleEncoder::STX_CHAR, 0, 0, 0, 0, 0, DleEncoder::ETX_CHAR
+};
+const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_NON_ESCAPED = {
+        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, 0, 0, 0, 0,
+        DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
+};
+
+const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_ESCAPED = {
+        DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR, 5, DleEncoder::ETX_CHAR
+};
+const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_NON_ESCAPED = {
+        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
+        5, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
+};
+
+const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_ESCAPED = {
+        DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR + 0x40,
+        5, DleEncoder::ETX_CHAR
+};
+const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_NON_ESCAPED = {
+        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0,
+        DleEncoder::STX_CHAR, 5, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
+};
+
+const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_ESCAPED = {
+        DleEncoder::STX_CHAR, 0, DleEncoder::CARRIAGE_RETURN,
+        DleEncoder::DLE_CHAR,  DleEncoder::ETX_CHAR + 0x40, DleEncoder::ETX_CHAR
+};
+const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_NON_ESCAPED = {
+        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0,
+        DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR, DleEncoder::DLE_CHAR,
+        DleEncoder::ETX_CHAR
+};
+
+const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_ESCAPED = {
+        DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
+        DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR + 0x40, DleEncoder::DLE_CHAR,
+        DleEncoder::STX_CHAR + 0x40, DleEncoder::ETX_CHAR
+};
+const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_NON_ESCAPED = {
+        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
+        DleEncoder::ETX_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
+};
+
+
+TEST_CASE("DleEncoder" , "[DleEncoder]") {
+    DleEncoder dleEncoder;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    std::array<uint8_t, 32> buffer;
+
+    size_t encodedLen = 0;
+    size_t readLen = 0;
+    size_t decodedLen = 0;
+
+    auto testLambdaEncode = [&](DleEncoder& encoder, const std::vector<uint8_t>& vecToEncode,
+            const std::vector<uint8_t>& expectedVec) {
+        result = encoder.encode(vecToEncode.data(), vecToEncode.size(),
+                buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == retval::CATCH_OK);
+        for(size_t idx = 0; idx < expectedVec.size(); idx++) {
+            REQUIRE(buffer[idx] == expectedVec[idx]);
+        }
+        REQUIRE(encodedLen == expectedVec.size());
+    };
+
+    auto testLambdaDecode = [&](DleEncoder& encoder, const std::vector<uint8_t>& testVecEncoded,
+            const std::vector<uint8_t>& expectedVec) {
+        result = encoder.decode(testVecEncoded.data(),
+                testVecEncoded.size(),
+                &readLen, buffer.data(), buffer.size(), &decodedLen);
+        REQUIRE(result == retval::CATCH_OK);
+        REQUIRE(readLen == testVecEncoded.size());
+        REQUIRE(decodedLen == expectedVec.size());
+        for(size_t idx = 0; idx < decodedLen; idx++) {
+            REQUIRE(buffer[idx] == expectedVec[idx]);
+        }
+    };
+
+    SECTION("Encoding") {
+        testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);
+
+        auto testFaultyEncoding = [&](const std::vector<uint8_t>& vecToEncode,
+                const std::vector<uint8_t>& expectedVec) {
+
+            for(size_t faultyDestSize = 0; faultyDestSize < expectedVec.size(); faultyDestSize ++) {
+                result = dleEncoder.encode(vecToEncode.data(), vecToEncode.size(),
+                        buffer.data(), faultyDestSize, &encodedLen);
+                REQUIRE(result == DleEncoder::STREAM_TOO_SHORT);
+            }
+        };
+
+        testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);
+
+        dleEncoder.setEscapeMode(false);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
+        testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);
+
+        testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
+        testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);
+        dleEncoder.setEscapeMode(true);
+    }
+
+    SECTION("Decoding") {
+        testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);
+
+        // Faulty source data
+        auto testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_ESCAPED;
+        testArray1EncodedFaulty[3] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        auto testArray2EncodedFaulty = TEST_ARRAY_2_ENCODED_ESCAPED;
+        testArray2EncodedFaulty[5] = 0;
+        result = dleEncoder.decode(testArray2EncodedFaulty.data(), testArray2EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        auto testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_ESCAPED;
+        testArray4EncodedFaulty[2] = 0;
+        result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        auto testArray4EncodedFaulty2 = TEST_ARRAY_4_ENCODED_ESCAPED;
+        testArray4EncodedFaulty2[4] = 0;
+        result = dleEncoder.decode(testArray4EncodedFaulty2.data(), testArray4EncodedFaulty2.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+        auto testFaultyDecoding = [&](const std::vector<uint8_t>& vecToDecode,
+                const std::vector<uint8_t>& expectedVec) {
+            for(size_t faultyDestSizes = 0;
+                    faultyDestSizes < expectedVec.size();
+                    faultyDestSizes ++) {
+                result = dleEncoder.decode(vecToDecode.data(),
+                        vecToDecode.size(), &readLen,
+                        buffer.data(), faultyDestSizes, &decodedLen);
+                REQUIRE(result == static_cast<int>(DleEncoder::STREAM_TOO_SHORT));
+            }
+        };
+
+        testFaultyDecoding(TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
+        testFaultyDecoding(TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
+        testFaultyDecoding(TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
+        testFaultyDecoding(TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
+        testFaultyDecoding(TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);
+
+        dleEncoder.setEscapeMode(false);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
+        testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);
+
+        testFaultyDecoding(TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
+        testFaultyDecoding(TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
+        testFaultyDecoding(TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
+        testFaultyDecoding(TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
+        testFaultyDecoding(TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);
+
+        // Faulty source data
+        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+        auto prevVal = testArray1EncodedFaulty[0];
+        testArray1EncodedFaulty[0] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        testArray1EncodedFaulty[0] = prevVal;
+        testArray1EncodedFaulty[1] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+        testArray1EncodedFaulty[6] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+        testArray1EncodedFaulty[7] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+        testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_NON_ESCAPED;
+        testArray4EncodedFaulty[3] = 0;
+        result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+        dleEncoder.setEscapeMode(true);
+    }
+}