Module: EventMachine

# File 'ext/rubymain.cpp', line 1153

static VALUE t__epoll (VALUE self UNUSED)
{
	if (t__epoll_p(self) == Qfalse)
		return Qfalse;

	evma_set_epoll (1);
	return Qtrue;
}

# File 'ext/rubymain.cpp', line 1140

static VALUE t__epoll_p (VALUE self UNUSED)
{
	#ifdef HAVE_EPOLL
	return Qtrue;
	#else
	return Qfalse;
	#endif
}

# File 'lib/eventmachine.rb', line 1450

def self.heartbeat_interval
  EM::get_heartbeat_interval
end

# File 'lib/eventmachine.rb', line 1459

def self.heartbeat_interval=(time)
  EM::set_heartbeat_interval time.to_f
end

# File 'ext/rubymain.cpp', line 1193

static VALUE t__kqueue (VALUE self UNUSED)
{
	if (t__kqueue_p(self) == Qfalse)
		return Qfalse;

	evma_set_kqueue (1);
	return Qtrue;
}

# File 'ext/rubymain.cpp', line 1180

static VALUE t__kqueue_p (VALUE self UNUSED)
{
	#ifdef HAVE_KQUEUE
	return Qtrue;
	#else
	return Qfalse;
	#endif
}

# File 'lib/eventmachine.rb', line 1228

def self.reactor_running?
  @reactor_running && Process.pid == @reactor_pid
end

# File 'lib/eventmachine.rb', line 80

attr_reader :reactor_thread

# File 'lib/eventmachine.rb', line 228

def self.reactor_thread?
  Thread.current == @reactor_thread
end

# File 'ext/rubymain.cpp', line 1220

static VALUE t__ssl_p (VALUE self UNUSED)
{
	#ifdef WITH_SSL
	return Qtrue;
	#else
	return Qfalse;
	#endif
}

# File 'ext/rubymain.cpp', line 1233

static VALUE t_stopping ()
{
	if (evma_stopping()) {
		return Qtrue;
	} else {
		return Qfalse;
	}
}

# File 'lib/eventmachine.rb', line 1106

attr_reader :threadpool

# File 'lib/eventmachine.rb', line 1110

attr_accessor :threadpool_size

# File 'ext/rubymain.cpp', line 291

static VALUE t_add_oneshot_timer (VALUE self UNUSED, VALUE interval)
{
	const uintptr_t f = evma_install_oneshot_timer (FIX2LONG (interval));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "ran out of timers; use #set_max_timers to increase limit");
	return BSIG2NUM (f);
}

# File 'lib/eventmachine.rb', line 352

def self.add_periodic_timer *args, &block
  interval = args.shift
  code = args.shift || block

  EventMachine::PeriodicTimer.new(interval, code)
end

# File 'lib/eventmachine.rb', line 292

def self.add_shutdown_hook &block
  @tails << block
end

# File 'lib/eventmachine.rb', line 324

def self.add_timer *args, &block
  interval = args.shift
  code = args.shift || block
  if code
    # check too many timers!
    s = add_oneshot_timer((interval.to_f * 1000).to_i)
    @timers[s] = code
    s
  end
end

# File 'lib/eventmachine.rb', line 742

def EventMachine::attach io, handler=nil, *args, &blk
  attach_io io, false, handler, *args, &blk
end

# File 'lib/eventmachine.rb', line 747

def EventMachine::attach_io io, watch_mode, handler=nil, *args
  klass = klass_from_handler(Connection, handler, *args)

  if !watch_mode and klass.public_instance_methods.any?{|m| [:notify_readable, :notify_writable].include? m.to_sym }
    raise ArgumentError, "notify_readable/writable with EM.attach is not supported. Use EM.watch(io){ |c| c.notify_readable = true }"
  end

  if io.respond_to?(:fileno)
    # getDescriptorByFileno deprecated in JRuby 1.7.x, removed in JRuby 9000
    if defined?(JRuby) && JRuby.runtime.respond_to?(:getDescriptorByFileno)
      fd = JRuby.runtime.getDescriptorByFileno(io.fileno).getChannel
    else
      fd = io.fileno
    end
  else
    fd = io
  end

  s = attach_fd fd, watch_mode
  c = klass.new s, *args

  c.instance_variable_set(:@io, io)
  c.instance_variable_set(:@watch_mode, watch_mode)
  c.instance_variable_set(:@fd, fd)

  @conns[s] = c
  block_given? and yield c
  c
end

# File 'ext/rubymain.cpp', line 339

static VALUE t_attach_sd(VALUE self UNUSED, VALUE sd)
{
	const uintptr_t f = evma_attach_sd(FIX2INT(sd));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no socket descriptor acceptor");
	return BSIG2NUM (f);
}

# File 'lib/eventmachine.rb', line 542

def self.attach_server sock, handler=nil, *args, &block
  klass = klass_from_handler(Connection, handler, *args)
  sd = sock.respond_to?(:fileno) ? sock.fileno : sock
  s = attach_sd(sd)
  @acceptors[s] = [klass,args,block,sock]
  s
end

# File 'lib/eventmachine.rb', line 662

def self.bind_connect bind_addr, bind_port, server, port=nil, handler=nil, *args
  begin
    port = Integer(port)
  rescue ArgumentError, TypeError
    # there was no port, so server must be a unix domain socket
    # the port argument is actually the handler, and the handler is one of the args
    args.unshift handler if handler
    handler = port
    port = nil
  end if port

  klass = klass_from_handler(Connection, handler, *args)

  s = if port
        if bind_addr
          bind_connect_server bind_addr, bind_port.to_i, server, port
        else
          connect_server server, port
        end
      else
        connect_unix_server server
      end

  c = klass.new s, *args
  @conns[s] = c
  block_given? and yield c
  c
end

# File 'ext/rubymain.cpp', line 719

static VALUE t_bind_connect_server (VALUE self UNUSED, VALUE bind_addr, VALUE bind_port, VALUE server, VALUE port)
{
	// Avoid FIX2INT in this case, because it doesn't deal with type errors properly.
	// Specifically, if the value of port comes in as a string rather than an integer,
	// NUM2INT will throw a type error, but FIX2INT will generate garbage.

	try {
		const uintptr_t f = evma_connect_to_server (StringValueCStr(bind_addr), NUM2INT(bind_port), StringValueCStr(server), NUM2INT(port));
		if (!f)
			rb_raise (EM_eConnectionError, "%s", "no connection");
		return BSIG2NUM (f);
	} catch (std::runtime_error e) {
		rb_raise (EM_eConnectionError, "%s", e.what());
	}
	return Qnil;
}

# File 'lib/em/callback.rb', line 47

def self.Callback(object = nil, method = nil, &blk)
  if object && method
    lambda { |*args| object.__send__ method, *args }
  else
    if object.respond_to? :call
      object
    else
      blk || raise(ArgumentError)
    end # if
  end # if
end

# File 'lib/eventmachine.rb', line 364

def self.cancel_timer timer_or_sig
  if timer_or_sig.respond_to? :cancel
    timer_or_sig.cancel
  else
    @timers[timer_or_sig] = false if @timers.has_key?(timer_or_sig)
  end
end

# File 'lib/eventmachine.rb', line 262

def self.cleanup_machine
  if @threadpool && !@threadpool.empty?
    # Tell the threads to stop
    @threadpool.each { |t| t.exit }
    # Join the threads or bump the stragglers one more time
    @threadpool.each { |t| t.join 0.01 || t.exit }
  end
  @threadpool = nil
  @threadqueue = nil
  @resultqueue = nil
  @all_threads_spawned = false
  @next_tick_queue = []
end

# File 'ext/rubymain.cpp', line 676

static VALUE t_close_connection (VALUE self UNUSED, VALUE signature, VALUE after_writing)
{
	evma_close_connection (NUM2BSIG (signature), ((after_writing == Qtrue) ? 1 : 0));
	return Qnil;
}

# File 'lib/eventmachine.rb', line 632

def self.connect server, port=nil, handler=nil, *args, &blk
  # EventMachine::connect initiates a TCP connection to a remote
  # server and sets up event-handling for the connection.
  # It internally creates an object that should not be handled
  # by the caller. HOWEVER, it's often convenient to get the
  # object to set up interfacing to other objects in the system.
  # We return the newly-created anonymous-class object to the caller.
  # It's expected that a considerable amount of code will depend
  # on this behavior, so don't change it.
  #
  # Ok, added support for a user-defined block, 13Apr06.
  # This leads us to an interesting choice because of the
  # presence of the post_init call, which happens in the
  # initialize method of the new object. We call the user's
  # block and pass the new object to it. This is a great
  # way to do protocol-specific initiation. It happens
  # AFTER post_init has been called on the object, which I
  # certainly hope is the right choice.
  # Don't change this lightly, because accepted connections
  # are different from connected ones and we don't want
  # to have them behave differently with respect to post_init
  # if at all possible.

  bind_connect nil, nil, server, port, handler, *args, &blk
end

# File 'ext/rubymain.cpp', line 698

static VALUE t_connect_server (VALUE self UNUSED, VALUE server, VALUE port)
{
	// Avoid FIX2INT in this case, because it doesn't deal with type errors properly.
	// Specifically, if the value of port comes in as a string rather than an integer,
	// NUM2INT will throw a type error, but FIX2INT will generate garbage.

	try {
		const uintptr_t f = evma_connect_to_server (NULL, 0, StringValueCStr(server), NUM2INT(port));
		if (!f)
			rb_raise (EM_eConnectionError, "%s", "no connection");
		return BSIG2NUM (f);
	} catch (std::runtime_error e) {
		rb_raise (EM_eConnectionError, "%s", e.what());
	}
	return Qnil;
}

# File 'lib/eventmachine.rb', line 814

def self.connect_unix_domain socketname, *args, &blk
  connect socketname, *args, &blk
end

# File 'ext/rubymain.cpp', line 740

static VALUE t_connect_unix_server (VALUE self UNUSED, VALUE serversocket)
{
	const uintptr_t f = evma_connect_to_unix_server (StringValueCStr(serversocket));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no connection");
	return BSIG2NUM (f);
}

# File 'lib/eventmachine.rb', line 956

def self.connection_count
  self.get_connection_count
end

# File 'ext/rubymain.cpp', line 1346

static VALUE t_get_loop_time (VALUE self UNUSED)
{
	uint64_t current_time = evma_get_current_loop_time();
	if (current_time == 0) {
		return Qnil;
	}

	// Generally the industry has moved to 64-bit time_t, this is just in case we're 32-bit time_t.
	if (sizeof(time_t) < 8 && current_time > INT_MAX) {
		return rb_funcall(rb_cTime, Intern_at, 2, INT2NUM(current_time / 1000000), INT2NUM(current_time % 1000000));
	} else {
		return rb_time_new(current_time / 1000000, current_time % 1000000);
	}
}

# File 'lib/eventmachine.rb', line 1044

def self.defer op = nil, callback = nil, errback = nil, &blk
  # OBSERVE that #next_tick hacks into this mechanism, so don't make any changes here
  # without syncing there.
  #
  # Running with $VERBOSE set to true gives a warning unless all ivars are defined when
  # they appear in rvalues. But we DON'T ever want to initialize @threadqueue unless we
  # need it, because the Ruby threads are so heavyweight. We end up with this bizarre
  # way of initializing @threadqueue because EventMachine is a Module, not a Class, and
  # has no constructor.

  unless @threadpool
    @threadpool = []
    @threadqueue = ::Queue.new
    @resultqueue = ::Queue.new
    spawn_threadpool
  end

  @threadqueue << [op||blk,callback,errback]
end

# File 'lib/eventmachine.rb', line 1441

def self.disable_proxy(from)
  EM::stop_proxy(from.signature)
end

# File 'lib/eventmachine.rb', line 1431

def self.enable_proxy(from, to, bufsize=0, length=0)
  EM::start_proxy(from.signature, to.signature, bufsize, length)
end

# File 'ext/rubymain.cpp', line 1166

static VALUE t__epoll_set (VALUE self, VALUE val)
{
	if (t__epoll_p(self) == Qfalse && val == Qtrue)
		rb_raise (EM_eUnsupported, "%s", "epoll is not supported on this platform");

	evma_set_epoll (val == Qtrue ? 1 : 0);
	return val;
}

# File 'lib/eventmachine.rb', line 1364

def self.error_handler cb = nil, &blk
  if cb or blk
    @error_handler = cb || blk
  elsif instance_variable_defined? :@error_handler
    remove_instance_variable :@error_handler
  end
end

# File 'lib/eventmachine.rb', line 1464

def self.event_callback conn_binding, opcode, data
  #
  # Changed 27Dec07: Eliminated the hookable error handling.
  # No one was using it, and it degraded performance significantly.
  # It's in original_event_callback, which is dead code.
  #
  # Changed 25Jul08: Added a partial solution to the problem of exceptions
  # raised in user-written event-handlers. If such exceptions are not caught,
  # we must cause the reactor to stop, and then re-raise the exception.
  # Otherwise, the reactor doesn't stop and it's left on the call stack.
  # This is partial because we only added it to #unbind, where it's critical
  # (to keep unbind handlers from being re-entered when a stopping reactor
  # runs down open connections). It should go on the other calls to user
  # code, but the performance impact may be too large.
  #
  if opcode == ConnectionUnbound
    if c = @conns.delete( conn_binding )
      begin
        if c.original_method(:unbind).arity != 0
          c.unbind(data == 0 ? nil : EventMachine::ERRNOS[data])
        else
          c.unbind
        end
        # If this is an attached (but not watched) connection, close the underlying io object.
        if c.instance_variable_defined?(:@io) and !c.instance_variable_get(:@watch_mode)
          io = c.instance_variable_get(:@io)
          begin
            io.close
          rescue Errno::EBADF, IOError
          end
        end
      # As noted above, unbind absolutely must not raise an exception or the reactor will crash.
      # If there is no EM.error_handler, or if the error_handler retrows, then stop the reactor,
      # stash the exception in $wrapped_exception, and the exception will be raised after the
      # reactor is cleaned up (see the last line of self.run).
      rescue Exception => error
        if instance_variable_defined? :@error_handler
          begin
            @error_handler.call error
            # No need to stop unless error_handler rethrows
          rescue Exception => error
            @wrapped_exception = error
            stop
          end
        else
          @wrapped_exception = error
          stop
        end
      end
    elsif c = @acceptors.delete( conn_binding )
      # no-op
    else
      if $! # Bubble user generated errors.
        @wrapped_exception = $!
        stop
      else
        raise ConnectionNotBound, "received ConnectionUnbound for an unknown signature: #{conn_binding}"
      end
    end
  elsif opcode == ConnectionAccepted
    accep,args,blk = @acceptors[conn_binding]
    raise NoHandlerForAcceptedConnection unless accep
    c = accep.new data, *args
    @conns[data] = c
    blk and blk.call(c)
    c # (needed?)
    ##
    # The remaining code is a fallback for the pure ruby and java reactors.
    # In the C++ reactor, these events are handled in the C event_callback() in rubymain.cpp
  elsif opcode == ConnectionCompleted
    c = @conns[conn_binding] or raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
    c.connection_completed
  elsif opcode == SslHandshakeCompleted
    c = @conns[conn_binding] or raise ConnectionNotBound, "received SslHandshakeCompleted for unknown signature: #{conn_binding}"
    c.ssl_handshake_completed
  elsif opcode == SslVerify
    c = @conns[conn_binding] or raise ConnectionNotBound, "received SslVerify for unknown signature: #{conn_binding}"
    c.close_connection if c.ssl_verify_peer(data) == false
  elsif opcode == TimerFired
    t = @timers.delete( data )
    return if t == false # timer cancelled
    t or raise UnknownTimerFired, "timer data: #{data}"
    t.call
  elsif opcode == ConnectionData
    c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
    c.receive_data data
  elsif opcode == LoopbreakSignalled
    run_deferred_callbacks
  elsif opcode == ConnectionNotifyReadable
    c = @conns[conn_binding] or raise ConnectionNotBound
    c.notify_readable
  elsif opcode == ConnectionNotifyWritable
    c = @conns[conn_binding] or raise ConnectionNotBound
    c.notify_writable
  end
end

# File 'lib/eventmachine.rb', line 244

def self.fork_reactor &block
  # This implementation is subject to change, especially if we clean up the relationship
  # of EM#run to @reactor_running.
  # Original patch by Aman Gupta.
  #
  Kernel.fork do
    if reactor_running?
      stop_event_loop
      release_machine
      cleanup_machine
      @reactor_running = false
      @reactor_thread = nil
    end
    run block
  end
end

# File 'ext/rubymain.cpp', line 434

static VALUE t_get_cipher_bits (VALUE self UNUSED, VALUE signature UNUSED)
{
	return Qnil;
}

# File 'ext/rubymain.cpp', line 454

static VALUE t_get_cipher_name (VALUE self UNUSED, VALUE signature UNUSED)
{
	return Qnil;
}

# File 'ext/rubymain.cpp', line 474

static VALUE t_get_cipher_protocol (VALUE self UNUSED, VALUE signature UNUSED)
{
	return Qnil;
}

# File 'ext/rubymain.cpp', line 619

static VALUE t_get_comm_inactivity_timeout (VALUE self UNUSED, VALUE signature)
{
	return rb_float_new(evma_get_comm_inactivity_timeout(NUM2BSIG (signature)));
}

# File 'ext/rubymain.cpp', line 610

static VALUE t_get_connection_count (VALUE self UNUSED)
{
	return INT2NUM(evma_get_connection_count());
}

# File 'ext/rubymain.cpp', line 1434

static VALUE t_get_heartbeat_interval (VALUE self UNUSED)
{
	return rb_float_new(evma_get_heartbeat_interval());
}

# File 'ext/rubymain.cpp', line 1409

static VALUE t_get_idle_time (VALUE self UNUSED, VALUE from)
{
	try{
		uint64_t current_time = evma_get_current_loop_time();
		uint64_t time = evma_get_last_activity_time(NUM2BSIG (from));
		if (current_time != 0 && time != 0) {
			if (time >= current_time)
				return BSIG2NUM(0);
			else {
				uint64_t diff = current_time - time;
				float seconds = diff / (1000.0*1000.0);
				return rb_float_new(seconds);
			}
			return Qnil;
		}
	} catch (std::runtime_error e) {
		rb_raise (EM_eConnectionError, "%s", e.what());
	}
	return Qnil;
}

# File 'ext/rubymain.cpp', line 976

static VALUE t_get_max_timer_count (VALUE self UNUSED)
{
	return INT2FIX (evma_get_max_timer_count());
}

# File 'lib/eventmachine.rb', line 925

def self.get_max_timers
  get_max_timer_count
end

# File 'ext/rubymain.cpp', line 415

static VALUE t_get_peer_cert (VALUE self UNUSED, VALUE signature UNUSED)
{
	return Qnil;
}

# File 'ext/rubymain.cpp', line 504

static VALUE t_get_peername (VALUE self UNUSED, VALUE signature)
{
	char buf[1024];
	socklen_t len = sizeof buf;
	try {
		if (evma_get_peername (NUM2BSIG (signature), (struct sockaddr*)buf, &len)) {
			return rb_str_new (buf, len);
		}
	} catch (std::runtime_error e) {
		rb_raise (rb_eRuntimeError, "%s", e.what());
	}

	return Qnil;
}

# File 'ext/rubymain.cpp', line 641

static VALUE t_get_pending_connect_timeout (VALUE self UNUSED, VALUE signature)
{
	return rb_float_new(evma_get_pending_connect_timeout(NUM2BSIG (signature)));
}

# File 'ext/rubymain.cpp', line 995

static VALUE t_get_simultaneous_accept_count (VALUE self UNUSED)
{
	return INT2FIX (evma_get_simultaneous_accept_count());
}

# File 'ext/rubymain.cpp', line 494

static VALUE t_get_sni_hostname (VALUE self UNUSED, VALUE signature UNUSED)
{
	return Qnil;
}

# File 'ext/rubymain.cpp', line 523

static VALUE t_get_sockname (VALUE self UNUSED, VALUE signature)
{
	char buf[1024];
	socklen_t len = sizeof buf;
	try {
		if (evma_get_sockname (NUM2BSIG (signature), (struct sockaddr*)buf, &len)) {
			return rb_str_new (buf, len);
		}
	} catch (std::runtime_error e) {
		rb_raise (rb_eRuntimeError, "%s", e.what());
	}

	return Qnil;
}

# File 'ext/rubymain.cpp', line 542

static VALUE t_get_subprocess_pid (VALUE self UNUSED, VALUE signature)
{
	pid_t pid;
	if (evma_get_subprocess_pid (NUM2BSIG (signature), &pid)) {
		return INT2NUM (pid);
	}

	return Qnil;
}

# File 'ext/rubymain.cpp', line 556

static VALUE t_get_subprocess_status (VALUE self UNUSED, VALUE signature)
{
	VALUE proc_status = Qnil;

	int status;
	pid_t pid;

	if (evma_get_subprocess_status (NUM2BSIG (signature), &status)) {
		if (evma_get_subprocess_pid (NUM2BSIG (signature), &pid)) {

#ifdef IS_RUBY_3_OR_LATER
			struct rb_process_status *data = NULL;

			/* Defined to match static definition from MRI Ruby 3.0 process.c
			 *
			 * Older C++ compilers before GCC 8 don't allow static initialization of a
			 * struct without every field specified, so the definition here is at runtime
			 */
			static rb_data_type_t rb_process_status_type;
			rb_process_status_type.wrap_struct_name = "Process::Status";
			rb_process_status_type.function.dfree = RUBY_DEFAULT_FREE;
			rb_process_status_type.flags = RUBY_TYPED_FREE_IMMEDIATELY;

			proc_status = TypedData_Make_Struct(rb_cProcessStatus, struct rb_process_status, &rb_process_status_type, data);
			data->pid = pid;
			data->status = status;
#else
			proc_status = rb_obj_alloc(rb_cProcessStatus);
			/* MRI Ruby uses hidden instance vars */
			rb_ivar_set(proc_status, rb_intern_const("status"), INT2FIX(status));
			rb_ivar_set(proc_status, rb_intern_const("pid"), INT2FIX(pid));
#endif

#ifdef RUBINIUS
			/* Rubinius uses standard instance vars */
			rb_iv_set(proc_status, "@pid", INT2FIX(pid));
			if (WIFEXITED(status)) {
				rb_iv_set(proc_status, "@status", INT2FIX(WEXITSTATUS(status)));
			} else if (WIFSIGNALED(status)) {
				rb_iv_set(proc_status, "@termsig", INT2FIX(WTERMSIG(status)));
			} else if (WIFSTOPPED(status)) {
				rb_iv_set(proc_status, "@stopsig", INT2FIX(WSTOPSIG(status)));
			}
#endif
		}
	}
	rb_obj_freeze(proc_status);
	return proc_status;
}

# File 'ext/rubymain.cpp', line 282

static VALUE t_get_timer_count ()
{
	return SIZET2NUM (evma_get_timer_count ());
}

# File 'ext/rubymain.cpp', line 247

static VALUE t_initialize_event_machine (VALUE self UNUSED)
{
	EmConnsHash = rb_ivar_get (EmModule, Intern_at_conns);
	EmTimersHash = rb_ivar_get (EmModule, Intern_at_timers);
	assert(EmConnsHash != Qnil);
	assert(EmTimersHash != Qnil);
	evma_initialize_library ((EMCallback)event_callback_wrapper);
	return Qnil;
}

# File 'ext/rubymain.cpp', line 1022

static VALUE t_invoke_popen (VALUE self UNUSED, VALUE cmd)
{
	#ifdef OS_WIN32
	rb_raise (EM_eUnsupported, "popen is not available on this platform");
	#endif

	int len = RARRAY_LEN(cmd);
	if (len >= 2048)
		rb_raise (rb_eRuntimeError, "%s", "too many arguments to popen");
	char *strings [2048];
	for (int i=0; i < len; i++) {
		VALUE ix = INT2FIX (i);
		VALUE s = rb_ary_aref (1, &ix, cmd);
		strings[i] = StringValueCStr (s);
	}
	strings[len] = NULL;

	uintptr_t f = 0;
	try {
		f = evma_popen (strings);
	} catch (std::runtime_error e) {
		rb_raise (rb_eRuntimeError, "%s", e.what());
	}
	if (!f) {
		char *err = strerror (errno);
		char buf[100];
		memset (buf, 0, sizeof(buf));
		snprintf (buf, sizeof(buf)-1, "no popen: %s", (err?err:"???"));
		rb_raise (rb_eRuntimeError, "%s", buf);
	}
	return BSIG2NUM (f);
}

# File 'lib/eventmachine.rb', line 1575

def self.klass_from_handler(klass = Connection, handler = nil, *args)
  klass = if handler and handler.is_a?(Class)
    raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
    handler
  elsif handler
    if defined?(handler::EM_CONNECTION_CLASS)
      handler::EM_CONNECTION_CLASS
    else
      handler::const_set(:EM_CONNECTION_CLASS, Class.new(klass) {include handler})
    end
  else
    klass
  end

  arity = klass.instance_method(:initialize).arity
  expected = arity >= 0 ? arity : -(arity + 1)
  if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
    raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
  end

  klass
end

# File 'ext/rubymain.cpp', line 1206

static VALUE t__kqueue_set (VALUE self, VALUE val)
{
	if (t__kqueue_p(self) == Qfalse && val == Qtrue)
		rb_raise (EM_eUnsupported, "%s", "kqueue is not supported on this platform");

	evma_set_kqueue (val == Qtrue ? 1 : 0);
	return val;
}

# File 'ext/rubymain.cpp', line 955

static VALUE t_library_type (VALUE self UNUSED)
{
	return rb_eval_string (":extension");
}

# File 'lib/eventmachine.rb', line 1122

def self.next_tick pr=nil, &block
  # This works by adding to the @resultqueue that's used for #defer.
  # The general idea is that next_tick is used when we want to give the reactor a chance
  # to let other operations run, either to balance the load out more evenly, or to let
  # outbound network buffers drain, or both. So we probably do NOT want to block, and
  # we probably do NOT want to be spinning any threads. A program that uses next_tick
  # but not #defer shouldn't suffer the penalty of having Ruby threads running. They're
  # extremely expensive even if they're just sleeping.

  raise ArgumentError, "no proc or block given" unless ((pr && pr.respond_to?(:call)) or block)
  @next_tick_mutex.synchronize do
    @next_tick_queue << ( pr || block )
  end
  signal_loopbreak if reactor_running?
end

# File 'lib/eventmachine.rb', line 873

def self.open_datagram_socket address, port, handler=nil, *args
  # Replaced the implementation on 01Oct06. Thanks to Tobias Gustafsson for pointing
  # out that this originally did not take a class but only a module.


  klass = klass_from_handler(Connection, handler, *args)
  s = open_udp_socket address, port.to_i
  c = klass.new s, *args
  @conns[s] = c
  block_given? and yield c
  c
end

# File 'lib/eventmachine.rb', line 1236

def self.open_keyboard handler=nil, *args
  klass = klass_from_handler(Connection, handler, *args)

  s = read_keyboard
  c = klass.new s, *args
  @conns[s] = c
  block_given? and yield c
  c
end

# File 'ext/rubymain.cpp', line 910

static VALUE t_open_udp_socket (VALUE self UNUSED, VALUE server, VALUE port)
{
	const uintptr_t f = evma_open_datagram_socket (StringValueCStr(server), FIX2INT(port));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no datagram socket");
	return BSIG2NUM(f);
}

# File 'lib/eventmachine.rb', line 1199

def self.popen cmd, handler=nil, *args
  # At this moment, it's only available on Unix.
  # Perhaps misnamed since the underlying function uses socketpair and is full-duplex.

  klass = klass_from_handler(Connection, handler, *args)
  w = case cmd
      when Array
        cmd
      when String
        Shellwords::shellwords( cmd )
      end
  w.unshift( w.first ) if w.first
  s = invoke_popen( w )
  c = klass.new s, *args
  @conns[s] = c
  yield(c) if block_given?
  c
end

# File 'ext/rubymain.cpp', line 1060

static VALUE t_read_keyboard (VALUE self UNUSED)
{
	const uintptr_t f = evma_open_keyboard();
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no keyboard reader");
	return BSIG2NUM (f);
}

# File 'lib/eventmachine.rb', line 782

def self.reconnect server, port, handler
  # Observe, the test for already-connected FAILS if we call a reconnect inside post_init,
  # because we haven't set up the connection in @conns by that point.
  # RESIST THE TEMPTATION to "fix" this problem by redefining the behavior of post_init.
  #
  # Changed 22Nov06: if called on an already-connected handler, just return the
  # handler and do nothing more. Originally this condition raised an exception.
  # We may want to change it yet again and call the block, if any.

  raise "invalid handler" unless handler.respond_to?(:connection_completed)
  #raise "still connected" if @conns.has_key?(handler.signature)
  return handler if @conns.has_key?(handler.signature)

  s = if port
        connect_server server, port
      else
        connect_unix_server server
      end
  handler.signature = s
  @conns[s] = handler
  block_given? and yield handler
  handler
end

# File 'ext/rubymain.cpp', line 924

static VALUE t_release_machine (VALUE self UNUSED)
{
	evma_release_library();
	return Qnil;
}

# File 'ext/rubymain.cpp', line 686

static VALUE t_report_connection_error_status (VALUE self UNUSED, VALUE signature)
{
	int b = evma_report_connection_error_status (NUM2BSIG (signature));
	return INT2NUM (b);
}

# File 'lib/eventmachine.rb', line 150

def self.run blk=nil, tail=nil, &block
  # Obsoleted the use_threads mechanism.
  # 25Nov06: Added the begin/ensure block. We need to be sure that release_machine
  # gets called even if an exception gets thrown within any of the user code
  # that the event loop runs. The best way to see this is to run a unit
  # test with two functions, each of which calls {EventMachine.run} and each of
  # which throws something inside of #run. Without the ensure, the second test
  # will start without release_machine being called and will immediately throw

  #
  if @reactor_running and @reactor_pid != Process.pid
    # Reactor was started in a different parent, meaning we have forked.
    # Clean up reactor state so a new reactor boots up in this child.
    stop_event_loop
    release_machine
    cleanup_machine
    @reactor_running = false
  end

  tail and @tails.unshift(tail)

  if reactor_running?
    (b = blk || block) and b.call # next_tick(b)
  else
    @conns = {}
    @acceptors = {}
    @timers = {}
    @wrapped_exception = nil
    @next_tick_queue ||= []
    @tails ||= []
    begin
      initialize_event_machine
      @reactor_pid = Process.pid
      @reactor_thread = Thread.current
      @reactor_running = true

      (b = blk || block) and add_timer(0, b)
      if @next_tick_queue && !@next_tick_queue.empty?
        add_timer(0) { signal_loopbreak }
      end

      # Rubinius needs to come back into "Ruby space" for GC to work,
      # so we'll crank the machine here.
      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
        while run_machine_once; end
      else
        run_machine
      end

    ensure
      until @tails.empty?
        @tails.pop.call
      end

      release_machine
      cleanup_machine
      @reactor_running = false
      @reactor_thread = nil
    end

    raise @wrapped_exception if @wrapped_exception
  end
end

# File 'lib/eventmachine.rb', line 219

def self.run_block &block
  pr = proc {
    block.call
    EventMachine::stop
  }
  run(&pr)
end

# File 'lib/eventmachine.rb', line 968

def self.run_deferred_callbacks
  until (@resultqueue ||= []).empty?
    result,cback = @resultqueue.pop
    cback.call result if cback
  end

  # Capture the size at the start of this tick...
  size = @next_tick_mutex.synchronize { @next_tick_queue.size }
  size.times do |i|
    callback = @next_tick_mutex.synchronize { @next_tick_queue.shift }
    begin
      callback.call
    rescue
      exception_raised = true
      raise
    ensure
      # This is a little nasty. The problem is, if an exception occurs during
      # the callback, then we need to send a signal to the reactor to actually
      # do some work during the next_tick. The only mechanism we have from the
      # ruby side is next_tick itself, although ideally, we'd just drop a byte
      # on the loopback descriptor.
      next_tick {} if exception_raised
    end
  end
end

# File 'ext/rubymain.cpp', line 272

static VALUE t_run_machine (VALUE self UNUSED)
{
	evma_run_machine();
	return Qnil;
}

# File 'ext/rubymain.cpp', line 262

static VALUE t_run_machine_once (VALUE self UNUSED)
{
	return evma_run_machine_once () ? Qtrue : Qfalse;
}

# File 'lib/eventmachine.rb', line 234

def self.schedule(*a, &b)
  cb = Callback(*a, &b)
  if reactor_running? && reactor_thread?
    cb.call
  else
    next_tick { cb.call }
  end
end

# File 'ext/rubymain.cpp', line 352

static VALUE t_send_data (VALUE self UNUSED, VALUE signature, VALUE data, VALUE data_length)
{
	int b = evma_send_data_to_connection (NUM2BSIG (signature), StringValuePtr (data), FIX2INT (data_length));
	return INT2NUM (b);
}

# File 'ext/rubymain.cpp', line 663

static VALUE t_send_datagram (VALUE self UNUSED, VALUE signature, VALUE data, VALUE data_length, VALUE address, VALUE port)
{
	int b = evma_send_datagram (NUM2BSIG (signature), StringValuePtr (data), FIX2INT (data_length), StringValueCStr(address), FIX2INT(port));
	if (b < 0)
		rb_raise (EM_eConnectionError, "%s", "error in sending datagram"); // FIXME: this could be more specific.
	return INT2NUM (b);
}

# File 'ext/rubymain.cpp', line 1247

static VALUE t_send_file_data (VALUE self UNUSED, VALUE signature, VALUE filename)
{

	/* The current implementation of evma_send_file_data_to_connection enforces a strict
	 * upper limit on the file size it will transmit (currently 32K). The function returns
	 * zero on success, -1 if the requested file exceeds its size limit, and a positive
	 * number for other errors.
	 * TODO: Positive return values are actually errno's, which is probably the wrong way to
	 * do this. For one thing it's ugly. For another, we can't be sure zero is never a real errno.
	 */

	int b = evma_send_file_data_to_connection (NUM2BSIG (signature), StringValueCStr(filename));
	if (b == -1)
		rb_raise(rb_eRuntimeError, "%s", "File too large.  send_file_data() supports files under 32k.");
	if (b > 0) {
		char *err = strerror (b);
		char buf[1024];
		memset (buf, 0, sizeof(buf));
		snprintf (buf, sizeof(buf)-1, ": %s %s", StringValueCStr(filename),(err?err:"???"));

		rb_raise (rb_eIOError, "%s", buf);
	}

	return INT2NUM (0);
}

# File 'ext/rubymain.cpp', line 628

static VALUE t_set_comm_inactivity_timeout (VALUE self UNUSED, VALUE signature, VALUE timeout)
{
	float ti = RFLOAT_VALUE(timeout);
	if (evma_set_comm_inactivity_timeout(NUM2BSIG(signature), ti)) {
		return Qtrue;
	}
	return Qfalse;
}

# File 'lib/eventmachine.rb', line 1169

def self.set_descriptor_table_size n_descriptors=nil
  EventMachine::set_rlimit_nofile n_descriptors
end

# File 'lib/eventmachine.rb', line 1150

def self.set_effective_user username
  EventMachine::setuid_string username
end

# File 'ext/rubymain.cpp', line 1444

static VALUE t_set_heartbeat_interval (VALUE self UNUSED, VALUE interval)
{
	float iv = RFLOAT_VALUE(interval);
	if (evma_set_heartbeat_interval(iv))
		return Qtrue;
	return Qfalse;
}

# File 'ext/rubymain.cpp', line 985

static VALUE t_set_max_timer_count (VALUE self UNUSED, VALUE ct)
{
	evma_set_max_timer_count (FIX2INT (ct));
	return Qnil;
}

# File 'lib/eventmachine.rb', line 918

def self.set_max_timers ct
  set_max_timer_count ct
end

# File 'ext/rubymain.cpp', line 650

static VALUE t_set_pending_connect_timeout (VALUE self UNUSED, VALUE signature, VALUE timeout)
{
	float ti = RFLOAT_VALUE(timeout);
	if (evma_set_pending_connect_timeout(NUM2BSIG(signature), ti)) {
		return Qtrue;
	}
	return Qfalse;
}

# File 'lib/eventmachine.rb', line 903

def self.set_quantum mills
  set_timer_quantum mills.to_i
end

# File 'ext/rubymain.cpp', line 1278

static VALUE t_set_rlimit_nofile (VALUE self UNUSED, VALUE arg)
{
	int arg_int = (NIL_P(arg)) ? -1 : NUM2INT (arg);
	return INT2NUM (evma_set_rlimit_nofile (arg_int));
}

# File 'ext/rubymain.cpp', line 1000

static VALUE t_set_simultaneous_accept_count (VALUE self UNUSED, VALUE ct)
{
	evma_set_simultaneous_accept_count (FIX2INT (ct));
	return Qnil;
}

# File 'ext/rubymain.cpp', line 966

static VALUE t_set_timer_quantum (VALUE self UNUSED, VALUE interval)
{
	evma_set_timer_quantum (FIX2INT (interval));
	return Qnil;
}

# File 'ext/rubymain.cpp', line 377

static VALUE t_set_tls_parms (VALUE self UNUSED, VALUE signature, VALUE privkeyfile, VALUE privkey, VALUE privkeypass, VALUE certchainfile, VALUE cert, VALUE verify_peer, VALUE fail_if_no_peer_cert, VALUE snihostname, VALUE cipherlist, VALUE ecdh_curve, VALUE dhparam, VALUE ssl_version)
{
	/* set_tls_parms 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 NULL strings.
	 */
	evma_set_tls_parms (NUM2BSIG (signature), StringValueCStr (privkeyfile), StringValueCStr (privkey), StringValueCStr (privkeypass), StringValueCStr (certchainfile), StringValueCStr (cert), (verify_peer == Qtrue ? 1 : 0), (fail_if_no_peer_cert == Qtrue ? 1 : 0), StringValueCStr (snihostname), StringValueCStr (cipherlist), StringValueCStr (ecdh_curve), StringValueCStr (dhparam), NUM2INT (ssl_version));
	return Qnil;
}

# File 'ext/rubymain.cpp', line 1010

static VALUE t_setuid_string (VALUE self UNUSED, VALUE username)
{
	evma_setuid_string (StringValueCStr (username));
	return Qnil;
}

# File 'ext/rubymain.cpp', line 945

static VALUE t_signal_loopbreak (VALUE self UNUSED)
{
	evma_signal_loopbreak();
	return Qnil;
}

# File 'lib/em/spawnable.rb', line 69

def self.spawn &block
  s = SpawnedProcess.new
  s.set_receiver block
  s
end

# File 'lib/eventmachine.rb', line 1066

def self.spawn_threadpool
  until @threadpool.size == @threadpool_size.to_i
    thread = Thread.new do
      Thread.current.abort_on_exception = true
      while true
        begin
          op, cback, eback = *@threadqueue.pop
        rescue ThreadError
          $stderr.puts $!.message
          break # Ruby 2.0 may fail at Queue.pop
        end
        begin
          result = op.call
          @resultqueue << [result, cback]
        rescue Exception => error
          raise error unless eback
          @resultqueue << [error, eback]
        end
        signal_loopbreak
      end
    end
    @threadpool << thread
  end
  @all_threads_spawned = true
end

# File 'lib/eventmachine.rb', line 518

def self.start_server server, port=nil, handler=nil, *args, &block
  begin
    port = Integer(port)
  rescue ArgumentError, TypeError
    # there was no port, so server must be a unix domain socket
    # the port argument is actually the handler, and the handler is one of the args
    args.unshift handler if handler
    handler = port
    port = nil
  end if port

  klass = klass_from_handler(Connection, handler, *args)

  s = if port
        start_tcp_server server, port
      else
        start_unix_server server
      end
  @acceptors[s] = [klass,args,block]
  s
end

# File 'ext/rubymain.cpp', line 304

static VALUE t_start_server (VALUE self UNUSED, VALUE server, VALUE port)
{
	const uintptr_t f = evma_create_tcp_server (StringValueCStr(server), FIX2INT(port));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no acceptor (port is in use or requires root privileges)");
	return BSIG2NUM (f);
}

# File 'ext/rubymain.cpp', line 363

static VALUE t_start_tls (VALUE self UNUSED, VALUE signature)
{
	try {
		evma_start_tls (NUM2BSIG (signature));
	} catch (const std::runtime_error& e) {
		rb_raise (EM_eInvalidPrivateKey, e.what(), signature);
	}
	return Qnil;
}

# File 'lib/eventmachine.rb', line 562

def self.start_unix_domain_server filename, *args, &block
  start_server filename, *args, &block
end

# File 'ext/rubymain.cpp', line 327

static VALUE t_start_unix_server (VALUE self UNUSED, VALUE filename)
{
	const uintptr_t f = evma_create_unix_domain_server (StringValueCStr(filename));
	if (!f)
		rb_raise (rb_eRuntimeError, "%s", "no unix-domain acceptor");
	return BSIG2NUM (f);
}

# File 'ext/rubymain.cpp', line 935

static VALUE t_stop (VALUE self UNUSED)
{
	evma_stop_machine();
	return Qnil;
}

# File 'lib/eventmachine.rb', line 418

def self.stop_event_loop
  EventMachine::stop
end

# File 'lib/eventmachine.rb', line 552

def self.stop_server signature
  EventMachine::stop_tcp_server signature
end

# File 'ext/rubymain.cpp', line 316

static VALUE t_stop_server (VALUE self UNUSED, VALUE signature)
{
	evma_stop_tcp_server (NUM2BSIG (signature));
	return Qnil;
}

# File 'lib/em/processes.rb', line 112

def EventMachine::system cmd, *args, &cb
  cb ||= args.pop if args.last.is_a? Proc
  init = args.pop if args.last.is_a? Proc

  # merge remaining arguments into the command
  cmd = [cmd, *args] if args.any?

  EM.get_subprocess_pid(EM.popen(cmd, SystemCmd, cb) do |c|
    init[c] if init
  end.signature)
end

# File 'lib/em/tick_loop.rb', line 3

def self.tick_loop(*a, &b)
  TickLoop.new(*a, &b).start
end

# File 'lib/eventmachine.rb', line 732

def EventMachine::watch io, handler=nil, *args, &blk
  attach_io io, true, handler, *args, &blk
end

# File 'lib/eventmachine.rb', line 1310

def self.watch_file(filename, handler=nil, *args)
  klass = klass_from_handler(FileWatch, handler, *args)

  s = EM::watch_filename(filename)
  c = klass.new s, *args
  # we have to set the path like this because of how Connection.new works
  c.instance_variable_set("@path", filename)
  @conns[s] = c
  block_given? and yield c
  c
end

# File 'lib/eventmachine.rb', line 1341

def self.watch_process(pid, handler=nil, *args)
  pid = pid.to_i

  klass = klass_from_handler(ProcessWatch, handler, *args)

  s = EM::watch_pid(pid)
  c = klass.new s, *args
  # we have to set the path like this because of how Connection.new works
  c.instance_variable_set("@pid", pid)
  @conns[s] = c
  block_given? and yield c
  c
end

# File 'lib/em/spawnable.rb', line 76

def self.yield &block
  return YieldBlockFromSpawnedProcess.new( block, false )
end

# File 'lib/em/spawnable.rb', line 81

def self.yield_and_notify &block
  return YieldBlockFromSpawnedProcess.new( block, true )
end