thrift 0.24.0 → 0.25.0

data/lib/thrift/protocol/binary_protocol.rb

@@ -24,20 +24,23 @@ module Thrift
     VERSION_1 = 0x80010000
     TYPE_MASK = 0x000000ff
     BYTE_MIN = -2**7
-    BYTE_MAX = 2**7 - 1
+    BYTE_MAX = (2**7) - 1
     I16_MIN = -2**15
-    I16_MAX = 2**15 - 1
+    I16_MAX = (2**15) - 1
     I32_MIN = -2**31
-    I32_MAX = 2**31 - 1
+    I32_MAX = (2**31) - 1
     I64_MIN = -2**63
-    I64_MAX = 2**63 - 1
+    I64_MAX = (2**63) - 1
 
-    attr_reader :strict_read, :strict_write
+    attr_reader :strict_read, :strict_write, :max_string_size
 
-    def initialize(trans, strict_read = true, strict_write = true)
+    def initialize(trans, strict_read = true, strict_write = true, max_string_size: DEFAULT_MAX_STRING_SIZE)
+      BaseProtocol.validate_max_string_size(max_string_size)
       super(trans)
+      @reset_message_size = trans.message_boundaries?
       @strict_read = strict_read
       @strict_write = strict_write
+      @max_string_size = max_string_size
 
       # Pre-allocated read buffer for fixed-size read methods. Needs to be at least 8 bytes long for
       # read_i64() and read_double().
@@ -46,9 +49,9 @@ module Thrift
 
     def write_message_begin(name, type, seqid)
       if strict_write
-        raise ::TypeError, 'integer argument expected' unless type.is_a?(Integer)
+        raise ::TypeError, "integer argument expected" unless type.is_a?(Integer)
         raise RangeError if type < BYTE_MIN || type > BYTE_MAX
-        trans.write([VERSION_1 | type].pack('N'))
+        trans.write([VERSION_1 | type].pack("N"))
         write_string(name)
         write_i32(seqid)
       else
@@ -90,48 +93,48 @@ module Thrift
     end
 
     def write_byte(byte)
-      raise 'nil argument not allowed!' if byte.nil?
-      raise ::TypeError, 'integer argument expected' unless byte.is_a?(Integer)
+      raise "nil argument not allowed!" if byte.nil?
+      raise ::TypeError, "integer argument expected" unless byte.is_a?(Integer)
       raise RangeError if byte < BYTE_MIN || byte > BYTE_MAX
-      trans.write([byte].pack('c'))
+      trans.write([byte].pack("c"))
     end
 
     def write_i16(i16)
-      raise 'nil argument not allowed!' if i16.nil?
-      raise ::TypeError, 'integer argument expected' unless i16.is_a?(Integer)
+      raise "nil argument not allowed!" if i16.nil?
+      raise ::TypeError, "integer argument expected" unless i16.is_a?(Integer)
       raise RangeError if i16 < I16_MIN || i16 > I16_MAX
-      trans.write([i16].pack('n'))
+      trans.write([i16].pack("n"))
     end
 
     def write_i32(i32)
-      raise 'nil argument not allowed!' if i32.nil?
-      raise ::TypeError, 'integer argument expected' unless i32.is_a?(Integer)
+      raise "nil argument not allowed!" if i32.nil?
+      raise ::TypeError, "integer argument expected" unless i32.is_a?(Integer)
       raise RangeError if i32 < I32_MIN || i32 > I32_MAX
-      trans.write([i32].pack('N'))
+      trans.write([i32].pack("N"))
     end
 
     def write_i64(i64)
-      raise 'nil argument not allowed!' if i64.nil?
-      raise ::TypeError, 'integer argument expected' unless i64.is_a?(Integer)
+      raise "nil argument not allowed!" if i64.nil?
+      raise ::TypeError, "integer argument expected" unless i64.is_a?(Integer)
       raise RangeError if i64 < I64_MIN || i64 > I64_MAX
       hi = i64 >> 32
       lo = i64 & 0xffffffff
-      trans.write([hi, lo].pack('N2'))
+      trans.write([hi, lo].pack("N2"))
     end
 
     def write_double(dub)
-      raise 'nil argument not allowed!' if dub.nil?
-      trans.write([dub].pack('G'))
+      raise "nil argument not allowed!" if dub.nil?
+      trans.write([dub].pack("G"))
     end
 
     def write_string(str)
-      raise 'nil argument not allowed!' if str.nil?
+      raise "nil argument not allowed!" if str.nil?
       buf = Bytes.convert_to_utf8_byte_buffer(str)
       write_binary(buf)
     end
 
     def write_binary(buf)
-      raise 'nil argument not allowed!' if buf.nil?
+      raise "nil argument not allowed!" if buf.nil?
       write_i32_size(buf.bytesize)
       trans.write(buf)
     end
@@ -142,10 +145,12 @@ module Thrift
     end
 
     def read_message_begin
+      trans.reset_message_size if @reset_message_size
+
       version = read_i32
       if version < 0
         if (version & VERSION_MASK != VERSION_1)
-          raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Missing version identifier')
+          raise ProtocolException.new(ProtocolException::BAD_VERSION, "Missing version identifier")
         end
         type = version & TYPE_MASK
         name = read_string
@@ -153,8 +158,9 @@ module Thrift
         [name, type, seqid]
       else
         if strict_read
-          raise ProtocolException.new(ProtocolException::BAD_VERSION, 'No version identifier, old protocol client?')
+          raise ProtocolException.new(ProtocolException::BAD_VERSION, "No version identifier, old protocol client?")
         end
+        check_string_size(version)
         name = trans.read_all(version)
         type = read_byte
         seqid = read_i32
@@ -178,21 +184,21 @@ module Thrift
       ktype = read_byte
       vtype = read_byte
       size = read_i32
-      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, "Negative size") unless size >= 0
       [ktype, vtype, size]
     end
 
     def read_list_begin
       etype = read_byte
       size = read_i32
-      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, "Negative size") unless size >= 0
       [etype, size]
     end
 
     def read_set_begin
       etype = read_byte
       size = read_i32
-      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size') unless size >= 0
+      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, "Negative size") unless size >= 0
       [etype, size]
     end
 
@@ -211,7 +217,7 @@ module Thrift
 
     def read_i16
       trans.read_into_buffer(@rbuf, 2)
-      val, = @rbuf.unpack('n')
+      val = @rbuf.unpack1("n")
       if (val > 0x7fff)
         val = 0 - ((val - 1) ^ 0xffff)
       end
@@ -220,7 +226,7 @@ module Thrift
 
     def read_i32
       trans.read_into_buffer(@rbuf, 4)
-      val, = @rbuf.unpack('N')
+      val = @rbuf.unpack1("N")
       if (val > 0x7fffffff)
         val = 0 - ((val - 1) ^ 0xffffffff)
       end
@@ -229,7 +235,7 @@ module Thrift
 
     def read_i64
       trans.read_into_buffer(@rbuf, 8)
-      hi, lo = @rbuf.unpack('N2')
+      hi, lo = @rbuf.unpack("N2")
       if (hi > 0x7fffffff)
         hi ^= 0xffffffff
         lo ^= 0xffffffff
@@ -241,8 +247,7 @@ module Thrift
 
     def read_double
       trans.read_into_buffer(@rbuf, 8)
-      val = @rbuf.unpack('G').first
-      val
+      @rbuf.unpack1("G")
     end
 
     def read_string
@@ -253,33 +258,42 @@ module Thrift
     def read_binary
       size = read_i32
       if size >= 0
+        check_string_size(size)
         trans.read_all(size)
       else
-        raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, 'Negative size')
+        raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, "Negative size")
       end
     end
 
+    def skip_string
+      read_binary
+    end
+
     def read_uuid
       UUID.uuid_from_bytes(trans.read_all(16))
     end
 
     def to_s
-      "binary(#{super.to_s})"
+      "binary(#{super})"
     end
 
     private
 
     def write_i32_size(size)
-      raise 'nil argument not allowed!' if size.nil?
-      raise ::TypeError, 'integer argument expected' unless size.is_a?(Integer)
+      raise "nil argument not allowed!" if size.nil?
+      raise ::TypeError, "integer argument expected" unless size.is_a?(Integer)
       raise RangeError if size < 0 || size > I32_MAX
-      trans.write([size].pack('N'))
+      trans.write([size].pack("N"))
     end
   end
 
   class BinaryProtocolFactory < BaseProtocolFactory
+    def initialize(max_string_size: BaseProtocol::DEFAULT_MAX_STRING_SIZE)
+      @max_string_size = max_string_size
+    end
+
     def get_protocol(trans)
-      return Thrift::BinaryProtocol.new(trans)
+      Thrift::BinaryProtocol.new(trans, max_string_size: @max_string_size)
     end
 
     def to_s

data/lib/thrift/protocol/binary_protocol_accelerated.rb

@@ -29,11 +29,15 @@ See MemoryBuffer and BufferedTransport for examples.
 
 module Thrift
   class BinaryProtocolAcceleratedFactory < BaseProtocolFactory
+    def initialize(max_string_size: BaseProtocol::DEFAULT_MAX_STRING_SIZE)
+      @max_string_size = max_string_size
+    end
+
     def get_protocol(trans)
       if (defined? BinaryProtocolAccelerated)
-        BinaryProtocolAccelerated.new(trans)
+        BinaryProtocolAccelerated.new(trans, max_string_size: @max_string_size)
       else
-        BinaryProtocol.new(trans)
+        BinaryProtocol.new(trans, max_string_size: @max_string_size)
       end
     end