Bindings: Python: Migrate to smart_holder

Updates to 3.0.1 and switches to smart_holder & native_enum.

.gitlab-ci.yml

@@ -1,5 +1,6 @@
 variables:
   DEBIAN_FRONTEND: noninteractive
+  LIBICSNEO_ICSPB_REPO: https://gitlab-ci-token:${CI_JOB_TOKEN}@${LIBICSNEO_ICSPB_GIT}
 
 stages:
   - build
@@ -13,7 +14,7 @@ stages:
 build windows/x64:
   stage: build
   script:
-    - CMD.EXE /C ci\build-windows64.bat
+    - cmd /C ci\build-windows64.bat
   artifacts:
     when: always
     paths:
@@ -37,7 +38,7 @@ unit_test windows/x64:
 build windows/x86:
   stage: build
   script:
-    - CMD.EXE /C ci\build-windows32.bat
+    - cmd /C ci\build-windows32.bat
   artifacts:
     when: always
     paths:
@@ -67,7 +68,9 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y g++ ninja-build cmake libpcap-dev git
+    - apt install -y g++ ninja-build cmake libpcap-dev 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
   artifacts:
     when: always
@@ -93,7 +96,9 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y clang lld ninja-build cmake libpcap-dev git
+    - apt install -y clang lld ninja-build cmake libpcap-dev 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
   artifacts:
     when: always
@@ -175,7 +180,9 @@ unit_test linux/ubuntu/2404/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
+    - dnf install -y g++ libpcap-devel 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
   artifacts:
     when: always
@@ -209,7 +216,9 @@ unit_test linux/ubuntu/2404/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
+    - dnf install -y clang lld libpcap-devel 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
   artifacts:
     when: always
@@ -234,30 +243,6 @@ unit_test linux/ubuntu/2404/amd64/clang:
     - linux-build
   timeout: 5m
 
-build linux/fedora/41/amd64/gcc:
-  <<: *build_linux_fedora_gcc
-  image: fedora:41
-
-unit_test linux/fedora/41/amd64/gcc:
-  <<: *test_linux_fedora_gcc
-  image: fedora:41
-  dependencies:
-    - build linux/fedora/41/amd64/gcc
-  needs:
-    - build linux/fedora/41/amd64/gcc
-
-build linux/fedora/41/amd64/clang:
-  <<: *build_linux_fedora_clang
-  image: fedora:41
-
-unit_test linux/fedora/41/amd64/clang:
-  <<: *test_linux_fedora_clang
-  image: fedora:41
-  dependencies:
-    - build linux/fedora/41/amd64/clang
-  needs:
-    - build linux/fedora/41/amd64/clang
-
 build linux/fedora/42/amd64/gcc:
   <<: *build_linux_fedora_gcc
   image: fedora:42
@@ -282,6 +267,30 @@ unit_test linux/fedora/42/amd64/clang:
   needs:
     - build linux/fedora/42/amd64/clang
 
+build linux/fedora/43/amd64/gcc:
+  <<: *build_linux_fedora_gcc
+  image: fedora:43
+
+unit_test linux/fedora/43/amd64/gcc:
+  <<: *test_linux_fedora_gcc
+  image: fedora:43
+  dependencies:
+    - build linux/fedora/43/amd64/gcc
+  needs:
+    - build linux/fedora/43/amd64/gcc
+
+build linux/fedora/43/amd64/clang:
+  <<: *build_linux_fedora_clang
+  image: fedora:43
+
+unit_test linux/fedora/43/amd64/clang:
+  <<: *test_linux_fedora_clang
+  image: fedora:43
+  dependencies:
+    - build linux/fedora/43/amd64/clang
+  needs:
+    - build linux/fedora/43/amd64/clang
+
 #-------------------------------------------------------------------------------
 # Python Module
 #-------------------------------------------------------------------------------
@@ -289,22 +298,13 @@ unit_test linux/fedora/42/amd64/clang:
 build python/linux/amd64:
   stage: build
   tags:
-    - linux-build
+    - linux-native-amd64
-  image: python:3.13
-  services:
-    - name: docker:dind
-      entrypoint: ["env", "-u", "DOCKER_HOST"]
-      command: ["dockerd-entrypoint.sh"]
   variables:
-    CIBW_BEFORE_ALL: yum install -y flex && sh ci/bootstrap-libpcap.sh
+    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: x86_64
-    DOCKER_HOST: unix:///var/run/docker.sock
-    DOCKER_DRIVER: overlay2
-    DOCKER_TLS_CERTDIR: ""
     CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install
   script:
-    - curl -sSL https://get.docker.com/ | sh
     - sh ci/build-wheel-posix.sh
   artifacts:
     paths:
@@ -315,7 +315,7 @@ build python/linux/arm64:
   tags:
     - arm64-linux-build
   variables:
-    CIBW_BEFORE_ALL: yum install -y flex && sh ci/bootstrap-libpcap.sh
+    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: aarch64
     CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install

99-intrepidcs.rules

@@ -3,24 +3,5 @@ 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"
 
-# neoVI ION/PLASMA PIDs are not in the latest ftdi_sio driver so lets make a
+ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", KERNEL=="ttyUSB*", \
-# rule to add it when we see a new unclaimed device.
+RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/ftdi_sio/unbind'"
-# PLASMA = 0x0801, ION = 0x0901
-ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
-        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0801", \
-        DRIVER=="", \
-        RUN+="/sbin/modprobe -b ftdi_sio"
-ACTION=="add", SUBSYSTEM=="drivers", \
-        ENV{DEVPATH}=="/bus/usb-serial/drivers/ftdi_sio", \
-        ATTR{new_id}="093c 0801"
-ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
-        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0901", \
-        DRIVER=="", \
-        RUN+="/sbin/modprobe -b ftdi_sio"
-ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
-        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="1000", \
-        DRIVER=="", \
-        RUN+="/sbin/modprobe -b ftdi_sio"
-ACTION=="add", SUBSYSTEM=="drivers", \
-        ENV{DEVPATH}=="/bus/usb-serial/drivers/ftdi_sio", \
-        ATTR{new_id}="093c 0901"

CMakeLists.txt

@@ -27,9 +27,8 @@ option(LIBICSNEO_ENABLE_DXX "Enable devices which communicate over D2XX/D3XX via
 
 option(LIBICSNEO_ENABLE_BINDINGS_PYTHON "Enable Python library" OFF)
 
-if(NOT CMAKE_CXX_STANDARD)
+set(CMAKE_CXX_STANDARD 17)
-	set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
-endif()
 
 include(GNUInstallDirs)
 
@@ -37,17 +36,13 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 # Enable Warnings
 if(MSVC)
-	# Force to always compile with W4
+	set(LIBICSNEO_COMPILER_WARNINGS /W4)
-	if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-		string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-	else()
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
-	endif()
 	# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html
 	# Still supported until a suitable replacement is standardized
 	add_definitions(-D_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
+	add_definitions(-D_ITERATOR_DEBUG_LEVEL=0)
 else() #if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-switch -Wno-unknown-pragmas")
+	set(LIBICSNEO_COMPILER_WARNINGS -Wall -Wno-switch -Wno-unknown-pragmas)
 endif()
 
 find_package(Threads REQUIRED)
@@ -200,7 +195,9 @@ set(SRC_FILES
 	communication/message/tc10statusmessage.cpp
 	communication/message/gptpstatusmessage.cpp
 	communication/message/ethernetstatusmessage.cpp
-	communication/message/macsecmessage.cpp
+	communication/message/networkmutexmessage.cpp
+	communication/message/clientidmessage.cpp
+	communication/message/transmitmessage.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
@@ -228,8 +225,9 @@ set(SRC_FILES
 	communication/communication.cpp
 	communication/driver.cpp
 	communication/livedata.cpp
-	communication/ringbuffer.cpp
+	core/ringbuffer.cpp
-	communication/crc32.cpp
+	core/crc32.cpp
+	core/macseccfg.cpp
 	device/extensions/flexray/extension.cpp
 	device/extensions/flexray/controller.cpp
 	device/idevicesettings.cpp
@@ -324,6 +322,7 @@ target_include_directories(icsneocpp
 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)
@@ -383,6 +382,21 @@ if(LIBICSNEO_ENABLE_RAW_ETHERNET)
 	endif(WIN32)
 endif(LIBICSNEO_ENABLE_RAW_ETHERNET)
 
+# protobuf
+if(DEFINED ENV{LIBICSNEO_ICSPB_REPO})
+	set(LIBICSNEO_ICSPB_REPO "$ENV{LIBICSNEO_ICSPB_REPO}")
+endif()
+if(NOT LIBICSNEO_ICSPB_REPO)
+	set(LIBICSNEO_ICSPB_REPO https://github.com/intrepidcs/icspb.git)
+endif()
+include(FetchContent)
+FetchContent_Declare(icspb
+	GIT_REPOSITORY ${LIBICSNEO_ICSPB_REPO}
+	GIT_TAG 48df5dd7fd0c38034f82a2f94e0eada404d5e2b9
+)
+FetchContent_MakeAvailable(icspb)
+target_link_libraries(icsneocpp PRIVATE icspb::icspb)
+
 if(LIBICSNEO_BUILD_ICSNEOC)
 	add_library(icsneoc SHARED api/icsneoc/icsneoc.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 	target_include_directories(icsneoc
@@ -394,6 +408,7 @@ if(LIBICSNEO_BUILD_ICSNEOC)
 	)
 	target_link_libraries(icsneoc PRIVATE icsneocpp)
 	target_compile_features(icsneoc PRIVATE cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
+	target_compile_options(icsneoc PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOC_STATIC)
@@ -408,6 +423,7 @@ if(LIBICSNEO_BUILD_ICSNEOC_STATIC)
 	target_link_libraries(icsneoc-static PUBLIC icsneocpp)
 	target_compile_features(icsneoc-static PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 	target_compile_definitions(icsneoc-static PUBLIC ICSNEOC_BUILD_STATIC)
+	target_compile_options(icsneoc-static PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOLEGACY)
@@ -426,6 +442,7 @@ if(LIBICSNEO_BUILD_ICSNEOLEGACY)
 	)
 	target_link_libraries(icsneolegacy PRIVATE icsneocpp)
 	target_compile_features(icsneolegacy PRIVATE cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
+	target_compile_options(icsneolegacy PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC)
@@ -445,6 +462,7 @@ if(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC)
 	target_link_libraries(icsneolegacy-static PUBLIC icsneocpp)
 	target_compile_features(icsneolegacy-static PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 	target_compile_definitions(icsneolegacy-static PUBLIC ICSNEOC_BUILD_STATIC)
+	target_compile_options(icsneolegacy-static PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 add_subdirectory(bindings)
@@ -475,6 +493,8 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/periodictest.cpp
 	)
 
+	target_compile_options(libicsneo-unit-tests PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
+
 	target_link_libraries(libicsneo-unit-tests gtest gtest_main)
 	target_link_libraries(libicsneo-unit-tests icsneocpp)
 
@@ -487,4 +507,4 @@ endif()
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-include(CPack)
+include(CPack)

README.md

@@ -27,6 +27,7 @@ each of the respective APIs.
 - RAD-EpsilonXL
 - RAD-Galaxy
 - RAD-Galaxy 2
+- RAD-Gemini
 - RAD-Gigastar
 - RAD-Gigastar 2
 - RAD-Moon 2

api/icsneocpp/event.cpp

@@ -156,6 +156,16 @@ static constexpr const char* VSA_BYTE_PARSE_FAILURE = "Failure to parse record b
 static constexpr const char* VSA_EXTENDED_MESSAGE_ERROR = "Failure to parse extended message record sequence";
 static constexpr const char* VSA_OTHER_ERROR = "Unknown error in VSA read API.";
 
+// MACSEC
+static constexpr const char* MACSEC_SECY_LIMIT = "Attempted to exceed the limit of SecY additions to this port";
+static constexpr const char* MACSEC_RULE_LIMIT = "Attempted to exceed the limit of rule additions to this port";
+static constexpr const char* MACSEC_SA_LIMIT = "Attempted to exceed the limit of SA additions to this port";
+static constexpr const char* MACSEC_INVALID_SECY_INDEX = "Attempted to access an invalid SecY index";
+static constexpr const char* MACSEC_INVALID_SA_INDEX = "Attempted to access an invalid SA index";
+static constexpr const char* MACSEC_INVALID_RULE_INDEX = "Attempted to access an invalid rule index";
+static constexpr const char* MACSEC_REKEY_NOT_ENABLED = "Attempted to set rekey SA when rekey was not enabled";
+static constexpr const char* MACSEC_NOT_SUPPORTED = "MACsec is not supported on this device";
+static constexpr const char* MACSEC_CONFIG_MISMATCH = "Attempted to configure device with a macsec configuration for a different device";
 // Servd
 static constexpr const char* SERVD_BIND_ERROR = "Error binding socket for Servd communication";
 static constexpr const char* SERVD_NONBLOCK_ERROR = "Error setting non-blocking mode for Servd socket";
@@ -371,6 +381,25 @@ const char* APIEvent::DescriptionForType(Type type) {
 		case Type::VSAOtherError:
 			return VSA_OTHER_ERROR;
 
+		// MACSEC
+		case Type::MACsecSecYLimit:
+			return MACSEC_SECY_LIMIT;
+		case Type::MACsecSaLimit:
+			return MACSEC_SA_LIMIT;
+		case Type::MACsecRuleLimit:
+			return MACSEC_RULE_LIMIT;
+		case Type::MACsecInvalidSecYIndex:
+			return MACSEC_INVALID_SECY_INDEX;
+		case Type::MACsecInvalidSaIndex:
+			return MACSEC_INVALID_SA_INDEX;
+		case Type::MACsecInvalidRuleIndex:
+			return MACSEC_INVALID_RULE_INDEX;
+		case Type::MACsecRekeyNotEnabled:
+			return MACSEC_REKEY_NOT_ENABLED;
+		case Type::MACsecNotSupported:
+			return MACSEC_NOT_SUPPORTED;
+		case Type::MACsecConfigMismatch:
+			return MACSEC_CONFIG_MISMATCH;
 		// Servd
 		case Type::ServdBindError:
 			return SERVD_BIND_ERROR;

api/icsneolegacy/icsneolegacy.cpp

@@ -90,6 +90,7 @@ static bool NeoMessageToSpyMessage(const neodevice_t* device, const neomessage_t
 		copyFrameData();
 		break;
 	case Network::Type::Ethernet:
+	case Network::Type::AutomotiveEthernet:
 		oldmsg.Protocol = SPY_PROTOCOL_ETHERNET;
 		oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF);
 		oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8);
@@ -1075,6 +1076,9 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_RADMOON3:
 		*pDeviceSettingsType = DeviceRADMoon3SettingsType;
 		break;
+	case NEODEVICE_RADGEMINI:
+		*pDeviceSettingsType = DeviceRADGeminiSettingsType;
+		break;
 	case NEODEVICE_RED2:
 		*pDeviceSettingsType = DeviceRed2SettingsType;
 		break;

bindings/python/CMakeLists.txt

@@ -9,7 +9,7 @@ else()
     FetchContent_Declare(
         pybind11
         GIT_REPOSITORY https://github.com/pybind/pybind11.git
-        GIT_TAG v2.13.6
+        GIT_TAG v3.0.1
     )
     FetchContent_MakeAvailable(pybind11)
 endif()
@@ -32,13 +32,15 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/gptpstatusmessage.cpp
     icsneopy/communication/message/ethernetstatusmessage.cpp
     icsneopy/communication/message/spimessage.cpp
-    icsneopy/communication/message/macsecmessage.cpp
     icsneopy/communication/message/scriptstatusmessage.cpp
     icsneopy/communication/message/ethphymessage.cpp
     icsneopy/communication/message/callback/messagecallback.cpp
     icsneopy/communication/message/filter/messagefilter.cpp
+    icsneopy/core/macseccfg.cpp
     icsneopy/flexray/flexray.cpp
     icsneopy/disk/diskdriver.cpp
+    icsneopy/device/chipid.cpp
+    icsneopy/device/versionreport.cpp
     icsneopy/device/device.cpp
     icsneopy/device/extensions/deviceextension.cpp
     icsneopy/device/idevicesettings.cpp

bindings/python/icsneopy/api/event.cpp

@@ -1,14 +1,15 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/api/event.h"
 
 namespace icsneo {
 
 void init_event(pybind11::module_& m) {
-	pybind11::class_<APIEvent, std::shared_ptr<APIEvent>> apiEvent(m, "APIEvent");
+	pybind11::classh<APIEvent> apiEvent(m, "APIEvent");
-	pybind11::enum_<APIEvent::Type>(apiEvent, "Type")
+	pybind11::native_enum<APIEvent::Type>(apiEvent, "Type", "enum.IntEnum")
 		.value("Any", APIEvent::Type::Any)
 		.value("InvalidNeoDevice", APIEvent::Type::InvalidNeoDevice)
 		.value("RequiredParameterNull", APIEvent::Type::RequiredParameterNull)
@@ -132,13 +133,15 @@ void init_event(pybind11::module_& m) {
 		.value("DXXErrorArg", APIEvent::Type::DXXErrorArg)
 		.value("NoErrorFound", APIEvent::Type::NoErrorFound)
 		.value("TooManyEvents", APIEvent::Type::TooManyEvents)
-		.value("Unknown", APIEvent::Type::Unknown);
+		.value("Unknown", APIEvent::Type::Unknown)
+		.finalize();
 
-		pybind11::enum_<APIEvent::Severity>(apiEvent, "Severity")
+		pybind11::native_enum<APIEvent::Severity>(apiEvent, "Severity", "enum.IntEnum")
 		.value("Any", APIEvent::Severity::Any)
 		.value("EventInfo", APIEvent::Severity::EventInfo)
 		.value("EventWarning", APIEvent::Severity::EventWarning)
-		.value("Error", APIEvent::Severity::Error);
+		.value("Error", APIEvent::Severity::Error)
+		.finalize();
 
 	apiEvent
 		.def("get_type", &APIEvent::getType)
@@ -147,7 +150,7 @@ void init_event(pybind11::module_& m) {
 		.def("describe", &APIEvent::describe)
 		.def("__repr__", &APIEvent::describe);
 
-	pybind11::class_<EventFilter, std::shared_ptr<EventFilter>>(m, "EventFilter")
+	pybind11::classh<EventFilter>(m, "EventFilter")
 		.def(pybind11::init())
 		.def(pybind11::init<APIEvent::Type>())
 		.def(pybind11::init<APIEvent::Severity>())

bindings/python/icsneopy/api/eventcallback.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_eventcallback(pybind11::module_& m) {
-	pybind11::class_<EventCallback>(m, "EventCallback")
+	pybind11::classh<EventCallback>(m, "EventCallback")
 		.def(pybind11::init<EventCallback::fn_eventCallback, EventFilter>())
 		.def(pybind11::init<EventCallback::fn_eventCallback>());
 }

bindings/python/icsneopy/api/eventmanager.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_eventmanager(pybind11::module_& m) {
-	pybind11::class_<EventManager>(m, "EventManager")
+	pybind11::classh<EventManager>(m, "EventManager")
 		.def_static("get_instance", &EventManager::GetInstance, pybind11::return_value_policy::reference)
 		.def("add_event_callback", &EventManager::addEventCallback)
 		.def("remove_event_callback", &EventManager::removeEventCallback)

bindings/python/icsneopy/api/version.cpp

@@ -9,7 +9,7 @@
 namespace icsneo {
 
 void init_version(pybind11::module_& m) {
-	pybind11::class_<neoversion_t>(m, "NeoVersion")
+	pybind11::classh<neoversion_t>(m, "NeoVersion")
 		.def_readonly("major", &neoversion_t::major)
 		.def_readonly("minor", &neoversion_t::minor)
 		.def_readonly("patch", &neoversion_t::patch)

bindings/python/icsneopy/communication/message/callback/messagecallback.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_messagecallback(pybind11::module_& m) {
-	pybind11::class_<MessageCallback, std::shared_ptr<MessageCallback>>(m, "MessageCallback")
+	pybind11::classh<MessageCallback>(m, "MessageCallback")
 		.def(pybind11::init<MessageCallback::fn_messageCallback, std::shared_ptr<MessageFilter>>());
 }
 

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

@@ -1,13 +1,14 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/message/canerrormessage.h"
 
 namespace icsneo {
 
 void init_errorcodes(pybind11::module_& m) {
-	pybind11::enum_<CANErrorCode>(m, "CANErrorCode")
+	pybind11::native_enum<CANErrorCode>(m, "CANErrorCode", "enum.IntEnum")
 		.value("NoError", CANErrorCode::NoError)
 		.value("StuffError", CANErrorCode::StuffError)
 		.value("FormError", CANErrorCode::FormError)
@@ -15,12 +16,13 @@ void init_errorcodes(pybind11::module_& m) {
 		.value("Bit1Error", CANErrorCode::Bit1Error)
 		.value("Bit0Error", CANErrorCode::Bit0Error)
 		.value("CRCError", CANErrorCode::CRCError)
-		.value("NoChange", CANErrorCode::NoChange);
+		.value("NoChange", CANErrorCode::NoChange)
+		.finalize();
 }
 
 void init_canerrormessage(pybind11::module_& m) {
 	init_errorcodes(m);
-	pybind11::class_<CANErrorMessage, std::shared_ptr<CANErrorMessage>, Message>(m, "CANErrorMessage")
+	pybind11::classh<CANErrorMessage, Message>(m, "CANErrorMessage")
 		.def_readonly("network", &CANErrorMessage::network)
 		.def_readonly("transmitErrorCount", &CANErrorMessage::transmitErrorCount)
 		.def_readonly("receiveErrorCount", &CANErrorMessage::receiveErrorCount)

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_canmessage(pybind11::module_& m) {
-	pybind11::class_<CANMessage, std::shared_ptr<CANMessage>, Frame>(m, "CANMessage")
+	pybind11::classh<CANMessage, Frame>(m, "CANMessage")
 		.def(pybind11::init())
 		.def_readwrite("arbid", &CANMessage::arbid)
 		.def_readwrite("dlcOnWire", &CANMessage::dlcOnWire)

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

@@ -7,11 +7,11 @@
 namespace icsneo {
 
 void init_ethernetmessage(pybind11::module_& m) {
-	pybind11::class_<MACAddress>(m, "MACAddress")
+	pybind11::classh<MACAddress>(m, "MACAddress")
 		.def("to_string", &MACAddress::toString)
 		.def("__repr__", &MACAddress::toString);
 	
-	pybind11::class_<EthernetMessage, std::shared_ptr<EthernetMessage>, Frame>(m, "EthernetMessage")
+	pybind11::classh<EthernetMessage, Frame>(m, "EthernetMessage")
 		.def(pybind11::init())
 		.def_readwrite("preemptionEnabled", &EthernetMessage::preemptionEnabled)
 		.def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags)

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_ethernetstatusmessage(pybind11::module_& m) {
-	pybind11::class_<EthernetStatusMessage, std::shared_ptr<EthernetStatusMessage>, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
+	pybind11::classh<EthernetStatusMessage, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
 
 	pybind11::enum_<EthernetStatusMessage::LinkSpeed>(ethernetStatusMessage, "LinkSpeed")
 		.value("LinkSpeedAuto", EthernetStatusMessage::LinkSpeed::LinkSpeedAuto)
@@ -22,7 +22,8 @@ void init_ethernetstatusmessage(pybind11::module_& m) {
 		.value("LinkModeAuto", EthernetStatusMessage::LinkMode::LinkModeAuto)
 		.value("LinkModeMaster", EthernetStatusMessage::LinkMode::LinkModeMaster)
 		.value("LinkModeSlave", EthernetStatusMessage::LinkMode::LinkModeSlave)
-		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid);
+		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid)
+		.value("LinkModeNone", EthernetStatusMessage::LinkMode::LinkModeNone);
 
 	ethernetStatusMessage
 		.def_readonly("network", &EthernetStatusMessage::network)

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

@@ -7,7 +7,17 @@
 namespace icsneo {
 
 void init_ethphymessage(pybind11::module_& m) {
-	pybind11::class_<PhyMessage, std::shared_ptr<PhyMessage>>(m, "PhyMessage")
+	pybind11::classh<Clause22Message>(m, "Clause22Message")
+		.def_readwrite("phyAddr", &Clause22Message::phyAddr)
+		.def_readwrite("page", &Clause22Message::page)
+		.def_readwrite("regAddr", &Clause22Message::regAddr)
+		.def_readwrite("regVal", &Clause22Message::regVal);
+	pybind11::classh<Clause45Message>(m, "Clause45Message")
+		.def_readwrite("port", &Clause45Message::port)
+		.def_readwrite("device", &Clause45Message::device)
+		.def_readwrite("regAddr", &Clause45Message::regAddr)
+		.def_readwrite("regVal", &Clause45Message::regVal);
+	pybind11::classh<PhyMessage>(m, "PhyMessage")
 		.def(pybind11::init())
 		.def_readwrite("Enabled", &PhyMessage::Enabled)
 		.def_readwrite("WriteEnable", &PhyMessage::WriteEnable)
@@ -16,19 +26,7 @@ void init_ethphymessage(pybind11::module_& m) {
 		.def_readwrite("BusIndex", &PhyMessage::BusIndex)
 		.def_readwrite("Clause22", &PhyMessage::Clause22)
 		.def_readwrite("Clause45", &PhyMessage::Clause45);
-	pybind11::class_<Clause22Message>(m, "Clause22Message")
+	pybind11::classh<EthPhyMessage, Message>(m, "EthPhyMessage")
-		.def(pybind11::init())
-		.def_readwrite("phyAddr", &Clause22Message::phyAddr)
-		.def_readwrite("page", &Clause22Message::page)
-		.def_readwrite("regAddr", &Clause22Message::regAddr)
-		.def_readwrite("regVal", &Clause22Message::regVal);
-	pybind11::class_<Clause45Message>(m, "Clause45Message")
-		.def(pybind11::init())
-		.def_readwrite("port", &Clause45Message::port)
-		.def_readwrite("device", &Clause45Message::device)
-		.def_readwrite("regAddr", &Clause45Message::regAddr)
-		.def_readwrite("regVal", &Clause45Message::regVal);
-	pybind11::class_<EthPhyMessage, std::shared_ptr<EthPhyMessage>, Message>(m, "EthPhyMessage")
 		.def(pybind11::init())
 		.def_readwrite("messages", &EthPhyMessage::messages);
 }

bindings/python/icsneopy/communication/message/filter/messagefilter.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_messagefilter(pybind11::module_& m) {
-	pybind11::class_<MessageFilter, std::shared_ptr<MessageFilter>>(m, "MessageFilter")
+	pybind11::classh<MessageFilter>(m, "MessageFilter")
 		.def(pybind11::init())
 		.def(pybind11::init<Message::Type>())
 		.def(pybind11::init<Network::NetID>());

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

@@ -7,72 +7,73 @@
 namespace icsneo {
 
 void init_gptpstatusmessage(pybind11::module_& m) {
-	pybind11::class_<GPTPStatus, std::shared_ptr<GPTPStatus>, Message> gptpStatus(m, "GPTPStatus");
+	pybind11::classh<GPTPStatus, Message> gptpStatus(m, "GPTPStatus");
 	
-	pybind11::class_<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
+	pybind11::classh<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
 		.def_readonly("seconds", &GPTPStatus::Timestamp::seconds)
 		.def_readonly("nanoseconds", &GPTPStatus::Timestamp::nanoseconds)
 		.def("to_seconds", &GPTPStatus::Timestamp::toSeconds, pybind11::call_guard<pybind11::gil_scoped_release>());
 	
-	pybind11::class_<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
+	pybind11::classh<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
-		.def_readonly("nanosecondsMSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
+		.def_readonly("nanoseconds_msb", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
-		.def_readonly("nanosecondsLSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
+		.def_readonly("nanoseconds_lsb", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
-		.def_readonly("fractionalNanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
+		.def_readonly("fractional_nanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
 	
-	pybind11::class_<GPTPStatus::PortID>(gptpStatus, "PortID")
+	pybind11::classh<GPTPStatus::PortID>(gptpStatus, "PortID")
-		.def_readonly("clockIdentity", &GPTPStatus::PortID::clockIdentity)
+		.def_readonly("clock_identity", &GPTPStatus::PortID::clockIdentity)
-		.def_readonly("portNumber", &GPTPStatus::PortID::portNumber);
+		.def_readonly("port_number", &GPTPStatus::PortID::portNumber);
 	
-	pybind11::class_<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
+	pybind11::classh<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
-		.def_readonly("clockClass", &GPTPStatus::ClockQuality::clockClass)
+		.def_readonly("clock_class", &GPTPStatus::ClockQuality::clockClass)
-		.def_readonly("clockAccuracy", &GPTPStatus::ClockQuality::clockAccuracy)
+		.def_readonly("clock_accuracy", &GPTPStatus::ClockQuality::clockAccuracy)
-		.def_readonly("offsetScaledLogVariance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
+		.def_readonly("offset_scaled_log_variance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
 	
-	pybind11::class_<GPTPStatus::SystemID>(gptpStatus, "SystemID")
+	pybind11::classh<GPTPStatus::SystemID>(gptpStatus, "SystemID")
 		.def_readonly("priority1", &GPTPStatus::SystemID::priority1)
-		.def_readonly("clockQuality", &GPTPStatus::SystemID::clockQuality)
+		.def_readonly("clock_quality", &GPTPStatus::SystemID::clockQuality)
 		.def_readonly("priority2", &GPTPStatus::SystemID::priority2)
-		.def_readonly("clockID", &GPTPStatus::SystemID::clockID);
+		.def_readonly("clock_id", &GPTPStatus::SystemID::clockID);
 	
-	pybind11::class_<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
+	pybind11::classh<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
-		.def_readonly("sysID", &GPTPStatus::PriorityVector::sysID)
+		.def_readonly("sys_id", &GPTPStatus::PriorityVector::sysID)
-		.def_readonly("stepsRemoved", &GPTPStatus::PriorityVector::stepsRemoved)
+		.def_readonly("steps_removed", &GPTPStatus::PriorityVector::stepsRemoved)
-		.def_readonly("portID", &GPTPStatus::PriorityVector::portID)
+		.def_readonly("port_id", &GPTPStatus::PriorityVector::portID)
-		.def_readonly("portNumber", &GPTPStatus::PriorityVector::portNumber);
+		.def_readonly("port_number", &GPTPStatus::PriorityVector::portNumber);
 	
-	pybind11::class_<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
+	pybind11::classh<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
-		.def_readonly("parentPortIdentity", &GPTPStatus::ParentDS::parentPortIdentity)
+		.def_readonly("parent_port_identity", &GPTPStatus::ParentDS::parentPortIdentity)
-		.def_readonly("cumulativeRateRatio", &GPTPStatus::ParentDS::cumulativeRateRatio)
+		.def_readonly("cumulative_rate_ratio", &GPTPStatus::ParentDS::cumulativeRateRatio)
-		.def_readonly("grandmasterIdentity", &GPTPStatus::ParentDS::grandmasterIdentity)
+		.def_readonly("grandmaster_identity", &GPTPStatus::ParentDS::grandmasterIdentity)
-		.def_readonly("gmClockQualityClockClass", &GPTPStatus::ParentDS::gmClockQualityClockClass)
+		.def_readonly("gm_clock_quality_clock_class", &GPTPStatus::ParentDS::gmClockQualityClockClass)
-		.def_readonly("gmClockQualityClockAccuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
+		.def_readonly("gm_clock_quality_clock_accuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
-		.def_readonly("gmClockQualityOffsetScaledLogVariance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
+		.def_readonly("gm_clock_quality_offset_scaled_log_variance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
-		.def_readonly("gmPriority1", &GPTPStatus::ParentDS::gmPriority1)
+		.def_readonly("gm_priority1", &GPTPStatus::ParentDS::gmPriority1)
-		.def_readonly("gmPriority2", &GPTPStatus::ParentDS::gmPriority2);
+		.def_readonly("gm_priority2", &GPTPStatus::ParentDS::gmPriority2);
 
-	pybind11::class_<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
+	pybind11::classh<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
-		.def_readonly("stepsRemoved", &GPTPStatus::CurrentDS::stepsRemoved)
+		.def_readonly("steps_removed", &GPTPStatus::CurrentDS::stepsRemoved)
-		.def_readonly("offsetFromMaster", &GPTPStatus::CurrentDS::offsetFromMaster)
+		.def_readonly("offset_from_master", &GPTPStatus::CurrentDS::offsetFromMaster)
-		.def_readonly("lastgmPhaseChange", &GPTPStatus::CurrentDS::lastgmPhaseChange)
+		.def_readonly("lastgm_phase_change", &GPTPStatus::CurrentDS::lastgmPhaseChange)
-		.def_readonly("lastgmFreqChange", &GPTPStatus::CurrentDS::lastgmFreqChange)
+		.def_readonly("lastgm_freq_change", &GPTPStatus::CurrentDS::lastgmFreqChange)
-		.def_readonly("gmTimeBaseIndicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
+		.def_readonly("gm_time_base_indicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
-		.def_readonly("gmChangeCount", &GPTPStatus::CurrentDS::gmChangeCount)
+		.def_readonly("gm_change_count", &GPTPStatus::CurrentDS::gmChangeCount)
-		.def_readonly("timeOfLastgmChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
+		.def_readonly("time_of_lastgm_change_event", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
-		.def_readonly("timeOfLastgmPhaseChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
+		.def_readonly("time_of_lastgm_phase_change_event", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
-		.def_readonly("timeOfLastgmFreqChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
+		.def_readonly("time_of_lastgm_freq_change_event", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
 
-	gptpStatus.def_readonly("currentTime", &GPTPStatus::currentTime)
+	gptpStatus.def_readonly("current_time", &GPTPStatus::currentTime)
-		.def_readonly("gmPriority", &GPTPStatus::gmPriority)
+		.def_readonly("gm_priority", &GPTPStatus::gmPriority)
-		.def_readonly("msOffsetNs", &GPTPStatus::msOffsetNs)
+		.def_readonly("ms_offset_ns", &GPTPStatus::msOffsetNs)
-		.def_readonly("isSync", &GPTPStatus::isSync)
+		.def_readonly("is_sync", &GPTPStatus::isSync)
-		.def_readonly("linkStatus", &GPTPStatus::linkStatus)
+		.def_readonly("link_status", &GPTPStatus::linkStatus)
-		.def_readonly("linkDelayNS", &GPTPStatus::linkDelayNS)
+		.def_readonly("link_delay_ns", &GPTPStatus::linkDelayNS)
-		.def_readonly("selectedRole", &GPTPStatus::selectedRole)
+		.def_readonly("selected_role", &GPTPStatus::selectedRole)
-		.def_readonly("asCapable", &GPTPStatus::asCapable)
+		.def_readonly("as_capable", &GPTPStatus::asCapable)
-		.def_readonly("isSyntonized", &GPTPStatus::isSyntonized)
+		.def_readonly("is_syntonized", &GPTPStatus::isSyntonized)
-		.def_readonly("lastRXSyncTS", &GPTPStatus::lastRXSyncTS)
+		.def_readonly("last_rx_sync_ts", &GPTPStatus::lastRXSyncTS)
-		.def_readonly("currentDS", &GPTPStatus::currentDS)
+		.def_readonly("current_ds", &GPTPStatus::currentDS)
-		.def_readonly("parentDS", &GPTPStatus::parentDS);
+		.def_readonly("parent_ds", &GPTPStatus::parentDS)
+		.def_readonly("short_format", &GPTPStatus::shortFormat);
 
 }
 

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_linmessage(pybind11::module_& m) {
-	pybind11::class_<LINErrorFlags>(m, "LINErrorFlags")
+	pybind11::classh<LINErrorFlags>(m, "LINErrorFlags")
 		.def_readwrite("ErrRxBreakOnly", &LINErrorFlags::ErrRxBreakOnly)
 		.def_readwrite("ErrRxBreakSyncOnly", &LINErrorFlags::ErrRxBreakSyncOnly)
 		.def_readwrite("ErrTxRxMismatch", &LINErrorFlags::ErrTxRxMismatch)
@@ -20,7 +20,7 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("ErrFrameResponderData", &LINErrorFlags::ErrFrameResponderData)
 		.def_readwrite("ErrChecksumMatch", &LINErrorFlags::ErrChecksumMatch);
 
-	pybind11::class_<LINStatusFlags>(m, "LINStatusFlags")
+	pybind11::classh<LINStatusFlags>(m, "LINStatusFlags")
 		.def_readwrite("TxChecksumEnhanced", &LINStatusFlags::TxChecksumEnhanced)
 		.def_readwrite("TxCommander", &LINStatusFlags::TxCommander)
 		.def_readwrite("TxResponder", &LINStatusFlags::TxResponder)
@@ -30,7 +30,7 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
 		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
 
-	pybind11::class_<LINMessage, std::shared_ptr<LINMessage>, Frame> linMessage(m, "LINMessage");
+	pybind11::classh<LINMessage, Frame> linMessage(m, "LINMessage");
 
 	pybind11::enum_<LINMessage::Type>(linMessage, "Type")
 		.value("NOT_SET", LINMessage::Type::NOT_SET)

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

@@ -1,160 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/communication/message/macsecmessage.h"
-
-namespace icsneo {
-
-void init_macsecmessage(pybind11::module_ & m)
-{
-	pybind11::enum_<MACsecPacketType>(m, "MACsecPacketType")
-		.value("NoVLAN_OrMPLS", MACsecPacketType::NoVLANOrMPLS)
-		.value("SingleVLAN", MACsecPacketType::SingleVLAN)
-		.value("DualVLAN", MACsecPacketType::DualVLAN)
-		.value("MPLS", MACsecPacketType::MPLS)
-		.value("SingleVLAN_FollowByMPLS", MACsecPacketType::SingleVLANFollowedByMPLS)
-		.value("DualVLAN_FollowByMPLS", MACsecPacketType::DualVLANFollowedByMPLS)
-		.value("Unsupported", MACsecPacketType::Unsupported);
-
-	pybind11::enum_<MACsecValidateFrameType>(m, "MACsecValidateFrameType")
-		.value("Disabled", MACsecValidateFrameType::Disabled)
-		.value("Check", MACsecValidateFrameType::Check)
-		.value("Strict", MACsecValidateFrameType::Strict)
-		.value("NA", MACsecValidateFrameType::NA);
-
-	pybind11::enum_<MACsecSecTagIcvStripType>(m, "MACsecSecTagIcvStripType")
-		.value("StripBoth", MACsecSecTagIcvStripType::StripBoth)
-		.value("StripSecTagPreserveICV", MACsecSecTagIcvStripType::StripSecTagPreserveICV)
-		.value("PreserveSecTagStripICV", MACsecSecTagIcvStripType::PreserveSecTagStripICV)
-		.value("PreserveBoth", MACsecSecTagIcvStripType::PreserveBoth);
-
-	pybind11::enum_<MACsecCipherSuiteType>(m, "MACsecCipherSuiteType")
-		.value("AES_128", MACsecCipherSuiteType::GcmAes128)
-		.value("AES_256", MACsecCipherSuiteType::GcmAes256)
-		.value("AES_128_XPN", MACsecCipherSuiteType::GcmAes128Xpn)
-		.value("AES_256_XPN", MACsecCipherSuiteType::GcmAes256Xpn);
-
-	pybind11::class_<MACsecVLANTag, std::shared_ptr<MACsecVLANTag>>(m, "MACsecVLANTag")
-		.def(pybind11::init())
-		.def_readwrite("vid", &MACsecVLANTag::vid)
-		.def_readwrite("pri_cfi", &MACsecVLANTag::priCfi);
-
-	pybind11::class_<MACsecMPLSOuter, std::shared_ptr<MACsecMPLSOuter>>(m, "MACsecMPLSOuter")
-		.def(pybind11::init())
-		.def_readwrite("mpls_label", &MACsecMPLSOuter::mplsLabel)
-		.def_readwrite("exp", &MACsecMPLSOuter::exp);
-
-	pybind11::class_<MACsecRule, std::shared_ptr<MACsecRule>>(m, "MACsecRule")
-		.def(pybind11::init())
-		.def_readwrite("index", &MACsecRule::index)
-		.def_readwrite("keyMacDa", &MACsecRule::keyMacDa)
-		.def_readwrite("maskMacDa", &MACsecRule::maskMacDa)
-		.def_readwrite("keyMacSa", &MACsecRule::keyMacSa)
-		.def_readwrite("maskMacSa", &MACsecRule::maskMacSa)
-		.def_readwrite("keyEthertype", &MACsecRule::keyEthertype)
-		.def_readwrite("maskEthertype", &MACsecRule::maskEthertype)
-		.def_readwrite("keyVlanTagOuter1", &MACsecRule::keyVlanTagOuter1)
-		.def_readwrite("keyMplsOuter1", &MACsecRule::keyMplsOuter1)
-		.def_readwrite("maskVlanTagOuter1", &MACsecRule::maskVlanTagOuter1)
-		.def_readwrite("maskMplsOuter1", &MACsecRule::maskMplsOuter1)
-		.def_readwrite("keyVlanTagOuter2", &MACsecRule::keyVlanTagOuter2)
-		.def_readwrite("keyMplsOuter2", &MACsecRule::keyMplsOuter2)
-		.def_readwrite("maskVlanTagOuter2", &MACsecRule::maskVlanTagOuter2)
-		.def_readwrite("maskMplsOuter2", &MACsecRule::maskMplsOuter2)
-		.def_readwrite("keyBonusData", &MACsecRule::keyBonusData)
-		.def_readwrite("maskBonusData", &MACsecRule::maskBonusData)
-		.def_readwrite("keyTagMatchBitmap", &MACsecRule::keyTagMatchBitmap)
-		.def_readwrite("maskTagMatchBitmap", &MACsecRule::maskTagMatchBitmap)
-		.def_readwrite("keyPacketType", &MACsecRule::keyPacketType)
-		.def_readwrite("maskPacketType", &MACsecRule::maskPacketType)
-		.def_readwrite("keyInnerVlanType", &MACsecRule::keyInnerVlanType)
-		.def_readwrite("maskInnerVlanType", &MACsecRule::maskInnerVlanType)
-		.def_readwrite("keyOuterVlanType", &MACsecRule::keyOuterVlanType)
-		.def_readwrite("maskOuterVlanType", &MACsecRule::maskOuterVlanType)
-		.def_readwrite("keyNumTags", &MACsecRule::keyNumTags)
-		.def_readwrite("maskNumTags", &MACsecRule::maskNumTags)
-		.def_readwrite("keyExpress", &MACsecRule::keyExpress)
-		.def_readwrite("maskExpress", &MACsecRule::maskExpress)
-		.def_readwrite("isMpls", &MACsecRule::isMpls)
-		.def_readwrite("enable", &MACsecRule::enable);
-
-	pybind11::class_<MACsecMap, std::shared_ptr<MACsecMap>>(m, "MACsecMap")
-		.def(pybind11::init())
-		.def_readwrite("index", &MACsecMap::index)
-		.def_readwrite("secTagSci", &MACsecMap::secTagSci)
-		.def_readwrite("secYIndex", &MACsecMap::secYIndex)
-		.def_readwrite("isControlPacket", &MACsecMap::isControlPacket)
-		.def_readwrite("scIndex", &MACsecMap::scIndex)
-		.def_readwrite("auxiliaryPlcy", &MACsecMap::auxiliaryPlcy)
-		.def_readwrite("ruleId", &MACsecMap::ruleId)
-		.def_readwrite("enable", &MACsecMap::enable);
-
-	pybind11::class_<MACsecSecY, std::shared_ptr<MACsecSecY>>(m, "MACsecSecY")
-		.def(pybind11::init())
-		.def_readwrite("index", &MACsecSecY::index)
-		.def_readwrite("controlledPortEnabled", &MACsecSecY::controlledPortEnabled)
-		.def_readwrite("frameValidationType", &MACsecSecY::frameValidationType)
-		.def_readwrite("secTagIcvStripType", &MACsecSecY::secTagIcvStripType)
-		.def_readwrite("cipher", &MACsecSecY::cipher)
-		.def_readwrite("confidentialOffset", &MACsecSecY::confidentialOffset)
-		.def_readwrite("icvIncludesDaSa", &MACsecSecY::icvIncludesDaSa)
-		.def_readwrite("replayProtect", &MACsecSecY::replayProtect)
-		.def_readwrite("replayWindow", &MACsecSecY::replayWindow)
-		.def_readwrite("protectFrames", &MACsecSecY::protectFrames)
-		.def_readwrite("secTagOffset", &MACsecSecY::secTagOffset)
-		.def_readwrite("secTagTci", &MACsecSecY::secTagTci)
-		.def_readwrite("mtu", &MACsecSecY::mtu)
-		.def_readwrite("enable", &MACsecSecY::enable);
-
-	pybind11::class_<MACsecSc, std::shared_ptr<MACsecSc>>(m, "MACsecSc")
-		.def(pybind11::init())
-		.def_readwrite("index", &MACsecSc::index)
-		.def_readwrite("secYIndex", &MACsecSc::secYIndex)
-		.def_readwrite("sci", &MACsecSc::sci)
-		.def_readwrite("saIndex0", &MACsecSc::saIndex0)
-		.def_readwrite("saIndex1", &MACsecSc::saIndex1)
-		.def_readwrite("saIndex0InUse", &MACsecSc::saIndex0InUse)
-		.def_readwrite("saIndex1InUse", &MACsecSc::saIndex1InUse)
-		.def_readwrite("enableAutoRekey", &MACsecSc::enableAutoRekey)
-		.def_readwrite("isActiveSa1", &MACsecSc::isActiveSa1)
-		.def_readwrite("enable", &MACsecSc::enable);
-
-	pybind11::class_<MACsecSa, std::shared_ptr<MACsecSa>>(m, "MACsecSa")
-		.def(pybind11::init())
-		.def_readwrite("index", &MACsecSa::index)
-		.def_readwrite("sak", &MACsecSa::sak)
-		.def_readwrite("hashKey", &MACsecSa::hashKey)
-		.def_readwrite("salt", &MACsecSa::salt)
-		.def_readwrite("ssci", &MACsecSa::ssci)
-		.def_readwrite("an", &MACsecSa::an)
-		.def_readwrite("nextPn", &MACsecSa::nextPn)
-		.def_readwrite("enable", &MACsecSa::enable);
-
-	pybind11::class_<MACSecFlags, std::shared_ptr<MACSecFlags>>(m, "MACSecFlags")
-		.def(pybind11::init())
-		.def_readwrite("en", &MACSecFlags::en);
-
-	pybind11::class_<MACsecConfig, std::shared_ptr<MACsecConfig>>(m, "MACsecConfig")
-		.def(pybind11::init())
-		.def_readwrite("flags", &MACsecConfig::flags)
-		.def_readwrite("rule", &MACsecConfig::rule)
-		.def_readwrite("map", &MACsecConfig::map)
-		.def_readwrite("secy", &MACsecConfig::secy)
-		.def_readwrite("sc", &MACsecConfig::sc)
-		.def_readwrite("sa", &MACsecConfig::sa);
-
-	pybind11::class_<MACSecGlobalFlags, std::shared_ptr<MACSecGlobalFlags>>(m, "MACSecGlobalFlags")
-		.def(pybind11::init())
-		.def_readwrite("en", &MACSecGlobalFlags::en)
-		.def_readwrite("nvm", &MACSecGlobalFlags::nvm);
-
-	pybind11::class_<MACsecMessage, std::shared_ptr<MACsecMessage>>(m, "MACsecMessage")
-		.def(pybind11::init())
-		.def_readwrite("flags", &MACsecMessage::flags)
-		.def_readwrite("rx", &MACsecMessage::rx)
-		.def_readwrite("tx", &MACsecMessage::tx);
-}
-
-} // namespace icsneo 
-

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_mdiomessage(pybind11::module_& m) {
-	pybind11::class_<MDIOMessage, std::shared_ptr<MDIOMessage>, Frame> mdioMessage(m, "MDIOMessage");
+	pybind11::classh<MDIOMessage, Frame> mdioMessage(m, "MDIOMessage");
 	pybind11::enum_<MDIOMessage::Clause>(mdioMessage, "Clause")
 		.value("Clause45", MDIOMessage::Clause::Clause45)
 		.value("Clause22", MDIOMessage::Clause::Clause22);

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

@@ -1,14 +1,16 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/message/message.h"
 
 namespace icsneo {
 
 void init_message(pybind11::module_& m) {
-	pybind11::class_<Message, std::shared_ptr<Message>> message(m, "Message");
+	// Using py::smart_holder for safer lifetime management
-	pybind11::enum_<Message::Type>(message, "Type")
+	pybind11::classh<Message> message(m, "Message");
+	pybind11::native_enum<Message::Type>(message, "Type", "enum.IntEnum")
 		.value("Frame", Message::Type::Frame)
 		.value("CANErrorCount", Message::Type::CANErrorCount)
 		.value("CANError", Message::Type::CANError)
@@ -34,17 +36,18 @@ void init_message(pybind11::module_& m) {
 		.value("TC10Status", Message::Type::TC10Status)
 		.value("AppError", Message::Type::AppError)
 		.value("GPTPStatus", Message::Type::GPTPStatus)
-		.value("EthernetStatus", Message::Type::EthernetStatus);
+		.value("EthernetStatus", Message::Type::EthernetStatus)
+		.finalize();
 
 	message.def(pybind11::init<Message::Type>());
 	message.def_readonly("type", &Message::type);
 	message.def_readwrite("timestamp", &Message::timestamp);
 
-	pybind11::class_<RawMessage, std::shared_ptr<RawMessage>, Message>(m, "RawMessage")
+	pybind11::classh<RawMessage, Message>(m, "RawMessage")
 		.def_readwrite("network", &RawMessage::network)
 		.def_readwrite("data", &RawMessage::data);
 
-	pybind11::class_<Frame, std::shared_ptr<Frame>, RawMessage>(m, "Frame")
+	pybind11::classh<Frame, RawMessage>(m, "Frame")
 		.def_readwrite("description", &Frame::description)
 		.def_readwrite("transmitted", &Frame::transmitted)
 		.def_readwrite("error", &Frame::error);

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_scriptstatusmessage(pybind11::module_& m) {
-	pybind11::class_<ScriptStatusMessage, std::shared_ptr<ScriptStatusMessage>, Message>(m, "ScriptStatusMessage")
+	pybind11::classh<ScriptStatusMessage, Message>(m, "ScriptStatusMessage")
         .def_readonly("isEncrypted", &ScriptStatusMessage::isEncrypted)
         .def_readonly("isCoreminiRunning", &ScriptStatusMessage::isCoreminiRunning)
         .def_readonly("sectorOverflows", &ScriptStatusMessage::sectorOverflows)

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_spimessage(pybind11::module_& m) {
-	pybind11::class_<SPIMessage, std::shared_ptr<SPIMessage>, Frame> spiMessage(m, "SPIMessage");
+	pybind11::classh<SPIMessage, Frame> spiMessage(m, "SPIMessage");
 	pybind11::enum_<SPIMessage::Direction>(spiMessage, "Direction")
 		.value("Write", SPIMessage::Direction::Write)
 		.value("Read", SPIMessage::Direction::Read);

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

@@ -17,7 +17,7 @@ void init_tc10statusmessage(pybind11::module_& m) {
 		.value("SleepFailed", TC10SleepStatus::SleepFailed)
 		.value("SleepAborted", TC10SleepStatus::SleepAborted);
 
-	pybind11::class_<TC10StatusMessage, std::shared_ptr<TC10StatusMessage>, Message>(m, "TC10StatusMessage")
+	pybind11::classh<TC10StatusMessage, Message>(m, "TC10StatusMessage")
 		.def_readonly("wakeStatus", &TC10StatusMessage::wakeStatus)
 		.def_readonly("sleepStatus", &TC10StatusMessage::sleepStatus);
 }

bindings/python/icsneopy/communication/network.cpp

@@ -1,15 +1,16 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/network.h"
 
 namespace icsneo {
 
 void init_network(pybind11::module_& m) {
-	pybind11::class_<Network> network(m, "Network");
+	pybind11::classh<Network> network(m, "Network");
 
-	pybind11::enum_<Network::NetID>(network, "NetID")
+	pybind11::native_enum<Network::NetID>(network, "NetID", "enum.IntEnum")
 		.value("Device", Network::NetID::Device)
 		.value("DWCAN_01", Network::NetID::DWCAN_01)
 		.value("DWCAN_08", Network::NetID::DWCAN_08)
@@ -166,9 +167,10 @@ void init_network(pybind11::module_& m) {
 		.value("LIN_15", Network::NetID::LIN_15)
 		.value("LIN_16", Network::NetID::LIN_16)
 		.value("Any", Network::NetID::Any)
-		.value("Invalid", Network::NetID::Invalid);
+		.value("Invalid", Network::NetID::Invalid)
+		.finalize();
 	
-	pybind11::enum_<Network::Type>(network, "Type")
+	pybind11::native_enum<Network::Type>(network, "Type", "enum.Enum")
 		.value("Invalid", Network::Type::Invalid)
 		.value("Internal", Network::Type::Internal)
 		.value("CAN", Network::Type::CAN)
@@ -179,12 +181,14 @@ void init_network(pybind11::module_& m) {
 		.value("LSFTCAN", Network::Type::LSFTCAN)
 		.value("SWCAN", Network::Type::SWCAN)
 		.value("ISO9141", Network::Type::ISO9141)
-		.value("I2C_01", Network::Type::I2C)
+		.value("I2C", Network::Type::I2C)
 		.value("A2B", Network::Type::A2B)
 		.value("SPI", Network::Type::SPI)
 		.value("MDIO", Network::Type::MDIO)
+		.value("AutomotiveEthernet", Network::Type::AutomotiveEthernet)
 		.value("Any", Network::Type::Any)
-		.value("Other", Network::Type::Other);
+		.value("Other", Network::Type::Other)
+		.finalize();
 
     network
 		.def(pybind11::init<Network::NetID>())

bindings/python/icsneopy/core/macseccfg.cpp

@@ -0,0 +1,166 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/core/macseccfg.h"
+
+namespace icsneo {
+
+void init_macsecconfig(pybind11::module_ & m)
+{
+	pybind11::enum_<MACsecPacketType>(m, "MACsecPacketType")
+		.value("DEFAULT", MACsecPacketType::Default)
+		.value("SINGLE_VLAN", MACsecPacketType::SingleVLAN)
+		.value("DUAL_VLAN", MACsecPacketType::DualVLAN)
+		.value("MPLS", MACsecPacketType::MPLS)
+		.value("SINGLE_VLAN_FOLLOWED_BY_MPLS", MACsecPacketType::SingleVLANFollowedByMPLS)
+		.value("DUAL_VLAN_FOLLOWED_BY_MPLS", MACsecPacketType::DualVLANFollowedByMPLS)
+		.value("UNSUPPORTED", MACsecPacketType::Unsupported);
+
+	pybind11::enum_<MACsecValidation>(m, "MACsecValidation")
+		.value("DISABLED", MACsecValidation::Disabled)
+		.value("CHECK", MACsecValidation::Check)
+		.value("STRICT", MACsecValidation::Strict)
+		.value("NA", MACsecValidation::NA);
+
+	pybind11::enum_<MACsecStrip>(m, "MACsecStrip")
+		.value("STRIP_SECTAG_AND_ICV", MACsecStrip::StripSecTagAndIcv)
+		.value("STRIP_SECTAG_PRESERVE_ICV", MACsecStrip::StripSecTagPreserveICV)
+		.value("PRESERVE_SECTAG_STRIP_ICV", MACsecStrip::PreserveSecTagStripICV)
+		.value("NO_STRIP", MACsecStrip::NoStrip);
+
+	pybind11::enum_<MACsecCipherSuite>(m, "MACsecCipherSuite")
+		.value("GCM_AES_128", MACsecCipherSuite::GcmAes128)
+		.value("GCM_AES_256", MACsecCipherSuite::GcmAes256)
+		.value("GCM_AES_128_XPN", MACsecCipherSuite::GcmAes128Xpn)
+		.value("GCM_AES_256_XPN", MACsecCipherSuite::GcmAes256Xpn);
+
+	pybind11::classh<MACsecVLANTag>(m, "MACsecVLANTag")
+		.def(pybind11::init())
+		.def_readwrite("vid", &MACsecVLANTag::vid)
+		.def_readwrite("pri_cfi", &MACsecVLANTag::priCfi);
+
+	pybind11::classh<MACsecMPLSOuter>(m, "MACsecMPLSOuter")
+		.def(pybind11::init())
+		.def_readwrite("mpls_label", &MACsecMPLSOuter::mplsLabel)
+		.def_readwrite("exp", &MACsecMPLSOuter::exp);
+
+	pybind11::classh<MACsecTci>(m, "MACsecTci")
+		.def(pybind11::init())
+		.def_readwrite("es", &MACsecTci::es)
+		.def_readwrite("sc", &MACsecTci::sc)
+		.def_readwrite("scb", &MACsecTci::scb)
+		.def_readwrite("e", &MACsecTci::e)
+		.def_readwrite("c", &MACsecTci::c);
+
+	pybind11::classh<MACsecRxRule>(m, "MACsecRxRule")
+		.def(pybind11::init())
+		.def_readwrite("key_mac_da", &MACsecRxRule::keyMacDa)
+		.def_readwrite("mask_mac_da", &MACsecRxRule::maskMacDa)
+		.def_readwrite("key_mask_sa", &MACsecRxRule::keyMacSa)
+		.def_readwrite("mask_mac_sa", &MACsecRxRule::maskMacSa)
+		.def_readwrite("key_ether_type", &MACsecRxRule::keyEthertype)
+		.def_readwrite("mask_ether_type", &MACsecRxRule::maskEthertype)
+		.def_readwrite("key_vlan_tag_outer1", &MACsecRxRule::keyVlanTagOuter1)
+		.def_readwrite("key_mpls_outer1", &MACsecRxRule::keyMplsOuter1)
+		.def_readwrite("mask_vlan_tag_outer1", &MACsecRxRule::maskVlanTagOuter1)
+		.def_readwrite("mask_mpls_outer1", &MACsecRxRule::maskMplsOuter1)
+		.def_readwrite("key_vlan_tag_outer2", &MACsecRxRule::keyVlanTagOuter2)
+		.def_readwrite("key_mpls_outer2", &MACsecRxRule::keyMplsOuter2)
+		.def_readwrite("mask_vlan_tag_outer2", &MACsecRxRule::maskVlanTagOuter2)
+		.def_readwrite("mask_mpls_outer2", &MACsecRxRule::maskMplsOuter2)
+		.def_readwrite("key_bonus_data", &MACsecRxRule::keyBonusData)
+		.def_readwrite("mask_bonus_data", &MACsecRxRule::maskBonusData)
+		.def_readwrite("key_tag_match_bitmap", &MACsecRxRule::keyTagMatchBitmap)
+		.def_readwrite("mask_tag_match_bitmap", &MACsecRxRule::maskTagMatchBitmap)
+		.def_readwrite("key_packet_type", &MACsecRxRule::keyPacketType)
+		.def_readwrite("mask_packet_type", &MACsecRxRule::maskPacketType)
+		.def_readwrite("key_inner_vlan_type", &MACsecRxRule::keyInnerVlanType)
+		.def_readwrite("mask_inner_vlan_type", &MACsecRxRule::maskInnerVlanType)
+		.def_readwrite("key_outer_vlan_type", &MACsecRxRule::keyOuterVlanType)
+		.def_readwrite("mask_outer_vlan_type", &MACsecRxRule::maskOuterVlanType)
+		.def_readwrite("key_num_tags", &MACsecRxRule::keyNumTags)
+		.def_readwrite("mask_num_tags", &MACsecRxRule::maskNumTags)
+		.def_readwrite("key_express", &MACsecRxRule::keyExpress)
+		.def_readwrite("mask_express", &MACsecRxRule::maskExpress)
+		.def_readwrite("is_mpls", &MACsecRxRule::isMpls);
+
+	pybind11::classh<MACsecTxSecY>(m, "MACsecTxSecY")
+		.def(pybind11::init())
+		.def_readwrite("enable_control_port", &MACsecTxSecY::enableControlPort)
+		.def_readwrite("cipher", &MACsecTxSecY::cipher)
+		.def_readwrite("confidentiality_offset", &MACsecTxSecY::confidentialityOffset)
+		.def_readwrite("icv_includes_da_sa", &MACsecTxSecY::icvIncludesDaSa)
+		.def_readwrite("protect_frames", &MACsecTxSecY::protectFrames)
+		.def_readwrite("sec_tag_offset", &MACsecTxSecY::secTagOffset)
+		.def_readwrite("sec_tag_tci", &MACsecTxSecY::tci)
+		.def_readwrite("mtu", &MACsecTxSecY::mtu)
+		.def_readwrite("is_control_packet", &MACsecTxSecY::isControlPacket)
+		.def_readwrite("auxiliary_policy", &MACsecTxSecY::auxiliaryPolicy)
+		.def_readwrite("sci", &MACsecTxSecY::sci);
+		
+	pybind11::classh<MACsecRxSecY>(m, "MACsecRxSecY")
+		.def(pybind11::init())
+		.def_readwrite("enable_control_port", &MACsecRxSecY::enableControlPort)
+		.def_readwrite("frame_validation", &MACsecRxSecY::frameValidation)
+		.def_readwrite("frame_strip", &MACsecRxSecY::frameStrip)
+		.def_readwrite("cipher", &MACsecRxSecY::cipher)
+		.def_readwrite("confidentiality_offset", &MACsecRxSecY::confidentialityOffset)
+		.def_readwrite("icv_includes_da_sa", &MACsecRxSecY::icvIncludesDaSa)
+		.def_readwrite("replay_protect", &MACsecRxSecY::replayProtect)
+		.def_readwrite("replay_window", &MACsecRxSecY::replayWindow)
+		.def_readwrite("is_control_packet", &MACsecRxSecY::isControlPacket)
+		.def_readwrite("sci", &MACsecRxSecY::sci);
+
+	pybind11::classh<MACsecTxSa>(m, "MACsecTxSa")
+		.def(pybind11::init())
+		.def_readwrite("sak", &MACsecTxSa::sak)
+		.def_readwrite("hash_key", &MACsecTxSa::hashKey)
+		.def_readwrite("salt", &MACsecTxSa::salt)
+		.def_readwrite("ssci", &MACsecTxSa::ssci)
+		.def_readwrite("next_pn", &MACsecTxSa::nextPn)
+		.def_readwrite("an", &MACsecTxSa::an);
+
+	pybind11::classh<MACsecRxSa>(m, "MACsecRxSa")
+		.def(pybind11::init())
+		.def_readwrite("sak", &MACsecRxSa::sak)
+		.def_readwrite("hash_key", &MACsecRxSa::hashKey)
+		.def_readwrite("salt", &MACsecRxSa::salt)
+		.def_readwrite("ssci", &MACsecRxSa::ssci)
+		.def_readwrite("next_pn", &MACsecRxSa::nextPn);
+
+	pybind11::classh<MACsecConfig>(m, "MACsecConfig")
+		.def(pybind11::init<icsneo::DeviceType>())
+		.def("add_rx_secy", &MACsecConfig::addRxSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("add_tx_secY", &MACsecConfig::addTxSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("add_rx_rule", &MACsecConfig::addRxRule, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("add_rx_sa", &MACsecConfig::addRxSa, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("add_tx_sa", &MACsecConfig::addTxSa, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_rx_secy", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxSecY& { return cfg.getRxSecY(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_tx_secy", [](MACsecConfig& cfg, uint8_t index) -> MACsecTxSecY& { return cfg.getTxSecY(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_rx_sa", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxSa& { return cfg.getRxSa(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_tx_sa", [](MACsecConfig& cfg, uint8_t index) -> MACsecTxSa& { return cfg.getTxSa(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_rx_rule", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxRule& { return cfg.getRxRule(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_tx_sa_index", &MACsecConfig::setTxSaIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("enable_tx_rekey", &MACsecConfig::enableTxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_tx_sa_rekey_index", &MACsecConfig::setTxSaRekeyIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("disable_tx_rekey", &MACsecConfig::disableTxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_rx_sa_index", &MACsecConfig::setRxSaIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("enable_rx_rekey", &MACsecConfig::enableRxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_rx_sa_rekey_index", &MACsecConfig::setRxSaRekeyIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("disable_rx_rekey", &MACsecConfig::disableRxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_rx_enable", &MACsecConfig::setRxEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_tx_enable", &MACsecConfig::setTxEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.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>())
+		.def("get_max_num_sa", &MACsecConfig::getMaxNumSa, pybind11::call_guard<pybind11::gil_scoped_release>());
+
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/device/chipid.cpp

@@ -0,0 +1,138 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
+
+#include "icsneo/device/chipid.h"
+
+namespace icsneo {
+
+void init_chipid(pybind11::module_& m) {
+	pybind11::native_enum<ChipID>(m, "ChipID", "enum.IntEnum")
+		.value("neoVIFIRE_MCHIP", ChipID::neoVIFIRE_MCHIP)
+		.value("neoVIFIRE_LCHIP", ChipID::neoVIFIRE_LCHIP)
+		.value("neoVIFIRE_UCHIP", ChipID::neoVIFIRE_UCHIP)
+		.value("neoVIFIRE_JCHIP", ChipID::neoVIFIRE_JCHIP)
+		.value("ValueCAN3_MCHIP", ChipID::ValueCAN3_MCHIP)
+		.value("neoVIECU_MPIC", ChipID::neoVIECU_MPIC)
+		.value("neoVIIEVB_MPIC", ChipID::neoVIIEVB_MPIC)
+		.value("neoVIPENDANT_MPIC", ChipID::neoVIPENDANT_MPIC)
+		.value("neoVIFIRE_VNET_MCHIP", ChipID::neoVIFIRE_VNET_MCHIP)
+		.value("neoVIFIRE_VNET_LCHIP", ChipID::neoVIFIRE_VNET_LCHIP)
+		.value("neoVIPLASMA_Core", ChipID::neoVIPLASMA_Core)
+		.value("neoVIPLASMA_HID", ChipID::neoVIPLASMA_HID)
+		.value("neoVIANALOG_MPIC", ChipID::neoVIANALOG_MPIC)
+		.value("neoVIPLASMA_ANALOG_Core", ChipID::neoVIPLASMA_ANALOG_Core)
+		.value("neoVIPLASMA_FlexRay_Core", ChipID::neoVIPLASMA_FlexRay_Core)
+		.value("neoVIPLASMA_Core_1_12", ChipID::neoVIPLASMA_Core_1_12)
+		.value("neoVIFIRE_Slave_VNET_MCHIP", ChipID::neoVIFIRE_Slave_VNET_MCHIP)
+		.value("neoVIFIRE_Slave_VNET_LCHIP", ChipID::neoVIFIRE_Slave_VNET_LCHIP)
+		.value("neoVIION_Core", ChipID::neoVIION_Core)
+		.value("neoVIION_HID", ChipID::neoVIION_HID)
+		.value("neoVIION_Core_Loader", ChipID::neoVIION_Core_Loader)
+		.value("neoVIION_HID_Loader", ChipID::neoVIION_HID_Loader)
+		.value("neoVIION_FPGA_BIT", ChipID::neoVIION_FPGA_BIT)
+		.value("neoVIFIRE_VNET_EP_MCHIP", ChipID::neoVIFIRE_VNET_EP_MCHIP)
+		.value("neoVIFIRE_VNET_EP_LCHIP", ChipID::neoVIFIRE_VNET_EP_LCHIP)
+		.value("neoVIAnalogOut_MCHIP", ChipID::neoVIAnalogOut_MCHIP)
+		.value("neoVIMOST25_MCHIP", ChipID::neoVIMOST25_MCHIP)
+		.value("neoVIMOST50_MCHIP", ChipID::neoVIMOST50_MCHIP)
+		.value("neoVIMOST150_MCHIP", ChipID::neoVIMOST150_MCHIP)
+		.value("ValueCAN4_4_MCHIP", ChipID::ValueCAN4_4_MCHIP)
+		.value("ValueCAN4_4_SCHIP", ChipID::ValueCAN4_4_SCHIP)
+		.value("cmProbe_ZYNQ", ChipID::cmProbe_ZYNQ)
+		.value("EEVB_STM32", ChipID::EEVB_STM32)
+		.value("neoVIFIRE_Slave_VNET_EP_MCHIP", ChipID::neoVIFIRE_Slave_VNET_EP_MCHIP)
+		.value("neoVIFIRE_Slave_VNET_EP_LCHIP", ChipID::neoVIFIRE_Slave_VNET_EP_LCHIP)
+		.value("RADStar_MCHIP", ChipID::RADStar_MCHIP)
+		.value("ValueCANrf_MCHIP", ChipID::ValueCANrf_MCHIP)
+		.value("neoVIFIRE2_MCHIP", ChipID::neoVIFIRE2_MCHIP)
+		.value("neoVIFIRE2_CCHIP", ChipID::neoVIFIRE2_CCHIP)
+		.value("neoVIFIRE2_Core", ChipID::neoVIFIRE2_Core)
+		.value("neoVIFIRE2_BLECHIP", ChipID::neoVIFIRE2_BLECHIP)
+		.value("neoVIFIRE2_ZYNQ", ChipID::neoVIFIRE2_ZYNQ)
+		.value("neoVIFIRE2_SECURITYCHIP", ChipID::neoVIFIRE2_SECURITYCHIP)
+		.value("RADGalaxy_ZYNQ", ChipID::RADGalaxy_ZYNQ)
+		.value("neoVIFIRE2_VNET_MCHIP", ChipID::neoVIFIRE2_VNET_MCHIP)
+		.value("neoVIFIRE2_Slave_VNET_A_MCHIP", ChipID::neoVIFIRE2_Slave_VNET_A_MCHIP)
+		.value("neoVIFIRE2_Slave_VNET_A_CCHIP", ChipID::neoVIFIRE2_Slave_VNET_A_CCHIP)
+		.value("neoVIFIRE2_VNET_CCHIP", ChipID::neoVIFIRE2_VNET_CCHIP)
+		.value("neoVIFIRE2_VNET_Core", ChipID::neoVIFIRE2_VNET_Core)
+		.value("RADStar2_ZYNQ", ChipID::RADStar2_ZYNQ)
+		.value("VividCAN_MCHIP", ChipID::VividCAN_MCHIP)
+		.value("neoOBD2SIM_MCHIP", ChipID::neoOBD2SIM_MCHIP)
+		.value("neoVIFIRE2_VNETZ_MCHIP", ChipID::neoVIFIRE2_VNETZ_MCHIP)
+		.value("neoVIFIRE2_VNETZ_ZYNQ", ChipID::neoVIFIRE2_VNETZ_ZYNQ)
+		.value("neoVIFIRE2_Slave_VNETZ_A_MCHIP", ChipID::neoVIFIRE2_Slave_VNETZ_A_MCHIP)
+		.value("neoVIFIRE2_Slave_VNETZ_A_ZYNQ", ChipID::neoVIFIRE2_Slave_VNETZ_A_ZYNQ)
+		.value("VividCAN_EXT_FLASH", ChipID::VividCAN_EXT_FLASH)
+		.value("VividCAN_NRF52", ChipID::VividCAN_NRF52)
+		.value("cmProbe_ZYNQ_Unused", ChipID::cmProbe_ZYNQ_Unused)
+		.value("neoOBD2PRO_MCHIP", ChipID::neoOBD2PRO_MCHIP)
+		.value("ValueCAN4_1_MCHIP", ChipID::ValueCAN4_1_MCHIP)
+		.value("ValueCAN4_2_MCHIP", ChipID::ValueCAN4_2_MCHIP)
+		.value("ValueCAN4_4_2EL_Core", ChipID::ValueCAN4_4_2EL_Core)
+		.value("neoOBD2PRO_SCHIP", ChipID::neoOBD2PRO_SCHIP)
+		.value("ValueCAN4_2EL_MCHIP", ChipID::ValueCAN4_2EL_MCHIP)
+		.value("neoECUAVBTSN_MCHIP", ChipID::neoECUAVBTSN_MCHIP)
+		.value("neoOBD2PRO_Core", ChipID::neoOBD2PRO_Core)
+		.value("RADSupermoon_ZYNQ", ChipID::RADSupermoon_ZYNQ)
+		.value("RADMoon2_ZYNQ", ChipID::RADMoon2_ZYNQ)
+		.value("VividCANPRO_MCHIP", ChipID::VividCANPRO_MCHIP)
+		.value("VividCANPRO_EXT_FLASH", ChipID::VividCANPRO_EXT_FLASH)
+		.value("RADPluto_MCHIP", ChipID::RADPluto_MCHIP)
+		.value("RADMars_ZYNQ", ChipID::RADMars_ZYNQ)
+		.value("neoECU12_MCHIP", ChipID::neoECU12_MCHIP)
+		.value("RADIOCANHUB_MCHIP", ChipID::RADIOCANHUB_MCHIP)
+		.value("FlexRay_VNETZ_ZCHIP", ChipID::FlexRay_VNETZ_ZCHIP)
+		.value("neoOBD2_LCBADGE_MCHIP", ChipID::neoOBD2_LCBADGE_MCHIP)
+		.value("neoOBD2_LCBADGE_SCHIP", ChipID::neoOBD2_LCBADGE_SCHIP)
+		.value("RADMoonDuo_MCHIP", ChipID::RADMoonDuo_MCHIP)
+		.value("neoVIFIRE3_ZCHIP", ChipID::neoVIFIRE3_ZCHIP)
+		.value("FlexRay_VNETZ_FCHIP", ChipID::FlexRay_VNETZ_FCHIP)
+		.value("RADJupiter_MCHIP", ChipID::RADJupiter_MCHIP)
+		.value("ValueCAN4Industrial_MCHIP", ChipID::ValueCAN4Industrial_MCHIP)
+		.value("EtherBADGE_MCHIP", ChipID::EtherBADGE_MCHIP)
+		.value("RADMars_3_ZYNQ", ChipID::RADMars_3_ZYNQ)
+		.value("RADGigastar_USBZ_ZYNQ", ChipID::RADGigastar_USBZ_ZYNQ)
+		.value("RADGigastar_ZYNQ", ChipID::RADGigastar_ZYNQ)
+		.value("RAD4G_MCHIP", ChipID::RAD4G_MCHIP)
+		.value("neoVIFIRE3_SCHIP", ChipID::neoVIFIRE3_SCHIP)
+		.value("RADEpsilon_MCHIP", ChipID::RADEpsilon_MCHIP)
+		.value("RADA2B_ZCHIP", ChipID::RADA2B_ZCHIP)
+		.value("neoOBD2Dev_MCHIP", ChipID::neoOBD2Dev_MCHIP)
+		.value("neoOBD2Dev_SCHIP", ChipID::neoOBD2Dev_SCHIP)
+		.value("neoOBD2SIMDoIP_MCHIP", ChipID::neoOBD2SIMDoIP_MCHIP)
+		.value("SFPModule_MCHIP", ChipID::SFPModule_MCHIP)
+		.value("RADEpsilonT_MCHIP", ChipID::RADEpsilonT_MCHIP)
+		.value("RADEpsilonExpress_MCHIP", ChipID::RADEpsilonExpress_MCHIP)
+		.value("RADProxima_MCHIP", ChipID::RADProxima_MCHIP)
+		.value("NewDevice57_ZCHIP", ChipID::NewDevice57_ZCHIP)
+		.value("RAD_GALAXY_2_ZMPCHIP_ID", ChipID::RAD_GALAXY_2_ZMPCHIP_ID)
+		.value("NewDevice59_MCHIP", ChipID::NewDevice59_MCHIP)
+		.value("RADMoon2_Z7010_ZYNQ", ChipID::RADMoon2_Z7010_ZYNQ)
+		.value("neoVIFIRE2_CORE_SG4", ChipID::neoVIFIRE2_CORE_SG4)
+		.value("RADBMS_MCHIP", ChipID::RADBMS_MCHIP)
+		.value("RADMoon2_ZL_MCHIP", ChipID::RADMoon2_ZL_MCHIP)
+		.value("RADGigastar_USBZ_Z7010_ZYNQ", ChipID::RADGigastar_USBZ_Z7010_ZYNQ)
+		.value("neoVIFIRE3_LINUX", ChipID::neoVIFIRE3_LINUX)
+		.value("RADGigastar_USBZ_Z7007S_ZYNQ", ChipID::RADGigastar_USBZ_Z7007S_ZYNQ)
+		.value("VEM_01_8DW_ZCHIP", ChipID::VEM_01_8DW_ZCHIP)
+		.value("RADGalaxy_FFG_Zynq", ChipID::RADGalaxy_FFG_Zynq)
+		.value("RADMoon3_MCHIP", ChipID::RADMoon3_MCHIP)
+		.value("RADComet_ZYNQ", ChipID::RADComet_ZYNQ)
+		.value("VEM_02_FR_ZCHIP", ChipID::VEM_02_FR_ZCHIP)
+		.value("RADA2B_REVB_ZCHIP", ChipID::RADA2B_REVB_ZCHIP)
+		.value("RADGigastar_FFG_ZYNQ", ChipID::RADGigastar_FFG_ZYNQ)
+		.value("VEM_02_FR_FCHIP", ChipID::VEM_02_FR_FCHIP)
+		.value("Connect_ZCHIP", ChipID::Connect_ZCHIP)
+		.value("RADGALAXY2_SYSMON_CHIP", ChipID::RADGALAXY2_SYSMON_CHIP)
+		.value("RADCOMET3_ZCHIP", ChipID::RADCOMET3_ZCHIP)
+		.value("Connect_LINUX", ChipID::Connect_LINUX)
+		.value("RADGigastar2_ZYNQ", ChipID::RADGigastar2_ZYNQ)
+		.value("RADGemini_MCHIP", ChipID::RADGemini_MCHIP)
+		.value("Invalid", ChipID::Invalid)
+		.finalize();
+}
+
+} // namespace icsneo

bindings/python/icsneopy/device/device.cpp

@@ -11,7 +11,7 @@
 namespace icsneo {
 
 void init_device(pybind11::module_& m) {
-	pybind11::class_<Device, std::shared_ptr<Device>>(m, "Device")
+	pybind11::classh<Device>(m, "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>())
@@ -56,6 +56,7 @@ void init_device(pybind11::module_& m) {
 		.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("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_readonly("settings", &Device::settings);
 }
 

bindings/python/icsneopy/device/devicetype.cpp

@@ -1,14 +1,15 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/native_enum.h>
 
 #include "icsneo/device/devicetype.h"
 
 namespace icsneo {
 
 void init_devicetype(pybind11::module_& m) {
-	pybind11::class_<DeviceType> deviceType(m, "DeviceType");
+	pybind11::classh<DeviceType> deviceType(m, "DeviceType");
-	pybind11::enum_<DeviceType::Enum>(deviceType, "Enum")
+	pybind11::native_enum<DeviceType::Enum>(deviceType, "Enum", "enum.IntEnum")
 		.value("Unknown", DeviceType::Enum::Unknown)
 		.value("BLUE", DeviceType::Enum::BLUE)
 		.value("ECU_AVB", DeviceType::Enum::ECU_AVB)
@@ -36,6 +37,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADEpsilonXL", DeviceType::Enum::RADEpsilonXL)
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
+		.value("RADGemini", DeviceType::Enum::RADGemini)
 		.value("RADComet", DeviceType::Enum::RADComet)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
 		.value("FIRE3_T1S_LIN", DeviceType::Enum::FIRE3_T1S_LIN)
@@ -69,7 +71,8 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADGalaxy", DeviceType::Enum::RADGalaxy)
 		.value("RADStar2", DeviceType::Enum::RADStar2)
 		.value("VividCAN", DeviceType::Enum::VividCAN)
-		.value("OBD2_SIM", DeviceType::Enum::OBD2_SIM);
+		.value("OBD2_SIM", DeviceType::Enum::OBD2_SIM)
+		.finalize();
 	deviceType.def(pybind11::init<DeviceType::Enum>());
 	deviceType.def("get_device_type", &DeviceType::getDeviceType);
 	deviceType.def("get_generic_product_name", &DeviceType::getGenericProductName);

bindings/python/icsneopy/device/extensions/deviceextension.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_deviceextension(pybind11::module_& m) {
-    pybind11::class_<DeviceExtension, std::shared_ptr<DeviceExtension>>(m, "DeviceExtension")
+    pybind11::classh<DeviceExtension>(m, "DeviceExtension")
         .def("get_name", &DeviceExtension::getName);
 }
 

bindings/python/icsneopy/device/idevicesettings.cpp

@@ -16,7 +16,7 @@ struct DeviceSettingsNamespace {
 };
 
 void init_idevicesettings(pybind11::module_& m) {
-    pybind11::class_<DeviceSettingsNamespace> settings(m, "Settings");
+    pybind11::classh<DeviceSettingsNamespace> settings(m, "Settings");
 
     pybind11::enum_<DeviceSettingsNamespace::EthLinkMode>(settings, "EthernetLinkMode")
         .value("Auto", DeviceSettingsNamespace::EthLinkMode::AE_LINK_AUTO)
@@ -31,7 +31,7 @@ void init_idevicesettings(pybind11::module_& m) {
         .value("Speed5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_5000)
         .value("Speed10G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10000);
 
-    pybind11::class_<IDeviceSettings, std::shared_ptr<IDeviceSettings>>(m, "IDeviceSettings")
+    pybind11::classh<IDeviceSettings>(m, "IDeviceSettings")
         .def("apply", &IDeviceSettings::apply, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("apply_defaults", &IDeviceSettings::applyDefaults, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("get_phy_enable", &IDeviceSettings::getPhyEnable, pybind11::call_guard<pybind11::gil_scoped_release>())

bindings/python/icsneopy/device/versionreport.cpp

@@ -0,0 +1,19 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/device/versionreport.h"
+
+namespace icsneo {
+
+void init_versionreport(pybind11::module_& m) {
+	pybind11::classh<VersionReport>(m, "VersionReport")
+		.def_readonly("id", &VersionReport::id)
+		.def_readonly("name", &VersionReport::name)
+		.def_readonly("major", &VersionReport::major)
+		.def_readonly("minor", &VersionReport::minor)
+		.def_readonly("maintenance", &VersionReport::maintenance)
+		.def_readonly("build", &VersionReport::build);
+}
+
+} // namespace icsneo

bindings/python/icsneopy/disk/diskdriver.cpp

@@ -13,7 +13,7 @@ struct DiskNamespace {
 };
 
 void init_diskdriver(pybind11::module_& m) {
-	pybind11::class_<DiskNamespace> disk(m, "Disk");
+	pybind11::classh<DiskNamespace> disk(m, "Disk");
 	pybind11::enum_<Disk::Access>(disk, "Access")
 		.value("None", Disk::Access::None)
 		.value("EntireCard", Disk::Access::EntireCard)

bindings/python/icsneopy/flexray/flexray.cpp

@@ -23,8 +23,8 @@ struct ClusterNamespace {
     using SPPType = icsneo::FlexRay::Cluster::SPPType;
 };
 
-void init_extension(pybind11::class_<FlexRayNamespace>& c) {
+void init_extension(pybind11::classh<FlexRayNamespace>& c) {
-    pybind11::class_<MessageBuffer, std::shared_ptr<MessageBuffer>>(c, "MessageBuffer")
+    pybind11::classh<MessageBuffer>(c, "MessageBuffer")
         .def(pybind11::init())
         .def_readwrite("is_dynamic", &MessageBuffer::isDynamic)
         .def_readwrite("is_sync", &MessageBuffer::isSync)
@@ -39,7 +39,7 @@ void init_extension(pybind11::class_<FlexRayNamespace>& c) {
         .def_readwrite("cycle_repetition", &MessageBuffer::cycleRepetition)
         .def_readwrite("continuous_mode", &MessageBuffer::continuousMode);
 
-    auto controller = pybind11::class_<Controller, std::shared_ptr<Controller>>(c, "Controller")
+    auto controller = pybind11::classh<Controller>(c, "Controller")
         .def("get_network", &Controller::getNetwork)
         .def("get_configuration", &Controller::getConfiguration)
         .def("set_configuration", &Controller::setConfiguration)
@@ -59,7 +59,7 @@ void init_extension(pybind11::class_<FlexRayNamespace>& c) {
         .def("freeze", &Controller::freeze)
         .def("trigger_mts", &Controller::triggerMTS);
 
-    pybind11::class_<Controller::Configuration>(controller, "Configuration")
+    pybind11::classh<Controller::Configuration>(controller, "Configuration")
         .def(pybind11::init())
         .def_readwrite("accept_startup_range_microticks", &Controller::Configuration::AcceptStartupRangeMicroticks)
         .def_readwrite("allow_passive_to_active_cycle_pairs", &Controller::Configuration::AllowPassiveToActiveCyclePairs)
@@ -93,7 +93,7 @@ void init_extension(pybind11::class_<FlexRayNamespace>& c) {
         .def_readwrite("wakeup_on_channel_b", &Controller::Configuration::WakeupOnChannelB);
 
     // Dummy class for cluster namespace
-    pybind11::class_<ClusterNamespace> cluster(c, "Cluster");
+    pybind11::classh<ClusterNamespace> cluster(c, "Cluster");
 
     pybind11::enum_<Cluster::SpeedType>(cluster, "SpeedType")
         .value("FLEXRAY_BAUDRATE_10M", Cluster::SpeedType::FLEXRAY_BAUDRATE_10M)
@@ -107,7 +107,7 @@ void init_extension(pybind11::class_<FlexRayNamespace>& c) {
         .value("FLEXRAY_SPP_6", Cluster::SPPType::FLEXRAY_SPP_6)
         .value("FLEXRAY_SPP_5_ALT", Cluster::SPPType::FLEXRAY_SPP_5_ALT);
 
-    pybind11::class_<Cluster::Configuration>(cluster, "Configuration")
+    pybind11::classh<Cluster::Configuration>(cluster, "Configuration")
         .def(pybind11::init())
         .def_readwrite("speed", &Cluster::Configuration::Speed)
         .def_readwrite("strobe_point_position", &Cluster::Configuration::StrobePointPosition)
@@ -143,7 +143,7 @@ void init_extension(pybind11::class_<FlexRayNamespace>& c) {
 } // namespace FlexRay
 
 void init_flexraymessage(pybind11::module_& m) {
-	pybind11::class_<FlexRayMessage, std::shared_ptr<FlexRayMessage>, Frame>(m, "FlexRayMessage")
+	pybind11::classh<FlexRayMessage, Frame>(m, "FlexRayMessage")
 		.def(pybind11::init())
 		.def_readwrite("slotid", &FlexRayMessage::slotid)
 		.def_readwrite("tsslen", &FlexRayMessage::tsslen)
@@ -166,7 +166,7 @@ void init_flexraymessage(pybind11::module_& m) {
 
 void init_flexray(pybind11::module_& m) {
     // Dummy class to act as FlexRay namespace
-    pybind11::class_<FlexRayNamespace> flexray(m, "FlexRay");
+    pybind11::classh<FlexRayNamespace> flexray(m, "FlexRay");
     
     pybind11::enum_<FlexRayNamespace::Symbol>(flexray, "Symbol")
         .value("None", FlexRayNamespace::Symbol::None)

bindings/python/icsneopy/icsneocpp.cpp

@@ -22,10 +22,12 @@ void init_gptpstatusmessage(pybind11::module_&);
 void init_mdiomessage(pybind11::module_&);
 void init_spimessage(pybind11::module_&);
 void init_ethernetstatusmessage(pybind11::module_&);
-void init_macsecmessage(pybind11::module_&);
+void init_macsecconfig(pybind11::module_&);
 void init_scriptstatusmessage(pybind11::module_&);
 void init_diskdriver(pybind11::module_&);
 void init_deviceextension(pybind11::module_&);
+void init_chipid(pybind11::module_&);
+void init_versionreport(pybind11::module_&);
 void init_device(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
@@ -55,7 +57,7 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_gptpstatusmessage(m);
 	init_mdiomessage(m);
 	init_ethernetstatusmessage(m);
-	init_macsecmessage(m);
+	init_macsecconfig(m);
 	init_scriptstatusmessage(m);
 	init_spimessage(m);
 	init_messagefilter(m);
@@ -63,6 +65,8 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_diskdriver(m);
     init_flexray(m);
 	init_ethphymessage(m);
+	init_chipid(m);
+	init_versionreport(m);
 	init_device(m);
     init_deviceextension(m);
 	init_idevicesettings(m);

ci/bootstrap-cibuildwheel.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+yum install -y flex ca-certificates || exit 1
+
+echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
+
+update-ca-trust || exit 1

ci/build-posix.sh

@@ -1,6 +1,5 @@
 #!/bin/sh
-export CFLAGS="-Wall -Werror"
+
-export CXXFLAGS="-Wall -Werror"
 cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON \
 	-DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
 

ci/build-windows.bat

@@ -1,12 +1,9 @@
-REM clean intermediate directories
+@setlocal
-rmdir /s /q build
+@echo off
-mkdir build
 
-REM build
+mkdir build >nul 2>&1
-cd build
+
-set CFLAGS=/WX /W4 /wd4127
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_UNIT_TESTS=ON ^
-set CXXFLAGS=/WX /W4 /wd4127
+    -DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
-cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=ON ..
+
-if %errorlevel% neq 0 exit /b %errorlevel%
+cmake --build build || exit /b 1
-cmake --build .
-if %errorlevel% neq 0 exit /b %errorlevel%

communication/communication.cpp

@@ -14,6 +14,12 @@
 #include "icsneo/communication/message/readsettingsmessage.h"
 #include "icsneo/communication/message/versionmessage.h"
 #include "icsneo/communication/message/componentversionsmessage.h"
+#include "icsneo/communication/message/filter/extendedresponsefilter.h"
+#include "icsneo/communication/message/clientidmessage.h"
+#include "icsneo/communication/icspb.h"
+
+#include <commands/generic/v1/client_id.pb.h>
+#include <commands/network/v1/mutex.pb.h>
 
 using namespace icsneo;
 
@@ -313,3 +319,32 @@ std::optional< std::vector<ComponentVersion> > Communication::getComponentVersio
 
 	return std::make_optional< std::vector<ComponentVersion> >(std::move(ver->versions));
 }
+
+std::optional<uint32_t> Communication::getClientIDSync() {	
+	constexpr auto timeout = std::chrono::milliseconds(250);
+	commands::generic::v1::ClientId msg;
+	msg.Clear();
+
+	std::vector<uint8_t> payload = protoapi::getPayload(protoapi::Command::GET, msg);
+
+	std::shared_ptr<Message> response = waitForMessageSync(
+		[this, payload](){
+			return sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<MessageFilter>(Message::Type::ClientId),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	auto clientIdMessage = std::dynamic_pointer_cast<ClientIdMessage>(response);
+	if(!clientIdMessage) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	return clientIdMessage->clientId;
+}

communication/decoder.cpp

@@ -23,6 +23,8 @@
 #include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/message/ethernetstatusmessage.h"
+#include "icsneo/communication/message/networkmutexmessage.h"
+#include "icsneo/communication/message/clientidmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -44,6 +46,8 @@
 #include "icsneo/communication/packet/livedatapacket.h"
 #include "icsneo/communication/packet/hardwareinfopacket.h"
 #include "icsneo/communication/packet/spipacket.h"
+#include "icsneo/communication/icspb.h"
+
 
 #include <iostream>
 
@@ -58,7 +62,8 @@ uint64_t Decoder::GetUInt64FromLEBytes(const uint8_t* bytes) {
 
 bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) {
 	switch(packet->network.getType()) {
-		case Network::Type::Ethernet: {
+		case Network::Type::Ethernet:
+		case Network::Type::AutomotiveEthernet: {
 			result = HardwareEthernetPacket::DecodeToMessage(packet->data);
 			if(!result) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
@@ -273,7 +278,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						result = can;
 					}
 
-					result->timestamp *= timestampResolution;
+					result->timestamp = can->timestamp * timestampResolution;
 					return true;
 				}
 				case Network::NetID::DeviceStatus: {
@@ -338,6 +343,25 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 							result = GPTPStatus::DecodeToMessage(packet->data, report);
 							return true;
 						}
+						case ExtendedCommand::ProtobufAPI: {
+							// get the proto id
+							std::vector<uint8_t> responseBody(
+								packet->data.begin() + sizeof(ExtendedResponseMessage::ResponseHeader),
+								packet->data.end()
+							);
+							protoapi::Id protoId = protoapi::getProtoId(responseBody.data(), responseBody.size());
+							switch(protoId) {
+								case protoapi::Id::NetworkMutex:
+									result = NetworkMutexMessage::DecodeToMessage(responseBody);
+									return true;
+								case protoapi::Id::ClientId:
+									result = ClientIdMessage::DecodeToMessage(responseBody);
+									return true;
+								default:
+									report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+									return false;
+							}
+						}
 						case ExtendedCommand::GetDiskDetails:
 						case ExtendedCommand::DiskFormatProgress: {
 							std::vector<uint8_t> responseBody(

communication/driver.cpp

@@ -71,8 +71,12 @@ bool Driver::write(const std::vector<uint8_t>& bytes) {
 
 	if(writeBlocks) {
 		if(writeQueueFull()) {
-			while(writeQueueAlmostFull()) // Wait until we have some decent amount of space
+			while(writeQueueAlmostFull() && !isDisconnected() && !isClosing()) // Wait until we have some decent amount of space
 				std::this_thread::sleep_for(std::chrono::milliseconds(10));
+			
+			if(isDisconnected() || isClosing()) {
+				return false;
+			}
 		}
 	} else {
 		if(writeQueueFull()) {

communication/encoder.cpp

@@ -32,7 +32,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			netid = uint16_t(frame->network.getNetID());
 
 			switch(frame->network.getType()) {
-				case Network::Type::Ethernet: {
+				case Network::Type::Ethernet:
+				case Network::Type::AutomotiveEthernet: {
 					auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
 					if(!ethmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -55,6 +56,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 					break;
 				}
+				case Network::Type::Internal:
 				case Network::Type::CAN:
 				case Network::Type::SWCAN:
 				case Network::Type::LSFTCAN: {
@@ -283,6 +285,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			case Command::RequestSerialNumber:
 			case Command::EnableNetworkCommunication:
 			case Command::EnableNetworkCommunicationEx:
+			case Command::KeepAlive:
 			case Command::GetMainVersion:
 			case Command::GetSecondaryVersions:
 			case Command::NeoReadMemory:

communication/message/clientidmessage.cpp

@@ -0,0 +1,21 @@
+#include "icsneo/communication/message/clientidmessage.h"
+#include "icsneo/communication/icspb.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+
+using namespace icsneo;
+
+std::shared_ptr<ClientIdMessage> ClientIdMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	ClientIdMessage decoded;
+	commands::generic::v1::ClientId msg;
+
+	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
+		return nullptr;
+	}
+
+	if(msg.has_client_id()) {
+		decoded.clientId.emplace(msg.client_id());
+	}
+
+	return std::make_shared<ClientIdMessage>(decoded);
+}

communication/message/ethernetstatusmessage.cpp

@@ -13,7 +13,15 @@ enum LinkSpeed {
 	ethSpeed10000,
 };
 
-enum LinkMode {
+enum TLinkMode {
+	T_LINK_NONE,
+	T_LINK_MASTER,
+	T_LINK_SLAVE,
+	T_LINK_AUTO,
+	T_LINK_INVALID = 255,
+};
+
+enum AELinkMode {
 	AE_LINK_AUTO,
 	AE_LINK_MASTER,
 	AE_LINK_SLAVE,
@@ -46,11 +54,26 @@ std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vecto
 		default: return nullptr;
 	}
 	LinkMode mode;
-	switch(packet->mode) {
+	switch(Network::GetTypeOfNetID((Network::NetID)packet->network, false)) {
-		case AE_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
+		case Network::Type::Ethernet:
-		case AE_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
+			switch(packet->mode) {
-		case AE_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+				case T_LINK_NONE: mode = EthernetStatusMessage::LinkMode::LinkModeNone; break;
-		case AE_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+				case T_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+				case T_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+				case T_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
+				case T_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
+				default: return nullptr;
+			}
+			break;
+		case Network::Type::AutomotiveEthernet:
+			switch(packet->mode) {
+				case AE_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
+				case AE_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+				case AE_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+				case AE_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
+				default: return nullptr;
+			}
+			break;
 		default: return nullptr;
 	}
 	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state, speed, packet->duplex, mode);

communication/message/macsecmessage.cpp

@@ -1,531 +0,0 @@
-#include "icsneo/communication/message/macsecmessage.h"
-
-#include "icsneo/communication/crc32.h"
-#include <memory>
-#include <cstdint>
-#include <iostream>
-#include <cstring>
-
-namespace icsneo
-{
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201) // nameless struct/union
-#endif
-
-#pragma pack(push, 1)
-/* MACsec Rule */
-/**
- * @brief Structure of Vlan tag
- *
- */
-typedef struct
-{
-	uint16_t vid; /*!< 12 bits */
-	uint8_t priCfi; /*!< PRI - 3 bits, CFI - 1bit */
-} MACSEC_VLANTAG_t;
-/**
- * @brief Structure of MPLS
- *
- */
-typedef struct
-{
-	uint32_t mplsLabel; /*!< 20 bits */
-	uint8_t exp; /*!< 3 bits */
-} MACSEC_MPLS_OUTER_t;
-/**
- * @brief Define Encoded Packet Type from the parser
- *
- */
-static constexpr int MACSEC_SETTINGS_RULE_SIZE = 88;
-typedef union _MACSecRule
-{
-	struct
-	{
-		uint8_t index;
-		uint8_t keyMacDa[6]; /*!< MAC DA field extracted from the packet */
-		uint8_t maskMacDa[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t keyMacSa[6]; /*!< MAC SA field extracted from the packet */
-		uint8_t maskMacSa[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t keyEthertype; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
-		uint16_t maskEthertype; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_VLANTAG_t keyVlanTagOuter1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-		MACSEC_MPLS_OUTER_t keyMplsOuter1;
-		MACSEC_VLANTAG_t maskVlanTagOuter1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_MPLS_OUTER_t maskMplsOuter1;
-		MACSEC_VLANTAG_t keyVlanTagOuter2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-		MACSEC_MPLS_OUTER_t keyMplsOuter2;
-		MACSEC_VLANTAG_t maskVlanTagOuter2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_MPLS_OUTER_t maskMplsOuter2;
-		uint16_t keyBonusData; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
-		uint16_t maskBonusData; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t
-			keyTagMatchBitmap; /*!< 8 bits total. Maps 1 to 1 bitwise with the set of custom tags. (set bit[N]=1 if check Nth custom tag) */
-		uint8_t maskTagMatchBitmap; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t keyPacketType; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
-		uint8_t maskPacketType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t
-			keyInnerVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
-		uint16_t maskInnerVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t keyOuterVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
-		uint16_t maskOuterVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t
-			keyNumTags; /*!< 7 bits total. Number of VLAN/custom tags or MPLS lables detected. Ingress: before SecTag; Egress: total detected. Exclude MCS header tags. i.e. Bit 2: 2 tags/labels before SecTAG...Bit 6: 6 or more tags/labels before SecTAG. */
-		uint8_t maskNumTags; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t keyExpress; /*!< 1 bits. Express packet. */
-		uint8_t maskExpress; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t isMpls;
-		uint8_t rsvd[5];
-		uint8_t enable;
-	};
-	uint8_t byte[MACSEC_SETTINGS_RULE_SIZE];
-} MACSecRule_t;
-/* MACsec Map */
-static constexpr int MACSEC_SETTINGS_MAP_SIZE = 20;
-typedef union _MACSecMap
-{
-	struct
-	{
-		uint8_t index;
-		uint64_t secTagSci; /*!< Identifies the SecTAG SCI for this Flow. */
-		uint8_t secYIndex; /*!< index for entry in Egress secY Policy */
-		uint8_t isControlPacket; /*!< Identifies all packets matching this index lookup as control packets. */
-		uint8_t scIndex; /*!< Identifies the SC for this Flow. */
-		uint8_t auxiliaryPlcy; /*!< Auxiliary policy bits. */
-		uint8_t ruleId; /*!< Identifies the Rule for this Flow. */
-		uint8_t rsvd[5];
-		uint8_t enable;
-	};
-	uint8_t byte[MACSEC_SETTINGS_MAP_SIZE];
-} MACSecMap_t;
-/* MACsec SecY */
-/**
- * @brief Define the permit police for frames as defined in 802.1ae
- *
- */
-static constexpr int MACSEC_SETTINGS_SECY_SIZE = 24;
-typedef union _MACSecSecY
-{
-	struct
-	{
-		uint8_t index; /*!< Identifies the SecY for this Flow. */
-		uint8_t controlledPortEnabled; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
-		uint8_t frameValidationType; /*!< see MACSEC_VALIDATEFRAME */
-		uint8_t secTagIcvStripType; /*!< see MACSEC_STRIP_SECTAG_ICV */
-		uint8_t cipher; /*!< Define the cipher suite to use for this SecY see MACSEC_CIPHER_SUITE */
-		uint8_t confidentialOffset; /*!< Define the number of bytes that are unencrypted following the SecTag. */
-		uint8_t icvIncludesDaSa; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
-		uint8_t replayProtect; /*!< Enables Anti-Replay protection */
-		uint32_t replayWindow; /*!< Unsigned value indicating the size of the anti-replay window. */
-		uint8_t
-			protectFrames; /*!< 0 = do not encrypt or authenticate this packet; 1 = always Authenticate frame and if SecTag.TCI.E = 1 encrypt the packet as well. */
-		uint8_t
-			secTagOffset; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
-		uint8_t secTagTci; /*!< Tag Control Information excluding the AN field which originates from the SA Policy table */
-		uint16_t mtu; /*!< Specifies the outgoing MTU for this SecY */
-		uint8_t rsvd[6];
-		uint8_t enable;
-	};
-	uint8_t byte[MACSEC_SETTINGS_SECY_SIZE];
-} MACSecSecY_t;
-/* MACsec SC */
-static constexpr int MACSEC_SETTINGS_SC_SIZE = 24;
-typedef union _MACSecSc
-{
-	struct
-	{
-		uint8_t index; /*!< SC index. */
-		uint8_t secYIndex; /*!< SecY associated with this packet. */
-		uint64_t sci; /*!< The Secure Channel Identifier. */
-		uint8_t saIndex0; /*!< Define the 1st SA to use */
-		uint8_t saIndex1; /*!< Define the 2nd SA to use */
-		uint8_t saIndex0InUse; /*!< Specifies whether 1st SA is in use or not. */
-		uint8_t saIndex1InUse; /*!< Specifies whether 2nd SA is in use or not.  */
-		uint8_t enableAutoRekey; /*!< If enabled, then once the pn_threshold is reached, auto rekey will happen. */
-		uint8_t
-			isActiveSa1; /*!< If set, then sa_index1 is the currently active SA index. If cleared, the sa_index0 is the currently active SA index). */
-		uint8_t rsvd[7];
-		uint8_t enable;
-	};
-	uint8_t byte[MACSEC_SETTINGS_SC_SIZE];
-} MACSecSc_t;
-/* MACsec SA */
-static constexpr int MACSEC_SETTINGS_SA_SIZE = 80;
-typedef union _MACSecSa
-{
-	struct
-	{
-		uint8_t index; /*!< SA index */
-		uint8_t
-			sak[32]; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
-		uint8_t hashKey[16]; /*!< 128b Hash Key: Key used for authentication. */
-		uint8_t salt[12]; /*!< 96b Salt value: Salt value used in XPN ciphers. */
-		uint32_t ssci; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
-		uint8_t an; /*!< 2b SecTag Association Number (AN) */
-		uint64_t nextPn; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
-		uint8_t rsvd[5];
-		uint8_t enable;
-	};
-	uint8_t byte[MACSEC_SETTINGS_SA_SIZE];
-} MACSecSa_t;
-/* MACsec Flags */
-typedef union _MACSecFlags
-{
-	struct
-	{
-		uint32_t en : 1; // '1' = enable; '0' = disable
-		uint32_t reserved : 31;
-	};
-	uint32_t flags_32b;
-} MACSecFlags_t;
-#define MACSEC_SETTINGS_FLAGS_SIZE (4)
-/* MACSec Settings for 1 port/phy */
-typedef struct MACSEC_CONFIG_t
-{
-	MACSecFlags_t flags;
-	MACSecRule_t rule[MACsecConfig::NumRules];
-	MACSecMap_t map[MACsecConfig::NumMaps];
-	MACSecSecY_t secy[MACsecConfig::NumSecY];
-	MACSecSc_t sc[MACsecConfig::NumSc];
-	MACSecSa_t sa[MACsecConfig::NumSa];
-} MACSEC_CONFIG;
-typedef union _MACSecGlobalFlags
-{
-	struct
-	{
-		uint32_t en : 1; // '1' = enable; '0' = disable
-		uint32_t nvm : 1; // store macsec config in non-volatile memory
-		uint32_t reserved : 30;
-	};
-	uint32_t flags_32b;
-} MACSecGlobalFlags_t;
-#define MACSEC_SETTINGS_SIZE (2040) // leave space for expansion and keep nicely aligned for flashing
-typedef union _MACSEC_SETTINGS
-{
-	struct
-	{
-		MACSecGlobalFlags_t flags;
-		MACSEC_CONFIG rx;
-		MACSEC_CONFIG tx;
-	};
-	uint8_t byte[MACSEC_SETTINGS_SIZE];
-} MACSEC_SETTINGS;
-
-#define MACSEC_SETTINGS_VERSION 1
-struct MACSEC_SETTINGS_W_HDR
-{
-	uint16_t version;
-	uint16_t len;
-	uint32_t crc32;
-	MACSEC_SETTINGS macsec;
-};
-
-#pragma pack(pop)
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-std::shared_ptr<MACsecMessage> MACsecMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report)
-{
-	if (bytestream.empty() || (bytestream.size() < sizeof(MACSEC_SETTINGS_W_HDR)))
-	{
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	MACSEC_SETTINGS_W_HDR* macsecArgs = (MACSEC_SETTINGS_W_HDR*)bytestream.data();
-	if (macsecArgs->version != MACSEC_SETTINGS_VERSION)
-	{
-		report(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
-		return nullptr;
-	}
-	if (macsecArgs->len != sizeof(MACSEC_SETTINGS))
-	{
-		report(APIEvent::Type::SettingsLengthError, APIEvent::Severity::Error);
-		return nullptr;
-	}
-	const auto crcCalculted = crc32(0, (uint8_t*)&macsecArgs->macsec, macsecArgs->len);
-	if (macsecArgs->crc32 != crcCalculted)
-	{
-		report(APIEvent::Type::SettingsChecksumError, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	auto msg = std::make_shared<MACsecMessage>();
-
-	const auto& copyConfig = [](const MACSEC_CONFIG& source, MACsecConfig& dest)
-	{
-		dest.flags.en = source.flags.en;
-		for (int index = 0; index < MACsecConfig::NumRules; index++)
-		{
-			if(!source.rule[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.rule[index].___name__ = (decltype(dest.rule[index].___name__))source.rule[index].___name__
-#undef __COPY_ARR
-#define __COPY_ARR(___name__) (void)memcpy(dest.rule[index].___name__.data(), source.rule[index].___name__, dest.rule[index].___name__.size())
-			__COPY_ITEM(index);
-			__COPY_ARR(keyMacDa);
-			__COPY_ARR(maskMacDa);
-			__COPY_ARR(keyMacSa);
-			__COPY_ARR(maskMacSa);
-			__COPY_ITEM(keyVlanTagOuter1.vid);
-			__COPY_ITEM(keyVlanTagOuter1.priCfi);
-			__COPY_ITEM(keyMplsOuter1.mplsLabel);
-			__COPY_ITEM(keyMplsOuter1.exp);
-			__COPY_ITEM(maskVlanTagOuter1.vid);
-			__COPY_ITEM(maskVlanTagOuter1.priCfi);
-			__COPY_ITEM(maskMplsOuter1.mplsLabel);
-			__COPY_ITEM(maskMplsOuter1.exp);
-			__COPY_ITEM(keyVlanTagOuter2.vid);
-			__COPY_ITEM(keyVlanTagOuter2.priCfi);
-			__COPY_ITEM(keyMplsOuter2.mplsLabel);
-			__COPY_ITEM(keyMplsOuter2.exp);
-			__COPY_ITEM(maskVlanTagOuter2.vid);
-			__COPY_ITEM(maskVlanTagOuter2.priCfi);
-			__COPY_ITEM(maskMplsOuter2.mplsLabel);
-			__COPY_ITEM(maskMplsOuter2.exp);
-			__COPY_ITEM(keyEthertype);
-			__COPY_ITEM(maskEthertype);
-			__COPY_ITEM(keyBonusData);
-			__COPY_ITEM(maskBonusData);
-			__COPY_ITEM(keyTagMatchBitmap);
-			__COPY_ITEM(maskTagMatchBitmap);
-			__COPY_ITEM(keyPacketType);
-			__COPY_ITEM(maskPacketType);
-			__COPY_ITEM(keyInnerVlanType);
-			__COPY_ITEM(maskInnerVlanType);
-			__COPY_ITEM(keyOuterVlanType);
-			__COPY_ITEM(maskOuterVlanType);
-			__COPY_ITEM(keyNumTags);
-			__COPY_ITEM(maskNumTags);
-			__COPY_ITEM(keyExpress);
-			__COPY_ITEM(maskExpress);
-			__COPY_ITEM(isMpls);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumMaps; index++)
-		{
-			if(!source.map[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.map[index].___name__ = source.map[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(secTagSci);
-			__COPY_ITEM(secYIndex);
-			__COPY_ITEM(isControlPacket);
-			__COPY_ITEM(scIndex);
-			__COPY_ITEM(auxiliaryPlcy);
-			__COPY_ITEM(ruleId);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSecY; index++)
-		{
-			if(!source.secy[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.secy[index].___name__ = (decltype(dest.secy[index].___name__))source.secy[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(controlledPortEnabled);
-			__COPY_ITEM(frameValidationType);
-			__COPY_ITEM(secTagIcvStripType);
-			__COPY_ITEM(cipher);
-			__COPY_ITEM(confidentialOffset);
-			__COPY_ITEM(icvIncludesDaSa);
-			__COPY_ITEM(replayProtect);
-			__COPY_ITEM(replayWindow);
-			__COPY_ITEM(protectFrames);
-			__COPY_ITEM(secTagOffset);
-			__COPY_ITEM(secTagTci);
-			__COPY_ITEM(mtu);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSc; index++)
-		{
-			if(!source.sc[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.sc[index].___name__ = source.sc[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(secYIndex);
-			__COPY_ITEM(sci);
-			__COPY_ITEM(saIndex0);
-			__COPY_ITEM(saIndex1);
-			__COPY_ITEM(saIndex0InUse);
-			__COPY_ITEM(saIndex1InUse);
-			__COPY_ITEM(enableAutoRekey);
-			__COPY_ITEM(isActiveSa1);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSa; index++)
-		{
-			if(!source.sa[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.sa[index].___name__ = source.sa[index].___name__
-#undef __COPY_ARR
-#define __COPY_ARR(___name__) (void)memcpy(dest.sa[index].___name__.data(), source.sa[index].___name__, dest.sa[index].___name__.size())
-			__COPY_ITEM(index);
-			__COPY_ARR(sak);
-			__COPY_ARR(hashKey);
-			__COPY_ARR(salt);
-			__COPY_ITEM(ssci);
-			__COPY_ITEM(an);
-			__COPY_ITEM(nextPn);
-			__COPY_ITEM(enable);
-		}
-	};
-
-	msg->flags.en = macsecArgs->macsec.flags.en;
-	copyConfig(macsecArgs->macsec.rx, msg->rx);
-	copyConfig(macsecArgs->macsec.tx, msg->tx);
-
-	return msg;
-}
-
-bool MACsecMessage::EncodeFromMessage(std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) const
-{
-	MACSEC_SETTINGS_W_HDR* macsecArgs;
-
-	bytestream.resize(sizeof(MACSEC_SETTINGS_W_HDR), 0);
-	macsecArgs = (MACSEC_SETTINGS_W_HDR*)bytestream.data();
-
-	macsecArgs->version = MACSEC_SETTINGS_VERSION;
-	macsecArgs->len = sizeof(MACSEC_SETTINGS_W_HDR);
-
-	const auto& copyConfig = [](const MACsecConfig& source, MACSEC_CONFIG& dest)
-	{
-		dest.flags.en = (uint8_t)source.flags.en;
-		for (int index = 0; index < MACsecConfig::NumRules; index++)
-		{
-			if(!source.rule[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.rule[index].___name__ = (decltype(dest.rule[index].___name__))source.rule[index].___name__
-#undef __COPY_ARR
-#define __COPY_ARR(___name__) (void)memcpy(dest.rule[index].___name__, source.rule[index].___name__.data(), source.rule[index].___name__.size())
-			__COPY_ITEM(index);
-			__COPY_ARR(keyMacDa);
-			__COPY_ARR(maskMacDa);
-			__COPY_ARR(keyMacSa);
-			__COPY_ARR(maskMacSa);
-			__COPY_ITEM(keyVlanTagOuter1.vid);
-			__COPY_ITEM(keyVlanTagOuter1.priCfi);
-			__COPY_ITEM(keyMplsOuter1.mplsLabel);
-			__COPY_ITEM(keyMplsOuter1.exp);
-			__COPY_ITEM(maskVlanTagOuter1.vid);
-			__COPY_ITEM(maskVlanTagOuter1.priCfi);
-			__COPY_ITEM(maskMplsOuter1.mplsLabel);
-			__COPY_ITEM(maskMplsOuter1.exp);
-			__COPY_ITEM(keyVlanTagOuter2.vid);
-			__COPY_ITEM(keyVlanTagOuter2.priCfi);
-			__COPY_ITEM(keyMplsOuter2.mplsLabel);
-			__COPY_ITEM(keyMplsOuter2.exp);
-			__COPY_ITEM(maskVlanTagOuter2.vid);
-			__COPY_ITEM(maskVlanTagOuter2.priCfi);
-			__COPY_ITEM(maskMplsOuter2.mplsLabel);
-			__COPY_ITEM(maskMplsOuter2.exp);
-			__COPY_ITEM(keyEthertype);
-			__COPY_ITEM(maskEthertype);
-			__COPY_ITEM(keyBonusData);
-			__COPY_ITEM(maskBonusData);
-			__COPY_ITEM(keyTagMatchBitmap);
-			__COPY_ITEM(maskTagMatchBitmap);
-			__COPY_ITEM(keyPacketType);
-			__COPY_ITEM(maskPacketType);
-			__COPY_ITEM(keyInnerVlanType);
-			__COPY_ITEM(maskInnerVlanType);
-			__COPY_ITEM(keyOuterVlanType);
-			__COPY_ITEM(maskOuterVlanType);
-			__COPY_ITEM(keyNumTags);
-			__COPY_ITEM(maskNumTags);
-			__COPY_ITEM(keyExpress);
-			__COPY_ITEM(maskExpress);
-			__COPY_ITEM(isMpls);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumMaps; index++)
-		{
-			if(!source.map[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.map[index].___name__ = source.map[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(secTagSci);
-			__COPY_ITEM(secYIndex);
-			__COPY_ITEM(isControlPacket);
-			__COPY_ITEM(scIndex);
-			__COPY_ITEM(auxiliaryPlcy);
-			__COPY_ITEM(ruleId);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSecY; index++)
-		{
-			if(!source.secy[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.secy[index].___name__ = (decltype(dest.secy[index].___name__))source.secy[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(controlledPortEnabled);
-			__COPY_ITEM(frameValidationType);
-			__COPY_ITEM(secTagIcvStripType);
-			__COPY_ITEM(cipher);
-			__COPY_ITEM(confidentialOffset);
-			__COPY_ITEM(icvIncludesDaSa);
-			__COPY_ITEM(replayProtect);
-			__COPY_ITEM(replayWindow);
-			__COPY_ITEM(protectFrames);
-			__COPY_ITEM(secTagOffset);
-			__COPY_ITEM(secTagTci);
-			__COPY_ITEM(mtu);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSc; index++)
-		{
-			if(!source.sc[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.sc[index].___name__ = source.sc[index].___name__
-			__COPY_ITEM(index);
-			__COPY_ITEM(secYIndex);
-			__COPY_ITEM(sci);
-			__COPY_ITEM(saIndex0);
-			__COPY_ITEM(saIndex1);
-			__COPY_ITEM(saIndex0InUse);
-			__COPY_ITEM(saIndex1InUse);
-			__COPY_ITEM(enableAutoRekey);
-			__COPY_ITEM(isActiveSa1);
-			__COPY_ITEM(enable);
-		}
-
-		for (int index = 0; index < MACsecConfig::NumSa; index++)
-		{
-			if(!source.sa[index].enable) continue;
-#undef __COPY_ITEM
-#define __COPY_ITEM(___name__) dest.sa[index].___name__ = source.sa[index].___name__
-#undef __COPY_ARR
-#define __COPY_ARR(___name__) (void)memcpy(dest.sa[index].___name__, source.sa[index].___name__.data(), source.sa[index].___name__.size())
-			__COPY_ITEM(index);
-			__COPY_ARR(sak);
-			__COPY_ARR(hashKey);
-			__COPY_ARR(salt);
-			__COPY_ITEM(ssci);
-			__COPY_ITEM(an);
-			__COPY_ITEM(nextPn);
-			__COPY_ITEM(enable);
-		}
-	};
-	macsecArgs->macsec.flags.en = this->flags.en;
-	macsecArgs->macsec.flags.nvm = this->flags.nvm;
-
-	copyConfig(this->rx, macsecArgs->macsec.rx);
-	copyConfig(this->tx, macsecArgs->macsec.tx);
-
-	macsecArgs->crc32 = crc32(0, (uint8_t*)&macsecArgs->macsec, sizeof(MACSEC_SETTINGS));
-
-	(void)report;
-
-	return true;
-}
-
-} // namespace icsneo

communication/message/neomessage.cpp

@@ -44,7 +44,8 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				can.status.canfdESI = canmsg->errorStateIndicator;
 				break;
 			}
-			case Network::Type::Ethernet: {
+			case Network::Type::Ethernet:
+			case Network::Type::AutomotiveEthernet: {
 				neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
 				auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
 				eth.preemptionFlags = ethmsg->preemptionFlags;
@@ -142,7 +143,8 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					canmsg->errorStateIndicator = can.status.canfdESI;
 					return canmsg;
 				}
-				case Network::Type::Ethernet: {
+				case Network::Type::Ethernet:
+				case Network::Type::AutomotiveEthernet: {
 					neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage;
 					auto ethmsg = std::make_shared<EthernetMessage>();
 					ethmsg->network = network;

communication/message/networkmutexmessage.cpp

@@ -0,0 +1,89 @@
+#include "icsneo/communication/message/networkmutexmessage.h"
+#include "icsneo/communication/icspb.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+
+
+using namespace icsneo;
+
+std::shared_ptr<NetworkMutexMessage> NetworkMutexMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	NetworkMutexMessage decoded;
+	commands::network::v1::NetworkMutex msg;
+
+	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
+		return nullptr;
+	}
+
+	if(msg.has_client_id()) {
+		decoded.owner_id.emplace(msg.client_id());
+	}
+	if(msg.has_type()) {
+		decoded.type.emplace(static_cast<NetworkMutexType>(msg.type()));
+	}
+	if(msg.has_priority()) {
+		decoded.priority.emplace(msg.priority());
+	}
+	if(msg.has_ttl()){
+		decoded.ttlMs.emplace(msg.ttl());
+	}
+	if(msg.has_event()){
+		decoded.event.emplace(static_cast<NetworkMutexEvent>(msg.event()));
+	}
+	for(int i = 0 ; i < msg.network_ids_size(); ++i){
+		decoded.networks.emplace(static_cast<Network::NetID>(msg.network_ids(i)));
+	}
+	return std::make_shared<NetworkMutexMessage>(decoded);
+}
+
+std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForLock(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const std::set<Network::NetID>& networks, const device_eventhandler_t& /* report */) {
+	commands::network::v1::NetworkMutex msg;
+	for(auto&& network_id : networks) {
+		msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network_id));
+	}
+	msg.set_client_id(client_id);
+	msg.set_priority(priority);
+	msg.set_ttl(ttlMs);
+	msg.set_type(static_cast<commands::network::v1::MutexType>(type));
+
+	return protoapi::getPayload(protoapi::Command::PUT, msg);
+}
+
+std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForLockAll(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const device_eventhandler_t& /* report */) {
+	commands::network::v1::NetworkMutex msg;
+	msg.set_client_id(client_id);
+	msg.set_priority(priority);
+	msg.set_ttl(ttlMs);
+	msg.set_type(static_cast<commands::network::v1::MutexType>(type));
+	msg.set_global(true);
+
+	return protoapi::getPayload(protoapi::Command::PUT, msg);
+}
+
+std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForUnlock(uint32_t client_id, const std::set<Network::NetID>& networks, const device_eventhandler_t& /* report */) {
+	commands::network::v1::NetworkMutex msg;
+	msg.Clear();
+	for(auto&& network_id : networks)
+	{
+		msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network_id));
+	}
+	msg.set_client_id(client_id);
+	msg.set_release(true);
+
+	return protoapi::getPayload(protoapi::Command::PUT, msg);
+}
+
+std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForUnlockAll(uint32_t client_id, const device_eventhandler_t& /* report */) {
+	commands::network::v1::NetworkMutex msg;
+	msg.Clear();
+	msg.set_client_id(client_id);
+	msg.set_release(true);
+	msg.set_global(true);
+
+	return protoapi::getPayload(protoapi::Command::PUT, msg);
+}
+
+std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForStatus(Network::NetID network, const device_eventhandler_t& /* report */) {
+	commands::network::v1::NetworkMutex msg;
+	msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network));
+	return protoapi::getPayload(protoapi::Command::GET, msg);
+}

communication/message/transmitmessage.cpp

@@ -0,0 +1,163 @@
+#include "icsneo/communication/message/transmitmessage.h"
+
+// packet defs
+#include "icsneo/communication/packet/ethernetpacket.h"
+#include "icsneo/communication/packet/canpacket.h"
+#include "icsneo/communication/packet/linpacket.h"
+
+using namespace icsneo;
+
+// copied.. TODO
+static std::optional<uint8_t> CAN_LengthToDLC(size_t dataLength, bool fd) {
+	if(dataLength <= 8)
+		return uint8_t(dataLength);
+
+	if(fd) {
+		if(dataLength <= 12)
+			return uint8_t(0x9);
+		if(dataLength <= 16)
+			return uint8_t(0xA);
+		if(dataLength <= 20)
+			return uint8_t(0xB);
+		if(dataLength <= 24)
+			return uint8_t(0xC);
+		if(dataLength <= 32)
+			return uint8_t(0xD);
+		if(dataLength <= 48)
+			return uint8_t(0xE);
+		if(dataLength <= 64)
+			return uint8_t(0xF);
+	}
+
+	return std::nullopt;
+}
+
+static std::vector<uint8_t> EncodeFromMessageEthernet(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
+	auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(frame);
+	if(!ethmsg) {
+		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+		return {};
+	}
+	std::vector<uint8_t> encoded;
+	size_t messageLen = ethmsg->data.size();
+	encoded.resize(sizeof(TransmitMessage) + messageLen);
+
+	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
+	HardwareEthernetPacket* const ethpacket = (HardwareEthernetPacket*)(msg->commonHeader);
+	uint8_t* const payload = encoded.data() + sizeof(TransmitMessage);
+
+	ethpacket->header.ENABLE_PADDING = ethmsg->noPadding ? 0 : 1;
+	ethpacket->header.FCS_OVERRIDE = ethmsg->fcs ? 1 : 0;
+	ethpacket->eid.txlen = static_cast<uint16_t>(messageLen);
+	ethpacket->Length = static_cast<uint16_t>(messageLen);
+	ethpacket->stats = ethmsg->description;
+	ethpacket->NetworkID = static_cast<uint16_t>(ethmsg->network.getNetID());
+	std::copy(ethmsg->data.begin(), ethmsg->data.end(), payload);
+	return encoded;
+}
+
+static std::vector<uint8_t> EncodeFromMessageCAN(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
+	auto canmsg = std::dynamic_pointer_cast<CANMessage>(frame);
+	if(!canmsg) {
+		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+		return {};
+	}
+	if(canmsg->isCANFD && canmsg->isRemote) {
+		report(APIEvent::Type::RTRNotSupported, APIEvent::Severity::Error);
+		return {}; // RTR frames can not be used with CAN FD
+	}
+	std::vector<uint8_t> encoded;
+	size_t messageLen = canmsg->data.size();
+	size_t extraLen = 0;
+	if(messageLen > 8) {
+		extraLen = messageLen - 8;
+	}
+	encoded.resize(sizeof(TransmitMessage) + extraLen);
+
+	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
+	HardwareCANPacket* const canpacket = (HardwareCANPacket*)(msg->commonHeader);
+	uint8_t* const extra_payload = encoded.data() + sizeof(TransmitMessage);
+
+	const size_t dataSize = canmsg->data.size();
+	std::optional<uint8_t> dlc = CAN_LengthToDLC(dataSize, canmsg->isCANFD);
+	if(!dlc.has_value()) {
+		report(APIEvent::Type::MessageMaxLengthExceeded, APIEvent::Severity::Error);
+		return {}; // Too much data for the protocol
+	}
+	// arb id
+	if(canmsg->isExtended) {
+		canpacket->header.IDE = 1;
+		canpacket->header.SID = (canmsg->arbid >> 18) & 0x7FF;
+		canpacket->eid.EID = (canmsg->arbid >> 6) & 0xfff;
+		canpacket->dlc.EID2 = canmsg->arbid & 0x3f;
+	} else {
+		canpacket->header.IDE = 0;
+		canpacket->header.SID = canmsg->arbid & 0x7FF;
+	}
+
+	// DLC
+	canpacket->dlc.DLC = dlc.value();
+
+	// FDF/BRS or remote frames
+	if(canmsg->isCANFD) {
+		canpacket->header.EDL = 1;
+		canpacket->header.BRS = canmsg->baudrateSwitch ? 1 : 0;
+		canpacket->header.ESI = canmsg->errorStateIndicator ? 1 : 0;
+		canpacket->dlc.RTR = 0;
+		canpacket->timestamp.IsExtended = 1;
+
+	} else {
+		canpacket->header.EDL = 0;
+		canpacket->header.BRS = 0;
+		canpacket->header.ESI = 0;
+		canpacket->dlc.RTR = canmsg->isRemote ? 1 : 0;
+	}
+	// network
+	canpacket->NetworkID = static_cast<uint16_t>(canmsg->network.getNetID());
+	canpacket->Length = static_cast<uint16_t>(extraLen);
+	// description id
+	canpacket->stats = canmsg->description;
+	// first 8 bytes
+	std::copy(canmsg->data.begin(), canmsg->data.begin() + (messageLen > 8 ? 8 : messageLen), canpacket->data);
+	// extra bytes
+	if(extraLen > 0) {
+		// copy extra data after the can packet
+		std::copy(canmsg->data.begin() + 8, canmsg->data.end(), extra_payload);
+	}
+	return encoded;
+}
+
+static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> /* frame */, const device_eventhandler_t& report) {
+	// TODO
+	report(APIEvent::Type::UnsupportedTXNetwork, APIEvent::Severity::Error);
+	return {};
+}
+
+std::vector<uint8_t> TransmitMessage::EncodeFromMessage(std::shared_ptr<Frame> frame, uint32_t client_id, const device_eventhandler_t& report) {
+	std::vector<uint8_t> result;
+	switch(frame->network.getType()) {
+		case Network::Type::Ethernet:
+		case Network::Type::AutomotiveEthernet:
+			result = EncodeFromMessageEthernet(frame, report);
+			break;
+		case Network::Type::Internal:
+		case Network::Type::CAN:
+			result = EncodeFromMessageCAN(frame, report);
+			break;
+		case Network::Type::LIN:
+			result = EncodeFromMessageLIN(frame, report);
+			break;
+		default:
+			report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
+			return result;
+	}
+	// common fields
+	TransmitMessage* const msg = (TransmitMessage*)result.data();
+	msg->options.clientId = client_id;
+	msg->options.networkId = static_cast<uint32_t>(frame->network.getNetID());
+	msg->options.reserved[0] = 0;
+	msg->options.reserved[1] = 0;
+	msg->options.reserved[2] = 0;
+
+	return result;
+}

communication/packet/canpacket.cpp

@@ -114,7 +114,7 @@ std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<ui
 			msg->data.insert(msg->data.end(), data->data, data->data + (length > 8 ? 8 : length));
 			if(length > 8) { // If there are more than 8 bytes, they come at the end of the message
 				// Messages with extra data are formatted as message, then uint16_t netid, then uint16_t length, then extra data
-				const auto extraDataStart = bytestream.begin() + sizeof(HardwareCANPacket) + 2 + 2;
+				const auto extraDataStart = bytestream.begin() + sizeof(HardwareCANPacket);
 				msg->data.insert(msg->data.end(), extraDataStart, extraDataStart + (length - 8));
 			}
 		}

communication/packet/linpacket.cpp

@@ -9,7 +9,7 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 	size_t numDataBytes = packet->CoreMiniBitsLIN.len;
 	size_t numHeaderBytes = sizeof(HardwareLINPacket::CoreMiniBitsLIN);
 
-	if( (sizeof(HardwareLINPacket) != bytestream.size()) ||
+	if( (sizeof(HardwareLINPacket) > bytestream.size()) ||
 		((numDataBytes + numHeaderBytes) > bytestream.size()) )
 		return nullptr;
 
@@ -17,7 +17,6 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 		--numDataBytes; //If data is present, there will be a checksum included
 
 	auto msg = std::make_shared<LINMessage>(static_cast<uint8_t>(packet->CoreMiniBitsLIN.ID));
-	msg->network = Network::GetNetIDFromCoreMiniNetwork(static_cast<Network::CoreMini>(packet->networkID));
 	msg->isEnhancedChecksum = static_cast<bool>(packet->CoreMiniBitsLIN.TxChkSumEnhanced);
 
 	/* Minimum one responder byte and one checksum byte. */

communication/ringbuffer.cpp

@@ -1,91 +0,0 @@
-#include "icsneo/communication/ringbuffer.h"
-#include <stdexcept>
-
-namespace icsneo {
-    
-RingBuffer::RingBuffer(size_t bufferSize) : readCursor(0), writeCursor(0) {
-    // round the buffer size to the nearest power of 2
-    bufferSize = RoundUp(bufferSize);
-    mask = bufferSize - 1;
-    buf = new uint8_t[bufferSize];
-}
-
-RingBuffer::~RingBuffer() {
-    delete[] buf;
-    buf = nullptr;
-}
-
-const uint8_t& RingBuffer::operator[](size_t offset) const { 
-    return get(offset); 
-}
-
-size_t RingBuffer::size() const { 
-    // The values in the cursors are monotonic, i.e. they only ever increment. They can be considered to be the total number of elements ever written or read
-    auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
-    auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
-    // Using unmasked values, writeCursor is guaranteed to be >= readCursor. If they are equal that means the buffer is empty
-    return currentWriteCursor - currentReadCursor; 
-}
-
-void RingBuffer::pop_front() {
-    pop(1);
-}
-
-void RingBuffer::pop(size_t count) {
-    if (size() < count) {
-        throw std::runtime_error("RingBuffer: Underflow");
-    }
-    readCursor.fetch_add(count, std::memory_order_release);
-}
-
-const uint8_t& RingBuffer::get(size_t offset) const {
-    if (offset >= size()) {
-        throw std::runtime_error("RingBuffer: Index out of range");
-    }
-    auto currentReadCursor = readCursor.load(std::memory_order_acquire);
-    return *resolve(currentReadCursor, offset);
-}
-
-bool RingBuffer::write(const uint8_t* addr, size_t length) {    
-    const auto freeSpace = (capacity() - size());
-    if (length > freeSpace) {
-        return false;
-    }
-    auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
-    auto spaceAtEnd = std::min(freeSpace, capacity() - (currentWriteCursor & mask)); // number of bytes from (masked) writeCursor to the end of the writable space (i.e. we reach the masked read cursor or the end of the buffer)
-    auto firstCopySize = std::min(spaceAtEnd, length);
-    (void)memcpy(resolve(currentWriteCursor, 0), addr, firstCopySize);
-    if (firstCopySize < length)
-    {
-        (void)memcpy(buf, &addr[firstCopySize], length - firstCopySize);
-    }
-
-    writeCursor.store(currentWriteCursor + length, std::memory_order_release);
-    return true;
-}
-
-bool RingBuffer::write(const std::vector<uint8_t>& source) {
-    return write(source.data(), source.size());
-}
-
-bool RingBuffer::read(uint8_t* dest, size_t startIndex, size_t length) const {
-    auto currentSize = size();
-    if ((startIndex >= currentSize) || ((startIndex + length) > size())) {
-        return false;
-    }
-    auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
-    auto bytesAtEnd = std::min<size_t>(capacity() - ((currentReadCursor + startIndex) & mask), length);
-    const auto bytesAtStart = (length - bytesAtEnd);
-
-    (void)memcpy(dest, resolve(currentReadCursor, startIndex), bytesAtEnd);
-    if (bytesAtStart > 0) {
-        (void)memcpy(&dest[bytesAtEnd], buf, bytesAtStart);
-    }
-    return true;
-}
-
-void RingBuffer::clear() {
-    pop(size());
-}
-
-}

core/crc32.cpp

@@ -4,8 +4,7 @@
  *  Created on: Jun 22, 2020
  *      Author: BJones
  */
-#include "icsneo/communication/crc32.h"
+#include "icsneo/core/crc32.h"
-#include <stddef.h>
 
 static const unsigned long crc32_table[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
 	0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
@@ -32,7 +31,7 @@ static const unsigned long crc32_table[256] = { 0x00000000, 0x77073096, 0xEE0E61
 	0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E,
 	0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D };
 
-uint32_t crc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+uint32_t icsneo::crc32(uint32_t crc, const unsigned char* buf, uint32_t len)
 {
 	unsigned char octet;
 	const unsigned char* p = buf;
@@ -50,13 +49,13 @@ static unsigned char rev_crc32_table[256];
 
 static void revgen(void)
 {
-	size_t k;
+	uint16_t k;
 
 	for (k = 0; k < 256; k++)
-		rev_crc32_table[crc32_table[k] >> 24] = (uint8_t)k;
+		rev_crc32_table[crc32_table[k] >> 24] = (unsigned char)k;
 }
 
-uint32_t revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+uint32_t icsneo::revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len)
 {
 	unsigned char k;
 	revgen();

core/macseccfg.cpp

@@ -0,0 +1,776 @@
+#include "icsneo/core/macseccfg.h"
+#include "icsneo/api/eventmanager.h"
+#include "icsneo/core/crc32.h"
+#include <cstring>
+
+namespace icsneo {
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4201) // nameless struct/union
+#endif
+
+#pragma pack(push, 1)
+
+typedef struct
+{
+	uint16_t VID; /*!< 12 bits */
+	uint8_t PRI_CFI; /*!< PRI - 3 bits, CFI - 1bit */
+} MACSEC_VLANTAG_t;
+/**
+ * @brief Structure of MPLS
+ *
+ */
+typedef struct
+{
+	uint32_t MPLS_label; /*!< 20 bits */
+	uint8_t exp; /*!< 3 bits */
+} MACSEC_MPLS_OUTER_t;
+
+#define MACSEC_SETTINGS_RULE_SIZE (88)
+typedef union _MACSecRule
+{
+	struct
+	{
+		uint8_t index;
+		uint8_t key_MAC_DA[6]; /*!< MAC DA field extracted from the packet */
+		uint8_t mask_MAC_DA[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t key_MAC_SA[6]; /*!< MAC SA field extracted from the packet */
+		uint8_t mask_MAC_SA[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t key_Ethertype; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
+		uint16_t mask_Ethertype; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_VLANTAG_t key_vlantag_outer1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+		MACSEC_MPLS_OUTER_t key_MPLS_outer1;
+		MACSEC_VLANTAG_t mask_vlantag_outer1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_MPLS_OUTER_t mask_MPLS_outer1;
+		MACSEC_VLANTAG_t key_vlantag_outer2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+		MACSEC_MPLS_OUTER_t key_MPLS_outer2;
+		MACSEC_VLANTAG_t mask_vlantag_outer2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_MPLS_OUTER_t mask_MPLS_outer2;
+		uint16_t key_bonus_data; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
+		uint16_t mask_bonus_data; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t
+			key_tag_match_bitmap; /*!< 8 bits total. Maps 1 to 1 bitwise with the set of custom tags. (set bit[N]=1 if check Nth custom tag) */
+		uint8_t mask_tag_match_bitmap; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACsecPacketType key_packet_type; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
+		uint8_t mask_packet_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t
+			key_inner_vlan_type; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
+		uint16_t mask_inner_vlan_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t key_outer_vlan_type; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
+		uint16_t mask_outer_vlan_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t
+			key_num_tags; /*!< 7 bits total. Number of VLAN/custom tags or MPLS lables detected. Ingress: before SecTag; Egress: total detected. Exclude MCS header tags. i.e. Bit 2: 2 tags/labels before SecTAG...Bit 6: 6 or more tags/labels before SecTAG. */
+		uint8_t mask_num_tags; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t key_express; /*!< 1 bits. Express packet. */
+		uint8_t mask_express; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t isMPLS;
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_RULE_SIZE];
+} MACSecRule_t;
+/* MACsec Map */
+#define MACSEC_SETTINGS_MAP_SIZE (20)
+typedef union _MACSecMap
+{
+	struct
+	{
+		uint8_t index;
+		uint64_t sectag_sci; /*!< Identifies the SecTAG SCI for this Flow. */
+		uint8_t secYIndex; /*!< index for entry in Egress secY Policy */
+		uint8_t isControlPacket; /*!< Identifies all packets matching this index lookup as control packets. */
+		uint8_t scIndex; /*!< Identifies the SC for this Flow. */
+		uint8_t auxiliary_plcy; /*!< Auxiliary policy bits. */
+		uint8_t ruleId; /*!< Identifies the Rule for this Flow. */
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_MAP_SIZE];
+} MACSecMap_t;
+/* MACsec SecY */
+
+#define MACSEC_SETTINGS_SECY_SIZE (24)
+typedef union _MACSecSecY
+{
+	struct
+	{
+		uint8_t index; /*!< Identifies the SecY for this Flow. */
+		uint8_t controlled_port_enabled; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
+		MACsecValidation validate_frames; /*!< see MACSEC_VALIDATEFRAME */
+		MACsecStrip strip_sectag_icv; /*!< see MACSEC_STRIP_SECTAG_ICV */
+		MACsecCipherSuite cipher; /*!< Define the cipher suite to use for this SecY */
+		uint8_t confidential_offset; /*!< Define the number of bytes that are unencrypted following the SecTag. */
+		uint8_t icv_includes_da_sa; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
+		uint8_t replay_protect; /*!< Enables Anti-Replay protection */
+		uint32_t replay_window; /*!< Unsigned value indicating the size of the anti-replay window. */
+		uint8_t
+			protect_frames; /*!< 0 = do not encrypt or authenticate this packet; 1 = always Authenticate frame and if SecTag.TCI.E = 1 encrypt the packet as well. */
+		uint8_t
+			sectag_offset; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
+		uint8_t sectag_tci; /*!< Tag Control Information excluding the AN field which originates from the SA Policy table */
+		uint16_t mtu; /*!< Specifies the outgoing MTU for this SecY */
+		uint8_t rsvd[6];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SECY_SIZE];
+} MACSecSecY_t;
+/* MACsec SC */
+#define MACSEC_SETTINGS_SC_SIZE (24)
+typedef union _MACSecSc
+{
+	struct
+	{
+		uint8_t index; /*!< SC index. */
+		uint8_t secYIndex; /*!< SecY associated with this packet. */
+		uint64_t sci; /*!< The Secure Channel Identifier. */
+		uint8_t sa_index0; /*!< Define the 1st SA to use */
+		uint8_t sa_index1; /*!< Define the 2nd SA to use */
+		uint8_t sa_index0_in_use; /*!< Specifies whether 1st SA is in use or not. */
+		uint8_t sa_index1_in_use; /*!< Specifies whether 2nd SA is in use or not.  */
+		uint8_t enable_auto_rekey; /*!< If enabled, then once the pn_threshold is reached, auto rekey will happen. */
+		uint8_t
+			isActiveSA1; /*!< If set, then sa_index1 is the currently active SA index. If cleared, the sa_index0 is the currently active SA index). */
+		uint8_t rsvd[7];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SC_SIZE];
+} MACSecSc_t;
+/* MACsec SA */
+#define MACSEC_SETTINGS_SA_SIZE (80)
+typedef union _MACSecSa
+{
+	struct
+	{
+		uint8_t index; /*!< SA index */
+		uint8_t
+			sak[32]; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
+		uint8_t hashKey[16]; /*!< 128b Hash Key: Key used for authentication. */
+		uint8_t salt[12]; /*!< 96b Salt value: Salt value used in XPN ciphers. */
+		uint32_t ssci; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
+		uint8_t AN; /*!< 2b SecTag Association Number (AN) */
+		uint64_t nextPN; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SA_SIZE];
+} MACSecSa_t;
+/* MACsec Flags */
+#define MACSEC_SETTINGS_FLAGS_SIZE (4)
+typedef union _MACSecFlags
+{
+	struct
+	{
+		uint32_t en : 1; // '1' = enable; '0' = disable
+		uint32_t reserved : 31;
+	};
+	uint32_t flags_32b;
+} MACSecFlags_t;
+/* MACSec Settings for 1 port/phy */
+#define MACSEC_NUM_FLAGS_PER_CONFIG (1)
+#define MACSEC_NUM_RULES_PER_CONFIG (2)
+#define MACSEC_NUM_MAPS_PER_CONFIG (2)
+#define MACSEC_NUM_SECY_PER_CONFIG (2)
+#define MACSEC_NUM_SC_PER_CONFIG (2)
+#define MACSEC_NUM_SA_PER_CONFIG (4)
+typedef struct MACSEC_CONFIG_t
+{
+	MACSecFlags_t flags;
+	MACSecRule_t rule[MACSEC_NUM_RULES_PER_CONFIG];
+	MACSecMap_t map[MACSEC_NUM_MAPS_PER_CONFIG];
+	MACSecSecY_t secy[MACSEC_NUM_SECY_PER_CONFIG];
+	MACSecSc_t sc[MACSEC_NUM_SC_PER_CONFIG];
+	MACSecSa_t sa[MACSEC_NUM_SA_PER_CONFIG];
+} MACSEC_CONFIG;
+typedef union _MACSecGlobalFlags
+{
+	struct
+	{
+		uint32_t en : 1; // '1' = enable; '0' = disable
+		uint32_t nvm : 1; // store macsec config in non-volatile memory
+		uint32_t reserved : 30;
+	};
+	uint32_t flags_32b;
+} MACSecGlobalFlags_t;
+#define MACSEC_SETTINGS_SIZE (2040) // leave space for expansion and keep nicely aligned for flashing
+typedef union _MACSEC_SETTINGS
+{
+	struct
+	{
+		MACSecGlobalFlags_t flags;
+		MACSEC_CONFIG rx;
+		MACSEC_CONFIG tx;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SIZE];
+} MACSEC_SETTINGS;
+
+#define MACSEC_SETTINGS_VERSION 1
+typedef struct MACSEC_SETTINGS_W_HDR
+{
+	uint16_t version;
+	uint16_t len;
+	uint32_t crc32;
+	MACSEC_SETTINGS macsec;
+} MACSEC_SETTINGS_W_HDR;
+#define MACSEC_SETTINGS_W_HDR_SIZE (2048)
+
+#pragma pack(pop)
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+static void ReportEvent(APIEvent::Type event, APIEvent::Severity severity) {
+	auto& em = EventManager::GetInstance();
+	em.add(APIEvent(event, severity));
+}
+
+MACsecConfig::MACsecConfig(const DeviceType& deviceType) : type(deviceType) {
+	switch(deviceType.getDeviceType()) {
+		case icsneo::DeviceType::Enum::RADMoon2:
+		case icsneo::DeviceType::Enum::RADMoon3:
+		case icsneo::DeviceType::Enum::RADEpsilon:
+			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;
+	}
+}
+
+int MACsecConfig::addRxSecY(const MACsecRxSecY& secY, uint8_t saIndex) {
+	if(rxSecY.size() >= maxSecY) {
+		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	if(saIndex >= rxSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	int ret = static_cast<int>(rxSecY.size());
+	rxSecY.emplace_back(secY);
+	rxSecYSaIndices.emplace_back(saIndex, saIndex + 1);
+	rxSecYRekey.emplace_back(false);
+	rxRuleIndices.emplace_back(0);
+
+	return ret;
+}
+
+int MACsecConfig::addTxSecY(const MACsecTxSecY& secY, uint8_t saIndex) {
+	if(txSecY.size() >= maxSecY) {
+		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	if(saIndex >= txSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	int ret = static_cast<int>(txSecY.size());
+	txSecY.emplace_back(secY);
+	txSecYSaIndices.emplace_back(saIndex, saIndex + 1);
+	txSecYRekey.emplace_back(false);
+
+	return ret;
+}
+
+int MACsecConfig::addRxSa(const MACsecRxSa& sa) {
+	if(rxSa.size() >= maxSa) {
+		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	int ret = static_cast<int>(rxSa.size());
+	rxSa.emplace_back(sa);
+	return ret;
+}
+
+int MACsecConfig::addTxSa(const MACsecTxSa& sa) {
+	if(txSa.size() >= maxSa) {
+		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	int ret = static_cast<int>(txSa.size());
+	txSa.emplace_back(sa);
+	return ret;
+}
+
+int MACsecConfig::addRxRule(const MACsecRxRule& rule, uint8_t secYIndex) {
+	if(rxRule.size() >= maxRule) {
+		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	if(maxSecY >= rxRule.size()) {
+		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
+		return -1;
+	}
+
+	int ret = static_cast<int>(rxRule.size());
+	rxRuleIndices[secYIndex] = static_cast<uint8_t>(rxRule.size());
+	rxRule.emplace_back(rule);
+	return ret;
+}
+
+MACsecRxRule& MACsecConfig::getRxRule(uint8_t ruleIndex) {
+	return rxRule[ruleIndex];
+}
+
+const MACsecRxRule& MACsecConfig::getRxRule(uint8_t ruleIndex) const {
+	return rxRule[ruleIndex];
+}
+
+MACsecRxSecY& MACsecConfig::getRxSecY(uint8_t secYIndex) {
+	return rxSecY[secYIndex];
+}
+
+const MACsecRxSecY& MACsecConfig::getRxSecY(uint8_t secYIndex) const {
+	return rxSecY[secYIndex];
+}
+
+MACsecTxSecY& MACsecConfig::getTxSecY(uint8_t secYIndex) {
+	return txSecY[secYIndex];
+}
+
+const MACsecTxSecY& MACsecConfig::getTxSecY(uint8_t secYIndex) const {
+	return txSecY[secYIndex];	
+}
+
+MACsecRxSa& MACsecConfig::getRxSa(uint8_t saIndex) {
+	return rxSa[saIndex];
+}
+
+const MACsecRxSa& MACsecConfig::getRxSa(uint8_t saIndex) const {
+	return rxSa[saIndex];
+}
+
+MACsecTxSa& MACsecConfig::getTxSa(uint8_t saIndex) {
+	return txSa[saIndex];
+}
+
+const MACsecTxSa& MACsecConfig::getTxSa(uint8_t saIndex) const {
+	return txSa[saIndex];
+}
+
+bool MACsecConfig::setTxSaIndex(uint8_t secYIndex, uint8_t saIndex) {
+	if(secYIndex >= txSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(saIndex >= txSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	txSecYSaIndices[secYIndex].first = saIndex;
+	return true;
+}
+
+bool MACsecConfig::enableTxRekey(uint8_t secYIndex, uint8_t rekeySaIndex) {
+	if(secYIndex >= txSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(rekeySaIndex >= txSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	txSecYSaIndices[secYIndex].second = rekeySaIndex;
+	txSecYRekey[secYIndex] = true;
+	return true;
+}
+
+bool MACsecConfig::setTxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex) {
+	if(secYIndex >= txSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(saIndex >= txSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	txSecYSaIndices[secYIndex].second = saIndex;
+	return true;
+}
+
+void MACsecConfig::disableTxRekey(uint8_t secYIndex) {
+	if(secYIndex >= txSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::EventWarning);
+		return;
+	}
+	txSecYRekey[secYIndex] = false;
+}
+
+bool MACsecConfig::setRxSaIndex(uint8_t secYIndex, uint8_t saIndex) {
+	if(secYIndex >= rxSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(saIndex >= rxSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	rxSecYSaIndices[secYIndex].first = saIndex;
+	return true;
+}
+
+bool MACsecConfig::enableRxRekey(uint8_t secYIndex, uint8_t rekeySaIndex) {
+	if(secYIndex >= rxSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(rekeySaIndex >= rxSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	rxSecYSaIndices[secYIndex].second = rekeySaIndex;
+	rxSecYRekey[secYIndex] = true;
+	return true;
+}
+
+bool MACsecConfig::setRxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex) {
+	if(secYIndex >= rxSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
+		return false;
+	}
+	if(saIndex >= rxSa.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
+		return false;
+	}
+
+	rxSecYSaIndices[secYIndex].second = saIndex;
+	return true;
+}
+
+void MACsecConfig::disableRxRekey(uint8_t secYIndex) {
+	if(secYIndex >= rxSecY.size()) {
+		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::EventWarning);
+		return;
+	}
+	rxSecYRekey[secYIndex] = false;
+}
+
+void MACsecConfig::setRxEnable(bool newRxEnable) {
+	enableRx = newRxEnable;
+}
+
+void MACsecConfig::setTxEnable(bool newTxEnable) {
+	enableTx = newTxEnable;
+}
+
+void MACsecConfig::setStorage(bool temporary) {
+	nvm = !temporary;
+}
+
+
+void MACsecConfig::clear() {
+	// Set everything back to default, except device maximums
+	rxSecY.clear();
+	txSecY.clear();
+	rxSa.clear();
+	txSa.clear();
+	rxRule.clear();
+	rxSecYRekey.clear();
+	txSecYRekey.clear();
+	rxSecYSaIndices.clear();
+	txSecYSaIndices.clear();
+	rxRuleIndices.clear();
+	enableRx = false;
+	enableTx = false;
+	nvm = false;
+}
+
+MACsecConfig::operator bool() const {
+	return (maxSa != 0) || (maxSecY != 0) || (maxRule != 0);
+}
+
+uint16_t MACsecConfig::getBinIndex() const {
+	return binIndex;
+}
+
+DeviceType MACsecConfig::getType() const {
+	return type;
+}
+
+uint8_t MACsecConfig::getMaxNumRule() const {
+	return maxRule;	
+}
+
+uint8_t MACsecConfig::getMaxNumSecY() const {
+	return maxSecY;
+}
+
+uint8_t MACsecConfig::getMaxNumSa() const {
+	return maxSa;
+}
+
+
+static uint8_t TCItoInt(const MACsecTci& tci) {
+	uint8_t res = 0;
+	res |= tci.c ? 0x01u : 0;
+	res |= tci.e ? 0x02u : 0;
+	res |= tci.scb ? 0x04u : 0;
+	res |= tci.sc ? 0x08u : 0;
+	res |= tci.es ? 0x10u : 0;
+	return res;
+}
+
+static void SetHardwareTxSecY(
+	MACSEC_SETTINGS_W_HDR* hwSettings,
+	const MACsecTxSecY& secY,
+	bool rekeyEnabled,
+	const std::pair<uint8_t, uint8_t>& saIndices,
+	uint8_t index
+) {
+
+	MACSecSecY_t* hwSecY = &hwSettings->macsec.tx.secy[index];
+	MACSecSc_t* hwSc = &hwSettings->macsec.tx.sc[index];
+	MACSecMap_t* hwMap = &hwSettings->macsec.tx.map[index]; 
+
+	hwSecY->index = index;
+	hwSecY->enable = true;
+	hwSecY->controlled_port_enabled = secY.enableControlPort ? 0x1u : 0x0u;
+	hwSecY->cipher = secY.cipher;
+	hwSecY->confidential_offset = secY.confidentialityOffset;
+	hwSecY->icv_includes_da_sa = secY.icvIncludesDaSa ? 0x1u : 0x0u;
+	hwSecY->mtu = secY.mtu;
+	hwSecY->sectag_tci = TCItoInt(secY.tci);
+	hwSecY->sectag_offset = secY.secTagOffset;
+	hwSecY->protect_frames = secY.protectFrames;
+
+	hwSc->index = index;
+	hwSc->enable = true;
+	hwSc->secYIndex = index;
+	hwSc->enable_auto_rekey = rekeyEnabled ? 0x1u : 0x0u;
+	hwSc->sa_index0 = saIndices.first;
+	hwSc->sa_index1 = saIndices.second;
+	hwSc->sa_index0_in_use = true;
+	hwSc->sa_index1_in_use = rekeyEnabled ? true : false;
+	hwSc->isActiveSA1 = rekeyEnabled ? true : false;
+	hwSc->sci = secY.sci;
+
+	hwMap->index = index;
+	hwMap->enable = true;
+	hwMap->auxiliary_plcy = secY.auxiliaryPolicy;
+	hwMap->secYIndex = index;
+	hwMap->isControlPacket = secY.isControlPacket ? 0x1u : 0x0u;
+	hwMap->scIndex = index;
+	hwMap->sectag_sci = secY.sci;
+
+}
+
+static void SetHardwareRxSecY(
+	MACSEC_SETTINGS_W_HDR* hwSettings,
+	const MACsecRxSecY& secY,
+	bool rekeyEnabled,
+	uint8_t ruleIndex,
+	const std::pair<uint8_t, uint8_t>& saIndices,
+	uint8_t index
+) {
+
+	MACSecSecY_t* hwSecY = &hwSettings->macsec.rx.secy[index];
+	MACSecSc_t* hwSc = &hwSettings->macsec.rx.sc[index];
+	MACSecMap_t* hwMap = &hwSettings->macsec.rx.map[index]; 
+
+	hwSecY->index = index;
+	hwSecY->enable = 0x1u;
+	hwSecY->controlled_port_enabled = secY.enableControlPort ? 0x1u : 0x0u;
+	hwSecY->cipher = secY.cipher;
+	hwSecY->confidential_offset = secY.confidentialityOffset;
+	hwSecY->icv_includes_da_sa = secY.icvIncludesDaSa ? 0x1u : 0x0u;
+	hwSecY->replay_protect = secY.replayProtect ? 0x1u : 0x0u;
+	hwSecY->replay_window = secY.replayWindow;
+	hwSecY->validate_frames = secY.frameValidation;
+	hwSecY->strip_sectag_icv = secY.frameStrip;
+	hwSecY->sectag_offset = 12;
+
+	hwSc->index = index;
+	hwSc->enable = 0x1u;
+	hwSc->secYIndex = index;
+	hwSc->enable_auto_rekey = rekeyEnabled ? 0x1u : 0x0u;
+	hwSc->sa_index0 = saIndices.first;
+	hwSc->sa_index1 = saIndices.second;
+	hwSc->sa_index0_in_use = 0x1u;
+	hwSc->sa_index1_in_use = rekeyEnabled ? 0x1u : 0x0u;
+	hwSc->isActiveSA1 = rekeyEnabled ? 0x1u : 0x0u;
+	hwSc->sci = secY.sci;
+
+	hwMap->index = index;
+	hwMap->enable = 0x1u;
+	hwMap->secYIndex = index;
+	hwMap->ruleId = ruleIndex;
+	hwMap->isControlPacket = secY.isControlPacket ? 0x1u : 0x0u;
+	hwMap->scIndex = index;
+	hwMap->sectag_sci = secY.sci;
+
+}
+
+static void SetHardwareTxSa(MACSEC_SETTINGS_W_HDR* hwSettings, const MACsecTxSa& sa, uint8_t index) {
+	MACSecSa_t* hwSa = &hwSettings->macsec.tx.sa[index];
+
+	hwSa->index = index;
+	hwSa->enable = 0x1u;
+	memcpy(hwSa->sak, sa.sak.data(), 32);
+	memcpy(hwSa->hashKey, sa.hashKey.data(), 16);
+	memcpy(hwSa->salt, sa.salt.data(), 12);
+	hwSa->ssci = sa.ssci;
+	hwSa->AN = sa.an;
+	hwSa->nextPN = sa.nextPn;
+
+}
+
+static void SetHardwareRxSa(MACSEC_SETTINGS_W_HDR* hwSettings, const MACsecRxSa& sa, uint8_t index) {
+	MACSecSa_t* hwSa = &hwSettings->macsec.rx.sa[index];
+
+	hwSa->index = index;
+	hwSa->enable = 0x1u;
+	memcpy(hwSa->sak, sa.sak.data(), 32);
+	memcpy(hwSa->hashKey, sa.hashKey.data(), 16);
+	memcpy(hwSa->salt, sa.salt.data(), 12);
+	hwSa->ssci = sa.ssci;
+	hwSa->nextPN = sa.nextPn;
+
+}
+
+static void SetHardwareRxRule(MACSecRule_t* hwRule, const MACsecRxRule& rule, uint8_t index) {
+
+	hwRule->enable = 0x1u;
+	hwRule->index = index;
+	memcpy(hwRule->key_MAC_DA, rule.keyMacDa.data(), 6);
+	memcpy(hwRule->mask_MAC_DA, rule.maskMacDa.data(), 6);
+	memcpy(hwRule->key_MAC_SA, rule.keyMacSa.data(), 6);
+	memcpy(hwRule->mask_MAC_SA, rule.maskMacSa.data(), 6);
+	hwRule->key_Ethertype = rule.keyEthertype;
+	hwRule->mask_Ethertype =  rule.maskEthertype;
+	hwRule->key_vlantag_outer1.PRI_CFI = rule.keyVlanTagOuter1.priCfi;
+	hwRule->key_vlantag_outer1.VID = rule.keyVlanTagOuter1.vid;
+	hwRule->key_MPLS_outer1.exp = rule.keyMplsOuter1.exp;
+	hwRule->key_MPLS_outer1.MPLS_label = rule.keyMplsOuter1.mplsLabel;
+	hwRule->mask_vlantag_outer1.PRI_CFI = rule.maskVlanTagOuter1.priCfi;
+	hwRule->mask_vlantag_outer1.VID = rule.maskVlanTagOuter1.vid;
+	hwRule->mask_MPLS_outer1.exp = rule.maskMplsOuter1.exp;
+	hwRule->mask_MPLS_outer1.MPLS_label = rule.maskMplsOuter1.mplsLabel;
+	hwRule->key_vlantag_outer2.PRI_CFI = rule.keyVlanTagOuter2.priCfi;
+	hwRule->key_vlantag_outer2.VID = rule.keyVlanTagOuter2.vid;
+	hwRule->key_MPLS_outer2.exp = rule.keyMplsOuter2.exp;
+	hwRule->key_MPLS_outer2.MPLS_label = rule.keyMplsOuter2.mplsLabel;
+	hwRule->mask_vlantag_outer2.PRI_CFI = rule.maskVlanTagOuter2.priCfi;
+	hwRule->mask_vlantag_outer2.VID = rule.maskVlanTagOuter2.vid;
+	hwRule->mask_MPLS_outer2.exp = rule.maskMplsOuter2.exp;
+	hwRule->mask_MPLS_outer2.MPLS_label = rule.maskMplsOuter2.mplsLabel;
+	hwRule->key_bonus_data = rule.keyBonusData;
+	hwRule->mask_bonus_data = rule.maskBonusData;
+	hwRule->key_tag_match_bitmap = rule.keyTagMatchBitmap;
+	hwRule->mask_tag_match_bitmap = rule.maskTagMatchBitmap;
+	hwRule->key_packet_type = rule.keyPacketType;
+	hwRule->mask_packet_type = rule.maskPacketType;
+	hwRule->key_inner_vlan_type = rule.keyInnerVlanType;
+	hwRule->mask_inner_vlan_type = rule.maskInnerVlanType;
+	hwRule->key_outer_vlan_type = rule.keyOuterVlanType;
+	hwRule->mask_outer_vlan_type = rule.maskOuterVlanType;
+	hwRule->key_num_tags = rule.keyNumTags;
+	hwRule->mask_num_tags = rule.maskNumTags;
+	hwRule->key_express = rule.keyExpress ? 0x1u : 0x0u;
+	hwRule->mask_express = rule.maskExpress ? 0x1u : 0x0u;
+	hwRule->isMPLS = rule.isMpls ? 0x1u : 0x0u;
+
+}
+
+std::vector<uint8_t> MACsecConfig::serialize() const {
+	std::vector<uint8_t> res(sizeof(MACSEC_SETTINGS_W_HDR), 0);
+	MACSEC_SETTINGS_W_HDR* hwSettings = (MACSEC_SETTINGS_W_HDR*)(res.data());
+
+	for(uint8_t i = 0; i < maxSecY; i++) {
+		if(i < rxSecY.size()) {
+			SetHardwareRxSecY(
+				hwSettings, 
+				rxSecY[i],
+				rxSecYRekey[i],
+				rxRuleIndices[i],
+				rxSecYSaIndices[i],
+				i
+			);
+		} else {
+			hwSettings->macsec.rx.secy[i].enable = false;
+			hwSettings->macsec.rx.map[i].enable = false;
+			hwSettings->macsec.rx.sc[i].enable = false;
+		}
+
+		if(i < txSecY.size()) {
+			SetHardwareTxSecY(
+				hwSettings, 
+				txSecY[i],
+				txSecYRekey[i],
+				txSecYSaIndices[i],
+				i
+			);
+		} else {
+			hwSettings->macsec.tx.secy[i].enable = false;
+			hwSettings->macsec.tx.map[i].enable = false;
+			hwSettings->macsec.tx.sc[i].enable = false;
+		}
+	}
+
+	for(uint8_t i = 0; i < maxSa; i++) {
+		if(i < rxSa.size()) {
+			SetHardwareRxSa(hwSettings, rxSa[i], i);
+		} else {
+			hwSettings->macsec.rx.sa[i].enable = false;
+		}
+		
+		if(i < txSa.size()) {
+			SetHardwareTxSa(hwSettings, txSa[i], i);
+		} else {
+			hwSettings->macsec.tx.sa[i].enable = false;
+		}
+	}
+
+	if(rxRule.size() == 0) {
+		MACsecRxRule defaultRule;
+		MACSecRule_t* hwRxRule = &hwSettings->macsec.rx.rule[0];
+		MACSecRule_t* hwTxRule = &hwSettings->macsec.tx.rule[0];
+		SetHardwareRxRule(hwRxRule, defaultRule, 0);
+		SetHardwareRxRule(hwTxRule, defaultRule, 0);
+		//hwSettings->macsec.tx.rule[0].enable = false;
+		for(uint8_t i = 1; i < maxRule; i++) {
+			hwSettings->macsec.rx.rule[i].enable = false;
+			hwSettings->macsec.tx.rule[i].enable = false;
+		}
+	} else  {
+		for(uint8_t i = 0; i < maxRule; i++) {
+			if(i < rxRule.size()) {
+				auto* hwRxRule = &hwSettings->macsec.rx.rule[i];
+				SetHardwareRxRule(hwRxRule, rxRule[i], i);
+			} else {
+				hwSettings->macsec.rx.rule[i].enable = false;
+				hwSettings->macsec.tx.rule[i].enable = false;
+			}
+		}
+	}
+
+	hwSettings->len = sizeof(MACSEC_SETTINGS_W_HDR);
+	hwSettings->version = MACSEC_SETTINGS_VERSION;
+	hwSettings->macsec.flags.en = (enableRx || enableTx) ? 1u : 0u;
+	hwSettings->macsec.flags.nvm = nvm ? 1u : 0u;
+	hwSettings->macsec.rx.flags.en = enableRx ? 1u : 0u;
+	hwSettings->macsec.tx.flags.en = enableTx ? 1u : 0u;
+	hwSettings->crc32 = crc32(0, (uint8_t*)&hwSettings->macsec, sizeof(MACSEC_SETTINGS));
+
+	return res;
+}
+}

core/ringbuffer.cpp

@@ -0,0 +1,91 @@
+#include "icsneo/core/ringbuffer.h"
+#include <stdexcept>
+
+namespace icsneo {
+	
+RingBuffer::RingBuffer(size_t bufferSize) : readCursor(0), writeCursor(0) {
+	// round the buffer size to the nearest power of 2
+	bufferSize = RoundUp(bufferSize);
+	mask = bufferSize - 1;
+	buf = new uint8_t[bufferSize];
+}
+
+RingBuffer::~RingBuffer() {
+	delete[] buf;
+	buf = nullptr;
+}
+
+const uint8_t& RingBuffer::operator[](size_t offset) const { 
+	return get(offset); 
+}
+
+size_t RingBuffer::size() const { 
+	// The values in the cursors are monotonic, i.e. they only ever increment. They can be considered to be the total number of elements ever written or read
+	auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
+	auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
+	// Using unmasked values, writeCursor is guaranteed to be >= readCursor. If they are equal that means the buffer is empty
+	return currentWriteCursor - currentReadCursor; 
+}
+
+void RingBuffer::pop_front() {
+	pop(1);
+}
+
+void RingBuffer::pop(size_t count) {
+	if (size() < count) {
+		throw std::runtime_error("RingBuffer: Underflow");
+	}
+	readCursor.fetch_add(count, std::memory_order_release);
+}
+
+const uint8_t& RingBuffer::get(size_t offset) const {
+	if (offset >= size()) {
+		throw std::runtime_error("RingBuffer: Index out of range");
+	}
+	auto currentReadCursor = readCursor.load(std::memory_order_acquire);
+	return *resolve(currentReadCursor, offset);
+}
+
+bool RingBuffer::write(const uint8_t* addr, size_t length) {    
+	const auto freeSpace = (capacity() - size());
+	if (length > freeSpace) {
+		return false;
+	}
+	auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
+	auto spaceAtEnd = std::min(freeSpace, capacity() - (currentWriteCursor & mask)); // number of bytes from (masked) writeCursor to the end of the writable space (i.e. we reach the masked read cursor or the end of the buffer)
+	auto firstCopySize = std::min(spaceAtEnd, length);
+	(void)memcpy(resolve(currentWriteCursor, 0), addr, firstCopySize);
+	if (firstCopySize < length)
+	{
+		(void)memcpy(buf, &addr[firstCopySize], length - firstCopySize);
+	}
+
+	writeCursor.store(currentWriteCursor + length, std::memory_order_release);
+	return true;
+}
+
+bool RingBuffer::write(const std::vector<uint8_t>& source) {
+	return write(source.data(), source.size());
+}
+
+bool RingBuffer::read(uint8_t* dest, size_t startIndex, size_t length) const {
+	auto currentSize = size();
+	if ((startIndex >= currentSize) || ((startIndex + length) > size())) {
+		return false;
+	}
+	auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
+	auto bytesAtEnd = std::min<size_t>(capacity() - ((currentReadCursor + startIndex) & mask), length);
+	const auto bytesAtStart = (length - bytesAtEnd);
+
+	(void)memcpy(dest, resolve(currentReadCursor, startIndex), bytesAtEnd);
+	if (bytesAtStart > 0) {
+		(void)memcpy(&dest[bytesAtEnd], buf, bytesAtStart);
+	}
+	return true;
+}
+
+void RingBuffer::clear() {
+	pop(size());
+}
+
+}

device/device.cpp

@@ -6,6 +6,8 @@
 #include "icsneo/device/extensions/deviceextension.h"
 #include "icsneo/disk/fat.h"
 #include "icsneo/communication/message/filter/extendedresponsefilter.h"
+#include "icsneo/communication/message/networkmutexmessage.h"
+#include "icsneo/communication/message/transmitmessage.h"
 
 #ifdef _MSC_VER
 #pragma warning(disable : 4996) // STL time functions
@@ -207,6 +209,75 @@ bool Device::refreshComponentVersions() {
 	return false;
 }
 
+std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
+	if(refreshComponents) {
+		refreshComponentVersions();
+	}
+	std::vector<VersionReport> chipVersions;
+
+	if (supportsComponentVersions()) {
+		const auto& compVersions = getComponentVersions();
+		auto disectVersion = [](uint32_t dotVersion) {
+			std::array<uint8_t, 4> result = {0,0,0,0};
+			size_t i = 0;
+
+			if(dotVersion & 0xFF000000ul) {
+				result[i++] = (uint8_t)((dotVersion & 0xFF000000ul) >> 24);
+				result[i++] = (uint8_t)((dotVersion & 0x00FF0000ul) >> 16);
+			} else if(dotVersion & 0x00FF0000ul) {
+				result[i++] = (uint8_t)((dotVersion & 0x00FF0000ul) >> 16);
+			}
+			result[i++] = (uint8_t)((dotVersion & 0x0000FF00ul) >> 8);
+			result[i] = (uint8_t)((dotVersion & 0x000000FFul) >> 0);
+			return result;
+		};
+
+		for(const auto& chipInfo : getChipInfo()) {
+			for(const auto& component : compVersions) {
+				if(!component.valid) {
+					continue;
+				}
+				if(component.identifier == (uint32_t)chipInfo.id) {
+					chipVersions.emplace_back();
+					auto& version = chipVersions.back();
+
+					auto disectedVersion = disectVersion(component.dotVersion);
+					version.id          = chipInfo.id;
+					version.name        = chipInfo.name;
+					version.major       = disectedVersion[0];
+					version.minor       = disectedVersion[1];
+					version.maintenance = disectedVersion[2];
+					version.build       = disectedVersion[3];
+				}
+			}
+		}
+	} else {
+		const auto& appVersions = getVersions();
+		for(const auto& chipInfo : getChipInfo()) {
+			if(!chipInfo.defaultEnabled) {
+				continue;
+			}
+			if(appVersions.size() <= chipInfo.versionIndex) {
+				continue;
+			}
+			const auto& appVer = appVersions[chipInfo.versionIndex];
+			if(!appVer) {
+				continue;
+			}
+			chipVersions.emplace_back();
+			auto& version = chipVersions.back();
+
+			version.id          = chipInfo.id;
+			version.name        = chipInfo.name;
+			version.major       = appVer->major;
+			version.minor       = appVer->minor;
+			version.maintenance = 0;
+			version.build       = 0;
+		}			
+	}
+	return chipVersions;
+}
+
 bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(!com) {
 		report(APIEvent::Type::Unknown, APIEvent::Severity::Error);
@@ -342,6 +413,44 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	return true;
 }
 
+bool Device::reconnect(std::chrono::milliseconds timeout, std::chrono::milliseconds interval) {
+	if(isOnline()) {
+		goOffline();
+	}
+	bool readsArePaused = com->readsArePaused();
+	if(!com->close()) {
+		return false;
+	}
+
+	std::vector<FoundDevice> foundDevices;
+	auto findAll = com->driver->getFinder();
+	auto start = std::chrono::system_clock::now();
+	while((std::chrono::system_clock::now() - start) < timeout) {
+		foundDevices.clear();
+		findAll(foundDevices);
+		for(auto& fd : foundDevices) {
+			if(!memcmp(fd.serial, data.serial, 6)) {
+				com->driver = fd.makeDriver(report, getWritableNeoDevice());
+				if(readsArePaused) {
+					// Pause reads again
+					com->pauseReads();
+				}
+				if(com->open()) {
+					return true;
+				} else {
+					if(readsArePaused) {
+						com->resumeReads();
+					}
+				} 
+			}
+		}
+		std::this_thread::sleep_for(interval);
+	}
+
+	return false;
+}
+
+
 APIEvent::Type Device::attemptToBeginCommunication() {
 	versions.clear();
 
@@ -451,8 +560,35 @@ bool Device::goOnline() {
 			return false;
 	}
 
+	if(supportsNetworkMutex()) {
+		assignedClientId = com->getClientIDSync();
+		if(assignedClientId) {
+			// firmware supports clientid/mutex
+			networkMutexCallbackHandle = lockAllNetworks(std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint32_t>::max(), NetworkMutexType::Shared, [this](std::shared_ptr<Message> message) {
+					auto netMutexMsg = std::static_pointer_cast<NetworkMutexMessage>(message);
+					if(netMutexMsg->networks.size() && netMutexMsg->event.has_value()) {
+						switch(*netMutexMsg->event) {
+							case NetworkMutexEvent::Acquired:
+								lockedNetworks.emplace(*netMutexMsg->networks.begin());
+								break;
+							case NetworkMutexEvent::Released: {
+								auto it = lockedNetworks.find(*netMutexMsg->networks.begin());
+								if (it != lockedNetworks.end())
+									lockedNetworks.erase(it);
+								break;
+							}
+						}
+					}
+				}
+			);
+		}
+	}
+
 	// (re)start the keeponline
-	keeponline = std::make_unique<Periodic>([this] { return enableNetworkCommunication(true, onlineTimeoutMs); }, std::chrono::milliseconds(onlineTimeoutMs / 4));
+	keeponline = std::make_unique<Periodic>([this] {
+		static std::vector<uint8_t> timeoutBytes = std::vector<uint8_t>((uint8_t*)&onlineTimeoutMs, (uint8_t*)&onlineTimeoutMs + sizeof(onlineTimeoutMs));
+		return com->sendCommand(Command::KeepAlive, timeoutBytes);
+	}, std::chrono::milliseconds(onlineTimeoutMs / 4));
 
 	online = true;
 
@@ -464,6 +600,9 @@ bool Device::goOnline() {
 bool Device::goOffline() {
 	keeponline.reset();
 
+	if(networkMutexCallbackHandle)
+		removeMessageCallback(*networkMutexCallbackHandle);
+
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onGoOffline(); return true; });
 
 	if(isDisconnected()) {
@@ -794,9 +933,12 @@ bool Device::transmit(std::shared_ptr<Frame> frame) {
 		return transmitStatusFromExtension;
 
 	std::vector<uint8_t> packet;
+	if(assignedClientId.has_value()) {
+		packet = TransmitMessage::EncodeFromMessage(frame, *assignedClientId, report);
+		return packet.size() && com->sendCommand(ExtendedCommand::TransmitMessage, packet);
+	}
 	if(!com->encoder->encode(*com->packetizer, packet, frame))
 		return false;
-
 	return com->sendPacket(packet);
 }
 
@@ -1870,6 +2012,15 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 		case Message::Type::RawMessage: {
 			auto rawMessage = std::static_pointer_cast<RawMessage>(message);
 			switch(rawMessage->network.getNetID()) {
+				case Network::NetID::Device: {
+					// Device is not guaranteed to be a CANMessage, it might be a RawMessage
+					// if it couldn't be decoded to a CANMessage. We only care about the
+					// CANMessage decoding right now.
+					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
+					if(canmsg)
+						handleNeoVIMessage(std::move(canmsg));
+					break;
+				}
 				case Network::NetID::DeviceStatus:
 					// Device Status format is unique per device, so the devices need to decode it themselves
 					handleDeviceStatus(rawMessage);
@@ -1879,15 +2030,6 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 			}
 			break;
 		}
-		case Message::Type::Frame: {
-			// Device is not guaranteed to be a CANMessage, it might be a RawMessage
-			// if it couldn't be decoded to a CANMessage. We only care about the
-			// CANMessage decoding right now.
-			auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
-			if(canmsg)
-				handleNeoVIMessage(std::move(canmsg));
-			break;
-		}
 		default: break;
 	}
 	forEachExtension([&](const std::shared_ptr<DeviceExtension>& ext) {
@@ -1957,10 +2099,6 @@ std::optional<EthPhyMessage> Device::sendEthPhyMsg(const EthPhyMessage& message,
 		report(APIEvent::Type::EthPhyRegisterControlNotAvailable, APIEvent::Severity::Error);
 		return std::nullopt;
 	}
-	if(!isOnline()) {
-		report(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
 
 	std::vector<uint8_t> bytes;
 	HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report);
@@ -2920,7 +3058,6 @@ std::optional<bool> Device::isVSAOverlapped(std::optional<VSAMetadata> optMetada
 			   lastSectorRecord->getTimestamp() > metadata.coreMiniTimestamp;
 	} else if(lastSectorStatus == VSAParser::RecordParseStatus::NotARecordStart) {
 		// The vsa record buffer is not full
-		report(APIEvent::Type::VSAOtherError, APIEvent::Severity::Error);
 		return false;
 	}
 	report(APIEvent::Type::VSABufferFormatError, APIEvent::Severity::Error);
@@ -3608,13 +3745,19 @@ std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeou
 	return *retMsg;
 }
 
-bool Device::writeMACsecConfig(const MACsecMessage& message, uint16_t binaryIndex)
+bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
-{
+	if(!cfg) {
-	std::vector<uint8_t> raw;
+		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
 
-	message.EncodeFromMessage(raw, report);
+	if(getType() != cfg.getType()) {
+		report(APIEvent::Type::MACsecConfigMismatch, APIEvent::Severity::Error);
+		return false;
+	}
 
-	return writeBinaryFile(raw, binaryIndex);
+	std::vector<uint8_t> raw = cfg.serialize();
+	return writeBinaryFile(raw, cfg.getBinIndex());
 }
 
 bool Device::enableNetworkCommunication(bool enable, uint32_t timeout) {
@@ -3756,3 +3899,201 @@ std::shared_ptr<DiskDetails> Device::getDiskDetails(std::chrono::milliseconds ti
 	return DiskDetails::Decode(extResponse->data, getDiskCount(), report);
 }
 
+[[nodiscard]] std::optional<int> Device::lockNetworks(const std::set<Network::NetID>& networks, uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
+{
+	if(!supportsNetworkMutex()) {
+		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	if(!assignedClientId.has_value()) {
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	constexpr auto timeout = std::chrono::milliseconds(250);
+
+	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForLock(*assignedClientId, type, priority, ttlMs, networks, report);
+	
+	std::optional<int> handle = std::nullopt;
+	if(on_event) {
+		handle.emplace(addMessageCallback(
+			std::make_shared<MessageCallback>(
+				on_event,
+				std::make_shared<MessageFilter>(Message::Type::NetworkMutex)
+			)
+		));
+	}
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, payload](){
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
+	if(!extResponse) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(extResponse->response != ExtendedResponse::OK && extResponse->response != ExtendedResponse::OperationPending) {
+		return std::nullopt;
+	}
+
+	return handle;
+}
+
+bool Device::unlockNetworks(const std::set<Network::NetID>& networks)
+{
+	if(!supportsNetworkMutex()) {
+		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+	if(!assignedClientId.has_value()) {
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return false;
+	}
+	constexpr auto timeout = std::chrono::milliseconds(250);
+
+	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForUnlock(*assignedClientId, networks, report);
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, payload](){
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return false;
+	}
+
+	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
+	if(!extResponse) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return false;
+	}
+
+	if(extResponse->response != ExtendedResponse::OK) {
+		return false;
+	}
+
+	return true;
+}
+
+std::shared_ptr<NetworkMutexMessage> Device::getNetworkMutexStatus(Network::NetID network)
+{
+	if(!supportsNetworkMutex()) {
+		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	constexpr auto timeout = std::chrono::milliseconds(1000);
+
+	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForStatus(network, report);
+	
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, payload](){
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<MessageFilter>(Message::Type::NetworkMutex),
+		timeout
+	);
+
+	return std::dynamic_pointer_cast<NetworkMutexMessage>(response);
+}
+
+[[nodiscard]] std::optional<int> Device::lockAllNetworks(uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
+{
+	if(!supportsNetworkMutex()) {
+		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	if(!assignedClientId.has_value()) {
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	constexpr auto timeout = std::chrono::milliseconds(1000);
+
+	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForLockAll(*assignedClientId, type, priority, ttlMs, report);
+	
+	int handle = addMessageCallback(
+		std::make_shared<MessageCallback>(
+			on_event,
+			std::make_shared<MessageFilter>(Message::Type::NetworkMutex)
+		)
+	);
+	
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, payload](){
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
+	if(!extResponse) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(extResponse->response != ExtendedResponse::OK && extResponse->response != ExtendedResponse::OperationPending) {
+		return std::nullopt;
+	}
+
+	return std::make_optional(handle);
+}
+
+bool Device::unlockAllNetworks() 
+{
+	if(!supportsNetworkMutex()) {
+		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+	if(!assignedClientId.has_value()) {
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return false;
+	}
+	constexpr auto timeout = std::chrono::milliseconds(1000);
+
+	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForUnlockAll(*assignedClientId, report);
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, payload](){
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return false;
+	}
+
+	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
+	if(!extResponse) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return false;
+	}
+
+	if(extResponse->response != ExtendedResponse::OK) {
+		return false;
+	}
+
+	return true;
+}

device/devicefinder.cpp

@@ -225,6 +225,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADMoon3>(dev, newFoundDevices);
 		#endif
 
+		#ifdef __RADGEMINI_H_
+		makeIfSerialMatches<RADGemini>(dev, newFoundDevices);
+		#endif
+
 		#ifdef __RADMOONDUO_H_
 		makeIfSerialMatches<RADMoonDuo>(dev, newFoundDevices);
 		#endif
@@ -384,6 +388,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADMoon3::DEVICE_TYPE,
 		#endif
 
+		#ifdef __RADGEMINI_H_
+		RADGemini::DEVICE_TYPE,
+		#endif
+
 		#ifdef __RADMOONDUO_H_
 		RADMoonDuo::DEVICE_TYPE,
 		#endif

docs/icsneopy/examples.rst

@@ -66,3 +66,19 @@ Complete Ethernet Example
 
 .. literalinclude:: ../../examples/python/ethernet/ethernet_complete_example.py
    :language: python
+
+Device Firmware/Chip Versions
+=============================
+
+:download:`Download example <../../examples/python/device/chip_versions.py>`
+
+.. literalinclude:: ../../examples/python/device/chip_versions.py
+   :language: python
+
+SPI Example for 10BASE-T1S
+=============================
+
+:download:`Download example <../../examples/python/spi/spi_example.py>`
+
+.. literalinclude:: ../../examples/python/spi/spi_example.py
+   :language: python

examples/CMakeLists.txt

@@ -10,8 +10,12 @@ option(LIBICSNEO_BUILD_CPP_COREMINI_EXAMPLE "Build the Coremini example." ON)
 option(LIBICSNEO_BUILD_CPP_MDIO_EXAMPLE "Build the MDIO example." ON)
 option(LIBICSNEO_BUILD_CPP_VSA_EXAMPLE "Build the VSA example." ON)
 option(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE "Build the app error example." ON)
+option(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE "Build the macsec example" ON)
 option(LIBICSNEO_BUILD_CPP_FLEXRAY_EXAMPLE "Build the FlexRay example." ON)
 option(LIBICSNEO_BUILD_CPP_SPI_EXAMPLE "Build the SPI example." ON)
+option(LIBICSNEO_BUILD_CPP_MUTEX_EXAMPLE "Build the NetworkMutex example." ON)
+
+add_compile_options(${LIBICSNEO_COMPILER_WARNINGS})
 
 if(LIBICSNEO_BUILD_C_INTERACTIVE_EXAMPLE)
 	add_subdirectory(c/interactive)
@@ -61,10 +65,18 @@ if(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE)
 	add_subdirectory(cpp/apperror)
 endif()
 
+if(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE)
+	add_subdirectory(cpp/macsec)
+endif()
+
 if(LIBICSNEO_BUILD_CPP_FLEXRAY_EXAMPLE)
     add_subdirectory(cpp/flexray)
 endif()
 
 if(LIBICSNEO_BUILD_CPP_SPI_EXAMPLE)
     add_subdirectory(cpp/spi)
-endif()
+endif()
+
+if(LIBICSNEO_BUILD_CPP_MUTEX_EXAMPLE)
+	add_subdirectory(cpp/mutex)
+endif()

examples/cpp/coremini/src/coremini.cpp

@@ -44,12 +44,6 @@ int main(int argc, char** argv) {
 		return EXIT_FAILURE;
 	}
 
-	if(!device->goOnline()) {
-		std::cout << "Failed to go online." << std::endl;
-		std::cout << icsneo::GetLastError() << std::endl;
-		return EXIT_FAILURE;
-	}
-
 	std::string memTypeString = arguments[3];
 
 	icsneo::Disk::MemoryType type;
@@ -75,7 +69,6 @@ int main(int argc, char** argv) {
 		std::cout << icsneo::GetLastError() << std::endl;
 	}
 
-	device->goOffline();
 	device->close();
 	return 0;
 }

examples/cpp/interactive/src/InteractiveExample.cpp

@@ -214,7 +214,8 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 					std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
 					break;
 				}
-				case icsneo::Network::Type::Ethernet: {
+				case icsneo::Network::Type::Ethernet:
+				case icsneo::Network::Type::AutomotiveEthernet: {
 					auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
 
 					std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec

examples/cpp/macsec/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(libicsneocpp-macsec src/macsec.cpp)
+target_link_libraries(libicsneocpp-macsec icsneocpp)

examples/cpp/macsec/src/macsec.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+#include "icsneo/icsneocpp.h"
+
+int main(int, char**) {
+	// Hash calculated by encrypting 16 zero bytes with AES ecb using the SAK
+	// The device uses this hash to authenticate the key
+	std::array<uint8_t, 16> sak = {0x01u, 0x02u, 0x03u, 0x04u, 0x01u, 0x02u, 0x03u, 0x04u, 0x01u, 0x02u, 0x03u, 0x04u, 0x01u, 0x02u, 0x03u, 0x04u};
+	std::array<uint8_t, 16> hash = {0xDAu, 0x80u, 0xF2u, 0x20u, 0x8Bu, 0x59u, 0x88u, 0x12u, 0x94u, 0x4Eu, 0xEA, 0xB0, 0x52u, 0xDEu, 0xDEu, 0x66u};
+
+	auto devices = icsneo::FindAllDevices();
+
+	if(devices.size() == 0) {
+		std::cout << "No device found" << std::endl;
+		return -1;
+	}
+
+	std::shared_ptr<icsneo::Device> device = devices[0];
+	
+	if(!device->open()) {
+		std::cout << "Failed to open device" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return -1;
+	}
+	
+	icsneo::MACsecConfig cfg(device->getType());
+
+	if(!cfg) {
+		std::cout << "Failed to initialize config" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return -1;
+	}
+
+	// Fill out secure association information for each rx/tx port
+	icsneo::MACsecRxSa rxSa;
+	std::copy(sak.begin(), sak.end(), rxSa.sak.begin());
+	std::copy(hash.begin(), hash.end(), rxSa.hashKey.begin());
+
+	icsneo::MACsecTxSa txSa;
+	std::copy(sak.begin(), sak.end(), txSa.sak.begin());
+	std::copy(hash.begin(), hash.end(), txSa.hashKey.begin());
+
+	// Add the secure associations to the config
+	int rxSaHandle = cfg.addRxSa(rxSa);
+	int txSaHandle = cfg.addTxSa(txSa);
+
+	// Verify secure associations were configured properly
+	if(rxSaHandle < 0 || txSaHandle < 0) {
+		std::cout << "Failed to verify secure associations" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return -1;
+	}
+
+	// Fill out security entity information for each rx/tx port
+	icsneo::MACsecRxSecY rxSecY;
+	rxSecY.cipher = icsneo::MACsecCipherSuite::GcmAes128;
+	rxSecY.sci = 0x1122334455660001ull;
+
+	icsneo::MACsecTxSecY txSecY;
+	txSecY.cipher = icsneo::MACsecCipherSuite::GcmAes128;
+	txSecY.sci = 0x1122334455660001ull;
+
+	// Add security entites to the config
+	int rxSecYHandle = cfg.addRxSecY(rxSecY, static_cast<uint8_t>(rxSaHandle));
+	int txSecYHandle = cfg.addTxSecY(txSecY, static_cast<uint8_t>(txSaHandle));	
+
+	// Verify security entities were configured properly
+	if(rxSecYHandle < 0 || txSecYHandle < 0) {
+		std::cout << "Failed to verify security entities" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return -1;
+	}
+
+	// Enable communication directions
+	cfg.setRxEnable(true);
+	cfg.setTxEnable(true);
+
+	// Write config to the device
+	if(!device->writeMACsecConfig(cfg)) {
+		std::cout << "Failed to write MACsec config" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return -1;
+	}
+	
+	device->close();
+	return 0;
+}

examples/cpp/mutex/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(libicsneocpp-mutex-example src/MutexExample.cpp)
+target_link_libraries(libicsneocpp-mutex-example icsneocpp)

examples/cpp/mutex/src/MutexExample.cpp

@@ -0,0 +1,215 @@
+#include <iostream>
+#include <iomanip>
+#include <thread>
+#include <chrono>
+#include <numeric>
+#include <unordered_set>
+
+#include "icsneo/icsneocpp.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4996) // STL time functions
+#endif
+
+static std::vector<std::shared_ptr<icsneo::Device>> findDevices(icsneo::DeviceType type)
+{
+	std::vector<std::shared_ptr<icsneo::Device>> ret;
+	for(auto&& dev : icsneo::FindAllDevices()) {
+		if(dev->getType() == type) {
+			ret.push_back(dev);
+		}
+	}
+	return ret;
+}
+
+static std::vector<icsneo::Network> supported_nets;
+static std::unordered_map<icsneo::Network::NetID, icsneo::NetworkMutexEvent> network_mutex_states;
+constexpr uint32_t MUTEX_PRIORITY = 12345678;
+constexpr uint32_t MUTEX_TTL_MS = 2500;
+
+static void on_mutex_event(std::shared_ptr<icsneo::Message> msg) {
+	if(msg->type == icsneo::Message::Type::NetworkMutex) {
+		auto nmm = std::static_pointer_cast<icsneo::NetworkMutexMessage>(msg);
+		if(nmm->event.has_value() && nmm->networks.size())
+		{
+			auto network = *nmm->networks.begin();
+			if(std::find_if(supported_nets.begin(), supported_nets.end(), [network](const icsneo::Network& net){ return net.getNetID() == network; }) != supported_nets.end())
+			{
+				std::cout << icsneo::Network::GetNetIDString(static_cast<icsneo::Network::NetID>(network)) << ": Mutex " << icsneo::NetworkMutexMessage::GetNetworkMutexEventString(nmm->event.value()) << std::endl;
+				network_mutex_states[network] = *nmm->event;
+			}
+		}
+	}
+}
+
+static void do_mutexed_operation(std::shared_ptr<icsneo::Device> device, icsneo::Network::NetID network, std::function<void()>&& operation)
+{
+	// Demonstrate taking a mutex on a single / group of networks
+	auto lt = device->lockNetworks({network}, MUTEX_PRIORITY, MUTEX_TTL_MS, icsneo::NetworkMutexType::TxExclusive, on_mutex_event);
+	if(lt.has_value()) {
+		while(network_mutex_states.find(network) == network_mutex_states.end() || 
+			network_mutex_states[network] != icsneo::NetworkMutexEvent::Acquired)
+		{
+			std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		}
+
+		operation();
+
+		device->unlockNetworks({network});
+		while(network_mutex_states.find(network) != network_mutex_states.end() && 
+			network_mutex_states[network] == icsneo::NetworkMutexEvent::Acquired)
+		{
+			std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		}
+		device->removeMessageCallback(*lt);
+	} else {
+		std::cout << "Failed to acquire mutex for " << icsneo::Network::GetNetIDString(network) << std::endl;
+	}
+}
+
+int main() {
+	// Print version
+	std::cout << "libicsneo version " << icsneo::GetVersion() << std::endl;
+
+	std::cout << "\nFinding devices... " << std::flush;
+	auto devices = findDevices(icsneo::DeviceType::FIRE3);
+	// You now hold the shared_ptrs for these devices, you are considered to "own" these devices from a memory perspective
+	std::cout << "OK, " << devices.size() << " device" << (devices.size() == 1 ? "" : "s") << " found" << std::endl;
+
+	// List off the devices
+	for(auto& device : devices)
+		std::cout << '\t' << device->describe() << " @ Handle " << device->getNeoDevice().handle << std::endl;
+	std::cout << std::endl;
+
+	for(auto& device : devices) {
+		std::cout << "Connecting to " << device->describe() << "... ";
+		bool ret = device->open();
+		if(!ret) { // Failed to open
+			std::cout << "FAIL" << std::endl;
+			std::cout << icsneo::GetLastError() << std::endl << std::endl;
+			continue;
+		}
+		std::cout << "OK" << std::endl;
+		
+		supported_nets = device->getSupportedTXNetworks();
+
+		device->goOnline();
+
+		// Demonstrate lock and unlock all networks
+		std::cout << "Requesting global exclusive network mutex" << std::endl;
+		auto lt = device->lockAllNetworks(MUTEX_PRIORITY, MUTEX_TTL_MS, icsneo::NetworkMutexType::TxExclusive, on_mutex_event);
+		if(lt.has_value()) {
+			// wait until we have the mutex on all networks
+			auto all_nets = device->getSupportedTXNetworks();
+			for(auto net = all_nets.begin(); net != all_nets.end();) {
+				auto state = network_mutex_states.find(net->getNetID());
+				if(state != network_mutex_states.end() && state->second == icsneo::NetworkMutexEvent::Acquired) {
+					net = all_nets.erase(net);
+				} else {
+					++net;
+				}
+			}
+			std::cout << "Acquired mutex for all supported networks on " << device->describe() << std::endl;
+
+			// request release
+			if(device->unlockAllNetworks()) {
+				std::cout << "Requested release of all networks" << std::endl;
+			} else {
+				std::cout << "Failed to request release of all networks" << std::endl;
+			}
+
+			// wait until we have released the mutex on all networks
+			all_nets = device->getSupportedTXNetworks();
+			for(auto net = all_nets.begin(); net != all_nets.end();) {
+				auto state = network_mutex_states.find(net->getNetID());
+				if(state == network_mutex_states.end() || state->second == icsneo::NetworkMutexEvent::Released) {
+					net = all_nets.erase(net);
+				} else {
+					++net;
+				}
+			}
+			std::cout << "released mutex on all supported networks" << std::endl;
+			
+			device->removeMessageCallback(*lt);
+		} else {
+			std::cout << "Failed to acquire global mutex" << std::endl;
+		}
+		
+		std::cout << "Doing mutexed operation on DWCAN 01" << std::endl;
+		do_mutexed_operation(device, icsneo::Network::NetID::DWCAN_01, [&](){
+			auto tx_message = std::make_shared<icsneo::CANMessage>();
+			tx_message->arbid = 0x12;
+			tx_message->isCANFD = true;
+			tx_message->baudrateSwitch = true;
+			tx_message->data.resize(64);
+			tx_message->network = icsneo::Network::NetID::DWCAN_01;
+			constexpr auto txInterval = std::chrono::microseconds(500);
+			auto nextRefresh = std::chrono::steady_clock::now() + std::chrono::milliseconds(MUTEX_TTL_MS / 2);
+			auto nextTx = std::chrono::steady_clock::now() + txInterval;
+			size_t numTx = 0;
+			while(numTx < 5000) {
+				if(std::chrono::steady_clock::now() < nextTx) {
+					continue;
+				}
+				nextTx = std::chrono::steady_clock::now() + txInterval;
+				std::iota(tx_message->data.begin(), tx_message->data.end(), (uint8_t)(numTx & 0xFF));
+				if(device->transmit(tx_message)) {
+					++numTx;
+				}
+				// check the mutex periodically - every 200 messages for demonstrative purposes
+				if(std::chrono::steady_clock::now() > nextRefresh) {
+					auto status = device->getNetworkMutexStatus(icsneo::Network::NetID::DWCAN_01);
+					if(!status) {
+						std::cout << "failed to poll status of network mutex for DWCAN 01" << std::endl;
+					} else {
+						std::cout << "DWCAN 01 mutex TTL: " << *status->ttlMs << " ms" << std::endl;
+					}
+					std::cout << "refreshing mutex on DWCAN 01, current tx count: " << numTx << std::endl;
+					(void)device->lockNetworks({icsneo::Network::NetID::DWCAN_01}, MUTEX_PRIORITY, MUTEX_TTL_MS, icsneo::NetworkMutexType::TxExclusive, nullptr);
+					nextRefresh = std::chrono::steady_clock::now() + std::chrono::milliseconds(MUTEX_TTL_MS / 2);
+				}
+			}
+		});
+		std::cout << "Completed mutexed operation on DWCAN 01" << std::endl;
+
+		
+		std::cout << "Doing mutexed operation on Ethernet 03" << std::endl;
+		do_mutexed_operation(device, icsneo::Network::NetID::ETHERNET_03, [&](){
+			auto tx_message = std::make_shared<icsneo::EthernetMessage>();
+			tx_message->data.resize(512);
+			// set mac addresses and ethertype
+			std::iota(tx_message->data.begin(), tx_message->data.begin() + 14, static_cast<uint8_t>(0x01));
+			tx_message->network = icsneo::Network::NetID::ETHERNET_03;
+			constexpr auto txInterval = std::chrono::microseconds(250);
+			auto nextRefresh = std::chrono::steady_clock::now() + std::chrono::milliseconds(MUTEX_TTL_MS / 2);
+			auto nextTx = std::chrono::steady_clock::now() + txInterval;
+			size_t numTx = 0;
+			while(numTx < 50000) {
+				if(std::chrono::steady_clock::now() < nextTx) {
+					continue;
+				}
+				nextTx = std::chrono::steady_clock::now() + txInterval;
+				// keep the mac addresses and ethertype constant
+				std::iota(tx_message->data.begin() + 14, tx_message->data.end(), (uint8_t)(numTx & 0xFF));
+				if(device->transmit(tx_message)) {
+					++numTx;
+				}
+				if(std::chrono::steady_clock::now() > nextRefresh) {
+					auto status = device->getNetworkMutexStatus(icsneo::Network::NetID::ETHERNET_03);
+					if(!status) {
+						std::cout << "failed to poll status of network mutex for Ethernet 03" << std::endl;
+					} else {
+						std::cout << "Ethernet 03 mutex TTL: " << *status->ttlMs << " ms" << std::endl;
+					}
+					std::cout << "refreshing mutex on Ethernet 03, current tx count: " << numTx << std::endl;
+					(void)device->lockNetworks({icsneo::Network::NetID::ETHERNET_03}, MUTEX_PRIORITY, MUTEX_TTL_MS, icsneo::NetworkMutexType::TxExclusive, nullptr);
+					nextRefresh = std::chrono::steady_clock::now() + std::chrono::milliseconds(MUTEX_TTL_MS / 2);
+				}
+			}
+		});
+		std::cout << "Completed mutexed operation on Ethernet 03" << std::endl;
+
+		device->close();
+	}
+	return 0;
+}

examples/cpp/simple/src/SimpleExample.cpp

@@ -199,7 +199,8 @@ int main() {
 							std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
 							break;
 						}
-						case icsneo::Network::Type::Ethernet: {
+						case icsneo::Network::Type::Ethernet:
+						case icsneo::Network::Type::AutomotiveEthernet: {
 							auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
 
 							std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec

examples/cpp/vsa/src/VSAExample.cpp

@@ -172,7 +172,7 @@ int main(int argc, char* argv[]) {
 		const auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
 		if(frame->network.getType() == icsneo::Network::Type::CAN) {
 			++canFrameCount;
-		} else if(frame->network.getType() == icsneo::Network::Type::Ethernet) {
+		} else if(frame->network.getType() == icsneo::Network::Type::AutomotiveEthernet || frame->network.getType() == icsneo::Network::Type::Ethernet) {
 			++ethFrameCount;
 		}
 	}));

examples/python/device/chip_versions.py

@@ -0,0 +1,30 @@
+import icsneopy
+
+def chip_versions():
+	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
+
+	chip_versions = device.get_chip_versions()
+	if not chip_versions:
+		print("no chip versions")
+		return False
+
+	print("chip versions:")
+	for i in chip_versions:
+		version = f"{i.major}.{i.minor}.{i.maintenance}.{i.build}"
+		print(f"    id: {i.id}, name: {i.name}, version: {version}")
+
+	return True
+
+if __name__ == "__main__":
+	chip_versions()

examples/python/ethernet/ethernet_monitor_status.py

@@ -17,7 +17,7 @@ def main():
    print(f"info: monitoring Ethernet status on {device}")
 
    def on_message(message):
-      print(f"info: network: {message.network}, state: {message.state}, speed: {message.speed}, duplex: {message.duplex}, mode: {message.mode}")
+      print(f"info: timestamp: {message.timestamp}, network: {message.network}, state: {message.state}, speed: {message.speed}, duplex: {message.duplex}, mode: {message.mode}")
 
    filter = icsneopy.MessageFilter(icsneopy.Message.Type.EthernetStatus)
    callback = icsneopy.MessageCallback(on_message, filter)

examples/python/spi/spi_example.py

@@ -0,0 +1,134 @@
+"""
+Complete SPI example for 10BASE-T1S MACPHYs using icsneopy library.
+
+Demonstrates device setup and SPI frame transmission/reception.
+"""
+
+import icsneopy
+import time
+
+
+def setup_device():
+    """Initialize SPI device."""
+    devices = icsneopy.find_all_devices()
+    if not devices:
+        raise RuntimeError("No devices found")
+
+    device = devices[0]
+    print(f"Using device: {device}")
+    return device
+
+
+def open_device(device):
+    """Open device connection."""
+    try:
+        if not device.open():
+            raise RuntimeError("Failed to open device")
+
+        if not device.go_online():
+            device.close()
+            raise RuntimeError("Failed to go online")
+
+        print("Device initialized successfully")
+        return True
+
+    except Exception as e:
+        print(f"Device setup failed: {e}")
+        return False
+
+
+def transmit_spi_frame(device, mms, addr, dir, write_data=None):
+    """Transmit a SPI frame."""
+    frame = icsneopy.SPIMessage()
+    frame.network = icsneopy.Network(icsneopy.Network.NetID.SPI_01)
+    frame.direction = dir
+    frame.mms = mms
+    frame.address = addr
+    if dir == icsneopy.SPIMessage.Direction.Read:
+        frame.payload = [0]  # single register
+    else:
+        frame.payload = [write_data]
+
+    success = device.transmit(frame)
+    if success:
+        print("Frame transmitted")
+    else:
+        print("Failed to transmit frame")
+
+    return success
+
+
+def setup_spi_reception(device):
+    """Configure SPI frame reception with callback."""
+
+    def frame_handler(frame):
+        access = (
+            "Write"
+            if frame.direction == icsneopy.SPIMessage.Direction.Write
+            else "Read"
+        )
+        print(
+            f"{access}, "
+            f"MMS: 0x{frame.mms:02X}, "
+            f"Register: 0x{frame.address:03X}, "
+            f"Data: {[hex(b) for b in frame.payload]}, "
+            f"Length: {len(frame.payload)}"
+        )
+
+    frame_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.SPI_01)
+    callback = icsneopy.MessageCallback(frame_handler, frame_filter)
+    device.add_message_callback(callback)
+
+    print("SPI frame reception configured")
+
+
+def cleanup_device(device):
+    """Close device connection."""
+    if device:
+        device.close()
+        print("Device connection closed")
+
+
+def main():
+    """Complete SPI example with proper error handling."""
+    device = None
+
+    try:
+        # Setup device
+        device = setup_device()
+
+        # Open device
+        if not open_device(device):
+            raise RuntimeError("Failed to initialize device")
+
+        # Setup frame reception
+        setup_spi_reception(device)
+
+        # Read 10BASE-T1S MACPHY ID register
+        transmit_spi_frame(device, 0x0, 0x0001, icsneopy.SPIMessage.Direction.Read)
+
+        # Change 10BASE-T1S Test mode control
+        transmit_spi_frame(device, 0x3, 0x08FB, icsneopy.SPIMessage.Direction.Read)
+        transmit_spi_frame(
+            device, 0x3, 0x08FB, icsneopy.SPIMessage.Direction.Write, 0x6000
+        )
+        transmit_spi_frame(device, 0x3, 0x08FB, icsneopy.SPIMessage.Direction.Read)
+
+        time.sleep(0.1)
+
+        # Listen for responses
+        print("Listening for SPI frames for 5 seconds...")
+        time.sleep(5)
+
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+    finally:
+        cleanup_device(device)
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

include/icsneo/api/event.h

@@ -54,7 +54,16 @@ public:
 		FixedPointOverflow = 0x1018,
 		FixedPointPrecision = 0x1019,
 		SyscallError = 0x1020, // check errno/GetLastError() for details
-
+		MACsecSecYLimit = 0x1021,
+		MACsecSaLimit = 0x1022,
+		MACsecRuleLimit = 0x1023,
+		MACsecInvalidSecYIndex = 0x1024,
+		MACsecInvalidSaIndex = 0x1025,
+		MACsecInvalidRuleIndex = 0x1026,
+		MACsecRekeyNotEnabled = 0x1027,
+		MACsecNotSupported = 0x1028,
+		MACsecConfigMismatch = 0x1029,
+		
 		// Device Events
 		PollingMessageOverflow = 0x2000,
 		NoSerialNumber = 0x2001, // api

include/icsneo/communication/command.h

@@ -8,6 +8,7 @@ namespace icsneo {
 enum class Command : uint8_t {
 	EnableNetworkCommunication = 0x07,
 	EnableNetworkCommunicationEx = 0x08,
+	KeepAlive = 0x09,
 	NeoReadMemory = 0x40,
 	NeoWriteMemory = 0x41,
 	ClearCoreMini = 0x42,
@@ -62,6 +63,8 @@ enum class ExtendedCommand : uint16_t {
 	RequestTC10Wake = 0x003D,
 	RequestTC10Sleep = 0x003E,
 	GetTC10Status = 0x003F,
+	ProtobufAPI = 0x0041,
+	TransmitMessage = 0x0042,
 };
 
 enum class ExtendedResponse : int32_t {

include/icsneo/communication/communication.h

@@ -42,6 +42,7 @@ public:
 	bool close();
 	bool isOpen();
 	bool isDisconnected();
+
 	virtual void spawnThreads();
 	virtual void joinThreads();
 	void modeChangeIncoming() { driver->modeChangeIncoming(); }
@@ -63,6 +64,8 @@ public:
 	std::optional< std::vector< std::optional<DeviceAppVersion> > > getVersionsSync(std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
 	std::shared_ptr<LogicalDiskInfoMessage> getLogicalDiskInfoSync(std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
 	std::optional< std::vector<ComponentVersion> > getComponentVersionsSync(std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
+	std::optional<uint32_t> getClientIDSync();
+	
 
 	int addMessageCallback(const std::shared_ptr<MessageCallback>& cb);
 	bool removeMessageCallback(int id);

include/icsneo/communication/driver.h

@@ -11,10 +11,13 @@
 #include <condition_variable>
 #include "icsneo/api/eventmanager.h"
 #include "icsneo/third-party/concurrentqueue/blockingconcurrentqueue.h"
-#include "icsneo/communication/ringbuffer.h"
+#include "icsneo/core/ringbuffer.h"
+#include "icsneo/device/founddevice.h"
 
 namespace icsneo {
 
+typedef std::function<void(std::vector<FoundDevice>&)> driver_finder_t;
+
 #define ICSNEO_DRIVER_RINGBUFFER_SIZE (512 * 1024)
 class Driver {
 public:
@@ -25,6 +28,7 @@ public:
 	virtual void modeChangeIncoming() {}
 	virtual void awaitModeChangeComplete() {}
 	virtual bool close() = 0;
+	virtual driver_finder_t getFinder() = 0;
 
 	inline bool isDisconnected() const { return disconnected; };
 	inline bool isClosing() const { return closing; }
@@ -37,6 +41,7 @@ public:
 	bool readAvailable() { return readBuffer.size() > 0; }
 	RingBuffer& getReadBuffer() { return readBuffer; }
 
+
 	virtual bool enableCommunication(bool /* enable */, bool& sendMsg) { sendMsg = true; return true; }
 
 	device_eventhandler_t report;

include/icsneo/communication/icspb.h

@@ -0,0 +1,127 @@
+#ifndef COMMUNICATION_PROTO_API_IMPL_H
+#define COMMUNICATION_PROTO_API_IMPL_H
+
+#include <cstdint>
+
+#ifdef _WIN32
+#pragma warning(push, 0)
+#endif
+#include <common/v1/proto_header.pb.h>
+#include <commands/generic/v1/client_id.pb.h>
+#include <commands/network/v1/mutex.pb.h>
+#ifdef _WIN32
+#pragma warning(pop)
+#endif
+
+namespace icsneo {
+namespace protoapi {
+
+enum class Command : uint8_t {
+	Unspecified = 0,
+	GET = 1,
+	PUT = 2,
+	PATCH = 3,
+};
+
+enum class Id : uint32_t {
+	Unspecified = 0,
+	MfgConfig = 1,
+	CpuId = 2,
+	NetworkMutex = 3,
+	ClientId = 4,
+};
+
+template <typename T>
+struct IDLookup {
+	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_UNSPECIFIED;
+};
+
+template <>
+struct IDLookup<commands::network::v1::NetworkMutex> {
+	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_NETWORK_MUTEX;
+};
+
+template <>
+struct IDLookup<commands::generic::v1::ClientId> {
+	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_GET_CLIENT_ID;
+};
+
+inline uint8_t* writeVarint32(uint32_t value, uint8_t* target) {
+	return google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(value, target);
+}
+
+inline const uint8_t* readVarint32(uint32_t& value, const uint8_t* source) {
+	value = 0;
+	do {
+		value <<= 7;
+		value += *source & 0x7F;
+	} while(*source++ & 0x80);
+	return source;
+}
+
+template <typename T>
+std::vector<uint8_t> getPayload(Command command, const T& msg) {
+	std::vector<uint8_t> payload;
+	constexpr uint32_t proto_version = 1;
+	common::v1::ProtoHeader hdr;
+	hdr.set_version(proto_version);
+	hdr.set_api_command(static_cast<common::v1::ApiCommand>(command));
+	hdr.set_auth_method(common::v1::AuthMethod::PROTO_API_AUTH_NONE); // TODO
+	hdr.set_proto_id(IDLookup<T>::value);
+
+	static constexpr size_t varint_size_max = 5;
+	size_t header_size = hdr.ByteSizeLong();
+	size_t msg_size = msg.ByteSizeLong();
+	size_t payload_size_max = header_size + msg_size + (varint_size_max * 2); // TODO: auth
+	payload.resize(payload_size_max);
+
+	uint8_t* target = payload.data();
+
+	target = writeVarint32(static_cast<uint32_t>(header_size), target);
+	hdr.SerializeToArray(target, static_cast<int>(header_size));
+	target += header_size;
+	if(msg_size) {
+		target = writeVarint32(static_cast<uint32_t>(msg_size), target);
+		msg.SerializeToArray(target, static_cast<int>(msg_size));
+		target += msg_size;
+	}
+	payload.resize(target - payload.data());
+	return payload;
+}
+
+template <typename T>
+bool processResponse(const uint8_t* payload, size_t /* payload_length */, T& msg) {
+	// TODO: we should probably check payload_length throughout to not go past the end of the supplied buffer
+
+	// header
+	common::v1::ProtoHeader hdr;
+	uint32_t length;
+	const uint8_t* serialized = readVarint32(length, payload);
+	if(!hdr.ParseFromArray(serialized, length)) {
+		return false;
+	}
+	// message payload
+	serialized = readVarint32(length, serialized + length);
+	if(!msg.ParseFromArray(serialized, length)) {
+		return false;
+	}
+	return true;
+}
+
+inline Id getProtoId(const uint8_t* payload, size_t /* payload_length */) {
+	// TODO: we should probably check this throughout to not go past the end of the supplied buffer
+
+	// header
+	common::v1::ProtoHeader hdr;
+	uint32_t length;
+	const uint8_t* serialized = readVarint32(length, payload);
+	if(!hdr.ParseFromArray(serialized, length)) {
+		return Id::Unspecified;
+	}
+	return static_cast<Id>(hdr.proto_id());
+}
+
+} // namespace protoapi
+} // namespace icsneo
+
+#endif

include/icsneo/communication/message/clientidmessage.h

@@ -0,0 +1,21 @@
+#ifndef CLIENT_ID_MESSAGE_H_
+#define CLIENT_ID_MESSAGE_H_
+
+#include <cstdint>
+#include "icsneo/communication/network.h"
+#include "icsneo/communication/message/message.h"
+#include "icsneo/api/eventmanager.h"
+
+namespace icsneo {
+
+class ClientIdMessage : public Message {
+public:
+	ClientIdMessage() : Message(Message::Type::ClientId) {}
+	static std::shared_ptr<ClientIdMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+
+	std::optional<uint32_t> clientId;
+};
+
+} // namespace icsneo
+
+#endif

include/icsneo/communication/message/ethernetstatusmessage.h

@@ -25,6 +25,7 @@ public:
 		LinkModeMaster,
 		LinkModeSlave,
 		LinkModeInvalid,
+		LinkModeNone,
 	};
 	EthernetStatusMessage(Network net, bool state, LinkSpeed speed, bool duplex, LinkMode mode) : Message(Type::EthernetStatus),
 		network(net), state(state), speed(speed), duplex(duplex), mode(mode) {}

include/icsneo/communication/message/macsecmessage.h

@@ -1,200 +0,0 @@
-#ifndef __MACSECMESSAGE_H__
-#define __MACSECMESSAGE_H__
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/message.h"
-#include "icsneo/communication/packet.h"
-#include "icsneo/api/eventmanager.h"
-#include <vector>
-#include <memory>
-#include <array>
-#include <cstring>
-
-namespace icsneo {
-
-struct MACsecVLANTag
-{
-	uint16_t vid; /*!< 12 bits */
-	uint8_t priCfi; /*!< PRI - 3 bits, CFI - 1bit */
-};
-
-struct MACsecMPLSOuter
-{
-	uint32_t mplsLabel; /*!< 20 bits */
-	uint8_t exp; /*!< 3 bits */
-};
-
-enum class MACsecPacketType : uint8_t
-{
-	NoVLANOrMPLS = 0,
-	SingleVLAN = 1,
-	DualVLAN = 2,
-	MPLS = 3,
-	SingleVLANFollowedByMPLS = 4,
-	DualVLANFollowedByMPLS = 5,
-	Unsupported = 6,
-};
-
-struct MACsecRule
-{
-	uint8_t index;
-	std::array<uint8_t, 6> keyMacDa; /*!< MAC DA field extracted from the packet */
-	std::array<uint8_t, 6> maskMacDa; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	std::array<uint8_t, 6> keyMacSa; /*!< MAC SA field extracted from the packet */
-	std::array<uint8_t, 6> maskMacSa; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	uint16_t keyEthertype; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
-	uint16_t maskEthertype; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	MACsecVLANTag keyVlanTagOuter1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-	MACsecMPLSOuter keyMplsOuter1;
-	MACsecVLANTag maskVlanTagOuter1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	MACsecMPLSOuter maskMplsOuter1;
-	MACsecVLANTag keyVlanTagOuter2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-	MACsecMPLSOuter keyMplsOuter2;
-	MACsecVLANTag maskVlanTagOuter2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	MACsecMPLSOuter maskMplsOuter2;
-	uint16_t keyBonusData; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
-	uint16_t maskBonusData; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	uint8_t keyTagMatchBitmap; /*!< 8 bits total. Maps 1 to 1 bitwise with the set of custom tags. (set bit[N]=1 if check Nth custom tag) */
-	uint8_t maskTagMatchBitmap; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	MACsecPacketType keyPacketType; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
-	uint8_t maskPacketType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	uint16_t keyInnerVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
-	uint16_t maskInnerVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	uint16_t keyOuterVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
-	uint16_t maskOuterVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	uint8_t keyNumTags; /*!< 7 bits total. Number of VLAN/custom tags or MPLS lables detected. Ingress: before SecTag; Egress: total detected. Exclude MCS header tags. i.e. Bit 2: 2 tags/labels before SecTAG...Bit 6: 6 or more tags/labels before SecTAG. */
-	uint8_t maskNumTags; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	bool keyExpress; /*!< 1 bits. Express packet. */
-	uint8_t maskExpress; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-	bool isMpls;
-	bool enable;
-};
-
-struct MACsecMap
-{
-	uint8_t index;
-	uint64_t secTagSci; /*!< Identifies the SecTAG SCI for this Flow. */
-	uint8_t secYIndex; /*!< index for entry in Egress secY Policy */
-	bool isControlPacket; /*!< Identifies all packets matching this index lookup as control packets. */
-	uint8_t scIndex; /*!< Identifies the SC for this Flow. */
-	uint8_t auxiliaryPlcy; /*!< Auxiliary policy bits. */
-	uint8_t ruleId; /*!< Identifies the Rule for this Flow. */
-	bool enable;
-};
-
-enum class MACsecValidateFrameType : uint8_t
-{
-	Disabled = 0, /*!< Disable validation */
-	Check = 1, /*!< Enable validation, do not discard invalid frames*/
-	Strict = 2, /*!< Enable validation and discard invalid frames */
-	NA = 3 /*!< No processing or accounting */
-};
-
-enum class MACsecSecTagIcvStripType : uint8_t
-{
-	StripBoth = 0, /*!< Strip both SecTag and ICV from packet */
-	StripSecTagPreserveICV = 1,
-	PreserveSecTagStripICV = 2, /*!< Preserve SecTag, Strip ICV */
-	PreserveBoth = 3 /*!< Preserve both SecTag and ICV */
-};
-
-enum class MACsecCipherSuiteType : uint8_t
-{
-	GcmAes128 = 0,
-	GcmAes256 = 1,
-	GcmAes128Xpn = 2,
-	GcmAes256Xpn = 3
-};
-
-struct MACsecSecY
-{
-	uint8_t index; /*!< Identifies the SecY for this Flow. */
-	bool controlledPortEnabled; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
-	MACsecValidateFrameType frameValidationType; /*!< see MACSEC_VALIDATEFRAME */
-	MACsecSecTagIcvStripType secTagIcvStripType; /*!< see MACSEC_STRIP_SECTAG_ICV */
-	MACsecCipherSuiteType cipher; /*!< Define the cipher suite to use for this SecY see MACSEC_CIPHER_SUITE */
-	uint8_t confidentialOffset; /*!< Define the number of bytes that are unencrypted following the SecTag. */
-	bool icvIncludesDaSa; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
-	bool replayProtect; /*!< Enables Anti-Replay protection */
-	uint32_t replayWindow; /*!< Unsigned value indicating the size of the anti-replay window. */
-	bool protectFrames; /*!< 0 = do not encrypt or authenticate this packet; 1 = always Authenticate frame and if SecTag.TCI.E = 1 encrypt the packet as well. */
-	uint8_t secTagOffset; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
-	uint8_t secTagTci; /*!< Tag Control Information excluding the AN field which originates from the SA Policy table */
-	uint16_t mtu; /*!< Specifies the outgoing MTU for this SecY */
-	bool enable;
-};
-
-struct MACsecSc
-{
-	uint8_t index; /*!< SC index. */
-	uint8_t secYIndex; /*!< SecY associated with this packet. */
-	uint64_t sci; /*!< The Secure Channel Identifier. */
-	uint8_t saIndex0; /*!< Define the 1st SA to use */
-	uint8_t saIndex1; /*!< Define the 2nd SA to use */
-	bool saIndex0InUse; /*!< Specifies whether 1st SA is in use or not. */
-	bool saIndex1InUse; /*!< Specifies whether 2nd SA is in use or not.  */
-	bool enableAutoRekey; /*!< If enabled, then once the pn_threshold is reached, auto rekey will happen. */
-	bool isActiveSa1; /*!< If set, then sa_index1 is the currently active SA index. If cleared, the sa_index0 is the currently active SA index). */
-	bool enable;
-};
-
-struct MACsecSa
-{
-	uint8_t index; /*!< SA index */
-	std::array<uint8_t, 32> sak; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
-	std::array<uint8_t, 16> hashKey; /*!< 128b Hash Key: Key used for authentication. */
-	std::array<uint8_t, 12> salt; /*!< 96b Salt value: Salt value used in XPN ciphers. */
-	uint32_t ssci; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
-	uint8_t an; /*!< 2b SecTag Association Number (AN) */
-	uint64_t nextPn; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
-	bool enable;
-};
-
-struct MACSecFlags
-{
-	bool en; // '1' = enable; '0' = disable
-};
-
-/* MACSec Settings for 1 port/phy */
-struct MACsecConfig
-{
-	static constexpr int NumFlags = 1;
-	static constexpr int NumRules = 2;
-	static constexpr int NumMaps = 2;
-	static constexpr int NumSecY = 2;
-	static constexpr int NumSc = 2;
-	static constexpr int NumSa = 4;
-
-	MACSecFlags flags;
-	std::array<MACsecRule, NumRules> rule;
-	std::array<MACsecMap, NumMaps> map;
-	std::array<MACsecSecY, NumSecY> secy;
-	std::array<MACsecSc, NumSc> sc;
-	std::array<MACsecSa, NumSa> sa;
-};
-
-struct MACSecGlobalFlags
-{
-	bool en; // '1' = enable; '0' = disable
-	bool nvm; // store macsec config in non-volatile memory
-};
-
-class MACsecMessage : public Message
-{
-public:
-	MACsecMessage(void) : Message(Message::Type::RawMessage) {}
-
-	MACSecGlobalFlags flags;
-	MACsecConfig rx;
-	MACsecConfig tx;
-
-	static std::shared_ptr<MACsecMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report);
-	bool EncodeFromMessage(std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) const;
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/communication/message/message.h

@@ -45,6 +45,8 @@ public:
 		GPTPStatus = 0x8013,
 		EthernetStatus = 0x8014,
 		LogData = 0x8015,
+		NetworkMutex = 0x8016,
+		ClientId = 0x8017,
 	};
 
 	Message(Type t) : type(t) {}

include/icsneo/communication/message/networkmutexmessage.h

@@ -0,0 +1,82 @@
+#ifndef __NETWORKMUTEXMESSAGE_H_
+#define __NETWORKMUTEXMESSAGE_H_
+
+#include <cstdint>
+#include <set>
+#include "icsneo/communication/network.h"
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+#include "icsneo/api/eventmanager.h"
+
+namespace icsneo {
+
+enum class NetworkMutexType : uint8_t {
+	Shared = 0,
+	TxExclusive = 1,
+	ExternalExclusive = 2,
+	FullyExclusive = 3,
+};
+
+enum class NetworkMutexEvent : uint8_t {
+	Released = 0,
+	Expired = 1,
+	Preempted = 2,
+	Queued = 3,
+	Acquired = 4,
+};
+
+class NetworkMutexMessage : public Message
+{
+public:
+	NetworkMutexMessage() : Message(Message::Type::NetworkMutex) {}
+
+	static std::shared_ptr<NetworkMutexMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+	static std::vector<uint8_t> EncodeArgumentsForLock(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const std::set<Network::NetID>& networks, const device_eventhandler_t& report);
+	static std::vector<uint8_t> EncodeArgumentsForLockAll(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const device_eventhandler_t& report);
+	static std::vector<uint8_t> EncodeArgumentsForUnlock(uint32_t client_id, const std::set<Network::NetID>& networks, const device_eventhandler_t& report);
+	static std::vector<uint8_t> EncodeArgumentsForUnlockAll(uint32_t client_id, const device_eventhandler_t& report);
+	static std::vector<uint8_t> EncodeArgumentsForStatus(Network::NetID network, const device_eventhandler_t& report);
+
+	static const char* GetNetworkMutexTypeString(NetworkMutexType type) {
+		switch(type) {
+			case icsneo::NetworkMutexType::Shared:
+				return "Shared";
+			case icsneo::NetworkMutexType::TxExclusive:
+				return "TxExclusive";
+			case icsneo::NetworkMutexType::ExternalExclusive:
+				return "ExternalExclusive";
+			case icsneo::NetworkMutexType::FullyExclusive:
+				return "FullyExclusive";
+			default:
+				return "Unknown";
+		}
+	}
+
+	static const char* GetNetworkMutexEventString(NetworkMutexEvent event) {
+		switch(event) {
+			case icsneo::NetworkMutexEvent::Acquired:
+				return "Acquired";
+			case icsneo::NetworkMutexEvent::Released:
+				return "Released";
+			case icsneo::NetworkMutexEvent::Preempted:
+				return "Preempted";
+			case icsneo::NetworkMutexEvent::Expired:
+				return "Expired";
+			case icsneo::NetworkMutexEvent::Queued:
+				return "Queued";
+			default:
+				return "Unknown";
+		}
+	}
+
+	std::optional<uint32_t> owner_id;
+	std::optional<NetworkMutexType> type;
+	std::optional<uint32_t> priority;
+	std::optional<uint32_t> ttlMs;
+	std::set<Network::NetID> networks;
+	std::optional<NetworkMutexEvent> event;
+};
+
+} // namespace icsneo
+
+#endif

include/icsneo/communication/message/transmitmessage.h

@@ -0,0 +1,30 @@
+#ifndef TRANSMIT_MESSAGE_H_
+#define TRANSMIT_MESSAGE_H_
+
+#include <cstdint>
+#include "icsneo/communication/message/message.h"  
+#include "icsneo/api/eventmanager.h"
+
+namespace icsneo {
+
+struct TransmitMessage {
+	static std::vector<uint8_t> EncodeFromMessage(std::shared_ptr<Frame> message, uint32_t client_id, const device_eventhandler_t& report);
+
+	constexpr static size_t messageOptionsOffset = 0;
+	constexpr static size_t messageOptionsSize = 20; // todo determine max
+	constexpr static size_t messageCommonHeaderOffset = messageOptionsOffset + messageOptionsSize; 
+	constexpr static size_t messageCommonHeaderSize = 28; // CoreminiMsgExtendedHdr
+#pragma pack(push,1)
+	struct
+	{
+		uint32_t clientId;
+		uint32_t networkId;
+		uint32_t reserved[3]; // set to 0
+	} options;
+	uint8_t commonHeader[messageCommonHeaderSize];
+#pragma pack(pop)
+};
+
+} // namespace icsneo
+
+#endif // TRANSMIT_MESSAGE_H_

include/icsneo/communication/packet/canpacket.h

@@ -50,6 +50,9 @@ struct HardwareCANPacket {
 		uint64_t : 3; // Reserved for future status bits
 		uint64_t IsExtended : 1;
 	} timestamp;
+	
+	uint16_t NetworkID;
+	uint16_t Length;
 };
 struct HardwareCANErrorPacket {
 	uint8_t error_code;

include/icsneo/communication/packet/linpacket.h

@@ -54,9 +54,6 @@ struct HardwareLINPacket {
 
 	uint16_t stats; //CxTRB0STAT
 	uint64_t timestamp; //Large timestamp
-	//CoreMiniMsgExtendedHdr
-	uint16_t networkID;
-	uint16_t length;
 };
 
 #pragma pack(pop)

include/icsneo/communication/packetizer.h

@@ -4,7 +4,7 @@
 #ifdef __cplusplus
 
 #include "icsneo/communication/packet.h"
-#include "icsneo/communication/ringbuffer.h"
+#include "icsneo/core/ringbuffer.h"
 #include "icsneo/api/eventmanager.h"
 #include <queue>
 #include <vector>

include/icsneo/communication/ringbuffer.h

@@ -1,75 +0,0 @@
-#ifndef _RINGBUFFER_H_
-#define _RINGBUFFER_H_
-
-#include <cstdint>
-#include <cstddef>
-#include <memory>
-#include <cstring>
-#include <mutex>
-#include <atomic>
-#include <vector>
-#if __cplusplus >= 202002L
-#include <bit>
-#endif
-namespace icsneo {
-
-class RingBuffer
-{
-private:
-    static constexpr size_t RoundUp(size_t size) {
-        if (size == 0) {
-            // Avoid underflow when decrementing later
-            return 1;
-        } else if (size >= SIZE_MAX) {
-            // overflow case - resolve to max size
-            return MaxSize;
-        }
-#if __cplusplus >= 202002L
-        // c++20 gives us countl_zero which should be more effecient on most platforms
-        auto lzero = std::countl_zero(size - 1);
-        auto shift = (sizeof(size_t) * 8) - lzero;
-        return 1ull << shift;
-#else
-        // Bit twiddling magic! See http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-        --size;
-        size |= size >> 1;
-        size |= size >> 2;
-        size |= size >> 4;
-        for (size_t i = 1; i < sizeof(size_t); i <<= 1) {
-            size |= size >> (i << 3);
-        }
-        ++size;
-        return size;
-#endif
-    }
-    //static_assert(std::atomic<size_t>::is_always_lock_free, "RingBuffer cursor types are not lock-free");
-    std::atomic<size_t> readCursor;
-    std::atomic<size_t> writeCursor;
-    // Use this to mask the cursor values to the buffer size. This is set to capacity - 1 where capacity is always an integral power of 2 (2, 4, 8, 16, etc)
-    size_t mask;
-    uint8_t* buf;
-
-public:
-    static constexpr auto MaxSize =  1ull << ((8 * sizeof(size_t)) - 1);
-    RingBuffer(size_t bufferSize);
-    ~RingBuffer();
-    const uint8_t& operator[](size_t offset) const;
-    size_t size() const;
-    void pop_front();
-    void pop(size_t count);
-    const uint8_t& get(size_t offset) const;
-    bool write(const uint8_t* addr, size_t count);
-    bool write(const std::vector<uint8_t>& source);
-    bool read(uint8_t* dest, size_t startIndex, size_t length) const;
-    void clear();
-    constexpr size_t capacity() const {
-        return mask + 1;
-    }
-
-protected:
-    inline uint8_t* resolve(size_t cursor, size_t offset) const {
-        return &buf[(cursor + offset) & mask];
-    }
-};
-}
-#endif

include/icsneo/core/crc32.h

@@ -5,13 +5,12 @@
  *      Author: BJones
  */
 
-#pragma once
+#ifndef __CRC32_H_
-
+#define __CRC32_H_
-#ifndef CRC32_H_
-#define CRC32_H_
 
 #include <stdint.h>
 
+namespace icsneo {
 /*
  * When any data/buffer is run through calCRC(), then the resulting CRC value
  *  is appended to the end of the data/buffer and the data/buffer is rerun
@@ -24,4 +23,6 @@
 uint32_t crc32(uint32_t crc, const unsigned char* buf, uint32_t len);
 uint32_t revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len);
 
+}
+
 #endif // CRC32_H_

include/icsneo/core/macseccfg.h

@@ -0,0 +1,217 @@
+#ifndef __MACSEC_CONFIG_H_
+#define __MACSEC_CONFIG_H_
+
+#include <vector>
+#include <array>
+#include <stdint.h>
+#include "icsneo/device/devicetype.h"
+
+namespace icsneo {
+
+
+struct MACsecVLANTag {
+	uint16_t vid = 0xFFFFu; /*!< 12 bits */
+	uint8_t priCfi = 0xFFu; /*!< PRI - 3 bits, CFI - 1bit */
+};
+
+struct MACsecMPLSOuter {
+	uint32_t mplsLabel = 0xFFFFFFFFu; /*!< 20 bits */
+	uint8_t exp = 0xFFu; /*!< 3 bits */
+};
+
+enum class MACsecPacketType : uint8_t {
+	Default = 0,
+	SingleVLAN = 1,
+	DualVLAN = 2,
+	MPLS = 3,
+	SingleVLANFollowedByMPLS = 4,
+	DualVLANFollowedByMPLS = 5,
+	Unsupported = 6,
+};
+
+// Tell the MACsec phy which packets to accept
+struct MACsecRxRule {
+	std::array<uint8_t, 6> keyMacDa = {0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu}; /*!< MAC DA field extracted from the packet */
+	std::array<uint8_t, 6> maskMacDa = {0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu}; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	std::array<uint8_t, 6> keyMacSa = {0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu}; /*!< MAC SA field extracted from the packet */
+	std::array<uint8_t, 6> maskMacSa = {0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu}; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	uint16_t keyEthertype = 0xFFFFu; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
+	uint16_t maskEthertype = 0xFFFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	MACsecVLANTag keyVlanTagOuter1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+	MACsecMPLSOuter keyMplsOuter1;
+	MACsecVLANTag maskVlanTagOuter1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	MACsecMPLSOuter maskMplsOuter1;
+	MACsecVLANTag keyVlanTagOuter2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+	MACsecMPLSOuter keyMplsOuter2;
+	MACsecVLANTag maskVlanTagOuter2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	MACsecMPLSOuter maskMplsOuter2;
+	uint16_t keyBonusData = 0xFFFFu; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
+	uint16_t maskBonusData = 0xFFFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	uint8_t keyTagMatchBitmap = 0xFFu; /*!< 8 bits total. Maps 1 to 1 bitwise with the set of custom tags. (set bit[N]=1 if check Nth custom tag) */
+	uint8_t maskTagMatchBitmap = 0xFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	MACsecPacketType keyPacketType = MACsecPacketType::Default; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
+	uint8_t maskPacketType = 0xFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	uint16_t keyInnerVlanType = 0xFFFFu; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
+	uint16_t maskInnerVlanType = 0xFFFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	uint16_t keyOuterVlanType = 0xFFFFu; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
+	uint16_t maskOuterVlanType = 0xFFFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	uint8_t keyNumTags = 0xFFu; /*!< 7 bits total. Number of VLAN/custom tags or MPLS lables detected. Ingress: before SecTag; Egress: total detected. Exclude MCS header tags. i.e. Bit 2: 2 tags/labels before SecTAG...Bit 6: 6 or more tags/labels before SecTAG. */
+	uint8_t maskNumTags = 0xFFu; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	bool keyExpress = true; /*!< 1 bits. Express packet. */
+	bool maskExpress = true; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+	bool isMpls = false;
+};
+
+enum class MACsecValidation : uint8_t {
+	Disabled = 0, /*!< Disable validation */
+	Check = 1, /*!< Enable validation, do not discard invalid frames*/
+	Strict = 2, /*!< Enable validation and discard invalid frames */
+	NA = 3 /*!< No processing or accounting */
+};
+
+enum class MACsecStrip : uint8_t {
+	StripSecTagAndIcv = 0, /*!< Strip both SecTag and ICV from packet */
+	StripSecTagPreserveICV = 1,
+	PreserveSecTagStripICV = 2, /*!< Preserve SecTag, Strip ICV */
+	NoStrip = 3 /*!< Preserve both SecTag and ICV */
+};
+
+enum class MACsecCipherSuite : uint8_t {
+	GcmAes128 = 0,
+	GcmAes256 = 1,
+	GcmAes128Xpn = 2,
+	GcmAes256Xpn = 3
+};
+
+// Tag control information
+struct MACsecTci {
+	bool es = false; // End station bit
+	bool sc = true; // SCI included bit
+	bool scb = false; // Single Copy Broadcast
+	bool e = false; // Encryption bit
+	bool c = false; // Changed text bit
+};
+
+
+struct MACsecRxSecY {
+	bool enableControlPort = true; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
+	MACsecValidation frameValidation = MACsecValidation::Strict; /*!< see MACSEC_VALIDATEFRAME */
+	MACsecStrip frameStrip = MACsecStrip::NoStrip; /*!< see MACSEC_STRIP_SECTAG_ICV */
+	MACsecCipherSuite cipher = MACsecCipherSuite::GcmAes128; /*!< Define the cipher suite to use for this SecY see MACSEC_CIPHER_SUITE */
+	uint8_t confidentialityOffset = 0; /*!< Define the number of bytes that are unencrypted following the SecTag. */
+	bool icvIncludesDaSa = true; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
+	bool replayProtect = true; /*!< Enables Anti-Replay protection */
+	uint32_t replayWindow = 1; /*!< Unsigned value indicating the size of the anti-replay window. */
+	bool isControlPacket = false; /*!< Identifies all packets matching this index lookup as control packets. */
+	uint64_t sci; /** The SCI of this secY */
+};
+
+struct MACsecTxSecY {
+	bool enableControlPort = true; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
+	MACsecCipherSuite cipher = MACsecCipherSuite::GcmAes128; /*!< Define the cipher suite to use for this SecY see MACSEC_CIPHER_SUITE */
+	uint8_t confidentialityOffset = 0; /*!< Define the number of bytes that are unencrypted following the SecTag. */
+	bool icvIncludesDaSa = true; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
+	bool protectFrames = true; /*!< 0 = do not encrypt or authenticate this packet; 1 = always Authenticate frame and if SecTag.TCI.E = 1 encrypt the packet as well. */
+	uint8_t secTagOffset = 12; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
+	MACsecTci tci; /*!< Tag Control Information excluding the AN field which originates from the SA Policy table */
+	uint16_t mtu = 0xFFFFu; /*!< Specifies the outgoing MTU for this SecY */
+	bool isControlPacket = false; /*!< Identifies all packets matching this index lookup as control packets. */
+	uint8_t auxiliaryPolicy = 0u; /*!< Auxiliary policy bits. */
+	uint64_t sci = 0x1122334455660001u;
+};
+
+struct MACsecTxSa {
+	std::array<uint8_t, 32> sak = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 
+		0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
+	std::array<uint8_t, 16> hashKey = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 128b Hash Key: Key used for authentication. */
+	std::array<uint8_t, 12> salt = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 96b Salt value: Salt value used in XPN ciphers. */
+	uint32_t ssci = 0x01u; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
+	uint8_t an = 0x00;; /*!< 2b SecTag Association Number (AN) */
+	uint64_t nextPn = 0x01u; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
+};
+
+struct MACsecRxSa {
+	std::array<uint8_t, 32> sak = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 
+		0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
+	std::array<uint8_t, 16> hashKey = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 128b Hash Key: Key used for authentication. */
+	std::array<uint8_t, 12> salt = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u}; /*!< 96b Salt value: Salt value used in XPN ciphers. */
+	uint32_t ssci = 0x01u; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
+	uint64_t nextPn = 0x01u; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
+};
+
+class MACsecConfig {
+private:
+	bool enableRx = false;
+	bool enableTx = false;
+	bool nvm = false;
+
+	uint8_t maxSecY;
+	uint8_t maxSa;
+	uint8_t maxRule;
+	uint16_t binIndex;
+	DeviceType type;
+
+	std::vector<MACsecRxRule> rxRule;
+	std::vector<MACsecRxSecY> rxSecY;
+	std::vector<MACsecTxSecY> txSecY;
+	std::vector<MACsecTxSa> txSa;
+	std::vector<MACsecRxSa> rxSa;
+	std::vector<std::pair<uint8_t, uint8_t>> txSecYSaIndices;
+	std::vector<std::pair<uint8_t, uint8_t>> rxSecYSaIndices;
+	std::vector<bool> rxSecYRekey;
+	std::vector<bool> txSecYRekey;
+	std::vector<uint8_t> rxRuleIndices;
+public:
+	MACsecConfig() = delete;
+	MACsecConfig(const DeviceType& deviceType);
+
+	int addRxSecY(const MACsecRxSecY& secY, uint8_t saIndex);
+	int addTxSecY(const MACsecTxSecY& secY, uint8_t saIndex);
+	
+	int addRxRule(const MACsecRxRule& rule, uint8_t secYIndex);
+
+	int addRxSa(const MACsecRxSa& sa);
+	int addTxSa(const MACsecTxSa& sa);
+
+	MACsecRxSecY& getRxSecY(uint8_t secYIndex);
+	const MACsecRxSecY& getRxSecY(uint8_t secYIndex) const;
+	MACsecTxSecY& getTxSecY(uint8_t secYIndex);
+	const MACsecTxSecY& getTxSecY(uint8_t secYIndex) const;
+
+	MACsecRxSa& getRxSa(uint8_t saIndex);
+	const MACsecRxSa& getRxSa(uint8_t saIndex) const;
+	MACsecTxSa& getTxSa(uint8_t saIndex);
+	const MACsecTxSa& getTxSa(uint8_t saIndex) const;
+
+	MACsecRxRule& getRxRule(uint8_t ruleIndex);
+	const MACsecRxRule& getRxRule(uint8_t ruleIndex) const;
+
+	bool setTxSaIndex(uint8_t secYIndex, uint8_t saIndex);
+	bool enableTxRekey(uint8_t secYIndex, uint8_t rekeySaIndex);
+	bool setTxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex);
+	void disableTxRekey(uint8_t secYIndex);
+
+	bool setRxSaIndex(uint8_t secYIndex, uint8_t saIndex);
+	bool enableRxRekey(uint8_t secYIndex, uint8_t rekeySaIndex);
+	bool setRxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex);
+	void disableRxRekey(uint8_t secYIndex);
+
+	void setRxEnable(bool rxEnable);
+	void setTxEnable(bool txEnable);
+	void setStorage(bool temporary);
+	
+	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;
+	uint8_t getMaxNumSa() const;
+};
+
+}
+
+#endif
+
+

include/icsneo/core/ringbuffer.h

@@ -0,0 +1,75 @@
+#ifndef _RINGBUFFER_H_
+#define _RINGBUFFER_H_
+
+#include <cstdint>
+#include <cstddef>
+#include <memory>
+#include <cstring>
+#include <mutex>
+#include <atomic>
+#include <vector>
+#if __cplusplus >= 202002L
+#include <bit>
+#endif
+namespace icsneo {
+
+class RingBuffer
+{
+private:
+	static constexpr size_t RoundUp(size_t size) {
+		if (size == 0) {
+			// Avoid underflow when decrementing later
+			return 1;
+		} else if (size >= SIZE_MAX) {
+			// overflow case - resolve to max size
+			return MaxSize;
+		}
+#if __cplusplus >= 202002L
+		// c++20 gives us countl_zero which should be more effecient on most platforms
+		auto lzero = std::countl_zero(size - 1);
+		auto shift = (sizeof(size_t) * 8) - lzero;
+		return 1ull << shift;
+#else
+		// Bit twiddling magic! See http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+		--size;
+		size |= size >> 1;
+		size |= size >> 2;
+		size |= size >> 4;
+		for (size_t i = 1; i < sizeof(size_t); i <<= 1) {
+			size |= size >> (i << 3);
+		}
+		++size;
+		return size;
+#endif
+	}
+	//static_assert(std::atomic<size_t>::is_always_lock_free, "RingBuffer cursor types are not lock-free");
+	std::atomic<size_t> readCursor;
+	std::atomic<size_t> writeCursor;
+	// Use this to mask the cursor values to the buffer size. This is set to capacity - 1 where capacity is always an integral power of 2 (2, 4, 8, 16, etc)
+	size_t mask;
+	uint8_t* buf;
+
+public:
+	static constexpr auto MaxSize =  1ull << ((8 * sizeof(size_t)) - 1);
+	RingBuffer(size_t bufferSize);
+	~RingBuffer();
+	const uint8_t& operator[](size_t offset) const;
+	size_t size() const;
+	void pop_front();
+	void pop(size_t count);
+	const uint8_t& get(size_t offset) const;
+	bool write(const uint8_t* addr, size_t count);
+	bool write(const std::vector<uint8_t>& source);
+	bool read(uint8_t* dest, size_t startIndex, size_t length) const;
+	void clear();
+	constexpr size_t capacity() const {
+		return mask + 1;
+	}
+
+protected:
+	inline uint8_t* resolve(size_t cursor, size_t offset) const {
+		return &buf[(cursor + offset) & mask];
+	}
+};
+}
+#endif

include/icsneo/device/bootloaderpipeline.h

@@ -0,0 +1,128 @@
+#ifndef __BOOTLOADER_PIPELINE_H_
+#define __BOOTLOADER_PIPELINE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/chipid.h"
+
+#include <vector>
+#include <memory>
+#include <variant>
+#include <utility>
+
+namespace icsneo {
+
+enum class BootloaderCommunication {
+	RAD,
+	RED,
+	REDCore,
+	RADGalaxy2Peripheral,
+	RADMultiChip,
+	Application,
+	Invalid
+};
+
+struct BootloaderPhase {
+	enum class Type {
+		Flash,
+		Finalize,
+		Reconnect,
+		EnterBootloader,
+		Wait,
+		EnterApplication
+	};
+
+	virtual Type getType() const = 0;
+	virtual ~BootloaderPhase() = default;
+};
+
+struct ReconnectPhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::Reconnect;
+	}
+
+	ReconnectPhase() = default;
+};
+
+struct FinalizePhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::Finalize;
+	}
+	
+	ChipID chip;
+	BootloaderCommunication comm;
+
+	FinalizePhase(ChipID chip, BootloaderCommunication comm) : chip(chip), comm(comm) {}
+};
+
+struct WaitPhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::Wait;
+	}
+
+	std::chrono::milliseconds timeout;
+
+	WaitPhase(std::chrono::milliseconds timeout) : timeout(timeout) {}
+};
+
+struct EnterBootloaderPhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::EnterBootloader;
+	}
+};
+
+struct EnterApplicationPhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::EnterApplication;
+	}
+
+	ChipID chip;
+
+	EnterApplicationPhase(ChipID chip) : chip(chip) {}
+};
+
+struct FlashPhase : public BootloaderPhase {
+	Type getType() const override {
+		return Type::Flash;
+	}
+
+	ChipID chip;
+	BootloaderCommunication comm;
+	bool authenticate = true;
+	bool encrypt = true;
+	bool checkOutOfDate = true;
+
+	FlashPhase(ChipID chip, BootloaderCommunication comm, bool authenticate = true, bool encrypt = true, bool checkOutOfDate = true) 
+		: chip(chip), comm(comm), authenticate(authenticate), encrypt(encrypt), checkOutOfDate(checkOutOfDate) {}
+};
+
+enum class BootloaderSetting {
+	UpdateAll
+};
+
+struct BootloaderPipeline {
+	std::vector<std::shared_ptr<BootloaderPhase>> phases;
+	std::unordered_map<BootloaderSetting, std::variant<int, bool>> settings;
+
+	template<typename Phase, typename... Args>
+	BootloaderPipeline& add(Args... args) {
+		phases.emplace_back(std::make_shared<Phase>(std::forward<Args>(args)...));
+		return *this;
+	}
+
+	BootloaderPipeline& addSetting(BootloaderSetting type, const std::variant<int, bool>& setting) {
+		settings.insert({type, setting});
+		return *this;
+	}
+
+	operator bool() const {
+		return !phases.empty();
+	}
+	
+};
+
+}
+
+#endif // __cplusplus
+
+#endif

include/icsneo/device/chipid.h

@@ -0,0 +1,140 @@
+#ifndef __CHIP_ID_H_
+#define __CHIP_ID_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+
+namespace icsneo {
+
+enum class ChipID : uint8_t {
+	neoVIFIRE_MCHIP = 0,
+	neoVIFIRE_LCHIP = 1,
+	neoVIFIRE_UCHIP = 2,
+	neoVIFIRE_JCHIP = 3,
+	ValueCAN3_MCHIP = 4,
+	neoVIECU_MPIC = 6,
+	neoVIIEVB_MPIC = 7,
+	neoVIPENDANT_MPIC = 8,
+	neoVIFIRE_VNET_MCHIP = 9,
+	neoVIFIRE_VNET_LCHIP = 10,
+	neoVIPLASMA_Core = 11,
+	neoVIPLASMA_HID = 12,
+	neoVIANALOG_MPIC = 13,
+	neoVIPLASMA_ANALOG_Core = 14,
+	neoVIPLASMA_FlexRay_Core = 15,
+	neoVIPLASMA_Core_1_12 = 16,
+	neoVIFIRE_Slave_VNET_MCHIP = 17,
+	neoVIFIRE_Slave_VNET_LCHIP = 18,
+	neoVIION_Core = 19,
+	neoVIION_HID = 20,
+	neoVIION_Core_Loader = 21,
+	neoVIION_HID_Loader = 22,
+	neoVIION_FPGA_BIT = 23,
+	neoVIFIRE_VNET_EP_MCHIP = 24,
+	neoVIFIRE_VNET_EP_LCHIP = 25,
+	neoVIAnalogOut_MCHIP = 26,
+	neoVIMOST25_MCHIP = 27,
+	neoVIMOST50_MCHIP = 28,
+	neoVIMOST150_MCHIP = 29,
+	ValueCAN4_4_MCHIP = 30,
+	ValueCAN4_4_SCHIP = 31,
+	cmProbe_ZYNQ = 33,
+	EEVB_STM32 = 34,
+	neoVIFIRE_Slave_VNET_EP_MCHIP = 35,
+	neoVIFIRE_Slave_VNET_EP_LCHIP = 36,
+	RADStar_MCHIP = 37,
+	ValueCANrf_MCHIP = 38,
+	neoVIFIRE2_MCHIP = 39,
+	neoVIFIRE2_CCHIP = 40,
+	neoVIFIRE2_Core = 41,
+	neoVIFIRE2_BLECHIP = 42,
+	neoVIFIRE2_ZYNQ = 43, // FIRE2 MVNET Z - Zynq
+	neoVIFIRE2_SECURITYCHIP = 44,
+	RADGalaxy_ZYNQ = 45,
+	neoVIFIRE2_VNET_MCHIP = 46,
+	neoVIFIRE2_Slave_VNET_A_MCHIP = 47,
+	neoVIFIRE2_Slave_VNET_A_CCHIP = 48,
+	neoVIFIRE2_VNET_CCHIP = 49,
+	neoVIFIRE2_VNET_Core = 50,
+	RADStar2_ZYNQ = 51,
+	VividCAN_MCHIP = 52,
+	neoOBD2SIM_MCHIP = 53,
+	neoVIFIRE2_VNETZ_MCHIP = 54,
+	neoVIFIRE2_VNETZ_ZYNQ = 55,
+	neoVIFIRE2_Slave_VNETZ_A_MCHIP = 56,
+	neoVIFIRE2_Slave_VNETZ_A_ZYNQ = 57,
+	VividCAN_EXT_FLASH = 58,
+	VividCAN_NRF52 = 59,
+	cmProbe_ZYNQ_Unused = 60, // Double defined
+	neoOBD2PRO_MCHIP = 61,
+	ValueCAN4_1_MCHIP = 62,
+	ValueCAN4_2_MCHIP = 63,
+	ValueCAN4_4_2EL_Core = 64,
+	neoOBD2PRO_SCHIP = 65,
+	ValueCAN4_2EL_MCHIP = 67,
+	neoECUAVBTSN_MCHIP = 68,
+	neoOBD2PRO_Core = 69,
+	RADSupermoon_ZYNQ = 70,
+	RADMoon2_ZYNQ = 71,
+	VividCANPRO_MCHIP = 72,
+	VividCANPRO_EXT_FLASH = 73,
+	RADPluto_MCHIP = 74,
+	RADMars_ZYNQ = 75,
+	neoECU12_MCHIP = 76,
+	RADIOCANHUB_MCHIP = 77,
+	FlexRay_VNETZ_ZCHIP = 78,
+	neoOBD2_LCBADGE_MCHIP = 79,
+	neoOBD2_LCBADGE_SCHIP = 80,
+	RADMoonDuo_MCHIP = 81,
+	neoVIFIRE3_ZCHIP = 82,
+	FlexRay_VNETZ_FCHIP = 83,
+	RADJupiter_MCHIP = 84,
+	ValueCAN4Industrial_MCHIP = 85,
+	EtherBADGE_MCHIP = 86,
+	RADMars_3_ZYNQ = 87,
+	RADGigastar_USBZ_ZYNQ = 88,
+	RADGigastar_ZYNQ = 89,
+	RAD4G_MCHIP = 90,
+	neoVIFIRE3_SCHIP = 91,
+	RADEpsilon_MCHIP = 92,
+	RADA2B_ZCHIP = 93,
+	neoOBD2Dev_MCHIP = 94,
+	neoOBD2Dev_SCHIP = 95,
+	neoOBD2SIMDoIP_MCHIP = 96,
+	SFPModule_MCHIP = 97,
+	RADEpsilonT_MCHIP = 98,
+	RADEpsilonExpress_MCHIP = 99,
+	RADProxima_MCHIP = 100,
+	NewDevice57_ZCHIP = 101,
+	RAD_GALAXY_2_ZMPCHIP_ID = 102,
+	NewDevice59_MCHIP = 103,
+	RADMoon2_Z7010_ZYNQ = 104,
+	neoVIFIRE2_CORE_SG4 = 105,
+	RADBMS_MCHIP = 106,
+	RADMoon2_ZL_MCHIP = 107,
+	RADGigastar_USBZ_Z7010_ZYNQ = 108,
+	neoVIFIRE3_LINUX = 109,
+	RADGigastar_USBZ_Z7007S_ZYNQ = 110,
+	VEM_01_8DW_ZCHIP = 111,
+	RADGalaxy_FFG_Zynq = 112,
+	RADMoon3_MCHIP = 113,
+	RADComet_ZYNQ = 114,
+	VEM_02_FR_ZCHIP = 115,
+	RADA2B_REVB_ZCHIP = 116,
+	RADGigastar_FFG_ZYNQ = 117,
+	VEM_02_FR_FCHIP = 118,
+	Connect_ZCHIP = 121,
+	RADGALAXY2_SYSMON_CHIP = 123,
+	RADCOMET3_ZCHIP = 125,
+	Connect_LINUX = 126,
+	RADGigastar2_ZYNQ = 131,
+	RADGemini_MCHIP = 135,
+	Invalid = 255
+};
+
+}
+
+#endif // __cplusplus
+
+#endif

include/icsneo/device/chipinfo.h

@@ -0,0 +1,59 @@
+#ifndef __CHIP_INFO_H_
+#define __CHIP_INFO_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/chipid.h"
+
+#include <vector>
+
+namespace icsneo {
+
+enum class FirmwareType {
+	IEF,
+	Zip
+};
+
+struct ChipInfo {
+	/**
+	 * The default enabled field is for devices which can't deduce the specific ChipID of a device
+	 * until entering the bootloader.
+	 * 
+	 * If defaultEnabled is set to true, the bootloader and version retrieval functions assume that
+	 * the chip is enabled, so it will perform version deduction based on the default enabled chip. If
+	 * defaultEnabled is set to false, then this chip info may or may not apply to this device
+	 * 
+	 * Example: RADA2B RevA and RevB chips
+	 * 
+	 * Sometimes we can't deduce whether we have a RevA or RevB chip before entering the bootloader if the
+	 * device does not support component versions. These chips track the same version, so we assume that the
+	 * chip is RevA (RevA defaultEnabled=true, RevB defaultEnabled=false) and check during the bootloader 
+	 * if this chip is RevA or RevB.
+	 */
+	ChipID id;
+	bool defaultEnabled = false;
+	const char* name = nullptr; // Chip user displayable name
+	const char* iefName = nullptr; // IEF name for a single segment chip (example RADA2B ZCHIP)
+	size_t versionIndex = 0; // Main and Secondary version index
+	FirmwareType fwType; // Firmwaare storagae type
+	std::vector<const char*> iefSegments; // IEF names for a multi segment chip (example RADGalaxy2 ZCHIP)
+
+	ChipInfo() = default;
+
+	ChipInfo(ChipID id, bool defaultEnabled, const char* name, const char* iefName, size_t versionIndex, FirmwareType fwType)
+		: id(id), defaultEnabled(defaultEnabled), name(name), iefName(iefName), versionIndex(versionIndex), fwType(fwType) {}
+
+	ChipInfo(ChipID id, bool defaultEnabled, const char* name, const char* iefName, const std::vector<const char*>& iefSegments, size_t versionIndex, FirmwareType fwType)
+		: id(id), defaultEnabled(defaultEnabled), name(name), iefName(iefName), versionIndex(versionIndex), fwType(fwType), iefSegments(iefSegments) {}
+
+	bool isMultiIEF() const {
+		return !iefSegments.empty();
+	}
+
+};
+
+}
+
+#endif // __cplusplus
+
+#endif

include/icsneo/device/device.h

@@ -13,6 +13,7 @@
 #include <optional>
 #include <unordered_map>
 #include <set>
+#include <unordered_set>
 #include <chrono>
 #include "icsneo/api/eventmanager.h"
 #include "icsneo/api/lifetime.h"
@@ -24,6 +25,9 @@
 #include "icsneo/device/deviceversion.h"
 #include "icsneo/device/founddevice.h"
 #include "icsneo/device/coremini.h"
+#include "icsneo/device/bootloaderpipeline.h"
+#include "icsneo/device/chipinfo.h"
+#include "icsneo/device/versionreport.h"
 #include "icsneo/disk/diskreaddriver.h"
 #include "icsneo/disk/diskwritedriver.h"
 #include "icsneo/disk/nulldiskdriver.h"
@@ -42,7 +46,7 @@
 #include "icsneo/communication/message/extendeddatamessage.h"
 #include "icsneo/communication/message/livedatamessage.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
-#include "icsneo/communication/message/macsecmessage.h"
+#include "icsneo/core/macseccfg.h"
 #include "icsneo/communication/packet/genericbinarystatuspacket.h"
 #include "icsneo/communication/packet/livedatapacket.h"
 #include "icsneo/device/extensions/flexray/controller.h"
@@ -54,7 +58,7 @@
 #include "icsneo/disk/vsa/vsaparser.h"
 #include "icsneo/communication/message/versionmessage.h"
 #include "icsneo/communication/message/gptpstatusmessage.h"
-
+#include "icsneo/communication/message/networkmutexmessage.h"
 
 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
 	static constexpr DeviceType::Enum DEVICE_TYPE = type; \
@@ -86,6 +90,78 @@ class Device {
 public:
 	virtual ~Device();
 
+	enum class ProductID : uint8_t {
+		neoVIRED = 0,
+		neoVIFIRE = 1,
+		ValueCAN3 = 2,
+		VividCANPro = 3, // Previously neoVI Yellow
+		neoECU = 4,
+		IEVB = 5,
+		Pendant = 6,
+		neoAnalog = 7,
+		neoECU12 = 8,
+		neoVIPLASMA = 10,
+		neoVIION = 11,
+		ValueCAN4_2EL_4 = 12,
+		cmProbe = 14,
+		EEVB = 15,
+		RADStar = 16,
+		ValueCANrf = 17,
+		neoVIFIRE2 = 18,
+		RADGalaxy = 19,
+		RADStar2 = 20,
+		VividCAN = 21,
+		neoOBD2Sim = 22,
+		neoOBD2Pro = 23,
+		ValueCAN4_1_2 = 24,
+		neoECUAVBTSN = 25,
+		RADSupermoon = 26,
+		RADMoon2 = 27,
+		RADPluto = 28,
+		RADMars = 29,
+		RADIOCANHUB = 30,
+		neoOBD2LCBadge = 31,
+		RADMoonDuo = 32,
+		neoVIFIRE3 = 33,
+		RADJupiter = 34,
+		ValueCAN4Industrial = 35,
+		RADGigastar = 36,
+		VividCANProUnused = 37, // The VividCAN Pro was double allocated
+		EtherBADGE = 38,
+		RADEpsilon = 39,
+		RADA2B = 40,
+		SFPModule = 41,
+		RADGalaxy2 = 47,
+		RADMoon3 = 49,
+		RADComet = 50,
+		Connect = 51,
+		RADComet3 = 54,
+		RADMoonT1S = 56,
+		RADGigastar2 = 57,
+		RADGemini = 60,
+	};
+
+	virtual ProductID getProductID() const = 0;
+
+	/**
+	 * Returns information for all potential chips, note some chips
+	 * might not apply to a specific device depending on different
+	 * hardware versions
+	 */
+	virtual const std::vector<ChipInfo>& getChipInfo() const {
+		static std::vector<ChipInfo> placeHolder;
+		return placeHolder; // TODO: Make pure virtual maybe? 
+	}
+
+	/**
+	 * Returns bootloader instructions
+	 */
+	virtual BootloaderPipeline getBootloader() {
+		return {};
+	}
+
+	bool hasBootloader() { return !!getBootloader(); }
+
 	static std::string SerialNumToString(uint32_t serial);
 	static uint32_t SerialStringToNum(const std::string& serial);
 	static bool SerialStringIsNumeric(const std::string& serial);
@@ -155,6 +231,7 @@ public:
 	virtual bool goOffline();
 	virtual bool enableLogData();
 	virtual bool disableLogData();
+	virtual bool reconnect(std::chrono::milliseconds timeout, std::chrono::milliseconds interval = std::chrono::milliseconds(100));
 
 	enum class PreloadReturn : uint8_t
 	{
@@ -586,10 +663,13 @@ public:
 
 	bool refreshComponentVersions();
 	/**
-	 * For use by extensions only. A more stable API will be provided in the future.
+	 * For use by extensions only.
 	 */
 	const std::vector<std::optional<DeviceAppVersion>>& getVersions() const { return versions; }
 	const std::vector<ComponentVersion>& getComponentVersions() const { return componentVersions; }
+	
+	virtual std::vector<VersionReport> getChipVersions(bool refreshComponents = true);
+
 
 	/**
 	 * Some alternate communication protocols do not support DFU
@@ -775,9 +855,17 @@ public:
 	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
 	/* MACsec support */
-	virtual bool writeMACsecConfig(const MACsecMessage& message, uint16_t binaryIndex);
+	virtual bool writeMACsecConfig(const MACsecConfig& cfg);
 
 	std::shared_ptr<DeviceExtension> getExtension(const std::string& name) const;
+	
+	[[nodiscard]] std::optional<int> lockNetworks(const std::set<Network::NetID>& networks, uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event);
+	[[nodiscard]] std::optional<int> lockAllNetworks(uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event);
+	bool unlockNetworks(const std::set<Network::NetID>& networks);
+	bool unlockAllNetworks();
+	std::shared_ptr<NetworkMutexMessage> getNetworkMutexStatus(Network::NetID network);
+	
+	virtual bool supportsNetworkMutex() const { return false; }
 
 protected:
 	bool online = false;
@@ -822,6 +910,8 @@ protected:
 		diskWriteDriver = std::unique_ptr<DiskWrite>(new DiskWrite());
 		setupSupportedRXNetworks(supportedRXNetworks);
 		setupSupportedTXNetworks(supportedTXNetworks);
+		supportedRXNetworks.emplace_back(Network::NetID::Device);
+		supportedTXNetworks.emplace_back(Network::NetID::Device);
 		setupExtensions();
 	}
 
@@ -891,6 +981,8 @@ protected:
 	};
 	LEDState ledState;
 	void updateLEDState();
+
+
 private:
 	neodevice_t data;
 	std::shared_ptr<ResetStatusMessage> latestResetStatus;
@@ -1049,6 +1141,10 @@ private:
 
 	// Keeponline (keepalive for online)
 	std::unique_ptr<Periodic> keeponline;
+
+	std::optional<uint32_t> assignedClientId;
+	std::unordered_set<icsneo::Network::NetID> lockedNetworks;
+	std::optional<int> networkMutexCallbackHandle;
 };
 
 }

include/icsneo/device/devicetype.h

@@ -58,6 +58,7 @@ public:
 		RADGigastar2 = (0x00000029),
 		FIRE3_T1S_LIN = (0x0000002A),
 		FIRE3_T1S_SENT = (0x0000002B),
+		RADGemini = (0x0000002C),
 		RED = (0x00000040),
 		ECU = (0x00000080),
 		IEVB = (0x00000100),
@@ -148,6 +149,8 @@ public:
 				return "RAD-EpsilonXL";
 			case RADMoon3:
 				return "RAD-Moon 3";
+			case RADGemini:
+				return "RAD-Gemini";
 			case RADComet:
 				return "RAD-Comet";
 			case RED:
@@ -271,6 +274,7 @@ private:
 #define ICSNEO_DEVICETYPE_RADGIGASTAR2 ((devicetype_t)0x00000029)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_LIN ((devicetype_t)0x0000002A)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_SENT ((devicetype_t)0x0000002B)
+#define ICSNEO_DEVICETYPE_RADGEMINI ((devicetype_t)0x0000002C)
 #define ICSNEO_DEVICETYPE_RED ((devicetype_t)0x00000040)
 #define ICSNEO_DEVICETYPE_ECU ((devicetype_t)0x00000080)
 #define ICSNEO_DEVICETYPE_IEVB ((devicetype_t)0x00000100)

include/icsneo/device/founddevice.h

@@ -1,11 +1,12 @@
 #ifndef __FOUNDDEVICE_H_
 #define __FOUNDDEVICE_H_
 
-#include "icsneo/communication/driver.h"
 #include "icsneo/device/neodevice.h"
+#include "icsneo/api/eventmanager.h"
 
 namespace icsneo {
 
+class Driver;
 typedef std::function< std::unique_ptr<Driver>(device_eventhandler_t err, neodevice_t& forDevice) > driver_factory_t;
 
 class FoundDevice {

include/icsneo/device/idevicesettings.h

@@ -409,6 +409,14 @@ typedef struct ETHERNET10T1S_SETTINGS_EXT_t
 } ETHERNET10T1S_SETTINGS_EXT;
 #define ETHERNET10T1S_SETTINGS_EXT_SIZE 16
 
+typedef struct ETHERNET10T1L_SETTINGS_t
+{
+	uint8_t tx_mode;
+	uint8_t rsvd[7];
+} ETHERNET10T1L_SETTINGS;
+#define ETHERNET10T1L_SETTINGS_SIZE 8
+
+
 #define ETHERNET_SETTINGS10G_FLAG_FULL_DUPLEX  0x01
 #define ETHERNET_SETTINGS10G_FLAG_AUTO_NEG     0x02
 #define ETHERNET_SETTINGS10G_FLAG_TCPIP_ENABLE 0x04

include/icsneo/device/tree/etherbadge/etherbadge.h

@@ -26,6 +26,10 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::EtherBADGE;
+	}
+
 protected:
 	EtherBADGE(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<EtherBADGESettings>(makeDriver);

include/icsneo/device/tree/etherbadge/etherbadgesettings.h

@@ -56,11 +56,15 @@ typedef struct {
 		uint32_t enablePcEthernetComm : 1;
 		uint32_t reserved : 29;
 	} flags;//4
+
+	ETHERNET_SETTINGS2 ethernet2; //16
 } etherbadge_settings_t;
 #pragma pack(pop)
 
 #ifdef __cplusplus
 
+static_assert(sizeof(etherbadge_settings_t) == 316, "EtherBadge settings size mismatch");
+
 #include <iostream>
 
 class EtherBADGESettings : public IDeviceSettings {

include/icsneo/device/tree/neoobd2pro/neoobd2pro.h

@@ -22,6 +22,10 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::neoOBD2Pro;
+	}
+
 private:
 	NeoOBD2PRO(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize(makeDriver);