thrift 0.23.0 → 0.25.0

data/ext/thrift_native.c

@@ -92,6 +92,7 @@ ID skip_method_id;
 ID write_method_id;
 ID read_all_method_id;
 ID read_into_buffer_method_id;
+ID reset_message_size_method_id;
 ID force_binary_encoding_id;
 ID convert_to_utf8_byte_buffer_id;
 ID convert_to_string_id;
@@ -99,8 +100,10 @@ ID convert_to_string_id;
 // constant ids
 ID fields_const_id;
 ID transport_ivar_id;
+ID reset_message_size_ivar_id;
 ID strict_read_ivar_id;
 ID strict_write_ivar_id;
+ID max_string_size_ivar_id;
 
 // cached symbols
 VALUE type_sym;
@@ -121,6 +124,7 @@ int PROTOERR_BAD_VERSION;
 int PROTOERR_NOT_IMPLEMENTED;
 int PROTOERR_DEPTH_LIMIT;
 
+// cppcheck-suppress unusedFunction
 RUBY_FUNC_EXPORTED void Init_thrift_native(void) {
   // cached classes
   thrift_module = rb_const_get(rb_cObject, rb_intern("Thrift"));
@@ -199,6 +203,7 @@ RUBY_FUNC_EXPORTED void Init_thrift_native(void) {
   write_method_id = rb_intern("write");
   read_all_method_id = rb_intern("read_all");
   read_into_buffer_method_id = rb_intern("read_into_buffer");
+  reset_message_size_method_id = rb_intern("reset_message_size");
   force_binary_encoding_id = rb_intern("force_binary_encoding");
   convert_to_utf8_byte_buffer_id = rb_intern("convert_to_utf8_byte_buffer");
   convert_to_string_id = rb_intern("convert_to_string");
@@ -206,8 +211,10 @@ RUBY_FUNC_EXPORTED void Init_thrift_native(void) {
   // constant ids
   fields_const_id = rb_intern("FIELDS");
   transport_ivar_id = rb_intern("@trans");
+  reset_message_size_ivar_id = rb_intern("@reset_message_size");
   strict_read_ivar_id = rb_intern("@strict_read");
   strict_write_ivar_id = rb_intern("@strict_write");
+  max_string_size_ivar_id = rb_intern("@max_string_size");
 
   // cached symbols
   type_sym = ID2SYM(rb_intern("type"));

data/lib/thrift/bytes.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
@@ -28,21 +29,23 @@ module Thrift
     # Returns a String with BINARY encoding, filled with null characters
     # if size is greater than zero
     def self.empty_byte_buffer(size = nil)
-      if (size && size > 0)
+      if size && size > 0
         "\0".b * size
       else
-        ''.b
+        "".b
       end
     end
 
     # Forces the encoding of the buffer to BINARY. If the buffer
-    # passed is frozen, then it will be duplicated.
+    # passed is frozen and not already BINARY, then it will be duplicated.
     #
     # buffer - The String to force the encoding of.
     #
     # Returns the String passed with an encoding of BINARY; returned
     # String may be a duplicate.
     def self.force_binary_encoding(buffer)
+      return buffer if buffer.encoding == Encoding::BINARY
+
       buffer = buffer.dup if buffer.frozen?
       buffer.force_encoding(Encoding::BINARY)
     end

data/lib/thrift/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -30,42 +31,22 @@ module Thrift
     end
 
     def send_message(name, args_class, args = {})
-      seqid = next_seqid!
-      @oprot.write_message_begin(name, MessageTypes::CALL, seqid)
-      send_message_args(args_class, args)
-      @pending_seqids << seqid
+      write_message(name, MessageTypes::CALL, args_class, args)
     end
 
     def send_oneway_message(name, args_class, args = {})
-      @oprot.write_message_begin(name, MessageTypes::ONEWAY, next_seqid!)
-      send_message_args(args_class, args)
+      write_message(name, MessageTypes::ONEWAY, args_class, args)
     end
 
     def send_message_args(args_class, args)
-      data = args_class.new
-      args.each do |k, v|
-        data.send("#{k.to_s}=", v)
-      end
-      begin
-        data.write(@oprot)
-      rescue StandardError => e
-        @oprot.trans.close
-        raise e
-      end
-      @oprot.write_message_end
-      @oprot.trans.flush
+      write_message(nil, nil, args_class, args)
     end
 
-    def receive_message_begin()
+    def receive_message_begin
       fname, mtype, rseqid = @iprot.read_message_begin
       [fname, mtype, rseqid]
     end
 
-    def reply_seqid(rseqid)
-      expected_seqid = dequeue_pending_seqid
-      !expected_seqid.nil? && rseqid == expected_seqid
-    end
-
     def validate_message_begin(fname, mtype, rseqid, expected_name)
       expected_seqid = dequeue_pending_seqid
 
@@ -76,14 +57,14 @@ module Thrift
       if mtype != MessageTypes::REPLY
         raise ApplicationException.new(
           ApplicationException::INVALID_MESSAGE_TYPE,
-          "#{expected_name} failed: invalid message type"
+          "#{expected_name} failed: invalid message type",
         )
       end
 
       if fname != expected_name
         raise ApplicationException.new(
           ApplicationException::WRONG_METHOD_NAME,
-          "#{expected_name} failed: wrong method name"
+          "#{expected_name} failed: wrong method name",
         )
       end
 
@@ -91,7 +72,7 @@ module Thrift
 
       raise ApplicationException.new(
         ApplicationException::BAD_SEQUENCE_ID,
-        "#{expected_name} failed: out of sequence response"
+        "#{expected_name} failed: out of sequence response",
       )
     end
 
@@ -102,14 +83,31 @@ module Thrift
       result
     end
 
-    def handle_exception(mtype)
-      if mtype == MessageTypes::EXCEPTION
-        dequeue_pending_seqid
-        raise_application_exception
+    private
+
+    def write_message(name, type, args_class, args)
+      data = args_class.new
+      args.each do |k, v|
+        data.send("#{k}=", v)
       end
-    end
+      seqid = next_seqid! unless name.nil?
 
-    private
+      flush_result = begin
+        @oprot.write_message_begin(name, type, seqid) unless name.nil?
+        data.write(@oprot)
+        @oprot.write_message_end
+        @oprot.trans.flush
+      rescue StandardError
+        begin
+          @oprot.trans.close
+        rescue StandardError
+          # Preserve the original send error.
+        end
+        raise
+      end
+
+      type == MessageTypes::CALL ? @pending_seqids << seqid : flush_result
+    end
 
     def next_seqid!
       seqid = @seqid

data/lib/thrift/exceptions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,6 +19,8 @@
 #
 
 module Thrift
+  DEFAULT_RECURSION_DEPTH = 64
+
   class Exception < StandardError
     def initialize(message)
       super
@@ -28,7 +31,6 @@ module Thrift
   end
 
   class ApplicationException < Exception
-
     UNKNOWN = 0
     UNKNOWN_METHOD = 1
     INVALID_MESSAGE_TYPE = 2
@@ -48,10 +50,11 @@ module Thrift
       @type = type
     end
 
-    def read(iprot)
+    def read(iprot, remaining_depth = DEFAULT_RECURSION_DEPTH)
+      raise ProtocolException.new(ProtocolException::DEPTH_LIMIT, "Maximum recursion depth exceeded") if remaining_depth <= 0
       iprot.read_struct_begin
       while true
-        fname, ftype, fid = iprot.read_field_begin
+        _, ftype, fid = iprot.read_field_begin
         if ftype == Types::STOP
           break
         end
@@ -67,21 +70,21 @@ module Thrift
       iprot.read_struct_end
     end
 
-    def write(oprot)
-      oprot.write_struct_begin('Thrift::ApplicationException')
+    def write(oprot, remaining_depth = DEFAULT_RECURSION_DEPTH)
+      raise ProtocolException.new(ProtocolException::DEPTH_LIMIT, "Maximum recursion depth exceeded") if remaining_depth <= 0
+      oprot.write_struct_begin("Thrift::ApplicationException")
       unless @message.nil?
-        oprot.write_field_begin('message', Types::STRING, 1)
+        oprot.write_field_begin("message", Types::STRING, 1)
         oprot.write_string(@message)
         oprot.write_field_end
       end
       unless @type.nil?
-        oprot.write_field_begin('type', Types::I32, 2)
+        oprot.write_field_begin("type", Types::I32, 2)
         oprot.write_i32(@type)
         oprot.write_field_end
       end
       oprot.write_field_stop
       oprot.write_struct_end
     end
-
   end
 end

data/lib/thrift/multiplexed_processor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -16,24 +17,33 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'thrift/protocol/protocol_decorator'
-require 'thrift/protocol/base_protocol'
+require "thrift/protocol/protocol_decorator"
+require "thrift/protocol/base_protocol"
 
 module Thrift
   class MultiplexedProcessor
     def initialize
       @actual_processors = {}
+      @default_processor = nil
     end
 
     def register_processor(service_name, processor)
       @actual_processors[service_name] = processor
     end
 
+    def register_default(processor)
+      @default_processor = processor
+    end
+
     def process(iprot, oprot)
       name, type, seqid = iprot.read_message_begin
       check_type(type)
-      check_separator(name)
-      service_name, method = name.split(':')
+      if name.count(":") < 1
+        check_default_processor(name)
+        return @default_processor.process(StoredMessageProtocol.new(iprot, [name, type, seqid]), oprot)
+      end
+
+      service_name, method = name.split(":", 2)
       processor(service_name).process(StoredMessageProtocol.new(iprot, [method, type, seqid]), oprot)
     end
 
@@ -49,19 +59,18 @@ module Thrift
 
     def check_type(type)
       unless [MessageTypes::CALL, MessageTypes::ONEWAY].include?(type)
-        raise Thrift::Exception.new('This should not have happened!?')
+        raise Thrift::Exception.new("This should not have happened!?")
       end
     end
 
-    def check_separator(name)
-      if name.count(':') < 1
+    def check_default_processor(name)
+      unless @default_processor
         raise Thrift::Exception.new("Service name not found in message name: #{name}. Did you forget to use a Thrift::Protocol::MultiplexedProtocol in your client?")
       end
     end
   end
 
   class StoredMessageProtocol < BaseProtocol
-
     include ProtocolDecorator
 
     def initialize(protocol, message_begin)

data/lib/thrift/processor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -17,10 +18,15 @@
 # under the License.
 #
 
-require 'logger'
+require "logger"
+require "thrift/protocol/base_protocol"
 
 module Thrift
   module Processor
+    class ArgumentProtocolException < ProtocolException
+    end
+    private_constant :ArgumentProtocolException
+
     def initialize(handler, logger = nil)
       @handler = handler
       if logger.nil?
@@ -33,11 +39,25 @@ module Thrift
 
     def process(iprot, oprot)
       name, type, seqid = iprot.read_message_begin
+      unless type == MessageTypes::CALL || type == MessageTypes::ONEWAY
+        iprot.skip(Types::STRUCT)
+        iprot.read_message_end
+        x = ApplicationException.new(
+          ApplicationException::INVALID_MESSAGE_TYPE,
+          "Invalid message type #{type} for function #{name}",
+        )
+        write_error(x, oprot, name, seqid)
+        return false
+      end
+
       if respond_to?("process_#{name}")
         begin
           send("process_#{name}", seqid, iprot, oprot)
+        rescue ArgumentProtocolException => e
+          x = ApplicationException.new(ApplicationException::PROTOCOL_ERROR, e.message)
+          write_error(x, oprot, name, seqid)
         rescue => e
-          x = ApplicationException.new(ApplicationException::INTERNAL_ERROR, 'Internal error')
+          x = ApplicationException.new(ApplicationException::INTERNAL_ERROR, "Internal error")
           @logger.debug "Internal error : #{e.message}\n#{e.backtrace.join("\n")}"
           write_error(x, oprot, name, seqid)
         end
@@ -45,7 +65,7 @@ module Thrift
       else
         iprot.skip(Types::STRUCT)
         iprot.read_message_end
-        x = ApplicationException.new(ApplicationException::UNKNOWN_METHOD, 'Unknown function '+name)
+        x = ApplicationException.new(ApplicationException::UNKNOWN_METHOD, "Unknown function " + name)
         write_error(x, oprot, name, seqid)
         false
       end
@@ -56,6 +76,8 @@ module Thrift
       args.read(iprot)
       iprot.read_message_end
       args
+    rescue ProtocolException => e
+      raise ArgumentProtocolException.new(e.type, e.message)
     end
 
     def write_result(result, oprot, name, seqid)

data/lib/thrift/protocol/base_protocol.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,11 +19,11 @@
 #
 
 # this require is to make generated struct definitions happy
-require 'set'
+require "set"
+require "thrift/exceptions"
 
 module Thrift
   class ProtocolException < Exception
-
     UNKNOWN = 0
     INVALID_DATA = 1
     NEGATIVE_SIZE = 2
@@ -40,6 +41,14 @@ module Thrift
   end
 
   class BaseProtocol
+    MAX_CONTAINER_SIZE = (1 << 31) - 1
+
+    # The longest string or binary field BinaryProtocol and CompactProtocol read
+    # by default: the frame size limit the framed transports apply. A string's
+    # length is the read size handed to the transport, and an unframed transport
+    # has no frame to bound it. Pass max_string_size: nil to read strings of any
+    # length.
+    DEFAULT_MAX_STRING_SIZE = 16_384_000
 
     attr_reader :trans
 
@@ -48,10 +57,24 @@ module Thrift
     end
 
     def native?
-      puts "wrong method is being called!"
       false
     end
 
+    # Raises a SIZE_LIMIT ProtocolException when a declared string length is over
+    # the protocol's max_string_size.
+    def check_string_size(size)
+      max = @max_string_size
+      return if max.nil? || size <= max
+
+      raise ProtocolException.new(ProtocolException::SIZE_LIMIT, "String size #{size} larger than the maximum #{max}")
+    end
+
+    def self.validate_max_string_size(max_string_size)
+      return if max_string_size.nil? || (max_string_size.is_a?(Integer) && max_string_size > 0)
+
+      raise ArgumentError, "max_string_size must be nil or a positive Integer"
+    end
+
     def write_message_begin(name, type, seqid)
       raise NotImplementedError
     end
@@ -228,6 +251,10 @@ module Thrift
       raise NotImplementedError
     end
 
+    def skip_string
+      read_string
+    end
+
     # Writes a field based on the field information, field ID and value.
     #
     # field_info - A Hash containing the definition of the field:
@@ -236,25 +263,19 @@ module Thrift
     #              :binary - A Boolean flag that indicates if Thrift::Types::STRING is a binary string (string without encoding).
     # fid        - The ID of the field.
     # value      - The field's value to write; object type varies based on :type.
+    # remaining_depth - The optional recursion budget of the enclosing struct.
     #
     # Returns nothing.
-    def write_field(*args)
-      if args.size == 3
-        # handles the documented method signature - write_field(field_info, fid, value)
-        field_info = args[0]
-        fid = args[1]
-        value = args[2]
-      elsif args.size == 4
-        # handles the deprecated method signature - write_field(name, type, fid, value)
-        field_info = {:name => args[0], :type => args[1]}
-        fid = args[2]
-        value = args[3]
-      else
-        raise ArgumentError, "wrong number of arguments (#{args.size} for 3)"
+    def write_field(field_info, fid, value, remaining_depth = nil)
+      unless field_info.is_a?(Hash)
+        field_info = {name: field_info, type: fid}
+        fid = value
+        value = remaining_depth
+        remaining_depth = nil
       end
 
       write_field_begin(field_info[:name], field_info[:type], fid)
-      write_type(field_info, value)
+      write_type(field_info, value, remaining_depth)
       write_field_end
     end
 
@@ -264,13 +285,14 @@ module Thrift
     #              :type   - The Thrift::Types constant that determines how the value is written.
     #              :binary - A Boolean flag that indicates if Thrift::Types::STRING is a binary string (string without encoding).
     # value      - The field's value to write; object type varies based on field_info[:type].
+    # remaining_depth - The optional recursion budget of the enclosing struct.
     #
     # Returns nothing.
-    def write_type(field_info, value)
+    def write_type(field_info, value, remaining_depth = nil)
       # if field_info is a Integer, assume it is a Thrift::Types constant
       # convert it into a field_info Hash for backwards compatibility
       if field_info.is_a? Integer
-        field_info = {:type => field_info}
+        field_info = {type: field_info}
       end
 
       case field_info[:type]
@@ -295,7 +317,11 @@ module Thrift
       when Types::UUID
         write_uuid(value)
       when Types::STRUCT
-        value.write(self)
+        if remaining_depth
+          value.write(self, remaining_depth - 1)
+        else
+          value.write(self)
+        end
       else
         raise NotImplementedError
       end
@@ -312,7 +338,7 @@ module Thrift
       # if field_info is a Integer, assume it is a Thrift::Types constant
       # convert it into a field_info Hash for backwards compatibility
       if field_info.is_a? Integer
-        field_info = {:type => field_info}
+        field_info = {type: field_info}
       end
 
       case field_info[:type]
@@ -341,7 +367,8 @@ module Thrift
       end
     end
 
-    def skip(type)
+    def skip(type, max_depth = 64)
+      raise ProtocolException.new(ProtocolException::DEPTH_LIMIT, "Maximum skip depth exceeded") if max_depth <= 0
       case type
       when Types::BOOL
         read_bool
@@ -356,44 +383,52 @@ module Thrift
       when Types::DOUBLE
         read_double
       when Types::STRING
-        read_string
+        skip_string
       when Types::UUID
         read_uuid
       when Types::STRUCT
         read_struct_begin
         while true
-          name, type, id = read_field_begin
+          _, type, _ = read_field_begin
           break if type == Types::STOP
-          skip(type)
+          skip(type, max_depth - 1)
           read_field_end
         end
         read_struct_end
       when Types::MAP
         ktype, vtype, size = read_map_begin
+        validate_container_size(size)
         size.times do
-          skip(ktype)
-          skip(vtype)
+          skip(ktype, max_depth - 1)
+          skip(vtype, max_depth - 1)
         end
         read_map_end
       when Types::SET
         etype, size = read_set_begin
+        validate_container_size(size)
         size.times do
-          skip(etype)
+          skip(etype, max_depth - 1)
         end
         read_set_end
       when Types::LIST
         etype, size = read_list_begin
+        validate_container_size(size)
         size.times do
-          skip(etype)
+          skip(etype, max_depth - 1)
         end
         read_list_end
       else
-        raise ProtocolException.new(ProtocolException::INVALID_DATA, 'Invalid data')
+        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Invalid data")
       end
     end
 
+    def validate_container_size(size)
+      raise ProtocolException.new(ProtocolException::NEGATIVE_SIZE, "Negative size") unless size >= 0
+      raise ProtocolException.new(ProtocolException::SIZE_LIMIT, "Container size limit exceeded") if size > MAX_CONTAINER_SIZE
+    end
+
     def to_s
-      "#{trans.to_s}"
+      trans.to_s
     end
   end