fix: setTimeout does not work on Windows

As the pthread_cancel function is not available on Windows, change the definition of setTimeout method - from now on when you want to use it, you should pass the timeout, the data that you want to be passed to the function that will be executed in case the timeout passes and the function itself.
The setTimeout method automatically allocates memory for the objects, so they will still live even when the function from which you call the setTimeout finishes its execution.
It is not a good idea to capture variables (with lambda functions) when we'll use them in a separate thread. As we do not await the execution of the thread, the captured variables may be cleared (method from which we've called setTimeout finished its execution). More information is available here http://bannalia.blogspot.com/2016/07/passing-capturing-c-lambda-functions-as.html
NOTE: Changes are not handled for macOS.
NOTE: Allocated memory should be cleaned in clearTimeout as well.

Author: rosen-vladimirov

IOSDeviceLib/SocketHelper.cpp

@@ -7,40 +7,93 @@
 #include "PlistCpp/Plist.hpp"
 #include "PlistCpp/PlistDate.hpp"
 
+struct TimeoutData {
+	int timeout;
+	void * data;
+	void(*operation)(void *);
+};
+
+#ifdef WIN32
+DWORD WINAPI TimeoutThreadExecutor(LPVOID lpParam) {
+	TimeoutData* threadData = (TimeoutData*)lpParam;
+	std::this_thread::sleep_for(std::chrono::milliseconds(threadData->timeout * 1000));
+	threadData->operation(threadData->data);
+	free(threadData);
+	return 0;
+}
+
+HANDLE setTimeout(int timeout, void * data, void(*operation)(void*))
+{
+	struct TimeoutData* currentTimeoutDataPtr = reinterpret_cast<TimeoutData*>(malloc(sizeof(struct TimeoutData)));
+	currentTimeoutDataPtr->timeout = timeout;
+	currentTimeoutDataPtr->data = data;
+	currentTimeoutDataPtr->operation = operation;
+
+	auto threadId = CreateThread(
+		NULL,                   // default security attributes
+		0,                      // use default stack size
+		TimeoutThreadExecutor,       // thread function name
+		currentTimeoutDataPtr,                   // argument to thread function
+		0,                      // use default creation flags
+		nullptr);
+
+	return threadId;
+}
+#else
 std::thread::native_handle_type setTimeout(std::function<void()> operation, int timeout) {
 	std::thread thread = std::thread([=]() {
 		std::this_thread::sleep_for(std::chrono::milliseconds(timeout * 1000));
 		operation();
 	});
-	
+
 	std::thread::native_handle_type native = thread.native_handle();
 	thread.detach();
-	
+
 	return native;
 }
 
-void clearTimeout(std::thread::native_handle_type nativeHandle) {
+#endif
+
+void clearTimeout(void* nativeHandle) {
+	// TODO: clean the malloced data
+
 	if (nativeHandle) {
+#ifdef WIN32
+		int terminateThreadResult = TerminateThread(nativeHandle, 9);
+		// https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-terminatethread#return-value
+		if (terminateThreadResult == 0)
+		{
+			DWORD errorCode = GetLastError();
+		}
+#else
 	   pthread_cancel(nativeHandle);
+#endif
 	}
 }
-	
+
+void CleanConnectionResources(void * data)
+{
+	// TODO: Remove the connection from the dictionary of available connections for current device.
+	// TODO: Use mutex for invalidating the connection, someone might use it.
+	ServiceConnRef conn = reinterpret_cast<ServiceConnRef>(data);
+	AMDServiceConnectionInvalidate(conn);
+}
+
 std::mutex receive_con_message_mutex;
 std::map<std::string, boost::any> receive_con_message(ServiceConnRef con, std::string device_identifier, std::string method_id, int timeout)
 {
 	receive_con_message_mutex.lock();
 
-	std::thread::native_handle_type nativeHandle;
-	
+	std::thread::native_handle_type nativeHandle = nullptr;
+
 	if (timeout > 0) {
-		nativeHandle = setTimeout([=]() {
-			AMDServiceConnectionInvalidate(con);
-		}, timeout);
+		nativeHandle = setTimeout(timeout, con, CleanConnectionResources);
 	}
-	
+
 	std::map<std::string, boost::any> dict;
 	char *buffer = new char[4];
 	int bytes_read = AMDServiceConnectionReceive(con, buffer, 4);
+	// TODO: clearTimeout in case connection is alive, but there's nothing to read, i.e. we have 0 bytes for reading.
 	if (bytes_read > 0)
 	{
 		unsigned long res = ntohl(*((unsigned long*)buffer));
@@ -50,7 +103,10 @@ std::map<std::string, boost::any> receive_con_message(ServiceConnRef con, std::s
 		if (bytes_read > 0)
 		{
 			Plist::readPlist(buffer, res, dict);
-			clearTimeout(nativeHandle);
+			if (nativeHandle)
+			{
+				clearTimeout(nativeHandle);
+			}
 		}
 	}