v25.11.6

changelog.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 2026-03-16 - 25.11.6 - fix(rustproxy-http,rustproxy-passthrough)
+improve upstream connection cleanup and graceful tunnel shutdown
+
+- Evict pooled HTTP/2 connections when their driver exits and shorten the maximum pooled H2 age to reduce reuse of stale upstream connections.
+- Strip hop-by-hop headers from backend responses before forwarding to HTTP/2 clients to avoid invalid H2 response handling.
+- Replace immediate task aborts in WebSocket and TCP tunnel watchdogs with cancellation-driven graceful shutdown plus timed fallback aborts.
+- Use non-blocking semaphore acquisition in the TCP listener so connection limits do not stall the accept loop for the entire port.
+
+## 2026-03-16 - 25.11.5 - fix(repo)
+no changes to commit
+
+
+## 2026-03-15 - 25.11.4 - fix(rustproxy-http)
+report streamed HTTP and WebSocket bytes per chunk for real-time throughput metrics
+
+- Update CountingBody to record bytes immediately on each data frame instead of aggregating until completion or drop
+- Record WebSocket tunnel traffic inside both copy loops and remove the final aggregate byte report to keep throughput metrics current
+
+## 2026-03-15 - 25.11.3 - fix(repo)
+no changes to commit
+
+
+## 2026-03-15 - 25.11.2 - fix(rustproxy-http)
+avoid reusing HTTP/1 senders during streaming responses and relax HTTP/2 keep-alive timeouts
+
+- Stop returning HTTP/1 senders to the connection pool before upstream response bodies finish streaming to prevent unsafe reuse on active connections.
+- Increase HTTP/2 keep-alive timeout from 5 seconds to 30 seconds in proxy connection builders to better support longer-lived backend streams.
+- Improves reliability for large streaming payloads and backend fallback request handling.
+
 ## 2026-03-15 - 25.11.1 - fix(rustproxy-http)
 keep connection idle tracking alive during streaming and tune HTTP/2 connection lifetimes
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "25.11.1",
+  "version": "25.11.6",
   "private": false,
   "description": "A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",

rust/crates/rustproxy-http/src/connection_pool.rs

@@ -20,7 +20,8 @@ const IDLE_TIMEOUT: Duration = Duration::from_secs(90);
 const EVICTION_INTERVAL: Duration = Duration::from_secs(30);
 /// Maximum age for pooled HTTP/2 connections before proactive eviction.
 /// Prevents staleness from backends that close idle connections (e.g. nginx GOAWAY).
-const MAX_H2_AGE: Duration = Duration::from_secs(300);
+/// 120s is well within typical server GOAWAY windows (nginx: ~60s idle, envoy: ~60s).
+const MAX_H2_AGE: Duration = Duration::from_secs(120);
 
 /// Identifies a unique backend endpoint.
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]

rust/crates/rustproxy-http/src/counting_body.rs

@@ -11,20 +11,17 @@ use rustproxy_metrics::MetricsCollector;
 
 /// Wraps any `http_body::Body` and counts data bytes passing through.
 ///
-/// When the body is fully consumed or dropped, accumulated byte counts
-/// are reported to the `MetricsCollector`.
+/// Each chunk is reported to the `MetricsCollector` immediately so that
+/// the throughput tracker (sampled at 1 Hz) reflects real-time data flow.
 ///
 /// The inner body is pinned on the heap to support `!Unpin` types like `hyper::body::Incoming`.
 pub struct CountingBody<B> {
     inner: Pin<Box<B>>,
-    counted_bytes: AtomicU64,
     metrics: Arc<MetricsCollector>,
     route_id: Option<String>,
     source_ip: Option<String>,
     /// Whether we count bytes as "in" (request body) or "out" (response body).
     direction: Direction,
-    /// Whether we've already reported the bytes (to avoid double-reporting on drop).
-    reported: bool,
     /// Optional connection-level activity tracker. When set, poll_frame updates this
     /// to keep the idle watchdog alive during active body streaming (uploads/downloads).
     connection_activity: Option<Arc<AtomicU64>>,
@@ -52,12 +49,10 @@ impl<B> CountingBody<B> {
     ) -> Self {
         Self {
             inner: Box::pin(inner),
-            counted_bytes: AtomicU64::new(0),
             metrics,
             route_id,
             source_ip,
             direction,
-            reported: false,
             connection_activity: None,
             activity_start: None,
         }
@@ -72,33 +67,18 @@ impl<B> CountingBody<B> {
         self
     }
 
-    /// Report accumulated bytes to the metrics collector.
-    fn report(&mut self) {
-        if self.reported {
-            return;
-        }
-        self.reported = true;
-
-        let bytes = self.counted_bytes.load(Ordering::Relaxed);
-        if bytes == 0 {
-            return;
-        }
-
+    /// Report a chunk of bytes immediately to the metrics collector.
+    #[inline]
+    fn report_chunk(&self, len: u64) {
         let route_id = self.route_id.as_deref();
         let source_ip = self.source_ip.as_deref();
         match self.direction {
-            Direction::In => self.metrics.record_bytes(bytes, 0, route_id, source_ip),
-            Direction::Out => self.metrics.record_bytes(0, bytes, route_id, source_ip),
+            Direction::In => self.metrics.record_bytes(len, 0, route_id, source_ip),
+            Direction::Out => self.metrics.record_bytes(0, len, route_id, source_ip),
         }
     }
 }
 
-impl<B> Drop for CountingBody<B> {
-    fn drop(&mut self) {
-        self.report();
-    }
-}
-
 // CountingBody is Unpin because inner is Pin<Box<B>> (always Unpin).
 impl<B> Unpin for CountingBody<B> {}
 
@@ -118,7 +98,9 @@ where
         match this.inner.as_mut().poll_frame(cx) {
             Poll::Ready(Some(Ok(frame))) => {
                 if let Some(data) = frame.data_ref() {
-                    this.counted_bytes.fetch_add(data.len() as u64, Ordering::Relaxed);
+                    let len = data.len() as u64;
+                    // Report bytes immediately so the 1 Hz throughput sampler sees them
+                    this.report_chunk(len);
                     // Keep the connection-level idle watchdog alive during body streaming
                     if let (Some(activity), Some(start)) = (&this.connection_activity, &this.activity_start) {
                         activity.store(start.elapsed().as_millis() as u64, Ordering::Relaxed);
@@ -127,11 +109,7 @@ where
                 Poll::Ready(Some(Ok(frame)))
             }
             Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
-            Poll::Ready(None) => {
-                // Body is fully consumed — report now
-                this.report();
-                Poll::Ready(None)
-            }
+            Poll::Ready(None) => Poll::Ready(None),
             Poll::Pending => Poll::Pending,
         }
     }

rust/crates/rustproxy-http/src/proxy_service.rs

@@ -910,8 +910,15 @@ impl HttpProxyService {
             }
         };
 
-        // Return sender to pool (body streams lazily, sender is reusable once response head is received)
-        self.connection_pool.checkin_h1(pool_key.clone(), sender);
+        // Note: we do NOT return the sender to the pool here because the response body
+        // hasn't been fully streamed yet. Pooling a sender while its response body is still
+        // in-flight risks another request being dispatched on the same connection if is_ready()
+        // momentarily returns true between chunks. The sender is dropped after this scope,
+        // and the backend connection remains alive via the spawned conn driver task until
+        // the response body finishes streaming.
+        // For small/empty responses, the sender could theoretically be reused, but the safety
+        // of large streaming responses (e.g. 352MB Docker layers) takes priority.
+        drop(sender);
 
         self.build_streaming_response(upstream_response, route, route_id, source_ip, conn_activity).await
     }
@@ -939,7 +946,7 @@ impl HttpProxyService {
         h2_builder
             .timer(hyper_util::rt::TokioTimer::new())
             .keep_alive_interval(std::time::Duration::from_secs(10))
-            .keep_alive_timeout(std::time::Duration::from_secs(5))
+            .keep_alive_timeout(std::time::Duration::from_secs(30))
             .initial_stream_window_size(2 * 1024 * 1024)
             .initial_connection_window_size(16 * 1024 * 1024);
         let (sender, conn): (
@@ -959,11 +966,18 @@ impl HttpProxyService {
             }
         };
 
-        tokio::spawn(async move {
-            if let Err(e) = conn.await {
-                debug!("HTTP/2 upstream connection error: {}", e);
-            }
-        });
+        // Spawn the H2 connection driver; proactively evict from pool on exit
+        // so the next request gets a fresh connection instead of a dead sender.
+        {
+            let pool = Arc::clone(&self.connection_pool);
+            let key = pool_key.clone();
+            tokio::spawn(async move {
+                if let Err(e) = conn.await {
+                    debug!("HTTP/2 upstream connection error: {}", e);
+                }
+                pool.remove_h2(&key);
+            });
+        }
 
         // Clone sender for potential pool registration; register only after first request succeeds
         let sender_for_pool = sender.clone();
@@ -1082,7 +1096,7 @@ impl HttpProxyService {
         h2_builder
             .timer(hyper_util::rt::TokioTimer::new())
             .keep_alive_interval(std::time::Duration::from_secs(10))
-            .keep_alive_timeout(std::time::Duration::from_secs(5))
+            .keep_alive_timeout(std::time::Duration::from_secs(30))
             .initial_stream_window_size(2 * 1024 * 1024)
             .initial_connection_window_size(16 * 1024 * 1024);
         let (mut sender, conn): (
@@ -1104,11 +1118,17 @@ impl HttpProxyService {
             }
         };
 
-        tokio::spawn(async move {
-            if let Err(e) = conn.await {
-                debug!("H2 retry: upstream connection error: {}", e);
-            }
-        });
+        // Spawn the H2 connection driver; proactively evict from pool on exit.
+        {
+            let pool = Arc::clone(&self.connection_pool);
+            let key = pool_key.clone();
+            tokio::spawn(async move {
+                if let Err(e) = conn.await {
+                    debug!("H2 retry: upstream connection error: {}", e);
+                }
+                pool.remove_h2(&key);
+            });
+        }
 
         // Build request with empty body using absolute URI for H2 pseudo-headers
         let scheme = if pool_key.use_tls { "https" } else { "http" };
@@ -1178,7 +1198,7 @@ impl HttpProxyService {
         h2_builder
             .timer(hyper_util::rt::TokioTimer::new())
             .keep_alive_interval(std::time::Duration::from_secs(10))
-            .keep_alive_timeout(std::time::Duration::from_secs(5))
+            .keep_alive_timeout(std::time::Duration::from_secs(30))
             .initial_stream_window_size(2 * 1024 * 1024)
             .initial_connection_window_size(16 * 1024 * 1024);
         let handshake_result = tokio::time::timeout(
@@ -1227,11 +1247,17 @@ impl HttpProxyService {
                 }
             }
             Ok(Ok((mut sender, conn))) => {
-                tokio::spawn(async move {
-                    if let Err(e) = conn.await {
-                        debug!("HTTP/2 upstream connection error: {}", e);
-                    }
-                });
+                // Spawn the H2 connection driver; proactively evict from pool on exit.
+                {
+                    let pool = Arc::clone(&self.connection_pool);
+                    let key = pool_key.clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = conn.await {
+                            debug!("HTTP/2 upstream connection error: {}", e);
+                        }
+                        pool.remove_h2(&key);
+                    });
+                }
 
                 // Save retry state before consuming parts/body (for bodyless requests like GET)
                 // Clone BEFORE removing Host — H1 fallback needs Host header
@@ -1425,8 +1451,8 @@ impl HttpProxyService {
             }
         };
 
-        // Return sender to pool for keep-alive reuse
-        self.connection_pool.checkin_h1(pool_key.clone(), sender);
+        // Don't pool the sender while response body is still streaming (same safety as forward_h1_with_sender)
+        drop(sender);
 
         self.build_streaming_response(upstream_response, route, route_id, source_ip, conn_activity).await
     }
@@ -1571,6 +1597,19 @@ impl HttpProxyService {
 
         if let Some(headers) = response.headers_mut() {
             *headers = resp_parts.headers;
+
+            // Strip hop-by-hop headers from the backend response.
+            // RFC 9113 §8.2.2 forbids connection-specific headers in HTTP/2 responses;
+            // forwarding them from an H1 backend can cause H2 stream resets.
+            // Mirrors the request-path stripping at the forward methods above.
+            headers.remove("connection");
+            headers.remove("keep-alive");
+            headers.remove("proxy-connection");
+            headers.remove("transfer-encoding");
+            headers.remove("te");
+            headers.remove("trailer");
+            // Note: "upgrade" is intentionally kept — needed for WebSocket 101 responses.
+
             ResponseFilter::apply_headers(route, headers, None);
         }
 
@@ -1906,59 +1945,89 @@ impl HttpProxyService {
             let last_activity = Arc::new(AtomicU64::new(0));
             let start = std::time::Instant::now();
 
+            // Per-connection cancellation token: the watchdog cancels this instead of
+            // aborting tasks, so the copy loops can shut down gracefully (TLS close_notify).
+            let ws_cancel = CancellationToken::new();
+
             // For H2 WebSocket: also update the connection-level activity tracker
             // to prevent the idle watchdog from killing the H2 connection
             let conn_act_c2u = conn_activity.as_ref().map(|ca| (Arc::clone(&ca.last_activity), ca.start));
             let conn_act_u2c = conn_activity.as_ref().map(|ca| (Arc::clone(&ca.last_activity), ca.start));
 
             let la1 = Arc::clone(&last_activity);
+            let metrics_c2u = Arc::clone(&metrics);
+            let route_c2u = route_id_owned.clone();
+            let ip_c2u = source_ip_owned.clone();
+            let wsc1 = ws_cancel.clone();
             let c2u = tokio::spawn(async move {
                 let mut buf = vec![0u8; 65536];
                 let mut total = 0u64;
                 loop {
-                    let n = match cr.read(&mut buf).await {
-                        Ok(0) | Err(_) => break,
-                        Ok(n) => n,
+                    let n = tokio::select! {
+                        result = cr.read(&mut buf) => match result {
+                            Ok(0) | Err(_) => break,
+                            Ok(n) => n,
+                        },
+                        _ = wsc1.cancelled() => break,
                     };
                     if uw.write_all(&buf[..n]).await.is_err() {
                         break;
                     }
                     total += n as u64;
+                    metrics_c2u.record_bytes(n as u64, 0, route_c2u.as_deref(), Some(&ip_c2u));
                     la1.store(start.elapsed().as_millis() as u64, Ordering::Relaxed);
                     if let Some((ref ca, ca_start)) = conn_act_c2u {
                         ca.store(ca_start.elapsed().as_millis() as u64, Ordering::Relaxed);
                     }
                 }
-                let _ = uw.shutdown().await;
+                // Graceful shutdown with timeout (sends TLS close_notify / TCP FIN)
+                let _ = tokio::time::timeout(
+                    std::time::Duration::from_secs(2),
+                    uw.shutdown(),
+                ).await;
                 total
             });
 
             let la2 = Arc::clone(&last_activity);
+            let metrics_u2c = Arc::clone(&metrics);
+            let route_u2c = route_id_owned.clone();
+            let ip_u2c = source_ip_owned.clone();
+            let wsc2 = ws_cancel.clone();
             let u2c = tokio::spawn(async move {
                 let mut buf = vec![0u8; 65536];
                 let mut total = 0u64;
                 loop {
-                    let n = match ur.read(&mut buf).await {
-                        Ok(0) | Err(_) => break,
-                        Ok(n) => n,
+                    let n = tokio::select! {
+                        result = ur.read(&mut buf) => match result {
+                            Ok(0) | Err(_) => break,
+                            Ok(n) => n,
+                        },
+                        _ = wsc2.cancelled() => break,
                     };
                     if cw.write_all(&buf[..n]).await.is_err() {
                         break;
                     }
                     total += n as u64;
+                    metrics_u2c.record_bytes(0, n as u64, route_u2c.as_deref(), Some(&ip_u2c));
                     la2.store(start.elapsed().as_millis() as u64, Ordering::Relaxed);
                     if let Some((ref ca, ca_start)) = conn_act_u2c {
                         ca.store(ca_start.elapsed().as_millis() as u64, Ordering::Relaxed);
                     }
                 }
-                let _ = cw.shutdown().await;
+                // Graceful shutdown with timeout (sends TLS close_notify / TCP FIN)
+                let _ = tokio::time::timeout(
+                    std::time::Duration::from_secs(2),
+                    cw.shutdown(),
+                ).await;
                 total
             });
 
-            // Watchdog: monitors inactivity, max lifetime, and cancellation
+            // Watchdog: monitors inactivity, max lifetime, and cancellation.
+            // First cancels the per-connection token for graceful shutdown (close_notify/FIN),
+            // then falls back to abort if the tasks are stuck (e.g. on a blocked write_all).
             let la_watch = Arc::clone(&last_activity);
-            let c2u_handle = c2u.abort_handle();
-            let u2c_handle = u2c.abort_handle();
+            let c2u_abort = c2u.abort_handle();
+            let u2c_abort = u2c.abort_handle();
             let inactivity_timeout = ws_inactivity_timeout;
             let max_lifetime = ws_max_lifetime;
 
@@ -1970,8 +2039,6 @@ impl HttpProxyService {
                         _ = tokio::time::sleep(check_interval) => {}
                         _ = cancel.cancelled() => {
                             debug!("WebSocket tunnel cancelled by shutdown");
-                            c2u_handle.abort();
-                            u2c_handle.abort();
                             break;
                         }
                     }
@@ -1979,8 +2046,6 @@ impl HttpProxyService {
                     // Check max lifetime
                     if start.elapsed() >= max_lifetime {
                         debug!("WebSocket tunnel exceeded max lifetime, closing");
-                        c2u_handle.abort();
-                        u2c_handle.abort();
                         break;
                     }
 
@@ -1990,13 +2055,18 @@ impl HttpProxyService {
                         let elapsed_since_activity = start.elapsed().as_millis() as u64 - current;
                         if elapsed_since_activity >= inactivity_timeout.as_millis() as u64 {
                             debug!("WebSocket tunnel inactive for {}ms, closing", elapsed_since_activity);
-                            c2u_handle.abort();
-                            u2c_handle.abort();
                             break;
                         }
                     }
                     last_seen = current;
                 }
+                // Phase 1: Signal copy loops to exit gracefully (allows close_notify/FIN)
+                ws_cancel.cancel();
+                // Phase 2: Wait for graceful shutdown (2s shutdown timeout + 2s margin)
+                tokio::time::sleep(std::time::Duration::from_secs(4)).await;
+                // Phase 3: Force-abort if still stuck (e.g. blocked on write_all)
+                c2u_abort.abort();
+                u2c_abort.abort();
             });
 
             let bytes_in = c2u.await.unwrap_or(0);
@@ -2006,9 +2076,7 @@ impl HttpProxyService {
             debug!("WebSocket tunnel closed: {} bytes in, {} bytes out", bytes_in, bytes_out);
 
             upstream_selector.connection_ended(&upstream_key_owned);
-            if let Some(ref rid) = route_id_owned {
-                metrics.record_bytes(bytes_in, bytes_out, Some(rid.as_str()), Some(&source_ip_owned));
-            }
+            // Bytes already reported per-chunk in the copy loops above
         });
 
         let body: BoxBody<Bytes, hyper::Error> = BoxBody::new(

rust/crates/rustproxy-passthrough/src/forwarder.rs

@@ -97,16 +97,25 @@ pub async fn forward_bidirectional_with_timeouts(
     let last_activity = Arc::new(AtomicU64::new(0));
     let start = std::time::Instant::now();
 
+    // Per-connection cancellation token: the watchdog cancels this instead of
+    // aborting tasks, so the copy loops can shut down gracefully (TCP FIN instead
+    // of RST, TLS close_notify if the stream is TLS-wrapped).
+    let conn_cancel = CancellationToken::new();
+
     let la1 = Arc::clone(&last_activity);
     let initial_len = initial_data.map_or(0u64, |d| d.len() as u64);
     let metrics_c2b = metrics.clone();
+    let cc1 = conn_cancel.clone();
     let c2b = tokio::spawn(async move {
         let mut buf = vec![0u8; 65536];
         let mut total = initial_len;
         loop {
-            let n = match client_read.read(&mut buf).await {
-                Ok(0) | Err(_) => break,
-                Ok(n) => n,
+            let n = tokio::select! {
+                result = client_read.read(&mut buf) => match result {
+                    Ok(0) | Err(_) => break,
+                    Ok(n) => n,
+                },
+                _ = cc1.cancelled() => break,
             };
             if backend_write.write_all(&buf[..n]).await.is_err() {
                 break;
@@ -117,19 +126,27 @@ pub async fn forward_bidirectional_with_timeouts(
                 ctx.collector.record_bytes(n as u64, 0, ctx.route_id.as_deref(), ctx.source_ip.as_deref());
             }
         }
-        let _ = backend_write.shutdown().await;
+        // Graceful shutdown with timeout (sends TCP FIN / TLS close_notify)
+        let _ = tokio::time::timeout(
+            std::time::Duration::from_secs(2),
+            backend_write.shutdown(),
+        ).await;
         total
     });
 
     let la2 = Arc::clone(&last_activity);
     let metrics_b2c = metrics;
+    let cc2 = conn_cancel.clone();
     let b2c = tokio::spawn(async move {
         let mut buf = vec![0u8; 65536];
         let mut total = 0u64;
         loop {
-            let n = match backend_read.read(&mut buf).await {
-                Ok(0) | Err(_) => break,
-                Ok(n) => n,
+            let n = tokio::select! {
+                result = backend_read.read(&mut buf) => match result {
+                    Ok(0) | Err(_) => break,
+                    Ok(n) => n,
+                },
+                _ = cc2.cancelled() => break,
             };
             if client_write.write_all(&buf[..n]).await.is_err() {
                 break;
@@ -140,14 +157,20 @@ pub async fn forward_bidirectional_with_timeouts(
                 ctx.collector.record_bytes(0, n as u64, ctx.route_id.as_deref(), ctx.source_ip.as_deref());
             }
         }
-        let _ = client_write.shutdown().await;
+        // Graceful shutdown with timeout (sends TCP FIN / TLS close_notify)
+        let _ = tokio::time::timeout(
+            std::time::Duration::from_secs(2),
+            client_write.shutdown(),
+        ).await;
         total
     });
 
-    // Watchdog: inactivity, max lifetime, and cancellation
+    // Watchdog: inactivity, max lifetime, and cancellation.
+    // First cancels the per-connection token for graceful shutdown (FIN/close_notify),
+    // then falls back to abort if the tasks are stuck (e.g. on a blocked write_all).
     let la_watch = Arc::clone(&last_activity);
-    let c2b_handle = c2b.abort_handle();
-    let b2c_handle = b2c.abort_handle();
+    let c2b_abort = c2b.abort_handle();
+    let b2c_abort = b2c.abort_handle();
     let watchdog = tokio::spawn(async move {
         let check_interval = std::time::Duration::from_secs(5);
         let mut last_seen = 0u64;
@@ -155,16 +178,12 @@ pub async fn forward_bidirectional_with_timeouts(
             tokio::select! {
                 _ = cancel.cancelled() => {
                     debug!("Connection cancelled by shutdown");
-                    c2b_handle.abort();
-                    b2c_handle.abort();
                     break;
                 }
                 _ = tokio::time::sleep(check_interval) => {
                     // Check max lifetime
                     if start.elapsed() >= max_lifetime {
                         debug!("Connection exceeded max lifetime, closing");
-                        c2b_handle.abort();
-                        b2c_handle.abort();
                         break;
                     }
 
@@ -174,8 +193,6 @@ pub async fn forward_bidirectional_with_timeouts(
                         let elapsed_since_activity = start.elapsed().as_millis() as u64 - current;
                         if elapsed_since_activity >= inactivity_timeout.as_millis() as u64 {
                             debug!("Connection inactive for {}ms, closing", elapsed_since_activity);
-                            c2b_handle.abort();
-                            b2c_handle.abort();
                             break;
                         }
                     }
@@ -183,6 +200,13 @@ pub async fn forward_bidirectional_with_timeouts(
                 }
             }
         }
+        // Phase 1: Signal copy loops to exit gracefully (allows FIN/close_notify)
+        conn_cancel.cancel();
+        // Phase 2: Wait for graceful shutdown (2s shutdown timeout + 2s margin)
+        tokio::time::sleep(std::time::Duration::from_secs(4)).await;
+        // Phase 3: Force-abort if still stuck (e.g. blocked on write_all)
+        c2b_abort.abort();
+        b2c_abort.abort();
     });
 
     let bytes_in = c2b.await.unwrap_or(0);

rust/crates/rustproxy-passthrough/src/tcp_listener.rs

@@ -465,21 +465,19 @@ impl TcpListenerManager {
                         Ok((stream, peer_addr)) => {
                             let ip = peer_addr.ip();
 
-                            // Global connection limit — acquire semaphore permit with timeout
-                            let permit = match tokio::time::timeout(
-                                std::time::Duration::from_secs(5),
-                                conn_semaphore.clone().acquire_owned(),
-                            ).await {
-                                Ok(Ok(permit)) => permit,
-                                Ok(Err(_)) => {
-                                    // Semaphore closed — shouldn't happen, but be safe
-                                    debug!("Connection semaphore closed, dropping connection from {}", peer_addr);
+                            // Global connection limit — non-blocking check.
+                            // MUST NOT block the accept loop: a blocking acquire would stall
+                            // ALL connections to this port (not just the one over limit), because
+                            // listener.accept() is not polled while we await the semaphore.
+                            let permit = match conn_semaphore.clone().try_acquire_owned() {
+                                Ok(permit) => permit,
+                                Err(tokio::sync::TryAcquireError::NoPermits) => {
+                                    debug!("Global connection limit reached, dropping connection from {}", peer_addr);
                                     drop(stream);
                                     continue;
                                 }
-                                Err(_) => {
-                                    // Timeout — global limit reached
-                                    debug!("Global connection limit reached, dropping connection from {}", peer_addr);
+                                Err(tokio::sync::TryAcquireError::Closed) => {
+                                    debug!("Connection semaphore closed, dropping connection from {}", peer_addr);
                                     drop(stream);
                                     continue;
                                 }
@@ -1396,15 +1394,24 @@ impl TcpListenerManager {
         let last_activity = Arc::new(AtomicU64::new(0));
         let start = std::time::Instant::now();
 
+        // Per-connection cancellation token: the watchdog cancels this instead of
+        // aborting tasks, so the copy loops can shut down gracefully (TLS close_notify
+        // for terminate/reencrypt mode, TCP FIN for passthrough mode).
+        let conn_cancel = CancellationToken::new();
+
         let la1 = Arc::clone(&last_activity);
         let metrics_c2b = metrics.clone();
+        let cc1 = conn_cancel.clone();
         let c2b = tokio::spawn(async move {
             let mut buf = vec![0u8; 65536];
             let mut total = 0u64;
             loop {
-                let n = match client_read.read(&mut buf).await {
-                    Ok(0) | Err(_) => break,
-                    Ok(n) => n,
+                let n = tokio::select! {
+                    result = client_read.read(&mut buf) => match result {
+                        Ok(0) | Err(_) => break,
+                        Ok(n) => n,
+                    },
+                    _ = cc1.cancelled() => break,
                 };
                 if backend_write.write_all(&buf[..n]).await.is_err() {
                     break;
@@ -1418,19 +1425,27 @@ impl TcpListenerManager {
                     ctx.collector.record_bytes(n as u64, 0, ctx.route_id.as_deref(), ctx.source_ip.as_deref());
                 }
             }
-            let _ = backend_write.shutdown().await;
+            // Graceful shutdown with timeout (sends TLS close_notify / TCP FIN)
+            let _ = tokio::time::timeout(
+                std::time::Duration::from_secs(2),
+                backend_write.shutdown(),
+            ).await;
             total
         });
 
         let la2 = Arc::clone(&last_activity);
         let metrics_b2c = metrics;
+        let cc2 = conn_cancel.clone();
         let b2c = tokio::spawn(async move {
             let mut buf = vec![0u8; 65536];
             let mut total = 0u64;
             loop {
-                let n = match backend_read.read(&mut buf).await {
-                    Ok(0) | Err(_) => break,
-                    Ok(n) => n,
+                let n = tokio::select! {
+                    result = backend_read.read(&mut buf) => match result {
+                        Ok(0) | Err(_) => break,
+                        Ok(n) => n,
+                    },
+                    _ = cc2.cancelled() => break,
                 };
                 if client_write.write_all(&buf[..n]).await.is_err() {
                     break;
@@ -1444,14 +1459,20 @@ impl TcpListenerManager {
                     ctx.collector.record_bytes(0, n as u64, ctx.route_id.as_deref(), ctx.source_ip.as_deref());
                 }
             }
-            let _ = client_write.shutdown().await;
+            // Graceful shutdown with timeout (sends TLS close_notify / TCP FIN)
+            let _ = tokio::time::timeout(
+                std::time::Duration::from_secs(2),
+                client_write.shutdown(),
+            ).await;
             total
         });
 
-        // Watchdog task: check for inactivity, max lifetime, and cancellation
+        // Watchdog task: check for inactivity, max lifetime, and cancellation.
+        // First cancels the per-connection token for graceful shutdown (close_notify/FIN),
+        // then falls back to abort if the tasks are stuck (e.g. on a blocked write_all).
         let la_watch = Arc::clone(&last_activity);
-        let c2b_handle = c2b.abort_handle();
-        let b2c_handle = b2c.abort_handle();
+        let c2b_abort = c2b.abort_handle();
+        let b2c_abort = b2c.abort_handle();
         let watchdog = tokio::spawn(async move {
             let check_interval = std::time::Duration::from_secs(5);
             let mut last_seen = 0u64;
@@ -1459,16 +1480,12 @@ impl TcpListenerManager {
                 tokio::select! {
                     _ = cancel.cancelled() => {
                         debug!("Split-stream connection cancelled by shutdown");
-                        c2b_handle.abort();
-                        b2c_handle.abort();
                         break;
                     }
                     _ = tokio::time::sleep(check_interval) => {
                         // Check max lifetime
                         if start.elapsed() >= max_lifetime {
                             debug!("Connection exceeded max lifetime, closing");
-                            c2b_handle.abort();
-                            b2c_handle.abort();
                             break;
                         }
 
@@ -1479,8 +1496,6 @@ impl TcpListenerManager {
                             let elapsed_since_activity = start.elapsed().as_millis() as u64 - current;
                             if elapsed_since_activity >= inactivity_timeout.as_millis() as u64 {
                                 debug!("Connection inactive for {}ms, closing", elapsed_since_activity);
-                                c2b_handle.abort();
-                                b2c_handle.abort();
                                 break;
                             }
                         }
@@ -1488,6 +1503,13 @@ impl TcpListenerManager {
                     }
                 }
             }
+            // Phase 1: Signal copy loops to exit gracefully (allows close_notify/FIN)
+            conn_cancel.cancel();
+            // Phase 2: Wait for graceful shutdown (2s shutdown timeout + 2s margin)
+            tokio::time::sleep(std::time::Duration::from_secs(4)).await;
+            // Phase 3: Force-abort if still stuck (e.g. blocked on write_all)
+            c2b_abort.abort();
+            b2c_abort.abort();
         });
 
         let bytes_in = c2b.await.unwrap_or(0);

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '25.11.1',
+  version: '25.11.6',
   description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 }