thrift 0.23.0 → 0.25.0

data/lib/thrift/transport/header_transport.rb

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,8 +19,8 @@
 # under the License.
 #
 
-require 'stringio'
-require 'zlib'
+require "stringio"
+require "zlib"
 
 module Thrift
   # Client type constants for Header protocol
@@ -70,9 +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
+
     # Binary protocol version mask and version 1
     BINARY_VERSION_MASK = 0xffff0000
     BINARY_VERSION_1 = 0x80010000
@@ -82,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.
@@ -99,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)
@@ -111,7 +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)
@@ -122,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
@@ -164,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
@@ -172,6 +198,14 @@ module Thrift
       @max_frame_size = size
     end
 
+    # Sets the maximum allowed decompressed size for ZLIB transforms
+    def set_max_decompressed_size(size)
+      if size <= 0 || size > MAX_FRAME_SIZE
+        raise ArgumentError, "max_decompressed_size must be > 0 and <= #{MAX_FRAME_SIZE}"
+      end
+      @max_decompressed_size = size
+    end
+
     def read(sz)
       # Try reading from existing buffer
       data = @read_buffer.read(sz)
@@ -183,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
@@ -201,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
@@ -219,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.
@@ -229,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
@@ -241,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
@@ -266,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
@@ -283,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
@@ -299,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
@@ -343,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
@@ -369,13 +445,39 @@ module Thrift
       payload = buf.read
       transforms.each do |transform_id|
         if transform_id == HeaderTransformID::ZLIB
-          payload = Zlib::Inflate.inflate(payload)
+          payload = bounded_inflate(payload)
         end
       end
 
       StringIO.new(payload)
     end
 
+    # Inflates +compressed+ with a running byte-count check against @max_decompressed_size.
+    # Raises TransportException::SIZE_LIMIT if the decompressed output would exceed the limit.
+    def bounded_inflate(compressed)
+      inflater = Zlib::Inflate.new
+      buffer = Bytes.empty_byte_buffer
+      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}",
+          )
+        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
+    end
+
     # Flushes data in Header format
     def flush_header_format(payload)
       # Apply transforms
@@ -403,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
@@ -414,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
 
@@ -429,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
@@ -446,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

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,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)
@@ -44,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

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -35,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

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -20,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
@@ -47,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
@@ -57,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
@@ -70,6 +69,12 @@ module Thrift
       data
     end
 
+    def read_all(size)
+      raise TransportException.new(TransportException::NEGATIVE_SIZE, "Negative size") unless size >= 0
+
+      read(size)
+    end
+
     def read_byte
       raise EOFError.new("Not enough bytes remain in buffer") if @index >= @buf.size
       val = Bytes.get_string_byte(@buf, @index)

data/lib/thrift/transport/server_socket.rb

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,12 +19,12 @@
 # under the License.
 #
 
-require 'socket'
+require "socket"
 
 module Thrift
   class ServerSocket < BaseServerTransport
-    # call-seq: initialize(host = nil, port)
-    def initialize(host_or_port, port = nil)
+    # call-seq: initialize(host = nil, port, client_timeout: DEFAULT_CLIENT_TIMEOUT)
+    def initialize(host_or_port, port = nil, client_timeout: DEFAULT_CLIENT_TIMEOUT)
       if port
         @host = host_or_port
         @port = port
@@ -31,10 +32,11 @@ module Thrift
         @host = nil
         @port = host_or_port
       end
+      @client_timeout = client_timeout
       @handle = nil
     end
 
-    attr_reader :handle
+    attr_reader :handle, :client_timeout
 
     def listen
       @handle = TCPServer.new(@host, @port)
@@ -45,14 +47,15 @@ module Thrift
         sock = @handle.accept
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
         trans = Socket.new
+        trans.timeout = @client_timeout
         trans.handle = sock
         trans
       end
     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?
@@ -60,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