smparkes-eventmachine 0.12.10.2 → 0.12.10.3

data/ext/ed.h

@@ -75,10 +75,10 @@ class EventableDescriptor: public Bindable_t
 		virtual X509 *GetPeerCert() {return NULL;}
 		#endif
 
-		virtual float GetCommInactivityTimeout() {return 0.0;}
-		virtual int SetCommInactivityTimeout (float value) {return 0;}
-		float GetPendingConnectTimeout();
-		int SetPendingConnectTimeout (float value);
+		virtual uint64_t GetCommInactivityTimeout() {return 0;}
+		virtual int SetCommInactivityTimeout (uint64_t value) {return 0;}
+		uint64_t GetPendingConnectTimeout();
+		int SetPendingConnectTimeout (uint64_t value);
 
 		#ifdef HAVE_EPOLL
 		struct epoll_event *GetEpollEvent() { return &EpollEvent; }
@@ -92,6 +92,10 @@ class EventableDescriptor: public Bindable_t
 		virtual bool Pause(){ return false; }
 		virtual bool Resume(){ return false; }
 
+		virtual int ReportErrorStatus(){ return 0; }
+		virtual bool IsConnectPending(){ return false; }
+		virtual uint64_t GetNextHeartbeat();
+
 	private:
 		bool bCloseNow;
 		bool bCloseAfterWriting;
@@ -102,7 +106,7 @@ class EventableDescriptor: public Bindable_t
 		EMCallback EventCallback;
 		void _GenericInboundDispatch(const char*, int);
 
-		Int64 CreatedAt;
+		uint64_t CreatedAt;
 		bool bCallbackUnbind;
 		int UnbindReasonCode;
 		EventableDescriptor *ProxyTarget;
@@ -115,7 +119,10 @@ class EventableDescriptor: public Bindable_t
 		#endif
 
 		EventMachine_t *MyEventMachine;
-		int PendingConnectTimeout;
+		uint64_t PendingConnectTimeout;
+		uint64_t InactivityTimeout;
+		uint64_t LastActivity;
+		uint64_t NextHeartbeat;
 };
 
 
@@ -149,10 +156,6 @@ class ConnectionDescriptor: public EventableDescriptor
 		ConnectionDescriptor (int, EventMachine_t*);
 		virtual ~ConnectionDescriptor();
 
-		static int SendDataToConnection (const unsigned long, const char*, int);
-		static void CloseConnection (const unsigned long, bool);
-		static int ReportErrorStatus (const unsigned long);
-
 		int SendOutboundData (const char*, int);
 
 		void SetConnectPending (bool f);
@@ -195,9 +198,11 @@ class ConnectionDescriptor: public EventableDescriptor
 		virtual bool GetPeername (struct sockaddr*);
 		virtual bool GetSockname (struct sockaddr*);
 
-		virtual float GetCommInactivityTimeout();
-		virtual int SetCommInactivityTimeout (float value);
+		virtual uint64_t GetCommInactivityTimeout();
+		virtual int SetCommInactivityTimeout (uint64_t value);
 
+		virtual int ReportErrorStatus();
+		virtual bool IsConnectPending(){ return bConnectPending; }
 
 	protected:
 		struct OutboundPage {
@@ -236,8 +241,6 @@ class ConnectionDescriptor: public EventableDescriptor
 		#endif
 
 		bool bIsServer;
-		Int64 LastIo;
-		int InactivityTimeout;
 
 	private:
 		void _UpdateEvents();
@@ -246,7 +249,6 @@ class ConnectionDescriptor: public EventableDescriptor
 		void _DispatchInboundData (const char *buffer, int size);
 		void _DispatchCiphertext();
 		int _SendRawOutboundData (const char*, int);
-		int _ReportErrorStatus();
 		void _CheckHandshakeStatus();
 
 };
@@ -278,11 +280,8 @@ class DatagramDescriptor: public EventableDescriptor
 		virtual bool GetPeername (struct sockaddr*);
 		virtual bool GetSockname (struct sockaddr*);
 
-    virtual float GetCommInactivityTimeout();
-    virtual int SetCommInactivityTimeout (float value);
-
-		static int SendDatagram (const unsigned long, const char*, int, const char*, int);
-
+		virtual uint64_t GetCommInactivityTimeout();
+		virtual int SetCommInactivityTimeout (uint64_t value);
 
 	protected:
 		struct OutboundPage {
@@ -298,9 +297,6 @@ class DatagramDescriptor: public EventableDescriptor
 		int OutboundDataSize;
 
 		struct sockaddr_in ReturnAddress;
-
-		Int64 LastIo;
-		int InactivityTimeout;
 };
 
 
@@ -360,8 +356,6 @@ class PipeDescriptor: public EventableDescriptor
 
 	protected:
 		bool bReadAttemptedAfterClose;
-		Int64 LastIo;
-		int InactivityTimeout;
 
 		deque<OutboundPage> OutboundPages;
 		int OutboundDataSize;
@@ -393,8 +387,6 @@ class KeyboardDescriptor: public EventableDescriptor
 
 	protected:
 		bool bReadAttemptedAfterClose;
-		Int64 LastIo;
-		int InactivityTimeout;
 
 	private:
 		void _DispatchInboundData (const char *buffer, int size);

data/ext/em.cpp

@@ -22,17 +22,6 @@ See the file COPYING for complete licensing information.
 
 #include "project.h"
 
-// Keep a global variable floating around
-// with the current loop time as set by the Event Machine.
-// This avoids the need for frequent expensive calls to time(NULL);
-Int64 gCurrentLoopTime;
-
-#ifdef OS_WIN32
-unsigned gTickCountTickover;
-unsigned gLastTickCount;
-#endif
-
-
 /* The numer of max outstanding timers was once a const enum defined in em.h.
  * Now we define it here so that users can change its value if necessary.
  */
@@ -353,21 +342,76 @@ EventMachine_t::_UpdateTime
 
 void EventMachine_t::_UpdateTime()
 {
+	MyCurrentLoopTime = GetRealTime();
+}
+
+/***************************
+EventMachine_t::GetRealTime
+***************************/
+
+uint64_t EventMachine_t::GetRealTime()
+{
+	uint64_t current_time;
 	#if defined(OS_UNIX)
 	struct timeval tv;
 	gettimeofday (&tv, NULL);
-	gCurrentLoopTime = (((Int64)(tv.tv_sec)) * 1000000LL) + ((Int64)(tv.tv_usec));
+	current_time = (((uint64_t)(tv.tv_sec)) * 1000000LL) + ((uint64_t)(tv.tv_usec));
 
 	#elif defined(OS_WIN32)
 	unsigned tick = GetTickCount();
-	if (tick < gLastTickCount)
-		gTickCountTickover += 1;
-	gLastTickCount = tick;
-	gCurrentLoopTime = ((Int64)gTickCountTickover << 32) + (Int64)tick;
+	if (tick < LastTickCountCount)
+		TickCountTickover += 1;
+	LastTickCountCount = tick;
+	current_time = ((uint64_t)TickCountTickover << 32) + (uint64_t)tick;
 
 	#else
-	gCurrentLoopTime = (Int64)time(NULL) * 1000000LL;
+	current_time = (uint64_t)time(NULL) * 1000000LL;
 	#endif
+	return current_time;
+}
+
+/***********************************
+EventMachine_t::_DispatchHeartbeats
+***********************************/
+
+void EventMachine_t::_DispatchHeartbeats()
+{
+	while (true) {
+		multimap<uint64_t,EventableDescriptor*>::iterator i = Heartbeats.begin();
+		if (i == Heartbeats.end())
+			break;
+		if (i->first > MyCurrentLoopTime)
+			break;
+		EventableDescriptor *ed = i->second;
+		ed->Heartbeat();
+		QueueHeartbeat(ed);
+	}
+}
+
+/******************************
+EventMachine_t::QueueHeartbeat
+******************************/
+
+void EventMachine_t::QueueHeartbeat(EventableDescriptor *ed)
+{
+	uint64_t heartbeat = ed->GetNextHeartbeat();
+
+	if (heartbeat) {
+		#ifndef HAVE_MAKE_PAIR
+		Heartbeats.insert (multimap<uint64_t,EventableDescriptor*>::value_type (heartbeat, ed));
+		#else
+		Heartbeats.insert (make_pair (heartbeat, ed));
+		#endif
+	}
+}
+
+/******************************
+EventMachine_t::ClearHeartbeat
+******************************/
+
+void EventMachine_t::ClearHeartbeat(uint64_t key)
+{
+	Heartbeats.erase(key);
 }
 
 /*******************
@@ -447,12 +491,16 @@ EventMachine_t::_RunOnce
 
 bool EventMachine_t::_RunOnce()
 {
+	bool ret;
 	if (bEpoll)
-		return _RunEpollOnce();
+		ret = _RunEpollOnce();
 	else if (bKqueue)
-		return _RunKqueueOnce();
+		ret = _RunKqueueOnce();
 	else
-		return _RunSelectOnce();
+		ret = _RunSelectOnce();
+	_DispatchHeartbeats();
+	_CleanupSockets();
+	return ret;
 }
 
 
@@ -467,12 +515,28 @@ bool EventMachine_t::_RunEpollOnce()
 	assert (epfd != -1);
 	int s;
 
+	timeval tv = _TimeTilNextEvent();
+
 	#ifdef BUILD_FOR_RUBY
+	int ret = 0;
+	fd_set fdreads;
+
+	FD_ZERO(&fdreads);
+	FD_SET(epfd, &fdreads);
+
+	while ((ret = rb_thread_select(epfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
+		if (ret == -1) continue;
+		if (ret == 0) return true;
+	}
+
 	TRAP_BEG;
-	#endif
-	s = epoll_wait (epfd, epoll_events, MaxEvents, 50);
-	#ifdef BUILD_FOR_RUBY
+	s = epoll_wait (epfd, epoll_events, MaxEvents, 0);
 	TRAP_END;
+	#else
+	int duration = 0;
+	duration = duration + (tv.tv_sec * 1000);
+	duration = duration + (tv.tv_usec / 1000);
+	s = epoll_wait (epfd, epoll_events, MaxEvents, duration);
 	#endif
 
 	if (s > 0) {
@@ -501,72 +565,6 @@ bool EventMachine_t::_RunEpollOnce()
 		EmSelect (0, NULL, NULL, NULL, &tv);
 	}
 
-	{ // 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.
-		//  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()) {
-				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) && (errno != EPERM)) {
-						char buf [200];
-						snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
-						throw std::runtime_error (buf);
-					}
-				}
-
-				ModifiedDescriptors.erase (ed);
-				delete ed;
-			}
-			else
-				Descriptors [j++] = ed;
-		}
-		while ((size_t)j < Descriptors.size())
-			Descriptors.pop_back();
-
-	}
-
-	// TODO, heartbeats.
-	// Added 14Sep07, its absence was noted by Brian Candler. But the comment was here, indicated
-	// that this got thought about and not done when EPOLL was originally written. Was there a reason
-	// not to do it, or was it an oversight? Certainly, running a heartbeat on 50,000 connections every
-	// two seconds can get to be a real bear, especially if all we're doing is timing out dead ones.
-	// Maybe there's a better way to do this. (Or maybe it's not that expensive after all.)
-	//
-	{ // dispatch heartbeats
-		if (gCurrentLoopTime >= NextHeartbeatTime) {
-			NextHeartbeatTime = gCurrentLoopTime + HeartbeatInterval;
-
-			for (int i=0; i < Descriptors.size(); i++) {
-				EventableDescriptor *ed = Descriptors[i];
-				assert (ed);
-				ed->Heartbeat();
-			}
-		}
-	}
-
-	#ifdef BUILD_FOR_RUBY
-	if (!rb_thread_alone()) {
-		rb_thread_schedule();
-	}
-	#endif
-
 	return true;
 	#else
 	throw std::runtime_error ("epoll is not implemented on this platform");
@@ -582,15 +580,30 @@ bool EventMachine_t::_RunKqueueOnce()
 {
 	#ifdef HAVE_KQUEUE
 	assert (kqfd != -1);
-	struct timespec ts = {0, 10000000}; // Too frequent. Use blocking_region
-
 	int k;
+
+	timeval tv = _TimeTilNextEvent();
+
 	#ifdef BUILD_FOR_RUBY
+	int ret = 0;
+	fd_set fdreads;
+
+	FD_ZERO(&fdreads);
+	FD_SET(kqfd, &fdreads);
+
+	while ((ret = rb_thread_select(kqfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
+		if (ret == -1) continue;
+		if (ret == 0) return true;
+	}
+
 	TRAP_BEG;
-	#endif
-	k = kevent (kqfd, NULL, 0, Karray, MaxEvents, &ts);
-	#ifdef BUILD_FOR_RUBY
+	k = kevent (kqfd, NULL, 0, Karray, MaxEvents, NULL);
 	TRAP_END;
+	#else
+	struct timespec ts;
+	ts.tv_sec = tv.tv_sec;
+	ts.tv_nsec = tv.tv_usec * 1000;
+	k = kevent (kqfd, NULL, 0, Karray, MaxEvents, &ts);
 	#endif
 
 	struct kevent *ke = Karray;
@@ -627,42 +640,6 @@ bool EventMachine_t::_RunKqueueOnce()
 		++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 (unsigned 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.
 	#ifdef BUILD_FOR_RUBY
 	if (!rb_thread_alone()) {
@@ -677,6 +654,85 @@ bool EventMachine_t::_RunKqueueOnce()
 }
 
 
+/*********************************
+EventMachine_t::_TimeTilNextEvent
+*********************************/
+
+timeval EventMachine_t::_TimeTilNextEvent()
+{
+	uint64_t next_event = 0;
+
+	if (!Heartbeats.empty()) {
+		multimap<uint64_t,EventableDescriptor*>::iterator heartbeats = Heartbeats.begin();
+		next_event = heartbeats->first;
+	}
+
+	if (!Timers.empty()) {
+		multimap<uint64_t,Timer_t>::iterator timers = Timers.begin();
+		if (timers->first != 0 && timers->first < next_event)
+			next_event = timers->first;
+	}
+
+	timeval tv;
+
+	if (next_event == 0) {
+		tv = Quantum;
+	} else {
+		uint64_t duration = next_event - MyCurrentLoopTime;
+		tv.tv_sec = duration / 1000000;
+		tv.tv_usec = duration % 1000000;
+	}
+
+	return tv;
+}
+
+/*******************************
+EventMachine_t::_CleanupSockets
+*******************************/
+
+void EventMachine_t::_CleanupSockets()
+{
+	// 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.
+	// 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()) {
+		#ifdef HAVE_EPOLL
+			if (bEpoll) {
+				assert (epfd != -1);
+				if (ed->GetSocket() != INVALID_SOCKET) {
+					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) && (errno != EPERM)) {
+						char buf [200];
+						snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
+						throw std::runtime_error (buf);
+					}
+				}
+				ModifiedDescriptors.erase(ed);
+			}
+		#endif
+			delete ed;
+		}
+		else
+			Descriptors [j++] = ed;
+	}
+	while ((size_t)j < Descriptors.size())
+		Descriptors.pop_back();
+}
+
 /*********************************
 EventMachine_t::_ModifyEpollEvent
 *********************************/
@@ -829,7 +885,7 @@ bool EventMachine_t::_RunSelectOnce()
 	{ // read and write the sockets
 		//timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
 		//timeval tv = Quantum;
-		SelectData.tv = Quantum;
+		SelectData.tv = _TimeTilNextEvent();
 		int s = SelectData._Select();
 		//rb_thread_blocking_region(xxx,(void*)&SelectData,RUBY_UBF_IO,0);
 		//int s = EmSelect (SelectData.maxsocket+1, &(SelectData.fdreads), &(SelectData.fdwrites), NULL, &(SelectData.tv));
@@ -874,36 +930,6 @@ bool EventMachine_t::_RunSelectOnce()
 		}
 	}
 
-
-	{ // dispatch heartbeats
-		if (gCurrentLoopTime >= NextHeartbeatTime) {
-			NextHeartbeatTime = gCurrentLoopTime + HeartbeatInterval;
-
-			for (i=0; i < Descriptors.size(); i++) {
-				EventableDescriptor *ed = Descriptors[i];
-				assert (ed);
-				ed->Heartbeat();
-			}
-		}
-	}
-
-	{ // cleanup dying sockets
-		// vector::pop_back works in constant time.
-		int i, j;
-		int nSockets = Descriptors.size();
-		for (i=0, j=0; i < nSockets; i++) {
-			EventableDescriptor *ed = Descriptors[i];
-			assert (ed);
-			if (ed->ShouldDelete())
-				delete ed;
-			else
-				Descriptors [j++] = ed;
-		}
-		while ((size_t)j < Descriptors.size())
-			Descriptors.pop_back();
-
-	}
-
 	return true;
 }
 
@@ -921,7 +947,7 @@ void EventMachine_t::_ReadLoopBreaker()
 	char buffer [1024];
 	read (LoopBreakerReader, buffer, sizeof(buffer));
 	if (EventCallback)
-		(*EventCallback)(NULL, EM_LOOPBREAK_SIGNAL, "", 0);
+		(*EventCallback)(0, EM_LOOPBREAK_SIGNAL, "", 0);
 }
 
 
@@ -939,13 +965,13 @@ bool EventMachine_t::_RunTimers()
 	// one that hasn't expired yet.
 
 	while (true) {
-		multimap<Int64,Timer_t>::iterator i = Timers.begin();
+		multimap<uint64_t,Timer_t>::iterator i = Timers.begin();
 		if (i == Timers.end())
 			break;
-		if (i->first > gCurrentLoopTime)
+		if (i->first > MyCurrentLoopTime)
 			break;
 		if (EventCallback)
-			(*EventCallback) (NULL, EM_TIMER_FIRED, NULL, i->second.GetBinding());
+			(*EventCallback) (0, EM_TIMER_FIRED, NULL, i->second.GetBinding());
 		Timers.erase (i);
 	}
 	return true;
@@ -964,28 +990,31 @@ const unsigned long EventMachine_t::InstallOneshotTimer (int milliseconds)
 	// Don't use the global loop-time variable here, because we might
 	// get called before the main event machine is running.
 
+	// XXX This should be replaced with a call to _GetRealTime(), but I don't
+	// understand if this is a bug or not? For OS_UNIX we multiply the argument
+	// milliseconds by 1000, but for OS_WIN32 we do not? This needs to be sorted out.
 	#ifdef OS_UNIX
 	struct timeval tv;
 	gettimeofday (&tv, NULL);
-	Int64 fire_at = (((Int64)(tv.tv_sec)) * 1000000LL) + ((Int64)(tv.tv_usec));
-	fire_at += ((Int64)milliseconds) * 1000LL;
+	uint64_t fire_at = (((uint64_t)(tv.tv_sec)) * 1000000LL) + ((uint64_t)(tv.tv_usec));
+	fire_at += ((uint64_t)milliseconds) * 1000LL;
 	#endif
 
 	#ifdef OS_WIN32
 	unsigned tick = GetTickCount();
-	if (tick < gLastTickCount)
-		gTickCountTickover += 1;
-	gLastTickCount = tick;
+	if (tick < LastTickCountCount)
+		TickCountTickover += 1;
+	LastTickCountCount = tick;
 
-	Int64 fire_at = ((Int64)gTickCountTickover << 32) + (Int64)tick;
-	fire_at += (Int64)milliseconds;
+	uint64_t fire_at = ((uint64_t)TickCountTickover << 32) + (uint64_t)tick;
+	fire_at += (uint64_t)milliseconds;
 	#endif
 
 	Timer_t t;
 	#ifndef HAVE_MAKE_PAIR
-	multimap<Int64,Timer_t>::iterator i = Timers.insert (multimap<Int64,Timer_t>::value_type (fire_at, t));
+	multimap<uint64_t,Timer_t>::iterator i = Timers.insert (multimap<uint64_t,Timer_t>::value_type (fire_at, t));
 	#else
-	multimap<Int64,Timer_t>::iterator i = Timers.insert (make_pair (fire_at, t));
+	multimap<uint64_t,Timer_t>::iterator i = Timers.insert (make_pair (fire_at, t));
 	#endif
 	return i->second.GetBinding();
 }
@@ -1086,7 +1115,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 		}
 	}
 
-	unsigned long out = NULL;
+	unsigned long out = 0;
 
 	#ifdef OS_UNIX
 	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
@@ -1215,10 +1244,10 @@ const unsigned long EventMachine_t::ConnectToUnixServer (const char *server)
 	// The whole rest of this function is only compiled on Unix systems.
 	#ifdef OS_UNIX
 
-	unsigned long out = NULL;
+	unsigned long out = 0;
 
 	if (!server || !*server)
-		return NULL;
+		return 0;
 
 	sockaddr_un pun;
 	memset (&pun, 0, sizeof(pun));
@@ -1234,19 +1263,19 @@ const unsigned long EventMachine_t::ConnectToUnixServer (const char *server)
 
 	int fd = socket (AF_LOCAL, SOCK_STREAM, 0);
 	if (fd == INVALID_SOCKET)
-		return NULL;
+		return 0;
 
 	// From here on, ALL error returns must close the socket.
 	// NOTE: At this point, the socket is still a blocking socket.
 	if (connect (fd, (struct sockaddr*)&pun, sizeof(pun)) != 0) {
 		closesocket (fd);
-		return NULL;
+		return 0;
 	}
 
 	// Set the newly-connected socket nonblocking.
 	if (!SetSocketNonblocking (fd)) {
 		closesocket (fd);
-		return NULL;
+		return 0;
 	}
 
 	// Set up a connection descriptor and add it to the event-machine.
@@ -1450,9 +1479,9 @@ const unsigned long EventMachine_t::CreateTcpServer (const char *server, int por
 	int family, bind_size;
 	struct sockaddr *bind_here = name2address (server, port, &family, &bind_size);
 	if (!bind_here)
-		return NULL;
+		return 0;
 
-	unsigned long output_binding = NULL;
+	unsigned long output_binding = 0;
 
 	//struct sockaddr_in sin;
 
@@ -1532,7 +1561,7 @@ const unsigned long EventMachine_t::CreateTcpServer (const char *server, int por
 	fail:
 	if (sd_accept != INVALID_SOCKET)
 		closesocket (sd_accept);
-	return NULL;
+	return 0;
 }
 
 
@@ -1542,7 +1571,7 @@ EventMachine_t::OpenDatagramSocket
 
 const unsigned long EventMachine_t::OpenDatagramSocket (const char *address, int port)
 {
-	unsigned long output_binding = NULL;
+	unsigned long output_binding = 0;
 
 	int sd = socket (AF_INET, SOCK_DGRAM, 0);
 	if (sd == INVALID_SOCKET)
@@ -1593,7 +1622,7 @@ const unsigned long EventMachine_t::OpenDatagramSocket (const char *address, int
 	fail:
 	if (sd != INVALID_SOCKET)
 		closesocket (sd);
-	return NULL;
+	return 0;
 }
 
 
@@ -1702,6 +1731,7 @@ void EventMachine_t::_AddNewDescriptors()
 		*/
 		#endif
 
+		QueueHeartbeat(ed);
 		Descriptors.push_back (ed);
 	}
 	NewDescriptors.clear();
@@ -1770,7 +1800,7 @@ const unsigned long EventMachine_t::_OpenFileForWriting (const char *filename)
 	 */
 
 	if (!filename || !*filename)
-		return NULL;
+		return 0;
 
   int fd = open (filename, O_CREAT|O_TRUNC|O_WRONLY|O_NONBLOCK, 0644);
   
@@ -1802,7 +1832,7 @@ const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename
 
 	// The whole rest of this function is only compiled on Unix systems.
 	#ifdef OS_UNIX
-	unsigned long output_binding = NULL;
+	unsigned long output_binding = 0;
 
 	struct sockaddr_un s_sun;
 
@@ -1863,7 +1893,7 @@ const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename
 	fail:
 	if (sd_accept != INVALID_SOCKET)
 		closesocket (sd_accept);
-	return NULL;
+	return 0;
 	#endif // OS_UNIX
 }
 
@@ -1924,18 +1954,18 @@ const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings)
 	#ifdef OS_UNIX
 	// Make sure the incoming array of command strings is sane.
 	if (!cmd_strings)
-		return NULL;
+		return 0;
 	int j;
-	for (j=0; j < 100 && cmd_strings[j]; j++)
+	for (j=0; cmd_strings[j]; j++)
 		;
-	if ((j==0) || (j==100))
+	if (j==0)
 		return NULL;
 
-	unsigned long output_binding = NULL;
+	unsigned long output_binding = 0;
 
 	int sv[2];
 	if (socketpair (AF_LOCAL, SOCK_STREAM, 0, sv) < 0)
-		return NULL;
+		return 0;
 	// from here, all early returns must close the pair of sockets.
 
 	// Set the parent side of the socketpair nonblocking.
@@ -1945,7 +1975,7 @@ const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings)
 	if (!SetSocketNonblocking (sv[0])) {
 		close (sv[0]);
 		close (sv[1]);
-		return NULL;
+		return 0;
 	}
 
 	pid_t f = fork();