eventmachine 0.5.3 → 0.7.0

data/RELEASE_NOTES

@@ -1,7 +1,20 @@
-$Id: RELEASE_NOTES 64 2006-05-17 07:00:16Z blackhedd $
+$Id: RELEASE_NOTES 223 2006-08-08 20:30:41Z blackhedd $
 
 RUBY/EventMachine RELEASE NOTES
 
+--------------------------------------------------
+Version: 0.7.0, released xxAug06
+Added a fix in em.cpp/ConnectToServer to fix a fatal exception that
+occurred in FreeBSD when connecting successfully to a remote server.
+
+--------------------------------------------------
+Version: 0.6.0, released xxJul06
+Added deferred operations, suggested by Don Stocks, amillionhitpoints@yahoo.com.
+
+--------------------------------------------------
+Version: 0.5.4, released xxJun06
+Added get_peername support for streams and datagrams.
+
 --------------------------------------------------
 Version: 0.5.3, released 17May06
 Fixed bugs in extconf.rb, thanks to Daniel Harple, dharple@generalconsumption.org.

data/TODO

@@ -0,0 +1,10 @@
+$Id: TODO 231 2006-08-13 17:15:53Z blackhedd $
+
+TODO List:
+
+12Aug06: Noticed by Don Stocks. A TCP connect-request that results
+in a failed DNS resolution fires a fatal error back to user code.
+Uuuuuugly. We should probably cause an unbind event to get fired
+instead, and add some parameterization so the caller can detect
+the nature of the failure.
+

data/ext/cmain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: cmain.cpp 47 2006-05-15 21:42:38Z blackhedd $
+$Id: cmain.cpp 265 2006-10-05 19:07:45Z blackhedd $
 
 File:     libmain.cpp
 Date:     06Apr06
@@ -105,6 +105,17 @@ extern "C" const char *evma_create_tcp_server (const char *address, int port)
 	return EventMachine->CreateTcpServer (address, port);
 }
 
+/******************************
+evma_create_unix_domain_server
+******************************/
+
+extern "C" const char *evma_create_unix_domain_server (const char *filename)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->CreateUnixDomainServer (filename);
+}
+
 /*************************
 evma_open_datagram_socket
 *************************/
@@ -173,10 +184,95 @@ extern "C" void evma_start_tls (const char *binding)
 {
 	if (!EventMachine)
 		throw std::runtime_error ("not initialized");
-  EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-  if (ed)
-    ed->StartTls();
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->StartTls();
+}
+
+
+/*****************
+evma_get_peername
+*****************/
+
+extern "C" int evma_get_peername (const char *binding, struct sockaddr *sa)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetPeername (sa) ? 1 : 0;
+	}
+	else
+		return 0;
+}
+
+
+/*********************
+evma_signal_loopbreak
+*********************/
+
+extern "C" void evma_signal_loopbreak()
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventMachine->SignalLoopBreaker();
+}
+
+
+
+/****************
+evma__write_file
+****************/
+
+extern "C" const char *evma__write_file (const char *filename)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->_OpenFileForWriting (filename);
+}
+
+
+/********************************
+evma_get_comm_inactivity_timeout
+********************************/
+
+extern "C" int evma_get_comm_inactivity_timeout (const char *binding, int *value)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->GetCommInactivityTimeout (value);
+	}
+	else
+		return 0; //Perhaps this should be an exception. Access to an unknown binding.
 }
 
+/********************************
+evma_set_comm_inactivity_timeout
+********************************/
 
+extern "C" int evma_set_comm_inactivity_timeout (const char *binding, int *value)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed) {
+		return ed->SetCommInactivityTimeout (value);
+	}
+	else
+		return 0; //Perhaps this should be an exception. Access to an unknown binding.
+}
+
+
+/**********************
+evma_set_timer_quantum
+**********************/
+
+extern "C" void evma_set_timer_quantum (int interval)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+  EventMachine->SetTimerQuantum (interval);
+}
 

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 47 2006-05-15 21:42:38Z blackhedd $
+$Id: ed.cpp 255 2006-09-15 11:21:15Z blackhedd $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -159,13 +159,16 @@ ConnectionDescriptor::ConnectionDescriptor
 ******************************************/
 
 ConnectionDescriptor::ConnectionDescriptor (int sd):
-  EventableDescriptor (sd),
-  bConnectPending (false),
-  OutboundDataSize (0),
+	EventableDescriptor (sd),
+	bConnectPending (false),
+	bReadAttemptedAfterClose (false),
+	OutboundDataSize (0),
 	#ifdef WITH_SSL
 	SslBox (NULL),
 	#endif
-	bIsServer (false)
+	bIsServer (false),
+	LastIo (gCurrentLoopTime),
+	InactivityTimeout (0)
 {
 }
 
@@ -333,10 +336,33 @@ void ConnectionDescriptor::Read()
 	 * a socket that has already been scheduled for closing or close-after-writing.
 	 * In those cases, we'll leave it up the to protocol handler to "do the
 	 * right thing" (which probably means to ignore the incoming data).
+	 *
+	 * 22Aug06: Chris Ochs reports that on FreeBSD, it's possible to come
+	 * here with the socket already closed, after the process receives
+	 * a ctrl-C signal (not sure if that's TERM or INT on BSD). The application
+	 * was one in which network connections were doing a lot of interleaved reads
+	 * and writes.
+	 * Since we always write before reading (in order to keep the outbound queues
+	 * as light as possible), I think what happened is that an interrupt caused
+	 * the socket to be closed in ConnectionDescriptor::Write. We'll then
+	 * come here in the same pass through the main event loop, and won't get
+	 * cleaned up until immediately after.
+	 * We originally asserted that the socket was valid when we got here.
+	 * To deal properly with the possibility that we are closed when we get here,
+	 * I removed the assert. HOWEVER, the potential for an infinite loop scares me,
+	 * so even though this is really clunky, I added a flag to assert that we never
+	 * come here more than once after being closed. (FCianfrocca)
 	 */
 
 	int sd = GetSocket();
-	assert (sd != INVALID_SOCKET);
+	//assert (sd != INVALID_SOCKET); (original, removed 22Aug06)
+	if (sd == INVALID_SOCKET) {
+		assert (!bReadAttemptedAfterClose);
+		bReadAttemptedAfterClose = true;
+		return;
+	}
+
+	LastIo = gCurrentLoopTime;
 
 	int total_bytes_read = 0;
 	char readbuffer [16 * 1024];
@@ -345,6 +371,10 @@ void ConnectionDescriptor::Read()
 		// 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.
+		
 
 		int r = recv (sd, readbuffer, sizeof(readbuffer) - 1, 0);
 		//cerr << "<R:" << r << ">";
@@ -355,17 +385,18 @@ void ConnectionDescriptor::Read()
 
 			// Add a null-terminator at the the end of the buffer
 			// that we will send to the callback.
-			// DO NOT CHANGE THIS. We want to explicitly allow users
+			// 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.
+			// the option to do some things faster. Additionally it's
+			// a security guard against buffer overflows.
 			readbuffer [r] = 0;
-      _DispatchInboundData (readbuffer, r);
+			_DispatchInboundData (readbuffer, r);
 		}
 		else if (r == 0) {
 			break;
 		}
 		else {
-			// Basically a would-block, meaning we've everything there is to read.
+			// Basically a would-block, meaning we've read everything there is to read.
 			break;
 		}
 
@@ -424,19 +455,19 @@ ConnectionDescriptor::Write
 
 void ConnectionDescriptor::Write()
 {
-  /* A socket which is in a pending-connect state will select
-   * writable when the disposition of the connect is known.
-   * At that point, check to be sure there are no errors,
-   * and if none, then promote the socket out of the pending
-   * state.
-   * TODO: I haven't figured out how Windows signals errors on
-   * unconnected sockets. Maybe it does the untraditional but
-   * logical thing and makes the socket selectable for error.
-   * If so, it's unsupported here for the time being, and connect
-   * errors will have to be caught by the timeout mechanism.
-   */
+	/* A socket which is in a pending-connect state will select
+	 * writable when the disposition of the connect is known.
+	 * At that point, check to be sure there are no errors,
+	 * and if none, then promote the socket out of the pending
+	 * state.
+	 * TODO: I haven't figured out how Windows signals errors on
+	 * unconnected sockets. Maybe it does the untraditional but
+	 * logical thing and makes the socket selectable for error.
+	 * If so, it's unsupported here for the time being, and connect
+	 * errors will have to be caught by the timeout mechanism.
+	 */
 
-  if (bConnectPending) {
+	if (bConnectPending) {
 		int error;
 		socklen_t len;
 		len = sizeof(error);
@@ -446,14 +477,17 @@ void ConnectionDescriptor::Write()
 		#ifdef OS_WIN32
 		int o = getsockopt (MySocket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
 		#endif
-    if ((o == 0) && (error == 0))
-      bConnectPending = false;
-    else
-      bCloseNow = true;
-  }
-  else {
-	_WriteOutboundData();
-  }
+		if ((o == 0) && (error == 0)) {
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_COMPLETED, "", 0);
+			bConnectPending = false;
+		}
+		else
+			bCloseNow = true;
+	}
+	else {
+		_WriteOutboundData();
+	}
 }
 
 
@@ -473,6 +507,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
 
+	LastIo = gCurrentLoopTime;
 	char output_buffer [16 * 1024];
 	size_t nbytes = 0;
 
@@ -617,14 +652,20 @@ ConnectionDescriptor::Heartbeat
 
 void ConnectionDescriptor::Heartbeat()
 {
-  /* Only allow a certain amount of time to go by while waiting
-   * for a pending connect. If it expires, then kill the socket.
-   */
+	/* Only allow a certain amount of time to go by while waiting
+	 * for a pending connect. If it expires, then kill the socket.
+	 * For a connected socket, close it if its inactivity timer
+	 * has expired.
+	 */
 
-  if (bConnectPending) {
-    if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout)
-      bCloseNow = true;
-  }
+	if (bConnectPending) {
+		if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout)
+			bCloseNow = true;
+	}
+	else {
+		if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+			bCloseNow = true;
+	}
 }
 
 
@@ -748,7 +789,9 @@ DatagramDescriptor::DatagramDescriptor
 
 DatagramDescriptor::DatagramDescriptor (int sd):
 	EventableDescriptor (sd),
-	OutboundDataSize (0)
+	OutboundDataSize (0),
+	LastIo (gCurrentLoopTime),
+	InactivityTimeout (0)
 {
 	memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 }
@@ -766,6 +809,19 @@ DatagramDescriptor::~DatagramDescriptor()
 }
 
 
+/*****************************
+DatagramDescriptor::Heartbeat
+*****************************/
+
+void DatagramDescriptor::Heartbeat()
+{
+	// Close it if its inactivity timer has expired.
+
+  if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+		bCloseNow = true;
+}
+
+
 /************************
 DatagramDescriptor::Read
 ************************/
@@ -774,6 +830,7 @@ void DatagramDescriptor::Read()
 {
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
+	LastIo = gCurrentLoopTime;
 
 	// This is an extremely large read buffer.
 	// In many cases you wouldn't expect to get any more than 4K.
@@ -783,6 +840,9 @@ void DatagramDescriptor::Read()
 		// 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.
 
 		struct sockaddr_in sin;
 		socklen_t slen = sizeof (sin);
@@ -797,9 +857,10 @@ void DatagramDescriptor::Read()
 
 			// Add a null-terminator at the the end of the buffer
 			// that we will send to the callback.
-			// DO NOT CHANGE THIS. We want to explicitly allow users
+			// 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.
+			// the option to do some things faster. Additionally it's
+			// a security guard against buffer overflows.
 			readbuffer [r] = 0;
 
 
@@ -819,7 +880,7 @@ void DatagramDescriptor::Read()
 
 		}
 		else {
-			// Basically a would-block, meaning we've everything there is to read.
+			// Basically a would-block, meaning we've read everything there is to read.
 			break;
 		}
 
@@ -848,6 +909,7 @@ void DatagramDescriptor::Write()
 
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
+	LastIo = gCurrentLoopTime;
 
 	assert (OutboundPages.size() > 0);
 
@@ -923,7 +985,7 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 {
 	// This is an exact clone of ConnectionDescriptor::SendOutboundData.
 	// That means it needs to move to a common ancestor.
-  // TODO: Refactor this so there's no overlap with SendOutboundData.
+	// TODO: Refactor this so there's no overlap with SendOutboundData.
 
 	if (bCloseNow || bCloseAfterWriting)
 		return 0;
@@ -972,7 +1034,129 @@ int DatagramDescriptor::SendDatagram (const char *binding, const char *data, int
 	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
 	if (dd)
 		return dd->SendOutboundDatagram (data, length, address, port);
-  else
-    return -1;
+	else
+		return -1;
+}
+
+
+/*********************************
+ConnectionDescriptor::GetPeername
+*********************************/
+
+bool ConnectionDescriptor::GetPeername (struct sockaddr *s)
+{
+	bool ok = false;
+	if (s) {
+		socklen_t len = sizeof(*s);
+		int gp = getpeername (GetSocket(), s, &len);
+		if (gp == 0)
+			ok = true;
+	}
+	return ok;
+}
+
+
+/**********************************************
+ConnectionDescriptor::GetCommInactivityTimeout
+**********************************************/
+
+int ConnectionDescriptor::GetCommInactivityTimeout (int *value)
+{
+  if (value) {
+    *value = InactivityTimeout;
+    return 1;
+  }
+  else {
+    // TODO, extended logging, got bad parameter.
+    return 0;  
+  }
+}
+
+
+/**********************************************
+ConnectionDescriptor::SetCommInactivityTimeout
+**********************************************/
+
+int ConnectionDescriptor::SetCommInactivityTimeout (int *value)
+{
+  int out = 0;
+
+  if (value) {
+    if ((*value==0) || (*value >= 2)) {
+      // Replace the value and send the old one back to the caller.
+      int v = *value;
+      *value = InactivityTimeout;
+      InactivityTimeout = v;
+      out = 1;
+    }
+    else {
+      // TODO, extended logging, got bad value.
+    }
+  }
+  else {
+    // TODO, extended logging, got bad parameter.
+  }
+
+  return out;
+}
+
+/*******************************
+DatagramDescriptor::GetPeername
+*******************************/
+
+bool DatagramDescriptor::GetPeername (struct sockaddr *s)
+{
+	bool ok = false;
+	if (s) {
+		memset (s, 0, sizeof(struct sockaddr));
+		memcpy (s, &ReturnAddress, sizeof(ReturnAddress));
+		ok = true;
+	}
+	return ok;
+}
+
+
+
+/********************************************
+DatagramDescriptor::GetCommInactivityTimeout
+********************************************/
+
+int DatagramDescriptor::GetCommInactivityTimeout (int *value)
+{
+  if (value) {
+    *value = InactivityTimeout;
+    return 1;
+  }
+  else {
+    // TODO, extended logging, got bad parameter.
+    return 0;  
+  }
+}
+
+/********************************************
+DatagramDescriptor::SetCommInactivityTimeout
+********************************************/
+
+int DatagramDescriptor::SetCommInactivityTimeout (int *value)
+{
+  int out = 0;
+
+  if (value) {
+    if ((*value==0) || (*value >= 2)) {
+      // Replace the value and send the old one back to the caller.
+      int v = *value;
+      *value = InactivityTimeout;
+      InactivityTimeout = v;
+      out = 1;
+    }
+    else {
+      // TODO, extended logging, got bad value.
+    }
+  }
+  else {
+    // TODO, extended logging, got bad parameter.
+  }
+
+  return out;
 }
 

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 47 2006-05-15 21:42:38Z blackhedd $
+$Id: ed.h 254 2006-09-15 11:17:01Z blackhedd $
 
 File:     ed.h
 Date:     06Apr06
@@ -67,8 +67,15 @@ class EventableDescriptor: public Bindable_t
 
 		void SetEventCallback (void (*cb)(const char*, int, const char*, int));
 
+		virtual bool GetPeername (struct sockaddr*) {return false;}
+
     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;}
+
 	protected:
 		enum {
 			PendingConnectTimeout = 4 // can easily be made an instance variable
@@ -116,6 +123,10 @@ class ConnectionDescriptor: public EventableDescriptor
 		virtual void StartTls();
 		void SetServerMode() {bIsServer = true;}
 
+		virtual bool GetPeername (struct sockaddr*);
+
+    virtual int GetCommInactivityTimeout (int *value);
+    virtual int SetCommInactivityTimeout (int *value);
 
 	protected:
 		struct OutboundPage {
@@ -128,6 +139,7 @@ class ConnectionDescriptor: public EventableDescriptor
 
 	protected:
 		bool bConnectPending;
+		bool bReadAttemptedAfterClose;
 
 		deque<OutboundPage> OutboundPages;
 		int OutboundDataSize;
@@ -137,6 +149,9 @@ class ConnectionDescriptor: public EventableDescriptor
 		#endif
 		bool bIsServer;
 
+		time_t LastIo;
+		int InactivityTimeout;
+
 	private:
 		void _WriteOutboundData();
 		void _DispatchInboundData (const char *buffer, int size);
@@ -158,7 +173,7 @@ class DatagramDescriptor: public EventableDescriptor
 
 		virtual void Read();
 		virtual void Write();
-		virtual void Heartbeat() {}
+		virtual void Heartbeat();
 
 		virtual bool SelectForRead() {return true;}
 		virtual bool SelectForWrite();
@@ -169,6 +184,11 @@ class DatagramDescriptor: public EventableDescriptor
 		// Do we have any data to write? This is used by ShouldDelete.
 		virtual int GetOutboundDataSize() {return OutboundDataSize;}
 
+		virtual bool GetPeername (struct sockaddr*);
+
+    virtual int GetCommInactivityTimeout (int *value);
+    virtual int SetCommInactivityTimeout (int *value);
+
 		static int SendDatagram (const char*, const char*, int, const char*, int);
 
 
@@ -186,6 +206,9 @@ class DatagramDescriptor: public EventableDescriptor
 		int OutboundDataSize;
 
 		struct sockaddr_in ReturnAddress;
+
+		time_t LastIo;
+		int InactivityTimeout;
 };