eventmachine 0.12.6-java → 0.12.8-java

data/ext/cplusplus.cpp

@@ -33,7 +33,7 @@ EM::Run
 
 void EM::Run (void (*start_func)())
 {
-	evma__epoll();
+	evma_set_epoll (1);
 	evma_initialize_library (EM::Callback);
 	if (start_func)
 		AddTimer (0, start_func);
@@ -115,13 +115,13 @@ void EM::Connection::Close (bool afterWriting)
 }
 
 
-/***********************
-EM::Connection::Connect
-***********************/
+/***************************
+EM::Connection::BindConnect
+***************************/
 
-void EM::Connection::Connect (const char *host, int port)
+void EM::Connection::BindConnect (const char *bind_addr, int bind_port, const char *host, int port)
 {
-	Signature = evma_connect_to_server (host, port);
+	Signature = evma_connect_to_server (bind_addr, bind_port, host, port);
 	#ifdef OS_SOLARIS8
 	Eventables.insert( std::map<std::string,EM::Eventable*>::value_type (Signature, this));
 	#else
@@ -129,6 +129,15 @@ void EM::Connection::Connect (const char *host, int port)
 	#endif
 }
 
+/***********************
+EM::Connection::Connect
+***********************/
+
+void EM::Connection::Connect (const char *host, int port)
+{
+	this->BindConnect(NULL, 0, host, port);
+}
+
 /*******************
 EM::Acceptor::Start
 *******************/

data/ext/ed.cpp

@@ -48,10 +48,9 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	bCloseAfterWriting (false),
 	MySocket (sd),
 	EventCallback (NULL),
-	LastRead (0),
-	LastWritten (0),
 	bCallbackUnbind (true),
 	UnbindReasonCode (0),
+	ProxyTarget(NULL),
 	MyEventMachine (em)
 {
 	/* There are three ways to close a socket, all of which should
@@ -95,6 +94,7 @@ EventableDescriptor::~EventableDescriptor()
 {
 	if (EventCallback && bCallbackUnbind)
 		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
+	StopProxy();
 	Close();
 }
 
@@ -168,6 +168,52 @@ bool EventableDescriptor::IsCloseScheduled()
 }
 
 
+/*******************************
+EventableDescriptor::StartProxy
+*******************************/
+
+void EventableDescriptor::StartProxy(const char *to)
+{
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (to));
+	if (ed) {
+		StopProxy();
+		ProxyTarget = strdup(to);
+		return;
+	}
+	throw std::runtime_error ("Tried to proxy to an invalid descriptor");
+}
+
+
+/******************************
+EventableDescriptor::StopProxy
+******************************/
+
+void EventableDescriptor::StopProxy()
+{
+	if (ProxyTarget) {
+		free(ProxyTarget);
+		ProxyTarget = NULL;
+	}
+}
+
+
+/********************************************
+EventableDescriptor::_GenericInboundDispatch
+********************************************/
+
+void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
+{
+	assert(EventCallback);
+
+	if (!ProxyTarget)
+		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, buf, size);
+	else if (ConnectionDescriptor::SendDataToConnection(ProxyTarget, buf, size) == -1) {
+		(*EventCallback)(GetBinding().c_str(), EM_PROXY_TARGET_UNBOUND, NULL, 0);
+		StopProxy();
+	}
+}
+
+
 /******************************************
 ConnectionDescriptor::ConnectionDescriptor
 ******************************************/
@@ -183,15 +229,18 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	#ifdef WITH_SSL
 	SslBox (NULL),
 	bHandshakeSignaled (false),
+	bSslVerifyPeer (false),
+	bSslPeerAccepted(false),
+	#endif
+	#ifdef HAVE_KQUEUE
+	bGotExtraKqueueEvent(false),
 	#endif
 	bIsServer (false),
 	LastIo (gCurrentLoopTime),
 	InactivityTimeout (0)
 {
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = EPOLLOUT;
-	#endif
 	// 22Jan09: Moved ArmKqueueWriter into SetConnectPending() to fix assertion failure in _WriteOutboundData()
+	//  5May09: Moved EPOLLOUT into SetConnectPending() so it doesn't happen for attached read pipes
 }
 
 
@@ -270,9 +319,60 @@ ConnectionDescriptor::SetConnectPending
 void ConnectionDescriptor::SetConnectPending(bool f)
 {
 	bConnectPending = f;
-	#ifdef HAVE_KQUEUE
-	MyEventMachine->ArmKqueueWriter (this);
-	#endif
+
+	if (bConnectPending) { // not yet connected, select for writability
+		#ifdef HAVE_EPOLL
+		EpollEvent.events = EPOLLOUT;
+		#endif
+		#ifdef HAVE_KQUEUE
+		MyEventMachine->ArmKqueueWriter (this);
+		#endif
+	} else { // connected, wait for incoming data and write out any pending outgoing data
+		#ifdef HAVE_EPOLL
+		EpollEvent.events = EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0);
+		#endif
+		#ifdef HAVE_KQUEUE
+		MyEventMachine->ArmKqueueReader (this);
+		if (SelectForWrite())
+			MyEventMachine->ArmKqueueWriter (this);
+		#endif
+	}
+}
+
+
+/***************************************
+ConnectionDescriptor::SetNotifyReadable
+****************************************/
+
+void ConnectionDescriptor::SetNotifyReadable(bool readable)
+{
+	bNotifyReadable = readable;
+	if (bNotifyReadable) {
+		#ifdef HAVE_EPOLL
+		EpollEvent.events |= EPOLLIN;
+		#endif
+		#ifdef HAVE_KQUEUE
+		MyEventMachine->ArmKqueueReader (this);
+		#endif
+	}
+}
+
+
+/***************************************
+ConnectionDescriptor::SetNotifyWritable
+****************************************/
+
+void ConnectionDescriptor::SetNotifyWritable(bool writable)
+{
+	bNotifyWritable = writable;
+	if (bNotifyWritable) {
+		#ifdef HAVE_EPOLL
+		EpollEvent.events |= EPOLLOUT;
+		#endif
+		#ifdef HAVE_KQUEUE
+		MyEventMachine->ArmKqueueWriter (this);
+		#endif
+	}
 }
 
 
@@ -328,10 +428,12 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	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);
@@ -340,6 +442,7 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	#ifdef HAVE_KQUEUE
 	MyEventMachine->ArmKqueueWriter (this);
 	#endif
+
 	return length;
 }
 
@@ -446,12 +549,11 @@ void ConnectionDescriptor::Read()
 		// to user code.
 		
 
-		int r = recv (sd, readbuffer, sizeof(readbuffer) - 1, 0);
+		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.
@@ -499,22 +601,25 @@ void ConnectionDescriptor::_DispatchInboundData (const char *buffer, int size)
 		while ((s = SslBox->GetPlaintext (B, sizeof(B) - 1)) > 0) {
 			_CheckHandshakeStatus();
 			B [s] = 0;
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, B, s);
+			_GenericInboundDispatch(B, s);
+		}
+
+		// If our SSL handshake had a problem, shut down the connection.
+		if (s == -2) {
+			ScheduleClose(false);
+			return;
 		}
+
 		_CheckHandshakeStatus();
-		// INCOMPLETE, s may indicate an SSL error that would force the connection down.
 		_DispatchCiphertext();
 	}
 	else {
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, buffer, size);
+		_GenericInboundDispatch(buffer, size);
 	}
 	#endif
 
 	#ifdef WITHOUT_SSL
-	if (EventCallback)
-		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, buffer, size);
+	_GenericInboundDispatch(buffer, size);
 	#endif
 }
 
@@ -568,17 +673,10 @@ void ConnectionDescriptor::Write()
 		if ((o == 0) && (error == 0)) {
 			if (EventCallback)
 				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_COMPLETED, "", 0);
-			bConnectPending = false;
-			#ifdef HAVE_EPOLL
-			// The callback may have scheduled outbound data.
-			EpollEvent.events = EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0);
-			#endif
-			#ifdef HAVE_KQUEUE
-			MyEventMachine->ArmKqueueReader (this);
-			// The callback may have scheduled outbound data.
-			if (SelectForWrite())
-				MyEventMachine->ArmKqueueWriter (this);
-			#endif
+
+			// 5May09: Moved epoll/kqueue read/write arming into SetConnectPending, so it can be called
+			// from EventMachine_t::AttachFD as well.
+			SetConnectPending (false);
 		}
 		else
 			ScheduleClose (false);
@@ -592,6 +690,22 @@ void ConnectionDescriptor::Write()
 			return;
 		}
 
+		/* 5May09: Kqueue bugs on OSX cause one extra writable event to fire even though we're using
+		   EV_ONESHOT. We ignore this extra event once, but only the first time. If it happens again,
+		   we should fall through to the assert(nbytes>0) failure to catch any EM bugs which might cause
+		   ::Write to be called in a busy-loop.
+		*/
+		#ifdef HAVE_KQUEUE
+		if (MyEventMachine->UsingKqueue()) {
+			if (OutboundDataSize == 0 && !bGotExtraKqueueEvent) {
+				bGotExtraKqueueEvent = true;
+				return;
+			} else if (OutboundDataSize > 0) {
+				bGotExtraKqueueEvent = false;
+			}
+		}
+		#endif
+
 		_WriteOutboundData();
 	}
 }
@@ -624,9 +738,25 @@ void ConnectionDescriptor::_WriteOutboundData()
 	}
 
 	LastIo = gCurrentLoopTime;
-	char output_buffer [16 * 1024];
 	size_t nbytes = 0;
 
+	#ifdef HAVE_WRITEV
+	int iovcnt = OutboundPages.size();
+	// Max of 16 outbound pages at a time
+	if (iovcnt > 16) iovcnt = 16;
+
+	struct iovec iov[ iovcnt ];
+
+	for(int i = 0; i < iovcnt; i++){
+		OutboundPage *op = &(OutboundPages[i]);
+		iov[i].iov_base = (void *)(op->Buffer + op->Offset);
+		iov[i].iov_len	= op->Length - op->Offset;
+
+		nbytes += iov[i].iov_len;
+	}
+	#else
+	char output_buffer [16 * 1024];
+
 	while ((OutboundPages.size() > 0) && (nbytes < sizeof(output_buffer))) {
 		OutboundPage *op = &(OutboundPages[0]);
 		if ((nbytes + op->Length - op->Offset) < sizeof (output_buffer)) {
@@ -642,6 +772,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 			nbytes += len;
 		}
 	}
+	#endif
 
 	// We should never have gotten here if there were no data to write,
 	// so assert that as a sanity check.
@@ -650,7 +781,11 @@ void ConnectionDescriptor::_WriteOutboundData()
 	assert (nbytes > 0);
 
 	assert (GetSocket() != INVALID_SOCKET);
-	int bytes_written = send (GetSocket(), output_buffer, nbytes, 0);
+	#ifdef HAVE_WRITEV
+	int bytes_written = writev (GetSocket(), iov, iovcnt);
+	#else
+	int bytes_written = write (GetSocket(), output_buffer, nbytes);
+	#endif
 
 	bool err = false;
 	if (bytes_written < 0) {
@@ -660,6 +795,31 @@ void ConnectionDescriptor::_WriteOutboundData()
 
 	assert (bytes_written >= 0);
 	OutboundDataSize -= bytes_written;
+
+	#ifdef HAVE_WRITEV
+	if (!err) {
+		int sent = bytes_written;
+		deque<OutboundPage>::iterator op = OutboundPages.begin();
+
+		for (int i = 0; i < iovcnt; i++) {
+			if (iov[i].iov_len <= sent) {
+				// Sent this page in full, free it.
+				op->Free();
+				OutboundPages.pop_front();
+
+				sent -= iov[i].iov_len;
+			} else {
+				// Sent part (or none) of this page, increment offset to send the remainder
+				op->Offset += sent;
+				break;
+			}
+
+			// Shouldn't be possible run out of pages before the loop ends
+			assert(op != OutboundPages.end());
+			*op++;
+		}
+	}
+	#else
 	if ((size_t)bytes_written < nbytes) {
 		int len = nbytes - bytes_written;
 		char *buffer = (char*) malloc (len + 1);
@@ -669,6 +829,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 		buffer [len] = 0;
 		OutboundPages.push_front (OutboundPage (buffer, len));
 	}
+	#endif
 
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = (EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0));
@@ -725,7 +886,7 @@ void ConnectionDescriptor::StartTls()
 	if (SslBox)
 		throw std::runtime_error ("SSL/TLS already running on connection");
 
-	SslBox = new SslBox_t (bIsServer, PrivateKeyFilename, CertChainFilename);
+	SslBox = new SslBox_t (bIsServer, PrivateKeyFilename, CertChainFilename, bSslVerifyPeer, GetBinding().c_str());
 	_DispatchCiphertext();
 	#endif
 
@@ -739,7 +900,7 @@ void ConnectionDescriptor::StartTls()
 ConnectionDescriptor::SetTlsParms
 *********************************/
 
-void ConnectionDescriptor::SetTlsParms (const char *privkey_filename, const char *certchain_filename)
+void ConnectionDescriptor::SetTlsParms (const char *privkey_filename, const char *certchain_filename, bool verify_peer)
 {
 	#ifdef WITH_SSL
 	if (SslBox)
@@ -748,6 +909,7 @@ void ConnectionDescriptor::SetTlsParms (const char *privkey_filename, const char
 		PrivateKeyFilename = privkey_filename;
 	if (certchain_filename && *certchain_filename)
 		CertChainFilename = certchain_filename;
+	bSslVerifyPeer = verify_peer;
 	#endif
 
 	#ifdef WITHOUT_SSL
@@ -770,6 +932,35 @@ X509 *ConnectionDescriptor::GetPeerCert()
 #endif
 
 
+/***********************************
+ConnectionDescriptor::VerifySslPeer
+***********************************/
+
+#ifdef WITH_SSL
+bool ConnectionDescriptor::VerifySslPeer(const char *cert)
+{
+	bSslPeerAccepted = false;
+
+	if (EventCallback)
+		(*EventCallback)(GetBinding().c_str(), EM_SSL_VERIFY, cert, strlen(cert));
+
+	return bSslPeerAccepted;
+}
+#endif
+
+
+/***********************************
+ConnectionDescriptor::AcceptSslPeer
+***********************************/
+
+#ifdef WITH_SSL
+void ConnectionDescriptor::AcceptSslPeer()
+{
+	bSslPeerAccepted = true;
+}
+#endif
+
+
 /*****************************************
 ConnectionDescriptor::_DispatchCiphertext
 *****************************************/
@@ -1156,7 +1347,6 @@ void DatagramDescriptor::Read()
 
 		// In UDP, a zero-length packet is perfectly legal.
 		if (r >= 0) {
-			LastRead = gCurrentLoopTime;
 
 			// Add a null-terminator at the the end of the buffer
 			// that we will send to the callback.
@@ -1178,8 +1368,7 @@ void DatagramDescriptor::Read()
 			memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 			memcpy (&ReturnAddress, &sin, slen);
 
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, readbuffer, r);
+			_GenericInboundDispatch(readbuffer, r);
 
 		}
 		else {
@@ -1290,11 +1479,13 @@ int DatagramDescriptor::SendOutboundData (const char *data, int length)
 	buffer [length] = 0;
 	OutboundPages.push_back (OutboundPage (buffer, length, ReturnAddress));
 	OutboundDataSize += length;
+
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = (EPOLLIN | EPOLLOUT);
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+
 	return length;
 }
 
@@ -1334,7 +1525,6 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 	pin.sin_port = htons (port);
 
 
-
 	if (!data && (length > 0))
 		throw std::runtime_error ("bad outbound data");
 	char *buffer = (char *) malloc (length + 1);
@@ -1344,11 +1534,13 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 	buffer [length] = 0;
 	OutboundPages.push_back (OutboundPage (buffer, length, pin));
 	OutboundDataSize += length;
+
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = (EPOLLIN | EPOLLOUT);
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+
 	return length;
 }
 
@@ -1404,16 +1596,9 @@ bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
 ConnectionDescriptor::GetCommInactivityTimeout
 **********************************************/
 
-int ConnectionDescriptor::GetCommInactivityTimeout (int *value)
+float ConnectionDescriptor::GetCommInactivityTimeout()
 {
-	if (value) {
-		*value = InactivityTimeout;
-		return 1;
-	}
-	else {
-		// TODO, extended logging, got bad parameter.
-		return 0;  
-	}
+	return ((float)InactivityTimeout / 1000000);
 }
 
 
@@ -1421,27 +1606,13 @@ int ConnectionDescriptor::GetCommInactivityTimeout (int *value)
 ConnectionDescriptor::SetCommInactivityTimeout
 **********************************************/
 
-int ConnectionDescriptor::SetCommInactivityTimeout (int *value)
+int ConnectionDescriptor::SetCommInactivityTimeout (float 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.
+	if (value > 0) {
+		InactivityTimeout = (Int64)(value * 1000000);
+		return 1;
 	}
-
-	return out;
+	return 0;
 }
 
 /*******************************
@@ -1481,42 +1652,81 @@ bool DatagramDescriptor::GetSockname (struct sockaddr *s)
 DatagramDescriptor::GetCommInactivityTimeout
 ********************************************/
 
-int DatagramDescriptor::GetCommInactivityTimeout (int *value)
+float DatagramDescriptor::GetCommInactivityTimeout()
 {
-  if (value) {
-    *value = InactivityTimeout;
-    return 1;
-  }
-  else {
-    // TODO, extended logging, got bad parameter.
-    return 0;  
-  }
+	return ((float)InactivityTimeout / 1000000);
 }
 
 /********************************************
 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.
-  }
+int DatagramDescriptor::SetCommInactivityTimeout (float value)
+{
+	if (value > 0) {
+		InactivityTimeout = (Int64)(value * 1000000);
+		return 1;
+	}
+	return 0;
+}
+
+
+/************************************
+InotifyDescriptor::InotifyDescriptor
+*************************************/
+
+InotifyDescriptor::InotifyDescriptor (EventMachine_t *em):
+	EventableDescriptor(0, em)
+{
+	bCallbackUnbind = false;
+
+	#ifndef HAVE_INOTIFY
+	throw std::runtime_error("no inotify support on this system");
+	#else
 
-  return out;
+	int fd = inotify_init();
+	if (fd == -1) {
+		char buf[200];
+		snprintf (buf, sizeof(buf)-1, "unable to create inotify descriptor: %s", strerror(errno));
+		throw std::runtime_error (buf);
+	}
+
+	MySocket = fd;
+	SetSocketNonblocking(MySocket);
+	#ifdef HAVE_EPOLL
+	EpollEvent.events = EPOLLIN;
+	#endif
+
+	#endif
+}
+
+
+/*************************************
+InotifyDescriptor::~InotifyDescriptor
+**************************************/
+
+InotifyDescriptor::~InotifyDescriptor()
+{
+	close(MySocket);
+	MySocket = INVALID_SOCKET;
 }
 
+/***********************
+InotifyDescriptor::Read
+************************/
+
+void InotifyDescriptor::Read()
+{
+	assert (MyEventMachine);
+	MyEventMachine->_ReadInotifyEvents();
+}
+
+
+/************************
+InotifyDescriptor::Write
+*************************/
+
+void InotifyDescriptor::Write()
+{
+	throw std::runtime_error("bad code path in inotify");
+}