Address review feedback: Use fs::getMaxHandles and restore connection adjustment logic

- Replaced direct getrlimit call with platform-abstraction fs::getMaxHandles()
- Used soft limit (rlim_cur) via fs::getMaxHandles() for accurate capacity
- Restored original connection limiting logic (MAX_ADDITIONAL_PEER_CONNECTIONS, etc.)
- Replaced CLOG_DEBUG(Config, ...) with LOG_DEBUG(DEFAULT_LOG, ...)
- Prevent overflow by capping RLIM_INFINITY safely in adjust()
- Kept Config::adjust() platform-independent

Resolves #5244

Author: EslaM-X

src/main/Config.cpp

@@ -2213,50 +2213,147 @@ Config::processConfig(std::shared_ptr<cpptoml::table> t)
     }
 }
 
-void Config::adjust()
-    // ================================================================
-    // FIX: Handle RLIMIT_NOFILE safely, especially for unlimited values.
-    // Addresses GitHub Issue #5244.
-    // Previously, fs::getMaxHandles() would overflow for RLIM_INFINITY,
-    // leading to potential crashes or undefined behavior when the system
-    // imposed no explicit limit on the number of open file descriptors.
-    // ================================================================
-    struct rlimit rl;
-if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
-{
-    // Use a dedicated, explicit type (rlim_t) to match system types
-    // and avoid platform-specific size mismatches.
-    rlim_t maxHandles = rl.rlim_max;
-
-    // Check for infinity explicitly to avoid overflow before any
-    // arithmetic operations or comparisons.
-    if (maxHandles == RLIM_INFINITY)
-    {
-        // For unlimited, set a practical high boundary that prevents
-        // overflow while still allowing high performance for most
-        // production workloads. This value is chosen to be safely
-        // below typical system limits (e.g., 2^31-1) to avoid
-        // any potential side effects from extremely large values.
-        rlim_t const SAFE_MAX_HANDLES = 1000000;
-        maxHandles = SAFE_MAX_HANDLES;
-        CLOG_DEBUG(Config,
-                   "RLIMIT_NOFILE is unlimited. Capping to {} for safety.",
-                   SAFE_MAX_HANDLES);
-    }
-
-    // Now assign the safe value to the internal member variable.
-    // Casting after the safe check is now guaranteed to be within
-    // a reasonable range for the target type.
-    mMaxHandles = static_cast<uint64_t>(maxHandles);
-}
-else
+void
+Config::adjust() void Config::adjust()
 {
-    // Fallback in case getrlimit fails unexpectedly (e.g., on
-    // non-POSIX-compliant systems or due to permission issues).
-    CLOG_WARNING(Config, "getrlimit(RLIMIT_NOFILE) failed. Using default.");
-    mMaxHandles = DEFAULT_MAX_HANDLES; // Ensure DEFAULT_MAX_HANDLES is defined
+    // Use the platform-abstraction function to get the current limit safely.
+    long maxFsConnections = fs::getMaxHandles();
+
+    // Handle the case where the limit is unlimited (RLIM_INFINITY) to prevent
+    // overflow.
+    if (maxFsConnections == RLIM_INFINITY)
+    {
+        // Set a practical, safe high boundary.
+        maxFsConnections = 1000000;
+        LOG_DEBUG(DEFAULT_LOG,
+                  "RLIMIT_NOFILE is unlimited. Capping connection adjustments "
+                  "to {} for safety.",
+                  maxFsConnections);
+    }
+
+    // --- Rest of the original adjust() logic, using the safe maxFsConnections
+    // value ---
+    if (MAX_ADDITIONAL_PEER_CONNECTIONS == -1)
+    {
+        if (TARGET_PEER_CONNECTIONS <=
+            std::numeric_limits<unsigned short>::max() / 8)
+        {
+            MAX_ADDITIONAL_PEER_CONNECTIONS = TARGET_PEER_CONNECTIONS * 8;
+        }
+        else
+        {
+            MAX_ADDITIONAL_PEER_CONNECTIONS =
+                std::numeric_limits<unsigned short>::max();
+        }
+    }
+
+    // Ensure outbound connections are capped based on inbound rate
+    int limit =
+        MAX_ADDITIONAL_PEER_CONNECTIONS / OverlayManager::MIN_INBOUND_FACTOR +
+        OverlayManager::MIN_INBOUND_FACTOR;
+    if (static_cast<int>(TARGET_PEER_CONNECTIONS) > limit)
+    {
+        TARGET_PEER_CONNECTIONS = static_cast<unsigned short>(limit);
+        LOG_WARNING(DEFAULT_LOG,
+                    "Adjusted TARGET_PEER_CONNECTIONS to {} due to "
+                    "insufficient MAX_ADDITIONAL_PEER_CONNECTIONS={}",
+                    limit, MAX_ADDITIONAL_PEER_CONNECTIONS);
+    }
+
+    // Adjust connection limits based on the safe maxFsConnections
+    auto const originalMaxAdditionalPeerConnections =
+        MAX_ADDITIONAL_PEER_CONNECTIONS;
+    auto const originalTargetPeerConnections = TARGET_PEER_CONNECTIONS;
+    auto const originalMaxPendingConnections = MAX_PENDING_CONNECTIONS;
+
+    int maxFs = std::min<int>(std::numeric_limits<unsigned short>::max(),
+                              maxFsConnections);
+
+    auto totalAuthenticatedConnections =
+        TARGET_PEER_CONNECTIONS + MAX_ADDITIONAL_PEER_CONNECTIONS;
+    int maxPendingConnections = MAX_PENDING_CONNECTIONS;
+
+    if (totalAuthenticatedConnections > 0)
+    {
+        auto outboundPendingRate =
+            double(TARGET_PEER_CONNECTIONS) / totalAuthenticatedConnections;
+        auto doubleToNonzeroUnsignedShort = [](double v) {
+            auto rounded = static_cast<int>(std::ceil(v));
+            auto cappedToUnsignedShort = std::min<int>(
+                std::numeric_limits<unsigned short>::max(), rounded);
+            return static_cast<unsigned short>(
+                std::max<int>(1, cappedToUnsignedShort));
+        };
+
+        if (totalAuthenticatedConnections + maxPendingConnections > maxFs)
+        {
+            maxPendingConnections =
+                totalAuthenticatedConnections >= maxFs
+                    ? 1
+                    : static_cast<unsigned short>(
+                          maxFs - totalAuthenticatedConnections);
+        }
+
+        if (totalAuthenticatedConnections + maxPendingConnections > maxFs)
+        {
+            maxPendingConnections = std::max<int>(MAX_PENDING_CONNECTIONS, 1);
+            int totalRequiredConnections =
+                totalAuthenticatedConnections + maxPendingConnections;
+            auto outboundRate =
+                (double)TARGET_PEER_CONNECTIONS / totalRequiredConnections;
+            auto inboundRate = (double)MAX_ADDITIONAL_PEER_CONNECTIONS /
+                               totalRequiredConnections;
+
+            TARGET_PEER_CONNECTIONS =
+                doubleToNonzeroUnsignedShort(maxFs * outboundRate);
+            MAX_ADDITIONAL_PEER_CONNECTIONS =
+                doubleToNonzeroUnsignedShort(maxFs * inboundRate);
+
+            auto authenticatedConnections =
+                TARGET_PEER_CONNECTIONS + MAX_ADDITIONAL_PEER_CONNECTIONS;
+            maxPendingConnections = authenticatedConnections >= maxFs
+                                        ? 1
+                                        : static_cast<unsigned short>(
+                                              maxFs - authenticatedConnections);
+        }
+
+        MAX_PENDING_CONNECTIONS = static_cast<unsigned short>(std::min<int>(
+            std::numeric_limits<unsigned short>::max(), maxPendingConnections));
+
+        if (MAX_OUTBOUND_PENDING_CONNECTIONS == 0 &&
+            MAX_INBOUND_PENDING_CONNECTIONS == 0)
+        {
+            MAX_OUTBOUND_PENDING_CONNECTIONS = std::max<unsigned short>(
+                1, doubleToNonzeroUnsignedShort(MAX_PENDING_CONNECTIONS *
+                                                outboundPendingRate));
+            MAX_INBOUND_PENDING_CONNECTIONS = std::max<unsigned short>(
+                1, MAX_PENDING_CONNECTIONS - MAX_OUTBOUND_PENDING_CONNECTIONS);
+        }
+    }
+    else
+    {
+        MAX_OUTBOUND_PENDING_CONNECTIONS = 0;
+        MAX_INBOUND_PENDING_CONNECTIONS = 0;
+    }
+
+    auto warnIfChanged = [&](std::string const name, auto const originalValue,
+                             auto const newValue) {
+        if (originalValue != newValue)
+        {
+            LOG_WARNING(DEFAULT_LOG,
+                        "Adjusted {} from {} to {} due to OS limits (the "
+                        "maximum number of file descriptors)",
+                        name, originalValue, newValue);
+        }
+    };
+    warnIfChanged("MAX_ADDITIONAL_PEER_CONNECTIONS",
+                  originalMaxAdditionalPeerConnections,
+                  MAX_ADDITIONAL_PEER_CONNECTIONS);
+    warnIfChanged("TARGET_PEER_CONNECTIONS", originalTargetPeerConnections,
+                  TARGET_PEER_CONNECTIONS);
+    warnIfChanged("MAX_PENDING_CONNECTIONS", originalMaxPendingConnections,
+                  MAX_PENDING_CONNECTIONS);
 }
-// ================================================================
 
 void
 Config::logBasicInfo() const