✅ Fix backport to not-imap 0.3 and ruby 2.6

For the net-imap v0.3 backport, two major changes were needed:
* the tests needed to be almost completely rewritten because FakeServer
  was added for v0.4.
* `max_response_size` needed to be on Net::IMAP directly, because Config
  was added for v0.4.

Author: nevans

lib/net/imap.rb

@@ -133,7 +133,7 @@ module Net
   #
   # Use paginated or limited versions of commands whenever possible.
   #
-  # Use Config#max_response_size to impose a limit on incoming server responses
+  # Use #max_response_size to impose a limit on incoming server responses
   # as they are being read.  <em>This is especially important for untrusted
   # servers.</em>
   #
@@ -288,6 +288,40 @@ class IMAP < Protocol
     # Seconds to wait until an IDLE response is received.
     attr_reader :idle_response_timeout
 
+    # The maximum allowed server response size.  When +nil+, there is no limit
+    # on response size.
+    #
+    # The default value is _unlimited_ (after +v0.5.8+, the default is 512 MiB).
+    # A _much_ lower value should be used with untrusted servers (for example,
+    # when connecting to a user-provided hostname).  When using a lower limit,
+    # message bodies should be fetched in chunks rather than all at once.
+    #
+    # <em>Please Note:</em> this only limits the size per response.  It does
+    # not prevent a flood of individual responses and it does not limit how
+    # many unhandled responses may be stored on the responses hash.  See
+    # Net::IMAP@Unbounded+memory+use.
+    #
+    # Socket reads are limited to the maximum remaining bytes for the current
+    # response: max_response_size minus the bytes that have already been read.
+    # When the limit is reached, or reading a +literal+ _would_ go over the
+    # limit, ResponseTooLargeError is raised and the connection is closed.
+    # See also #socket_read_limit.
+    #
+    # Note that changes will not take effect immediately, because the receiver
+    # thread may already be waiting for the next response using the previous
+    # value.  Net::IMAP#noop can force a response and enforce the new setting
+    # immediately.
+    #
+    # ==== Versioned Defaults
+    #
+    # Net::IMAP#max_response_size <em>was added in +v0.2.5+ and +v0.3.9+ as an
+    # attr_accessor, and in +v0.4.20+ and +v0.5.7+ as a delegator to a config
+    # attribute.</em>
+    #
+    # * original: +nil+ <em>(no limit)</em>
+    # * +0.5+: 512 MiB
+    attr_accessor :max_response_size
+
     # The thread to receive exceptions.
     attr_accessor :client_thread
 
@@ -317,17 +351,6 @@ class << self
       alias default_ssl_port default_tls_port
     end
 
-    ##
-    # :attr_accessor: max_response_size
-    #
-    # The maximum allowed server response size, in bytes.
-    # Delegates to {config.max_response_size}[rdoc-ref:Config#max_response_size].
-
-    # :stopdoc:
-    def max_response_size;      config.max_response_size       end
-    def max_response_size=(val) config.max_response_size = val end
-    # :startdoc:
-
     # Disconnects from the server.
     def disconnect
       return if disconnected?
@@ -1129,6 +1152,7 @@ def idle_done
     #                     that the greeting is handled in the current thread,
     #                     but all other responses are handled in the receiver
     #                     thread.
+    # max_response_size:: See #max_response_size.
     #
     # The most common errors are:
     #
@@ -1159,6 +1183,7 @@ def initialize(host, port_or_options = {},
       @tagno = 0
       @open_timeout = options[:open_timeout] || 30
       @idle_response_timeout = options[:idle_response_timeout] || 5
+      @max_response_size     = options[:max_response_size]
       @parser = ResponseParser.new
       @sock = tcp_socket(@host, @port)
       @reader = ResponseReader.new(self, @sock)

lib/net/imap/errors.rb

@@ -32,6 +32,7 @@ def initialize(msg = nil, *args,
           "Response size", response_size_msg, "exceeds max_response_size",
           max_response_size && "(#{max_response_size}B)",
         ].compact.join(" ")
+        return super(msg, *args) if kwargs.empty? # ruby 2.6 compatibility
         super(msg, *args, **kwargs)
       end
 

test/net/imap/test_imap_max_response_size.rb

@@ -2,13 +2,10 @@
 
 require "net/imap"
 require "test/unit"
-require_relative "fake_server"
 
 class IMAPMaxResponseSizeTest < Test::Unit::TestCase
-  include Net::IMAP::FakeServer::TestHelper
 
   def setup
-    Net::IMAP.config.reset
     @do_not_reverse_lookup = Socket.do_not_reverse_lookup
     Socket.do_not_reverse_lookup = true
     @threads = []
@@ -23,45 +20,95 @@ def teardown
   end
 
   test "#max_response_size reading literals" do
-    with_fake_server(preauth: true) do |server, imap|
+    _, port = with_server_socket do |sock|
+      sock.gets # => NOOP
+      sock.print("RUBY0001 OK done\r\n")
+      sock.gets # => NOOP
+      sock.print("* 1 FETCH (BODY[] {12345}\r\n" + "a" * 12_345 + ")\r\n")
+      sock.print("RUBY0002 OK done\r\n")
+      "RUBY0003"
+    end
+    Timeout.timeout(5) do
+      imap = Net::IMAP.new("localhost", port: port, max_response_size: 640 << 20)
+      assert_equal 640 << 20, imap.max_response_size
       imap.max_response_size = 12_345 + 30
-      server.on("NOOP") do |resp|
-        resp.untagged("1 FETCH (BODY[] {12345}\r\n" + "a" * 12_345 + ")")
-        resp.done_ok
-      end
-      imap.noop
-      assert_equal "a" * 12_345, imap.responses("FETCH").first.message
+      assert_equal 12_345 + 30, imap.max_response_size
+      imap.noop # to reset the get_response limit
+      imap.noop # to send the FETCH
+      assert_equal "a" * 12_345, imap.responses["FETCH"].first.attr["BODY[]"]
+    ensure
+      imap.logout rescue nil
+      imap.disconnect rescue nil
     end
   end
 
   test "#max_response_size closes connection for too long line" do
-    Net::IMAP.config.max_response_size = 10
-    run_fake_server_in_thread(preauth: false, ignore_io_error: true) do |server|
-      assert_raise_with_message(
-        Net::IMAP::ResponseTooLargeError, /exceeds max_response_size .*\b10B\b/
-      ) do
-        with_client("localhost", port: server.port) do
-          fail "should not get here (greeting longer than max_response_size)"
-        end
-      end
+    _, port = with_server_socket do |sock|
+      sock.gets or next # => never called
+      fail "client disconnects first"
+    end
+    assert_raise_with_message(
+      Net::IMAP::ResponseTooLargeError, /exceeds max_response_size .*\b10B\b/
+    ) do
+      Net::IMAP.new("localhost", port: port, max_response_size: 10)
+      fail "should not get here (greeting longer than max_response_size)"
     end
   end
 
   test "#max_response_size closes connection for too long literal" do
-    Net::IMAP.config.max_response_size = 1<<20
-    with_fake_server(preauth: false, ignore_io_error: true) do |server, client|
-      client.max_response_size = 50
-      server.on("NOOP") do |resp|
-        resp.untagged("1 FETCH (BODY[] {1000}\r\n" + "a" * 1000 + ")")
-      end
-      assert_raise_with_message(
-        Net::IMAP::ResponseTooLargeError,
-        /\d+B read \+ 1000B literal.* exceeds max_response_size .*\b50B\b/
-      ) do
-        client.noop
-        fail "should not get here (FETCH literal longer than max_response_size)"
+    _, port = with_server_socket(ignore_io_error: true) do |sock|
+      sock.gets # => NOOP
+      sock.print "* 1 FETCH (BODY[] {1000}\r\n" + "a" * 1000 + ")\r\n"
+      sock.print("RUBY0001 OK done\r\n")
+    end
+    client = Net::IMAP.new("localhost", port: port, max_response_size: 1000)
+    assert_equal 1000, client.max_response_size
+    client.max_response_size = 50
+    assert_equal 50, client.max_response_size
+    assert_raise_with_message(
+      Net::IMAP::ResponseTooLargeError,
+      /\d+B read \+ 1000B literal.* exceeds max_response_size .*\b50B\b/
+    ) do
+      client.noop
+      fail "should not get here (FETCH literal longer than max_response_size)"
+    end
+  end
+
+  def with_server_socket(ignore_io_error: false)
+    server = create_tcp_server
+    port   = server.addr[1]
+    start_server do
+      Timeout.timeout(5) do
+        sock = server.accept
+        sock.print("* OK connection established\r\n")
+        logout_tag = yield sock if block_given?
+        sock.gets # => LOGOUT
+        sock.print("* BYE terminating connection\r\n")
+        sock.print("#{logout_tag} OK LOGOUT completed\r\n") if logout_tag
+      rescue IOError, EOFError, Errno::ECONNABORTED, Errno::ECONNRESET,
+        Errno::EPIPE, Errno::ETIMEDOUT
+        ignore_io_error or raise
+      ensure
+        sock.close rescue nil
+        server.close rescue nil
       end
     end
+    return server, port
+  end
+
+  def start_server
+    th = Thread.new do
+      yield
+    end
+    @threads << th
+    sleep 0.1 until th.stop?
   end
 
+  def create_tcp_server
+    return TCPServer.new(server_addr, 0)
+  end
+
+  def server_addr
+    Addrinfo.tcp("localhost", 0).ip_address
+  end
 end

test/net/imap/test_response_reader.rb

@@ -6,7 +6,7 @@
 
 class ResponseReaderTest < Test::Unit::TestCase
   class FakeClient
-    def max_response_size; config.max_response_size end
+    attr_accessor :max_response_size
   end
 
   def literal(str) "{#{str.bytesize}}\r\n#{str}" end
@@ -47,7 +47,7 @@ def literal(str) "{#{str.bytesize}}\r\n#{str}" end
 
   test "#read_response_buffer with max_response_size" do
     client = FakeClient.new
-    client.config.max_response_size = 10
+    client.max_response_size = 10
     under = "+ 3456\r\n"
     exact = "+ 345678\r\n"
     over  = "+ 3456789\r\n"