anytls 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c797edcda4beba1d06a85d522a65ba7c4a3b7079955ea5640cc6f4320078e05b
-  data.tar.gz: e0d213605c4574257a28a0231b11dee4484db37aae667dda501532955fc4abf3
+  metadata.gz: 21faa499b108b3acc3a415299b217b68af2227f1325759c696540780fe549d23
+  data.tar.gz: 3a366b73c675a95347ebfdc05431708e65caddaebd1aed09e654dc3756cb5a10
 SHA512:
-  metadata.gz: d8d10834c474ffd7e04c325dcf00b187c2b68984af406591b947cc8dd2ec390d7cd425024d24af87d17de62e1e8217926faae0cb12e9cfc55355a54f85609052
-  data.tar.gz: 7799f998dd9825273c1de1dd045e64d7cfad11816f8dd1d594a105386e312a630c1cbd5ae62951d575079733048b36ca215726ab7119edb987125d9b9c33d4b1
+  metadata.gz: a5858b4a20fb03be5498b0fb8a31e2f4f2f1e91427e868fef5a530cb4fafcbca138d6c38afb72052b2a16c91d01c7417c6d2c56efcd0f45cea5b2acf31e5d72f
+  data.tar.gz: 6c8f642a7d1a591f0ca48b7cef7f2f2980a847fba4647427f77e1efd9c63d8dcb810a6e53222028c1b980f570aba0399fbaaab26c7d93b468f5aa7c922240cba

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.6 (2026-10-09)
+
+- UoT 在远端 FIN 后继续排空完整数据包，保留 EOF 与原始错误；显式关闭 UoT/缓冲 IO 时释放未读尾部。
+- 修复已有 Stream 缓冲绕过读取超时、BufferedIO 部分读取重置预算的问题，非法超时在设置阶段拒绝。
+- 增量解帧在等待载荷片段时复用已解析的帧头，减少碎片化输入下的重复解析与对象分配。
+
 ## 0.1.5 (2026-10-06)
 
 - 修复 v1 多流集中报告目标就绪时，操作队列未排空却进入等待导致整条会话超时的问题。

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.5`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
+当前版本为 `0.1.6`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
 [SOURCES](docs/SOURCES.md)。
 
 ## 使用
@@ -72,6 +72,7 @@ end
 不提供 `to_io` 或真正的 TCP half-close。
 远端结束后可继续排空接收数据；显式 `close` 会丢弃未读数据，即使远端已经结束。
 大块写入按最多 65,535 字节分片，每片完成后才提交下一片；排队与发送共用本次 write 的超时预算。
+读取的超时预算也适用于已有缓冲数据；`read(0)` 仍立即返回空字符串。
 
 AnyTLS 没有独立的认证成功回执；首次连接或 v1 peer 可能先返回尚未确认目标连接的
 Stream。`connection_status` 区分 `:unconfirmed`、`:confirmed`、`:failed`。远端拒绝、认证
@@ -92,6 +93,8 @@ end
 上限约束，可能以 `EMSGSIZE` 拒绝较大的包；线协议上限不是网络发送保证。
 SOCKS5 UDP ASSOCIATE 通过同一 UoT 能力实现。
 转发资源与必需线程全部创建后才报告就绪；准备失败不会先回复成功。
+远端 FIN 后 `closed?` 为 true，`receive_packet` 仍可排空已完整接收的数据包，随后报告 EOF
+或原始故障；显式 `close` 会丢弃未读数据。不完整的数据包读取失败后关闭流，不能继续解析。
 
 ```ruby
 tls = AnyTLS::TLSConfig.new(server: true, cert: "fullchain.pem", key: "private-key.pem")

data/docs/ARCHITECTURE.md

@@ -28,6 +28,7 @@
 每个协议帧由 `command:uint8 + stream_id:uint32be + payload_length:uint16be + payload` 组成。
 增量 Decoder 能处理任意 header/body 分割；不把一次 TLS read 当成一帧。payload 最大
 65,535 字节，公开 Stream 大 write 在编码前分片。Decoder 先按声明长度完成帧边界解析；
+完整帧头只解析一次，等待载荷片段时保留该帧头，输出完整帧后再解析下一个。
 Session 与 Go 参考保持一致：未知命令的空 payload 可忽略，非空 payload 则拒绝并结束 session。
 
 Session 先完成 TLS 与认证，再推进 SETTINGS/SYN/PSH 等协议状态。服务端收到 SYN 时分配
@@ -75,6 +76,9 @@ Session 状态锁只保护短操作；锁内不等待网络、不回调调用者
 
 `Deadline` 使用 `CLOCK_MONOTONIC`。同一读写操作中的等待消耗同一预算，不在部分进度后
 重新计时；排队和锁等待也会消耗预算。连接、握手、目标拨号和关闭具有单独边界。
+Stream 在消费已有缓冲前也检查截止时间，已排空的流继续报告原 EOF/错误，零长度 read 不消费预算。
+BufferedIO 复用 `Deadline` 与 `IOHelpers.read_partial`；一次 read 的所有片段使用同一截止时间，
+并受握手阶段截止时间约束。预读字节不能绕过阶段预算，非法超时不会覆盖现有配置。
 
 | 限制 | 当前默认 |
 | --- | --- |
@@ -116,6 +120,9 @@ UoT 与 SOCKS5 UDP association 使用启动门：全部必需线程取得后才
 创建失败则唤醒尚未启动的线程退出、回收 socket/stream，并报告失败。后续延迟创建地址族
 资源失败也会结束转发并触发统一清理。UoT 非固定模式在每条流内最多保留一个数字 IP 与
 端口对应的解析结果，目标改变时更新；域名结果不缓存，继续逐包解析。
+UoT 的串行读取门不把底层 `closed?` 当成数据耗尽：FIN 后仍可排空完整数据包，再报告 EOF
+或底层错误；写入门继续拒绝关闭后的写入。UoT 和 BufferedIO 显式关闭时始终委托底层幂等 close，
+确保已远端结束的 Stream 尾部也被释放。BufferedIO 同时丢弃自己的预读缓冲。
 
 同一 TCP 连接天然存在队首阻塞；有限缓冲只能限制 Ruby 自身的资源占用和慢消费者影响。
 当前没有扩展协议增加 per-stream credit，不承诺无限慢消费者仍可无损持续接收。

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.5.gem` 可验证已有包与当前源码
+运行 `bundle exec ruby script/verify_package.rb /path/to/anytls-0.1.6.gem` 可验证已有包与当前源码
 的文件内容、元数据和依赖一致，并隔离安装该包；提供路径时不会重新构建 gem。
 GitHub Release 和 RubyGems 必须使用这一份验证过的包，发布后下载两处产物并核对 SHA256。
 

data/lib/anytls/buffered_io.rb

@@ -17,11 +17,13 @@ module AnyTLS
     # 在协议阶段边界重新设定绝对读取预算；握手完成后清除预算，
     # 允许已建立的隧道持续空闲。
     def timeout=(value)
+      deadline = Deadline.new(value)
       @timeout = value
-      @deadline = value && (Process.clock_gettime(Process::CLOCK_MONOTONIC) + value)
+      @deadline = deadline
     end
 
     def peek(length)
+      @deadline.check!
       fill(length)
       @buffer.byteslice(0, length)
     end
@@ -29,11 +31,12 @@ module AnyTLS
     def read(length = nil, outbuf = nil, timeout: @timeout)
       raise ArgumentError, "negative length" if length&.negative?
 
+      deadline = read_deadline(timeout)
       data = +"".b
       if length
-        data << readpartial(length - data.bytesize, timeout: timeout) while data.bytesize < length
+        data << read_chunk(length - data.bytesize, deadline) while data.bytesize < length
       else
-        loop { data << readpartial(16_384, timeout: timeout) }
+        loop { data << read_chunk(16_384, deadline) }
       end
       outbuf ? outbuf.replace(data) : data
     rescue EOFError
@@ -49,13 +52,7 @@ module AnyTLS
       raise ArgumentError, "negative length" if length.negative?
       return outbuf ? outbuf.replace("") : +"".b if length.zero?
 
-      data = if @buffer.empty?
-               read_underlying(length, timeout)
-             else
-               @buffer.slice!(0, length)
-             end
-      raise EOFError if data.nil? || data.empty?
-
+      data = read_chunk(length, read_deadline(timeout))
       outbuf ? outbuf.replace(data) : data
     rescue EOFError
       outbuf&.clear
@@ -66,6 +63,7 @@ module AnyTLS
       raise ArgumentError, "separator must not be empty" if separator.nil? || separator.empty?
 
       loop do
+        @deadline.check!
         if (index = @buffer.index(separator))
           size = index + separator.bytesize
           raise BufferLimitExceeded, "HTTP line exceeds limit" if size > limit
@@ -74,7 +72,7 @@ module AnyTLS
         end
         raise BufferLimitExceeded, "HTTP line exceeds limit" if @buffer.bytesize >= limit
 
-        @buffer << read_underlying([4096, limit - @buffer.bytesize].min, @timeout)
+        @buffer << read_underlying([4096, limit - @buffer.bytesize].min, @deadline)
       end
     rescue EOFError
       return nil if @buffer.empty?
@@ -100,7 +98,9 @@ module AnyTLS
     end
 
     def close
-      IOHelpers.close(@io) unless @io.closed?
+      @buffer.clear
+      # 远端 FIN 只结束底层流；显式关闭仍须委托它释放尚未读取的尾部。
+      IOHelpers.close(@io)
     rescue IOError, SystemCallError
       nil
     end
@@ -134,37 +134,29 @@ module AnyTLS
     private
 
     def fill(length)
-      @buffer << read_underlying([length - @buffer.bytesize, 4096].max, @timeout) while @buffer.bytesize < length
+      @buffer << read_underlying([length - @buffer.bytesize, 4096].max, @deadline) while @buffer.bytesize < length
     end
 
-    def read_underlying(length, timeout)
-      if @deadline
-        remaining = @deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        raise TimeoutError, "read timed out" unless remaining.positive?
+    # 一次 read 与整个握手阶段各有预算，选择更早的截止时间并贯穿所有片段。
+    def read_deadline(timeout)
+      deadline = Deadline.new(timeout)
+      remaining = @deadline.remaining
+      remaining && (timeout.nil? || remaining <= timeout) ? @deadline : deadline
+    end
 
-        timeout = timeout ? [timeout, remaining].min : remaining
-      end
-      unless @io.respond_to?(:read_nonblock)
-        return @io.readpartial(length, timeout: timeout)
-      end
+    def read_chunk(length, deadline)
+      deadline.check!
+      result = @buffer.empty? ? read_underlying(length, deadline) : @buffer.slice!(0, length)
+      raise EOFError if result.nil? || result.empty?
 
-      deadline = timeout && (Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout)
-      loop do
-        result = @io.read_nonblock(length, exception: false)
-        case result
-        when :wait_readable, :wait_writable
-          remaining = deadline && (deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC))
-          raise TimeoutError, "read timed out" if remaining && remaining <= 0
-
-          ready = IO.select(result == :wait_readable ? [@io] : nil, result == :wait_writable ? [@io] : nil, nil,
-                            remaining)
-          raise TimeoutError, "read timed out" unless ready
-        when nil
-          raise EOFError
-        else
-          return result
-        end
-      end
+      result
+    end
+
+    def read_underlying(length, deadline)
+      result = IOHelpers.read_partial(@io, length, deadline: deadline)
+      raise EOFError if result.nil? || result.empty?
+
+      result
     end
 
     def account_line(line)

data/lib/anytls/byte_buffer.rb

@@ -83,6 +83,8 @@ module AnyTLS
 
           raise EOFError, "end of stream"
         end
+        # 已有缓冲也要计入排队和部分读取的总预算；超时不能继续消费字节。
+        deadline.check!
         count = [length, @size].min
         result = nil
         remaining = count

data/lib/anytls/protocol/decoder.rb

@@ -15,11 +15,14 @@ module AnyTLS
         frames = []
         offset = 0
         while @buffer.bytesize - offset >= HEADER_SIZE
-          command, stream_id, length = @buffer.unpack("CNn", offset:)
+          # 载荷可以拆成任意小片段；完整头部只解析一次，直到整帧到齐。
+          @header ||= @buffer.unpack("CNn", offset:)
+          command, stream_id, length = @header
           break if @buffer.bytesize - offset < HEADER_SIZE + length
 
           frames << Frame.new(command:, stream_id:, payload: @buffer.byteslice(offset + HEADER_SIZE, length))
           offset += HEADER_SIZE + length
+          @header = nil
         end
         @buffer = @buffer.byteslice(offset..) if offset.positive?
         frames

data/lib/anytls/uot/connection.rb

@@ -27,7 +27,7 @@ module AnyTLS
           IOHelpers.write_all(stream, request, timeout: timeout)
         end
       rescue StandardError
-        stream.close unless stream.closed?
+        stream.close
         raise
       end
 
@@ -53,12 +53,15 @@ module AnyTLS
 
         bytes = @destination ? +"".b : encode_address(target)
         bytes << [payload.bytesize].pack("n") << payload
-        with_gate(@write_gate, deadline) { IOHelpers.write_all(@stream, bytes, timeout: deadline.remaining) }
+        with_gate(@write_gate, deadline, writing: true) do
+          IOHelpers.write_all(@stream, bytes, timeout: deadline.remaining)
+        end
         payload.bytesize
       end
 
       def receive_packet(timeout: nil)
         deadline = Deadline.new(timeout)
+        # FIN 后仍可排空完整数据包；EOF 和原始故障由底层读取报告。
         with_gate(@read_gate, deadline) do
           destination = @destination || read_address(deadline)
           length = IOHelpers.read_exact(@stream, 2, timeout: deadline.remaining).unpack1("n")
@@ -69,18 +72,20 @@ module AnyTLS
       end
 
       def close
-        IOHelpers.close(@stream) unless @stream.closed?
+        IOHelpers.close(@stream)
       end
 
       def closed? = @stream.closed?
 
       private
 
-      def with_gate(gate, deadline)
+      def with_gate(gate, deadline, writing: false)
         deadline.check!
         acquired = gate.pop(timeout: deadline.remaining)
         raise TimeoutError, "datagram operation timed out waiting for another operation" unless acquired
-        raise ClosedError, "datagram connection closed" if closed?
+
+        deadline.check!
+        raise ClosedError, "datagram connection closed" if writing && closed?
 
         begin
           yield

data/lib/anytls/version.rb

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

metadata

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