raptor-io 0.0.1

data/lib/raptor-io/ruby/ipaddr.rb

@@ -0,0 +1,15 @@
+require 'ipaddr'
+
+class IPAddr
+
+  # @param [String, IPAddr] parse_me Object to parse.
+  # @return [IPAddr]
+  def self.parse(parse_me)
+    if parse_me.kind_of?(IPAddr)
+      parse_me
+    else
+      IPAddr.new(parse_me)
+    end
+  end
+end
+

data/lib/raptor-io/ruby/openssl.rb

@@ -0,0 +1,23 @@
+require 'openssl'
+
+class OpenSSL::SSL::SSLServer
+  # Guard this in case stdlib ever implements it
+  unless method_defined?(:accept_nonblock)
+    # Non-blocking version of accept, stolen directly from the blocking
+    # version, OpenSSL::SSL::SSLServer#accept.
+    def accept_nonblock
+      sock = @svr.accept_nonblock
+
+      begin
+        ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+        ssl.sync_close = true
+        ssl.accept if @start_immediately
+        ssl
+      rescue OpenSSL::SSL::SSLError => ex
+        sock.close
+        raise ex
+      end
+    end
+  end
+end
+

data/lib/raptor-io/ruby/string.rb

@@ -0,0 +1,27 @@
+class String
+
+  # @return [String]  `self` with 8-bit unsigned characters.
+  def repack
+    unpack( 'C*' ).pack( 'C*' )
+  end
+
+  # Forces `self` to UTF-8 and replaces invalid characters.
+  def force_utf8!
+    force_encoding( 'utf-8' )
+    encode!( 'utf-16be', invalid: :replace, undef: :replace ).encode( 'utf-8' )
+  end
+
+  # @return [String]  Copy of `self`, {#force_utf8! forced to UTF-8}.
+  def force_utf8
+    dup.force_utf8!
+  end
+
+  # @return [Bool]
+  #   `true` if `self` is binary, `false` if regular text.
+  def binary?
+    encoding == Encoding::ASCII_8BIT ||
+        index( "\x00" ) ||
+        count( "\x00-\x7F", "^ -~\t\r\n").fdiv( length ) > 0.3
+  end
+
+end

data/lib/raptor-io/socket.rb

@@ -0,0 +1,175 @@
+require 'forwardable'
+require 'raptor-io/ruby'
+
+# A basic class for specific transports to inherit from. Analogous to
+# stdlib's BasicSocket
+class RaptorIO::Socket
+  extend Forwardable
+
+  require 'raptor-io/socket/error'
+  require 'raptor-io/socket/switch_board'
+  require 'raptor-io/socket/tcp'
+  require 'raptor-io/socket/tcp/ssl'
+  require 'raptor-io/socket/tcp_server'
+  require 'raptor-io/socket/tcp_server/ssl'
+
+  # Like IO.select, but smarter
+  #
+  # OpenSSL does its own buffering which can result in a consumed TCP
+  # buffer, leading `IO.select` to think that the SSLSocket has no more
+  # data to provide, when that's not the case, effectively making
+  # `IO.select` block forever, even though the SSLSocket's buffer has
+  # not yet been consumed.
+  #
+  # We work around this by attempting a non-blocking read of one byte on
+  # each of the `read_array`, and putting the byte back with
+  # `Socket#ungetc` if it worked, or running it through the the real
+  # `IO.select` if it doesn't.
+  #
+  # @see http://bugs.ruby-lang.org/issues/8875
+  # @see http://jira.codehaus.org/browse/JRUBY-6874
+  # @param read_array [Array] (see IO.select)
+  # @param write_array [Array] (see IO.select)
+  # @param error_array [Array] (see IO.select)
+  # @param timeout [Fixnum,nil] (see IO.select)
+  #
+  # @return [Array] An Array containing three arrays of IO objects that
+  #   are ready for reading, ready for writing, or have pending errors,
+  #   respectively.
+  # @return [nil] If optional `timeout` is given and `timeout` seconds
+  #   elapse before any data is available
+  def self.select(read_array=[], write_array=[], error_array=[], timeout=nil)
+    read_array  ||= []
+    write_array ||= []
+    error_array ||= []
+
+    readers_with_data = []
+
+    selectable_readers = read_array.dup.delete_if do |reader|
+      begin
+        # If this socket doesn't have a read_nonblock method, then it's
+        # a server of some kind and we have to run it through the real
+        # select to see if it can {TCPServer#accept accept}.
+        next false unless reader.respond_to? :read_nonblock
+
+        byte = reader.read_nonblock(1)
+      rescue IO::WaitReadable, IO::WaitWritable
+        # Then this thing needs to go through the real select to be able
+        # to tell if it has data.
+        #
+        # Note that {IO::WaitWritable} is needed here because OpenSSL
+        # sockets can block for writing when calling `read*` because of
+        # session renegotiation and the like.
+        false
+      rescue EOFError
+        # Then this thing has an empty read buffer and there's no more
+        # on the wire. We mark it as having data so a subsequent
+        # read or read_nonblock will raise EOFError appropriately.
+        readers_with_data << reader
+        true
+      else
+        # Then this thing has data already in its read buffer and we can
+        # skip the real select for it.
+        reader.ungetc(byte)
+        readers_with_data << reader
+        true
+      end
+    end
+
+    if readers_with_data.any?
+      if selectable_readers.any? || write_array.any? || error_array.any?
+        #$stderr.puts(" ----- Selecting readers:")
+        #pp selectable_readers
+        # Then see if anything has data right now by using a 0 timeout
+        r,w,e = IO.select(selectable_readers, write_array, error_array, 0)
+
+        real = [
+          readers_with_data | (r || []),
+          w || [],
+          e || []
+        ]
+      else
+        # Then there's nothing selectable and we can just return stuff
+        # that has buffered data
+        real = [ readers_with_data, [], [] ]
+      end
+    else
+      # Then wait the given timeout, regardless of whether the arrays
+      # are empty
+      real = IO.select(read_array, write_array, error_array, timeout)
+    end
+
+    #$stderr.puts '------ RaptorIO::Socket.select result ------'
+    #pp real
+    return real
+  end
+
+  class << self
+
+    # Captures Ruby exceptions and converts them to RaptorIO Errors.
+    #
+    # @param  [Block] block Block to run.
+    def translate_errors( &block )
+      block.call
+    rescue ::Errno::EPIPE, ::Errno::ECONNRESET => e
+      raise RaptorIO::Socket::Error::BrokenPipe, e.to_s
+    rescue ::Errno::ECONNREFUSED => e
+      raise RaptorIO::Socket::Error::ConnectionRefused, e.to_s
+    end
+
+    # Delegates to `::Socket.getaddrinfo`.
+    def getaddrinfo( *args )
+      begin
+        ::Socket.getaddrinfo( *args )
+      # OSX raises SocketError.
+      rescue ::SocketError, ::Errno::ENOENT => e
+        raise RaptorIO::Socket::Error::CouldNotResolve.new( e.to_s )
+      end
+    end
+
+    # Delegate to Ruby Socket.
+    def method_missing(meth, *args, &block)
+      #$stderr.puts("Socket.method_missing(#{meth}, #{args.inspect}")
+      if ::Socket.respond_to?(meth)
+        translate_errors do
+          ::Socket.__send__(meth, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, include_private=false)
+      ::Socket.respond_to?(meth, include_private)
+    end
+  end
+
+  # Options for this socket.
+  #
+  # @return [Hash<Symbol,Object>]
+  attr_accessor :options
+
+  # @!method to_io
+  #   Used by Kernel.select
+  #   @return [IO]
+  def_delegator :@socket, :to_io, :to_io
+
+  # @param socket [IO] An already-connected socket.
+  # @param options [Hash] Options (see {#options}).
+  def initialize( socket, options = {} )
+    @socket  = socket
+    @options = options
+  end
+
+  # @!method closed?
+  def_delegator :@socket, :closed?, :closed?
+
+  # @!method close
+  def_delegator :@socket, :close, :close
+
+  # Whether this socket is an SSL stream.
+  def ssl?
+    false
+  end
+
+end

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

@@ -0,0 +1,143 @@
+# -*- coding: binary -*-
+require 'raptor-io/socket'
+require 'ipaddr'
+
+###
+#
+# Provides the basic interface that a derived class must implement
+# in order to be a routable socket creator.
+#
+# See {RaptorIO::Socket::Comm::Local} for an implementation using sockets
+# created with standard Ruby Socket classes.
+#
+# Subclasses must implement the following methods:
+#
+#   * `resolve`
+#   * `create_tcp`
+#   * `create_tcp_server`
+#   * `create_udp`
+#   * `create_udp_server`
+#   * `support_ipv6?`
+#
+###
+class RaptorIO::Socket::Comm
+  require 'raptor-io/socket/comm/local'
+  require 'raptor-io/socket/comm/socks'
+  require 'raptor-io/socket/comm/sapni'
+
+  # @param uri [URI]
+  def self.from_uri(uri, opts = {})
+    raise ArgumentError unless uri.kind_of? URI
+
+    prev_comm = opts[:prev_comm] || RaptorIO::Socket::Comm::Local.new
+
+    comm = case uri.scheme.downcase
+           when "sapni"
+             uri.port ||= 3299
+             RaptorIO::Socket::Comm::SAPNI.new(
+               sap_host: uri.host,
+               sap_port: uri.port,
+               sap_comm: prev_comm,
+             )
+           when "socks"
+             uri.port ||= 1080
+             RaptorIO::Socket::Comm::SOCKS.new(
+               socks_host: uri.host,
+               socks_port: uri.port,
+               socks_comm: prev_comm,
+             )
+           end
+
+    comm
+  end
+
+  # Creates a socket on this Comm based on the supplied uniform
+  # parameters.
+  #
+  # @option options :switch_board [SwitchBoard]
+  # @option options :port [Fixnum] Optional based on proto
+  # @option options :protocol [Symbol]
+  #   * `:tcp`
+  #   * `:udp`
+  #
+  # @return [RaptorIO::Socket]
+  def create( options )
+    options = options.dup
+    options[:peer_host] = IPAddr.parse(options[:peer_host])
+
+    case options.delete(:protocol)
+      when :tcp
+        options[:server] ? create_tcp_server(options) : create_tcp(options)
+
+      when :udp
+        options[:server] ? create_udp_server(options) : create_udp(options)
+    end
+  end
+
+  # Resolves a hostname to an IP address using this comm.
+  #
+  # @abstract
+  #
+  # @param  [String]  hostname
+  def resolve( hostname )
+    raise NotImplementedError
+  end
+
+  # Resolves an IP address to a hostname using this comm.
+  #
+  # @abstract
+  #
+  # @param ip_address [String]
+  def reverse_resolve( ip_address )
+    raise NotImplementedError
+  end
+
+  # Connect to a host over TCP.
+  #
+  # @abstract
+  #
+  # @option options :peer_host [String,IPAddr]
+  # @option options :peer_port [Fixnum]
+  # @option options :local_host [String,IPAddr]
+  # @option options :local_port [Fixnum]
+  # @return [RaptorIO::Socket::TCP]
+  def create_tcp(options)
+    raise NotImplementedError
+  end
+
+  # Create a UDP socket bound to the given :peer_host
+  #
+  # @abstract
+  #
+  # @option options :peer_host [String,IPAddr]
+  # @option options :peer_port [Fixnum]
+  # @option options :local_host [String,IPAddr]
+  # @option options :local_port [Fixnum]
+  def create_udp(options)
+    raise NotImplementedError
+  end
+
+  # Create a TCP server listening on :local_port
+  #
+  # @abstract
+  #
+  # @option options :local_host [String,IPAddr]
+  # @option options :local_port [Fixnum]
+  # @option options :ssl_context [OpenSSL::SSL::Context]
+  def create_tcp_server(options)
+    raise NotImplementedError
+  end
+
+  # Create a UDP server listening on :local_port
+  #
+  # @abstract
+  #
+  # @option options :local_host [String,IPAddr]
+  # @option options :local_port [Fixnum]
+  def create_udp_server(options)
+    raise NotImplementedError
+  end
+
+
+end
+

data/lib/raptor-io/socket/comm/local.rb

@@ -0,0 +1,94 @@
+# -*- coding: binary -*-
+require 'timeout'
+require 'socket'
+require 'resolv'
+
+# Local communication using Ruby `::Socket`s
+class RaptorIO::Socket::Comm::Local < RaptorIO::Socket::Comm
+
+  # Determine whether we support IPv6
+  #
+  # We attempt to discover this by creating an unbound UDP socket with
+  # the AF_INET6 address family
+  def support_ipv6?
+    return @supports_ipv6 unless @supports_ipv6.nil?
+
+    @supports_ipv6 = false
+
+    if ::Socket.const_defined?('AF_INET6')
+      begin
+        ::Socket.new(::Socket::AF_INET6, ::Socket::SOCK_DGRAM, ::Socket::IPPROTO_UDP).close
+        @supports_ipv6 = true
+      rescue
+      end
+    end
+
+    @supports_ipv6
+  end
+
+  # Resolves a hostname to an IP address using this comm.
+  #
+  # @param hostname [String]
+  def resolve( hostname )
+    ::Resolv.getaddress hostname
+  end
+
+  # Resolves an IP address to a hostname using this comm.
+  #
+  # @param  [String]  ip_address
+  def reverse_resolve( ip_address )
+    ::Resolv.getname ip_address
+  end
+
+  # Connect to `:peer_host`
+  #
+  # @option (see Comm#create_tcp)
+  # @return [Socket::TCP]
+  # @raise [RaptorIO::Socket::Error::ConnectTimeout]
+  def create_tcp( options )
+    phost = IPAddr.parse( options[:peer_host] )
+
+    # Passing an explicit ::Socket::IPPROTO_TCP is broken on jruby
+    #  See https://github.com/jruby/jruby/issues/785
+    socket = ::Socket.new(phost.family, ::Socket::SOCK_STREAM, 0)
+    socket.do_not_reverse_lookup = true
+
+    if options[:local_port] || options[:local_host]
+      socket.bind(::Socket.pack_sockaddr_in(options[:local_port], options[:local_host]))
+    end
+
+    begin
+      socket.connect_nonblock(::Socket.pack_sockaddr_in(options[:peer_port], phost.to_s))
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET
+      raise RaptorIO::Socket::Error::ConnectionRefused
+    rescue Errno::EINPROGRESS
+      # This should almost always be raised with a call to
+      # connect_nonblock. When the socket finishes connecting it
+      # becomes available for writing.
+      res = select(nil, [socket], nil, options[:connect_timeout] || 2)
+      if res.nil?
+        raise RaptorIO::Socket::Error::ConnectionTimeout
+      end
+    end
+
+    if options[:ssl_context]
+      RaptorIO::Socket::TCP::SSL.new(socket, options)
+    else
+      RaptorIO::Socket::TCP.new(socket, options)
+    end
+  end
+
+  # Listen locally on `:local_port`
+  #
+  # @option (see Comm#create_tcp_server)
+  def create_tcp_server( options )
+    socket = TCPServer.new( options[:local_host], options[:local_port] )
+
+    if (options[:context] = options.delete(:ssl_context))
+      RaptorIO::Socket::TCPServer::SSL.new( socket, options )
+    else
+      RaptorIO::Socket::TCPServer.new( socket, options )
+    end
+  end
+
+end