eventmachine 0.8.1 → 0.9.0

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 447 2007-07-20 16:42:06Z blackhedd $
+$Id: ed.h 502 2007-08-24 09:29:53Z blackhedd $
 
 File:     ed.h
 Date:     06Apr06
@@ -65,6 +65,7 @@ class EventableDescriptor: public Bindable_t
 		virtual bool GetSubprocessPid (pid_t*) {return false;}
 
 		virtual void StartTls() {}
+		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename) {}
 
 		// Properties: return 0/1 to signify T/F, and handle the values
 		// through arguments.
@@ -148,6 +149,7 @@ class ConnectionDescriptor: public EventableDescriptor
 		virtual int GetOutboundDataSize() {return OutboundDataSize;}
 
 		virtual void StartTls();
+		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename);
 		void SetServerMode() {bIsServer = true;}
 
 		virtual bool GetPeername (struct sockaddr*);
@@ -174,6 +176,8 @@ class ConnectionDescriptor: public EventableDescriptor
 
 		#ifdef WITH_SSL
 		SslBox_t *SslBox;
+		std::string CertChainFilename;
+		std::string PrivateKeyFilename;
 		#endif
 		bool bIsServer;
 
@@ -268,7 +272,7 @@ class PipeDescriptor
 class PipeDescriptor: public EventableDescriptor
 {
 	public:
-		PipeDescriptor (FILE*, pid_t, EventMachine_t*);
+		PipeDescriptor (int, pid_t, EventMachine_t*);
 		virtual ~PipeDescriptor();
 
 		virtual void Read();
@@ -296,7 +300,6 @@ class PipeDescriptor: public EventableDescriptor
 		bool bReadAttemptedAfterClose;
 		time_t LastIo;
 		int InactivityTimeout;
-		//FILE *MyStream;
 
 		deque<OutboundPage> OutboundPages;
 		int OutboundDataSize;
@@ -309,6 +312,34 @@ class PipeDescriptor: public EventableDescriptor
 #endif // OS_UNIX
 
 
+/************************
+class KeyboardDescriptor
+************************/
+
+class KeyboardDescriptor: public EventableDescriptor
+{
+	public:
+		KeyboardDescriptor (EventMachine_t*);
+		virtual ~KeyboardDescriptor();
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat();
+
+		virtual bool SelectForRead() {return true;}
+		virtual bool SelectForWrite() {return false;}
+
+	protected:
+		bool bReadAttemptedAfterClose;
+		time_t LastIo;
+		int InactivityTimeout;
+
+	private:
+		void _DispatchInboundData (const char *buffer, int size);
+};
+
+
+
 #endif // __EventableDescriptor__H_
 
 

data/ext/eee

@@ -0,0 +1,173 @@
+# $Id: extconf.rb 501 2007-08-18 18:32:16Z blackhedd $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# extconf.rb for Ruby/EventMachine
+# We have to munge LDSHARED because this code needs a C++ link.
+#
+
+require 'mkmf'
+
+flags = []
+
+case RUBY_PLATFORM.split('-',2)[1]
+when 'mswin32', 'mingw32', 'bccwin32'
+  unless have_header('windows.h') and
+      have_header('winsock.h') and
+      have_library('kernel32') and
+      have_library('rpcrt4') and
+      have_library('gdi32')
+    exit
+  end
+
+  flags << "-D OS_WIN32"
+  flags << '-D BUILD_FOR_RUBY'
+  flags << "-EHs"
+  flags << "-GR"
+
+  dir_config('ssl')
+  if have_library('ssleay32') and
+	  have_library('libeay32') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-D WITH_SSL'
+  else
+    flags << '-D WITHOUT_SSL'
+  end
+
+when /solaris/
+  unless have_library('pthread') and
+	have_library('nsl') and
+	have_library('socket')
+	  exit
+  end
+
+  flags << '-D OS_UNIX'
+  flags << '-D OS_SOLARIS8'
+  flags << '-D BUILD_FOR_RUBY'
+
+  dir_config('ssl')
+  if have_library('ssl') and
+	  have_library('crypto') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-D WITH_SSL'
+  else
+    flags << '-D WITHOUT_SSL'
+  end
+
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+  # Patch by Tim Pease, fixes SUNWspro compile problems.
+  if CONFIG['CC'] == 'cc'
+    $CFLAGS = CONFIG['CFLAGS'] = "-g -O2 -fPIC"
+    CONFIG['CCDLFLAGS'] = "-fPIC"
+  end
+
+when /darwin/
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('ssl')
+  if have_library('ssl') and
+	  have_library('crypto') and
+	  have_library('C') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-DWITH_SSL'
+  else
+    flags << '-DWITHOUT_SSL'
+  end
+  # on Unix we need a g++ link, not gcc.
+  # Ff line contributed by Daniel Harple.
+  CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+when /linux/
+  unless have_library('pthread')
+	  exit
+  end
+
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  # Original epoll test is inadequate because 2.4 kernels have the header
+  # but not the code.
+  #flags << '-DHAVE_EPOLL' if have_header('sys/epoll.h')
+  if have_header('sys/epoll.h')
+	  File.open("hasEpollTest.c", "w") {|f|
+		  f.puts "#include <sys/epoll.h>"
+		  f.puts "int main() { epoll_create(1024); return 0;}"
+	  }
+	  (e = system( "gcc hasEpollTest.c -o hasEpollTest " )) and (e = $?.to_i)
+	  `rm -f hasEpollTest.c hasEpollTest`
+	  flags << '-DHAVE_EPOLL' if e == 0
+  end
+
+  dir_config('ssl', "#{ENV['OPENSSL']}/include", ENV['OPENSSL'])
+  # Check for libcrypto twice, before and after ssl. That's because on some platforms
+  # and openssl versions, libssl will emit unresolved externals from crypto. It
+  # would be cleaner to simply check crypto first, but that doesn't always work in 
+  # Ruby. The order we check them doesn't seem to control the order in which they're
+  # emitted into the link command. This is pretty weird, I have to admit.
+  if have_library('crypto') and
+	  have_library('ssl') and
+	  have_library('crypto') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-DWITH_SSL'
+  else
+    flags << '-DWITHOUT_SSL'
+  end
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+  # Modify the mkmf constant LINK_SO so the generated shared object is stripped.
+  # You might think modifying CONFIG['LINK_SO'] would be a better way to do this,
+  # but it doesn't work because mkmf doesn't look at CONFIG['LINK_SO'] again after
+  # it initializes.
+  linkso = Object.send :remove_const, "LINK_SO"
+  LINK_SO = linkso + "; strip $@"
+
+else
+  unless have_library('pthread')
+	  exit
+  end
+
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('ssl')
+  if have_library('ssl') and
+	  have_library('crypto') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-DWITH_SSL'
+  else
+    flags << '-DWITHOUT_SSL'
+  end
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+end
+
+if $CPPFLAGS
+  $CPPFLAGS += ' ' + flags.join(' ')
+else
+  $CFLAGS += ' ' + flags.join(' ')
+end
+
+
+create_makefile "rubyeventmachine"

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 386 2007-06-20 00:08:19Z blackhedd $
+$Id: em.cpp 533 2007-09-14 17:36:04Z blackhedd $
 
 File:     em.cpp
 Date:     06Apr06
@@ -414,6 +414,23 @@ bool EventMachine_t::_RunEpollOnce()
 	}
 
 	// 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();
+			}
+		}
+	}
 
 	timeval tv = {0,0};
 	EmSelect (0, NULL, NULL, NULL, &tv);
@@ -1375,7 +1392,7 @@ const char *EventMachine_t::Socketpair (char * const*cmd_strings)
 	pid_t f = fork();
 	if (f > 0) {
 		close (sv[1]);
-		PipeDescriptor *pd = new PipeDescriptor (fdopen(sv[0], "r+"), f, this);
+		PipeDescriptor *pd = new PipeDescriptor (sv[0], f, this);
 		if (!pd)
 			throw std::runtime_error ("unable to allocate pipe");
 		Add (pd);
@@ -1397,6 +1414,29 @@ const char *EventMachine_t::Socketpair (char * const*cmd_strings)
 }
 
 
+/****************************
+EventMachine_t::OpenKeyboard
+****************************/
+
+const char *EventMachine_t::OpenKeyboard()
+{
+	#ifdef OS_UNIX
+	KeyboardDescriptor *kd = new KeyboardDescriptor (this);
+	if (!kd)
+		throw std::runtime_error ("no keyboard-object allocated");
+	Add (kd);
+	return kd->GetBinding().c_str();
+	#endif
+
+	#ifdef OS_WIN32
+	throw std::runtime_error ("open-keyboard is currently unavailable on this platform");
+	return NULL;
+	#endif
+}
+
+
+
+
 
 //#endif // OS_UNIX
 

data/ext/em.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.h 377 2007-06-13 01:05:56Z blackhedd $
+$Id: em.h 502 2007-08-24 09:29:53Z blackhedd $
 
 File:     em.h
 Date:     06Apr06
@@ -70,6 +70,7 @@ class EventMachine_t
 		const char *OpenDatagramSocket (const char *, int);
 		const char *CreateUnixDomainServer (const char*);
 		const char *_OpenFileForWriting (const char*);
+		const char *OpenKeyboard();
 		//const char *Popen (const char*, const char*);
 		const char *Socketpair (char* const*);
 

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 426 2007-07-17 16:54:08Z blackhedd $
+$Id: eventmachine.h 502 2007-08-24 09:29:53Z blackhedd $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -43,6 +43,8 @@ extern "C" {
 	const char *evma_create_tcp_server (const char *address, int port);
 	const char *evma_create_unix_domain_server (const char *filename);
 	const char *evma_open_datagram_socket (const char *server, int port);
+	const char *evma_open_keyboard();
+	void evma_set_tls_parms (const char *binding, const char *privatekey_filename, const char *certchain_filenane);
 	void evma_start_tls (const char *binding);
 	int evma_get_peername (const char *binding, struct sockaddr*);
 	int evma_get_subprocess_pid (const char *binding, pid_t*);

data/ext/extconf.rb

@@ -1,4 +1,4 @@
-# $Id: extconf.rb 404 2007-07-13 01:07:28Z blackhedd $
+# $Id: extconf.rb 526 2007-09-11 17:43:23Z blackhedd $
 #
 #----------------------------------------------------------------------------
 #
@@ -116,8 +116,14 @@ when /linux/
 	  flags << '-DHAVE_EPOLL' if e == 0
   end
 
-  dir_config('ssl')
-  if have_library('ssl') and
+  dir_config('ssl', "#{ENV['OPENSSL']}/include", ENV['OPENSSL'])
+  # Check for libcrypto twice, before and after ssl. That's because on some platforms
+  # and openssl versions, libssl will emit unresolved externals from crypto. It
+  # would be cleaner to simply check crypto first, but that doesn't always work in 
+  # Ruby. The order we check them doesn't seem to control the order in which they're
+  # emitted into the link command. This is pretty weird, I have to admit.
+  if have_library('crypto') and
+	  have_library('ssl') and
 	  have_library('crypto') and
 	  have_header('openssl/ssl.h') and
 	  have_header('openssl/err.h')

data/ext/kb.cpp

@@ -0,0 +1,365 @@
+/*****************************************************************************
+
+$Id: kb.cpp 502 2007-08-24 09:29:53Z blackhedd $
+
+File:     kb.cpp
+Date:     24Aug07
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: blackhedd
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+#include "project.h"
+
+
+/**************************************
+KeyboardDescriptor::KeyboardDescriptor
+**************************************/
+
+KeyboardDescriptor::KeyboardDescriptor (EventMachine_t *parent_em):
+	EventableDescriptor (0, parent_em),
+	bReadAttemptedAfterClose (false),
+	LastIo (gCurrentLoopTime),
+	InactivityTimeout (0)
+{
+	#ifdef HAVE_EPOLL
+	EpollEvent.events = EPOLLIN;
+	#endif
+}
+
+
+/***************************************
+KeyboardDescriptor::~KeyboardDescriptor
+***************************************/
+
+KeyboardDescriptor::~KeyboardDescriptor()
+{
+}
+
+
+/*************************
+KeyboardDescriptor::Write
+*************************/
+
+void KeyboardDescriptor::Write()
+{
+	// Why are we here?
+	throw std::runtime_error ("bad code path in keyboard handler");
+}
+
+
+/*****************************
+KeyboardDescriptor::Heartbeat
+*****************************/
+
+void KeyboardDescriptor::Heartbeat()
+{
+	// no-op
+}
+
+
+/************************
+KeyboardDescriptor::Read
+************************/
+
+void KeyboardDescriptor::Read()
+{
+	char c;
+	read (GetSocket(), &c, 1);
+	if (EventCallback)
+		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, &c, 1);
+}
+
+
+
+
+#if 0
+/******************************
+PipeDescriptor::PipeDescriptor
+******************************/
+
+PipeDescriptor::PipeDescriptor (int fd, pid_t subpid, EventMachine_t *parent_em):
+	EventableDescriptor (fd, parent_em),
+	bReadAttemptedAfterClose (false),
+	LastIo (gCurrentLoopTime),
+	InactivityTimeout (0),
+	OutboundDataSize (0),
+	SubprocessPid (subpid)
+{
+	#ifdef HAVE_EPOLL
+	EpollEvent.events = EPOLLIN;
+	#endif
+}
+
+
+/*******************************
+PipeDescriptor::~PipeDescriptor
+*******************************/
+
+PipeDescriptor::~PipeDescriptor()
+{
+	// Run down any stranded outbound data.
+	for (size_t i=0; i < OutboundPages.size(); i++)
+		OutboundPages[i].Free();
+
+	/* As a virtual destructor, we come here before the base-class
+	 * destructor that closes our file-descriptor.
+	 * We have to make sure the subprocess goes down (if it's not
+	 * already down) and we have to reap the zombie.
+	 *
+	 * This implementation is PROVISIONAL and will surely be improved.
+	 * The intention here is that we never block, hence the highly
+	 * undesirable sleeps. But if we can't reap the subprocess even
+	 * after sending it SIGKILL, then something is wrong and we
+	 * throw a fatal exception, which is also not something we should
+	 * be doing.
+	 *
+	 * Eventually the right thing to do will be to have the reactor
+	 * core respond to SIGCHLD by chaining a handler on top of the
+	 * one Ruby may have installed, and dealing with a list of dead
+	 * children that are pending cleanup.
+	 *
+	 * Since we want to have a signal processor integrated into the
+	 * client-visible API, let's wait until that is done before cleaning
+	 * this up.
+	 */
+
+	struct timespec req = {0, 10000000};
+	kill (SubprocessPid, SIGTERM);
+	nanosleep (&req, NULL);
+	if (waitpid (SubprocessPid, NULL, WNOHANG) == 0) {
+		kill (SubprocessPid, SIGKILL);
+		nanosleep (&req, NULL);
+		if (waitpid (SubprocessPid, NULL, WNOHANG) == 0)
+			throw std::runtime_error ("unable to reap subprocess");
+	}
+}
+
+
+
+/********************
+PipeDescriptor::Read
+********************/
+
+void PipeDescriptor::Read()
+{
+	int sd = GetSocket();
+	if (sd == INVALID_SOCKET) {
+		assert (!bReadAttemptedAfterClose);
+		bReadAttemptedAfterClose = true;
+		return;
+	}
+
+	LastIo = gCurrentLoopTime;
+
+	int total_bytes_read = 0;
+	char readbuffer [16 * 1024];
+
+	for (int i=0; i < 10; i++) {
+		// Don't read just one buffer and then move on. This is faster
+		// if there is a lot of incoming.
+		// But don't read indefinitely. Give other sockets a chance to run.
+		// NOTICE, we're reading one less than the buffer size.
+		// That's so we can put a guard byte at the end of what we send
+		// to user code.
+		// Use read instead of recv, which on Linux gives a "socket operation
+		// on nonsocket" error.
+		
+
+		int r = read (sd, readbuffer, sizeof(readbuffer) - 1);
+		//cerr << "<R:" << r << ">";
+
+		if (r > 0) {
+			total_bytes_read += r;
+			LastRead = gCurrentLoopTime;
+
+			// Add a null-terminator at the the end of the buffer
+			// that we will send to the callback.
+			// DO NOT EVER CHANGE THIS. We want to explicitly allow users
+			// to be able to depend on this behavior, so they will have
+			// the option to do some things faster. Additionally it's
+			// a security guard against buffer overflows.
+			readbuffer [r] = 0;
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, readbuffer, r);
+			}
+		else if (r == 0) {
+			break;
+		}
+		else {
+			// Basically a would-block, meaning we've read everything there is to read.
+			break;
+		}
+
+	}
+
+
+	if (total_bytes_read == 0) {
+		// If we read no data on a socket that selected readable,
+		// it generally means the other end closed the connection gracefully.
+		ScheduleClose (false);
+		//bCloseNow = true;
+	}
+
+}
+
+/*********************
+PipeDescriptor::Write
+*********************/
+
+void PipeDescriptor::Write()
+{
+	int sd = GetSocket();
+	assert (sd != INVALID_SOCKET);
+
+	LastIo = gCurrentLoopTime;
+	char output_buffer [16 * 1024];
+	size_t nbytes = 0;
+
+	while ((OutboundPages.size() > 0) && (nbytes < sizeof(output_buffer))) {
+		OutboundPage *op = &(OutboundPages[0]);
+		if ((nbytes + op->Length - op->Offset) < sizeof (output_buffer)) {
+			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, op->Length - op->Offset);
+			nbytes += (op->Length - op->Offset);
+			op->Free();
+			OutboundPages.pop_front();
+		}
+		else {
+			int len = sizeof(output_buffer) - nbytes;
+			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, len);
+			op->Offset += len;
+			nbytes += len;
+		}
+	}
+
+	// We should never have gotten here if there were no data to write,
+	// so assert that as a sanity check.
+	// Don't bother to make sure nbytes is less than output_buffer because
+	// if it were we probably would have crashed already.
+	assert (nbytes > 0);
+
+	assert (GetSocket() != INVALID_SOCKET);
+	int bytes_written = write (GetSocket(), output_buffer, nbytes);
+
+	if (bytes_written > 0) {
+		OutboundDataSize -= bytes_written;
+		if ((size_t)bytes_written < nbytes) {
+			int len = nbytes - bytes_written;
+			char *buffer = (char*) malloc (len + 1);
+			if (!buffer)
+				throw std::runtime_error ("bad alloc throwing back data");
+			memcpy (buffer, output_buffer + bytes_written, len);
+			buffer [len] = 0;
+			OutboundPages.push_front (OutboundPage (buffer, len));
+		}
+		#ifdef HAVE_EPOLL
+		EpollEvent.events = (EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0));
+		assert (MyEventMachine);
+		MyEventMachine->Modify (this);
+		#endif
+	}
+	else {
+		#ifdef OS_UNIX
+		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
+		#endif
+		#ifdef OS_WIN32
+		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
+		#endif
+			Close();
+	}
+}
+
+
+/*************************
+PipeDescriptor::Heartbeat
+*************************/
+
+void PipeDescriptor::Heartbeat()
+{
+	// If an inactivity timeout is defined, then check for it.
+	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+		ScheduleClose (false);
+		//bCloseNow = true;
+}
+
+
+/*****************************
+PipeDescriptor::SelectForRead
+*****************************/
+
+bool PipeDescriptor::SelectForRead()
+{
+	/* Pipe descriptors, being local by definition, don't have
+	 * a pending state, so this is simpler than for the
+	 * ConnectionDescriptor object.
+	 */
+	return true;
+}
+
+/******************************
+PipeDescriptor::SelectForWrite
+******************************/
+
+bool PipeDescriptor::SelectForWrite()
+{
+	/* Pipe descriptors, being local by definition, don't have
+	 * a pending state, so this is simpler than for the
+	 * ConnectionDescriptor object.
+	 */
+	return (GetOutboundDataSize() > 0);
+}
+
+
+
+
+/********************************
+PipeDescriptor::SendOutboundData
+********************************/
+
+int PipeDescriptor::SendOutboundData (const char *data, int length)
+{
+	//if (bCloseNow || bCloseAfterWriting)
+	if (IsCloseScheduled())
+		return 0;
+
+	if (!data && (length > 0))
+		throw std::runtime_error ("bad outbound data");
+	char *buffer = (char *) malloc (length + 1);
+	if (!buffer)
+		throw std::runtime_error ("no allocation for outbound data");
+	memcpy (buffer, data, length);
+	buffer [length] = 0;
+	OutboundPages.push_back (OutboundPage (buffer, length));
+	OutboundDataSize += length;
+	#ifdef HAVE_EPOLL
+	EpollEvent.events = (EPOLLIN | EPOLLOUT);
+	assert (MyEventMachine);
+	MyEventMachine->Modify (this);
+	#endif
+	return length;
+}
+
+/********************************
+PipeDescriptor::GetSubprocessPid
+********************************/
+
+bool PipeDescriptor::GetSubprocessPid (pid_t *pid)
+{
+	bool ok = false;
+	if (pid && (SubprocessPid > 0)) {
+		*pid = SubprocessPid;
+		ok = true;
+	}
+	return ok;
+}
+
+#endif 
+