eventmachine 0.7.2 → 0.8.0

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 318 2007-05-22 22:06:24Z blackhedd $
+$Id: ed.h 400 2007-07-11 12:10:33Z blackhedd $
 
 File:     ed.h
 Date:     06Apr06
@@ -36,7 +36,7 @@ class EventableDescriptor
 class EventableDescriptor: public Bindable_t
 {
 	public:
-		EventableDescriptor (int);
+		EventableDescriptor (int, EventMachine_t*);
 		virtual ~EventableDescriptor();
 
 		int GetSocket() {return MySocket;}
@@ -57,17 +57,28 @@ class EventableDescriptor: public Bindable_t
 		virtual int GetOutboundDataSize() {return 0;}
 
 		void ScheduleClose (bool after_writing);
+		bool IsCloseScheduled();
 
 		void SetEventCallback (void (*cb)(const char*, int, const char*, int));
 
 		virtual bool GetPeername (struct sockaddr*) {return false;}
+		virtual bool GetSubprocessPid (pid_t*) {return false;}
 
-    virtual void StartTls() {}
+		virtual void StartTls() {}
 
-    // Properties: return 0/1 to signify T/F, and handle the values
-    // through arguments.
-    virtual int GetCommInactivityTimeout (int *value) {return 0;}
-    virtual int SetCommInactivityTimeout (int *value) {return 0;}
+		// Properties: return 0/1 to signify T/F, and handle the values
+		// through arguments.
+		virtual int GetCommInactivityTimeout (int *value) {return 0;}
+		virtual int SetCommInactivityTimeout (int *value) {return 0;}
+
+		#ifdef HAVE_EPOLL
+		struct epoll_event *GetEpollEvent() { return &EpollEvent; }
+		#endif
+
+	private:
+		bool bCloseNow;
+		bool bCloseAfterWriting;
+		int MySocket;
 
 	protected:
 		enum {
@@ -79,13 +90,36 @@ class EventableDescriptor: public Bindable_t
 		time_t CreatedAt;
 		time_t LastRead;
 		time_t LastWritten;
-		int MySocket;
-		bool bCloseNow;
-		bool bCloseAfterWriting;
+		bool bCallbackUnbind;
+
+		#ifdef HAVE_EPOLL
+		struct epoll_event EpollEvent;
+		#endif
+
+		EventMachine_t *MyEventMachine;
 };
 
 
 
+/*************************
+class LoopbreakDescriptor
+*************************/
+
+class LoopbreakDescriptor: public EventableDescriptor
+{
+	public:
+		LoopbreakDescriptor (int, EventMachine_t*);
+		virtual ~LoopbreakDescriptor() {}
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat() {}
+
+		virtual bool SelectForRead() {return true;}
+		virtual bool SelectForWrite() {return false;}
+};
+
+
 /**************************
 class ConnectionDescriptor
 **************************/
@@ -93,7 +127,7 @@ class ConnectionDescriptor
 class ConnectionDescriptor: public EventableDescriptor
 {
 	public:
-		ConnectionDescriptor (int);
+		ConnectionDescriptor (int, EventMachine_t*);
 		virtual ~ConnectionDescriptor();
 
 		static int SendDataToConnection (const char*, const char*, int);
@@ -118,8 +152,8 @@ class ConnectionDescriptor: public EventableDescriptor
 
 		virtual bool GetPeername (struct sockaddr*);
 
-    virtual int GetCommInactivityTimeout (int *value);
-    virtual int SetCommInactivityTimeout (int *value);
+		virtual int GetCommInactivityTimeout (int *value);
+		virtual int SetCommInactivityTimeout (int *value);
 
 	protected:
 		struct OutboundPage {
@@ -161,7 +195,7 @@ class DatagramDescriptor
 class DatagramDescriptor: public EventableDescriptor
 {
 	public:
-		DatagramDescriptor (int);
+		DatagramDescriptor (int, EventMachine_t*);
 		virtual ~DatagramDescriptor();
 
 		virtual void Read();
@@ -212,7 +246,7 @@ class AcceptorDescriptor
 class AcceptorDescriptor: public EventableDescriptor
 {
 	public:
-		AcceptorDescriptor (EventMachine_t*, int);
+		AcceptorDescriptor (int, EventMachine_t*);
 		virtual ~AcceptorDescriptor();
 
 		virtual void Read();
@@ -221,11 +255,55 @@ class AcceptorDescriptor: public EventableDescriptor
 
 		virtual bool SelectForRead() {return true;}
 		virtual bool SelectForWrite() {return false;}
+};
+
+/********************
+class PipeDescriptor
+********************/
+
+#ifdef OS_UNIX
+class PipeDescriptor: public EventableDescriptor
+{
+	public:
+		PipeDescriptor (FILE*, pid_t, EventMachine_t*);
+		virtual ~PipeDescriptor();
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat();
+
+		virtual bool SelectForRead();
+		virtual bool SelectForWrite();
+
+		int SendOutboundData (const char*, int);
+		virtual int GetOutboundDataSize() {return OutboundDataSize;}
+
+		virtual bool GetSubprocessPid (pid_t*);
 
 	protected:
-		EventMachine_t *MyEventMachine;
-};
+		struct OutboundPage {
+			OutboundPage (const char *b, int l, int o=0): Buffer(b), Length(l), Offset(o) {}
+			void Free() {if (Buffer) free ((char*)Buffer); }
+			const char *Buffer;
+			int Length;
+			int Offset;
+		};
+
+	protected:
+		bool bReadAttemptedAfterClose;
+		time_t LastIo;
+		int InactivityTimeout;
+		//FILE *MyStream;
+
+		deque<OutboundPage> OutboundPages;
+		int OutboundDataSize;
 
+		pid_t SubprocessPid;
+
+	private:
+		void _DispatchInboundData (const char *buffer, int size);
+};
+#endif // OS_UNIX
 
 
 #endif // __EventableDescriptor__H_

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 318 2007-05-22 22:06:24Z blackhedd $
+$Id: em.cpp 386 2007-06-20 00:08:19Z blackhedd $
 
 File:     em.cpp
 Date:     06Apr06
@@ -42,7 +42,9 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	EventCallback (event_callback),
 	NextHeartbeatTime (0),
 	LoopBreakerReader (-1),
-	LoopBreakerWriter (-1)
+	LoopBreakerWriter (-1),
+	bEpoll (false),
+	epfd (-1)
 {
 	// Default time-slice is just smaller than one hundred mills.
 	Quantum.tv_sec = 0;
@@ -53,6 +55,17 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	// objects before we start running.
 	gCurrentLoopTime = time(NULL);
 
+	/* We initialize the network library here (only on Windows of course)
+	 * and initialize "loop breakers." Our destructor also does some network-level
+	 * cleanup. There's thus an implicit assumption that any given instance of EventMachine_t
+	 * will only call ::Run once. Is that a good assumption? Should we move some of these
+	 * inits and de-inits into ::Run?
+	 */
+	#ifdef OS_WIN32
+	WSADATA w;
+	WSAStartup (MAKEWORD (1, 1), &w);
+	#endif
+
 	_InitializeLoopBreaker();
 }
 
@@ -72,9 +85,30 @@ EventMachine_t::~EventMachine_t()
 
 	close (LoopBreakerReader);
 	close (LoopBreakerWriter);
+
+	if (epfd != -1)
+		close (epfd);
 }
 
 
+/*************************
+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::ScheduleHalt
@@ -127,9 +161,15 @@ 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 us
+     * 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
@@ -148,6 +188,34 @@ void EventMachine_t::SetuidString (const char *username)
 }
 
 
+/****************************************
+(STATIC) EventMachine_t::SetRlimitNofile
+****************************************/
+
+int EventMachine_t::SetRlimitNofile (int nofiles)
+{
+	#ifdef OS_UNIX
+	struct rlimit rlim;
+	getrlimit (RLIMIT_NOFILE, &rlim);
+	if (nofiles >= 0) {
+		rlim.rlim_cur = nofiles;
+		if (nofiles > rlim.rlim_max)
+			rlim.rlim_max = nofiles;
+		setrlimit (RLIMIT_NOFILE, &rlim);
+		// ignore the error return, for now at least.
+		// TODO, emit an error message someday when we have proper debug levels.
+	}
+	getrlimit (RLIMIT_NOFILE, &rlim);
+	return rlim.rlim_cur;
+	#endif
+
+	#ifdef OS_WIN32
+	// No meaningful implementation on Windows.
+	return 0;
+	#endif
+}
+
+
 /*********************************
 EventMachine_t::SignalLoopBreaker
 *********************************/
@@ -219,16 +287,41 @@ EventMachine_t::Run
 void EventMachine_t::Run()
 {
 	#ifdef OS_WIN32
-	WSADATA w;
-	WSAStartup (MAKEWORD (1, 1), &w);
 	HookControlC (true);
 	#endif
 
+	#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
+
 	while (true) {
 		gCurrentLoopTime = time(NULL);
 		if (!_RunTimers())
 			break;
+
+		/* _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();
+
 		if (!_RunOnce())
 			break;
 		if (gTerminateSignalReceived)
@@ -241,12 +334,123 @@ void EventMachine_t::Run()
 }
 
 
-
 /************************
 EventMachine_t::_RunOnce
 ************************/
 
 bool EventMachine_t::_RunOnce()
+{
+	if (bEpoll)
+		return _RunEpollOnce();
+	else
+		return _RunSelectOnce();
+}
+
+
+
+/*****************************
+EventMachine_t::_RunEpollOnce
+*****************************/
+
+bool EventMachine_t::_RunEpollOnce()
+{
+	#ifdef HAVE_EPOLL
+	assert (epfd != -1);
+	struct epoll_event ev [MaxEpollDescriptors];
+	int s = epoll_wait (epfd, ev, MaxEpollDescriptors, 10);
+	if (s > 0) {
+		for (int i=0; i < s; i++) {
+			EventableDescriptor *ed = (EventableDescriptor*) ev[i].data.ptr;
+
+			if (ev[i].events & (EPOLLERR | EPOLLHUP))
+				ed->ScheduleClose (false);
+			if (ev[i].events & EPOLLIN)
+				ed->Read();
+			if (ev[i].events & EPOLLOUT) {
+				ed->Write();
+				epoll_ctl (epfd, EPOLL_CTL_MOD, ed->GetSocket(), ed->GetEpollEvent());
+				// Ignoring return value
+			}
+		}
+	}
+	else if (s < 0) {
+		// epoll_wait can fail on error in a handful of ways.
+		// If this happens, then wait for a little while to avoid busy-looping.
+		// If the error was EINTR, we probably caught SIGCHLD or something,
+		// so keep the wait short.
+		timeval tv = {0, ((errno == EINTR) ? 5 : 50) * 1000};
+		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.
+		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);
+				}
+
+				ModifiedDescriptors.erase (ed);
+				delete ed;
+			}
+			else
+				Descriptors [j++] = ed;
+		}
+		while ((size_t)j < Descriptors.size())
+			Descriptors.pop_back();
+
+	}
+
+	// TODO, heartbeats.
+
+	timeval tv = {0,0};
+	EmSelect (0, NULL, NULL, NULL, &tv);
+
+	return true;
+	#else
+	throw std::runtime_error ("epoll is not implemented on this platform");
+	#endif
+}
+
+
+/*********************************
+EventMachine_t::_ModifyEpollEvent
+*********************************/
+
+void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed)
+{
+	#ifdef HAVE_EPOLL
+	if (bEpoll) {
+		assert (epfd != -1);
+		assert (ed);
+		int e = epoll_ctl (epfd, EPOLL_CTL_MOD, ed->GetSocket(), ed->GetEpollEvent());
+		if (e) {
+			char buf [200];
+			snprintf (buf, sizeof(buf)-1, "unable to modify epoll event: %s", strerror(errno));
+			throw std::runtime_error (buf);
+		}
+	}
+	#endif
+}
+
+
+/******************************
+EventMachine_t::_RunSelectOnce
+******************************/
+
+bool EventMachine_t::_RunSelectOnce()
 {
 	// Crank the event machine once.
 	// If there are no descriptors to process, then sleep
@@ -315,9 +519,16 @@ bool EventMachine_t::_RunOnce()
 		timeval tv = Quantum;
 		int s = EmSelect (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
 		if (s > 0) {
-			if (FD_ISSET (LoopBreakerReader, &fdreads))
-				_ReadLoopBreaker();
-
+			/* Changed 01Jun07. We used to handle the Loop-breaker right here.
+			 * Now we do it AFTER all the regular descriptors. There's an
+			 * incredibly important and subtle reason for this. Code on
+			 * loop breakers is sometimes used to cause the reactor core to
+			 * cycle (for example, to allow outbound network buffers to drain).
+			 * If a loop-breaker handler reschedules itself (say, after determining
+			 * that the write buffers are still too full), then it will execute
+			 * IMMEDIATELY if _ReadLoopBreaker is done here instead of after
+			 * the other descriptors are processed. That defeats the whole purpose.
+			 */
 			for (i=0; i < Descriptors.size(); i++) {
 				EventableDescriptor *ed = Descriptors[i];
 				assert (ed);
@@ -329,6 +540,9 @@ bool EventMachine_t::_RunOnce()
 				if (FD_ISSET (sd, &fdreads))
 					ed->Read();
 			}
+
+			if (FD_ISSET (LoopBreakerReader, &fdreads))
+				_ReadLoopBreaker();
 		}
 		else if (s < 0) {
 			// select can fail on error in a handful of ways.
@@ -387,7 +601,7 @@ void EventMachine_t::_ReadLoopBreaker()
 	char buffer [1024];
 	read (LoopBreakerReader, buffer, sizeof(buffer));
 	if (EventCallback)
-		(*EventCallback)("", EventMachine_t::LOOPBREAK_SIGNAL, "", 0);
+		(*EventCallback)("", EM_LOOPBREAK_SIGNAL, "", 0);
 }
 
 
@@ -425,7 +639,7 @@ bool EventMachine_t::_RunTimers()
 		if (i->first > now)
 			break;
 		if (EventCallback)
-			(*EventCallback) ("", TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
+			(*EventCallback) ("", EM_TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
 		Timers.erase (i);
 	}
 	return true;
@@ -556,7 +770,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 		 * some needed initialization will happen in the ConnectionDescriptor.
 		 * (To wit, the ConnectionCompleted event gets sent to the client.)
 		 */
-		ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+		ConnectionDescriptor *cd = new ConnectionDescriptor (sd, this);
 		if (!cd)
 			throw std::runtime_error ("no connection allocated");
 		cd->SetConnectPending (true);
@@ -574,7 +788,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 			// Here, there's no disposition.
 			// Put the connection on the stack and wait for it to complete
 			// or time out.
-			ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+			ConnectionDescriptor *cd = new ConnectionDescriptor (sd, this);
 			if (!cd)
 				throw std::runtime_error ("no connection allocated");
 			cd->SetConnectPending (true);
@@ -594,7 +808,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 			 * revised behavior, in case it causes problems like making it hard
 			 * for people to know that a failure occurred.
 			 */
-			ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+			ConnectionDescriptor *cd = new ConnectionDescriptor (sd, this);
 			if (!cd)
 				throw std::runtime_error ("no connection allocated");
 			cd->ScheduleClose (false);
@@ -621,7 +835,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 		// such stuff at this point.
 		// Put the connection on the stack and wait for it to complete
 		// or time out.
-		ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+		ConnectionDescriptor *cd = new ConnectionDescriptor (sd, this);
 		if (!cd)
 			throw std::runtime_error ("no connection allocated");
 		cd->SetConnectPending (true);
@@ -698,7 +912,7 @@ const char *EventMachine_t::ConnectToUnixServer (const char *server)
 	// Observe, even though we know the connection status is connect-success,
 	// we still set the "pending" flag, so some needed initializations take
 	// place.
-	ConnectionDescriptor *cd = new ConnectionDescriptor (fd);
+	ConnectionDescriptor *cd = new ConnectionDescriptor (fd, this);
 	if (!cd)
 		throw std::runtime_error ("no connection allocated");
 	cd->SetConnectPending (true);
@@ -790,7 +1004,7 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 	}
 
 	{ // Looking good.
-		AcceptorDescriptor *ad = new AcceptorDescriptor (this, sd_accept);
+		AcceptorDescriptor *ad = new AcceptorDescriptor (sd_accept, this);
 		if (!ad)
 			throw std::runtime_error ("unable to allocate acceptor");
 		Add (ad);
@@ -851,7 +1065,7 @@ const char *EventMachine_t::OpenDatagramSocket (const char *address, int port)
 		goto fail;
 
 	{ // Looking good.
-		DatagramDescriptor *ds = new DatagramDescriptor (sd);
+		DatagramDescriptor *ds = new DatagramDescriptor (sd, this);
 		if (!ds)
 			throw std::runtime_error ("unable to allocate datagram-socket");
 		Add (ds);
@@ -902,12 +1116,75 @@ void EventMachine_t::_AddNewDescriptors()
 		EventableDescriptor *ed = NewDescriptors[i];
 		if (ed == NULL)
 			throw std::runtime_error ("adding bad descriptor");
+
+		#if HAVE_EPOLL
+		if (bEpoll) {
+			assert (epfd != -1);
+			int e = epoll_ctl (epfd, EPOLL_CTL_ADD, ed->GetSocket(), ed->GetEpollEvent());
+			if (e) {
+				char buf [200];
+				snprintf (buf, sizeof(buf)-1, "unable to add new descriptor: %s", strerror(errno));
+				throw std::runtime_error (buf);
+			}
+		}
+		#endif
+
 		Descriptors.push_back (ed);
 	}
 	NewDescriptors.clear();
 }
 
 
+/**********************************
+EventMachine_t::_ModifyDescriptors
+**********************************/
+
+void EventMachine_t::_ModifyDescriptors()
+{
+	/* For implementations which don't level check every descriptor on
+	 * every pass through the machine, as select does.
+	 * If we're not selecting, then descriptors need a way to signal to the
+	 * machine that their readable or writable status has changed.
+	 * That's what the ::Modify call is for. We do it this way to avoid
+	 * modifying descriptors during the loop traversal, where it can easily
+	 * happen that an object (like a UDP socket) gets data written on it by
+	 * the application during #post_init. That would take place BEFORE the
+	 * descriptor even gets added to the epoll descriptor, so the modify
+	 * operation will crash messily.
+	 * Another really messy possibility is for a descriptor to put itself
+	 * on the Modified list, and then get deleted before we get here.
+	 * Remember, deletes happen after the I/O traversal and before the
+	 * next pass through here. So we have to make sure when we delete a
+	 * descriptor to remove it from the Modified list.
+	 */
+
+	#ifdef HAVE_EPOLL
+	if (bEpoll) {
+		set<EventableDescriptor*>::iterator i = ModifiedDescriptors.begin();
+		while (i != ModifiedDescriptors.end()) {
+			assert (*i);
+			_ModifyEpollEvent (*i);
+			++i;
+		}
+	}
+	#endif
+
+	ModifiedDescriptors.clear();
+}
+
+
+/**********************
+EventMachine_t::Modify
+**********************/
+
+void EventMachine_t::Modify (EventableDescriptor *ed)
+{
+	if (!ed)
+		throw std::runtime_error ("modified bad descriptor");
+	ModifiedDescriptors.insert (ed);
+}
+
+
 /***********************************
 EventMachine_t::_OpenFileForWriting
 ***********************************/
@@ -924,7 +1201,7 @@ const char *EventMachine_t::_OpenFileForWriting (const char *filename)
 
   int fd = open (filename, O_CREAT|O_TRUNC|O_WRONLY|O_NONBLOCK, 0644);
   
-	FileStreamDescriptor *fsd = new FileStreamDescriptor (fd);
+	FileStreamDescriptor *fsd = new FileStreamDescriptor (fd, this);
   if (!fsd)
   	throw std::runtime_error ("no file-stream allocated");
   Add (fsd);
@@ -1001,7 +1278,7 @@ const char *EventMachine_t::CreateUnixDomainServer (const char *filename)
 	}
 
 	{ // Looking good.
-		AcceptorDescriptor *ad = new AcceptorDescriptor (this, sd_accept);
+		AcceptorDescriptor *ad = new AcceptorDescriptor (sd_accept, this);
 		if (!ad)
 			throw std::runtime_error ("unable to allocate acceptor");
 		Add (ad);
@@ -1018,5 +1295,108 @@ const char *EventMachine_t::CreateUnixDomainServer (const char *filename)
 }
 
 
+/*********************
+EventMachine_t::Popen
+*********************/
+#if OBSOLETE
+const char *EventMachine_t::Popen (const char *cmd, const char *mode)
+{
+	#ifdef OS_WIN32
+	throw std::runtime_error ("popen is currently unavailable on this platform");
+	#endif
+
+	// The whole rest of this function is only compiled on Unix systems.
+	// Eventually we need this functionality (or a full-duplex equivalent) on Windows.
+	#ifdef OS_UNIX
+	const char *output_binding = NULL;
+
+	FILE *fp = popen (cmd, mode);
+	if (!fp)
+		return NULL;
+
+	// From here, all early returns must pclose the stream.
+
+	// According to the pipe(2) manpage, descriptors returned from pipe have both
+	// CLOEXEC and NONBLOCK clear. Do NOT set CLOEXEC. DO set nonblocking.
+	if (!SetSocketNonblocking (fileno (fp))) {
+		pclose (fp);
+		return NULL;
+	}
+
+	{ // Looking good.
+		PipeDescriptor *pd = new PipeDescriptor (fp, this);
+		if (!pd)
+			throw std::runtime_error ("unable to allocate pipe");
+		Add (pd);
+		output_binding = pd->GetBinding().c_str();
+	}
+
+	return output_binding;
+	#endif
+}
+#endif // OBSOLETE
+
+/**************************
+EventMachine_t::Socketpair
+**************************/
+
+const char *EventMachine_t::Socketpair (char * const*cmd_strings)
+{
+	#ifdef OS_WIN32
+	throw std::runtime_error ("socketpair is currently unavailable on this platform");
+	#endif
+
+	// The whole rest of this function is only compiled on Unix systems.
+	// Eventually we need this functionality (or a full-duplex equivalent) on Windows.
+	#ifdef OS_UNIX
+	// Make sure the incoming array of command strings is sane.
+	if (!cmd_strings)
+		return NULL;
+	int j;
+	for (j=0; j < 100 && cmd_strings[j]; j++)
+		;
+	if ((j==0) || (j==100))
+		return NULL;
+
+	const char *output_binding = NULL;
+
+	int sv[2];
+	if (socketpair (AF_LOCAL, SOCK_STREAM, 0, sv) < 0)
+		return NULL;
+	// from here, all early returns must close the pair of sockets.
+
+	// Set the socketpair nonblocking. Obviously DON'T set CLOEXEC.
+	if (!SetSocketNonblocking (sv[0]) || !SetSocketNonblocking (sv[1])) {
+		close (sv[0]);
+		close (sv[1]);
+		return NULL;
+	}
+
+	pid_t f = fork();
+	if (f > 0) {
+		close (sv[1]);
+		PipeDescriptor *pd = new PipeDescriptor (fdopen(sv[0], "r+"), f, this);
+		if (!pd)
+			throw std::runtime_error ("unable to allocate pipe");
+		Add (pd);
+		output_binding = pd->GetBinding().c_str();
+	}
+	else if (f == 0) {
+		close (sv[0]);
+		dup2 (sv[1], STDIN_FILENO);
+		close (sv[1]);
+		dup2 (STDIN_FILENO, STDOUT_FILENO);
+		execvp (cmd_strings[0], cmd_strings+1);
+		exit (-1); // end the child process if the exec doesn't work.
+	}
+	else
+		throw std::runtime_error ("no fork");
+
+	return output_binding;
+	#endif
+}
+
+
+
 //#endif // OS_UNIX