Drivers: Decouple from devices

This allows us to better implement alternative drivers for devices, such as for device sharing servers or talking to CoreMini processors within the same device.
2026-08-05 01:18:36 +02:00 · 2022-03-27 14:30:31 -04:00
parent 0ff12300f3
commit 781fc2c034
66 changed files with 780 additions and 1566 deletions
@@ -4,8 +4,9 @@
 #include "icsneo/platform/windows/pcap.h"
 #include "icsneo/communication/network.h"
 #include "icsneo/communication/communication.h"
-#include "icsneo/communication/packetizer.h"
 #include "icsneo/communication/ethernetpacketizer.h"
+#include "icsneo/communication/packetizer.h"
+#include "icsneo/communication/decoder.h"
 #include <pcap.h>
 #include <iphlpapi.h>
 #pragma comment(lib, "IPHLPAPI.lib")
@@ -17,17 +18,14 @@
 using namespace icsneo;

 static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-static const uint8_t BROADCAST_MAC[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-static const uint8_t ICS_UNSET_MAC[6] = { 0x00, 0xFC, 0x70, 0xFF, 0xFF, 0xFF };

 std::vector<PCAP::NetworkInterface> PCAP::knownInterfaces;

-std::vector<PCAP::PCAPFoundDevice> PCAP::FindAll() {
-	std::vector<PCAPFoundDevice> foundDevices;
+void PCAP::Find(std::vector<FoundDevice>& found) {
 	const PCAPDLL& pcap = PCAPDLL::getInstance();
 	if(!pcap.ok()) {
 		EventManager::GetInstance().add(APIEvent::Type::PCAPCouldNotStart, APIEvent::Severity::Error);
-		return std::vector<PCAPFoundDevice>();
+		return;
 	}

 	// First we ask WinPCAP to give us all of the devices
@@ -45,7 +43,7 @@ std::vector<PCAP::PCAPFoundDevice> PCAP::FindAll() {

 	if(!success) {
 		EventManager::GetInstance().add(APIEvent::Type::PCAPCouldNotFindDevices, APIEvent::Severity::Error);
-		return std::vector<PCAPFoundDevice>();
+		return;
 	}

 	std::vector<NetworkInterface> interfaces;
@@ -62,13 +60,13 @@ std::vector<PCAP::PCAPFoundDevice> PCAP::FindAll() {
 	ULONG size = 0;
 	if(GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, nullptr, nullptr, &size) != ERROR_BUFFER_OVERFLOW) {
 		EventManager::GetInstance().add(APIEvent::Type::PCAPCouldNotFindDevices, APIEvent::Severity::Error);
-		return std::vector<PCAPFoundDevice>();
+		return;
 	}
 	std::vector<uint8_t> adapterAddressBuffer;
 	adapterAddressBuffer.resize(size);
 	if(GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, nullptr, (IP_ADAPTER_ADDRESSES*)adapterAddressBuffer.data(), &size) != ERROR_SUCCESS) {
 		EventManager::GetInstance().add(APIEvent::Type::PCAPCouldNotFindDevices, APIEvent::Severity::Error);
-		return std::vector<PCAPFoundDevice>();
+		return;
 	}
 	
 	// aa->AdapterName constains a unique name of the interface like "{3B1D2791-435A-456F-8A7B-9CB0EEE5DAB3}"
@@ -137,46 +135,48 @@ std::vector<PCAP::PCAPFoundDevice> PCAP::FindAll() {
 			if(res == 0)
 				continue; // Keep waiting for that packet
 			
-			EthernetPacketizer::EthernetPacket packet(data, header->caplen);
-			// Is this an ICS response packet (0xCAB2) from an ICS MAC, either to broadcast or directly to us?
-			if(packet.etherType == 0xCAB2 && packet.srcMAC[0] == 0x00 && packet.srcMAC[1] == 0xFC && packet.srcMAC[2] == 0x70 && (
-				memcmp(packet.destMAC, iface.macAddress, sizeof(packet.destMAC)) == 0 ||
-				memcmp(packet.destMAC, BROADCAST_MAC, sizeof(packet.destMAC)) == 0
-			)) {
-				/* We have received a packet from a device. We don't know if this is the device we're
-				 * looking for, we don't know if it's actually a response to our RequestSerialNumber
-				 * or not, we just know we got something.
-				 *
-				 * Unlike most transport layers, we can't get the serial number here as we actually
-				 * need to parse this message that has been returned. Some devices parse messages
-				 * differently, so we need to use their communication layer. We could technically
-				 * create a communication layer to parse the packet we have in `payload` here, but
-				 * we'd need to be given a packetizer and decoder for the device. I'm intentionally
-				 * avoiding passing that information down here for code quality's sake. Instead, pass
-				 * the packet we received back up so the device can handle it.
-				 */
-				neodevice_handle_t handle = (neodevice_handle_t)((i << 24) | (packet.srcMAC[3] << 16) | (packet.srcMAC[4] << 8) | (packet.srcMAC[5]));
-				PCAPFoundDevice* alreadyExists = nullptr;
-				for(auto& dev : foundDevices)
-					if(dev.device.handle == handle)
-						alreadyExists = &dev;
+			EthernetPacketizer ethPacketizer([](APIEvent::Type, APIEvent::Severity) {});
+			memcpy(ethPacketizer.hostMAC, iface.macAddress, sizeof(ethPacketizer.hostMAC));
+			ethPacketizer.allowInPacketsFromAnyMAC = true;
+			if(!ethPacketizer.inputUp({ data, data + header->caplen }))
+				continue; // This packet is not for us

-				if(alreadyExists == nullptr) {
-					PCAPFoundDevice foundDevice;
-					foundDevice.device.handle = handle;
-					foundDevice.discoveryPackets.push_back(std::move(packet.payload));
-					foundDevices.push_back(foundDevice);
-				} else {
-					alreadyExists->discoveryPackets.push_back(std::move(packet.payload));
-				}
+			Packetizer packetizer([](APIEvent::Type, APIEvent::Severity) {});
+			if(!packetizer.input(ethPacketizer.outputUp()))
+				continue; // This packet was not well formed
+
+			EthernetPacketizer::EthernetPacket decoded(data, header->caplen);
+			for(const auto& packet : packetizer.output()) {
+				Decoder decoder([](APIEvent::Type, APIEvent::Severity) {});
+				std::shared_ptr<Message> message;
+				if(!decoder.decode(message, packet))
+					continue;
+
+				const neodevice_handle_t handle = (neodevice_handle_t)((i << 24) | (decoded.srcMAC[3] << 16) | (decoded.srcMAC[4] << 8) | (decoded.srcMAC[5]));
+				if(std::any_of(found.begin(), found.end(), [&handle](const auto& found) { return handle == found.handle; }))
+					continue; // We already have this device on this interface
+
+				const auto serial = std::dynamic_pointer_cast<SerialNumberMessage>(message);
+				if(!serial || serial->deviceSerial.size() != 6)
+					continue;
+
+				FoundDevice foundDevice;
+				foundDevice.handle = handle;
+				foundDevice.productId = decoded.srcMAC[2];
+				memcpy(foundDevice.serial, serial->deviceSerial.c_str(), sizeof(foundDevice.serial) - 1);
+				foundDevice.serial[sizeof(foundDevice.serial) - 1] = '\0';
+
+				foundDevice.makeDriver = [](const device_eventhandler_t& reportFn, neodevice_t& device) {
+					return std::unique_ptr<Driver>(new PCAP(reportFn, device));
+				};
+
+				found.push_back(foundDevice);
 			}
 		}

 		pcap.close(iface.fp);
 		iface.fp = nullptr;
 	}
-
-	return foundDevices;
 }

 bool PCAP::IsHandleValid(neodevice_handle_t handle) {
@@ -1,6 +1,7 @@
 #include "icsneo/platform/windows/ftdi.h"
 #include "icsneo/platform/ftdi.h"
 #include "icsneo/platform/registry.h"
+#include "icsneo/device/founddevice.h"
 #include <windows.h>
 #include <iostream>
 #include <iomanip>
@@ -19,8 +20,7 @@ static const std::wstring ALL_ENUM_REG_KEY = L"SYSTEM\\CurrentControlSet\\Enum\\
 static constexpr unsigned int RETRY_TIMES = 5;
 static constexpr unsigned int RETRY_DELAY = 50;

-struct VCP::Detail
-{
+struct VCP::Detail {
 	Detail() {
 		overlappedRead.hEvent = INVALID_HANDLE_VALUE;
 		overlappedWrite.hEvent = INVALID_HANDLE_VALUE;
@@ -32,21 +32,22 @@ struct VCP::Detail
 	OVERLAPPED overlappedWait = {};
 };

-std::vector<neodevice_t> VCP::FindByProduct(int product, std::vector<std::wstring> driverNames) {
-	std::vector<neodevice_t> found;
-
+void VCP::Find(std::vector<FoundDevice>& found, std::vector<std::wstring> driverNames) {
 	for(auto& driverName : driverNames) {
 		std::wstringstream regss;
 		regss << DRIVER_SERVICES_REG_KEY << driverName << L"\\Enum\\";
 		std::wstring driverEnumRegKey = regss.str();

 		uint32_t deviceCount = 0;
-		if(!Registry::Get(driverEnumRegKey, L"Count", deviceCount)) {
-			return found;
-		}
+		if(!Registry::Get(driverEnumRegKey, L"Count", deviceCount))
+			continue;

 		for(uint32_t i = 0; i < deviceCount; i++) {
-			neodevice_t device = {};
+			FoundDevice device;
+
+			device.makeDriver = [](const device_eventhandler_t& reportFn, neodevice_t& device) {
+				return std::unique_ptr<Driver>(new VCP(reportFn, device));
+			};

 			// First we want to look at what devices FTDI is enumerating (inside driverEnumRegKey)
 			// The entry for a ValueCAN 3 with SN 138635 looks like "FTDIBUS\VID_093C+PID_0601+138635A\0000"
@@ -64,11 +65,10 @@ std::vector<neodevice_t> VCP::FindByProduct(int product, std::vector<std::wstrin
 			if(entry.find(vss.str()) == std::wstring::npos)
 				continue;

-			std::wstringstream pss;
-			pss << "PID_" << std::setfill(L'0') << std::setw(4) << std::uppercase << std::hex << product;
-			auto pidpos = entry.find(pss.str());
+			auto pidpos = entry.find(L"PID_");
 			if(pidpos == std::wstring::npos)
 				continue;
+			// We will later use this and startchar to parse the PID

 			// Okay, this is a device we want
 			// Get the serial number
@@ -90,13 +90,18 @@ std::vector<neodevice_t> VCP::FindByProduct(int product, std::vector<std::wstrin
 			else
 				oss << sn;

+			device.productId = uint16_t(std::wcstol(entry.c_str() + pidpos + 4, nullptr, 16));
+			if(!device.productId)
+				continue;
+
 			std::string serial = converter.to_bytes(oss.str());
 			// The serial number should not have a path slash in it. If it does, that means we don't have the real serial.
 			if(serial.find_first_of('\\') != std::string::npos) {
 				// The serial number was not in the first serenum key where we expected it.
 				// We can try to match the ContainerID with the one in ALL_ENUM\USB and get a serial that way
 				std::wstringstream uess;
-				uess << ALL_ENUM_REG_KEY << L"\\USB\\" << vss.str() << L'&' << pss.str() << L'\\';
+				uess << ALL_ENUM_REG_KEY << L"\\USB\\" << vss.str() << L"&PID_" << std::setfill(L'0') << std::setw(4)
+					<< std::uppercase << std::hex << device.productId << L'\\';
 				std::wstringstream ciss;
 				ciss << ALL_ENUM_REG_KEY << entry;
 				std::wstring containerIDFromEntry, containerIDFromEnum;
@@ -166,7 +171,7 @@ std::vector<neodevice_t> VCP::FindByProduct(int product, std::vector<std::wstrin
 			}

 			bool alreadyFound = false;
-			neodevice_t* shouldReplace = nullptr;
+			FoundDevice* shouldReplace = nullptr;
 			for(auto& foundDev : found) {
 				if((foundDev.handle == device.handle || foundDev.handle == 0 || device.handle == 0) && serial == foundDev.serial) {
 					alreadyFound = true;
@@ -182,8 +187,6 @@ std::vector<neodevice_t> VCP::FindByProduct(int product, std::vector<std::wstrin
 				*shouldReplace = device;
 		}
 	}
-
-	return found;
 }

 VCP::VCP(const device_eventhandler_t& err, neodevice_t& forDevice) : Driver(err), device(forDevice) {