eventmachine-eventmachine 0.12.7 → 0.12.8

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);
 

data/ext/ssl.cpp

@@ -208,9 +208,10 @@ SslContext_t::~SslContext_t()
 SslBox_t::SslBox_t
 ******************/
 
-SslBox_t::SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile):
+SslBox_t::SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile, bool verify_peer, const char *binding):
 	bIsServer (is_server),
 	bHandshakeCompleted (false),
+	bVerifyPeer (verify_peer),
 	pSSL (NULL),
 	pbioRead (NULL),
 	pbioWrite (NULL)
@@ -232,6 +233,12 @@ SslBox_t::SslBox_t (bool is_server, const string &privkeyfile, const string &cer
 	assert (pSSL);
 	SSL_set_bio (pSSL, pbioRead, pbioWrite);
 
+	// Store a pointer to the binding signature in the SSL object so we can retrieve it later
+	SSL_set_ex_data(pSSL, 0, (void*) binding);
+
+	if (bVerifyPeer)
+		SSL_set_verify(pSSL, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, ssl_verify_wrapper);
+
 	if (!bIsServer)
 		SSL_connect (pSSL);
 }
@@ -419,5 +426,35 @@ X509 *SslBox_t::GetPeerCert()
 	return cert;
 }
 
+
+/******************
+ssl_verify_wrapper
+*******************/
+
+extern "C" int ssl_verify_wrapper(int preverify_ok, X509_STORE_CTX *ctx)
+{
+	const char *binding;
+	X509 *cert;
+	SSL *ssl;
+	BUF_MEM *buf;
+	BIO *out;
+	int result;
+
+	cert = X509_STORE_CTX_get_current_cert(ctx);
+	ssl = (SSL*) X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
+	binding = (const char*) SSL_get_ex_data(ssl, 0);
+
+	out = BIO_new(BIO_s_mem());
+	PEM_write_bio_X509(out, cert);
+	BIO_write(out, "\0", 1);
+	BIO_get_mem_ptr(out, &buf);
+
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject(binding));
+	result = (cd->VerifySslPeer(buf->data) == true ? 1 : 0);
+	BUF_MEM_free(buf);
+
+	return result;
+}
+
 #endif // WITH_SSL
 

data/ext/ssl.h

@@ -57,7 +57,7 @@ class SslBox_t
 class SslBox_t
 {
 	public:
-		SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile);
+		SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile, bool verify_peer, const char *binding);
 		virtual ~SslBox_t();
 
 		int PutPlaintext (const char*, int);
@@ -75,6 +75,7 @@ class SslBox_t
 	protected:
 		SslContext_t *Context;
 
+		bool bVerifyPeer;
 		bool bIsServer;
 		bool bHandshakeCompleted;
 		SSL *pSSL;
@@ -83,6 +84,9 @@ class SslBox_t
 
 		PageList OutboundQ;
 };
+
+extern "C" int ssl_verify_wrapper(int, X509_STORE_CTX*);
+
 #endif // WITH_SSL
 
 

data/java/src/com/rubyeventmachine/Application.java

@@ -128,16 +128,20 @@ public class Application {
 		reactor.timers.put(s, t);
 		
 	}
-	
-	public void connect (String host, int port, Connection c) {
+
+	public void bindConnect (String bindAddr, int bindPort, String host, int port, Connection c) {
 		try {
-			String s = reactor.connectTcpServer(host, port);
+			String s = reactor.connectTcpServer(bindAddr, bindPort, host, port);
 			c.application = this;
 			c.signature = s;
 			reactor.connections.put(s, c);
 			c.postInit();
 		} catch (ClosedChannelException e) {}
 	}
+
+	public void connect (String host, int port, Connection c) {
+		bindConnect(null, 0, host, port, c);
+	}
 	
 	public void startServer (SocketAddress sa, ConnectionFactory f) throws EmReactorException {
 		String s = reactor.startTcpServer(sa);