eventmachine 0.10.0 → 0.12.0

data/DEFERRABLES

@@ -1,4 +1,4 @@
-$Id: DEFERRABLES 551 2007-09-22 12:57:36Z blackhedd $
+$Id: DEFERRABLES 668 2008-01-04 23:00:34Z blackhedd $
 
 [DOCUMENT UNDER CONSTRUCTION]
 

data/LIGHTWEIGHT_CONCURRENCY

@@ -1,4 +1,4 @@
-$Id: LIGHTWEIGHT_CONCURRENCY 541 2007-09-17 15:08:36Z blackhedd $
+$Id: LIGHTWEIGHT_CONCURRENCY 668 2008-01-04 23:00:34Z blackhedd $
 
 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/PURE_RUBY

@@ -1,4 +1,4 @@
-$Id: PURE_RUBY 602 2007-12-05 18:45:29Z blackhedd $
+$Id: PURE_RUBY 668 2008-01-04 23:00:34Z blackhedd $
 
 EventMachine is supplied in three alternative versions.
 

data/README

@@ -1,4 +1,4 @@
-$Id: README 479 2007-07-27 08:51:26Z blackhedd $
+$Id: README 668 2008-01-04 23:00:34Z blackhedd $
 
 = RUBY/EventMachine
 

data/RELEASE_NOTES

@@ -1,4 +1,4 @@
-$Id: RELEASE_NOTES 388 2007-06-25 02:06:05Z blackhedd $
+$Id: RELEASE_NOTES 668 2008-01-04 23:00:34Z blackhedd $
 
 RUBY/EventMachine RELEASE NOTES
 

data/SMTP

@@ -1,4 +1,4 @@
-$Id: SMTP 539 2007-09-17 14:42:52Z blackhedd $
+$Id: SMTP 668 2008-01-04 23:00:34Z blackhedd $
 
 
 [DOCUMENT UNDER CONSTRUCTION]

data/SPAWNED_PROCESSES

@@ -1,4 +1,4 @@
-$Id: SPAWNED_PROCESSES 538 2007-09-17 14:38:56Z blackhedd $
+$Id: SPAWNED_PROCESSES 668 2008-01-04 23:00:34Z blackhedd $
 
 [DOCUMENT UNDER CONSTRUCTION]
 

data/TODO

@@ -1,4 +1,4 @@
-$Id: TODO 231 2006-08-13 17:15:53Z blackhedd $
+$Id: TODO 668 2008-01-04 23:00:34Z blackhedd $
 
 TODO List:
 

data/ext/binder.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: binder.cpp 318 2007-05-22 22:06:24Z blackhedd $
+$Id: binder.cpp 668 2008-01-04 23:00:34Z blackhedd $
 
 File:     binder.cpp
 Date:     07Apr06

data/ext/binder.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: binder.h 318 2007-05-22 22:06:24Z blackhedd $
+$Id: binder.h 668 2008-01-04 23:00:34Z blackhedd $
 
 File:     binder.h
 Date:     07Apr06

data/ext/cmain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: cmain.cpp 585 2007-11-27 14:29:34Z blackhedd $
+$Id: cmain.cpp 679 2008-01-19 01:40:06Z blackhedd $
 
 File:     cmain.cpp
 Date:     06Apr06
@@ -22,6 +22,7 @@ See the file COPYING for complete licensing information.
 
 static EventMachine_t *EventMachine;
 static int bUseEpoll = 0;
+static int bUseKqueue = 0;
 
 
 /***********************
@@ -38,6 +39,8 @@ extern "C" void evma_initialize_library (void(*cb)(const char*, int, const char*
 	EventMachine = new EventMachine_t (cb);
 	if (bUseEpoll)
 		EventMachine->_UseEpoll();
+	if (bUseKqueue)
+		EventMachine->_UseKqueue();
 }
 
 
@@ -259,6 +262,22 @@ extern "C" int evma_get_peername (const char *binding, struct sockaddr *sa)
 		return 0;
 }
 
+/*****************
+evma_get_sockname
+*****************/
+
+extern "C" int evma_get_sockname (const char *binding, struct sockaddr *sa)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetSockname (sa) ? 1 : 0;
+	}
+	else
+		return 0;
+}
+
 /***********************
 evma_get_subprocess_pid
 ***********************/
@@ -418,6 +437,15 @@ extern "C" void evma__epoll()
 	bUseEpoll = 1;
 }
 
+/************
+evma__kqueue
+************/
+
+extern "C" void evma__kqueue()
+{
+	bUseKqueue = 1;
+}
+
 
 /**********************
 evma_set_rlimit_nofile

data/ext/cplusplus.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: cplusplus.cpp 505 2007-08-26 20:44:57Z blackhedd $
+$Id: cplusplus.cpp 668 2008-01-04 23:00:34Z blackhedd $
 
 File:     cplusplus.cpp
 Date:     27Jul07

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 572 2007-11-15 23:13:45Z blackhedd $
+$Id: ed.cpp 687 2008-05-15 14:28:32Z francis $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -187,6 +187,9 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = EPOLLOUT;
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueWriter (this);
+	#endif
 }
 
 
@@ -321,6 +324,9 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueWriter (this);
+	#endif
 	return length;
 }
 
@@ -531,6 +537,12 @@ void ConnectionDescriptor::Write()
 			// The callback may have scheduled outbound data.
 			EpollEvent.events = EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0);
 			#endif
+			#ifdef HAVE_KQUEUE
+			MyEventMachine->ArmKqueueReader (this);
+			// The callback may have scheduled outbound data.
+			if (SelectForWrite())
+				MyEventMachine->ArmKqueueWriter (this);
+			#endif
 		}
 		else
 			ScheduleClose (false);
@@ -614,6 +626,10 @@ void ConnectionDescriptor::_WriteOutboundData()
 		assert (MyEventMachine);
 		MyEventMachine->Modify (this);
 		#endif
+		#ifdef HAVE_KQUEUE
+		if (SelectForWrite())
+			MyEventMachine->ArmKqueueWriter (this);
+		#endif
 	}
 	else {
 		#ifdef OS_UNIX
@@ -797,6 +813,9 @@ LoopbreakDescriptor::LoopbreakDescriptor (int sd, EventMachine_t *parent_em):
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = EPOLLIN;
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueReader (this);
+	#endif
 }
 
 
@@ -834,6 +853,9 @@ AcceptorDescriptor::AcceptorDescriptor (int sd, EventMachine_t *parent_em):
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = EPOLLIN;
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueReader (this);
+	#endif
 }
 
 
@@ -922,6 +944,11 @@ void AcceptorDescriptor::Read()
 		#endif
 		assert (MyEventMachine);
 		MyEventMachine->Add (cd);
+		#ifdef HAVE_KQUEUE
+		if (cd->SelectForWrite())
+			MyEventMachine->ArmKqueueWriter (cd);
+		MyEventMachine->ArmKqueueReader (cd);
+		#endif
 	}
 
 }
@@ -948,6 +975,22 @@ void AcceptorDescriptor::Heartbeat()
 }
 
 
+/*******************************
+AcceptorDescriptor::GetSockname
+*******************************/
+
+bool AcceptorDescriptor::GetSockname (struct sockaddr *s)
+{
+	bool ok = false;
+	if (s) {
+		socklen_t len = sizeof(*s);
+		int gp = getsockname (GetSocket(), s, &len);
+		if (gp == 0)
+			ok = true;
+	}
+	return ok;
+}
+
 
 
 /**************************************
@@ -986,6 +1029,9 @@ DatagramDescriptor::DatagramDescriptor (int sd, EventMachine_t *parent_em):
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = EPOLLIN;
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueReader (this);
+	#endif
 }
 
 
@@ -1273,6 +1319,22 @@ bool ConnectionDescriptor::GetPeername (struct sockaddr *s)
 	return ok;
 }
 
+/*********************************
+ConnectionDescriptor::GetSockname
+*********************************/
+
+bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
+{
+	bool ok = false;
+	if (s) {
+		socklen_t len = sizeof(*s);
+		int gp = getsockname (GetSocket(), s, &len);
+		if (gp == 0)
+			ok = true;
+	}
+	return ok;
+}
+
 
 /**********************************************
 ConnectionDescriptor::GetCommInactivityTimeout
@@ -1333,6 +1395,22 @@ bool DatagramDescriptor::GetPeername (struct sockaddr *s)
 	return ok;
 }
 
+/*******************************
+DatagramDescriptor::GetSockname
+*******************************/
+
+bool DatagramDescriptor::GetSockname (struct sockaddr *s)
+{
+	bool ok = false;
+	if (s) {
+		socklen_t len = sizeof(*s);
+		int gp = getsockname (GetSocket(), s, &len);
+		if (gp == 0)
+			ok = true;
+	}
+	return ok;
+}
+
 
 
 /********************************************

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 585 2007-11-27 14:29:34Z blackhedd $
+$Id: ed.h 687 2008-05-15 14:28:32Z francis $
 
 File:     ed.h
 Date:     06Apr06
@@ -62,6 +62,7 @@ class EventableDescriptor: public Bindable_t
 		void SetEventCallback (void (*cb)(const char*, int, const char*, int));
 
 		virtual bool GetPeername (struct sockaddr*) {return false;}
+		virtual bool GetSockname (struct sockaddr*) {return false;}
 		virtual bool GetSubprocessPid (pid_t*) {return false;}
 
 		virtual void StartTls() {}
@@ -154,6 +155,7 @@ class ConnectionDescriptor: public EventableDescriptor
 		void SetServerMode() {bIsServer = true;}
 
 		virtual bool GetPeername (struct sockaddr*);
+		virtual bool GetSockname (struct sockaddr*);
 
 		virtual int GetCommInactivityTimeout (int *value);
 		virtual int SetCommInactivityTimeout (int *value);
@@ -220,6 +222,7 @@ class DatagramDescriptor: public EventableDescriptor
 		virtual int GetOutboundDataSize() {return OutboundDataSize;}
 
 		virtual bool GetPeername (struct sockaddr*);
+		virtual bool GetSockname (struct sockaddr*);
 
     virtual int GetCommInactivityTimeout (int *value);
     virtual int SetCommInactivityTimeout (int *value);
@@ -264,6 +267,8 @@ class AcceptorDescriptor: public EventableDescriptor
 		virtual bool SelectForRead() {return true;}
 		virtual bool SelectForWrite() {return false;}
 
+		virtual bool GetSockname (struct sockaddr*);
+
 		static void StopAcceptor (const char *binding);
 };
 

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 587 2007-12-01 13:50:32Z blackhedd $
+$Id: em.cpp 686 2008-05-14 21:21:10Z francis $
 
 File:     em.cpp
 Date:     06Apr06
@@ -40,6 +40,11 @@ unsigned gLastTickCount;
 static int MaxOutstandingTimers = 1000;
 
 
+/* Internal helper to convert strings to internet addresses. IPv6-aware.
+ * Not reentrant or threadsafe, optimized for speed.
+ */
+static struct sockaddr *name2address (const char *server, int port, int *family, int *bind_size);
+
 
 /***************************************
 STATIC EventMachine_t::SetMaxTimerCount
@@ -71,6 +76,7 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	LoopBreakerReader (-1),
 	LoopBreakerWriter (-1),
 	bEpoll (false),
+	bKqueue (false),
 	epfd (-1)
 {
 	// Default time-slice is just smaller than one hundred mills.
@@ -115,6 +121,8 @@ EventMachine_t::~EventMachine_t()
 
 	if (epfd != -1)
 		close (epfd);
+	if (kqfd != -1)
+		close (kqfd);
 }
 
 
@@ -136,6 +144,21 @@ void EventMachine_t::_UseEpoll()
 	#endif
 }
 
+/**************************
+EventMachine_t::_UseKqueue
+**************************/
+
+void EventMachine_t::_UseKqueue()
+{
+	/* Temporary.
+	 * See comments under _UseEpoll.
+	 */
+
+	#ifdef HAVE_KQUEUE
+	bKqueue = true;
+	#endif
+}
+
 
 /****************************
 EventMachine_t::ScheduleHalt
@@ -337,6 +360,23 @@ void EventMachine_t::Run()
 	}
 	#endif
 
+	#ifdef HAVE_KQUEUE
+	if (bKqueue) {
+		kqfd = kqueue();
+		if (kqfd == -1) {
+			char buf[200];
+			snprintf (buf, sizeof(buf)-1, "unable to create kqueue descriptor: %s", strerror(errno));
+			throw std::runtime_error (buf);
+		}
+		// cloexec not needed. By definition, kqueues are not carried across forks.
+
+		assert (LoopBreakerReader >= 0);
+		LoopbreakDescriptor *ld = new LoopbreakDescriptor (LoopBreakerReader, this);
+		assert (ld);
+		Add (ld);
+	}
+	#endif
+
 	while (true) {
 		gCurrentLoopTime = time(NULL);
 		if (!_RunTimers())
@@ -369,6 +409,8 @@ bool EventMachine_t::_RunOnce()
 {
 	if (bEpoll)
 		return _RunEpollOnce();
+	else if (bKqueue)
+		return _RunKqueueOnce();
 	else
 		return _RunSelectOnce();
 }
@@ -384,7 +426,7 @@ bool EventMachine_t::_RunEpollOnce()
 	#ifdef HAVE_EPOLL
 	assert (epfd != -1);
 	struct epoll_event ev [MaxEpollDescriptors];
-	int s = epoll_wait (epfd, ev, MaxEpollDescriptors, 10);
+	int s = epoll_wait (epfd, ev, MaxEpollDescriptors, 50);
 	if (s > 0) {
 		for (int i=0; i < s; i++) {
 			EventableDescriptor *ed = (EventableDescriptor*) ev[i].data.ptr;
@@ -413,20 +455,30 @@ bool EventMachine_t::_RunEpollOnce()
 		// vector::pop_back works in constant time.
 		// TODO, rip this out and only delete the descriptors we know have died,
 		// rather than traversing the whole list.
+		//  Modified 05Jan08 per suggestions by Chris Heath. It's possible that
+		//  an EventableDescriptor will have a descriptor value of -1. That will
+		//  happen if EventableDescriptor::Close was called on it. In that case,
+		//  don't call epoll_ctl to remove the socket's filters from the epoll set.
+		//  According to the epoll docs, this happens automatically when the
+		//  descriptor is closed anyway. This is different from the case where
+		//  the socket has already been closed but the descriptor in the ED object
+		//  hasn't yet been set to INVALID_SOCKET.
 		int i, j;
 		int nSockets = Descriptors.size();
 		for (i=0, j=0; i < nSockets; i++) {
 			EventableDescriptor *ed = Descriptors[i];
 			assert (ed);
 			if (ed->ShouldDelete()) {
-				assert (bEpoll); // wouldn't be in this method otherwise.
-				assert (epfd != -1);
-				int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
-				// ENOENT is not an error because the socket may be already closed when we get here.
-				if (e && (e != ENOENT)) {
-					char buf [200];
-					snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
-					throw std::runtime_error (buf);
+				if (ed->GetSocket() != INVALID_SOCKET) {
+					assert (bEpoll); // wouldn't be in this method otherwise.
+					assert (epfd != -1);
+					int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
+					// ENOENT or EBADF are not errors because the socket may be already closed when we get here.
+					if (e && (errno != ENOENT) && (errno != EBADF)) {
+						char buf [200];
+						snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
+						throw std::runtime_error (buf);
+					}
 				}
 
 				ModifiedDescriptors.erase (ed);
@@ -469,6 +521,82 @@ bool EventMachine_t::_RunEpollOnce()
 }
 
 
+/******************************
+EventMachine_t::_RunKqueueOnce
+******************************/
+
+bool EventMachine_t::_RunKqueueOnce()
+{
+	#ifdef HAVE_KQUEUE
+	assert (kqfd != -1);
+	const int maxKevents = 2000;
+	struct kevent Karray [maxKevents];
+	struct timespec ts = {0, 10000000}; // Too frequent. Use blocking_region
+
+	int k = kevent (kqfd, NULL, 0, Karray, maxKevents, &ts);
+	struct kevent *ke = Karray;
+	while (k > 0) {
+		EventableDescriptor *ed = (EventableDescriptor*) (ke->udata);
+		assert (ed);
+
+		if (ke->filter == EVFILT_READ)
+			ed->Read();
+		else if (ke->filter == EVFILT_WRITE)
+			ed->Write();
+		else
+			cerr << "Discarding unknown kqueue event " << ke->filter << endl;
+
+		--k;
+		++ke;
+	}
+
+	{ // cleanup dying sockets
+		// vector::pop_back works in constant time.
+		// TODO, rip this out and only delete the descriptors we know have died,
+		// rather than traversing the whole list.
+		// In kqueue, closing a descriptor automatically removes its event filters.
+
+		int i, j;
+		int nSockets = Descriptors.size();
+		for (i=0, j=0; i < nSockets; i++) {
+			EventableDescriptor *ed = Descriptors[i];
+			assert (ed);
+			if (ed->ShouldDelete()) {
+				ModifiedDescriptors.erase (ed);
+				delete ed;
+			}
+			else
+				Descriptors [j++] = ed;
+		}
+		while ((size_t)j < Descriptors.size())
+			Descriptors.pop_back();
+
+	}
+
+	{ // dispatch heartbeats
+		if (gCurrentLoopTime >= NextHeartbeatTime) {
+			NextHeartbeatTime = gCurrentLoopTime + HeartbeatInterval;
+
+			for (int i=0; i < Descriptors.size(); i++) {
+				EventableDescriptor *ed = Descriptors[i];
+				assert (ed);
+				ed->Heartbeat();
+			}
+		}
+	}
+
+
+	// TODO, replace this with rb_thread_blocking_region for 1.9 builds.
+	timeval tv = {0,0};
+	EmSelect (0, NULL, NULL, NULL, &tv);
+
+	return true;
+	#else
+	throw std::runtime_error ("kqueue is not implemented on this platform");
+	#endif
+}
+
+
 /*********************************
 EventMachine_t::_ModifyEpollEvent
 *********************************/
@@ -490,6 +618,48 @@ void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed)
 }
 
 
+
+/**************************
+SelectData_t::SelectData_t
+**************************/
+
+SelectData_t::SelectData_t()
+{
+	maxsocket = 0;
+	FD_ZERO (&fdreads);
+	FD_ZERO (&fdwrites);
+}
+
+
+/*****************
+_SelectDataSelect
+*****************/
+
+static VALUE _SelectDataSelect (void *v)
+{
+	SelectData_t *sd = (SelectData_t*)v;
+	sd->nSockets = select (sd->maxsocket+1, &(sd->fdreads), &(sd->fdwrites), NULL, &(sd->tv));
+	return Qnil;
+}
+
+/*********************
+SelectData_t::_Select
+*********************/
+
+int SelectData_t::_Select()
+{
+	#ifdef HAVE_TBR
+	rb_thread_blocking_region (_SelectDataSelect, (void*)this, RB_UBF_DFL, 0);
+	return nSockets;
+	#endif
+
+	#ifndef HAVE_TBR
+	return rb_thread_select (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
+	#endif
+}
+
+
+
 /******************************
 EventMachine_t::_RunSelectOnce
 ******************************/
@@ -525,20 +695,23 @@ bool EventMachine_t::_RunSelectOnce()
 	}
 	*/
 
+	SelectData_t SelectData;
+	/*
 	fd_set fdreads, fdwrites;
 	FD_ZERO (&fdreads);
 	FD_ZERO (&fdwrites);
 
 	int maxsocket = 0;
+	*/
 
 	// Always read the loop-breaker reader.
 	// Changed 23Aug06, provisionally implemented for Windows with a UDP socket
 	// running on localhost with a randomly-chosen port. (*Puke*)
 	// Windows has a version of the Unix pipe() library function, but it doesn't
 	// give you back descriptors that are selectable.
-	FD_SET (LoopBreakerReader, &fdreads);
-	if (maxsocket < LoopBreakerReader)
-		maxsocket = LoopBreakerReader;
+	FD_SET (LoopBreakerReader, &(SelectData.fdreads));
+	if (SelectData.maxsocket < LoopBreakerReader)
+		SelectData.maxsocket = LoopBreakerReader;
 
 	// prepare the sockets for reading and writing
 	size_t i;
@@ -549,19 +722,23 @@ bool EventMachine_t::_RunSelectOnce()
 		assert (sd != INVALID_SOCKET);
 
 		if (ed->SelectForRead())
-			FD_SET (sd, &fdreads);
+			FD_SET (sd, &(SelectData.fdreads));
 		if (ed->SelectForWrite())
-			FD_SET (sd, &fdwrites);
+			FD_SET (sd, &(SelectData.fdwrites));
 
-		if (maxsocket < sd)
-			maxsocket = sd;
+		if (SelectData.maxsocket < sd)
+			SelectData.maxsocket = sd;
 	}
 
 
 	{ // read and write the sockets
 		//timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
-		timeval tv = Quantum;
-		int s = EmSelect (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
+		//timeval tv = Quantum;
+		SelectData.tv = Quantum;
+		int s = SelectData._Select();
+		//rb_thread_blocking_region(xxx,(void*)&SelectData,RB_UBF_DFL,0);
+		//int s = EmSelect (SelectData.maxsocket+1, &(SelectData.fdreads), &(SelectData.fdwrites), NULL, &(SelectData.tv));
+		//int s = SelectData.nSockets;
 		if (s > 0) {
 			/* Changed 01Jun07. We used to handle the Loop-breaker right here.
 			 * Now we do it AFTER all the regular descriptors. There's an
@@ -579,13 +756,13 @@ bool EventMachine_t::_RunSelectOnce()
 				int sd = ed->GetSocket();
 				assert (sd != INVALID_SOCKET);
 
-				if (FD_ISSET (sd, &fdwrites))
+				if (FD_ISSET (sd, &(SelectData.fdwrites)))
 					ed->Write();
-				if (FD_ISSET (sd, &fdreads))
+				if (FD_ISSET (sd, &(SelectData.fdreads)))
 					ed->Read();
 			}
 
-			if (FD_ISSET (LoopBreakerReader, &fdreads))
+			if (FD_ISSET (LoopBreakerReader, &(SelectData.fdreads)))
 				_ReadLoopBreaker();
 		}
 		else if (s < 0) {
@@ -758,6 +935,16 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	if (!server || !*server || !port)
 		return NULL;
 
+	int family, bind_size;
+	struct sockaddr *bind_as = name2address (server, port, &family, &bind_size);
+	if (!bind_as)
+		return NULL;
+
+	int sd = socket (family, SOCK_STREAM, 0);
+	if (sd == INVALID_SOCKET)
+		return NULL;
+
+	/*
 	sockaddr_in pin;
 	unsigned long HostAddr;
 
@@ -783,6 +970,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	int sd = socket (AF_INET, SOCK_STREAM, 0);
 	if (sd == INVALID_SOCKET)
 		return NULL;
+	*/
 
 	// From here on, ALL error returns must close the socket.
 	// Set the new socket nonblocking.
@@ -790,11 +978,15 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 		closesocket (sd);
 		return NULL;
 	}
+	// Disable slow-start (Nagle algorithm).
+	int one = 1;
+	setsockopt (sd, IPPROTO_TCP, TCP_NODELAY, (char*) &one, sizeof(one));
 
 	const char *out = NULL;
 
 	#ifdef OS_UNIX
-	if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
+	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
+	if (connect (sd, bind_as, bind_size) == 0) {
 		// This is a connect success, which Linux appears
 		// never to give when the socket is nonblocking,
 		// even if the connection is intramachine or to
@@ -866,7 +1058,8 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	#endif
 
 	#ifdef OS_WIN32
-	if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
+	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
+	if (connect (sd, bind_as, bind_size) == 0) {
 		// This is a connect success, which Windows appears
 		// never to give when the socket is nonblocking,
 		// even if the connection is intramachine or to
@@ -971,6 +1164,71 @@ const char *EventMachine_t::ConnectToUnixServer (const char *server)
 }
 
 
+/************
+name2address
+************/
+
+struct sockaddr *name2address (const char *server, int port, int *family, int *bind_size)
+{
+	// THIS IS NOT RE-ENTRANT OR THREADSAFE. Optimize for speed.
+	// Check the more-common cases first.
+	// Return NULL if no resolution.
+
+	static struct sockaddr_in in4;
+	static struct sockaddr_in6 in6;
+	struct hostent *hp;
+
+	if (!server || !*server)
+		server = "0.0.0.0";
+
+	memset (&in4, 0, sizeof(in4));
+	if ( (in4.sin_addr.s_addr = inet_addr (server)) != INADDR_NONE) {
+		if (family)
+			*family = AF_INET;
+		if (bind_size)
+			*bind_size = sizeof(in4);
+		in4.sin_family = AF_INET;
+		in4.sin_port = htons (port);
+		return (struct sockaddr*)&in4;
+	}
+
+	#ifdef OS_UNIX
+	memset (&in6, 0, sizeof(in6));
+	if (inet_pton (AF_INET6, server, in6.sin6_addr.s6_addr) > 0) {
+		if (family)
+			*family = AF_INET6;
+		if (bind_size)
+			*bind_size = sizeof(in6);
+		in6.sin6_family = AF_INET6;
+		in6.sin6_port = htons (port);
+		return (struct sockaddr*)&in6;
+	}
+	#endif
+
+	#ifdef OS_WIN32
+	// TODO, must complete this branch. Windows doesn't have inet_pton.
+	// A possible approach is to make a getaddrinfo call with the supplied
+	// server address, constraining the hints to ipv6 and seeing if we
+	// get any addresses.
+	// For the time being, Ipv6 addresses aren't supported on Windows.
+	#endif
+
+	hp = gethostbyname ((char*)server); // Windows requires the cast.
+	if (hp) {
+		in4.sin_addr.s_addr = ((in_addr*)(hp->h_addr))->s_addr;
+		if (family)
+			*family = AF_INET;
+		if (bind_size)
+			*bind_size = sizeof(in4);
+		in4.sin_family = AF_INET;
+		in4.sin_port = htons (port);
+		return (struct sockaddr*)&in4;
+	}
+
+	return NULL;
+}
+
+
 /*******************************
 EventMachine_t::CreateTcpServer
 *******************************/
@@ -983,15 +1241,22 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 	 * to indicate accepted connections.
 	 */
 
+
+	int family, bind_size;
+	struct sockaddr *bind_here = name2address (server, port, &family, &bind_size);
+	if (!bind_here)
+		return NULL;
+
 	const char *output_binding = NULL;
 
-	struct sockaddr_in sin;
+	//struct sockaddr_in sin;
 
-	int sd_accept = socket (AF_INET, SOCK_STREAM, 0);
+	int sd_accept = socket (family, SOCK_STREAM, 0);
 	if (sd_accept == INVALID_SOCKET) {
 		goto fail;
 	}
 
+	/*
 	memset (&sin, 0, sizeof(sin));
 	sin.sin_family = AF_INET;
 	sin.sin_addr.s_addr = INADDR_ANY;
@@ -1008,6 +1273,7 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 			sin.sin_addr.s_addr = ((in_addr*)(hp->h_addr))->s_addr;
 		}
 	}
+	*/
 
 	{ // set reuseaddr to improve performance on restarts.
 		int oval = 1;
@@ -1027,7 +1293,8 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 	}
 
 
-	if (bind (sd_accept, (struct sockaddr*)&sin, sizeof(sin))) {
+	//if (bind (sd_accept, (struct sockaddr*)&sin, sizeof(sin))) {
+	if (bind (sd_accept, bind_here, bind_size)) {
 		//__warning ("binding failed");
 		goto fail;
 	}
@@ -1139,6 +1406,42 @@ void EventMachine_t::Add (EventableDescriptor *ed)
 }
 
 
+/*******************************
+EventMachine_t::ArmKqueueWriter
+*******************************/
+
+void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed)
+{
+	#ifdef HAVE_KQUEUE
+	if (bKqueue) {
+		if (!ed)
+			throw std::runtime_error ("added bad descriptor");
+		struct kevent k;
+		EV_SET (&k, ed->GetSocket(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, ed);
+		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
+		assert (t == 0);
+	}
+	#endif
+}
+
+/*******************************
+EventMachine_t::ArmKqueueReader
+*******************************/
+
+void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed)
+{
+	#ifdef HAVE_KQUEUE
+	if (bKqueue) {
+		if (!ed)
+			throw std::runtime_error ("added bad descriptor");
+		struct kevent k;
+		EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, ed);
+		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
+		assert (t == 0);
+	}
+	#endif
+}
+
 /**********************************
 EventMachine_t::_AddNewDescriptors
 **********************************/
@@ -1173,6 +1476,19 @@ void EventMachine_t::_AddNewDescriptors()
 		}
 		#endif
 
+		#if HAVE_KQUEUE
+		/*
+		if (bKqueue) {
+			// INCOMPLETE. Some descriptors don't want to be readable.
+			assert (kqfd != -1);
+			struct kevent k;
+			EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, ed);
+			int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
+			assert (t == 0);
+		}
+		*/
+		#endif
+
 		Descriptors.push_back (ed);
 	}
 	NewDescriptors.clear();