Rework reconnection logic

Signed-off-by: Christian Gabriel <ch_gabriel@web.de>

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "third-party/libicsneo"]
 	path = third-party/libicsneo
 	url = https://github.com/intrepidcs/libicsneo.git
+	branch = master

CHANGELOG

@@ -1,3 +1,29 @@
+v3.1.2
+	Update libicsneo
+	Update copyright
+	Add scan-interval-ms parameter (Jorge Alejandro <jorge.a.alejandro@gmail.com>)
+
+v3.1.1
+	Update libicsneo
+
+v3.1.0
+	Update libicsneo
+	Update copyright
+
+v3.0.0
+	Added Functionality for Ethernet
+
+v2.1.0
+	Update copyright date
+	Update to libicsneo v0.3.0
+	Report transmits down to the kernel for echo
+	Allow filtering devices by serial number
+
+v2.0.3
+	Update copyright date
+	Update to libicsneo v0.2.0
+	Ensure lock is held when accessing open devices
+
 v2.0.2
 	Use libicsneo v0.1.2 to resolve LEDs not indicating device status
 

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.2)
-project(libicsneo-socketcan-daemon VERSION 2.0.2)
+project(libicsneo-socketcan-daemon VERSION 3.2.0)
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 
 include(GNUInstallDirs)
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2019 Intrepid Control Systems, Inc.
+Copyright (c) 2016-2025 Intrepid Control Systems, Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README.md

@@ -1,18 +1,18 @@
-Version 2.0.2
+Version 3.1.2
 
 This is the usermode daemon for the Intrepid Control Systems SocketCAN support. This daemon requires that ```intrepid.ko``` is loaded on your system.
 
 1. Build and load the kernel module follwowing the instructions in [intrepid-socketcan-kernel-module](https://github.com/intrepidcs/intrepid-socketcan-kernel-module).
 
-2. Install the dependencies needed. These are CMake 3.2+, GCC 4.8+, git, and libusb-1.0-0-dev.
+2. Install the dependencies needed. These are CMake 3.2+, GCC 4.8+, git, libusb-1.0-0-dev, and libpcap.
 
-On Ubuntu or other Debian-based systems, run `sudo apt install git cmake gcc libusb-1.0-0-dev build-essential`.
+On Ubuntu or other Debian-based systems, run `sudo apt install git cmake gcc libusb-1.0-0-dev libpcap-dev build-essential`.
 
 3. Clone this repository recursively by running `git clone --recursive https://github.com/intrepidcs/icsscand.git`
 
 4. Switch into the cloned directory, `cd icsscand`
 
-5. Make a build directory and switch into it, `mkdir -p build && cd build`
+5. Make a build directory and switch into it, `mkdir build && cd build`
 
 6. Invoke CMake, `cmake .. -DCMAKE_BUILD_TYPE=Release`
 
@@ -24,6 +24,6 @@ On Ubuntu or other Debian-based systems, run `sudo apt install git cmake gcc lib
 
 10. CAN interfaces will have been created, but are "down" or, in other words, not enabled for transmit and receive yet. You can see them with `ip link`. They will be labelled `can0`, `can1`, and etc. They will have an alias listed which corresponds to the serial number of the device and network on that device.
 
-11. Enable the CAN interface with `sudo ip link set up can0`, replacing `can0` with whichever interface you'd like to enable
+11. Enable the CAN interface with `sudo ip link set can0 up`, replacing `can0` with whichever interface you'd like to enable
 
 12. You can now use any SocketCAN application with this interface. A good package for testing is the `can-utils` package. You can get this package with `sudo apt install can-utils`. A good testing tool which comes with this package is `candump`. Running `candump can0` will print a line for every incoming frame.

RPC.md

@@ -0,0 +1,95 @@
+# RPC
+
+icsscand contains an RPC endpoint that can be used to control the libicsneo
+instance within the daemon. To enable the RPC channel, add `--fifo-path <path>`
+during launching. The provided path will be used to open a named FIFO, the path
+should not exist prior to launching icsscand.
+
+## lock_networks
+
+Invokes `icsneo::Device::lockNetworks()` with the provided space separated
+arguments and writes the results of the call to the provided client FIFO. This
+call in non-blocking, with the return type indicating that the request was sent
+to the device (it does not indicate that the network was successfully locked).
+Use `get_network_mutex_status` to check the status of the lock request.
+
+### Usage
+
+- Request: `<api version> lock_networks <device serial> <netid integers, comma separated> <priority> <ttl, ms> <lock type> <client fifo path>`
+- Response: `<0 or 1, with 0 indicating an error and 1 indicating success>`
+  - On error, check the icsscand logs for more detailed information
+
+### Example
+
+- API version: 1
+- Service serial: ON0123
+- Networks: `ETHERNET_01` & `ETHERNET_02`
+  - See `icsneo::Network::NetID` for values
+- Priority: 2
+- TTL (in ms): 1s
+- Opened client FIFO path: `/tmp/tmp.AYkIg0b3np`
+  - This FIFO must be opened prior to invoking the RPC
+
+`1 lock_networks ON0123 93,520 2 1000 /tmp/tmp.AYkIg0b3np`
+
+## unlock_networks
+
+Invokes `icsneo::Device::unlockNetworks()` with the provided space separated
+arguments and writes the results of the call to the provided client FIFO.
+
+### Usage
+
+- Request: `<api version> unlock_networks <device serial> <netid integers, comma separated> <client fifo path>`
+- Response: `<0 or 1, with 0 indicating an error and 1 indicating success>`
+  - On error, check the icsscand logs for more detailed information
+
+### Example
+
+- API version: 1
+- Service serial: ON0123
+- Networks: `ETHERNET_01` & `ETHERNET_02`
+  - See `icsneo::Network::NetID` for values
+- Opened client FIFO path: `/tmp/tmp.KXY8SCXtux`
+  - This FIFO must be opened prior to invoking the RPC
+
+`1 lock_networks ON0123 93,520 /tmp/tmp.KXY8SCXtux`
+
+## get_network_mutex_status
+
+Invokes `icsneo::Device::getNetworkMutexStatus()` with the provided space separated
+arguments and writes the results of the call to the provided client FIFO.
+
+### Usage
+
+- Request: `<api version> get_network_mutex_status <device serial> <netid integer> <client fifo path>`
+- Response (one of):
+  - `0`, error, check the icsscand logs for more detailed information
+  - `1 <owner client id> <type> <priority> <ttl, ms> <netid integers, comma separated> <event>`
+
+### Example
+
+- API version: 1
+- Service serial: ON0123
+- Network: `ETHERNET_01`
+  - See `icsneo::Network::NetID` for values
+- Opened client FIFO path: `/tmp/tmp.4huaosZjhA`
+  - This FIFO must be opened prior to invoking the RPC
+
+`1 get_network_mutex_status ON0123 93 /tmp/tmp.4huaosZjhA`
+
+## get_serials
+
+Returns a space separated list of devices serial numbers that isscand has open.
+
+### Usage
+
+- Request: `<api version> get_serials <client fifo path>`
+- Response: `<0 or 1, with 0 indicating an error and 1 indicating success> [serial]...`
+
+### Example
+
+- API version: 1
+- Opened client FIFO path: `/tmp/tmp.bBcUh5obRK`
+  - This FIFO must be opened prior to invoking the RPC
+
+`1 get_serials /tmp/tmp.bBcUh5obRK`

src/main.cpp

@@ -17,29 +17,38 @@
 #include <fcntl.h>
 #include <signal.h>
 #include <linux/if.h>
+#include <sys/eventfd.h>
+#include <poll.h>
 
 #include <icsneo/icsneocpp.h>
 #include <icsneo/communication/message/neomessage.h>
+#include <icsneo/communication/message/message.h>
+#include <icsneo/communication/network.h>
 #include <icsneo/communication/message/callback/canmessagecallback.h>
 #include <generated/buildinfo.h>
 
-#define LOG(LVL, MSG)              do{if(runningAsDaemon) syslog(LVL, MSG); \
+#define LOG(LVL, MSG)			do{if(runningAsDaemon) syslog(LVL, MSG); \
-                                    else fprintf(stderr, MSG);}while(0)
+					else fprintf(stderr, MSG);}while(0)
-#define LOGF(LVL, MSG, ...)        do{if(runningAsDaemon) syslog(LVL, MSG, __VA_ARGS__); \
+#define LOGF(LVL, MSG, ...)		do{if(runningAsDaemon) syslog(LVL, MSG, __VA_ARGS__); \
-                                    else fprintf(stderr, MSG, __VA_ARGS__);}while(0)
+					else fprintf(stderr, MSG, __VA_ARGS__);}while(0)
 
-#define SIOCSADDIF                 0x3001
+#define SIOCSADDCANIF			0x3001
-#define SIOCSREMOVEIF              0x3002
+#define SIOCSADDETHIF			0x3002
-#define SIOCGSHAREDMEMSIZE         0x3003
+#define SIOCSREMOVECANIF		0x3003
-#define SIOCSMSGSWRITTEN           0x3004
+#define SIOCSREMOVEETHIF		0x3004
-#define SIOCGMAXIFACES             0x3005
+#define SIOCGSHAREDMEMSIZE		0x3005
-#define SIOCGVERSION               0x3006
+#define SIOCSMSGSWRITTEN		0x3006
-#define SIOCGCLIENTVEROK           0x3007
+#define SIOCGMAXIFACES			0x3007
+#define SIOCGVERSION			0x3008
+#define SIOCGCLIENTVEROK		0x3009
+#define SIOCSBAUDRATE			0x300A
 
-#define RX_BOX_SIZE                (sharedMemSize / (maxInterfaces * 2))
+#define RX_BOX_SIZE			(sharedMemSize / (maxInterfaces * 2))
-#define TX_BOX_SIZE                (sharedMemSize / 4)
+#define TX_BOX_SIZE			(sharedMemSize / 4)
-#define GET_RX_BOX(DEVICE_INDEX)   (reinterpret_cast<uint8_t*>(sharedMemory) + (RX_BOX_SIZE * DEVICE_INDEX))
+#define GET_RX_BOX(DEVICE_INDEX)	(reinterpret_cast<uint8_t*>(sharedMemory) + (RX_BOX_SIZE * DEVICE_INDEX))
-#define GET_TX_BOX(INDEX)          (reinterpret_cast<uint8_t*>(sharedMemory) + (sharedMemSize / 2) + (INDEX * TX_BOX_SIZE))
+#define GET_TX_BOX(INDEX)		(reinterpret_cast<uint8_t*>(sharedMemory) + (sharedMemSize / 2) + (INDEX * TX_BOX_SIZE))
+
+#define DEFAULT_SCAN_INTERVAL_MS 1000
 
 bool runningAsDaemon = false;
 int driver = 0; // /dev/intrepid_netdevice
@@ -49,6 +58,9 @@ int driverPatch = 0;
 int maxInterfaces = 0; // From driver
 int sharedMemSize = 0; // From driver
 void* sharedMemory = nullptr;
+std::string serialFilter;
+int scanIntervalMs = DEFAULT_SCAN_INTERVAL_MS;
+std::string fifoPath;
 
 std::atomic<bool> stopRunning(false);
 
@@ -60,10 +72,16 @@ struct intrepid_pending_tx_info {
 
 class NetworkInterface {
 public:
-	NetworkInterface(const std::string& desiredName) : name(desiredName) {
+	NetworkInterface(const std::string& desiredName, icsneo::Network::Type device) : type(device), name(desiredName) {
 		char ifname[IFALIASZ + 1] = {0};
 		strncpy(ifname, name.c_str(), IFALIASZ);
-		kernelHandle = ioctl(driver, SIOCSADDIF, ifname);
+
+		if(device == icsneo::Network::Type::CAN) {
+			kernelHandle = ioctl(driver, SIOCSADDCANIF, ifname); // this will call the intrepid_dev_ioctl()
+		} else if(device == icsneo::Network::Type::Ethernet) {
+			kernelHandle = ioctl(driver, SIOCSADDETHIF, ifname); // this will call the intrepid_dev_ioctl()
+		}
+
 		if(openedSuccessfully()) {
 			rxBox = GET_RX_BOX(kernelHandle);
 			rxBoxCurrentPosition = rxBox;
@@ -71,12 +89,36 @@ public:
 	}
 	~NetworkInterface() {
 		if(openedSuccessfully()) {
+			int res = 0;
 			LOGF(LOG_DEBUG, "Removing device %s with handle %d\n", name.c_str(), kernelHandle);
-			int res = ioctl(driver, SIOCSREMOVEIF, kernelHandle);
+			if(type == icsneo::Network::Type::CAN) {
+				res = ioctl(driver, SIOCSREMOVECANIF, kernelHandle);
+			} else if(type == icsneo::Network::Type::Ethernet) {
+				res = ioctl(driver, SIOCSREMOVEETHIF, kernelHandle);
+			}
 			LOGF(LOG_DEBUG, "Removed device %s with handle %d, result %d\n", name.c_str(), kernelHandle, res);
 		} else
 			LOG(LOG_DEBUG, "Removing interface which was not opened successfully\n");
 	}
+
+	bool reportBaudrates(int64_t baudrate, int64_t fd_baudrate) {
+		struct baudrate_info {
+			int handle;
+			int64_t baudrates[2];
+		} info;
+
+		info.handle = kernelHandle;
+		info.baudrates[0] = baudrate;
+		/* set fd baudrate to zero if equal to baudrate
+		 * this will disable fd mode in kernel */
+		info.baudrates[1] = (fd_baudrate==baudrate)?0:fd_baudrate;
+		if (ioctl(driver, SIOCSBAUDRATE, &info) != 0) {
+			LOGF(LOG_INFO, "Unable to set baudrate for device %s\n", name.c_str());
+			return false;
+		}
+
+		return true;
+	}
 	NetworkInterface(const NetworkInterface&) = delete;
 	NetworkInterface& operator =(const NetworkInterface&) = delete;
 
@@ -85,29 +127,42 @@ public:
 	const std::string& getName() const { return name; }
 	uint8_t* getRxBox() { return rxBox; }
 	const uint8_t* getRxBox() const { return rxBox; }
-	void addReceivedMessageToQueue(const std::shared_ptr<icsneo::Message>& msg) {
+
-		auto neomessage = icsneo::CreateNeoMessage(msg);
+	template<typename T>
-		size_t bytesNeeded = sizeof(neomessage) + neomessage.length;
+	void addReceivedMessageToQueue(const std::shared_ptr<icsneo::Frame>& msg) {
-		std::lock_guard<std::mutex> lg(rxBoxLock);
+		const auto neomessageGeneric = icsneo::CreateNeoMessage(msg);
-		if(ssize_t((rxBoxCurrentPosition - rxBox) + bytesNeeded) > RX_BOX_SIZE) {
+		if(neomessageGeneric.messageType != neomessagetype_t(icsneo::Message::Type::Frame)) {
-			// fail, too big!
+			LOG(LOG_DEBUG, "could not create a neomessage_can_t\n");
-			LOG(LOG_DEBUG, "box too small\n");
 			return;
 		}
-		memcpy(rxBoxCurrentPosition, &neomessage, sizeof(neomessage));
+
-		rxBoxCurrentPosition += sizeof(neomessage);
+		if(msg->network.getType() == icsneo::Network::Type::CAN || msg->network.getType() == icsneo::Network::Type::Ethernet) {
-		memcpy(rxBoxCurrentPosition, neomessage.data, neomessage.length);
+
-		rxBoxCurrentPosition += neomessage.length;
+			const auto& neomessage = *reinterpret_cast<const T*>(&neomessageGeneric);
-		rxBoxMessageCount++;
+
-		if(ioctl(driver, SIOCSMSGSWRITTEN, (kernelHandle << 16) | rxBoxMessageCount) < 0) {
+			size_t bytesNeeded = sizeof(neomessage) + neomessage.length;
-			LOGF(LOG_DEBUG, "send ioctl failed %d %zu\n", kernelHandle, rxBoxMessageCount);
+			std::lock_guard<std::mutex> lg(rxBoxLock);
-			return;
+			if(ssize_t((rxBoxCurrentPosition - rxBox) + bytesNeeded) > RX_BOX_SIZE) {
+				// fail, too big!
+				LOG(LOG_DEBUG, "box too small\n");
+				return;
+			}
+			memcpy(rxBoxCurrentPosition, &neomessage, sizeof(neomessage));
+			rxBoxCurrentPosition += sizeof(neomessage);
+			memcpy(rxBoxCurrentPosition, neomessage.data, neomessage.length);
+			rxBoxCurrentPosition += neomessage.length;
+			rxBoxMessageCount++;
+			if(ioctl(driver, SIOCSMSGSWRITTEN, (kernelHandle << 16) | rxBoxMessageCount) < 0) {
+				LOGF(LOG_DEBUG, "send ioctl failed %d %zu\n", kernelHandle, rxBoxMessageCount);
+				return;
+			}
+			rxBoxCurrentPosition = rxBox;
+			rxBoxMessageCount = 0;
 		}
-		rxBoxCurrentPosition = rxBox;
-		rxBoxMessageCount = 0;
 	}
 
 private:
+	icsneo::Network::Type type;
 	std::string name;
 	int kernelHandle = -1;
 	std::mutex rxBoxLock;
@@ -151,6 +206,327 @@ std::vector<OpenDevice> openDevices;
 std::vector<std::string /* serial */> failedToOpen;
 std::mutex openDevicesMutex;
 
+class RPC {
+public:
+	RPC() {
+		if(::mkfifo(fifoPath.c_str(), 0777) == -1) {
+			throw std::runtime_error("Error creating RPC FIFO: " + std::string(strerror(errno)));
+			return;
+		}
+		::chmod(fifoPath.c_str(), 0777);
+		fifo = ::open(fifoPath.c_str(), O_RDWR);
+		if(fifo == -1) {
+			throw std::runtime_error("Error opening RPC FIFO: " + std::string(strerror(errno)));
+			return;
+		}
+		interrupt = ::eventfd(0, 0);
+		if(interrupt == -1) {
+			throw std::runtime_error("Error opening eventfd: " + std::string(strerror(errno)));
+			return;
+		}
+		thread = std::thread(&RPC::loop, this);
+	}
+
+	~RPC() {
+		uint64_t u = 1;
+		::write(interrupt, &u, sizeof(uint64_t));
+		thread.join();
+		::close(fifo);
+		::close(interrupt);
+		::unlink(fifoPath.c_str());
+	}
+
+private:
+	int fifo;
+	int interrupt;
+	std::thread thread;
+
+	void loop() {
+		static char buffer[2048];
+		struct pollfd fds[2] = {};
+		fds[0].fd = fifo;
+		fds[0].events = POLLIN;
+		fds[1].fd = interrupt;
+		fds[1].events = POLLIN;
+		while (!stopRunning) {
+			if(::poll(fds, 2, -1) == -1) {
+				LOGF(LOG_WARNING, "Error polling for RPC: %s\n", strerror(errno));
+				break;
+			}
+			if(fds[1].revents & POLLIN) {
+				break;
+			}
+			const auto size = ::read(fifo, buffer, sizeof(buffer));
+			if (size == -1) {
+				LOGF(LOG_WARNING, "Error reading from RPC FIFO: %s\n", strerror(errno));
+				break;
+			}
+			const auto args = split(std::string(buffer, size));
+			if(args.size() < 2) {
+				continue;
+			}
+			const auto& apiVersion = args[0];
+			const auto& command = args[1];
+			if(apiVersion != "1") {
+				LOGF(LOG_WARNING, "Invalid API version, expected '1' got '%s'\n", apiVersion.c_str());
+				continue;
+			}
+			if(command == "lock_networks") {
+				lockNetworks(args);
+			} else if(command == "unlock_networks") {
+				unlockNetworks(args);
+			} else if(command == "get_network_mutex_status") {
+				getNetworkMutexStatus(args);
+			} else if(command == "get_serials") {
+				getSerials(args);
+			} else {
+				LOGF(LOG_WARNING, "Unknown command '%s'\n", command.c_str());
+			}
+		}
+	}
+
+	bool parseNetid(const std::string& arg, icsneo::Network::NetID& netid) {
+		try {
+			netid = static_cast<icsneo::Network::NetID>(std::stoi(arg));
+			return true;
+		} catch (const std::exception& e) {
+			LOGF(LOG_WARNING, "Invalid netid '%s': %s\n", arg.c_str(), e.what());
+			return false;
+		}
+	}
+
+	bool parseNetids(const std::string& arg, std::set<icsneo::Network::NetID>& netids) {
+		for(auto&& str : split(arg, ',')) {
+			icsneo::Network::NetID nid;
+			if(!parseNetid(str, nid)) {
+				return false;
+			}
+			netids.emplace(nid);			
+		}
+		return true;
+	}
+
+	template<typename T>
+	std::string optionalArg(const std::optional<T>& opt) {
+		return opt ? std::to_string((uint64_t)*opt) : "-1";
+	}
+
+
+	bool fifoWrite(const std::string& message, const std::string& fifoPath) {
+		int fifo = ::open(fifoPath.c_str(), O_WRONLY);
+		if(fifo == -1) {
+			return false;
+		}
+		if(::write(fifo, message.c_str(), message.size()) == -1) {
+			::close(fifo);
+			return false;
+		}
+		::close(fifo);
+		return true;
+	}
+
+	std::vector<std::string> split(const std::string& str, char delim = ' ') {
+		if(str.empty())
+			return {};
+		std::vector<std::string> ret;
+		size_t tail = 0;
+		size_t head = 0;
+		while(head < str.size()) {
+			if(str[head] == delim) {
+				ret.emplace_back(&str[tail], head - tail);
+				tail = head + 1;
+			}
+			++head;
+		}
+		ret.emplace_back(&str[tail], head - tail);
+		return ret;
+	}
+
+	std::string join(const std::vector<std::string>& parts, char delim = ' ') {
+		if(parts.empty())
+			return "";
+		std::string ret = parts[0];
+		for(size_t i = 1; i < parts.size(); i++) {
+			ret += delim + parts[i];
+		}
+		return ret;
+	}
+
+	void lockNetworks(const std::vector<std::string>& args) {
+		if(args.size() != 8) {
+			LOGF(LOG_WARNING, "lock_networks requires 8 arguments, got %zu\n", args.size());
+			return;
+		}
+		const auto& serial = args[2];
+		const auto& clientFifoPath = args[7];
+
+		std::set<icsneo::Network::NetID> netids;
+		if(!parseNetids(args[3], netids)) {
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		uint32_t priority;
+		try {
+			priority = std::stoul(args[4]);
+		} catch (const std::exception& e) {
+			LOGF(LOG_WARNING, "Invalid priority '%s': %s\n", args[4].c_str(), e.what());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+		
+		uint32_t ttl;
+		try {
+			ttl = std::stoul(args[5]);
+		} catch (const std::exception& e) {
+			LOGF(LOG_WARNING, "Invalid TTL '%s': %s\n", args[5].c_str(), e.what());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		icsneo::NetworkMutexType type;
+		try {
+			type = static_cast<icsneo::NetworkMutexType>(std::stoi(args[6]));
+		} catch (const std::exception& e) {
+			LOGF(LOG_WARNING, "Invalid mutex type '%s': %s\n", args[6].c_str(), e.what());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		std::lock_guard<std::mutex> lg(openDevicesMutex);
+		std::shared_ptr<icsneo::Device> device;
+		for(const auto& dev : openDevices) {
+			if(dev.device->getSerial() == serial) {
+				device = dev.device;
+				break;
+			}
+		}
+		if(!device) {
+			LOGF(LOG_WARNING, "Device with serial '%s' not found\n", serial.c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+		const auto locked = device->lockNetworks(netids, priority, ttl, type, [serial](std::shared_ptr<icsneo::Message> msg) -> void {
+			auto mutexMsg = std::dynamic_pointer_cast<icsneo::NetworkMutexMessage>(msg);
+			if(!mutexMsg) {
+				LOG(LOG_WARNING, "Received a message for the network mutex callback which was not a NetworkMutexMessage\n");
+				return;
+			}
+			LOGF(LOG_INFO, "Received network mutex event for device %s\n", serial.c_str());
+		});
+		if(!locked) {
+			LOGF(LOG_WARNING, "Failed to lock networks for device '%s'\n", icsneo::GetLastError().describe().c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+		device->removeMessageCallback(*locked); // client will explicitly poll status
+		fifoWrite("1", clientFifoPath);
+	}
+
+	void unlockNetworks(const std::vector<std::string>& args) {
+		if(args.size() != 5) {
+			LOGF(LOG_WARNING, "unlock_networks requires 5 arguments, got %zu\n", args.size());
+			return;
+		}
+		const auto& serial = args[2];
+		const auto& clientFifoPath = args[4];
+
+		std::set<icsneo::Network::NetID> netids;
+		if(!parseNetids(args[3], netids)) {
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		std::lock_guard<std::mutex> lg(openDevicesMutex);
+		std::shared_ptr<icsneo::Device> device;
+		for(const auto& dev : openDevices) {
+			if(dev.device->getSerial() == serial) {
+				device = dev.device;
+				break;
+			}
+		}
+		if(!device) {
+			LOGF(LOG_WARNING, "Device with serial '%s' not found\n", serial.c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		const auto success = device->unlockNetworks(netids);
+		if(!success) {
+			LOGF(LOG_WARNING, "Failed to unlock networks for device '%s': %s\n", serial.c_str(), icsneo::GetLastError().describe().c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+		fifoWrite("1", clientFifoPath);
+	}
+
+	void getNetworkMutexStatus(const std::vector<std::string>& args) {
+		if(args.size() != 5) {
+			LOGF(LOG_WARNING, "get_network_mutex_status requires 5 arguments, got %zu\n", args.size());
+			return;
+		}
+		const auto& serial = args[2];
+		const auto& clientFifoPath = args[4];
+
+		icsneo::Network::NetID netid;
+		if(!parseNetid(args[3], netid)) {
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		std::lock_guard<std::mutex> lg(openDevicesMutex);
+		std::shared_ptr<icsneo::Device> device;
+		for(const auto& dev : openDevices) {
+			if(dev.device->getSerial() == serial) {
+				device = dev.device;
+				break;
+			}
+		}
+		if(!device) {
+			LOGF(LOG_WARNING, "Device with serial '%s' not found\n", serial.c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		const auto status = device->getNetworkMutexStatus(netid);
+
+		if(!status) {
+			LOGF(LOG_WARNING, "Failed to get network mutex status for device '%s': %s\n", serial.c_str(), icsneo::GetLastError().describe().c_str());
+			fifoWrite("0", clientFifoPath);
+			return;
+		}
+
+		const std::string id = optionalArg(status->owner_id);
+		const std::string type = optionalArg(status->type);
+		const std::string priority = optionalArg(status->priority);
+		const std::string ttl = optionalArg(status->ttlMs);
+		std::vector<std::string> networkStrs;
+		for(const auto& net : status->networks) {
+			networkStrs.push_back(std::to_string((neonetid_t)net));
+		}
+		const std::string networks = join(networkStrs, ',');
+		const std::string event = optionalArg(status->event);
+
+		const std::string response = join({"1", id, type, priority, ttl, networks, event});
+
+		fifoWrite(response, clientFifoPath);
+	}
+
+	void getSerials(const std::vector<std::string>& args) {
+		if(args.size() != 3) {
+			LOGF(LOG_WARNING, "get_serials requires 3 arguments, got %zu\n", args.size());
+			return;
+		}
+		const auto& clientFifoPath = args[2];
+		std::string response = "1";
+		std::lock_guard<std::mutex> lg(openDevicesMutex);
+		for(const auto& dev : openDevices) {
+			response += ' ' + dev.device->getSerial();
+		}
+		fifoWrite(response, clientFifoPath);
+	}
+};
+
 std::string& replaceInPlace(std::string& str, char o, const std::string& n) {
 	size_t start_pos = 0;
 	const size_t new_len = n.length();
@@ -170,7 +546,7 @@ std::string sanitizeInterfaceName(std::string str) {
 
 void header() {
 	std::cout << "The libicsneo SocketCAN Usermode Daemon\n";
-	std::cout << "Copyright Intrepid Control Systems, Inc. 2019\n\n";
+	std::cout << "Copyright Intrepid Control Systems, Inc. 2025\n\n";
 	std::cout << "Daemon v";
 	std::cout << (int)ICSNEO_SOCKETCAN_BUILD_MAJOR << '.' << (int)ICSNEO_SOCKETCAN_BUILD_MINOR << '.' << (int)ICSNEO_SOCKETCAN_BUILD_PATCH;
 	if(ICSNEO_SOCKETCAN_BUILD_METADATA[0] != '\0')
@@ -187,12 +563,15 @@ void header() {
 
 void usage(std::string executableName) {
 	std::cerr << "The libicsneo SocketCAN Usermode Daemon\n";
-	std::cerr << "Copyright Intrepid Control Systems, Inc. 2019\n\n";
+	std::cerr << "Copyright 2019-2025 Intrepid Control Systems, Inc.\n\n";
 	std::cerr << "Usage: " << executableName << " [option]\n\n";
 	std::cerr << "Options:\n";
-	std::cerr << "\t-d,     --daemon\t\tRun as a daemon in the background\n";
+	std::cerr << "\t-d,     --daemon\t\t\tRun as a daemon in the background\n";
-	std::cerr << "\t-h, -?, --help, --usage\t\tShow this help page\n";
+	std::cerr << "\t-h, -?, --help, --usage\t\t\tShow this help page\n";
-	std::cerr << "\t        --devices\t\tList supported devices\n";
+	std::cerr << "\t        --devices\t\t\tList supported devices\n";
+	std::cerr << "\t        --filter <serial>\t\tOnly connect to devices with serial\n\t\t\t\t\t\tnumbers starting with this filter\n";
+	std::cerr << "\t        --scan-interval-ms <interval>\tDevice scan interval in ms\n\t\t\t\t\t\tIf 0, only a single scan is performed\n";
+	std::cerr << "\t        --fifo-path <path>\t\tPath to RPC FIFO for libicsneo control\n";
 }
 
 void terminateSignal(int signal) {
@@ -200,8 +579,8 @@ void terminateSignal(int signal) {
 }
 
 void searchForDevices() {
-	auto found = icsneo::FindAllDevices();
 	std::lock_guard<std::mutex> lg(openDevicesMutex);
+	auto found = icsneo::FindAllDevices();
 
 	// Open devices we have not seen before
 	for(auto& dev : found) {
@@ -215,42 +594,48 @@ void searchForDevices() {
 		if(alreadyOpen)
 			continue;
 
+		const std::string serial = dev->getSerial();
+
+		// If we have a serial filter, make sure our serial starts with the given filter
+		if(!serialFilter.empty() && serial.rfind(serialFilter, 0) != 0)
+			continue;
+
 		// Now open the device
 		OpenDevice newDevice(dev);
-		const std::string serial = newDevice.device->getSerial();
 		Lazy<bool> firstTimeFailedToOpen([&serial]() {
 			return std::find(failedToOpen.begin(), failedToOpen.end(), serial) == failedToOpen.end();
 		});
 		if(!newDevice.device->open() || !newDevice.device->goOnline()) {
 			if(firstTimeFailedToOpen) {
-				icsneo::APIEvent err = icsneo::GetLastError();
+				const std::string err = icsneo::GetLastError().describe();
-				LOGF(LOG_INFO, "%s failed to connect. Will keep trying...\n%s\n", newDevice.device->describe().c_str(), err.describe().c_str());
+				LOGF(LOG_INFO, "%s failed to connect. Will keep trying...\n%s\n", newDevice.device->describe().c_str(), err.c_str());
 				failedToOpen.push_back(serial);
 			}
 			continue;
 		}
 
-		// Get the supported CAN networks
+		// Get the supported networks
 		auto supportedNetworks = newDevice.device->getSupportedRXNetworks();
 		supportedNetworks.erase(std::remove_if(supportedNetworks.begin(), supportedNetworks.end(), [](const icsneo::Network& net) -> bool {
-			return net.getType() != icsneo::Network::Type::CAN;// Only want CAN networks
+			return net.getType() != icsneo::Network::Type::CAN && net.getType() != icsneo::Network::Type::Ethernet;
 		}), supportedNetworks.end());
 		if(supportedNetworks.empty()) {
 			if(firstTimeFailedToOpen) {
-				LOGF(LOG_INFO, "%s has no supported CAN networks\n", newDevice.device->describe().c_str());
+				LOGF(LOG_INFO, "%s has no supported networks\n", newDevice.device->describe().c_str());
 				failedToOpen.push_back(serial);
 			}
 			continue;
 		}
 
-		// Create a network interface for each CAN network
+		// Create a network interface for each network
 		for(const auto& net : supportedNetworks) {
 			std::stringstream ss;
 			ss << sanitizeInterfaceName(icsneo::Network::GetNetIDString(net.getNetID())) << "_" << serial;
 			std::string interfaceName(ss.str());
 			if(firstTimeFailedToOpen)
 				LOGF(LOG_INFO, "Creating network interface %s\n", interfaceName.c_str());
-			newDevice.interfaces[net.getNetID()] = std::make_shared<NetworkInterface>(interfaceName);
+
+			newDevice.interfaces[net.getNetID()] = std::make_shared<NetworkInterface>(interfaceName, net.getType());
 			LOGF(LOG_INFO, "Created network interface %s\n", interfaceName.c_str());
 		}
 		bool failedToCreateNetworkInterfaces = false;
@@ -267,27 +652,35 @@ void searchForDevices() {
 			}
 			continue;
 		}
+		if (driverMinor > 0) {
+			for(const auto& net : supportedNetworks) {
+				if (net.getType() != icsneo::Network::Type::CAN)
+					continue;
+				newDevice.interfaces[net.getNetID()]->reportBaudrates(
+					newDevice.device->settings->getBaudrateFor(net.getNetID()),
+					newDevice.device->settings->getFDBaudrateFor(net.getNetID())
+				);
+			}
+		}
 
 		// Create rx listener
-		newDevice.device->addMessageCallback(icsneo::CANMessageCallback([serial](std::shared_ptr<icsneo::Message> message) {
+		for(auto&& interface : newDevice.interfaces) {
-			if(message->transmitted)
+			newDevice.device->addMessageCallback(std::make_shared<icsneo::MessageCallback>([interface = interface.second](std::shared_ptr<icsneo::Message> message) {
-				return;
+				const auto frame = std::static_pointer_cast<icsneo::Frame>(message);
-			auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
+				const auto messageType = frame->network.getType();
-			const OpenDevice* openDevice = nullptr;
+				if(frame->type != icsneo::Message::Type::Frame) {
-			for(const auto& dev : openDevices) {
+					LOG(LOG_ERR, "Dropping message: received invalid message type, expected RawMessage\n");
-				if(dev.device->getSerial() == serial) {
+					return;
-					openDevice = &dev;
-					break;
 				}
-			}
+				if(messageType == icsneo::Network::Type::CAN) {
-			if(!openDevice) {
+					interface->addReceivedMessageToQueue<neomessage_can_t>(frame);
-				LOG(LOG_ERR, "Dropping message, no open device\n");
+				} else if(messageType == icsneo::Network::Type::Ethernet) {
-				return;
+					interface->addReceivedMessageToQueue<neomessage_eth_t>(frame);
-			}
+				} else {
-
+					LOG(LOG_ERR, "Dropping message, only CAN and Ethernet are currently supported\n");
-			// todo might throw
+				}
-			openDevice->interfaces.at(canMessage->network.getNetID())->addReceivedMessageToQueue(canMessage);
+			}, std::make_shared<icsneo::MessageFilter>(interface.first)));
-		}));
+		}
 
 		LOGF(LOG_INFO, "%s connected\n", newDevice.device->describe().c_str());
 		failedToOpen.erase(std::remove_if(failedToOpen.begin(), failedToOpen.end(), [&serial](const std::string& s) -> bool {
@@ -338,18 +731,16 @@ void searchForDevices() {
 void deviceSearchThread() {
 	while(!stopRunning) {
 		searchForDevices();
-		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+		if(scanIntervalMs == 0) {
+			break;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(scanIntervalMs));
 	}
 }
 
 int main(int argc, char** argv) {
-	if(argc > 2) {
+	for(int i = 1; i != argc; i++) {
-		usage(argv[0]);
+		const std::string arg = argv[i];
-		return EX_USAGE;
-	}
-
-	if(argc == 2) {
-		const std::string arg = argv[1];
 		if(arg == "-d" || arg == "--daemon") {
 			runningAsDaemon = true;
 		} else if(arg == "-h" || arg == "--help" || arg == "-?" || arg == "--usage") {
@@ -361,6 +752,26 @@ int main(int argc, char** argv) {
 			for(auto& dev : icsneo::GetSupportedDevices())
 				std::cout << '\t' << dev << std::endl;
 			return EXIT_SUCCESS;
+		} else if(arg == "--filter" && i + 1 <= argc) {
+			serialFilter = argv[++i];
+			transform(serialFilter.begin(), serialFilter.end(), serialFilter.begin(), ::toupper);
+		} else if(arg == "--scan-interval-ms" && i + 1 <= argc) {
+			try {
+				scanIntervalMs = std::stoi(argv[++i]);
+			} catch (const std::invalid_argument& e) {
+				std::cerr << "Invalid input for scan-interval-ms\n";
+				return EX_USAGE;
+			} catch (const std::out_of_range& e) {
+				std::cerr << "Out of range input for scan-interval-ms\n";
+				return EX_USAGE;
+			}
+
+			if(scanIntervalMs < 0) {
+				std::cerr << "Invalid input for scan-interval-ms\n";
+				return EX_USAGE;
+			}
+		} else if(arg == "--fifo-path" && i + 1 <= argc) {
+			fifoPath = argv[++i];
 		} else {
 			usage(argv[0]);
 			return EX_USAGE;
@@ -404,7 +815,7 @@ int main(int argc, char** argv) {
 		return EXIT_FAILURE;
 	}
 	std::cout << "Driver v" << driverMajor << '.' << driverMinor << '.' << driverPatch << "\n\n";
-	if(driverMajor > 2) {
+	if(driverMajor > 3) {
 		LOG(LOG_ERR, "This version of the usermode daemon is too old to work with this driver\nPlease ensure that both the usermode daemon and kernel driver are up to date\n");
 		return EXIT_FAILURE;
 	}
@@ -443,6 +854,16 @@ int main(int argc, char** argv) {
 		LOG(LOG_INFO, "Waiting for connections...\n");
 	}
 
+	std::unique_ptr<RPC> rpc;
+	if(!fifoPath.empty()) {
+		try {
+			rpc = std::make_unique<RPC>();
+		} catch (const std::exception& e) {
+			LOGF(LOG_ERR, "Failed to set up RPC: %s\n", e.what());
+			return EXIT_FAILURE;
+		}
+	}
+
 	std::thread searchThread(deviceSearchThread);
 
 	while(!stopRunning) {
@@ -464,7 +885,7 @@ int main(int argc, char** argv) {
 			// Call read() to find out which box they're in and how many
 			struct intrepid_pending_tx_info info;
 			ssize_t r = read(driver, &info, sizeof(info));
-			if (r == -1) {
+			if(r == -1) {
 				LOGF(LOG_ERR, "Error waiting for tx messages: %s\n", strerror(errno));
 				stopRunning = true;
 				break;
@@ -472,31 +893,76 @@ int main(int argc, char** argv) {
 				LOGF(LOG_ERR, "Unexpected number of bytes read, expected %d got %d\n", (int)sizeof(info), (int)r);
 				stopRunning = true;
 				break;
+			} else if (info.tx_box_index < 0) {
+				// Baudrate changed in kernel
+				int dev_idx = -(info.tx_box_index + 1);
+				LOGF(LOG_INFO, "Baudrate change, device %d, baudrate %d fd_baudrate %ld\n",
+					dev_idx, info.count, info.bytes);
+				/* fd baudrate is zero if fd mode is disabled in kernel
+				 * set fd baudrate equal to baudrate */
+				if (info.bytes == 0) {
+					info.bytes = info.count;
+				}
+				for(auto& dev : openDevices) {
+					for(auto& netifPair : dev.interfaces) {
+						auto netid = netifPair.first;
+						if(netifPair.second->getKernelHandle() != dev_idx)
+							continue;
+						if (! dev.device->settings->setBaudrateFor(netid, info.count) ) {
+							LOGF(LOG_ERR, "Unable to set baudrate for device %s\n",
+								netifPair.second->getName().c_str());
+						} else if (! dev.device->settings->setFDBaudrateFor(netid, info.bytes)) {
+							LOGF(LOG_ERR, "Unable to set fd baudrate for device %s\n",
+								netifPair.second->getName().c_str());
+						} else if (! dev.device->settings->apply()) {
+							LOGF(LOG_ERR, "Unable to apply settings for device %s\n",
+								netifPair.second->getName().c_str());
+						}
+					}
+				}
 			} else {
 				// Send!
 				uint8_t* currentPosition = GET_TX_BOX(info.tx_box_index);
 				while(info.count--) {
-					neomessage_t* msg = reinterpret_cast<neomessage_t*>(currentPosition);
+					neomessage_frame_t* msg = reinterpret_cast<neomessage_frame_t*>(currentPosition);
-					currentPosition += sizeof(neomessage_t);
+					currentPosition += sizeof(neomessage_frame_t);
 					msg->data = currentPosition;
 					currentPosition += msg->length;
-					bool sent = false;
+
-					for(auto& dev : openDevices) {
+					if(msg->type != neonettype_t(icsneo::Network::Type::CAN) && msg->type != neonettype_t(icsneo::Network::Type::Ethernet)) {
-						for(auto& netifPair : dev.interfaces) {
+						LOG(LOG_ERR, "Message dropped, kernel sent a non-CAN/Ethernet message\n");
-							if(netifPair.second->getKernelHandle() != msg->netid)
+						continue;
-								continue;
-							msg->netid = static_cast<uint16_t>(netifPair.first);
-							auto tx = icsneo::CreateMessageFromNeoMessage(msg);
-							if(!dev.device->transmit(tx))
-								break;
-							sent = true;
-							break;
-						}
-						if(sent)
-							break;
 					}
-					if(!sent)
+
+					const auto transmit = [&] {
+						std::lock_guard<std::mutex> lg(openDevicesMutex);
+						for(auto it = openDevices.begin(); it != openDevices.end(); ++it) {
+							auto& dev = *it;
+							for(auto& netifPair : dev.interfaces) {
+								if(netifPair.second->getKernelHandle() != msg->netid)
+									continue;
+								if(!dev.device->isOpen() || !dev.device->isOnline() || dev.device->isDisconnected()) {
+									LOGF(LOG_ERR, "Message dropped, %s is not open and online\n", dev.device->getSerial().c_str());
+									openDevices.erase(it);
+									return;
+								}
+								msg->netid = static_cast<uint16_t>(netifPair.first);
+								auto txMsg = icsneo::CreateMessageFromNeoMessage(reinterpret_cast<neomessage_t*>(msg));
+								auto tx = std::dynamic_pointer_cast<icsneo::Frame>(txMsg);
+								if(!tx) {
+									LOG(LOG_ERR, "Message dropped, invalid transmit message\n");
+										return;
+									}
+								if(!dev.device->transmit(tx)) {
+									LOGF(LOG_ERR, "Message dropped, unable to transmit: %s\n", icsneo::GetLastError().describe().c_str());
+									return;
+								}
+								return;
+							}
+						}
 						LOG(LOG_ERR, "Message dropped, could not find the device the kernel referenced\n");
+					};
+					transmit();
 				}
 			}
 		}