raptor-io 0.0.1

data/lib/raptor-io/socket/switch_board/route.rb

@@ -0,0 +1,42 @@
+require 'ipaddr'
+require 'raptor-io/ruby/ipaddr'
+
+#
+# A logical switch board route.
+#
+class RaptorIO::Socket::SwitchBoard::Route
+  include Comparable
+
+  # @param subnet [String,IPAddr]  The network associated with this
+  #   route. If specified as a String, must be parseable by IPAddr.new
+  # @param netmask [String,IPAddr] `subnet`'s netmask. If specified as
+  #   a String, must be parseable by IPAddr.new
+  # @param comm [Comm] The endpoint where sockets for this route
+  #   should be created.
+  def initialize(subnet, netmask, comm)
+    self.netmask = IPAddr.parse(netmask)
+    self.subnet  = IPAddr.parse(subnet).mask netmask.to_s
+    self.comm    = comm
+  end
+
+  #
+  # For direct equality, make sure all the attributes are the same
+  #
+  def ==(other)
+    return false unless other.kind_of? RaptorIO::Socket::SwitchBoard::Route
+    netmask == other.netmask && subnet == other.subnet && comm == other.comm
+  end
+
+  #
+  # For comparison, sort according to netmask.
+  #
+  # This allows {Route routes} to be ordered by specificity
+  #
+  def <=>(other)
+    netmask <=> other.netmask
+  end
+
+  attr_reader :subnet, :netmask, :comm
+protected
+  attr_writer :subnet, :netmask, :comm
+end

data/lib/raptor-io/socket/tcp.rb

@@ -0,0 +1,231 @@
+# TCP client socket
+class RaptorIO::Socket::TCP < RaptorIO::Socket
+
+  # Default configuration options.
+  DEFAULT_OPTIONS = {
+    connect_timeout: 5,
+  }
+
+  # Default options for SSL streams connected through this socket.
+  #
+  # @see #to_ssl
+  # @see TCP::SSL
+  DEFAULT_SSL_OPTIONS = {
+    ssl_version:         :TLSv1,
+    ssl_verify_mode:     OpenSSL::SSL::VERIFY_NONE,
+  }
+
+  # @!attribute socket
+  #   The underlying IO for this socket. Usually this is the
+  #   `socket` passed to {#initialize}
+  #   @return [IO]
+  attr_accessor :socket
+
+  # @param (see Socket#initialize)
+  def initialize(socket, options = {})
+    options = DEFAULT_OPTIONS.merge(options)
+    super
+    @plaintext_socket = @socket = socket
+  end
+
+  # @!method getpeername(string)
+  #   Return a Sockaddr struct for the *socket*. Note that this is the
+  #   @return [String] Sockaddr data.
+  def_delegator :@plaintext_socket, :getpeername, :getpeername
+
+  # @!method ungetc
+  #   Pushes back one character onto the {#socket}'s read buffer. Note
+  #   that some streams will *lose data* if this is called with a
+  #   `string` larger than one byte or called more than once between
+  #   calls to {#read}!
+  #
+  #   @param string [String] A single-byte string
+  #   @return [nil]
+  def_delegator :@socket, :ungetc, :ungetc
+
+  def remote_address
+    ::Addrinfo.new([ "AF_INET", options[:peer_port], options[:peer_host], options[:peer_host] ])
+  end
+
+  # Write `data` to the {#socket}.
+  #
+  # @param data [String,#to_s]
+  # @return [Fixnum]
+  def write(data)
+    begin
+      write_nonblock(data)
+    rescue IO::WaitWritable
+      IO.select(nil, [@socket])
+      retry
+    end
+  end
+
+  # Try to write `data` to the {#socket}.
+  #
+  # @param maxlen [Fixnum]
+  # @return [String]
+  def write_nonblock(data)
+    translate_errors do
+      @socket.write_nonblock(data)
+    end
+  end
+
+  # Read exactly `maxlen` bytes from the {#socket}. If fewer than
+  # `maxlen` bytes are available for reading, wait until enough data
+  # is sent.
+  #
+  # @note May block
+  #
+  # @param (see #read_nonblock)
+  # @return (see #read_nonblock)
+  def read(maxlen)
+    buf = ""
+    until 0 == maxlen
+      prev_length = buf.length
+      buf << readpartial(maxlen)
+      maxlen -= buf.length - prev_length
+    end
+    buf
+  end
+
+  # Read at most `maxlen` bytes from the {#socket}.
+  #
+  # @note May block
+  #
+  # @param (see #read_nonblock)
+  # @return (see #read_nonblock)
+  def readpartial(maxlen = nil)
+    begin
+      read_nonblock(maxlen)
+    rescue IO::WaitReadable
+      IO.select([@socket])
+      retry
+    end
+  end
+
+  # Read at most `maxlen` bytes from the {#socket}.
+  #
+  # @param maxlen [Fixnum]
+  # @return [String]
+  def read_nonblock(maxlen = nil)
+    translate_errors do
+      @socket.read_nonblock(maxlen)
+    end
+  end
+
+  # Ruby `Socket#gets` accepts:
+  #
+  # * `gets( sep = $/ )`
+  # * `gets( limit = nil )`
+  # * `gets( sep = $/, limit = nil )`
+  #
+  # `OpenSSL::SSL::SSLSocket#gets` however only supports `gets(sep=$/, limit=nil)`.
+  # This hack allows SSLSocket to behave the same as Ruby Socket.
+  #
+  # @note May block
+  def gets(*args)
+    translate_errors do
+      if args.size == 1
+        arg = args.first
+        if arg.is_a?(Numeric)
+          @socket.gets($/, arg)
+        else
+          @socket.gets(arg)
+        end
+      else
+        @socket.gets(*args)
+      end
+    end
+  end
+
+  # Close this socket. If this socket is an SSL stream, closes both the
+  # SSL stream and the underlying socket
+  #
+  # @return [void]
+  def close
+    begin
+      super
+    ensure
+      if (!@plaintext_socket.closed?)
+        @plaintext_socket.close
+      end
+    end
+  end
+
+  # Attempt to turn this into something usable by `IO.select`.
+  #
+  # @return [IO]
+  def to_io
+    IO.try_convert(@socket) || @socket
+  end
+
+  # Whether this socket is encrypted with SSL
+  def ssl?
+    !!(@socket.respond_to?(:context) && @socket.context)
+  end
+
+  # The version of SSL/TLS that was negotiated with the server.
+  #
+  # @return [String] See OpenSSL::SSL::SSLSocket#ssl_version for
+  #   possible values
+  # @return [nil] If this socket is not SSL
+  def ssl_version
+    return nil unless ssl?
+    @socket.ssl_version
+  end
+
+  # @return [OpenSSL::SSL::SSLContext]
+  # @return [nil] If this socket is not SSL (see {#ssl?})
+  def ssl_context
+    return nil unless ssl?
+    @socket.context
+  end
+
+  # @note The original socket is replaced by the newly connected
+  #   {TCP::SSL} socket
+  #
+  # Starts an SSL/TLS stream over this connection.
+  #
+  # Using this as opposed to directly instantiating {TCP::SSL} allows
+  # you to start a TLS connection after data has already been exchanged
+  # to enable things like `STARTTLS`.
+  #
+  # @note May block
+  #
+  # @param ssl_options [Hash]  Options
+  # @option ssl_options :ssl_version [Symbol] (:TLSv1)
+  # @option ssl_options :ssl_verify_mode [Constant] (OpenSSL::SSL::VERIFY_PEER)
+  #   Peer verification mode.
+  # @option ssl_config :ssl_context [OpenSSL::SSL::SSLContext] (nil)
+  #   SSL context to use.
+  #
+  # @return [RaptorIO::Socket::TCP::SSL] A new Socket with an established
+  #   SSL connection
+  def to_ssl(ssl_options = {})
+    if ssl_options[:ssl_context]
+      options[:ssl_context] = ssl_options[:ssl_context]
+    else
+      ssl_options = DEFAULT_SSL_OPTIONS.merge(ssl_options)
+      options[:ssl_context] = OpenSSL::SSL::SSLContext.new.tap do |ctx|
+        ctx.ssl_version = ssl_options[:ssl_version]
+        ctx.verify_mode = ssl_options[:ssl_verify_mode]
+      end
+    end
+
+    s = RaptorIO::Socket::TCP::SSL.new(@plaintext_socket, options)
+    @socket = s
+    s
+  end
+
+  private
+  attr_accessor :plaintext_socket
+
+  def translate_errors(&block)
+    yield
+  rescue Errno::ECONNRESET, Errno::EPIPE
+    raise RaptorIO::Socket::Error::BrokenPipe
+  rescue Errno::ECONNREFUSED
+    raise RaptorIO::Socket::Error::ConnectionRefused
+  end
+
+end

data/lib/raptor-io/socket/tcp/ssl.rb

@@ -0,0 +1,77 @@
+
+# TCP client with SSL encryption.
+#
+# @author Tasos Laskos <tasos_laskos@rapid7.com>
+class RaptorIO::Socket::TCP::SSL < RaptorIO::Socket::TCP
+
+  # Create a new {SSL} from an already-connected
+  # `OpenSSL::SSL::SSLSocket`.
+  #
+  # @example
+  #   tcp_server = ::TCPServer.new()
+  #   ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server)
+  #   RaptorIO::Socket::TCP::SSL.from_openssl(ssl_server.accept)
+  #
+  # @see TCPServer::SSL
+  # @param openssl_socket [OpenSSL::SSL::SSLSocket]
+  # @return [SSL]
+  def self.from_openssl(openssl_socket)
+    raptor = self.allocate
+    raptor.__send__(:socket=, openssl_socket)
+    raptor.__send__(:plaintext_socket=, openssl_socket.to_io)
+    raptor.options = {}
+    raptor.options[:ssl_context] = openssl_socket.context
+
+    raptor
+  end
+
+  # @!method ssl_context
+  #   The SSL context for this encrypted stream.
+  #
+  #   @return [OpenSSL::SSL::Context]
+  def_delegator :@socket, :ssl_context, :context
+
+  # @!method verify_mode
+  #   @return [Fixnum] One of the `OpenSSL::SSL::VERIFY_*` constants
+  def_delegator :@socket, :ssl_verify_mode, :verify_mode
+
+  # @!method version
+  #   @return [Symbol]  SSL version.
+  def_delegator :@socket, :ssl_version, :version
+
+  # @param  socket  [RaptorIO::Socket]
+  # @param  options [Hash]  Options
+  # @option (see TCP#to_ssl)
+  def initialize( socket, options = {} )
+    options = DEFAULT_SSL_OPTIONS.merge( options )
+    super
+
+    @context = options[:context] || options[:ssl_context]
+
+    if @context.nil?
+      @context = OpenSSL::SSL::SSLContext.new( options[:ssl_version] )
+      @context.verify_mode = options[:ssl_verify_mode]
+    end
+
+    @socket = OpenSSL::SSL::SSLSocket.new(socket.to_io, @context)
+    begin
+      #$stderr.puts("#{self.class}#initialize connecting")
+      @socket.connect_nonblock
+    rescue IO::WaitReadable, IO::WaitWritable => e
+      #$stderr.puts("Wait*able #{e}, #{options[:connect_timeout].inspect}")
+      if e.kind_of? IO::WaitReadable
+        r,w,_ = IO.select([@socket], nil, nil, options[:connect_timeout])
+      else
+        r,w,_ = IO.select(nil, [@socket], nil, options[:connect_timeout])
+      end
+
+      if r.nil? && w.nil?
+        #$stderr.puts("timeout")
+        raise RaptorIO::Socket::Error::ConnectionTimeout.new(e.to_s)
+      end
+
+      retry
+    end
+  end
+
+end

data/lib/raptor-io/socket/tcp_server.rb

@@ -0,0 +1,16 @@
+# A listening TCP socket
+class RaptorIO::Socket::TCPServer < RaptorIO::Socket
+
+  # @!method accept
+  def_delegator :@socket, :accept, :accept
+
+  # @!method accept_nonblock
+  def_delegator :@socket, :accept_nonblock, :accept_nonblock
+
+  # @!method bind
+  def_delegator :@socket, :bind, :bind
+
+  # @!method listen
+  def_delegator :@socket, :listen, :listen
+
+end

data/lib/raptor-io/socket/tcp_server/ssl.rb

@@ -0,0 +1,52 @@
+# TCP server with SSL encryption.
+#
+# @author Tasos Laskos <tasos_laskos@rapid7.com>
+class RaptorIO::Socket::TCPServer::SSL < RaptorIO::Socket::TCPServer
+
+  def initialize( socket, options = {} )
+    #p options[:context].frozen?
+    super
+    #p options[:context].frozen?
+
+    @context = options[:context]
+    if @context.nil?
+      @context = OpenSSL::SSL::SSLContext.new( options[:ssl_version] )
+      @context.verify_mode = options[:verify_mode]
+    end
+
+    @plaintext_socket = socket
+    @socket = OpenSSL::SSL::SSLServer.new( socket, @context )
+  end
+
+  # Accepts a client connection.
+  #
+  # @see Socket::TCP::SSL.from_openssl
+  # @return [RaptorIO::Socket::TCP::SSL]
+  def accept
+    RaptorIO::Socket::TCP::SSL.from_openssl(@socket.accept)
+  end
+
+  # Accepts a client connection without blocking.
+  #
+  # @see Socket::TCP::SSL.from_openssl
+  # @return [RaptorIO::Socket::TCP::SSL]
+  # @raise [IO::WaitWritable]
+  def accept_nonblock
+    RaptorIO::Socket::TCP::SSL.from_openssl(@socket.accept_nonblock)
+  end
+
+  # Close this SSL stream and the underlying socket
+  #
+  # @return [void]
+  def close
+    begin
+      @socket.close
+    ensure
+      if (!@plaintext_socket.closed?)
+        @plaintext_socket.close
+      end
+    end
+  end
+
+
+end

data/lib/raptor-io/version.rb

@@ -0,0 +1,6 @@
+module RaptorIO
+
+  # Version number.
+  VERSION = '0.0.1'
+
+end

data/lib/tasks/yard.rake

@@ -0,0 +1,26 @@
+# @note All options not specific to any given rake task should go in the .yardopts file so they are available to both
+#   the below rake tasks and when invoking `yard` from the command line
+
+if defined? YARD
+  namespace :yard do
+    YARD::Rake::YardocTask.new(:doc) do |t|
+      # --no-stats here as 'stats' task called after will print fuller stats
+      t.options = ['--no-stats']
+
+      t.after = Proc.new {
+        Rake::Task['yard:stats'].execute
+      }
+    end
+
+    desc "Shows stats for YARD Documentation including listing undocumented modules, classes, constants, and methods"
+    task :stats => :environment do
+      stats = YARD::CLI::Stats.new
+      stats.run('--compact', '--list-undoc')
+    end
+  end
+
+  # @todo Figure out how to just clone description from yard:doc
+  desc "Generate YARD documentation"
+  # allow calling namespace to as a task that goes to default task for namespace
+  task :yard => ['yard:doc']
+end