thrift 0.24.0 → 0.25.0

data/lib/thrift/struct_union.rb

@@ -17,7 +17,9 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-require 'set'
+require "set"
+require "thrift/exceptions"
+require "thrift/types"
 
 module Thrift
   module Struct_Union
@@ -49,16 +51,17 @@ module Thrift
       end
     end
 
-    def read_field(iprot, field = {})
+    def read_field(iprot, field = {}, remaining_depth = DEFAULT_RECURSION_DEPTH)
       case field[:type]
       when Types::STRUCT
+        remaining_depth -= 1
         value = field[:class].new
-        value.read(iprot)
+        value.read(iprot, remaining_depth)
       when Types::MAP
         key_type, val_type, size = iprot.read_map_begin
-        raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+        iprot.validate_container_size(size)
         # Skip the map contents if the declared key or value types don't match the expected ones.
-        if (size != 0 && (key_type != field[:key][:type] || val_type != field[:value][:type]))
+        if size != 0 && (key_type != field[:key][:type] || val_type != field[:value][:type])
           size.times do
             iprot.skip(key_type)
             iprot.skip(val_type)
@@ -67,15 +70,15 @@ module Thrift
         else
           value = {}
           size.times do
-            k = read_field(iprot, field_info(field[:key]))
-            v = read_field(iprot, field_info(field[:value]))
+            k = read_field(iprot, field_info(field[:key]), remaining_depth)
+            v = read_field(iprot, field_info(field[:value]), remaining_depth)
             value[k] = v
           end
         end
         iprot.read_map_end
       when Types::LIST
         e_type, size = iprot.read_list_begin
-        raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+        iprot.validate_container_size(size)
         # Skip the list contents if the declared element type doesn't match the expected one.
         if (e_type != field[:element][:type])
           size.times do
@@ -85,13 +88,13 @@ module Thrift
         else
           value = []
           size.times do
-            value << read_field(iprot, field_info(field[:element]))
+            value << read_field(iprot, field_info(field[:element]), remaining_depth)
           end
         end
         iprot.read_list_end
       when Types::SET
         e_type, size = iprot.read_set_begin
-        raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+        iprot.validate_container_size(size)
         # Skip the set contents if the declared element type doesn't match the expected one.
         if (e_type != field[:element][:type])
           size.times do
@@ -100,7 +103,7 @@ module Thrift
         else
           value = Set.new
           size.times do
-            element = read_field(iprot, field_info(field[:element]))
+            element = read_field(iprot, field_info(field[:element]), remaining_depth)
             value << element
           end
         end
@@ -111,33 +114,36 @@ module Thrift
       value
     end
 
-    def write_data(oprot, value, field)
+    def write_data(oprot, value, field, remaining_depth = DEFAULT_RECURSION_DEPTH)
       if is_container? field[:type]
-        write_container(oprot, value, field)
+        write_container(oprot, value, field, remaining_depth)
+      elsif field[:type] == Types::STRUCT
+        remaining_depth -= 1
+        value.write(oprot, remaining_depth)
       else
         oprot.write_type(field, value)
       end
     end
 
-    def write_container(oprot, value, field = {})
+    def write_container(oprot, value, field = {}, remaining_depth = DEFAULT_RECURSION_DEPTH)
       case field[:type]
       when Types::MAP
         oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
         value.each do |k, v|
-          write_data(oprot, k, field[:key])
-          write_data(oprot, v, field[:value])
+          write_data(oprot, k, field[:key], remaining_depth)
+          write_data(oprot, v, field[:value], remaining_depth)
         end
         oprot.write_map_end
       when Types::LIST
         oprot.write_list_begin(field[:element][:type], value.size)
         value.each do |elem|
-          write_data(oprot, elem, field[:element])
+          write_data(oprot, elem, field[:element], remaining_depth)
         end
         oprot.write_list_end
       when Types::SET
         oprot.write_set_begin(field[:element][:type], value.size)
         value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
-          write_data(oprot, v, field[:element])
+          write_data(oprot, v, field[:element], remaining_depth)
         end
         oprot.write_set_end
       else
@@ -154,11 +160,13 @@ module Thrift
     end
 
     def field_info(field)
-      { :type => field[:type],
-        :class => field[:class],
-        :key => field[:key],
-        :value => field[:value],
-        :element => field[:element] }
+      {
+        type: field[:type],
+        class: field[:class],
+        key: field[:key],
+        value: field[:value],
+        element: field[:element],
+      }
     end
 
     def inspect_field(value, field_info)
@@ -166,9 +174,8 @@ module Thrift
         "#{enum_class.const_get(:VALUE_MAP)[value]} (#{value})"
       elsif value.is_a? Hash
         if field_info[:type] == Types::MAP
-          map_buf = []
-          value.each do |k, v|
-            map_buf << inspect_field(k, field_info[:key]) + ": " + inspect_field(v, field_info[:value])
+          map_buf = value.map do |k, v|
+            inspect_field(k, field_info[:key]) + ": " + inspect_field(v, field_info[:value])
           end
           "{" + map_buf.join(", ") + "}"
         else
@@ -180,16 +187,15 @@ module Thrift
       elsif value.is_a? Set
         inspect_collection(value, field_info)
       elsif value.is_a?(String) && field_info[:binary]
-        value.unpack("H*").first
+        value.unpack1("H*")
       else
         value.inspect
       end
     end
 
     def inspect_collection(collection, field_info)
-      buf = []
-      collection.each do |k|
-        buf << inspect_field(k, field_info[:element])
+      buf = collection.map do |element|
+        inspect_field(element, field_info[:element])
       end
       "[" + buf.join(", ") + "]"
     end

data/lib/thrift/transport/base_transport.rb

@@ -56,6 +56,11 @@ module Thrift
 
     def close; end
 
+    # Returns true when the transport needs protocol message boundary notifications.
+    def message_boundaries?
+      false
+    end
+
     # Reads a number of bytes from the transports. The String returned will have a BINARY (aka ASCII-8BIT) encoding.
     #
     # sz - The number of bytes to read from the transport.
@@ -68,7 +73,7 @@ module Thrift
     # Returns an unsigned byte as a Integer in the range (0..255).
     def read_byte
       buf = read_all(1)
-      return Bytes.get_string_byte(buf, 0)
+      Bytes.get_string_byte(buf, 0)
     end
 
     # Reads size bytes and copies them into buffer[0..size].
@@ -83,12 +88,25 @@ 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
       return Bytes.empty_byte_buffer if size == 0
-      buf = Bytes.force_binary_encoding(read(size))
+
+      buf = read(size)
+      if buf.nil? || buf.empty?
+        raise TransportException.new(TransportException::END_OF_FILE, "No more data available")
+      end
+
+      buf = Bytes.force_binary_encoding(buf)
+      return buf if buf.length >= size
+
+      buf = buf.dup if buf.frozen?
       while (buf.length < size)
         chunk = read(size - buf.length)
-        buf << chunk
+        if chunk.nil? || chunk.empty?
+          raise TransportException.new(TransportException::END_OF_FILE, "No more data available")
+        end
+
+        buf << Bytes.force_binary_encoding(chunk)
       end
 
       buf
@@ -111,7 +129,7 @@ module Thrift
 
   class BaseTransportFactory
     def get_transport(trans)
-      return trans
+      trans
     end
 
     def to_s

data/lib/thrift/transport/buffered_transport.rb

@@ -31,7 +31,7 @@ module Thrift
     end
 
     def open?
-      return @transport.open?
+      @transport.open?
     end
 
     def open
@@ -66,7 +66,7 @@ module Thrift
       # The read buffer has some data now, read a single byte. Using get_string_byte() avoids
       # allocating a temp string of size 1 unnecessarily.
       @index += 1
-      return Bytes.get_string_byte(@rbuf, @index - 1)
+      Bytes.get_string_byte(@rbuf, @index - 1)
     end
 
     # Reads a number of bytes from the transport into the buffer passed.
@@ -107,13 +107,13 @@ module Thrift
     end
 
     def to_s
-      "buffered(#{@transport.to_s})"
+      "buffered(#{@transport})"
     end
   end
 
   class BufferedTransportFactory < BaseTransportFactory
     def get_transport(transport)
-      return BufferedTransport.new(transport)
+      BufferedTransport.new(transport)
     end
 
     def to_s

data/lib/thrift/transport/framed_transport.rb

@@ -21,15 +21,30 @@
 
 module Thrift
   class FramedTransport < BaseTransport
-    def initialize(transport, read = true, write = true)
+    # The largest frame accepted by default. The value the Java, netstd, C++
+    # and Python framed transports use.
+    DEFAULT_MAX_FRAME_SIZE = 16_384_000
+
+    # The frame length field is 30 bits, so no frame can usefully be larger
+    # than this whatever a caller configures.
+    HARD_MAX_FRAME_SIZE = 0x3FFFFFFF
+
+    def initialize(transport, read = true, write = true, max_frame_size: DEFAULT_MAX_FRAME_SIZE)
+      unless max_frame_size > 0 && max_frame_size <= HARD_MAX_FRAME_SIZE
+        raise ArgumentError, "max_frame_size must be > 0 and <= #{HARD_MAX_FRAME_SIZE}"
+      end
+
       @transport = transport
       @rbuf      = Bytes.empty_byte_buffer
       @wbuf      = Bytes.empty_byte_buffer
       @read      = read
       @write     = write
       @index     = 0
+      @max_frame_size = max_frame_size
     end
 
+    attr_reader :max_frame_size
+
     def open?
       @transport.open?
     end
@@ -54,14 +69,14 @@ module Thrift
     end
 
     def read_byte
-      return @transport.read_byte() unless @read
+      return @transport.read_byte unless @read
 
       read_frame if @index >= @rbuf.length
 
       # The read buffer has some data now, read a single byte. Using get_string_byte() avoids
       # allocating a temp string of size 1 unnecessarily.
       @index += 1
-      return Bytes.get_string_byte(@rbuf, @index - 1)
+      Bytes.get_string_byte(@rbuf, @index - 1)
     end
 
     def read_into_buffer(buffer, size)
@@ -92,7 +107,7 @@ module Thrift
     def flush
       return @transport.flush unless @write
 
-      out = [@wbuf.length].pack('N')
+      out = [@wbuf.length].pack("N")
       # Array#pack should return a BINARY encoded String, so it shouldn't be necessary to force encoding
       out << @wbuf
       @transport.write(out)
@@ -101,13 +116,23 @@ module Thrift
     end
 
     def to_s
-      "framed(#{@transport.to_s})"
+      "framed(#{@transport})"
     end
 
     private
 
     def read_frame
-      sz = @transport.read_all(4).unpack('N').first
+      sz = @transport.read_all(4).unpack1("N")
+      raise TransportException.new(TransportException::END_OF_FILE, "Cannot read from a zero-length frame") if sz == 0
+
+      # Checked before the read, not after: read_all accumulates whatever the
+      # four bytes declare while the peer decides how much of it to send.
+      if sz > @max_frame_size
+        raise TransportException.new(
+          TransportException::UNKNOWN,
+          "Frame size #{sz} exceeds maximum #{@max_frame_size}",
+        )
+      end
 
       @index = 0
       @rbuf = @transport.read_all(sz)
@@ -116,7 +141,7 @@ module Thrift
 
   class FramedTransportFactory < BaseTransportFactory
     def get_transport(transport)
-      return FramedTransport.new(transport)
+      FramedTransport.new(transport)
     end
 
     def to_s