librats 1.0.2 → 2.2.0

package/native-src/src/socket.h

@@ -1,228 +0,0 @@
-#pragma once
-
-#include <string>
-#include <functional>
-#include <vector>
-#include <cstdint>
-
-#ifdef _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    #ifdef _MSC_VER
-        #pragma comment(lib, "ws2_32.lib")
-    #endif
-    typedef SOCKET socket_t;
-    #define INVALID_SOCKET_VALUE INVALID_SOCKET
-    #define SOCKET_ERROR_VALUE SOCKET_ERROR
-#else
-    #include <sys/socket.h>
-    #include <arpa/inet.h>
-    #include <netinet/in.h>
-    #include <unistd.h>
-    typedef int socket_t;
-    #define INVALID_SOCKET_VALUE -1
-    #define SOCKET_ERROR_VALUE -1
-    #define closesocket close
-#endif
-
-namespace librats {
-
-/**
- * Address family for socket creation
- */
-enum class AddressFamily {
-    IPv4,       // IPv4 only
-    IPv6,       // IPv6 only
-    DualStack   // IPv6 socket with IPv4 support (default)
-};
-
-/**
- * UDP peer information
- */
-struct Peer {
-    std::string ip;
-    uint16_t port;
-    
-    Peer() : port(0) {}
-    Peer(const std::string& ip, uint16_t port) : ip(ip), port(port) {}
-    
-    bool operator==(const Peer& other) const {
-        return ip == other.ip && port == other.port;
-    }
-    
-    bool operator!=(const Peer& other) const {
-        return !(*this == other);
-    }
-};
-
-// Socket Library Initialization
-/**
- * Initialize the socket library
- * @return true if successful, false otherwise
- */
-bool init_socket_library();
-
-/**
- * Cleanup the socket library
- */
-void cleanup_socket_library();
-
-// TCP Socket Functions
-/**
- * Create a TCP client socket and connect to a server using dual stack (IPv6 with IPv4 fallback)
- * @param host The hostname or IP address to connect to
- * @param port The port number to connect to
- * @param timeout_ms Connection timeout in milliseconds (0 for blocking)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_client(const std::string& host, int port, int timeout_ms = 0);
-
-/**
- * Create a TCP server socket and bind to a port
- * @param port The port number to bind to
- * @param backlog The maximum number of pending connections
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @param af Address family (DualStack by default)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_server(int port, int backlog = 5, const std::string& bind_address = "",
-                           AddressFamily af = AddressFamily::DualStack);
-
-/**
- * Accept a client connection on a server socket
- * @param server_socket The server socket handle
- * @return Client socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t accept_client(socket_t server_socket);
-
-/**
- * Get the peer address (IP:port) from a connected socket
- * @param socket The connected socket handle
- * @return Peer address string in format "IP:port", or empty string on error
- */
-std::string get_peer_address(socket_t socket);
-
-/**
- * Send data through a TCP socket
- * @param socket The socket handle
- * @param data The binary data to send
- * @return Number of bytes sent, or -1 on error
- */
-int send_tcp_data(socket_t socket, const std::vector<uint8_t>& data);
-
-/**
- * Receive data from a TCP socket
- * @param socket The socket handle
- * @param buffer_size Maximum number of bytes to receive
- * @return Received binary data, empty vector on error
- */
-std::vector<uint8_t> receive_tcp_data(socket_t socket, size_t buffer_size = 1024);
-
-/**
- * Send a length-prefixed framed message through a TCP socket
- * @param socket The socket handle
- * @param message The binary message to send
- * @return Total bytes sent (including length prefix), or -1 on error
- */
-int send_tcp_message(socket_t socket, const std::vector<uint8_t>& message);
-
-/**
- * Receive a complete length-prefixed framed message from a TCP socket
- * @param socket The socket handle
- * @return Complete binary message, empty vector on error or connection close
- */
-std::vector<uint8_t> receive_tcp_message(socket_t socket);
-
-/**
- * Send string data through a TCP socket (converts to binary)
- * @param socket The socket handle
- * @param data The string data to send
- * @return Number of bytes sent, or -1 on error
- */
-int send_tcp_string(socket_t socket, const std::string& data);
-
-// UDP Socket Functions
-/**
- * Create a UDP socket and bind to a port
- * @param port The port to bind to (0 for any available port)
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @param af Address family (DualStack by default)
- * @return UDP socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_udp_socket(int port = 0, const std::string& bind_address = "",
-                           AddressFamily af = AddressFamily::DualStack);
-
-/**
- * Send UDP data to a destination host and port
- * @param socket The UDP socket handle
- * @param data The data to send
- * @param host The destination hostname or IP address
- * @param port The destination port
- * @param af Address family matching the socket (DualStack by default)
- * @return Number of bytes sent, or -1 on error
- */
-int send_udp_data(socket_t socket, const std::vector<uint8_t>& data, const std::string& host, int port,
-                  AddressFamily af = AddressFamily::DualStack);
-
-/**
- * Receive UDP data with optional timeout
- * @param socket The UDP socket handle
- * @param buffer_size Maximum number of bytes to receive
- * @param sender_peer Output parameter for the sender's peer info
- * @param timeout_ms Timeout in milliseconds (-1 for blocking, 0 for non-blocking, >0 for timeout)
- * @param interrupt_fd Optional second socket to watch; when it becomes readable the
- *                     call returns immediately with an empty vector (used to wake a
- *                     blocking receive on shutdown). INVALID_SOCKET_VALUE disables it.
- * @return Received data, empty vector on timeout, error or interrupt
- */
-std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
-                                      int timeout_ms = -1,
-                                      socket_t interrupt_fd = INVALID_SOCKET_VALUE);
-
-// Common Socket Functions
-/**
- * Close a socket
- * @param socket The socket handle to close
- * @param force If true, send RST instead of FIN (avoids TIME_WAIT)
- */
-void close_socket(socket_t socket, bool force = false);
-
-/**
- * Check if a socket is valid
- * @param socket The socket handle to check
- * @return true if valid, false otherwise
- */
-bool is_valid_socket(socket_t socket);
-
-/**
- * Set socket to non-blocking mode
- * @param socket The socket handle
- * @return true if successful, false otherwise
- */
-bool set_socket_nonblocking(socket_t socket);
-
-/**
- * Set socket to blocking mode
- * @param socket The socket handle
- * @return true if successful, false otherwise
- */
-bool set_socket_blocking(socket_t socket);
-
-/**
- * Connect to a socket address with timeout
- * @param socket The socket handle (should be non-blocking)
- * @param addr The socket address structure
- * @param addr_len Length of the address structure
- * @param timeout_ms Connection timeout in milliseconds
- * @return true if connected successfully, false on timeout or error
- */
-bool connect_with_timeout(socket_t socket, struct sockaddr* addr, socklen_t addr_len, int timeout_ms);
-
-/**
- * Get the port that a socket is bound to
- * @param socket The socket handle
- * @return The bound port, or 0 on error
- */
-int get_bound_port(socket_t socket);
-
-} // namespace librats

package/native-src/src/threadmanager.cpp

@@ -1,105 +0,0 @@
-#include "threadmanager.h"
-
-// ThreadManager module logging macros
-#define LOG_THREAD_DEBUG(message) LOG_DEBUG("thread", message)
-#define LOG_THREAD_INFO(message)  LOG_INFO("thread", message)
-#define LOG_THREAD_WARN(message)  LOG_WARN("thread", message)
-#define LOG_THREAD_ERROR(message) LOG_ERROR("thread", message)
-
-namespace librats {
-
-ThreadManager::ThreadManager() {
-    LOG_THREAD_DEBUG("ThreadManager initialized");
-}
-
-ThreadManager::~ThreadManager() {
-    // Ensure all threads are properly cleaned up
-    join_all_active_threads();
-    LOG_THREAD_DEBUG("ThreadManager destroyed");
-}
-
-void ThreadManager::add_managed_thread(std::thread&& t, const std::string& name) {
-    // Check if shutdown has been requested - don't add new threads during shutdown
-    if (shutdown_requested_.load()) {
-        LOG_THREAD_WARN("Ignoring thread detach during shutdown: " << name);
-        // Join the thread so it can finish on its own during shutdown
-        if (t.joinable()) {
-            t.join();
-        }
-        return;
-    }
-    
-    std::lock_guard<std::mutex> lock(active_threads_mutex_);
-    
-    // Double-check after acquiring lock
-    if (shutdown_requested_.load()) {
-        LOG_THREAD_WARN("Ignoring thread detach during shutdown (double-check): " << name);
-        // Join the thread so it can finish on its own during shutdown
-        if (t.joinable()) {
-            t.join();
-        }
-        return;
-    }
-    
-    active_threads_.emplace_back(std::move(t));
-    LOG_THREAD_DEBUG("Added managed thread: " << name << " (total: " << active_threads_.size() << ")");
-}
-
-void ThreadManager::cleanup_finished_threads() {
-    // we wait until all threads are finished thus mean cleanup is done
-    join_all_active_threads();
-}
-
-void ThreadManager::shutdown_all_threads() {
-    LOG_THREAD_INFO("Initiating shutdown of all background threads");
-    
-    // Set shutdown flag first
-    shutdown_requested_.store(true);
-    
-    // Notify all waiting threads to wake up immediately
-    notify_shutdown();
-}
-
-void ThreadManager::join_all_active_threads() {
-    std::vector<std::thread> threads_to_join;
-    
-    // Move threads out of the container while holding the lock
-    {
-        std::lock_guard<std::mutex> lock(active_threads_mutex_);
-        LOG_THREAD_INFO("Waiting for " << active_threads_.size() << " managed threads to finish");
-        
-        if (active_threads_.empty()) {
-            LOG_THREAD_INFO("No active threads to join");
-            return;
-        }
-        
-        // Move all threads to local vector to avoid holding lock during join
-        threads_to_join = std::move(active_threads_);
-        active_threads_.clear();
-    }
-    
-    // Join threads without holding the mutex
-    for (auto& t : threads_to_join) {
-        if (t.joinable()) {
-            try {
-                t.join();
-            } catch (const std::exception& e) {
-                LOG_THREAD_ERROR("Exception while joining thread: " << e.what());
-            }
-        }
-    }
-    
-    LOG_THREAD_INFO("All managed threads have been cleaned up");
-}
-
-size_t ThreadManager::get_active_thread_count() const {
-    std::lock_guard<std::mutex> lock(active_threads_mutex_);
-    return active_threads_.size();
-}
-
-void ThreadManager::notify_shutdown() {
-    shutdown_cv_.notify_all();
-}
-
-} // namespace librats
-

package/native-src/src/threadmanager.h

@@ -1,53 +0,0 @@
-#ifndef THREADMANAGER_H
-#define THREADMANAGER_H
-
-#include <thread>
-#include <vector>
-#include <mutex>
-#include <condition_variable>
-#include <atomic>
-#include "logger.h"
-
-namespace librats {
-
-/**
- * ThreadManager - Manages background threads with graceful shutdown
- */
-class ThreadManager {
-public:
-    ThreadManager();
-    virtual ~ThreadManager();
-
-    // Add a new managed thread with optional name for debugging
-    void add_managed_thread(std::thread&& t, const std::string& name = "unnamed");
-
-    // Clean up finished threads (non-blocking)
-    void cleanup_finished_threads();
-
-    // Signal shutdown to all threads
-    void shutdown_all_threads();
-
-    // Wait for all active threads to finish (blocking)
-    void join_all_active_threads();
-
-    // Get count of active threads
-    size_t get_active_thread_count() const;
-
-protected:
-    // Notify waiting threads of shutdown
-    void notify_shutdown();
-
-    // Condition variable for shutdown coordination
-    std::condition_variable shutdown_cv_;
-    std::mutex shutdown_mutex_;
-
-private:
-    mutable std::mutex active_threads_mutex_;
-    std::vector<std::thread> active_threads_;
-    std::atomic<bool> shutdown_requested_{false};
-};
-
-} // namespace librats
-
-#endif // THREADMANAGER_H
-