added the single measurement mode to the mgm helpers

improve filesystem API
FreeRTOS clock fix
2024-10-25 14:45:40 +02:00 · 2024-04-17 21:52:31 +02:00 · 2024-04-17 20:56:07 +02:00 · 2024-04-17 20:49:57 +02:00 · 2024-04-17 20:47:49 +02:00 · 2024-04-17 20:47:33 +02:00
545 changed files with 13455 additions and 6073 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,5 +1,5 @@
 # PyCharm and CLion
-/.idea/*
+.idea/*
 !/.idea/runConfigurations
 !/.idea/cmake.xml
 !/.idea/codeStyles
--- a/.idea/cmake.xml
+++ b/.idea/cmake.xml
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeSharedSettings">
+    <configurations>
+      <configuration PROFILE_NAME="Debug Test" ENABLED="true" CONFIG_NAME="Debug" GENERATION_OPTIONS="-DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON" NO_GENERATOR="true" />
+    </configurations>
+  </component>
+</project>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -8,10 +8,86 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

-# [v6.0.0]
+## Fixes
+
+- FreshDeviceHandlerBase did not initialize the fdirInstance
+- The `PusTmCreator` API only accepted 255 bytes of source data. It can now accept source
+  data with a size limited only by the size of `size_t`.
+- Important bugfix in CFDP PDU header format: The entity length field and the transaction sequence
+  number fields stored the actual length of the field instead of the length minus 1 like specified
+  in the CFDP standard.
+- PUS Health Service: Size check for set health command.
+  Perform operation completion for announce health command.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/746
+- Linux OSAL `getUptime` fix: Check validity of `/proc/uptime` file before reading uptime.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/745
+- Small tweak for version getter
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/744
+
+## Added
+
+- add CFDP subsystem ID
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
+- `PusTmZcWriter` now exposes API to set message counter field.
+- Relative timeshift in the PUS time service.
+
+## Changed
+
+- The PUS time service now dumps the time before setting a new time and after having set the
+  time.
+- HK generation is now countdown based.
+- Bump ETL version to 20.35.14
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/748
+- Renamed `PCDU_2` subsystem ID to `POWER_SWITCH_IF`.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
+- Add new `PowerSwitchIF::SWITCH_UNKNOWN` returnvalue.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
+- Assert that `FixedArrayList` is larger than 0 at compile time.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/740
+- Health functions are virtual now.
+- PUS Service Base request queue depth and maximum number of handled packets per cycle is now
+  configurable.
+
+## Added
+
+- `EventManager`: Add function to print all listeners.
+
+## Changed
+
+- `EventManager`: Queue depth is configurable now
+
+# [v6.0.0] 2023-02-10

 ## Fixes

+- Mode Service: Add allowed subservice
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/739
+- `CService200ModeManagement`: Various bugfixes which lead to now execution complete being generated
+  on mode announcements, duplicate mode reply generated on announce commands, and the mode read
+  subservice not working properly.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/736
+- Memory leak fixes for the TCP/IP TMTC bridge.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/737
+- `Service9TimeManagement`: Fix the time dump at the `SET_TIME` subservice: Include clock timeval
+  seconds instead of uptime.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
+- HAL MGM3100 Handler: Use axis specific gain/scaling factors. Previously,
+  only the X scaling factor was used.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/724
+- HAL MGM3100 Handler: Z value was previously calculated with bytes of the X value.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/733
+- DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
+  to false correctly because the `read` and `write` calls were missing.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/728
+- PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
+  of the correct unsegmented flags (0b11) as specified in the standard.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/727
+- TC Scheduler Service 11: Add size and CRC check for contained TC.
+  Bug: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/issues/719
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/720
+- Only delete health table entry in `HealthHelper` destructor if
+  health table was set.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710
 - I2C Bugfixes: Do not keep iterator as member and fix some incorrect handling with the iterator.
  Also properly reset the reply size for successfull transfers and erroneous transfers.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/700
@ -21,14 +97,85 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `TcpTmTcServer.cpp`: The server was actually not able to handle
  CCSDS packets which were clumped together. This has been fixed now.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
+- `CServiceHealthCommanding`: Add announce all health info implementation
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
+- various fixes related to linux Unittests and memory leaks
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/715
+- small fix to allow teardown handling
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/713
+- fix compiler warning for fixed array list copy ctor
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/704
+- missing include
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/703
+- defaultconfig did not build anymore
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/702
+- hotfix
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/699
+- small fix for helper
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/698
+- missing retval conv
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/697
+- DHB Countdown Bug
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/693
+- doc corrections
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/687
+- better error printout
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/686
+- include correction
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/683
+- better warning for missing include paths
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/676
+- Service 11 regression
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/670

 ## Added

+- `CServiceHealthCommanding`: Add announce all health info implementation
+  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
+- Empty constructor for `CdsShortTimeStamper` which does not do an object manager registration.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/730
+- `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
+- `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
+  option on the TCP server. CTOR prototype has changed and expects an explicit
+  TCP configuration struct to be passed.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/722
+- `DleParser` helper class to parse DLE encoded packets from a byte stream.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/711
+- `UioMapper` is able to resolve symlinks now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/709
 - Add new `UnsignedByteField` class
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
+- publish documentation for development and master branch
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/681
+- Add Linux HAL options
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/663
+- Expand SerializeIF
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/656
+- PUS Service 11: Additional Safety Check
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/666
+- improvements for auto-formatter script
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/665
+- provide a weak print char impl
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/674
+
+## Removed
+
+- now that doc server is up, remove markdown files
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/688
+- remove bsp specific code
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/679

 ## Changes

+- `CService201HealthCommanding` renamed to `CServiceHealthCommanding`,
+  service ID customizable now. `CServiceHealthCommanding` expects configuration struct
+  `HealthServiceCfg` now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
+- `AcceptsTelemetryIF`: `getReportReceptionQueue` is const now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/712
+- Moved some container returnvalues to dedicated header and namespace
+  so they can be used without template specification.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/707
 - Remove default secondary header argument for
  `uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)` and
  `uint16_t getTmSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)`
@ -61,8 +208,57 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  - Make functions `const` where it makes sense
  - Add `const char* getName const` abstract function
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/684
+- Generic TMTC Bridge Update
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/734
+- comment tweak to event parser can read everything
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/732
+- CMakeLists file updates
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/731
+- improve srv20 error messages
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/723
+- I2C Linux: remove duplicate printout
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/718
+- printout handling improvements
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/717
+- vec getter, reset for content
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/716
+- updates for source sequence counter
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/714
+- SP reader getPacketData is const now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/708
+- refactoring of serial drivers for linux
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/705
+- Local Pool Update Remove Add Data Ignore Fault Argument
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/701
+- Switch to new documentation server
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/694
+- Windows Tweaks
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/691
+- Refactor Local Pool API
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/667
+- group MGM data in local pool vectors
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/664

-# [v5.0.0] 25.07.2022
+
+## CFDP
+
+- Refactoring of CFDP stack which was done during implementation of the CFDP source and destination
+  handlers.
+   - New filesystem module, changes for filesystem abstraction `HasFileSystemIF` to better
+     fit requirements of CFDP
+   - New `HostFilesystem` implementation of the `HasFileSystemIF`
+   - New `cfdp::UserBase` class which is the abstraction for the CFDP user in an OBSW context.
+   - mib module for the CFDP stack
+   - PDU classes renamed from `...Serializer`/`...Deserializer` to `...Creator`/`...Reader`
+     respetively
+   - Renamed `TcDistributor` to `TcDistributorBase` to prevent confusion
+   - Refactored `TcDisitributorBase` to be more flexible and usable for CFDP distribution
+   - Renamed `CCSDSDistributor` to `CcsdsDistributor` and add feature which allows it
+     to remove the CCSDS header when routing a packet. This allows CCSDS agnostic receiver
+     implementation without an extra component
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/682
+
+# [v5.0.0] 2022-07-25

 ## Changes

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################

-set(FSFW_VERSION_IF_GIT_FAILS 5)
+set(FSFW_VERSION_IF_GIT_FAILS 6)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)

@ -72,7 +72,7 @@ set(FSFW_ETL_LIB_MAJOR_VERSION
    20
    CACHE STRING "ETL library major version requirement")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.36.0
    CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)

@ -80,7 +80,7 @@ set(FSFW_CATCH2_LIB_MAJOR_VERSION
    3
    CACHE STRING "Catch2 library major version requirement")
 set(FSFW_CATCH2_LIB_VERSION
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.1.0
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.3.2
    CACHE STRING "Catch2 library exact version requirement")

 # Keep this off by default for now. See PR:
@ -104,7 +104,8 @@ if(FSFW_GENERATE_SECTIONS)
  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()

-option(FSFW_BUILD_TESTS "Build unittest binary in addition to static library"
+option(FSFW_BUILD_TESTS
+       "Build unittest binary in addition to static library. Requires Catch2"
       OFF)
 option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
@ -115,13 +116,13 @@ endif()
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
-option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
 option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)

 if(UNIX)
  option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers"
         OFF)
  option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
+  option(FSFW_HAL_LINUX_ADD_SERIAL_DRIVERS "Add serial drivers" ON)
 endif()

 # Optional sources
@ -152,12 +153,12 @@ if(FSFW_BUILD_TESTS)
      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
  )
  # Check whether the user has already installed Catch2 first
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} QUIET)
  # Not installed, so use FetchContent to download and provide Catch2
  if(NOT Catch2_FOUND)
    message(
      STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent."
    )
    include(FetchContent)

@ -200,8 +201,8 @@ find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
  message(
    STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
+      "${MSG_PREFIX} ETL installation not found. Downloading ETL with FetchContent."
+  )
  include(FetchContent)

  FetchContent_Declare(
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -1,45 +1,87 @@
 pipeline {
    environment {
-        BUILDDIR = 'cmake-build-tests'
+        BUILDDIR_HOST = 'cmake-build-tests-host'
+        BUILDDIR_LINUX = 'cmake-build-tests-linux'
        DOCDDIR = 'cmake-build-documentation'
    }
    agent {
        docker { 
            image 'fsfw-ci:d6'
-            args '--network host'
+            args '--network host --sysctl fs.mqueue.msg_max=100'
        }
    }
    stages {
-        stage('Clean') {
-            steps {
-                sh 'rm -rf $BUILDDIR'
-            }
-        }
-        stage('Configure') {
-            steps {
-                dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+        stage('Host') {
+            stages{
+                stage('Clean') {
+                    steps {
+                        sh 'rm -rf $BUILDDIR_HOST'
+                    }
+                }
+                stage('Configure') {
+                    steps {
+                        dir(BUILDDIR_HOST) {
+                            sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                        }
+                    }
+                }
+                stage('Build') {
+                    steps {
+                        dir(BUILDDIR_HOST) {
+                            sh 'cmake --build . -j4'
+                        }
+                    }
+                }
+                stage('Unittests') {
+                    steps {
+                        dir(BUILDDIR_HOST) {
+                            sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                        }
+                    }
+                }
+                stage('Valgrind') {
+                    steps {
+                        dir(BUILDDIR_HOST) {
+                            sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
+                        }
+                    }
                }
            }
        }
-        stage('Build') {
-            steps {
-                dir(BUILDDIR) {
-                    sh 'cmake --build . -j4'
+        stage('Linux') {
+            stages{
+                stage('Clean') {
+                    steps {
+                        sh 'rm -rf $BUILDDIR_LINUX'
+                    }
                }
-            }
-        }
-        stage('Unittests') {
-            steps {
-                dir(BUILDDIR) {
-                    sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                stage('Configure') {
+                    steps {
+                        dir(BUILDDIR_LINUX) {
+                            sh 'cmake -DFSFW_OSAL=linux -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                        }
+                    }
                }
-            }
-        }
-        stage('Valgrind') {
-            steps {
-                dir(BUILDDIR) {
-                    sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
+                stage('Build') {
+                    steps {
+                        dir(BUILDDIR_LINUX) {
+                            sh 'cmake --build . -j4'
+                        }
+                    }
+                }
+                stage('Unittests') {
+                    steps {
+                        dir(BUILDDIR_LINUX) {
+                            sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                        }
+                    }
+                }
+                stage('Valgrind') {
+                    steps {
+                        dir(BUILDDIR_LINUX) {
+                            sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
+                        }
+                    }
                }
            }
        }
@ -55,7 +97,7 @@ pipeline {
                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
                    }
                }
-                dir(BUILDDIR) {
+                dir(BUILDDIR_LINUX) {
                    sshagent(credentials: ['documentation-buildfix']) {
                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
                    }
@ -74,7 +116,7 @@ pipeline {
                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
                    }
                }
-                dir(BUILDDIR) {
+                dir(BUILDDIR_LINUX) {
                    sshagent(credentials: ['documentation-buildfix']) {
                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
                    }
--- a/cmake/cmake-modules/bilke/CodeCoverage.cmake
+++ b/cmake/cmake-modules/bilke/CodeCoverage.cmake
@ -140,7 +140,7 @@ find_program( GCOV_PATH gcov )
 find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
 find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
 find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
-find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( GCOVR_PATH gcovr )
 find_program( CPPFILT_PATH NAMES c++filt )

 if(NOT GCOV_PATH)
--- a/docs/api.rst
+++ b/docs/api.rst
@ -4,6 +4,7 @@ API
 .. toctree::
   :maxdepth: 4

+   api/cfdp
   api/objectmanager
   api/task
   api/ipc
--- a/docs/api/cfdp.rst
+++ b/docs/api/cfdp.rst
@ -0,0 +1,8 @@
+CFDP API
+=================
+
+``UserBase``
+-----------------
+
+.. doxygenclass:: cfdp::UserBase
+	:members:
--- a/docs/conf.py
+++ b/docs/conf.py
@ -17,12 +17,12 @@

 # -- Project information -----------------------------------------------------

-project = 'Flight Software Framework'
-copyright = '2021, Institute of Space Systems (IRS)'
-author = 'Institute of Space Systems (IRS)'
+project = "Flight Software Framework"
+copyright = "2021, Institute of Space Systems (IRS)"
+author = "Institute of Space Systems (IRS)"

 # The full version, including alpha/beta/rc tags
-release = '2.0.1'
+release = "5.0.0"


 # -- General configuration ---------------------------------------------------
@ -30,17 +30,17 @@ release = '2.0.1'
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = [ "breathe" ]
+extensions = ["breathe"]

 breathe_default_project = "fsfw"

 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]

 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]


 # -- Options for HTML output -------------------------------------------------
@ -48,14 +48,17 @@ exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = "alabaster"

 html_theme_options = {
-    "extra_nav_links": {"Impressum" : "https://www.uni-stuttgart.de/impressum", "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html"}
+    "extra_nav_links": {
+        "Impressum": "https://www.uni-stuttgart.de/impressum",
+        "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html",
+    }
 }


 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = []
+html_static_path = []
--- a/scripts/auto-formatter.sh
+++ b/scripts/auto-formatter.sh
@ -12,7 +12,8 @@ cmake_fmt="cmake-format"
 file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
  ${cmake_fmt} -i CMakeLists.txt
-  find ./src ${file_selectors} | xargs ${cmake_fmt}  -i
+  find ./src ${file_selectors} | xargs ${cmake_fmt} -i
+  find ./unittests ${file_selectors} | xargs ${cmake_fmt} -i
 else
  echo "No ${cmake_fmt} tool found, not formatting CMake files"
 fi
--- a/scripts/check_release.py
+++ b/scripts/check_release.py
@ -0,0 +1,110 @@
+#! /bin/python
+
+
+import argparse
+import json
+import urllib.request
+import re
+from pathlib import Path
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="List undocumented PRs"
+    )
+    parser.add_argument("-v", "--version", type=str, required=True)
+    args = parser.parse_args()
+    
+    match = re.search("([0-9]+\.[0-9]+\.[0-9]+)", args.version)
+    
+    if not match:
+        print("invalid version")
+        exit(1)
+    
+    version = "v" + match.group(1)
+    
+    print("looking for milestone for " + version + " ...")
+    
+    
+    with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/milestones?name=" + version) as milestone_json:
+        milestones = json.load(milestone_json)
+        if (len(milestones) == 0):
+            print("did not find any milestone")
+            exit(1)
+        if (len(milestones) > 1):
+            print("found multiple milestons")
+        milestone_title = milestones[0]['title']
+        milestone = str(milestones[0]['id'])
+        print("Using Milestone \""+ milestone_title + "\" with id " + milestone)
+    
+    milestone_prs = []
+    
+    page = 1
+    last_count = 1;
+    while last_count != 0:
+        with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/pulls?state=closed&milestone=" + str(milestone) + "&limit=100&page=" + str(page)) as pull_requests_json:
+            pull_requests = json.load(pull_requests_json)
+            for pr in pull_requests:
+                milestone_prs.append({'number': str(pr['number']), 'title' : pr['title']})
+            page += 1
+            last_count = len(pull_requests)
+    
+    print("Found " + str(len(milestone_prs)) + " closed PRs in Milestone")
+    
+    print("looking for CHANGELOG.md ...")
+    
+    path = Path(".")
+    
+    files = list(path.glob("CHANGELOG.md"))
+    
+    if (len(files) != 1):
+        files = list(path.glob("../CHANGELOG.md"))
+        
+    if (len(files) != 1):
+        print("did not find CHANGELOG.md. Run script in either root directory or scripts subfolder.")
+        exit(1)
+        
+    print("Scanning CHANGELOG.md ...")
+    
+    changelog_prs = []
+    
+    with open(files[0]) as changelog:
+        line = changelog.readline()
+        while (line):
+            #print("line: " + line)
+            match = re.search("\#.+(v[0-9]+\.[0-9]+\.[0-9]+)", line)
+            if (match):
+                if match.group(1) == version:
+                    #print("found version")
+                    line = changelog.readline()
+                    continue
+                else:
+                    #print("done with " + match.group(1))
+                    break
+            
+            match = re.search("PR: https://egit\.irs\.uni-stuttgart\.de/fsfw/fsfw/pulls/([0-9]+)", line)
+            if match:
+                changelog_prs.append(match.group(1))
+                
+            line = changelog.readline()
+    
+    print("Found " + str(len(changelog_prs)) + " PRs in CHANGELOG.md")
+    
+    print("")
+    
+    copy_array = changelog_prs.copy()
+    print("PRs in CHANGELOG.md that are not in Milestone:")
+    for pr in milestone_prs:
+        if pr['number'] in copy_array:
+            copy_array.remove(pr['number'])
+    for pr in copy_array:
+        print("https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr)
+
+    print("")
+
+    print("PRs in milestone that are not in CHANGELOG.md:")
+    
+    for pr in milestone_prs:
+        if pr['number'] not in changelog_prs:
+            print("- " + pr['title'] + "\n  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr['number'])
+
+main()
--- a/scripts/helper.py
+++ b/scripts/helper.py
@ -51,7 +51,7 @@ def main():
    parser.add_argument(
        "-g",
        "--generators",
-        default = "Ninja",
+        default="Ninja",
        action="store",
        help="CMake generators",
    )
@ -165,10 +165,18 @@ def create_tests_build_cfg(args):
    os.mkdir(UNITTEST_FOLDER_NAME)
    os.chdir(UNITTEST_FOLDER_NAME)
    if args.windows:
-        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON \
+        cmake_cmd = (
+            'cmake -G "'
+            + args.generators
+            + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON \
        -DGCOVR_PATH="py -m gcovr" ..'
+        )
    else:
-        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON ..'
+        cmake_cmd = (
+            'cmake -G "'
+            + args.generators
+            + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON ..'
+        )
    cmd_runner(cmake_cmd)
    os.chdir("..")

--- a/src/fsfw/CMakeLists.txt
+++ b/src/fsfw/CMakeLists.txt
@ -31,6 +31,8 @@ add_subdirectory(thermal)
 add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)
 add_subdirectory(tmtcservices)
+add_subdirectory(filesystem)
+add_subdirectory(util)

 # Optional

--- a/src/fsfw/action/ActionHelper.cpp
+++ b/src/fsfw/action/ActionHelper.cpp
@ -59,17 +59,24 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }

 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                    store_address_t dataAddress) {
+  bool hasAdditionalData = false;
  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
-  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != returnvalue::OK) {
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, result);
-    queueToUse->sendMessage(commandedBy, &reply);
-    return;
+  ReturnValue_t result;
+  if (dataAddress != store_address_t::invalid()) {
+    hasAdditionalData = true;
+    result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != returnvalue::OK) {
+      CommandMessage reply;
+      ActionMessage::setStepReply(&reply, actionId, 0, result);
+      queueToUse->sendMessage(commandedBy, &reply);
+      return;
+    }
  }
  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-  ipcStore->deleteData(dataAddress);
+  if (hasAdditionalData) {
+    ipcStore->deleteData(dataAddress);
+  }
  if (result == HasActionsIF::EXECUTION_FINISHED) {
    CommandMessage reply;
    ActionMessage::setCompletionReply(&reply, actionId, true, result);
--- a/src/fsfw/action/CommandActionHelper.h
+++ b/src/fsfw/action/CommandActionHelper.h
@ -16,8 +16,8 @@ class CommandActionHelper {
 public:
  explicit CommandActionHelper(CommandsActionsIF* owner);
  virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
-                              uint32_t size);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
+                              const uint8_t* data = nullptr, uint32_t size = 0);
  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
  ReturnValue_t initialize();
  ReturnValue_t handleReply(CommandMessage* reply);
--- a/src/fsfw/cfdp.h
+++ b/src/fsfw/cfdp.h
@ -0,0 +1,12 @@
+#ifndef FSFW_CFDP_H
+#define FSFW_CFDP_H
+
+#include "cfdp/definitions.h"
+#include "cfdp/handler/DestHandler.h"
+#include "cfdp/handler/FaultHandlerBase.h"
+#include "cfdp/helpers.h"
+#include "cfdp/tlv/Lv.h"
+#include "cfdp/tlv/StringLv.h"
+#include "cfdp/tlv/Tlv.h"
+
+#endif  // FSFW_CFDP_H
--- a/src/fsfw/cfdp/CMakeLists.txt
+++ b/src/fsfw/cfdp/CMakeLists.txt
@ -1,4 +1,6 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE CfdpHandler.cpp CfdpMessage.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE CfdpMessage.cpp CfdpDistributor.cpp
+                                        VarLenFields.cpp helpers.cpp)

 add_subdirectory(pdu)
 add_subdirectory(tlv)
+add_subdirectory(handler)
--- a/src/fsfw/cfdp/CfdpDistributor.cpp
+++ b/src/fsfw/cfdp/CfdpDistributor.cpp
@ -0,0 +1,55 @@
+#include "CfdpDistributor.h"
+
+#include "fsfw/tcdistribution/definitions.h"
+
+CfdpDistributor::CfdpDistributor(CfdpDistribCfg cfg)
+    : TcDistributorBase(cfg.objectId, cfg.tcQueue), cfg(cfg) {}
+
+ReturnValue_t CfdpDistributor::registerTcDestination(const cfdp::EntityId& address,
+                                                     AcceptsTelecommandsIF& tcDest) {
+  for (const auto& dest : tcDestinations) {
+    if (dest.id == address) {
+      return returnvalue::FAILED;
+    }
+  }
+  tcDestinations.emplace_back(address, tcDest.getName(), tcDest.getRequestQueue());
+  return returnvalue::OK;
+}
+
+ReturnValue_t CfdpDistributor::selectDestination(MessageQueueId_t& destId) {
+  auto accessorPair = cfg.tcStore.getData(currentMessage.getStorageId());
+  if (accessorPair.first != returnvalue::OK) {
+    return accessorPair.first;
+  }
+  ReturnValue_t result =
+      pduReader.setReadOnlyData(accessorPair.second.data(), accessorPair.second.size());
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = pduReader.parseData();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  cfdp::EntityId foundId;
+  pduReader.getDestId(foundId);
+  bool destFound = false;
+  for (const auto& dest : tcDestinations) {
+    if (dest.id == foundId) {
+      destId = dest.queueId;
+      destFound = true;
+    }
+  }
+  if (not destFound) {
+    // TODO: Warning and event?
+    return tmtcdistrib::NO_DESTINATION_FOUND;
+  }
+  // Packet was forwarded successfully, so do not delete it.
+  accessorPair.second.release();
+  return returnvalue::OK;
+}
+
+const char* CfdpDistributor::getName() const { return "CFDP Distributor"; }
+
+uint32_t CfdpDistributor::getIdentifier() const { return 0; }
+
+MessageQueueId_t CfdpDistributor::getRequestQueue() const { return tcQueue->getId(); }
--- a/src/fsfw/cfdp/CfdpDistributor.h
+++ b/src/fsfw/cfdp/CfdpDistributor.h
@ -0,0 +1,76 @@
+#ifndef FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
+#define FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
+
+#include <utility>
+#include <vector>
+
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/tcdistribution/CfdpPacketChecker.h"
+#include "fsfw/tcdistribution/TcDistributorBase.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
+#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
+#include "fsfw/tmtcservices/VerificationReporter.h"
+
+struct CfdpDistribCfg {
+  CfdpDistribCfg(object_id_t objectId, StorageManagerIF& tcStore, MessageQueueIF* tcQueue)
+      : objectId(objectId), tcStore(tcStore), tcQueue(tcQueue) {}
+
+  object_id_t objectId;
+  StorageManagerIF& tcStore;
+  MessageQueueIF* tcQueue;
+};
+
+/**
+ * This will be the primary component to perform PDU forwading procedures. This includes forwarding
+ * CFDP TC packets to registered source or destination handlers, and forwarding all telemetry
+ * generated by them to registered TM sinks.
+ * @ingroup tc_distribution
+ */
+class CfdpDistributor : public TcDistributorBase, public AcceptsTelecommandsIF {
+ public:
+  /**
+   * The ctor passes @c set_apid to the checker class and calls the
+   * TcDistribution ctor with a certain object id.
+   * @param setApid The APID of this receiving Application.
+   * @param setObjectId Object ID of the distributor itself
+   * @param setPacketSource Object ID of the source of TC packets.
+   * Must implement CcsdsDistributorIF.
+   */
+  explicit CfdpDistributor(CfdpDistribCfg cfg);
+
+  [[nodiscard]] const char* getName() const override;
+  [[nodiscard]] uint32_t getIdentifier() const override;
+  [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
+
+  /**
+   * Register a new CFDP entity which can receive PDUs.
+   * @param address
+   * @param tcDest
+   * @return
+   *  - @c RETURN_FAILED: Entry already exists for the given address
+   */
+  ReturnValue_t registerTcDestination(const cfdp::EntityId& address, AcceptsTelecommandsIF& tcDest);
+
+ protected:
+  struct EntityInfo {
+    EntityInfo(cfdp::EntityId id, const char* name, MessageQueueId_t queueId)
+        : id(std::move(id)), name(name), queueId(queueId) {}
+    cfdp::EntityId id;
+    const char* name;
+    MessageQueueId_t queueId;
+  };
+  PduHeaderReader pduReader;
+  ReturnValue_t lastTcError = returnvalue::OK;
+  ReturnValue_t lastTmError = returnvalue::OK;
+  // I don't think a regular OBSW will have more than 1 or 2 of these destinations, so I think
+  // it is okay to accept the overhead here
+  std::vector<EntityInfo> tcDestinations;
+  CfdpDistribCfg cfg;
+
+  ReturnValue_t selectDestination(MessageQueueId_t& destId) override;
+
+ private:
+};
+
+#endif /* FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_ */
--- a/src/fsfw/cfdp/CfdpHandler.cpp
+++ b/src/fsfw/cfdp/CfdpHandler.cpp
@ -1,56 +0,0 @@
-#include "fsfw/cfdp/CfdpHandler.h"
-
-#include "fsfw/cfdp/CfdpMessage.h"
-#include "fsfw/ipc/CommandMessage.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/storagemanager/storeAddress.h"
-#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
-
-object_id_t CfdpHandler::packetSource = 0;
-object_id_t CfdpHandler::packetDestination = 0;
-
-CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
-    : SystemObject(setObjectId) {
-  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
-  distributor = dist;
-}
-
-CfdpHandler::~CfdpHandler() = default;
-
-ReturnValue_t CfdpHandler::initialize() {
-  ReturnValue_t result = SystemObject::initialize();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  this->distributor->registerHandler(this);
-  return returnvalue::OK;
-}
-
-ReturnValue_t CfdpHandler::handleRequest(store_address_t storeId) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::debug << "CFDPHandler::handleRequest" << std::endl;
-#else
-  sif::printDebug("CFDPHandler::handleRequest\n");
-#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif
-
-  // TODO read out packet from store using storeId
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t CfdpHandler::performOperation(uint8_t opCode) {
-  ReturnValue_t status = returnvalue::OK;
-  CommandMessage currentMessage;
-  for (status = this->requestQueue->receiveMessage(&currentMessage); status == returnvalue::OK;
-       status = this->requestQueue->receiveMessage(&currentMessage)) {
-    store_address_t storeId = CfdpMessage::getStoreId(&currentMessage);
-    this->handleRequest(storeId);
-  }
-  return returnvalue::OK;
-}
-
-uint32_t CfdpHandler::getIdentifier() const { return 0; }
-
-MessageQueueId_t CfdpHandler::getRequestQueue() const { return this->requestQueue->getId(); }
--- a/src/fsfw/cfdp/CfdpHandler.h
+++ b/src/fsfw/cfdp/CfdpHandler.h
@ -1,60 +0,0 @@
-#ifndef FSFW_CFDP_CFDPHANDLER_H_
-#define FSFW_CFDP_CFDPHANDLER_H_
-
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/tcdistribution/CFDPDistributor.h"
-#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class CfdpHandler : public ExecutableObjectIF, public AcceptsTelecommandsIF, public SystemObject {
-  friend void(Factory::setStaticFrameworkObjectIds)();
-
- public:
-  CfdpHandler(object_id_t setObjectId, CFDPDistributor* distributor);
-  /**
-   * The destructor is empty.
-   */
-  virtual ~CfdpHandler();
-
-  virtual ReturnValue_t handleRequest(store_address_t storeId);
-
-  virtual ReturnValue_t initialize() override;
-  uint32_t getIdentifier() const override;
-  MessageQueueId_t getRequestQueue() const override;
-  ReturnValue_t performOperation(uint8_t opCode) override;
-
- protected:
-  /**
-   * This is a complete instance of the telecommand reception queue
-   * of the class. It is initialized on construction of the class.
-   */
-  MessageQueueIF* requestQueue = nullptr;
-
-  CFDPDistributor* distributor = nullptr;
-
-  /**
-   * The current CFDP packet to be processed.
-   * It is deleted after handleRequest was executed.
-   */
-  CfdpPacketStored currentPacket;
-
-  static object_id_t packetSource;
-
-  static object_id_t packetDestination;
-
- private:
-  /**
-   * This constant sets the maximum number of packets accepted per call.
-   * Remember that one packet must be completely handled in one
-   * #handleRequest call.
-   */
-  static const uint8_t CFDP_HANDLER_MAX_RECEPTION = 100;
-};
-
-#endif /* FSFW_CFDP_CFDPHANDLER_H_ */
--- a/src/fsfw/cfdp/CfdpMessage.cpp
+++ b/src/fsfw/cfdp/CfdpMessage.cpp
@ -4,8 +4,9 @@ CfdpMessage::CfdpMessage() = default;

 CfdpMessage::~CfdpMessage() = default;

-void CfdpMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
-  message->setParameter(cfdpPacket.raw);
+void CfdpMessage::setPutRequest(CommandMessage *message, store_address_t putRequest) {
+  message->setCommand(PUT_REQUEST);
+  message->setParameter(putRequest.raw);
 }

 store_address_t CfdpMessage::getStoreId(const CommandMessage *message) {
--- a/src/fsfw/cfdp/CfdpMessage.h
+++ b/src/fsfw/cfdp/CfdpMessage.h
@ -11,9 +11,11 @@ class CfdpMessage {

 public:
  static const uint8_t MESSAGE_ID = messagetypes::CFDP;
+  static const Command_t PUT_REQUEST = MAKE_COMMAND_ID(1);
+  static const Command_t CANCEL_REQUEST = MAKE_COMMAND_ID(1);

  virtual ~CfdpMessage();
-  static void setCommand(CommandMessage* message, store_address_t cfdpPacket);
+  static void setPutRequest(CommandMessage* message, store_address_t putRequest);

  static store_address_t getStoreId(const CommandMessage* message);

--- a/src/fsfw/cfdp/FileSize.h
+++ b/src/fsfw/cfdp/FileSize.h
@ -1,16 +1,23 @@
-#ifndef FSFW_SRC_FSFW_CFDP_FILESIZE_H_
-#define FSFW_SRC_FSFW_CFDP_FILESIZE_H_
+#ifndef FSFW_CFDP_FILESIZE_H_
+#define FSFW_CFDP_FILESIZE_H_
+
+#include <optional>

 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serialize/SerializeIF.h"

 namespace cfdp {

-struct FileSize : public SerializeIF {
+/**
+ * Helper type for the CFDP File Size Sensitive (FSS) fields.
+ */
+struct Fss : public SerializeIF {
 public:
-  FileSize() : largeFile(false){};
+  Fss() = default;

-  FileSize(uint64_t fileSize, bool isLarge = false) { setFileSize(fileSize, isLarge); };
+  explicit Fss(uint64_t fileSize, bool isLarge = false) { setFileSize(fileSize, isLarge); };
+
+  [[nodiscard]] uint64_t value() const { return fileSize; }

  ReturnValue_t serialize(bool isLarge, uint8_t **buffer, size_t *size, size_t maxSize,
                          Endianness streamEndianness) {
@ -27,7 +34,7 @@ struct FileSize : public SerializeIF {
    return SerializeAdapter::serialize(&fileSize, buffer, size, maxSize, streamEndianness);
  }

-  size_t getSerializedSize() const override {
+  [[nodiscard]] size_t getSerializedSize() const override {
    if (largeFile) {
      return 8;
    } else {
@ -50,20 +57,22 @@ struct FileSize : public SerializeIF {
    }
  }

-  ReturnValue_t setFileSize(uint64_t fileSize, bool largeFile) {
+  ReturnValue_t setFileSize(uint64_t fileSize_, std::optional<bool> largeFile_) {
+    if (largeFile_) {
+      largeFile = largeFile_.value();
+    }
    if (not largeFile and fileSize > UINT32_MAX) {
      // TODO: emit warning here
      return returnvalue::FAILED;
    }
-    this->fileSize = fileSize;
-    this->largeFile = largeFile;
+    this->fileSize = fileSize_;
    return returnvalue::OK;
  }

-  bool isLargeFile() const { return largeFile; }
-  uint64_t getSize(bool *largeFile = nullptr) const {
-    if (largeFile != nullptr) {
-      *largeFile = this->largeFile;
+  [[nodiscard]] bool isLargeFile() const { return largeFile; }
+  uint64_t getSize(bool *largeFile_ = nullptr) const {
+    if (largeFile_ != nullptr) {
+      *largeFile_ = this->largeFile;
    }
    return fileSize;
  }
@ -75,4 +84,4 @@ struct FileSize : public SerializeIF {

 }  // namespace cfdp

-#endif /* FSFW_SRC_FSFW_CFDP_FILESIZE_H_ */
+#endif /* FSFW_CFDP_FILESIZE_H_ */
--- a/src/fsfw/cfdp/pdu/VarLenField.cpp
+++ b/src/fsfw/cfdp/pdu/VarLenField.cpp
@ -1,11 +1,10 @@
-#include "VarLenField.h"
+#include "VarLenFields.h"

-#include "fsfw/FSFW.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"

-cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
-  ReturnValue_t result = this->setValue(width, value);
+cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, uint64_t value) : VarLenField() {
+  ReturnValue_t result = this->setValueAndWidth(width, value);
  if (result != returnvalue::OK) {
 #if FSFW_DISABLE_PRINTOUT == 0
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -21,38 +20,41 @@ cfdp::VarLenField::VarLenField() : width(cfdp::WidthInBytes::ONE_BYTE) { value.o

 cfdp::WidthInBytes cfdp::VarLenField::getWidth() const { return width; }

-ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_t value) {
-  switch (widthInBytes) {
+ReturnValue_t cfdp::VarLenField::setValueAndWidth(cfdp::WidthInBytes width_, uint64_t value_) {
+  switch (width_) {
    case (cfdp::WidthInBytes::ONE_BYTE): {
-      if (value > UINT8_MAX) {
+      if (value_ > UINT8_MAX) {
        return returnvalue::FAILED;
      }
-      this->value.oneByte = value;
+      this->value.oneByte = value_;
      break;
    }
    case (cfdp::WidthInBytes::TWO_BYTES): {
-      if (value > UINT16_MAX) {
+      if (value_ > UINT16_MAX) {
        return returnvalue::FAILED;
      }
-      this->value.twoBytes = value;
+      this->value.twoBytes = value_;
      break;
    }
    case (cfdp::WidthInBytes::FOUR_BYTES): {
-      if (value > UINT32_MAX) {
+      if (value_ > UINT32_MAX) {
        return returnvalue::FAILED;
      }
-      this->value.fourBytes = value;
+      this->value.fourBytes = value_;
      break;
    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      this->value.eightBytes = value_;
+    }
    default: {
      break;
    }
  }
-  this->width = widthInBytes;
+  this->width = width_;
  return returnvalue::OK;
 }

-size_t cfdp::VarLenField::getValue() const {
+uint64_t cfdp::VarLenField::getValue() const {
  switch (width) {
    case (cfdp::WidthInBytes::ONE_BYTE): {
      return value.oneByte;
@ -63,6 +65,9 @@ size_t cfdp::VarLenField::getValue() const {
    case (cfdp::WidthInBytes::FOUR_BYTES): {
      return value.fourBytes;
    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return value.eightBytes;
+    }
  }
  return 0;
 }
@ -85,6 +90,10 @@ ReturnValue_t cfdp::VarLenField::serialize(uint8_t **buffer, size_t *size, size_
    case (cfdp::WidthInBytes::FOUR_BYTES): {
      return SerializeAdapter::serialize(&value.fourBytes, buffer, size, maxSize, streamEndianness);
    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return SerializeAdapter::serialize(&value.eightBytes, buffer, size, maxSize,
+                                         streamEndianness);
+    }
    default: {
      return returnvalue::FAILED;
    }
@ -93,17 +102,22 @@ ReturnValue_t cfdp::VarLenField::serialize(uint8_t **buffer, size_t *size, size_

 size_t cfdp::VarLenField::getSerializedSize() const { return width; }

-ReturnValue_t cfdp::VarLenField::deSerialize(cfdp::WidthInBytes width, const uint8_t **buffer,
+ReturnValue_t cfdp::VarLenField::deSerialize(cfdp::WidthInBytes width_, const uint8_t **buffer,
                                             size_t *size, Endianness streamEndianness) {
-  this->width = width;
+  this->width = width_;
  return deSerialize(buffer, size, streamEndianness);
 }

+ReturnValue_t cfdp::VarLenField::setValue(uint64_t value_) {
+  return setValueAndWidth(getWidth(), value_);
+}
+
 ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *size,
                                             Endianness streamEndianness) {
  switch (width) {
    case (cfdp::WidthInBytes::ONE_BYTE): {
      value.oneByte = **buffer;
+      *buffer += 1;
      *size += 1;
      return returnvalue::OK;
    }
@ -113,8 +127,31 @@ ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *siz
    case (cfdp::WidthInBytes::FOUR_BYTES): {
      return SerializeAdapter::deSerialize(&value.fourBytes, buffer, size, streamEndianness);
    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return SerializeAdapter::deSerialize(&value.eightBytes, buffer, size, streamEndianness);
+    }
    default: {
      return returnvalue::FAILED;
    }
  }
 }
+
+bool cfdp::VarLenField::operator<(const cfdp::VarLenField &other) const {
+  if (getWidth() < other.getWidth()) {
+    return true;
+  } else if (getWidth() == other.getWidth()) {
+    return getValue() < other.getValue();
+  } else {
+    return false;
+  }
+}
+
+bool cfdp::VarLenField::operator==(const cfdp::VarLenField &other) const {
+  return getWidth() == other.getWidth() and getValue() == other.getValue();
+}
+
+bool cfdp::VarLenField::operator!=(const cfdp::VarLenField &other) const {
+  return not(*this == other);
+}
+
+void cfdp::VarLenField::setWidth(cfdp::WidthInBytes width_) { this->width = width_; }
--- a/src/fsfw/cfdp/VarLenFields.h
+++ b/src/fsfw/cfdp/VarLenFields.h
@ -0,0 +1,136 @@
+#ifndef FSFW_CFDP_PDU_VARLENFIELD_H_
+#define FSFW_CFDP_PDU_VARLENFIELD_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+#include "fsfw/cfdp/definitions.h"
+#include "fsfw/serialize/SerializeIF.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw/util/UnsignedByteField.h"
+
+namespace cfdp {
+
+class VarLenField : public SerializeIF {
+ public:
+  union LengthFieldLen {
+    uint8_t oneByte;
+    uint16_t twoBytes;
+    uint32_t fourBytes;
+    uint64_t eightBytes;
+  };
+
+  VarLenField();
+  template <typename T>
+  explicit VarLenField(UnsignedByteField<T> byteField);
+
+  VarLenField(cfdp::WidthInBytes width, uint64_t value);
+
+  bool operator==(const VarLenField &other) const;
+  bool operator!=(const VarLenField &other) const;
+  bool operator<(const VarLenField &other) const;
+
+  ReturnValue_t setValueAndWidth(cfdp::WidthInBytes width, uint64_t value);
+  void setWidth(cfdp::WidthInBytes width);
+  ReturnValue_t setValue(uint64_t value);
+
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+
+  [[nodiscard]] size_t getSerializedSize() const override;
+
+  ReturnValue_t deSerialize(cfdp::WidthInBytes width, const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness);
+
+  [[nodiscard]] cfdp::WidthInBytes getWidth() const;
+  [[nodiscard]] uint64_t getValue() const;
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  friend std::ostream &operator<<(std::ostream &os, const VarLenField &id) {
+    os << "dec: " << id.getValue() << ", hex: " << std::hex << std::setw(id.getWidth())
+       << std::setfill('0') << id.getValue() << std::dec << std::setfill('0');
+    return os;
+  }
+#endif
+ private:
+  using SerializeIF::deSerialize;  // we overloaded above, so this is needed to uncofuse the
+                                   // compiler
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override;
+
+  cfdp::WidthInBytes width;
+  LengthFieldLen value{};
+};
+
+template <typename T>
+cfdp::VarLenField::VarLenField(UnsignedByteField<T> byteField)
+    : width(static_cast<cfdp::WidthInBytes>(sizeof(T))) {
+  static_assert((sizeof(T) % 2) == 0);
+  setValueAndWidth(width, byteField.getValue());
+}
+
+struct EntityId : public VarLenField {
+ public:
+  EntityId() : VarLenField() {}
+  template <typename T>
+  explicit EntityId(UnsignedByteField<T> byteField) : VarLenField(byteField) {}
+  EntityId(cfdp::WidthInBytes width, size_t entityId) : VarLenField(width, entityId) {}
+
+  ReturnValue_t serializeAsLv(uint8_t **buffer, size_t *size, size_t maxSize) const {
+    if (buffer == nullptr or size == nullptr) {
+      return returnvalue::FAILED;
+    }
+    if (*size + 1 + getWidth() > maxSize) {
+      return SerializeIF::BUFFER_TOO_SHORT;
+    }
+    **buffer = getWidth();
+    *buffer += 1;
+    *size += 1;
+    return serialize(buffer, size, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+  ReturnValue_t deSerializeFromLv(const uint8_t **buffer, size_t *deserLen) {
+    if (buffer == nullptr or deserLen == nullptr) {
+      return returnvalue::FAILED;
+    }
+    if (*deserLen < 2) {
+      return SerializeIF::STREAM_TOO_SHORT;
+    }
+    auto width = static_cast<WidthInBytes>(**buffer);
+    *buffer += 1;
+    *deserLen -= 1;
+    return VarLenField::deSerialize(width, buffer, deserLen, SerializeIF::Endianness::NETWORK);
+  }
+};
+
+struct TransactionSeqNum : public VarLenField {
+ public:
+  TransactionSeqNum() : VarLenField() {}
+  template <typename T>
+  explicit TransactionSeqNum(UnsignedByteField<T> byteField) : VarLenField(byteField) {}
+  TransactionSeqNum(cfdp::WidthInBytes width, size_t seqNum) : VarLenField(width, seqNum) {}
+};
+
+struct TransactionId {
+  TransactionId() = default;
+  TransactionId(EntityId entityId, TransactionSeqNum seqNum)
+      : entityId(std::move(entityId)), seqNum(std::move(seqNum)) {}
+
+  bool operator==(const TransactionId &other) const {
+    return entityId == other.entityId and seqNum == other.seqNum;
+  }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  friend std::ostream &operator<<(std::ostream &os, const TransactionId &id) {
+    os << "Source ID { " << id.entityId << " }, Sequence Number " << id.seqNum.getValue();
+    return os;
+  }
+#endif
+  EntityId entityId;
+  TransactionSeqNum seqNum;
+};
+
+}  // namespace cfdp
+
+#endif /* FSFW_CFDP_PDU_VARLENFIELD_H_ */
--- a/src/fsfw/cfdp/definitions.h
+++ b/src/fsfw/cfdp/definitions.h
@ -11,12 +11,16 @@

 namespace cfdp {

-static constexpr uint8_t VERSION_BITS = 0b00100000;
+static constexpr char CFDP_VERSION_2_NAME[] = "CCSDS 727.0-B-5";

-static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP;
+// Second version of the protocol, only this one is supported here
+static constexpr uint8_t CFDP_VERSION_2 = 0b001;
+static constexpr uint8_t VERSION_BITS = CFDP_VERSION_2 << 5;
+
+static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP_BASE;

 static constexpr ReturnValue_t INVALID_TLV_TYPE = returnvalue::makeCode(CFDP_CLASS_ID, 1);
-static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = returnvalue::makeCode(CFDP_CLASS_ID, 2);
+static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELD = returnvalue::makeCode(CFDP_CLASS_ID, 2);
 static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN = returnvalue::makeCode(CFDP_CLASS_ID, 3);
 static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS =
    returnvalue::makeCode(CFDP_CLASS_ID, 4);
@ -26,13 +30,14 @@ static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS =
    returnvalue::makeCode(CFDP_CLASS_ID, 5);
 static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS = returnvalue::makeCode(CFDP_CLASS_ID, 6);
 static constexpr ReturnValue_t FINISHED_CANT_PARSE_FS_RESPONSES =
-    returnvalue::makeCode(CFDP_CLASS_ID, 6);
+    returnvalue::makeCode(CFDP_CLASS_ID, 7);
 static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE =
    returnvalue::makeCode(CFDP_CLASS_ID, 8);
 //! Can not parse filestore response because user did not pass a valid instance
 //! or remaining size is invalid
 static constexpr ReturnValue_t FILESTORE_RESPONSE_CANT_PARSE_FS_MESSAGE =
    returnvalue::makeCode(CFDP_CLASS_ID, 9);
+static constexpr ReturnValue_t INVALID_PDU_FORMAT = returnvalue::makeCode(CFDP_CLASS_ID, 10);

 //! Checksum types according to the SANA Checksum Types registry
 //! https://sanaregistry.org/r/checksum_identifiers/
@ -45,17 +50,17 @@ enum ChecksumType {
  NULL_CHECKSUM = 15
 };

-enum PduType : bool { FILE_DIRECTIVE = 0, FILE_DATA = 1 };
+enum PduType : uint8_t { FILE_DIRECTIVE = 0, FILE_DATA = 1 };

-enum TransmissionModes : bool { ACKNOWLEDGED = 0, UNACKNOWLEDGED = 1 };
+enum TransmissionMode : uint8_t { ACKNOWLEDGED = 0, UNACKNOWLEDGED = 1 };

-enum SegmentMetadataFlag : bool { NOT_PRESENT = 0, PRESENT = 1 };
+enum SegmentMetadataFlag : bool { NOT_PRESENT = false, PRESENT = true };

-enum Direction : bool { TOWARDS_RECEIVER = 0, TOWARDS_SENDER = 1 };
+enum Direction : uint8_t { TOWARDS_RECEIVER = 0, TOWARDS_SENDER = 1 };

 enum SegmentationControl : bool {
-  NO_RECORD_BOUNDARIES_PRESERVATION = 0,
-  RECORD_BOUNDARIES_PRESERVATION = 1
+  NO_RECORD_BOUNDARIES_PRESERVATION = false,
+  RECORD_BOUNDARIES_PRESERVATION = true
 };

 enum WidthInBytes : uint8_t {
@ -63,10 +68,12 @@ enum WidthInBytes : uint8_t {
  ONE_BYTE = 1,
  TWO_BYTES = 2,
  FOUR_BYTES = 4,
+  EIGHT_BYTES = 8
 };

-enum FileDirectives : uint8_t {
+enum FileDirective : uint8_t {
  INVALID_DIRECTIVE = 0x0f,
+  // The _DIRECTIVE suffix is mandatory here because of some nameclash!
  EOF_DIRECTIVE = 0x04,
  FINISH = 0x05,
  ACK = 0x06,
@ -93,6 +100,14 @@ enum ConditionCode : uint8_t {
  CANCEL_REQUEST_RECEIVED = 0b1111
 };

+enum FaultHandlerCode {
+  RESERVED = 0b0000,
+  NOTICE_OF_CANCELLATION = 0b0001,
+  NOTICE_OF_SUSPENSION = 0b0010,
+  IGNORE_ERROR = 0b0011,
+  ABANDON_TRANSACTION = 0b0100
+};
+
 enum AckTransactionStatus {
  UNDEFINED = 0b00,
  ACTIVE = 0b01,
@ -100,18 +115,18 @@ enum AckTransactionStatus {
  UNRECOGNIZED = 0b11
 };

-enum FinishedDeliveryCode { DATA_COMPLETE = 0, DATA_INCOMPLETE = 1 };
+enum FileDeliveryCode { DATA_COMPLETE = 0, DATA_INCOMPLETE = 1 };

-enum FinishedFileStatus {
+enum FileDeliveryStatus {
  DISCARDED_DELIBERATELY = 0,
  DISCARDED_FILESTORE_REJECTION = 1,
  RETAINED_IN_FILESTORE = 2,
  FILE_STATUS_UNREPORTED = 3
 };

-enum PromptResponseRequired : bool { PROMPT_NAK = 0, PROMPT_KEEP_ALIVE = 1 };
+enum PromptResponseRequired : uint8_t { PROMPT_NAK = 0, PROMPT_KEEP_ALIVE = 1 };

-enum TlvTypes : uint8_t {
+enum TlvType : uint8_t {
  FILESTORE_REQUEST = 0x00,
  FILESTORE_RESPONSE = 0x01,
  MSG_TO_USER = 0x02,
@ -128,6 +143,20 @@ enum RecordContinuationState {
  CONTAINS_START_AND_END = 0b11
 };

+enum class ProxyOpMessageType : uint8_t {
+  PUT_REQUEST = 0x00,
+  MSG_TO_USR = 0x01,
+  FS_REQUEST = 0x02,
+  FAULT_HANDLER_OVERRIDE = 0x03,
+  TRANSMISSION_MODE = 0x04,
+  FLOW_LABEL = 0x05,
+  SEG_CTRL = 0x06,
+  PUT_RESPONSE = 0x07,
+  FS_RESPONSE = 0x08,
+  PUT_CANCEL = 0x09,
+  CLOSURE = 0x0b
+};
+
 }  // namespace cfdp

 #endif /* FSFW_SRC_FSFW_CFDP_PDU_DEFINITIONS_H_ */
--- a/src/fsfw/cfdp/handler/CMakeLists.txt
+++ b/src/fsfw/cfdp/handler/CMakeLists.txt
@ -0,0 +1,4 @@
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE SourceHandler.cpp DestHandler.cpp PutRequest.cpp
+          ReservedMessageParser.cpp FaultHandlerBase.cpp UserBase.cpp)
--- a/src/fsfw/cfdp/handler/DestHandler.cpp
+++ b/src/fsfw/cfdp/handler/DestHandler.cpp
@ -0,0 +1,574 @@
+#include "DestHandler.h"
+
+#include <etl/crc32.h>
+
+#include <utility>
+
+#include "fsfw/FSFW.h"
+#include "fsfw/cfdp/pdu/EofPduReader.h"
+#include "fsfw/cfdp/pdu/FileDataReader.h"
+#include "fsfw/cfdp/pdu/FinishedPduCreator.h"
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"
+#include "fsfw/objectmanager.h"
+#include "fsfw/tmtcservices/TmTcMessage.h"
+
+using namespace returnvalue;
+
+cfdp::DestHandler::DestHandler(DestHandlerParams params, FsfwParams fsfwParams)
+    : tlvVec(params.maxTlvsInOnePdu),
+      msgToUserVec(params.maxTlvsInOnePdu),
+      transactionParams(params.maxFilenameLen),
+      destParams(std::move(params)),
+      fsfwParams(fsfwParams) {
+  transactionParams.pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+}
+
+const cfdp::DestHandler::FsmResult& cfdp::DestHandler::stateMachine() {
+  ReturnValue_t result;
+  uint8_t errorIdx = 0;
+  fsmRes.resetOfIteration();
+  if (fsmRes.step == TransactionStep::IDLE) {
+    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
+        destParams.packetListRef.erase(infoIter++);
+      } else {
+        infoIter++;
+      }
+    }
+    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 = destParams.packetListRef.begin();
+           infoIter != destParams.packetListRef.end();) {
+        fsfwParams.tcStore->deleteData(infoIter->storeId);
+        infoIter++;
+      }
+      destParams.packetListRef.clear();
+    }
+
+    if (fsmRes.step != TransactionStep::IDLE) {
+      fsmRes.callStatus = CallStatus::CALL_AGAIN;
+    }
+    return updateFsmRes(errorIdx);
+  }
+  if (fsmRes.state == CfdpState::BUSY_CLASS_1_NACKED) {
+    if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) {
+      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
+          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
+          destParams.packetListRef.erase(infoIter++);
+        } else {
+          infoIter++;
+        }
+      }
+    }
+    if (fsmRes.step == TransactionStep::TRANSFER_COMPLETION) {
+      result = handleTransferCompletion();
+      checkAndHandleError(result, errorIdx);
+    }
+    if (fsmRes.step == TransactionStep::SENDING_FINISHED_PDU) {
+      result = sendFinishedPdu();
+      checkAndHandleError(result, errorIdx);
+      finish();
+    }
+    return updateFsmRes(errorIdx);
+  }
+  if (fsmRes.state == CfdpState::BUSY_CLASS_2_ACKED) {
+    // TODO: Will be implemented at a later stage
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "CFDP state machine for acknowledged mode not implemented yet" << std::endl;
+#endif
+  }
+  return updateFsmRes(errorIdx);
+}
+
+ReturnValue_t cfdp::DestHandler::passPacket(PacketInfo packet) {
+  if (destParams.packetListRef.full()) {
+    return FAILED;
+  }
+  destParams.packetListRef.push_back(packet);
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::initialize() {
+  if (fsfwParams.tmStore == nullptr) {
+    fsfwParams.tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+    if (fsfwParams.tmStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fsfwParams.tcStore == nullptr) {
+    fsfwParams.tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
+    if (fsfwParams.tcStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fsfwParams.msgQueue == nullptr) {
+    return FAILED;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::handleMetadataPdu(const PacketInfo& info) {
+  // Process metadata PDU
+  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;
+  MetadataGenericInfo metadataInfo(transactionParams.fileSize);
+  MetadataPduReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(),
+                           metadataInfo, tlvVec.data(), tlvVec.size());
+  ReturnValue_t result = reader.parseData();
+  // TODO: The standard does not really specify what happens if this kind of error happens
+  //       I think it might be a good idea to cache some sort of error code, which
+  //       is translated into a warning and/or event by an upper layer
+  if (result != OK) {
+    return handleMetadataParseError(result, constAccessorPair.second.data(),
+                                    constAccessorPair.second.size());
+  }
+  return startTransaction(reader);
+}
+
+ReturnValue_t cfdp::DestHandler::handleFileDataPdu(const cfdp::PacketInfo& info) {
+  // Process file data PDU
+  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;
+  }
+  FileDataInfo fdInfo;
+  FileDataReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(), fdInfo);
+  ReturnValue_t result = reader.parseData();
+  if (result != OK) {
+    return result;
+  }
+  size_t fileSegmentLen = 0;
+  const uint8_t* fileData = fdInfo.getFileData(&fileSegmentLen);
+  FileOpParams fileOpParams(transactionParams.destName.data(), fileSegmentLen);
+  fileOpParams.offset = fdInfo.getOffset().value();
+  if (destParams.cfg.indicCfg.fileSegmentRecvIndicRequired) {
+    FileSegmentRecvdParams segParams;
+    segParams.offset = fdInfo.getOffset().value();
+    segParams.id = transactionParams.transactionId;
+    segParams.length = fileSegmentLen;
+    segParams.recContState = fdInfo.getRecordContinuationState();
+    size_t segmentMetadatLen = 0;
+    auto* segMetadata = fdInfo.getSegmentMetadata(&segmentMetadatLen);
+    segParams.segmentMetadata = {segMetadata, segmentMetadatLen};
+    destParams.user.fileSegmentRecvdIndication(segParams);
+  }
+  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
+    transactionParams.vfsErrorCount++;
+    if (transactionParams.vfsErrorCount < 3) {
+      // TODO: Provide execution step as parameter
+      fsfwParams.eventReporter->forwardEvent(events::FILESTORE_ERROR,
+                                             static_cast<uint8_t>(fsmRes.step), result);
+    }
+    return result;
+  } else {
+    transactionParams.deliveryStatus = FileDeliveryStatus::RETAINED_IN_FILESTORE;
+    transactionParams.vfsErrorCount = 0;
+  }
+  if (fdInfo.getOffset().value() + fileSegmentLen > transactionParams.progress) {
+    transactionParams.progress = fdInfo.getOffset().value() + fileSegmentLen;
+  }
+  return result;
+}
+
+ReturnValue_t cfdp::DestHandler::handleEofPdu(const cfdp::PacketInfo& info) {
+  // Process EOF PDU
+  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;
+  }
+  EofInfo eofInfo(nullptr);
+  EofPduReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(), eofInfo);
+  ReturnValue_t result = reader.parseData();
+  if (result != OK) {
+    return result;
+  }
+  // TODO: Error handling
+  if (eofInfo.getConditionCode() == ConditionCode::NO_ERROR) {
+    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 > transactionParams.progress) {
+      // TODO: File size error
+    }
+    transactionParams.fileSize.setFileSize(fileSizeFromEof, std::nullopt);
+  }
+  if (destParams.cfg.indicCfg.eofRecvIndicRequired) {
+    destParams.user.eofRecvIndication(getTransactionId());
+  }
+  if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) {
+    if (fsmRes.state == CfdpState::BUSY_CLASS_1_NACKED) {
+      fsmRes.step = TransactionStep::TRANSFER_COMPLETION;
+    } else if (fsmRes.state == CfdpState::BUSY_CLASS_2_ACKED) {
+      fsmRes.step = TransactionStep::SENDING_ACK_PDU;
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t cfdp::DestHandler::handleMetadataParseError(ReturnValue_t result,
+                                                          const uint8_t* rawData, size_t maxSize) {
+  // TODO: try to extract destination ID for error
+  // TODO: Invalid metadata PDU.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Parsing Metadata PDU failed with code " << result << std::endl;
+#else
+#endif
+  PduHeaderReader headerReader(rawData, maxSize);
+  result = headerReader.parseData();
+  if (result != OK) {
+    // TODO: Now this really should not happen. Warning or error,
+    //       yield or cache appropriate returnvalue
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "Parsing Header failed" << std::endl;
+#else
+#endif
+    // TODO: Trigger appropriate event
+    return result;
+  }
+  cfdp::EntityId destId;
+  headerReader.getDestId(destId);
+  RemoteEntityCfg* 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
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "No remote config exists for destination ID" << std::endl;
+#else
+#endif
+    // TODO: Trigger appropriate event
+  }
+  // TODO: Appropriate returnvalue?
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t cfdp::DestHandler::startTransaction(const MetadataPduReader& reader) {
+  if (fsmRes.state != CfdpState::IDLE) {
+    // According to standard, discard metadata PDU if we are busy
+    return OK;
+  }
+  ReturnValue_t result = OK;
+  size_t sourceNameSize = 0;
+
+  if (not reader.getSourceFileName().isEmpty()) {
+    const uint8_t* sourceNamePtr = reader.getSourceFileName().getValue(&sourceNameSize);
+    if (sourceNameSize + 1 > transactionParams.sourceName.size()) {
+      fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "source filename too large");
+      return FAILED;
+    }
+    std::memcpy(transactionParams.sourceName.data(), sourceNamePtr, sourceNameSize);
+    transactionParams.sourceName[sourceNameSize] = '\0';
+  }
+  size_t destNameSize = 0;
+  if (not reader.getDestFileName().isEmpty()) {
+    const uint8_t* destNamePtr = reader.getDestFileName().getValue(&destNameSize);
+    if (destNameSize + 1 > transactionParams.destName.size()) {
+      fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0, "dest filename too large");
+      return FAILED;
+    }
+    std::memcpy(transactionParams.destName.data(), destNamePtr, destNameSize);
+    transactionParams.destName[destNameSize] = '\0';
+  }
+
+  transactionParams.metadataOnly = true;
+  // 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) {
+    transactionParams.metadataOnly = false;
+    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 (destParams.user.vfs.isDirectory(transactionParams.destName.data())) {
+      result = tryBuildingAbsoluteDestName(destNameSize);
+      if (result != OK) {
+        return result;
+      }
+    }
+    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 = destParams.user.vfs.createFile(fparams);
+      if (result != OK) {
+        fileErrorHandler(events::FILESTORE_ERROR, result, "file creation error");
+        return FAILED;
+        // TODO: Relevant for filestore rejection error?
+      }
+    }
+  }
+  EntityId sourceId;
+  reader.getSourceId(sourceId);
+  if (not destParams.remoteCfgTable.getRemoteCfg(sourceId, &transactionParams.remoteCfg)) {
+    // TODO: Warning, event etc.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler" << __func__
+                 << ": No remote configuration found for destination ID "
+                 << transactionParams.pduConf.sourceId.getValue() << std::endl;
+#endif
+    return FAILED;
+  }
+  if (reader.getTransmissionMode() == TransmissionMode::UNACKNOWLEDGED) {
+    fsmRes.state = CfdpState::BUSY_CLASS_1_NACKED;
+  } else if (reader.getTransmissionMode() == TransmissionMode::ACKNOWLEDGED) {
+    fsmRes.state = CfdpState::BUSY_CLASS_2_ACKED;
+  }
+  if (transactionParams.metadataOnly) {
+    fsmRes.step = TransactionStep::TRANSFER_COMPLETION;
+  } else {
+    // Kind of ugly, make FSM working on packet per packet basis..
+    fsmRes.step = TransactionStep::TRANSACTION_START;
+    fsmRes.step = TransactionStep::RECEIVING_FILE_DATA_PDUS;
+  }
+  auto& info = reader.getGenericInfo();
+  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;
+  transactionParams.fileSize = info.getFileSize();
+  MetadataRecvdParams params(transactionParams.transactionId, transactionParams.pduConf.sourceId,
+                             transactionParams.fileSize);
+  params.destFileName = transactionParams.destName.data();
+  params.sourceFileName = transactionParams.sourceName.data();
+  params.numberOfMsgsToUser = 0;
+  for (const auto& opt : tlvVec) {
+    if (opt.getType() == TlvType::MSG_TO_USER) {
+      msgToUserVec[params.numberOfMsgsToUser] =
+          MessageToUserTlv(opt.getValue(), opt.getLengthField());
+      params.numberOfMsgsToUser++;
+    }
+  }
+  params.msgsToUserArray = msgToUserVec.data();
+  destParams.user.metadataRecvdIndication(params);
+  return result;
+}
+
+cfdp::CfdpState cfdp::DestHandler::getCfdpState() const { return fsmRes.state; }
+
+ReturnValue_t cfdp::DestHandler::handleTransferCompletion() {
+  ReturnValue_t result;
+  if (transactionParams.checksumType != ChecksumType::NULL_CHECKSUM) {
+    result = checksumVerification();
+    if (result != OK) {
+      // TODO: Warning / error handling?
+    }
+  } else {
+    transactionParams.conditionCode = ConditionCode::NO_ERROR;
+  }
+  result = noticeOfCompletion();
+  if (result != OK) {
+  }
+  if (fsmRes.state == CfdpState::BUSY_CLASS_1_NACKED) {
+    if (transactionParams.closureRequested) {
+      fsmRes.step = TransactionStep::SENDING_FINISHED_PDU;
+    } else {
+      finish();
+    }
+  } else if (fsmRes.state == CfdpState::BUSY_CLASS_2_ACKED) {
+    fsmRes.step = TransactionStep::SENDING_FINISHED_PDU;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::tryBuildingAbsoluteDestName(size_t destNameSize) {
+  // 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 = 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 > transactionParams.destName.size()) {
+    fileErrorHandler(events::FILENAME_TOO_LARGE_ERROR, 0,
+                     "dest filename too large after adding source base name");
+    return FAILED;
+  }
+  transactionParams.destName[destNameSize++] = '/';
+  std::memcpy(transactionParams.destName.data() + destNameSize, baseNameBuf, baseNameLen);
+  destNameSize += baseNameLen;
+  transactionParams.destName[destNameSize++] = '\0';
+  return OK;
+}
+
+void cfdp::DestHandler::fileErrorHandler(Event event, ReturnValue_t result,
+                                         const char* info) const {
+  fsfwParams.eventReporter->forwardEvent(event, static_cast<uint8_t>(fsmRes.step), result);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "cfdp::DestHandler: " << info << std::endl;
+#endif
+}
+
+void cfdp::DestHandler::finish() {
+  transactionParams.reset();
+  destParams.packetListRef.clear();
+  fsmRes.state = CfdpState::IDLE;
+  fsmRes.step = TransactionStep::IDLE;
+}
+
+ReturnValue_t cfdp::DestHandler::checksumVerification() {
+  std::array<uint8_t, 1024> buf{};
+  etl::crc32 crcCalc;
+  uint64_t currentOffset = 0;
+  FileOpParams params(transactionParams.destName.data(), transactionParams.fileSize.value());
+  while (currentOffset < transactionParams.fileSize.value()) {
+    uint64_t readLen;
+    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 = 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
+        return FAILED;
+      }
+      crcCalc.add(buf.begin(), buf.begin() + readLen);
+    }
+    currentOffset += readLen;
+  }
+
+  uint32_t value = crcCalc.value();
+  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 " << transactionParams.destName.data() << " failed"
+                 << std::endl;
+#endif
+    transactionParams.conditionCode = ConditionCode::FILE_CHECKSUM_FAILURE;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::noticeOfCompletion() {
+  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(transactionParams.conditionCode, transactionParams.deliveryCode,
+                    transactionParams.deliveryStatus);
+  FinishPduCreator finishedPdu(transactionParams.pduConf, info);
+  store_address_t storeId;
+  uint8_t* dataPtr = nullptr;
+  ReturnValue_t result =
+      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
+    fsfwParams.eventReporter->forwardEvent(events::STORE_ERROR, result, 0);
+    return result;
+  }
+  size_t serLen = 0;
+  result = finishedPdu.serialize(dataPtr, serLen, finishedPdu.getSerializedSize());
+  if (result != OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler::sendFinishedPdu: Serializing Finished PDU failed"
+                 << std::endl;
+#endif
+    fsfwParams.eventReporter->forwardEvent(events::SERIALIZATION_ERROR, result, 0);
+    return result;
+  }
+  TmTcMessage msg(storeId);
+  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
+    fsfwParams.eventReporter->forwardEvent(events::MSG_QUEUE_ERROR, result, 0);
+    return result;
+  }
+  fsmRes.packetsSent++;
+  return OK;
+}
+
+cfdp::DestHandler::TransactionStep cfdp::DestHandler::getTransactionStep() const {
+  return fsmRes.step;
+}
+
+const cfdp::DestHandler::FsmResult& cfdp::DestHandler::updateFsmRes(uint8_t errors) {
+  fsmRes.errors = errors;
+  fsmRes.result = OK;
+  if (fsmRes.errors > 0) {
+    fsmRes.result = FAILED;
+  }
+  return fsmRes;
+}
+
+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) {
+    fsmRes.errorCodes[errorIdx] = result;
+    errorIdx++;
+  }
+}
+
+void cfdp::DestHandler::setMsgQueue(MessageQueueIF& queue) { fsfwParams.msgQueue = &queue; }
+
+void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) {
+  fsfwParams.eventReporter = &reporter;
+}
+
+const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const {
+  return destParams;
+}
+
+StorageManagerIF* cfdp::DestHandler::getTmStore() const { return fsfwParams.tmStore; }
+StorageManagerIF* cfdp::DestHandler::getTcStore() const { return fsfwParams.tcStore; }
--- a/src/fsfw/cfdp/handler/DestHandler.h
+++ b/src/fsfw/cfdp/handler/DestHandler.h
@ -0,0 +1,178 @@
+#ifndef FSFW_CFDP_CFDPDESTHANDLER_H
+#define FSFW_CFDP_CFDPDESTHANDLER_H
+
+#include <etl/list.h>
+#include <etl/set.h>
+
+#include <array>
+#include <optional>
+#include <utility>
+
+#include "RemoteConfigTableIF.h"
+#include "UserBase.h"
+#include "defs.h"
+#include "fsfw/cfdp/handler/mib.h"
+#include "fsfw/cfdp/pdu/MetadataPduReader.h"
+#include "fsfw/cfdp/pdu/PduConfig.h"
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+#include "fsfw/container/DynamicFIFO.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/storagemanager/storeAddress.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+
+namespace cfdp {
+
+template <size_t SIZE>
+using LostSegmentsList = etl::set<etl::pair<uint64_t, uint64_t>, SIZE>;
+using LostSegmentsListBase = etl::iset<etl::pair<uint64_t, uint64_t>>;
+
+struct DestHandlerParams {
+  DestHandlerParams(LocalEntityCfg cfg, UserBase& user, RemoteConfigTableIF& remoteCfgTable,
+                    PacketInfoListBase& packetList,
+                    // TODO: This container can potentially take tons of space. For a better
+                    //       memory efficient implementation, an additional abstraction could be
+                    //       be used so users can use uint32_t as the pair type
+                    // TODO: Actually, we can provide a better abstraction via interface, which
+                    //       allows using something like a bounded map. This simplifies
+                    //       the implementation significantly.
+                    LostSegmentsListBase& lostSegmentsContainer)
+      : cfg(std::move(cfg)),
+        user(user),
+        remoteCfgTable(remoteCfgTable),
+        packetListRef(packetList),
+        lostSegmentsContainer(lostSegmentsContainer) {}
+
+  LocalEntityCfg cfg;
+  UserBase& user;
+  RemoteConfigTableIF& remoteCfgTable;
+
+  PacketInfoListBase& packetListRef;
+  LostSegmentsListBase& lostSegmentsContainer;
+  uint8_t maxTlvsInOnePdu = 20;
+  size_t maxFilenameLen = 255;
+};
+
+class DestHandler {
+ public:
+  enum class TransactionStep : uint8_t {
+    IDLE = 0,
+    TRANSACTION_START = 1,
+    RECEIVING_FILE_DATA_PDUS = 2,
+    SENDING_ACK_PDU = 3,
+    TRANSFER_COMPLETION = 4,
+    SENDING_FINISHED_PDU = 5
+  };
+
+  struct FsmResult {
+   public:
+    ReturnValue_t result = returnvalue::OK;
+    CallStatus callStatus = CallStatus::CALL_AFTER_DELAY;
+    TransactionStep step = TransactionStep::IDLE;
+    CfdpState state = CfdpState::IDLE;
+    uint32_t packetsSent = 0;
+    uint8_t errors = 0;
+    std::array<ReturnValue_t, 3> errorCodes = {};
+    void resetOfIteration() {
+      result = returnvalue::OK;
+      callStatus = CallStatus::CALL_AFTER_DELAY;
+      packetsSent = 0;
+      errors = 0;
+      errorCodes.fill(returnvalue::OK);
+    }
+  };
+  /**
+   * Will be returned if it is advisable to call the state machine operation call again
+   */
+  ReturnValue_t PARTIAL_SUCCESS = returnvalue::makeCode(0, 2);
+  ReturnValue_t FAILURE = returnvalue::makeCode(0, 3);
+  explicit DestHandler(DestHandlerParams handlerParams, FsfwParams fsfwParams);
+
+  /**
+   *
+   * @return
+   *  - @c returnvalue::OK  State machine OK for this execution cycle
+   *  - @c CALL_FSM_AGAIN   State machine should be called again.
+   */
+  const FsmResult& stateMachine();
+  void setMsgQueue(MessageQueueIF& queue);
+  void setEventReporter(EventReportingProxyIF& reporter);
+
+  ReturnValue_t passPacket(PacketInfo packet);
+
+  ReturnValue_t initialize();
+
+  [[nodiscard]] CfdpState getCfdpState() const;
+  [[nodiscard]] TransactionStep getTransactionStep() const;
+  [[nodiscard]] const TransactionId& getTransactionId() const;
+  [[nodiscard]] const DestHandlerParams& getDestHandlerParams() const;
+  [[nodiscard]] StorageManagerIF* getTcStore() const;
+  [[nodiscard]] StorageManagerIF* getTmStore() const;
+
+ private:
+  struct TransactionParams {
+    // Initialize char vectors with length + 1 for 0 termination
+    explicit TransactionParams(size_t maxFileNameLen)
+        : sourceName(maxFileNameLen + 1), destName(maxFileNameLen + 1) {}
+
+    void reset() {
+      pduConf = PduConfig();
+      transactionId = TransactionId();
+      std::fill(sourceName.begin(), sourceName.end(), '\0');
+      std::fill(destName.begin(), destName.end(), '\0');
+      fileSize.setFileSize(0, false);
+      conditionCode = ConditionCode::NO_ERROR;
+      deliveryCode = FileDeliveryCode::DATA_INCOMPLETE;
+      deliveryStatus = FileDeliveryStatus::DISCARDED_DELIBERATELY;
+      crc = 0;
+      progress = 0;
+      remoteCfg = nullptr;
+      metadataOnly = false;
+      closureRequested = false;
+      vfsErrorCount = 0;
+      checksumType = ChecksumType::NULL_CHECKSUM;
+    }
+
+    bool metadataOnly = false;
+    ChecksumType checksumType = ChecksumType::NULL_CHECKSUM;
+    bool closureRequested = false;
+    uint16_t vfsErrorCount = 0;
+    std::vector<char> sourceName;
+    std::vector<char> destName;
+    cfdp::Fss fileSize;
+    TransactionId transactionId;
+    PduConfig pduConf;
+    ConditionCode conditionCode = ConditionCode::NO_ERROR;
+    FileDeliveryCode deliveryCode = FileDeliveryCode::DATA_INCOMPLETE;
+    FileDeliveryStatus deliveryStatus = FileDeliveryStatus::DISCARDED_DELIBERATELY;
+    uint32_t crc = 0;
+    uint64_t progress = 0;
+    RemoteEntityCfg* remoteCfg = nullptr;
+  };
+
+  std::vector<cfdp::Tlv> tlvVec;
+  std::vector<MessageToUserTlv> msgToUserVec;
+  TransactionParams transactionParams;
+  DestHandlerParams destParams;
+  cfdp::FsfwParams fsfwParams;
+  FsmResult fsmRes;
+
+  ReturnValue_t startTransaction(const MetadataPduReader& reader);
+  ReturnValue_t handleMetadataPdu(const PacketInfo& info);
+  ReturnValue_t handleFileDataPdu(const PacketInfo& info);
+  ReturnValue_t handleEofPdu(const PacketInfo& info);
+  ReturnValue_t handleMetadataParseError(ReturnValue_t result, const uint8_t* rawData,
+                                         size_t maxSize);
+  ReturnValue_t handleTransferCompletion();
+  ReturnValue_t tryBuildingAbsoluteDestName(size_t destNameSize);
+  ReturnValue_t sendFinishedPdu();
+  ReturnValue_t noticeOfCompletion();
+  ReturnValue_t checksumVerification();
+  void fileErrorHandler(Event event, ReturnValue_t result, const char* info) const;
+  const FsmResult& updateFsmRes(uint8_t errors);
+  void checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx);
+  void finish();
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_CFDPDESTHANDLER_H
--- a/src/fsfw/cfdp/handler/FaultHandlerBase.cpp
+++ b/src/fsfw/cfdp/handler/FaultHandlerBase.cpp
@ -0,0 +1,51 @@
+#include "FaultHandlerBase.h"
+
+namespace cfdp {
+
+FaultHandlerBase::FaultHandlerBase() = default;
+FaultHandlerBase::~FaultHandlerBase() = default;
+
+bool FaultHandlerBase::getFaultHandler(cfdp::ConditionCode code,
+                                       cfdp::FaultHandlerCode& handler) const {
+  auto iter = faultHandlerMap.find(code);
+  if (iter == faultHandlerMap.end()) {
+    return false;
+  }
+  handler = iter->second;
+  return true;
+}
+
+bool FaultHandlerBase::setFaultHandler(cfdp::ConditionCode code, cfdp::FaultHandlerCode handler) {
+  if (not faultHandlerMap.contains(code)) {
+    return false;
+  }
+  if (handler != FaultHandlerCode::NOTICE_OF_SUSPENSION and
+      handler != FaultHandlerCode::ABANDON_TRANSACTION and
+      handler != FaultHandlerCode::NOTICE_OF_CANCELLATION and
+      handler != FaultHandlerCode::IGNORE_ERROR) {
+    return false;
+  }
+  faultHandlerMap[code] = handler;
+  return true;
+}
+
+bool FaultHandlerBase::reportFault(cfdp::TransactionId& id, cfdp::ConditionCode code) {
+  if (not faultHandlerMap.contains(code)) {
+    return false;
+  }
+  cfdp::FaultHandlerCode fh = faultHandlerMap[code];
+  if (fh == cfdp::FaultHandlerCode::IGNORE_ERROR) {
+    ignoreCb(id, code);
+  } else if (fh == cfdp::FaultHandlerCode::ABANDON_TRANSACTION) {
+    abandonCb(id, code);
+  } else if (fh == cfdp::FaultHandlerCode::NOTICE_OF_CANCELLATION) {
+    noticeOfCancellationCb(id, code);
+  } else if (fh == cfdp::FaultHandlerCode::NOTICE_OF_SUSPENSION) {
+    noticeOfSuspensionCb(id, code);
+  } else {
+    // Should never happen, but use defensive programming
+    return false;
+  }
+  return true;
+}
+}  // namespace cfdp
--- a/src/fsfw/cfdp/handler/FaultHandlerBase.h
+++ b/src/fsfw/cfdp/handler/FaultHandlerBase.h
@ -0,0 +1,77 @@
+#ifndef FSFW_CFDP_FAULTHANDLERBASE_H
+#define FSFW_CFDP_FAULTHANDLERBASE_H
+
+#include <etl/flat_map.h>
+
+#include "fsfw/cfdp/VarLenFields.h"
+#include "fsfw/cfdp/definitions.h"
+
+namespace cfdp {
+
+/**
+ * @brief Provides a way to implement the fault handling procedures as specified
+ * in chapter 4.8 of the CFDP standard.
+ *
+ * @details
+ * It is passed into the CFDP handlers as part of the local entity configuration and provides
+ * a way to specify custom user error handlers.
+ *
+ * It does so by mapping each applicable CFDP condition code to a fault handler which
+ * is denoted by the four @cfdp::FaultHandlerCodes. This code is used to dispatch
+ * to a user-provided callback function:
+ *
+ * 1. @FaultHandlerCodes::IGNORE_ERROR -> @ignore_cb
+ * 2. @FaultHandlerCodes::NOTICE_OF_CANCELLATION` -> @notice_of_cancellation_cb
+ * 3. @FaultHandlerCodes::NOTICE_OF_SUSPENSION` -> @notice_of_suspension_cb
+ * 4. @FaultHandlerCodes::ABANDON_TRANSACTION` -> @abandon_transaction_cb
+ *
+ * For each error reported by @reportError, the appropriate fault handler callback
+ * will be called. The user provides the callbacks by providing a custom class which implements
+ * these base class and all abstract fault handler callbacks.
+ */
+class FaultHandlerBase {
+ public:
+  virtual ~FaultHandlerBase();
+  FaultHandlerBase();
+
+  /**
+   * Get the fault handler code for the given condition code
+   * @param code
+   * @param handler [out] Will be set to the approrpiate handler for the condition code if
+   *    it is valid
+   * @return
+   *  - true if the condition code is valid
+   *  - false otherwise
+   */
+  bool getFaultHandler(cfdp::ConditionCode code, cfdp::FaultHandlerCode& handler) const;
+
+  bool setFaultHandler(cfdp::ConditionCode code, cfdp::FaultHandlerCode handler);
+
+  bool reportFault(cfdp::TransactionId& id, cfdp::ConditionCode code);
+
+  virtual void noticeOfSuspensionCb(cfdp::TransactionId& id, cfdp::ConditionCode code) = 0;
+  virtual void noticeOfCancellationCb(cfdp::TransactionId& id, cfdp::ConditionCode code) = 0;
+  virtual void abandonCb(cfdp::TransactionId& id, cfdp::ConditionCode code) = 0;
+  virtual void ignoreCb(cfdp::TransactionId& id, cfdp::ConditionCode code) = 0;
+
+ private:
+  etl::flat_map<cfdp::ConditionCode, cfdp::FaultHandlerCode, 10> faultHandlerMap = {
+      etl::pair{cfdp::ConditionCode::POSITIVE_ACK_LIMIT_REACHED,
+                cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::KEEP_ALIVE_LIMIT_REACHED,
+                cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::INVALID_TRANSMISSION_MODE,
+                cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::FILE_CHECKSUM_FAILURE, cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::FILE_SIZE_ERROR, cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::NAK_LIMIT_REACHED, cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::INACTIVITY_DETECTED, cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::UNSUPPORTED_CHECKSUM_TYPE,
+                cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::FILESTORE_REJECTION, cfdp::FaultHandlerCode::IGNORE_ERROR},
+      etl::pair{cfdp::ConditionCode::CHECK_LIMIT_REACHED, cfdp::FaultHandlerCode::IGNORE_ERROR}};
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_FAULTHANDLERBASE_H
--- a/src/fsfw/cfdp/handler/PutRequest.cpp
+++ b/src/fsfw/cfdp/handler/PutRequest.cpp
@ -0,0 +1,201 @@
+#include "PutRequest.h"
+
+using namespace returnvalue;
+
+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) {}
+
+cfdp::PutRequest::PutRequest(cfdp::EntityId destId, cfdp::StringLv &sourceName,
+                             cfdp::StringLv &destName)
+    : destId(std::move(destId)), sourceName(std::move(sourceName)), destName(std::move(destName)) {}
+
+[[nodiscard]] bool cfdp::PutRequest::isMetadataOnly() const { return metadataOnly; }
+
+ReturnValue_t cfdp::PutRequest::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                          SerializeIF::Endianness streamEndianness) const {
+  if (buffer == nullptr or size == nullptr) {
+    return FAILED;
+  }
+  if (*size + getSerializedSize() > maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  ReturnValue_t result = destId.serializeAsLv(buffer, size, maxSize);
+  if (result != OK) {
+    return result;
+  }
+  result = SerializeAdapter::serialize(&metadataOnly, buffer, size, maxSize, streamEndianness);
+  if (result != OK) {
+    return result;
+  }
+  if (!metadataOnly) {
+    result = sourceName.serialize(buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result = destName.serialize(buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result =
+        SerializeAdapter::serialize(&hasTransmissionMode, buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result =
+        SerializeAdapter::serialize(&transmissionMode, buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result =
+        SerializeAdapter::serialize(&hasClosureRequested, buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result =
+        SerializeAdapter::serialize(&closureRequested, buffer, size, maxSize, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+  }
+  result =
+      SerializeAdapter::serialize(&msgsToUsersTotalSize, buffer, size, maxSize, streamEndianness);
+  if (result != OK) {
+    return result;
+  }
+  std::memcpy(*buffer, msgsToUserStartPtr, msgsToUsersTotalSize);
+  *buffer += msgsToUsersTotalSize;
+  *size += msgsToUsersTotalSize;
+
+  result =
+      SerializeAdapter::serialize(&fsRequestsTotalSize, buffer, size, maxSize, streamEndianness);
+  if (result != OK) {
+    return result;
+  }
+  std::memcpy(*buffer, fsRequestStartPtr, fsRequestsTotalSize);
+  *buffer += fsRequestsTotalSize;
+  *size += fsRequestsTotalSize;
+  return OK;
+}
+
+ReturnValue_t cfdp::PutRequest::deSerialize(const uint8_t **buffer, size_t *size,
+                                            SerializeIF::Endianness streamEndianness) {
+  if (buffer == nullptr or size == nullptr) {
+    return FAILED;
+  }
+  ReturnValue_t result = destId.deSerializeFromLv(buffer, size);
+  if (result != OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&metadataOnly, buffer, size, streamEndianness);
+  if (result != OK) {
+    return result;
+  }
+  if (!metadataOnly) {
+    result = sourceName.deSerialize(buffer, size, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result = destName.deSerialize(buffer, size, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&hasTransmissionMode, buffer, size, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&transmissionMode, buffer, size, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&hasClosureRequested, buffer, size, streamEndianness);
+    if (result != OK) {
+      return result;
+    }
+    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;
+  return OK;
+}
+
+size_t cfdp::PutRequest::getSerializedSize() const {
+  // Entity ID LV (1 leading size byte) and the metadata only flag.
+  size_t baseSize = 1 + destId.getSerializedSize() + 1;
+  if (!metadataOnly) {
+    baseSize += sourceName.getSerializedSize() + destName.getSerializedSize() + 4;
+  }
+  baseSize += sizeof(msgsToUsersTotalSize) + msgsToUsersTotalSize + sizeof(fsRequestsTotalSize) +
+              fsRequestsTotalSize;
+  return baseSize;
+}
+
+void cfdp::PutRequest::setSourceAndDestName(cfdp::StringLv &sourceName_,
+                                            cfdp::StringLv &destName_) {
+  metadataOnly = false;
+  this->sourceName = std::move(sourceName_);
+  this->destName = std::move(destName_);
+}
+
+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); }
+
+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;
+}
+
+const uint8_t *cfdp::PutRequest::getMessagesToUser(size_t &totalSize) {
+  totalSize = this->msgsToUsersTotalSize;
+  return msgsToUserStartPtr;
+}
+
+bool cfdp::PutRequest::getClosureRequested(bool &closureRequested_) const {
+  if (hasClosureRequested) {
+    closureRequested_ = this->closureRequested;
+  }
+  return hasClosureRequested;
+}
+
+bool cfdp::PutRequest::getTransmissionMode(cfdp::TransmissionMode &mode) const {
+  if (hasTransmissionMode) {
+    mode = static_cast<cfdp::TransmissionMode>(this->transmissionMode);
+  }
+  return hasTransmissionMode;
+}
--- a/src/fsfw/cfdp/handler/PutRequest.h
+++ b/src/fsfw/cfdp/handler/PutRequest.h
@ -0,0 +1,82 @@
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include "fsfw/cfdp/VarLenFields.h"
+#include "fsfw/cfdp/tlv/FilestoreRequestTlv.h"
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+
+namespace cfdp {
+
+class PutRequest : public SerializeIF {
+ public:
+  /**
+   * Metadata only constructor.
+   * @param destId
+   * @param msgsToUser
+   * @param msgsToUserTotalSize
+   * @param fsRequests
+   * @param fsRequestsSize
+   */
+  PutRequest(EntityId destId, const uint8_t* msgsToUser, size_t msgsToUserTotalSize,
+             const uint8_t* fsRequests, size_t fsRequestsSize);
+  /**
+   * Put request to initiate file transfers. By default, the transmission mode and closure requested
+   * parameter are not present, thereby being derived from the remote configuration for a
+   * particular destination ID.
+   * @param destId
+   * @param sourceName
+   * @param destName
+   */
+  PutRequest(EntityId destId, cfdp::StringLv& sourceName, cfdp::StringLv& destName);
+
+  /**
+   * Default constructor for deserialization.
+   */
+  PutRequest() = default;
+
+  [[nodiscard]] ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                        Endianness streamEndianness) const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override;
+  [[nodiscard]] size_t getSerializedSize() const override;
+  void setSourceAndDestName(cfdp::StringLv& sourceName, cfdp::StringLv& destName);
+
+  [[nodiscard]] const cfdp::StringLv& getSourceName() const;
+  [[nodiscard]] const cfdp::StringLv& getDestName() const;
+
+  void setTransmissionMode(cfdp::TransmissionMode transmissionMode);
+  void clearTransmissionMode();
+  void setClosureRequest(bool closureRequested);
+  void clearClosureRequest();
+
+  const uint8_t* getMessagesToUser(size_t& msgSize);
+
+  [[nodiscard]] bool isMetadataOnly() const;
+
+  bool getTransmissionMode(TransmissionMode& mode) const;
+  bool getClosureRequested(bool& closureRequested) const;
+
+  [[nodiscard]] const EntityId& getDestId() const;
+  void setDestId(EntityId id);
+
+ private:
+  EntityId destId;
+  uint8_t metadataOnly = true;
+  // Transaction parameters. Omitted if the put request is metadata only.
+  cfdp::StringLv sourceName;
+
+  cfdp::StringLv destName;
+  bool hasTransmissionMode = false;
+  uint8_t transmissionMode = TransmissionMode::UNACKNOWLEDGED;
+  bool hasClosureRequested = false;
+  uint8_t closureRequested = false;
+  // Metadata
+  size_t msgsToUsersTotalSize = 0;
+  const uint8_t* msgsToUserStartPtr = nullptr;
+  size_t fsRequestsTotalSize = 0;
+  const uint8_t* fsRequestStartPtr = nullptr;
+};
+
+}  // namespace cfdp
--- a/src/fsfw/cfdp/handler/RemoteConfigTableIF.h
+++ b/src/fsfw/cfdp/handler/RemoteConfigTableIF.h
@ -0,0 +1,35 @@
+#ifndef FSFW_CFDP_HANDLER_REMOTECONFIGTABLEIF_H
+#define FSFW_CFDP_HANDLER_REMOTECONFIGTABLEIF_H
+
+#include "fsfw/cfdp/handler/mib.h"
+
+namespace cfdp {
+
+class RemoteConfigTableIF {
+ public:
+  virtual ~RemoteConfigTableIF() = default;
+  virtual bool getRemoteCfg(const cfdp::EntityId& remoteId, cfdp::RemoteEntityCfg** cfg) = 0;
+};
+
+/**
+ * Helper class for the common case that there is exactly one remote entity
+ */
+class OneRemoteConfigProvider : public RemoteConfigTableIF {
+ public:
+  explicit OneRemoteConfigProvider(RemoteEntityCfg& cfg) : cfg(cfg) {}
+
+  bool getRemoteCfg(const EntityId& remoteId, cfdp::RemoteEntityCfg** cfg_) override {
+    if (remoteId != cfg.remoteId) {
+      return false;
+    }
+    *cfg_ = &cfg;
+    return true;
+  }
+
+ private:
+  RemoteEntityCfg& cfg;
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_HANDLER_REMOTECONFIGTABLEIF_H
--- a/src/fsfw/cfdp/handler/ReservedMessageParser.cpp
+++ b/src/fsfw/cfdp/handler/ReservedMessageParser.cpp
@ -0,0 +1,74 @@
+#include "ReservedMessageParser.h"
+
+#include "fsfw/cfdp/CfdpMessage.h"
+#include "fsfw/cfdp/handler/PutRequest.h"
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/QueueFactory.h"
+
+using namespace returnvalue;
+
+cfdp::ReservedMessageParser::ReservedMessageParser(StorageManagerIF& ipcStore,
+                                                   MessageQueueIF& msgQueue,
+                                                   MessageQueueId_t userDestination)
+    : msgQueue(msgQueue), ipcStore(ipcStore), userDestination(userDestination) {}
+
+ReturnValue_t cfdp::ReservedMessageParser::parse(const MessageToUserTlv* msgsToUserArray,
+                                                 size_t numMsgToUser) {
+  ReturnValue_t result = returnvalue::OK;
+  cfdp::StringLv sourceFileName;
+  cfdp::StringLv destFileName;
+  PutRequest putRequest;
+  const uint8_t* currentPtr = nullptr;
+  size_t deserSize = 0;
+  bool needToSendPutRequest = false;
+  for (size_t idx = 0; idx < numMsgToUser; idx++) {
+    if (&msgsToUserArray[idx] == nullptr) {
+      continue;
+    }
+    uint8_t messageType = 0;
+    if (msgsToUserArray[idx].isReservedCfdpMessage(messageType, &currentPtr, deserSize)) {
+      if (messageType == static_cast<uint8_t>(ProxyOpMessageType::PUT_REQUEST)) {
+        EntityId entityIdLv;
+        result = entityIdLv.deSerializeFromLv(&currentPtr, &deserSize);
+        if (result != returnvalue::OK) {
+          return result;
+        }
+        putRequest.setDestId(entityIdLv);
+        result =
+            sourceFileName.deSerialize(&currentPtr, &deserSize, SerializeIF::Endianness::NETWORK);
+        if (result != OK) {
+          return result;
+        }
+        result =
+            destFileName.deSerialize(&currentPtr, &deserSize, SerializeIF::Endianness::NETWORK);
+        if (result != OK) {
+          return result;
+        }
+        putRequest.setSourceAndDestName(sourceFileName, destFileName);
+        needToSendPutRequest = true;
+      }
+    }
+  }
+  if (needToSendPutRequest) {
+    store_address_t storeId;
+    uint8_t* dataPtr;
+    result = ipcStore.getFreeElement(&storeId, putRequest.getSerializedSize(), &dataPtr);
+    if (result != OK) {
+      return result;
+    }
+    size_t serLen = 0;
+    result = putRequest.serialize(&dataPtr, &serLen, putRequest.getSerializedSize(),
+                                  SerializeIF::Endianness::MACHINE);
+    if (result != OK) {
+      return result;
+    }
+    CommandMessage msg;
+    CfdpMessage::setPutRequest(&msg, storeId);
+    result = msgQueue.sendMessage(userDestination, &msg);
+    if (result != OK) {
+      return result;
+    }
+  }
+  return OK;
+}
--- a/src/fsfw/cfdp/handler/ReservedMessageParser.h
+++ b/src/fsfw/cfdp/handler/ReservedMessageParser.h
@ -0,0 +1,27 @@
+#pragma once
+
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+
+namespace cfdp {
+
+/**
+ * This class parses messages to user for special CFDP messages and converts them to appropriate
+ * CFDP requests sent via the IPC store where applicable. It also provides an API to retrieve
+ * custom messages which are not special CFDP messages from a provided bytestream.
+ */
+class ReservedMessageParser {
+ public:
+  ReservedMessageParser(StorageManagerIF& ipcStore, MessageQueueIF& msgQueue,
+                        MessageQueueId_t userDestination);
+
+  ReturnValue_t parse(const MessageToUserTlv* msgsToUserArray, size_t numMsgsToUser);
+
+ private:
+  MessageQueueIF& msgQueue;
+  StorageManagerIF& ipcStore;
+  MessageQueueId_t userDestination;
+};
+
+}  // namespace cfdp
--- a/src/fsfw/cfdp/handler/SourceHandler.cpp
+++ b/src/fsfw/cfdp/handler/SourceHandler.cpp
@ -0,0 +1,376 @@
+#include "SourceHandler.h"
+
+#include <etl/crc32.h>
+
+#include <array>
+
+#include "fsfw/cfdp/pdu/EofPduCreator.h"
+#include "fsfw/cfdp/pdu/FileDataCreator.h"
+#include "fsfw/cfdp/pdu/MetadataPduCreator.h"
+#include "fsfw/filesystem/HasFileSystemIF.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/objectmanager.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/tmtcservices/TmTcMessage.h"
+
+using namespace returnvalue;
+
+cfdp::SourceHandler::SourceHandler(SourceHandlerParams params, FsfwParams fsfwParams)
+    : sourceParams(std::move(params)), fsfwParams(fsfwParams) {
+  // The entity ID portion of the transaction ID will always remain fixed.
+  transactionParams.id.entityId = sourceParams.cfg.localId;
+  transactionParams.pduConf.sourceId = sourceParams.cfg.localId;
+  if (sourceParams.seqCountProvider.bitWidth() == 8) {
+    transactionParams.pduConf.seqNum.setWidth(cfdp::WidthInBytes::ONE_BYTE);
+  } else if (sourceParams.seqCountProvider.bitWidth() == 16) {
+    transactionParams.pduConf.seqNum.setWidth(cfdp::WidthInBytes::TWO_BYTES);
+  } else if (sourceParams.seqCountProvider.bitWidth() == 32) {
+    transactionParams.pduConf.seqNum.setWidth(cfdp::WidthInBytes::FOUR_BYTES);
+  } else if (sourceParams.seqCountProvider.bitWidth() == 64) {
+    transactionParams.pduConf.seqNum.setWidth(cfdp::WidthInBytes::EIGHT_BYTES);
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "cfdp::SourceHandler: Seq count provider bit width "
+               << sourceParams.seqCountProvider.bitWidth() << " not allowed" << std::endl;
+#else
+    sif::printError("cfdp::SourceHandler: Seq count provider bit width %d not allowed\n",
+                    sourceParams.seqCountProvider.bitWidth());
+#endif
+    // Yeah, what am I supposed to do here? Can't throw an exception in the FSFW..
+    transactionParams.pduConf.seqNum.setWidth(cfdp::WidthInBytes::ONE_BYTE);
+  }
+  transactionParams.pduConf.seqNum.setValue(0);
+}
+
+cfdp::SourceHandler::FsmResult& cfdp::SourceHandler::fsmNacked() {
+  ReturnValue_t result;
+  if (step == TransactionStep::IDLE) {
+    step = TransactionStep::TRANSACTION_START;
+  }
+  if (step == TransactionStep::TRANSACTION_START) {
+    sourceParams.user.transactionIndication(transactionParams.id);
+    result = checksumGeneration();
+    if (result != OK) {
+      addError(result);
+    }
+    step = TransactionStep::SENDING_METADATA;
+  }
+  if (step == TransactionStep::SENDING_METADATA) {
+    result = prepareAndSendMetadataPdu();
+    if (result != OK) {
+      addError(result);
+    }
+    fsmResult.callStatus = CallStatus::CALL_AGAIN;
+    return fsmResult;
+  }
+  if (step == TransactionStep::SENDING_FILE_DATA) {
+    bool noFdPdu = false;
+    result = prepareAndSendNextFileDataPdu(noFdPdu);
+    if (result == OK and !noFdPdu) {
+      fsmResult.callStatus = CallStatus::CALL_AGAIN;
+      return fsmResult;
+    }
+  }
+  if (step == TransactionStep::SENDING_EOF) {
+    result = prepareAndSendEofPdu();
+    if (result != OK) {
+      addError(result);
+    }
+    if (sourceParams.cfg.indicCfg.eofSentIndicRequired) {
+      sourceParams.user.eofSentIndication(transactionParams.id);
+    }
+    if (transactionParams.closureRequested) {
+      step = TransactionStep::WAIT_FOR_FINISH;
+      fsmResult.callStatus = CallStatus::CALL_AFTER_DELAY;
+    } else {
+      step = TransactionStep::NOTICE_OF_COMPLETION;
+      fsmResult.callStatus = CallStatus::CALL_AGAIN;
+    }
+    return fsmResult;
+  }
+  if (step == TransactionStep::WAIT_FOR_FINISH) {
+    // TODO: In case this is a request with closure, wait for finish.
+    // Done, issue notice of completion
+    step = TransactionStep::NOTICE_OF_COMPLETION;
+  }
+  if (step == TransactionStep::NOTICE_OF_COMPLETION) {
+    noticeOfCompletion();
+    reset();
+  }
+  return fsmResult;
+}
+
+const cfdp::SourceHandler::FsmResult& cfdp::SourceHandler::stateMachine() {
+  fsmResult.packetsSent = 0;
+  fsmResult.errors = 0;
+  fsmResult.callStatus = CallStatus::DONE;
+  if (state == cfdp::CfdpState::IDLE) {
+    return fsmResult;
+  }
+  if (state == cfdp::CfdpState::BUSY_CLASS_1_NACKED) {
+    return fsmNacked();
+  }
+  return fsmResult;
+}
+
+ReturnValue_t cfdp::SourceHandler::checksumGeneration() {
+  if (transactionParams.fileSize.value() == 0) {
+    // NULL checksum for empty file.
+    transactionParams.crc = 0;
+    return OK;
+  }
+  std::array<uint8_t, 1024> buf{};
+  etl::crc32 crcCalc;
+  uint64_t currentOffset = 0;
+  FileOpParams params(transactionParams.sourceName.data(), transactionParams.fileSize.value());
+  while (currentOffset < transactionParams.fileSize.value()) {
+    uint64_t readLen;
+    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 = sourceParams.user.vfs.readFromFile(params, buf.data(), buf.size());
+      if (result != OK) {
+        addError(result);
+        return FAILED;
+      }
+      crcCalc.add(buf.begin(), buf.begin() + readLen);
+    }
+    currentOffset += readLen;
+  }
+
+  transactionParams.crc = crcCalc.value();
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::transactionStart(PutRequest& putRequest, RemoteEntityCfg& cfg) {
+  if (state != CfdpState::IDLE) {
+    return SOURCE_TRANSACTION_PENDING;
+  }
+  if (cfg.remoteId != putRequest.getDestId()) {
+    return WRONG_REMOTE_CFG_ENTITY_ID;
+  }
+  if (putRequest.getSourceName().getValueLen() == 0) {
+    return SOURCE_NAME_EMPTY;
+  }
+  if (putRequest.getDestName().getValueLen() == 0) {
+    return DEST_NAME_EMPTY;
+  }
+  const char* srcNamePtr = putRequest.getSourceName().getCString(transactionParams.sourceNameSize);
+  const char* destNamePtr = putRequest.getDestName().getCString(transactionParams.destNameSize);
+  std::strncpy(transactionParams.sourceName.data(), srcNamePtr, transactionParams.sourceNameSize);
+  std::strncpy(transactionParams.destName.data(), destNamePtr, transactionParams.destNameSize);
+  // Add 0 termination. The source and dest name size can not be larger than UINT8_MAX, so this
+  // operation is safe.
+  transactionParams.sourceName[transactionParams.sourceNameSize] = '\0';
+  transactionParams.destName[transactionParams.destNameSize] = '\0';
+  FilesystemParams params(transactionParams.sourceName.data());
+  if (!sourceParams.user.vfs.fileExists(params)) {
+    return FILE_DOES_NOT_EXIST;
+  }
+  if (cfg.maxFileSegmentLen > fileBuf.size() or cfg.maxFileSegmentLen == 0) {
+    return FILE_SEGMENT_LEN_INVALID;
+  }
+  // If transmission mode is not set, use default transmission mode for the remote entity.
+  if (not putRequest.getTransmissionMode(transactionParams.pduConf.mode)) {
+    transactionParams.pduConf.mode = cfg.defaultTransmissionMode;
+  }
+  // If closure request field is not set, use default option for the remote entity.
+  if (not putRequest.getClosureRequested(transactionParams.closureRequested)) {
+    transactionParams.closureRequested = cfg.closureRequested;
+  }
+  const EntityId& destId = putRequest.getDestId();
+  // The width of the source and destination ID must be the same. Use the larger ID value to
+  // ensure the width is large enough for both IDs
+  if (destId.getWidth() > transactionParams.pduConf.sourceId.getWidth()) {
+    transactionParams.pduConf.destId = destId;
+    transactionParams.pduConf.sourceId.setWidth(destId.getWidth());
+  } else {
+    transactionParams.pduConf.destId.setValueAndWidth(transactionParams.pduConf.sourceId.getWidth(),
+                                                      destId.getValue());
+  }
+  // Only used for PDU forwarding, file is sent to file receiver regularly here.
+  transactionParams.pduConf.direction = Direction::TOWARDS_RECEIVER;
+  transactionParams.pduConf.seqNum.setValue(sourceParams.seqCountProvider.getAndIncrement());
+  transactionParams.id.seqNum = transactionParams.pduConf.seqNum;
+
+  if (transactionParams.pduConf.mode == TransmissionMode::ACKNOWLEDGED) {
+    state = cfdp::CfdpState::BUSY_CLASS_2_ACKED;
+  } else if (transactionParams.pduConf.mode == TransmissionMode::UNACKNOWLEDGED) {
+    state = cfdp::CfdpState::BUSY_CLASS_1_NACKED;
+  }
+  step = TransactionStep::IDLE;
+  uint64_t fileSize = 0;
+  sourceParams.user.vfs.getFileSize(params, fileSize);
+  transactionParams.pduConf.largeFile = false;
+  if (fileSize > UINT32_MAX) {
+    transactionParams.pduConf.largeFile = true;
+  }
+  if (fileSize == 0) {
+    transactionParams.checksumType = ChecksumType::NULL_CHECKSUM;
+  } else {
+    transactionParams.checksumType = ChecksumType::CRC_32;
+  }
+  transactionParams.fileSize.setFileSize(fileSize, transactionParams.pduConf.largeFile);
+  transactionParams.progress = 0;
+  transactionParams.remoteCfg = cfg;
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::prepareAndSendMetadataPdu() {
+  cfdp::StringLv sourceName(transactionParams.sourceName.data(), transactionParams.sourceNameSize);
+  cfdp::StringLv destName(transactionParams.destName.data(), transactionParams.destNameSize);
+  auto metadataInfo =
+      MetadataGenericInfo(transactionParams.closureRequested, transactionParams.checksumType,
+                          transactionParams.fileSize);
+  auto metadataPdu =
+      MetadataPduCreator(transactionParams.pduConf, metadataInfo, sourceName, destName, nullptr, 0);
+  ReturnValue_t result = sendGenericPdu(metadataPdu);
+  if (result != OK) {
+    return result;
+  }
+  // Advance FSM if everything works
+  step = TransactionStep::SENDING_FILE_DATA;
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::prepareAndSendNextFileDataPdu(bool& noFileDataPdu) {
+  cfdp::Fss offset(transactionParams.progress);
+  uint64_t readLen;
+  uint64_t fileSize = transactionParams.fileSize.value();
+  noFileDataPdu = false;
+  if (fileSize == 0) {
+    // We are done, no need to send file data PDUs for an empty file.
+    step = TransactionStep::SENDING_EOF;
+    noFileDataPdu = true;
+    return OK;
+  }
+  if (fileSize < transactionParams.remoteCfg.maxFileSegmentLen) {
+    readLen = transactionParams.fileSize.value();
+  } else {
+    if (transactionParams.progress + transactionParams.remoteCfg.maxFileSegmentLen > fileSize) {
+      readLen = fileSize - transactionParams.progress;
+    } else {
+      readLen = transactionParams.remoteCfg.maxFileSegmentLen;
+    }
+  }
+  FileOpParams fileParams(transactionParams.sourceName.data(), readLen);
+  fileParams.offset = transactionParams.progress;
+  ReturnValue_t result =
+      sourceParams.user.vfs.readFromFile(fileParams, fileBuf.data(), fileBuf.size());
+  if (result != returnvalue::OK) {
+    addError(result);
+    return result;
+  }
+  auto fileDataInfo = FileDataInfo(offset, fileBuf.data(), readLen);
+  auto fileDataPdu = FileDataCreator(transactionParams.pduConf, fileDataInfo);
+  result = sendGenericPdu(fileDataPdu);
+  if (result != OK) {
+    return result;
+  }
+  transactionParams.progress += readLen;
+  if (transactionParams.progress >= fileSize) {
+    // Advance FSM after all file data PDUs were sent.
+    step = TransactionStep::SENDING_EOF;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::prepareAndSendEofPdu() {
+  auto eofInfo =
+      EofInfo(ConditionCode::NO_ERROR, transactionParams.crc, transactionParams.fileSize);
+  auto eofPdu = EofPduCreator(transactionParams.pduConf, eofInfo);
+  ReturnValue_t result = sendGenericPdu(eofPdu);
+  if (result != OK) {
+    return result;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::initialize() {
+  if (fsfwParams.tmStore == nullptr) {
+    fsfwParams.tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+    if (fsfwParams.tmStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fsfwParams.tcStore == nullptr) {
+    fsfwParams.tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
+    if (fsfwParams.tcStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fsfwParams.msgQueue == nullptr) {
+    return FAILED;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::sendGenericPdu(const SerializeIF& pdu) {
+  uint8_t* dataPtr;
+  store_address_t storeId;
+  ReturnValue_t result =
+      fsfwParams.tmStore->getFreeElement(&storeId, pdu.getSerializedSize(), &dataPtr);
+  if (result != OK) {
+    addError(result);
+    fsmResult.callStatus = CallStatus::CALL_AFTER_DELAY;
+    if (result == StorageManagerIF::DATA_STORAGE_FULL) {
+      return TM_STORE_FULL;
+    }
+    return result;
+  }
+  size_t serializedLen = 0;
+  result = pdu.serializeBe(dataPtr, serializedLen, pdu.getSerializedSize());
+  if (result != OK) {
+    addError(result);
+    return result;
+  }
+  TmTcMessage tmMsg(storeId);
+  result =
+      fsfwParams.msgQueue->sendMessage(fsfwParams.packetDest.getReportReceptionQueue(), &tmMsg);
+  if (result != OK) {
+    fsmResult.callStatus = CallStatus::CALL_AFTER_DELAY;
+  }
+  if (result == MessageQueueIF::FULL) {
+    return TARGET_MSG_QUEUE_FULL;
+  } else if (result == OK) {
+    fsmResult.packetsSent += 1;
+  }
+  return result;
+}
+
+ReturnValue_t cfdp::SourceHandler::noticeOfCompletion() {
+  if (sourceParams.cfg.indicCfg.transactionFinishedIndicRequired) {
+    cfdp::TransactionFinishedParams params(transactionParams.id, ConditionCode::NO_ERROR,
+                                           FileDeliveryCode::DATA_COMPLETE,
+                                           FileDeliveryStatus::RETAINED_IN_FILESTORE);
+    sourceParams.user.transactionFinishedIndication(params);
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::SourceHandler::reset() {
+  step = TransactionStep::IDLE;
+  state = cfdp::CfdpState::IDLE;
+  fsmResult.callStatus = CallStatus::DONE;
+  transactionParams.reset();
+  return OK;
+}
+cfdp::CfdpState cfdp::SourceHandler::getState() const { return state; }
+
+cfdp::SourceHandler::TransactionStep cfdp::SourceHandler::getStep() const { return step; }
+
+void cfdp::SourceHandler::addError(ReturnValue_t error) {
+  if (fsmResult.errors < fsmResult.errorCodes.size()) {
+    fsmResult.errorCodes[fsmResult.errors] = error;
+    fsmResult.errors++;
+    fsmResult.result = error;
+  }
+}
--- a/src/fsfw/cfdp/handler/SourceHandler.h
+++ b/src/fsfw/cfdp/handler/SourceHandler.h
@ -0,0 +1,110 @@
+#ifndef FSFW_CFDP_CFDPSOURCEHANDLER_H
+#define FSFW_CFDP_CFDPSOURCEHANDLER_H
+
+#include <cstdint>
+#include <vector>
+
+#include "UserBase.h"
+#include "defs.h"
+#include "fsfw/cfdp/Fss.h"
+#include "fsfw/cfdp/handler/PutRequest.h"
+#include "fsfw/cfdp/handler/mib.h"
+#include "fsfw/events/EventReportingProxyIF.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+#include "fsfw/util/ProvidesSeqCountIF.h"
+
+namespace cfdp {
+
+struct SourceHandlerParams {
+  SourceHandlerParams(LocalEntityCfg cfg, UserBase& user, ProvidesSeqCountIF& seqCountProvider)
+      : cfg(std::move(cfg)), user(user), seqCountProvider(seqCountProvider) {}
+
+  LocalEntityCfg cfg;
+  UserBase& user;
+  ProvidesSeqCountIF& seqCountProvider;
+};
+
+class SourceHandler {
+ public:
+  enum class TransactionStep : uint8_t {
+    IDLE = 0,
+    TRANSACTION_START = 1,
+    SENDING_METADATA = 3,
+    SENDING_FILE_DATA = 4,
+    SENDING_EOF = 5,
+    WAIT_FOR_ACK = 6,
+    WAIT_FOR_FINISH = 7,
+    NOTICE_OF_COMPLETION = 8
+  };
+  struct FsmResult {
+   public:
+    ReturnValue_t result = returnvalue::OK;
+    CallStatus callStatus = CallStatus::CALL_AFTER_DELAY;
+    CfdpState state = CfdpState::IDLE;
+    uint32_t packetsSent = 0;
+    uint8_t errors = 0;
+    std::array<ReturnValue_t, 3> errorCodes = {};
+  };
+
+  SourceHandler(SourceHandlerParams params, FsfwParams fsfwParams);
+
+  [[nodiscard]] CfdpState getState() const;
+  [[nodiscard]] TransactionStep getStep() const;
+
+  /**
+   * Pass a put request to the source handler, which might initiate a CFDP transaction and start
+   * the state machine
+   * @return
+   */
+  ReturnValue_t transactionStart(PutRequest& putRequest, RemoteEntityCfg& cfg);
+  const FsmResult& stateMachine();
+
+  ReturnValue_t initialize();
+
+ private:
+  struct TransactionParams {
+    uint32_t crc{};
+    std::array<char, UINT8_MAX + 1> sourceName{};
+    size_t sourceNameSize = 0;
+    std::array<char, UINT8_MAX + 1> destName{};
+    size_t destNameSize = 0;
+    cfdp::Fss fileSize;
+    size_t progress = 0;
+    bool closureRequested = false;
+    ChecksumType checksumType = ChecksumType::NULL_CHECKSUM;
+    RemoteEntityCfg remoteCfg;
+    PduConfig pduConf;
+    cfdp::TransactionId id{};
+
+    void reset() {
+      sourceNameSize = 0;
+      destNameSize = 0;
+      fileSize.setFileSize(0, false);
+      progress = 0;
+      closureRequested = false;
+    }
+  } transactionParams;
+
+  cfdp::CfdpState state = cfdp::CfdpState::IDLE;
+  TransactionStep step = TransactionStep::IDLE;
+  std::array<uint8_t, 4096> fileBuf{};
+  SourceHandlerParams sourceParams;
+  cfdp::FsfwParams fsfwParams;
+  FsmResult fsmResult;
+
+  FsmResult& fsmNacked();
+  ReturnValue_t checksumGeneration();
+  ReturnValue_t prepareAndSendMetadataPdu();
+  ReturnValue_t prepareAndSendNextFileDataPdu(bool& noFileDataPdu);
+  ReturnValue_t prepareAndSendEofPdu();
+  ReturnValue_t noticeOfCompletion();
+  ReturnValue_t reset();
+
+  [[nodiscard]] ReturnValue_t sendGenericPdu(const SerializeIF& pdu);
+  void addError(ReturnValue_t error);
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_CFDPSOURCEHANDLER_H
--- a/src/fsfw/cfdp/handler/StatusReportIF.h
+++ b/src/fsfw/cfdp/handler/StatusReportIF.h
@ -0,0 +1,12 @@
+#ifndef FSFW_CFDP_HANDLER_STATUSREPORTIF_H
+#define FSFW_CFDP_HANDLER_STATUSREPORTIF_H
+
+namespace cfdp {
+
+class StatusReportIF {
+  virtual ~StatusReportIF() = default;
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_HANDLER_STATUSREPORTIF_H
--- a/src/fsfw/cfdp/handler/UserBase.cpp
+++ b/src/fsfw/cfdp/handler/UserBase.cpp
@ -0,0 +1,3 @@
+#include "UserBase.h"
+
+cfdp::UserBase::UserBase(HasFileSystemIF& vfs) : vfs(vfs) {}
--- a/src/fsfw/cfdp/handler/UserBase.h
+++ b/src/fsfw/cfdp/handler/UserBase.h
@ -0,0 +1,103 @@
+#ifndef FSFW_CFDP_USERBASE_H
+#define FSFW_CFDP_USERBASE_H
+
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "StatusReportIF.h"
+#include "fsfw/cfdp/Fss.h"
+#include "fsfw/cfdp/VarLenFields.h"
+#include "fsfw/cfdp/tlv/FilestoreResponseTlv.h"
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+#include "fsfw/filesystem/HasFileSystemIF.h"
+
+namespace cfdp {
+
+struct TransactionFinishedParams {
+  TransactionFinishedParams(const TransactionId& id, ConditionCode code, FileDeliveryCode delivCode,
+                            FileDeliveryStatus status)
+      : id(id), condCode(code), status(status), deliveryCode(delivCode) {}
+
+  const TransactionId& id;
+  ConditionCode condCode;
+  FileDeliveryStatus status;
+  FileDeliveryCode deliveryCode;
+  std::vector<FilestoreResponseTlv*> fsResponses;
+  StatusReportIF* statusReport = nullptr;
+};
+
+struct MetadataRecvdParams {
+  MetadataRecvdParams(const TransactionId& id, const EntityId& sourceId, Fss fileSize)
+      : id(id), sourceId(sourceId), fileSize(std::move(fileSize)) {}
+  const TransactionId& id;
+  const EntityId& sourceId;
+  Fss fileSize{};
+  const char* sourceFileName = "";
+  const char* destFileName = "";
+  size_t numberOfMsgsToUser = 0;
+  const MessageToUserTlv* msgsToUserArray = nullptr;
+};
+
+struct FileSegmentRecvdParams {
+  TransactionId id;
+  size_t offset;
+  size_t length;
+  std::optional<RecordContinuationState> recContState = std::nullopt;
+  std::pair<const uint8_t*, size_t> segmentMetadata;
+};
+
+/**
+ * @brief Base class which provides a user interface to interact with CFDP handlers.
+ *
+ * @details
+ * This class is also used to pass the Virtual Filestore (VFS) Implementation to the CFDP
+ * handlers so the filestore operations can be mapped to the underlying filestore.
+ *
+ * It is used by implementing it in a child class and then passing it to the CFDP
+ * handler objects. The base class provides default implementation for the user indication
+ * primitives specified in the CFDP standard. The user can override these implementations
+ * to provide custom indication handlers.
+ *
+ * Please note that for all indication callbacks, the passed transaction ID reference will
+ * become invalid shortly after the function has been executed. If the transaction ID is to be
+ * cached or used, create an own copy of it.
+ * @param vfs Virtual Filestore Object. Will be used for all file operations
+ */
+class UserBase {
+  friend class DestHandler;
+  friend class SourceHandler;
+
+ public:
+  explicit UserBase(HasFileSystemIF& vfs);
+
+  virtual void transactionIndication(const TransactionId& id) = 0;
+  virtual void eofSentIndication(const TransactionId& id) = 0;
+  virtual void transactionFinishedIndication(const TransactionFinishedParams& params) = 0;
+  /**
+   * Will be called if metadata was received.
+   *
+   * IMPORTANT: The passed struct contains the messages to the user in form of a raw C array.
+   * The TLVs in these arrays are zero-copy types, which means that they point to the raw data
+   * inside the metadata packet directly. The metadata packet will be deleted from the TC store
+   * shortly after it was processed. If some of the data is to be cached and/or used after the
+   * function call, it needs to be copied into another user-provided buffer.
+   * @param params
+   */
+  virtual void metadataRecvdIndication(const MetadataRecvdParams& params) = 0;
+  virtual void fileSegmentRecvdIndication(const FileSegmentRecvdParams& params) = 0;
+  virtual void reportIndication(const TransactionId& id, StatusReportIF& report) = 0;
+  virtual void suspendedIndication(const TransactionId& id, ConditionCode code) = 0;
+  virtual void resumedIndication(const TransactionId& id, size_t progress) = 0;
+  virtual void faultIndication(const TransactionId& id, ConditionCode code, size_t progress) = 0;
+  virtual void abandonedIndication(const TransactionId& id, ConditionCode code,
+                                   size_t progress) = 0;
+  virtual void eofRecvIndication(const TransactionId& id) = 0;
+
+ private:
+  HasFileSystemIF& vfs;
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_USERBASE_H
--- a/src/fsfw/cfdp/handler/defs.h
+++ b/src/fsfw/cfdp/handler/defs.h
@ -0,0 +1,76 @@
+#ifndef FSFW_CFDP_HANDLER_DEFS_H
+#define FSFW_CFDP_HANDLER_DEFS_H
+
+#include <etl/list.h>
+
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/storagemanager/storeAddress.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+
+namespace cfdp {
+
+enum class CfdpState { IDLE, BUSY_CLASS_1_NACKED, BUSY_CLASS_2_ACKED, SUSPENDED };
+
+static constexpr uint8_t SSID = SUBSYSTEM_ID::CFDP;
+static constexpr uint8_t CID = CLASS_ID::CFDP_HANDLER;
+
+struct PacketInfo {
+  PacketInfo(PduType type, store_address_t storeId,
+             std::optional<FileDirective> directive = std::nullopt)
+      : pduType(type), directiveType(directive), storeId(storeId) {}
+
+  PduType pduType = PduType::FILE_DATA;
+  std::optional<FileDirective> directiveType = FileDirective::INVALID_DIRECTIVE;
+  store_address_t storeId = store_address_t::invalid();
+  PacketInfo() = default;
+};
+
+struct FsfwParams {
+  FsfwParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue,
+             EventReportingProxyIF* eventReporter, StorageManagerIF& tcStore,
+             StorageManagerIF& tmStore)
+      : FsfwParams(packetDest, msgQueue, eventReporter) {
+    this->tcStore = &tcStore;
+    this->tmStore = &tmStore;
+  }
+
+  FsfwParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue,
+             EventReportingProxyIF* eventReporter)
+      : packetDest(packetDest), msgQueue(msgQueue), eventReporter(eventReporter) {}
+  AcceptsTelemetryIF& packetDest;
+  MessageQueueIF* msgQueue;
+  EventReportingProxyIF* eventReporter = nullptr;
+  StorageManagerIF* tcStore = nullptr;
+  StorageManagerIF* tmStore = nullptr;
+};
+
+template <size_t SIZE>
+using PacketInfoList = etl::list<PacketInfo, SIZE>;
+using PacketInfoListBase = etl::ilist<PacketInfo>;
+
+enum class CallStatus { DONE, CALL_AFTER_DELAY, CALL_AGAIN };
+
+namespace events {
+
+static constexpr Event STORE_ERROR = event::makeEvent(SSID, 0, severity::LOW);
+static constexpr Event MSG_QUEUE_ERROR = event::makeEvent(SSID, 1, severity::LOW);
+static constexpr Event SERIALIZATION_ERROR = event::makeEvent(SSID, 2, severity::LOW);
+static constexpr Event FILESTORE_ERROR = event::makeEvent(SSID, 3, severity::LOW);
+//! [EXPORT] : [COMMENT] P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name
+static constexpr Event FILENAME_TOO_LARGE_ERROR = event::makeEvent(SSID, 4, severity::LOW);
+//! [EXPORT] : [COMMENT] CFDP request handling failed. P2: Returncode.
+static constexpr Event HANDLING_CFDP_REQUEST_FAILED = event::makeEvent(SSID, 5, severity::LOW);
+
+}  // namespace events
+
+static constexpr ReturnValue_t SOURCE_TRANSACTION_PENDING = returnvalue::makeCode(CID, 0);
+static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = returnvalue::makeCode(CID, 1);
+static constexpr ReturnValue_t FILE_SEGMENT_LEN_INVALID = returnvalue::makeCode(CID, 2);
+static constexpr ReturnValue_t SOURCE_NAME_EMPTY = returnvalue::makeCode(CID, 3);
+static constexpr ReturnValue_t DEST_NAME_EMPTY = returnvalue::makeCode(CID, 4);
+static constexpr ReturnValue_t WRONG_REMOTE_CFG_ENTITY_ID = returnvalue::makeCode(CID, 5);
+static constexpr ReturnValue_t TARGET_MSG_QUEUE_FULL = returnvalue::makeCode(CID, 6);
+static constexpr ReturnValue_t TM_STORE_FULL = returnvalue::makeCode(CID, 7);
+
+}  // namespace cfdp
+#endif  // FSFW_CFDP_HANDLER_DEFS_H
--- a/src/fsfw/cfdp/handler/mib.h
+++ b/src/fsfw/cfdp/handler/mib.h
@ -0,0 +1,43 @@
+#ifndef FSFW_CFDP_MIB_H
+#define FSFW_CFDP_MIB_H
+
+#include <utility>
+
+#include "FaultHandlerBase.h"
+#include "fsfw/cfdp/pdu/PduConfig.h"
+
+namespace cfdp {
+
+struct IndicationCfg {
+  bool eofSentIndicRequired = true;
+  bool eofRecvIndicRequired = true;
+  bool fileSegmentRecvIndicRequired = true;
+  bool transactionFinishedIndicRequired = true;
+  bool suspendedIndicRequired = true;
+  bool resumedIndicRequired = true;
+};
+
+struct LocalEntityCfg {
+  LocalEntityCfg(EntityId localId, IndicationCfg indicationCfg, FaultHandlerBase& fhBase)
+      : localId(std::move(localId)), indicCfg(indicationCfg), fhBase(fhBase) {}
+
+  EntityId localId;
+  IndicationCfg indicCfg;
+  FaultHandlerBase& fhBase;
+};
+
+struct RemoteEntityCfg {
+  RemoteEntityCfg() = default;
+  explicit RemoteEntityCfg(EntityId id) : remoteId(std::move(id)) {}
+  EntityId remoteId;
+  size_t maxFileSegmentLen = 1024;
+  bool closureRequested = false;
+  bool crcOnTransmission = false;
+  TransmissionMode defaultTransmissionMode = TransmissionMode::UNACKNOWLEDGED;
+  ChecksumType defaultChecksum = ChecksumType::NULL_CHECKSUM;
+  uint8_t version = CFDP_VERSION_2;
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_MIB_H
--- a/src/fsfw/cfdp/helpers.cpp
+++ b/src/fsfw/cfdp/helpers.cpp
@ -0,0 +1,50 @@
+#include "helpers.h"
+
+const char* COND_CODE_STRINGS[14] = {"Unknown",
+                                     "No Error",
+                                     "Positive ACK Limit Reached",
+                                     "Keep Alive Limit Reached",
+                                     "Invalid Transmission Mode",
+                                     "Filestore Rejection",
+                                     "File Checksum Failure",
+                                     "File Size Error",
+                                     "NAK limit reached",
+                                     "Inactivity Detected",
+                                     "Check Limit Reached",
+                                     "Unsupported Checksum Type",
+                                     "Suspend Request Received",
+                                     "Cancel Request Received"};
+
+const char* cfdp::getConditionCodeString(cfdp::ConditionCode code) {
+  switch (code) {
+    case NO_CONDITION_FIELD:
+      return COND_CODE_STRINGS[0];
+    case NO_ERROR:
+      return COND_CODE_STRINGS[1];
+    case POSITIVE_ACK_LIMIT_REACHED:
+      return COND_CODE_STRINGS[2];
+    case KEEP_ALIVE_LIMIT_REACHED:
+      return COND_CODE_STRINGS[3];
+    case INVALID_TRANSMISSION_MODE:
+      return COND_CODE_STRINGS[4];
+    case FILESTORE_REJECTION:
+      return COND_CODE_STRINGS[5];
+    case FILE_CHECKSUM_FAILURE:
+      return COND_CODE_STRINGS[6];
+    case FILE_SIZE_ERROR:
+      return COND_CODE_STRINGS[7];
+    case NAK_LIMIT_REACHED:
+      return COND_CODE_STRINGS[8];
+    case INACTIVITY_DETECTED:
+      return COND_CODE_STRINGS[9];
+    case CHECK_LIMIT_REACHED:
+      return COND_CODE_STRINGS[10];
+    case UNSUPPORTED_CHECKSUM_TYPE:
+      return COND_CODE_STRINGS[11];
+    case SUSPEND_REQUEST_RECEIVED:
+      return COND_CODE_STRINGS[12];
+    case CANCEL_REQUEST_RECEIVED:
+      return COND_CODE_STRINGS[13];
+  }
+  return "Unknown";
+}
--- a/src/fsfw/cfdp/helpers.h
+++ b/src/fsfw/cfdp/helpers.h
@ -0,0 +1,11 @@
+#ifndef FSFW_EXAMPLE_HOSTED_HELPER_H
+#define FSFW_EXAMPLE_HOSTED_HELPER_H
+
+#include "definitions.h"
+
+namespace cfdp {
+
+const char* getConditionCodeString(cfdp::ConditionCode code);
+
+}
+#endif  // FSFW_EXAMPLE_HOSTED_HELPER_H
--- a/src/fsfw/cfdp/pdu/AckInfo.cpp
+++ b/src/fsfw/cfdp/pdu/AckInfo.cpp
@ -1,12 +1,12 @@
 #include "AckInfo.h"

-AckInfo::AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedConditionCode,
+AckInfo::AckInfo(cfdp::FileDirective ackedDirective, cfdp::ConditionCode ackedConditionCode,
                 cfdp::AckTransactionStatus transactionStatus, uint8_t directiveSubtypeCode)
    : ackedDirective(ackedDirective),
      ackedConditionCode(ackedConditionCode),
      transactionStatus(transactionStatus),
      directiveSubtypeCode(directiveSubtypeCode) {
-  if (ackedDirective == cfdp::FileDirectives::FINISH) {
+  if (ackedDirective == cfdp::FileDirective::FINISH) {
    this->directiveSubtypeCode = 0b0001;
  } else {
    this->directiveSubtypeCode = 0b0000;
@ -17,16 +17,16 @@ cfdp::ConditionCode AckInfo::getAckedConditionCode() const { return ackedConditi

 void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
  this->ackedConditionCode = ackedConditionCode;
-  if (ackedDirective == cfdp::FileDirectives::FINISH) {
+  if (ackedDirective == cfdp::FileDirective::FINISH) {
    this->directiveSubtypeCode = 0b0001;
  } else {
    this->directiveSubtypeCode = 0b0000;
  }
 }

-cfdp::FileDirectives AckInfo::getAckedDirective() const { return ackedDirective; }
+cfdp::FileDirective AckInfo::getAckedDirective() const { return ackedDirective; }

-void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective) {
+void AckInfo::setAckedDirective(cfdp::FileDirective ackedDirective) {
  this->ackedDirective = ackedDirective;
 }

--- a/src/fsfw/cfdp/pdu/AckInfo.h
+++ b/src/fsfw/cfdp/pdu/AckInfo.h
@ -6,14 +6,14 @@
 class AckInfo {
 public:
  AckInfo();
-  AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedConditionCode,
+  AckInfo(cfdp::FileDirective ackedDirective, cfdp::ConditionCode ackedConditionCode,
          cfdp::AckTransactionStatus transactionStatus, uint8_t directiveSubtypeCode = 0);

  cfdp::ConditionCode getAckedConditionCode() const;
  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode);

-  cfdp::FileDirectives getAckedDirective() const;
-  void setAckedDirective(cfdp::FileDirectives ackedDirective);
+  cfdp::FileDirective getAckedDirective() const;
+  void setAckedDirective(cfdp::FileDirective ackedDirective);

  uint8_t getDirectiveSubtypeCode() const;
  void setDirectiveSubtypeCode(uint8_t directiveSubtypeCode);
@ -22,7 +22,7 @@ class AckInfo {
  void setTransactionStatus(cfdp::AckTransactionStatus transactionStatus);

 private:
-  cfdp::FileDirectives ackedDirective = cfdp::FileDirectives::INVALID_DIRECTIVE;
+  cfdp::FileDirective ackedDirective = cfdp::FileDirective::INVALID_DIRECTIVE;
  cfdp::ConditionCode ackedConditionCode = cfdp::ConditionCode::NO_CONDITION_FIELD;
  cfdp::AckTransactionStatus transactionStatus = cfdp::AckTransactionStatus::UNDEFINED;
  uint8_t directiveSubtypeCode = 0;
--- a/src/fsfw/cfdp/pdu/AckPduCreator.cpp
+++ b/src/fsfw/cfdp/pdu/AckPduCreator.cpp
@ -0,0 +1,33 @@
+#include "AckPduCreator.h"
+
+AckPduCreator::AckPduCreator(AckInfo &ackInfo, PduConfig &pduConf)
+    : FileDirectiveCreator(pduConf, cfdp::FileDirective::ACK, 2), ackInfo(ackInfo) {}
+
+size_t AckPduCreator::getSerializedSize() const { return FileDirectiveCreator::getWholePduSize(); }
+
+ReturnValue_t AckPduCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                       Endianness streamEndianness) const {
+  ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  cfdp::FileDirective ackedDirective = ackInfo.getAckedDirective();
+  uint8_t directiveSubtypeCode = ackInfo.getDirectiveSubtypeCode();
+  cfdp::ConditionCode ackedConditionCode = ackInfo.getAckedConditionCode();
+  cfdp::AckTransactionStatus transactionStatus = ackInfo.getTransactionStatus();
+  if (ackedDirective != cfdp::FileDirective::FINISH and
+      ackedDirective != cfdp::FileDirective::EOF_DIRECTIVE) {
+    // TODO: better returncode
+    return returnvalue::FAILED;
+  }
+  if (*size + 2 > maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  **buffer = ackedDirective << 4 | directiveSubtypeCode;
+  *buffer += 1;
+  *size += 1;
+  **buffer = ackedConditionCode << 4 | transactionStatus;
+  *buffer += 1;
+  *size += 1;
+  return returnvalue::OK;
+}
--- a/src/fsfw/cfdp/pdu/AckPduSerializer.h
+++ b/src/fsfw/cfdp/pdu/AckPduSerializer.h
@ -1,11 +1,11 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_
+#ifndef FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_
+#define FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_

 #include "AckInfo.h"
-#include "FileDirectiveDeserializer.h"
-#include "FileDirectiveSerializer.h"
+#include "FileDirectiveCreator.h"
+#include "FileDirectiveReader.h"

-class AckPduSerializer : public FileDirectiveSerializer {
+class AckPduCreator : public FileDirectiveCreator {
 public:
  /**
   * @brief   Serializer to pack ACK PDUs
@ -16,9 +16,9 @@ class AckPduSerializer : public FileDirectiveSerializer {
   * @param transactionStatus
   * @param pduConf
   */
-  AckPduSerializer(AckInfo& ackInfo, PduConfig& pduConf);
+  AckPduCreator(AckInfo& ackInfo, PduConfig& pduConf);

-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;

  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          Endianness streamEndianness) const override;
@ -27,4 +27,4 @@ class AckPduSerializer : public FileDirectiveSerializer {
  AckInfo& ackInfo;
 };

-#endif /* FSFW_SRC_FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_ */
+#endif /* FSFW_CFDP_PDU_ACKPDUSERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/AckPduDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/AckPduDeserializer.cpp
@ -1,37 +0,0 @@
-#include "AckPduDeserializer.h"
-
-AckPduDeserializer::AckPduDeserializer(const uint8_t* pduBuf, size_t maxSize, AckInfo& info)
-    : FileDirectiveDeserializer(pduBuf, maxSize), info(info) {}
-
-ReturnValue_t AckPduDeserializer::parseData() {
-  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
-  if (currentIdx + 2 > this->maxSize) {
-    return SerializeIF::BUFFER_TOO_SHORT;
-  }
-  if (not checkAndSetCodes(rawPtr[currentIdx], rawPtr[currentIdx + 1])) {
-    return cfdp::INVALID_ACK_DIRECTIVE_FIELDS;
-  }
-  return returnvalue::OK;
-}
-
-bool AckPduDeserializer::checkAndSetCodes(uint8_t firstByte, uint8_t secondByte) {
-  uint8_t ackedDirective = static_cast<cfdp::FileDirectives>(firstByte >> 4);
-
-  if (ackedDirective != cfdp::FileDirectives::EOF_DIRECTIVE and
-      ackedDirective != cfdp::FileDirectives::FINISH) {
-    return false;
-  }
-  this->info.setAckedDirective(static_cast<cfdp::FileDirectives>(ackedDirective));
-  uint8_t directiveSubtypeCode = firstByte & 0x0f;
-  if (directiveSubtypeCode != 0b0000 and directiveSubtypeCode != 0b0001) {
-    return false;
-  }
-  this->info.setDirectiveSubtypeCode(directiveSubtypeCode);
-  this->info.setAckedConditionCode(static_cast<cfdp::ConditionCode>(secondByte >> 4));
-  this->info.setTransactionStatus(static_cast<cfdp::AckTransactionStatus>(secondByte & 0x0f));
-  return true;
-}
--- a/src/fsfw/cfdp/pdu/AckPduReader.cpp
+++ b/src/fsfw/cfdp/pdu/AckPduReader.cpp
@ -0,0 +1,45 @@
+#include "AckPduReader.h"
+
+AckPduReader::AckPduReader(const uint8_t* pduBuf, size_t maxSize, AckInfo& info)
+    : FileDirectiveReader(pduBuf, maxSize), info(info) {}
+
+ReturnValue_t AckPduReader::parseData() {
+  ReturnValue_t result = FileDirectiveReader::parseData();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  size_t currentIdx = FileDirectiveReader::getHeaderSize();
+  if (currentIdx + 2 > this->maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  if (not checkAndSetCodes(pointers.rawPtr[currentIdx], pointers.rawPtr[currentIdx + 1])) {
+    return cfdp::INVALID_ACK_DIRECTIVE_FIELDS;
+  }
+  return returnvalue::OK;
+}
+
+bool AckPduReader::checkAndSetCodes(uint8_t firstByte, uint8_t secondByte) {
+  cfdp::FileDirective directive;
+  if (not checkAckedDirectiveField(firstByte, directive)) {
+    return false;
+  }
+  this->info.setAckedDirective(directive);
+  uint8_t directiveSubtypeCode = firstByte & 0x0f;
+  if (directiveSubtypeCode != 0b0000 and directiveSubtypeCode != 0b0001) {
+    return false;
+  }
+  this->info.setDirectiveSubtypeCode(directiveSubtypeCode);
+  this->info.setAckedConditionCode(static_cast<cfdp::ConditionCode>(secondByte >> 4));
+  this->info.setTransactionStatus(static_cast<cfdp::AckTransactionStatus>(secondByte & 0x0f));
+  return true;
+}
+bool AckPduReader::checkAckedDirectiveField(uint8_t firstPduDataByte,
+                                            cfdp::FileDirective& ackedDirective) {
+  uint8_t ackedDirectiveRaw = static_cast<cfdp::FileDirective>(firstPduDataByte >> 4);
+  if (ackedDirectiveRaw != cfdp::FileDirective::EOF_DIRECTIVE and
+      ackedDirectiveRaw != cfdp::FileDirective::FINISH) {
+    return false;
+  }
+  ackedDirective = (static_cast<cfdp::FileDirective>(ackedDirectiveRaw));
+  return true;
+}
--- a/src/fsfw/cfdp/pdu/AckPduDeserializer.h
+++ b/src/fsfw/cfdp/pdu/AckPduDeserializer.h
@ -2,18 +2,21 @@
 #define FSFW_SRC_FSFW_CFDP_PDU_ACKPDUDESERIALIZER_H_

 #include "AckInfo.h"
-#include "fsfw/cfdp/pdu/FileDirectiveDeserializer.h"
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"

-class AckPduDeserializer : public FileDirectiveDeserializer {
+class AckPduReader : public FileDirectiveReader {
 public:
-  AckPduDeserializer(const uint8_t* pduBuf, size_t maxSize, AckInfo& info);
+  AckPduReader(const uint8_t* pduBuf, size_t maxSize, AckInfo& info);

  /**
   *
   * @return
   *  - cfdp::INVALID_DIRECTIVE_FIELDS: Invalid fields
   */
-  ReturnValue_t parseData();
+  ReturnValue_t parseData() override;
+
+  static bool checkAckedDirectiveField(uint8_t firstPduDataByte,
+                                       cfdp::FileDirective& ackedDirective);

 private:
  bool checkAndSetCodes(uint8_t rawAckedByte, uint8_t rawAckedConditionCode);
--- a/src/fsfw/cfdp/pdu/AckPduSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/AckPduSerializer.cpp
@ -1,36 +0,0 @@
-#include "AckPduSerializer.h"
-
-AckPduSerializer::AckPduSerializer(AckInfo &ackInfo, PduConfig &pduConf)
-    : FileDirectiveSerializer(pduConf, cfdp::FileDirectives::ACK, 2), ackInfo(ackInfo) {}
-
-size_t AckPduSerializer::getSerializedSize() const {
-  return FileDirectiveSerializer::getWholePduSize();
-}
-
-ReturnValue_t AckPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                          Endianness streamEndianness) const {
-  ReturnValue_t result =
-      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  cfdp::FileDirectives ackedDirective = ackInfo.getAckedDirective();
-  uint8_t directiveSubtypeCode = ackInfo.getDirectiveSubtypeCode();
-  cfdp::ConditionCode ackedConditionCode = ackInfo.getAckedConditionCode();
-  cfdp::AckTransactionStatus transactionStatus = ackInfo.getTransactionStatus();
-  if (ackedDirective != cfdp::FileDirectives::FINISH and
-      ackedDirective != cfdp::FileDirectives::EOF_DIRECTIVE) {
-    // TODO: better returncode
-    return returnvalue::FAILED;
-  }
-  if (*size + 2 > maxSize) {
-    return SerializeIF::BUFFER_TOO_SHORT;
-  }
-  **buffer = ackedDirective << 4 | directiveSubtypeCode;
-  *buffer += 1;
-  *size += 1;
-  **buffer = ackedConditionCode << 4 | transactionStatus;
-  *buffer += 1;
-  *size += 1;
-  return returnvalue::OK;
-}
--- a/src/fsfw/cfdp/pdu/CMakeLists.txt
+++ b/src/fsfw/cfdp/pdu/CMakeLists.txt
@ -1,30 +1,29 @@
 target_sources(
  ${LIB_FSFW_NAME}
  PRIVATE PduConfig.cpp
-          VarLenField.cpp
-          HeaderSerializer.cpp
-          HeaderDeserializer.cpp
-          FileDirectiveDeserializer.cpp
-          FileDirectiveSerializer.cpp
+          HeaderCreator.cpp
+          HeaderReader.cpp
+          FileDirectiveReader.cpp
+          FileDirectiveCreator.cpp
          AckInfo.cpp
-          AckPduSerializer.cpp
-          AckPduDeserializer.cpp
+          AckPduCreator.cpp
+          AckPduReader.cpp
          EofInfo.cpp
-          EofPduSerializer.cpp
-          EofPduDeserializer.cpp
+          EofPduCreator.cpp
+          EofPduReader.cpp
          NakInfo.cpp
-          NakPduSerializer.cpp
-          NakPduDeserializer.cpp
+          NakPduCreator.cpp
+          NakPduReader.cpp
          FinishedInfo.cpp
-          FinishedPduSerializer.cpp
-          FinishedPduDeserializer.cpp
-          MetadataInfo.cpp
-          MetadataPduSerializer.cpp
-          MetadataPduDeserializer.cpp
-          KeepAlivePduSerializer.cpp
-          KeepAlivePduDeserializer.cpp
-          PromptPduSerializer.cpp
-          PromptPduDeserializer.cpp
-          FileDataSerializer.cpp
-          FileDataDeserializer.cpp
+          FinishedPduCreator.cpp
+          FinishedPduReader.cpp
+          MetadataGenericInfo.cpp
+          MetadataPduCreator.cpp
+          MetadataPduReader.cpp
+          KeepAlivePduCreator.cpp
+          KeepAlivePduReader.cpp
+          PromptPduCreator.cpp
+          PromptPduReader.cpp
+          FileDataCreator.cpp
+          FileDataReader.cpp
          FileDataInfo.cpp)
--- a/src/fsfw/cfdp/pdu/EofInfo.cpp
+++ b/src/fsfw/cfdp/pdu/EofInfo.cpp
@ -1,8 +1,13 @@
 #include "EofInfo.h"

-EofInfo::EofInfo(cfdp::ConditionCode conditionCode, uint32_t checksum, cfdp::FileSize fileSize,
+#include <utility>
+
+EofInfo::EofInfo(cfdp::ConditionCode conditionCode, uint32_t checksum, cfdp::Fss fileSize,
                 EntityIdTlv* faultLoc)
-    : conditionCode(conditionCode), checksum(checksum), fileSize(fileSize), faultLoc(faultLoc) {}
+    : conditionCode(conditionCode),
+      checksum(checksum),
+      fileSize(std::move(fileSize)),
+      faultLoc(faultLoc) {}

 EofInfo::EofInfo(EntityIdTlv* faultLoc)
    : conditionCode(cfdp::ConditionCode::NO_CONDITION_FIELD),
@ -16,15 +21,15 @@ cfdp::ConditionCode EofInfo::getConditionCode() const { return conditionCode; }

 EntityIdTlv* EofInfo::getFaultLoc() const { return faultLoc; }

-cfdp::FileSize& EofInfo::getFileSize() { return fileSize; }
+cfdp::Fss& EofInfo::getFileSize() { return fileSize; }

-void EofInfo::setChecksum(uint32_t checksum) { this->checksum = checksum; }
+void EofInfo::setChecksum(uint32_t checksum_) { this->checksum = checksum_; }

-void EofInfo::setConditionCode(cfdp::ConditionCode conditionCode) {
-  this->conditionCode = conditionCode;
+void EofInfo::setConditionCode(cfdp::ConditionCode conditionCode_) {
+  this->conditionCode = conditionCode_;
 }

-void EofInfo::setFaultLoc(EntityIdTlv* faultLoc) { this->faultLoc = faultLoc; }
+void EofInfo::setFaultLoc(EntityIdTlv* faultLoc_) { this->faultLoc = faultLoc_; }

 size_t EofInfo::getSerializedSize(bool fssLarge) {
  // Condition code + spare + 4 byte checksum
@ -42,6 +47,6 @@ size_t EofInfo::getSerializedSize(bool fssLarge) {
  return size;
 }

-ReturnValue_t EofInfo::setFileSize(size_t fileSize, bool isLarge) {
-  return this->fileSize.setFileSize(fileSize, isLarge);
+ReturnValue_t EofInfo::setFileSize(size_t fileSize_, bool isLarge) {
+  return this->fileSize.setFileSize(fileSize_, isLarge);
 }
--- a/src/fsfw/cfdp/pdu/EofInfo.h
+++ b/src/fsfw/cfdp/pdu/EofInfo.h
@ -1,23 +1,23 @@
 #ifndef FSFW_SRC_FSFW_CFDP_PDU_EOFINFO_H_
 #define FSFW_SRC_FSFW_CFDP_PDU_EOFINFO_H_

-#include "../FileSize.h"
+#include "../Fss.h"
 #include "../definitions.h"
 #include "fsfw/cfdp/tlv/EntityIdTlv.h"

 struct EofInfo {
 public:
-  EofInfo(EntityIdTlv* faultLoc = nullptr);
-  EofInfo(cfdp::ConditionCode conditionCode, uint32_t checksum, cfdp::FileSize fileSize,
+  explicit EofInfo(EntityIdTlv* faultLoc = nullptr);
+  EofInfo(cfdp::ConditionCode conditionCode, uint32_t checksum, cfdp::Fss fileSize,
          EntityIdTlv* faultLoc = nullptr);

  size_t getSerializedSize(bool fssLarge = false);

-  uint32_t getChecksum() const;
-  cfdp::ConditionCode getConditionCode() const;
+  [[nodiscard]] uint32_t getChecksum() const;
+  [[nodiscard]] cfdp::ConditionCode getConditionCode() const;

-  EntityIdTlv* getFaultLoc() const;
-  cfdp::FileSize& getFileSize();
+  [[nodiscard]] EntityIdTlv* getFaultLoc() const;
+  cfdp::Fss& getFileSize();
  void setChecksum(uint32_t checksum);
  void setConditionCode(cfdp::ConditionCode conditionCode);
  void setFaultLoc(EntityIdTlv* faultLoc);
@ -26,7 +26,7 @@ struct EofInfo {
 private:
  cfdp::ConditionCode conditionCode;
  uint32_t checksum;
-  cfdp::FileSize fileSize;
+  cfdp::Fss fileSize;
  EntityIdTlv* faultLoc = nullptr;
 };

--- a/src/fsfw/cfdp/pdu/EofPduSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/EofPduSerializer.cpp
@ -1,21 +1,17 @@
-#include "EofPduSerializer.h"
+#include "EofPduCreator.h"

 #include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"

-EofPduSerializer::EofPduSerializer(PduConfig &conf, EofInfo &info)
-    : FileDirectiveSerializer(conf, cfdp::FileDirectives::EOF_DIRECTIVE, 9), info(info) {
-  setDirectiveDataFieldLen(info.getSerializedSize(getLargeFileFlag()));
+EofPduCreator::EofPduCreator(PduConfig &conf, EofInfo &info)
+    : FileDirectiveCreator(conf, cfdp::FileDirective::EOF_DIRECTIVE, 9), info(info) {
+  setDirectiveDataFieldLen(info.getSerializedSize(HeaderCreator::getLargeFileFlag()));
 }

-size_t EofPduSerializer::getSerializedSize() const {
-  return FileDirectiveSerializer::getWholePduSize();
-}
+size_t EofPduCreator::getSerializedSize() const { return FileDirectiveCreator::getWholePduSize(); }

-ReturnValue_t EofPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                          Endianness streamEndianness) const {
-  ReturnValue_t result =
-      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
+ReturnValue_t EofPduCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                       Endianness streamEndianness) const {
+  ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
  }
--- a/src/fsfw/cfdp/pdu/EofPduSerializer.h
+++ b/src/fsfw/cfdp/pdu/EofPduSerializer.h
@ -2,18 +2,20 @@
 #define FSFW_SRC_FSFW_CFDP_PDU_EOFPDUSERIALIZER_H_

 #include "EofInfo.h"
-#include "fsfw/cfdp/pdu/FileDirectiveSerializer.h"
+#include "fsfw/cfdp/pdu/FileDirectiveCreator.h"
 #include "fsfw/cfdp/tlv/EntityIdTlv.h"

-class EofPduSerializer : public FileDirectiveSerializer {
+class EofPduCreator : public FileDirectiveCreator {
 public:
-  EofPduSerializer(PduConfig& conf, EofInfo& info);
+  EofPduCreator(PduConfig& conf, EofInfo& info);

-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;

  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          Endianness streamEndianness) const override;

+  using FileDirectiveCreator::serialize;
+
 private:
  EofInfo& info;
 };
--- a/src/fsfw/cfdp/pdu/EofPduDeserializer.h
+++ b/src/fsfw/cfdp/pdu/EofPduDeserializer.h
@ -1,17 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_
-
-#include "EofInfo.h"
-#include "fsfw/cfdp/pdu/FileDirectiveDeserializer.h"
-
-class EofPduDeserializer : public FileDirectiveDeserializer {
- public:
-  EofPduDeserializer(const uint8_t* pduBuf, size_t maxSize, EofInfo& eofInfo);
-
-  virtual ReturnValue_t parseData() override;
-
- private:
-  EofInfo& info;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/EofPduDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/EofPduDeserializer.cpp
@ -1,23 +1,23 @@
-#include "EofPduDeserializer.h"
+#include "EofPduReader.h"

 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"

-EofPduDeserializer::EofPduDeserializer(const uint8_t* pduBuf, size_t maxSize, EofInfo& eofInfo)
-    : FileDirectiveDeserializer(pduBuf, maxSize), info(eofInfo) {}
+EofPduReader::EofPduReader(const uint8_t* pduBuf, size_t maxSize, EofInfo& eofInfo)
+    : FileDirectiveReader(pduBuf, maxSize), info(eofInfo) {}

-ReturnValue_t EofPduDeserializer::parseData() {
-  ReturnValue_t result = FileDirectiveDeserializer::parseData();
+ReturnValue_t EofPduReader::parseData() {
+  ReturnValue_t result = FileDirectiveReader::parseData();
  if (result != returnvalue::OK) {
    return result;
  }

-  const uint8_t* bufPtr = rawPtr;
+  const uint8_t* bufPtr = pointers.rawPtr;
  size_t expectedFileFieldLen = 4;
  if (this->getLargeFileFlag()) {
    expectedFileFieldLen = 8;
  }
-  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
+  size_t currentIdx = FileDirectiveReader::getHeaderSize();
  size_t deserLen = maxSize;
  if (maxSize < currentIdx + 5 + expectedFileFieldLen) {
    return SerializeIF::STREAM_TOO_SHORT;
--- a/src/fsfw/cfdp/pdu/EofPduReader.h
+++ b/src/fsfw/cfdp/pdu/EofPduReader.h
@ -0,0 +1,17 @@
+#ifndef FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_
+#define FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_
+
+#include "EofInfo.h"
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"
+
+class EofPduReader : public FileDirectiveReader {
+ public:
+  EofPduReader(const uint8_t* pduBuf, size_t maxSize, EofInfo& eofInfo);
+
+  ReturnValue_t parseData() override;
+
+ private:
+  EofInfo& info;
+};
+
+#endif /* FSFW_SRC_FSFW_CFDP_PDU_EOFPDUDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FileDataSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/FileDataSerializer.cpp
@ -1,28 +1,31 @@
-#include "FileDataSerializer.h"
+#include "FileDataCreator.h"

 #include <cstring>

-FileDataSerializer::FileDataSerializer(PduConfig& conf, FileDataInfo& info)
-    : HeaderSerializer(conf, cfdp::PduType::FILE_DATA, 0, info.getSegmentMetadataFlag()),
-      info(info) {
+FileDataCreator::FileDataCreator(PduConfig& conf, FileDataInfo& info)
+    : HeaderCreator(conf, cfdp::PduType::FILE_DATA, 0, info.getSegmentMetadataFlag()), info(info) {
  update();
 }

-void FileDataSerializer::update() {
+void FileDataCreator::update() {
  this->setSegmentMetadataFlag(info.getSegmentMetadataFlag());
  this->setSegmentationControl(info.getSegmentationControl());
  setPduDataFieldLen(info.getSerializedSize(this->getLargeFileFlag()));
 }

-ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                            Endianness streamEndianness) const {
-  ReturnValue_t result = HeaderSerializer::serialize(buffer, size, maxSize, streamEndianness);
+ReturnValue_t FileDataCreator::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                         Endianness streamEndianness) const {
+  if (buffer == nullptr or size == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (*size + getSerializedSize() > maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  ReturnValue_t result = HeaderCreator::serialize(buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
  }
-  if (*size + this->getSerializedSize() > maxSize) {
-    return SerializeIF::BUFFER_TOO_SHORT;
-  }
+
  const uint8_t* readOnlyPtr = nullptr;
  if (this->hasSegmentMetadataFlag()) {
    size_t segmentMetadataLen = info.getSegmentMetadataLen();
@ -34,7 +37,7 @@ ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size
    *buffer += segmentMetadataLen;
    *size += segmentMetadataLen;
  }
-  cfdp::FileSize& offset = info.getOffset();
+  cfdp::Fss& offset = info.getOffset();
  result = offset.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
@ -50,6 +53,6 @@ ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size
  return returnvalue::OK;
 }

-size_t FileDataSerializer::getSerializedSize() const {
-  return HeaderSerializer::getSerializedSize() + info.getSerializedSize(this->getLargeFileFlag());
+size_t FileDataCreator::getSerializedSize() const {
+  return HeaderCreator::getSerializedSize() + info.getSerializedSize(this->getLargeFileFlag());
 }
--- a/src/fsfw/cfdp/pdu/FileDataCreator.h
+++ b/src/fsfw/cfdp/pdu/FileDataCreator.h
@ -0,0 +1,27 @@
+#ifndef FSFW_CFDP_PDU_FILEDATASERIALIZER_H_
+#define FSFW_CFDP_PDU_FILEDATASERIALIZER_H_
+
+#include "../definitions.h"
+#include "FileDataInfo.h"
+#include "HeaderCreator.h"
+
+class FileDataCreator : public HeaderCreator {
+ public:
+  FileDataCreator(PduConfig& conf, FileDataInfo& info);
+
+  void update();
+
+  ReturnValue_t serialize(uint8_t* buf, size_t& serLen, size_t maxSize) const {
+    return SerializeIF::serialize(buf, serLen, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+
+  [[nodiscard]] size_t getSerializedSize() const override;
+
+ private:
+  FileDataInfo& info;
+};
+
+#endif /* FSFW_CFDP_PDU_FILEDATASERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FileDataInfo.cpp
+++ b/src/fsfw/cfdp/pdu/FileDataInfo.cpp
@ -1,9 +1,9 @@
 #include "FileDataInfo.h"

-FileDataInfo::FileDataInfo(cfdp::FileSize &offset, const uint8_t *fileData, size_t fileSize)
-    : offset(offset), fileData(fileData), fileSize(fileSize) {}
+#include <utility>

-FileDataInfo::FileDataInfo(cfdp::FileSize &offset) : offset(offset) {}
+FileDataInfo::FileDataInfo(cfdp::Fss offset, const uint8_t *fileData, size_t fileSize)
+    : offset(std::move(offset)), fileData(fileData), fileSize(fileSize) {}

 void FileDataInfo::setSegmentMetadataFlag(bool enable) {
  if (enable) {
@ -57,21 +57,21 @@ ReturnValue_t FileDataInfo::addSegmentMetadataInfo(cfdp::RecordContinuationState
  return returnvalue::OK;
 }

-const uint8_t *FileDataInfo::getFileData(size_t *fileSize) const {
-  if (fileSize != nullptr) {
-    *fileSize = this->fileSize;
+const uint8_t *FileDataInfo::getFileData(size_t *fileSize_) const {
+  if (fileSize_ != nullptr) {
+    *fileSize_ = this->fileSize;
  }
  return fileData;
 }

-const uint8_t *FileDataInfo::getSegmentMetadata(size_t *segmentMetadataLen) {
-  if (segmentMetadataLen != nullptr) {
-    *segmentMetadataLen = this->segmentMetadataLen;
+const uint8_t *FileDataInfo::getSegmentMetadata(size_t *segmentMetadataLen_) {
+  if (segmentMetadataLen_ != nullptr) {
+    *segmentMetadataLen_ = this->segmentMetadataLen;
  }
  return segmentMetadata;
 }

-cfdp::FileSize &FileDataInfo::getOffset() { return offset; }
+cfdp::Fss &FileDataInfo::getOffset() { return offset; }

 void FileDataInfo::setRecordContinuationState(cfdp::RecordContinuationState recContState) {
  this->recContState = recContState;
--- a/src/fsfw/cfdp/pdu/FileDataInfo.h
+++ b/src/fsfw/cfdp/pdu/FileDataInfo.h
@ -1,30 +1,30 @@
 #ifndef FSFW_SRC_FSFW_CFDP_PDU_FILEDATAINFO_H_
 #define FSFW_SRC_FSFW_CFDP_PDU_FILEDATAINFO_H_

-#include <fsfw/cfdp/FileSize.h>
+#include <fsfw/cfdp/Fss.h>
 #include <fsfw/cfdp/definitions.h>

 class FileDataInfo {
 public:
-  FileDataInfo(cfdp::FileSize& offset);
-  FileDataInfo(cfdp::FileSize& offset, const uint8_t* fileData, size_t fileSize);
+  FileDataInfo() = default;
+  FileDataInfo(cfdp::Fss offset, const uint8_t* fileData, size_t fileSize);

-  size_t getSerializedSize(bool largeFile = false) const;
+  [[nodiscard]] size_t getSerializedSize(bool largeFile = false) const;

-  cfdp::FileSize& getOffset();
+  cfdp::Fss& getOffset();
  const uint8_t* getFileData(size_t* fileSize = nullptr) const;
  void setFileData(const uint8_t* fileData, size_t fileSize);

-  cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const;
-  cfdp::SegmentationControl getSegmentationControl() const;
-  cfdp::RecordContinuationState getRecordContinuationState() const;
+  [[nodiscard]] cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const;
+  [[nodiscard]] cfdp::SegmentationControl getSegmentationControl() const;
+  [[nodiscard]] cfdp::RecordContinuationState getRecordContinuationState() const;
  void setRecordContinuationState(cfdp::RecordContinuationState recContState);
  void setSegmentationControl(cfdp::SegmentationControl segCtrl);

-  size_t getSegmentMetadataLen() const;
+  [[nodiscard]] size_t getSegmentMetadataLen() const;
  void setSegmentMetadataLen(size_t len);
  void setSegmentMetadata(const uint8_t* ptr);
-  bool hasSegmentMetadata() const;
+  [[nodiscard]] bool hasSegmentMetadata() const;
  void setSegmentMetadataFlag(bool enable);
  ReturnValue_t addSegmentMetadataInfo(cfdp::RecordContinuationState recContState,
                                       const uint8_t* segmentMetadata, size_t segmentMetadataLen);
@ -33,7 +33,7 @@ class FileDataInfo {
 private:
  cfdp::SegmentMetadataFlag segmentMetadataFlag = cfdp::SegmentMetadataFlag::NOT_PRESENT;
  cfdp::SegmentationControl segCtrl = cfdp::SegmentationControl::NO_RECORD_BOUNDARIES_PRESERVATION;
-  cfdp::FileSize& offset;
+  cfdp::Fss offset;
  const uint8_t* fileData = nullptr;
  size_t fileSize = 0;
  cfdp::RecordContinuationState recContState = cfdp::RecordContinuationState::NO_START_NO_END;
--- a/src/fsfw/cfdp/pdu/FileDataDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/FileDataDeserializer.cpp
@ -1,17 +1,16 @@
-#include "FileDataDeserializer.h"
+#include "FileDataReader.h"

-FileDataDeserializer::FileDataDeserializer(const uint8_t* pduBuf, size_t maxSize,
-                                           FileDataInfo& info)
-    : HeaderDeserializer(pduBuf, maxSize), info(info) {}
+FileDataReader::FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info)
+    : PduHeaderReader(pduBuf, maxSize), info(info) {}

-ReturnValue_t FileDataDeserializer::parseData() {
-  ReturnValue_t result = HeaderDeserializer::parseData();
+ReturnValue_t FileDataReader::parseData() {
+  ReturnValue_t result = PduHeaderReader::parseData();
  if (result != returnvalue::OK) {
    return result;
  }
-  size_t currentIdx = HeaderDeserializer::getHeaderSize();
-  const uint8_t* buf = rawPtr + currentIdx;
-  size_t remSize = HeaderDeserializer::getWholePduSize() - currentIdx;
+  size_t currentIdx = PduHeaderReader::getHeaderSize();
+  const uint8_t* buf = pointers.rawPtr + currentIdx;
+  size_t remSize = PduHeaderReader::getWholePduSize() - currentIdx;
  if (remSize < 1) {
    return SerializeIF::STREAM_TOO_SHORT;
  }
@ -41,8 +40,8 @@ ReturnValue_t FileDataDeserializer::parseData() {
  return returnvalue::OK;
 }

-SerializeIF::Endianness FileDataDeserializer::getEndianness() const { return endianness; }
+SerializeIF::Endianness FileDataReader::getEndianness() const { return endianness; }

-void FileDataDeserializer::setEndianness(SerializeIF::Endianness endianness) {
-  this->endianness = endianness;
+void FileDataReader::setEndianness(SerializeIF::Endianness endianness_) {
+  endianness = endianness_;
 }
--- a/src/fsfw/cfdp/pdu/FileDataDeserializer.h
+++ b/src/fsfw/cfdp/pdu/FileDataDeserializer.h
@ -3,14 +3,14 @@

 #include "../definitions.h"
 #include "FileDataInfo.h"
-#include "HeaderDeserializer.h"
+#include "PduHeaderReader.h"

-class FileDataDeserializer : public HeaderDeserializer {
+class FileDataReader : public PduHeaderReader {
 public:
-  FileDataDeserializer(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info);
+  FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info);

-  ReturnValue_t parseData();
-  SerializeIF::Endianness getEndianness() const;
+  ReturnValue_t parseData() override;
+  [[nodiscard]] SerializeIF::Endianness getEndianness() const;
  void setEndianness(SerializeIF::Endianness endianness = SerializeIF::Endianness::NETWORK);

 private:
--- a/src/fsfw/cfdp/pdu/FileDataSerializer.h
+++ b/src/fsfw/cfdp/pdu/FileDataSerializer.h
@ -1,23 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_FILEDATASERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_FILEDATASERIALIZER_H_
-
-#include "../definitions.h"
-#include "FileDataInfo.h"
-#include "HeaderSerializer.h"
-
-class FileDataSerializer : public HeaderSerializer {
- public:
-  FileDataSerializer(PduConfig& conf, FileDataInfo& info);
-
-  void update();
-
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override;
-
-  size_t getSerializedSize() const override;
-
- private:
-  FileDataInfo& info;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_FILEDATADESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FileDirectiveCreator.cpp
+++ b/src/fsfw/cfdp/pdu/FileDirectiveCreator.cpp
@ -0,0 +1,39 @@
+#include "FileDirectiveCreator.h"
+
+FileDirectiveCreator::FileDirectiveCreator(PduConfig &pduConf, cfdp::FileDirective directiveCode,
+                                           size_t directiveParamFieldLen)
+    : HeaderCreator(pduConf, cfdp::PduType::FILE_DIRECTIVE, directiveParamFieldLen + 1),
+      directiveCode(directiveCode) {}
+
+size_t FileDirectiveCreator::getSerializedSize() const {
+  return HeaderCreator::getSerializedSize() + 1;
+}
+
+ReturnValue_t FileDirectiveCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                              Endianness streamEndianness) const {
+  if (buffer == nullptr or size == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (FileDirectiveCreator::getWholePduSize() > maxSize) {
+    return BUFFER_TOO_SHORT;
+  }
+  ReturnValue_t result = HeaderCreator::serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  if (*size >= maxSize) {
+    return BUFFER_TOO_SHORT;
+  }
+  **buffer = directiveCode;
+  *buffer += 1;
+  *size += 1;
+  return returnvalue::OK;
+}
+
+void FileDirectiveCreator::setDirectiveDataFieldLen(size_t len) {
+  // Set length of data field plus 1 byte for the directive octet
+  HeaderCreator::setPduDataFieldLen(len + 1);
+}
+
+cfdp::FileDirective FileDirectiveCreator::getDirectiveCode() const { return directiveCode; }
--- a/src/fsfw/cfdp/pdu/FileDirectiveCreator.h
+++ b/src/fsfw/cfdp/pdu/FileDirectiveCreator.h
@ -0,0 +1,34 @@
+#ifndef FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_
+#define FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_
+
+#include "fsfw/cfdp/pdu/HeaderCreator.h"
+
+class FileDirectiveCreator : public HeaderCreator {
+ public:
+  FileDirectiveCreator(PduConfig& pduConf, cfdp::FileDirective directiveCode,
+                       size_t directiveParamFieldLen);
+
+  [[nodiscard]] cfdp::FileDirective getDirectiveCode() const;
+
+  /**
+   * This only returns the size of the PDU header + 1 for the directive code octet.
+   * Use FileDirectiveCreator::getWholePduSize to get the full packet length, assuming
+   * the length fields was set correctly
+   * @return
+   */
+  [[nodiscard]] size_t getSerializedSize() const override;
+
+  [[nodiscard]] ReturnValue_t serialize(uint8_t* buffer, size_t& serLen, size_t maxSize) const {
+    return SerializeIF::serialize(buffer, serLen, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+
+  void setDirectiveDataFieldLen(size_t len);
+
+ private:
+  cfdp::FileDirective directiveCode = cfdp::FileDirective::INVALID_DIRECTIVE;
+};
+
+#endif /* FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FileDirectiveDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/FileDirectiveDeserializer.cpp
@ -1,49 +0,0 @@
-#include "FileDirectiveDeserializer.h"
-
-FileDirectiveDeserializer::FileDirectiveDeserializer(const uint8_t *pduBuf, size_t maxSize)
-    : HeaderDeserializer(pduBuf, maxSize) {}
-
-cfdp::FileDirectives FileDirectiveDeserializer::getFileDirective() const { return fileDirective; }
-
-ReturnValue_t FileDirectiveDeserializer::parseData() {
-  ReturnValue_t result = HeaderDeserializer::parseData();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  if (this->getPduDataFieldLen() < 1) {
-    return cfdp::INVALID_PDU_DATAFIELD_LEN;
-  }
-  if (FileDirectiveDeserializer::getWholePduSize() > maxSize) {
-    return SerializeIF::STREAM_TOO_SHORT;
-  }
-  size_t currentIdx = HeaderDeserializer::getHeaderSize();
-  if (not checkFileDirective(rawPtr[currentIdx])) {
-    return cfdp::INVALID_DIRECTIVE_FIELDS;
-  }
-  setFileDirective(static_cast<cfdp::FileDirectives>(rawPtr[currentIdx]));
-  return returnvalue::OK;
-}
-
-size_t FileDirectiveDeserializer::getHeaderSize() const {
-  // return size of header plus the directive byte
-  return HeaderDeserializer::getHeaderSize() + 1;
-}
-
-bool FileDirectiveDeserializer::checkFileDirective(uint8_t rawByte) {
-  if (rawByte < cfdp::FileDirectives::EOF_DIRECTIVE or
-      (rawByte > cfdp::FileDirectives::PROMPT and rawByte != cfdp::FileDirectives::KEEP_ALIVE)) {
-    // Invalid directive field. TODO: Custom returnvalue
-    return false;
-  }
-  return true;
-}
-
-void FileDirectiveDeserializer::setFileDirective(cfdp::FileDirectives fileDirective) {
-  this->fileDirective = fileDirective;
-}
-
-void FileDirectiveDeserializer::setEndianness(SerializeIF::Endianness endianness) {
-  this->endianness = endianness;
-}
-
-SerializeIF::Endianness FileDirectiveDeserializer::getEndianness() const { return endianness; }
--- a/src/fsfw/cfdp/pdu/FileDirectiveReader.cpp
+++ b/src/fsfw/cfdp/pdu/FileDirectiveReader.cpp
@ -0,0 +1,49 @@
+#include "FileDirectiveReader.h"
+
+FileDirectiveReader::FileDirectiveReader(const uint8_t *pduBuf, size_t maxSize)
+    : PduHeaderReader(pduBuf, maxSize) {}
+
+cfdp::FileDirective FileDirectiveReader::getFileDirective() const { return fileDirective; }
+
+ReturnValue_t FileDirectiveReader::parseData() {
+  ReturnValue_t result = PduHeaderReader::parseData();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  if (this->getPduDataFieldLen() < 1) {
+    return cfdp::INVALID_PDU_DATAFIELD_LEN;
+  }
+  if (FileDirectiveReader::getWholePduSize() > maxSize) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  size_t currentIdx = PduHeaderReader::getHeaderSize();
+  if (not checkFileDirective(pointers.rawPtr[currentIdx])) {
+    return cfdp::INVALID_DIRECTIVE_FIELD;
+  }
+  setFileDirective(static_cast<cfdp::FileDirective>(pointers.rawPtr[currentIdx]));
+  return returnvalue::OK;
+}
+
+size_t FileDirectiveReader::getHeaderSize() const {
+  // return size of header plus the directive byte
+  return PduHeaderReader::getHeaderSize() + 1;
+}
+
+bool FileDirectiveReader::checkFileDirective(uint8_t rawByte) {
+  if (rawByte < cfdp::FileDirective::EOF_DIRECTIVE or
+      (rawByte > cfdp::FileDirective::PROMPT and rawByte != cfdp::FileDirective::KEEP_ALIVE)) {
+    // Invalid directive field
+    return false;
+  }
+  return true;
+}
+
+void FileDirectiveReader::setFileDirective(cfdp::FileDirective fileDirective_) {
+  fileDirective = fileDirective_;
+}
+
+void FileDirectiveReader::setEndianness(SerializeIF::Endianness endianness_) {
+  endianness = endianness_;
+}
+
+SerializeIF::Endianness FileDirectiveReader::getEndianness() const { return endianness; }
--- a/src/fsfw/cfdp/pdu/FileDirectiveDeserializer.h
+++ b/src/fsfw/cfdp/pdu/FileDirectiveDeserializer.h
@ -2,7 +2,7 @@
 #define FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVEDESERIALIZER_H_

 #include "../definitions.h"
-#include "fsfw/cfdp/pdu/HeaderDeserializer.h"
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"

 /**
 * @brief   This class is used to deserialize a PDU file directive header from raw memory.
@ -11,28 +11,27 @@
 * This is a zero-copy implementation and #parseData needs to be called to ensure the data is
 * valid.
 */
-class FileDirectiveDeserializer : public HeaderDeserializer {
+class FileDirectiveReader : public PduHeaderReader {
 public:
-  FileDirectiveDeserializer(const uint8_t* pduBuf, size_t maxSize);
+  FileDirectiveReader(const uint8_t* pduBuf, size_t maxSize);

  /**
   * This needs to be called before accessing the PDU fields to avoid segmentation faults.
   * @return
   */
-  virtual ReturnValue_t parseData();
-  size_t getHeaderSize() const;
+  ReturnValue_t parseData() override;
+  [[nodiscard]] size_t getHeaderSize() const override;

-  cfdp::FileDirectives getFileDirective() const;
+  [[nodiscard]] cfdp::FileDirective getFileDirective() const;

  void setEndianness(SerializeIF::Endianness endianness);
-  SerializeIF::Endianness getEndianness() const;
+  [[nodiscard]] SerializeIF::Endianness getEndianness() const;
+  static bool checkFileDirective(uint8_t rawByte);

 protected:
-  bool checkFileDirective(uint8_t rawByte);
-
 private:
-  void setFileDirective(cfdp::FileDirectives fileDirective);
-  cfdp::FileDirectives fileDirective = cfdp::FileDirectives::INVALID_DIRECTIVE;
+  void setFileDirective(cfdp::FileDirective fileDirective);
+  cfdp::FileDirective fileDirective = cfdp::FileDirective::INVALID_DIRECTIVE;
  SerializeIF::Endianness endianness = SerializeIF::Endianness::NETWORK;
 };

--- a/src/fsfw/cfdp/pdu/FileDirectiveSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/FileDirectiveSerializer.cpp
@ -1,38 +0,0 @@
-#include "FileDirectiveSerializer.h"
-
-FileDirectiveSerializer::FileDirectiveSerializer(PduConfig &pduConf,
-                                                 cfdp::FileDirectives directiveCode,
-                                                 size_t directiveParamFieldLen)
-    : HeaderSerializer(pduConf, cfdp::PduType::FILE_DIRECTIVE, directiveParamFieldLen + 1),
-      directiveCode(directiveCode) {}
-
-size_t FileDirectiveSerializer::getSerializedSize() const {
-  return HeaderSerializer::getSerializedSize() + 1;
-}
-
-ReturnValue_t FileDirectiveSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                                 Endianness streamEndianness) const {
-  if (buffer == nullptr or size == nullptr) {
-    return returnvalue::FAILED;
-  }
-  if (FileDirectiveSerializer::getWholePduSize() > maxSize) {
-    return BUFFER_TOO_SHORT;
-  }
-  ReturnValue_t result = HeaderSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  if (*size >= maxSize) {
-    return BUFFER_TOO_SHORT;
-  }
-  **buffer = directiveCode;
-  *buffer += 1;
-  *size += 1;
-  return returnvalue::OK;
-}
-
-void FileDirectiveSerializer::setDirectiveDataFieldLen(size_t len) {
-  // Set length of data field plus 1 byte for the directive octet
-  HeaderSerializer::setPduDataFieldLen(len + 1);
-}
--- a/src/fsfw/cfdp/pdu/FileDirectiveSerializer.h
+++ b/src/fsfw/cfdp/pdu/FileDirectiveSerializer.h
@ -1,28 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_
-
-#include "fsfw/cfdp/pdu/HeaderSerializer.h"
-
-class FileDirectiveSerializer : public HeaderSerializer {
- public:
-  FileDirectiveSerializer(PduConfig& pduConf, cfdp::FileDirectives directiveCode,
-                          size_t directiveParamFieldLen);
-
-  /**
-   * This only returns the size of the PDU header + 1 for the directive code octet.
-   * Use FileDirectiveSerializer::getWholePduSize to get the full packet length, assuming
-   * the length fields was set correctly
-   * @return
-   */
-  size_t getSerializedSize() const override;
-
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override;
-
-  void setDirectiveDataFieldLen(size_t len);
-
- private:
-  cfdp::FileDirectives directiveCode = cfdp::FileDirectives::INVALID_DIRECTIVE;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FinishedInfo.cpp
+++ b/src/fsfw/cfdp/pdu/FinishedInfo.cpp
@ -2,9 +2,8 @@

 FinishedInfo::FinishedInfo() {}

-FinishedInfo::FinishedInfo(cfdp::ConditionCode conditionCode,
-                           cfdp::FinishedDeliveryCode deliveryCode,
-                           cfdp::FinishedFileStatus fileStatus)
+FinishedInfo::FinishedInfo(cfdp::ConditionCode conditionCode, cfdp::FileDeliveryCode deliveryCode,
+                           cfdp::FileDeliveryStatus fileStatus)
    : conditionCode(conditionCode), deliveryCode(deliveryCode), fileStatus(fileStatus) {}

 size_t FinishedInfo::getSerializedSize() const {
@ -83,13 +82,13 @@ void FinishedInfo::setConditionCode(cfdp::ConditionCode conditionCode) {
  this->conditionCode = conditionCode;
 }

-cfdp::FinishedDeliveryCode FinishedInfo::getDeliveryCode() const { return deliveryCode; }
+cfdp::FileDeliveryCode FinishedInfo::getDeliveryCode() const { return deliveryCode; }

-void FinishedInfo::setDeliveryCode(cfdp::FinishedDeliveryCode deliveryCode) {
+void FinishedInfo::setDeliveryCode(cfdp::FileDeliveryCode deliveryCode) {
  this->deliveryCode = deliveryCode;
 }

-cfdp::FinishedFileStatus FinishedInfo::getFileStatus() const { return fileStatus; }
+cfdp::FileDeliveryStatus FinishedInfo::getFileStatus() const { return fileStatus; }

 void FinishedInfo::setFilestoreResponsesArrayLen(size_t fsResponsesLen) {
  this->fsResponsesLen = fsResponsesLen;
@ -97,6 +96,6 @@ void FinishedInfo::setFilestoreResponsesArrayLen(size_t fsResponsesLen) {

 size_t FinishedInfo::getFsResponsesLen() const { return fsResponsesLen; }

-void FinishedInfo::setFileStatus(cfdp::FinishedFileStatus fileStatus) {
+void FinishedInfo::setFileStatus(cfdp::FileDeliveryStatus fileStatus) {
  this->fileStatus = fileStatus;
 }
--- a/src/fsfw/cfdp/pdu/FinishedInfo.h
+++ b/src/fsfw/cfdp/pdu/FinishedInfo.h
@ -8,13 +8,13 @@
 class FinishedInfo {
 public:
  FinishedInfo();
-  FinishedInfo(cfdp::ConditionCode conditionCode, cfdp::FinishedDeliveryCode deliveryCode,
-               cfdp::FinishedFileStatus fileStatus);
+  FinishedInfo(cfdp::ConditionCode conditionCode, cfdp::FileDeliveryCode deliveryCode,
+               cfdp::FileDeliveryStatus fileStatus);

-  size_t getSerializedSize() const;
+  [[nodiscard]] size_t getSerializedSize() const;

-  bool hasFsResponses() const;
-  bool canHoldFsResponses() const;
+  [[nodiscard]] bool hasFsResponses() const;
+  [[nodiscard]] bool canHoldFsResponses() const;

  ReturnValue_t setFilestoreResponsesArray(FilestoreResponseTlv** fsResponses,
                                           size_t* fsResponsesLen, const size_t* maxFsResponseLen);
@ -22,20 +22,20 @@ class FinishedInfo {

  ReturnValue_t getFilestoreResonses(FilestoreResponseTlv*** fsResponses, size_t* fsResponsesLen,
                                     size_t* fsResponsesMaxLen);
-  size_t getFsResponsesLen() const;
+  [[nodiscard]] size_t getFsResponsesLen() const;
  void setFilestoreResponsesArrayLen(size_t fsResponsesLen);
  ReturnValue_t getFaultLocation(EntityIdTlv** entityId);
-  cfdp::ConditionCode getConditionCode() const;
+  [[nodiscard]] cfdp::ConditionCode getConditionCode() const;
  void setConditionCode(cfdp::ConditionCode conditionCode);
-  cfdp::FinishedDeliveryCode getDeliveryCode() const;
-  void setDeliveryCode(cfdp::FinishedDeliveryCode deliveryCode);
-  cfdp::FinishedFileStatus getFileStatus() const;
-  void setFileStatus(cfdp::FinishedFileStatus fileStatus);
+  [[nodiscard]] cfdp::FileDeliveryCode getDeliveryCode() const;
+  void setDeliveryCode(cfdp::FileDeliveryCode deliveryCode);
+  [[nodiscard]] cfdp::FileDeliveryStatus getFileStatus() const;
+  void setFileStatus(cfdp::FileDeliveryStatus fileStatus);

 private:
  cfdp::ConditionCode conditionCode = cfdp::ConditionCode::NO_CONDITION_FIELD;
-  cfdp::FinishedDeliveryCode deliveryCode = cfdp::FinishedDeliveryCode::DATA_COMPLETE;
-  cfdp::FinishedFileStatus fileStatus = cfdp::FinishedFileStatus::DISCARDED_DELIBERATELY;
+  cfdp::FileDeliveryCode deliveryCode = cfdp::FileDeliveryCode::DATA_COMPLETE;
+  cfdp::FileDeliveryStatus fileStatus = cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY;
  FilestoreResponseTlv** fsResponses = nullptr;
  size_t fsResponsesLen = 0;
  size_t fsResponsesMaxLen = 0;
--- a/src/fsfw/cfdp/pdu/FinishedPduSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/FinishedPduSerializer.cpp
@ -1,26 +1,23 @@
-#include "FinishedPduSerializer.h"
+#include "FinishedPduCreator.h"

-FinishPduSerializer::FinishPduSerializer(PduConfig &conf, FinishedInfo &finishInfo)
-    : FileDirectiveSerializer(conf, cfdp::FileDirectives::FINISH, 0), finishInfo(finishInfo) {
+FinishPduCreator::FinishPduCreator(PduConfig &conf, FinishedInfo &finishInfo)
+    : FileDirectiveCreator(conf, cfdp::FileDirective::FINISH, 0), finishInfo(finishInfo) {
  updateDirectiveFieldLen();
 }

-size_t FinishPduSerializer::getSerializedSize() const {
-  return FinishPduSerializer::getWholePduSize();
-}
+size_t FinishPduCreator::getSerializedSize() const { return FinishPduCreator::getWholePduSize(); }

-void FinishPduSerializer::updateDirectiveFieldLen() {
+void FinishPduCreator::updateDirectiveFieldLen() {
  setDirectiveDataFieldLen(finishInfo.getSerializedSize());
 }

-ReturnValue_t FinishPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                             Endianness streamEndianness) const {
-  ReturnValue_t result =
-      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
+ReturnValue_t FinishPduCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                          Endianness streamEndianness) const {
+  ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
  }
-  if (*size + 1 >= maxSize) {
+  if (*size + 1 > maxSize) {
    return SerializeIF::BUFFER_TOO_SHORT;
  }
  **buffer = finishInfo.getConditionCode() << 4 | finishInfo.getDeliveryCode() << 2 |
--- a/src/fsfw/cfdp/pdu/FinishedPduCreator.h
+++ b/src/fsfw/cfdp/pdu/FinishedPduCreator.h
@ -0,0 +1,24 @@
+#ifndef FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_
+#define FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_
+
+#include "FinishedInfo.h"
+#include "fsfw/cfdp/pdu/FileDataCreator.h"
+#include "fsfw/cfdp/pdu/FileDirectiveCreator.h"
+
+class FinishPduCreator : public FileDirectiveCreator {
+ public:
+  FinishPduCreator(PduConfig& pduConf, FinishedInfo& finishInfo);
+
+  void updateDirectiveFieldLen();
+
+  [[nodiscard]] size_t getSerializedSize() const override;
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+  using FileDirectiveCreator::serialize;
+
+ private:
+  FinishedInfo& finishInfo;
+};
+
+#endif /* FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FinishedPduDeserializer.h
+++ b/src/fsfw/cfdp/pdu/FinishedPduDeserializer.h
@ -1,22 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_
-
-#include "fsfw/cfdp/pdu/FileDirectiveDeserializer.h"
-#include "fsfw/cfdp/pdu/FinishedInfo.h"
-
-class FinishPduDeserializer : public FileDirectiveDeserializer {
- public:
-  FinishPduDeserializer(const uint8_t* pduBuf, size_t maxSize, FinishedInfo& info);
-
-  ReturnValue_t parseData() override;
-
-  FinishedInfo& getInfo();
-
- private:
-  FinishedInfo& finishedInfo;
-
-  ReturnValue_t parseTlvs(size_t remLen, size_t currentIdx, const uint8_t* buf,
-                          cfdp::ConditionCode conditionCode);
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FinishedPduDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/FinishedPduDeserializer.cpp
@ -1,25 +1,24 @@
-#include "FinishedPduDeserializer.h"
+#include "FinishedPduReader.h"

-FinishPduDeserializer::FinishPduDeserializer(const uint8_t* pduBuf, size_t maxSize,
-                                             FinishedInfo& info)
-    : FileDirectiveDeserializer(pduBuf, maxSize), finishedInfo(info) {}
+FinishPduReader::FinishPduReader(const uint8_t* pduBuf, size_t maxSize, FinishedInfo& info)
+    : FileDirectiveReader(pduBuf, maxSize), finishedInfo(info) {}

-ReturnValue_t FinishPduDeserializer::parseData() {
-  ReturnValue_t result = FileDirectiveDeserializer::parseData();
+ReturnValue_t FinishPduReader::parseData() {
+  ReturnValue_t result = FileDirectiveReader::parseData();
  if (result != returnvalue::OK) {
    return result;
  }
-  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
-  const uint8_t* buf = rawPtr + currentIdx;
-  size_t remSize = FileDirectiveDeserializer::getWholePduSize() - currentIdx;
+  size_t currentIdx = FileDirectiveReader::getHeaderSize();
+  const uint8_t* buf = pointers.rawPtr + currentIdx;
+  size_t remSize = FileDirectiveReader::getWholePduSize() - currentIdx;
  if (remSize < 1) {
    return SerializeIF::STREAM_TOO_SHORT;
  }
  uint8_t firstByte = *buf;
-  cfdp::ConditionCode condCode = static_cast<cfdp::ConditionCode>((firstByte >> 4) & 0x0f);
+  auto condCode = static_cast<cfdp::ConditionCode>((firstByte >> 4) & 0x0f);
  finishedInfo.setConditionCode(condCode);
-  finishedInfo.setDeliveryCode(static_cast<cfdp::FinishedDeliveryCode>(firstByte >> 2 & 0b1));
-  finishedInfo.setFileStatus(static_cast<cfdp::FinishedFileStatus>(firstByte & 0b11));
+  finishedInfo.setDeliveryCode(static_cast<cfdp::FileDeliveryCode>(firstByte >> 2 & 0b1));
+  finishedInfo.setFileStatus(static_cast<cfdp::FileDeliveryStatus>(firstByte & 0b11));
  buf += 1;
  remSize -= 1;
  currentIdx += 1;
@ -29,17 +28,17 @@ ReturnValue_t FinishPduDeserializer::parseData() {
  return result;
 }

-FinishedInfo& FinishPduDeserializer::getInfo() { return finishedInfo; }
+FinishedInfo& FinishPduReader::getInfo() { return finishedInfo; }

-ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx, const uint8_t* buf,
-                                               cfdp::ConditionCode conditionCode) {
+ReturnValue_t FinishPduReader::parseTlvs(size_t remLen, size_t currentIdx, const uint8_t* buf,
+                                         cfdp::ConditionCode conditionCode) {
  ReturnValue_t result = returnvalue::OK;
  size_t fsResponsesIdx = 0;
  auto endianness = getEndianness();
  FilestoreResponseTlv** fsResponseArray = nullptr;
  size_t fsResponseMaxArrayLen = 0;
  EntityIdTlv* faultLocation = nullptr;
-  cfdp::TlvTypes nextTlv = cfdp::TlvTypes::INVALID_TLV;
+  cfdp::TlvType nextTlv = cfdp::TlvType::INVALID_TLV;
  while (remLen > 0) {
    // Simply forward parse the TLV type. Every TLV type except the last one must be a Filestore
    // Response TLV, and even the last one can be a Filestore Response TLV if the fault
@ -47,8 +46,8 @@ ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx,
    if (currentIdx + 2 > maxSize) {
      return SerializeIF::STREAM_TOO_SHORT;
    }
-    nextTlv = static_cast<cfdp::TlvTypes>(*buf);
-    if (nextTlv == cfdp::TlvTypes::FILESTORE_RESPONSE) {
+    nextTlv = static_cast<cfdp::TlvType>(*buf);
+    if (nextTlv == cfdp::TlvType::FILESTORE_RESPONSE) {
      if (fsResponseArray == nullptr) {
        if (not finishedInfo.canHoldFsResponses()) {
          return cfdp::FINISHED_CANT_PARSE_FS_RESPONSES;
@ -64,7 +63,7 @@ ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx,
        return result;
      }
      fsResponsesIdx += 1;
-    } else if (nextTlv == cfdp::TlvTypes::ENTITY_ID) {
+    } else if (nextTlv == cfdp::TlvType::ENTITY_ID) {
      // This needs to be the last TLV and it should not be here if the condition code
      // is "No Error" or "Unsupported Checksum Type"
      if (conditionCode == cfdp::ConditionCode::NO_ERROR or
--- a/src/fsfw/cfdp/pdu/FinishedPduReader.h
+++ b/src/fsfw/cfdp/pdu/FinishedPduReader.h
@ -0,0 +1,22 @@
+#ifndef FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_
+#define FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_
+
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"
+#include "fsfw/cfdp/pdu/FinishedInfo.h"
+
+class FinishPduReader : public FileDirectiveReader {
+ public:
+  FinishPduReader(const uint8_t* pduBuf, size_t maxSize, FinishedInfo& info);
+
+  ReturnValue_t parseData() override;
+
+  FinishedInfo& getInfo();
+
+ private:
+  FinishedInfo& finishedInfo;
+
+  ReturnValue_t parseTlvs(size_t remLen, size_t currentIdx, const uint8_t* buf,
+                          cfdp::ConditionCode conditionCode);
+};
+
+#endif /* FSFW_CFDP_PDU_FINISHEDPDUDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/FinishedPduSerializer.h
+++ b/src/fsfw/cfdp/pdu/FinishedPduSerializer.h
@ -1,23 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_
-
-#include "FinishedInfo.h"
-#include "fsfw/cfdp/pdu/FileDataSerializer.h"
-#include "fsfw/cfdp/pdu/FileDirectiveSerializer.h"
-
-class FinishPduSerializer : public FileDirectiveSerializer {
- public:
-  FinishPduSerializer(PduConfig& pduConf, FinishedInfo& finishInfo);
-
-  void updateDirectiveFieldLen();
-
-  size_t getSerializedSize() const override;
-
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override;
-
- private:
-  FinishedInfo& finishInfo;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_FINISHEDPDUSERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/HeaderCreator.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderCreator.cpp
@ -0,0 +1,111 @@
+#include "HeaderCreator.h"
+
+HeaderCreator::HeaderCreator(PduConfig &pduConf, cfdp::PduType pduType, size_t initPduDataFieldLen,
+                             cfdp::SegmentMetadataFlag segmentMetadataFlag,
+                             cfdp::SegmentationControl segCtrl)
+    : pduType(pduType),
+      segmentMetadataFlag(segmentMetadataFlag),
+      segmentationCtrl(segCtrl),
+      pduDataFieldLen(initPduDataFieldLen),
+      pduConf(pduConf) {}
+
+ReturnValue_t HeaderCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                       Endianness streamEndianness) const {
+  if (buffer == nullptr or size == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (maxSize < this->getSerializedSize()) {
+    return BUFFER_TOO_SHORT;
+  }
+  **buffer = cfdp::VERSION_BITS | this->pduType << 4 | pduConf.direction << 3 | pduConf.mode << 2 |
+             pduConf.crcFlag << 1 | pduConf.largeFile;
+  *buffer += 1;
+  **buffer = (pduDataFieldLen & 0xff00) >> 8;
+  *buffer += 1;
+  **buffer = pduDataFieldLen & 0x00ff;
+  *buffer += 1;
+  **buffer = segmentationCtrl << 7 | ((pduConf.sourceId.getWidth() - 1) << 4) |
+             segmentMetadataFlag << 3 | (pduConf.seqNum.getWidth() - 1);
+  *buffer += 1;
+  *size += 4;
+  ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = pduConf.seqNum.serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = pduConf.destId.serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  return returnvalue::OK;
+}
+
+size_t HeaderCreator::getSerializedSize() const {
+  return pduConf.seqNum.getWidth() + pduConf.sourceId.getWidth() * 2 + 4;
+}
+
+ReturnValue_t HeaderCreator::deSerialize(const uint8_t **buffer, size_t *size,
+                                         Endianness streamEndianness) {
+  // We could implement this, but I prefer dedicated classes
+  return returnvalue::FAILED;
+}
+
+size_t HeaderCreator::getWholePduSize() const {
+  // Return size of header plus the PDU data field length
+  return pduDataFieldLen + HeaderCreator::getSerializedSize();
+}
+
+size_t HeaderCreator::getPduDataFieldLen() const { return pduDataFieldLen; }
+
+void HeaderCreator::setPduDataFieldLen(size_t pduDataFieldLen_) {
+  pduDataFieldLen = pduDataFieldLen_;
+}
+
+void HeaderCreator::setPduType(cfdp::PduType pduType_) { pduType = pduType_; }
+
+void HeaderCreator::setSegmentMetadataFlag(cfdp::SegmentMetadataFlag segmentMetadataFlag_) {
+  segmentMetadataFlag = segmentMetadataFlag_;
+}
+
+cfdp::PduType HeaderCreator::getPduType() const { return pduType; }
+
+cfdp::Direction HeaderCreator::getDirection() const { return pduConf.direction; }
+
+cfdp::TransmissionMode HeaderCreator::getTransmissionMode() const { return pduConf.mode; }
+
+bool HeaderCreator::getCrcFlag() const { return pduConf.crcFlag; }
+
+bool HeaderCreator::getLargeFileFlag() const { return pduConf.largeFile; }
+
+cfdp::SegmentationControl HeaderCreator::getSegmentationControl() const { return segmentationCtrl; }
+
+cfdp::WidthInBytes HeaderCreator::getLenEntityIds() const { return pduConf.sourceId.getWidth(); }
+
+cfdp::WidthInBytes HeaderCreator::getLenSeqNum() const { return pduConf.seqNum.getWidth(); }
+
+cfdp::SegmentMetadataFlag HeaderCreator::getSegmentMetadataFlag() const {
+  return segmentMetadataFlag;
+}
+
+void HeaderCreator::getSourceId(cfdp::EntityId &sourceId) const { sourceId = pduConf.sourceId; }
+
+void HeaderCreator::getDestId(cfdp::EntityId &destId) const { destId = pduConf.destId; }
+
+void HeaderCreator::setSegmentationControl(cfdp::SegmentationControl segmentationControl) {
+  this->segmentationCtrl = segmentationControl;
+}
+
+void HeaderCreator::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
+  seqNum = pduConf.seqNum;
+}
+
+bool HeaderCreator::hasSegmentMetadataFlag() const {
+  if (this->segmentMetadataFlag == cfdp::SegmentMetadataFlag::PRESENT) {
+    return true;
+  }
+  return false;
+}
--- a/src/fsfw/cfdp/pdu/HeaderSerializer.h
+++ b/src/fsfw/cfdp/pdu/HeaderSerializer.h
@ -1,14 +1,14 @@
 #ifndef FSFW_SRC_FSFW_CFDP_PDU_HEADERSERIALIZER_H_
 #define FSFW_SRC_FSFW_CFDP_PDU_HEADERSERIALIZER_H_

-#include "../definitions.h"
 #include "PduConfig.h"
 #include "PduHeaderIF.h"
+#include "fsfw/cfdp/definitions.h"
 #include "fsfw/serialize/SerializeIF.h"

-class HeaderSerializer : public SerializeIF, public PduHeaderIF {
+class HeaderCreator : public SerializeIF, public PduHeaderIF {
 public:
-  HeaderSerializer(
+  HeaderCreator(
      PduConfig& pduConf, cfdp::PduType pduType, size_t initPduDataFieldLen,
      cfdp::SegmentMetadataFlag segmentMetadataFlag = cfdp::SegmentMetadataFlag::NOT_PRESENT,
      cfdp::SegmentationControl segCtrl =
@ -23,7 +23,7 @@ class HeaderSerializer : public SerializeIF, public PduHeaderIF {
   * data field length was not properly.
   * @return
   */
-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;

  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                            Endianness streamEndianness) override;
@ -32,19 +32,19 @@ class HeaderSerializer : public SerializeIF, public PduHeaderIF {
  void setPduType(cfdp::PduType pduType);
  void setSegmentMetadataFlag(cfdp::SegmentMetadataFlag);

-  size_t getPduDataFieldLen() const override;
-  size_t getWholePduSize() const override;
+  [[nodiscard]] size_t getPduDataFieldLen() const override;
+  [[nodiscard]] size_t getWholePduSize() const override;

-  cfdp::PduType getPduType() const override;
-  cfdp::Direction getDirection() const override;
-  cfdp::TransmissionModes getTransmissionMode() const override;
-  bool getCrcFlag() const override;
-  bool getLargeFileFlag() const override;
-  cfdp::SegmentationControl getSegmentationControl() const override;
-  cfdp::WidthInBytes getLenEntityIds() const override;
-  cfdp::WidthInBytes getLenSeqNum() const override;
-  cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const override;
-  bool hasSegmentMetadataFlag() const override;
+  [[nodiscard]] cfdp::PduType getPduType() const override;
+  [[nodiscard]] cfdp::Direction getDirection() const override;
+  [[nodiscard]] cfdp::TransmissionMode getTransmissionMode() const override;
+  [[nodiscard]] bool getCrcFlag() const override;
+  [[nodiscard]] bool getLargeFileFlag() const override;
+  [[nodiscard]] cfdp::SegmentationControl getSegmentationControl() const override;
+  [[nodiscard]] cfdp::WidthInBytes getLenEntityIds() const override;
+  [[nodiscard]] cfdp::WidthInBytes getLenSeqNum() const override;
+  [[nodiscard]] cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const override;
+  [[nodiscard]] bool hasSegmentMetadataFlag() const override;
  void setSegmentationControl(cfdp::SegmentationControl);

  void getSourceId(cfdp::EntityId& sourceId) const override;
--- a/src/fsfw/cfdp/pdu/HeaderDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderDeserializer.cpp
@ -1,128 +0,0 @@
-#include "HeaderDeserializer.h"
-
-#include <fsfw/serialize/SerializeAdapter.h>
-
-#include <cstring>
-
-HeaderDeserializer::HeaderDeserializer(const uint8_t *pduBuf, size_t maxSize)
-    : rawPtr(pduBuf), maxSize(maxSize) {}
-
-ReturnValue_t HeaderDeserializer::parseData() {
-  if (maxSize < 7) {
-    return SerializeIF::STREAM_TOO_SHORT;
-  }
-  return setData(const_cast<uint8_t *>(rawPtr), maxSize);
-}
-
-ReturnValue_t HeaderDeserializer::setData(uint8_t *dataPtr, size_t maxSize, void *args) {
-  if (dataPtr == nullptr) {
-    // Allowed for now
-    this->fixedHeader = nullptr;
-    return returnvalue::OK;
-  }
-  this->fixedHeader = reinterpret_cast<PduHeaderFixedStruct *>(const_cast<uint8_t *>(dataPtr));
-  sourceIdRaw = static_cast<uint8_t *>(&fixedHeader->variableFieldsStart);
-  cfdp::WidthInBytes widthEntityIds = getLenEntityIds();
-  cfdp::WidthInBytes widthSeqNum = getLenSeqNum();
-  seqNumRaw = static_cast<uint8_t *>(sourceIdRaw) + static_cast<uint8_t>(widthEntityIds);
-  destIdRaw = static_cast<uint8_t *>(seqNumRaw) + static_cast<uint8_t>(widthSeqNum);
-  this->maxSize = maxSize;
-  return returnvalue::OK;
-}
-
-size_t HeaderDeserializer::getHeaderSize() const {
-  if (fixedHeader != nullptr) {
-    return getLenEntityIds() * 2 + getLenSeqNum() + 4;
-  }
-  return 0;
-}
-
-size_t HeaderDeserializer::getPduDataFieldLen() const {
-  uint16_t pduFiedlLen = (fixedHeader->pduDataFieldLenH << 8) | fixedHeader->pduDataFieldLenL;
-  return pduFiedlLen;
-}
-
-size_t HeaderDeserializer::getWholePduSize() const {
-  return getPduDataFieldLen() + getHeaderSize();
-}
-
-cfdp::PduType HeaderDeserializer::getPduType() const {
-  return static_cast<cfdp::PduType>((fixedHeader->firstByte >> 4) & 0x01);
-}
-
-cfdp::Direction HeaderDeserializer::getDirection() const {
-  return static_cast<cfdp::Direction>((fixedHeader->firstByte >> 3) & 0x01);
-}
-
-cfdp::TransmissionModes HeaderDeserializer::getTransmissionMode() const {
-  return static_cast<cfdp::TransmissionModes>((fixedHeader->firstByte >> 2) & 0x01);
-}
-
-bool HeaderDeserializer::getCrcFlag() const { return (fixedHeader->firstByte >> 1) & 0x01; }
-
-bool HeaderDeserializer::getLargeFileFlag() const { return fixedHeader->firstByte & 0x01; }
-
-cfdp::SegmentationControl HeaderDeserializer::getSegmentationControl() const {
-  return static_cast<cfdp::SegmentationControl>((fixedHeader->fourthByte >> 7) & 0x01);
-}
-
-cfdp::WidthInBytes HeaderDeserializer::getLenEntityIds() const {
-  return static_cast<cfdp::WidthInBytes>((fixedHeader->fourthByte >> 4) & 0x07);
-}
-
-cfdp::WidthInBytes HeaderDeserializer::getLenSeqNum() const {
-  return static_cast<cfdp::WidthInBytes>(fixedHeader->fourthByte & 0x07);
-}
-
-cfdp::SegmentMetadataFlag HeaderDeserializer::getSegmentMetadataFlag() const {
-  return static_cast<cfdp::SegmentMetadataFlag>((fixedHeader->fourthByte >> 3) & 0x01);
-}
-
-void HeaderDeserializer::getSourceId(cfdp::EntityId &sourceId) const {
-  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&sourceId), getLenEntityIds(),
-                    this->sourceIdRaw);
-}
-
-void HeaderDeserializer::getDestId(cfdp::EntityId &destId) const {
-  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&destId), getLenEntityIds(), this->destIdRaw);
-}
-
-void HeaderDeserializer::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
-  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&seqNum), getLenSeqNum(), this->seqNumRaw);
-}
-
-void HeaderDeserializer::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInBytes width,
-                                           void *sourcePtr) const {
-  switch (width) {
-    case (cfdp::WidthInBytes::ONE_BYTE): {
-      uint8_t *fieldTyped = static_cast<uint8_t *>(sourcePtr);
-      field->setValue(width, *fieldTyped);
-      break;
-    }
-    case (cfdp::WidthInBytes::TWO_BYTES): {
-      uint16_t fieldTyped = 0;
-      size_t deserSize = 0;
-      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
-                                    SerializeIF::Endianness::NETWORK);
-      field->setValue(width, fieldTyped);
-      break;
-    }
-    case (cfdp::WidthInBytes::FOUR_BYTES): {
-      uint32_t fieldTyped = 0;
-      size_t deserSize = 0;
-      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
-                                    SerializeIF::Endianness::NETWORK);
-      field->setValue(width, fieldTyped);
-      break;
-    }
-  }
-}
-
-size_t HeaderDeserializer::getMaxSize() const { return maxSize; }
-
-bool HeaderDeserializer::hasSegmentMetadataFlag() const {
-  if (this->getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT) {
-    return true;
-  }
-  return false;
-}
--- a/src/fsfw/cfdp/pdu/HeaderDeserializer.h
+++ b/src/fsfw/cfdp/pdu/HeaderDeserializer.h
@ -1,90 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_HEADERDESERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_HEADERDESERIALIZER_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "PduConfig.h"
-#include "PduHeaderIF.h"
-#include "fsfw/serialize/SerializeIF.h"
-#include "fsfw/tmtcpacket/RedirectableDataPointerIF.h"
-
-struct PduHeaderFixedStruct {
-  uint8_t firstByte;
-  uint8_t pduDataFieldLenH;
-  uint8_t pduDataFieldLenL;
-  uint8_t fourthByte;
-  uint8_t variableFieldsStart;
-};
-
-/**
- * @brief   This class is used to deserialize a PDU header from raw memory.
- * @details
- * This is a zero-copy implementation and #parseData needs to be called to ensure the data is
- * valid.
- */
-class HeaderDeserializer : public RedirectableDataPointerIF, public PduHeaderIF {
- public:
-  /**
-   * Initialize a PDU header from raw data. This is a zero-copy implementation and #parseData
-   * needs to be called to ensure the data is valid
-   * @param pduBuf
-   * @param maxSize
-   */
-  HeaderDeserializer(const uint8_t* pduBuf, size_t maxSize);
-
-  /**
-   * This needs to be called before accessing the PDU fields to avoid segmentation faults.
-   * @return
-   *  - returnvalue::OK on parse success
-   *  - returnvalue::FAILED Invalid raw data
-   *  - SerializeIF::BUFFER_TOO_SHORT if buffer is shorter than expected
-   */
-  virtual ReturnValue_t parseData();
-  size_t getHeaderSize() const;
-
-  size_t getPduDataFieldLen() const override;
-  size_t getWholePduSize() const override;
-
-  cfdp::PduType getPduType() const override;
-  cfdp::Direction getDirection() const override;
-  cfdp::TransmissionModes getTransmissionMode() const override;
-  bool getCrcFlag() const override;
-  bool getLargeFileFlag() const override;
-  cfdp::SegmentationControl getSegmentationControl() const override;
-  cfdp::WidthInBytes getLenEntityIds() const override;
-  cfdp::WidthInBytes getLenSeqNum() const override;
-  cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const override;
-  bool hasSegmentMetadataFlag() const override;
-
-  void getSourceId(cfdp::EntityId& sourceId) const override;
-  void getDestId(cfdp::EntityId& destId) const override;
-  void getTransactionSeqNum(cfdp::TransactionSeqNum& seqNum) const override;
-
-  ReturnValue_t deserResult = returnvalue::OK;
-
-  /**
-   * Can also be used to reset the pointer to a nullptr, but the getter functions will not
-   * perform nullptr checks!
-   * @param dataPtr
-   * @param maxSize
-   * @param args
-   * @return
-   */
-  ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args = nullptr) override;
-
-  size_t getMaxSize() const;
-
- protected:
-  PduHeaderFixedStruct* fixedHeader = nullptr;
-  const uint8_t* rawPtr = nullptr;
-  size_t maxSize = 0;
-
- private:
-  void assignVarLenField(cfdp::VarLenField* field, cfdp::WidthInBytes width, void* sourcePtr) const;
-  void* sourceIdRaw = nullptr;
-  void* seqNumRaw = nullptr;
-  void* destIdRaw = nullptr;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_HEADERDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/HeaderReader.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderReader.cpp
@ -0,0 +1,168 @@
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#include <cstring>
+
+#include "PduHeaderReader.h"
+
+PduHeaderReader::PduHeaderReader(const uint8_t *pduBuf, size_t maxSize) {
+  setReadOnlyData(pduBuf, maxSize);
+}
+
+ReturnValue_t PduHeaderReader::parseData() {
+  if (pointers.rawPtr == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (maxSize < 7) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  pointers.fixedHeader =
+      reinterpret_cast<PduHeaderFixedStruct *>(const_cast<uint8_t *>(pointers.rawPtr));
+  sourceIdRaw = static_cast<uint8_t *>(&pointers.fixedHeader->variableFieldsStart);
+  cfdp::WidthInBytes widthEntityIds = getLenEntityIds();
+  cfdp::WidthInBytes widthSeqNum = getLenSeqNum();
+  seqNumRaw = static_cast<uint8_t *>(sourceIdRaw) + static_cast<uint8_t>(widthEntityIds);
+  destIdRaw = static_cast<uint8_t *>(seqNumRaw) + static_cast<uint8_t>(widthSeqNum);
+  if (getWholePduSize() > PduHeaderReader::getHeaderSize()) {
+    pointers.dataFieldStart = reinterpret_cast<const uint8_t *>(destIdRaw) + widthEntityIds;
+  } else {
+    pointers.dataFieldStart = nullptr;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PduHeaderReader::setData(uint8_t *dataPtr, size_t maxSize_, void *args) {
+  if (dataPtr == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (maxSize_ < 7) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  pointers.rawPtr = dataPtr;
+  maxSize = maxSize_;
+  return returnvalue::OK;
+}
+
+size_t PduHeaderReader::getHeaderSize() const {
+  if (pointers.fixedHeader != nullptr) {
+    return getLenEntityIds() * 2 + getLenSeqNum() + 4;
+  }
+  return 0;
+}
+
+size_t PduHeaderReader::getPduDataFieldLen() const {
+  return (pointers.fixedHeader->pduDataFieldLenH << 8) | pointers.fixedHeader->pduDataFieldLenL;
+}
+
+size_t PduHeaderReader::getWholePduSize() const {
+  return getPduDataFieldLen() + PduHeaderReader::getHeaderSize();
+}
+
+cfdp::PduType PduHeaderReader::getPduType() const {
+  return static_cast<cfdp::PduType>((pointers.fixedHeader->firstByte >> 4) & 0x01);
+}
+
+cfdp::Direction PduHeaderReader::getDirection() const {
+  return static_cast<cfdp::Direction>((pointers.fixedHeader->firstByte >> 3) & 0x01);
+}
+
+cfdp::TransmissionMode PduHeaderReader::getTransmissionMode() const {
+  return static_cast<cfdp::TransmissionMode>((pointers.fixedHeader->firstByte >> 2) & 0x01);
+}
+
+bool PduHeaderReader::getCrcFlag() const { return (pointers.fixedHeader->firstByte >> 1) & 0x01; }
+
+bool PduHeaderReader::getLargeFileFlag() const { return pointers.fixedHeader->firstByte & 0x01; }
+
+cfdp::SegmentationControl PduHeaderReader::getSegmentationControl() const {
+  return static_cast<cfdp::SegmentationControl>((pointers.fixedHeader->fourthByte >> 7) & 0x01);
+}
+
+cfdp::WidthInBytes PduHeaderReader::getLenEntityIds() const {
+  return static_cast<cfdp::WidthInBytes>(((pointers.fixedHeader->fourthByte >> 4) & 0b111) + 1);
+}
+
+cfdp::WidthInBytes PduHeaderReader::getLenSeqNum() const {
+  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte & 0b111) + 1);
+}
+
+cfdp::SegmentMetadataFlag PduHeaderReader::getSegmentMetadataFlag() const {
+  return static_cast<cfdp::SegmentMetadataFlag>((pointers.fixedHeader->fourthByte >> 3) & 0x01);
+}
+
+void PduHeaderReader::getSourceId(cfdp::EntityId &sourceId) const {
+  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&sourceId), getLenEntityIds(),
+                    this->sourceIdRaw);
+}
+
+void PduHeaderReader::getDestId(cfdp::EntityId &destId) const {
+  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&destId), getLenEntityIds(), this->destIdRaw);
+}
+
+void PduHeaderReader::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
+  assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&seqNum), getLenSeqNum(), this->seqNumRaw);
+}
+
+void PduHeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInBytes width,
+                                        void *sourcePtr) {
+  switch (width) {
+    case (cfdp::WidthInBytes::ONE_BYTE): {
+      auto *fieldTyped = static_cast<uint8_t *>(sourcePtr);
+      field->setValueAndWidth(width, *fieldTyped);
+      break;
+    }
+    case (cfdp::WidthInBytes::TWO_BYTES): {
+      uint16_t fieldTyped = 0;
+      size_t deserSize = 0;
+      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
+                                    SerializeIF::Endianness::NETWORK);
+      field->setValueAndWidth(width, fieldTyped);
+      break;
+    }
+    case (cfdp::WidthInBytes::FOUR_BYTES): {
+      uint32_t fieldTyped = 0;
+      size_t deserSize = 0;
+      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
+                                    SerializeIF::Endianness::NETWORK);
+      field->setValueAndWidth(width, fieldTyped);
+      break;
+    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      uint64_t fieldTyped = 0;
+      size_t deserSize = 0;
+      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
+                                    SerializeIF::Endianness::NETWORK);
+      field->setValueAndWidth(width, fieldTyped);
+      break;
+    }
+  }
+}
+
+size_t PduHeaderReader::getMaxSize() const { return maxSize; }
+
+bool PduHeaderReader::hasSegmentMetadataFlag() const {
+  if (this->getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT) {
+    return true;
+  }
+  return false;
+}
+
+ReturnValue_t PduHeaderReader::setReadOnlyData(const uint8_t *dataPtr, size_t maxSize_) {
+  return setData(const_cast<uint8_t *>(dataPtr), maxSize_, nullptr);
+}
+bool PduHeaderReader::isNull() const {
+  return pointers.rawPtr == nullptr or pointers.fixedHeader == nullptr;
+}
+
+PduHeaderReader::operator bool() const { return not isNull(); }
+
+void PduHeaderReader::fillConfig(PduConfig &cfg) const {
+  cfg.largeFile = getLargeFileFlag();
+  cfg.crcFlag = getCrcFlag();
+  cfg.mode = getTransmissionMode();
+  cfg.direction = getDirection();
+  getTransactionSeqNum(cfg.seqNum);
+  getSourceId(cfg.sourceId);
+  getDestId(cfg.destId);
+}
+
+const uint8_t *PduHeaderReader::getPduDataField() const { return pointers.dataFieldStart; }
--- a/src/fsfw/cfdp/pdu/HeaderSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderSerializer.cpp
@ -1,117 +0,0 @@
-#include "HeaderSerializer.h"
-
-#include "HeaderDeserializer.h"
-
-HeaderSerializer::HeaderSerializer(PduConfig &pduConf, cfdp::PduType pduType,
-                                   size_t initPduDataFieldLen,
-                                   cfdp::SegmentMetadataFlag segmentMetadataFlag,
-                                   cfdp::SegmentationControl segCtrl)
-    : pduType(pduType),
-      segmentMetadataFlag(segmentMetadataFlag),
-      segmentationCtrl(segCtrl),
-      pduDataFieldLen(initPduDataFieldLen),
-      pduConf(pduConf) {}
-
-ReturnValue_t HeaderSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                          Endianness streamEndianness) const {
-  if (buffer == nullptr or size == nullptr) {
-    return returnvalue::FAILED;
-  }
-  if (maxSize < this->getSerializedSize()) {
-    return BUFFER_TOO_SHORT;
-  }
-  **buffer = cfdp::VERSION_BITS | this->pduType << 4 | pduConf.direction << 3 | pduConf.mode << 2 |
-             pduConf.crcFlag << 1 | pduConf.largeFile;
-  *buffer += 1;
-  **buffer = (pduDataFieldLen & 0xff00) >> 8;
-  *buffer += 1;
-  **buffer = pduDataFieldLen & 0x00ff;
-  *buffer += 1;
-  **buffer = segmentationCtrl << 7 | pduConf.sourceId.getWidth() << 4 | segmentMetadataFlag << 3 |
-             pduConf.seqNum.getWidth();
-  *buffer += 1;
-  *size += 4;
-  ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = pduConf.seqNum.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = pduConf.destId.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
-}
-
-size_t HeaderSerializer::getSerializedSize() const {
-  size_t shit = pduConf.seqNum.getWidth() + pduConf.sourceId.getWidth() * 2 + 4;
-  return shit;
-}
-
-ReturnValue_t HeaderSerializer::deSerialize(const uint8_t **buffer, size_t *size,
-                                            Endianness streamEndianness) {
-  // We could implement this, but I prefer dedicated classes
-  return returnvalue::FAILED;
-}
-
-size_t HeaderSerializer::getWholePduSize() const {
-  // Return size of header plus the PDU data field length
-  return pduDataFieldLen + HeaderSerializer::getSerializedSize();
-}
-
-size_t HeaderSerializer::getPduDataFieldLen() const { return pduDataFieldLen; }
-
-void HeaderSerializer::setPduDataFieldLen(size_t pduDataFieldLen) {
-  this->pduDataFieldLen = pduDataFieldLen;
-}
-
-void HeaderSerializer::setPduType(cfdp::PduType pduType) { this->pduType = pduType; }
-
-void HeaderSerializer::setSegmentMetadataFlag(cfdp::SegmentMetadataFlag segmentMetadataFlag) {
-  this->segmentMetadataFlag = segmentMetadataFlag;
-}
-
-cfdp::PduType HeaderSerializer::getPduType() const { return pduType; }
-
-cfdp::Direction HeaderSerializer::getDirection() const { return pduConf.direction; }
-
-cfdp::TransmissionModes HeaderSerializer::getTransmissionMode() const { return pduConf.mode; }
-
-bool HeaderSerializer::getCrcFlag() const { return pduConf.crcFlag; }
-
-bool HeaderSerializer::getLargeFileFlag() const { return pduConf.largeFile; }
-
-cfdp::SegmentationControl HeaderSerializer::getSegmentationControl() const {
-  return segmentationCtrl;
-}
-
-cfdp::WidthInBytes HeaderSerializer::getLenEntityIds() const { return pduConf.sourceId.getWidth(); }
-
-cfdp::WidthInBytes HeaderSerializer::getLenSeqNum() const { return pduConf.seqNum.getWidth(); }
-
-cfdp::SegmentMetadataFlag HeaderSerializer::getSegmentMetadataFlag() const {
-  return segmentMetadataFlag;
-}
-
-void HeaderSerializer::getSourceId(cfdp::EntityId &sourceId) const { sourceId = pduConf.sourceId; }
-
-void HeaderSerializer::getDestId(cfdp::EntityId &destId) const { destId = pduConf.destId; }
-
-void HeaderSerializer::setSegmentationControl(cfdp::SegmentationControl segmentationControl) {
-  this->segmentationCtrl = segmentationControl;
-}
-
-void HeaderSerializer::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
-  seqNum = pduConf.seqNum;
-}
-
-bool HeaderSerializer::hasSegmentMetadataFlag() const {
-  if (this->segmentMetadataFlag == cfdp::SegmentMetadataFlag::PRESENT) {
-    return true;
-  }
-  return false;
-}
--- a/src/fsfw/cfdp/pdu/KeepAlivePduCreator.cpp
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduCreator.cpp
@ -0,0 +1,25 @@
+#include "KeepAlivePduCreator.h"
+
+KeepAlivePduCreator::KeepAlivePduCreator(PduConfig &conf, cfdp::Fss &progress)
+    : FileDirectiveCreator(conf, cfdp::FileDirective::KEEP_ALIVE, 4), progress(progress) {
+  updateDirectiveFieldLen();
+}
+
+size_t KeepAlivePduCreator::getSerializedSize() const {
+  return FileDirectiveCreator::getWholePduSize();
+}
+
+void KeepAlivePduCreator::updateDirectiveFieldLen() {
+  if (this->getLargeFileFlag()) {
+    this->setDirectiveDataFieldLen(8);
+  }
+}
+
+ReturnValue_t KeepAlivePduCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                             Endianness streamEndianness) const {
+  ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return progress.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);
+}
--- a/src/fsfw/cfdp/pdu/KeepAlivePduCreator.h
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduCreator.h
@ -0,0 +1,22 @@
+#ifndef FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_
+#define FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_
+
+#include "fsfw/cfdp/Fss.h"
+#include "fsfw/cfdp/pdu/FileDirectiveCreator.h"
+
+class KeepAlivePduCreator : public FileDirectiveCreator {
+ public:
+  KeepAlivePduCreator(PduConfig& conf, cfdp::Fss& progress);
+
+  void updateDirectiveFieldLen();
+
+  [[nodiscard]] size_t getSerializedSize() const override;
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+
+ private:
+  cfdp::Fss& progress;
+};
+
+#endif /* FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/KeepAlivePduDeserializer.cpp
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduDeserializer.cpp
@ -1,18 +0,0 @@
-#include "KeepAlivePduDeserializer.h"
-
-KeepAlivePduDeserializer::KeepAlivePduDeserializer(const uint8_t* pduBuf, size_t maxSize,
-                                                   cfdp::FileSize& progress)
-    : FileDirectiveDeserializer(pduBuf, maxSize), progress(progress) {}
-
-ReturnValue_t KeepAlivePduDeserializer::parseData() {
-  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
-  size_t remLen = FileDirectiveDeserializer::getWholePduSize() - currentIdx;
-  const uint8_t* buffer = rawPtr + currentIdx;
-  return progress.deSerialize(&buffer, &remLen, getEndianness());
-}
-
-cfdp::FileSize& KeepAlivePduDeserializer::getProgress() { return progress; }
--- a/src/fsfw/cfdp/pdu/KeepAlivePduDeserializer.h
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduDeserializer.h
@ -1,19 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUDESERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUDESERIALIZER_H_
-
-#include "fsfw/cfdp/FileSize.h"
-#include "fsfw/cfdp/pdu/FileDirectiveDeserializer.h"
-
-class KeepAlivePduDeserializer : public FileDirectiveDeserializer {
- public:
-  KeepAlivePduDeserializer(const uint8_t* pduBuf, size_t maxSize, cfdp::FileSize& progress);
-
-  ReturnValue_t parseData() override;
-
-  cfdp::FileSize& getProgress();
-
- private:
-  cfdp::FileSize& progress;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUDESERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/KeepAlivePduReader.cpp
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduReader.cpp
@ -0,0 +1,17 @@
+#include "KeepAlivePduReader.h"
+
+KeepAlivePduReader::KeepAlivePduReader(const uint8_t* pduBuf, size_t maxSize, cfdp::Fss& progress)
+    : FileDirectiveReader(pduBuf, maxSize), progress(progress) {}
+
+ReturnValue_t KeepAlivePduReader::parseData() {
+  ReturnValue_t result = FileDirectiveReader::parseData();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  size_t currentIdx = FileDirectiveReader::getHeaderSize();
+  size_t remLen = FileDirectiveReader::getWholePduSize() - currentIdx;
+  const uint8_t* buffer = pointers.rawPtr + currentIdx;
+  return progress.deSerialize(&buffer, &remLen, getEndianness());
+}
+
+cfdp::Fss& KeepAlivePduReader::getProgress() { return progress; }
--- a/src/fsfw/cfdp/pdu/KeepAlivePduReader.h
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduReader.h
@ -0,0 +1,19 @@
+#ifndef FSFW_CFDP_PDU_KEEPALIVEREADER_H_
+#define FSFW_CFDP_PDU_KEEPALIVEREADER_H_
+
+#include "fsfw/cfdp/Fss.h"
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"
+
+class KeepAlivePduReader : public FileDirectiveReader {
+ public:
+  KeepAlivePduReader(const uint8_t* pduBuf, size_t maxSize, cfdp::Fss& progress);
+
+  ReturnValue_t parseData() override;
+
+  cfdp::Fss& getProgress();
+
+ private:
+  cfdp::Fss& progress;
+};
+
+#endif /* FSFW_CFDP_PDU_KEEPALIVEPDUREADER_H_ */
--- a/src/fsfw/cfdp/pdu/KeepAlivePduSerializer.cpp
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduSerializer.cpp
@ -1,26 +0,0 @@
-#include "KeepAlivePduSerializer.h"
-
-KeepAlivePduSerializer::KeepAlivePduSerializer(PduConfig &conf, cfdp::FileSize &progress)
-    : FileDirectiveSerializer(conf, cfdp::FileDirectives::KEEP_ALIVE, 4), progress(progress) {
-  updateDirectiveFieldLen();
-}
-
-size_t KeepAlivePduSerializer::getSerializedSize() const {
-  return FileDirectiveSerializer::getWholePduSize();
-}
-
-void KeepAlivePduSerializer::updateDirectiveFieldLen() {
-  if (this->getLargeFileFlag()) {
-    this->setDirectiveDataFieldLen(8);
-  }
-}
-
-ReturnValue_t KeepAlivePduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                                Endianness streamEndianness) const {
-  ReturnValue_t result =
-      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return progress.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);
-}
--- a/src/fsfw/cfdp/pdu/KeepAlivePduSerializer.h
+++ b/src/fsfw/cfdp/pdu/KeepAlivePduSerializer.h
@ -1,22 +0,0 @@
-#ifndef FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_
-#define FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_
-
-#include "fsfw/cfdp/FileSize.h"
-#include "fsfw/cfdp/pdu/FileDirectiveSerializer.h"
-
-class KeepAlivePduSerializer : public FileDirectiveSerializer {
- public:
-  KeepAlivePduSerializer(PduConfig& conf, cfdp::FileSize& progress);
-
-  void updateDirectiveFieldLen();
-
-  size_t getSerializedSize() const override;
-
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override;
-
- private:
-  cfdp::FileSize& progress;
-};
-
-#endif /* FSFW_SRC_FSFW_CFDP_PDU_KEEPALIVEPDUSERIALIZER_H_ */
--- a/src/fsfw/cfdp/pdu/MetadataGenericInfo.cpp
+++ b/src/fsfw/cfdp/pdu/MetadataGenericInfo.cpp
@ -0,0 +1,35 @@
+#include "MetadataGenericInfo.h"
+
+MetadataGenericInfo::MetadataGenericInfo(bool closureRequested, cfdp::ChecksumType checksumType,
+                                         cfdp::Fss fileSize)
+    : MetadataGenericInfo(std::move(fileSize)) {
+  this->closureRequested = closureRequested;
+  this->checksumType = checksumType;
+}
+
+MetadataGenericInfo::MetadataGenericInfo(cfdp::Fss fileSize) : fileSize(std::move(fileSize)) {}
+
+cfdp::ChecksumType MetadataGenericInfo::getChecksumType() const { return checksumType; }
+
+void MetadataGenericInfo::setChecksumType(cfdp::ChecksumType checksumType_) {
+  checksumType = checksumType_;
+}
+
+bool MetadataGenericInfo::isClosureRequested() const { return closureRequested; }
+
+void MetadataGenericInfo::setClosureRequested(bool closureRequested_) {
+  closureRequested = closureRequested_;
+}
+
+const cfdp::Fss& MetadataGenericInfo::getFileSize() const { return fileSize; }
+
+size_t MetadataGenericInfo::getSerializedSize(bool fssLarge) {
+  // 1 byte + minimal FSS 4 bytes
+  size_t size = 5;
+  if (fssLarge) {
+    size += 4;
+  }
+  return size;
+}
+
+cfdp::Fss& MetadataGenericInfo::getMutFileSize() { return fileSize; }
--- a/src/fsfw/cfdp/pdu/MetadataGenericInfo.h
+++ b/src/fsfw/cfdp/pdu/MetadataGenericInfo.h
@ -0,0 +1,35 @@
+#ifndef FSFW_SRC_FSFW_CFDP_PDU_METADATAINFO_H_
+#define FSFW_SRC_FSFW_CFDP_PDU_METADATAINFO_H_
+
+#include <optional>
+
+#include "fsfw/cfdp/Fss.h"
+#include "fsfw/cfdp/definitions.h"
+#include "fsfw/cfdp/tlv/Lv.h"
+#include "fsfw/cfdp/tlv/StringLv.h"
+#include "fsfw/cfdp/tlv/Tlv.h"
+
+class MetadataGenericInfo {
+ public:
+  MetadataGenericInfo() = default;
+  explicit MetadataGenericInfo(cfdp::Fss fileSize);
+  MetadataGenericInfo(bool closureRequested, cfdp::ChecksumType checksumType, cfdp::Fss fileSize);
+
+  static size_t getSerializedSize(bool fssLarge = false);
+
+  [[nodiscard]] cfdp::ChecksumType getChecksumType() const;
+  void setChecksumType(cfdp::ChecksumType checksumType);
+  [[nodiscard]] bool isClosureRequested() const;
+  void setClosureRequested(bool closureRequested = false);
+
+  [[nodiscard]] const cfdp::Fss& getFileSize() const;
+
+  cfdp::Fss& getMutFileSize();
+
+ private:
+  bool closureRequested = false;
+  cfdp::ChecksumType checksumType = cfdp::ChecksumType::NULL_CHECKSUM;
+  cfdp::Fss fileSize;
+};
+
+#endif /* FSFW_SRC_FSFW_CFDP_PDU_METADATAINFO_H_ */
--- a/Show More
+++ b/Show More