eventmachine 0.4.5 → 0.5.1

data/RELEASE_NOTES

@@ -1,7 +1,23 @@
-$Id: RELEASE_NOTES 2326 2006-04-19 16:16:16Z francis $
+$Id: RELEASE_NOTES 2459 2006-05-05 17:11:04Z francis $
 
 RUBY/EventMachine RELEASE NOTES
 
+--------------------------------------------------
+Version: 0.5.1, released 05May06
+Made it possible to pass a Class rather than a Module
+to a protocol handler.
+Added Windows port.
+
+--------------------------------------------------
+Version: 0.5.0, released 30Apr06
+Added a preliminary SSL/TLS extension. This will probably
+change over the next few releases.
+
+--------------------------------------------------
+Version: 0.4.5, released 29Apr06
+Changed ext files so the ruby.h is installed after unistd.h
+otherwise it doesn't compile on gcc 4.1
+
 --------------------------------------------------
 Version: 0.4.2, released 19Apr06
 Changed the Ruby-glue so the extension will play nicer

data/ext/binder.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: binder.cpp 2381 2006-04-24 13:33:03Z francis $
+$Id: binder.cpp 2451 2006-05-05 03:16:31Z francis $
 
 File:     binder.cpp
 Date:     07Apr06
@@ -42,6 +42,7 @@ string Bindable_t::CreateBinding()
 	static string seed;
 
 	if ((index >= 1000000) || (seed.length() == 0)) {
+		#ifdef OS_UNIX
 		int fd = open (DEV_URANDOM, O_RDONLY);
 		if (fd < 0)
 			throw std::runtime_error ("No entropy device");
@@ -58,6 +59,21 @@ string Bindable_t::CreateBinding()
 			sprintf (u2 + (i * 2), "%02x", u1[i]);
 
 		seed = string (u2);
+		#endif
+
+
+		#ifdef OS_WIN32
+		UUID uuid;
+		UuidCreate (&uuid);
+		unsigned char *uuidstring = NULL;
+		UuidToString (&uuid, &uuidstring);
+		if (!uuidstring)
+			throw std::runtime_error ("Unable to read uuid");
+		seed = string ((const char*)uuidstring);
+
+		RpcStringFree (&uuidstring);
+		#endif
+
 		index = 0;
 
 

data/ext/binder.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: binder.h 2291 2006-04-14 03:56:18Z francis $
+$Id: binder.h 2412 2006-04-29 01:18:59Z francis $
 
 File:     binder.h
 Date:     07Apr06

data/ext/cmain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: libmain.cpp 2291 2006-04-14 03:56:18Z francis $
+$Id: cmain.cpp 2416 2006-04-29 02:02:16Z francis $
 
 File:     libmain.cpp
 Date:     06Apr06
@@ -165,4 +165,18 @@ extern "C" void evma_stop_machine()
 }
 
 
+/**************
+evma_start_tls
+**************/
+
+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();
+}
+
+
 

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 2382 2006-04-25 03:03:53Z francis $
+$Id: ed.cpp 2457 2006-05-05 14:57:21Z francis $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -27,6 +27,25 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "project.h"
 
 
+
+/********************
+SetSocketNonblocking
+********************/
+
+bool SetSocketNonblocking (SOCKET sd)
+{
+	#ifdef OS_UNIX
+	int val = fcntl (sd, F_GETFL, 0);
+	return (fcntl (sd, F_SETFL, val | O_NONBLOCK) != SOCKET_ERROR) ? true : false;
+	#endif
+	
+	#ifdef OS_WIN32
+	unsigned long one = 1;
+	return (ioctlsocket (sd, FIONBIO, &one) == 0) ? true : false;
+	#endif
+}
+
+
 /****************************************
 EventableDescriptor::EventableDescriptor
 ****************************************/
@@ -60,7 +79,7 @@ EventableDescriptor::EventableDescriptor (int sd):
    * effect of discarding outbound data.
    */
 
-  if (sd == -1)
+  if (sd == INVALID_SOCKET)
     throw std::runtime_error ("bad eventable descriptor");
   CreatedAt = gCurrentLoopTime;
 }
@@ -95,10 +114,10 @@ EventableDescriptor::Close
 void EventableDescriptor::Close()
 {
 	// Close the socket right now. Intended for emergencies.
-	if (MySocket != -1) {
+	if (MySocket != INVALID_SOCKET) {
 		shutdown (MySocket, 1);
-		close (MySocket);
-		MySocket = -1;
+		closesocket (MySocket);
+		MySocket = INVALID_SOCKET;
 	}
 }
 
@@ -118,7 +137,7 @@ bool EventableDescriptor::ShouldDelete()
 	 * if there is outbound data to write, and only request a close if there is none.
 	 */
 
-	return ((MySocket == -1) || bCloseNow || (bCloseAfterWriting && (GetOutboundDataSize() <= 0)));
+	return ((MySocket == INVALID_SOCKET) || bCloseNow || (bCloseAfterWriting && (GetOutboundDataSize() <= 0)));
 }
 
 
@@ -142,7 +161,9 @@ ConnectionDescriptor::ConnectionDescriptor
 ConnectionDescriptor::ConnectionDescriptor (int sd):
   EventableDescriptor (sd),
   bConnectPending (false),
-  OutboundDataSize (0)
+  OutboundDataSize (0),
+	SslBox (NULL),
+	bIsServer (false)
 {
 }
 
@@ -156,6 +177,9 @@ ConnectionDescriptor::~ConnectionDescriptor()
 	// Run down any stranded outbound data.
 	for (size_t i=0; i < OutboundPages.size(); i++)
 		OutboundPages[i].Free();
+
+	if (SslBox)
+		delete SslBox;
 }
 
 
@@ -196,6 +220,36 @@ ConnectionDescriptor::SendOutboundData
 
 int ConnectionDescriptor::SendOutboundData (const char *data, int length)
 {
+	if (SslBox) {
+		if (length > 0) {
+			int w = SslBox->PutPlaintext (data, length);
+			if (w < 0)
+				ScheduleClose (false);
+			else
+				_DispatchCiphertext();
+		}
+		// TODO: What's the correct return value?
+		return 1; // That's a wild guess, almost certainly wrong.
+	}
+	else
+		return _SendRawOutboundData (data, length);
+}
+
+
+
+/******************************************
+ConnectionDescriptor::_SendRawOutboundData
+******************************************/
+
+int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
+{
+	/* This internal method is called to schedule bytes that
+	 * will be sent out to the remote peer.
+	 * It's not directly accessed by the caller, who hits ::SendOutboundData,
+	 * which may or may not filter or encrypt the caller's data before
+	 * sending it here.
+	 */
+
 	// Highly naive and incomplete implementation.
 	// There's no throttle for runaways (which should abort only this connection
 	// and not the whole process), and no coalescing of small pages.
@@ -276,7 +330,7 @@ void ConnectionDescriptor::Read()
 	 */
 
 	int sd = GetSocket();
-	assert (sd != -1);
+	assert (sd != INVALID_SOCKET);
 
 	int total_bytes_read = 0;
 	char readbuffer [16 * 1024];
@@ -299,10 +353,7 @@ void ConnectionDescriptor::Read()
 			// to be able to depend on this behavior, so they will have
 			// the option to do some things faster.
 			readbuffer [r] = 0;
-
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_READ, readbuffer, r);
-
+      _DispatchInboundData (readbuffer, r);
 		}
 		else if (r == 0) {
 			break;
@@ -324,6 +375,36 @@ void ConnectionDescriptor::Read()
 }
 
 
+
+/******************************************
+ConnectionDescriptor::_DispatchInboundData
+******************************************/
+
+void ConnectionDescriptor::_DispatchInboundData (const char *buffer, int size)
+{
+	if (SslBox) {
+		SslBox->PutCiphertext (buffer, size);
+
+		int s;
+		char B [2048];
+		while ((s = SslBox->GetPlaintext (B, sizeof(B) - 1)) > 0) {
+			B [s] = 0;
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_READ, B, s);
+		}
+		// INCOMPLETE, s may indicate an SSL error that would force the connection down.
+		_DispatchCiphertext();
+	}
+	else {
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_READ, buffer, size);
+	}
+}
+
+
+
+
+
 /***************************
 ConnectionDescriptor::Write
 ***************************/
@@ -335,13 +416,23 @@ void ConnectionDescriptor::Write()
    * 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) {
 		int error;
 		socklen_t len;
 		len = sizeof(error);
+		#ifdef OS_UNIX
 		int o = getsockopt (MySocket, SOL_SOCKET, SO_ERROR, &error, &len);
+		#endif
+		#ifdef OS_WIN32
+		int o = getsockopt (MySocket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
+		#endif
     if ((o == 0) && (error == 0))
       bConnectPending = false;
     else
@@ -367,7 +458,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	 */
 
 	int sd = GetSocket();
-	assert (sd != -1);
+	assert (sd != INVALID_SOCKET);
 
 	char output_buffer [16 * 1024];
 	size_t nbytes = 0;
@@ -394,7 +485,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	// if it were we probably would have crashed already.
 	assert (nbytes > 0);
 
-	assert (GetSocket() != -1);
+	assert (GetSocket() != INVALID_SOCKET);
 	int bytes_written = send (GetSocket(), output_buffer, nbytes, 0);
 
 	if (bytes_written > 0) {
@@ -410,13 +501,97 @@ void ConnectionDescriptor::_WriteOutboundData()
 		}
 	}
 	else {
+		#ifdef OS_UNIX
 		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
+		#endif
+		#ifdef OS_WIN32
+		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
+		#endif
 			Close();
 	}
 }
 
 
 
+/******************************
+ConnectionDescriptor::StartTls
+******************************/
+
+void ConnectionDescriptor::StartTls()
+{
+	if (SslBox)
+		throw std::runtime_error ("SSL/TLS already running on connection");
+
+	SslBox = new SslBox_t (bIsServer);
+	_DispatchCiphertext();
+}
+
+
+
+/*****************************************
+ConnectionDescriptor::_DispatchCiphertext
+*****************************************/
+
+void ConnectionDescriptor::_DispatchCiphertext()
+{
+	assert (SslBox);
+
+
+	char BigBuf [2048];
+	bool did_work;
+
+	do {
+		did_work = false;
+
+		// try to drain ciphertext
+		while (SslBox->CanGetCiphertext()) {
+			int r = SslBox->GetCiphertext (BigBuf, sizeof(BigBuf));
+			assert (r > 0);
+			_SendRawOutboundData (BigBuf, r);
+			did_work = true;
+		}
+
+		// Pump the SslBox, in case it has queued outgoing plaintext
+		// This will return >0 if data was written,
+		// 0 if no data was written, and <0 if there was a fatal error.
+		bool pump;
+		do {
+			pump = false;
+			int w = SslBox->PutPlaintext (NULL, 0);
+			if (w > 0) {
+				did_work = true;
+				pump = true;
+			}
+			else if (w < 0)
+				ScheduleClose (false);
+		} while (pump);
+
+		// try to put plaintext. INCOMPLETE, doesn't belong here?
+		// In SendOutboundData, we're spooling plaintext directly
+		// into SslBox. That may be wrong, we may need to buffer it
+		// up here! 
+		/*
+		const char *ptr;
+		int ptr_length;
+		while (OutboundPlaintext.GetPage (&ptr, &ptr_length)) {
+			assert (ptr && (ptr_length > 0));
+			int w = SslMachine.PutPlaintext (ptr, ptr_length);
+			if (w > 0) {
+				OutboundPlaintext.DiscardBytes (w);
+				did_work = true;
+			}
+			else
+				break;
+		}
+		*/
+
+	} while (did_work);
+
+}
+
+
+
+
 /*******************************
 ConnectionDescriptor::Heartbeat
 *******************************/
@@ -486,7 +661,7 @@ void AcceptorDescriptor::Read()
 
 	for (int i=0; i < 10; i++) {
 		int sd = accept (GetSocket(), (struct sockaddr*)&pin, &addrlen);
-		if (sd == -1) {
+		if (sd == INVALID_SOCKET) {
 			// This breaks the loop when we've accepted everything on the kernel queue,
 			// up to 10 new connections. But what if the *first* accept fails?
 			// Does that mean anything serious is happening, beyond the situation
@@ -497,10 +672,11 @@ void AcceptorDescriptor::Read()
 		// Set the newly-accepted socket non-blocking.
 		// On Windows, this may fail because, weirdly, Windows inherits the non-blocking
 		// attribute that we applied to the acceptor socket into the accepted one.
-		int val = fcntl (sd, F_GETFL, 0);
-		if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
+		if (!SetSocketNonblocking (sd)) {
+		//int val = fcntl (sd, F_GETFL, 0);
+		//if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
 			shutdown (sd, 1);
-			close (sd);
+			closesocket (sd);
 			continue;
 		}
 
@@ -513,6 +689,7 @@ void AcceptorDescriptor::Read()
 		ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
 		if (!cd)
 			throw std::runtime_error ("no newly accepted connection");
+		cd->SetServerMode();
 		if (EventCallback) {
 			(*EventCallback) (GetBinding().c_str(), EventMachine_t::CONNECTION_ACCEPTED, cd->GetBinding().c_str(), cd->GetBinding().size());
 		}
@@ -554,7 +731,7 @@ DatagramDescriptor::DatagramDescriptor (int sd):
 	EventableDescriptor (sd),
 	OutboundDataSize (0)
 {
-	bzero (&ReturnAddress, sizeof(ReturnAddress));
+	memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 }
 
 
@@ -577,7 +754,7 @@ DatagramDescriptor::Read
 void DatagramDescriptor::Read()
 {
 	int sd = GetSocket();
-	assert (sd != -1);
+	assert (sd != INVALID_SOCKET);
 
 	// This is an extremely large read buffer.
 	// In many cases you wouldn't expect to get any more than 4K.
@@ -590,7 +767,7 @@ void DatagramDescriptor::Read()
 
 		struct sockaddr_in sin;
 		socklen_t slen = sizeof (sin);
-		bzero (&sin, slen);
+		memset (&sin, 0, slen);
 
 		int r = recvfrom (sd, readbuffer, sizeof(readbuffer) - 1, 0, (struct sockaddr*)&sin, &slen);
 		//cerr << "<R:" << r << ">";
@@ -615,7 +792,7 @@ void DatagramDescriptor::Read()
 			// There is a different call (evma_send_datagram) for cases where the caller
 			// actually wants to send a packet somewhere else.
 
-			bzero (&ReturnAddress, sizeof(ReturnAddress));
+			memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 			memcpy (&ReturnAddress, &sin, slen);
 
 			if (EventCallback)
@@ -651,7 +828,7 @@ void DatagramDescriptor::Write()
 	 */
 
 	int sd = GetSocket();
-	assert (sd != -1);
+	assert (sd != INVALID_SOCKET);
 
 	assert (OutboundPages.size() > 0);
 
@@ -668,8 +845,13 @@ void DatagramDescriptor::Write()
 		op->Free();
 		OutboundPages.pop_front();
 
-		if (s == -1) {
+		if (s == SOCKET_ERROR) {
+			#ifdef OS_UNIX
 			if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EINTR)) {
+			#endif
+			#ifdef OS_WIN32
+			if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
+			#endif
 				Close();
 				break;
 			}
@@ -773,7 +955,3 @@ int DatagramDescriptor::SendDatagram (const char *binding, const char *data, int
     return -1;
 }
 
-
-
-
-