anytls 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97d6d911a444c22bb45735dd22aede45733d1af86990df618339690fe9069d2c
-  data.tar.gz: 0acb6a2669394ad05207c19dafffcb3419ac1eabe1c43024a876da302c20bdd6
+  metadata.gz: 614c54295c75168e63b13a6c1cb9703321cc70bbaa672a5a3d064ed630b014ad
+  data.tar.gz: 51446c2245624537d53fb9fcd8b49f51b3a57f3241bcfe5785eaa5206404c02e
 SHA512:
-  metadata.gz: d3d97bc849f71208a4c81ee69867704d0bd6ca744f7b130d341a7ca0271dbd91fa41928d73d4a231236e48b41c76d9390cb41bbcb092a466c5d3477c58a59ded
-  data.tar.gz: 8b95f3c45e6664619ab5e9615aa62a62f555e2f99747a646cbb2f6c05085584fe240c58b16437cbffdd77b2160e3d4e7a261d4b292d0f16ab29d96316faa57ea
+  metadata.gz: 1da8ddbc879a82a96263c991f27cbdaf8f9ae2b4ff90a112a811ad42ab63b102e09078af8fff6b8893c121c8b5683c68a65b942907181ffe464a0c8674e012f7
+  data.tar.gz: b3cece03e15e6593db595b7ca78e3291fecaf8eae3a1e4bc71cd73ba1b08ff22aab8a3cec5891e3eb8851e4af56b8cdfde760fc1c52197e88fa95cb79e58ddee

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.4 (2026-10-05)
+
+- 临时接入网络错误后继续接受连接，保留已有代理会话。
+- 修复 HTTP 上传完成后的响应超时，保留慢上传、提前拒绝、流式响应和 keep-alive；临时响应不重置超时预算。
+- 接受 HTTP 字段值两端的合法空白，继续拒绝重复 Host、重复消息长度和冲突定界。
+- 减少 HTTP 请求头写入、多流接收统计和频繁连接复用的处理开销。
+
 ## 0.1.3 (2026-10-05)
 
 - 忽略 CI 的 Bundler 安装缓存，避免发布前工作区检查误判为未提交源文件。

data/README.md

@@ -4,7 +4,7 @@ Ruby 3.4+ 的 AnyTLS gem 与命令行客户端、服务端。参考版本固定
 [`anytls-go` 的 `fd6167a`](https://github.com/anytls/anytls-go/tree/fd6167acd6d73b9fa3e607659951847fbc9e6c50)。
 核心代码不依赖 Rails。
 
-当前版本为 `0.1.1`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
+当前版本为 `0.1.4`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
 [SOURCES](docs/SOURCES.md)。
 
 ## 使用
@@ -99,7 +99,8 @@ server.run # 阻塞；由其他正常线程调用 server.stop(grace: 5)
 
 构造 Client 不拨号；首次连接时才启动会话池。`min_idle_sessions` 是回收时保留已有空闲
 session 的数量，不会主动创建连接填满池。默认最多 128 个 session，空闲超时与检查间隔
-各 30 秒。客户端租用空闲 session；并发请求需要时建立新的 session。服务端默认最多
+各 30 秒；归还 session 不提前触发空闲扫描。客户端租用空闲 session；并发请求需要时
+建立新的 session。服务端默认最多
 256 个活动 stream。`Client#stats`、`Server#stats` 返回冻结的计数快照。
 
 ## 功能与边界
@@ -110,10 +111,15 @@ session 的数量，不会主动创建连接填满池。默认最多 128 个 ses
 SOCKS UDP 分片和 UoT v1 不在当前接口范围。
 
 HTTP 转发使用 `protocol-http1` 解析消息边界，拒绝冲突 Content-Length/Transfer-Encoding
-及重复 Host。带请求体的 HTTP Upgrade 返回 400，避免丢弃消息体；无体 Upgrade 继续支持。
+及重复 Host，接受字段值两端合法的空格和制表符。带请求体的 HTTP Upgrade 返回 400，
+避免丢弃消息体；无体 Upgrade 继续支持。
+普通 HTTP 上传完成后，最终响应头须在 `handshake_timeout` 内到达，否则返回 504；
+上传过程及响应体传输不计入该响应头预算，临时响应不重置预算。目标提前拒绝上传时仍立即返回响应。
 HTTPS 目标使用 CONNECT。代理客户端监听仅默认绑定回环地址；扩大监听
 范围时由部署环境限制访问者。
 
+服务端与 CLI 监听器会对待接入连接的暂时网络错误退避重试，保留已有连接；监听 fd 故障仍会报错退出。
+
 每条 TLS 连接只有一个 owner Thread。协议接收按 stream/session 字节预算限流；慢消费者
 超过预算会被关闭，避免无限增长或阻塞其他 stream。TLS/TCP 本身的队首阻塞仍然存在。
 设计和状态边界见 [ARCHITECTURE](docs/ARCHITECTURE.md)。

data/docs/ARCHITECTURE.md

@@ -38,6 +38,7 @@ FIN 结束整个虚拟 stream，不提供 read/write 两侧独立关闭语义。
 Client pool 同一时刻将一个 session 租给一条业务 stream，完成后将其归还并复用。
 服务端 Session 解码器支持多条 stream 的帧，入站数量另受 session 和 server 限制。
 旧空闲连接检测、心跳和 peer stream-ID 限制都在 session 生命周期中处理，不由应用代理层重试。
+池容量等待与定时回收使用独立通知；租用、归还不触发全池回收扫描，关闭会立即唤醒两类等待者。
 
 ## 线程与 TLS 所有权
 
@@ -89,10 +90,19 @@ Session 状态锁只保护短操作；锁内不等待网络、不回调调用者
 `ByteBuffer` 将输入合并为最多 16 KiB 的块，读取用头块偏移推进，避免小读后下一次写入
 复制整个接收缓冲。容量按未读字节计算，消费完的块立即移除；小输入合并到尾块，避免
 逐字节输入产生与字节数相同的队列对象。远端结束仍允许排空，显式关闭总会释放未读块。
+活跃流共享 `ByteBuffer::Budget`：入队先预留，读取释放，结束时一次性退出共享计费，
+因此每帧不再扫描所有 stream。锁顺序为 buffer → budget，不反向取 session/stream 锁。
+与原先扫描活跃流的范围一致，远端结束后由调用者保留的尾部不计入 session 总量，
+仍受单流容量限制；调用者应及时排空或关闭这些 Stream。
 
 HTTP 提前拒绝上传时，先停止客户端上传读取并转发完整响应，再关闭上游和等待上传线程。
 不能在转发响应前等待上传线程，因为该线程可能正在等待上游写入背压；也不能提前关闭
 AnyTLS Stream，否则已接收的响应体会被丢弃。
+上传线程完成写入后，以同一线程和条件变量守候最终响应头，避免新增定时线程或轮询。
+预算从上传完成开始，到最终响应头结束；临时响应不延长预算，响应体不受此预算限制。
+超时先记录原因再关闭上游，唤醒已经阻塞的读取者；提前响应与清理均解除等待并回收上传线程。
+HTTP 字段值仅修剪 SP/HTAB，保持重复字段及定界冲突检查。头字段写入以最多 16 KiB
+缓冲合并，保留依赖的校验和字段顺序，返回前发送；消息体仍直接流式转发。
 
 同一 TCP 连接天然存在队首阻塞；有限缓冲只能限制 Ruby 自身的资源占用和慢消费者影响。
 当前没有扩展协议增加 per-stream credit，不承诺无限慢消费者仍可无损持续接收。
@@ -108,6 +118,8 @@ Client 默认验证证书和目标名称；`insecure: true` 必须显式选择
 `close` 可重复调用。`ensure` 负责 socket、session、stream 与线程回收，保留原始业务错误。
 INT/TERM trap 只向 pipe 写字节；实际清理在正常线程执行。没有 gem publish、在线下载设备配置
 或全局代理设置等隐藏副作用。
+监听器仅对 accept 返回的待接入网络错误及资源不足退避重试，日志有界；已取得 socket
+后的设置错误、失效监听 fd 等错误仍向外传播。退避可被停止请求唤醒，不影响已建立流。
 
 服务端 `stop(grace:)` 先停止监听，允许已经建立的 stream 在宽限期继续传输；到期再关闭
 剩余 session/目标 socket 并等待 worker 退出。并发 `stop` 服从第一次停止请求确定的边界，

data/docs/VALIDATION.md

@@ -25,7 +25,7 @@
 
 CI 的 Ubuntu / Ruby 4.0 任务在验证通过后上传 `anytls-gem` artifact，包含 gem 和 `SHA256SUMS`。
 发布前须确认同一提交的完整 Ruby 矩阵和 Go 互通任务均通过，下载该 artifact 并核对校验和。
-运行 `bundle exec ruby script/verify_package.rb /path/to/anytls-0.1.3.gem` 可验证已有包与当前源码
+运行 `bundle exec ruby script/verify_package.rb /path/to/anytls-0.1.4.gem` 可验证已有包与当前源码
 的文件内容、元数据和依赖一致，并隔离安装该包；提供路径时不会重新构建 gem。
 GitHub Release 和 RubyGems 必须使用这一份验证过的包，发布后下载两处产物并核对 SHA256。
 

data/lib/anytls/byte_buffer.rb

@@ -4,11 +4,34 @@ module AnyTLS
   # 有界二进制接收队列；生产者不阻塞，读取者可等待数据。
   # 远端结束后先读完缓冲再报告 EOF 或异常；本地关闭则丢弃缓冲。
   class ByteBuffer
+    # 多个活跃接收队列共用的字节预算。仅从 buffer 锁进入预算锁，
+    # 不反向获取队列、stream 或 session 锁，也不调用应用回调。
+    class Budget
+      def initialize(limit)
+        @limit = limit
+        @size = 0
+        @mutex = Mutex.new
+      end
+
+      def reserve(size)
+        @mutex.synchronize do
+          raise BufferLimitExceeded, "session receive buffer limit exceeded" if @size + size > @limit
+
+          @size += size
+        end
+      end
+
+      def release(size)
+        @mutex.synchronize { @size -= size }
+      end
+    end
+
     CHUNK_SIZE = 16_384
     private_constant :CHUNK_SIZE
 
-    def initialize(limit: 262_144)
+    def initialize(limit: 262_144, budget: nil)
       @limit = limit
+      @budget = budget
       @chunks = []
       @offset = 0
       @size = 0
@@ -30,6 +53,7 @@ module AnyTLS
         return if @finished
         raise BufferLimitExceeded, "stream receive buffer limit exceeded" if @size + bytes.bytesize > @limit
 
+        @budget&.reserve(bytes.bytesize)
         # 合并小片段，避免逐字节输入生成大量队列对象；只复制有界尾块。
         # 已消费的前缀用偏移记录，不在每次小读后切出整个剩余缓冲。
         cursor = 0
@@ -75,6 +99,7 @@ module AnyTLS
           end
         end
         @size -= count
+        @budget&.release(count)
         result
       end
     end
@@ -84,6 +109,10 @@ module AnyTLS
         unless @finished
           @error = error
           @finished = true
+          # 流移出会话后退出共享计费；远端 FIN 保留的尾部仍受单流上限约束，
+          # 并可读到 EOF。之后的读、重复 finish/close 不得再次释放预算。
+          @budget&.release(@size)
+          @budget = nil
         end
         if discard
           @chunks.clear

data/lib/anytls/cli/client_listener.rb

@@ -60,8 +60,16 @@ module AnyTLS
         end
         start_worker(socket)
         @resource_limited = false
+      rescue *IOHelpers::ACCEPT_RETRY_ERRORS => error
+        raise if socket.is_a?(IO)
+
+        pause_accept(shutdown, error)
       rescue Errno::EMFILE, Errno::ENFILE, ThreadError => error
         socket.close if socket.is_a?(IO) && !socket.closed?
+        pause_accept(shutdown, error)
+      end
+
+      def pause_accept(shutdown, error)
         Log.emit(@logger, :warn, "proxy admission paused (#{error.class})") unless @resource_limited
         @resource_limited = true
         IO.select([shutdown.reader], nil, nil, 0.05)

data/lib/anytls/inbound/http_proxy.rb

@@ -17,8 +17,8 @@ module AnyTLS
         attr_reader :declared_content_length
 
         def read_headers
-          headers = super
-          fields = headers.to_a
+          # OWS 仅包含 SP/HTAB；保留重复字段，避免规范化掩盖消息定界冲突。
+          fields = super.to_a.map { |name, value| [name, value.gsub(/\A[ \t]+|[ \t]+\z/, "")] }
           lengths = fields.select { |name, _| name.downcase == "content-length" }.map(&:last)
           transfers = fields.select { |name, _| name.downcase == "transfer-encoding" }.map(&:last)
           hosts = fields.count { |name, _| name.downcase == "host" }
@@ -36,7 +36,7 @@ module AnyTLS
           fields.map(&:last).each do |value|
             raise ProtocolError, "invalid HTTP header value" if value.match?(/[\x00-\x08\x0a-\x1f\x7f]/)
           end
-          headers
+          ::Protocol::HTTP::Headers.new(fields)
         end
 
         def read_request_body(method, headers)
@@ -49,8 +49,85 @@ module AnyTLS
 
           super
         end
+
+        # 仅在同步写出头字段期间合并小写入；不缓存消息体，结束时即发送。
+        # 继续使用依赖的字段校验、顺序和重复字段语义。
+        def write_headers(headers)
+          @header_buffer = +"".b
+          super
+          bytes = @header_buffer
+          @header_buffer = nil
+          write_stream(bytes) unless bytes.empty?
+        ensure
+          @header_buffer = nil
+        end
+
+        private
+
+        def write_stream(bytes)
+          return super unless @header_buffer
+
+          if @header_buffer.bytesize + bytes.bytesize > 16_384
+            super(@header_buffer) unless @header_buffer.empty?
+            @header_buffer.clear
+          end
+          if bytes.bytesize > 16_384
+            super
+          else
+            @header_buffer << bytes
+          end
+        end
       end
 
+      # 复用上传线程守候最终响应头，不增加每请求的定时器线程。
+      # 上传结束才启动预算；提前响应和异常清理均唤醒此等待者。
+      class ResponseWait
+        def initialize(timeout)
+          @timeout = timeout
+          @mutex = Mutex.new
+          @changed = ConditionVariable.new
+          @uploading = true
+          @complete = false
+        end
+
+        def uploading?
+          @mutex.synchronize { @uploading }
+        end
+
+        def error
+          @mutex.synchronize { @error }
+        end
+
+        def fail(error)
+          @mutex.synchronize do
+            return if @error
+
+            @error = error
+          end
+        end
+
+        def uploaded
+          @mutex.synchronize do
+            @uploading = false
+            deadline = Deadline.new(@timeout)
+            deadline.wait(@changed, @mutex) until @complete
+          rescue TimeoutError => error
+            # 必须先发布超时再关闭上游，让被唤醒的读取者得到原始错误。
+            @error = error
+            raise
+          end
+        end
+
+        def complete
+          @mutex.synchronize do
+            @complete = true
+            @changed.broadcast
+          end
+        end
+      end
+
+      private_constant :ResponseWait
+
       def initialize(client:, logger: nil, handshake_timeout: 5)
         @client = client
         @logger = logger
@@ -136,27 +213,33 @@ module AnyTLS
           transport.write("\r\n")
         elsif body
           cancel_upload = false
+          response_wait = ResponseWait.new(@handshake_timeout)
           upload = Thread.new do
             upstream.write_body("HTTP/1.1", body)
+            response_wait.uploaded
             nil
           rescue StandardError => error
+            response_wait.fail(error)
             stream.close unless cancel_upload || stream.closed?
             error
           end
         else
           upstream.write_body("HTTP/1.1", body)
         end
+        transport.timeout = upload ? nil : @handshake_timeout
         loop do
-          transport.timeout = upload&.alive? ? nil : @handshake_timeout
           transport.begin_headers!
           _response_version, status, reason, response_headers, response_body = upstream.read_response(method)
-          transport.timeout = nil
           if status.between?(100, 199) && status != 101
             downstream.write_interim_response(version, status, filtered_headers(response_headers), reason)
             next
           end
 
-          if upload&.alive?
+          response_wait&.complete
+          raise response_wait.error if response_wait&.error
+
+          transport.timeout = nil
+          if response_wait&.uploading?
             # 目标服务可能在读取完整请求体之前拒绝上传。
             # 先停止本地上传读取并交付完整响应。上传也可能停在上游写入，
             # 必须在 ensure 关闭上游后再 join，否则背压会阻止响应交付。
@@ -193,15 +276,17 @@ module AnyTLS
           break
         end
       rescue StandardError => error
-        upload_error = upload.value if upload && !upload.alive?
-        raise(upload_error || error)
+        raise(response_wait&.error || error)
       ensure
+        response_wait&.complete
         stream&.close
-        if upload&.alive?
+        # 上传结束后线程可能仍在等待响应或退出；不能用 alive? 判断
+        # 客户端是否还有未读请求体，否则会误关 keep-alive 的读方向。
+        if response_wait&.uploading?
           cancel_upload = true
           io.close_read
-          upload.join
         end
+        upload&.join
       end
 
       def filtered_headers(headers, upgrade: false)

data/lib/anytls/io_helpers.rb

@@ -4,6 +4,13 @@ module AnyTLS
   # 为原生 socket、StringIO 和支持超时的流提供完整二进制读写。
   # 部分进度消耗同一预算；辅助方法不重放失败写入。
   module IOHelpers
+    # accept 可返回待接入连接的网络错误；它们不代表监听 fd 已失效。
+    # 常量按平台提供的 errno 构建，EBADF/EINVAL 等监听器故障仍向外传播。
+    ACCEPT_RETRY_ERRORS = %i[ECONNABORTED EPROTO ENETDOWN ENOPROTOOPT EHOSTDOWN ENONET
+                             EHOSTUNREACH EOPNOTSUPP ENETUNREACH].filter_map do |name|
+      Errno.const_get(name) if Errno.const_defined?(name)
+    end.freeze
+
     module_function
 
     # Linux 上仅关闭描述符不能唤醒另一线程的 select；先终止 socket 通信。

data/lib/anytls/server.rb

@@ -59,14 +59,15 @@ module AnyTLS
           socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
           accept_connection(socket)
           socket = nil # 所有权已交给会话，或连接已被拒绝并关闭。
+        rescue *IOHelpers::ACCEPT_RETRY_ERRORS => error
+          # 仅重试 accept 本身；已接入 socket 的设置或会话构造错误不可吞掉。
+          raise if socket
+
+          pause_accept(error)
+          break if @mutex.synchronize { @stopping }
         rescue Errno::EMFILE, Errno::ENFILE, ThreadError => error
           socket&.close unless socket&.closed?
-          now = Deadline.now
-          if !@resource_warning_at || now - @resource_warning_at >= 5
-            Log.emit(@logger, :warn, "accept capacity exhausted (#{error.class})")
-            @resource_warning_at = now
-          end
-          @mutex.synchronize { @changed.wait(@mutex, 0.05) unless @stopping }
+          pause_accept(error)
           break if @mutex.synchronize { @stopping }
         ensure
           socket&.close unless socket&.closed?
@@ -130,6 +131,15 @@ module AnyTLS
 
     private
 
+    def pause_accept(error)
+      now = Deadline.now
+      if !@resource_warning_at || now - @resource_warning_at >= 5
+        Log.emit(@logger, :warn, "accept paused (#{error.class})")
+        @resource_warning_at = now
+      end
+      @mutex.synchronize { @changed.wait(@mutex, 0.05) unless @stopping }
+    end
+
     def accept_connection(socket)
       @mutex.synchronize do
         if @stopping || @sessions.size >= @max_sessions

data/lib/anytls/session.rb

@@ -53,7 +53,7 @@ module AnyTLS
       @open_timeout = open_timeout
       @max_streams = max_streams
       @receive_limit = receive_limit
-      @session_receive_limit = session_receive_limit
+      @receive_budget = ByteBuffer::Budget.new(session_receive_limit)
       @send_limit = send_limit
       @logger = logger
       @on_stream = on_stream
@@ -507,10 +507,6 @@ module AnyTLS
       stream = @streams[frame.stream_id]
       return unless stream
 
-      if @streams.values.sum(&:buffered_bytes) + frame.payload.bytesize > @session_receive_limit
-        raise BufferLimitExceeded, "session receive buffer limit exceeded"
-      end
-
       stream.receive(frame.payload)
     rescue BufferLimitExceeded => error
       remove_stream(frame.stream_id)&.finish(error)
@@ -546,7 +542,7 @@ module AnyTLS
     end
 
     def register_stream(id)
-      stream = Stream.new(self, id, receive_limit: @receive_limit)
+      stream = Stream.new(self, id, receive_limit: @receive_limit, receive_budget: @receive_budget)
       @mutex.synchronize do
         @streams[id] = stream
         @active_count = @streams.size

data/lib/anytls/session_pool.rb

@@ -29,6 +29,7 @@ module AnyTLS
       @factory = factory
       @mutex = Mutex.new
       @changed = ConditionVariable.new
+      @maintenance_changed = ConditionVariable.new
       @sessions = {}
       @idle = {}
       @creating = 0
@@ -123,6 +124,7 @@ module AnyTLS
       sessions = @mutex.synchronize do
         @closed = true
         @changed.broadcast
+        @maintenance_changed.broadcast
         result = @sessions.keys
         @sessions.clear
         @idle.clear
@@ -143,7 +145,12 @@ module AnyTLS
       @maintenance = Thread.new do
         loop do
           expired = @mutex.synchronize do
-            @changed.wait(@mutex, @interval) unless @closed
+            # 租用者的容量通知不触发全池扫描；关闭仍须立即唤醒维护线程。
+            # 绝对时间防止虚假唤醒提前扫描或重新消耗完整间隔。
+            check_at = Deadline.now + @interval
+            while !@closed && (remaining = check_at - Deadline.now).positive?
+              @maintenance_changed.wait(@mutex, remaining)
+            end
             break if @closed
 
             retained = @idle.keys.sort_by { |session| -session.sequence }.first(@min_idle_sessions)

data/lib/anytls/stream.rb

@@ -7,10 +7,10 @@ module AnyTLS
   class Stream
     attr_reader :id
 
-    def initialize(session, id, receive_limit: 262_144)
+    def initialize(session, id, receive_limit: 262_144, receive_budget: nil)
       @session = session
       @id = id
-      @buffer = ByteBuffer.new(limit: receive_limit)
+      @buffer = ByteBuffer.new(limit: receive_limit, budget: receive_budget)
       @mutex = Mutex.new
       @changed = ConditionVariable.new
       @closed = false

data/lib/anytls/version.rb

@@ -2,5 +2,5 @@
 
 module AnyTLS
   # gemspec、命令行和对端标识共用的唯一版本来源。
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: anytls
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - AnyTLS Ruby contributors