Use a fixed deadline in the native connect timeout

awaitConnectComplete reset its time baseline (start = now) on every EINTR
and subtracted only whole milliseconds of elapsed time. Under a
high-frequency signal storm on the connecting thread -- e.g. a wall-clock
profiler or interval timer interrupting the blocked poll() more than once
per millisecond -- each interval truncated to 0 ms, so the budget never
decremented and poll() was re-armed with the full timeout every
iteration. The connect timeout could then extend well past its bound, or
never fire at all, contradicting the comment that EINTR storms cannot
extend it. Even at lower rates each interrupt discarded up to ~1 ms of
accounting, drifting the timeout one-directionally.

Compute one absolute monotonic deadline up front and derive the remaining
poll() budget from it each iteration. The remaining time can only
decrease, so the timeout is a strict upper bound regardless of interrupt
frequency; truncation now only under-shoots the final poll by < 1 ms,
which never extends the wait. The success, refused, and timeout paths are
otherwise unchanged.

Validated: NetConnectTimeoutTest (loopback success, refused-vs-timeout,
black-hole timeout within budget) passes against the rebuilt library. A
standalone harness driving the old vs new logic under a simulated 2.5 kHz
EINTR storm confirms the old logic runs unbounded (aborted at >10x the
budget) while the new logic returns at the budget. A deterministic
regression test at the JNI layer is not practical: Java cannot target a
POSIX signal at the specific connecting thread, and the only hanging-
connect fixture available (TEST-NET-1 black-hole) is routing-dependent
and already Assume-skipped on most runners.

Rebuilds the committed linux-x86-64 libquestdb.so from the net.c change
(mirrors the copy step in ci.yml); other platforms are refreshed by the
rebuild-native-libs workflow.

Author: bluestreak01

core/src/main/c/share/net.c

@@ -306,17 +306,42 @@ JNIEXPORT jint JNICALL Java_io_questdb_client_network_Net_connectAddrInfo
 // caller can read it via Os.errno()), or com_questdb_network_Net_ECONNTIMEOUT
 // on timeout.
 static jint awaitConnectComplete(int fd, jint timeout_millis) {
-    struct timespec start;
-    clock_gettime(CLOCK_MONOTONIC, &start);
+    // Fix a single absolute deadline up front. Recomputing the remaining budget
+    // against a moving baseline on each EINTR (reset start = now, then subtract
+    // whole milliseconds) lets a high-frequency signal storm extend the timeout:
+    // under sub-millisecond interrupts every interval truncates to 0 ms, the
+    // budget never decrements, and poll is re-armed with the full budget each
+    // time. A fixed deadline is immune to interrupt frequency -- the remaining
+    // time can only ever decrease.
+    struct timespec deadline;
+    clock_gettime(CLOCK_MONOTONIC, &deadline);
+    long budget_millis = timeout_millis > 0 ? timeout_millis : 0;
+    deadline.tv_sec += budget_millis / 1000L;
+    deadline.tv_nsec += (budget_millis % 1000L) * 1000000L;
+    if (deadline.tv_nsec >= 1000000000L) {
+        deadline.tv_sec += 1;
+        deadline.tv_nsec -= 1000000000L;
+    }
 
     for (;;) {
+        struct timespec now;
+        clock_gettime(CLOCK_MONOTONIC, &now);
+        // Remaining time until the deadline, truncated to whole milliseconds for
+        // poll(). Truncation only ever under-shoots by < 1 ms (it never extends
+        // the wait), which keeps the timeout a strict upper bound.
+        long remaining_millis = (deadline.tv_sec - now.tv_sec) * 1000L
+                                + (deadline.tv_nsec - now.tv_nsec) / 1000000L;
+        if (remaining_millis <= 0) {
+            errno = ETIMEDOUT;
+            return com_questdb_network_Net_ECONNTIMEOUT;
+        }
+
         struct pollfd pfd;
         pfd.fd = fd;
         pfd.events = POLLOUT;
         pfd.revents = 0;
 
-        int wait_millis = timeout_millis > 0 ? timeout_millis : 0;
-        int rc = poll(&pfd, 1, wait_millis);
+        int rc = poll(&pfd, 1, (int) remaining_millis);
         if (rc > 0) {
             // The connect attempt has finished one way or another; the only
             // authoritative result is SO_ERROR (POLLOUT alone does not mean
@@ -339,18 +364,8 @@ static jint awaitConnectComplete(int fd, jint timeout_millis) {
         if (errno != EINTR) {
             return -1;
         }
-        // Interrupted by a signal: recompute the remaining budget against a
-        // monotonic clock so EINTR storms cannot extend the timeout, and retry.
-        struct timespec now;
-        clock_gettime(CLOCK_MONOTONIC, &now);
-        long elapsed = (now.tv_sec - start.tv_sec) * 1000L
-                       + (now.tv_nsec - start.tv_nsec) / 1000000L;
-        start = now;
-        timeout_millis = (jint) (timeout_millis - elapsed);
-        if (timeout_millis <= 0) {
-            errno = ETIMEDOUT;
-            return com_questdb_network_Net_ECONNTIMEOUT;
-        }
+        // Interrupted by a signal: loop and recompute the remaining time against
+        // the fixed deadline. EINTR storms cannot extend the timeout.
     }
 }