CI: Adjust twine upload args

.gitlab-ci.yml

@@ -47,7 +47,7 @@ unit_test windows/x64:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y g++ ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y g++ ninja-build cmake git ca-certificates
     - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
     - update-ca-certificates --fresh
     - sh ci/build-posix.sh
@@ -64,7 +64,6 @@ unit_test windows/x64:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y libpcap-dev
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -75,7 +74,7 @@ unit_test windows/x64:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y clang lld ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y clang lld ninja-build cmake git ca-certificates
     - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
     - update-ca-certificates --fresh
     - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
@@ -92,7 +91,6 @@ unit_test windows/x64:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y libpcap-dev
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -159,7 +157,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y g++ libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y g++ cmake ninja-build git ca-certificates
     - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
     - update-ca-trust
     - sh ci/build-posix.sh
@@ -180,7 +178,6 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y libpcap-devel
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -195,7 +192,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y clang lld libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y clang lld cmake ninja-build git ca-certificates
     - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
     - update-ca-trust
     - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
@@ -216,7 +213,6 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y libpcap-devel
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -279,13 +275,9 @@ build python/linux/amd64:
   tags:
     - linux-native-amd64
   variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
-    CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: x86_64
-    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
   script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-linux.sh
   artifacts:
     paths:
       - wheelhouse
@@ -295,13 +287,9 @@ build python/linux/arm64:
   tags:
     - arm64-linux-build
   variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
-    CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: aarch64
-    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
   script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-linux.sh
   artifacts:
     paths:
       - wheelhouse
@@ -310,14 +298,8 @@ build python/macos:
   stage: build
   tags:
     - macos-arm64
-  variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-libpcap.sh
-    CIBW_ARCHS: arm64
-    CIBW_ENVIRONMENT: PCAP_ROOT=$CI_PROJECT_DIR/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=$CI_PROJECT_DIR/icspb
-    MACOSX_DEPLOYMENT_TARGET: 10.14
   script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-macos.sh
   artifacts:
     paths:
       - wheelhouse
@@ -347,9 +329,10 @@ deploy python/pypi:
   image: python:3.13
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_TAG
   script:
     - python3 -m pip install -U twine
-    - twine upload wheelhouse/*
+    - twine upload --verbose wheelhouse/*
   dependencies:
     - build python/linux/amd64
     - build python/linux/arm64
@@ -367,14 +350,23 @@ push github:
   tags:
     - linux-build
   image: alpine:latest
+  variables:
+    GIT_DEPTH: 0
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
       when: delayed
       start_in: 10 minutes
+      variables:
+        REFSPEC: HEAD:master
+    - if: $CI_COMMIT_TAG
+      when: delayed
+      start_in: 10 minutes
+      variables:
+        REFSPEC: $CI_COMMIT_TAG
   dependencies:
     - deploy python/pypi
   needs:
     - deploy python/pypi
   script:
     - apk add git
-    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git HEAD:master
+    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git $REFSPEC

99-intrepidcs.rules

@@ -1,10 +0,0 @@
-# Intrepid Control System, Inc. neoVI Devices
-SUBSYSTEM=="usb", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-KERNEL=="ttyUSB?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-KERNEL=="ttyACM?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", KERNEL=="ttyUSB*", \
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/ftdi_sio/unbind'"
-
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", DRIVER=="usbhid", \
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/usbhid/unbind'"

CMakeLists.txt

@@ -53,22 +53,20 @@ option(LIBICSNEO_BUILD_ICSNEOC2 "Build dynamic C2 library" ON)
 option(LIBICSNEO_BUILD_ICSNEOC2_STATIC "Build static C2 library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY "Build icsnVC40 compatibility library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC "Build static icsnVC40 compatibility library" ON)
-set(LIBICSNEO_NPCAP_INCLUDE_DIR "" CACHE STRING "Npcap include directory; set to build with Npcap")
 
 # Device Drivers
 # You almost certainly don't want firmio for your build,
 # it is only relevant for communication between Linux and
 # CoreMini from the onboard processor of the device.
 option(LIBICSNEO_ENABLE_FIRMIO "Enable communication between Linux and CoreMini within the same device" OFF)
-option(LIBICSNEO_ENABLE_RAW_ETHERNET "Enable devices which communicate over raw ethernet" ON)
-option(LIBICSNEO_ENABLE_CDCACM "Enable devices which communicate over USB CDC ACM" ON)
-option(LIBICSNEO_ENABLE_TCP "Enable devices which communicate over TCP" OFF)
-option(LIBICSNEO_ENABLE_DXX "Enable devices which communicate over D2XX/D3XX via libredxx" ON)
 
 option(LIBICSNEO_ENABLE_BINDINGS_PYTHON "Enable Python library" OFF)
 
+option(LIBICSNEO_ENABLE_BOOTLOADER "Enable bootloader firmware update support" OFF)
+
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 include(GNUInstallDirs)
 
@@ -142,82 +140,10 @@ if(LIBICSNEO_BUILD_DOCS)
 	endif()
 endif()
 
-if(WIN32)
-	set(PLATFORM_SRC
-		platform/windows/strings.cpp
-		platform/windows/registry.cpp
-	)
-
-	if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-		list(APPEND PLATFORM_SRC
-			platform/windows/pcap.cpp
-			platform/windows/internal/pcapdll.cpp
-		)
+if(LIBICSNEO_ENABLE_FIRMIO AND NOT WIN32)
+	set(PLATFORM_SRC platform/posix/firmio.cpp)
 endif()
 
-	if(LIBICSNEO_ENABLE_CDCACM)
-		list(APPEND PLATFORM_SRC
-			platform/windows/cdcacm.cpp
-		)
-	endif()
-else() # Darwin or Linux
-	set(PLATFORM_SRC)
-
-	if(LIBICSNEO_ENABLE_FIRMIO)
-		list(APPEND PLATFORM_SRC
-			platform/posix/firmio.cpp
-		)
-	endif()
-
-	if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-		list(APPEND PLATFORM_SRC
-			platform/posix/pcap.cpp
-		)
-	endif()
-
-	if(LIBICSNEO_ENABLE_CDCACM)
-		list(APPEND PLATFORM_SRC
-			platform/posix/cdcacm.cpp
-		)
-
-		if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-			list(APPEND PLATFORM_SRC
-				platform/posix/darwin/cdcacmdarwin.cpp
-			)
-		else() # Linux or other
-			list(APPEND PLATFORM_SRC
-				platform/posix/linux/cdcacmlinux.cpp
-			)
-			if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-				message(WARNING
-					"There is no CDCACM platform port defined for ${CMAKE_SYSTEM_NAME}!\n"
-					"The Linux platform code will be used, as it will generally allow building, but some devices may not enumerate properly."
-				)
-			endif()
-		endif()
-	endif()
-endif()
-
-if(LIBICSNEO_ENABLE_DXX)
-	list(APPEND PLATFORM_SRC
-		platform/dxx.cpp
-	)
-endif()
-
-if(LIBICSNEO_ENABLE_TCP)
-	list(APPEND PLATFORM_SRC
-		platform/tcp.cpp
-	)
-endif()
-
-# Extensions
-set(LIBICSNEO_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-foreach(EXT_PATH ${LIBICSNEO_EXTENSION_DIRS})
-	get_filename_component(EXT_DIR ${EXT_PATH} NAME)
-	message("Adding extension " ${EXT_DIR})
-	add_subdirectory(${EXT_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${EXT_DIR})
-endforeach()
-
 set(SRC_FILES
 	communication/message/flexray/control/flexraycontrolmessage.cpp
 	communication/message/callback/streamoutput/a2bwavoutput.cpp
@@ -306,6 +232,28 @@ set(SRC_FILES
 	${PLATFORM_SRC}
 )
 
+if(LIBICSNEO_ENABLE_BOOTLOADER)
+	list(APPEND SRC_FILES
+		device/extensions/bootloader/api.cpp
+		device/extensions/bootloader/version.cpp
+		device/extensions/bootloader/platform/logging.cpp
+		device/extensions/bootloader/parser/ief.cpp
+		device/extensions/bootloader/parser/fwzip.cpp
+		device/extensions/bootloader/parser/fwbin.cpp
+		device/extensions/bootloader/parser/fwbundle.cpp
+		device/extensions/bootloader/parser/fwloader.cpp
+		device/extensions/bootloader/communication/red.cpp
+		device/extensions/bootloader/communication/radmultichipcommunication.cpp
+		device/extensions/bootloader/communication/communication.cpp
+		device/extensions/bootloader/communication/radperiphcommunication.cpp
+		device/extensions/bootloader/communication/radcommunication.cpp
+		device/extensions/bootloader/communication/redpacketizer.cpp
+		device/extensions/bootloader/communication/redcore.cpp
+		device/extensions/bootloader/communication/application.cpp
+		device/extensions/bootloader/communication/redbase.cpp
+	)
+endif()
+
 # Generate build info header
 execute_process(
 	COMMAND git rev-parse --abbrev-ref HEAD
@@ -335,17 +283,6 @@ configure_file(api/icsneocpp/buildinfo.h.template ${CMAKE_CURRENT_BINARY_DIR}/ge
 configure_file(api/icsneoc/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 configure_file(api/icsneoc2/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc2/version.rc)
 
-foreach(EXTINC ${LIBICSNEO_EXTENSION_INCLUDES})
-	message("Including " ${EXTINC})
-	list(APPEND LIBICSNEO_EXT_CODE_INCS_LIST "#include \"${EXTINC}\"")
-endforeach()
-list(JOIN LIBICSNEO_EXT_CODE_INCS_LIST "\n" LIBICSNEO_EXT_CODE_INCS)
-foreach(EXTCLASS ${LIBICSNEO_EXTENSION_CLASSES})
-	list(APPEND LIBICSNEO_EXT_CODE_LIST "device->addExtension(std::make_shared<${EXTCLASS}>(*device))\;")
-endforeach()
-list(JOIN LIBICSNEO_EXT_CODE_LIST "\n\t" LIBICSNEO_EXT_CODE)
-configure_file(include/icsneo/device/extensions/builtin.h.template ${CMAKE_CURRENT_BINARY_DIR}/generated/extensions/builtin.h)
-
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
 
 add_library(icsneocpp
@@ -356,78 +293,24 @@ add_library(icsneocpp
 	api/icsneocpp/version.cpp
 	${SRC_FILES}
 )
-message("Include paths " ${LIBICSNEO_EXTENSION_INCLUDE_PATHS})
 target_include_directories(icsneocpp
 	PUBLIC
 		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 		$<INSTALL_INTERFACE:>
 	PRIVATE
 		${CMAKE_CURRENT_SOURCE_DIR}/include
-		${LIBICSNEO_EXTENSION_INCLUDE_PATHS}
 )
 target_link_libraries(icsneocpp PUBLIC Threads::Threads $<$<BOOL:${WIN32}>:ws2_32 iphlpapi>)
-set_property(TARGET icsneocpp PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_compile_features(icsneocpp PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 target_compile_options(icsneocpp PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
-message("Loaded extensions: " ${LIBICSNEO_EXTENSION_TARGETS})
-target_link_libraries(icsneocpp PUBLIC ${LIBICSNEO_EXTENSION_TARGETS})
 if(LIBICSNEO_ENABLE_FIRMIO)
 	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_FIRMIO)
 endif()
-if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_RAW_ETHERNET)
-endif()
-if(LIBICSNEO_ENABLE_CDCACM)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_CDCACM)
-	if(APPLE)
-		find_library(CORE_FOUNDATION_FRAMEWORK CoreFoundation REQUIRED)
-		find_library(IO_KIT_FRAMEWORK IOKit REQUIRED)
-		target_link_libraries(icsneocpp PRIVATE ${CORE_FOUNDATION_FRAMEWORK} ${IO_KIT_FRAMEWORK})
-	endif()
-endif()
-if(LIBICSNEO_ENABLE_DXX)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_DXX)
-	target_link_libraries(icsneocpp PRIVATE libredxx::libredxx)
-endif()
-if(LIBICSNEO_ENABLE_TCP)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_TCP)
-	if(WIN32)
-		target_link_libraries(icsneocpp PRIVATE ws2_32 iphlpapi)
-	endif()
-endif()
 
 # fatfs
 add_subdirectory(third-party/fatfs)
-set_property(TARGET fatfs PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(icsneocpp PRIVATE fatfs)
 
-# dxx
-if(LIBICSNEO_ENABLE_DXX)
-	include(FetchContent)
-	FetchContent_Declare(libredxx
-		GIT_REPOSITORY https://github.com/Zeranoe/libredxx.git
-		GIT_TAG e823a96c39a64ab41b7d1632dbe8f86bb854df83
-	)
-	set(LIBREDXX_DISABLE_INSTALL ON)
-	FetchContent_MakeAvailable(libredxx)
-endif()
-
-# pcap
-if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-	if(WIN32)
-		if(LIBICSNEO_NPCAP_INCLUDE_DIR STREQUAL "")
-			target_include_directories(icsneocpp PUBLIC AFTER third-party/winpcap/include)
-			add_definitions(-DWPCAP -DHAVE_REMOTE)
-		else()
-			target_include_directories(icsneocpp PUBLIC AFTER ${LIBICSNEO_NPCAP_INCLUDE_DIR})
-		endif()
-	else()
-		find_package(PCAP REQUIRED)
-		target_include_directories(icsneocpp PUBLIC ${PCAP_INCLUDE_DIR})
-		target_link_libraries(icsneocpp PUBLIC ${PCAP_LIBRARY})
-	endif(WIN32)
-endif(LIBICSNEO_ENABLE_RAW_ETHERNET)
-
 # protobuf
 if(DEFINED ENV{LIBICSNEO_ICSPB_REPO})
 	set(LIBICSNEO_ICSPB_REPO "$ENV{LIBICSNEO_ICSPB_REPO}")
@@ -443,6 +326,59 @@ FetchContent_Declare(icspb
 FetchContent_MakeAvailable(icspb)
 target_link_libraries(icsneocpp PRIVATE icspb::icspb)
 
+# libicsbl
+if(LIBICSNEO_ENABLE_BOOTLOADER)
+	if(NOT LIBICSNEO_LIBICSBL_ZIP_URL)
+		if(DEFINED ENV{LIBICSNEO_LIBICSBL_ZIP_URL})
+			set(LIBICSNEO_LIBICSBL_ZIP_URL "$ENV{LIBICSNEO_LIBICSBL_ZIP_URL}")
+		else()
+			if(NOT LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX)
+				if(DEFINED ENV{LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX})
+					set(LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX "$ENV{LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}")
+				else()
+					set(LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX "https://cdn.intrepidcs.net/libicsbl/5ce699ada0ccaadb92cabda6e3537c09b333020e")
+				endif()
+			endif()
+			if(NOT LIBICSNEO_LIBICSBL_VERSION)
+				if(DEFINED ENV{LIBICSNEO_LIBICSBL_VERSION})
+					set(LIBICSNEO_LIBICSBL_VERSION "$ENV{LIBICSNEO_LIBICSBL_VERSION}")
+				else()
+					set(LIBICSNEO_LIBICSBL_VERSION "26.4.0")
+				endif()
+			endif()
+			if(WIN32)
+				if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8 OR CMAKE_CXX_COMPILER_ARCHITECTURE_ID MATCHES "ARM")
+					message(FATAL_ERROR "Unsupported bootloader architecture: ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}")
+				endif()
+				set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-windows-amd64.zip")
+			elseif(APPLE)
+				set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-macos-universal.zip")
+			else()
+				if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+					set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-linux-x86_64-glibc.zip")
+				elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+					set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-linux-aarch64-glibc.zip")
+				else()
+					message(FATAL_ERROR "Unsupported CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
+				endif()
+			endif()
+		endif()
+	endif()
+
+	FetchContent_Declare(
+		libicsbl
+		URL "${LIBICSNEO_LIBICSBL_ZIP_URL}"
+	)
+	FetchContent_MakeAvailable(libicsbl)
+	set(libicsbl_ROOT "${libicsbl_SOURCE_DIR}")
+	find_package(libicsbl CONFIG REQUIRED)
+	target_link_libraries(icsneocpp PUBLIC libicsbl::icsbl)
+
+	# miniz
+	add_subdirectory(third-party/miniz)
+	target_link_libraries(icsneocpp PRIVATE miniz)
+endif()
+
 if(LIBICSNEO_BUILD_ICSNEOC)
 	add_library(icsneoc SHARED api/icsneoc/icsneoc.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 	target_include_directories(icsneoc
@@ -570,10 +506,12 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/a2bencoderdecodertest.cpp
 		test/unit/mdioencoderdecodertest.cpp
 		test/unit/livedataencoderdecodertest.cpp
+		test/unit/macsectest.cpp
 		test/unit/ringbuffertest.cpp
 		test/unit/apperrordecodertest.cpp
 		test/unit/icsneoc2.cpp
-		test/unit/windowsstrings.cpp
+		test/unit/ethphyregistertest.cpp
+		test/unit/tc10test.cpp
 		test/unit/periodictest.cpp
 	)
 

README.md

@@ -30,13 +30,13 @@ Instructions for installing each API can be found in its respective documentatio
 - neoVI PLASMA
 - neoVI RED 2
 - RAD-A2B
+- RAD-Argos
 - RAD-Comet 2
 - RAD-Comet 3
 - RAD-Epsilon
 - RAD-EpsilonXL
 - RAD-Galaxy
 - RAD-Galaxy 2
-- RAD-Gemini
 - RAD-Gigastar
 - RAD-Gigastar 2
 - RAD-Moon 2

api/icsneoc2/icsneoc2settings.cpp

@@ -706,7 +706,7 @@ icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_set(icsneoc2_device_t* device
     return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
+icsneoc2_error_t icsneoc2_settings_t1s_max_burst_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
     // Make sure the device is valid
     auto res = icsneoc2_device_is_valid(device);
     if(res != icsneoc2_error_success) {
@@ -725,7 +725,7 @@ icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t
     }
 }
 
-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
+icsneoc2_error_t icsneoc2_settings_t1s_max_burst_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
     // Make sure the device is valid
     auto res = icsneoc2_device_is_valid(device);
     if(res != icsneoc2_error_success) {

api/icsneocpp/event.cpp

@@ -117,6 +117,9 @@ static constexpr const char* GPTP_NOT_SUPPORTED = "GPTP clock synchronization is
 static constexpr const char* SETTING_NOT_AVAILABLE = "Requested a setting that is not available on this device";
 static constexpr const char* DISK_FORMAT_NOT_SUPPORTED = "Disk formatting is not supported on this device.";
 static constexpr const char* DISK_FORMAT_INVALID_COUNT = "Disk format config disk count is mismatched with device disk count.";
+static constexpr const char* TC10_REQUEST_FAILED = "The device rejected the TC10 request.";
+static constexpr const char* FIRMWARE_UPDATE_NOT_SUPPORTED = "Firmware updates are not supported for this device.";
+static constexpr const char* FIRMWARE_UPDATE_FAILED = "The firmware update failed.";
 
 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@@ -168,6 +171,7 @@ static constexpr const char* SERVD_POLL_ERROR = "Error polling on Servd socket";
 static constexpr const char* SERVD_NODATA_ERROR = "No data received from Servd";
 static constexpr const char* SERVD_JOIN_MULTICAST_ERROR = "Error joining Servd multicast group";
 static constexpr const char* SERVD_NOT_REACHABLE = "Could not reach Servd; ensure it is installed and running";
+static constexpr const char* SERVD_DISABLED = "Servd is disabled via LIBICSNEO_USE_SERVD; no devices will be found";
 
 // DXX
 static constexpr const char* DXX_ERROR_SYS = "System error, check errno/GetLastError()";
@@ -381,6 +385,12 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return DISK_FORMAT_NOT_SUPPORTED;
 		case Type::DiskFormatInvalidCount:
 			return DISK_FORMAT_INVALID_COUNT;
+		case Type::TC10RequestFailed:
+			return TC10_REQUEST_FAILED;
+		case Type::FirmwareUpdateNotSupported:
+			return FIRMWARE_UPDATE_NOT_SUPPORTED;
+		case Type::FirmwareUpdateFailed:
+			return FIRMWARE_UPDATE_FAILED;
 
 		// VSA
 		case Type::VSABufferCorrupted:
@@ -442,6 +452,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return SERVD_JOIN_MULTICAST_ERROR;
 		case Type::ServdNotReachable:
 			return SERVD_NOT_REACHABLE;
+		case Type::ServdDisabled:
+			return SERVD_DISABLED;
 
 		// DXX
 		case Type::DXXErrorSys:

api/icsneocpp/eventmanager.cpp

@@ -65,7 +65,6 @@ void EventManager::add(APIEvent event) {
 				std::lock_guard<std::mutex> eventsLock(eventsMutex);
 				addEventInternal(event);
 			} // free the lock so that callbacks may modify events
-			runCallbacks(event);
 		} else {
 			std::lock_guard<std::mutex> errorsLock(errorsMutex);
 			lastUserErrors[std::this_thread::get_id()] = event;
@@ -75,8 +74,8 @@ void EventManager::add(APIEvent event) {
 			std::lock_guard<std::mutex> eventsLock(eventsMutex);
 			addEventInternal(event);
 		} // free the lock so that callbacks may modify events
-		runCallbacks(event);
 	}
+	runCallbacks(event);
 }
 
 void EventManager::addEventInternal(APIEvent event) {
@@ -100,8 +99,12 @@ void EventManager::addEventInternal(APIEvent event) {
 }
 
 void EventManager::runCallbacks(APIEvent event) {
+    std::map<int, icsneo::EventCallback> tempCallbacks;
+    {
         std::lock_guard<std::mutex> lk(callbacksMutex);
-	for(auto& i : callbacks)
+        tempCallbacks = callbacks;
+    }
+    for(auto& i : tempCallbacks)
         i.second.callIfMatch(std::make_shared<APIEvent>(event));
 }
 

api/icsneolegacy/icsneolegacy.cpp

@@ -1073,8 +1073,8 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_RADMOON3:
 		*pDeviceSettingsType = DeviceRADMoon3SettingsType;
 		break;
-	case NEODEVICE_RADGEMINI:
-		*pDeviceSettingsType = DeviceRADGeminiSettingsType;
+	case NEODEVICE_RADARGOS:
+		*pDeviceSettingsType = DeviceRADArgosSettingsType;
 		break;
 	case NEODEVICE_RED2:
 		*pDeviceSettingsType = DeviceRed2SettingsType;

bindings/python/CMakeLists.txt

@@ -26,6 +26,7 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/message.cpp
     icsneopy/communication/message/canmessage.cpp
     icsneopy/communication/message/canerrormessage.cpp
+    icsneopy/communication/message/iso15765message.cpp
     icsneopy/communication/message/ethernetmessage.cpp
     icsneopy/communication/message/linmessage.cpp
     icsneopy/communication/message/tc10statusmessage.cpp
@@ -56,6 +57,18 @@ pybind11_add_module(icsneopy
 )
 target_link_libraries(icsneopy PRIVATE icsneocpp)
 
+if(LIBICSNEO_ENABLE_BOOTLOADER)
+    target_sources(icsneopy PRIVATE icsneopy/bootloader/bootloader.cpp)
+    target_compile_definitions(icsneopy PRIVATE ICSNEO_ENABLE_BOOTLOADER)
+    if(WIN32)
+        # Windows has no build RPATH; the .pyd only finds DLLs in its own directory
+        add_custom_command(TARGET icsneopy POST_BUILD
+            COMMAND "${CMAKE_COMMAND}" -E copy_if_different "$<TARGET_FILE:libicsbl::icsbl>" "$<TARGET_FILE_DIR:icsneopy>"
+            VERBATIM
+        )
+    endif()
+endif()
+
 install(TARGETS icsneopy LIBRARY DESTINATION icsneopy)
 
 find_program(STUBGEN_EXE stubgen)

bindings/python/icsneopy/api/event.cpp

@@ -92,6 +92,9 @@ void init_event(pybind11::module_& m) {
 		.value("SettingNotAvaiableDevice", APIEvent::Type::SettingNotAvaiableDevice)
 		.value("DiskFormatNotSupported", APIEvent::Type::DiskFormatNotSupported)
 		.value("DiskFormatInvalidCount", APIEvent::Type::DiskFormatInvalidCount)
+		.value("TC10RequestFailed", APIEvent::Type::TC10RequestFailed)
+		.value("FirmwareUpdateNotSupported", APIEvent::Type::FirmwareUpdateNotSupported)
+		.value("FirmwareUpdateFailed", APIEvent::Type::FirmwareUpdateFailed)
 		.value("FailedToRead", APIEvent::Type::FailedToRead)
 		.value("FailedToWrite", APIEvent::Type::FailedToWrite)
 		.value("DriverFailedToOpen", APIEvent::Type::DriverFailedToOpen)
@@ -127,6 +130,7 @@ void init_event(pybind11::module_& m) {
 		.value("ServdNoDataError", APIEvent::Type::ServdNoDataError)
 		.value("ServdJoinMulticastError", APIEvent::Type::ServdJoinMulticastError)
 		.value("ServdNotReachable", APIEvent::Type::ServdNotReachable)
+		.value("ServdDisabled", APIEvent::Type::ServdDisabled)
 		.value("DXXErrorSys", APIEvent::Type::DXXErrorSys)
 		.value("DXXErrorInt", APIEvent::Type::DXXErrorInt)
 		.value("DXXErrorOverflow", APIEvent::Type::DXXErrorOverflow)

bindings/python/icsneopy/bootloader/bootloader.cpp

@@ -0,0 +1,37 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/parser/fwloader.h"
+
+namespace icsneo {
+
+struct BootloaderNamespace {};
+
+void init_bootloader(pybind11::module_& m) {
+	// Dummy class to act as Bootloader namespace
+	pybind11::classh<BootloaderNamespace> bootloader(m, "Bootloader");
+
+	// Opaque handle returned by FWLoader.load and consumed by update
+	pybind11::classh<Bootloader::FWRepo>(bootloader, "FWRepo");
+
+	pybind11::classh<Bootloader::FWLoader>(bootloader, "FWLoader")
+		.def_static("load", &Bootloader::FWLoader::Load, pybind11::arg("path"), pybind11::call_guard<pybind11::gil_scoped_release>());
+
+	bootloader.def_static("update",
+		[](Device& device, const Bootloader::FWRepo& fw, Bootloader::Logger logger, bool alreadyInBootloader, bool forceFlash) {
+			if(!logger) {
+				logger = [](Device::OpenStatusType, const std::string&, std::optional<double>) { return Device::OpenDirective::Continue; };
+			}
+			return Bootloader::update(device, fw, logger, alreadyInBootloader, forceFlash);
+		},
+		pybind11::arg("device"),
+		pybind11::arg("fw"),
+		pybind11::arg("logger") = pybind11::none(),
+		pybind11::arg("already_in_bootloader") = false,
+		pybind11::arg("force_flash") = false,
+		pybind11::call_guard<pybind11::gil_scoped_release>());
+}
+
+} // namespace icsneo

bindings/python/icsneopy/communication/message/iso15765message.cpp

@@ -0,0 +1,48 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "icsneo/communication/message/iso15765message.h"
+
+namespace icsneo {
+
+void init_iso15765message(pybind11::module_& m) {
+	auto args = pybind11::classh<Iso15765MessageArgs>(m, "Iso15765MessageArgs");
+
+	pybind11::classh<Iso15765MessageArgs::ArbId>(args, "ArbId")
+		.def(pybind11::init<uint32_t, bool>(), pybind11::arg("id") = 0, pybind11::arg("is_29bit") = false)
+		.def_readwrite("id", &Iso15765MessageArgs::ArbId::Id)
+		.def_readwrite("is_29bit", &Iso15765MessageArgs::ArbId::Is29Bit);
+
+	args.def(pybind11::init<>())
+		.def_property("tx_index", &Iso15765MessageArgs::getTxIndex, &Iso15765MessageArgs::setTxIndex)
+		.def_property("arb_id",
+			[](Iso15765MessageArgs& self) -> Iso15765MessageArgs::ArbId& {
+				return const_cast<Iso15765MessageArgs::ArbId&>(self.getArbId());
+			},
+			&Iso15765MessageArgs::setArbId,
+			pybind11::return_value_policy::reference_internal)
+		.def_property("flow_control_arb_id",
+			[](Iso15765MessageArgs& self) -> Iso15765MessageArgs::ArbId& {
+				return const_cast<Iso15765MessageArgs::ArbId&>(self.getFlowControlArbId());
+			},
+			&Iso15765MessageArgs::setFlowControlArbId,
+			pybind11::return_value_policy::reference_internal)
+		.def_property("flow_control_arb_id_mask", &Iso15765MessageArgs::getFlowControlArbIdMask, &Iso15765MessageArgs::setFlowControlArbIdMask)
+		.def_property("is_can_fd", &Iso15765MessageArgs::getIsCanFd, &Iso15765MessageArgs::setIsCanFd)
+		.def_property("is_brs_enabled", &Iso15765MessageArgs::getIsBrsEnabled, &Iso15765MessageArgs::setIsBrsEnabled)
+		.def_property("tx_dl", &Iso15765MessageArgs::getTxDl, &Iso15765MessageArgs::setTxDl)
+		.def_property("st_min", &Iso15765MessageArgs::getStMin, &Iso15765MessageArgs::setStMin)
+		.def_property("block_size", &Iso15765MessageArgs::getBlockSize, &Iso15765MessageArgs::setBlockSize)
+		.def_property("extended_address", &Iso15765MessageArgs::getExtendedAddress, &Iso15765MessageArgs::setExtendedAddress)
+		.def_property("flow_control_extended_address", &Iso15765MessageArgs::getFlowControlExtendedAddress, &Iso15765MessageArgs::setFlowControlExtendedAddress)
+		.def_property("padding_value", &Iso15765MessageArgs::getPaddingValue, &Iso15765MessageArgs::setPaddingValue)
+		.def_property("fs_timeout", &Iso15765MessageArgs::getFsTimeout, &Iso15765MessageArgs::setFsTimeout)
+		.def_property("fs_wait_timeout", &Iso15765MessageArgs::getFsWaitTimeout, &Iso15765MessageArgs::setFsWaitTimeout)
+		.def_property("cf_timeout", &Iso15765MessageArgs::getCfTimeout, &Iso15765MessageArgs::setCfTimeout)
+		.def_property("data",
+			&Iso15765MessageArgs::getData,
+			[](Iso15765MessageArgs& self, std::vector<uint8_t> data) { self.setData(std::move(data)); })
+		.def_property("is_flow_control_enabled", &Iso15765MessageArgs::getIsFlowControlEnabled, &Iso15765MessageArgs::setIsFlowControlEnabled);
+}
+
+} // namespace icsneo

bindings/python/icsneopy/core/macseccfg.cpp

@@ -154,7 +154,6 @@ void init_macsecconfig(pybind11::module_ & m)
 		.def("set_storage", &MACsecConfig::setStorage, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("clear", &MACsecConfig::clear, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("serialize", &MACsecConfig::serialize, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_bin_index", &MACsecConfig::getBinIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_type", &MACsecConfig::getType, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_max_num_rule", &MACsecConfig::getMaxNumRule, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_max_num_secy", &MACsecConfig::getMaxNumSecY, pybind11::call_guard<pybind11::gil_scoped_release>())

bindings/python/icsneopy/device/chipid.cpp

@@ -134,7 +134,8 @@ void init_chipid(pybind11::module_& m) {
 		.value("SFPModule_lan8670_MCHIP", ChipID::SFPModule_lan8670_MCHIP)
 		.value("RADGigastar2_ZYNQ", ChipID::RADGigastar2_ZYNQ)
 		.value("SFPModule_ent11100_MCHIP", ChipID::SFPModule_ent11100_MCHIP)
-		.value("RADGemini_MCHIP", ChipID::RADGemini_MCHIP)
+		.value("RADArgos_MCHIP", ChipID::RADArgos_MCHIP)
+		.value("SFPModule_ad1101_MCHIP", ChipID::SFPModule_ad1101_MCHIP)
 		.value("Invalid", ChipID::Invalid)
 		.finalize();
 }

bindings/python/icsneopy/device/device.cpp

@@ -2,6 +2,7 @@
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
 #include <pybind11/chrono.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/device/device.h"
 #include "icsneo/device/extensions/deviceextension.h"
@@ -12,7 +13,22 @@
 namespace icsneo {
 
 void init_device(pybind11::module_& m) {
-	pybind11::classh<Device>(m, "Device")
+	pybind11::classh<Device> device(m, "Device");
+
+	pybind11::native_enum<Device::OpenDirective>(device, "OpenDirective", "enum.IntEnum")
+		.value("Continue", Device::OpenDirective::Continue)
+		.value("Cancel", Device::OpenDirective::Cancel)
+		.value("Skip", Device::OpenDirective::Skip)
+		.finalize();
+
+	pybind11::native_enum<Device::OpenStatusType>(device, "OpenStatusType", "enum.IntEnum")
+		.value("QuestionContinueSkipCancel", Device::OpenStatusType::QuestionContinueSkipCancel)
+		.value("QuestionContinueCancel", Device::OpenStatusType::QuestionContinueCancel)
+		.value("Progress", Device::OpenStatusType::Progress)
+		.value("Failed", Device::OpenStatusType::Failed)
+		.finalize();
+
+	device
 		.def("__repr__", &Device::describe)
 		.def("add_message_callback", &Device::addMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("clear_script", &Device::clearScript, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -34,6 +50,7 @@ void init_device(pybind11::module_& m) {
 		.def("get_serial", &Device::getSerial)
 		.def("get_pcb_serial", &Device::getPCBSerial, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_mac_addresses", &Device::getMACAddresses, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_macsec_networks", &Device::getMACsecNetworks)
 		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
 		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
 		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -44,6 +61,10 @@ void init_device(pybind11::module_& m) {
 		.def("is_online_supported", &Device::isOnlineSupported)
 		.def("is_online", &Device::isOnline)
 		.def("is_open", &Device::isOpen)
+		.def("iso15765_enable", &Device::iso15765Enable, pybind11::arg("network"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_disable_all", &Device::iso15765DisableAll, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_transmit_message", &Device::iso15765TransmitMessage, pybind11::arg("network"), pybind11::arg("message"), pybind11::arg("timeout"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_setup_rx_flow_control", &Device::iso15765SetupRxFlowControl, pybind11::arg("network"), pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("prepare_script_load", &Device::prepareScriptLoad, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -64,7 +85,7 @@ void init_device(pybind11::module_& m) {
 		.def("set_value_live_data", &Device::setValueLiveData, pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("upload_coremini", [](Device& device, std::string& path, Disk::MemoryType memType) { std::ifstream ifs(path, std::ios::binary); return device.uploadCoremini(ifs, memType); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("write_macsec_config", &Device::writeMACsecConfig, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("write_macsec_config", &Device::writeMACsecConfig, pybind11::arg("config"), pybind11::arg("network"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("send_eth_phy_msg", &Device::sendEthPhyMsg, pybind11::arg("message"), pybind11::arg("timeout") = std::chrono::milliseconds(50), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_chip_versions", &Device::getChipVersions, pybind11::arg("refreshComponents") = true, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("supports_disk_formatting", &Device::supportsDiskFormatting, pybind11::call_guard<pybind11::gil_scoped_release>())

bindings/python/icsneopy/device/devicetype.cpp

@@ -38,7 +38,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADwBMS", DeviceType::Enum::RADwBMS)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
-		.value("RADGemini", DeviceType::Enum::RADGemini)
+		.value("RADArgos", DeviceType::Enum::RADArgos)
 		.value("RADComet2", DeviceType::Enum::RADComet2)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
 		.value("FIRE3_T1S_LIN", DeviceType::Enum::FIRE3_T1S_LIN)

bindings/python/icsneopy/icsneocpp.cpp

@@ -15,6 +15,7 @@ void init_devicetype(pybind11::module_&);
 void init_message(pybind11::module_&);
 void init_canmessage(pybind11::module_&);
 void init_canerrormessage(pybind11::module_&);
+void init_iso15765message(pybind11::module_&);
 void init_ethernetmessage(pybind11::module_&);
 void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
@@ -43,6 +44,9 @@ void init_idevicesettings(pybind11::module_&);
 void init_ethphymessage(pybind11::module_&);
 void init_livedata(pybind11::module_&);
 void init_livedatamessage(pybind11::module_&);
+#ifdef ICSNEO_ENABLE_BOOTLOADER
+void init_bootloader(pybind11::module_&);
+#endif
 
 PYBIND11_MODULE(icsneopy, m) {
 	pybind11::options options;
@@ -60,6 +64,7 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_message(m);
 	init_canmessage(m);
 	init_canerrormessage(m);
+	init_iso15765message(m);
 	init_ethernetmessage(m);
 	init_linmessage(m);
 	init_tc10statusmessage(m);
@@ -86,6 +91,9 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_device(m);
     init_deviceextension(m);
 	init_idevicesettings(m);
+#ifdef ICSNEO_ENABLE_BOOTLOADER
+	init_bootloader(m);
+#endif
 
 	m.def("find_all_devices", &FindAllDevices);
 	m.def("get_supported_devices", &GetSupportedDevices);

ci/bootstrap-libpcap.sh

@@ -1,18 +0,0 @@
-#!/bin/sh
-
-VERSION="1.10.5"
-ROOT="$PWD/libpcap"
-SOURCE="$ROOT/source"
-BUILD="$ROOT/build"
-INSTALL="$ROOT/install"
-
-mkdir -p "$ROOT"
-cd "$ROOT" || exit 1
-
-curl -LO "https://www.tcpdump.org/release/libpcap-$VERSION.tar.xz" || exit 1
-tar -xf "libpcap-$VERSION.tar.xz" || exit 1
-mv "libpcap-$VERSION" "$SOURCE" || exit 1
-
-cmake -D CMAKE_POSITION_INDEPENDENT_CODE=ON -D CMAKE_INSTALL_PREFIX="$INSTALL" -D BUILD_SHARED_LIBS=OFF -D BUILD_WITH_LIBNL=OFF -D DISABLE_DBUS=ON -D DISABLE_LINUX_USBMON=ON -D DISABLE_BLUETOOTH=ON -D DISABLE_NETMAP=ON -D DISABLE_DPDK=ON -D DISABLE_RDMA=ON -D DISABLE_DAG=ON -D DISABLE_SEPTEL=ON -D DISABLE_SNF=ON -D DISABLE_TC=ON -B "$BUILD" -S "$SOURCE" || exit 1
-cmake --build "$BUILD" || exit 1
-cmake --install "$BUILD" || exit 1

ci/build-posix.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_BOOTLOADER=ON || exit 1
 
 cmake --build build || exit 1
 

ci/build-wheel-linux.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export CIBW_BEFORE_ALL="sh ci/bootstrap-cibuildwheel.sh"
+export CIBW_BUILD="*manylinux*" # no musl
+export CIBW_ENVIRONMENT="LD_LIBRARY_PATH=/project/fc/libicsbl-src/lib64"
+export SKBUILD_CMAKE_DEFINE="LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=/project/icspb;FETCHCONTENT_BASE_DIR=/project/fc"
+
+sh ci/build-wheel-posix.sh

ci/build-wheel-macos.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export CIBW_ARCHS="arm64"
+export SKBUILD_CMAKE_DEFINE="LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=$PWD/icspb;FETCHCONTENT_BASE_DIR=$PWD/fc"
+export REPAIR_LIBRARY_PATH="$PWD/fc/libicsbl-src/lib"
+export MACOSX_DEPLOYMENT_TARGET="10.14"
+
+sh ci/build-wheel-posix.sh

ci/build-wheel-windows.bat

@@ -3,6 +3,9 @@
 
 call "%VCVARS64_2022%"
 
+set "SKBUILD_CMAKE_DEFINE=LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=%CD%\icspb;FETCHCONTENT_BASE_DIR=%CD%\fc"
+set "PATH=%CD%\fc\libicsbl-src\bin;%PATH%"
+
 python.exe -m venv env || exit /b 1
 call env\Scripts\Activate.bat || exit /b 1
 python.exe -m pip install cibuildwheel || exit /b 1

ci/build-windows.bat

@@ -3,6 +3,6 @@
 
 mkdir build >nul 2>&1
 
-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON-DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_BOOTLOADER=ON || exit /b 1
 
 cmake --build build || exit /b 1

cmake/FindPCAP.cmake

@@ -1,74 +0,0 @@
-# - Try to find libpcap include dirs and libraries
-#
-# Usage of this module as follows:
-#
-#     find_package(PCAP)
-#
-# Variables used by this module, they can change the default behaviour and need
-# to be set before calling find_package:
-#
-#  PCAP_ROOT_DIR             Set this variable to the root installation of
-#                            libpcap if the module has problems finding the
-#                            proper installation path.
-#
-# Variables defined by this module:
-#
-#  PCAP_FOUND                System has libpcap, include and library dirs found
-#  PCAP_INCLUDE_DIR          The libpcap include directories.
-#  PCAP_LIBRARY              The libpcap library (possibly includes a thread
-#                            library e.g. required by pf_ring's libpcap)
-#  HAVE_PF_RING              If a found version of libpcap supports PF_RING
-
-find_path(PCAP_ROOT_DIR
-	NAMES include/pcap.h
-)
-
-find_path(PCAP_INCLUDE_DIR
-	NAMES pcap.h
-	HINTS ${PCAP_ROOT_DIR}/include
-)
-
-find_library(PCAP_LIBRARY
-	NAMES pcap
-	HINTS ${PCAP_ROOT_DIR}/lib
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(PCAP DEFAULT_MSG
-	PCAP_LIBRARY
-	PCAP_INCLUDE_DIR
-)
-
-include(CheckCSourceCompiles)
-set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
-check_c_source_compiles("int main() { return 0; }" PCAP_LINKS_SOLO)
-set(CMAKE_REQUIRED_LIBRARIES)
-
-# check if linking against libpcap also needs to link against a thread library
-if (NOT PCAP_LINKS_SOLO)
-	find_package(Threads)
-	if (THREADS_FOUND)
-		set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
-		check_c_source_compiles("int main() { return 0; }" PCAP_NEEDS_THREADS)
-		set(CMAKE_REQUIRED_LIBRARIES)
-	endif ()
-	if (THREADS_FOUND AND PCAP_NEEDS_THREADS)
-		set(_tmp ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
-		list(REMOVE_DUPLICATES _tmp)
-		set(PCAP_LIBRARY ${_tmp}
-			CACHE STRING "Libraries needed to link against libpcap" FORCE)
-	else ()
-		message(FATAL_ERROR "Couldn't determine how to link against libpcap")
-	endif ()
-endif ()
-
-include(CheckFunctionExists)
-set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
-check_function_exists(pcap_get_pfring_id HAVE_PF_RING)
-set(CMAKE_REQUIRED_LIBRARIES)
-
-mark_as_advanced(
-	PCAP_ROOT_DIR
-	PCAP_INCLUDE_DIR
-	PCAP_LIBRARY
-)

communication/message/transmitmessage.cpp

@@ -152,6 +152,7 @@ static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, c
 	                linmsg->linMsgType == LINMessage::Type::LIN_UPDATE_RESPONDER) && dataLen > 0;
 
 	if(hasData) {
+		LINMessage::calcChecksum(*linmsg);
 		// len includes data bytes + 1 checksum byte
 		linpacket->CoreMiniBitsLIN.len = static_cast<uint16_t>(dataLen + 1);
 		std::copy(linmsg->data.begin(), linmsg->data.begin() + dataLen, linpacket->data);

communication/packet/ethphyregpacket.cpp

@@ -20,7 +20,7 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 	if(
 		(PhyPacketVersion == pHeader->version) &&
 		(sizeof(PhyRegisterPacket_t) == pHeader->entryBytes) &&
-		(numEntries <= MaxPhyEntries) &&
+		(numEntries > 0 && numEntries <= MaxPhyEntries) &&
 		((bytestream.size() - sizeof(PhyRegisterHeader_t))
 			== (sizeof(PhyRegisterPacket_t) * numEntries))
 	)
@@ -30,11 +30,16 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 		for(size_t entryIdx{0}; entryIdx < numEntries; ++entryIdx)
 		{
 			const PhyRegisterPacket_t* pEntry = (pFirstEntry + entryIdx);
+			if(pEntry->version != PhyPacketVersion) {
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+			}
 			auto phyMessage = std::make_shared<PhyMessage>();
 			phyMessage->Enabled = (pEntry->Enabled != 0u);
 			phyMessage->WriteEnable = (pEntry->WriteEnable != 0u);
 			phyMessage->Clause45Enable = (pEntry->Clause45Enable != 0u);
 			phyMessage->BusIndex = static_cast<uint8_t>(pEntry->BusIndex);
+			phyMessage->Status = static_cast<uint8_t>(pEntry->status);
 			phyMessage->Version = static_cast<uint8_t>(pEntry->version);
 			if(phyMessage->Clause45Enable)
 				phyMessage->Clause45 = pEntry->clause45;
@@ -43,6 +48,10 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 			msg->messages.push_back(phyMessage);
 		}
 	}
+	else {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return nullptr;
+	}
 	return msg;
 }
 
@@ -59,7 +68,20 @@ bool HardwareEthernetPhyRegisterPacket::EncodeFromMessage(const EthPhyMessage& m
 		report(APIEvent::Type::MessageMaxLengthExceeded, APIEvent::Severity::Error);
 		return false;
 	}
-	auto byteSize = (messageCount * sizeof(PhyRegisterPacket_t)) + sizeof(PhyRegisterHeader_t);
+	// Validate every entry before touching the caller's output or submitting a command.
+	for(const auto& entry : message.messages) {
+		if(!entry) {
+			report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+			return false;
+		}
+		if(entry->BusIndex > 15 || entry->Version != PhyPacketVersion ||
+			(entry->Clause45Enable ? (entry->Clause45.port > FiveBits || entry->Clause45.device > FiveBits) :
+			(entry->Clause22.phyAddr > FiveBits || entry->Clause22.regAddr > FiveBits))) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+	}
+	auto byteSize = bytestream.size() + (messageCount * sizeof(PhyRegisterPacket_t)) + sizeof(PhyRegisterHeader_t);
 	bytestream.reserve(byteSize);
 	bytestream.push_back(static_cast<uint8_t>(messageCount & 0xFF));
 	bytestream.push_back(static_cast<uint8_t>((messageCount >> 8) & 0xFF));
@@ -67,7 +89,7 @@ bool HardwareEthernetPhyRegisterPacket::EncodeFromMessage(const EthPhyMessage& m
 	bytestream.push_back(static_cast<uint8_t>(sizeof(PhyRegisterPacket_t)));
 	for(auto& phyMessage : message.messages)
 	{
-		PhyRegisterPacket_t tempPacket;
+		PhyRegisterPacket_t tempPacket{};
 		tempPacket.Enabled = phyMessage->Enabled ? 0x1u : 0x0u;
 		tempPacket.WriteEnable = phyMessage->WriteEnable ? 0x1u : 0x0u;
 		tempPacket.BusIndex = (phyMessage->BusIndex & 0xF);

core/macseccfg.cpp

@@ -231,16 +231,16 @@ MACsecConfig::MACsecConfig(const DeviceType& deviceType) : type(deviceType) {
 		case icsneo::DeviceType::Enum::RADMoon3:
 		case icsneo::DeviceType::Enum::RADEpsilon:
 		case icsneo::DeviceType::Enum::RADGigastar2:
+		case icsneo::DeviceType::Enum::RADComet2:
+		case icsneo::DeviceType::Enum::RADComet3:
 			maxSecY = 2;
 			maxRule = 2;
 			maxSa = 4;
-			binIndex = 0;
 			break;
 		default:
 			maxSecY = 0;
 			maxSa = 0;
 			maxRule = 0;
-			binIndex = 0;
 			ReportEvent(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
 			return;
 	}
@@ -515,10 +515,6 @@ MACsecConfig::operator bool() const {
 	return (maxSa != 0) || (maxSecY != 0) || (maxRule != 0);
 }
 
-uint16_t MACsecConfig::getBinIndex() const {
-	return binIndex;
-}
-
 DeviceType MACsecConfig::getType() const {
 	return type;
 }

device/device.cpp

@@ -2053,7 +2053,12 @@ std::optional<EthPhyMessage> Device::sendEthPhyMsg(const EthPhyMessage& message,
 	}
 
 	std::vector<uint8_t> bytes;
-	HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report);
+	if(timeout.count() <= 0) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	if(!HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report))
+		return std::nullopt;
 	std::shared_ptr<Message> response = com->waitForMessageSync(
 		[this, bytes](){ return com->sendCommand(Command::PHYControlRegisters, bytes); },
 		std::make_shared<MessageFilter>(Message::Type::EthernetPhyRegister), timeout);
@@ -3654,7 +3659,7 @@ bool Device::requestTC10Wake(Network::NetID network) {
 	*(Network::NetID*)args.data() = network;
 	auto msg = com->waitForMessageSync([&] {
 		return com->sendCommand(ExtendedCommand::RequestTC10Wake, args);
-	}, std::make_shared<MessageFilter>(Message::Type::ExtendedResponse), std::chrono::milliseconds(1000));
+	}, std::make_shared<ExtendedResponseFilter>(ExtendedCommand::RequestTC10Wake), std::chrono::milliseconds(1000));
 
 	if(!msg) {
 		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
@@ -3667,7 +3672,11 @@ bool Device::requestTC10Wake(Network::NetID network) {
 		return false;
 	}
 
-	return resp->response == ExtendedResponse::OK;
+	if(resp->response != ExtendedResponse::OK) {
+		report(APIEvent::Type::TC10RequestFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
 }
 
 bool Device::requestTC10Sleep(Network::NetID network) {
@@ -3679,7 +3688,7 @@ bool Device::requestTC10Sleep(Network::NetID network) {
 	*(Network::NetID*)args.data() = network;
 	auto msg = com->waitForMessageSync([&] {
 		return com->sendCommand(ExtendedCommand::RequestTC10Sleep, args);
-	}, std::make_shared<MessageFilter>(Message::Type::ExtendedResponse), std::chrono::milliseconds(1000));
+	}, std::make_shared<ExtendedResponseFilter>(ExtendedCommand::RequestTC10Sleep), std::chrono::milliseconds(1000));
 
 	if(!msg) {
 		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
@@ -3692,7 +3701,11 @@ bool Device::requestTC10Sleep(Network::NetID network) {
 		return false;
 	}
 
-	return typed->response == ExtendedResponse::OK;
+	if(typed->response != ExtendedResponse::OK) {
+		report(APIEvent::Type::TC10RequestFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
 }
 
 bool Device::reboot(bool safe) {
@@ -3761,7 +3774,15 @@ std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeou
 	return *retMsg;
 }
 
-bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
+std::vector<Network> Device::getMACsecNetworks() const {
+	std::vector<Network> networks;
+	for(const auto& network : getMACsecNetworkMap()) {
+		networks.emplace_back(network.first);
+	}
+	return networks;
+}
+
+bool Device::writeMACsecConfig(const MACsecConfig& cfg, Network::NetID network) {
 	if(!cfg) {
 		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
 		return false;
@@ -3772,8 +3793,15 @@ bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
 		return false;
 	}
 
+	const auto& networks = getMACsecNetworkMap();
+	const auto binaryIndex = networks.find(network);
+	if(binaryIndex == networks.end()) {
+		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+
 	std::vector<uint8_t> raw = cfg.serialize();
-	return writeBinaryFile(raw, cfg.getBinIndex());
+	return writeBinaryFile(raw, binaryIndex->second);
 }
 
 bool Device::enableNetworkCommunication(bool enable, uint32_t timeout) {

device/devicefinder.cpp

@@ -1,29 +1,12 @@
 #include "icsneo/device/devicefinder.h"
 #include "icsneo/platform/devices.h"
 #include "icsneo/device/founddevice.h"
-#include "generated/extensions/builtin.h"
 #include "icsneo/platform/servd.h"
 
 #ifdef ICSNEO_ENABLE_FIRMIO
 #include "icsneo/platform/firmio.h"
 #endif
 
-#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-#include "icsneo/platform/pcap.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_CDCACM
-#include "icsneo/platform/cdcacm.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_DXX
-#include "icsneo/platform/dxx.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_TCP
-#include "icsneo/platform/tcp.h"
-#endif
-
 using namespace icsneo;
 
 template<typename T>
@@ -56,22 +39,8 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 	} else {
 		#ifdef ICSNEO_ENABLE_FIRMIO
 		FirmIO::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_TCP
-		TCP::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-		PCAP::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_CDCACM
-		CDCACM::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_DXX
-		DXX::Find(newDriverFoundDevices);
+		#else
+		EventManager::GetInstance().add(APIEvent::Type::ServdDisabled, APIEvent::Severity::EventWarning);
 		#endif
 	}
 
@@ -221,8 +190,8 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADMoon3>(dev, newFoundDevices);
 		#endif
 
-		#ifdef __RADGEMINI_H_
-		makeIfSerialMatches<RADGemini>(dev, newFoundDevices);
+		#ifdef __RADARGOS_H_
+		makeIfSerialMatches<RADArgos>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __RADMOONDUO_H_
@@ -274,10 +243,6 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		#endif
 	}
 
-	for(auto& device : newFoundDevices) {
-		AddBuiltInExtensionsTo(device);
-	}
-
 	// Grab a weak pointer from the new devices
 	foundDevices.insert(foundDevices.end(), newFoundDevices.begin(), newFoundDevices.end());
 
@@ -388,8 +353,8 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADMoon3::DEVICE_TYPE,
 		#endif
 
-		#ifdef __RADGEMINI_H_
-		RADGemini::DEVICE_TYPE,
+		#ifdef __RADARGOS_H_
+		RADArgos::DEVICE_TYPE,
 		#endif
 
 		#ifdef __RADMOONDUO_H_

device/extensions/bootloader/api.cpp

@@ -0,0 +1,366 @@
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/communication/radcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/radmultichipcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/radperiphcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/redcore.h"
+#include "icsneo/device/extensions/bootloader/communication/red.h"
+#include "icsneo/device/extensions/bootloader/communication/application.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/communication/message/resetstatusmessage.h"
+#include "icsneo/api/lifetime.h"
+
+#include <algorithm>
+#include <chrono>
+#include <set>
+#include <thread>
+#include <unordered_set>
+
+using namespace icsneo;
+using namespace icsneo::Bootloader;
+
+static std::unique_ptr<Bootloader::Communication> getCommunication(
+	icsneo::Device& device, const FlashPhase& phase, const ChipInfo& chip
+) {
+	switch(phase.comm) {
+		case BootloaderCommunication::Application:
+			return std::make_unique<Application>(device, chip, phase.authenticate, phase.encrypt);
+		case BootloaderCommunication::RED:
+			return std::make_unique<REDCommunication>(device, chip, phase.authenticate, phase.encrypt);
+		case BootloaderCommunication::REDCore:
+			return std::make_unique<REDCoreCommunication>(device, chip);
+		case BootloaderCommunication::RAD:
+			return std::make_unique<RADCommunication>(device, chip);
+		case BootloaderCommunication::RADMultiChip:
+			return std::make_unique<RADMultiChipCommunication>(device, chip, phase.authenticate, phase.slot);
+		case BootloaderCommunication::RADGalaxy2Peripheral:
+			return std::make_unique<RADPeriphCommunication>(device, chip);
+		case BootloaderCommunication::Invalid:
+			break;
+	}
+	return nullptr;
+}
+
+static bool findInfo(icsneo::Device& device, ChipID chip, ChipInfo& info) {
+	const auto& allInfo = device.getChipInfo();
+	auto iter = std::find_if(allInfo.begin(), allInfo.end(), [chip](const auto& candidate) { return candidate.id == chip; });
+	if(iter == allInfo.end()) {
+		return false;
+	}
+	info = *iter;
+	return true;
+}
+
+static const FlashPhase* findCorrespondingFlashPhase(const BootloaderPipeline& pipeline, ChipID chip) {
+	for(const auto& phase : pipeline.phases) {
+		if(phase->getType() == BootloaderPhase::Type::Flash) {
+			const auto* flashPhase = static_cast<const FlashPhase*>(phase.get());
+			if(flashPhase->chip == chip) {
+				return flashPhase;
+			}
+		}
+	}
+	return nullptr;
+}
+
+static std::string chipString(ChipID chip) {
+	return "chip id: " + std::to_string(static_cast<int>(chip));
+}
+
+bool Bootloader::requiresUpdate(icsneo::Device& device, const FWRepo& fw) {
+	const auto versions = device.getChipVersions();
+	for(const auto& info : device.getChipInfo()) {
+		if(!info.defaultEnabled || !info.iefName) {
+			continue;
+		}
+		auto iter = std::find_if(versions.begin(), versions.end(), [&info](const auto& ver) { return ver.id == info.id; });
+		if(iter == versions.end()) {
+			continue;
+		}
+		auto ver = fw.getChipVersion(info.iefName);
+		if(ver && *ver != iter->makeAppVersion()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Open the communication, run the action, then close it
+ */
+template<typename Action>
+static bool withCommunication(Bootloader::Communication* com, const ChipInfo& info, const char* phaseName, Action action) {
+	if(!com) {
+		Log::Error(phaseName, "no bootloader communication for " + chipString(info.id));
+		return false;
+	}
+	if(!com->open()) {
+		Log::Error(phaseName, "failed to open communication for " + chipString(info.id));
+		return false;
+	}
+	if(!action(*com)) {
+		return false;
+	}
+	if(!com->close()) {
+		Log::Error(phaseName, "failed to close communication for " + chipString(info.id));
+		return false;
+	}
+	return true;
+}
+
+static bool runPipeline(
+	icsneo::Device& device,
+	const BootloaderPipeline& pipeline,
+	const FWRepo& fw,
+	const Logger& logger,
+	bool alreadyInBootloader,
+	bool forceFlash
+) {
+	icsneo::Lifetime suppressHeartbeats = device.suppressDisconnects();
+	const auto versions = device.getChipVersions();
+	std::unordered_set<icsneo::ChipID> chipsFlashed;
+
+	bool updateAll = false;
+	if(auto iter = pipeline.settings.find(BootloaderSetting::UpdateAll); iter != pipeline.settings.end()) {
+		updateAll = std::get<bool>(iter->second);
+	}
+
+	for(const auto& phase : pipeline.phases) {
+		switch(phase->getType()) {
+			case BootloaderPhase::Type::EnterBootloader: {
+				if(alreadyInBootloader) {
+					Log::Trace("EnterBootloaderPhase", "device already in bootloader, skipping");
+					break;
+				}
+				Log::Info("EnterBootloaderPhase", "entering bootloader");
+				if(!enterBootloader(device)) {
+					Log::Error("EnterBootloaderPhase", "failed to enter bootloader");
+					return false;
+				}
+				break;
+			}
+			case BootloaderPhase::Type::Flash: {
+				const auto& flashPhase = static_cast<const FlashPhase&>(*phase);
+				Log::Info("FlashPhase", "started for " + chipString(flashPhase.chip));
+
+				ChipInfo info;
+				if(!findInfo(device, flashPhase.chip, info)) {
+					Log::Error("FlashPhase", "failed to find chip info for " + chipString(flashPhase.chip));
+					return false;
+				}
+
+				const auto sourceVer = info.iefName ? fw.getChipVersion(info.iefName) : std::nullopt;
+				if(!sourceVer) {
+					Log::Trace("FlashPhase", "skipped, no source version for " + chipString(flashPhase.chip));
+					break;
+				}
+				if(!updateAll && !forceFlash) {
+					auto iter = std::find_if(versions.begin(), versions.end(), [&info](const auto& ver) { return ver.id == info.id; });
+					if(iter == versions.end()) {
+						Log::Trace("FlashPhase", "skipped, chip not reported by the device, " + chipString(flashPhase.chip));
+						break;
+					}
+					if(iter->makeAppVersion() == *sourceVer) {
+						Log::Trace("FlashPhase", "skipped, chip already at target version, " + chipString(flashPhase.chip));
+						break;
+					}
+				}
+
+				auto com = getCommunication(device, flashPhase, info);
+				if(!withCommunication(com.get(), info, "FlashPhase", [&](Bootloader::Communication& opened) {
+					if(!opened.flash(fw, logger)) {
+						Log::Error("FlashPhase", "failed to flash " + chipString(flashPhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+
+				chipsFlashed.insert(info.id);
+				Log::Info("FlashPhase", "completed successfully for " + chipString(flashPhase.chip));
+				break;
+			}
+			case BootloaderPhase::Type::Finalize: {
+				const auto& finalizePhase = static_cast<const FinalizePhase&>(*phase);
+				if(!chipsFlashed.count(finalizePhase.chip)) {
+					Log::Trace("FinalizePhase", "skipped, chip not flashed, " + chipString(finalizePhase.chip));
+					break;
+				}
+				Log::Info("FinalizePhase", "started for " + chipString(finalizePhase.chip));
+				const FlashPhase* flashPhase = findCorrespondingFlashPhase(pipeline, finalizePhase.chip);
+				ChipInfo info;
+				if(!flashPhase || !findInfo(device, finalizePhase.chip, info)) {
+					// Should never happen (developer error)
+					Log::Error("FinalizePhase", "no flash phase or chip info for " + chipString(finalizePhase.chip));
+					return false;
+				}
+
+				auto com = getCommunication(device, *flashPhase, info);
+				if(com && !com->hasFinalizationStep()) {
+					Log::Trace("FinalizePhase", "skipped, no finalization step for " + chipString(finalizePhase.chip));
+					break;
+				}
+
+				if(!withCommunication(com.get(), info, "FinalizePhase", [&](Bootloader::Communication& opened) {
+					if(!opened.finalize()) {
+						Log::Error("FinalizePhase", "failed to finalize " + chipString(finalizePhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+				Log::Info("FinalizePhase", "completed successfully for " + chipString(finalizePhase.chip));
+				break;
+			}
+			case BootloaderPhase::Type::Reconnect: {
+				Log::Info("ReconnectPhase", "reconnecting to device");
+				if(!device.reconnect(std::chrono::milliseconds(60000))) {
+					Log::Error("ReconnectPhase", "failed to reconnect to device");
+					return false;
+				}
+				break;
+			}
+			case BootloaderPhase::Type::Wait: {
+				const auto& waitPhase = static_cast<const WaitPhase&>(*phase);
+				Log::Trace("WaitPhase", "waiting " + std::to_string(waitPhase.timeout.count()) + "ms");
+				std::this_thread::sleep_for(waitPhase.timeout);
+				break;
+			}
+			case BootloaderPhase::Type::EnterApplication: {
+				const auto& enterAppPhase = static_cast<const EnterApplicationPhase&>(*phase);
+				if(!chipsFlashed.count(enterAppPhase.chip)) {
+					Log::Trace("EnterApplicationPhase", "skipped, chip not flashed, " + chipString(enterAppPhase.chip));
+					break;
+				}
+				Log::Info("EnterApplicationPhase", "started for " + chipString(enterAppPhase.chip));
+				const FlashPhase* flashPhase = findCorrespondingFlashPhase(pipeline, enterAppPhase.chip);
+				ChipInfo info;
+				if(!flashPhase || !findInfo(device, enterAppPhase.chip, info)) {
+					// Should never happen (developer error)
+					Log::Error("EnterApplicationPhase", "no flash phase or chip info for " + chipString(enterAppPhase.chip));
+					return false;
+				}
+
+				auto com = getCommunication(device, *flashPhase, info);
+				if(!withCommunication(com.get(), info, "EnterApplicationPhase", [&](Bootloader::Communication& opened) {
+					if(!opened.enterApplication()) {
+						Log::Error("EnterApplicationPhase", "failed to enter application for " + chipString(enterAppPhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+				Log::Info("EnterApplicationPhase", "completed successfully for " + chipString(enterAppPhase.chip));
+				break;
+			}
+		}
+	}
+	return exitBootloader(device, logger, !chipsFlashed.empty());
+}
+
+bool Bootloader::update(
+	icsneo::Device& device,
+	const FWRepo& fw,
+	Logger logger,
+	bool alreadyInBootloader,
+	bool forceFlash
+) {
+	const auto pipeline = device.getBootloader();
+	if(!pipeline) {
+		device.getEventHandler()(APIEvent::Type::FirmwareUpdateNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+
+	if(!runPipeline(device, pipeline, fw, logger, alreadyInBootloader, forceFlash)) {
+		device.getEventHandler()(APIEvent::Type::FirmwareUpdateFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
+}
+
+bool Bootloader::enterBootloader(icsneo::Device& device) {
+	if(!device.com->sendCommand(icsneo::Command::EnterBootloader)) {
+		return false;
+	}
+	return device.reconnect(std::chrono::milliseconds(30000));
+}
+
+bool Bootloader::exitBootloader(icsneo::Device& device, Logger logger, bool updatedChips) {
+	if(!updatedChips) {
+		return true;
+	}
+	logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", std::nullopt);
+	return verifyConnection(device, logger);
+}
+
+/**
+ * Toggle network communication and wait up to 5 seconds for a reset status confirming the change.
+ * Like icsneo::Device::goOnline(), a timeout is not an error.
+ */
+static bool setCommunicationEnabled(icsneo::Device& device, const Logger& logger, bool enable, double progressStart) {
+	static constexpr std::chrono::seconds Timeout(5);
+	const auto filter = std::make_shared<MessageFilter>(Message::Type::ResetStatus);
+
+	if(!device.com->sendCommand(Command::EnableNetworkCommunication, enable)) {
+		return false;
+	}
+	device.com->sendCommand(Command::UpdateLEDState, std::vector<uint8_t>({uint8_t(enable ? 0x10 : 0x04)}));
+
+	const auto startTime = std::chrono::steady_clock::now();
+	auto elapsedTime = std::chrono::duration<double>(0);
+	while(elapsedTime < Timeout) {
+		bool failOut = false;
+		auto msg = device.com->waitForMessageSync([&device, &failOut]() {
+			if(!device.com->sendCommand(Command::RequestStatusUpdate)) {
+				failOut = true;
+				return false;
+			}
+			return true;
+		}, filter, std::chrono::milliseconds(100));
+
+		if(failOut) {
+			return false;
+		}
+
+		if(msg && std::static_pointer_cast<icsneo::ResetStatusMessage>(msg)->comEnabled == enable) {
+			break;
+		}
+
+		// Each call covers half of the overall progress
+		logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", progressStart + (elapsedTime / Timeout) / 2.0);
+		elapsedTime = std::chrono::steady_clock::now() - startTime;
+	}
+	logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", progressStart + 0.5);
+	return true;
+}
+
+bool Bootloader::verifyConnection(icsneo::Device& device, Logger logger) {
+	// Firmware needs to confirm the update by verifying that it can enable/disable the connection on the device
+	return setCommunicationEnabled(device, logger, true, 0.0) && setCommunicationEnabled(device, logger, false, 0.5);
+}
+
+bool Bootloader::isSFPChip(const icsneo::Bootloader::Chip& chip) {
+	static const std::set<icsneo::ChipID> sfpChipIDs = {
+		icsneo::ChipID::SFPModule_88q2112_MCHIP,
+		icsneo::ChipID::SFPModule_88q2221_MCHIP,
+		icsneo::ChipID::SFPModule_88q3244_MCHIP,
+		icsneo::ChipID::SFPModule_ent11100_MCHIP,
+		icsneo::ChipID::SFPModule_lan8670_MCHIP,
+		icsneo::ChipID::SFPModule_ad1101_MCHIP,
+	};
+	return sfpChipIDs.find(chip.getID()) != sfpChipIDs.end();
+}
+
+bool Bootloader::isSFPIEF(const icsneo::Bootloader::IEF& ief) {
+	static const std::set<icsneo::Device::ProductID> sfpProductIDs = {
+		icsneo::Device::ProductID::SFPModule_88q2112,
+		icsneo::Device::ProductID::SFPModule_88q2221m,
+		icsneo::Device::ProductID::SFPModule_88q4364,
+		icsneo::Device::ProductID::SFPModule_ent11100,
+		icsneo::Device::ProductID::SFPModule_lan8670,
+		icsneo::Device::ProductID::SFPModule_ad1101,
+	};
+	return sfpProductIDs.find(static_cast<icsneo::Device::ProductID>(ief.getVersion().prodId)) != sfpProductIDs.end();
+}

device/extensions/bootloader/communication/application.cpp

@@ -0,0 +1,407 @@
+#include "icsneo/device/extensions/bootloader/communication/application.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+#include "icsneo/communication/message/main51message.h"
+
+#include <algorithm>
+#include <condition_variable>
+#include <cstring>
+#include <limits>
+#include <mutex>
+#include <optional>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool Application::enterApplication() {
+	// Always reboot
+	Log::Info(__func__, "sending reboot command");
+	bool ok = device.com->sendCommand(icsneo::ExtendedCommand::Reboot);
+	if(!ok) {
+		Log::Error(__func__, "reboot command failed");
+	}
+	return ok;
+}
+
+bool Application::finalize() {
+	Log::Debug(__func__, "sending finalize command");
+	bool ok = sendCommand(Update::Finalize, [](double) {});
+	if(!ok) {
+		Log::Error(__func__, "finalize command failed");
+	}
+	return ok;
+}
+
+bool Application::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	const auto& srcVer = fw.getVersion();
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		Log::Error(__func__, "failed to get firmware for " + targetChip.getIEFName());
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		Log::Error(__func__, "failed to load IEF for " + targetChip.getName());
+		return false;
+	}
+
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	if(doAuthChecks) {
+		if(!authenticate()) {
+			Log::Error(__func__, "authentication failed for " + targetChip.getName());
+			return false;
+		}
+
+		// Tell the application software what version of Vehicle Spy 3 this firmware is from.
+		// We check to make sure it approves, but also, the device will not accept new firmware
+		// if we have not sent this.
+		// Sometimes new hardware revisions can not accept firmware which is too old.
+		if(!sendCommand(Update::CheckVersion, [](double) {}, 0, {srcVer.major, srcVer.minor, srcVer.release, srcVer.build})) {
+			Log::Error(__func__, "version check failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	bool ok = sendSoftware(ief.getSectors(), ief.getBlockSize(), handler);
+	if(!ok) {
+		Log::Error(__func__, "sendSoftware failed for " + targetChip.getName());
+	}
+	return ok;
+}
+
+bool Application::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	// Send the challenge (seed.a), the device replies with seed.b and one trailing byte
+	std::vector<uint8_t> cmdArgs(sizeof(seed.a));
+	writeLE32(cmdArgs.data(), seed.a[0]);
+	writeLE32(cmdArgs.data() + 4, seed.a[1]);
+
+	auto filter = std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::Main51);
+	auto msg = device.com->waitForMessageSync([&] {
+		return device.com->sendCommand(icsneo::Command::ValidateDevice, cmdArgs);
+	}, filter, std::chrono::milliseconds(200));
+
+	if(!msg) {
+		Log::Error(__func__, "No response from the device");
+		return false;
+	}
+
+	auto main51Msg = std::static_pointer_cast<icsneo::Main51Message>(msg);
+
+	if(main51Msg->data.size() != sizeof(seed.b) + 1) {
+		Log::Error(__func__, "Unexpected authentication reply size from the device");
+		return false;
+	}
+
+	const bool authenticated = readLE32(main51Msg->data.data()) == seed.b[0] && readLE32(main51Msg->data.data() + 4) == seed.b[1];
+	if(!authenticated) {
+		Log::Error(__func__, "The authentication reply does not match, the device did not authenticate");
+	}
+	return authenticated;
+}
+
+bool Application::validateFirmware(const DeviceAppVersion& chipSrcVer) {
+	return sendCommand(Update::CheckComponentVersion, [](double) {}, 0, {chipSrcVer.major, chipSrcVer.minor});
+}
+
+bool Application::sendSoftware(const std::vector<uint8_t>& bin, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(bin.size()) + " bytes)");
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+	if(bin.empty() || bin.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "invalid firmware size for " + targetChip.getName());
+		return false;
+	}
+	const uint32_t totalSize = static_cast<uint32_t>(bin.size());
+
+	Log::Debug(__func__, "erasing " + targetChip.getName());
+	if(!sendCommand(Update::Erase, 0, totalSize, [&](double progress) {
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, progress);
+	}, std::chrono::milliseconds(45000))) {
+		Log::Error(__func__, "erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	currentString = "Updating " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	const uint32_t stepSize = std::min<uint32_t>(totalSize, 2048);
+	uint32_t bytesTransferred = 0;
+	while(bytesTransferred < totalSize) {
+		const uint32_t bytesToSend = std::min(stepSize, totalSize - bytesTransferred);
+		if(!sendCommand(Update::Write, [](double) {}, bytesTransferred, { bin.begin() + bytesTransferred, bin.begin() + bytesTransferred + bytesToSend})) {
+			Log::Error(__func__, "write failed at offset " + std::to_string(bytesTransferred) + " for " + targetChip.getName());
+			return false;
+		}
+
+		bytesTransferred += bytesToSend;
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, double(bytesTransferred) / totalSize);
+	}
+	Log::Debug(__func__, "write complete, validating " + targetChip.getName());
+	if(!validateComponent()) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+		return false;
+	}
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool Application::sendSoftware(const std::vector<IEF::Sector>& sectorPairs, uint32_t blockSize, const icsneo::Device::OpenStatusHandler& handler) {
+	if(sectorPairs.empty()) {
+		Log::Error(__func__, "no sectors to flash for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(sectorPairs.size()) + " sectors)");
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+	uint64_t totalSize = 0;
+	for(const auto& sector : sectorPairs) {
+		totalSize += sector.second.size();
+	}
+	if(totalSize > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "total size too large for " + targetChip.getName());
+		return false;
+	}
+
+	if(totalSize == 0) {
+		Log::Error(__func__, "total size is 0 for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "erasing " + targetChip.getName() + " (" + std::to_string(totalSize) + " bytes)");
+	if(!sendCommand(Update::Erase, 0, static_cast<uint32_t>(totalSize), [&](double progress) {
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, progress);
+	}, std::chrono::milliseconds(45000))) {
+		Log::Error(__func__, "erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(isSFPChip(targetChip)) {
+		// SFPs are not ready to write until 4 seconds after finishing erasing (for some reason)
+		Log::Trace(__func__, "SFP chip detected, waiting 4000ms after erase");
+		std::this_thread::sleep_for(std::chrono::milliseconds(4000));
+	}
+
+	currentString = "Updating " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	uint32_t bytesTransferred = 0;
+	for(const auto& pair : sectorPairs) {
+		const auto& rawData = pair.second;
+		const uint32_t offset = pair.first * blockSize;
+		std::vector<uint8_t> processedData(rawData.begin(), rawData.end());
+		if(encrypted) {
+			if(rawData.size() % 8 != 0) {
+				Log::Error(__func__, "raw data size not aligned");
+				return false;
+			}
+			icsbl_encrypt_v1(device.getSerialNumber(), rawData.data(), rawData.size(), processedData.data());
+		}
+
+		if(!sendCommand(Update::Write, [](double) {}, offset, processedData)) {
+			Log::Error(__func__, "write failed at offset " + std::to_string(offset) + " for " + targetChip.getName());
+			return false;
+		}
+
+		bytesTransferred += static_cast<uint32_t>(rawData.size());
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, double(bytesTransferred) / double(totalSize));
+	}
+	Log::Debug(__func__, "write complete, validating " + targetChip.getName());
+	bool ok = validateComponent();
+	if(!ok) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+	}
+	else {
+		Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	}
+	return ok;
+}
+
+bool Application::validateComponent() {
+	Log::Debug(__func__, "validating " + targetChip.getName());
+	bool ok = sendCommand(Update::ValidateComponent, [](double) {}, 0, {}, std::chrono::milliseconds(45000));
+	if(!ok) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+	}
+	return ok;
+}
+
+/**
+ * Send one SoftwareUpdate sub-command and wait for it to complete.
+ *
+ * The device answers the request with OK when it is already done, or OperationPending when it will
+ * finish later. For a pending command we poll Update::GetProgress (except for Write and
+ * ValidateComponent, which do not report progress) until the device sends a final OK or the timeout
+ * passes. Progress replies are OperationPending with a SoftwareUpdateCommandHeader whose
+ * commandSizeOrProgress holds the progress so far, or a GenericReturn with no progress.
+ */
+bool Application::sendCommand(Update command, uint32_t offset, uint32_t length, const StatusHandler& handler, std::chrono::milliseconds timeout, std::vector<uint8_t> args) {
+	bool finishedResponse = false;
+	std::condition_variable finishedResponseCV;
+	std::mutex finishedResponseMutex;
+
+	std::optional<uint32_t> progress;
+	std::condition_variable progressCV;
+	std::mutex progressMutex;
+
+	bool firstResponse = true;
+	// Register the callback before sending the command, so that if it goes from pending to finished quickly we will still catch it
+	const auto callback = std::make_shared<icsneo::MessageCallback>(std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::ExtendedResponse), [&](std::shared_ptr<icsneo::Message> msg) {
+		if(firstResponse) {
+			firstResponse = false;
+			return true; // let waitForMessageSync handle the first message
+		}
+		auto extMsg = std::static_pointer_cast<ExtendedResponseMessage>(msg);
+		if(extMsg->command != ExtendedCommand::SoftwareUpdate) {
+			Log::Error(__func__, "Got an extended response for a command other than SoftwareUpdate");
+			return false;
+		}
+		if(extMsg->response == ExtendedResponse::OK) {
+			{
+				std::scoped_lock lk(finishedResponseMutex);
+				finishedResponse = true;
+			}
+			finishedResponseCV.notify_one();
+		} else if(extMsg->response == ExtendedResponse::OperationPending) {
+			if(extMsg->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader)) {
+				Log::Error(__func__, "The pending response is too short to contain a header");
+				return false;
+			}
+			ExtendedResponseMessage::ResponseHeader respHeader;
+			std::memcpy(&respHeader, extMsg->data.data(), sizeof(respHeader));
+			if(respHeader.command == ExtendedCommand::SoftwareUpdate) {
+				if(respHeader.length != sizeof(SoftwareUpdateCommandHeader) ||
+					extMsg->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(SoftwareUpdateCommandHeader)) {
+					Log::Error(__func__, "The progress response does not contain a SoftwareUpdate header");
+					return false;
+				}
+				SoftwareUpdateCommandHeader resp;
+				std::memcpy(&resp, extMsg->data.data() + sizeof(ExtendedResponseMessage::ResponseHeader), sizeof(resp));
+				{
+					std::scoped_lock lk(progressMutex);
+					progress.emplace(resp.commandSizeOrProgress);
+				}
+				progressCV.notify_one();
+			} else if(respHeader.command == ExtendedCommand::GenericReturn) {
+				// No progress information, the final OK comes later
+				{
+					std::scoped_lock lk(progressMutex);
+					progress.emplace(0);
+				}
+				progressCV.notify_one();
+			} else {
+				Log::Error(__func__, "The pending response is for an unexpected command");
+				return false;
+			}
+		} else {
+			Log::Error(__func__, "The device reported an error for the SoftwareUpdate command");
+			return false;
+		}
+		return true;
+	});
+	const auto finishedCallbackHandle = device.com->addMessageCallback(callback);
+	Lifetime statusCallbackCleanup([&] {
+		device.com->removeMessageCallback(finishedCallbackHandle);
+	});
+
+	SoftwareUpdateCommandHeader header = {};
+	header.componentIdentifier = static_cast<uint32_t>(targetChip.getID());
+	header.commandType = command;
+	header.offset = offset;
+	header.commandSizeOrProgress = length;
+	header.expansionSlot = targetChip.expansionSlot;
+	const auto headerBytes = reinterpret_cast<const uint8_t*>(&header);
+	args.insert(args.begin(), headerBytes, headerBytes + sizeof(header));
+
+	{
+		auto msg = device.com->waitForMessageSync([&] {
+			return device.com->sendCommand(ExtendedCommand::SoftwareUpdate, args);
+		}, std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::ExtendedResponse), timeout);
+
+		if(!msg) {
+			Log::Error(__func__, "No response to the SoftwareUpdate command");
+			return false;
+		}
+
+		auto extMsg = std::static_pointer_cast<ExtendedResponseMessage>(msg);
+		if(extMsg->command != ExtendedCommand::SoftwareUpdate) {
+			Log::Error(__func__, "Got an extended response for a command other than SoftwareUpdate");
+			return false;
+		}
+		if(extMsg->response == ExtendedResponse::OK) {
+			return true;
+		}
+		if(extMsg->response != ExtendedResponse::OperationPending) {
+			Log::Error(__func__, "The device rejected the SoftwareUpdate command");
+			return false;
+		}
+	}
+
+	SoftwareUpdateCommandHeader progressHeader = {};
+	progressHeader.componentIdentifier = static_cast<uint32_t>(targetChip.getID());
+	progressHeader.commandType = Update::GetProgress;
+	progressHeader.expansionSlot = targetChip.expansionSlot;
+	const auto progressHeaderBytes = reinterpret_cast<const uint8_t*>(&progressHeader);
+	const std::vector<uint8_t> progressArgs(progressHeaderBytes, progressHeaderBytes + sizeof(progressHeader));
+	const auto deadline = std::chrono::steady_clock::now() + timeout;
+	// Write and ValidateComponent do not report progress, just wait for the final OK
+	if(command != Update::Write && command != Update::ValidateComponent) {
+		while(std::chrono::steady_clock::now() < deadline) {
+			{
+				std::unique_lock lk(progressMutex);
+				progress.reset();
+				if(!device.com->sendCommand(ExtendedCommand::SoftwareUpdate, progressArgs)) {
+					Log::Error(__func__, "Failed to send progress request to the device");
+					return false;
+				}
+				if(!progressCV.wait_for(lk, std::chrono::milliseconds(5000), [&]{ return progress.has_value(); })) {
+					Log::Error(__func__, "No progress response from device");
+					return false;
+				}
+				handler(*progress / double(length));
+			}
+			{
+				std::scoped_lock lk(finishedResponseMutex);
+				if(finishedResponse) {
+					break;
+				}
+			}
+		}
+	}
+
+	std::unique_lock lk(finishedResponseMutex);
+	return finishedResponseCV.wait_until(lk, deadline, [&]{ return finishedResponse; });
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/communication/communication.cpp

@@ -0,0 +1,14 @@
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+
+using namespace icsneo::Bootloader;
+
+uint32_t Communication::readLE32(const uint8_t* buf) {
+	return (uint32_t)buf[0] | ((uint32_t)buf[1] << 8) | ((uint32_t)buf[2] << 16) | ((uint32_t)buf[3] << 24);
+}
+
+void Communication::writeLE32(uint8_t* buf, uint32_t num) {
+	buf[0] = num & 0xFFu;
+	buf[1] = (num >> 8) & 0xFFu;
+	buf[2] = (num >> 16) & 0xFFu;
+	buf[3] = (num >> 24) & 0xFFu;
+}

device/extensions/bootloader/communication/radcommunication.cpp

@@ -0,0 +1,547 @@
+#include "icsneo/device/extensions/bootloader/communication/radcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/bootloaderversion.h"
+#include "icsneo/device/extensions/bootloader/parser/fwzip.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <cstring>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+using namespace icsneo::Bootloader;
+
+RADCommunication::RADCommunication(icsneo::Device& dev, const ChipInfo& info)
+	: Communication(dev), targetChip(info) {}
+
+bool RADCommunication::supportsFlashBuffer() const {
+	switch(targetChip.getID()) {
+		case icsneo::ChipID::RADGigastar_USBZ_ZYNQ:
+		case icsneo::ChipID::RADGigastar_USBZ_Z7007S_ZYNQ:
+		case icsneo::ChipID::RADGigastar_USBZ_Z7010_ZYNQ: {
+			return true;
+		}
+		default:
+			return false;
+	}
+}
+
+RADCommunication::Request RADCommunication::makeRequest(Request::Type type, size_t payloadSize, size_t expectedResponseLen) {
+	const size_t headerSize = supportsZynqBinaryFlasher ? ZynqFlasherHeaderSize : 0;
+	const size_t packetSize = headerSize + 1 + payloadSize; // Header + command + payload
+
+	// This shouldn't cause any re-allocations since we already reserved the MaxMessageLength in initialize()
+	txBuffer.resize(packetSize, 0);
+
+	if(supportsZynqBinaryFlasher) {
+		std::copy(std::begin(ZynqFlasherSync), std::end(ZynqFlasherSync), txBuffer.begin());
+
+		// The length covers the command byte and the payload
+		const uint16_t payloadPlusCmd = static_cast<uint16_t>(payloadSize) + 1;
+		txBuffer[4] = payloadPlusCmd & 0xFFu;
+		txBuffer[5] = (payloadPlusCmd >> 8) & 0xFFu;
+	}
+
+	txBuffer[headerSize] = static_cast<uint8_t>(type);
+
+	Request newRequest;
+	newRequest.type = type;
+	newRequest.expectedResponseLen = expectedResponseLen;
+	if(payloadSize > 0) {
+		newRequest.payload = &txBuffer[headerSize + 1]; // First byte right after the command
+	}
+
+	return newRequest;
+}
+
+bool RADCommunication::sendRequestNoResponse() {
+	/**
+	 * Send our current packet, the payload was written to it if the user
+	 * of this function wrote to request.payload. The remaining details were
+	 * written when makeRequest() was called
+	*/
+	return device.com->sendPacket(txBuffer);
+}
+
+RADCommunication::Response& RADCommunication::sendRequest(const Request& request, std::chrono::milliseconds timeout) {
+	static constexpr size_t ResponseHeaderSize = 2;
+	const size_t rxSize = ResponseHeaderSize + request.expectedResponseLen;
+	/**
+	 * Clear previous response
+	*/
+	lastResponse = Response();
+
+	if(!sendRequestNoResponse()) {
+		Log::Error(__func__, "Failed to send request " + std::to_string(static_cast<uint8_t>(request.type)));
+		return lastResponse;
+	}
+
+	auto& rb = device.com->driver->getReadBuffer();
+	rb.clear();
+	auto result = device.com->driver->waitForRx(rxSize, timeout);
+
+	if(!result) {
+		Log::Error(__func__, "No response to request " + std::to_string(static_cast<uint8_t>(request.type)));
+		return lastResponse;
+	}
+
+	rb.read(rxBuffer.data(), 0, rxSize);
+	rb.clear();
+
+	lastResponse.done = true;
+
+	/**
+	 * Second byte is success/failure byte
+	*/
+	lastResponse.type = static_cast<Response::Type>(rxBuffer[1]);
+
+	/**
+	 * The rest is the payload, if we requested any
+	*/
+	if(request.expectedResponseLen > 0) {
+		lastResponse.payload = &rxBuffer[2];
+		lastResponse.size = request.expectedResponseLen;
+	}
+
+	return lastResponse;
+}
+
+bool RADCommunication::enterApplication() {
+	Log::Info(__func__, "sending EnterApplication request");
+	makeRequest(Request::Type::EnterApplication);
+	bool ok = sendRequestNoResponse();
+	if(!ok) {
+		Log::Error(__func__, "EnterApplication request failed");
+	}
+	return ok;
+}
+
+bool RADCommunication::close() {
+	device.com->resumeReads();
+	return true;
+}
+
+bool RADCommunication::open() {
+	device.com->pauseReads();
+
+	if(!initialize()) {
+		close();
+		return false;
+	}
+
+	if(!sanityCheck()) {
+		// Note: RAD-Gigastar on low power USB flash fails here for some reason, try another sanity check
+		if(!sanityCheck()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!getBootloaderVersion()) {
+		// Try again, just like the sanity checks
+		if(!getBootloaderVersion()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!sanityCheck()) {
+		// Note: RAD-Gigastar on low power USB flash fails here for some reason, try another sanity check
+		if(!sanityCheck()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!authenticate()) {
+		close();
+		return false;
+	}
+
+	return true;
+}
+
+bool RADCommunication::initialize() {
+	auto& rb = device.com->driver->getReadBuffer();
+
+	rxBuffer = std::vector<uint8_t>(MaxMessageLength, 0);
+	txBuffer.reserve(MaxMessageLength);
+
+	// An EnterBootloader command on Main51, as a framed short packet (0xAA, then length << 4 | netid)
+	// with a trailing 0xAF, followed by the same command without the 0xAA framing
+	const uint8_t lengthAndNetID = (1 << 4) | static_cast<uint8_t>(icsneo::Network::NetID::Main51);
+	std::vector<uint8_t> pkt = {
+		0xAA,
+		lengthAndNetID,
+		static_cast<uint8_t>(icsneo::Command::EnterBootloader),
+		0xAF
+	};
+
+	rb.clear();
+	if(!device.com->sendPacket(pkt)) {
+		Log::Error(__func__, "Failed to send the framed enter bootloader command");
+		return false;
+	}
+
+	pkt = {
+		lengthAndNetID,
+		static_cast<uint8_t>(icsneo::Command::EnterBootloader)
+	};
+
+	if(!device.com->sendPacket(pkt)) {
+		Log::Error(__func__, "Failed to send the unframed enter bootloader command");
+		return false;
+	}
+
+	// The Zynq binary flasher answers with the command, Success, then ZynqFlasherSync
+	static constexpr size_t ZynqFlasherReplySize = 2 + sizeof(ZynqFlasherSync);
+	if(!device.com->driver->waitForRx(ZynqFlasherReplySize, std::chrono::milliseconds(1000))) {
+		Log::Error(__func__, "No response to the enter bootloader command");
+		return false;
+	}
+
+	const size_t rxLen = rb.size();
+	if(rxLen == ZynqFlasherReplySize) {
+		rb.read(rxBuffer.data(), 0, rxLen);
+	}
+	rb.clear();
+	supportsZynqBinaryFlasher =
+		rxLen == ZynqFlasherReplySize &&
+		rxBuffer[0] == static_cast<uint8_t>(icsneo::Command::EnterBootloader) &&
+		rxBuffer[1] == static_cast<uint8_t>(Response::Type::Success) &&
+		std::equal(std::begin(ZynqFlasherSync), std::end(ZynqFlasherSync), rxBuffer.begin() + 2);
+
+	return true;
+}
+
+bool RADCommunication::finalize() {
+	return true;
+}
+
+bool RADCommunication::hasFinalizationStep() const {
+	return false;
+}
+
+bool RADCommunication::sanityCheck() {
+	if(!supportsZynqBinaryFlasher) {
+		return true;
+	}
+
+	// Two numbered test patterns the bootloader must accept, the 8 byte replies are not checked
+	constexpr uint8_t PatternA[8] = {0xAA, 0x55, 0xAA, 0x55, 0xAA, 0xAA, 0x55, 0x55};
+	constexpr uint8_t PatternB[8] = {0x12, 0x21, 0x34, 0x43, 0x56, 0x65, 0x78, 0x87};
+
+	auto request = makeRequest(Request::Type::SanityCheck, 1 + sizeof(PatternA), sizeof(PatternA));
+
+	request.payload[0] = 0x01u;
+	std::copy(std::begin(PatternA), std::end(PatternA), request.payload + 1);
+
+	if(!sendRequest(request, std::chrono::milliseconds(1000))) {
+		return false;
+	}
+
+	request.payload[0] = 0x02u;
+	std::copy(std::begin(PatternB), std::end(PatternB), request.payload + 1);
+
+	return sendRequest(request, std::chrono::milliseconds(1000));
+}
+
+bool RADCommunication::getBootloaderVersion() {
+	auto request = makeRequest(Request::Type::BootloaderVersion, 0, sizeof(BootloaderVersionResponse));
+	auto response = sendRequest(request, std::chrono::milliseconds(1000));
+
+	if(!response) {
+		return false;
+	}
+
+	if(response.size < sizeof(BootloaderVersionResponse)) {
+		return false;
+	}
+
+	BootloaderVersionResponse version;
+	std::memcpy(&version, response.payload, sizeof(version));
+	targetChip.info.id = static_cast<ChipID>(version.zynqId);
+	return true;
+}
+
+bool RADCommunication::validateChipVersion(const icsneo::DeviceAppVersion& chipSrcVer) {
+	if(!supportsZynqBinaryFlasher) {
+		return true;
+	}
+
+	auto request = makeRequest(Request::Type::ValidateVersion, 2, 2);
+
+	request.payload[0] = chipSrcVer.major;
+	request.payload[1] = chipSrcVer.minor;
+
+	return sendRequest(request, std::chrono::milliseconds(1000));
+}
+
+bool RADCommunication::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	auto request = makeRequest(Request::Type::Authenticate, sizeof(seed.a), sizeof(seed.b));
+
+	writeLE32(&request.payload[0], seed.a[0]);
+	writeLE32(&request.payload[4], seed.a[1]);
+
+	auto response = sendRequest(request, std::chrono::milliseconds(2000));
+
+	if(!response) {
+		return false;
+	}
+
+	return seed.b[0] == readLE32(&response.payload[0]) && seed.b[1] == readLE32(&response.payload[4]);
+}
+
+bool RADCommunication::sendSoftware(const std::vector<uint8_t>& chipSoftware) {
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(chipSoftware.size()) + " bytes)");
+	static constexpr size_t MaxEthernetPayload = 1487;
+
+	if(supportsZynqBinaryFlasher && chipSoftware.size() < sizeof(uint32_t)) {
+		Log::Error(__func__, "firmware too short to contain a CRC for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Trace(__func__, "sending BeginTransfer for " + targetChip.getName());
+	auto request = makeRequest(Request::Type::BeginTransfer, 0, 0);
+	auto response = sendRequest(request, std::chrono::milliseconds(10000));
+
+	if(!response) {
+		Log::Error(__func__, "BeginTransfer failed for " + targetChip.getName());
+		return false;
+	}
+
+	const size_t headerSize = 1 + (supportsZynqBinaryFlasher ? ZynqFlasherHeaderSize : 0); // Command byte plus the optional Zynq flasher header
+	const size_t maxPayloadSize = MaxEthernetPayload - headerSize;
+
+	size_t remainingBytes = chipSoftware.size();
+	size_t currentlyReading = 0;
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	while(remainingBytes > 0) {
+		const double progress = static_cast<double>(currentlyReading) / static_cast<double>(chipSoftware.size());
+
+		logger(
+			icsneo::Device::OpenStatusType::Progress,
+			"Flashing " + targetChip.getName() + "...",
+			progress
+		);
+
+		size_t numToSend = std::min<size_t>(maxPayloadSize, remainingBytes);
+		request = makeRequest(Request::Type::FWPayload, numToSend, supportsZynqBinaryFlasher ? 2 : 0);
+
+		std::copy(
+			chipSoftware.begin() + currentlyReading,
+			chipSoftware.begin() + currentlyReading + numToSend,
+			request.payload
+		);
+
+		if(supportsFlashBuffer()) {
+			if(!sendRequest(request, std::chrono::milliseconds(2000))) {
+				return false;
+			}
+		} else if(!sendRequestNoResponse()) {
+			return false;
+		}
+
+		currentlyReading += numToSend;
+		remainingBytes -= numToSend;
+		if(device.com->driver->isEthernet()) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		}
+	}
+
+	Log::Trace(__func__, "sending EndTransfer for " + targetChip.getName());
+	request = makeRequest(Request::Type::EndTransfer, 0, 0);
+	response = sendRequest(request, std::chrono::milliseconds(10000));
+
+	if(!response) {
+		Log::Error(__func__, "EndTransfer failed for " + targetChip.getName());
+		return false;
+	}
+
+	request = makeRequest(Request::Type::DownloadedBinInfo, 0, 4);
+	response = sendRequest(request, std::chrono::milliseconds(6000));
+
+	if(!response) {
+		Log::Error(__func__, "DownloadedBinInfo failed for " + targetChip.getName());
+		return false;
+	}
+
+	const uint32_t numDownloaded = readLE32(response.payload);
+
+	if(numDownloaded != static_cast<uint32_t>(chipSoftware.size())) {
+		Log::Error(__func__, "downloaded size mismatch for " + targetChip.getName() + ": expected " + std::to_string(chipSoftware.size()) + ", got " + std::to_string(numDownloaded));
+		return false;
+	}
+
+	if(supportsZynqBinaryFlasher) {
+		request = makeRequest(Request::Type::VerifyCRC, sizeof(uint32_t), 2);
+
+		/**
+		 * Copy CRC from end of the binary
+		*/
+		std::copy(chipSoftware.end() - sizeof(uint32_t), chipSoftware.end(), request.payload);
+
+		response = sendRequest(request, std::chrono::milliseconds(2000));
+
+		if(!response) {
+			return false;
+		}
+
+		// The first response byte is 1 when the CRC matched
+		if(response.payload[0] != 0x01) {
+			Log::Error(__func__, "CRC mismatch for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		1.0
+	);
+
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool RADCommunication::getProgrammingStatus(size_t sizeToValidate) {
+	Log::Debug(__func__, "starting for " + targetChip.getName());
+	auto request = makeRequest(Request::Type::ProgramFlash, 0, supportsZynqBinaryFlasher ? 2 : 0);
+
+	if(!sendRequest(request, std::chrono::milliseconds(2000))) {
+		Log::Error(__func__, "ProgramFlash failed for " + targetChip.getName());
+		return false;
+	}
+
+	request = makeRequest(Request::Type::ProgrammingStatus, 0, 4);
+
+	uint32_t status = 0;
+	const auto beginTime = std::chrono::steady_clock::now();
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Programming " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	while(status < static_cast<uint32_t>(sizeToValidate)) {
+		const double progress = static_cast<double>(status) / static_cast<double>(sizeToValidate);
+
+		logger(
+			icsneo::Device::OpenStatusType::Progress,
+			"Programming " + targetChip.getName() + "...",
+			progress
+		);
+
+		const auto& response = sendRequest(request, std::chrono::milliseconds(60000));
+		if(!response) {
+			return false;
+		}
+		status = readLE32(response.payload);
+
+		if(std::chrono::steady_clock::now() - beginTime >= std::chrono::milliseconds(180000)) {
+			return false;
+		}
+	}
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Programming " + targetChip.getName() + "...",
+		1.0
+	);
+
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool RADCommunication::loadZips(const FWRepo& fw, std::vector<uint8_t>& chipSoftware) {
+	if(const auto& segmentNames = targetChip.getMultiIEFName(); !segmentNames.empty()) {
+		std::vector<std::unique_ptr<FWZip>> zips;
+		zips.reserve(segmentNames.size());
+
+		size_t totalSize = 0;
+		for(const auto& name : segmentNames) {
+			std::vector<uint8_t> segment;
+			if(!fw.getFW(name, segment)) {
+				return false;
+			}
+
+			zips.push_back(std::make_unique<FWZip>(std::move(segment)));
+			auto& zip = zips.back();
+			if(!zip->size()) {
+				return false;
+			}
+			totalSize += *zip->size();
+		}
+		chipSoftware.resize(totalSize, 0);
+		size_t offset = 0;
+		for(auto& zip : zips) {
+			if(!zip->readAll(chipSoftware.data() + offset)) {
+				return false;
+			}
+			offset += *(zip->size());
+		}
+		return true;
+	} else if(!targetChip.getIEFName().empty()) {
+		std::vector<uint8_t> bin;
+		if(!fw.getFW(targetChip.getIEFName(), bin)) {
+			return false;
+		}
+		FWZip fwZip(std::move(bin));
+		if(!fwZip.readAll(chipSoftware)) {
+			return false;
+		}
+		return true;
+	}
+	// Should never happen
+	return false;
+}
+
+bool RADCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	auto chipSrcVer = fw.getChipVersion(targetChip.getIEFName());
+	if(!chipSrcVer) {
+		Log::Error(__func__, "no chip version found for " + targetChip.getIEFName());
+		return false;
+	}
+
+	std::vector<uint8_t> chipSoftware;
+	if(!loadZips(fw, chipSoftware)) {
+		Log::Error(__func__, "loadZips failed for " + targetChip.getName());
+		return false;
+	}
+
+	logger = handler;
+	if(!validateChipVersion(*chipSrcVer)) {
+		Log::Error(__func__, "validateChipVersion failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!sendSoftware(chipSoftware)) {
+		Log::Error(__func__, "sendSoftware failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!supportsFlashBuffer()) {
+		if(!getProgrammingStatus(chipSoftware.size())) {
+			Log::Error(__func__, "getProgrammingStatus failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	Log::Info(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}

device/extensions/bootloader/communication/radmultichipcommunication.cpp

@@ -0,0 +1,144 @@
+#include "icsneo/device/extensions/bootloader/communication/radmultichipcommunication.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <thread>
+
+using namespace icsneo::Bootloader;
+
+RADMultiChipCommunication::RADMultiChipCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash, bool auth, uint8_t slot)
+	: RADCommunication(dev, chipToFlash), doAuthChecks(auth), slot(slot) {}
+
+bool RADMultiChipCommunication::authenticate() {
+	if(!doAuthChecks) {
+		Log::Trace(__func__, "auth checks disabled, skipping");
+		return true;
+	}
+	Log::Debug(__func__, "starting authentication");
+	if(!standardComm->authenticate()) {
+		Log::Warning(__func__, "standardComm auth failed, retrying with sanity check");
+		device.com->pauseReads();
+		if(!sanityCheck()) {
+			if(!sanityCheck()) {
+				device.com->resumeReads();
+				Log::Error(__func__, "sanity check failed after retries");
+				return false;
+			}
+		}
+
+		if(!RADCommunication::authenticate()) {
+			device.com->resumeReads();
+			Log::Error(__func__, "RADCommunication auth failed");
+			return false;
+		}
+
+		device.com->resumeReads();
+	}
+	Log::Debug(__func__, "authentication successful");
+	return true;
+}
+
+bool RADMultiChipCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	auto chipSrcVer = fw.getChipVersion(targetChip.getIEFName());
+	if(!chipSrcVer) {
+		Log::Error(__func__, "no chip version found for " + targetChip.getIEFName());
+		return false;
+	}
+
+	if(!authenticate()) {
+		Log::Error(__func__, "authentication failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!standardComm->validateFirmware(*chipSrcVer)) {
+		Log::Error(__func__, "firmware validation failed for " + targetChip.getName());
+		handler(icsneo::Device::OpenStatusType::Failed, "Failed to validate firmware", std::nullopt);
+		return false;
+	}
+
+	if(targetChip.getFirmwareType() == FirmwareType::Zip) {
+		std::vector<uint8_t> chipSoftware;
+		if(!loadZips(fw, chipSoftware)) {
+			Log::Error(__func__, "loadZips failed for " + targetChip.getName());
+			return false;
+		}
+
+		if(!standardComm->sendSoftware(chipSoftware, handler)) {
+			return false;
+		}
+	} else {
+		std::vector<uint8_t> bin;
+		if(!fw.getFW(targetChip.getIEFName(), bin)) {
+			return false;
+		}
+
+		IEF ief;
+		if(!ief.load(std::move(bin))) {
+			return false;
+		}
+
+		// The supplied IEF is not for this product
+		if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID()) && !isSFPIEF(ief)) {
+			Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+			return false;
+		}
+
+		// The supplied IEF is for this product, but not for this chip
+		if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+			Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+			return false;
+		}
+
+		if(!standardComm->sendSoftware(ief.getSectors(), ief.getBlockSize(), handler)) {
+			return false;
+		}
+	}
+	Log::Debug(__func__, "calling finalize");
+	if(!standardComm->finalize()) {
+		Log::Error(__func__, "finalize failed");
+		return false;
+	}
+	Log::Debug(__func__, "finalize successful, proceeding to reboot");
+	handler(icsneo::Device::OpenStatusType::Progress, "Rebooting device...", std::nullopt);
+	return true;
+}
+
+bool RADMultiChipCommunication::enterApplication() {
+	Log::Info(__func__, "starting");
+	if(!standardComm->enterApplication()) {
+		Log::Error(__func__, "reboot failed");
+		return false;
+	}
+	Log::Debug(__func__, "reboot sent, waiting 5000ms");
+	std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+	return true;
+}
+
+bool RADMultiChipCommunication::open() {
+	const auto& components = device.getComponentVersions();
+	auto component = std::find_if(components.begin(), components.end(), [this](const auto& candidate) {
+		if(slot != UINT8_MAX && slot != candidate.expansionSlot) {
+			return false;
+		}
+		return targetChip.getID() == (ChipID)candidate.identifier;
+	});
+	if(component == components.end()) {
+		Log::Error(__func__, "no component found for " + targetChip.getName());
+		return false;
+	}
+	standardComm = std::make_unique<Application>(device, targetChip.info);
+	standardComm->setExpansionSlot(component->expansionSlot);
+	// Pause the read thread so it doesn't consume any responses
+	device.com->pauseReads();
+	const bool res = initialize();
+	device.com->resumeReads();
+	return res;
+}
+
+bool RADMultiChipCommunication::close() {
+	return true;
+}

device/extensions/bootloader/communication/radperiphcommunication.cpp

@@ -0,0 +1,334 @@
+#include "icsneo/device/extensions/bootloader/communication/radperiphcommunication.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstddef>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+using namespace icsneo::Bootloader;
+
+RADPeriphCommunication::RADPeriphCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash)
+	: Communication(dev), targetChip(chipToFlash) {}
+
+RADPeriphCommunication::~RADPeriphCommunication() {
+	if(device.com->readsArePaused()) {
+		device.com->resumeReads();
+	}
+}
+
+bool RADPeriphCommunication::sendRequestNoResponse(Request req, std::vector<uint8_t>&& args) {
+	return sendRequestNoResponse(req, targetChip.getID(), std::move(args));
+}
+
+bool RADPeriphCommunication::sendRequestNoResponse(Request req, ChipID id, std::vector<uint8_t>&& args) {
+	args.insert(args.begin(), {
+		(uint8_t)id,
+		(uint8_t)req,
+	});
+	return device.com->sendCommand(icsneo::Command::PeripheralBootloader, args);
+}
+
+RADPeriphCommunication::Response RADPeriphCommunication::sendRequest(Request req, std::vector<uint8_t>&& args, std::chrono::milliseconds timeout) {
+	return sendRequest(req, targetChip.getID(), std::move(args), timeout);
+}
+
+RADPeriphCommunication::Response RADPeriphCommunication::sendRequest(Request req, ChipID id, std::vector<uint8_t>&& args, std::chrono::milliseconds timeout) {
+	// Total reply sizes, including the header bytes
+	size_t expectedResponseLength = 0;
+	bool checkBlAccepted = false;
+	switch(req) {
+		case Request::Mode:
+			expectedResponseLength = 6;
+			break;
+		case Request::Version:
+			expectedResponseLength = 24;
+			checkBlAccepted = true;
+			break;
+		case Request::Authenticate:
+			expectedResponseLength = 13;
+			checkBlAccepted = true;
+			break;
+		case Request::Echo:
+			expectedResponseLength = 3;
+			break;
+		case Request::Erase:
+		case Request::FirmwareValidate:
+		case Request::FlashSector:
+			expectedResponseLength = 3;
+			checkBlAccepted = true;
+			break;
+		default:
+			expectedResponseLength = 3;
+			break;
+	}
+
+	auto& rb = device.com->driver->getReadBuffer();
+	rb.clear();
+	if(!sendRequestNoResponse(req, id, std::move(args))) {
+		Log::Error(__func__, "Failed to send request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	auto result = device.com->driver->waitForRx(expectedResponseLength, timeout);
+	if(!result) {
+		Log::Error(__func__, "No response to request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	Response resp;
+	resp.data.resize(expectedResponseLength, 0);
+	rb.read(resp.data.data(), 0, expectedResponseLength);
+	resp.success = resp.data[ReplySuccessOffset] == ReplySuccess;
+	if(!resp.success) {
+		Log::Error(__func__, "The peripheral reported failure for request " + std::to_string(static_cast<uint8_t>(req)));
+		return resp;
+	}
+	if(checkBlAccepted && resp.data[ReplyAcceptedOffset] != ReplyAccepted) {
+		Log::Error(__func__, "The bootloader rejected request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	return resp;
+}
+
+RADPeriphCommunication::Mode RADPeriphCommunication::getMode() {
+	auto resp = sendRequest(Request::Mode, {}, std::chrono::milliseconds(2000));
+
+	if(!resp) {
+		return Mode::NoAnswer;
+	}
+	static constexpr size_t ModeOffset = 4;
+	return (Mode)resp.data[ModeOffset];
+}
+
+bool RADPeriphCommunication::sendPeriphTest() {
+	// Echo is sent to chip id 0, the reply carries the bitwise inverse of the test byte
+	const uint8_t testByte = 0x00;
+	auto resp = sendRequest(Request::Echo, (ChipID)0x00, {testByte}, std::chrono::milliseconds(2000));
+
+	if(!resp) {
+		return false;
+	}
+
+	if(resp.data[2] != static_cast<uint8_t>(~testByte)) {
+		Log::Error(__func__, "The peripheral echo reply did not match");
+		return false;
+	}
+
+	return true;
+}
+
+bool RADPeriphCommunication::readSerialNumber() {
+	auto resp = sendRequest(Request::Version, {0x00}, std::chrono::milliseconds(2000));
+	if(!resp) {
+		return false;
+	}
+
+	// The reply payload is the start of a BootloaderVersionResponse
+	static constexpr size_t SerialOffset = ReplyHeaderSize + offsetof(BootloaderVersionResponse, serialNum);
+	serialNumber = readLE32(resp.data.data() + SerialOffset);
+	return true;
+}
+
+bool RADPeriphCommunication::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(serialNumber, &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	std::vector<uint8_t> args(BootloaderArgsOffset + sizeof(seed.a), 0);
+	writeLE32(args.data() + BootloaderArgsOffset, seed.a[0]);
+	writeLE32(args.data() + BootloaderArgsOffset + 4, seed.a[1]);
+
+	auto resp = sendRequest(Request::Authenticate, std::move(args), std::chrono::milliseconds(3000));
+	if(!resp) {
+		return false;
+	}
+
+	// seed.b follows the header and one more byte
+	static constexpr size_t ReplyOffset = ReplyHeaderSize + 1;
+	return readLE32(resp.data.data() + ReplyOffset) == seed.b[0] &&
+		readLE32(resp.data.data() + ReplyOffset + 4) == seed.b[1];
+}
+
+bool RADPeriphCommunication::validateFirmware() {
+	return sendRequest(Request::FirmwareValidate, {0x00u}, std::chrono::milliseconds(2000));
+}
+
+bool RADPeriphCommunication::flashSector(const IEF::Sector& sector) {
+	if(sector.second.size() < FlashSectorFirstChunkSize) {
+		Log::Error(__func__, "Invalid sector length");
+		return false;
+	}
+
+	// The first request is the 32-bit little-endian address followed by the first chunk, encrypted
+	std::vector<uint8_t> args(BootloaderArgsOffset + sizeof(uint32_t) + FlashSectorFirstChunkSize, 0);
+	writeLE32(args.data() + BootloaderArgsOffset, sector.first);
+	icsbl_encrypt_v1(serialNumber, sector.second.begin(), FlashSectorFirstChunkSize, args.data() + BootloaderArgsOffset + sizeof(uint32_t));
+	if(!sendRequestNoResponse(Request::FlashSector, std::move(args))) {
+		return false;
+	}
+	std::this_thread::sleep_for(std::chrono::milliseconds(400));
+
+	// The second request is the rest of the sector, encrypted
+	const size_t bytesLeft = sector.second.size() - FlashSectorFirstChunkSize;
+	args = std::vector<uint8_t>(bytesLeft, 0);
+	icsbl_encrypt_v1(serialNumber, sector.second.begin() + FlashSectorFirstChunkSize, bytesLeft, args.data());
+	return sendRequest(Request::FlashSector, std::move(args), std::chrono::milliseconds(3000));
+}
+
+bool RADPeriphCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	// Validate the firmware before touching the device so a bad file can not leave it erased
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		return false;
+	}
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	const auto& sectors = ief.getSectors();
+	uint32_t totalSize = 0;
+	for(const auto& sector : sectors) {
+		if(sector.second.size() < FlashSectorFirstChunkSize) {
+			Log::Error(__func__, "Invalid sector length in IEF for " + targetChip.getName());
+			return false;
+		}
+		totalSize += static_cast<uint32_t>(sector.second.size());
+	}
+
+	if(!readSerialNumber()) {
+		return false;
+	}
+
+	if(!authenticate()) {
+		return false;
+	}
+
+	if(!sendRequest(Request::Erase)) {
+		Log::Error(__func__, "Failed to erase firmware");
+		return false;
+	}
+
+	handler(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	uint32_t sizeFlashed = 0;
+
+	for(const auto& sector : sectors) {
+		if(!flashSector(sector)) {
+			return false;
+		}
+
+		sizeFlashed += static_cast<uint32_t>(sector.second.size());
+		handler(
+			icsneo::Device::OpenStatusType::Progress,
+			"Flashing " + targetChip.getName() + "...",
+			(double)sizeFlashed / (double)totalSize
+		);
+	}
+
+	return validateFirmware();
+}
+
+bool RADPeriphCommunication::waitForConnect(std::chrono::milliseconds timeout) {
+	const auto deadline = std::chrono::steady_clock::now() + timeout;
+	while(std::chrono::steady_clock::now() < deadline) {
+		if(sendPeriphTest()) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool RADPeriphCommunication::open() {
+	device.com->pauseReads();
+
+	int attempts = 3;
+	do {
+		mode = getMode();
+		if(mode == Mode::NoAnswer) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(500));
+			mode = getMode();
+			if(mode == Mode::NoAnswer) {
+				return false;
+			}
+		}
+
+		if(mode == Mode::MainApplication) {
+			if(!sendRequestNoResponse(Request::SwitchToBootloader)) {
+				return false;
+			}
+			if(!device.reconnect(std::chrono::seconds(30))) {
+				return false;
+			}
+			if(!waitForConnect(std::chrono::seconds(30))) {
+				return false;
+			}
+		} else if(mode == Mode::Bootloader) {
+			return true;
+		}
+	} while(attempts--);
+
+	return false;
+}
+
+bool RADPeriphCommunication::close() {
+	if(mode != Mode::Bootloader) {
+		device.com->resumeReads();
+		return true;
+	}
+	if(!sendRequestNoResponse(Request::SwitchToApp)) {
+		return false;
+	}
+
+	std::this_thread::sleep_for(std::chrono::seconds(5)); // measured at 2s, 5s for buffer, yes this is needed
+
+	if(!device.reconnect(std::chrono::seconds(30))) {
+		return false;
+	}
+
+	if(!waitForConnect()) {
+		return false;
+	}
+
+	mode = getMode();
+	if(mode == Mode::MainApplication) {
+		device.com->resumeReads();
+		return true;
+	}
+	return false;
+}
+
+bool RADPeriphCommunication::enterApplication() {
+	return true;
+}
+
+bool RADPeriphCommunication::finalize() {
+	return true;
+}
+
+bool RADPeriphCommunication::hasFinalizationStep() const {
+	return false;
+}

device/extensions/bootloader/communication/red.cpp

@@ -0,0 +1,244 @@
+#include "icsneo/device/extensions/bootloader/communication/red.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstring>
+#include <optional>
+
+#include <icsbl/icsbl.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+REDCommunication::REDCommunication(icsneo::Device& dev, const ChipInfo& chip, bool auth, bool encryptWithDeviceKey)
+	: REDCommunicationBase(dev, chip), doAuthChecks(auth), encryptFirmwareWithDeviceKey(encryptWithDeviceKey) {}
+
+bool REDCommunication::open() {
+	device.com->pauseReads();
+
+	if(doAuthChecks) {
+		if(!authenticate()) {
+			return false;
+		}
+	}
+
+	return getVersion();
+}
+
+bool REDCommunication::authenticate(bool firstTime) {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	// The challenge is sent as: uint8_t 0x09, uint16_t 0 (a length on top of the protocol length, always zero here),
+	// one padding byte, then seed.a
+	std::vector<uint8_t> challenge(3 + sizeof(seed.a));
+	challenge[0] = 0x09;
+	std::memcpy(&challenge[3], &seed.a, sizeof(seed.a));
+
+	// Ask the bootloader to decode the seed
+	Log::Debug(__func__, "Authenticating");
+	if(!sendCommand(uint8_t(Command::Authenticate), challenge, std::chrono::seconds(1), false)) {
+		if(firstTime) {
+			// Attempt to flush out any buffers
+			Log::Debug(__func__, "Authentication failed, flushing buffers");
+			std::vector<uint8_t> flush(4096, PaddingByte);
+			device.com->sendPacket(flush);
+
+			// Allow any failure messages to come back
+			const bool any = waitForRx(std::chrono::milliseconds(100));
+			Log::Trace(__func__, any ? "A message came back" : "No communication came back");
+
+			lastData.clear();
+
+			// Now try again
+			return authenticate(false); // Either way, we don't need to continue authenticating
+		} else {
+			Log::Error(__func__, "The bootloader rejected the authentication challenge twice");
+			enterApplication();
+			return false;
+		}
+	}
+
+	// The reply is one byte followed by seed.b
+	if(lastData.back().data.size() < 1 + sizeof(seed.b)) {
+		Log::Error(__func__, "The authentication reply is too short");
+		enterApplication();
+		return false;
+	}
+	if(std::memcmp(&lastData.back().data[1], &seed.b, sizeof(seed.b)) != 0) {
+		Log::Error(__func__, "The authentication reply does not match, the device did not authenticate");
+		enterApplication();
+		return false;
+	}
+	lastData.clear();
+
+	return true;
+}
+
+bool REDCommunication::getVersion() {
+	if(!sendCommand(uint8_t(Command::GetVersion), std::chrono::seconds(1), false)) {
+		Log::Error(__func__, "The bootloader did not answer the version request");
+		enterApplication();
+		return false;
+	}
+
+	if(lastData.front().data.size() < VersionResponse::EncodedSize) {
+		Log::Error(__func__, "The bootloader version reply is too short");
+		enterApplication();
+		return false;
+	}
+
+	currentVersion = VersionResponse(lastData.front());
+	lastData.clear();
+
+	if(doAuthChecks) {
+		// Check that the serial number the bootloader reports is correct
+		uint8_t correctSerial[sizeof(VersionResponse::serial_num)] = {};
+		uint32_t devSerial = device.getSerialNumber();
+		std::memcpy(correctSerial, &devSerial, sizeof(devSerial));
+		if(std::memcmp(correctSerial, currentVersion.serial_num, sizeof(correctSerial))) {
+			Log::Error(__func__, "The serial number reported by the bootloader does not match the device");
+			enterApplication();
+			return false;
+		}
+	}
+
+	blockSize = currentVersion.block_size;
+	device.setBootloaderVersion({currentVersion.bl_major, currentVersion.bl_minor});
+	return true;
+}
+
+bool REDCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	const auto& srcVer = fw.getVersion();
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		return false;
+	}
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "IEF version " + std::to_string(ief.getVersion().appMajor) + "." + std::to_string(ief.getVersion().appMinor)
+		+ ", " + std::to_string(ief.getSectors().size()) + " sectors");
+
+	if(doAuthChecks && device.supportsSwVersionValidate()) {
+		// Tell the bootloader what version of Vehicle Spy 3 this firmware is from.
+		// We check to make sure it approves, but also, some devices will not accept
+		// new firmware if we have not sent this.
+		// Sometimes new hardware revisions can not accept firmware which is too old.
+		if(!sendCommand(uint8_t(Command::ValidateSWVersion), {srcVer.major, srcVer.minor, srcVer.release, srcVer.build})) {
+			Log::Error(__func__, "SW version validation failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	handler(icsneo::Device::OpenStatusType::Progress,
+		"Preparing to update " + targetChip.getName() + "...", std::nullopt);
+	Log::Debug(__func__, "Erasing " + targetChip.getName());
+	if(!sendCommand(uint8_t(Command::Erase), std::chrono::seconds(45))) {
+		Log::Error(__func__, "Erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	const auto& sectorPairs = ief.getSectors();
+	size_t sectorsFlashed = 0;
+	for(const auto& [id, sector] : sectorPairs) {
+		Log::Trace(__func__, "Flashing sector " + std::to_string(id));
+		handler(icsneo::Device::OpenStatusType::Progress,
+			"Updating " + targetChip.getName() + "...",
+			double(sectorsFlashed++) / sectorPairs.size());
+
+		if(sector.size() > blockSize) {
+			Log::Error(__func__, "Sector " + std::to_string(id) + " too large");
+			return false;
+		}
+
+		// Sectors smaller than the block size are padded out with zeros
+		std::vector<uint8_t> padded(sector.begin(), sector.end());
+		padded.resize(blockSize, 0);
+
+		std::vector<uint8_t> encrypted(padded.size());
+		if(encryptFirmwareWithDeviceKey)
+			icsbl_encrypt_v1(device.getSerialNumber(), padded.data(), padded.size(), encrypted.data());
+		else
+			encrypted = std::move(padded);
+
+		encrypted.insert(encrypted.begin(), {
+			0x00, 0x00, 0x00, // Padding bytes
+			// Address
+			uint8_t((id >> 0x00) & 0xFF),
+			uint8_t((id >> 0x08) & 0xFF),
+			uint8_t((id >> 0x10) & 0xFF),
+			uint8_t((id >> 0x18) & 0xFF),
+		});
+
+		// Unencrypted firmware is used for FIRE2 Zynq (and VNET) which also uses the top bit of the ID
+		// to denote whether the sector is flashed to chip A or chip B. That is indicated
+		// with a 1 (for chip B) or a 0 as the first byte of the flash packet payload.
+		if(!encryptFirmwareWithDeviceKey)
+			encrypted.insert(encrypted.begin(), uint8_t(id & (1u << 31) ? 1 : 0));
+
+		if(!sendCommand(uint8_t(Command::Flash), encrypted)) {
+			Log::Error(__func__, "Flash failed at sector " + std::to_string(id) + " for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	// Tell the application that we flashed 100%
+	handler(icsneo::Device::OpenStatusType::Progress,
+		"Updating " + targetChip.getName() + "...",
+		1.0);
+
+	handler(icsneo::Device::OpenStatusType::Progress, "Finalizing update...", std::nullopt);
+	if(!sendCommand(uint8_t(Command::ValidateFirmware))) {
+		Log::Error(__func__, "Firmware validation failed for " + targetChip.getName());
+		return false;
+	}
+	return true;
+}
+
+REDCommunication::VersionResponse::VersionResponse(const REDPacketizer::RxFrame& r) {
+	auto i = r.data.begin();
+	bl_major = *i++;
+	bl_minor = *i++;
+	app_major = *i++;
+	app_minor = *i++;
+	hardware_rev_major = *i++;
+	hardware_rev_minor = *i++;
+	flags = *i++;
+	block_size = *i++;
+	block_size |= uint16_t(*i++) << 8;
+	man_day = *i++;
+	man_month = *i++;
+	man_year = *i++;
+	man_year |= uint16_t(*i++) << 8;
+	for(size_t x = 0; x != sizeof(serial_num); ++x)
+		serial_num[x] = *i++;
+	prod_id = *i++;
+	last_error_code = *i++;
+	pad_byte = *i++;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/communication/redbase.cpp

@@ -0,0 +1,86 @@
+#include "icsneo/device/extensions/bootloader/communication/redbase.h"
+
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+REDCommunicationBase::REDCommunicationBase(icsneo::Device& dev, const ChipInfo& chip)
+	: Communication(dev), targetChip(chip) {}
+
+bool REDCommunicationBase::open() {
+	device.com->pauseReads();
+	return true;
+}
+
+bool REDCommunicationBase::close() {
+	device.com->resumeReads();
+	return true;
+}
+
+bool REDCommunicationBase::handleData() {
+	auto& rb = device.com->driver->getReadBuffer();
+
+	if(rp.input(rb)) {
+		lastData = rp.output();
+		return true;
+	}
+
+	return false;
+}
+
+bool REDCommunicationBase::waitForRx(std::chrono::milliseconds timeout) {
+	return device.com->driver->waitForRx([this]() { return handleData(); }, timeout);
+}
+
+bool REDCommunicationBase::sendCommand(uint8_t cmd, std::vector<uint8_t> args, std::chrono::seconds timeout, bool clearLastResponse) {
+	lastData.clear();
+	device.com->driver->getReadBuffer().clear();
+
+	if(!sendCommandRaw(cmd, std::move(args)))
+		return false;
+
+	if(!waitForRx(std::chrono::duration_cast<std::chrono::milliseconds>(timeout)))
+		return false;
+
+	const bool ret = lastData.front().resp == REDPacketizer::Response::Accepted;
+
+	if(clearLastResponse) {
+		lastData.clear();
+	}
+	return ret;
+}
+
+bool REDCommunicationBase::sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args) {
+	// For some reason, some devices need it padded to even total bytes, and some to odd total bytes
+	const bool padEven = device.getType() == DeviceType::FIRE2;
+
+	args.insert(args.begin(), uint8_t(cmd)); // Prepend the command byte to the arguments
+	if(args.size() > std::numeric_limits<uint16_t>::max())
+		return false;
+
+	uint16_t size = uint16_t(args.size());
+	// The header counts, and the header is 5 bytes, so we're checking for even inner size here
+	const bool padding = size % 2 != (padEven ? 0 : 1);
+	if(padding) // We will add padding, so make space for it
+		size++;
+
+	// Prepend the magic, 16-bit little-endian chip ID, and 16-bit little-endian size
+	const uint16_t chipID = uint16_t(targetChip.getID());
+	args.insert(args.begin(), {
+		REDPacketizer::Magic,
+		uint8_t(chipID & 0xFF), uint8_t(chipID >> 8),
+		uint8_t(size & 0xFF), uint8_t(size >> 8)
+	});
+
+	if(padding)
+		args.push_back(PaddingByte); // Ignored by the firmware
+
+	// Write it to the device
+	return device.com->sendPacket(args);
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/communication/redcore.cpp

@@ -0,0 +1,111 @@
+#include "icsneo/device/extensions/bootloader/communication/redcore.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool REDCoreCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	constexpr const size_t MaxSectorSize = 0x600;
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	if(bin.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "Firmware too large for " + targetChip.getName());
+		return false;
+	}
+
+	const std::string message = "Updating " + targetChip.getName() + "...";
+
+	// First send the firmware
+	const uint32_t fileSize = uint32_t(bin.size());
+	size_t sectorsFlashed = 0;
+	const size_t sectorCount = (fileSize / MaxSectorSize) + (fileSize % MaxSectorSize ? 1 : 0);
+	std::vector<uint8_t> sector;
+	for(size_t i = 0; i < fileSize; i += MaxSectorSize) {
+		Log::Trace(__func__, "Sending sector " + std::to_string(sectorsFlashed));
+		handler(icsneo::Device::OpenStatusType::Progress, message, double(sectorsFlashed++) / sectorCount);
+
+		sector.assign(bin.begin() + i, bin.begin() + i + std::min<size_t>(MaxSectorSize, fileSize - i));
+		if(!sendCommand(uint8_t(Command::SendFirmware), sector)) {
+			Log::Error(__func__, "Failed to send sector " + std::to_string(sectorsFlashed - 1) + " for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	// Then flash it
+	Log::Debug(__func__, "Starting core flash for " + targetChip.getName());
+	handler(icsneo::Device::OpenStatusType::Progress, message, std::nullopt);
+
+	// There is a long timeout on the StartFirmwareFlash because the bootloader may block here,
+	// potentially for the entire duration of the flash
+	if(!sendCommand(uint8_t(Command::StartFirmwareFlash), {
+			uint8_t(fileSize & 0xFF), uint8_t((fileSize >> 8) & 0xFF),
+			uint8_t((fileSize >> 16) & 0xFF), uint8_t((fileSize >> 24) & 0xFF),
+		}, std::chrono::seconds(60))) {
+		Log::Error(__func__, "Failed to start core flash for " + targetChip.getName());
+		return false;
+	}
+
+	// Watch the responses to know when it's done
+	const auto endTime = std::chrono::steady_clock::now() + std::chrono::seconds(60);
+	uint32_t flashed = 0;
+	while(flashed < fileSize && std::chrono::steady_clock::now() < endTime) {
+		if(!sendCommandRaw(uint8_t(Command::GetFlashProgress))) {
+			Log::Error(__func__, "Failed to request flash progress for " + targetChip.getName());
+			return false;
+		}
+
+		if(!waitForRx(std::chrono::milliseconds(3000))) {
+			Log::Trace(__func__, "No flash progress packet within 3 seconds");
+			continue;
+		}
+
+		const uint32_t oldFlashed = flashed;
+		for(const auto& packet : lastData) {
+			if(packet.resp != REDPacketizer::Response::Accepted)
+				return false;
+			if(packet.data.size() != 4) {
+				Log::Trace(__func__, "Got a flash progress packet of length " + std::to_string(packet.data.size()));
+				continue;
+			}
+			const uint32_t newFlashed = readLE32(packet.data.data());
+			if(newFlashed >= flashed)
+				flashed = newFlashed;
+			else
+				Log::Trace(__func__, "Got a flash progress packet which went backwards " + std::to_string(newFlashed) + " " + std::to_string(flashed));
+
+			// After sending us the packet that confirms the flash, the flash position is cleared and will send us zeros.
+			// We don't need any of these other packets, in that case.
+			if(flashed >= fileSize)
+				break;
+		}
+		lastData.clear();
+
+		Log::Trace(__func__, "Flashed " + std::to_string(flashed) + " of " + std::to_string(fileSize));
+
+		if(flashed != oldFlashed)
+			handler(icsneo::Device::OpenStatusType::Progress, message, std::min(double(flashed) / fileSize, 1.0));
+	}
+
+	return flashed == fileSize;
+}
+
+bool REDCoreCommunication::sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args) {
+	if(args.size() > std::numeric_limits<uint16_t>::max())
+		return false;
+	const uint16_t size = static_cast<uint16_t>(args.size());
+	args.insert(args.begin(), { CoreFlasherMagic, uint8_t(size & 0xFF), uint8_t((size >> 8) & 0xFF), cmd });
+	return REDCommunicationBase::sendCommandRaw(CoreFlasherCommand, std::move(args));
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/communication/redpacketizer.cpp

@@ -0,0 +1,85 @@
+#include "icsneo/device/extensions/bootloader/communication/redpacketizer.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool REDPacketizer::input(icsneo::RingBuffer& bytes) {
+	while(bytes.size() > 0) {
+		switch(state) {
+		case HEADER:
+			if(bytes[0] == Magic) {
+				working.emplace_back();
+				state = CMD;
+			} else {
+				Log::Trace(__func__, "Got bootloader unknown byte: " + std::to_string(bytes[0]));
+			}
+			bytes.pop_front();
+			break;
+		case CMD:
+			working.back().resp = Response(bytes[0]);
+			if(working.back().resp != Response::Accepted && working.back().resp != Response::Rejected) {
+				Log::Trace(__func__, "Got bootloader unknown response: " + std::to_string(bytes[0]));
+				working.pop_back();
+				state = HEADER;
+			} else {
+				state = LENGTH_LOWER;
+			}
+			bytes.pop_front();
+			break;
+		case LENGTH_LOWER:
+			working.back().len = bytes[0];
+			state = LENGTH_UPPER;
+			bytes.pop_front();
+			break;
+		case LENGTH_UPPER:
+			working.back().len |= uint16_t(bytes[0]) << 8;
+			if(working.back().len == 0) {
+				working.back().done = true;
+				state = HEADER;
+			} else {
+				state = DATA;
+			}
+			bytes.pop_front();
+			break;
+		case DATA: {
+			// The RingBuffer is not contiguous, so copy out with read() rather than taking a pointer
+			auto& frame = working.back();
+			const size_t dataToGo = frame.len - frame.data.size();
+			const size_t toCopy = std::min(bytes.size(), dataToGo);
+			const size_t oldSize = frame.data.size();
+			frame.data.resize(oldSize + toCopy);
+			bytes.read(frame.data.data() + oldSize, 0, toCopy);
+			bytes.pop(toCopy);
+			if(toCopy == dataToGo) {
+				frame.done = true;
+				state = HEADER;
+			}
+			break;
+		}
+		}
+	}
+
+	return std::any_of(working.begin(), working.end(), [](const RxFrame& rx) { return rx.done; });
+}
+
+std::vector<REDPacketizer::RxFrame> REDPacketizer::output() {
+	// Hand back the completed frames, anything still in progress stays in working
+	std::vector<RxFrame> done;
+	std::vector<RxFrame> pending;
+	for(auto& rx : working) {
+		if(rx.done)
+			done.push_back(std::move(rx));
+		else
+			pending.push_back(std::move(rx));
+	}
+	working = std::move(pending);
+	return done;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/parser/fwbin.cpp

@@ -0,0 +1,249 @@
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+
+#include <unordered_map>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * fw.bin file format (all integers little-endian):
+ *
+ *   uint8_t  versionLength
+ *   char     version[versionLength]  Vehicle Spy 3 version, "major.minor.release.build"
+ *   uint8_t  hashLength
+ *   char     hash[hashLength]        Build hash, unused
+ *   Then tags until the end of the file:
+ *     uint32_t nameHash              HashDjb2() of the tag name, e.g. "fire2_core"
+ *     uint8_t  type                  TagData::Type
+ *     uint32_t length
+ *     uint8_t  data[length]
+ *
+ * Exactly one Signature tag is required, it uses the reserved name hash 0.
+ */
+
+uint32_t FWBin::HashDjb2(const std::string& tag) {
+	uint32_t retv = 5381;
+	for(char c : tag)
+		retv = ((retv << 5) + retv) + c;
+	return retv;
+}
+
+bool FWBin::load(const std::string& path) {
+	file.open(path, std::ios::binary);
+	if(!file.is_open() || file.fail() || file.eof()) {
+		Log::Error(__func__, "Could not open file at " + path);
+		return false;
+	}
+	// Read out the version string, it is a single byte length followed by a string
+	uint8_t size;
+	file.read((char*)&size, 1);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the version length");
+		return false;
+	}
+	std::string unparsedVersion;
+	unparsedVersion.resize(size);
+	file.read(unparsedVersion.data(), size);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the version string");
+		return false;
+	}
+
+	if(!version.load(unparsedVersion)) {
+		Log::Error(__func__, "The fw.bin version string is invalid: " + unparsedVersion);
+		return false;
+	}
+
+	// Read out the hash string, it is a single byte length followed by a string
+	file.read((char*)&size, 1);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the hash length");
+		return false;
+	}
+
+	// The hash string is not used, skip over it
+	file.seekg(size, file.cur);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the hash string");
+		return false;
+	}
+
+	while(true) {
+		uint32_t tagHash;
+		file.read((char*)&tagHash, sizeof(uint32_t));
+		if(file.eof()) {
+			break;
+		}
+		if(file.fail()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag name hash");
+			return false;
+		}
+
+		if(tags.count(tagHash)) {
+			// Duplicate tag
+			Log::Error(__func__, "The fw.bin contains a duplicate tag");
+			return false;
+		}
+		TagData& current = tags[tagHash];
+
+		// Read the type field
+		file.read((char*)&current.type, sizeof(TagData::Type));
+		if(file.fail() || file.eof()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag type");
+			return false;
+		}
+
+		switch(current.type) {
+			case TagData::Type::DataBytes:
+			case TagData::Type::DataLength:
+			case TagData::Type::IEFVersion:
+				if(tagHash == SignatureHash) {
+					Log::Error(__func__, "The fw.bin contains a data tag using the reserved signature name hash");
+					return false;
+				}
+				break;
+			case TagData::Type::Signature:
+				if(tagHash != SignatureHash) {
+					Log::Error(__func__, "The fw.bin contains a signature tag with a non-signature name hash");
+					return false;
+				}
+				break;
+			default: // Unknown type
+				Log::Error(__func__, "The fw.bin contains a tag of unknown type " + std::to_string(static_cast<int>(current.type)));
+				return false;
+		}
+
+		// Read the length field
+		file.read((char*)&current.arrayLength, sizeof(uint32_t));
+		if(file.fail() || file.eof()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag length");
+			return false;
+		}
+
+		// Note the current position so we can jump back to it and read it later
+		current.arrayPosition = file.tellg();
+		file.seekg(current.arrayLength, file.cur);
+		if(file.fail()) {
+			Log::Error(__func__, "The fw.bin is truncated, a tag extends past the end of the file");
+			return false;
+		}
+	}
+	file.clear();
+
+	// The signature tag is required to be present, but it is not verified
+	if(tags.count(SignatureHash) == 0) {
+		Log::Error(__func__, "The fw.bin is missing its signature tag");
+		return false;
+	}
+	return true;
+}
+
+bool FWBin::readTag(const std::string& tag, std::vector<uint8_t>& out) const {
+	const auto hash = HashDjb2(tag);
+	if(hash == SignatureHash) {
+		Log::Error(__func__, "The signature tag can not be read as data");
+		return false;
+	}
+	const auto it = tags.find(hash);
+	if(it == tags.end()) {
+		Log::Error(__func__, "The fw.bin does not contain the tag " + tag);
+		return false;
+	}
+	return it->second.read(file, out);
+}
+
+bool FWBin::TagData::read(std::ifstream& stream, std::vector<uint8_t>& out) const {
+	stream.clear();
+	stream.seekg(arrayPosition, stream.beg);
+	out.resize(arrayLength);
+	stream.read((char*)out.data(), arrayLength);
+	if(stream.fail()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read tag data");
+		return false;
+	}
+	return true;
+}
+
+bool FWBin::getFW(const std::string& iefName, std::vector<uint8_t>& fw) const {
+	return readTag(iefName, fw);
+}
+
+FWBin::VersionTags FWBin::GetVersionTags(const std::string& iefName) {
+	static const std::unordered_map<std::string, VersionTags> VersionTable = {
+		{"fire2_core", {"fire2_core_version_major", "fire2_core_version_minor"}},
+		{"fire2_core_sg4", {"fire2_core_sg4_version_major", "fire2_core_sg4_version_minor"}},
+		{"RADA2B_SW_bin", {"RADA2B_SW_Version_Major", "RADA2B_SW_Version_Minor"}},
+		{"RADA2B_REVB_SW_bin", {"RADA2B_SW_Version_Major", "RADA2B_SW_Version_Minor"}},
+		{"RADComet_SW_bin", {"RADComet_SW_Version_Major", "RADComet_SW_Version_Minor"}},
+		{"RADComet3_SW_bin", {"RADComet3_SW_Version_Major", "RADComet3_SW_Version_Minor"}},
+		{"RADGalaxy_SG2_SW_bin", {"RADGalaxy_SG2_SW_Version_Major", "RADGalaxy_SG2_SW_Version_Minor"}},
+		{"RADGalaxy_SG2_FFG_SW_bin", {"RADGalaxy_SG2_FFG_SW_Version_Major", "RADGalaxy_SG2_SW_Version_Minor"}},
+		{"RADGalaxy2_SW_bin_p1", {"RADGalaxy2_SW_Version_Major", "RADGalaxy2_SW_Version_Minor"}},
+		{"RADGalaxy2_SW_bin_p2", {"RADGalaxy2_SW_Version_Major", "RADGalaxy2_SW_Version_Minor"}},
+		{"RADGigastar_SW_bin", {"RADGigastar_SW_Version_Major", "RADGigastar_SW_Version_Minor"}},
+		{"RADGigastar_FFG_SW_bin", {"RADGigastar_SW_Version_Major", "RADGigastar_SW_Version_Minor"}},
+		{"RADGigastar_USBz_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar_USBz_Z7010_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar_USBz_Z7007s_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar2_T1S_LIN_SW_bin", {"RADGigastar2_T1S_LIN_SW_Version_Major", "RADGigastar2_T1S_LIN_SW_Version_Minor"}},
+		{"RADGigastar2_T1S_CAN_SW_bin", {"RADGigastar2_T1S_CAN_SW_Version_Major", "RADGigastar2_T1S_CAN_SW_Version_Minor"}},
+		{"RADMoon2_SW_bin", {"RADMoon2_SW_Version_Major", "RADMoon2_SW_Version_Minor"}},
+		{"RADMoon2_Z7010_SW_bin", {"RADMoon2_SW_Version_Major", "RADMoon2_SW_Version_Minor"}},
+		{"RADMoonT1S_SW_bin", {"RADMoonT1S_SW_Version_Major", "RADMoonT1S_SW_Version_Minor"}},
+		{"vcan44_core_ief", {"vcan44_core_version_major", "vcan44_core_version_minor"}}
+	};
+	auto iter = VersionTable.find(iefName);
+	return iter != VersionTable.end() ? iter->second : VersionTags();
+}
+
+std::optional<icsneo::DeviceAppVersion> FWBin::getChipVersion(const std::string& iefName) const {
+	auto versionTags = GetVersionTags(iefName);
+
+	if(versionTags) {
+		std::vector<uint8_t> majData;
+		std::vector<uint8_t> minData;
+
+		if(!readTag(versionTags.majorTag, majData)) {
+			return std::nullopt;
+		}
+
+		if(!readTag(versionTags.minorTag, minData)) {
+			return std::nullopt;
+		}
+
+		if(majData.size() != 1)
+			return std::nullopt;
+
+		if(minData.size() != 1)
+			return std::nullopt;
+
+		icsneo::DeviceAppVersion chipVersion;
+		chipVersion.major = majData[0];
+		chipVersion.minor = minData[0];
+		return chipVersion;
+	}
+
+	std::vector<uint8_t> buf;
+
+	if(!readTag(iefName, buf)) {
+		return std::nullopt;
+	}
+
+	IEF ief;
+
+	if(!ief.load(std::move(buf))) {
+		return std::nullopt;
+	}
+
+	icsneo::DeviceAppVersion chipVersion;
+	chipVersion.major = ief.getVersion().appMajor;
+	chipVersion.minor = ief.getVersion().appMinor;
+	return chipVersion;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/parser/fwbundle.cpp

@@ -0,0 +1,142 @@
+#include "icsneo/device/extensions/bootloader/parser/fwbundle.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/core/crc32.h"
+#include <cstddef>
+#include <cstring>
+#include <fstream>
+#include <iterator>
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * Firmware bundle file format (all integers little-endian):
+ *
+ *   FWBundleHeader
+ *   Then chips until the end of the file:
+ *     FWBundleChip
+ *     uint8_t data[FWBundleChip::length]
+ *
+ * The CRC32 covers the whole file with the crc field set to zero.
+ */
+#pragma pack(push, 1)
+struct FWBundleHeader {
+	char magic[2]; // "FW"
+	uint16_t fmtVersion;
+	uint32_t crc;
+	uint8_t build;
+	uint8_t maintenance;
+	uint8_t minor;
+	uint8_t major;
+	uint8_t type; // Build type, unused
+};
+
+struct FWBundleChip {
+	uint32_t hash; // FWBin::HashDjb2() of the chip's IEF name
+	uint8_t build;
+	uint8_t maintenance;
+	uint8_t minor;
+	uint8_t major;
+	uint32_t length;
+};
+#pragma pack(pop)
+
+bool FWBundle::IsFWBundle(const std::string& path) {
+	std::ifstream file(path, std::ios::binary);
+	if(!file.is_open())
+		return false;
+	// Only check the magic, so a truncated bundle is still reported as a bundle error by load()
+	char magic[sizeof(FWBundleHeader::magic)];
+	file.read(magic, sizeof(magic));
+	if(file.fail())
+		return false;
+	return magic[0] == 'F' && magic[1] == 'W';
+}
+
+bool FWBundle::load(const std::string& path) {
+	std::ifstream file(path, std::ios::binary);
+	if(!file.is_open()) {
+		Log::Error(__func__, "Could not open file at " + path);
+		return false;
+	}
+	std::vector<uint8_t> bytes((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+	if(file.bad()) {
+		Log::Error(__func__, "Could not read file at " + path);
+		return false;
+	}
+
+	if(bytes.size() < sizeof(FWBundleHeader) || bytes.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "The firmware bundle is smaller than its header or larger than 4 GiB");
+		return false;
+	}
+
+	FWBundleHeader header;
+	std::memcpy(&header, bytes.data(), sizeof(header));
+	if(header.magic[0] != 'F' || header.magic[1] != 'W') {
+		Log::Error(__func__, "The file is not a firmware bundle, bad magic");
+		return false;
+	}
+
+	// The CRC is computed with the CRC field zeroed
+	std::memset(bytes.data() + offsetof(FWBundleHeader, crc), 0, sizeof(header.crc));
+	if(icsneo::crc32(0, bytes.data(), static_cast<uint32_t>(bytes.size())) != header.crc) {
+		Log::Error(__func__, "The firmware bundle failed CRC validation");
+		return false;
+	}
+
+	std::unordered_map<uint32_t, ChipBinary> parsed;
+	size_t offset = sizeof(FWBundleHeader);
+	while(offset < bytes.size()) {
+		if(bytes.size() - offset < sizeof(FWBundleChip)) {
+			Log::Error(__func__, "The firmware bundle is truncated, could not read a chip header");
+			return false;
+		}
+		FWBundleChip chip;
+		std::memcpy(&chip, bytes.data() + offset, sizeof(chip));
+		offset += sizeof(FWBundleChip);
+
+		if(bytes.size() - offset < chip.length) {
+			Log::Error(__func__, "The firmware bundle is truncated, a chip binary extends past the end of the file");
+			return false;
+		}
+
+		auto& bin = parsed[chip.hash];
+		bin.data.assign(bytes.begin() + offset, bytes.begin() + offset + chip.length);
+		bin.version.major = chip.major;
+		bin.version.minor = chip.minor;
+		bin.version.release = chip.maintenance;
+		bin.version.build = chip.build;
+		offset += chip.length;
+	}
+
+	version.major = header.major;
+	version.minor = header.minor;
+	version.release = header.maintenance;
+	version.build = header.build;
+	binaries = std::move(parsed);
+	return true;
+}
+
+bool FWBundle::getFW(const std::string& iefName, std::vector<uint8_t>& fw) const {
+	const auto it = binaries.find(FWBin::HashDjb2(iefName));
+	if(it == binaries.end()) {
+		Log::Error(__func__, "The chip binary could not be found");
+		return false;
+	}
+	fw = it->second.data;
+	return true;
+}
+
+std::optional<icsneo::DeviceAppVersion> FWBundle::getChipVersion(const std::string& iefName) const {
+	const auto it = binaries.find(FWBin::HashDjb2(iefName));
+	if(it == binaries.end())
+		return std::nullopt;
+	return icsneo::DeviceAppVersion(it->second.version.major, it->second.version.minor);
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/parser/fwloader.cpp

@@ -0,0 +1,25 @@
+#include "icsneo/device/extensions/bootloader/parser/fwloader.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbundle.h"
+
+namespace icsneo {
+
+namespace Bootloader {
+
+std::unique_ptr<FWRepo> FWLoader::Load(const std::string& path) {
+	if(FWBundle::IsFWBundle(path)) {
+		auto bundle = std::make_unique<FWBundle>();
+		if(!bundle->load(path))
+			return nullptr;
+		return bundle;
+	}
+
+	auto bin = std::make_unique<FWBin>();
+	if(!bin->load(path))
+		return nullptr;
+	return bin;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/parser/fwzip.cpp

@@ -0,0 +1,73 @@
+#include "icsneo/device/extensions/bootloader/parser/fwzip.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <miniz.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class ZipHandle {
+public:
+	ZipHandle() {
+		mz_zip_zero_struct(&handle);
+	}
+	~ZipHandle() {
+		mz_zip_reader_end(&handle);
+	}
+
+	operator mz_zip_archive*() {
+		return &handle;
+	}
+
+private:
+	mz_zip_archive handle;
+};
+
+// A zip firmware image holds a single entry, the raw binary to send to the device
+FWZip::FWZip(std::vector<uint8_t>&& tagData)
+	: handle(std::make_unique<ZipHandle>()), zipData(std::move(tagData)) {
+
+	if(!mz_zip_reader_init_mem(*handle, zipData.data(), zipData.size(), 0)) {
+		Log::Error(__func__, "The firmware zip could not be opened");
+		return;
+	}
+
+	mz_zip_archive_file_stat file;
+	if(!mz_zip_reader_file_stat(*handle, 0, &file)) {
+		Log::Error(__func__, "The firmware zip is empty or its first entry could not be read");
+	} else {
+		uncompressedSize = static_cast<size_t>(file.m_uncomp_size);
+	}
+}
+
+FWZip::~FWZip() = default;
+
+bool FWZip::readAll(uint8_t* out) {
+	if(!uncompressedSize) {
+		return false;
+	}
+
+	if(!out) {
+		Log::Error(__func__, "No output buffer for the firmware zip");
+		return false;
+	}
+
+	if(!mz_zip_reader_extract_to_mem(*handle, 0, out, *uncompressedSize, 0)) {
+		Log::Error(__func__, "The firmware zip could not be decompressed");
+		return false;
+	}
+	return true;
+}
+
+bool FWZip::readAll(std::vector<uint8_t>& out) {
+	if(!uncompressedSize) {
+		return false;
+	}
+	out = std::vector<uint8_t>(*uncompressedSize, 0);
+	return readAll(out.data());
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/parser/ief.cpp

@@ -0,0 +1,74 @@
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstring>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * IEF file format (all integers little-endian):
+ *
+ *   uint8_t  magic                0xAA
+ *   Version  version
+ *   uint8_t  configLength
+ *   uint8_t  config[configLength] Unused
+ *   Then sectors until the end of the file:
+ *     uint8_t  magic              0xAA
+ *     uint32_t index              Sector index, see the communication for how this maps to an address
+ *     uint32_t length
+ *     uint8_t  data[length]
+ */
+bool IEF::load(std::vector<uint8_t>&& bytes) {
+	static constexpr uint8_t Magic = 0xAA;
+	// Magic, version, config byte count
+	static constexpr size_t FixedHeaderSize = 1 + sizeof(Version) + 1;
+	// Magic, index, size
+	static constexpr size_t SectorHeaderSize = 1 + sizeof(uint32_t) + sizeof(uint32_t);
+
+	data = std::move(bytes);
+	sectors.clear();
+	if(data.size() < FixedHeaderSize) {
+		Log::Error(__func__, "IEF too short");
+		return false;
+	}
+
+	if(data.front() != Magic) {
+		Log::Error(__func__, "Invalid IEF magic");
+		return false;
+	}
+
+	std::memcpy(&version, data.data() + 1, sizeof(Version));
+
+	const size_t headerSize = FixedHeaderSize + data[FixedHeaderSize - 1];
+	if(data.size() <= headerSize) {
+		Log::Error(__func__, "Invalid IEF config bytes");
+		return false;
+	}
+
+	size_t offset = headerSize;
+	while(data.size() - offset >= SectorHeaderSize) {
+		if(data[offset] != Magic) {
+			Log::Error(__func__, "Invalid IEF sector magic");
+			return false;
+		}
+		uint32_t index;
+		uint32_t size;
+		std::memcpy(&index, data.data() + offset + 1, sizeof(index));
+		std::memcpy(&size, data.data() + offset + 1 + sizeof(index), sizeof(size));
+		offset += SectorHeaderSize;
+		if(data.size() - offset < size) {
+			Log::Error(__func__, "Invalid IEF sector");
+			return false;
+		}
+
+		sectors.emplace_back(index, BytesView(data.data() + offset, size));
+		offset += size;
+	}
+	return true;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/platform/logging.cpp

@@ -0,0 +1,57 @@
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstdlib>
+#include <iostream>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+namespace Log {
+
+// Set ICS_BOOTLOADER_LOG_LEVEL to 1 (error) through 5 (trace) to enable logging to stderr
+static int GetLogLevel() {
+	static const int level = [] {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996) // getenv
+#endif
+		const char* env = std::getenv("ICS_BOOTLOADER_LOG_LEVEL");
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+		return env ? std::atoi(env) : 0;
+	}();
+	return level;
+}
+
+static void Write(int level, const char* prefix, const std::string& subject, const std::string& msg) {
+	if(GetLogLevel() >= level)
+		std::cerr << prefix << subject << " - " << msg << std::endl;
+}
+
+void Trace(const std::string& subject, const std::string& msg) {
+	Write(5, "[TRACE] ", subject, msg);
+}
+
+void Debug(const std::string& subject, const std::string& msg) {
+	Write(4, "[DEBUG] ", subject, msg);
+}
+
+void Info(const std::string& subject, const std::string& msg) {
+	Write(3, "[INFO] ", subject, msg);
+}
+
+void Warning(const std::string& subject, const std::string& msg) {
+	Write(2, "[WARN] ", subject, msg);
+}
+
+void Error(const std::string& subject, const std::string& msg) {
+	Write(1, "[ERROR] ", subject, msg);
+}
+
+} // namespace Log
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/extensions/bootloader/version.cpp

@@ -0,0 +1,50 @@
+#include "icsneo/device/extensions/bootloader/version.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <limits>
+#include <optional>
+#include <regex>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool FirmwareSourceVersion::load(const std::string& toParse) {
+	static const std::regex VersionRegex{"(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)"};
+	std::smatch match;
+	if(!std::regex_match(toParse, match, VersionRegex)) {
+		Log::Error(__func__, "Failed to parse version");
+		return false;
+	}
+
+	const auto parse = [](const std::string& input) -> std::optional<ValueType> {
+		// The regex guarantees only digits, limit the length so stoul can not overflow
+		if(input.size() > 3) {
+			return std::nullopt;
+		}
+		const auto value = std::stoul(input);
+		if(value > std::numeric_limits<ValueType>::max()) {
+			return std::nullopt;
+		}
+		return static_cast<ValueType>(value);
+	};
+
+	const auto parsedMajor = parse(match[1]);
+	const auto parsedMinor = parse(match[2]);
+	const auto parsedRelease = parse(match[3]);
+	const auto parsedBuild = parse(match[4]);
+	if(!parsedMajor || !parsedMinor || !parsedRelease || !parsedBuild) {
+		Log::Error(__func__, "Invalid sized version number");
+		return false;
+	}
+
+	major = *parsedMajor;
+	minor = *parsedMinor;
+	release = *parsedRelease;
+	build = *parsedBuild;
+	return true;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo

device/idevicesettings.cpp

@@ -1113,3 +1113,177 @@ bool IDeviceSettings::setLinuxConfigurationPort(LinuxConfigurationPort port) {
 	(*os)->ethConfigurationPort = static_cast<uint8_t>(port);
 	return true;
 }
+
+namespace {
+
+void reportT1SUnavailable(const icsneo::device_eventhandler_t& report) {
+	report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+}
+
+std::optional<bool> t1sFlag(const ETHERNET10T1S_SETTINGS* t1s, uint8_t flag, const icsneo::device_eventhandler_t& report) {
+	if(t1s == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	return (t1s->flags & flag) != 0;
+}
+
+bool setT1SFlag(ETHERNET10T1S_SETTINGS* t1s, uint8_t flag, bool enable, const icsneo::device_eventhandler_t& report) {
+	if(t1s == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	if(enable)
+		t1s->flags |= flag;
+	else
+		t1s->flags = static_cast<uint8_t>(t1s->flags & ~flag);
+	return true;
+}
+
+std::optional<uint8_t> t1sByte(const uint8_t* field, const icsneo::device_eventhandler_t& report) {
+	if(field == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	return *field;
+}
+
+bool setT1SByte(uint8_t* field, uint8_t value, const icsneo::device_eventhandler_t& report) {
+	if(field == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	*field = value;
+	return true;
+}
+
+} // namespace
+
+std::optional<bool> IDeviceSettings::isT1SPLCAEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA, report);
+}
+
+bool IDeviceSettings::setT1SPLCAFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA, enable, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SLocalIDFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->local_id, report);
+}
+
+bool IDeviceSettings::setT1SLocalIDFor(Network net, uint8_t id) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->local_id, id, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMaxNodesFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->max_num_nodes, report);
+}
+
+bool IDeviceSettings::setT1SMaxNodesFor(Network net, uint8_t nodes) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->max_num_nodes, nodes, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1STxOppTimerFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->to_timer, report);
+}
+
+bool IDeviceSettings::setT1STxOppTimerFor(Network net, uint8_t timer) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->to_timer, timer, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMaxBurstFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->max_burst_count, report);
+}
+
+bool IDeviceSettings::setT1SMaxBurstFor(Network net, uint8_t burst) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->max_burst_count, burst, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SBurstTimerFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->burst_timer, report);
+}
+
+bool IDeviceSettings::setT1SBurstTimerFor(Network net, uint8_t timer) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->burst_timer, timer, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SLocalIDAlternateFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->local_id_alternate, report);
+}
+
+bool IDeviceSettings::setT1SLocalIDAlternateFor(Network net, uint8_t id) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->local_id_alternate, id, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1STerminationEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_TERMINATION, report);
+}
+
+bool IDeviceSettings::setT1STerminationFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_TERMINATION, enable, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1SBusDecodingBeaconsEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS, report);
+}
+
+bool IDeviceSettings::setT1SBusDecodingBeaconsFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS, enable, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1SBusDecodingAllEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL, report);
+}
+
+bool IDeviceSettings::setT1SBusDecodingAllFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL, enable, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMultiIDEnableMaskFor(Network net) const {
+	const auto* ext = getT1SSettingsExtFor(net);
+	return t1sByte(ext == nullptr ? nullptr : &ext->enable_multi_id, report);
+}
+
+bool IDeviceSettings::setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) {
+	auto* ext = getMutableT1SSettingsExtFor(net);
+	return setT1SByte(ext == nullptr ? nullptr : &ext->enable_multi_id, mask, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMultiIDFor(Network net, uint8_t index) const {
+	const auto* ext = getT1SSettingsExtFor(net);
+	if(ext == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	if(index >= sizeof(ext->multi_id)) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	return ext->multi_id[index];
+}
+
+bool IDeviceSettings::setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) {
+	auto* ext = getMutableT1SSettingsExtFor(net);
+	if(ext == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	if(index >= sizeof(ext->multi_id)) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return false;
+	}
+	ext->multi_id[index] = id;
+	return true;
+}

docs/icsneocpp/installation.rst

@@ -8,7 +8,6 @@ Dependencies
 The minimum requirements to build libicsneo are:
 - CMake version 3.12 or newer
 - A C++17 compiler
-- libpcap on Linux and macOS
 
 
 Building library & examples
@@ -30,10 +29,3 @@ libicsneo supports being added as a sub-projects with CMake's
 #. Clone libicsneo into the desired location within the project
 #. Add ``add_subdirectory(path/to/libicsneo)`` to ``CMakeLists.txt``
 #. Link the project to libicsneo with ``target_link_libraries(app icsneocpp)``
-
-Linux udev Rules
-================
-
-Linux users may want to install the included udev rules to run libicsneo based
-applications without root, this can be done with:
-``cp 99-intrepidcs.rules /etc/udev/rules.d/``

docs/icsneopy/examples.rst

@@ -107,3 +107,25 @@ Analog Output Control
 
 .. literalinclude:: ../../examples/python/analog_out/analog_out_basic.py
    :language: python
+
+ISO-TP CAN1 Loopback
+====================
+
+Two devices, CAN1 wired together. ``--raw`` checks the cable, ``--sf`` sends one
+firmware single frame, ``--both`` sends a segmented payload with firmware flow control.
+
+:download:`Download example <../../examples/python/iso15765/iso15765_loopback.py>`
+
+.. literalinclude:: ../../examples/python/iso15765/iso15765_loopback.py
+   :language: python
+
+Firmware Update
+===============
+
+Updates the first device found from a ``fw.bin`` or firmware bundle, see
+:doc:`firmware_update`.
+
+:download:`Download example <../../examples/python/bootloader/update.py>`
+
+.. literalinclude:: ../../examples/python/bootloader/update.py
+   :language: python

docs/icsneopy/installation.rst

@@ -25,14 +25,3 @@ To upgrade an existing installation:
 .. code-block:: bash
 
    pip install --pre --upgrade icsneopy
-
-Linux udev Rules
-================
-
-Linux users may want to install the included udev rules to run icsneopy-based
-applications without root. The rules file can be found in the libicsneo source
-repository at https://github.com/intrepidcs/libicsneo/.
-
-.. code-block:: bash
-
-   sudo cp 99-intrepidcs.rules /etc/udev/rules.d/

docs/index.rst

@@ -15,17 +15,3 @@ communication library. The source code for libicsneo can be found on GitHub:
    icsneoc/index
    icsneoc2/index
 
-Linux Installation
-==================
-
-Applications that use raw Ethernet device discovery, such as PCAP-backed
-discovery, need permission to open raw network sockets. Instead of running your
-application with ``sudo``, grant the installed executable the required Linux
-capabilities:
-
-.. code-block:: bash
-
-   sudo setcap cap_net_raw,cap_net_admin=eip /usr/bin/your-app
-
-Replace ``/usr/bin/your-app`` with the full path to the application executable.
-

examples/c/interactive/README.md

@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step
 
 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.
 
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
     * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
     * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.
 
 ## macOS
 

examples/c/legacy/README.md

@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step
 
 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.
 
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
     * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
     * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.
 
 ## macOS
 

examples/c/simple/README.md

@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step
 
 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.
 
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
     * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
     * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.
 
 ## macOS
 

examples/c2/t1s_loopback/src/main.c

@@ -378,7 +378,7 @@ static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid,
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S TX opportunity timer", res);
 	res = icsneoc2_settings_t1s_burst_timer_set(device, netid, T1S_BURST_TIMER);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S burst timer", res);
-	res = icsneoc2_settings_t1s_max_burst_timer_for_set(device, netid, T1S_MAX_BURST);
+	res = icsneoc2_settings_t1s_max_burst_set(device, netid, T1S_MAX_BURST);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max burst", res);
 
 	res = icsneoc2_settings_t1s_is_termination_enabled_for(device, netid, &termination);

examples/cpp/interactive/README.md

@@ -32,15 +32,14 @@ If you haven't done this, `third-party/libicsneo` will be empty and you won't be
 
 ### Ubuntu 18.04 LTS
 
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to your `libicsneo-examples/libicsneocpp-example` folder and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
     * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make libicsneocpp-interactive-example` to build.
     * Hint! Speed up your build by using multiple processors! Use `make libicsneocpp-interactive-example -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Now run `sudo ./libicsneocpp-interactive-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Now run `./libicsneocpp-interactive-example` to run the example.
 7. If you wish to run the simple example instead, replace any instances of "interactive" with "simple" in steps 5 and 6.
 
 ### macOS

examples/cpp/macsec/src/macsec.cpp

@@ -77,7 +77,7 @@ int main(int, char**) {
 	cfg.setTxEnable(true);
 
 	// Write config to the device
-	if(!device->writeMACsecConfig(cfg)) {
+	if(!device->writeMACsecConfig(cfg, icsneo::Network::NetID::AE_01)) {
 		std::cout << "Failed to write MACsec config" << std::endl;
 		std::cout << icsneo::GetLastError() << std::endl;
 		return -1;

examples/cpp/simple/README.md

@@ -32,15 +32,14 @@ If you haven't done this, `third-party/libicsneo` will be empty and you won't be
 
 ### Ubuntu 18.04 LTS
 
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to your `libicsneo-examples/libicsneocpp-example` folder and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
     * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make libicsneocpp-interactive-example` to build.
     * Hint! Speed up your build by using multiple processors! Use `make libicsneocpp-interactive-example -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Now run `sudo ./libicsneocpp-interactive-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Now run `./libicsneocpp-interactive-example` to run the example.
 7. If you wish to run the simple example instead, replace any instances of "interactive" with "simple" in steps 5 and 6.
 
 ### macOS

examples/python/bootloader/update.py

@@ -0,0 +1,49 @@
+import sys
+
+import icsneopy
+
+def update(firmware_path):
+	devices = icsneopy.find_all_devices()
+
+	if len(devices) == 0:
+		print("no devices found")
+		return False
+
+	device = devices[0]
+	print(f"selected {device}")
+
+	if not device.open():
+		print("unable to open device")
+		return False
+
+	fw = icsneopy.Bootloader.FWLoader.load(firmware_path)
+	if fw is None:
+		print(f"unable to load firmware from {firmware_path}")
+		return False
+
+	last_status = None
+
+	# repeated status messages overwrite the current line so progress updates in place
+	def logger(status_type, status, progress):
+		nonlocal last_status
+		if last_status not in (None, status):
+			print()
+		last_status = status
+		print(f"\r{status}" + (f" ({progress * 100:.1f}%)" if progress is not None else ""), end="", flush=True)
+		return icsneopy.Device.OpenDirective.Continue
+
+	# force_flash updates every chip, even those already at the version in the firmware file
+	ok = icsneopy.Bootloader.update(device, fw, logger, force_flash=True)
+	print()
+	if not ok:
+		print(f"update failed: {icsneopy.get_last_error()}")
+		return False
+
+	print("update complete")
+	return True
+
+if __name__ == "__main__":
+	if len(sys.argv) != 2:
+		print(f"usage: {sys.argv[0]} <fw.bin|bundle>")
+		sys.exit(1)
+	sys.exit(0 if update(sys.argv[1]) else 1)

examples/python/iso15765/iso15765_loopback.py

@@ -0,0 +1,264 @@
+"""
+Two-device ISO-TP loopback on CAN1.
+
+Firmware segments the payload. This script sends it once and prints CAN1
+frames with the ISO-TP PCI nibble decoded (SF/FF/CF/FC).
+
+Wire CAN1 of two devices together (CANH/CANL, terminated).
+
+  python iso15765_loopback.py --raw
+  python iso15765_loopback.py --sf
+  python iso15765_loopback.py --both
+"""
+
+import argparse
+import threading
+import time
+from datetime import timedelta
+
+import icsneopy
+
+
+CAN1 = icsneopy.Network.NetID.DWCAN_01
+
+
+def pci_describe(data):
+	if not data:
+		return ""
+	pci_type = data[0] >> 4
+	pci_low = data[0] & 0x0F
+	if pci_type == 0x0:
+		if pci_low > 7 or len(data) < 1 + pci_low:
+			return ""
+		return f"SF len={pci_low}"
+	if pci_type == 0x1:
+		if len(data) < 8:
+			return ""
+		length = (pci_low << 8) | data[1]
+		if length < 8:
+			return ""
+		return f"FF len={length}"
+	if pci_type == 0x2:
+		if len(data) < 2:
+			return ""
+		return f"CF SN={pci_low}"
+	if pci_type == 0x3:
+		if len(data) < 3 or pci_low > 2:
+			return ""
+		fs_name = ("CTS", "WAIT", "OVFLW")[pci_low]
+		return f"FC FS={fs_name} BS={data[1]} STmin=0x{data[2]:02X}"
+	return ""
+
+
+def print_api_result(what, ok):
+	line = f"  {what}: {'OK' if ok else 'FAIL'}"
+	if not ok:
+		err = icsneopy.get_last_error()
+		if err.get_type() != icsneopy.APIEvent.Type.NoErrorFound:
+			line += f" [{err.describe()}]"
+	print(line)
+
+
+def is_extended(arb_id):
+	return arb_id > 0x7FF
+
+
+def make_args(tx_id, fc_id, payload, rx):
+	msg = icsneopy.Iso15765MessageArgs()
+	msg.tx_index = 0
+	msg.arb_id = icsneopy.Iso15765MessageArgs.ArbId(tx_id, is_extended(tx_id))
+	msg.flow_control_arb_id = icsneopy.Iso15765MessageArgs.ArbId(fc_id, is_extended(fc_id))
+	msg.flow_control_arb_id_mask = 0x1FFFFFFF if is_extended(tx_id) else 0x7FF
+	msg.is_can_fd = False
+	msg.is_brs_enabled = False
+	msg.tx_dl = 8
+	msg.padding_value = 0x00
+	msg.fs_timeout = 75
+	msg.fs_wait_timeout = 150
+	msg.cf_timeout = 150
+	msg.is_flow_control_enabled = rx
+	if payload:
+		msg.data = payload
+	return msg
+
+
+def transmit_can(device, arb_id, data):
+	frame = icsneopy.CANMessage()
+	frame.network = icsneopy.Network(CAN1)
+	frame.arbid = arb_id
+	# RawMessage.data is vector<uint8_t>: a list of ints, not bytes.
+	frame.data = list(data)
+	frame.isExtended = is_extended(arb_id)
+	frame.isCANFD = False
+	ok = device.transmit(frame)
+	if not ok:
+		print_api_result("transmit CAN", ok)
+	return ok
+
+
+class Sniffer:
+	def __init__(self, tag):
+		self.tag = tag
+		self.t0 = None
+		self.lock = threading.Lock()
+
+	def on_message(self, message):
+		if not isinstance(message, icsneopy.CANMessage):
+			return
+		if message.network.get_type() != icsneopy.Network.Type.CAN:
+			return
+		with self.lock:
+			if self.t0 is None:
+				self.t0 = message.timestamp
+			rel_ms = 0.0
+			if message.timestamp >= self.t0:
+				rel_ms = (message.timestamp - self.t0) / 1e6
+			direction = "TX" if message.transmitted else "RX"
+			width = 8 if is_extended(message.arbid) else 3
+			data = " ".join(f"{b:02X}" for b in message.data)
+			line = (
+				f"  [{self.tag} {direction}] {rel_ms:8.3f} ms  "
+				f"{message.network}  0x{message.arbid:0{width}X} "
+				f"[{len(message.data)}]  {data}"
+			)
+			pci = pci_describe(message.data)
+			if pci:
+				line += f"  {pci}"
+			print(line)
+
+
+def open_and_online(device, baud, keep_baud):
+	print(f"Opening {device.describe()} ...")
+	if not device.open():
+		print_api_result("open", False)
+		return False
+	if not keep_baud and device.settings is not None:
+		net = icsneopy.Network(CAN1)
+		if not device.settings.set_baudrate(net, baud):
+			print_api_result("set_baudrate", False)
+		elif not device.settings.apply(True):
+			print_api_result("settings.apply(temporary)", False)
+	if not device.go_online():
+		print_api_result("go_online", False)
+		device.close()
+		return False
+	return True
+
+
+def close_device(device):
+	if device is None:
+		return
+	device.iso15765_disable_all()
+	if device.is_online():
+		device.go_offline()
+	if device.is_open():
+		device.close()
+
+
+def find_by_serial(devices, serial):
+	for device in devices:
+		if device.get_serial().lower() == serial.lower():
+			return device
+	return None
+
+
+def parse_args():
+	parser = argparse.ArgumentParser(
+		description="Two Intrepid devices with CAN1 wired together (CANH/CANL, terminated)."
+	)
+	mode = parser.add_mutually_exclusive_group(required=True)
+	mode.add_argument("--raw", action="store_true", help="Raw CAN ping-pong (cable check)")
+	mode.add_argument("--sf", action="store_true", help="Firmware ISO-TP single-frame TX from tester")
+	mode.add_argument("--both", action="store_true", help="Firmware ISO-TP TX on tester, firmware flow-control on ECU")
+	parser.add_argument("--tester", default="", help="Tester (sender) serial. Optional if exactly two devices are found.")
+	parser.add_argument("--ecu", default="", help="ECU / peer serial. Optional if exactly two devices are found.")
+	parser.add_argument("--baud", type=int, default=500000, help="CAN1 baud, applied temporarily (default 500000)")
+	parser.add_argument("--keep-baud", action="store_true", help="Do not change device baud")
+	parser.add_argument("--tx-id", type=lambda s: int(s, 0), default=0x7E0, help="Tester ISO-TP CAN ID (default 0x7E0)")
+	parser.add_argument("--fc-id", type=lambda s: int(s, 0), default=0x7E8, help="Flow-control CAN ID (default 0x7E8)")
+	parser.add_argument("--bytes", type=int, default=None, help="ISO-TP payload size (sf default 5, both default 20)")
+	parser.add_argument("--listen-ms", type=int, default=2000, help="Time to listen after the action (default 2000)")
+	return parser.parse_args()
+
+
+def main():
+	args = parse_args()
+	print(f"libicsneo {icsneopy.get_version()}")
+
+	devices = icsneopy.find_all_devices()
+	print(f"Found {len(devices)} device(s)")
+	for device in devices:
+		print(f"  {device.describe()} serial={device.get_serial()}")
+	if len(devices) < 2:
+		raise SystemExit("Need two devices connected.")
+
+	if not args.tester and not args.ecu:
+		if len(devices) != 2:
+			raise SystemExit("More than two devices found; pass --tester and --ecu serials.")
+		tester, ecu = devices[0], devices[1]
+		print("No serials given; using first as tester, second as ECU.")
+	else:
+		if not args.tester or not args.ecu:
+			raise SystemExit("Pass both --tester and --ecu, or neither.")
+		tester = find_by_serial(devices, args.tester)
+		ecu = find_by_serial(devices, args.ecu)
+		if tester is None or ecu is None:
+			raise SystemExit("Could not match tester/ECU serials.")
+
+	payload_size = args.bytes if args.bytes is not None else (5 if args.sf else 20)
+	payload = [i & 0xFF for i in range(payload_size)]
+
+	print(f"Tester: {tester.describe()}")
+	print(f"ECU:    {ecu.describe()}")
+	if not args.raw:
+		print(f"CAN1 TX 0x{args.tx_id:X}  FC 0x{args.fc_id:X}  payload {payload_size} bytes")
+	print()
+
+	network = icsneopy.Network(CAN1)
+	try:
+		if not open_and_online(tester, args.baud, args.keep_baud):
+			return 1
+		if not open_and_online(ecu, args.baud, args.keep_baud):
+			return 1
+
+		for device, sniffer in ((tester, Sniffer("TESTER")), (ecu, Sniffer("ECU   "))):
+			callback = icsneopy.MessageCallback(sniffer.on_message, icsneopy.MessageFilter(CAN1))
+			device.add_message_callback(callback)
+
+		if args.raw:
+			print("Mode --raw: tester 0x123, then ECU 0x456")
+			transmit_can(tester, 0x123, [0x11, 0x22, 0x33, 0x44])
+			time.sleep(0.2)
+			transmit_can(ecu, 0x456, [0x55, 0x66, 0x77, 0x88])
+		elif args.sf:
+			print("Mode --sf: firmware ISO-TP single frame from tester")
+			if len(payload) > 7:
+				print("  warning: payload > 7 bytes will be a First Frame (no flow control in this mode)")
+			ok = tester.iso15765_enable(network)
+			print_api_result("tester iso15765_enable", ok)
+			msg = make_args(args.tx_id, args.fc_id, payload, rx=False)
+			ok = tester.iso15765_transmit_message(network, msg, timedelta(0))
+			print_api_result("tester iso15765_transmit_message", ok)
+		else:
+			print("Mode --both: firmware TX on tester, firmware flow-control on ECU")
+			ok = tester.iso15765_enable(network)
+			print_api_result("tester iso15765_enable", ok)
+			ok = ecu.iso15765_enable(network)
+			print_api_result("ECU iso15765_enable", ok)
+			msg = make_args(args.tx_id, args.fc_id, [], rx=True)
+			ok = ecu.iso15765_setup_rx_flow_control(network, msg)
+			print_api_result("ECU iso15765_setup_rx_flow_control", ok)
+			time.sleep(0.1)
+			msg = make_args(args.tx_id, args.fc_id, payload, rx=False)
+			ok = tester.iso15765_transmit_message(network, msg, timedelta(0))
+			print_api_result("tester iso15765_transmit_message", ok)
+
+		time.sleep(args.listen_ms / 1000.0)
+	finally:
+		close_device(tester)
+		close_device(ecu)
+	return 0
+
+
+if __name__ == "__main__":
+	raise SystemExit(main())

include/icsneo/api/event.h

@@ -126,6 +126,9 @@ public:
 		SettingNotAvaiableDevice = 0x2057,
 		DiskFormatNotSupported = 0x2058,
 		DiskFormatInvalidCount = 0x2059,
+		TC10RequestFailed = 0x205A,
+		FirmwareUpdateNotSupported = 0x205B,
+		FirmwareUpdateFailed = 0x205C,
 
 		// Transport Events
 		FailedToRead = 0x3000,
@@ -167,6 +170,7 @@ public:
 		ServdNoDataError = ServdBindError + 9,
 		ServdJoinMulticastError = ServdBindError + 10,
 		ServdNotReachable = ServdBindError + 11,
+		ServdDisabled = ServdBindError + 12,
 
 		// DXX
 		DXXErrorSys = 0x6100,

include/icsneo/communication/command.h

@@ -31,7 +31,10 @@ enum class Command : uint8_t {
 	LoadCoreMini = 0x43,
 	GetRTC = 0x49,
 	SetRTC = 0x50,
+	PeripheralBootloader = 0x83,
+	EnterBootloader = 0xA0,
 	RequestSerialNumber = 0xA1,
+	ValidateDevice = 0xA2,
 	GetMainVersion = 0xA3, // Previously known as RED_CMD_APP_VERSION_REQ
 	SetSettings = 0xA4, // Previously known as RED_CMD_SET_BAUD_REQ, follow up with SaveSettings to write to EEPROM
 	//GetSettings = 0xA5, // Previously known as RED_CMD_READ_BAUD_REQ, now unused

include/icsneo/communication/message/ethphymessage.h

@@ -8,6 +8,7 @@
 #include "icsneo/communication/packet.h"
 #include <vector>
 #include <memory>
+#include <optional>
 
 namespace icsneo {
 
@@ -17,13 +18,16 @@ namespace icsneo {
 #endif
 
 struct PhyMessage {
-	bool Enabled;
-	bool WriteEnable;
-	bool Clause45Enable;
-	uint8_t BusIndex;
-	uint8_t Version;
+	bool Enabled = false;
+	bool WriteEnable = false;
+	bool Clause45Enable = false;
+	uint8_t BusIndex = 0;
+	uint8_t Version = PhyPacketVersion;
+	// Unset on locally constructed messages; every decoded response sets the raw wire status.
+	// Ignored when sending. A value does not establish firmware error coverage.
+	std::optional<uint8_t> Status;
 	union {
-		Clause22Message Clause22;
+		Clause22Message Clause22{};
 		Clause45Message Clause45;
 	};
 };

include/icsneo/communication/packet/ethphyregpacket.h

@@ -65,7 +65,7 @@ struct PhyRegisterPacket_t {
 #pragma pack(pop)
 
 static constexpr size_t MaxPhyEntries = 128u;
-static constexpr size_t MaxBytesPhyEntries = MaxPhyEntries * sizeof(PhyRegisterHeader_t);
+static constexpr size_t MaxBytesPhyEntries = MaxPhyEntries * sizeof(PhyRegisterPacket_t);
 static constexpr uint8_t PhyPacketVersion = 1u;
 static constexpr uint8_t FiveBits = 0x1Fu;
 

include/icsneo/core/macseccfg.h

@@ -150,7 +150,6 @@ private:
 	uint8_t maxSecY;
 	uint8_t maxSa;
 	uint8_t maxRule;
-	uint16_t binIndex;
 	DeviceType type;
 
 	std::vector<MACsecRxRule> rxRule;
@@ -205,7 +204,6 @@ public:
 	void clear();
 	std::vector<uint8_t> serialize() const;
 	operator bool() const;
-	uint16_t getBinIndex() const;
 	DeviceType getType() const;
 	uint8_t getMaxNumRule() const;
 	uint8_t getMaxNumSecY() const;

include/icsneo/device/bootloaderpipeline.h

@@ -91,9 +91,10 @@ struct FlashPhase : public BootloaderPhase {
 	bool authenticate = true;
 	bool encrypt = true;
 	bool checkOutOfDate = true;
+	uint8_t slot = UINT8_MAX;
 
-	FlashPhase(ChipID chip, BootloaderCommunication comm, bool authenticate = true, bool encrypt = true, bool checkOutOfDate = true) 
-		: chip(chip), comm(comm), authenticate(authenticate), encrypt(encrypt), checkOutOfDate(checkOutOfDate) {}
+	FlashPhase(ChipID chip, BootloaderCommunication comm, bool authenticate = true, bool encrypt = true, bool checkOutOfDate = true, uint8_t slot = UINT8_MAX) 
+		: chip(chip), comm(comm), authenticate(authenticate), encrypt(encrypt), checkOutOfDate(checkOutOfDate), slot(slot) {}
 };
 
 enum class BootloaderSetting {

include/icsneo/device/chipid.h

@@ -138,7 +138,8 @@ enum class ChipID : icsneoc2_chip_id_t {
 	RADMOONT1S_ZCHIP = icsneoc2_chip_id_radmoont1s_zchip,
 	RADGigastar2_ZYNQ = icsneoc2_chip_id_radgigastar2_zynq,
 	SFPModule_ent11100_MCHIP = icsneoc2_chip_id_sfpmodule_ent11100_mchip,
-	RADGemini_MCHIP = icsneoc2_chip_id_radgemini_mchip,
+	RADArgos_MCHIP = icsneoc2_chip_id_radargos_mchip,
+	SFPModule_ad1101_MCHIP = icsneoc2_chip_id_sfpmodule_ad1101_mchip,
 	Invalid = icsneoc2_chip_id_invalid
 };
 

include/icsneo/device/device.h

@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <optional>
 #include <unordered_map>
+#include <map>
 #include <set>
 #include <unordered_set>
 #include <chrono>
@@ -150,7 +151,8 @@ public:
 		RADMoonT1S = 56,
 		RADGigastar2 = 57,
 		SFPModule_ent11100 = 58,
-		RADGemini = 60,
+		RADArgos = 60,
+		SFPModule_ad1101 = 61,
 	};
 
 	virtual ProductID getProductID() const = 0;
@@ -897,7 +899,8 @@ public:
 	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
 	/* MACsec support */
-	virtual bool writeMACsecConfig(const MACsecConfig& cfg);
+	std::vector<Network> getMACsecNetworks() const;
+	bool writeMACsecConfig(const MACsecConfig& cfg, Network::NetID network);
 
 	std::shared_ptr<DeviceExtension> getExtension(const std::string& name) const;
 	
@@ -917,6 +920,13 @@ public:
 	bool iso15765SetupRxFlowControl(const Network& network, const Iso15765MessageArgs& msg);
 
 protected:
+	using MACsecNetworkMap = std::map<Network::NetID, uint16_t>;
+
+	virtual const MACsecNetworkMap& getMACsecNetworkMap() const {
+		static const MACsecNetworkMap networks;
+		return networks;
+	}
+
 	bool online = false;
 	int messagePollingCallbackID = 0;
 	int internalHandlerCallbackID = 0;

include/icsneo/device/devicetype.h

@@ -62,7 +62,7 @@ public:
 		RADGigastar2 = icsneoc2_devicetype_rad_gigastar2,
 		FIRE3_T1S_LIN = icsneoc2_devicetype_fire3_t1s_lin,
 		FIRE3_T1S_SENT = icsneoc2_devicetype_fire3_t1s_sent,
-		RADGemini = icsneoc2_devicetype_rad_gemini,
+		RADArgos = icsneoc2_devicetype_rad_argos,
 		RED = icsneoc2_devicetype_red,
 		ECU = icsneoc2_devicetype_ecu,
 		IEVB = icsneoc2_devicetype_ievb,
@@ -153,8 +153,8 @@ public:
 				return "RAD-EpsilonXL";
 			case RADMoon3:
 				return "RAD-Moon 3";
-			case RADGemini:
-				return "RAD-Gemini";
+			case RADArgos:
+				return "RAD-Argos";
 			case RADComet2:
 				return "RAD-Comet 2";
 			case RED:
@@ -281,7 +281,7 @@ private:
 #define ICSNEO_DEVICETYPE_RADGIGASTAR2 ((devicetype_t)icsneoc2_devicetype_rad_gigastar2)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_LIN ((devicetype_t)icsneoc2_devicetype_fire3_t1s_lin)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_SENT ((devicetype_t)icsneoc2_devicetype_fire3_t1s_sent)
-#define ICSNEO_DEVICETYPE_RADGEMINI ((devicetype_t)icsneoc2_devicetype_rad_gemini)
+#define ICSNEO_DEVICETYPE_RADARGOS ((devicetype_t)icsneoc2_devicetype_rad_argos)
 #define ICSNEO_DEVICETYPE_RED ((devicetype_t)icsneoc2_devicetype_red)
 #define ICSNEO_DEVICETYPE_ECU ((devicetype_t)icsneoc2_devicetype_ecu)
 #define ICSNEO_DEVICETYPE_IEVB ((devicetype_t)icsneoc2_devicetype_ievb)

include/icsneo/device/extensions/bootloader/api.h

@@ -0,0 +1,42 @@
+#ifndef __BOOTLOADER_API_H_
+#define __BOOTLOADER_API_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/chip.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/device.h"
+
+#include <string>
+#include <optional>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+using Logger = icsneo::Device::OpenStatusHandler;
+
+bool requiresUpdate(icsneo::Device& device, const FWRepo& fw);
+bool update(
+	icsneo::Device& device,
+	const FWRepo& fw,
+	Logger logger = [](icsneo::Device::OpenStatusType, const std::string&, std::optional<double>) { return icsneo::Device::OpenDirective::Continue; },
+	bool alreadyInBootloader = false,
+	bool forceFlash = false
+);
+
+bool enterBootloader(icsneo::Device& device);
+bool exitBootloader(icsneo::Device& device, Logger logger, bool updatedChips);
+bool verifyConnection(icsneo::Device& device, Logger logger);
+
+bool isSFPChip(const icsneo::Bootloader::Chip& chip);
+bool isSFPIEF(const icsneo::Bootloader::IEF& ief);
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_API_H_

include/icsneo/device/extensions/bootloader/bytesview.h

@@ -0,0 +1,48 @@
+#ifndef __BOOTLOADER_BYTESVIEW_H_
+#define __BOOTLOADER_BYTESVIEW_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+#include <cstddef>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class BytesView {
+private:
+	const uint8_t* ptr = nullptr;
+	size_t length = 0;
+public:
+	BytesView() = default;
+	BytesView(const uint8_t* buf, size_t size) : ptr(buf), length(size) {}
+
+	const uint8_t* begin() const {
+		return ptr;
+	}
+
+	const uint8_t* end() const {
+		return ptr + length;
+	}
+
+	const uint8_t* data() const {
+		return ptr;
+	}
+
+	size_t size() const {
+		return length;
+	}
+
+	const uint8_t& operator[](size_t index) const {
+		return ptr[index];
+	}
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_BYTESVIEW_H_

include/icsneo/device/extensions/bootloader/chip.h

@@ -0,0 +1,35 @@
+#ifndef __BOOTLOADER_CHIP_H_
+#define __BOOTLOADER_CHIP_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/chipinfo.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+struct Chip {
+	uint8_t expansionSlot = 0;
+	ChipInfo info;
+
+	Chip(const ChipInfo& info) : info(info) {}
+
+	ChipID getID() const { return info.id; }
+	std::string getName() const { return info.name ? info.name : ""; }
+	std::string getIEFName() const { return info.iefName ? info.iefName : ""; }
+	const std::vector<const char*>& getMultiIEFName() const { return info.iefSegments; }
+	FirmwareType getFirmwareType() const { return info.fwType; }
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_CHIP_H_

include/icsneo/device/extensions/bootloader/communication/application.h

@@ -0,0 +1,92 @@
+#ifndef __BOOTLOADER_APPLICATION_H_
+#define __BOOTLOADER_APPLICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The software update protocol used with the application
+ * on RED devices, does not require entering the bootloader.
+ */
+class Application : public Communication {
+public:
+	Application(icsneo::Device& dev, const ChipInfo& chip, bool doAuthChecks = false, bool encrypt = false)
+		: Communication(dev), targetChip(chip), doAuthChecks(doAuthChecks), encrypted(encrypt) {}
+
+	void setExpansionSlot(uint8_t slot) { targetChip.expansionSlot = slot; }
+
+	bool enterApplication() override;
+	bool hasFinalizationStep() const override {
+		return true;
+	}
+	bool finalize() override;
+	bool flash(const FWRepo& repo, const icsneo::Device::OpenStatusHandler& handler) override;
+
+	bool open() override {
+		return true;
+	}
+
+	bool close() override {
+		return true;
+	}
+
+	bool authenticate();
+	bool sendSoftware(const std::vector<uint8_t>& bin, const icsneo::Device::OpenStatusHandler& handler);
+	bool sendSoftware(const std::vector<IEF::Sector>& sectors, uint32_t blockSize, const icsneo::Device::OpenStatusHandler& handler);
+	bool validateFirmware(const DeviceAppVersion& chipSrcVer);
+	bool validateComponent();
+
+private:
+	// Sub-commands of ExtendedCommand::SoftwareUpdate
+	enum class Update : uint8_t {
+		Write = 0,
+		Erase = 1,
+		GetProgress = 2,
+		CheckVersion = 5,
+		ValidateComponent = 6,
+		Finalize = 7,
+		CheckComponentVersion = 9
+	};
+
+	// Prefixes the arguments of every ExtendedCommand::SoftwareUpdate request, and is echoed back with progress
+#pragma pack(push, 2)
+	struct SoftwareUpdateCommandHeader {
+		uint32_t componentIdentifier; // unique id for the software component - analogous to what used to be "chip id"
+		Update commandType;
+		uint8_t expansionSlot;
+		uint32_t offset;
+		uint32_t commandSizeOrProgress; // size
+	};
+#pragma pack(pop)
+
+	Chip targetChip;
+	const bool doAuthChecks;
+	const bool encrypted;
+
+	using StatusHandler = std::function<void(double progress)>;
+	bool sendCommand(Update command, const StatusHandler& handler, uint32_t offset = 0,
+		const std::vector<uint8_t>& args = {}, std::chrono::milliseconds timeout = std::chrono::milliseconds(3000)) {
+		return sendCommand(command, offset, static_cast<uint32_t>(args.size()), handler, timeout, args);
+	}
+	bool sendCommand(Update command, uint32_t offset, uint32_t length, const StatusHandler& handler,
+		std::chrono::milliseconds timeout = std::chrono::milliseconds(3000), std::vector<uint8_t> args = {});
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_APPLICATION_H_

include/icsneo/device/extensions/bootloader/communication/bootloaderversion.h

@@ -0,0 +1,37 @@
+#ifndef __BOOTLOADER_BOOTLOADERVERSION_H_
+#define __BOOTLOADER_BOOTLOADERVERSION_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+#pragma pack(push, 1)
+struct BootloaderVersionResponse {
+	uint8_t blMajor;
+	uint8_t blMinor;
+	uint16_t reserved1;
+	uint8_t hwMajor;
+	uint8_t hwMinor;
+	uint8_t hwPlatform;
+	uint16_t reserved2;
+	uint8_t manDay;
+	uint8_t manMonth;
+	uint16_t manYear;
+	uint8_t serialNum[8];
+	uint8_t hwId;
+	uint8_t reserved3;
+	uint8_t zynqId;
+};
+#pragma pack(pop)
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_BOOTLOADERVERSION_H_

include/icsneo/device/extensions/bootloader/communication/communication.h

@@ -0,0 +1,49 @@
+#ifndef __BOOTLOADER_COMMUNICATION_H_
+#define __BOOTLOADER_COMMUNICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/chip.h"
+#include "icsneo/device/device.h"
+
+#include <cstdint>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWRepo;
+
+/**
+ * A bootloader protocol for one chip.
+ *
+ * Authentication is a challenge/response handled by libicsbl: icsbl_generate_seed_v1() derives
+ * a challenge (seed.a) and the reply the device must send back (seed.b) from the serial number.
+ * Firmware is encrypted for a specific device with icsbl_encrypt_v1(), also keyed by the serial number.
+ */
+class Communication {
+public:
+	Communication(icsneo::Device& dev) : device(dev) {}
+	virtual ~Communication() = default;
+
+	virtual bool enterApplication() = 0;
+	virtual bool hasFinalizationStep() const = 0;
+	virtual bool finalize() = 0;
+	virtual bool flash(const FWRepo& repo, const icsneo::Device::OpenStatusHandler& handler) = 0;
+
+	virtual bool open() = 0;
+	virtual bool close() = 0;
+
+protected:
+	static uint32_t readLE32(const uint8_t* data);
+	static void writeLE32(uint8_t* data, uint32_t val);
+	icsneo::Device& device;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_COMMUNICATION_H_

include/icsneo/device/extensions/bootloader/communication/radcommunication.h

@@ -0,0 +1,108 @@
+#ifndef __BOOTLOADER_RADCOMMUNICATION_H_
+#define __BOOTLOADER_RADCOMMUNICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+
+#include <chrono>
+#include <cstdint>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The bootloader protocol used by RAD devices.
+ *
+ * Requests are a command byte followed by the payload, responses are the command byte,
+ * a Response::Type byte and then the payload. Newer RAD bootloaders (the "Zynq binary
+ * flasher") also prefix each request with ZynqFlasherSync and a 16-bit little-endian
+ * length of the command byte plus payload.
+ */
+class RADCommunication : public Communication {
+protected:
+	static constexpr size_t MaxMessageLength = 1518;
+	static constexpr uint8_t ZynqFlasherSync[4] = {0xAA, 0xAA, 0x55, 0x55};
+	static constexpr size_t ZynqFlasherHeaderSize = sizeof(ZynqFlasherSync) + sizeof(uint16_t);
+
+	struct Request {
+		enum class Type : uint8_t {
+			BootloaderVersion = 0x01,
+			EnterApplication = 0x02,
+			BeginTransfer = 0x03,
+			FWPayload = 0x04,
+			EndTransfer = 0x05,
+			ProgramFlash = 0x06,
+			DownloadedBinInfo = 0x07,
+			ProgrammingStatus = 0x08,
+			Authenticate = 0x09,
+			SanityCheck = 0x0A,
+			VerifyCRC = 0x0B,
+			ValidateVersion = 0x0F,
+			Invalid = 0xFF
+		} type = Type::Invalid;
+
+		uint8_t* payload = nullptr;
+		size_t expectedResponseLen = 0;
+	};
+
+	Request makeRequest(Request::Type type, size_t payloadSize = 0, size_t expectedResponseLen = 0);
+
+	struct Response {
+		enum class Type {
+			Failure = 0x00,
+			Success = 0x01
+		} type = Type::Failure;
+
+		uint8_t* payload = nullptr;
+		size_t size = 0;
+
+		bool done = false;
+
+		operator bool() const {
+			return done && type == Type::Success;
+		}
+	};
+
+	Response& sendRequest(const Request& request, std::chrono::milliseconds timeout = std::chrono::milliseconds(2000));
+	bool sendRequestNoResponse();
+
+	icsneo::Device::OpenStatusHandler logger; // Progress updates, set in flash()
+	Response lastResponse; // Last response received from sendRequest
+	bool supportsZynqBinaryFlasher = false; // Dictates how messages are formatted, this gets set in initialize()
+
+	std::vector<uint8_t> rxBuffer;
+	std::vector<uint8_t> txBuffer;
+	Chip targetChip; // Chip to flash
+
+	bool loadZips(const FWRepo& fw, std::vector<uint8_t>& chipSoftware);
+
+	bool initialize();
+	bool sanityCheck();
+	bool getBootloaderVersion();
+	bool validateChipVersion(const icsneo::DeviceAppVersion& srcVer);
+	virtual bool authenticate();
+	bool sendSoftware(const std::vector<uint8_t>& chipSoftware);
+	bool getProgrammingStatus(size_t sizeToValidate);
+	bool supportsFlashBuffer() const;
+public:
+	RADCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash);
+
+	bool enterApplication() override;
+	bool finalize() override;
+	bool flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) override;
+
+	bool open() override;
+	bool close() override;
+	bool hasFinalizationStep() const override;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_RADCOMMUNICATION_H_

include/icsneo/device/extensions/bootloader/communication/radmultichipcommunication.h

@@ -0,0 +1,37 @@
+#ifndef __BOOTLOADER_RADMULTICHIPCOMMUNICATION_H_
+#define __BOOTLOADER_RADMULTICHIPCOMMUNICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/radcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/application.h"
+
+#include <cstdint>
+#include <memory>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class RADMultiChipCommunication : public RADCommunication {
+private:
+	std::unique_ptr<Application> standardComm;
+	const bool doAuthChecks;
+	const uint8_t slot;
+	bool authenticate() override;
+public:
+	RADMultiChipCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash, bool auth, uint8_t slot = UINT8_MAX);
+
+	bool flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) override;
+	bool open() override;
+	bool close() override;
+	bool enterApplication() override;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_RADMULTICHIPCOMMUNICATION_H_

include/icsneo/device/extensions/bootloader/communication/radperiphcommunication.h

@@ -0,0 +1,96 @@
+#ifndef __BOOTLOADER_RADPERIPHCOMMUNICATION_H_
+#define __BOOTLOADER_RADPERIPHCOMMUNICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+#include "icsneo/device/extensions/bootloader/communication/bootloaderversion.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+
+#include <chrono>
+#include <cstdint>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The bootloader protocol used by peripheral chips on the RAD-Galaxy 2, tunneled through
+ * Command::PeripheralBootloader. Requests are the chip id, the Request and the arguments.
+ * Replies are a byte, ReplySuccess, then for bootloader requests ReplyAccepted, then the payload.
+ */
+class RADPeriphCommunication : public Communication {
+protected:
+	static constexpr size_t ReplySuccessOffset = 1;
+	static constexpr size_t ReplyAcceptedOffset = 2;
+	static constexpr uint8_t ReplySuccess = 0x01;
+	static constexpr uint8_t ReplyAccepted = 0x77;
+	static constexpr size_t ReplyHeaderSize = 3;
+	// Requests that write to the bootloader have three leading zero bytes before their arguments
+	static constexpr size_t BootloaderArgsOffset = 3;
+	// Flash sectors are sent as two requests, the first with this many bytes and the second with the rest
+	static constexpr size_t FlashSectorFirstChunkSize = 1024;
+
+	enum class Mode : uint8_t {
+		NoAnswer = 0x00u,
+		MainApplication = 0xAFu,
+		Bootloader = 0xFEu
+	} mode = Mode::NoAnswer;
+
+	Chip targetChip;
+	uint32_t serialNumber = 0;
+public:
+	enum class Request : uint8_t {
+		SwitchToApp = 0x01u,
+		SwitchToBootloader = 0x02u,
+		Version = 0x12u,
+		Authenticate = 0x13u,
+		FlashSector = 0x14u,
+		FirmwareValidate = 0x16u,
+		Erase = 0x20u,
+		Echo = 0xAFu,
+		Mode = 0xADu,
+	};
+
+	struct Response {
+		bool success = false;
+		std::vector<uint8_t> data;
+
+		operator bool() const {
+			return success;
+		}
+	};
+
+	bool waitForConnect(std::chrono::milliseconds timeout = std::chrono::milliseconds(30000));
+
+	bool sendRequestNoResponse(Request req, std::vector<uint8_t>&& args = {});
+	bool sendRequestNoResponse(Request req, ChipID id, std::vector<uint8_t>&& args = {});
+	Response sendRequest(Request req, std::vector<uint8_t>&& args = {}, std::chrono::milliseconds timeout = std::chrono::milliseconds(2000));
+	Response sendRequest(Request req, ChipID id, std::vector<uint8_t>&& args = {}, std::chrono::milliseconds timeout = std::chrono::milliseconds(2000));
+
+	Mode getMode();
+	bool sendPeriphTest();
+	bool readSerialNumber();
+	bool authenticate();
+	bool validateFirmware();
+	bool flashSector(const IEF::Sector& sector);
+
+	RADPeriphCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash);
+	~RADPeriphCommunication();
+
+	bool flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) override;
+	bool open() override;
+	bool close() override;
+	bool enterApplication() override;
+	bool finalize() override;
+	bool hasFinalizationStep() const override;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_RADPERIPHCOMMUNICATION_H_

include/icsneo/device/extensions/bootloader/communication/red.h

@@ -0,0 +1,72 @@
+#ifndef __BOOTLOADER_RED_H_
+#define __BOOTLOADER_RED_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/redbase.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The bootloader communication protocol used for non-FPGA
+ * chips on neoVI and ValueCAN devices.
+ *
+ * Zynq doesn't count as an FPGA chip for the sake of
+ * this, so it's handled here.
+ */
+class REDCommunication : public REDCommunicationBase {
+public:
+	REDCommunication(icsneo::Device& dev, const ChipInfo& chip, bool auth, bool encryptWithDeviceKey = true);
+	bool enterApplication() override { return sendCommand(uint8_t(Command::EnterApplication)); }
+	bool flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) override;
+	bool open() override;
+
+private:
+	const bool doAuthChecks;
+	const bool encryptFirmwareWithDeviceKey;
+	size_t blockSize = 2048;
+
+	enum class Command : uint8_t {
+		GetVersion = 0x12,
+		Authenticate = 0x13,
+		Flash = 0x14,
+		ValidateFirmware = 0x16,
+		Erase = 0x20,
+		EnterApplication = 0x21,
+		ValidateSWVersion = 0x27,
+	};
+
+	// The reply to Command::GetVersion
+	struct VersionResponse {
+		uint8_t bl_major, bl_minor, app_major, app_minor, flags, prod_id;
+		uint8_t hardware_rev_major, hardware_rev_minor;
+		uint8_t man_day, man_month;
+		uint16_t man_year;
+		uint8_t serial_num[8];
+		uint16_t block_size;
+		uint8_t last_error_code;
+		uint8_t pad_byte;
+
+		static constexpr size_t EncodedSize = 24;
+
+		VersionResponse() = default;
+		VersionResponse(const REDPacketizer::RxFrame& r);
+	} currentVersion;
+
+	// Called from open()
+	bool authenticate(bool firstTime = true);
+	bool getVersion();
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_RED_H_

include/icsneo/device/extensions/bootloader/communication/redbase.h

@@ -0,0 +1,66 @@
+#ifndef __BOOTLOADER_REDBASE_H_
+#define __BOOTLOADER_REDBASE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+#include "icsneo/device/extensions/bootloader/communication/redpacketizer.h"
+
+#include <chrono>
+#include <cstdint>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * Implementation shared by REDCommunication and REDCoreCommunication
+ *
+ * Requests are framed as:
+ *   uint8_t  REDPacketizer::Magic
+ *   uint16_t chip id (little-endian)
+ *   uint16_t length of the command byte, arguments and padding (little-endian)
+ *   uint8_t  command
+ *   uint8_t  arguments[]
+ *   uint8_t  optional PaddingByte, see sendCommandRaw()
+ */
+class REDCommunicationBase : public Communication {
+public:
+	REDCommunicationBase(icsneo::Device& dev, const ChipInfo& chip);
+	~REDCommunicationBase() {
+		// This must happen before the Packetizer is destroyed
+		device.com->resumeReads();
+	}
+
+	bool open() override;
+	bool close() override;
+	bool hasFinalizationStep() const override {
+		return false;
+	}
+	bool finalize() override {
+		return true;
+	}
+
+protected:
+	static constexpr uint8_t PaddingByte = 0x55;
+
+	Chip targetChip;
+
+	std::vector<REDPacketizer::RxFrame> lastData;
+	REDPacketizer rp;
+
+	bool handleData();
+	bool sendCommand(uint8_t cmd, std::chrono::seconds timeout, bool clearLastResponse = true) { return sendCommand(cmd, {}, timeout, clearLastResponse); }
+	bool sendCommand(uint8_t cmd, std::vector<uint8_t> args = {}, std::chrono::seconds timeout = std::chrono::seconds(1), bool clearLastResponse = true);
+	virtual bool sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args = {});
+	bool waitForRx(std::chrono::milliseconds timeout);
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_REDBASE_H_

include/icsneo/device/extensions/bootloader/communication/redcore.h

@@ -0,0 +1,54 @@
+#ifndef __BOOTLOADER_REDCORE_H_
+#define __BOOTLOADER_REDCORE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/redbase.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The bootloader communication protocol used for FPGA
+ * chips on neoVI and ValueCAN devices.
+ *
+ * Zynq doesn't count as an FPGA chip for the sake of
+ * this, it's just targetting the non-hybrid FPGAs.
+ *
+ * This was previously called FIRE 2 Core Flasher, but
+ * it does more than just FIRE 2 nowadays.
+ */
+class REDCoreCommunication : public REDCommunicationBase {
+public:
+	using REDCommunicationBase::REDCommunicationBase;
+
+	bool enterApplication() override { return false; }
+	bool flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) override;
+private:
+	/**
+	 * Core flasher commands are tunneled through a RED request using CoreFlasherCommand,
+	 * the arguments are CoreFlasherMagic, a 16-bit little-endian length, then the core command and its arguments
+	 */
+	static constexpr uint8_t CoreFlasherCommand = 0xCD;
+	static constexpr uint8_t CoreFlasherMagic = 0xEF;
+
+	enum class Command : uint8_t {
+		SendFirmware = 0,
+		StartFirmwareFlash = 1,
+		GetFlashProgress = 2,
+	};
+
+	bool sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args = {}) override;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_REDCORE_H_

include/icsneo/device/extensions/bootloader/communication/redpacketizer.h

@@ -0,0 +1,56 @@
+#ifndef __BOOTLOADER_REDPACKETIZER_H_
+#define __BOOTLOADER_REDPACKETIZER_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/core/ringbuffer.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * Splits bytes from a RED bootloader into frames:
+ *   uint8_t  Magic
+ *   uint8_t  Response
+ *   uint16_t length (little-endian)
+ *   uint8_t  data[length]
+ */
+class REDPacketizer {
+public:
+	static constexpr uint8_t Magic = 0xAA;
+
+	enum class Response : uint8_t {
+		Accepted = 0x77,
+		Rejected = 0x7F,
+	};
+
+	struct RxFrame {
+		uint16_t len = 0;
+		Response resp = Response::Rejected;
+		std::vector<uint8_t> data;
+		bool done = false;
+	};
+
+	/**
+	 * Call with bytes received from the device.
+	 * The returned boolean indicates if there is output waiting in output()
+	 */
+	bool input(icsneo::RingBuffer& bytes);
+	std::vector<RxFrame> output();
+private:
+	enum ReadState { HEADER, CMD, LENGTH_LOWER, LENGTH_UPPER, DATA };
+	ReadState state = HEADER;
+	std::vector<RxFrame> working;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_REDPACKETIZER_H_

include/icsneo/device/extensions/bootloader/parser/fwbin.h

@@ -0,0 +1,74 @@
+#ifndef __BOOTLOADER_FWBIN_H_
+#define __BOOTLOADER_FWBIN_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+
+#include <cstdint>
+#include <fstream>
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWBin : public FWRepo {
+public:
+	FWBin() = default;
+
+	bool load(const std::string& path);
+
+	const FirmwareSourceVersion& getVersion() const override { return version; }
+	bool getFW(const std::string& iefName, std::vector<uint8_t>& fw) const override;
+	std::optional<icsneo::DeviceAppVersion> getChipVersion(const std::string& iefName) const override;
+
+	static uint32_t HashDjb2(const std::string& str);
+
+private:
+	static constexpr const uint32_t SignatureHash = 0;
+
+	struct VersionTags {
+		const char* majorTag = nullptr;
+		const char* minorTag = nullptr;
+
+		operator bool() const {
+			return majorTag && minorTag;
+		}
+	};
+
+	static VersionTags GetVersionTags(const std::string& iefName);
+
+	struct TagData {
+		enum class Type : uint8_t {
+			DataBytes = 0,
+			DataLength = 1,
+			IEFVersion = 2,
+			Signature = 3,
+			Unknown = 0xFF
+		};
+
+		Type type = Type::Unknown;
+		std::streampos arrayPosition = 0;
+		uint32_t arrayLength = 0;
+
+		bool read(std::ifstream& stream, std::vector<uint8_t>& out) const;
+	};
+
+	bool readTag(const std::string& tag, std::vector<uint8_t>& out) const;
+
+	mutable std::ifstream file;
+	FirmwareSourceVersion version;
+	std::map<uint32_t, TagData> tags;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_FWBIN_H_

include/icsneo/device/extensions/bootloader/parser/fwbundle.h

@@ -0,0 +1,45 @@
+#ifndef __BOOTLOADER_FWBUNDLE_H_
+#define __BOOTLOADER_FWBUNDLE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWBundle : public FWRepo {
+public:
+	FWBundle() = default;
+
+	bool load(const std::string& path);
+	static bool IsFWBundle(const std::string& path);
+
+	const FirmwareSourceVersion& getVersion() const override { return version; }
+	bool getFW(const std::string& iefName, std::vector<uint8_t>& fw) const override;
+	std::optional<icsneo::DeviceAppVersion> getChipVersion(const std::string& iefName) const override;
+
+private:
+	struct ChipBinary {
+		std::vector<uint8_t> data;
+		FirmwareSourceVersion version;
+	};
+
+	FirmwareSourceVersion version;
+	std::unordered_map<uint32_t, ChipBinary> binaries;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_FWBUNDLE_H_

include/icsneo/device/extensions/bootloader/parser/fwloader.h

@@ -0,0 +1,27 @@
+#ifndef __BOOTLOADER_FWLOADER_H_
+#define __BOOTLOADER_FWLOADER_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+
+#include <memory>
+#include <string>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWLoader {
+public:
+	// Detects whether the file is a firmware bundle or a fw.bin and loads it, returns nullptr on failure
+	static std::unique_ptr<FWRepo> Load(const std::string& path);
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_FWLOADER_H_

include/icsneo/device/extensions/bootloader/parser/fwrepo.h

@@ -0,0 +1,34 @@
+#ifndef __BOOTLOADER_FWREPO_H_
+#define __BOOTLOADER_FWREPO_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/version.h"
+#include "icsneo/device/deviceversion.h"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWRepo {
+public:
+	FWRepo() = default;
+	virtual ~FWRepo() = default;
+
+	virtual bool getFW(const std::string& iefName, std::vector<uint8_t>& fw) const = 0;
+	virtual std::optional<icsneo::DeviceAppVersion> getChipVersion(const std::string& iefName) const = 0;
+	virtual const FirmwareSourceVersion& getVersion() const = 0;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_FWREPO_H_

include/icsneo/device/extensions/bootloader/parser/fwzip.h

@@ -0,0 +1,37 @@
+#ifndef __BOOTLOADER_FWZIP_H_
+#define __BOOTLOADER_FWZIP_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class ZipHandle;
+
+class FWZip {
+private:
+	std::unique_ptr<ZipHandle> handle;
+	std::vector<uint8_t> zipData;
+	std::optional<size_t> uncompressedSize = std::nullopt;
+public:
+	FWZip(std::vector<uint8_t>&& tagData);
+	~FWZip();
+
+	std::optional<size_t> size() const { return uncompressedSize; }
+	bool readAll(uint8_t* out);
+	bool readAll(std::vector<uint8_t>& out);
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_FWZIP_H_

include/icsneo/device/extensions/bootloader/parser/ief.h

@@ -0,0 +1,47 @@
+#ifndef __BOOTLOADER_IEF_H_
+#define __BOOTLOADER_IEF_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/bytesview.h"
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class IEF {
+public:
+	struct Version {
+		uint8_t appMajor;
+		uint8_t appMinor;
+		uint8_t prodId;
+		uint8_t chipId;
+	};
+	using Sector = std::pair<uint32_t, BytesView>;
+
+	IEF() = default;
+
+	bool load(std::vector<uint8_t>&& bytes);
+
+	const Version& getVersion() const { return version; }
+	const std::vector<Sector>& getSectors() const { return sectors; }
+	// IEFs are comprised of equally sized blocks of data - take the size of the first
+	uint32_t getBlockSize() const { return sectors.empty() ? 0 : static_cast<uint32_t>(sectors.front().second.size()); }
+
+private:
+	std::vector<uint8_t> data;
+	Version version = {};
+	std::vector<Sector> sectors;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_IEF_H_

include/icsneo/device/extensions/bootloader/platform/logging.h

@@ -0,0 +1,28 @@
+#ifndef __BOOTLOADER_LOGGING_H_
+#define __BOOTLOADER_LOGGING_H_
+
+#ifdef __cplusplus
+
+#include <string>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+namespace Log {
+
+void Trace(const std::string& subject, const std::string& msg);
+void Debug(const std::string& subject, const std::string& msg);
+void Info(const std::string& subject, const std::string& msg);
+void Warning(const std::string& subject, const std::string& msg);
+void Error(const std::string& subject, const std::string& msg);
+
+} // namespace Log
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_LOGGING_H_

include/icsneo/device/extensions/bootloader/version.h

@@ -0,0 +1,32 @@
+#ifndef __BOOTLOADER_VERSION_H_
+#define __BOOTLOADER_VERSION_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+#include <string>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * Tracks the Vehicle Spy 3 version that a firmware
+ * package is intended for.
+ */
+struct FirmwareSourceVersion {
+	using ValueType = uint8_t;
+	ValueType major = 0;
+	ValueType minor = 0;
+	ValueType release = 0;
+	ValueType build = 0;
+	bool load(const std::string& toParse);
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_VERSION_H_

include/icsneo/device/extensions/builtin.h.template

@@ -1,17 +0,0 @@
-#ifndef __ICSNEO_DEVICE_EXTENSIONS_BUILTIN_H_
-#define __ICSNEO_DEVICE_EXTENSIONS_BUILTIN_H_
-
-@LIBICSNEO_EXT_CODE_INCS@
-#include "icsneo/device/device.h"
-#include <memory>
-
-namespace icsneo {
-
-static void AddBuiltInExtensionsTo(const std::shared_ptr<icsneo::Device>& device) {
-	(void)device; // [[maybe_unused]]
-	@LIBICSNEO_EXT_CODE@
-}
-
-}
-
-#endif

include/icsneo/device/idevicesettings.h

@@ -1205,143 +1205,32 @@ public:
 		return std::nullopt;
 	}
 
-	virtual std::optional<bool> isT1SPLCAEnabledFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SPLCAFor(Network net, bool enable) {
-		(void)net; (void)enable;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SLocalIDFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SLocalIDFor(Network net, uint8_t id) {
-		(void)net; (void)id;
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SMaxNodesFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SMaxNodesFor(Network net, uint8_t nodes) {
-		(void)net; (void)nodes;
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1STxOppTimerFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1STxOppTimerFor(Network net, uint8_t timer) {
-		(void)net; (void)timer;
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SMaxBurstFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SMaxBurstFor(Network net, uint8_t burst) {
-		(void)net; (void)burst;
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SBurstTimerFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SBurstTimerFor(Network net, uint8_t timer) {
-		(void)net; (void)timer;
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SLocalIDAlternateFor(Network net, uint8_t id) {
-		(void)net; (void)id;
-		return false;
-	}
-
-	virtual std::optional<bool> isT1STerminationEnabledFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1STerminationFor(Network net, bool enable) {
-		(void)net; (void)enable;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-
-	virtual std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SBusDecodingBeaconsFor(Network net, bool enable) {
-		(void)net; (void)enable;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-
-	virtual std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SBusDecodingAllFor(Network net, bool enable) {
-		(void)net; (void)enable;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const {
-		(void)net;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) {
-		(void)net; (void)mask;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-
-	virtual std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const {
-		(void)net; (void)index;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) {
-		(void)net; (void)index; (void)id;
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
+	// 10BASE-T1S. Devices expose a network by overriding getT1SSettingsFor / getT1SSettingsExtFor.
+	// Every field in the mapped struct is readable; a null accessor means the network has no T1S block.
+	std::optional<bool> isT1SPLCAEnabledFor(Network net) const;
+	bool setT1SPLCAFor(Network net, bool enable);
+	std::optional<uint8_t> getT1SLocalIDFor(Network net) const;
+	bool setT1SLocalIDFor(Network net, uint8_t id);
+	std::optional<uint8_t> getT1SMaxNodesFor(Network net) const;
+	bool setT1SMaxNodesFor(Network net, uint8_t nodes);
+	std::optional<uint8_t> getT1STxOppTimerFor(Network net) const;
+	bool setT1STxOppTimerFor(Network net, uint8_t timer);
+	std::optional<uint8_t> getT1SMaxBurstFor(Network net) const;
+	bool setT1SMaxBurstFor(Network net, uint8_t burst);
+	std::optional<uint8_t> getT1SBurstTimerFor(Network net) const;
+	bool setT1SBurstTimerFor(Network net, uint8_t timer);
+	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const;
+	bool setT1SLocalIDAlternateFor(Network net, uint8_t id);
+	std::optional<bool> isT1STerminationEnabledFor(Network net) const;
+	bool setT1STerminationFor(Network net, bool enable);
+	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const;
+	bool setT1SBusDecodingBeaconsFor(Network net, bool enable);
+	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const;
+	bool setT1SBusDecodingAllFor(Network net, bool enable);
+	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const;
+	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask);
+	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const;
+	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id);
 
 	virtual std::optional<bool> isPerfTestEnabled() const {
 		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
@@ -1427,6 +1316,28 @@ protected:
 		return reinterpret_cast<ICSNEO_UNALIGNED(uint64_t*)>((void*)(settings.data() + (offset - settingsInDeviceRAM.data())));
 	}
 
+	// Pointer into the device RAM image. Override per device. Unknown networks return nullptr
+	// and do not report; the public T1S methods report SettingNotAvaiableDevice.
+	virtual const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const { (void)net; return nullptr; }
+	ETHERNET10T1S_SETTINGS* getMutableT1SSettingsFor(Network net) {
+		if(disabled || readonly)
+			return nullptr;
+		const uint8_t* offset = reinterpret_cast<const uint8_t*>(getT1SSettingsFor(net));
+		if(offset == nullptr)
+			return nullptr;
+		return reinterpret_cast<ETHERNET10T1S_SETTINGS*>(settings.data() + (offset - settingsInDeviceRAM.data()));
+	}
+
+	virtual const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const { (void)net; return nullptr; }
+	ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
+		if(disabled || readonly)
+			return nullptr;
+		const uint8_t* offset = reinterpret_cast<const uint8_t*>(getT1SSettingsExtFor(net));
+		if(offset == nullptr)
+			return nullptr;
+		return reinterpret_cast<ETHERNET10T1S_SETTINGS_EXT*>(settings.data() + (offset - settingsInDeviceRAM.data()));
+	}
+
 	static bool SetNetworkEnabled(uint64_t* bitfields, size_t count, uint64_t networkID) {
 		const size_t index = networkID / 64;
 		const size_t offset = networkID & 0x3F;

include/icsneo/device/tree/neovifire3t1slin/neovifire3t1slinsettings.h

@@ -269,215 +269,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isT1SPLCAEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA) != 0);
-	}
-
-	bool setT1SPLCAFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SLocalIDFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->local_id);
-	}
-
-	bool setT1SLocalIDFor(Network net, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->local_id = id;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxNodesFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->max_num_nodes);
-	}
-
-	bool setT1SMaxNodesFor(Network net, uint8_t nodes) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->max_num_nodes = nodes;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1STxOppTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->to_timer);
-	}
-
-	bool setT1STxOppTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->to_timer = timer;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxBurstFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->max_burst_count);
-	}
-
-	bool setT1SMaxBurstFor(Network net, uint8_t burst) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->max_burst_count = burst;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SBurstTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->burst_timer);
-	}
-
-	bool setT1SBurstTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->burst_timer = timer;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->local_id_alternate);
-	}
-
-	bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->local_id_alternate = id;
-		return true;
-	}
-
-	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
-	}
-
-	bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
-		
-		return true;
-	}
-
-	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
-	}
-
-	bool setT1SBusDecodingAllFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
-		
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1sExt->enable_multi_id);
-	}
-
-	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
-		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return false;
-		
-		t1sExt->enable_multi_id = mask;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
-		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return std::nullopt;
-		
-		if(index >= 7) {
-			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-			return std::nullopt;
-		}
-		
-		return std::make_optional(t1sExt->multi_id[index]);
-	}
-
-	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return false;
-		
-		if(index >= 7) {
-			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-			return false;
-		}
-		
-		t1sExt->multi_id[index] = id;
-		return true;
-	}
-
 	std::optional<bool> isPerfTestEnabled() const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
 		if(cfg == nullptr)
@@ -496,11 +287,10 @@ public:
 	}
 
 private:
-	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
+	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
 		switch(net.getNetID()) {
 			case Network::NetID::AE_01: return &(cfg->t1s1);
 			case Network::NetID::AE_02: return &(cfg->t1s2);
@@ -510,69 +300,24 @@ private:
 			case Network::NetID::AE_06: return &(cfg->t1s6);
 			case Network::NetID::AE_07: return &(cfg->t1s7);
 			case Network::NetID::AE_08: return &(cfg->t1s8);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
+			default: return nullptr;
 		}
 	}
 
-	ETHERNET10T1S_SETTINGS* getMutableT1SSettingsFor(Network net) {
-		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
-		if(cfg == nullptr)
-			return nullptr;
-		
-		switch(net.getNetID()) {
-			case Network::NetID::AE_01: return &(cfg->t1s1);
-			case Network::NetID::AE_02: return &(cfg->t1s2);
-			case Network::NetID::AE_03: return &(cfg->t1s3);
-			case Network::NetID::AE_04: return &(cfg->t1s4);
-			case Network::NetID::AE_05: return &(cfg->t1s5);
-			case Network::NetID::AE_06: return &(cfg->t1s6);
-			case Network::NetID::AE_07: return &(cfg->t1s7);
-			case Network::NetID::AE_08: return &(cfg->t1s8);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
-		}
-	}
-
-	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const {
+	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
 		switch(net.getNetID()) {
-			case Network::NetID::AE_03: return &(cfg->t1s1Ext);
-			case Network::NetID::AE_04: return &(cfg->t1s2Ext);
-			case Network::NetID::AE_05: return &(cfg->t1s3Ext);
-			case Network::NetID::AE_06: return &(cfg->t1s4Ext);
-			case Network::NetID::AE_07: return &(cfg->t1s5Ext);
-			case Network::NetID::AE_08: return &(cfg->t1s6Ext);
-			case Network::NetID::AE_09: return &(cfg->t1s7Ext);
-			case Network::NetID::AE_10: return &(cfg->t1s8Ext);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
-		}
-	}
-
-	ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
-		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
-		if(cfg == nullptr)
-			return nullptr;
-		
-		switch(net.getNetID()) {
-			case Network::NetID::AE_03: return &(cfg->t1s1Ext);
-			case Network::NetID::AE_04: return &(cfg->t1s2Ext);
-			case Network::NetID::AE_05: return &(cfg->t1s3Ext);
-			case Network::NetID::AE_06: return &(cfg->t1s4Ext);
-			case Network::NetID::AE_07: return &(cfg->t1s5Ext);
-			case Network::NetID::AE_08: return &(cfg->t1s6Ext);
-			case Network::NetID::AE_09: return &(cfg->t1s7Ext);
-			case Network::NetID::AE_10: return &(cfg->t1s8Ext);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
+			case Network::NetID::AE_01: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_02: return &(cfg->t1s2Ext);
+			case Network::NetID::AE_03: return &(cfg->t1s3Ext);
+			case Network::NetID::AE_04: return &(cfg->t1s4Ext);
+			case Network::NetID::AE_05: return &(cfg->t1s5Ext);
+			case Network::NetID::AE_06: return &(cfg->t1s6Ext);
+			case Network::NetID::AE_07: return &(cfg->t1s7Ext);
+			case Network::NetID::AE_08: return &(cfg->t1s8Ext);
+			default: return nullptr;
 		}
 	}
 

include/icsneo/device/tree/radargos/radargos.h

@@ -1,19 +1,19 @@
-#ifndef __RADGEMINI_H_
-#define __RADGEMINI_H_
+#ifndef __RADARGOS_H_
+#define __RADARGOS_H_
 
 #ifdef __cplusplus
 
 #include "icsneo/device/device.h"
 #include "icsneo/device/devicetype.h"
-#include "icsneo/device/tree/radgemini/radgeminisettings.h"
+#include "icsneo/device/tree/radargos/radargossettings.h"
 
 namespace icsneo {
 
-class RADGemini : public Device {
+class RADArgos : public Device {
 public:
 	// Serial numbers start with GE
 	// USB PID is 0x110E, standard driver is CDCACM
-	ICSNEO_FINDABLE_DEVICE(RADGemini, DeviceType::RADGemini, "GE");
+	ICSNEO_FINDABLE_DEVICE(RADArgos, DeviceType::RADArgos, "GE");
 
 	static const std::vector<Network>& GetSupportedNetworks() {
 		static std::vector<Network> supportedNetworks = {
@@ -28,11 +28,11 @@ public:
 
 	bool supportsTC10() const override { return true; }
 
-	ProductID getProductID() const override { return ProductID::RADGemini; }
+	ProductID getProductID() const override { return ProductID::RADArgos; }
 
 	const std::vector<ChipInfo>& getChipInfo() const override {
 		static std::vector<ChipInfo> chips = {
-			{ChipID::RADGemini_MCHIP, true, "MCHIP", "radgemini_mchip_ief", 0, FirmwareType::IEF},
+			{ChipID::RADArgos_MCHIP, true, "MCHIP", "radargos_mchip_ief", 0, FirmwareType::IEF},
 		};
 		return chips;
 	}
@@ -40,15 +40,15 @@ public:
 	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
 			.add<EnterBootloaderPhase>()
-			.add<FlashPhase>(ChipID::RADGemini_MCHIP, BootloaderCommunication::RED)
-			.add<EnterApplicationPhase>(ChipID::RADGemini_MCHIP)
+			.add<FlashPhase>(ChipID::RADArgos_MCHIP, BootloaderCommunication::RED)
+			.add<EnterApplicationPhase>(ChipID::RADArgos_MCHIP)
 			.add<ReconnectPhase>()
 			.add<WaitPhase>(std::chrono::milliseconds(3000));
 	}
 
 protected:
-	RADGemini(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
-		initialize<RADGeminiSettings>(makeDriver);
+	RADArgos(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		initialize<RADArgosSettings>(makeDriver);
 	}
 
 	void setupPacketizer(Packetizer& packetizer) override {
@@ -74,4 +74,4 @@ protected:
 
 #endif // __cplusplus
 
-#endif // __RADGEMINI_H_
+#endif // __RADARGOS_H_

include/icsneo/device/tree/radargos/radargossettings.h

@@ -1,5 +1,5 @@
-#ifndef LIBICSNEO_RADGEMINISETTINGS_H
-#define LIBICSNEO_RADGEMINISETTINGS_H
+#ifndef LIBICSNEO_RADARGOSSETTINGS_H
+#define LIBICSNEO_RADARGOSSETTINGS_H
 
 #include <stdint.h>
 #include "icsneo/device/idevicesettings.h"
@@ -31,18 +31,18 @@ typedef struct {
 		uint16_t enableLatencyTest : 1;
 		uint16_t reserved : 15;
 	} flags; // 2
-} radgemini_settings_t;
+} radargos_settings_t;
 #pragma pack(pop)
 
 #ifdef __cplusplus
 
-static_assert(sizeof(radgemini_settings_t) == 86, "RADGemini settings size mismatch");
+static_assert(sizeof(radargos_settings_t) == 86, "RADArgos settings size mismatch");
 
 #include <iostream>
 
-class RADGeminiSettings : public IDeviceSettings {
+class RADArgosSettings : public IDeviceSettings {
 public:
-	RADGeminiSettings(Device* device) : IDeviceSettings(device, sizeof(radgemini_settings_t)) {}
+	RADArgosSettings(Device* device) : IDeviceSettings(device, sizeof(radargos_settings_t)) {}
 };
 
 }
@@ -50,4 +50,4 @@ public:
 #endif // __cplusplus
 
 
-#endif // LIBICSNEO_RADGEMINISETTINGS_H
+#endif // LIBICSNEO_RADARGOSSETTINGS_H

include/icsneo/device/tree/radcomet2/radcomet2.h

@@ -70,6 +70,13 @@ public:
 	}
 
 protected:
+	const MACsecNetworkMap& getMACsecNetworkMap() const override {
+		static const MACsecNetworkMap networks = {
+			{Network::NetID::AE_01, 0},
+		};
+		return networks;
+	}
+
 	RADComet2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADComet2Settings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}

include/icsneo/device/tree/radcomet2/radcomet2settings.h

@@ -130,133 +130,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isT1SPLCAEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA) != 0);
-	}
-
-	bool setT1SPLCAFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SLocalIDFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->local_id);
-	}
-
-	bool setT1SLocalIDFor(Network net, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->local_id = id;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxNodesFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->max_num_nodes);
-	}
-
-	bool setT1SMaxNodesFor(Network net, uint8_t nodes) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->max_num_nodes = nodes;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1STxOppTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->to_timer);
-	}
-
-	bool setT1STxOppTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->to_timer = timer;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxBurstFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->max_burst_count);
-	}
-
-	bool setT1SMaxBurstFor(Network net, uint8_t burst) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->max_burst_count = burst;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SBurstTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->burst_timer);
-	}
-
-	bool setT1SBurstTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->burst_timer = timer;
-		return true;
-	}
-
-	std::optional<bool> isT1STerminationEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_TERMINATION) != 0);
-	}
-
-	bool setT1STerminationFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
-		
-		return true;
-	}
-
 	std::optional<bool> isPerfTestEnabled() const override {
 		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
@@ -274,32 +147,41 @@ public:
 		return true;
 	}
 
-private:
-	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
+	std::vector<TerminationGroup> getTerminationGroups() const override {
+		return {
+			{ Network(Network::NetID::DWCAN_01) },
+			{ Network(Network::NetID::DWCAN_02) }
+		};
+	}
+
+protected:
+	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
 		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
-		switch(net.getNetID()) {
-			case Network::NetID::AE_02: return &(cfg->t1s1);
-			case Network::NetID::AE_03: return &(cfg->t1s2);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
-		}
+		return &cfg->termination_enables;
 	}
 
-	ETHERNET10T1S_SETTINGS* getMutableT1SSettingsFor(Network net) {
-		auto cfg = getMutableStructurePointer<radcomet2_settings_t>();
+private:
+	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
 		switch(net.getNetID()) {
 			case Network::NetID::AE_02: return &(cfg->t1s1);
 			case Network::NetID::AE_03: return &(cfg->t1s2);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			default: return nullptr;
+		}
+	}
+
+	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const override {
+		auto cfg = getStructurePointer<radcomet2_settings_t>();
+		if(cfg == nullptr)
 			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::AE_02: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_03: return &(cfg->t1s2Ext);
+			default: return nullptr;
 		}
 	}
 

include/icsneo/device/tree/radcomet3/radcomet3.h

@@ -77,6 +77,13 @@ public:
 	}
 
 protected:
+	const MACsecNetworkMap& getMACsecNetworkMap() const override {
+		static const MACsecNetworkMap networks = {
+			{Network::NetID::AE_01, 0},
+		};
+		return networks;
+	}
+
 	RADComet3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADComet3Settings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}

include/icsneo/device/tree/radcomet3/radcomet3settings.h

@@ -165,215 +165,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isT1SPLCAEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA) != 0);
-	}
-
-	bool setT1SPLCAFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SLocalIDFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional(t1s->local_id);
-	}
-
-	bool setT1SLocalIDFor(Network net, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		t1s->local_id = id;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxNodesFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional(t1s->max_num_nodes);
-	}
-
-	bool setT1SMaxNodesFor(Network net, uint8_t nodes) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		t1s->max_num_nodes = nodes;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1STxOppTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional(t1s->to_timer);
-	}
-
-	bool setT1STxOppTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		t1s->to_timer = timer;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMaxBurstFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional(t1s->max_burst_count);
-	}
-
-	bool setT1SMaxBurstFor(Network net, uint8_t burst) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		t1s->max_burst_count = burst;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SBurstTimerFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-
-		return std::make_optional(t1s->burst_timer);
-	}
-
-	bool setT1SBurstTimerFor(Network net, uint8_t timer) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-
-		t1s->burst_timer = timer;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1s->local_id_alternate);
-	}
-
-	bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		t1s->local_id_alternate = id;
-		return true;
-	}
-
-	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
-	}
-
-	bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
-		
-		return true;
-	}
-
-	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
-	}
-
-	bool setT1SBusDecodingAllFor(Network net, bool enable) override {
-		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
-		if(t1s == nullptr)
-			return false;
-		
-		if(enable)
-			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
-		else
-			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
-		
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
-		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional(t1sExt->enable_multi_id);
-	}
-
-	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
-		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return false;
-		
-		t1sExt->enable_multi_id = mask;
-		return true;
-	}
-
-	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
-		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return std::nullopt;
-		
-		if(index >= 7) {
-			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-			return std::nullopt;
-		}
-		
-		return std::make_optional(t1sExt->multi_id[index]);
-	}
-
-	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
-		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
-		if(t1sExt == nullptr)
-			return false;
-		
-		if(index >= 7) {
-			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-			return false;
-		}
-		
-		t1sExt->multi_id[index] = id;
-		return true;
-	}
-
 	bool setPhyRoleFor(Network net, AELinkMode mode) override {
 		if (mode != AE_LINK_AUTO && mode != AE_LINK_MASTER && mode != AE_LINK_SLAVE) {
 			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
@@ -668,12 +459,26 @@ public:
 		return true;
 	}
 
+	std::vector<TerminationGroup> getTerminationGroups() const override {
+		return {
+			{ Network(Network::NetID::DWCAN_01) },
+			{ Network(Network::NetID::DWCAN_02) }
+		};
+	}
+
+protected:
+	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
+		auto cfg = getStructurePointer<radcomet3_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		return &cfg->termination_enables;
+	}
+
 private:
-	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
+	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<radcomet3_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-
 		switch(net.getNetID()) {
 			case Network::NetID::AE_02: return &(cfg->t1s1);
 			case Network::NetID::AE_03: return &(cfg->t1s2);
@@ -681,35 +486,14 @@ private:
 			case Network::NetID::AE_05: return &(cfg->t1s4);
 			case Network::NetID::AE_06: return &(cfg->t1s5);
 			case Network::NetID::AE_07: return &(cfg->t1s6);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
+			default: return nullptr;
 		}
 	}
 
-	ETHERNET10T1S_SETTINGS* getMutableT1SSettingsFor(Network net) {
-		auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
-		if(cfg == nullptr)
-			return nullptr;
-
-		switch(net.getNetID()) {
-			case Network::NetID::AE_02: return &(cfg->t1s1);
-			case Network::NetID::AE_03: return &(cfg->t1s2);
-			case Network::NetID::AE_04: return &(cfg->t1s3);
-			case Network::NetID::AE_05: return &(cfg->t1s4);
-			case Network::NetID::AE_06: return &(cfg->t1s5);
-			case Network::NetID::AE_07: return &(cfg->t1s6);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
-		}
-	}
-
-	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const {
+	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const override {
 		auto cfg = getStructurePointer<radcomet3_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
 		switch(net.getNetID()) {
 			case Network::NetID::AE_02: return &(cfg->t1s1Ext);
 			case Network::NetID::AE_03: return &(cfg->t1s2Ext);
@@ -717,27 +501,7 @@ private:
 			case Network::NetID::AE_05: return &(cfg->t1s4Ext);
 			case Network::NetID::AE_06: return &(cfg->t1s5Ext);
 			case Network::NetID::AE_07: return &(cfg->t1s6Ext);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
-		}
-	}
-
-	ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
-		auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
-		if(cfg == nullptr)
-			return nullptr;
-		
-		switch(net.getNetID()) {
-			case Network::NetID::AE_02: return &(cfg->t1s1Ext);
-			case Network::NetID::AE_03: return &(cfg->t1s2Ext);
-			case Network::NetID::AE_04: return &(cfg->t1s3Ext);
-			case Network::NetID::AE_05: return &(cfg->t1s4Ext);
-			case Network::NetID::AE_06: return &(cfg->t1s5Ext);
-			case Network::NetID::AE_07: return &(cfg->t1s6Ext);
-			default:
-				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-				return nullptr;
+			default: return nullptr;
 		}
 	}
 

include/icsneo/device/tree/radgigastar/radgigastar.h

@@ -41,7 +41,8 @@ public:
 			{ChipID::SFPModule_88q2221_MCHIP, true, "SFP-MV2221M", "sfp_mv2221m_b2_mchip_ief", 3, FirmwareType::IEF},
 			{ChipID::SFPModule_lan8670_MCHIP, true, "SFP-MC8670", "sfp_module_lan8670_ief", 3, FirmwareType::IEF},
 			{ChipID::SFPModule_88q3244_MCHIP, true, "SFP-MV3244", "sfp_module_88q3244_ief", 3, FirmwareType::IEF},
-			{ChipID::SFPModule_ent11100_MCHIP, true, "SFP-EN11100", "sfp_module_ent11100_ief", 3, FirmwareType::IEF}
+			{ChipID::SFPModule_ent11100_MCHIP, true, "SFP-EN11100", "sfp_module_ent11100_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_ad1101_MCHIP, true, "SFP-AD1101", "sfp_module_adi1101_ief", 3, FirmwareType::IEF},
 		};
 		return chips;
 	}
@@ -87,9 +88,32 @@ public:
 				}
 
 				BootloaderPipeline pipeline;
+				auto compVersions = getComponentVersions();
 				for(size_t i = 0; i < chipVersions.size(); i++) {
 					const auto& version = chipVersions[i];
-					pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip, i == 0);
+					auto it = compVersions.begin();
+					std::vector<ComponentVersion> sameIdComponents;
+					while(it != compVersions.end()) {
+						it = std::find_if(it, compVersions.end(), [&version](const auto& component) { 
+							return (ChipID)component.identifier == version.id; 
+						});
+						if (it != compVersions.end()) {
+							sameIdComponents.push_back(*it);
+							it++;
+						}
+					}
+					if (sameIdComponents.size() > 1) {
+						std::vector<ComponentVersion> tempCompVersions;
+						for (const auto& component : compVersions) {
+							if ((ChipID)component.identifier != version.id || component.expansionSlot != sameIdComponents[0].expansionSlot) {
+								tempCompVersions.push_back(component);
+							}
+						}
+						compVersions = std::move(tempCompVersions);
+					}
+					if (!sameIdComponents.empty()) {
+						pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip, i == 0, true, true, sameIdComponents[0].expansionSlot);
+					}
 				}
 				pipeline.add<EnterApplicationPhase>(mainChipID);
 				pipeline.add<WaitPhase>(std::chrono::milliseconds(3000));