arachni-reactor 0.1.0.beta5 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f7671f97abb22c56a6488378023cd84ad92a8f30
-  data.tar.gz: ffd8c0513e0c41d4483249faaeeea3d9eea5aa21
+SHA256:
+  metadata.gz: ef5b5d0eb1a76745be3671829841cbd1c9780d9c731c12e9933bafadf2c622ff
+  data.tar.gz: 0e2a91dc4a9159042ce590bd6c1a09ae61cd660ad18aa9a900a19fe04d2a599d
 SHA512:
-  metadata.gz: 5678c3dd7c6e90aa2061f06c892a4889538baee925550db1f5a46fc3ff232a5c66849ae1fef8c24fe6ae06d1e066dc8bfc2570b6f996dfe89ce33effd6d8e86c
-  data.tar.gz: 8c5ebfd3235211408111216a1dbf942266354f085e14cd629ae56eda7ddb91126b9b4ccbf3705aa2732cf28a45d45598a2aaeea7eabad9af08c1486abd5b26f5
+  metadata.gz: 314fb418807020a5d9aed021e6bb55063d343ea514ff5b06df75f6b0c894ac3c4e53c25fade813313205e4326841c391e441c2432ad758c6c0142f412cdf85e7
+  data.tar.gz: 23a506068c6b7b8c529b3c8d4500d709fb05f8fd8e8c1b40848bf08719104b684602a4816a77a5e79c5515e51dc3a1a367c1d132754ae3d9bc5e8c8f446c6b69

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # ChangeLog
 
+## Version 0.1.3
+
+- `Reactor` -- Reduced object allocations.
+- `Connection::TLS#_read` -- Handle `OpenSSL::SSL::SSLErrorWaitReadable`.
+
+## Version 0.1.2
+
+ - `Reactor` -- Reduced object allocations.
+- `Connection::Error.translate` -- Handle `Errno::ENOTSOCK` errors.
+
+## Version 0.1.1
+
+- `Connection`
+    - `#_write` -- Use `String#byteslice` instead of `String#slice` and
+        `String#bytesize` instead of `String#size`.
+    - `Error.translate` -- Translate `Errno::ECONNABORTED` as `Error::Reset`.
+
+## Version 0.1.0
+
+- Cleaned up connection handling structure for JRuby support.
+- `Connection`
+    - `PeerInfo` now not included by default and only available for servers.
+
 ## Version 0.1.0.beta5 _(September 4, 2014)_
 
 - `Tasks::OneOff#call`: Ensure that the task is marked as done even if an

data/LICENSE.md

@@ -1,6 +1,6 @@
 # License
 
-    Copyright (C) 2014, Tasos Laskos <tasos.laskos@gmail.com>
+    Copyright (C) 2014-2017, Sarosys LLC <http://www.sarosys.com/>
     All rights reserved.
 
     Redistribution and use in source and binary forms, with or without modification,

data/README.md

@@ -3,7 +3,7 @@
 <table>
     <tr>
         <th>Version</th>
-        <td>0.1.0.beta5</td>
+        <td>0.1.2</td>
     </tr>
     <tr>
         <th>Github page</th>
@@ -23,7 +23,7 @@
     </tr>
     <tr>
         <th>Copyright</th>
-        <td>2014</td>
+        <td>2014-2017 <a href="http://www.sarosys.com">Sarosys LLC</a></td>
     </tr>
     <tr>
         <th>License</th>
@@ -51,7 +51,7 @@ on network connections -- and less so on generic tasks.
  - Rubies:
     - MRI >= 1.9
     - Rubinius
-    - JRuby (Without OpenSSL support)
+    - JRuby
  - Operating Systems:
     - Linux
     - OSX
@@ -63,7 +63,7 @@ For examples please see the `examples/` directory.
 
 ## Installation
 
-    gem install arachni-reactor --pre
+    gem install arachni-reactor
 
 ## Running the Specs
 

data/lib/arachni/reactor/connection/error.rb

@@ -24,7 +24,7 @@ class Error < Arachni::Reactor::Error
         # @param  [Block] block Block to run.
         def translate( &block )
             block.call
-        rescue IOError, Errno::ENOTCONN => e
+        rescue IOError, Errno::ENOTCONN, Errno::ENOTSOCK => e
             raise_with_proper_backtrace( e, Closed )
         rescue SocketError, Errno::ENOENT => e
             raise_with_proper_backtrace( e, HostNotFound )
@@ -35,7 +35,7 @@ class Error < Arachni::Reactor::Error
             # non-existent server.
             Errno::EADDRINUSE => e
             raise_with_proper_backtrace( e, Refused )
-        rescue Errno::ECONNRESET => e
+        rescue Errno::ECONNRESET, Errno::ECONNABORTED => e
             raise_with_proper_backtrace( e, Reset )
         rescue Errno::EACCES => e
             raise_with_proper_backtrace( e, Permission )
@@ -51,7 +51,7 @@ class Error < Arachni::Reactor::Error
         # aren't any specific exceptions for these.
         #
         # Why make things easy and clean, right?
-        rescue OpenSSL::OpenSSLError => e
+        rescue OpenSSL::SSL::SSLError, OpenSSL::OpenSSLError => e
             raise_with_proper_backtrace( e, SSL )
         end
 

data/lib/arachni/reactor/connection/tls.rb

@@ -62,17 +62,79 @@ module TLS
             @socket = OpenSSL::SSL::SSLSocket.new( @socket, @ssl_context )
             @socket.sync_close = true
 
-            begin
-                @socket.connect_nonblock
-            rescue IO::WaitReadable, IO::WaitWritable
-            end
+            # We've switched to SSL, a connection needs to be re-established
+            # via the SSL handshake.
+            @connected         = false
+
+            _connect if unix?
         end
 
         @socket
     end
 
+    # Performs an SSL handshake in addition to a plaintext connect operation.
+    #
+    # @private
+    def _connect
+        return if @ssl_connected
+
+        Error.translate do
+            @plaintext_connected ||= super
+            return if !@plaintext_connected
+
+            # Mark the connection as not connected due to the pending SSL handshake.
+            @connected = false
+
+            @socket.connect_nonblock
+            @ssl_connected = @connected = true
+        end
+    rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
+    rescue Error => e
+        close e
+    end
+
+    # First checks if there's a pending SSL #accept operation when this
+    # connection is a server handler which has been passed an accepted
+    # plaintext connection.
+    #
+    # @private
+    def _write( *args )
+        return ssl_accept if accept?
+
+        super( *args )
+    end
+
+    # First checks if there's a pending SSL #accept operation when this
+    # connection is a server handler which has been passed an accepted
+    # plaintext connection.
+    #
+    # @private
+    def _read
+        return ssl_accept if accept?
+
+        super
+    rescue OpenSSL::SSL::SSLErrorWaitReadable
+    end
+
     private
 
+    def ssl_accept
+        Error.translate do
+            @accepted = !!@socket.accept_nonblock
+        end
+    rescue IO::WaitReadable, IO::WaitWritable
+    rescue Error => e
+        close e
+        false
+    end
+
+    def accept?
+        return false if @accepted
+        return false if role != :server || !@socket.is_a?( OpenSSL::SSL::SSLSocket )
+
+        true
+    end
+
     # Accepts a new SSL client connection.
     #
     # @return   [OpenSSL::SSL::SSLSocket, nil]
@@ -81,26 +143,20 @@ module TLS
     #
     # @private
     def socket_accept
-        socket = nil
-        begin
+        Error.translate do
             socket = to_io.accept_nonblock
-        rescue IO::WaitReadable, IO::WaitWritable
-            return
-        end
-
-        socket = OpenSSL::SSL::SSLSocket.new(
-            socket,
-            @ssl_context
-        )
-        socket.sync_close = true
 
-        begin
-            socket.accept_nonblock
-        rescue IO::WaitReadable, IO::WaitWritable
+            ssl_socket = OpenSSL::SSL::SSLSocket.new(
+                socket,
+                @ssl_context
+            )
+            ssl_socket.sync_close = true
+            ssl.accept if @start_immediately
+            ssl_socket
         end
-
-        socket
-    rescue OpenSSL::SSL::SSLError
+    rescue IO::WaitReadable, IO::WaitWritable
+    rescue Error => e
+        close e
     end
 
 end

data/lib/arachni/reactor/connection.rb

@@ -7,8 +7,8 @@
 =end
 
 require_relative 'connection/error'
-require_relative 'connection/peer_info'
 require_relative 'connection/callbacks'
+require_relative 'connection/peer_info'
 require_relative 'connection/tls'
 
 module Arachni
@@ -16,7 +16,6 @@ class Reactor
 
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 class Connection
-    include PeerInfo
     include Callbacks
 
     # Maximum amount of data to be written or read at a time.
@@ -42,17 +41,21 @@ class Connection
     #   `true` when using a UNIX-domain socket, `nil` if no {#socket} is
     #   available, `false` otherwise.
     def unix?
+        return @is_unix if !@is_unix.nil?
         return if !to_io
         return false if !Arachni::Reactor.supports_unix_sockets?
-        to_io.is_a?( UNIXServer ) || to_io.is_a?( UNIXSocket )
+
+        @is_unix = to_io.is_a?( UNIXServer ) || to_io.is_a?( UNIXSocket )
     end
 
     # @return   [Bool]
     #   `true` when using an Internet socket, `nil` if no {#socket} is
     #   available, `false` otherwise.
     def inet?
+        return @is_inet if !@is_inet.nil?
         return if !to_io
-        to_io.is_a?( TCPServer ) || to_io.is_a?( TCPSocket ) || to_io.is_a?( Socket )
+
+        @is_inet = to_io.is_a?( TCPServer ) || to_io.is_a?( TCPSocket ) || to_io.is_a?( Socket )
     end
 
     # @return   [IO, nil]
@@ -65,8 +68,10 @@ class Connection
     # @return   [Bool]
     #   `true` if the connection is a server listener.
     def listener?
+        return @is_listener if !@is_listener.nil?
         return if !to_io
-        to_io.is_a?( TCPServer ) || (unix? && to_io.is_a?( UNIXServer ))
+
+        @is_listener = to_io.is_a?( TCPServer ) || (unix? && to_io.is_a?( UNIXServer ))
     end
 
     # @note The data will be buffered and sent in future {Reactor} ticks.
@@ -176,48 +181,67 @@ class Connection
         nil
     end
 
-    # @note Will call {#on_write} every time any of the buffer is consumed,
-    #   can be multiple times when performing partial writes.
-    # @note Will call {#on_flush} once all of the buffer has been consumed.
-    #
-    # Processes a `write` event for this connection.
+    # Accepts a new client connection.
     #
-    # Consumes and writes {BLOCK_SIZE} amount of data from the the beginning of
-    # the {#write} buffer to the socket.
+    # @return   [Connection, nil]
+    #   New connection or `nil` if the socket isn't ready to accept new
+    #   connections yet.
     #
-    # @return   [Integer]
-    #   Amount of the buffer consumed.
+    # @private
+    def accept
+        return if !(accepted = socket_accept)
+
+        connection = @server_handler.call
+        connection.configure socket: accepted, role: :server
+        @reactor.attach connection
+        connection
+    end
+
+    # @param    [Socket]    socket
+    #   Ruby `Socket` associated with this connection.
+    # @param    [Symbol]    role
+    #   `:server` or `:client`.
+    # @param    [Block]    server_handler
+    #   Block that generates a handler as specified in {Reactor#listen}.
     #
     # @private
-    def _write
-        chunk = write_buffer.slice( 0, BLOCK_SIZE )
-        total_written = 0
+    def configure( options = {} )
+        @socket         = options[:socket]
+        @role           = options[:role]
+        @host           = options[:host]
+        @port           = options[:port]
+        @server_handler = options[:server_handler]
+
+        # If we're a server without a handler then we're an accepted connection.
+        if unix? || role == :server
+            @connected = true
+            on_connect
+        end
 
-        begin
-            Error.translate do
-                # Send out the buffer, **all** of it, or at least try to.
-                loop do
-                    total_written += written = @socket.write_nonblock( chunk )
-                    write_buffer.slice!( 0, written )
+        nil
+    end
 
-                    # Call #on_write every time any of the buffer is consumed.
-                    on_write
+    def connected?
+        !!@connected
+    end
 
-                    break if written == chunk.size
-                    chunk.slice!( 0, written )
-                end
-            end
+    # @private
+    def _connect
+        return true if unix? || connected?
 
-        # Not ready to read or write yet, we'll catch it on future Reactor ticks.
-        rescue IO::WaitReadable, IO::WaitWritable
+        begin
+            Error.translate do
+                socket.connect_nonblock( Socket.sockaddr_in( @port, @host ) )
+            end
+        # Already connected. :)
+        rescue Errno::EISCONN, Errno::EALREADY
         end
 
-        if write_buffer.empty?
-            @socket.flush
-            on_flush
-        end
+        @connected = true
+        on_connect
 
-        total_written
+        true
+    rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
     rescue Error => e
         close e
     end
@@ -230,7 +254,8 @@ class Connection
     #
     # @private
     def _read
-        return accept if listener?
+        return _connect if !listener? && !connected?
+        return accept   if listener?
 
         Error.translate do
             on_read @socket.read_nonblock( BLOCK_SIZE )
@@ -242,38 +267,52 @@ class Connection
         close e
     end
 
-    # Accepts a new client connection.
+    # @note Will call {#on_write} every time any of the buffer is consumed,
+    #   can be multiple times when performing partial writes.
+    # @note Will call {#on_flush} once all of the buffer has been consumed.
     #
-    # @return   [Connection, nil]
-    #   New connection or `nil` if the socket isn't ready to accept new
-    #   connections yet.
+    # Processes a `write` event for this connection.
+    #
+    # Consumes and writes {BLOCK_SIZE} amount of data from the the beginning of
+    # the {#write} buffer to the socket.
+    #
+    # @return   [Integer]
+    #   Amount of the buffer consumed.
     #
     # @private
-    def accept
-        return if !(accepted = socket_accept)
+    def _write
+        return _connect if !connected?
 
-        connection = @server_handler.call
-        connection.configure accepted, :server
-        @reactor.attach connection
-        connection
-    end
+        chunk = write_buffer.byteslice( 0, BLOCK_SIZE )
+        total_written = 0
 
-    # @param    [Socket]    socket
-    #   Ruby `Socket` associated with this connection.
-    # @param    [Symbol]    role
-    #   `:server` or `:client`.
-    # @param    [Block]    server_handler
-    #   Block that generates a handler as specified in {Reactor#listen}.
-    #
-    # @private
-    def configure( socket, role, server_handler = nil )
-        @socket         = socket
-        @role           = role
-        @server_handler = server_handler
+        begin
+            Error.translate do
+                # Send out the chunk, **all** of it, or at least try to.
+                loop do
+                    total_written += written = @socket.write_nonblock( chunk )
+                    @write_buffer = @write_buffer.byteslice( written..-1 )
 
-        on_connect
+                    # Call #on_write every time any of the buffer is consumed.
+                    on_write
 
-        nil
+                    break if written == chunk.bytesize
+                    chunk = chunk.byteslice( written..-1 )
+                end
+            end
+
+        # Not ready to read or write yet, we'll catch it on future Reactor ticks.
+        rescue IO::WaitReadable, IO::WaitWritable
+        end
+
+        if write_buffer.empty?
+            @socket.flush
+            on_flush
+        end
+
+        total_written
+    rescue Error => e
+        close e
     end
 
     private

data/lib/arachni/reactor/version.rb

@@ -9,7 +9,7 @@
 module Arachni
 class Reactor
 
-    VERSION = '0.1.0.beta5'
+    VERSION = '0.1.3'
 
 end
 end