Add device sharing support

platform/windows/pcap.cpp

@@ -166,8 +166,8 @@ void PCAP::Find(std::vector<FoundDevice>& found) {
 				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));
+				foundDevice.makeDriver = [](const device_eventhandler_t& reportFn, neodevice_t& forDevice) {
+					return std::unique_ptr<Driver>(new PCAP(reportFn, forDevice));
 				};
 
 				found.push_back(foundDevice);
@@ -184,7 +184,7 @@ bool PCAP::IsHandleValid(neodevice_handle_t handle) {
 	return (netifIndex < knownInterfaces.size());
 }
 
-PCAP::PCAP(const device_eventhandler_t& err, neodevice_t& forDevice) : Driver(err), device(forDevice), pcap(PCAPDLL::getInstance()), ethPacketizer(err) {
+PCAP::PCAP(const device_eventhandler_t& err, neodevice_t& forDevice) : Driver(err, forDevice), pcap(PCAPDLL::getInstance()), ethPacketizer(err) {
 	if(IsHandleValid(device.handle)) {
 		iface = knownInterfaces[(device.handle >> 24) & 0xFF];
 		iface.fp = nullptr; // We're going to open our own connection to the interface. This should already be nullptr but just in case.

platform/windows/sharedmemory.cpp

@@ -0,0 +1,47 @@
+#include "icsneo/api/event.h"
+#include "icsneo/platform/windows/sharedmemory.h"
+
+using namespace icsneo;
+
+SharedMemory::~SharedMemory() {
+	close();
+}
+
+bool SharedMemory::open(const std::string& name, uint32_t size, bool create) {
+	HANDLE shm;
+	if(create)
+		shm = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, name.c_str());
+	else
+		shm = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, name.c_str());
+
+	if(shm == NULL) {
+		report(APIEvent::Type::SharedMemoryFailedToOpen, APIEvent::Severity::Error);
+		return false;
+	}
+	mHandle.emplace(shm);
+	const auto dataStart = MapViewOfFile(shm, FILE_MAP_ALL_ACCESS, 0, 0, size);
+	if(dataStart == NULL) {
+		report(APIEvent::Type::SharedMemoryMappingError, APIEvent::Severity::Error);
+		close();
+		return false;
+	}
+	mData.emplace(std::make_pair((uint8_t*)dataStart, size));
+	mCreated.emplace(create);
+	return true;
+}
+
+bool SharedMemory::close() {
+	bool failed = false; // TODO: need to close properly
+	if(failed) {
+		report(APIEvent::Type::SharedMemoryFailedToClose, APIEvent::Severity::Error);
+	}
+	return !failed;
+}
+
+uint8_t* SharedMemory::data() {
+	if(!mData) {
+		report(APIEvent::Type::SharedMemoryDataIsNull, APIEvent::Severity::Error);
+		return nullptr;
+	}
+	return mData->first;
+}

platform/windows/sharedsemaphore.cpp

@@ -0,0 +1,65 @@
+#include "icsneo/platform/windows/sharedsemaphore.h"
+
+using namespace icsneo;
+
+SharedSemaphore::~SharedSemaphore() {
+	close();
+}
+
+bool SharedSemaphore::open(const std::string& name, bool create, unsigned initialCount) {
+	HANDLE sem;
+	if(create)
+		sem = CreateSemaphore(NULL, initialCount, LONG_MAX, name.c_str());
+	else
+		sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, name.c_str());
+
+	if(sem == NULL) {
+		report(APIEvent::Type::SharedSemaphoreFailedToOpen, APIEvent::Severity::Error);
+		return false;
+	}
+	semaphore.emplace(sem);
+	created.emplace(create);
+	return true;
+}
+
+bool SharedSemaphore::close() {
+	if(!semaphore)
+		return false;
+
+	closing = true;
+
+	post(); // wake any waiting
+
+	if(CloseHandle(*semaphore) == 0) {
+		report(APIEvent::Type::SharedSemaphoreFailedToClose, APIEvent::Severity::Error);
+		return false;
+	}
+	semaphore.reset();
+	return true;
+}
+
+bool SharedSemaphore::wait(const std::chrono::milliseconds& timeout) {
+	if(!semaphore) {
+		report(APIEvent::Type::SharedSemaphoreNotOpenForWait, APIEvent::Severity::Error);
+		return false;
+	}
+	if(WaitForSingleObject(*semaphore, static_cast<DWORD>(timeout.count())) != 0) {
+		report(APIEvent::Type::SharedSemaphoreFailedToWait, APIEvent::Severity::Error);
+		return false;
+	}
+	if(closing)
+		return false; // we were woken by close()
+	return true;
+}
+
+bool SharedSemaphore::post() {
+	if(!semaphore) {
+		report(APIEvent::Type::SharedSemaphoreNotOpenForPost, APIEvent::Severity::Error);
+		return false;
+	}
+	if(ReleaseSemaphore(*semaphore, 1, NULL) == 0) {
+		report(APIEvent::Type::SharedSemaphoreFailedToPost, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
+}

platform/windows/vcp.cpp

@@ -192,7 +192,7 @@ void VCP::Find(std::vector<FoundDevice>& found, std::vector<std::wstring> driver
 	}
 }
 
-VCP::VCP(const device_eventhandler_t& err, neodevice_t& forDevice) : Driver(err), device(forDevice) {
+VCP::VCP(const device_eventhandler_t& err, neodevice_t& forDevice) : Driver(err, forDevice) {
 	detail = std::make_shared<Detail>();
 }