dalli 5.2.2 → 5.2.5

data/lib/dalli/socket.rb

@@ -8,6 +8,12 @@ module Dalli
   # Various socket implementations used by Dalli.
   ##
   module Socket
+    # Timeout for establishing a connection: connect_timeout if set,
+    # otherwise socket_timeout.
+    def self.connect_timeout_for(options)
+      options[:connect_timeout] || options[:socket_timeout]
+    end
+
     ##
     # Common methods for all socket implementations.
     ##
@@ -162,11 +168,13 @@ module Dalli
       end
 
       def self.create_socket_with_timeout(host, port, options)
+        timeout = Dalli::Socket.connect_timeout_for(options)
         if supports_connect_timeout?
-          sock = new(host, port, connect_timeout: options[:socket_timeout])
+          # resolv_timeout bounds the DNS lookup, which connect_timeout doesn't cover
+          sock = new(host, port, connect_timeout: timeout, resolv_timeout: timeout)
           yield(sock)
         else
-          Timeout.timeout(options[:socket_timeout]) do
+          Timeout.timeout(timeout) do
             sock = new(host, port)
             yield(sock)
           end
@@ -228,12 +236,41 @@ module Dalli
         [seconds, microseconds].pack(timeval_pack_format(sock))
       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
+
+      # Class variable to track whether the TLS verification warning has been logged
+      @@ssl_verification_warning_logged = false # rubocop:disable Style/ClassVars
+
+      # 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 = 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
+        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 # rubocop:disable Style/ClassVars
       end
     end
 
@@ -261,7 +298,7 @@ module Dalli
         attr_accessor :options
 
         def self.open(path, options = {})
-          Timeout.timeout(options[:socket_timeout]) do
+          Timeout.timeout(Dalli::Socket.connect_timeout_for(options)) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
             init_socket_options(sock, options)

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.2.2'
+  VERSION = '5.2.5'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6.27'
 end

data/lib/dalli.rb

@@ -31,6 +31,10 @@ module Dalli
   # socket/server communication error that can be retried
   class RetryableNetworkError < NetworkError; end
 
+  # a multi-get reply named a key that wasn't requested, so the rest of that
+  # server's replies can't be trusted
+  class UnexpectedReplyKeyError < 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

data/lib/rack/session/dalli.rb

@@ -2,7 +2,6 @@
 
 require 'rack/session/abstract/id'
 require 'dalli'
-require 'connection_pool'
 require 'English'
 
 module Rack
@@ -21,6 +20,11 @@ module Rack
         namespace: 'rack:session'
       }
 
+      # Our pool options and the ConnectionPool options they set. These are
+      # not passed on to Dalli::Client.
+      POOL_OPTIONS = { pool_size: :size, pool_timeout: :timeout }.freeze
+      private_constant :POOL_OPTIONS
+
       # Brings in a new Rack::Session::Dalli middleware with the given
       # `:memcache_server`. The server is either a hostname, or a
       # host-with-port string in the form of "host_name:port", or an array of
@@ -73,10 +77,18 @@ module Rack
         @data = build_data_source(options)
       end
 
-      def call(*_args)
-        super
+      # If the session is deleted from memcached while a request is running
+      # (for example, by a logout in another request), the session is not
+      # written back, so a logged-out session can't come back. The app's
+      # response is replaced with a 401 that expires the session cookie.
+      # The app has already run by then, so any side effects it had (database
+      # writes, emails, and so on) have happened.
+      def context(env, app = @app)
+        body = nil
+        super(env, ->(app_env) { app.call(app_env).tap { |response| body = response[2] } })
       rescue MissingSessionError
-        [401, {}, ['Wrong session ID']]
+        body.close if body.respond_to?(:close)
+        missing_session_response(env)
       end
 
       def find_session(req, sid)
@@ -111,13 +123,23 @@ module Rack
       def delete_session(_req, sid, options)
         with_dalli_client do |dc|
           key = memcached_key_from_sid(sid)
-          dc.delete(key) if key
+          delete_session_key(dc, key) if key
           generate_sid_with(dc) unless options[:drop]
         end
       end
 
       private
 
+      # A failed delete leaves the old session readable in memcached (e.g.
+      # after logout), so always log it, even though with_dalli_client then
+      # handles the error as before.
+      def delete_session_key(client, key)
+        client.delete(key)
+      rescue ::Dalli::DalliError, Errno::ECONNREFUSED => e
+        ::Dalli.logger.warn("#{self.class} failed to delete a session from memcached: #{e.class}: #{e.message}")
+        raise
+      end
+
       def memcached_key_from_sid(sid)
         sid.private_id if sid.respond_to?(:private_id)
       end
@@ -162,6 +184,12 @@ module Rack
         end
       end
 
+      def missing_session_response(env)
+        options = env[Rack::RACK_SESSION_OPTIONS] || @default_options
+        cookie = Rack::Utils.delete_set_cookie_header(key, options.slice(:path, :domain))
+        [401, { 'content-type' => 'text/plain', 'set-cookie' => cookie }, ['Wrong session ID']]
+      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!
@@ -181,15 +209,14 @@ module Rack
       end
 
       def retrieve_client_options(options)
-        # Filter out Rack::Session-specific options and apply our defaults
-        filtered_opts = options.reject { |k, _| DEFAULT_OPTIONS.key? k }
+        # Filter out Rack::Session-specific and pool options and apply our defaults
+        filtered_opts = options.reject { |k, _| DEFAULT_OPTIONS.key?(k) || POOL_OPTIONS.key?(k) }
         DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
       end
 
       def retrieve_pool_options(options)
-        {}.tap do |pool_options|
-          pool_options[:size] = options.delete(:pool_size) if options[:pool_size]
-          pool_options[:timeout] = options.delete(:pool_timeout) if options[:pool_timeout]
+        POOL_OPTIONS.each_with_object({}) do |(option, pool_option), pool_options|
+          pool_options[pool_option] = options[option] if options[option]
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.2.2
+  version: 5.2.5
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.23
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []