arachni-reactor 0.1.0.beta5 → 0.1.3

data/lib/arachni/reactor.rb

@@ -199,10 +199,9 @@ class Reactor
         begin
             Connection::Error.translate do
                 socket = options[:unix_socket] ?
-                    connect_unix( options[:unix_socket] ) :
-                    connect_tcp( options[:host], options[:port] )
+                    connect_unix( options[:unix_socket] ) : connect_tcp
 
-                connection.configure socket, :client
+                connection.configure options.merge( socket: socket, role: :client )
                 attach connection
             end
         rescue Connection::Error => e
@@ -266,7 +265,7 @@ class Reactor
                     listen_unix( options[:unix_socket] ) :
                     listen_tcp( options[:host], options[:port] )
 
-                server.configure socket, :server, server_handler
+                server.configure options.merge( socket: socket, role: :server, server_handler: server_handler )
                 attach server
             end
         rescue Connection::Error => e
@@ -415,7 +414,7 @@ class Reactor
     def schedule( &block )
         fail_if_not_running
 
-        if running? && in_same_thread?
+        if in_same_thread?
             block.call
         else
             next_tick(&block)
@@ -500,7 +499,7 @@ class Reactor
 
         schedule do
             connection.reactor = self
-            @connections[connection.socket] = connection
+            @connections[connection.to_io] = connection
             connection.on_attach
         end
     end
@@ -517,7 +516,7 @@ class Reactor
 
         schedule do
             connection.on_detach
-            @connections.delete connection.socket
+            @connections.delete connection.to_io
             connection.reactor = nil
         end
     end
@@ -525,7 +524,7 @@ class Reactor
     # @return   [Bool]
     #   `true` if the connection is attached, `false` otherwise.
     def attached?( connection )
-        @connections.include? connection.socket
+        @connections.include? connection.to_io
     end
 
     private
@@ -552,25 +551,8 @@ class Reactor
              'The host OS does not support UNIX-domain sockets.'
     end
 
-    def process_connections
-        if @connections.empty?
-            sleep @max_tick_interval
-            return
-        end
-
-        # Get connections with available events - :read, :write, :error.
-        selected = select_connections
-
-        # Close connections that have errors.
-        [selected.delete(:error)].flatten.compact.each(&:close)
-
-        # Call the corresponding event on the connections.
-        selected.each { |event, connections| connections.each(&"_#{event}".to_sym) }
-    end
-
     def determine_connection_options( *args )
         options = {}
-        host = port = unix_socket = nil
 
         if args[1].is_a? Integer
             options[:host], options[:port], options[:handler], *handler_options = *args
@@ -599,26 +581,13 @@ class Reactor
 
     # @return   [Socket]
     #   Connected socket.
-    def connect_tcp( host, port )
+    def connect_tcp
         socket = Socket.new(
             Socket::Constants::AF_INET,
             Socket::Constants::SOCK_STREAM,
             Socket::Constants::IPPROTO_IP
         )
         socket.do_not_reverse_lookup = true
-
-        # JRuby throws java.nio.channels.NotYetConnectedException even after
-        # it returns the socket from Kernel.select, so wait for it to connect
-        # before moving on.
-        if self.class.jruby?
-            socket.connect( Socket.sockaddr_in( port, host ) )
-        else
-            begin
-                socket.connect_nonblock( Socket.sockaddr_in( port, host ) )
-            rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
-            end
-        end
-
         socket
     end
 
@@ -641,6 +610,22 @@ class Reactor
         @connections.values.each(&:close)
     end
 
+    def process_connections
+        if @connections.empty?
+            sleep @max_tick_interval
+            return
+        end
+
+        # Get connections with available events - :read, :write, :error.
+        selected = self.select_connections
+
+        # Close connections that have errors.
+        selected.delete(:error)&.each(&:close)
+
+        # Call the corresponding event on the connections.
+        selected.each { |event, connections| connections.each(&"_#{event}".to_sym) }
+    end
+
     # @return   [Hash]
     #
     #   Connections grouped by their available events:
@@ -650,52 +635,71 @@ class Reactor
     #       {Connection#has_outgoing_data? outgoing buffer).
     #   * `:error`
     def select_connections
-        grouped_sockets =
+        r = []
+        w = []
+        e = []
+
+        @connections.values.each do |connection|
+
+            # Required for OSX as it connects immediately and then #select returns
+            # nothing as there's no activity, given that, OpenSSL doesn't get a chance
+            # to do its handshake so explicitly connect pending sockets, bypassing #select.
+            connection._connect if !connection.connected?
+
+            socket = connection.socket
+
+            e << socket
+
+            if connection.listener? || connection.connected?
+                r << socket
+            end
+
+            if connection.connected? && connection.has_outgoing_data?
+                w << socket
+            end
+        end
+
+        selected_sockets =
             begin
                 Connection::Error.translate do
-                    select(
-                        read_sockets,
-                        write_sockets,
-                        read_sockets, # Read sockets are actually all sockets.
-                        @select_timeout
-                    )
+                    select( r, w, e, @select_timeout )
                 end
-            rescue Connection::Error
+            rescue Connection::Error => e
+                nil
             end
 
-        return {} if !grouped_sockets
+        selected_sockets ||= [[],[],[]]
+
+        # SSL sockets maintain their own buffer whose state can't be checked by
+        # Kernel.select, leading to cases where the SSL buffer isn't empty,
+        # even though Kernel.select says that there's nothing to read.
+        #
+        # So force a read for SSL sockets to cover all our bases.
+        #
+        # This is apparent especially on JRuby.
+        if r.size != selected_sockets[0].size
+            (r - selected_sockets[0]).each do |socket|
+                next if !socket.is_a?( OpenSSL::SSL::SSLSocket )
+                selected_sockets[0] << socket
+            end
+        end
+
+        if selected_sockets[0].empty? && selected_sockets[1].empty? &&
+            selected_sockets[2].empty?
+            return {}
+        end
 
         {
             # Since these will be processed in order, it's better have the write
             # ones first to flush the buffers ASAP.
-            write: connections_from_sockets( grouped_sockets[1] ),
-            read:  connections_from_sockets( grouped_sockets[0] ),
-            error: connections_from_sockets( grouped_sockets[2] )
+            write:   connections_from_sockets( selected_sockets[1] ),
+            read:    connections_from_sockets( selected_sockets[0] ),
+            error:   connections_from_sockets( selected_sockets[2] )
         }
     end
 
-    # @return   [Array<Socket>]
-    #   Sockets of all connections, we want to be ready to read at any time.
-    def read_sockets
-        @connections.keys
-    end
-
-    # @return   [Array<Socket>]
-    #   Sockets of connections with
-    #   {Connection#has_outgoing_data? outgoing data}.
-    def write_sockets
-        @connections.map do |socket, connection|
-            next if !connection.has_outgoing_data?
-            socket
-        end.compact
-    end
-
     def connections_from_sockets( sockets )
-        sockets.map { |s| connection_from_socket( s ) }
-    end
-
-    def connection_from_socket( socket )
-        @connections[socket]
+        sockets.map { |s| @connections[s.to_io] }
     end
 
 end

data/spec/arachni/reactor/connection/tls_spec.rb

@@ -43,16 +43,32 @@ describe Arachni::Reactor::Connection::TLS do
         end
     end
 
+    before :each do
+        @accept_q = Queue.new
+        @accepted = nil
+    end
+
     let(:unix_socket) { unix_connect( @unix_socket ) }
     let(:unix_server_socket) { unix_server( port_to_socket( Servers.available_port ) ) }
 
-    let(:echo_client) { tcp_connect( @host, @port ) }
+    let(:echo_client) { tcp_socket }
     let(:echo_client_handler) { EchoClientTLS.new }
 
     let(:peer_client_socket) { tcp_ssl_connect( host, port ) }
-    let(:peer_server_socket) { tcp_ssl_server( host, port ) }
+    let(:peer_server_socket) do
+        s = tcp_ssl_server( host, port )
+        Thread.new do
+            begin
+                @accept_q << s.accept
+            rescue => e
+                ap e
+            end
+        end
+        s
+    end
+    let(:accepted) { @accepted ||= @accept_q.pop }
 
-    let(:client_socket) { tcp_connect( host, port ) }
+    let(:client_socket) { tcp_socket }
     let(:server_socket) { tcp_server( host, port ) }
 
     let(:connection) { TLSHandler.new }
@@ -113,10 +129,12 @@ describe Arachni::Reactor::Connection::TLS do
                         reactor.listen( host, port, TLSHandler, options )
 
                         client.write data
+                        sleep 1
+
                         reactor.stop
                         reactor.wait rescue Arachni::Reactor::Error::NotRunning
 
-                        received_data.should == data
+                        expect(received_data).to eq data
                     end
                 end
 
@@ -244,7 +262,15 @@ describe Arachni::Reactor::Connection::TLS do
 
         context 'when connecting to a server' do
             let(:server) do
-                tcp_ssl_server( host, port, server_ssl_options )
+                s = tcp_ssl_server( host, port, server_ssl_options )
+                Thread.new do
+                    begin
+                        @accept_q << s.accept
+                    rescue => e
+                        # ap e
+                    end
+                end
+                s
             end
 
             before :each do
@@ -258,9 +284,7 @@ describe Arachni::Reactor::Connection::TLS do
                     it 'connects successfully' do
                         received = nil
                         Thread.new do
-                            s = server.accept
-                            received = s.gets
-
+                            received = accepted.gets
                             reactor.stop
                         end
 
@@ -279,10 +303,6 @@ describe Arachni::Reactor::Connection::TLS do
 
                 context 'and no options have been provided' do
                     it "passes #{Arachni::Reactor::Connection::Error} to #on_error" do
-                        Thread.new do
-                            server.accept
-                        end
-
                         connection = nil
                         reactor.run do
                             connection = reactor.connect( host, port, TLSHandler )
@@ -297,8 +317,7 @@ describe Arachni::Reactor::Connection::TLS do
                         it 'connects successfully' do
                             received = nil
                             t = Thread.new do
-                                s = server.accept
-                                received = s.gets
+                                received = accepted.gets
                                 reactor.stop
                             end
 
@@ -307,16 +326,13 @@ describe Arachni::Reactor::Connection::TLS do
                                 connection.write data
                             end
 
-                            received.should == data
+                            sleep 1
+                            expect(received).to eq data
                         end
                     end
 
                     context 'and are invalid' do
                         it "passes #{Arachni::Reactor::Connection::Error} to #on_error" do
-                            Thread.new do
-                                server.accept
-                            end
-
                             connection = nil
                             reactor.run do
                                 connection = reactor.connect( host, port, TLSHandler, client_invalid_ssl_options )

data/spec/arachni/reactor/connection_spec.rb

@@ -39,16 +39,32 @@ describe Arachni::Reactor::Connection do
         end
     end
 
+    before :each do
+        @accept_q = Queue.new
+        @accepted = nil
+    end
+
     let(:unix_socket) { unix_connect( @unix_socket ) }
     let(:unix_server_socket) { unix_server( port_to_socket( Servers.available_port ) ) }
 
-    let(:echo_client) { tcp_connect( @host, @port ) }
+    let(:echo_client) { tcp_socket }
     let(:echo_client_handler) { EchoClient.new }
 
     let(:peer_client_socket) { tcp_connect( host, port ) }
-    let(:peer_server_socket) { tcp_server( host, port ) }
+    let(:peer_server_socket) do
+        s = tcp_server( host, port )
+        Thread.new do
+            begin
+                @accept_q << s.accept
+            rescue => e
+                ap e
+            end
+        end
+        s
+    end
+    let(:accepted) { @accepted ||= @accept_q.pop }
 
-    let(:client_socket) { tcp_connect( host, port ) }
+    let(:client_socket) { tcp_socket }
     let(:server_socket) { tcp_server( host, port ) }
 
     let(:connection) { Handler.new }

data/spec/arachni/reactor/iterator_spec.rb

@@ -25,7 +25,7 @@ describe Arachni::Reactor::Iterator do
         end
 
         context 'when the concurrency is' do
-            context 0 do
+            context '0' do
                 let(:concurrency) { 0 }
 
                 it "raises #{ArgumentError}" do

data/spec/arachni/reactor/tasks/delayed_spec.rb

@@ -35,7 +35,9 @@ describe Arachni::Reactor::Tasks::Delayed do
                 time = Time.now
                 task.call while called < 1
 
-                (Time.now - time).round(2).should == 0.25
+                elapsed = (Time.now - time).round(2)
+                elapsed.should >= 0.25
+                elapsed.should < 0.30
             end
 
             it 'calls #done' do

data/spec/arachni/reactor/tasks/periodic_spec.rb

@@ -33,7 +33,9 @@ describe Arachni::Reactor::Tasks::Periodic do
                 time = Time.now
                 task.call while called < 5
 
-                (Time.now - time).round(2).should == 1.25
+                elapsed = (Time.now - time).round(2)
+                elapsed.should >= 1.25
+                elapsed.should < 1.35
             end
         end
 

data/spec/arachni/reactor/tasks_spec.rb

@@ -25,14 +25,14 @@ describe Arachni::Reactor::Tasks do
         context 'when it includes the given task' do
             it 'returns true' do
                 subject << task
-                subject.should include task
+                expect(subject.include?( task )).to be_truthy
             end
         end
 
         context 'when it does not includes the given task' do
             it 'returns false' do
                 subject << task
-                subject.should_not include another_task
+                expect(subject.include?( another_task )).to be_falsey
             end
         end
     end
@@ -125,8 +125,8 @@ describe Arachni::Reactor::Tasks do
 
             subject.call
 
-            called_one.should be_true
-            called_two.should be_true
+            called_one.should be_truthy
+            called_two.should be_truthy
         end
 
         it 'returns self' do

data/spec/support/helpers/utilities.rb

@@ -17,6 +17,16 @@ def tcp_connect( host, port )
     TCPSocket.new( host, port )
 end
 
+def tcp_socket
+    socket = Socket.new(
+        Socket::Constants::AF_INET,
+        Socket::Constants::SOCK_STREAM,
+        Socket::Constants::IPPROTO_IP
+    )
+    socket.do_not_reverse_lookup = true
+    socket
+end
+
 def tcp_write( host, port, data )
     s = tcp_connect( host, port )
     s.write data
@@ -45,6 +55,10 @@ def tcp_server( host, port )
     TCPServer.new( host, port )
 end
 
+def tcp_ssl_socket( host, port, options = {}  )
+    convert_client_to_ssl( tcp_socket, options )
+end
+
 def tcp_ssl_connect( host, port, options = {}  )
     convert_client_to_ssl( tcp_connect( host, port ), options )
 end
@@ -100,7 +114,7 @@ def convert_server_to_ssl( server, options = {} )
         context.cert.version    = 2
         context.cert.serial     = 1
 
-        context.cert.sign( context.key, OpenSSL::Digest::SHA1.new )
+        context.cert.sign( context.key, OpenSSL::Digest::SHA256.new )
     end
 
     OpenSSL::SSL::SSLServer.new( server, context )

data/spec/support/lib/servers.rb

@@ -26,7 +26,7 @@ class Servers
         return [host_for(name), port_for(name)] if server_info[:pid] && up?( name )
 
         server_info[:pid] = Process.spawn(
-            'ruby', RUNNER, server_info[:path], '-p', server_info[:port].to_s,
+            RbConfig.ruby, RUNNER, server_info[:path], '-p', server_info[:port].to_s,
             '-o', host_for( name )
         )
 

data/spec/support/servers/echo.rb

@@ -4,10 +4,10 @@ loop do
     Thread.new server.accept do |socket|
         begin
             loop do
-                next if !(line = socket.gets)
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
-        rescue EOFError, Errno::EPIPE
+        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
             socket.close
         end
     end

data/spec/support/servers/echo_tls.rb

@@ -12,10 +12,10 @@ loop do
     Thread.new do
         begin
             loop do
-                next if (line = socket.gets).to_s.empty?
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
-        rescue EOFError, Errno::EPIPE
+        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
             socket.close
         end
     end

data/spec/support/servers/echo_unix.rb

@@ -4,10 +4,10 @@ loop do
     Thread.new server.accept do |socket|
         begin
             loop do
-                next if !(line = socket.gets)
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
-        rescue EOFError, Errno::EPIPE
+        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
             socket.close
         end
     end

data/spec/support/servers/echo_unix_tls.rb

@@ -12,10 +12,10 @@ loop do
     Thread.new do
         begin
             loop do
-                next if (line = socket.gets).to_s.empty?
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
-        rescue EOFError, Errno::EPIPE
+        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
             socket.close
         end
     end