eventmachine 1.0.7-java → 1.0.8-java

data/ext/em.cpp

@@ -38,6 +38,33 @@ static unsigned int SimultaneousAcceptCount = 10;
  */
 static struct sockaddr *name2address (const char *server, int port, int *family, int *bind_size);
 
+/* Internal helper to create a socket with SOCK_CLOEXEC set, and fall
+ * back to fcntl'ing it if the headers/runtime don't support it.
+ */
+
+int EmSocket (int domain, int type, int protocol)
+{
+	int sd;
+#ifdef HAVE_SOCKET_CLOEXEC
+	sd = socket (domain, type | SOCK_CLOEXEC, protocol);
+	if (sd < 0) {
+		sd = socket (domain, type, protocol);
+		if (sd < 0) {
+			return sd;
+		}
+		SetFdCloexec(sd);
+	}
+#else
+	sd = socket (domain, type, protocol);
+	if (sd < 0) {
+		return sd;
+	}
+	SetFdCloexec(sd);
+#endif
+	return sd;
+}
+
+
 /***************************************
 STATIC EventMachine_t::GetMaxTimerCount
 ***************************************/
@@ -83,24 +110,29 @@ void EventMachine_t::SetSimultaneousAcceptCount (int count)
 EventMachine_t::EventMachine_t
 ******************************/
 
-EventMachine_t::EventMachine_t (EMCallback event_callback):
+EventMachine_t::EventMachine_t (EMCallback event_callback, Poller_t poller):
 	NumCloseScheduled (0),
 	HeartbeatInterval(2000000),
 	EventCallback (event_callback),
-	NextHeartbeatTime (0),
 	LoopBreakerReader (-1),
 	LoopBreakerWriter (-1),
 	bTerminateSignalReceived (false),
-	bEpoll (false),
+	Poller (poller),
 	epfd (-1),
-	bKqueue (false),
-	kqfd (-1),
-	inotify (NULL)
+	kqfd (-1)
+	#ifdef HAVE_INOTIFY
+	, inotify (NULL)
+	#endif
 {
 	// Default time-slice is just smaller than one hundred mills.
 	Quantum.tv_sec = 0;
 	Quantum.tv_usec = 90000;
 
+	// Override the requested poller back to default if needed.
+	#if !defined(HAVE_EPOLL) && !defined(HAVE_KQUEUE)
+	Poller = Poller_Default;
+	#endif
+
 	/* Initialize monotonic timekeeping on OS X before the first call to GetRealTime */
 	#ifdef OS_DARWIN
 	(void) mach_timebase_info(&mach_timebase);
@@ -157,59 +189,25 @@ EventMachine_t::~EventMachine_t()
 }
 
 
-/*************************
-EventMachine_t::_UseEpoll
-*************************/
-
-void EventMachine_t::_UseEpoll()
-{
-	/* Temporary.
-	 * Use an internal flag to switch in epoll-based functionality until we determine
-	 * how it should be integrated properly and the extent of the required changes.
-	 * A permanent solution needs to allow the integration of additional technologies,
-	 * like kqueue and Solaris's events.
-	 */
-
-	#ifdef HAVE_EPOLL
-	bEpoll = true;
-	#endif
-}
-
-/**************************
-EventMachine_t::_UseKqueue
-**************************/
-
-void EventMachine_t::_UseKqueue()
-{
-	/* Temporary.
-	 * See comments under _UseEpoll.
-	 */
-
-	#ifdef HAVE_KQUEUE
-	bKqueue = true;
-	#endif
-}
-
-
 /****************************
 EventMachine_t::ScheduleHalt
 ****************************/
 
 void EventMachine_t::ScheduleHalt()
 {
-  /* This is how we stop the machine.
-   * This can be called by clients. Signal handlers will probably
-   * set the global flag.
-   * For now this means there can only be one EventMachine ever running at a time.
-   *
-   * IMPORTANT: keep this light, fast, and async-safe. Don't do anything frisky in here,
-   * because it may be called from signal handlers invoked from code that we don't
-   * control. At this writing (20Sep06), EM does NOT install any signal handlers of
-   * its own.
-   *
-   * We need a FAQ. And one of the questions is: how do I stop EM when Ctrl-C happens?
-   * The answer is to call evma_stop_machine, which calls here, from a SIGINT handler.
-   */
+	/* This is how we stop the machine.
+	 * This can be called by clients. Signal handlers will probably
+	 * set the global flag.
+	 * For now this means there can only be one EventMachine ever running at a time.
+	 *
+	 * IMPORTANT: keep this light, fast, and async-safe. Don't do anything frisky in here,
+	 * because it may be called from signal handlers invoked from code that we don't
+	 * control. At this writing (20Sep06), EM does NOT install any signal handlers of
+	 * its own.
+	 *
+	 * We need a FAQ. And one of the questions is: how do I stop EM when Ctrl-C happens?
+	 * The answer is to call evma_stop_machine, which calls here, from a SIGINT handler.
+	 */
 	bTerminateSignalReceived = true;
 
 	/* Signal the loopbreaker so we break out of long-running select/epoll/kqueue and
@@ -244,33 +242,33 @@ void EventMachine_t::SetTimerQuantum (int interval)
 
 void EventMachine_t::SetuidString (const char *username)
 {
-    /* This method takes a caller-supplied username and tries to setuid
-     * to that user. There is no meaningful implementation (and no error)
-     * on Windows. On Unix, a failure to setuid the caller-supplied string
-     * causes a fatal abort, because presumably the program is calling here
-     * in order to fulfill a security requirement. If we fail silently,
-     * the user may continue to run with too much privilege.
-     *
-     * TODO, we need to decide on and document a way of generating C++ level errors
-     * that can be wrapped in documented Ruby exceptions, so users can catch
-     * and handle them. And distinguish it from errors that we WON'T let the Ruby
-     * user catch (like security-violations and resource-overallocation).
-     * A setuid failure here would be in the latter category.
-     */
+	/* This method takes a caller-supplied username and tries to setuid
+	 * to that user. There is no meaningful implementation (and no error)
+	 * on Windows. On Unix, a failure to setuid the caller-supplied string
+	 * causes a fatal abort, because presumably the program is calling here
+	 * in order to fulfill a security requirement. If we fail silently,
+	 * the user may continue to run with too much privilege.
+	 *
+	 * TODO, we need to decide on and document a way of generating C++ level errors
+	 * that can be wrapped in documented Ruby exceptions, so users can catch
+	 * and handle them. And distinguish it from errors that we WON'T let the Ruby
+	 * user catch (like security-violations and resource-overallocation).
+	 * A setuid failure here would be in the latter category.
+	 */
 
-    #ifdef OS_UNIX
-    if (!username || !*username)
-	throw std::runtime_error ("setuid_string failed: no username specified");
+	#ifdef OS_UNIX
+	if (!username || !*username)
+		throw std::runtime_error ("setuid_string failed: no username specified");
 
-    struct passwd *p = getpwnam (username);
-    if (!p)
-	throw std::runtime_error ("setuid_string failed: unknown username");
+	struct passwd *p = getpwnam (username);
+	if (!p)
+		throw std::runtime_error ("setuid_string failed: unknown username");
 
-    if (setuid (p->pw_uid) != 0)
-	throw std::runtime_error ("setuid_string failed: no setuid");
+	if (setuid (p->pw_uid) != 0)
+		throw std::runtime_error ("setuid_string failed: no setuid");
 
-    // Success.
-    #endif
+	// Success.
+	#endif
 }
 
 
@@ -309,7 +307,7 @@ EventMachine_t::SignalLoopBreaker
 void EventMachine_t::SignalLoopBreaker()
 {
 	#ifdef OS_UNIX
-	write (LoopBreakerWriter, "", 1);
+	(void)write (LoopBreakerWriter, "", 1);
 	#endif
 	#ifdef OS_WIN32
 	sendto (LoopBreakerReader, "", 0, 0, (struct sockaddr*)&(LoopBreakerTarget), sizeof(LoopBreakerTarget));
@@ -333,8 +331,18 @@ void EventMachine_t::_InitializeLoopBreaker()
 
 	#ifdef OS_UNIX
 	int fd[2];
+#if defined (HAVE_CLOEXEC) && defined (HAVE_PIPE2)
+	int pipestatus = pipe2(fd, O_CLOEXEC);
+	if (pipestatus < 0) {
+		if (pipe(fd))
+			throw std::runtime_error (strerror(errno));
+	}
+#else
 	if (pipe (fd))
 		throw std::runtime_error (strerror(errno));
+#endif
+	if (!SetFdCloexec(fd[0]) || !SetFdCloexec(fd[1]))
+		throw std::runtime_error (strerror(errno));
 
 	LoopBreakerWriter = fd[1];
 	LoopBreakerReader = fd[0];
@@ -345,7 +353,7 @@ void EventMachine_t::_InitializeLoopBreaker()
 	#endif
 
 	#ifdef OS_WIN32
-	int sd = socket (AF_INET, SOCK_DGRAM, 0);
+	int sd = EmSocket (AF_INET, SOCK_DGRAM, 0);
 	if (sd == INVALID_SOCKET)
 		throw std::runtime_error ("no loop breaker socket");
 	SetSocketNonblocking (sd);
@@ -367,6 +375,43 @@ void EventMachine_t::_InitializeLoopBreaker()
 		throw std::runtime_error ("no loop breaker");
 	LoopBreakerReader = sd;
 	#endif
+
+	#ifdef HAVE_EPOLL
+	if (Poller == Poller_Epoll) {
+		epfd = epoll_create (MaxEpollDescriptors);
+		if (epfd == -1) {
+			char buf[200];
+			snprintf (buf, sizeof(buf)-1, "unable to create epoll descriptor: %s", strerror(errno));
+			throw std::runtime_error (buf);
+		}
+		int cloexec = fcntl (epfd, F_GETFD, 0);
+		assert (cloexec >= 0);
+		cloexec |= FD_CLOEXEC;
+		fcntl (epfd, F_SETFD, cloexec);
+
+		assert (LoopBreakerReader >= 0);
+		LoopbreakDescriptor *ld = new LoopbreakDescriptor (LoopBreakerReader, this);
+		assert (ld);
+		Add (ld);
+	}
+	#endif
+
+	#ifdef HAVE_KQUEUE
+	if (Poller == Poller_Kqueue) {
+		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
 }
 
 /***************************
@@ -511,75 +556,44 @@ EventMachine_t::Run
 
 void EventMachine_t::Run()
 {
-	#ifdef HAVE_EPOLL
-	if (bEpoll) {
-		epfd = epoll_create (MaxEpollDescriptors);
-		if (epfd == -1) {
-			char buf[200];
-			snprintf (buf, sizeof(buf)-1, "unable to create epoll descriptor: %s", strerror(errno));
-			throw std::runtime_error (buf);
-		}
-		int cloexec = fcntl (epfd, F_GETFD, 0);
-		assert (cloexec >= 0);
-		cloexec |= FD_CLOEXEC;
-		fcntl (epfd, F_SETFD, cloexec);
-
-		assert (LoopBreakerReader >= 0);
-		LoopbreakDescriptor *ld = new LoopbreakDescriptor (LoopBreakerReader, this);
-		assert (ld);
-		Add (ld);
-	}
-	#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) {
-		_UpdateTime();
-		_RunTimers();
-
-		/* _Add must precede _Modify because the same descriptor might
-		 * be on both lists during the same pass through the machine,
-		 * and to modify a descriptor before adding it would fail.
-		 */
-		_AddNewDescriptors();
-		_ModifyDescriptors();
-
-		_RunOnce();
-		if (bTerminateSignalReceived)
-			break;
-	}
+	while (RunOnce()) ;
 }
 
+/***********************
+EventMachine_t::RunOnce
+***********************/
 
-/************************
-EventMachine_t::_RunOnce
-************************/
-
-void EventMachine_t::_RunOnce()
+bool EventMachine_t::RunOnce()
 {
-	if (bEpoll)
+	_UpdateTime();
+	_RunTimers();
+
+	/* _Add must precede _Modify because the same descriptor might
+	 * be on both lists during the same pass through the machine,
+	 * and to modify a descriptor before adding it would fail.
+	 */
+	_AddNewDescriptors();
+	_ModifyDescriptors();
+
+	switch (Poller) {
+	case Poller_Epoll:
 		_RunEpollOnce();
-	else if (bKqueue)
+		break;
+	case Poller_Kqueue:
 		_RunKqueueOnce();
-	else
+		break;
+	case Poller_Default:
 		_RunSelectOnce();
+		break;
+	}
+
 	_DispatchHeartbeats();
 	_CleanupSockets();
+
+	if (bTerminateSignalReceived)
+		return false;
+
+	return true;
 }
 
 
@@ -660,9 +674,9 @@ void EventMachine_t::_RunEpollOnce()
 EventMachine_t::_RunKqueueOnce
 ******************************/
 
+#ifdef HAVE_KQUEUE
 void EventMachine_t::_RunKqueueOnce()
 {
-	#ifdef HAVE_KQUEUE
 	assert (kqfd != -1);
 	int k;
 
@@ -740,10 +754,13 @@ void EventMachine_t::_RunKqueueOnce()
 		rb_thread_schedule();
 	}
 	#endif
-	#else
+}
+#else
+void EventMachine_t::_RunKqueueOnce()
+{
 	throw std::runtime_error ("kqueue is not implemented on this platform");
-	#endif
 }
+#endif
 
 
 /*********************************
@@ -818,7 +835,7 @@ void EventMachine_t::_CleanupSockets()
 		assert (ed);
 		if (ed->ShouldDelete()) {
 		#ifdef HAVE_EPOLL
-			if (bEpoll) {
+			if (Poller == Poller_Epoll) {
 				assert (epfd != -1);
 				if (ed->GetSocket() != INVALID_SOCKET) {
 					int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
@@ -845,10 +862,10 @@ void EventMachine_t::_CleanupSockets()
 EventMachine_t::_ModifyEpollEvent
 *********************************/
 
+#ifdef HAVE_EPOLL
 void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed)
 {
-	#ifdef HAVE_EPOLL
-	if (bEpoll) {
+	if (Poller == Poller_Epoll) {
 		assert (epfd != -1);
 		assert (ed);
 		assert (ed->GetSocket() != INVALID_SOCKET);
@@ -859,9 +876,10 @@ void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed)
 			throw std::runtime_error (buf);
 		}
 	}
-	#endif
 }
-
+#else
+void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed UNUSED) { }
+#endif
 
 
 /**************************
@@ -1082,7 +1100,7 @@ void EventMachine_t::_ReadLoopBreaker()
 	 * and send a loop-break event back to user code.
 	 */
 	char buffer [1024];
-	read (LoopBreakerReader, buffer, sizeof(buffer));
+	(void)read (LoopBreakerReader, buffer, sizeof(buffer));
 	if (EventCallback)
 		(*EventCallback)(0, EM_LOOPBREAK_SIGNAL, "", 0);
 }
@@ -1118,7 +1136,7 @@ void EventMachine_t::_RunTimers()
 EventMachine_t::InstallOneshotTimer
 ***********************************/
 
-const unsigned long EventMachine_t::InstallOneshotTimer (int milliseconds)
+const uintptr_t EventMachine_t::InstallOneshotTimer (int milliseconds)
 {
 	if (Timers.size() > MaxOutstandingTimers)
 		return false;
@@ -1140,7 +1158,7 @@ const unsigned long EventMachine_t::InstallOneshotTimer (int milliseconds)
 EventMachine_t::ConnectToServer
 *******************************/
 
-const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int bind_port, const char *server, int port)
+const uintptr_t EventMachine_t::ConnectToServer (const char *bind_addr, int bind_port, const char *server, int port)
 {
 	/* We want to spend no more than a few seconds waiting for a connection
 	 * to a remote host. So we use a nonblocking connect.
@@ -1174,7 +1192,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 		throw std::runtime_error ("unable to resolve server address");
 	bind_as = *bind_as_ptr; // copy because name2address points to a static
 
-	int sd = socket (family, SOCK_STREAM, 0);
+	int sd = EmSocket (family, SOCK_STREAM, 0);
 	if (sd == INVALID_SOCKET) {
 		char buf [200];
 		snprintf (buf, sizeof(buf)-1, "unable to create new socket: %s", strerror(errno));
@@ -1206,7 +1224,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 		}
 	}
 
-	unsigned long out = 0;
+	uintptr_t out = 0;
 	int e = 0;
 
 	#ifdef OS_UNIX
@@ -1326,7 +1344,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 EventMachine_t::ConnectToUnixServer
 ***********************************/
 
-const unsigned long EventMachine_t::ConnectToUnixServer (const char *server)
+const uintptr_t EventMachine_t::ConnectToUnixServer (const char *server)
 {
 	/* Connect to a Unix-domain server, which by definition is running
 	 * on the same host.
@@ -1343,7 +1361,7 @@ 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 = 0;
+	uintptr_t out = 0;
 
 	if (!server || !*server)
 		return 0;
@@ -1360,7 +1378,7 @@ const unsigned long EventMachine_t::ConnectToUnixServer (const char *server)
 
 	strcpy (pun.sun_path, server);
 
-	int fd = socket (AF_LOCAL, SOCK_STREAM, 0);
+	int fd = EmSocket (AF_LOCAL, SOCK_STREAM, 0);
 	if (fd == INVALID_SOCKET)
 		return 0;
 
@@ -1399,7 +1417,7 @@ const unsigned long EventMachine_t::ConnectToUnixServer (const char *server)
 EventMachine_t::AttachFD
 ************************/
 
-const unsigned long EventMachine_t::AttachFD (int fd, bool watch_mode)
+const uintptr_t EventMachine_t::AttachFD (int fd, bool watch_mode)
 {
 	#ifdef OS_UNIX
 	if (fcntl(fd, F_GETFL, 0) < 0)
@@ -1442,7 +1460,7 @@ const unsigned long EventMachine_t::AttachFD (int fd, bool watch_mode)
 
 	Add (cd);
 
-	const unsigned long out = cd->GetBinding();
+	const uintptr_t out = cd->GetBinding();
 	return out;
 }
 
@@ -1458,7 +1476,7 @@ int EventMachine_t::DetachFD (EventableDescriptor *ed)
 	int fd = ed->GetSocket();
 
 	#ifdef HAVE_EPOLL
-	if (bEpoll) {
+	if (Poller == Poller_Epoll) {
 		if (ed->GetSocket() != INVALID_SOCKET) {
 			assert (epfd != -1);
 			int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
@@ -1473,7 +1491,7 @@ int EventMachine_t::DetachFD (EventableDescriptor *ed)
 	#endif
 
 	#ifdef HAVE_KQUEUE
-	if (bKqueue) {
+	if (Poller == Poller_Kqueue) {
 		// remove any read/write events for this fd
 		struct kevent k;
 #ifdef __NetBSD__
@@ -1579,7 +1597,7 @@ struct sockaddr *name2address (const char *server, int port, int *family, int *b
 EventMachine_t::CreateTcpServer
 *******************************/
 
-const unsigned long EventMachine_t::CreateTcpServer (const char *server, int port)
+const uintptr_t EventMachine_t::CreateTcpServer (const char *server, int port)
 {
 	/* Create a TCP-acceptor (server) socket and add it to the event machine.
 	 * Return the binding of the new acceptor to the caller.
@@ -1595,7 +1613,7 @@ const unsigned long EventMachine_t::CreateTcpServer (const char *server, int por
 
 	//struct sockaddr_in sin;
 
-	int sd_accept = socket (family, SOCK_STREAM, 0);
+	int sd_accept = EmSocket (family, SOCK_STREAM, 0);
 	if (sd_accept == INVALID_SOCKET) {
 		goto fail;
 	}
@@ -1642,11 +1660,11 @@ const unsigned long EventMachine_t::CreateTcpServer (const char *server, int por
 EventMachine_t::OpenDatagramSocket
 **********************************/
 
-const unsigned long EventMachine_t::OpenDatagramSocket (const char *address, int port)
+const uintptr_t EventMachine_t::OpenDatagramSocket (const char *address, int port)
 {
-	unsigned long output_binding = 0;
+	uintptr_t output_binding = 0;
 
-	int sd = socket (AF_INET, SOCK_DGRAM, 0);
+	int sd = EmSocket (AF_INET, SOCK_DGRAM, 0);
 	if (sd == INVALID_SOCKET)
 		goto fail;
 	// from here on, early returns must close the socket!
@@ -1717,10 +1735,10 @@ void EventMachine_t::Add (EventableDescriptor *ed)
 EventMachine_t::ArmKqueueWriter
 *******************************/
 
+#ifdef HAVE_KQUEUE
 void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed)
 {
-	#ifdef HAVE_KQUEUE
-	if (bKqueue) {
+	if (Poller == Poller_Kqueue) {
 		if (!ed)
 			throw std::runtime_error ("added bad descriptor");
 		struct kevent k;
@@ -1736,17 +1754,19 @@ void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed)
 			throw std::runtime_error (buf);
 		}
 	}
-	#endif
 }
+#else
+void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed UNUSED) { }
+#endif
 
 /*******************************
 EventMachine_t::ArmKqueueReader
 *******************************/
 
+#ifdef HAVE_KQUEUE
 void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed)
 {
-	#ifdef HAVE_KQUEUE
-	if (bKqueue) {
+	if (Poller == Poller_Kqueue) {
 		if (!ed)
 			throw std::runtime_error ("added bad descriptor");
 		struct kevent k;
@@ -1762,8 +1782,10 @@ void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed)
 			throw std::runtime_error (buf);
 		}
 	}
-	#endif
 }
+#else
+void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed UNUSED) { }
+#endif
 
 /**********************************
 EventMachine_t::_AddNewDescriptors
@@ -1788,7 +1810,7 @@ void EventMachine_t::_AddNewDescriptors()
 			throw std::runtime_error ("adding bad descriptor");
 
 		#if HAVE_EPOLL
-		if (bEpoll) {
+		if (Poller == Poller_Epoll) {
 			assert (epfd != -1);
 			int e = epoll_ctl (epfd, EPOLL_CTL_ADD, ed->GetSocket(), ed->GetEpollEvent());
 			if (e) {
@@ -1801,7 +1823,7 @@ void EventMachine_t::_AddNewDescriptors()
 
 		#if HAVE_KQUEUE
 		/*
-		if (bKqueue) {
+		if (Poller == Poller_Kqueue) {
 			// INCOMPLETE. Some descriptors don't want to be readable.
 			assert (kqfd != -1);
 			struct kevent k;
@@ -1847,7 +1869,7 @@ void EventMachine_t::_ModifyDescriptors()
 	 */
 
 	#ifdef HAVE_EPOLL
-	if (bEpoll) {
+	if (Poller == Poller_Epoll) {
 		set<EventableDescriptor*>::iterator i = ModifiedDescriptors.begin();
 		while (i != ModifiedDescriptors.end()) {
 			assert (*i);
@@ -1857,6 +1879,18 @@ void EventMachine_t::_ModifyDescriptors()
 	}
 	#endif
 
+	#ifdef HAVE_KQUEUE
+	if (Poller == Poller_Kqueue) {
+		set<EventableDescriptor*>::iterator i = ModifiedDescriptors.begin();
+		while (i != ModifiedDescriptors.end()) {
+			assert (*i);
+			if ((*i)->GetKqueueArmWrite())
+				ArmKqueueWriter (*i);
+			++i;
+		}
+	}
+	#endif
+
 	ModifiedDescriptors.clear();
 }
 
@@ -1885,7 +1919,7 @@ void EventMachine_t::Deregister (EventableDescriptor *ed)
 	// cut/paste from _CleanupSockets().  The error handling could be
 	// refactored out of there, but it is cut/paste all over the
 	// file already.
-	if (bEpoll) {
+	if (Poller == Poller_Epoll) {
 		assert (epfd != -1);
 		assert (ed->GetSocket() != INVALID_SOCKET);
 		int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
@@ -1905,7 +1939,7 @@ void EventMachine_t::Deregister (EventableDescriptor *ed)
 EventMachine_t::CreateUnixDomainServer
 **************************************/
 
-const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename)
+const uintptr_t EventMachine_t::CreateUnixDomainServer (const char *filename)
 {
 	/* Create a UNIX-domain acceptor (server) socket and add it to the event machine.
 	 * Return the binding of the new acceptor to the caller.
@@ -1923,7 +1957,7 @@ const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename
 
 	struct sockaddr_un s_sun;
 
-	int sd_accept = socket (AF_LOCAL, SOCK_STREAM, 0);
+	int sd_accept = EmSocket (AF_LOCAL, SOCK_STREAM, 0);
 	if (sd_accept == INVALID_SOCKET) {
 		goto fail;
 	}
@@ -1971,9 +2005,9 @@ const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename
 EventMachine_t::AttachSD
 **************************************/
 
-const unsigned long EventMachine_t::AttachSD (int sd_accept)
+const uintptr_t EventMachine_t::AttachSD (int sd_accept)
 {
-	unsigned long output_binding = 0;
+	uintptr_t output_binding = 0;
 
 	{
 		// Set the acceptor non-blocking.
@@ -2006,7 +2040,7 @@ const unsigned long EventMachine_t::AttachSD (int sd_accept)
 EventMachine_t::Socketpair
 **************************/
 
-const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings)
+const uintptr_t EventMachine_t::Socketpair (char * const*cmd_strings)
 {
 	#ifdef OS_WIN32
 	throw std::runtime_error ("socketpair is currently unavailable on this platform");
@@ -2024,7 +2058,7 @@ const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings)
 	if ((j==0) || (j==2048))
 		return 0;
 
-	unsigned long output_binding = 0;
+	uintptr_t output_binding = 0;
 
 	int sv[2];
 	if (socketpair (AF_LOCAL, SOCK_STREAM, 0, sv) < 0)
@@ -2070,7 +2104,7 @@ const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings)
 EventMachine_t::OpenKeyboard
 ****************************/
 
-const unsigned long EventMachine_t::OpenKeyboard()
+const uintptr_t EventMachine_t::OpenKeyboard()
 {
 	KeyboardDescriptor *kd = new KeyboardDescriptor (this);
 	if (!kd)
@@ -2094,10 +2128,10 @@ int EventMachine_t::GetConnectionCount ()
 EventMachine_t::WatchPid
 ************************/
 
-const unsigned long EventMachine_t::WatchPid (int pid)
+#ifdef HAVE_KQUEUE
+const uintptr_t EventMachine_t::WatchPid (int pid)
 {
-	#ifdef HAVE_KQUEUE
-	if (!bKqueue)
+	if (Poller != Poller_Kqueue)
 		throw std::runtime_error("must enable kqueue (EM.kqueue=true) for pid watching support");
 
 	struct kevent event;
@@ -2112,17 +2146,17 @@ const unsigned long EventMachine_t::WatchPid (int pid)
 		sprintf(errbuf, "failed to register file watch descriptor with kqueue: %s", strerror(errno));
 		throw std::runtime_error(errbuf);
 	}
-	#endif
-
-	#ifdef HAVE_KQUEUE
 	Bindable_t* b = new Bindable_t();
 	Pids.insert(make_pair (pid, b));
 
 	return b->GetBinding();
-	#endif
-
+}
+#else
+const uintptr_t EventMachine_t::WatchPid (int pid UNUSED)
+{
 	throw std::runtime_error("no pid watching support on this system");
 }
+#endif
 
 /**************************
 EventMachine_t::UnwatchPid
@@ -2148,7 +2182,7 @@ void EventMachine_t::UnwatchPid (int pid)
 	delete b;
 }
 
-void EventMachine_t::UnwatchPid (const unsigned long sig)
+void EventMachine_t::UnwatchPid (const uintptr_t sig)
 {
 	for(map<int, Bindable_t*>::iterator i=Pids.begin(); i != Pids.end(); i++)
 	{
@@ -2166,7 +2200,7 @@ void EventMachine_t::UnwatchPid (const unsigned long sig)
 EventMachine_t::WatchFile
 *************************/
 
-const unsigned long EventMachine_t::WatchFile (const char *fpath)
+const uintptr_t EventMachine_t::WatchFile (const char *fpath)
 {
 	struct stat sb;
 	int sres;
@@ -2197,7 +2231,7 @@ const unsigned long EventMachine_t::WatchFile (const char *fpath)
 	#endif
 
 	#ifdef HAVE_KQUEUE
-	if (!bKqueue)
+	if (Poller != Poller_Kqueue)
 		throw std::runtime_error("must enable kqueue (EM.kqueue=true) for file watching support");
 
 	// With kqueue we have to open the file first and use the resulting fd to register for events
@@ -2244,7 +2278,7 @@ void EventMachine_t::UnwatchFile (int wd)
 	delete b;
 }
 
-void EventMachine_t::UnwatchFile (const unsigned long sig)
+void EventMachine_t::UnwatchFile (const uintptr_t sig)
 {
 	for(map<int, Bindable_t*>::iterator i=Files.begin(); i != Files.end(); i++)
 	{
@@ -2270,9 +2304,9 @@ void EventMachine_t::_ReadInotifyEvents()
 
 	for (;;) {
 		int returned = read(inotify->GetSocket(), buffer, sizeof(buffer));
-		assert(!(returned == 0 || returned == -1 && errno == EINVAL));
+		assert(!(returned == 0 || (returned == -1 && errno == EINVAL)));
 		if (returned <= 0) {
-		    break;
+			break;
 		}
 		int current = 0;
 		while (current < returned) {