eventmachine 1.0.0.beta.2-x86-mingw32

data/docs/TODO

@@ -0,0 +1,8 @@
+TODO List:
+
+12Aug06: Noticed by Don Stocks. A TCP connect-request that results
+in a failed DNS resolution fires a fatal error back to user code.
+Uuuuuugly. We should probably cause an unbind event to get fired
+instead, and add some parameterization so the caller can detect
+the nature of the failure.
+

data/eventmachine.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.date = "2010-11-13"
+
+  s.name = 'eventmachine'
+  s.version = EventMachine::VERSION
+  s.homepage = 'http://rubyeventmachine.com'
+  s.rubyforge_project = 'eventmachine'
+
+  s.authors = ["Francis Cianfrocca", "Aman Gupta"]
+  s.email   = ["garbagecat10@gmail.com", "aman@tmm1.net"]
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
+
+  s.add_development_dependency 'rake-compiler'
+
+  s.summary = 'Ruby/EventMachine library'
+  s.description = "EventMachine implements a fast, single-threaded engine for arbitrary network
+communications. It's extremely easy to use in Ruby. EventMachine wraps all
+interactions with IP sockets, allowing programs to concentrate on the
+implementation of network protocols. It can be used to create both network
+servers and clients. To create a server or client, a Ruby program only needs
+to specify the IP address and port, and provide a Module that implements the
+communications protocol. Implementations of several standard network protocols
+are provided with the package, primarily to serve as examples. The real goal
+of EventMachine is to enable programs to easily interface with other programs
+using TCP/IP, especially if custom protocols are required."
+
+  s.rdoc_options = ["--title", "EventMachine", "--main", "README", "-x", "lib/em/version", "-x", "lib/jeventmachine"]
+end

data/examples/ex_channel.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/helper'
+
+EM.run do
+
+  # Create a channel to push data to, this could be stocks...
+  RandChannel = EM::Channel.new
+
+  # The server simply subscribes client connections to the channel on connect,
+  # and unsubscribes them on disconnect.
+  class Server < EM::Connection
+    def self.start(host = '127.0.0.1', port = 8000)
+      EM.start_server(host, port, self)
+    end
+
+    def post_init
+      @sid = RandChannel.subscribe { |m| send_data "#{m.inspect}\n" }
+    end
+
+    def unbind
+      RandChannel.unsubscribe @sid
+    end
+  end
+  Server.start
+
+  # Two client connections, that just print what they receive.
+  2.times do
+    EM.connect('127.0.0.1', 8000) do |c|
+      c.extend EM::P::LineText2
+      def c.receive_line(line)
+        puts "Subscriber: #{signature} got #{line}"
+      end
+      EM.add_timer(2) { c.close_connection }
+    end
+  end
+
+  # This part of the example is more fake, but imagine sleep was in fact a 
+  # long running calculation to achieve the value.
+  40.times do
+    EM.defer lambda { v = sleep(rand * 2); RandChannel << [Time.now, v] }
+  end
+  
+  EM.add_timer(5) { EM.stop }
+end

data/examples/ex_queue.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/helper'
+

data/examples/ex_tick_loop_array.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/helper'
+
+EM.run do
+  array = (1..100).to_a
+
+  tickloop = EM.tick_loop do
+    if array.empty?
+      :stop
+    else
+      puts array.shift
+    end
+  end
+
+  tickloop.on_stop { EM.stop }
+end

data/examples/ex_tick_loop_counter.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TickCounter
+  attr_reader :start_time, :count
+
+  def initialize
+    reset
+    @tick_loop = EM.tick_loop(method(:tick))
+  end
+
+  def reset
+    @count = 0
+    @start_time = EM.current_time
+  end
+
+  def tick
+    @count += 1
+  end
+
+  def rate
+    @count / (EM.current_time - @start_time)
+  end
+end
+
+period = 5
+EM.run do
+  counter = TickCounter.new
+  EM.add_periodic_timer(period) do
+    puts "Ticks per second: #{counter.rate} (mean of last #{period}s)"
+    counter.reset
+  end
+end

data/examples/helper.rb

@@ -0,0 +1,2 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'eventmachine'

data/ext/binder.cpp

@@ -0,0 +1,124 @@
+/*****************************************************************************
+
+$Id$
+
+File:     binder.cpp
+Date:     07Apr06
+
+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.
+
+*****************************************************************************/
+
+#include "project.h"
+
+#define DEV_URANDOM "/dev/urandom"
+
+
+map<unsigned long, Bindable_t*> Bindable_t::BindingBag;
+
+
+/********************************
+STATIC Bindable_t::CreateBinding
+********************************/
+
+unsigned long Bindable_t::CreateBinding()
+{
+	static unsigned long num = 0;
+	while(BindingBag[++num]);
+	return num;
+}
+
+#if 0
+string Bindable_t::CreateBinding()
+{
+	static int index = 0;
+	static string seed;
+
+	if ((index >= 1000000) || (seed.length() == 0)) {
+		#ifdef OS_UNIX
+		int fd = open (DEV_URANDOM, O_RDONLY);
+		if (fd < 0)
+			throw std::runtime_error ("No entropy device");
+
+		unsigned char u[16];
+		size_t r = read (fd, u, sizeof(u));
+		if (r < sizeof(u))
+			throw std::runtime_error ("Unable to read entropy device");
+
+		unsigned char *u1 = (unsigned char*)u;
+		char u2 [sizeof(u) * 2 + 1];
+
+		for (size_t i=0; i < sizeof(u); i++)
+			sprintf (u2 + (i * 2), "%02x", u1[i]);
+
+		seed = string (u2);
+		#endif
+
+
+		#ifdef OS_WIN32
+		UUID uuid;
+		UuidCreate (&uuid);
+		unsigned char *uuidstring = NULL;
+		UuidToString (&uuid, &uuidstring);
+		if (!uuidstring)
+			throw std::runtime_error ("Unable to read uuid");
+		seed = string ((const char*)uuidstring);
+
+		RpcStringFree (&uuidstring);
+		#endif
+
+		index = 0;
+
+
+	}
+
+	stringstream ss;
+	ss << seed << (++index);
+	return ss.str();
+}
+#endif
+
+/*****************************
+STATIC: Bindable_t::GetObject
+*****************************/
+
+Bindable_t *Bindable_t::GetObject (const unsigned long binding)
+{
+  map<unsigned long, Bindable_t*>::const_iterator i = BindingBag.find (binding);
+  if (i != BindingBag.end())
+    return i->second;
+  else
+    return NULL;
+}
+
+
+/**********************
+Bindable_t::Bindable_t
+**********************/
+
+Bindable_t::Bindable_t()
+{
+	Binding = Bindable_t::CreateBinding();
+	BindingBag [Binding] = this;
+}
+
+
+
+/***********************
+Bindable_t::~Bindable_t
+***********************/
+
+Bindable_t::~Bindable_t()
+{
+	BindingBag.erase (Binding);
+}
+
+

data/ext/binder.h

@@ -0,0 +1,46 @@
+/*****************************************************************************
+
+$Id$
+
+File:     binder.h
+Date:     07Apr06
+
+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.
+
+*****************************************************************************/
+
+#ifndef __ObjectBindings__H_
+#define __ObjectBindings__H_
+
+
+class Bindable_t
+{
+	public:
+		static unsigned long CreateBinding();
+		static Bindable_t *GetObject (const unsigned long);
+		static map<unsigned long, Bindable_t*> BindingBag;
+
+	public:
+		Bindable_t();
+		virtual ~Bindable_t();
+
+		const unsigned long GetBinding() {return Binding;}
+
+	private:
+		unsigned long Binding;
+};
+
+
+
+
+
+#endif // __ObjectBindings__H_
+

data/ext/cmain.cpp

@@ -0,0 +1,838 @@
+/*****************************************************************************
+
+$Id$
+
+File:			cmain.cpp
+Date:			06Apr06
+
+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.
+
+*****************************************************************************/
+
+#include "project.h"
+
+/* 21Sep09: ruby 1.9 defines macros for common i/o functions that point to rb_w32_* implementations.
+   We need to undef the stat to fix a build failure in evma_send_file_data_to_connection.
+   See http://groups.google.com/group/eventmachine/browse_thread/thread/fc60d9bb738ffc71
+*/
+#if defined(BUILD_FOR_RUBY) && defined(OS_WIN32)
+#undef stat
+#undef fstat
+#endif
+
+static EventMachine_t *EventMachine;
+static int bUseEpoll = 0;
+static int bUseKqueue = 0;
+
+extern "C" void ensure_eventmachine (const char *caller = "unknown caller")
+{
+	if (!EventMachine) {
+		const int err_size = 128;
+		char err_string[err_size];
+		snprintf (err_string, err_size, "eventmachine not initialized: %s", caller);
+		#ifdef BUILD_FOR_RUBY
+			rb_raise(rb_eRuntimeError, "%s", err_string);
+		#else
+			throw std::runtime_error (err_string);
+		#endif
+	}
+}
+
+/***********************
+evma_initialize_library
+***********************/
+
+extern "C" void evma_initialize_library (EMCallback cb)
+{
+	if (EventMachine)
+		#ifdef BUILD_FOR_RUBY
+			rb_raise(rb_eRuntimeError, "eventmachine already initialized: evma_initialize_library");
+		#else
+			throw std::runtime_error ("eventmachine already initialized: evma_initialize_library");
+		#endif
+	EventMachine = new EventMachine_t (cb);
+	if (bUseEpoll)
+		EventMachine->_UseEpoll();
+	if (bUseKqueue)
+		EventMachine->_UseKqueue();
+}
+
+
+/********************
+evma_release_library
+********************/
+
+extern "C" void evma_release_library()
+{
+	ensure_eventmachine("evma_release_library");
+	delete EventMachine;
+	EventMachine = NULL;
+}
+
+
+/****************
+evma_run_machine
+****************/
+
+extern "C" void evma_run_machine()
+{
+	ensure_eventmachine("evma_run_machine");
+	EventMachine->Run();
+}
+
+
+/**************************
+evma_install_oneshot_timer
+**************************/
+
+extern "C" const unsigned long evma_install_oneshot_timer (int seconds)
+{
+	ensure_eventmachine("evma_install_oneshot_timer");
+	return EventMachine->InstallOneshotTimer (seconds);
+}
+
+
+/**********************
+evma_connect_to_server
+**********************/
+
+extern "C" const unsigned long evma_connect_to_server (const char *bind_addr, int bind_port, const char *server, int port)
+{
+	ensure_eventmachine("evma_connect_to_server");
+	return EventMachine->ConnectToServer (bind_addr, bind_port, server, port);
+}
+
+/***************************
+evma_connect_to_unix_server
+***************************/
+
+extern "C" const unsigned long evma_connect_to_unix_server (const char *server)
+{
+	ensure_eventmachine("evma_connect_to_unix_server");
+	return EventMachine->ConnectToUnixServer (server);
+}
+
+/**************
+evma_attach_fd
+**************/
+
+extern "C" const unsigned long evma_attach_fd (int file_descriptor, int watch_mode)
+{
+	ensure_eventmachine("evma_attach_fd");
+	return EventMachine->AttachFD (file_descriptor, watch_mode ? true : false);
+}
+
+/**************
+evma_detach_fd
+**************/
+
+extern "C" int evma_detach_fd (const unsigned long binding)
+{
+	ensure_eventmachine("evma_detach_fd");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return EventMachine->DetachFD (ed);
+	else
+		#ifdef BUILD_FOR_RUBY
+			rb_raise(rb_eRuntimeError, "invalid binding to detach");
+		#else
+			throw std::runtime_error ("invalid binding to detach");
+		#endif
+			return -1;
+}
+
+/************************
+evma_get_file_descriptor
+************************/
+
+extern "C" int evma_get_file_descriptor (const unsigned long binding)
+{
+	ensure_eventmachine("evma_get_file_descriptor");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->GetSocket();
+	else
+		#ifdef BUILD_FOR_RUBY
+			rb_raise(rb_eRuntimeError, "invalid binding to get_fd");
+		#else
+			throw std::runtime_error ("invalid binding to get_fd");
+		#endif
+			return -1;
+}
+
+/***********************
+evma_is_notify_readable
+***********************/
+
+extern "C" int evma_is_notify_readable (const unsigned long binding)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->IsNotifyReadable() ? 1 : 0;
+	return -1;
+}
+
+/************************
+evma_set_notify_readable
+************************/
+
+extern "C" void evma_set_notify_readable (const unsigned long binding, int mode)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		cd->SetNotifyReadable (mode ? true : false);
+}
+
+/***********************
+evma_is_notify_writable
+***********************/
+
+extern "C" int evma_is_notify_writable (const unsigned long binding)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->IsNotifyWritable() ? 1 : 0;
+	return -1;
+}
+
+/************************
+evma_set_notify_writable
+************************/
+
+extern "C" void evma_set_notify_writable (const unsigned long binding, int mode)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		cd->SetNotifyWritable (mode ? true : false);
+}
+
+/**********
+evma_pause
+**********/
+
+extern "C" int evma_pause (const unsigned long binding)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->Pause() ? 1 : 0;
+
+	return 0;
+}
+
+/***********
+evma_resume
+***********/
+
+extern "C" int evma_resume (const unsigned long binding)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->Resume() ? 1 : 0;
+
+	return 0;
+}
+
+/**************
+evma_is_paused
+**************/
+
+extern "C" int evma_is_paused (const unsigned long binding)
+{
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->IsPaused() ? 1 : 0;
+
+	return 0;
+}
+
+/**********************
+evma_create_tcp_server
+**********************/
+
+extern "C" const unsigned long evma_create_tcp_server (const char *address, int port)
+{
+	ensure_eventmachine("evma_create_tcp_server");
+	return EventMachine->CreateTcpServer (address, port);
+}
+
+/******************************
+evma_create_unix_domain_server
+******************************/
+
+extern "C" const unsigned long evma_create_unix_domain_server (const char *filename)
+{
+	ensure_eventmachine("evma_create_unix_domain_server");
+	return EventMachine->CreateUnixDomainServer (filename);
+}
+
+/*************************
+evma_open_datagram_socket
+*************************/
+
+extern "C" const unsigned long evma_open_datagram_socket (const char *address, int port)
+{
+	ensure_eventmachine("evma_open_datagram_socket");
+	return EventMachine->OpenDatagramSocket (address, port);
+}
+
+/******************
+evma_open_keyboard
+******************/
+
+extern "C" const unsigned long evma_open_keyboard()
+{
+	ensure_eventmachine("evma_open_keyboard");
+	return EventMachine->OpenKeyboard();
+}
+
+/*******************
+evma_watch_filename
+*******************/
+
+extern "C" const unsigned long evma_watch_filename (const char *fname)
+{
+	ensure_eventmachine("evma_watch_filename");
+	return EventMachine->WatchFile(fname);
+}
+
+/*********************
+evma_unwatch_filename
+*********************/
+
+extern "C" void evma_unwatch_filename (const unsigned long sig)
+{
+	ensure_eventmachine("evma_unwatch_file");
+	EventMachine->UnwatchFile(sig);
+}
+
+/**************
+evma_watch_pid
+**************/
+
+extern "C" const unsigned long evma_watch_pid (int pid)
+{
+	ensure_eventmachine("evma_watch_pid");
+	return EventMachine->WatchPid(pid);
+}
+
+/****************
+evma_unwatch_pid
+****************/
+
+extern "C" void evma_unwatch_pid (const unsigned long sig)
+{
+	ensure_eventmachine("evma_unwatch_pid");
+	EventMachine->UnwatchPid(sig);
+}
+
+/****************************
+evma_send_data_to_connection
+****************************/
+
+extern "C" int evma_send_data_to_connection (const unsigned long binding, const char *data, int data_length)
+{
+	ensure_eventmachine("evma_send_data_to_connection");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->SendOutboundData(data, data_length);
+	return -1;
+}
+
+/******************
+evma_send_datagram
+******************/
+
+extern "C" int evma_send_datagram (const unsigned long binding, const char *data, int data_length, const char *address, int port)
+{
+	ensure_eventmachine("evma_send_datagram");
+	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
+	if (dd)
+		return dd->SendOutboundDatagram(data, data_length, address, port);
+	return -1;
+}
+
+
+/*********************
+evma_close_connection
+*********************/
+
+extern "C" void evma_close_connection (const unsigned long binding, int after_writing)
+{
+	ensure_eventmachine("evma_close_connection");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->ScheduleClose (after_writing ? true : false);
+}
+
+/***********************************
+evma_report_connection_error_status
+***********************************/
+
+extern "C" int evma_report_connection_error_status (const unsigned long binding)
+{
+	ensure_eventmachine("evma_report_connection_error_status");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->ReportErrorStatus();
+	return -1;
+}
+
+/********************
+evma_stop_tcp_server
+********************/
+
+extern "C" void evma_stop_tcp_server (const unsigned long binding)
+{
+	ensure_eventmachine("evma_stop_tcp_server");
+	AcceptorDescriptor::StopAcceptor (binding);
+}
+
+
+/*****************
+evma_stop_machine
+*****************/
+
+extern "C" void evma_stop_machine()
+{
+	ensure_eventmachine("evma_stop_machine");
+	EventMachine->ScheduleHalt();
+}
+
+
+/**************
+evma_start_tls
+**************/
+
+extern "C" void evma_start_tls (const unsigned long binding)
+{
+	ensure_eventmachine("evma_start_tls");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->StartTls();
+}
+
+/******************
+evma_set_tls_parms
+******************/
+
+extern "C" void evma_set_tls_parms (const unsigned long binding, const char *privatekey_filename, const char *certchain_filename, int verify_peer)
+{
+	ensure_eventmachine("evma_set_tls_parms");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->SetTlsParms (privatekey_filename, certchain_filename, (verify_peer == 1 ? true : false));
+}
+
+/******************
+evma_get_peer_cert
+******************/
+
+#ifdef WITH_SSL
+extern "C" X509 *evma_get_peer_cert (const unsigned long binding)
+{
+	ensure_eventmachine("evma_get_peer_cert");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->GetPeerCert();
+	return NULL;
+}
+#endif
+
+/********************
+evma_accept_ssl_peer
+********************/
+
+#ifdef WITH_SSL
+extern "C" void evma_accept_ssl_peer (const unsigned long binding)
+{
+	ensure_eventmachine("evma_accept_ssl_peer");
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		cd->AcceptSslPeer();
+}
+#endif
+
+/*****************
+evma_get_peername
+*****************/
+
+extern "C" int evma_get_peername (const unsigned long binding, struct sockaddr *sa)
+{
+	ensure_eventmachine("evma_get_peername");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetPeername (sa) ? 1 : 0;
+	}
+	else
+		return 0;
+}
+
+/*****************
+evma_get_sockname
+*****************/
+
+extern "C" int evma_get_sockname (const unsigned long binding, struct sockaddr *sa)
+{
+	ensure_eventmachine("evma_get_sockname");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetSockname (sa) ? 1 : 0;
+	}
+	else
+		return 0;
+}
+
+/***********************
+evma_get_subprocess_pid
+***********************/
+
+extern "C" int evma_get_subprocess_pid (const unsigned long binding, pid_t *pid)
+{
+	ensure_eventmachine("evma_get_subprocess_pid");
+	#ifdef OS_UNIX
+	PipeDescriptor *pd = dynamic_cast <PipeDescriptor*> (Bindable_t::GetObject (binding));
+	if (pd) {
+		return pd->GetSubprocessPid (pid) ? 1 : 0;
+	}
+	else if (pid && EventMachine->SubprocessPid) {
+		*pid = EventMachine->SubprocessPid;
+		return 1;
+	}
+	else
+		return 0;
+	#else
+	return 0;
+	#endif
+}
+
+/**************************
+evma_get_subprocess_status
+**************************/
+
+extern "C" int evma_get_subprocess_status (const unsigned long binding, int *status)
+{
+	ensure_eventmachine("evma_get_subprocess_status");
+	if (status) {
+		*status = EventMachine->SubprocessExitStatus;
+		return 1;
+	}
+	else
+		return 0;
+}
+
+/*************************
+evma_get_connection_count
+*************************/
+
+extern "C" int evma_get_connection_count()
+{
+	ensure_eventmachine("evma_get_connection_count");
+	return EventMachine->GetConnectionCount();
+}
+
+/*********************
+evma_signal_loopbreak
+*********************/
+
+extern "C" void evma_signal_loopbreak()
+{
+	ensure_eventmachine("evma_signal_loopbreak");
+	EventMachine->SignalLoopBreaker();
+}
+
+
+
+/********************************
+evma_get_comm_inactivity_timeout
+********************************/
+
+extern "C" float evma_get_comm_inactivity_timeout (const unsigned long binding)
+{
+	ensure_eventmachine("evma_get_comm_inactivity_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ((float)ed->GetCommInactivityTimeout() / 1000);
+	}
+	else
+		return 0.0; //Perhaps this should be an exception. Access to an unknown binding.
+}
+
+/********************************
+evma_set_comm_inactivity_timeout
+********************************/
+
+extern "C" int evma_set_comm_inactivity_timeout (const unsigned long binding, float value)
+{
+	ensure_eventmachine("evma_set_comm_inactivity_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->SetCommInactivityTimeout ((uint64_t)(value * 1000));
+	}
+	else
+		return 0; //Perhaps this should be an exception. Access to an unknown binding.
+}
+
+
+/********************************
+evma_get_pending_connect_timeout
+********************************/
+
+extern "C" float evma_get_pending_connect_timeout (const unsigned long binding)
+{
+	ensure_eventmachine("evma_get_pending_connect_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ((float)ed->GetPendingConnectTimeout() / 1000);
+	}
+	else
+		return 0.0;
+}
+
+
+/********************************
+evma_set_pending_connect_timeout
+********************************/
+
+extern "C" int evma_set_pending_connect_timeout (const unsigned long binding, float value)
+{
+	ensure_eventmachine("evma_set_pending_connect_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->SetPendingConnectTimeout ((uint64_t)(value * 1000));
+	}
+	else
+		return 0;
+}
+
+
+/**********************
+evma_set_timer_quantum
+**********************/
+
+extern "C" void evma_set_timer_quantum (int interval)
+{
+	ensure_eventmachine("evma_set_timer_quantum");
+	EventMachine->SetTimerQuantum (interval);
+}
+
+
+/************************
+evma_get_max_timer_count
+************************/
+
+extern "C" int evma_get_max_timer_count()
+{
+	return EventMachine_t::GetMaxTimerCount();
+}
+
+
+/************************
+evma_set_max_timer_count
+************************/
+
+extern "C" void evma_set_max_timer_count (int ct)
+{
+	// This may only be called if the reactor is not running.
+
+	if (EventMachine)
+		#ifdef BUILD_FOR_RUBY
+			rb_raise(rb_eRuntimeError, "eventmachine already initialized: evma_set_max_timer_count");
+		#else
+			throw std::runtime_error ("eventmachine already initialized: evma_set_max_timer_count");
+		#endif
+	EventMachine_t::SetMaxTimerCount (ct);
+}
+
+/******************
+evma_setuid_string
+******************/
+
+extern "C" void evma_setuid_string (const char *username)
+{
+	// We do NOT need to be running an EM instance because this method is static.
+	EventMachine_t::SetuidString (username);
+}
+
+
+/**********
+evma_popen
+**********/
+
+extern "C" const unsigned long evma_popen (char * const*cmd_strings)
+{
+	ensure_eventmachine("evma_popen");
+	return EventMachine->Socketpair (cmd_strings);
+}
+
+
+/***************************
+evma_get_outbound_data_size
+***************************/
+
+extern "C" int evma_get_outbound_data_size (const unsigned long binding)
+{
+	ensure_eventmachine("evma_get_outbound_data_size");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	return ed ? ed->GetOutboundDataSize() : 0;
+}
+
+
+/**************
+evma_set_epoll
+**************/
+
+extern "C" void evma_set_epoll (int use)
+{
+	bUseEpoll = !!use;
+}
+
+/***************
+evma_set_kqueue
+***************/
+
+extern "C" void evma_set_kqueue (int use)
+{
+	bUseKqueue = !!use;
+}
+
+
+/**********************
+evma_set_rlimit_nofile
+**********************/
+
+extern "C" int evma_set_rlimit_nofile (int nofiles)
+{
+	return EventMachine_t::SetRlimitNofile (nofiles);
+}
+
+
+/*********************************
+evma_send_file_data_to_connection
+*********************************/
+
+extern "C" int evma_send_file_data_to_connection (const unsigned long binding, const char *filename)
+{
+	/* This is a sugaring over send_data_to_connection that reads a file into a
+	 * locally-allocated buffer, and sends the file data to the remote peer.
+	 * Return the number of bytes written to the caller.
+	 * TODO, needs to impose a limit on the file size. This is intended only for
+	 * small files. (I don't know, maybe 8K or less.) For larger files, use interleaved
+	 * I/O to avoid slowing the rest of the system down.
+	 * TODO: we should return a code rather than barf, in case of file-not-found.
+	 * TODO, does this compile on Windows?
+	 * TODO, given that we want this to work only with small files, how about allocating
+	 * the buffer on the stack rather than the heap?
+	 *
+	 * Modified 25Jul07. This now returns -1 on file-too-large; 0 for success, and a positive
+	 * errno in case of other errors.
+	 *
+	 * Contributed by Kirk Haines.
+	 */
+
+	char data[32*1024];
+	int r;
+
+	ensure_eventmachine("evma_send_file_data_to_connection");
+
+	int Fd = open (filename, O_RDONLY);
+
+	if (Fd < 0)
+		return errno;
+	// From here on, all early returns MUST close Fd.
+
+	struct stat st;
+	if (fstat (Fd, &st)) {
+		int e = errno;
+		close (Fd);
+		return e;
+	}
+
+	off_t filesize = st.st_size;
+	if (filesize <= 0) {
+		close (Fd);
+		return 0;
+	}
+	else if (filesize > (off_t) sizeof(data)) {
+		close (Fd);
+		return -1;
+	}
+
+
+	r = read (Fd, data, filesize);
+	if (r != filesize) {
+		int e = errno;
+		close (Fd);
+		return e;
+	}
+	evma_send_data_to_connection (binding, data, r);
+	close (Fd);
+
+	return 0;
+}
+
+
+/****************
+evma_start_proxy
+*****************/
+
+extern "C" void evma_start_proxy (const unsigned long from, const unsigned long to, const unsigned long bufsize, const unsigned long length)
+{
+	ensure_eventmachine("evma_start_proxy");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
+	if (ed)
+		ed->StartProxy(to, bufsize, length);
+}
+
+
+/***************
+evma_stop_proxy
+****************/
+
+extern "C" void evma_stop_proxy (const unsigned long from)
+{
+	ensure_eventmachine("evma_stop_proxy");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
+	if (ed)
+		ed->StopProxy();
+}
+
+
+/***************************
+evma_get_heartbeat_interval
+****************************/
+
+extern "C" float evma_get_heartbeat_interval()
+{
+	ensure_eventmachine("evma_get_heartbeat_interval");
+	return EventMachine->GetHeartbeatInterval();
+}
+
+
+/***************************
+evma_set_heartbeat_interval
+****************************/
+
+extern "C" int evma_set_heartbeat_interval(float interval)
+{
+	ensure_eventmachine("evma_set_heartbeat_interval");
+	return EventMachine->SetHeartbeatInterval(interval);
+}
+
+
+/**************************
+evma_get_current_loop_time
+***************************/
+
+extern "C" uint64_t evma_get_current_loop_time()
+{
+	ensure_eventmachine("evma_get_current_loop_time");
+	return EventMachine->GetCurrentLoopTime();
+}