dalli 3.2.15 → 4.0.0

data/lib/dalli/protocol/value_compressor.rb

@@ -15,33 +15,18 @@ module Dalli
         compress: true,
         compressor: ::Dalli::Compressor,
         # min byte size to attempt compression
-        compression_min_size: 4 * 1024, # 4K
-        # max size a stored value may decompress to (nil: no limit). Guards
-        # against a small compressed value expanding into gigabytes on read.
-        decompressed_max_bytes: 128 * 1024 * 1024 # 128 MiB
+        compression_min_size: 4 * 1024 # 4K
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      KEYWORD_PARAMETER_TYPES = %i[key keyreq].freeze
-      private_constant :KEYWORD_PARAMETER_TYPES
-
       # https://www.hjp.at/zettel/m/memcached_flags.rxml
       # Looks like most clients use bit 1 to indicate gzip compression.
       FLAG_COMPRESSED = 0x2
 
       def initialize(client_options)
-        # Support the deprecated compression option, but don't allow it to override
-        # an explicit compress
-        # Remove this with 4.0
-        if client_options.key?(:compression) && !client_options.key?(:compress)
-          Dalli.logger.warn "DEPRECATED: Dalli's :compression option is now just 'compress: true'.  " \
-                            'Please update your configuration.'
-          client_options[:compress] = client_options.delete(:compression)
-        end
-
         @compression_options =
-          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(client_options.slice(*OPTIONS))
       end
 
       def store(value, req_options, bitflags)
@@ -53,16 +38,8 @@ module Dalli
       end
 
       def retrieve(value, bitflags)
-        return value unless bitflags.anybits?(FLAG_COMPRESSED)
-
-        max_bytes = @compression_options[:decompressed_max_bytes]
-        # Custom compressors that only define decompress(data) keep working,
-        # without the limit
-        if max_bytes && compressor_accepts_max_bytes?
-          compressor.decompress(value, max_bytes: max_bytes)
-        else
-          compressor.decompress(value)
-        end
+        compressed = bitflags.anybits?(FLAG_COMPRESSED)
+        compressed ? compressor.decompress(value) : value
 
       # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
       # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
@@ -71,19 +48,6 @@ module Dalli
         raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
       end
 
-      def compressor_accepts_max_bytes?
-        return @compressor_accepts_max_bytes if defined?(@compressor_accepts_max_bytes)
-
-        @compressor_accepts_max_bytes =
-          begin
-            compressor.method(:decompress).parameters.any? do |type, name|
-              name == :max_bytes && KEYWORD_PARAMETER_TYPES.include?(type)
-            end
-          rescue NameError # an object without a reflectable decompress method
-            false
-          end
-      end
-
       def compress_by_default?
         @compression_options[:compress]
       end
@@ -97,13 +61,11 @@ module Dalli
       end
 
       # Checks whether we should apply compression when serializing a value
-      # based on the specified options.  Returns false for a raw request
-      # (raw reads ignore bitflags, so the value must be stored as given) or
-      # unless the value is greater than the minimum compression size.
-      # Otherwise returns based on a method-level option if specified,
-      # falling back to the server default.
+      # based on the specified options.  Returns false unless the value
+      # is greater than the minimum compression size.  Otherwise returns
+      # based on a method-level option if specified, falling back to the
+      # server default.
       def compress_value?(value, req_options)
-        return false if req_options&.dig(:raw)
         return false unless value.bytesize >= compression_min_size
         return compress_by_default? unless req_options && !req_options[:compress].nil?
 

data/lib/dalli/protocol/value_marshaller.rb

@@ -27,7 +27,7 @@ module Dalli
         @value_compressor = ValueCompressor.new(client_options)
 
         @marshal_options =
-          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(client_options.slice(*OPTIONS))
       end
 
       def store(key, value, options = nil)

data/lib/dalli/protocol/value_serializer.rb

@@ -18,57 +18,53 @@ module Dalli
       # https://www.hjp.at/zettel/m/memcached_flags.rxml
       # Looks like most clients use bit 0 to indicate native language serialization
       FLAG_SERIALIZED = 0x1
+      FLAG_UTF8 = 0x2
+
+      # Class variable to track whether the Marshal warning has been logged
+      @@marshal_warning_logged = false # rubocop:disable Style/ClassVars
 
       attr_accessor :serialization_options
 
       def initialize(protocol_options)
         @serialization_options =
-          DEFAULTS.merge(protocol_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(protocol_options.slice(*OPTIONS))
+        warn_if_marshal_default(protocol_options) unless protocol_options[:silence_marshal_warning]
       end
 
       def store(value, req_options, bitflags)
-        do_serialize = !(req_options && req_options[:raw])
-        store_value = do_serialize ? serialize_value(value) : value.to_s
-        bitflags |= FLAG_SERIALIZED if do_serialize
-        [store_value, bitflags]
+        if req_options
+          return [value.to_s, bitflags] if req_options[:raw]
+
+          # If the value is a simple string, going through serialization is costly
+          # for no benefit other than preserving encoding.
+          # Assuming most strings are either UTF-8 or BINARY we can just store
+          # that information in the bitflags.
+          if req_options[:string_fastpath] && value.instance_of?(String)
+            case value.encoding
+            when Encoding::BINARY
+              return [value, bitflags]
+            when Encoding::UTF_8
+              return [value, bitflags | FLAG_UTF8]
+            end
+          end
+        end
+
+        [serialize_value(value), bitflags | FLAG_SERIALIZED]
       end
 
-      # TODO: Some of these error messages need to be validated.  It's not obvious
-      # that all of them are actually generated by the invoked code
-      # in current systems
-      # rubocop:disable Layout/LineLength
-      TYPE_ERR_REGEXP = %r{needs to have method `_load'|exception class/object expected|instance of IO needed|incompatible marshal file format}.freeze
-      ARGUMENT_ERR_REGEXP = /undefined class|marshal data too short/.freeze
-      NAME_ERR_STR = 'uninitialized constant'
-      # rubocop:enable Layout/LineLength
-
       def retrieve(value, bitflags)
-        serialized = (bitflags & FLAG_SERIALIZED) != 0
-        serialized ? serializer.load(value) : value
-      rescue TypeError => e
-        filter_type_error(e)
-      rescue ArgumentError => e
-        filter_argument_error(e)
-      rescue NameError => e
-        filter_name_error(e)
-      end
-
-      def filter_type_error(err)
-        raise err unless TYPE_ERR_REGEXP.match?(err.message)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
-      end
-
-      def filter_argument_error(err)
-        raise err unless ARGUMENT_ERR_REGEXP.match?(err.message)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
-      end
-
-      def filter_name_error(err)
-        raise err unless err.message.include?(NAME_ERR_STR)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
+        serialized = bitflags.anybits?(FLAG_SERIALIZED)
+        if serialized
+          begin
+            serializer.load(value)
+          rescue StandardError
+            raise UnmarshalError, 'Unable to unmarshal value'
+          end
+        elsif bitflags.anybits?(FLAG_UTF8)
+          value.force_encoding(Encoding::UTF_8)
+        else
+          value
+        end
       end
 
       def serializer
@@ -86,6 +82,19 @@ module Dalli
         exc.set_backtrace e.backtrace
         raise exc
       end
+
+      private
+
+      def warn_if_marshal_default(protocol_options)
+        return if protocol_options.key?(:serializer)
+        return if @@marshal_warning_logged
+
+        Dalli.logger.warn 'SECURITY WARNING: Dalli is using Marshal for serialization. ' \
+                          'Marshal can execute arbitrary code during deserialization. ' \
+                          'If your memcached server could be compromised, consider using ' \
+                          'a safer serializer like JSON: Dalli::Client.new(servers, serializer: JSON)'
+        @@marshal_warning_logged = true # rubocop:disable Style/ClassVars
+      end
     end
   end
 end

data/lib/dalli/protocol.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'openssl'
 require 'timeout'
 
 module Dalli
@@ -16,11 +15,5 @@ module Dalli
       else
         [Timeout::Error]
       end
-
-    # SSL errors during the TLS handshake count as a failed request: they
-    # trigger reconnection and, after socket_max_failures, mark the server
-    # down. openssl is required above because this file loads before
-    # dalli/socket, so OpenSSL may not be defined yet.
-    SSL_ERRORS = [OpenSSL::SSL::SSLError].freeze
   end
 end

data/lib/dalli/socket.rb

@@ -52,7 +52,7 @@ module Dalli
 
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
-        options.reject { |k, _| FILTERED_OUT_OPTIONS.include? k }
+        options.except(*FILTERED_OUT_OPTIONS)
       end
     end
 
@@ -63,6 +63,7 @@ module Dalli
     ##
     class SSLSocket < ::OpenSSL::SSL::SSLSocket
       include Dalli::Socket::InstanceMethods
+
       def options
         io.options
       end
@@ -85,6 +86,7 @@ module Dalli
     ##
     class TCP < TCPSocket
       include Dalli::Socket::InstanceMethods
+
       # options - supports enhanced logging in the case of a timeout
       attr_accessor :options
 
@@ -117,57 +119,41 @@ module Dalli
       end
 
       def self.init_socket_options(sock, options)
+        configure_tcp_options(sock, options)
+        configure_socket_buffers(sock, options)
+        configure_timeout(sock, options)
+      end
+
+      def self.configure_tcp_options(sock, options)
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+      end
+
+      def self.configure_socket_buffers(sock, options)
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVBUF, options[:rcvbuf]) if options[:rcvbuf]
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
+      end
 
+      def self.configure_timeout(sock, options)
         return unless options[:socket_timeout]
 
-        seconds, fractional = options[:socket_timeout].divmod(1)
-        microseconds = fractional * 1_000_000
-        timeval = [seconds, microseconds].pack('l_2')
+        if sock.respond_to?(:timeout=)
+          sock.timeout = options[:socket_timeout]
+        else
+          seconds, fractional = options[:socket_timeout].divmod(1)
+          timeval = [seconds, fractional * 1_000_000].pack('l_2')
 
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+        end
       end
 
-      # Closes the TCP socket if the handshake fails or times out, so a failed
-      # attempt doesn't hold a file descriptor until GC.
       def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
-        warn_if_unverified(ssl_context)
-        connected = false
         ssl_socket = Dalli::Socket::SSLSocket.new(tcp_socket, ssl_context)
         ssl_socket.hostname = host
         ssl_socket.sync_close = true
         ssl_socket.connect
-        connected = true
         ssl_socket
-      ensure
-        tcp_socket.close unless connected
-      end
-
-      # Verification comes entirely from the caller's ssl_context, and a bare
-      # SSLContext.new verifies nothing, so warn (once per process) when the
-      # certificate or the hostname won't be checked.
-      def self.warn_if_unverified(ssl_context)
-        return if @ssl_verification_warning_logged
-
-        problem = unverified_problem(ssl_context)
-        return unless problem
-
-        Dalli.logger.warn "SECURITY WARNING: Dalli's ssl_context #{problem}. " \
-                          'Use ssl_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER, ' \
-                          'verify_hostname: true) to verify the server.'
-        @ssl_verification_warning_logged = true
-      end
-
-      def self.unverified_problem(ssl_context)
-        if !ssl_context.verify_mode.to_i.anybits?(::OpenSSL::SSL::VERIFY_PEER)
-          'verify_mode is VERIFY_NONE, so the server certificate is not checked'
-        elsif !ssl_context.verify_hostname
-          'verify_hostname is false, so the certificate is not checked against the hostname'
-        end
       end
     end
 
@@ -198,9 +184,16 @@ module Dalli
           Timeout.timeout(options[:socket_timeout]) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
+            init_socket_options(sock, options)
             sock
           end
         end
+
+        def self.init_socket_options(sock, options)
+          # https://man7.org/linux/man-pages/man7/unix.7.html
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
+          sock.timeout = options[:socket_timeout] if options[:socket_timeout] && sock.respond_to?(:timeout=)
+        end
       end
     end
   end

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '3.2.15'
+  VERSION = '4.0.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -4,8 +4,6 @@
 # Namespace for all Dalli code.
 ##
 module Dalli
-  autoload :Server, 'dalli/server'
-
   # generic error
   class DalliError < RuntimeError; end
 
@@ -27,6 +25,9 @@ module Dalli
   # operation is not permitted in a multi block
   class NotPermittedMultiOpError < DalliError; end
 
+  # raised when Memcached response with a SERVER_ERROR
+  class ServerError < DalliError; end
+
   # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
   class NilObject; end # rubocop:disable Lint/EmptyClass
   NOT_FOUND = NilObject.new
@@ -57,7 +58,6 @@ end
 require_relative 'dalli/version'
 
 require_relative 'dalli/compressor'
-require_relative 'dalli/json_serializer'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'

data/lib/rack/session/dalli.rb

@@ -9,6 +9,10 @@ module Rack
   module Session
     # Rack::Session::Dalli provides memcached based session management.
     class Dalli < Abstract::PersistedSecure
+      class MissingSessionError < StandardError; end
+
+      RACK_SESSION_PERSISTED = 'rack.session.persisted'
+
       attr_reader :data
 
       # Don't freeze this until we fix the specs/implementation
@@ -70,23 +74,37 @@ module Rack
         @data = build_data_source(options)
       end
 
-      def find_session(_req, sid)
+      def call(*_args)
+        super
+      rescue MissingSessionError
+        [401, {}, ['Wrong session ID']]
+      end
+
+      def find_session(req, sid)
         with_dalli_client([nil, {}]) do |dc|
           existing_session = existing_session_for_sid(dc, sid)
-          return [sid, existing_session] unless existing_session.nil?
+          if existing_session.nil?
+            sid = create_sid_with_empty_session(dc)
+            existing_session = {}
+          end
 
-          [create_sid_with_empty_session(dc), {}]
+          update_session_persisted_data(req, { id: sid })
+          return [sid, existing_session]
         end
       end
 
-      def write_session(_req, sid, session, options)
+      def write_session(req, sid, session, options)
         return false unless sid
 
         key = memcached_key_from_sid(sid)
         return false unless key
 
         with_dalli_client(false) do |dc|
-          dc.set(memcached_key_from_sid(sid), session, ttl(options[:expire_after]))
+          write_session_safely!(
+            dc, sid, session_persisted_data(req),
+            write_args: [memcached_key_from_sid(sid), session, ttl(options[:expire_after])]
+          )
+
           sid
         end
       end
@@ -145,6 +163,15 @@ module Rack
         end
       end
 
+      def write_session_safely!(dalli_client, sid, persisted_data, write_args:)
+        if persisted_data && persisted_data[:id] == sid # That means that we update the existing session
+          # Override the session only if it still exists in the store!
+          raise MissingSessionError unless dalli_client.replace(*write_args)
+        else
+          dalli_client.set(*write_args)
+        end
+      end
+
       def extract_dalli_options(options)
         raise 'Rack::Session::Dalli no longer supports the :cache option.' if options[:cache]
 
@@ -175,8 +202,8 @@ module Rack
         raise e
       end
 
-      def with_dalli_client(result_on_error = nil, &block)
-        @data.with(&block)
+      def with_dalli_client(result_on_error = nil, &)
+        @data.with(&)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
         raise if $ERROR_INFO.message.include?('undefined class')
 
@@ -190,6 +217,14 @@ module Rack
       def ttl(expire_after)
         expire_after.nil? ? 0 : expire_after + 1
       end
+
+      def session_persisted_data(req)
+        req.get_header RACK_SESSION_PERSISTED
+      end
+
+      def update_session_persisted_data(req, data)
+        req.set_header RACK_SESSION_PERSISTED, data
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.2.15
+  version: 4.0.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -40,7 +40,6 @@ files:
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
-- lib/dalli/json_serializer.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
 - lib/dalli/pid_cache.rb
@@ -64,7 +63,6 @@ files:
 - lib/dalli/protocol/value_marshaller.rb
 - lib/dalli/protocol/value_serializer.rb
 - lib/dalli/ring.rb
-- lib/dalli/server.rb
 - lib/dalli/servers_arg_normalizer.rb
 - lib/dalli/socket.rb
 - lib/dalli/version.rb
@@ -83,14 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.23
+rubygems_version: 4.0.3
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

data/lib/dalli/json_serializer.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Dalli
-  ##
-  # A serializer that stores values as JSON and never creates Ruby objects
-  # from what it reads.
-  #
-  # Passing the JSON module itself as the serializer (serializer: JSON) reads
-  # values back with JSON.load, which on json gem versions before 3.0 honors
-  # "json_class" and instantiates other classes when the json gem's additions
-  # are loaded. This serializer reads with JSON.parse, so a value written to
-  # memcached by someone else can only come back as plain hashes, arrays,
-  # strings, numbers, booleans and nil.
-  #
-  #   Dalli::Client.new(servers, serializer: Dalli::JSONSerializer)
-  ##
-  module JSONSerializer
-    def self.dump(value)
-      JSON.generate(value)
-    end
-
-    def self.load(data)
-      JSON.parse(data)
-    end
-  end
-end

data/lib/dalli/server.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli # rubocop:disable Style/Documentation
-  warn 'Dalli::Server is deprecated, use Dalli::Protocol::Binary instead'
-  Server = Protocol::Binary
-end