react-native-tcp-windows 0.2.0 → 0.2.2

package/windows/ReactNativeTcpWindows/TcpSocket.cpp

@@ -1,565 +1,565 @@
-#include "pch.h"
-#include "TcpSocket.h"
-#include <sstream>
-
-bool TcpSocket::s_wsaInitialized = false;
-int TcpSocket::s_wsaRefCount = 0;
-std::mutex TcpSocket::s_wsaMutex;
-
-TcpSocket::TcpSocket(const std::string &address, int port, ConnectionType type)
-    : m_address(address), m_port(port), m_type(type), m_socket(INVALID_SOCKET), m_serverSocket(INVALID_SOCKET), m_isRunning(false), m_isConnected(false), m_isServerRunning(false)
-{
-
-    std::lock_guard<std::mutex> lock(s_wsaMutex);
-    if (!s_wsaInitialized)
-    {
-        WSADATA wsaData;
-        if (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0)
-        {
-            s_wsaInitialized = true;
-        }
-    }
-    s_wsaRefCount++;
-}
-
-TcpSocket::~TcpSocket()
-{
-    close();
-
-    std::lock_guard<std::mutex> lock(s_wsaMutex);
-    s_wsaRefCount--;
-    if (s_wsaRefCount == 0 && s_wsaInitialized)
-    {
-        WSACleanup();
-        s_wsaInitialized = false;
-    }
-}
-
-bool TcpSocket::connect()
-{
-    if (m_type != ConnectionType::Client)
-    {
-        return false;
-    }
-
-    if (m_isConnected)
-    {
-        close();
-    }
-
-    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (m_socket == INVALID_SOCKET)
-    {
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Failed to create socket");
-        }
-        return false;
-    }
-
-    sockaddr_in serverAddr = {};
-    serverAddr.sin_family = AF_INET;
-    serverAddr.sin_port = htons(m_port);
-
-    if (inet_pton(AF_INET, m_address.c_str(), &serverAddr.sin_addr) <= 0)
-    {
-        closesocket(m_socket);
-        m_socket = INVALID_SOCKET;
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Invalid address format");
-        }
-        return false;
-    }
-
-    if (::connect(m_socket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
-    {
-        int error = WSAGetLastError();
-        closesocket(m_socket);
-        m_socket = INVALID_SOCKET;
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Connection failed. Error: " + std::to_string(error));
-        }
-        return false;
-    }
-
-    m_isConnected = true;
-    m_isRunning = true;
-    startReading();
-
-    if (m_connectionStatusCallback)
-    {
-        m_connectionStatusCallback(true, "Connected successfully");
-    }
-
-    return true;
-}
-
-bool TcpSocket::startServer()
-{
-    if (m_type != ConnectionType::Server)
-    {
-        return false;
-    }
-
-    if (m_isServerRunning)
-    {
-        close();
-    }
-
-    m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (m_serverSocket == INVALID_SOCKET)
-    {
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Failed to create server socket");
-        }
-        return false;
-    }
-
-    // Allow socket reuse
-    BOOL reuseAddr = TRUE;
-    setsockopt(m_serverSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&reuseAddr, sizeof(reuseAddr));
-
-    sockaddr_in serverAddr = {};
-    serverAddr.sin_family = AF_INET;
-    serverAddr.sin_port = htons(m_port);
-    serverAddr.sin_addr.s_addr = INADDR_ANY;
-
-    if (bind(m_serverSocket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
-    {
-        int error = WSAGetLastError();
-        closesocket(m_serverSocket);
-        m_serverSocket = INVALID_SOCKET;
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Bind failed. Error: " + std::to_string(error));
-        }
-        return false;
-    }
-
-    if (listen(m_serverSocket, SOMAXCONN) == SOCKET_ERROR)
-    {
-        int error = WSAGetLastError();
-        closesocket(m_serverSocket);
-        m_serverSocket = INVALID_SOCKET;
-        if (m_connectionStatusCallback)
-        {
-            m_connectionStatusCallback(false, "Listen failed. Error: " + std::to_string(error));
-        }
-        return false;
-    }
-
-    m_isServerRunning = true;
-    m_isRunning = true;
-
-    // Start accepting connections
-    m_acceptThread = std::thread(&TcpSocket::serverAcceptThread, this);
-
-    if (m_connectionStatusCallback)
-    {
-        m_connectionStatusCallback(true, "Server started on port " + std::to_string(m_port));
-    }
-
-    return true;
-}
-
-void TcpSocket::close()
-{
-    // STEP 1: Shutdown sockets FIRST to wake up any blocking operations
-    if (m_socket != INVALID_SOCKET) {
-        shutdown(m_socket, SD_BOTH);  // This wakes up recv() calls
-    }
-    
-    if (m_serverSocket != INVALID_SOCKET) {
-        shutdown(m_serverSocket, SD_BOTH);  // This wakes up accept() calls
-    }
-    
-    // Shutdown all client connections
-    {
-        std::lock_guard<std::mutex> lock(m_clientsMutex);
-        for (SOCKET clientSocket : m_clientSockets) {
-            if (clientSocket != INVALID_SOCKET) {
-                shutdown(clientSocket, SD_BOTH);
-            }
-        }
-    }
-    
-    // STEP 2: Now stopReading should complete quickly since sockets are shutdown
-    stopReading();
-
-    // STEP 3: Close the sockets
-    if (m_socket != INVALID_SOCKET)
-    {
-        closesocket(m_socket);
-        m_socket = INVALID_SOCKET;
-    }
-
-    if (m_serverSocket != INVALID_SOCKET)
-    {
-        closesocket(m_serverSocket);
-        m_serverSocket = INVALID_SOCKET;
-    }
-
-    // Close all client connections
-    {
-        std::lock_guard<std::mutex> lock(m_clientsMutex);
-        for (SOCKET clientSocket : m_clientSockets)
-        {
-            closesocket(clientSocket);
-        }
-        m_clientSockets.clear();
-    }
-
-    m_isConnected = false;
-    m_isServerRunning = false;
-}
-
-bool TcpSocket::write(const std::vector<uint8_t> &data)
-{
-    if (data.empty())
-    {
-        return false;
-    }
-
-    if (m_type == ConnectionType::Client && m_isConnected)
-    {
-        int result = send(m_socket, (char *)data.data(), static_cast<int>(data.size()), 0);
-        return result != SOCKET_ERROR;
-    }
-    else if (m_type == ConnectionType::Server && m_isServerRunning)
-    {
-        // Send to all connected clients
-        std::lock_guard<std::mutex> lock(m_clientsMutex);
-        bool success = true;
-        for (SOCKET clientSocket : m_clientSockets)
-        {
-            int result = send(clientSocket, (char *)data.data(), static_cast<int>(data.size()), 0);
-            if (result == SOCKET_ERROR)
-            {
-                success = false;
-            }
-        }
-        return success;
-    }
-
-    return false;
-}
-
-void TcpSocket::setDataReceivedCallback(DataReceivedCallback callback)
-{
-    m_dataCallback = std::move(callback);
-}
-
-void TcpSocket::setClientConnectedCallback(ClientConnectedCallback callback)
-{
-    m_clientConnectedCallback = std::move(callback);
-}
-
-void TcpSocket::setClientDisconnectedCallback(ClientDisconnectedCallback callback)
-{
-    m_clientDisconnectedCallback = std::move(callback);
-}
-
-void TcpSocket::setConnectionStatusCallback(ConnectionStatusCallback callback)
-{
-    m_connectionStatusCallback = std::move(callback);
-}
-
-void TcpSocket::startReading()
-{
-    if (m_type == ConnectionType::Client)
-    {
-        m_readThread = std::thread(&TcpSocket::clientReadThread, this);
-    }
-}
-
-// CHANGE 1: Update clientReadThread() - Add socket timeout
-void TcpSocket::clientReadThread()
-{
-    std::vector<uint8_t> buffer(1024);
-
-    // Set socket timeout to prevent infinite blocking
-    DWORD timeout = 1000; // 1 second
-    setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-
-    while (m_isRunning && m_isConnected)
-    {
-        int bytesReceived = recv(m_socket, (char *)buffer.data(), buffer.size(), 0);
-
-        if (bytesReceived > 0)
-        {
-            if (m_dataCallback)
-            {
-                OutputDebugStringA(("TCP Client received " + std::to_string(bytesReceived) + " bytes\n").c_str());
-                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
-            }
-        }
-        else if (bytesReceived == 0)
-        {
-            // Connection closed by peer
-            m_isConnected = false;
-            if (m_connectionStatusCallback)
-            {
-                m_connectionStatusCallback(false, "Connection closed by peer");
-            }
-            break;
-        }
-        else
-        {
-            // Error occurred
-            int error = WSAGetLastError();
-            if (error == WSAETIMEDOUT)
-            {
-                // Timeout - continue loop to check m_isRunning
-                continue;
-            }
-            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
-            {
-                // Connection closed/shutdown - exit gracefully
-                m_isConnected = false;
-                OutputDebugStringA("Connection closed during recv\n");
-                break;
-            }
-            else if (error != WSAEWOULDBLOCK)
-            {
-                m_isConnected = false;
-                if (m_connectionStatusCallback)
-                {
-                    m_connectionStatusCallback(false, "Receive error: " + std::to_string(error));
-                }
-                break;
-            }
-        }
-    }
-    OutputDebugStringA("Client read thread exiting\n");
-}
-
-// CHANGE 2: Update serverAcceptThread() - Add socket timeout
-void TcpSocket::serverAcceptThread()
-{
-    // Set socket timeout for accept() to prevent infinite blocking
-    DWORD timeout = 1000; // 1 second
-    setsockopt(m_serverSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-
-    while (m_isRunning && m_isServerRunning)
-    {
-        sockaddr_in clientAddr = {};
-        int clientAddrLen = sizeof(clientAddr);
-
-        SOCKET clientSocket = accept(m_serverSocket, (sockaddr *)&clientAddr, &clientAddrLen);
-
-        if (clientSocket != INVALID_SOCKET)
-        {
-            std::string clientAddress = getSocketAddress(clientSocket);
-
-            {
-                std::lock_guard<std::mutex> lock(m_clientsMutex);
-                m_clientSockets.push_back(clientSocket);
-                m_clientThreads.emplace_back(&TcpSocket::serverClientReadThread, this, clientSocket, clientAddress);
-            }
-
-            if (m_clientConnectedCallback)
-            {
-                m_clientConnectedCallback(clientAddress);
-            }
-
-            OutputDebugStringA(("Client connected from: " + clientAddress + "\n").c_str());
-        }
-        else if (m_isRunning && m_isServerRunning)
-        {
-            int error = WSAGetLastError();
-            if (error == WSAETIMEDOUT)
-            {
-                // Timeout - continue loop to check m_isRunning
-                continue;
-            }
-            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
-            {
-                // Server socket closed/shutdown - exit gracefully
-                OutputDebugStringA("Server socket closed during accept\n");
-                break;
-            }
-            else if (error != WSAEINTR)
-            {
-                OutputDebugStringA(("Accept error: " + std::to_string(error) + "\n").c_str());
-            }
-        }
-    }
-    OutputDebugStringA("Server accept thread exiting\n");
-}
-
-// CHANGE 3: Update serverClientReadThread() - Add socket timeout
-void TcpSocket::serverClientReadThread(SOCKET clientSocket, std::string clientAddress)
-{
-    std::vector<uint8_t> buffer(1024);
-
-    // Set socket timeout to prevent infinite blocking
-    DWORD timeout = 1000; // 1 second
-    setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-
-    while (m_isRunning && m_isServerRunning)
-    {
-        int bytesReceived = recv(clientSocket, (char *)buffer.data(), buffer.size(), 0);
-
-        if (bytesReceived > 0)
-        {
-            if (m_dataCallback)
-            {
-                OutputDebugStringA(("TCP Server received " + std::to_string(bytesReceived) + " bytes from " + clientAddress + "\n").c_str());
-                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
-            }
-        }
-        else if (bytesReceived == 0)
-        {
-            // Client disconnected
-            OutputDebugStringA(("Client disconnected normally: " + clientAddress + "\n").c_str());
-            break;
-        }
-        else
-        {
-            // Error occurred
-            int error = WSAGetLastError();
-            if (error == WSAETIMEDOUT)
-            {
-                // Timeout - continue loop to check m_isRunning
-                continue;
-            }
-            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
-            {
-                // Client connection closed/shutdown - exit gracefully
-                OutputDebugStringA(("Client connection closed during recv: " + clientAddress + "\n").c_str());
-                break;
-            }
-            else if (error != WSAEWOULDBLOCK)
-            {
-                OutputDebugStringA(("Client receive error: " + std::to_string(error) + " for " + clientAddress + "\n").c_str());
-                break;
-            }
-        }
-    }
-
-    // Remove client from list and close socket
-    {
-        std::lock_guard<std::mutex> lock(m_clientsMutex);
-        auto it = std::find(m_clientSockets.begin(), m_clientSockets.end(), clientSocket);
-        if (it != m_clientSockets.end())
-        {
-            m_clientSockets.erase(it);
-        }
-    }
-
-    closesocket(clientSocket);
-
-    if (m_clientDisconnectedCallback)
-    {
-        m_clientDisconnectedCallback(clientAddress);
-    }
-
-    OutputDebugStringA(("Client thread exiting: " + clientAddress + "\n").c_str());
-}
-
-// CHANGE 4: Simplify stopReading() - Remove async timeout logic (it's causing issues)
-void TcpSocket::stopReading()
-{
-    OutputDebugStringA("stopReading() called\n");
-
-    // 1. Set the stop flag
-    m_isRunning = false;
-    OutputDebugStringA("Set m_isRunning = false\n");
-
-    // 2. WAKE UP blocked threads by shutting down sockets
-    if (m_socket != INVALID_SOCKET)
-    {
-        OutputDebugStringA("Shutting down main socket...\n");
-        shutdown(m_socket, SD_BOTH);
-    }
-
-    if (m_serverSocket != INVALID_SOCKET)
-    {
-        OutputDebugStringA("Shutting down server socket...\n");
-        shutdown(m_serverSocket, SD_BOTH);
-    }
-
-    // Wake up client sockets
-    {
-        std::lock_guard<std::mutex> lock(m_clientsMutex);
-        OutputDebugStringA(("Shutting down " + std::to_string(m_clientSockets.size()) + " client sockets...\n").c_str());
-        for (SOCKET clientSocket : m_clientSockets)
-        {
-            shutdown(clientSocket, SD_BOTH);
-        }
-    }
-
-    // 3. Join threads with simple timeout
-    OutputDebugStringA("Joining read thread...\n");
-    if (m_readThread.joinable())
-    {
-        try
-        {
-            m_readThread.join();
-            OutputDebugStringA("Read thread joined successfully\n");
-        }
-        catch (...)
-        {
-            OutputDebugStringA("Read thread join failed - detaching\n");
-            m_readThread.detach();
-        }
-    }
-
-    OutputDebugStringA("Joining accept thread...\n");
-    if (m_acceptThread.joinable())
-    {
-        try
-        {
-            m_acceptThread.join();
-            OutputDebugStringA("Accept thread joined successfully\n");
-        }
-        catch (...)
-        {
-            OutputDebugStringA("Accept thread join failed - detaching\n");
-            m_acceptThread.detach();
-        }
-    }
-
-    // Join client threads
-    OutputDebugStringA(("Joining " + std::to_string(m_clientThreads.size()) + " client threads...\n").c_str());
-    for (size_t i = 0; i < m_clientThreads.size(); ++i)
-    {
-        auto &thread = m_clientThreads[i];
-        if (thread.joinable())
-        {
-            try
-            {
-                thread.join();
-                OutputDebugStringA(("Client thread " + std::to_string(i) + " joined successfully\n").c_str());
-            }
-            catch (...)
-            {
-                OutputDebugStringA(("Client thread " + std::to_string(i) + " join failed - detaching\n").c_str());
-                thread.detach();
-            }
-        }
-    }
-    m_clientThreads.clear();
-
-    OutputDebugStringA("stopReading() completed successfully\n");
-}
-
-std::string TcpSocket::getSocketAddress(SOCKET socket)
-{
-    sockaddr_in addr = {};
-    int addrLen = sizeof(addr);
-
-    if (getpeername(socket, (sockaddr *)&addr, &addrLen) == 0)
-    {
-        char ipStr[INET_ADDRSTRLEN];
-        if (inet_ntop(AF_INET, &addr.sin_addr, ipStr, INET_ADDRSTRLEN))
-        {
-            return std::string(ipStr) + ":" + std::to_string(ntohs(addr.sin_port));
-        }
-    }
-
-    return "unknown";
+#include "pch.h"
+#include "TcpSocket.h"
+#include <sstream>
+
+bool TcpSocket::s_wsaInitialized = false;
+int TcpSocket::s_wsaRefCount = 0;
+std::mutex TcpSocket::s_wsaMutex;
+
+TcpSocket::TcpSocket(const std::string &address, int port, ConnectionType type)
+    : m_address(address), m_port(port), m_type(type), m_socket(INVALID_SOCKET), m_serverSocket(INVALID_SOCKET), m_isRunning(false), m_isConnected(false), m_isServerRunning(false)
+{
+
+    std::lock_guard<std::mutex> lock(s_wsaMutex);
+    if (!s_wsaInitialized)
+    {
+        WSADATA wsaData;
+        if (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0)
+        {
+            s_wsaInitialized = true;
+        }
+    }
+    s_wsaRefCount++;
+}
+
+TcpSocket::~TcpSocket()
+{
+    close();
+
+    std::lock_guard<std::mutex> lock(s_wsaMutex);
+    s_wsaRefCount--;
+    if (s_wsaRefCount == 0 && s_wsaInitialized)
+    {
+        WSACleanup();
+        s_wsaInitialized = false;
+    }
+}
+
+bool TcpSocket::connect()
+{
+    if (m_type != ConnectionType::Client)
+    {
+        return false;
+    }
+
+    if (m_isConnected)
+    {
+        close();
+    }
+
+    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (m_socket == INVALID_SOCKET)
+    {
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Failed to create socket");
+        }
+        return false;
+    }
+
+    sockaddr_in serverAddr = {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(m_port);
+
+    if (inet_pton(AF_INET, m_address.c_str(), &serverAddr.sin_addr) <= 0)
+    {
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Invalid address format");
+        }
+        return false;
+    }
+
+    if (::connect(m_socket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Connection failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    m_isConnected = true;
+    m_isRunning = true;
+    startReading();
+
+    if (m_connectionStatusCallback)
+    {
+        m_connectionStatusCallback(true, "Connected successfully");
+    }
+
+    return true;
+}
+
+bool TcpSocket::startServer()
+{
+    if (m_type != ConnectionType::Server)
+    {
+        return false;
+    }
+
+    if (m_isServerRunning)
+    {
+        close();
+    }
+
+    m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (m_serverSocket == INVALID_SOCKET)
+    {
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Failed to create server socket");
+        }
+        return false;
+    }
+
+    // Allow socket reuse
+    BOOL reuseAddr = TRUE;
+    setsockopt(m_serverSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&reuseAddr, sizeof(reuseAddr));
+
+    sockaddr_in serverAddr = {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(m_port);
+    serverAddr.sin_addr.s_addr = INADDR_ANY;
+
+    if (bind(m_serverSocket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Bind failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    if (listen(m_serverSocket, SOMAXCONN) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Listen failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    m_isServerRunning = true;
+    m_isRunning = true;
+
+    // Start accepting connections
+    m_acceptThread = std::thread(&TcpSocket::serverAcceptThread, this);
+
+    if (m_connectionStatusCallback)
+    {
+        m_connectionStatusCallback(true, "Server started on port " + std::to_string(m_port));
+    }
+
+    return true;
+}
+
+void TcpSocket::close()
+{
+    // STEP 1: Shutdown sockets FIRST to wake up any blocking operations
+    if (m_socket != INVALID_SOCKET) {
+        shutdown(m_socket, SD_BOTH);  // This wakes up recv() calls
+    }
+    
+    if (m_serverSocket != INVALID_SOCKET) {
+        shutdown(m_serverSocket, SD_BOTH);  // This wakes up accept() calls
+    }
+    
+    // Shutdown all client connections
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        for (SOCKET clientSocket : m_clientSockets) {
+            if (clientSocket != INVALID_SOCKET) {
+                shutdown(clientSocket, SD_BOTH);
+            }
+        }
+    }
+    
+    // STEP 2: Now stopReading should complete quickly since sockets are shutdown
+    stopReading();
+
+    // STEP 3: Close the sockets
+    if (m_socket != INVALID_SOCKET)
+    {
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+    }
+
+    if (m_serverSocket != INVALID_SOCKET)
+    {
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+    }
+
+    // Close all client connections
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            closesocket(clientSocket);
+        }
+        m_clientSockets.clear();
+    }
+
+    m_isConnected = false;
+    m_isServerRunning = false;
+}
+
+bool TcpSocket::write(const std::vector<uint8_t> &data)
+{
+    if (data.empty())
+    {
+        return false;
+    }
+
+    if (m_type == ConnectionType::Client && m_isConnected)
+    {
+        int result = send(m_socket, (char *)data.data(), static_cast<int>(data.size()), 0);
+        return result != SOCKET_ERROR;
+    }
+    else if (m_type == ConnectionType::Server && m_isServerRunning)
+    {
+        // Send to all connected clients
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        bool success = true;
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            int result = send(clientSocket, (char *)data.data(), static_cast<int>(data.size()), 0);
+            if (result == SOCKET_ERROR)
+            {
+                success = false;
+            }
+        }
+        return success;
+    }
+
+    return false;
+}
+
+void TcpSocket::setDataReceivedCallback(DataReceivedCallback callback)
+{
+    m_dataCallback = std::move(callback);
+}
+
+void TcpSocket::setClientConnectedCallback(ClientConnectedCallback callback)
+{
+    m_clientConnectedCallback = std::move(callback);
+}
+
+void TcpSocket::setClientDisconnectedCallback(ClientDisconnectedCallback callback)
+{
+    m_clientDisconnectedCallback = std::move(callback);
+}
+
+void TcpSocket::setConnectionStatusCallback(ConnectionStatusCallback callback)
+{
+    m_connectionStatusCallback = std::move(callback);
+}
+
+void TcpSocket::startReading()
+{
+    if (m_type == ConnectionType::Client)
+    {
+        m_readThread = std::thread(&TcpSocket::clientReadThread, this);
+    }
+}
+
+// CHANGE 1: Update clientReadThread() - Add socket timeout
+void TcpSocket::clientReadThread()
+{
+    std::vector<uint8_t> buffer(1024);
+
+    // Set socket timeout to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isConnected)
+    {
+        int bytesReceived = recv(m_socket, (char *)buffer.data(), buffer.size(), 0);
+
+        if (bytesReceived > 0)
+        {
+            if (m_dataCallback)
+            {
+                OutputDebugStringA(("TCP Client received " + std::to_string(bytesReceived) + " bytes\n").c_str());
+                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
+            }
+        }
+        else if (bytesReceived == 0)
+        {
+            // Connection closed by peer
+            m_isConnected = false;
+            if (m_connectionStatusCallback)
+            {
+                m_connectionStatusCallback(false, "Connection closed by peer");
+            }
+            break;
+        }
+        else
+        {
+            // Error occurred
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Connection closed/shutdown - exit gracefully
+                m_isConnected = false;
+                OutputDebugStringA("Connection closed during recv\n");
+                break;
+            }
+            else if (error != WSAEWOULDBLOCK)
+            {
+                m_isConnected = false;
+                if (m_connectionStatusCallback)
+                {
+                    m_connectionStatusCallback(false, "Receive error: " + std::to_string(error));
+                }
+                break;
+            }
+        }
+    }
+    OutputDebugStringA("Client read thread exiting\n");
+}
+
+// CHANGE 2: Update serverAcceptThread() - Add socket timeout
+void TcpSocket::serverAcceptThread()
+{
+    // Set socket timeout for accept() to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(m_serverSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isServerRunning)
+    {
+        sockaddr_in clientAddr = {};
+        int clientAddrLen = sizeof(clientAddr);
+
+        SOCKET clientSocket = accept(m_serverSocket, (sockaddr *)&clientAddr, &clientAddrLen);
+
+        if (clientSocket != INVALID_SOCKET)
+        {
+            std::string clientAddress = getSocketAddress(clientSocket);
+
+            {
+                std::lock_guard<std::mutex> lock(m_clientsMutex);
+                m_clientSockets.push_back(clientSocket);
+                m_clientThreads.emplace_back(&TcpSocket::serverClientReadThread, this, clientSocket, clientAddress);
+            }
+
+            if (m_clientConnectedCallback)
+            {
+                m_clientConnectedCallback(clientAddress);
+            }
+
+            OutputDebugStringA(("Client connected from: " + clientAddress + "\n").c_str());
+        }
+        else if (m_isRunning && m_isServerRunning)
+        {
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Server socket closed/shutdown - exit gracefully
+                OutputDebugStringA("Server socket closed during accept\n");
+                break;
+            }
+            else if (error != WSAEINTR)
+            {
+                OutputDebugStringA(("Accept error: " + std::to_string(error) + "\n").c_str());
+            }
+        }
+    }
+    OutputDebugStringA("Server accept thread exiting\n");
+}
+
+// CHANGE 3: Update serverClientReadThread() - Add socket timeout
+void TcpSocket::serverClientReadThread(SOCKET clientSocket, std::string clientAddress)
+{
+    std::vector<uint8_t> buffer(1024);
+
+    // Set socket timeout to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isServerRunning)
+    {
+        int bytesReceived = recv(clientSocket, (char *)buffer.data(), buffer.size(), 0);
+
+        if (bytesReceived > 0)
+        {
+            if (m_dataCallback)
+            {
+                OutputDebugStringA(("TCP Server received " + std::to_string(bytesReceived) + " bytes from " + clientAddress + "\n").c_str());
+                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
+            }
+        }
+        else if (bytesReceived == 0)
+        {
+            // Client disconnected
+            OutputDebugStringA(("Client disconnected normally: " + clientAddress + "\n").c_str());
+            break;
+        }
+        else
+        {
+            // Error occurred
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Client connection closed/shutdown - exit gracefully
+                OutputDebugStringA(("Client connection closed during recv: " + clientAddress + "\n").c_str());
+                break;
+            }
+            else if (error != WSAEWOULDBLOCK)
+            {
+                OutputDebugStringA(("Client receive error: " + std::to_string(error) + " for " + clientAddress + "\n").c_str());
+                break;
+            }
+        }
+    }
+
+    // Remove client from list and close socket
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        auto it = std::find(m_clientSockets.begin(), m_clientSockets.end(), clientSocket);
+        if (it != m_clientSockets.end())
+        {
+            m_clientSockets.erase(it);
+        }
+    }
+
+    closesocket(clientSocket);
+
+    if (m_clientDisconnectedCallback)
+    {
+        m_clientDisconnectedCallback(clientAddress);
+    }
+
+    OutputDebugStringA(("Client thread exiting: " + clientAddress + "\n").c_str());
+}
+
+// CHANGE 4: Simplify stopReading() - Remove async timeout logic (it's causing issues)
+void TcpSocket::stopReading()
+{
+    OutputDebugStringA("stopReading() called\n");
+
+    // 1. Set the stop flag
+    m_isRunning = false;
+    OutputDebugStringA("Set m_isRunning = false\n");
+
+    // 2. WAKE UP blocked threads by shutting down sockets
+    if (m_socket != INVALID_SOCKET)
+    {
+        OutputDebugStringA("Shutting down main socket...\n");
+        shutdown(m_socket, SD_BOTH);
+    }
+
+    if (m_serverSocket != INVALID_SOCKET)
+    {
+        OutputDebugStringA("Shutting down server socket...\n");
+        shutdown(m_serverSocket, SD_BOTH);
+    }
+
+    // Wake up client sockets
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        OutputDebugStringA(("Shutting down " + std::to_string(m_clientSockets.size()) + " client sockets...\n").c_str());
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            shutdown(clientSocket, SD_BOTH);
+        }
+    }
+
+    // 3. Join threads with simple timeout
+    OutputDebugStringA("Joining read thread...\n");
+    if (m_readThread.joinable())
+    {
+        try
+        {
+            m_readThread.join();
+            OutputDebugStringA("Read thread joined successfully\n");
+        }
+        catch (...)
+        {
+            OutputDebugStringA("Read thread join failed - detaching\n");
+            m_readThread.detach();
+        }
+    }
+
+    OutputDebugStringA("Joining accept thread...\n");
+    if (m_acceptThread.joinable())
+    {
+        try
+        {
+            m_acceptThread.join();
+            OutputDebugStringA("Accept thread joined successfully\n");
+        }
+        catch (...)
+        {
+            OutputDebugStringA("Accept thread join failed - detaching\n");
+            m_acceptThread.detach();
+        }
+    }
+
+    // Join client threads
+    OutputDebugStringA(("Joining " + std::to_string(m_clientThreads.size()) + " client threads...\n").c_str());
+    for (size_t i = 0; i < m_clientThreads.size(); ++i)
+    {
+        auto &thread = m_clientThreads[i];
+        if (thread.joinable())
+        {
+            try
+            {
+                thread.join();
+                OutputDebugStringA(("Client thread " + std::to_string(i) + " joined successfully\n").c_str());
+            }
+            catch (...)
+            {
+                OutputDebugStringA(("Client thread " + std::to_string(i) + " join failed - detaching\n").c_str());
+                thread.detach();
+            }
+        }
+    }
+    m_clientThreads.clear();
+
+    OutputDebugStringA("stopReading() completed successfully\n");
+}
+
+std::string TcpSocket::getSocketAddress(SOCKET socket)
+{
+    sockaddr_in addr = {};
+    int addrLen = sizeof(addr);
+
+    if (getpeername(socket, (sockaddr *)&addr, &addrLen) == 0)
+    {
+        char ipStr[INET_ADDRSTRLEN];
+        if (inet_ntop(AF_INET, &addr.sin_addr, ipStr, INET_ADDRSTRLEN))
+        {
+            return std::string(ipStr) + ":" + std::to_string(ntohs(addr.sin_port));
+        }
+    }
+
+    return "unknown";
 }