eventmachine 0.12.6-x86-mswin32-60 → 0.12.8-x86-mswin32-60

data/{docs/README → README}

@@ -1,8 +1,11 @@
-$Id$
-
 = RUBY/EventMachine
 
 Homepage::  http://rubyeventmachine.com
+Rubyforge Page:: http://rubyforge.org/projects/eventmachine
+Google Group:: http://groups.google.com/group/eventmachine
+Mailing List:: http://rubyforge.org/pipermail/eventmachine-talk
+RDoc:: http://eventmachine.rubyforge.org
+IRC:: ##eventmachine on irc.freenode.net
 Copyright:: (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
 Email:: gmail address: garbagecat10
 
@@ -57,18 +60,23 @@ improved.
 
 Here's a fully-functional echo server written with EventMachine:
 
-      require 'rubygems'
-      require 'eventmachine'
+ require 'eventmachine'
 
-      module EchoServer
-        def receive_data data
-          send_data ">>>you sent: #{data}"
-          close_connection if data =~ /quit/i
-        end
-      end
+ module EchoServer
+   def post_init
+     puts "-- someone connected to the echo server!"
+   end
 
-      EventMachine::run {
-        EventMachine::start_server "192.168.0.100", 8081, EchoServer
-      }
+   def receive_data data
+     send_data ">>>you sent: #{data}"
+     close_connection if data =~ /quit/i
+   end
 
+   def unbind
+     puts "-- someone disconnected from the echo server!"
+   end
+ end
 
+ EventMachine::run {
+   EventMachine::start_server "127.0.0.1", 8081, EchoServer
+ }

data/Rakefile

@@ -87,8 +87,8 @@ Spec = Gem::Specification.new do |s|
   s.platform          = Gem::Platform::RUBY
 
   s.has_rdoc          = true
-  s.rdoc_options      = %w(--title EventMachine --main docs/README --line-numbers)
-  s.extra_rdoc_files  = Dir['docs/*']
+  s.rdoc_options      = %w(--title EventMachine --main README --line-numbers -x lib/em/version -x lib/emva -x lib/evma/ -x lib/pr_eventmachine -x lib/jeventmachine)
+  s.extra_rdoc_files  = Dir['README,docs/*']
 
   s.files             = `git ls-files`.split("\n")
 
@@ -124,7 +124,7 @@ of EventMachine is to enable programs to easily interface with other programs
 using TCP/IP, especially if custom protocols are required.
   EOD
 
-  require 'lib/eventmachine_version'
+  require 'lib/em/version'
   s.version = EventMachine::VERSION
 end
 
@@ -132,6 +132,10 @@ if RUBY_PLATFORM =~ /mswin/
   Spec.platform = 'x86-mswin32-60'
   Spec.files += %w[ lib/rubyeventmachine.so lib/fastfilereaderext.so ]
   Spec.extensions = nil
+elsif RUBY_PLATFORM =~ /java/
+  Spec.platform = 'java'
+  Spec.files += %w[ lib/em_reactor.jar ]
+  Spec.extensions = nil
 end
 
 # this is a hack right now, it requires installing msysgit in the global path so it can use tar/curl/etc.
@@ -181,6 +185,7 @@ namespace :win32 do
     end
   end
 
+  desc "build binary win32 gem"
   task :gem => :build_openssl do
     Rake::Task['build'].invoke
     Rake::Task['gem'].invoke
@@ -220,7 +225,7 @@ namespace :ext do
     end
   end
 end
-  
+
 namespace :java do
   # This task creates the JRuby JAR file and leaves it in the lib directory.
   # This step is required before executing the jgem task.
@@ -244,6 +249,11 @@ namespace :java do
       sh "jar -cf em_reactor.jar com/rubyeventmachine/*.class"
     end
   end
+
+  desc "build a java binary gem"
+  task :gem => :build do
+    Rake::Task['gem'].invoke
+  end
 end
 
 task :gemspec => :clobber do

data/docs/DEFERRABLES

@@ -1,10 +1,5 @@
-$Id$
-
-[DOCUMENT UNDER CONSTRUCTION]
-
 EventMachine (EM) adds two different formalisms for lightweight concurrency to the Ruby programmer's toolbox: spawned processes and deferrables. This note will show you how to use deferrables. For more information, see the separate document LIGHTWEIGHT_CONCURRENCY.
 
-
 === What are Deferrables?
 
 EventMachine's Deferrable borrows heavily from the "deferred" object in Python's "Twisted" event-handling framework. Here's a minimal example that illustrates Deferrable:

data/docs/INSTALL

@@ -1,5 +1,3 @@
-$Id$
-
 If you have obtained an EventMachine source-tarball (.tar.gz):
 unzip and untar the tarball, and enter the directory that is
 created. In that directory, say:
@@ -7,8 +5,8 @@ ruby setup.rb
 (You may need to be root to execute this command.)
 
 To create documentation for EventMachine, simply type:
-rdoc
-in the distro directory. Rdocs will be created in subdirectory doc.
+rake rdoc
+in the distro directory. Rdocs will be created in subdirectory rdoc.
 
 If you have obtained a gem version of EventMachine, install it in the
 usual way (gem install eventmachine). You may need superuser privileges

data/docs/LEGAL

@@ -19,7 +19,7 @@ setup.rb
 	the GNU LGPL, Lesser General Public License version 2.1.
 
 
-lib/protocols/buftok.rb
+lib/em/buftok.rb
 	This file is Copyright (C) 2007 by Tony Arcieri. This file is
 	covered by the terms of Ruby's License (see the file COPYING).
 

data/docs/LIGHTWEIGHT_CONCURRENCY

@@ -1,5 +1,3 @@
-$Id$
-
 EventMachine (EM) adds two different formalisms for lightweight concurrency to the Ruby programmer's toolbox: spawned processes and deferrables. This note will show you how to use them.
 
 

data/docs/PURE_RUBY

@@ -1,5 +1,3 @@
-$Id$
-
 EventMachine is supplied in three alternative versions.
 
 1) A version that includes a Ruby extension written in C++. This version requires compilation;

data/docs/RELEASE_NOTES

@@ -1,5 +1,3 @@
-$Id$
-
 RUBY/EventMachine RELEASE NOTES
 
 --------------------------------------------------

data/docs/SMTP

@@ -1,9 +1,2 @@
-$Id$
-
-
-[DOCUMENT UNDER CONSTRUCTION]
-
 This note details the usage of EventMachine's built-in support for SMTP. EM supports both client and server connections, which will be described in separate sections.
 
-
-

data/docs/SPAWNED_PROCESSES

@@ -1,7 +1,3 @@
-$Id$
-
-[DOCUMENT UNDER CONSTRUCTION]
-
 EventMachine (EM) adds two different formalisms for lightweight concurrency to the Ruby programmer's toolbox: spawned processes and deferrables. This note will show you how to use spawned processes. For more information, see the separate document LIGHTWEIGHT_CONCURRENCY.
 
 

data/docs/TODO

@@ -1,5 +1,3 @@
-$Id$
-
 TODO List:
 
 12Aug06: Noticed by Don Stocks. A TCP connect-request that results

data/eventmachine.gemspec

@@ -1,32 +1,41 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{eventmachine}
-  s.version = "0.12.6"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Francis Cianfrocca"]
-  s.date = %q{2009-03-07}
-  s.description = %q{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.email = %q{garbagecat10@gmail.com}
-  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
-  s.extra_rdoc_files = ["docs/ChangeLog", "docs/COPYING", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/README", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO"]
-  s.files = [".gitignore", "Rakefile", "docs/COPYING", "docs/ChangeLog", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/README", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO", "eventmachine.gemspec", "ext/binder.cpp", "ext/binder.h", "ext/cmain.cpp", "ext/cplusplus.cpp", "ext/ed.cpp", "ext/ed.h", "ext/em.cpp", "ext/em.h", "ext/emwin.cpp", "ext/emwin.h", "ext/epoll.cpp", "ext/epoll.h", "ext/eventmachine.h", "ext/eventmachine_cpp.h", "ext/extconf.rb", "ext/fastfilereader/extconf.rb", "ext/fastfilereader/mapper.cpp", "ext/fastfilereader/mapper.h", "ext/fastfilereader/rubymain.cpp", "ext/files.cpp", "ext/files.h", "ext/kb.cpp", "ext/page.cpp", "ext/page.h", "ext/pipe.cpp", "ext/project.h", "ext/rubymain.cpp", "ext/sigs.cpp", "ext/sigs.h", "ext/ssl.cpp", "ext/ssl.h", "java/.classpath", "java/.project", "java/src/com/rubyeventmachine/Application.java", "java/src/com/rubyeventmachine/Connection.java", "java/src/com/rubyeventmachine/ConnectionFactory.java", "java/src/com/rubyeventmachine/DefaultConnectionFactory.java", "java/src/com/rubyeventmachine/EmReactor.java", "java/src/com/rubyeventmachine/EmReactorException.java", "java/src/com/rubyeventmachine/EventableChannel.java", "java/src/com/rubyeventmachine/EventableDatagramChannel.java", "java/src/com/rubyeventmachine/EventableSocketChannel.java", "java/src/com/rubyeventmachine/PeriodicTimer.java", "java/src/com/rubyeventmachine/Timer.java", "java/src/com/rubyeventmachine/tests/ApplicationTest.java", "java/src/com/rubyeventmachine/tests/ConnectTest.java", "java/src/com/rubyeventmachine/tests/EMTest.java", "java/src/com/rubyeventmachine/tests/TestDatagrams.java", "java/src/com/rubyeventmachine/tests/TestServers.java", "java/src/com/rubyeventmachine/tests/TestTimers.java", "lib/em/deferrable.rb", "lib/em/eventable.rb", "lib/em/future.rb", "lib/em/messages.rb", "lib/em/processes.rb", "lib/em/spawnable.rb", "lib/em/streamer.rb", "lib/eventmachine.rb", "lib/eventmachine_version.rb", "lib/evma.rb", "lib/evma/callback.rb", "lib/evma/container.rb", "lib/evma/factory.rb", "lib/evma/protocol.rb", "lib/evma/reactor.rb", "lib/jeventmachine.rb", "lib/pr_eventmachine.rb", "lib/protocols/buftok.rb", "lib/protocols/header_and_content.rb", "lib/protocols/httpcli2.rb", "lib/protocols/httpclient.rb", "lib/protocols/line_and_text.rb", "lib/protocols/linetext2.rb", "lib/protocols/memcache.rb", "lib/protocols/postgres.rb", "lib/protocols/saslauth.rb", "lib/protocols/smtpclient.rb", "lib/protocols/smtpserver.rb", "lib/protocols/stomp.rb", "lib/protocols/tcptest.rb", "setup.rb", "tasks/cpp.rake", "tasks/project.rake", "tasks/tests.rake", "tests/test_attach.rb", "tests/test_basic.rb", "tests/test_connection_count.rb", "tests/test_defer.rb", "tests/test_epoll.rb", "tests/test_error_handler.rb", "tests/test_errors.rb", "tests/test_eventables.rb", "tests/test_exc.rb", "tests/test_futures.rb", "tests/test_handler_check.rb", "tests/test_hc.rb", "tests/test_httpclient.rb", "tests/test_httpclient2.rb", "tests/test_kb.rb", "tests/test_ltp.rb", "tests/test_ltp2.rb", "tests/test_next_tick.rb", "tests/test_processes.rb", "tests/test_pure.rb", "tests/test_running.rb", "tests/test_sasl.rb", "tests/test_send_file.rb", "tests/test_servers.rb", "tests/test_smtpclient.rb", "tests/test_smtpserver.rb", "tests/test_spawn.rb", "tests/test_ssl_args.rb", "tests/test_ssl_methods.rb", "tests/test_timers.rb", "tests/test_ud.rb", "tests/testem.rb", "web/whatis"]
-  s.has_rdoc = true
-  s.homepage = %q{http://rubyeventmachine.com}
-  s.rdoc_options = ["--title", "EventMachine", "--main", "docs/README", "--line-numbers"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{eventmachine}
-  s.rubygems_version = %q{1.3.1}
-  s.summary = %q{Ruby/EventMachine library}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{eventmachine}
+  s.version = "0.12.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Francis Cianfrocca"]
+  s.date = %q{2009-05-22}
+  s.description = %q{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.email = %q{garbagecat10@gmail.com}
+  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
+  s.has_rdoc = true
+  s.files = [".gitignore", "README", "Rakefile", "docs/COPYING", "docs/ChangeLog", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO", "eventmachine.gemspec", "examples/ex_channel.rb", "examples/ex_queue.rb", "examples/helper.rb", "ext/binder.cpp", "ext/binder.h", "ext/cmain.cpp", "ext/cplusplus.cpp", "ext/ed.cpp", "ext/ed.h", "ext/em.cpp", "ext/em.h", "ext/emwin.cpp", "ext/emwin.h", "ext/epoll.cpp", "ext/epoll.h", "ext/eventmachine.h", "ext/eventmachine_cpp.h", "ext/extconf.rb", "ext/fastfilereader/extconf.rb", "ext/fastfilereader/mapper.cpp", "ext/fastfilereader/mapper.h", "ext/fastfilereader/rubymain.cpp", "ext/files.cpp", "ext/files.h", "ext/kb.cpp", "ext/page.cpp", "ext/page.h", "ext/pipe.cpp", "ext/project.h", "ext/rubymain.cpp", "ext/sigs.cpp", "ext/sigs.h", "ext/ssl.cpp", "ext/ssl.h", "java/.classpath", "java/.project", "java/src/com/rubyeventmachine/Application.java", "java/src/com/rubyeventmachine/Connection.java", "java/src/com/rubyeventmachine/ConnectionFactory.java", "java/src/com/rubyeventmachine/DefaultConnectionFactory.java", "java/src/com/rubyeventmachine/EmReactor.java", "java/src/com/rubyeventmachine/EmReactorException.java", "java/src/com/rubyeventmachine/EventableChannel.java", "java/src/com/rubyeventmachine/EventableDatagramChannel.java", "java/src/com/rubyeventmachine/EventableSocketChannel.java", "java/src/com/rubyeventmachine/PeriodicTimer.java", "java/src/com/rubyeventmachine/Timer.java", "java/src/com/rubyeventmachine/tests/ApplicationTest.java", "java/src/com/rubyeventmachine/tests/ConnectTest.java", "java/src/com/rubyeventmachine/tests/EMTest.java", "java/src/com/rubyeventmachine/tests/TestDatagrams.java", "java/src/com/rubyeventmachine/tests/TestServers.java", "java/src/com/rubyeventmachine/tests/TestTimers.java", "lib/em/buftok.rb", "lib/em/callback.rb", "lib/em/channel.rb", "lib/em/connection.rb", "lib/em/deferrable.rb", "lib/em/file_watch.rb", "lib/em/future.rb", "lib/em/messages.rb", "lib/em/process_watch.rb", "lib/em/processes.rb", "lib/em/protocols.rb", "lib/em/protocols/header_and_content.rb", "lib/em/protocols/httpclient.rb", "lib/em/protocols/httpclient2.rb", "lib/em/protocols/line_and_text.rb", "lib/em/protocols/linetext2.rb", "lib/em/protocols/memcache.rb", "lib/em/protocols/object_protocol.rb", "lib/em/protocols/postgres3.rb", "lib/em/protocols/saslauth.rb", "lib/em/protocols/smtpclient.rb", "lib/em/protocols/smtpserver.rb", "lib/em/protocols/stomp.rb", "lib/em/protocols/tcptest.rb", "lib/em/queue.rb", "lib/em/spawnable.rb", "lib/em/streamer.rb", "lib/em/timers.rb", "lib/em/version.rb", "lib/eventmachine.rb", "lib/evma.rb", "lib/evma/callback.rb", "lib/evma/container.rb", "lib/evma/factory.rb", "lib/evma/protocol.rb", "lib/evma/reactor.rb", "lib/jeventmachine.rb", "lib/pr_eventmachine.rb", "setup.rb", "tasks/cpp.rake", "tasks/project.rake", "tasks/tests.rake", "tests/client.crt", "tests/client.key", "tests/test_attach.rb", "tests/test_basic.rb", "tests/test_channel.rb", "tests/test_connection_count.rb", "tests/test_defer.rb", "tests/test_epoll.rb", "tests/test_error_handler.rb", "tests/test_errors.rb", "tests/test_exc.rb", "tests/test_file_watch.rb", "tests/test_futures.rb", "tests/test_handler_check.rb", "tests/test_hc.rb", "tests/test_httpclient.rb", "tests/test_httpclient2.rb", "tests/test_inactivity_timeout.rb", "tests/test_kb.rb", "tests/test_ltp.rb", "tests/test_ltp2.rb", "tests/test_next_tick.rb", "tests/test_object_protocol.rb", "tests/test_process_watch.rb", "tests/test_processes.rb", "tests/test_proxy_connection.rb", "tests/test_pure.rb", "tests/test_queue.rb", "tests/test_running.rb", "tests/test_sasl.rb", "tests/test_send_file.rb", "tests/test_servers.rb", "tests/test_smtpclient.rb", "tests/test_smtpserver.rb", "tests/test_spawn.rb", "tests/test_ssl_args.rb", "tests/test_ssl_methods.rb", "tests/test_ssl_verify.rb", "tests/test_timers.rb", "tests/test_ud.rb", "tests/testem.rb", "web/whatis"]
+  s.homepage = %q{http://rubyeventmachine.com}
+  s.rdoc_options = ["--title", "EventMachine", "--main", "README", "--line-numbers", "-x", "lib/em/version", "-x", "lib/emva", "-x", "lib/evma/", "-x", "lib/pr_eventmachine", "-x", "lib/jeventmachine"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{eventmachine}
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Ruby/EventMachine library}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+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/helper.rb

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

data/ext/cmain.cpp

@@ -1,586 +1,685 @@
-/*****************************************************************************
-
-$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"
-
-
-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, err_string);
-		#else
-			throw std::runtime_error (err_string);
-		#endif
-	}
-}
-
-/***********************
-evma_initialize_library
-***********************/
-
-extern "C" void evma_initialize_library (void(*cb)(const char*, int, const char*, int))
-{
-	// Probably a bad idea to mess with the signal mask of a process
-	// we're just being linked into.
-	//InstallSignalHandlers();
-	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 char *evma_install_oneshot_timer (int seconds)
-{
-	ensure_eventmachine("evma_install_oneshot_timer");
-	return EventMachine->InstallOneshotTimer (seconds);
-}
-
-
-/**********************
-evma_connect_to_server
-**********************/
-
-extern "C" const char *evma_connect_to_server (const char *server, int port)
-{
-	ensure_eventmachine("evma_connect_to_server");
-	return EventMachine->ConnectToServer (server, port);
-}
-
-/***************************
-evma_connect_to_unix_server
-***************************/
-
-extern "C" const char *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 char *evma_attach_fd (int file_descriptor, int notify_readable, int notify_writable)
-{
-	ensure_eventmachine("evma_attach_fd");
-	return EventMachine->AttachFD (file_descriptor, (notify_readable ? true : false), (notify_writable ? true : false));
-}
-
-/**************
-evma_detach_fd
-**************/
-
-extern "C" int evma_detach_fd (const char *binding)
-{
-	ensure_eventmachine("evma_dettach_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
-}
-
-/**********************
-evma_create_tcp_server
-**********************/
-
-extern "C" const char *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 char *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 char *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 char *evma_open_keyboard()
-{
-	ensure_eventmachine("evma_open_keyboard");
-	return EventMachine->OpenKeyboard();
-}
-
-
-
-/****************************
-evma_send_data_to_connection
-****************************/
-
-extern "C" int evma_send_data_to_connection (const char *binding, const char *data, int data_length)
-{
-	ensure_eventmachine("evma_send_data_to_connection");
-	return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
-}
-
-/******************
-evma_send_datagram
-******************/
-
-extern "C" int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port)
-{
-	ensure_eventmachine("evma_send_datagram");
-	return DatagramDescriptor::SendDatagram (binding, data, data_length, address, port);
-}
-
-
-/*********************
-evma_close_connection
-*********************/
-
-extern "C" void evma_close_connection (const char *binding, int after_writing)
-{
-	ensure_eventmachine("evma_close_connection");
-	ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
-}
-
-/***********************************
-evma_report_connection_error_status
-***********************************/
-
-extern "C" int evma_report_connection_error_status (const char *binding)
-{
-	ensure_eventmachine("evma_report_connection_error_status");
-	return ConnectionDescriptor::ReportErrorStatus (binding);
-}
-
-/********************
-evma_stop_tcp_server
-********************/
-
-extern "C" void evma_stop_tcp_server (const char *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 char *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 char *binding, const char *privatekey_filename, const char *certchain_filename)
-{
-	ensure_eventmachine("evma_set_tls_parms");
-	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-	if (ed)
-		ed->SetTlsParms (privatekey_filename, certchain_filename);
-}
-
-/**************
-evma_get_peer_cert
-**************/
-
-#ifdef WITH_SSL
-extern "C" X509 *evma_get_peer_cert (const char *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_get_peername
-*****************/
-
-extern "C" int evma_get_peername (const char *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 char *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 char *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 char *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__write_file
-****************/
-
-extern "C" const char *evma__write_file (const char *filename)
-{
-	ensure_eventmachine("evma__write_file");
-	return EventMachine->_OpenFileForWriting (filename);
-}
-
-
-/********************************
-evma_get_comm_inactivity_timeout
-********************************/
-
-extern "C" int evma_get_comm_inactivity_timeout (const char *binding, int *value)
-{
-	ensure_eventmachine("evma_get_comm_inactivity_timeout");
-	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-	if (ed) {
-		return ed->GetCommInactivityTimeout (value);
-	}
-	else
-		return 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 char *binding, int *value)
-{
-	ensure_eventmachine("evma_set_comm_inactivity_timeout");
-	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-	if (ed) {
-		return ed->SetCommInactivityTimeout (value);
-	}
-	else
-		return 0; //Perhaps this should be an exception. Access to an unknown binding.
-}
-
-
-/**********************
-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 char *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 char *binding)
-{
-	ensure_eventmachine("evma_get_outbound_data_size");
-	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-	return ed ? ed->GetOutboundDataSize() : 0;
-}
-
-
-/***********
-evma__epoll
-***********/
-
-extern "C" void evma__epoll()
-{
-	bUseEpoll = 1;
-}
-
-/************
-evma__kqueue
-************/
-
-extern "C" void evma__kqueue()
-{
-	bUseKqueue = 1;
-}
-
-
-/**********************
-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 char *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;
-	}
-
-	int filesize = st.st_size;
-	if (filesize <= 0) {
-		close (Fd);
-		return 0;
-	}
-	else if (filesize > 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;
-}
-
+/*****************************************************************************
+
+$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"
+
+
+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, err_string);
+		#else
+			throw std::runtime_error (err_string);
+		#endif
+	}
+}
+
+/***********************
+evma_initialize_library
+***********************/
+
+extern "C" void evma_initialize_library (void(*cb)(const char*, int, const char*, int))
+{
+	// Probably a bad idea to mess with the signal mask of a process
+	// we're just being linked into.
+	//InstallSignalHandlers();
+	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 char *evma_install_oneshot_timer (int seconds)
+{
+	ensure_eventmachine("evma_install_oneshot_timer");
+	return EventMachine->InstallOneshotTimer (seconds);
+}
+
+
+/**********************
+evma_connect_to_server
+**********************/
+
+extern "C" const char *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 char *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 char *evma_attach_fd (int file_descriptor, int notify_readable, int notify_writable)
+{
+	ensure_eventmachine("evma_attach_fd");
+	return EventMachine->AttachFD (file_descriptor, (notify_readable ? true : false), (notify_writable ? true : false));
+}
+
+/**************
+evma_detach_fd
+**************/
+
+extern "C" int evma_detach_fd (const char *binding)
+{
+	ensure_eventmachine("evma_dettach_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
+}
+
+/**********************
+evma_create_tcp_server
+**********************/
+
+extern "C" const char *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 char *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 char *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 char *evma_open_keyboard()
+{
+	ensure_eventmachine("evma_open_keyboard");
+	return EventMachine->OpenKeyboard();
+}
+
+/*******************
+evma_watch_filename
+*******************/
+
+extern "C" const char *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 char *sig)
+{
+	ensure_eventmachine("evma_unwatch_file");
+	EventMachine->UnwatchFile(sig);
+}
+
+/**************
+evma_watch_pid
+**************/
+
+extern "C" const char *evma_watch_pid (int pid)
+{
+	ensure_eventmachine("evma_watch_pid");
+	return EventMachine->WatchPid(pid);
+}
+
+/****************
+evma_unwatch_pid
+****************/
+
+extern "C" void evma_unwatch_pid (const char *sig)
+{
+	ensure_eventmachine("evma_unwatch_pid");
+	EventMachine->UnwatchPid(sig);
+}
+
+/****************************
+evma_send_data_to_connection
+****************************/
+
+extern "C" int evma_send_data_to_connection (const char *binding, const char *data, int data_length)
+{
+	ensure_eventmachine("evma_send_data_to_connection");
+	return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
+}
+
+/******************
+evma_send_datagram
+******************/
+
+extern "C" int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port)
+{
+	ensure_eventmachine("evma_send_datagram");
+	return DatagramDescriptor::SendDatagram (binding, data, data_length, address, port);
+}
+
+
+/*********************
+evma_close_connection
+*********************/
+
+extern "C" void evma_close_connection (const char *binding, int after_writing)
+{
+	ensure_eventmachine("evma_close_connection");
+	ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
+}
+
+/***********************************
+evma_report_connection_error_status
+***********************************/
+
+extern "C" int evma_report_connection_error_status (const char *binding)
+{
+	ensure_eventmachine("evma_report_connection_error_status");
+	return ConnectionDescriptor::ReportErrorStatus (binding);
+}
+
+/********************
+evma_stop_tcp_server
+********************/
+
+extern "C" void evma_stop_tcp_server (const char *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 char *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 char *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 char *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 char *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 char *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 char *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 char *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 char *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__write_file
+****************/
+
+extern "C" const char *evma__write_file (const char *filename)
+{
+	ensure_eventmachine("evma__write_file");
+	return EventMachine->_OpenFileForWriting (filename);
+}
+
+
+/********************************
+evma_get_comm_inactivity_timeout
+********************************/
+
+extern "C" float evma_get_comm_inactivity_timeout (const char *binding)
+{
+	ensure_eventmachine("evma_get_comm_inactivity_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetCommInactivityTimeout();
+	}
+	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 char *binding, float value)
+{
+	ensure_eventmachine("evma_set_comm_inactivity_timeout");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->SetCommInactivityTimeout (value);
+	}
+	else
+		return 0; //Perhaps this should be an exception. Access to an unknown binding.
+}
+
+
+/**********************
+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 char *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 char *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 char *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;
+	}
+
+	int filesize = st.st_size;
+	if (filesize <= 0) {
+		close (Fd);
+		return 0;
+	}
+	else if (filesize > 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 char *from, const char *to)
+{
+	ensure_eventmachine("evma_start_proxy");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
+	if (ed)
+		ed->StartProxy(to);
+}
+
+
+/***************
+evma_stop_proxy
+****************/
+
+extern "C" void evma_stop_proxy (const char *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);
+}