thrift 0.24.0 → 0.25.0

data/lib/thrift/transport/header_transport.rb

@@ -19,8 +19,8 @@
 # under the License.
 #
 
-require 'stringio'
-require 'zlib'
+require "stringio"
+require "zlib"
 
 module Thrift
   # Client type constants for Header protocol
@@ -71,15 +71,18 @@ module Thrift
     # Header magic value (first 2 bytes of header)
     HEADER_MAGIC = 0x0FFF
 
-    # Maximum frame size (~1GB)
+    # The largest frame the length field can express (~1GB). This is the
+    # protocol's ceiling, not a sensible default -- see DEFAULT_MAX_FRAME_SIZE.
     MAX_FRAME_SIZE = 0x3FFFFFFF
 
+    # The largest frame accepted by default (~15.6 MB, matches other Thrift
+    # bindings). Defaulting to MAX_FRAME_SIZE let a four-byte header ask for a
+    # gigabyte, which is the ceiling rather than a limit.
+    DEFAULT_MAX_FRAME_SIZE = 16_384_000
+
     # Default decompressed-size cap for ZLIB transform (~15.6 MB, matches other Thrift bindings)
     DEFAULT_MAX_DECOMPRESSED_SIZE = 16_384_000
 
-    # Chunk size for streaming inflate loop
-    ZLIB_INFLATE_CHUNK_SIZE = 16_384
-
     # Binary protocol version mask and version 1
     BINARY_VERSION_MASK = 0xffff0000
     BINARY_VERSION_1 = 0x80010000
@@ -89,6 +92,9 @@ module Thrift
     COMPACT_VERSION_MASK = 0x1f
     COMPACT_VERSION = 0x01
 
+    MAX_VARINT32_BYTES = 5
+    MAX_VARINT32_LAST_BYTE = 0x0f
+
     attr_reader :protocol_id, :sequence_id, :flags
 
     # Creates a new HeaderTransport wrapping the given transport.
@@ -106,7 +112,7 @@ module Thrift
         HeaderClientType::FRAMED_BINARY,
         HeaderClientType::UNFRAMED_BINARY,
         HeaderClientType::FRAMED_COMPACT,
-        HeaderClientType::UNFRAMED_COMPACT
+        HeaderClientType::UNFRAMED_COMPACT,
       ]
 
       @read_buffer = StringIO.new(Bytes.empty_byte_buffer)
@@ -118,8 +124,9 @@ module Thrift
 
       @sequence_id = 0
       @flags = 0
-      @max_frame_size = MAX_FRAME_SIZE
+      @max_frame_size = DEFAULT_MAX_FRAME_SIZE
       @max_decompressed_size = DEFAULT_MAX_DECOMPRESSED_SIZE
+      @unframed_bytes_read = 0
     end
 
     def sequence_id=(sequence_id)
@@ -130,6 +137,14 @@ module Thrift
       @sequence_id = sequence_id
     end
 
+    def protocol_id=(protocol_id)
+      unless [HeaderSubprotocolID::BINARY, HeaderSubprotocolID::COMPACT].include?(protocol_id)
+        raise ArgumentError, "Unknown protocol ID: #{protocol_id}"
+      end
+
+      @protocol_id = protocol_id
+    end
+
     def open?
       @transport.open?
     end
@@ -172,6 +187,9 @@ module Thrift
       @write_transforms << transform_id unless @write_transforms.include?(transform_id)
     end
 
+    # The maximum frame size currently in force
+    attr_reader :max_frame_size
+
     # Sets the maximum allowed frame size
     def set_max_frame_size(size)
       if size <= 0 || size > MAX_FRAME_SIZE
@@ -199,7 +217,7 @@ module Thrift
       # Handle unframed passthrough - read directly from underlying transport
       if @client_type == HeaderClientType::UNFRAMED_BINARY ||
          @client_type == HeaderClientType::UNFRAMED_COMPACT
-        return data + @transport.read(bytes_left)
+        return data + read_unframed(bytes_left)
       end
 
       # Need to read the next frame
@@ -217,16 +235,15 @@ module Thrift
       @write_buffer = StringIO.new(Bytes.empty_byte_buffer)
 
       return if payload.empty?
-      if payload.bytesize > @max_frame_size
-        raise TransportException.new(TransportException::UNKNOWN, "Attempting to send frame that is too large")
-      end
 
       case @client_type
       when HeaderClientType::HEADERS
         flush_header_format(payload)
       when HeaderClientType::FRAMED_BINARY, HeaderClientType::FRAMED_COMPACT
+        validate_frame_size!(payload.bytesize)
         flush_framed(payload)
       when HeaderClientType::UNFRAMED_BINARY, HeaderClientType::UNFRAMED_COMPACT
+        validate_frame_size!(payload.bytesize)
         @transport.write(payload)
         @transport.flush
       else
@@ -235,7 +252,7 @@ module Thrift
     end
 
     def to_s
-      "header(#{@transport.to_s})"
+      "header(#{@transport})"
     end
 
     # Reads the next frame to detect protocol/client type before decoding.
@@ -245,6 +262,17 @@ module Thrift
       read_frame(0)
     end
 
+    def message_boundaries?
+      true
+    end
+
+    # Starts a new protocol message without forcing client-type detection.
+    def reset_message_size
+      return unless @read_buffer.nil? || @read_buffer.eof?
+
+      @unframed_bytes_read = 0
+    end
+
     private
 
     # Sets the client type after validation
@@ -257,9 +285,16 @@ module Thrift
 
     # Reads the next frame, detecting client type on first read
     def read_frame(req_sz)
+      @read_headers = {}
+      @unframed_bytes_read = 0
+
       # Read first 4 bytes - could be frame length or protocol magic
-      first_word = @transport.read_all(4)
-      frame_size = first_word.unpack('N').first
+      begin
+        first_word = @transport.read_all(4)
+      rescue EOFError
+        raise TransportException.new(TransportException::END_OF_FILE, "Unexpected EOF reading frame size")
+      end
+      frame_size = first_word.unpack1("N")
 
       # Check for unframed binary protocol
       if (frame_size & BINARY_VERSION_MASK) == BINARY_VERSION_1
@@ -282,16 +317,23 @@ module Thrift
       if frame_size > @max_frame_size
         raise TransportException.new(TransportException::UNKNOWN, "Frame size #{frame_size} exceeds maximum #{@max_frame_size}")
       end
+      if frame_size < 4
+        raise TransportException.new(TransportException::UNKNOWN, "Frame size #{frame_size} is too small")
+      end
 
       # Read the complete frame
-      frame_data = @transport.read_all(frame_size)
+      begin
+        frame_data = @transport.read_all(frame_size)
+      rescue EOFError
+        raise TransportException.new(TransportException::END_OF_FILE, "Unexpected EOF reading frame")
+      end
       frame_buf = StringIO.new(frame_data)
 
       # Check the second word for protocol type
       second_word = frame_buf.read(4)
       frame_buf.rewind
 
-      magic = second_word.unpack('n').first
+      magic = second_word.unpack1("n")
 
       if magic == HEADER_MAGIC
         if frame_size < 10
@@ -299,7 +341,7 @@ module Thrift
         end
         set_client_type(HeaderClientType::HEADERS)
         @read_buffer = parse_header_format(frame_buf)
-      elsif (second_word.unpack('N').first & BINARY_VERSION_MASK) == BINARY_VERSION_1
+      elsif (second_word.unpack1("N") & BINARY_VERSION_MASK) == BINARY_VERSION_1
         set_client_type(HeaderClientType::FRAMED_BINARY)
         @protocol_id = HeaderSubprotocolID::BINARY
         @read_buffer = frame_buf
@@ -315,26 +357,45 @@ module Thrift
 
     # Handles unframed protocol - puts first_word back in buffer
     def handle_unframed(first_word, req_sz)
+      @unframed_bytes_read = first_word.bytesize
+      raise_unframed_size_limit if @unframed_bytes_read > @max_frame_size
+
       bytes_left = req_sz - 4
-      if bytes_left > 0
-        rest = @transport.read(bytes_left)
+      if bytes_left > 0 && @unframed_bytes_read < @max_frame_size
+        rest = read_unframed(bytes_left)
         @read_buffer = StringIO.new(first_word + rest)
       else
         @read_buffer = StringIO.new(first_word)
       end
     end
 
+    def read_unframed(size)
+      remaining = @max_frame_size - @unframed_bytes_read
+      raise_unframed_size_limit if remaining <= 0
+
+      data = @transport.read([size, remaining].min)
+      @unframed_bytes_read += data.bytesize
+      data
+    end
+
+    def raise_unframed_size_limit
+      raise TransportException.new(
+        TransportException::SIZE_LIMIT,
+        "Unframed message size exceeds maximum #{@max_frame_size}",
+      )
+    end
+
     # Parses a Header format frame
     def parse_header_format(buf)
       # Skip magic (already identified)
       buf.read(2)
 
       # Read flags and sequence ID
-      @flags = buf.read(2).unpack('n').first
-      @sequence_id = signed_int32(buf.read(4).unpack('N').first)
+      @flags = buf.read(2).unpack1("n")
+      @sequence_id = signed_int32(buf.read(4).unpack1("N"))
 
       # Read header length (in 32-bit words)
-      header_words = buf.read(2).unpack('n').first
+      header_words = buf.read(2).unpack1("n")
       if header_words >= 16_384
         raise TransportException.new(TransportException::UNKNOWN, "Header size is unreasonable")
       end
@@ -359,7 +420,6 @@ module Thrift
         transforms << transform_id
       end
       # Read info headers
-      @read_headers = {}
       while buf.pos < end_of_headers
         info_type = read_varint32(buf, end_of_headers)
         if info_type == 0
@@ -397,26 +457,22 @@ module Thrift
     def bounded_inflate(compressed)
       inflater = Zlib::Inflate.new
       buffer = Bytes.empty_byte_buffer
-      offset = 0
-      begin
-        while offset < compressed.bytesize
-          buffer << inflater.inflate(compressed.byteslice(offset, ZLIB_INFLATE_CHUNK_SIZE))
-          if buffer.bytesize > @max_decompressed_size
-            raise TransportException.new(
-              TransportException::SIZE_LIMIT,
-              "Decompressed size exceeds limit of #{@max_decompressed_size}"
-            )
-          end
-          offset += ZLIB_INFLATE_CHUNK_SIZE
-        end
-        buffer << inflater.finish
-        if buffer.bytesize > @max_decompressed_size
+      append_chunk = lambda do |chunk|
+        if buffer.bytesize + chunk.bytesize > @max_decompressed_size
           raise TransportException.new(
             TransportException::SIZE_LIMIT,
-            "Decompressed size exceeds limit of #{@max_decompressed_size}"
+            "Decompressed size exceeds limit of #{@max_decompressed_size}",
           )
         end
+
+        buffer << chunk
+      end
+      begin
+        inflater.inflate(compressed, &append_chunk)
+        inflater.finish(&append_chunk)
         buffer
+      rescue Zlib::DataError, Zlib::BufError
+        raise TransportException.new(TransportException::UNKNOWN, "Invalid ZLIB payload")
       ensure
         inflater.close rescue nil
       end
@@ -449,7 +505,6 @@ module Thrift
           write_varstring(header_buf, key)
           write_varstring(header_buf, value)
         end
-        @write_headers = {}
       end
 
       # Pad header to 4-byte boundary
@@ -460,14 +515,16 @@ module Thrift
       # Calculate total frame size (excludes the 4-byte length field itself)
       # Frame = magic(2) + flags(2) + seqid(4) + header_len(2) + header_data + payload
       frame_size = 2 + 2 + 4 + 2 + header_data.bytesize + payload.bytesize
+      validate_frame_size!(frame_size)
+      @write_headers = {}
 
       # Write complete frame
       frame = Bytes.empty_byte_buffer
-      frame << [frame_size].pack('N')               # Length
-      frame << [HEADER_MAGIC].pack('n')             # Magic
-      frame << [@flags].pack('n')                   # Flags
-      frame << [unsigned_int32(@sequence_id)].pack('N') # Sequence ID
-      frame << [header_data.bytesize / 4].pack('n') # Header length (in 32-bit words)
+      frame << [frame_size].pack("N")               # Length
+      frame << [HEADER_MAGIC].pack("n")             # Magic
+      frame << [@flags].pack("n")                   # Flags
+      frame << [unsigned_int32(@sequence_id)].pack("N") # Sequence ID
+      frame << [header_data.bytesize / 4].pack("n") # Header length (in 32-bit words)
       frame << header_data                          # Header data
       frame << payload                              # Payload
 
@@ -475,9 +532,18 @@ module Thrift
       @transport.flush
     end
 
+    def validate_frame_size!(frame_size)
+      return if frame_size <= @max_frame_size
+
+      raise TransportException.new(
+        TransportException::UNKNOWN,
+        "Frame size #{frame_size} exceeds maximum #{@max_frame_size}",
+      )
+    end
+
     # Flushes data in simple framed format (for legacy compatibility)
     def flush_framed(payload)
-      frame = [payload.bytesize].pack('N') + payload
+      frame = [payload.bytesize].pack("N") + payload
       @transport.write(frame)
       @transport.flush
     end
@@ -492,21 +558,35 @@ module Thrift
         end
         byte = io.getbyte
         raise TransportException.new(TransportException::END_OF_FILE, "Unexpected EOF reading varint") if byte.nil?
+
+        if shift == (MAX_VARINT32_BYTES - 1) * 7
+          if (byte & 0x80) != 0
+            raise TransportException.new(TransportException::UNKNOWN, "Variable-length int over 5 bytes.")
+          end
+          if (byte & ~MAX_VARINT32_LAST_BYTE) != 0
+            raise TransportException.new(TransportException::UNKNOWN, "Variable-length int overflows uint32.")
+          end
+        end
+
         result |= (byte & 0x7f) << shift
-        break if (byte & 0x80) == 0
+        return result if (byte & 0x80) == 0
         shift += 7
       end
-      result
     end
 
     # Writes a varint32 to the given IO
     def write_varint32(io, n)
+      # Encode the low 32 bits: Ruby's >> is arithmetic, so a negative value
+      # would keep its sign bit set and never satisfy the (n & ~0x7F) == 0 exit
+      # condition below. Masking yields the same unsigned varint read_varint32
+      # produces and accepts.
+      n &= 0xFFFFFFFF
       loop do
         if (n & ~0x7F) == 0
-          io.write([n].pack('C'))
+          io.write([n].pack("C"))
           break
         else
-          io.write([(n & 0x7F) | 0x80].pack('C'))
+          io.write([(n & 0x7F) | 0x80].pack("C"))
           n >>= 7
         end
       end

data/lib/thrift/transport/http_client_transport.rb

@@ -19,24 +19,31 @@
 # under the License.
 #
 
-require 'net/http'
-require 'net/https'
-require 'openssl'
-require 'uri'
-require 'stringio'
+require "net/http"
+require "net/https"
+require "openssl"
+require "uri"
+require "stringio"
 
 module Thrift
   class HTTPClientTransport < BaseTransport
-
     def initialize(url, opts = {})
       @url = URI url
-      @headers = {'Content-Type' => 'application/x-thrift'}
+      @headers = {"Content-Type" => "application/x-thrift"}
       @outbuf = Bytes.empty_byte_buffer
       @ssl_verify_mode = opts.fetch(:ssl_verify_mode, OpenSSL::SSL::VERIFY_PEER)
+      @ssl_ca_file = opts[:ssl_ca_file]
     end
 
     def open?; true end
-    def read(sz); @inbuf.read sz end
+
+    def read(sz)
+      data = @inbuf.read sz
+      return data unless data.nil?
+
+      raise TransportException.new(TransportException::END_OF_FILE, "#{self.class.name} reached EOF reading response from #{self}, HTTP status code #{@response_code}")
+    end
+
     def write(buf); @outbuf << Bytes.force_binary_encoding(buf) end
 
     def add_headers(headers)
@@ -45,20 +52,26 @@ module Thrift
 
     def flush
       http = Net::HTTP.new @url.host, @url.port
-      http.use_ssl = @url.scheme == 'https'
-      http.verify_mode = @ssl_verify_mode if @url.scheme == 'https'
+      http.use_ssl = @url.scheme == "https"
+      if @url.scheme == "https"
+        http.verify_mode = @ssl_verify_mode
+        http.ca_file = @ssl_ca_file if @ssl_ca_file
+      end
       resp = http.post(@url.request_uri, @outbuf, @headers)
-      raise TransportException.new(TransportException::UNKNOWN, "#{self.class.name} Could not connect to #{@url}, HTTP status code #{resp.code.to_i}") unless (200..299).include?(resp.code.to_i)
+      response_code = resp.code.to_i
+      raise TransportException.new(TransportException::UNKNOWN, "#{self.class.name} Could not connect to #{self}, HTTP status code #{response_code}") unless (200..299).cover?(response_code)
 
-      data = resp.body
-      data = Bytes.force_binary_encoding(data)
+      @response_code = response_code
+      data = Bytes.force_binary_encoding(resp.body || Bytes.empty_byte_buffer)
       @inbuf = StringIO.new data
     ensure
       @outbuf = Bytes.empty_byte_buffer
     end
 
     def to_s
-      "@{self.url}"
+      path = @url.path.to_s
+      path = "/" if path.empty?
+      "#{@url.scheme}(#{@url.host}:#{@url.port}#{path})"
     end
   end
 end

data/lib/thrift/transport/io_stream_transport.rb

@@ -36,8 +36,9 @@ module Thrift
     def write(buf); @output.write(Bytes.force_binary_encoding(buf)) end
     def close; @input.close; @output.close end
     def to_io; @input end # we're assuming this is used in a IO.select for reading
+
     def to_s
-      "iostream(input=#{@input.to_s},output=#{@output.to_s})"
+      "iostream(input=#{@input},output=#{@output})"
     end
   end
 end

data/lib/thrift/transport/memory_buffer_transport.rb

@@ -21,20 +21,16 @@
 
 module Thrift
   class MemoryBufferTransport < BaseTransport
-    GARBAGE_BUFFER_SIZE = 4*(2**10) # 4kB
+    GARBAGE_BUFFER_SIZE = 4 * (2**10) # 4kB
 
-    # If you pass a string to this, you should #dup that string
-    # unless you want it to be modified by #read and #write
-    #--
-    # this behavior is no longer required. If you wish to change it
-    # go ahead, just make sure the specs pass
+    # The transport copies the input buffer and keeps its own mutable storage.
     def initialize(buffer = nil)
-      @buf = buffer ? Bytes.force_binary_encoding(buffer) : Bytes.empty_byte_buffer
+      @buf = buffer ? Bytes.force_binary_encoding(buffer.dup) : Bytes.empty_byte_buffer
       @index = 0
     end
 
     def open?
-      return true
+      true
     end
 
     def open
@@ -48,7 +44,7 @@ module Thrift
     end
 
     # this method does not use the passed object directly but copies it
-    def reset_buffer(new_buf = '')
+    def reset_buffer(new_buf = "")
       @buf.replace Bytes.force_binary_encoding(new_buf)
       @index = 0
     end
@@ -58,6 +54,8 @@ module Thrift
     end
 
     def read(len)
+      raise TransportException.new(TransportException::NEGATIVE_SIZE, "Negative size") unless len >= 0
+
       data = @buf.slice(@index, len)
       @index += len
       @index = @buf.size if @index > @buf.size
@@ -72,7 +70,7 @@ module Thrift
     end
 
     def read_all(size)
-      raise TransportException.new(TransportException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+      raise TransportException.new(TransportException::NEGATIVE_SIZE, "Negative size") unless size >= 0
 
       read(size)
     end

data/lib/thrift/transport/server_socket.rb

@@ -19,7 +19,7 @@
 # under the License.
 #
 
-require 'socket'
+require "socket"
 
 module Thrift
   class ServerSocket < BaseServerTransport
@@ -54,8 +54,8 @@ module Thrift
     end
 
     def close
-     @handle.close unless @handle.nil? or @handle.closed?
-     @handle = nil
+      @handle.close unless @handle.nil? or @handle.closed?
+      @handle = nil
     end
 
     def closed?
@@ -63,12 +63,11 @@ module Thrift
     end
 
     def to_io
-      @handle&.to_io || raise(IOError, 'closed stream')
+      @handle&.to_io || raise(IOError, "closed stream")
     end
 
     def to_s
       "socket(#{@host}:#{@port})"
     end
-
   end
 end

data/lib/thrift/transport/socket.rb

@@ -19,11 +19,11 @@
 # under the License.
 #
 
-require 'socket'
+require "socket"
 
 module Thrift
   class Socket < BaseTransport
-    def initialize(host = 'localhost', port = 9090, timeout = nil)
+    def initialize(host = "localhost", port = 9090, timeout = nil)
       @host = host
       @port = port
       @timeout = timeout
@@ -34,6 +34,8 @@ module Thrift
     attr_accessor :handle, :timeout
 
     def open
+      raise TransportException.new(TransportException::ALREADY_OPEN, "Socket already open") if open?
+
       deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @timeout unless @timeout.nil? || @timeout == 0
       @handle = connect_socket(deadline)
     end
@@ -54,7 +56,7 @@ module Thrift
 
           while len < str.length
             begin
-              len += @handle.write_nonblock(str[len..-1])
+              len += @handle.write_nonblock(str[len..])
             rescue IO::WaitWritable
               wait_for(:write, deadline, str.length)
             rescue IO::WaitReadable
@@ -64,12 +66,11 @@ module Thrift
 
           len
         end
-      rescue TransportException => e
-        # pass this on
-        raise e
+      rescue TransportException
+        close
+        raise
       rescue StandardError => e
-        close_socket(@handle)
-        @handle = nil
+        close
         raise TransportException.new(TransportException::NOT_OPEN, e.message)
       end
     end
@@ -84,24 +85,21 @@ module Thrift
           deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @timeout
 
           data = loop do
-            begin
-              break @handle.read_nonblock(sz)
-            rescue IO::WaitReadable
-              wait_for(:read, deadline, sz)
-            rescue IO::WaitWritable
-              wait_for(:write, deadline, sz)
-            end
+            break @handle.read_nonblock(sz)
+          rescue IO::WaitReadable
+            wait_for(:read, deadline, sz)
+          rescue IO::WaitWritable
+            wait_for(:write, deadline, sz)
           end
         end
-      rescue TransportException => e
-        # don't let this get caught by the StandardError handler
-        raise e
+      rescue TransportException
+        close
+        raise
       rescue StandardError => e
-        close_socket(@handle)
-        @handle = nil
+        close
         raise TransportException.new(TransportException::NOT_OPEN, e.message)
       end
-      if (data.nil? || data.length == 0)
+      if data.nil? || data.length == 0
         raise TransportException.new(TransportException::UNKNOWN, "Socket: Could not read #{sz} bytes from #{@desc}")
       end
       data
@@ -113,7 +111,7 @@ module Thrift
     end
 
     def to_io
-      @handle&.to_io || raise(IOError, 'closed stream')
+      @handle&.to_io || raise(IOError, "closed stream")
     end
 
     def to_s