eventmachine 0.12.6-java → 0.12.8-java

data/ext/em.h

@@ -57,9 +57,10 @@ typedef long long Int64;
 typedef __int64 Int64;
 #endif
 
-extern time_t gCurrentLoopTime;
+extern Int64 gCurrentLoopTime;
 
 class EventableDescriptor;
+class InotifyDescriptor;
 
 
 /********************
@@ -80,9 +81,8 @@ class EventMachine_t
 		void ScheduleHalt();
 		void SignalLoopBreaker();
 		const char *InstallOneshotTimer (int);
-		const char *ConnectToServer (const char *, int);
+		const char *ConnectToServer (const char *, int, const char *, int);
 		const char *ConnectToUnixServer (const char *);
-		const char *AttachFD (int, bool, bool);
 
 		const char *CreateTcpServer (const char *, int);
 		const char *OpenDatagramSocket (const char *, int);
@@ -94,7 +94,10 @@ class EventMachine_t
 
 		void Add (EventableDescriptor*);
 		void Modify (EventableDescriptor*);
+
+		const char *AttachFD (int, bool, bool);
 		int DetachFD (EventableDescriptor*);
+
 		void ArmKqueueWriter (EventableDescriptor*);
 		void ArmKqueueReader (EventableDescriptor*);
 
@@ -106,15 +109,37 @@ class EventMachine_t
 		int SubprocessExitStatus;
 
 		int GetConnectionCount();
+		float GetHeartbeatInterval();
+		int SetHeartbeatInterval(float);
+
+		const char *WatchFile (const char*);
+		void UnwatchFile (int);
+		void UnwatchFile (const char*);
+
+		#ifdef HAVE_KQUEUE
+		void _HandleKqueueFileEvent (struct kevent*);
+		void _RegisterKqueueFileEvent(int);
+		#endif
+
+		const char *WatchPid (int);
+		void UnwatchPid (int);
+		void UnwatchPid (const char *);
+
+		#ifdef HAVE_KQUEUE
+		void _HandleKqueuePidEvent (struct kevent*);
+		#endif
 
 		// Temporary:
 		void _UseEpoll();
 		void _UseKqueue();
 
+		bool UsingKqueue() { return bKqueue; }
+		bool UsingEpoll() { return bEpoll; }
 
 	private:
 		bool _RunOnce();
 		bool _RunTimers();
+		void _UpdateTime();
 		void _AddNewDescriptors();
 		void _ModifyDescriptors();
 		void _InitializeLoopBreaker();
@@ -127,23 +152,27 @@ class EventMachine_t
 
 	public:
 		void _ReadLoopBreaker();
+		void _ReadInotifyEvents();
 
 	private:
 		enum {
-			HeartbeatInterval = 2,
-			MaxEpollDescriptors = 64*1024
+			MaxEpollDescriptors = 64*1024,
+			MaxEvents = 4096
 		};
+		int HeartbeatInterval;
 		void (*EventCallback)(const char*, int, const char*, int);
 
 		class Timer_t: public Bindable_t {
 		};
 
 		multimap<Int64, Timer_t> Timers;
+		map<int, Bindable_t*> Files;
+		map<int, Bindable_t*> Pids;
 		vector<EventableDescriptor*> Descriptors;
 		vector<EventableDescriptor*> NewDescriptors;
 		set<EventableDescriptor*> ModifiedDescriptors;
 
-		time_t NextHeartbeatTime;
+		Int64 NextHeartbeatTime;
 
 		int LoopBreakerReader;
 		int LoopBreakerWriter;
@@ -156,9 +185,17 @@ class EventMachine_t
 	private:
 		bool bEpoll;
 		int epfd; // Epoll file-descriptor
+		#ifdef HAVE_EPOLL
+		struct epoll_event epoll_events [MaxEvents];
+		#endif
 
 		bool bKqueue;
 		int kqfd; // Kqueue file-descriptor
+		#ifdef HAVE_KQUEUE
+		struct kevent Karray [MaxEvents];
+		#endif
+
+		InotifyDescriptor *inotify; // pollable descriptor for our inotify instance
 };
 
 

data/ext/eventmachine.h

@@ -33,7 +33,9 @@ extern "C" {
 		EM_LOOPBREAK_SIGNAL = 105,
 		EM_CONNECTION_NOTIFY_READABLE = 106,
 		EM_CONNECTION_NOTIFY_WRITABLE = 107,
-		EM_SSL_HANDSHAKE_COMPLETED = 108
+		EM_SSL_HANDSHAKE_COMPLETED = 108,
+		EM_SSL_VERIFY = 109,
+		EM_PROXY_TARGET_UNBOUND = 110
 
 	};
 
@@ -41,7 +43,7 @@ extern "C" {
 	void evma_run_machine();
 	void evma_release_library();
 	const char *evma_install_oneshot_timer (int seconds);
-	const char *evma_connect_to_server (const char *server, int port);
+	const char *evma_connect_to_server (const char *bind_addr, int bind_port, const char *server, int port);
 	const char *evma_connect_to_unix_server (const char *server);
 
 	const char *evma_attach_fd (int file_descriptor, int read_mode, int write_mode);
@@ -52,11 +54,12 @@ extern "C" {
 	const char *evma_create_unix_domain_server (const char *filename);
 	const char *evma_open_datagram_socket (const char *server, int port);
 	const char *evma_open_keyboard();
-	void evma_set_tls_parms (const char *binding, const char *privatekey_filename, const char *certchain_filenane);
+	void evma_set_tls_parms (const char *binding, const char *privatekey_filename, const char *certchain_filenane, int verify_peer);
 	void evma_start_tls (const char *binding);
 
 	#ifdef WITH_SSL
 	X509 *evma_get_peer_cert (const char *binding);
+	void evma_accept_ssl_peer (const char *binding);
 	#endif
 
 	int evma_get_peername (const char *binding, struct sockaddr*);
@@ -66,8 +69,8 @@ extern "C" {
 	int evma_get_connection_count();
 	int evma_send_data_to_connection (const char *binding, const char *data, int data_length);
 	int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port);
-	int evma_get_comm_inactivity_timeout (const char *binding, /*out*/int *value);
-	int evma_set_comm_inactivity_timeout (const char *binding, /*in,out*/int *value);
+	float evma_get_comm_inactivity_timeout (const char *binding);
+	int evma_set_comm_inactivity_timeout (const char *binding, float value);
 	int evma_get_outbound_data_size (const char *binding);
 	int evma_send_file_data_to_connection (const char *binding, const char *filename);
 
@@ -79,15 +82,25 @@ extern "C" {
 	void evma_set_max_timer_count (int);
 	void evma_setuid_string (const char *username);
 	void evma_stop_machine();
+	float evma_get_heartbeat_interval();
+	int evma_set_heartbeat_interval(float);
 
 	const char *evma__write_file (const char *filename);
 	const char *evma_popen (char * const*cmd_strings);
 
+	const char *evma_watch_filename (const char *fname);
+	void evma_unwatch_filename (const char *sig);
+
+	const char *evma_watch_pid (int);
+	void evma_unwatch_pid (const char *sig);
+
+	void evma_start_proxy(const char*, const char*);
+	void evma_stop_proxy(const char*);
+
 	int evma_set_rlimit_nofile (int n_files);
 
-	// Temporary:
-	void evma__epoll();
-	void evma__kqueue();
+	void evma_set_epoll (int use);
+	void evma_set_kqueue (int use);
 
 #if __cplusplus
 }

data/ext/eventmachine_cpp.h

@@ -63,6 +63,7 @@ namespace EM {
 			virtual ~Connection() {}
 
 			virtual void Connect (const char*, int);
+			virtual void BindConnect (const char *, int, const char*, int);
 
 			void SendData (const char *data);
 			void SendData (const char *data, int length);

data/ext/extconf.rb

@@ -15,6 +15,9 @@ end
 add_define 'BUILD_FOR_RUBY'
 add_define 'HAVE_RBTRAP' if have_var('rb_trap_immediate', ['ruby.h', 'rubysig.h'])
 add_define "HAVE_TBR" if have_func('rb_thread_blocking_region')# and have_macro('RUBY_UBF_IO', 'ruby.h')
+add_define "HAVE_INOTIFY" if inotify = have_func('inotify_init', 'sys/inotify.h')
+add_define "HAVE_OLD_INOTIFY" if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
+add_define 'HAVE_WRITEV' if have_func('writev', 'sys/uio.h')
 
 # Minor platform details between *nix and Windows:
 
@@ -59,6 +62,7 @@ when /solaris/
     # on Unix we need a g++ link, not gcc.
     CONFIG['LDSHARED'] = "$(CXX) -shared"
   end
+
 when /openbsd/
   # OpenBSD branch contributed by Guillaume Sellier.
 

data/ext/kb.cpp

@@ -77,6 +77,5 @@ void KeyboardDescriptor::Read()
 {
 	char c;
 	read (GetSocket(), &c, 1);
-	if (EventCallback)
-		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, &c, 1);
+	_GenericInboundDispatch(&c, 1);
 }

data/ext/pipe.cpp

@@ -164,7 +164,6 @@ void PipeDescriptor::Read()
 
 		if (r > 0) {
 			total_bytes_read += r;
-			LastRead = gCurrentLoopTime;
 
 			// Add a null-terminator at the the end of the buffer
 			// that we will send to the callback.
@@ -173,8 +172,7 @@ void PipeDescriptor::Read()
 			// the option to do some things faster. Additionally it's
 			// a security guard against buffer overflows.
 			readbuffer [r] = 0;
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, readbuffer, r);
+			_GenericInboundDispatch(readbuffer, r);
 			}
 		else if (r == 0) {
 			break;

data/ext/project.h

@@ -102,6 +102,27 @@ using namespace std;
 #include <sys/queue.h>
 #endif
 
+#ifdef HAVE_INOTIFY
+#include <sys/inotify.h>
+#endif
+
+#ifdef HAVE_OLD_INOTIFY
+#include <sys/syscall.h>
+#include <linux/inotify.h>
+static inline int inotify_init (void) { return syscall (__NR_inotify_init); }
+static inline int inotify_add_watch (int fd, const char *name, __u32 mask) { return syscall (__NR_inotify_add_watch, fd, name, mask); }
+static inline int inotify_rm_watch (int fd, __u32 wd) { return syscall (__NR_inotify_rm_watch, fd, wd); }
+#define HAVE_INOTIFY 1
+#endif
+
+#ifdef HAVE_INOTIFY
+#define INOTIFY_EVENT_SIZE  (sizeof(struct inotify_event))
+#endif
+
+#ifdef HAVE_WRITEV
+#include <sys/uio.h>
+#endif
+
 #include "binder.h"
 #include "em.h"
 #include "epoll.h"

data/ext/rubymain.cpp

@@ -21,7 +21,9 @@ See the file COPYING for complete licensing information.
 #include "eventmachine.h"
 #include <ruby.h>
 
-
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(arg) RFLOAT(arg)->value
+#endif
 
 /*******
 Statics
@@ -43,8 +45,10 @@ static VALUE Intern_delete;
 static VALUE Intern_call;
 static VALUE Intern_receive_data;
 static VALUE Intern_ssl_handshake_completed;
+static VALUE Intern_ssl_verify_peer;
 static VALUE Intern_notify_readable;
 static VALUE Intern_notify_writable;
+static VALUE Intern_proxy_target_unbound;
 
 static VALUE rb_cProcStatus;
 
@@ -93,10 +97,15 @@ static void event_callback (struct em_event* e)
 	else if (a2 == EM_TIMER_FIRED) {
 		VALUE t = rb_ivar_get (EmModule, Intern_at_timers);
 		VALUE q = rb_funcall (t, Intern_delete, 1, rb_str_new(a3, a4));
-		if (q == Qnil)
+		if (q == Qnil) {
 			rb_raise (EM_eUnknownTimerFired, "no such timer: %s", a1);
-		rb_funcall (q, Intern_call, 0);
+		} else if (q == Qfalse) {
+			/* Timer Canceled */
+		} else {
+			rb_funcall (q, Intern_call, 0);
+		}
 	}
+	#ifdef WITH_SSL
 	else if (a2 == EM_SSL_HANDSHAKE_COMPLETED) {
 		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
 		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
@@ -104,6 +113,23 @@ static void event_callback (struct em_event* e)
 			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
 		rb_funcall (q, Intern_ssl_handshake_completed, 0);
 	}
+	else if (a2 == EM_SSL_VERIFY) {
+		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
+		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
+		if (q == Qnil)
+			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
+		VALUE r = rb_funcall (q, Intern_ssl_verify_peer, 1, rb_str_new(a3, a4));
+		if (RTEST(r))
+			evma_accept_ssl_peer (a1);
+	}
+	#endif
+	else if (a2 == EM_PROXY_TARGET_UNBOUND) {
+		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
+		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
+		if (q == Qnil)
+			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
+		rb_funcall (q, Intern_proxy_target_unbound, 0);
+	}
 	else
 		rb_funcall (EmModule, Intern_event_callback, 3, rb_str_new2(a1), (a2 << 1) | 1, rb_str_new(a3,a4));
 }
@@ -234,20 +260,20 @@ static VALUE t_start_tls (VALUE self, VALUE signature)
 t_set_tls_parms
 ***************/
 
-static VALUE t_set_tls_parms (VALUE self, VALUE signature, VALUE privkeyfile, VALUE certchainfile)
+static VALUE t_set_tls_parms (VALUE self, VALUE signature, VALUE privkeyfile, VALUE certchainfile, VALUE verify_peer)
 {
 	/* 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 (StringValuePtr (signature), StringValuePtr (privkeyfile), StringValuePtr (certchainfile) );
+	evma_set_tls_parms (StringValuePtr (signature), StringValuePtr (privkeyfile), StringValuePtr (certchainfile), (verify_peer == Qtrue ? 1 : 0));
 	return Qnil;
 }
 
-/***********
+/***************
 t_get_peer_cert
-***********/
+***************/
 
 static VALUE t_get_peer_cert (VALUE self, VALUE signature)
 {
@@ -352,10 +378,7 @@ t_get_comm_inactivity_timeout
 
 static VALUE t_get_comm_inactivity_timeout (VALUE self, VALUE signature)
 {
-	int timeout;
-	if (evma_get_comm_inactivity_timeout (StringValuePtr (signature), &timeout))
-		return INT2FIX (timeout);
-	return Qnil;
+	return rb_float_new(evma_get_comm_inactivity_timeout(StringValuePtr(signature)));
 }
 
 /*****************************
@@ -364,10 +387,10 @@ t_set_comm_inactivity_timeout
 
 static VALUE t_set_comm_inactivity_timeout (VALUE self, VALUE signature, VALUE timeout)
 {
-	int ti = FIX2INT (timeout);
-	if (evma_set_comm_inactivity_timeout (StringValuePtr (signature), &ti));
+	float ti = RFLOAT_VALUE(timeout);
+	if (evma_set_comm_inactivity_timeout (StringValuePtr (signature), ti));
 		return Qtrue;
-	return Qnil;
+	return Qfalse;
 }
 
 
@@ -414,12 +437,33 @@ static VALUE t_connect_server (VALUE self, VALUE server, VALUE port)
 	// 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.
 
-	const char *f = evma_connect_to_server (StringValuePtr(server), NUM2INT(port));
+	const char *f = evma_connect_to_server (NULL, 0, StringValuePtr(server), NUM2INT(port));
 	if (!f || !*f)
 		rb_raise (rb_eRuntimeError, "no connection");
 	return rb_str_new2 (f);
 }
 
+/*********************
+t_bind_connect_server
+*********************/
+
+static VALUE t_bind_connect_server (VALUE self, 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.
+
+	const char *f;
+	try {
+		f = evma_connect_to_server (StringValuePtr(bind_addr), NUM2INT(bind_port), StringValuePtr(server), NUM2INT(port));
+		if (!f || !*f)
+			rb_raise (rb_eRuntimeError, "no connection");
+	} catch (std::runtime_error e) {
+		rb_sys_fail(e.what());
+	}
+	return rb_str_new2 (f);
+}
+
 /*********************
 t_connect_unix_server
 *********************/
@@ -609,17 +653,56 @@ static VALUE t_read_keyboard (VALUE self)
 }
 
 
-/********
-t__epoll
-********/
+/****************
+t_watch_filename
+****************/
 
-static VALUE t__epoll (VALUE self)
+static VALUE t_watch_filename (VALUE self, VALUE fname)
+{
+	try {
+		return rb_str_new2(evma_watch_filename(StringValuePtr(fname)));
+	} catch (std::runtime_error e) {
+		rb_sys_fail(e.what());
+	}
+}
+
+
+/******************
+t_unwatch_filename
+******************/
+
+static VALUE t_unwatch_filename (VALUE self, VALUE sig)
 {
-	// Temporary.
-	evma__epoll();
+	evma_unwatch_filename(StringValuePtr(sig));
 	return Qnil;
 }
 
+
+/***********
+t_watch_pid
+***********/
+
+static VALUE t_watch_pid (VALUE self, VALUE pid)
+{
+	try {
+		return rb_str_new2(evma_watch_pid(NUM2INT(pid)));
+	} catch (std::runtime_error e) {
+		rb_sys_fail(e.what());
+	}
+}
+
+
+/*************
+t_unwatch_pid
+*************/
+
+static VALUE t_unwatch_pid (VALUE self, VALUE sig)
+{
+	evma_unwatch_pid(StringValuePtr(sig));
+	return Qnil;
+}
+
+
 /**********
 t__epoll_p
 **********/
@@ -633,18 +716,33 @@ static VALUE t__epoll_p (VALUE self)
   #endif
 }
 
+/********
+t__epoll
+********/
 
-/*********
-t__kqueue
-*********/
+static VALUE t__epoll (VALUE self)
+{
+	if (t__epoll_p(self) == Qfalse)
+		return Qfalse;
 
-static VALUE t__kqueue (VALUE self)
+	evma_set_epoll (1);
+	return Qtrue;
+}
+
+/***********
+t__epoll_set
+***********/
+
+static VALUE t__epoll_set (VALUE self, VALUE val)
 {
-	// Temporary.
-	evma__kqueue();
-	return Qnil;
+	if (t__epoll_p(self) == Qfalse)
+		return Qfalse;
+
+	evma_set_epoll (val == Qtrue ? 1 : 0);
+	return val;
 }
 
+
 /***********
 t__kqueue_p
 ***********/
@@ -658,6 +756,46 @@ static VALUE t__kqueue_p (VALUE self)
   #endif
 }
 
+/*********
+t__kqueue
+*********/
+
+static VALUE t__kqueue (VALUE self)
+{
+	if (t__kqueue_p(self) == Qfalse)
+		return Qfalse;
+
+	evma_set_kqueue (1);
+	return Qtrue;
+}
+
+/*************
+t__kqueue_set
+*************/
+
+static VALUE t__kqueue_set (VALUE self, VALUE val)
+{
+	if (t__kqueue_p(self) == Qfalse)
+		return Qfalse;
+
+	evma_set_kqueue (val == Qtrue ? 1 : 0);
+	return val;
+}
+
+
+/********
+t__ssl_p
+********/
+
+static VALUE t__ssl_p (VALUE self)
+{
+  #ifdef WITH_SSL
+  return Qtrue;
+  #else
+  return Qfalse;
+  #endif
+}
+
 
 /****************
 t_send_file_data
@@ -739,6 +877,51 @@ static VALUE t_get_loop_time (VALUE self)
 }
 
 
+/*************
+t_start_proxy
+**************/
+
+static VALUE t_start_proxy (VALUE self, VALUE from, VALUE to)
+{
+	evma_start_proxy(StringValuePtr(from), StringValuePtr(to));
+	return Qnil;
+}
+
+
+/************
+t_stop_proxy
+*************/
+
+static VALUE t_stop_proxy (VALUE self, VALUE from)
+{
+	evma_stop_proxy(StringValuePtr(from));
+	return Qnil;
+}
+
+
+/************************
+t_get_heartbeat_interval
+*************************/
+
+static VALUE t_get_heartbeat_interval (VALUE self)
+{
+	return rb_float_new(evma_get_heartbeat_interval());
+}
+
+
+/************************
+t_set_heartbeat_interval
+*************************/
+
+static VALUE t_set_heartbeat_interval (VALUE self, VALUE interval)
+{
+	float iv = RFLOAT_VALUE(interval);
+	if (evma_set_heartbeat_interval(iv))
+		return Qtrue;
+	return Qfalse;
+}
+
+
 /*********************
 Init_rubyeventmachine
 *********************/
@@ -761,8 +944,10 @@ extern "C" void Init_rubyeventmachine()
 	Intern_call = rb_intern ("call");
 	Intern_receive_data = rb_intern ("receive_data");
 	Intern_ssl_handshake_completed = rb_intern ("ssl_handshake_completed");
+	Intern_ssl_verify_peer = rb_intern ("ssl_verify_peer");
 	Intern_notify_readable = rb_intern ("notify_readable");
 	Intern_notify_writable = rb_intern ("notify_writable");
+	Intern_proxy_target_unbound = rb_intern ("proxy_target_unbound");
 
 	// INCOMPLETE, we need to define class Connections inside module EventMachine
 	// run_machine and run_machine_without_threads are now identical.
@@ -781,7 +966,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "start_tcp_server", (VALUE(*)(...))t_start_server, 2);
 	rb_define_module_function (EmModule, "stop_tcp_server", (VALUE(*)(...))t_stop_server, 1);
 	rb_define_module_function (EmModule, "start_unix_server", (VALUE(*)(...))t_start_unix_server, 1);
-	rb_define_module_function (EmModule, "set_tls_parms", (VALUE(*)(...))t_set_tls_parms, 3);
+	rb_define_module_function (EmModule, "set_tls_parms", (VALUE(*)(...))t_set_tls_parms, 4);
 	rb_define_module_function (EmModule, "start_tls", (VALUE(*)(...))t_start_tls, 1);
 	rb_define_module_function (EmModule, "get_peer_cert", (VALUE(*)(...))t_get_peer_cert, 1);
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);
@@ -789,11 +974,21 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2);
 	rb_define_module_function (EmModule, "report_connection_error_status", (VALUE(*)(...))t_report_connection_error_status, 1);
 	rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2);
+	rb_define_module_function (EmModule, "bind_connect_server", (VALUE(*)(...))t_bind_connect_server, 4);
 	rb_define_module_function (EmModule, "connect_unix_server", (VALUE(*)(...))t_connect_unix_server, 1);
 
 	rb_define_module_function (EmModule, "attach_fd", (VALUE (*)(...))t_attach_fd, 3);
 	rb_define_module_function (EmModule, "detach_fd", (VALUE (*)(...))t_detach_fd, 1);
 
+	rb_define_module_function (EmModule, "start_proxy", (VALUE (*)(...))t_start_proxy, 2);
+	rb_define_module_function (EmModule, "stop_proxy", (VALUE (*)(...))t_stop_proxy, 1);
+
+	rb_define_module_function (EmModule, "watch_filename", (VALUE (*)(...))t_watch_filename, 1);
+	rb_define_module_function (EmModule, "unwatch_filename", (VALUE (*)(...))t_unwatch_filename, 1);
+
+	rb_define_module_function (EmModule, "watch_pid", (VALUE (*)(...))t_watch_pid, 1);
+	rb_define_module_function (EmModule, "unwatch_pid", (VALUE (*)(...))t_unwatch_pid, 1);
+
 	rb_define_module_function (EmModule, "current_time", (VALUE(*)(...))t_get_loop_time, 0);
 
 	rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2);
@@ -808,6 +1003,8 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1);
 	rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1);
 	rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2);
+	rb_define_module_function (EmModule, "get_heartbeat_interval", (VALUE(*)(...))t_get_heartbeat_interval, 0);
+	rb_define_module_function (EmModule, "set_heartbeat_interval", (VALUE(*)(...))t_set_heartbeat_interval, 1);
 
 	// Provisional:
 	rb_define_module_function (EmModule, "_write_file", (VALUE(*)(...))t__write_file, 1);
@@ -821,13 +1018,16 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "set_rlimit_nofile", (VALUE(*)(...))t_set_rlimit_nofile, 1);
 	rb_define_module_function (EmModule, "get_connection_count", (VALUE(*)(...))t_get_connection_count, 0);
 
-	// Temporary:
 	rb_define_module_function (EmModule, "epoll", (VALUE(*)(...))t__epoll, 0);
-	rb_define_module_function (EmModule, "kqueue", (VALUE(*)(...))t__kqueue, 0);
-
+	rb_define_module_function (EmModule, "epoll=", (VALUE(*)(...))t__epoll_set, 1);
 	rb_define_module_function (EmModule, "epoll?", (VALUE(*)(...))t__epoll_p, 0);
+
+	rb_define_module_function (EmModule, "kqueue", (VALUE(*)(...))t__kqueue, 0);
+	rb_define_module_function (EmModule, "kqueue=", (VALUE(*)(...))t__kqueue_set, 1);
 	rb_define_module_function (EmModule, "kqueue?", (VALUE(*)(...))t__kqueue_p, 0);
 
+	rb_define_module_function (EmModule, "ssl?", (VALUE(*)(...))t__ssl_p, 0);
+
 	rb_define_method (EmConnection, "get_outbound_data_size", (VALUE(*)(...))conn_get_outbound_data_size, 0);
 	rb_define_method (EmConnection, "associate_callback_target", (VALUE(*)(...))conn_associate_callback_target, 1);