bring in on_timeout from the http-retry branch

When shutdown times out, the on_timeout callback cancels the in-flight
HTTP request (via curl progress callback abort or WinHTTP handle
closure), unblocking the worker thread so it can finish remaining
tasks like cache cleanup. Fixes test_cache_max_items failing on
Windows where WinHTTP blocks for seconds on unreachable hosts.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jpnurmi

src/sentry_sync.c

@@ -425,7 +425,8 @@ shutdown_task(void *task_data, void *UNUSED(state))
 }
 
 int
-sentry__bgworker_shutdown(sentry_bgworker_t *bgw, uint64_t timeout)
+sentry__bgworker_shutdown_cb(sentry_bgworker_t *bgw, uint64_t timeout,
+    void (*on_timeout)(void *), void *on_timeout_data)
 {
     if (!sentry__atomic_fetch(&bgw->running)) {
         SENTRY_WARN("trying to shut down non-running thread");
@@ -441,12 +442,23 @@ sentry__bgworker_shutdown(sentry_bgworker_t *bgw, uint64_t timeout)
     while (true) {
         uint64_t now = sentry__monotonic_time();
         if (now > started && now - started > timeout) {
-            sentry__atomic_store(&bgw->running, 0);
-            sentry__thread_detach(bgw->thread_id);
-            sentry__mutex_unlock(&bgw->task_lock);
-            SENTRY_WARN(
-                "background thread failed to shut down cleanly within timeout");
-            return 1;
+            if (on_timeout) {
+                // fire on_timeout to cancel the ongoing task, and give the
+                // worker an extra loop cycle up to 250ms to handle the
+                // cancellation
+                sentry__mutex_unlock(&bgw->task_lock);
+                on_timeout(on_timeout_data);
+                on_timeout = NULL;
+                sentry__mutex_lock(&bgw->task_lock);
+                // fall through to !running check below
+            } else {
+                sentry__atomic_store(&bgw->running, 0);
+                sentry__thread_detach(bgw->thread_id);
+                sentry__mutex_unlock(&bgw->task_lock);
+                SENTRY_WARN("background thread failed to shut down cleanly "
+                            "within timeout");
+                return 1;
+            }
         }
 
         if (!sentry__atomic_fetch(&bgw->running)) {

src/sentry_sync.h

@@ -469,8 +469,20 @@ int sentry__bgworker_flush(sentry_bgworker_t *bgw, uint64_t timeout);
 /**
  * This will try to shut down the background worker thread, with a `timeout`.
  * Returns 0 on success.
+ *
+ * The `_cb` variant accepts an `on_timeout` callback that is invoked when
+ * the timeout expires, just before detaching the thread. This gives the
+ * caller a chance to unblock the worker (e.g. by closing transport handles)
+ * so it can finish in-flight work.
  */
-int sentry__bgworker_shutdown(sentry_bgworker_t *bgw, uint64_t timeout);
+int sentry__bgworker_shutdown_cb(sentry_bgworker_t *bgw, uint64_t timeout,
+    void (*on_timeout)(void *), void *on_timeout_data);
+
+static inline int
+sentry__bgworker_shutdown(sentry_bgworker_t *bgw, uint64_t timeout)
+{
+    return sentry__bgworker_shutdown_cb(bgw, timeout, NULL, NULL);
+}
 
 /**
  * This will set a preferable thread name for background worker.

src/transports/sentry_http_transport.c

@@ -252,6 +252,15 @@ http_send_task(void *_envelope, void *_state)
     }
 }
 
+static void
+http_transport_shutdown_timeout(void *_state)
+{
+    http_transport_state_t *state = _state;
+    if (state->shutdown_client) {
+        state->shutdown_client(state->client);
+    }
+}
+
 static int
 http_transport_start(const sentry_options_t *options, void *transport_state)
 {
@@ -288,10 +297,8 @@ http_transport_shutdown(uint64_t timeout, void *transport_state)
     sentry_bgworker_t *bgworker = transport_state;
     http_transport_state_t *state = sentry__bgworker_get_state(bgworker);
 
-    int rv = sentry__bgworker_shutdown(bgworker, timeout);
-    if (rv != 0 && state->shutdown_client) {
-        state->shutdown_client(state->client);
-    }
+    int rv = sentry__bgworker_shutdown_cb(
+        bgworker, timeout, http_transport_shutdown_timeout, state);
     return rv;
 }
 

src/transports/sentry_http_transport_curl.c

@@ -4,6 +4,7 @@
 #include "sentry_http_transport.h"
 #include "sentry_options.h"
 #include "sentry_string.h"
+#include "sentry_sync.h"
 #include "sentry_transport.h"
 #include "sentry_utils.h"
 
@@ -20,6 +21,7 @@ typedef struct {
     char *proxy;
     char *ca_certs;
     bool debug;
+    long shutdown;
 #ifdef SENTRY_PLATFORM_NX
     void *nx_state;
 #endif
@@ -117,6 +119,22 @@ curl_client_start(void *_client, const sentry_options_t *options)
     return 0;
 }
 
+static void
+curl_client_shutdown(void *_client)
+{
+    curl_client_t *client = _client;
+    sentry__atomic_store(&client->shutdown, 1);
+}
+
+static int
+progress_callback(void *clientp, curl_off_t UNUSED(dltotal),
+    curl_off_t UNUSED(dlnow), curl_off_t UNUSED(ultotal),
+    curl_off_t UNUSED(ulnow))
+{
+    curl_client_t *client = clientp;
+    return sentry__atomic_fetch(&client->shutdown) ? 1 : 0;
+}
+
 static size_t
 swallow_data(
     char *UNUSED(ptr), size_t size, size_t nmemb, void *UNUSED(userdata))
@@ -189,6 +207,10 @@ curl_send_task(void *_client, sentry_prepared_http_request_t *req,
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, req->body);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)req->body_len);
     curl_easy_setopt(curl, CURLOPT_USERAGENT, SENTRY_SDK_USER_AGENT);
+    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, 15000L);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+    curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, progress_callback);
+    curl_easy_setopt(curl, CURLOPT_XFERINFODATA, client);
 
     char error_buf[CURL_ERROR_SIZE];
     error_buf[0] = 0;
@@ -253,5 +275,6 @@ sentry__transport_new_default(void)
     }
     sentry__http_transport_set_free_client(transport, curl_client_free);
     sentry__http_transport_set_start_client(transport, curl_client_start);
+    sentry__http_transport_set_shutdown_client(transport, curl_client_shutdown);
     return transport;
 }

src/transports/sentry_http_transport_winhttp.c

@@ -134,6 +134,9 @@ winhttp_client_start(void *_client, const sentry_options_t *opts)
         return 1;
     }
 
+    // 15s resolve/connect, 30s send/receive (WinHTTP defaults)
+    WinHttpSetTimeouts(client->session, 15000, 15000, 30000, 30000);
+
     return 0;
 }
 
@@ -154,9 +157,9 @@ winhttp_client_shutdown(void *_client)
         WinHttpCloseHandle(client->session);
         client->session = NULL;
     }
-    if (client->request) {
-        WinHttpCloseHandle(client->request);
-        client->request = NULL;
+    HINTERNET request = InterlockedExchangePointer(&client->request, NULL);
+    if (request) {
+        WinHttpCloseHandle(request);
     }
 }
 
@@ -302,10 +305,9 @@ winhttp_send_task(void *_client, sentry_prepared_http_request_t *req,
     uint64_t now = sentry__monotonic_time();
     SENTRY_DEBUGF("request handled in %llums", now - started);
 
-exit:
-    if (client->request) {
-        HINTERNET request = client->request;
-        client->request = NULL;
+exit:;
+    HINTERNET request = InterlockedExchangePointer(&client->request, NULL);
+    if (request) {
         WinHttpCloseHandle(request);
     }
     sentry_free(url);