librats 0.7.0 → 0.7.2

package/native-src/src/network_utils.cpp

@@ -35,350 +35,9 @@
 namespace librats {
 namespace network_utils {
 
-std::string resolve_hostname(const std::string& hostname) {
-    LOG_NETUTILS_DEBUG("Resolving hostname: " << hostname);
-    
-    // Handle empty string
-    if (hostname.empty()) {
-        LOG_NETUTILS_DEBUG("Empty hostname provided");
-        return "";
-    }
-    
-    // Check if it's already an IP address
-    if (is_valid_ipv4(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IP address: " << hostname);
-        return hostname;
-    }
-    
-    // Resolve hostname using getaddrinfo
-    struct addrinfo hints, *result;
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET;  // IPv4
-    hints.ai_socktype = SOCK_DGRAM;  // UDP
-    
-    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
-    if (status != 0) {
-#ifdef _WIN32
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << WSAGetLastError());
-#else
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << gai_strerror(status));
-#endif
-        return "";
-    }
-    
-    char ip_str[INET_ADDRSTRLEN];
-    struct sockaddr_in* addr_in = (struct sockaddr_in*)result->ai_addr;
-    inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
-    
-    freeaddrinfo(result);
-    
-    LOG_NETUTILS_INFO("Resolved " << hostname << " to " << ip_str);
-    return std::string(ip_str);
-}
-
-std::string resolve_hostname_v6(const std::string& hostname) {
-    LOG_NETUTILS_DEBUG("Resolving hostname to IPv6: " << hostname);
-    
-    // Handle empty string
-    if (hostname.empty()) {
-        LOG_NETUTILS_DEBUG("Empty hostname provided");
-        return "";
-    }
-    
-    // Check if it's already an IPv6 address
-    if (is_valid_ipv6(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IPv6 address: " << hostname);
-        return hostname;
-    }
-    
-    // Resolve hostname using getaddrinfo
-    struct addrinfo hints, *result;
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET6;  // IPv6
-    hints.ai_socktype = SOCK_DGRAM;  // UDP
-    
-    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
-    if (status != 0) {
-#ifdef _WIN32
-        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << WSAGetLastError());
-#else
-        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << gai_strerror(status));
-#endif
-        return "";
-    }
-    
-    char ip_str[INET6_ADDRSTRLEN];
-    struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)result->ai_addr;
-    inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
-    
-    freeaddrinfo(result);
-    
-    LOG_NETUTILS_DEBUG("Resolved " << hostname << " to IPv6 " << ip_str);
-    return std::string(ip_str);
-}
-
-bool is_valid_ipv4(const std::string& ip_str) {
-#ifdef __APPLE__
-    // macOS-specific validation to handle inet_pton() accepting leading zeros
-    // inet_pton() behaves differently on macOS vs Linux/Windows for leading zeros
-    
-    // Split the IP string into octets
-    std::vector<std::string> octets;
-    std::string current_octet;
-    
-    for (char c : ip_str) {
-        if (c == '.') {
-            octets.push_back(current_octet);
-            current_octet.clear();
-        } else {
-            current_octet += c;
-        }
-    }
-    
-    // Add the last octet
-    if (!current_octet.empty()) {
-        octets.push_back(current_octet);
-    }
-    
-    // Must have exactly 4 octets
-    if (octets.size() != 4) {
-        return false;
-    }
-    
-    // Check each octet for validity
-    for (const std::string& octet : octets) {
-        // Empty octet is invalid
-        if (octet.empty()) {
-            return false;
-        }
-        
-        // Check for leading zeros (invalid except for "0")
-        if (octet.length() > 1 && octet[0] == '0') {
-            return false;
-        }
-        
-        // Check that all characters are digits
-        for (char c : octet) {
-            if (c < '0' || c > '9') {
-                return false;
-            }
-        }
-        
-        // Check range (0-255)
-        int value = std::stoi(octet);
-        if (value < 0 || value > 255) {
-            return false;
-        }
-    }
-#endif
-    // Linux/Windows: inet_pton() already rejects leading zeros correctly
-    struct sockaddr_in sa;
-    return inet_pton(AF_INET, ip_str.c_str(), &sa.sin_addr) == 1;
-}
-
-bool is_valid_ipv6(const std::string& ip_str) {
-    struct sockaddr_in6 sa;
-    return inet_pton(AF_INET6, ip_str.c_str(), &sa.sin6_addr) == 1;
-}
-
-bool is_hostname(const std::string& str) {
-    // First check if it's an IP address - if so, it's not a hostname
-    if (is_valid_ipv4(str) || is_valid_ipv6(str)) {
-        return false;
-    }
-    
-    // Check basic validation rules
-    if (str.empty() || str.length() > 253) {
-        return false;
-    }
-    
-    // Check for invalid characters at start/end
-    if (str.front() == '.' || str.back() == '.') {
-        return false;
-    }
-    
-    if (str.front() == '-' || str.back() == '-') {
-        return false;
-    }
-    
-    // Check for invalid patterns
-    if (str.find("..") != std::string::npos) {
-        return false;
-    }
-    
-    if (str == ".") {
-        return false;
-    }
-    
-    // Check for invalid characters
-    for (char c : str) {
-        if (c == ' ' || c == '@' || c == '#' || c == '$' || c == '%' || 
-            c == '^' || c == '&' || c == '*' || c == '(' || c == ')' || 
-            c == '+' || c == '=' || c == '[' || c == ']' || c == '{' || 
-            c == '}' || c == '|' || c == '\\' || c == '/' || c == '?' || 
-            c == '<' || c == '>' || c == ',' || c == ';' || c == ':' || 
-            c == '"' || c == '\'' || c == '`' || c == '~' || c == '!') {
-            return false;
-        }
-    }
-    
-    return true;
-}
-
-std::string to_ip_address(const std::string& host) {
-    return resolve_hostname(host);
-}
-
-std::vector<std::string> resolve_all_addresses(const std::string& hostname) {
-    LOG_NETUTILS_DEBUG("Resolving all addresses for hostname: " << hostname);
-    
-    std::vector<std::string> addresses;
-    
-    // Check if it's already an IP address
-    if (is_valid_ipv4(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IP address: " << hostname);
-        addresses.push_back(hostname);
-        return addresses;
-    }
-    
-    // Resolve hostname using getaddrinfo
-    struct addrinfo hints, *result, *rp;
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET;  // IPv4
-    hints.ai_socktype = SOCK_DGRAM;  // UDP
-    
-    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
-    if (status != 0) {
-#ifdef _WIN32
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << WSAGetLastError());
-#else
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << gai_strerror(status));
-#endif
-        return addresses;
-    }
-    
-    // Iterate through all addresses
-    for (rp = result; rp != nullptr; rp = rp->ai_next) {
-        char ip_str[INET_ADDRSTRLEN];
-        struct sockaddr_in* addr_in = (struct sockaddr_in*)rp->ai_addr;
-        inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
-        
-        std::string ip_address(ip_str);
-        addresses.push_back(ip_address);
-        LOG_NETUTILS_DEBUG("Found address: " << ip_address);
-    }
-    
-    freeaddrinfo(result);
-    
-    LOG_NETUTILS_INFO("Resolved " << hostname << " to " << addresses.size() << " addresses");
-    return addresses;
-}
-
-std::vector<std::string> resolve_all_addresses_v6(const std::string& hostname) {
-    LOG_NETUTILS_DEBUG("Resolving all IPv6 addresses for hostname: " << hostname);
-    
-    std::vector<std::string> addresses;
-    
-    // Check if it's already an IPv6 address
-    if (is_valid_ipv6(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IPv6 address: " << hostname);
-        addresses.push_back(hostname);
-        return addresses;
-    }
-    
-    // Resolve hostname using getaddrinfo
-    struct addrinfo hints, *result, *rp;
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET6;  // IPv6
-    hints.ai_socktype = SOCK_DGRAM;  // UDP
-    
-    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
-    if (status != 0) {
-#ifdef _WIN32
-        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << WSAGetLastError());
-#else
-        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << gai_strerror(status));
-#endif
-        return addresses;
-    }
-    
-    // Iterate through all addresses
-    for (rp = result; rp != nullptr; rp = rp->ai_next) {
-        char ip_str[INET6_ADDRSTRLEN];
-        struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)rp->ai_addr;
-        inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
-        
-        std::string ip_address(ip_str);
-        addresses.push_back(ip_address);
-        LOG_NETUTILS_DEBUG("Found IPv6 address: " << ip_address);
-    }
-    
-    freeaddrinfo(result);
-    
-    LOG_NETUTILS_INFO("Resolved " << hostname << " to " << addresses.size() << " IPv6 addresses");
-    return addresses;
-}
+// ── Internal helpers (not exposed in header) ────────────────────────────────
 
-std::vector<std::string> resolve_all_addresses_dual(const std::string& hostname) {
-    LOG_NETUTILS_DEBUG("Resolving all addresses (dual stack) for hostname: " << hostname);
-    
-    std::vector<std::string> addresses;
-    
-    // Check if it's already an IP address
-    if (is_valid_ipv4(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IPv4 address: " << hostname);
-        addresses.push_back(hostname);
-        return addresses;
-    }
-    
-    if (is_valid_ipv6(hostname)) {
-        LOG_NETUTILS_DEBUG("Already an IPv6 address: " << hostname);
-        addresses.push_back(hostname);
-        return addresses;
-    }
-    
-    // Resolve hostname using getaddrinfo with dual stack
-    struct addrinfo hints, *result, *rp;
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_UNSPEC;  // Both IPv4 and IPv6
-    hints.ai_socktype = SOCK_DGRAM;  // UDP
-    
-    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
-    if (status != 0) {
-#ifdef _WIN32
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << " (dual stack): " << WSAGetLastError());
-#else
-        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << " (dual stack): " << gai_strerror(status));
-#endif
-        return addresses;
-    }
-    
-    // Iterate through all addresses
-    for (rp = result; rp != nullptr; rp = rp->ai_next) {
-        if (rp->ai_family == AF_INET) {
-            char ip_str[INET_ADDRSTRLEN];
-            struct sockaddr_in* addr_in = (struct sockaddr_in*)rp->ai_addr;
-            inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
-            
-            std::string ip_address(ip_str);
-            addresses.push_back(ip_address);
-            LOG_NETUTILS_DEBUG("Found IPv4 address: " << ip_address);
-        } else if (rp->ai_family == AF_INET6) {
-            char ip_str[INET6_ADDRSTRLEN];
-            struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)rp->ai_addr;
-            inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
-            
-            std::string ip_address(ip_str);
-            addresses.push_back(ip_address);
-            LOG_NETUTILS_DEBUG("Found IPv6 address: " << ip_address);
-        }
-    }
-    
-    freeaddrinfo(result);
-    
-    LOG_NETUTILS_INFO("Resolved " << hostname << " to " << addresses.size() << " addresses (dual stack)");
-    return addresses;
-}
+namespace {
 
 std::vector<std::string> get_local_interface_addresses_v4() {
     LOG_NETUTILS_DEBUG("Getting local IPv4 interface addresses");
@@ -386,7 +45,6 @@ std::vector<std::string> get_local_interface_addresses_v4() {
     std::vector<std::string> addresses;
     
 #ifdef _WIN32
-    // Windows implementation using GetAdaptersAddresses
     DWORD dwRetVal = 0;
     ULONG outBufLen = 15000;
     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
@@ -438,7 +96,6 @@ std::vector<std::string> get_local_interface_addresses_v4() {
     }
 
 #else
-    // Linux/Unix implementation using getifaddrs
     struct ifaddrs *ifaddr, *ifa;
     
     if (getifaddrs(&ifaddr) == -1) {
@@ -472,7 +129,6 @@ std::vector<std::string> get_local_interface_addresses_v6() {
     std::vector<std::string> addresses;
     
 #ifdef _WIN32
-    // Windows implementation using GetAdaptersAddresses
     DWORD dwRetVal = 0;
     ULONG outBufLen = 15000;
     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
@@ -524,7 +180,6 @@ std::vector<std::string> get_local_interface_addresses_v6() {
     }
 
 #else
-    // Linux/Unix implementation using getifaddrs
     struct ifaddrs *ifaddr, *ifa;
     
     if (getifaddrs(&ifaddr) == -1) {
@@ -552,16 +207,186 @@ std::vector<std::string> get_local_interface_addresses_v6() {
     return addresses;
 }
 
+} // anonymous namespace
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+std::string resolve_hostname(const std::string& hostname) {
+    LOG_NETUTILS_DEBUG("Resolving hostname: " << hostname);
+    
+    if (hostname.empty()) {
+        LOG_NETUTILS_DEBUG("Empty hostname provided");
+        return "";
+    }
+    
+    if (is_valid_ipv4(hostname)) {
+        LOG_NETUTILS_DEBUG("Already an IP address: " << hostname);
+        return hostname;
+    }
+    
+    struct addrinfo hints, *result;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_DGRAM;
+    
+    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
+    if (status != 0) {
+#ifdef _WIN32
+        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << WSAGetLastError());
+#else
+        LOG_NETUTILS_ERROR("Failed to resolve hostname " << hostname << ": " << gai_strerror(status));
+#endif
+        return "";
+    }
+    
+    char ip_str[INET_ADDRSTRLEN];
+    struct sockaddr_in* addr_in = (struct sockaddr_in*)result->ai_addr;
+    inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
+    
+    freeaddrinfo(result);
+    
+    LOG_NETUTILS_INFO("Resolved " << hostname << " to " << ip_str);
+    return std::string(ip_str);
+}
+
+std::string resolve_hostname_v6(const std::string& hostname) {
+    LOG_NETUTILS_DEBUG("Resolving hostname to IPv6: " << hostname);
+    
+    if (hostname.empty()) {
+        LOG_NETUTILS_DEBUG("Empty hostname provided");
+        return "";
+    }
+    
+    if (is_valid_ipv6(hostname)) {
+        LOG_NETUTILS_DEBUG("Already an IPv6 address: " << hostname);
+        return hostname;
+    }
+    
+    struct addrinfo hints, *result;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET6;
+    hints.ai_socktype = SOCK_DGRAM;
+    
+    int status = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
+    if (status != 0) {
+#ifdef _WIN32
+        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << WSAGetLastError());
+#else
+        LOG_NETUTILS_DEBUG("Failed to resolve hostname " << hostname << " to IPv6: " << gai_strerror(status));
+#endif
+        return "";
+    }
+    
+    char ip_str[INET6_ADDRSTRLEN];
+    struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)result->ai_addr;
+    inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
+    
+    freeaddrinfo(result);
+    
+    LOG_NETUTILS_DEBUG("Resolved " << hostname << " to IPv6 " << ip_str);
+    return std::string(ip_str);
+}
+
+bool is_valid_ipv4(const std::string& ip_str) {
+#ifdef __APPLE__
+    // macOS-specific validation to handle inet_pton() accepting leading zeros
+    std::vector<std::string> octets;
+    std::string current_octet;
+    
+    for (char c : ip_str) {
+        if (c == '.') {
+            octets.push_back(current_octet);
+            current_octet.clear();
+        } else {
+            current_octet += c;
+        }
+    }
+    
+    if (!current_octet.empty()) {
+        octets.push_back(current_octet);
+    }
+    
+    if (octets.size() != 4) {
+        return false;
+    }
+    
+    for (const std::string& octet : octets) {
+        if (octet.empty()) {
+            return false;
+        }
+        
+        if (octet.length() > 1 && octet[0] == '0') {
+            return false;
+        }
+        
+        for (char c : octet) {
+            if (c < '0' || c > '9') {
+                return false;
+            }
+        }
+        
+        int value = std::stoi(octet);
+        if (value < 0 || value > 255) {
+            return false;
+        }
+    }
+#endif
+    struct sockaddr_in sa;
+    return inet_pton(AF_INET, ip_str.c_str(), &sa.sin_addr) == 1;
+}
+
+bool is_valid_ipv6(const std::string& ip_str) {
+    struct sockaddr_in6 sa;
+    return inet_pton(AF_INET6, ip_str.c_str(), &sa.sin6_addr) == 1;
+}
+
+bool is_hostname(const std::string& str) {
+    if (is_valid_ipv4(str) || is_valid_ipv6(str)) {
+        return false;
+    }
+    
+    if (str.empty() || str.length() > 253) {
+        return false;
+    }
+    
+    if (str.front() == '.' || str.back() == '.') {
+        return false;
+    }
+    
+    if (str.front() == '-' || str.back() == '-') {
+        return false;
+    }
+    
+    if (str.find("..") != std::string::npos) {
+        return false;
+    }
+    
+    if (str == ".") {
+        return false;
+    }
+    
+    for (char c : str) {
+        if (c == ' ' || c == '@' || c == '#' || c == '$' || c == '%' || 
+            c == '^' || c == '&' || c == '*' || c == '(' || c == ')' || 
+            c == '+' || c == '=' || c == '[' || c == ']' || c == '{' || 
+            c == '}' || c == '|' || c == '\\' || c == '/' || c == '?' || 
+            c == '<' || c == '>' || c == ',' || c == ';' || c == ':' || 
+            c == '"' || c == '\'' || c == '`' || c == '~' || c == '!') {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
 std::vector<std::string> get_local_interface_addresses() {
     LOG_NETUTILS_DEBUG("Getting all local interface addresses (IPv4 and IPv6)");
     
     std::vector<std::string> addresses;
     
-    // Get IPv4 addresses
     auto ipv4_addresses = get_local_interface_addresses_v4();
     addresses.insert(addresses.end(), ipv4_addresses.begin(), ipv4_addresses.end());
     
-    // Get IPv6 addresses
     auto ipv6_addresses = get_local_interface_addresses_v6();
     addresses.insert(addresses.end(), ipv6_addresses.begin(), ipv6_addresses.end());
     
@@ -571,28 +396,5 @@ std::vector<std::string> get_local_interface_addresses() {
     return addresses;
 }
 
-bool is_local_interface_address(const std::string& ip_address) {
-    LOG_NETUTILS_DEBUG("Checking if " << ip_address << " is a local interface address");
-    
-    // Get all local addresses and check if the given address is in the list
-    auto local_addresses = get_local_interface_addresses();
-    
-    for (const auto& local_addr : local_addresses) {
-        if (local_addr == ip_address) {
-            LOG_NETUTILS_DEBUG(ip_address << " is a local interface address");
-            return true;
-        }
-    }
-    
-    // Also check common localhost addresses
-    if (ip_address == "127.0.0.1" || ip_address == "::1" || ip_address == "localhost") {
-        LOG_NETUTILS_DEBUG(ip_address << " is a localhost address");
-        return true;
-    }
-    
-    LOG_NETUTILS_DEBUG(ip_address << " is not a local interface address");
-    return false;
-}
-
 } // namespace network_utils
-} // namespace librats 
+} // namespace librats