fix(fetch): add partial support for abort signals during DNS resolution

This commit adds infrastructure to handle abort signals during DNS resolution
and connection establishment, but the fix is incomplete.

Changes:
- Add abort signal checks before and after connection attempts
- Export Bun__http_isAsyncHTTPAborted() to check abort status from C
- Add async_http_id field to us_connecting_socket_t for tracking
- Check for abort after DNS resolution completes in us_internal_socket_after_resolve()
- Add comprehensive tests for various abort scenarios

Known issues:
- async_http_id is not properly passed through socket extension data
- DNS resolution in work pool doesn't actively check for abort signals
- Connection timeout needs better integration with abort signal system

The current implementation improves abort handling but doesn't fully fix
the issue where DNS resolution can block for 135+ seconds ignoring timeouts.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

packages/bun-usockets/src/context.c

@@ -548,6 +548,7 @@ void *us_socket_context_connect(int ssl, struct us_socket_context_t *context, co
     c->long_timeout = 255;
     c->pending_resolve_callback = 1;
     c->port = port;
+    c->async_http_id = 0; // Will be set later if needed
     us_internal_socket_context_link_connecting_socket(ssl, context, c);
 
 #ifdef _WIN32
@@ -604,6 +605,9 @@ int start_connections(struct us_connecting_socket_t *c, int count) {
     return opened;
 }
 
+// External function to check if an async_http_id has been aborted
+extern int Bun__http_isAsyncHTTPAborted(uint32_t async_http_id);
+
 void us_internal_socket_after_resolve(struct us_connecting_socket_t *c) {
     // make sure to decrement the active_handles counter, no matter what
 #ifdef _WIN32
@@ -613,6 +617,14 @@ void us_internal_socket_after_resolve(struct us_connecting_socket_t *c) {
 #endif
 
     c->pending_resolve_callback = 0;
+
+    // Check if this connection was aborted during DNS resolution
+    if (c->async_http_id != 0 && Bun__http_isAsyncHTTPAborted(c->async_http_id)) {
+        c->closed = 1;
+        us_connecting_socket_free(c->ssl, c);
+        return;
+    }
+
     // if the socket was closed while we were resolving the address, free it
     if (c->closed) {
         us_connecting_socket_free(c->ssl, c);

packages/bun-usockets/src/internal/internal.h

@@ -202,6 +202,8 @@ struct us_connecting_socket_t {
     // this is used to track pending connecting sockets in the context
     struct us_connecting_socket_t* next_pending;
     struct us_connecting_socket_t* prev_pending;
+    // Track async_http_id for abort signal handling during connection
+    uint32_t async_http_id;
 };
 
 struct us_wrapped_socket_context_t {

src/http.zig

@@ -119,6 +119,15 @@ pub fn unregisterAbortTracker(
     }
 }
 
+pub fn isAsyncHTTPAborted(async_http_id: u32) bool {
+    // Check if this async_http_id has been marked for abort
+    return socket_async_http_abort_tracker.get(async_http_id) != null;
+}
+
+export fn Bun__http_isAsyncHTTPAborted(async_http_id: u32) bool {
+    return isAsyncHTTPAborted(async_http_id);
+}
+
 pub fn onOpen(
     client: *HTTPClient,
     comptime is_ssl: bool,

src/http/HTTPContext.zig

@@ -476,6 +476,11 @@ pub fn NewHTTPContext(comptime ssl: bool) type {
                 }
             }
 
+            // Check for abort before starting connection
+            if (client.signals.get(.aborted)) {
+                return error.AbortedBeforeConnecting;
+            }
+
             const socket = try HTTPSocket.connectAnon(
                 hostname,
                 port,
@@ -483,6 +488,15 @@ pub fn NewHTTPContext(comptime ssl: bool) type {
                 ActiveSocket.init(client).ptr(),
                 false,
             );
+
+            // Check for abort after DNS resolution/connection attempt
+            if (client.signals.get(.aborted)) {
+                if (socket.isClosed() == false) {
+                    socket.close(.failure);
+                }
+                return error.AbortedDuringConnect;
+            }
+
             client.allow_retry = false;
             return socket;
         }

test-abort-hang.js

@@ -0,0 +1,83 @@
+// Test abort signal with various hanging scenarios
+import { createServer } from "net";
+
+// Test 1: Server that accepts connection but never responds
+async function testHangingServer() {
+  const server = createServer((socket) => {
+    console.log("Client connected, but not responding...");
+    // Never send any data - just keep the connection open
+  });
+
+  await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
+  const port = server.address().port;
+
+  console.log("=== Test 1: Server accepts but never responds ===");
+  console.time("fetch-hanging");
+  try {
+    await fetch(`http://127.0.0.1:${port}`, {
+      signal: AbortSignal.timeout(1000),
+    });
+  } catch (error) {
+    console.log("Error:", error.name, error.message);
+  } finally {
+    console.timeEnd("fetch-hanging");
+    server.close();
+  }
+}
+
+// Test 2: IP address that doesn't exist (connection timeout)
+async function testNonRoutableIP() {
+  console.log("\n=== Test 2: Non-routable IP (should hang on connect) ===");
+  console.time("fetch-nonroutable");
+  try {
+    // Using a non-routable IP that will cause connection to hang
+    await fetch("http://10.255.255.254:8080", {
+      signal: AbortSignal.timeout(1000),
+    });
+  } catch (error) {
+    console.log("Error:", error.name, error.message);
+  } finally {
+    console.timeEnd("fetch-nonroutable");
+  }
+}
+
+// Test 3: The original problematic domain
+async function testSlowDNS() {
+  console.log("\n=== Test 3: Domain with slow DNS (original issue) ===");
+  console.time("fetch-slowdns");
+  try {
+    await fetch("http://univ-toulouse.fr", {
+      signal: AbortSignal.timeout(1000),
+    });
+  } catch (error) {
+    console.log("Error:", error.name, error.message);
+  } finally {
+    console.timeEnd("fetch-slowdns");
+  }
+}
+
+// Test 4: Server that never accepts connections (DROP packets)
+async function testDroppedPackets() {
+  console.log("\n=== Test 4: Simulated dropped packets (iptables would be needed) ===");
+  console.time("fetch-dropped");
+  try {
+    // This IP is in the TEST-NET-3 range (reserved for documentation)
+    // Packets to this should be dropped by most routers
+    await fetch("http://203.0.113.1:8080", {
+      signal: AbortSignal.timeout(1000),
+    });
+  } catch (error) {
+    console.log("Error:", error.name, error.message);
+  } finally {
+    console.timeEnd("fetch-dropped");
+  }
+}
+
+// Run all tests
+console.log("Testing abort signal behavior in different scenarios...\n");
+await testHangingServer();
+await testNonRoutableIP();
+await testSlowDNS();
+await testDroppedPackets();
+
+console.log("\n✅ All tests completed");

test-dns-slow.js

@@ -0,0 +1,56 @@
+// Test script to reproduce slow DNS with abort signal
+import { createServer } from "dgram";
+import { spawn } from "child_process";
+
+// Create a UDP server that acts as a slow DNS server
+const dnsServer = createServer("udp4");
+
+dnsServer.on("message", (msg, rinfo) => {
+  console.log(`DNS query received from ${rinfo.address}:${rinfo.port}`);
+
+  // Intentionally delay the DNS response by 5 seconds
+  // This simulates a very slow DNS resolution
+  setTimeout(() => {
+    // For simplicity, we're not sending a proper DNS response
+    // which will cause the resolver to timeout/fail eventually
+    console.log("Would send DNS response now (but we won't to force timeout)");
+  }, 5000);
+});
+
+dnsServer.bind(15353, "127.0.0.1", () => {
+  console.log("Slow DNS server listening on 127.0.0.1:15353");
+
+  // Now test fetch with a custom DNS resolver pointing to our slow server
+  testFetchWithAbort();
+});
+
+async function testFetchWithAbort() {
+  console.log("\n=== Testing fetch with abort signal (1 second timeout) ===");
+
+  // We need to test with a domain that will use our slow DNS
+  // This requires system-level DNS configuration which is complex
+  // Instead, let's test with a direct approach
+
+  console.time("fetch-with-abort");
+  try {
+    // Using a domain that's likely to have slow DNS resolution
+    // or we can use a non-routable IP that will hang
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      console.log("Aborting fetch due to timeout");
+      controller.abort();
+    }, 1000);
+
+    const response = await fetch("http://10.255.255.254:8080", {
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+    console.log("Fetch succeeded:", response.status);
+  } catch (error) {
+    console.log("Fetch error:", error.name, error.message);
+  } finally {
+    console.timeEnd("fetch-with-abort");
+    dnsServer.close();
+  }
+}

test/regression/issue/test-fetch-abort-dns.test.ts

@@ -0,0 +1,109 @@
+import { test, expect } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { createServer } from "net";
+
+test("fetch aborts during slow DNS resolution", async () => {
+  // Test with a non-routable IP that causes connection to hang
+  const startTime = performance.now();
+
+  try {
+    await fetch("http://10.255.255.254:8080", {
+      signal: AbortSignal.timeout(1000),
+    });
+    expect.unreachable("Fetch should have been aborted");
+  } catch (error: any) {
+    const duration = performance.now() - startTime;
+
+    // Should abort within 1.5 seconds (1s timeout + some overhead)
+    expect(duration).toBeLessThan(1500);
+    expect(error.name).toBe("TimeoutError");
+    expect(error.message).toContain("timed out");
+  }
+}, 10000);
+
+test("fetch aborts during DNS resolution with explicit abort", async () => {
+  const controller = new AbortController();
+
+  // Start fetch to a non-routable address
+  const fetchPromise = fetch("http://203.0.113.1:8080", {
+    signal: controller.signal,
+  });
+
+  // Abort after 500ms
+  const timeoutId = setTimeout(() => controller.abort(), 500);
+
+  const startTime = performance.now();
+
+  try {
+    await fetchPromise;
+    expect.unreachable("Fetch should have been aborted");
+  } catch (error: any) {
+    clearTimeout(timeoutId);
+    const duration = performance.now() - startTime;
+
+    // Should abort within 1 second
+    expect(duration).toBeLessThan(1000);
+    expect(error.name).toBe("AbortError");
+  }
+}, 10000);
+
+test("fetch aborts when server accepts but doesn't respond", async () => {
+  // Create a server that accepts connections but never responds
+  const server = createServer((socket) => {
+    // Just keep the connection open, don't send any data
+  });
+
+  await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+  const port = (server.address() as any).port;
+
+  const startTime = performance.now();
+
+  try {
+    await fetch(`http://127.0.0.1:${port}`, {
+      signal: AbortSignal.timeout(1000),
+    });
+    expect.unreachable("Fetch should have timed out");
+  } catch (error: any) {
+    const duration = performance.now() - startTime;
+
+    // Should timeout within 1.5 seconds
+    expect(duration).toBeLessThan(1500);
+    expect(error.name).toBe("TimeoutError");
+  } finally {
+    server.close();
+  }
+}, 10000);
+
+test("fetch respects abort signal during redirect to slow host", async () => {
+  // Create a server that redirects to a non-routable address
+  const server = createServer((socket) => {
+    socket.write(
+      "HTTP/1.1 302 Found\r\n" +
+      "Location: http://10.255.255.254:8080/redirected\r\n" +
+      "Content-Length: 0\r\n" +
+      "\r\n"
+    );
+    socket.end();
+  });
+
+  await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+  const port = (server.address() as any).port;
+
+  const startTime = performance.now();
+
+  try {
+    await fetch(`http://127.0.0.1:${port}`, {
+      signal: AbortSignal.timeout(1000),
+      redirect: "follow",
+    });
+    expect.unreachable("Fetch should have been aborted during redirect");
+  } catch (error: any) {
+    const duration = performance.now() - startTime;
+
+    // Should abort within 1.5 seconds
+    expect(duration).toBeLessThan(1500);
+    expect(error.name).toBe("TimeoutError");
+  } finally {
+    server.close();
+  }
+}, 10000);