eventmachine-mkroman 1.3.0.dev.1

data/lib/em/pure_ruby.rb

@@ -0,0 +1,1300 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 Apr 2006
+#
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+#
+# See the file COPYING for complete licensing information.
+#
+#-------------------------------------------------------------------
+#
+#
+
+# TODO List:
+# TCP-connects currently assume non-blocking connect is available- need to
+#  degrade automatically on versions of Ruby prior to June 2006.
+#
+
+require 'singleton'
+require 'forwardable'
+require 'socket'
+require 'fcntl'
+require 'set'
+require 'openssl'
+
+module EventMachine
+  # @private
+  class Error < Exception; end
+  # @private
+  class UnknownTimerFired < RuntimeError; end
+  # @private
+  class Unsupported < RuntimeError; end
+  # @private
+  class ConnectionError < RuntimeError; end
+  # @private
+  class ConnectionNotBound < RuntimeError; end
+  class InvalidPrivateKey < RuntimeError; end
+
+  # Older versions of Ruby may not provide the SSLErrorWaitReadable
+  # OpenSSL class. Create an error class to act as a "proxy".
+  if defined?(OpenSSL::SSL::SSLErrorWaitReadable)
+    SSLConnectionWaitReadable = OpenSSL::SSL::SSLErrorWaitReadable
+  else
+    SSLConnectionWaitReadable = IO::WaitReadable
+  end
+
+  # Older versions of Ruby may not provide the SSLErrorWaitWritable
+  # OpenSSL class. Create an error class to act as a "proxy".
+  if defined?(OpenSSL::SSL::SSLErrorWaitWritable)
+    SSLConnectionWaitWritable = OpenSSL::SSL::SSLErrorWaitWritable
+  else
+    SSLConnectionWaitWritable = IO::WaitWritable
+  end
+end
+
+module EventMachine
+  class CertificateCreator
+    attr_reader :cert, :key
+
+    def initialize
+      @key = OpenSSL::PKey::RSA.new(1024)
+      public_key = @key.public_key
+      subject = "/C=EventMachine/O=EventMachine/OU=EventMachine/CN=EventMachine"
+      @cert = OpenSSL::X509::Certificate.new
+      @cert.subject = @cert.issuer = OpenSSL::X509::Name.parse(subject)
+      @cert.not_before = Time.now
+      @cert.not_after = Time.now + 365 * 24 * 60 * 60
+      @cert.public_key = public_key
+      @cert.serial = 0x0
+      @cert.version = 2
+      factory = OpenSSL::X509::ExtensionFactory.new
+      factory.subject_certificate = @cert
+      factory.issuer_certificate = @cert
+      @cert.extensions = [
+        factory.create_extension("basicConstraints","CA:TRUE", true),
+        factory.create_extension("subjectKeyIdentifier", "hash")
+      ]
+      @cert.add_extension factory.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always")
+      @cert.sign(@key, OpenSSL::Digest::SHA1.new)
+    end
+  end
+
+  # @private
+  DefaultCertificate = CertificateCreator.new
+
+  # @private
+  DefaultDHKey1024 = OpenSSL::PKey::DH.new <<-_end_of_pem_
+-----BEGIN DH PARAMETERS-----
+MIGHAoGBAJ0lOVy0VIr/JebWn0zDwY2h+rqITFOpdNr6ugsgvkDXuucdcChhYExJ
+AV/ZD2AWPbrTqV76mGRgJg4EddgT1zG0jq3rnFdMj2XzkBYx3BVvfR0Arnby0RHR
+T4h7KZ/2zmjvV+eF8kBUHBJAojUlzxKj4QeO2x20FP9X5xmNUXeDAgEC
+-----END DH PARAMETERS-----
+  _end_of_pem_
+
+  # @private
+  DefaultDHKey2048 = OpenSSL::PKey::DH.new <<-_end_of_pem_
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEA7E6kBrYiyvmKAMzQ7i8WvwVk9Y/+f8S7sCTN712KkK3cqd1jhJDY
+JbrYeNV3kUIKhPxWHhObHKpD1R84UpL+s2b55+iMd6GmL7OYmNIT/FccKhTcveab
+VBmZT86BZKYyf45hUF9FOuUM9xPzuK3Vd8oJQvfYMCd7LPC0taAEljQLR4Edf8E6
+YoaOffgTf5qxiwkjnlVZQc3whgnEt9FpVMvQ9eknyeGB5KHfayAc3+hUAvI3/Cr3
+1bNveX5wInh5GDx1FGhKBZ+s1H+aedudCm7sCgRwv8lKWYGiHzObSma8A86KG+MD
+7Lo5JquQ3DlBodj3IDyPrxIv96lvRPFtAwIBAg==
+-----END DH PARAMETERS-----
+  _end_of_pem_
+end
+
+# @private
+module EventMachine
+  class << self
+    # This is mostly useful for automated tests.
+    # Return a distinctive symbol so the caller knows whether he's dealing
+    # with an extension or with a pure-Ruby library.
+    # @private
+    def library_type
+      :pure_ruby
+    end
+
+    # @private
+    def initialize_event_machine
+      Reactor.instance.initialize_for_run
+    end
+
+    # Changed 04Oct06: intervals from the caller are now in milliseconds, but our native-ruby
+    # processor still wants them in seconds.
+    # @private
+    def add_oneshot_timer interval
+      Reactor.instance.install_oneshot_timer(interval.to_f / 1000)
+    end
+
+    # @private
+    def run_machine
+      Reactor.instance.run
+    end
+
+    # @private
+    def release_machine
+    end
+
+
+    def stopping?
+      return Reactor.instance.stop_scheduled
+    end
+
+    # @private
+    def stop
+      Reactor.instance.stop
+    end
+
+    # @private
+    def connect_server host, port
+      bind_connect_server nil, nil, host, port
+    end
+
+    # @private
+    def bind_connect_server bind_addr, bind_port, host, port
+      EvmaTCPClient.connect(bind_addr, bind_port, host, port).uuid
+    end
+
+    # @private
+    def send_data target, data, datalength
+      selectable = Reactor.instance.get_selectable( target ) or raise "unknown send_data target"
+      selectable.send_data data
+    end
+
+    # @private
+    def close_connection target, after_writing
+      selectable = Reactor.instance.get_selectable( target )
+      selectable.schedule_close after_writing if selectable
+    end
+
+    # @private
+    def start_tcp_server host, port
+      (s = EvmaTCPServer.start_server host, port) or raise "no acceptor"
+      s.uuid
+    end
+
+    # @private
+    def stop_tcp_server sig
+      s = Reactor.instance.get_selectable(sig)
+      s.schedule_close
+    end
+
+    # @private
+    def start_unix_server chain
+      (s = EvmaUNIXServer.start_server chain) or raise "no acceptor"
+      s.uuid
+    end
+
+    # @private
+    def connect_unix_server chain
+      EvmaUNIXClient.connect(chain).uuid
+    end
+
+    # @private
+    def signal_loopbreak
+      Reactor.instance.signal_loopbreak
+    end
+
+    # @private
+    def get_peername sig
+      selectable = Reactor.instance.get_selectable( sig ) or raise "unknown get_peername target"
+      selectable.get_peername
+    end
+
+    # @private
+    def get_sockname sig
+      selectable = Reactor.instance.get_selectable( sig ) or raise "unknown get_sockname target"
+      selectable.get_sockname
+    end
+
+    # @private
+    def open_udp_socket host, port
+      EvmaUDPSocket.create(host, port).uuid
+    end
+
+    # This is currently only for UDP!
+    # We need to make it work with unix-domain sockets as well.
+    # @private
+    def send_datagram target, data, datalength, host, port
+      selectable = Reactor.instance.get_selectable( target ) or raise "unknown send_data target"
+      selectable.send_datagram data, Socket::pack_sockaddr_in(port, host)
+    end
+
+
+    # Sets reactor quantum in milliseconds. The underlying Reactor function wants a (possibly
+    # fractional) number of seconds.
+    # @private
+    def set_timer_quantum interval
+      Reactor.instance.set_timer_quantum(( 1.0 * interval) / 1000.0)
+    end
+
+    # This method is a harmless no-op in the pure-Ruby implementation. This is intended to ensure
+    # that user code behaves properly across different EM implementations.
+    # @private
+    def epoll
+    end
+
+    # @private
+    def ssl?
+      true
+    end
+
+    def tls_parm_set?(parm)
+      !(parm.nil? || parm.empty?)
+    end
+
+    # This method takes a series of positional arguments for specifying such
+    # things as private keys and certificate chains. It's expected that the
+    # parameter list will grow as we add more supported features. ALL of these
+    # parameters are optional, and can be specified as empty or nil strings.
+    # @private
+    def set_tls_parms signature, priv_key_path, priv_key, priv_key_pass, cert_chain_path, cert, verify_peer, fail_if_no_peer_cert, sni_hostname, cipher_list, ecdh_curve, dhparam, protocols_bitmask
+      bitmask = protocols_bitmask
+      ssl_options = OpenSSL::SSL::OP_ALL
+      ssl_options |= OpenSSL::SSL::OP_NO_SSLv2 if defined?(OpenSSL::SSL::OP_NO_SSLv2) && EM_PROTO_SSLv2 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_SSLv3 if defined?(OpenSSL::SSL::OP_NO_SSLv3) && EM_PROTO_SSLv3 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1 if defined?(OpenSSL::SSL::OP_NO_TLSv1) && EM_PROTO_TLSv1 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_1 if defined?(OpenSSL::SSL::OP_NO_TLSv1_1) && EM_PROTO_TLSv1_1 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_2 if defined?(OpenSSL::SSL::OP_NO_TLSv1_2) && EM_PROTO_TLSv1_2 & bitmask == 0
+      @tls_parms ||= {}
+      @tls_parms[signature] = {
+        :verify_peer => verify_peer,
+        :fail_if_no_peer_cert => fail_if_no_peer_cert,
+        :ssl_options => ssl_options
+      }
+      @tls_parms[signature][:priv_key] = File.read(priv_key_path) if tls_parm_set?(priv_key_path)
+      @tls_parms[signature][:priv_key] = priv_key if tls_parm_set?(priv_key)
+      @tls_parms[signature][:priv_key_pass] = priv_key_pass if tls_parm_set?(priv_key_pass)
+      @tls_parms[signature][:cert_chain] = File.read(cert_chain_path) if tls_parm_set?(cert_chain_path)
+      @tls_parms[signature][:cert_chain] = cert if tls_parm_set?(cert_chain)
+      @tls_parms[signature][:sni_hostname] = sni_hostname if tls_parm_set?(sni_hostname)
+      @tls_parms[signature][:cipher_list] = cipher_list.gsub(/,\s*/, ':') if tls_parm_set?(cipher_list)
+      @tls_parms[signature][:dhparam] = File.read(dhparam) if tls_parm_set?(dhparam)
+      @tls_parms[signature][:ecdh_curve] = ecdh_curve if tls_parm_set?(ecdh_curve)
+    end
+
+    def start_tls signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown io selectable for start_tls"
+      tls_parms = @tls_parms[signature]
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.options = tls_parms[:ssl_options]
+      ctx.cert = DefaultCertificate.cert
+      ctx.key = DefaultCertificate.key
+      ctx.cert_store = OpenSSL::X509::Store.new
+      ctx.cert_store.set_default_paths
+      ctx.cert = OpenSSL::X509::Certificate.new(tls_parms[:cert_chain]) if tls_parms[:cert_chain]
+      if tls_parms[:priv_key_pass]!=nil
+        ctx.key = OpenSSL::PKey::RSA.new(tls_parms[:priv_key],tls_parms[:priv_key_pass]) if tls_parms[:priv_key]
+      else
+        ctx.key = OpenSSL::PKey::RSA.new(tls_parms[:priv_key]) if tls_parms[:priv_key]
+      end
+      verify_mode = OpenSSL::SSL::VERIFY_NONE
+      if tls_parms[:verify_peer]
+        verify_mode |= OpenSSL::SSL::VERIFY_PEER
+      end
+      if tls_parms[:fail_if_no_peer_cert]
+        verify_mode |= OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      end
+      ctx.verify_mode = verify_mode
+      ctx.servername_cb = Proc.new do |_, server_name|
+        tls_parms[:server_name] = server_name
+        nil
+      end
+      ctx.ciphers = tls_parms[:cipher_list] if tls_parms[:cipher_list]
+      if selectable.is_server
+        ctx.tmp_dh_callback = Proc.new do |_, _, key_length|
+          if tls_parms[:dhparam]
+            OpenSSL::PKey::DH.new(tls_parms[:dhparam])
+          else
+            case key_length
+            when 1024 then DefaultDHKey1024
+            when 2048 then DefaultDHKey2048
+            else
+              nil
+            end
+          end
+        end
+        if tls_parms[:ecdh_curve] && ctx.respond_to?(:tmp_ecdh_callback)
+          ctx.tmp_ecdh_callback = Proc.new do
+            OpenSSL::PKey::EC.new(tls_parms[:ecdh_curve])
+          end
+        end
+      end
+      ssl_io = OpenSSL::SSL::SSLSocket.new(selectable, ctx)
+      ssl_io.sync_close = true
+      if tls_parms[:sni_hostname]
+        ssl_io.hostname = tls_parms[:sni_hostname] if ssl_io.respond_to?(:hostname=)
+      end
+      begin
+        selectable.is_server ? ssl_io.accept_nonblock : ssl_io.connect_nonblock
+      rescue; end
+      selectable.io = ssl_io
+    end
+
+    def get_peer_cert signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_peer_cert target"
+      if selectable.io.respond_to?(:peer_cert) && selectable.io.peer_cert
+        selectable.io.peer_cert.to_pem
+      else
+        nil
+      end
+    end
+
+    def get_cipher_name signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_name target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[0] : nil
+    end
+
+    def get_cipher_protocol signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_protocol target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[1] : nil
+    end
+
+    def get_cipher_bits signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_bits target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[2] : nil
+    end
+
+    def get_sni_hostname signature
+      @tls_parms ||= {}
+      if @tls_parms[signature]
+        @tls_parms[signature][:server_name]
+      else
+        nil
+      end
+    end
+
+    # This method is a no-op in the pure-Ruby implementation. We simply return Ruby's built-in
+    # per-process file-descriptor limit.
+    # @private
+    def set_rlimit_nofile n
+      1024
+    end
+
+    # This method is a harmless no-op in pure Ruby, which doesn't have a built-in limit
+    # on the number of available timers.
+    # @private
+    def set_max_timer_count n
+    end
+
+    # @private
+    def get_sock_opt signature, level, optname
+      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown get_sock_opt target"
+      selectable.getsockopt level, optname
+    end
+
+    # @private
+    def set_sock_opt signature, level, optname, optval
+      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown set_sock_opt target"
+      selectable.setsockopt level, optname, optval
+    end
+
+    # @private
+    def send_file_data sig, filename
+      sz = File.size(filename)
+      raise "file too large" if sz > 32*1024
+      data =
+        begin
+          File.read filename
+        rescue
+          ""
+        end
+      send_data sig, data, data.length
+    end
+
+    # @private
+    def get_outbound_data_size sig
+      r = Reactor.instance.get_selectable( sig ) or raise "unknown get_outbound_data_size target"
+      r.get_outbound_data_size
+    end
+
+    # @private
+    def read_keyboard
+      EvmaKeyboard.open.uuid
+    end
+
+    # @private
+    def set_comm_inactivity_timeout sig, tm
+      r = Reactor.instance.get_selectable( sig ) or raise "unknown set_comm_inactivity_timeout target"
+      r.set_inactivity_timeout tm
+    end
+
+    # @private
+    def set_pending_connect_timeout sig, tm
+      # Needs to be implemented. Currently a no-op stub to allow
+      # certain software to operate with the EM pure-ruby.
+    end
+
+    # @private
+    def report_connection_error_status signature
+      get_sock_opt(signature, Socket::SOL_SOCKET, Socket::SO_ERROR).int
+    end
+  end
+end
+
+module EventMachine
+  # @private
+  class Connection
+    # @private
+    def get_outbound_data_size
+      EventMachine::get_outbound_data_size @signature
+    end
+  end
+end
+
+module EventMachine
+
+  # Factored out so we can substitute other implementations
+  # here if desired, such as the one in ActiveRBAC.
+  # @private
+  module UuidGenerator
+    def self.generate
+      @ix ||= 0
+      @ix += 1
+    end
+  end
+end
+
+
+module EventMachine
+  # @private
+  TimerFired = 100
+  # @private
+  ConnectionData = 101
+  # @private
+  ConnectionUnbound = 102
+  # @private
+  ConnectionAccepted = 103
+  # @private
+  ConnectionCompleted = 104
+  # @private
+  LoopbreakSignalled = 105
+  # @private
+  ConnectionNotifyReadable = 106
+  # @private
+  ConnectionNotifyWritable = 107
+  # @private
+  SslHandshakeCompleted = 108
+  # @private
+  SslVerify = 109
+  # @private
+  EM_PROTO_SSLv2 = 2
+  # @private
+  EM_PROTO_SSLv3 = 4
+  # @private
+  EM_PROTO_TLSv1 = 8
+  # @private
+  EM_PROTO_TLSv1_1 = 16
+  # @private
+  EM_PROTO_TLSv1_2 = 32
+end
+
+module EventMachine
+  # @private
+  class Reactor
+    include Singleton
+
+    HeartbeatInterval = 2
+
+    attr_reader :current_loop_time, :stop_scheduled
+
+    def initialize
+      initialize_for_run
+    end
+
+    def get_timer_count
+      @timers.size
+    end
+
+    def install_oneshot_timer interval
+      uuid = UuidGenerator::generate
+      #@timers << [Time.now + interval, uuid]
+      #@timers.sort! {|a,b| a.first <=> b.first}
+      @timers.add([Time.now + interval, uuid])
+      uuid
+    end
+
+    # Called before run, this is a good place to clear out arrays
+    # with cruft that may be left over from a previous run.
+    # @private
+    def initialize_for_run
+      @running = false
+      @stop_scheduled = false
+      @selectables ||= {}; @selectables.clear
+      @timers = SortedSet.new # []
+      set_timer_quantum(0.1)
+      @current_loop_time = Time.now
+      @next_heartbeat = @current_loop_time + HeartbeatInterval
+    end
+
+    def add_selectable io
+      @selectables[io.uuid] = io
+    end
+
+    def get_selectable uuid
+      @selectables[uuid]
+    end
+
+    def run
+      raise Error.new( "already running" ) if @running
+      @running = true
+
+      begin
+        open_loopbreaker
+
+        loop {
+          @current_loop_time = Time.now
+
+          break if @stop_scheduled
+          run_timers
+          break if @stop_scheduled
+          crank_selectables
+          break if @stop_scheduled
+          run_heartbeats
+        }
+      ensure
+        close_loopbreaker
+        @selectables.each {|k, io| io.close}
+        @selectables.clear
+
+        @running = false
+      end
+
+    end
+
+    def run_timers
+      timers_to_delete = []
+      @timers.each {|t|
+        if t.first <= @current_loop_time
+          #@timers.delete t
+          timers_to_delete << t
+          EventMachine::event_callback "", TimerFired, t.last
+        else
+          break
+        end
+      }
+      timers_to_delete.map{|c| @timers.delete c}
+      timers_to_delete = nil
+      #while @timers.length > 0 and @timers.first.first <= now
+      #  t = @timers.shift
+      #  EventMachine::event_callback "", TimerFired, t.last
+      #end
+    end
+
+    def run_heartbeats
+      if @next_heartbeat <= @current_loop_time
+        @next_heartbeat = @current_loop_time + HeartbeatInterval
+        @selectables.each {|k,io| io.heartbeat}
+      end
+    end
+
+    def crank_selectables
+      #$stderr.write 'R'
+
+      readers = @selectables.values.select {|io| io.select_for_reading?}
+      writers = @selectables.values.select {|io| io.select_for_writing?}
+
+      s = select( readers, writers, nil, @timer_quantum)
+
+      s and s[1] and s[1].each {|w| w.eventable_write }
+      s and s[0] and s[0].each {|r| r.eventable_read }
+
+      @selectables.delete_if {|k,io|
+        if io.close_scheduled?
+          io.close
+          begin
+            EventMachine::event_callback io.uuid, ConnectionUnbound, nil
+          rescue ConnectionNotBound; end
+          true
+        end
+      }
+    end
+
+    # #stop
+    def stop
+      raise Error.new( "not running") unless @running
+      @stop_scheduled = true
+    end
+
+    def open_loopbreaker
+      # Can't use an IO.pipe because they can't be set nonselectable in Windows.
+      # Pick a random localhost UDP port.
+      #@loopbreak_writer.close if @loopbreak_writer
+      #rd,@loopbreak_writer = IO.pipe
+      @loopbreak_reader = UDPSocket.new
+      @loopbreak_writer = UDPSocket.new
+      bound = false
+      100.times {
+        @loopbreak_port = rand(10000) + 40000
+        begin
+          @loopbreak_reader.bind "127.0.0.1", @loopbreak_port
+          bound = true
+          break
+        rescue
+        end
+      }
+      raise "Unable to bind Loopbreaker" unless bound
+      LoopbreakReader.new(@loopbreak_reader)
+    end
+
+    def close_loopbreaker
+      @loopbreak_writer.close
+      @loopbreak_writer = nil
+    end
+
+    def signal_loopbreak
+      begin
+        @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
+      rescue IOError; end
+    end
+
+    def set_timer_quantum interval_in_seconds
+      @timer_quantum = interval_in_seconds
+    end
+
+  end
+
+end
+
+# @private
+class IO
+  extend Forwardable
+  def_delegator :@my_selectable, :close_scheduled?
+  def_delegator :@my_selectable, :select_for_reading?
+  def_delegator :@my_selectable, :select_for_writing?
+  def_delegator :@my_selectable, :eventable_read
+  def_delegator :@my_selectable, :eventable_write
+  def_delegator :@my_selectable, :uuid
+  def_delegator :@my_selectable, :is_server
+  def_delegator :@my_selectable, :is_server=
+  def_delegator :@my_selectable, :send_data
+  def_delegator :@my_selectable, :schedule_close
+  def_delegator :@my_selectable, :get_peername
+  def_delegator :@my_selectable, :get_sockname
+  def_delegator :@my_selectable, :send_datagram
+  def_delegator :@my_selectable, :get_outbound_data_size
+  def_delegator :@my_selectable, :set_inactivity_timeout
+  def_delegator :@my_selectable, :heartbeat
+  def_delegator :@my_selectable, :io
+  def_delegator :@my_selectable, :io=
+end
+
+module EventMachine
+  # @private
+  class Selectable
+
+    attr_accessor :io, :is_server
+    attr_reader :uuid
+
+    def initialize io
+      @io = io
+      @uuid = UuidGenerator.generate
+      @is_server = false
+      @last_activity = Reactor.instance.current_loop_time
+
+      if defined?(Fcntl::F_GETFL)
+        m = @io.fcntl(Fcntl::F_GETFL, 0)
+        @io.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK | m)
+      else
+        # Windows doesn't define F_GETFL.
+        # It's not very reliable about setting descriptors nonblocking either.
+        begin
+          s = Socket.for_fd(@io.fileno)
+          s.fcntl( Fcntl::F_SETFL, Fcntl::O_NONBLOCK )
+        rescue Errno::EINVAL, Errno::EBADF
+          warn "Serious error: unable to set descriptor non-blocking"
+        end
+      end
+      # TODO, should set CLOEXEC on Unix?
+
+      @close_scheduled = false
+      @close_requested = false
+
+      se = self; @io.instance_eval { @my_selectable = se }
+      Reactor.instance.add_selectable @io
+    end
+
+    def close_scheduled?
+      @close_scheduled
+    end
+
+    def select_for_reading?
+      false
+    end
+
+    def select_for_writing?
+      false
+    end
+
+    def get_peername
+      nil
+    end
+
+    def get_sockname
+      nil
+    end
+
+    def set_inactivity_timeout tm
+      @inactivity_timeout = tm
+    end
+
+    def heartbeat
+    end
+
+    def schedule_close(after_writing=false)
+      if after_writing
+        @close_requested = true
+      else
+        @close_scheduled = true
+      end
+    end
+  end
+
+end
+
+module EventMachine
+  # @private
+  class StreamObject < Selectable
+    def initialize io
+      super io
+      @outbound_q = []
+    end
+
+    # If we have to close, or a close-after-writing has been requested,
+    # then don't read any more data.
+    def select_for_reading?
+      true unless (@close_scheduled || @close_requested)
+    end
+
+    # If we have to close, don't select for writing.
+    # Otherwise, see if the protocol is ready to close.
+    # If not, see if he has data to send.
+    # If a close-after-writing has been requested and the outbound queue
+    # is empty, convert the status to close_scheduled.
+    def select_for_writing?
+      unless @close_scheduled
+        if @outbound_q.empty?
+          @close_scheduled = true if @close_requested
+          false
+        else
+          true
+        end
+      end
+    end
+
+    # Proper nonblocking I/O was added to Ruby 1.8.4 in May 2006.
+    # If we have it, then we can read multiple times safely to improve
+    # performance.
+    # The last-activity clock ASSUMES that we only come here when we
+    # have selected readable.
+    # TODO, coalesce multiple reads into a single event.
+    # TODO, do the function check somewhere else and cache it.
+    def eventable_read
+      @last_activity = Reactor.instance.current_loop_time
+      begin
+        if io.respond_to?(:read_nonblock)
+          10.times {
+            data = io.read_nonblock(4096)
+            EventMachine::event_callback uuid, ConnectionData, data
+          }
+        else
+          data = io.sysread(4096)
+          EventMachine::event_callback uuid, ConnectionData, data
+        end
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, SSLConnectionWaitReadable
+        # no-op
+      rescue Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, Errno::EPIPE, OpenSSL::SSL::SSLError
+        @close_scheduled = true
+        EventMachine::event_callback uuid, ConnectionUnbound, nil
+      end
+
+    end
+
+    # Provisional implementation. Will be re-implemented in subclasses.
+    # TODO: Complete this implementation. As it stands, this only writes
+    # a single packet per cycle. Highly inefficient, but required unless
+    # we're running on a Ruby with proper nonblocking I/O (Ruby 1.8.4
+    # built from sources from May 25, 2006 or newer).
+    # We need to improve the loop so it writes multiple times, however
+    # not more than a certain number of bytes per cycle, otherwise
+    # one busy connection could hog output buffers and slow down other
+    # connections. Also we should coalesce small writes.
+    # URGENT TODO: Coalesce small writes. They are a performance killer.
+    # The last-activity recorder ASSUMES we'll only come here if we've
+    # selected writable.
+    def eventable_write
+      # coalesce the outbound array here, perhaps
+      @last_activity = Reactor.instance.current_loop_time
+      while data = @outbound_q.shift do
+        begin
+          data = data.to_s
+          w = if io.respond_to?(:write_nonblock)
+                io.write_nonblock data
+              else
+                io.syswrite data
+              end
+
+          if w < data.length
+            @outbound_q.unshift data[w..-1]
+            break
+          end
+        rescue Errno::EAGAIN, SSLConnectionWaitReadable, SSLConnectionWaitWritable
+          @outbound_q.unshift data
+          break
+        rescue EOFError, Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::EPIPE, OpenSSL::SSL::SSLError
+          @close_scheduled = true
+          @outbound_q.clear
+        end
+      end
+
+    end
+
+    # #send_data
+    def send_data data
+      # TODO, coalesce here perhaps by being smarter about appending to @outbound_q.last?
+      unless @close_scheduled or @close_requested or !data or data.length <= 0
+        @outbound_q << data.to_s
+      end
+    end
+
+    # #get_peername
+    # This is defined in the normal way on connected stream objects.
+    # Return an object that is suitable for passing to Socket#unpack_sockaddr_in or variants.
+    # We could also use a convenience method that did the unpacking automatically.
+    def get_peername
+      io.getpeername
+    end
+
+    # #get_sockname
+    # This is defined in the normal way on connected stream objects.
+    # Return an object that is suitable for passing to Socket#unpack_sockaddr_in or variants.
+    # We could also use a convenience method that did the unpacking automatically.
+    def get_sockname
+      io.getsockname
+    end
+
+    # #get_outbound_data_size
+    def get_outbound_data_size
+      @outbound_q.inject(0) {|memo,obj| memo += (obj || "").length}
+    end
+
+    def heartbeat
+      if @inactivity_timeout and @inactivity_timeout > 0 and (@last_activity + @inactivity_timeout) < Reactor.instance.current_loop_time
+        schedule_close true
+      end
+    end
+  end
+
+
+end
+
+
+#--------------------------------------------------------------
+
+
+
+module EventMachine
+  # @private
+  class EvmaTCPClient < StreamObject
+
+    def self.connect bind_addr, bind_port, host, port
+      sd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      sd.bind( Socket.pack_sockaddr_in( bind_port, bind_addr ))  if bind_addr
+
+      begin
+        # TODO, this assumes a current Ruby snapshot.
+        # We need to degrade to a nonblocking connect otherwise.
+        sd.connect_nonblock( Socket.pack_sockaddr_in( port, host ))
+      rescue Errno::ECONNREFUSED, Errno::EINPROGRESS
+      end
+      EvmaTCPClient.new sd
+    end
+
+    def initialize io
+      super
+      @pending = true
+      @handshake_complete = false
+    end
+
+    def ready?
+      if RUBY_PLATFORM =~ /linux/
+        io.getsockopt(Socket::SOL_TCP, Socket::TCP_INFO).unpack("i").first == 1 # TCP_ESTABLISHED
+      else
+        io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first == 0 # NO ERROR
+      end
+    end
+
+    def handshake_complete?
+      if !@handshake_complete && io.respond_to?(:state)
+        if io.state =~ /^SSLOK/
+          @handshake_complete = true
+          EventMachine::event_callback uuid, SslHandshakeCompleted, ""
+          EventMachine::event_callback uuid, SslVerify, io.peer_cert.to_pem if io.peer_cert
+        end
+      else
+        @handshake_complete = true
+      end
+      @handshake_complete
+    end
+
+    def pending?
+      handshake_complete?
+      if @pending
+        if ready?
+          @pending = false
+          EventMachine::event_callback uuid, ConnectionCompleted, ""
+        end
+      end
+      @pending
+    end
+
+    def select_for_writing?
+      pending?
+      super
+    end
+
+    def select_for_reading?
+      pending?
+      super
+    end
+  end
+end
+
+
+
+module EventMachine
+  # @private
+  class EvmaKeyboard < StreamObject
+
+    def self.open
+      EvmaKeyboard.new STDIN
+    end
+
+
+    def initialize io
+      super
+    end
+
+
+    def select_for_writing?
+      false
+    end
+
+    def select_for_reading?
+      true
+    end
+
+
+  end
+end
+
+
+
+module EventMachine
+  # @private
+  class EvmaUNIXClient < StreamObject
+
+    def self.connect chain
+      sd = Socket.new( Socket::AF_LOCAL, Socket::SOCK_STREAM, 0 )
+      begin
+        # TODO, this assumes a current Ruby snapshot.
+        # We need to degrade to a nonblocking connect otherwise.
+        sd.connect_nonblock( Socket.pack_sockaddr_un( chain ))
+      rescue Errno::EINPROGRESS
+      end
+      EvmaUNIXClient.new sd
+    end
+
+
+    def initialize io
+      super
+      @pending = true
+    end
+
+
+    def select_for_writing?
+      @pending ? true : super
+    end
+
+    def select_for_reading?
+      @pending ? false : super
+    end
+
+    def eventable_write
+      if @pending
+        @pending = false
+        if 0 == io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first
+          EventMachine::event_callback uuid, ConnectionCompleted, ""
+        end
+      else
+        super
+      end
+    end
+
+
+
+  end
+end
+
+
+#--------------------------------------------------------------
+
+module EventMachine
+  # @private
+  class EvmaTCPServer < Selectable
+
+    # TODO, refactor and unify with EvmaUNIXServer.
+
+    class << self
+      # Versions of ruby 1.8.4 later than May 26 2006 will work properly
+      # with an object of type TCPServer. Prior versions won't so we
+      # play it safe and just build a socket.
+      #
+      def start_server host, port
+        sd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+        sd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true )
+        sd.bind( Socket.pack_sockaddr_in( port, host ))
+        sd.listen( 50 ) # 5 is what you see in all the books. Ain't enough.
+        EvmaTCPServer.new sd
+      end
+    end
+
+    def initialize io
+      super io
+    end
+
+
+    def select_for_reading?
+      true
+    end
+
+    #--
+    # accept_nonblock returns an array consisting of the accepted
+    # socket and a sockaddr_in which names the peer.
+    # Don't accept more than 10 at a time.
+    def eventable_read
+      begin
+        10.times {
+          descriptor,peername = io.accept_nonblock
+          sd = EvmaTCPClient.new descriptor
+          sd.is_server = true
+          EventMachine::event_callback uuid, ConnectionAccepted, sd.uuid
+        }
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+      end
+    end
+
+    #--
+    #
+    def schedule_close
+      @close_scheduled = true
+    end
+
+  end
+end
+
+
+#--------------------------------------------------------------
+
+module EventMachine
+  # @private
+  class EvmaUNIXServer < Selectable
+
+    # TODO, refactor and unify with EvmaTCPServer.
+
+    class << self
+      # Versions of ruby 1.8.4 later than May 26 2006 will work properly
+      # with an object of type TCPServer. Prior versions won't so we
+      # play it safe and just build a socket.
+      #
+      def start_server chain
+        sd = Socket.new( Socket::AF_LOCAL, Socket::SOCK_STREAM, 0 )
+        sd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true )
+        sd.bind( Socket.pack_sockaddr_un( chain ))
+        sd.listen( 50 ) # 5 is what you see in all the books. Ain't enough.
+        EvmaUNIXServer.new sd
+      end
+    end
+
+    def initialize io
+      super io
+    end
+
+
+    def select_for_reading?
+      true
+    end
+
+    #--
+    # accept_nonblock returns an array consisting of the accepted
+    # socket and a sockaddr_in which names the peer.
+    # Don't accept more than 10 at a time.
+    def eventable_read
+      begin
+        10.times {
+          descriptor,peername = io.accept_nonblock
+          sd = StreamObject.new descriptor
+          EventMachine::event_callback uuid, ConnectionAccepted, sd.uuid
+        }
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+      end
+    end
+
+    #--
+    #
+    def schedule_close
+      @close_scheduled = true
+    end
+
+  end
+end
+
+
+
+#--------------------------------------------------------------
+
+module EventMachine
+  # @private
+  class LoopbreakReader < Selectable
+
+    def select_for_reading?
+      true
+    end
+
+    def eventable_read
+      io.sysread(128)
+      EventMachine::event_callback "", LoopbreakSignalled, ""
+    end
+
+  end
+end
+
+
+
+# @private
+module EventMachine
+  # @private
+  class DatagramObject < Selectable
+    def initialize io
+      super io
+      @outbound_q = []
+    end
+
+    # #send_datagram
+    def send_datagram data, target
+      # TODO, coalesce here perhaps by being smarter about appending to @outbound_q.last?
+      unless @close_scheduled or @close_requested
+        @outbound_q << [data.to_s, target]
+      end
+    end
+
+    # #select_for_writing?
+    def select_for_writing?
+      unless @close_scheduled
+        if @outbound_q.empty?
+          @close_scheduled = true if @close_requested
+          false
+        else
+          true
+        end
+      end
+    end
+
+    # #select_for_reading?
+    def select_for_reading?
+      true
+    end
+
+    # #get_outbound_data_size
+    def get_outbound_data_size
+      @outbound_q.inject(0) {|memo,obj| memo += (obj || "").length}
+    end
+
+
+  end
+
+
+end
+
+
+module EventMachine
+  # @private
+  class EvmaUDPSocket < DatagramObject
+
+    class << self
+      def create host, port
+        sd = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+        sd.bind Socket::pack_sockaddr_in( port, host )
+        EvmaUDPSocket.new sd
+      end
+    end
+
+    # #eventable_write
+    # This really belongs in DatagramObject, but there is some UDP-specific stuff.
+    def eventable_write
+      40.times {
+        break if @outbound_q.empty?
+        begin
+          data,target = @outbound_q.first
+
+          # This damn better be nonblocking.
+          io.send data.to_s, 0, target
+
+          @outbound_q.shift
+        rescue Errno::EAGAIN
+          # It's not been observed in testing that we ever get here.
+          # True to the definition, packets will be accepted and quietly dropped
+          # if the system is under pressure.
+          break
+        rescue EOFError, Errno::ECONNRESET
+          @close_scheduled = true
+          @outbound_q.clear
+        end
+      }
+    end
+
+    # Proper nonblocking I/O was added to Ruby 1.8.4 in May 2006.
+    # If we have it, then we can read multiple times safely to improve
+    # performance.
+    def eventable_read
+      begin
+        if io.respond_to?(:recvfrom_nonblock)
+          40.times {
+            data,@return_address = io.recvfrom_nonblock(16384)
+            EventMachine::event_callback uuid, ConnectionData, data
+            @return_address = nil
+          }
+        else
+          raise "unimplemented datagram-read operation on this Ruby"
+        end
+      rescue Errno::EAGAIN
+        # no-op
+      rescue Errno::ECONNRESET, EOFError
+        @close_scheduled = true
+        EventMachine::event_callback uuid, ConnectionUnbound, nil
+      end
+    end
+
+    def send_data data
+      send_datagram data, @return_address
+    end
+  end
+end
+
+# load base EM api on top, now that we have the underlying pure ruby
+# implementation defined
+require 'eventmachine'