Fix Config::adjust() overflow for unlimited RLIMIT_NOFILE (Closes #5244)

src/main/Config.cpp

@@ -2214,8 +2214,25 @@ Config::processConfig(std::shared_ptr<cpptoml::table> t)
 }
 
 void
-Config::adjust()
+Config::adjust() void Config::adjust()
 {
+    // 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 <=
@@ -2243,24 +2260,23 @@ Config::adjust()
                     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 maxFsConnections = std::min<int>(
-        std::numeric_limits<unsigned short>::max(), fs::getMaxHandles());
+    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>(
@@ -2269,51 +2285,41 @@ Config::adjust()
                 std::max<int>(1, cappedToUnsignedShort));
         };
 
-        // see if we need to reduce maxPendingConnections
-        if (totalAuthenticatedConnections + maxPendingConnections >
-            maxFsConnections)
+        if (totalAuthenticatedConnections + maxPendingConnections > maxFs)
         {
             maxPendingConnections =
-                totalAuthenticatedConnections >= maxFsConnections
+                totalAuthenticatedConnections >= maxFs
                     ? 1
                     : static_cast<unsigned short>(
-                          maxFsConnections - totalAuthenticatedConnections);
+                          maxFs - totalAuthenticatedConnections);
         }
 
-        // if we're still over, we scale everything
-        if (totalAuthenticatedConnections + maxPendingConnections >
-            maxFsConnections)
+        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(maxFsConnections * outboundRate);
+                doubleToNonzeroUnsignedShort(maxFs * outboundRate);
             MAX_ADDITIONAL_PEER_CONNECTIONS =
-                doubleToNonzeroUnsignedShort(maxFsConnections * inboundRate);
+                doubleToNonzeroUnsignedShort(maxFs * inboundRate);
 
             auto authenticatedConnections =
                 TARGET_PEER_CONNECTIONS + MAX_ADDITIONAL_PEER_CONNECTIONS;
-            maxPendingConnections =
-                authenticatedConnections >= maxFsConnections
-                    ? 1
-                    : static_cast<unsigned short>(maxFsConnections -
-                                                  authenticatedConnections);
+            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));
 
-        // derive outbound/inbound pending connections
-        // from MAX_PENDING_CONNECTIONS, using the ratio of inbound/outbound
-        // connections
         if (MAX_OUTBOUND_PENDING_CONNECTIONS == 0 &&
             MAX_INBOUND_PENDING_CONNECTIONS == 0)
         {
@@ -2329,6 +2335,7 @@ Config::adjust()
         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)