1285 lines
35 KiB
Ruby
1285 lines
35 KiB
Ruby
#--
|
|
#
|
|
# 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
|
|
|
|
# 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 / 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, cert_chain, 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) if tls_parm_set?(priv_key)
|
|
@tls_parms[signature][:cert_chain] = File.read(cert_chain) 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]
|
|
ctx.key = OpenSSL::PKey::RSA.new(tls_parms[:priv_key]) if tls_parms[:priv_key]
|
|
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 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.each {|t|
|
|
if t.first <= @current_loop_time
|
|
@timers.delete t
|
|
EventMachine::event_callback "", TimerFired, t.last
|
|
else
|
|
break
|
|
end
|
|
}
|
|
#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'
|