eventmachine 0.12.8-x86-mswin32-60 → 0.12.10-x86-mswin32-60

data/ext/cplusplus.cpp

@@ -1,202 +1,202 @@
-/*****************************************************************************
-
-$Id$
-
-File:     cplusplus.cpp
-Date:     27Jul07
-
-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"
-
-
-namespace EM {
-	static map<string, Eventable*> Eventables;
-	static map<string, void(*)()> Timers;
-}
-
-
-/*******
-EM::Run
-*******/
-
-void EM::Run (void (*start_func)())
-{
-	evma_set_epoll (1);
-	evma_initialize_library (EM::Callback);
-	if (start_func)
-		AddTimer (0, start_func);
-	evma_run_machine();
-	evma_release_library();
-}
-
-/************
-EM::AddTimer
-************/
-
-void EM::AddTimer (int milliseconds, void (*func)())
-{
-	if (func) {
-		const char *sig = evma_install_oneshot_timer (milliseconds);
-		#ifdef OS_SOLARIS8
-		Timers.insert (map<string, void(*)()>::value_type (sig, func));
-		#else
-		Timers.insert (make_pair (sig, func));
-		#endif
-	}
-}
-
-
-/***************
-EM::StopReactor
-***************/
-
-void EM::StopReactor()
-{
-	evma_stop_machine();
-}
-
-
-/********************
-EM::Acceptor::Accept
-********************/
-
-void EM::Acceptor::Accept (const char *signature)
-{
-	Connection *c = MakeConnection();
-	c->Signature = signature;
-	#ifdef OS_SOLARIS8
-	Eventables.insert (std::map<std::string,EM::Eventable*>::value_type (c->Signature, c));
-	#else
-	Eventables.insert (make_pair (c->Signature, c));
-	#endif
-	c->PostInit();
-}
-
-/************************
-EM::Connection::SendData
-************************/
-
-void EM::Connection::SendData (const char *data)
-{
-	if (data)
-		SendData (data, strlen (data));
-}
-
-
-/************************
-EM::Connection::SendData
-************************/
-
-void EM::Connection::SendData (const char *data, int length)
-{
-	evma_send_data_to_connection (Signature.c_str(), data, length);
-}
-
-
-/*********************
-EM::Connection::Close
-*********************/
-
-void EM::Connection::Close (bool afterWriting)
-{
-	evma_close_connection (Signature.c_str(), afterWriting);
-}
-
-
-/***************************
-EM::Connection::BindConnect
-***************************/
-
-void EM::Connection::BindConnect (const char *bind_addr, int bind_port, const char *host, int 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
-	Eventables.insert( make_pair (Signature, this));
-	#endif
-}
-
-/***********************
-EM::Connection::Connect
-***********************/
-
-void EM::Connection::Connect (const char *host, int port)
-{
-	this->BindConnect(NULL, 0, host, port);
-}
-
-/*******************
-EM::Acceptor::Start
-*******************/
-
-void EM::Acceptor::Start (const char *host, int port)
-{
-	Signature = evma_create_tcp_server (host, port);
-	#ifdef OS_SOLARIS8
-	Eventables.insert( std::map<std::string,EM::Eventable*>::value_type (Signature, this));
-	#else
-	Eventables.insert( make_pair (Signature, this));
-	#endif
-}
-
-
-
-/************
-EM::Callback
-************/
-
-void EM::Callback (const char *sig, int ev, const char *data, int length)
-{
-	EM::Eventable *e;
-	void (*f)();
-
-	switch (ev) {
-		case EM_TIMER_FIRED:
-			f = Timers [data];
-			if (f)
-				(*f)();
-			Timers.erase (sig);
-			break;
-
-		case EM_CONNECTION_READ:
-			e = EM::Eventables [sig];
-			e->ReceiveData (data, length);
-			break;
-
-		case EM_CONNECTION_COMPLETED:
-			e = EM::Eventables [sig];
-			e->ConnectionCompleted();
-			break;
-
-		case EM_CONNECTION_ACCEPTED:
-			e = EM::Eventables [sig];
-			e->Accept (data);
-			break;
-
-		case EM_CONNECTION_UNBOUND:
-			e = EM::Eventables [sig];
-			e->Unbind();
-			EM::Eventables.erase (sig);
-			delete e;
-			break;
-
-		case EM_SSL_HANDSHAKE_COMPLETED:
-			e = EM::Eventables [sig];
-			e->SslHandshakeCompleted();
-			break;
-	}
-}
-
+/*****************************************************************************
+
+$Id$
+
+File:     cplusplus.cpp
+Date:     27Jul07
+
+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"
+
+
+namespace EM {
+	static map<unsigned long, Eventable*> Eventables;
+	static map<unsigned long, void(*)()> Timers;
+}
+
+
+/*******
+EM::Run
+*******/
+
+void EM::Run (void (*start_func)())
+{
+	evma_set_epoll (1);
+	evma_initialize_library (EM::Callback);
+	if (start_func)
+		AddTimer (0, start_func);
+	evma_run_machine();
+	evma_release_library();
+}
+
+/************
+EM::AddTimer
+************/
+
+void EM::AddTimer (int milliseconds, void (*func)())
+{
+	if (func) {
+		const unsigned long sig = evma_install_oneshot_timer (milliseconds);
+		#ifndef HAVE_MAKE_PAIR
+		Timers.insert (map<unsigned long, void(*)()>::value_type (sig, func));
+		#else
+		Timers.insert (make_pair (sig, func));
+		#endif
+	}
+}
+
+
+/***************
+EM::StopReactor
+***************/
+
+void EM::StopReactor()
+{
+	evma_stop_machine();
+}
+
+
+/********************
+EM::Acceptor::Accept
+********************/
+
+void EM::Acceptor::Accept (const unsigned long signature)
+{
+	Connection *c = MakeConnection();
+	c->Signature = signature;
+	#ifndef HAVE_MAKE_PAIR
+	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (c->Signature, c));
+	#else
+	Eventables.insert (make_pair (c->Signature, c));
+	#endif
+	c->PostInit();
+}
+
+/************************
+EM::Connection::SendData
+************************/
+
+void EM::Connection::SendData (const char *data)
+{
+	if (data)
+		SendData (data, strlen (data));
+}
+
+
+/************************
+EM::Connection::SendData
+************************/
+
+void EM::Connection::SendData (const char *data, int length)
+{
+	evma_send_data_to_connection (Signature, data, length);
+}
+
+
+/*********************
+EM::Connection::Close
+*********************/
+
+void EM::Connection::Close (bool afterWriting)
+{
+	evma_close_connection (Signature, afterWriting);
+}
+
+
+/***************************
+EM::Connection::BindConnect
+***************************/
+
+void EM::Connection::BindConnect (const char *bind_addr, int bind_port, const char *host, int port)
+{
+	Signature = evma_connect_to_server (bind_addr, bind_port, host, port);
+	#ifndef HAVE_MAKE_PAIR
+	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (Signature, this));
+	#else
+	Eventables.insert (make_pair (Signature, this));
+	#endif
+}
+
+/***********************
+EM::Connection::Connect
+***********************/
+
+void EM::Connection::Connect (const char *host, int port)
+{
+	this->BindConnect(NULL, 0, host, port);
+}
+
+/*******************
+EM::Acceptor::Start
+*******************/
+
+void EM::Acceptor::Start (const char *host, int port)
+{
+	Signature = evma_create_tcp_server (host, port);
+	#ifndef HAVE_MAKE_PAIR
+	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (Signature, this));
+	#else
+	Eventables.insert (make_pair (Signature, this));
+	#endif
+}
+
+
+
+/************
+EM::Callback
+************/
+
+void EM::Callback (const unsigned long sig, int ev, const char *data, const unsigned long length)
+{
+	EM::Eventable *e;
+	void (*f)();
+
+	switch (ev) {
+		case EM_TIMER_FIRED:
+			f = Timers [length]; // actually a binding
+			if (f)
+				(*f)();
+			Timers.erase (length);
+			break;
+
+		case EM_CONNECTION_READ:
+			e = EM::Eventables [sig];
+			e->ReceiveData (data, length);
+			break;
+
+		case EM_CONNECTION_COMPLETED:
+			e = EM::Eventables [sig];
+			e->ConnectionCompleted();
+			break;
+
+		case EM_CONNECTION_ACCEPTED:
+			e = EM::Eventables [sig];
+			e->Accept (length); // actually a binding
+			break;
+
+		case EM_CONNECTION_UNBOUND:
+			e = EM::Eventables [sig];
+			e->Unbind();
+			EM::Eventables.erase (sig);
+			delete e;
+			break;
+
+		case EM_SSL_HANDSHAKE_COMPLETED:
+			e = EM::Eventables [sig];
+			e->SslHandshakeCompleted();
+			break;
+	}
+}
+

data/ext/ed.cpp

@@ -33,9 +33,16 @@ bool SetSocketNonblocking (SOCKET sd)
 	#endif
 	
 	#ifdef OS_WIN32
+	#ifdef BUILD_FOR_RUBY
+	// 14Jun09 Ruby provides its own wrappers for ioctlsocket. On 1.8 this is a simple wrapper,
+	// however, 1.9 keeps its own state about the socket.
+	// NOTE: F_GETFL is not supported
+	return (fcntl (sd, F_SETFL, O_NONBLOCK) == 0) ? true : false;
+	#else
 	unsigned long one = 1;
 	return (ioctlsocket (sd, FIONBIO, &one) == 0) ? true : false;
 	#endif
+	#endif
 }
 
 
@@ -51,7 +58,10 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	bCallbackUnbind (true),
 	UnbindReasonCode (0),
 	ProxyTarget(NULL),
-	MyEventMachine (em)
+	ProxiedFrom(NULL),
+	MaxOutboundBufSize(0),
+	MyEventMachine (em),
+	PendingConnectTimeout(20000000)
 {
 	/* There are three ways to close a socket, all of which should
 	 * automatically signal to the event machine that this object
@@ -81,6 +91,7 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	CreatedAt = gCurrentLoopTime;
 
 	#ifdef HAVE_EPOLL
+	EpollEvent.events = 0;
 	EpollEvent.data.ptr = this;
 	#endif
 }
@@ -93,7 +104,11 @@ EventableDescriptor::~EventableDescriptor
 EventableDescriptor::~EventableDescriptor()
 {
 	if (EventCallback && bCallbackUnbind)
-		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
+		(*EventCallback)(GetBinding(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
+	if (ProxiedFrom) {
+		(*EventCallback)(ProxiedFrom->GetBinding(), EM_PROXY_TARGET_UNBOUND, NULL, 0);
+		ProxiedFrom->StopProxy();
+	}
 	StopProxy();
 	Close();
 }
@@ -103,7 +118,7 @@ EventableDescriptor::~EventableDescriptor()
 EventableDescriptor::SetEventCallback
 *************************************/
 
-void EventableDescriptor::SetEventCallback (void(*cb)(const char*, int, const char*, int))
+void EventableDescriptor::SetEventCallback (void(*cb)(const unsigned long, int, const char*, const unsigned long))
 {
 	EventCallback = cb;
 }
@@ -172,12 +187,13 @@ bool EventableDescriptor::IsCloseScheduled()
 EventableDescriptor::StartProxy
 *******************************/
 
-void EventableDescriptor::StartProxy(const char *to)
+void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long bufsize)
 {
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (to));
 	if (ed) {
 		StopProxy();
-		ProxyTarget = strdup(to);
+		ProxyTarget = ed;
+		ed->SetProxiedFrom(this, bufsize);
 		return;
 	}
 	throw std::runtime_error ("Tried to proxy to an invalid descriptor");
@@ -191,12 +207,23 @@ EventableDescriptor::StopProxy
 void EventableDescriptor::StopProxy()
 {
 	if (ProxyTarget) {
-		free(ProxyTarget);
+		ProxyTarget->SetProxiedFrom(NULL, 0);
 		ProxyTarget = NULL;
 	}
 }
 
 
+/***********************************
+EventableDescriptor::SetProxiedFrom
+***********************************/
+
+void EventableDescriptor::SetProxiedFrom(EventableDescriptor *from, const unsigned long bufsize)
+{
+	ProxiedFrom = from;
+	MaxOutboundBufSize = bufsize;
+}
+
+
 /********************************************
 EventableDescriptor::_GenericInboundDispatch
 ********************************************/
@@ -205,12 +232,34 @@ 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();
+	if (ProxyTarget)
+		ProxyTarget->SendOutboundData(buf, size);
+	else
+		(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf, size);
+}
+
+
+/*********************************************
+EventableDescriptor::GetPendingConnectTimeout
+*********************************************/
+
+float EventableDescriptor::GetPendingConnectTimeout()
+{
+	return ((float)PendingConnectTimeout / 1000000);
+}
+
+
+/*********************************************
+EventableDescriptor::SetPendingConnectTimeout
+*********************************************/
+
+int EventableDescriptor::SetPendingConnectTimeout (float value)
+{
+	if (value > 0) {
+		PendingConnectTimeout = (Int64)(value * 1000000);
+		return 1;
 	}
+	return 0;
 }
 
 
@@ -220,9 +269,11 @@ ConnectionDescriptor::ConnectionDescriptor
 
 ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	EventableDescriptor (sd, em),
+	bPaused (false),
 	bConnectPending (false),
 	bNotifyReadable (false),
 	bNotifyWritable (false),
+	bWatchOnly (false),
 	bReadAttemptedAfterClose (false),
 	bWriteAttemptedAfterClose (false),
 	OutboundDataSize (0),
@@ -265,7 +316,7 @@ ConnectionDescriptor::~ConnectionDescriptor()
 STATIC: ConnectionDescriptor::SendDataToConnection
 **************************************************/
 
-int ConnectionDescriptor::SendDataToConnection (const char *binding, const char *data, int data_length)
+int ConnectionDescriptor::SendDataToConnection (const unsigned long binding, const char *data, int data_length)
 {
 	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
 	// TODO: Poor polymorphism here. We should be calling one virtual method
@@ -289,7 +340,7 @@ int ConnectionDescriptor::SendDataToConnection (const char *binding, const char
 STATIC: ConnectionDescriptor::CloseConnection
 *********************************************/
 
-void ConnectionDescriptor::CloseConnection (const char *binding, bool after_writing)
+void ConnectionDescriptor::CloseConnection (const unsigned long binding, bool after_writing)
 {
 	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
@@ -301,7 +352,7 @@ void ConnectionDescriptor::CloseConnection (const char *binding, bool after_writ
 STATIC: ConnectionDescriptor::ReportErrorStatus
 ***********************************************/
 
-int ConnectionDescriptor::ReportErrorStatus (const char *binding)
+int ConnectionDescriptor::ReportErrorStatus (const unsigned long binding)
 {
 	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
 	// TODO: Poor polymorphism here. We should be calling one virtual method
@@ -312,6 +363,49 @@ int ConnectionDescriptor::ReportErrorStatus (const char *binding)
 	return -1;
 }
 
+/***********************************
+ConnectionDescriptor::_UpdateEvents
+************************************/
+
+void ConnectionDescriptor::_UpdateEvents()
+{
+	_UpdateEvents(true, true);
+}
+
+void ConnectionDescriptor::_UpdateEvents(bool read, bool write)
+{
+	if (MySocket == INVALID_SOCKET)
+		return;
+
+	#ifdef HAVE_EPOLL
+	unsigned int old = EpollEvent.events;
+
+	if (read) {
+		if (SelectForRead())
+			EpollEvent.events |= EPOLLIN;
+		else
+			EpollEvent.events &= ~EPOLLIN;
+	}
+
+	if (write) {
+		if (SelectForWrite())
+			EpollEvent.events |= EPOLLOUT;
+		else
+			EpollEvent.events &= ~EPOLLOUT;
+	}
+
+	if (old != EpollEvent.events)
+		MyEventMachine->Modify (this);
+	#endif
+
+	#ifdef HAVE_KQUEUE
+	if (read && SelectForRead())
+		MyEventMachine->ArmKqueueReader (this);
+	if (write && SelectForWrite())
+		MyEventMachine->ArmKqueueWriter (this);
+	#endif
+}
+
 /***************************************
 ConnectionDescriptor::SetConnectPending
 ****************************************/
@@ -319,42 +413,67 @@ ConnectionDescriptor::SetConnectPending
 void ConnectionDescriptor::SetConnectPending(bool f)
 {
 	bConnectPending = f;
+	_UpdateEvents();
+}
 
-	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::SetWatchOnly
+***********************************/
+
+void ConnectionDescriptor::SetWatchOnly(bool watching)
+{
+	bWatchOnly = watching;
+	_UpdateEvents();
+}
+
+
+/*********************************
+ConnectionDescriptor::HandleError
+*********************************/
+
+void ConnectionDescriptor::HandleError()
+{
+	if (bWatchOnly) {
+		// An EPOLLHUP | EPOLLIN condition will call Read() before HandleError(), in which case the
+		// socket is already detached and invalid, so we don't need to do anything.
+		if (MySocket == INVALID_SOCKET) return;
+
+		// HandleError() is called on WatchOnly descriptors by the epoll reactor
+		// when it gets a EPOLLERR | EPOLLHUP. Usually this would show up as a readable and
+		// writable event on other reactors, so we have to fire those events ourselves.
+		if (bNotifyReadable) Read();
+		if (bNotifyWritable) Write();
+	} else {
+		ScheduleClose (false);
 	}
 }
 
 
+/***********************************
+ConnectionDescriptor::ScheduleClose
+***********************************/
+
+void ConnectionDescriptor::ScheduleClose (bool after_writing)
+{
+	if (bWatchOnly)
+		throw std::runtime_error ("cannot close 'watch only' connections");
+
+	EventableDescriptor::ScheduleClose(after_writing);
+}
+
+
 /***************************************
 ConnectionDescriptor::SetNotifyReadable
 ****************************************/
 
 void ConnectionDescriptor::SetNotifyReadable(bool readable)
 {
+	if (!bWatchOnly)
+		throw std::runtime_error ("notify_readable must be on 'watch only' connections");
+
 	bNotifyReadable = readable;
-	if (bNotifyReadable) {
-		#ifdef HAVE_EPOLL
-		EpollEvent.events |= EPOLLIN;
-		#endif
-		#ifdef HAVE_KQUEUE
-		MyEventMachine->ArmKqueueReader (this);
-		#endif
-	}
+	_UpdateEvents(true, false);
 }
 
 
@@ -364,15 +483,11 @@ ConnectionDescriptor::SetNotifyWritable
 
 void ConnectionDescriptor::SetNotifyWritable(bool writable)
 {
+	if (!bWatchOnly)
+		throw std::runtime_error ("notify_writable must be on 'watch only' connections");
+
 	bNotifyWritable = writable;
-	if (bNotifyWritable) {
-		#ifdef HAVE_EPOLL
-		EpollEvent.events |= EPOLLOUT;
-		#endif
-		#ifdef HAVE_KQUEUE
-		MyEventMachine->ArmKqueueWriter (this);
-		#endif
-	}
+	_UpdateEvents(false, true);
 }
 
 
@@ -382,6 +497,12 @@ ConnectionDescriptor::SendOutboundData
 
 int ConnectionDescriptor::SendOutboundData (const char *data, int length)
 {
+	if (bWatchOnly)
+		throw std::runtime_error ("cannot send data on a 'watch only' connection");
+
+	if (ProxiedFrom && MaxOutboundBufSize && GetOutboundDataSize() + length > MaxOutboundBufSize)
+		ProxiedFrom->Pause();
+
 	#ifdef WITH_SSL
 	if (SslBox) {
 		if (length > 0) {
@@ -434,14 +555,7 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	OutboundPages.push_back (OutboundPage (buffer, length));
 	OutboundDataSize += length;
 
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = (EPOLLIN | EPOLLOUT);
-	assert (MyEventMachine);
-	MyEventMachine->Modify (this);
-	#endif
-	#ifdef HAVE_KQUEUE
-	MyEventMachine->ArmKqueueWriter (this);
-	#endif
+	_UpdateEvents(false, true);
 
 	return length;
 }
@@ -468,7 +582,14 @@ bool ConnectionDescriptor::SelectForRead()
    * is known to be in a connected state.
    */
 
-  return bConnectPending ? false : true;
+  if (bPaused)
+    return false;
+  else if (bConnectPending)
+    return false;
+  else if (bWatchOnly)
+    return bNotifyReadable ? true : false;
+  else
+    return true;
 }
 
 
@@ -484,13 +605,45 @@ bool ConnectionDescriptor::SelectForWrite()
    * have outgoing data to send.
    */
 
-  if (bConnectPending || bNotifyWritable)
+  if (bPaused)
+    return false;
+  else if (bConnectPending)
     return true;
-  else {
+  else if (bWatchOnly)
+    return bNotifyWritable ? true : false;
+  else
     return (GetOutboundDataSize() > 0);
-  }
 }
 
+/***************************
+ConnectionDescriptor::Pause
+***************************/
+
+bool ConnectionDescriptor::Pause()
+{
+	if (bWatchOnly)
+		throw std::runtime_error ("cannot pause/resume 'watch only' connections, set notify readable/writable instead");
+
+	bool old = bPaused;
+	bPaused = true;
+	_UpdateEvents();
+	return old == false;
+}
+
+/****************************
+ConnectionDescriptor::Resume
+****************************/
+
+bool ConnectionDescriptor::Resume()
+{
+	if (bWatchOnly)
+		throw std::runtime_error ("cannot pause/resume 'watch only' connections, set notify readable/writable instead");
+
+	bool old = bPaused;
+	bPaused = false;
+	_UpdateEvents();
+	return old == true;
+}
 
 /**************************
 ConnectionDescriptor::Read
@@ -529,9 +682,9 @@ void ConnectionDescriptor::Read()
 		return;
 	}
 
-	if (bNotifyReadable) {
-		if (EventCallback)
-			(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_NOTIFY_READABLE, NULL, 0);
+	if (bWatchOnly) {
+		if (bNotifyReadable && EventCallback)
+			(*EventCallback)(GetBinding(), EM_CONNECTION_NOTIFY_READABLE, NULL, 0);
 		return;
 	}
 
@@ -635,7 +788,7 @@ void ConnectionDescriptor::_CheckHandshakeStatus()
 	if (SslBox && (!bHandshakeSignaled) && SslBox->IsHandshakeCompleted()) {
 		bHandshakeSignaled = true;
 		if (EventCallback)
-			(*EventCallback)(GetBinding().c_str(), EM_SSL_HANDSHAKE_COMPLETED, NULL, 0);
+			(*EventCallback)(GetBinding(), EM_SSL_HANDSHAKE_COMPLETED, NULL, 0);
 	}
 	#endif
 }
@@ -672,7 +825,7 @@ void ConnectionDescriptor::Write()
 		#endif
 		if ((o == 0) && (error == 0)) {
 			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_COMPLETED, "", 0);
+				(*EventCallback)(GetBinding(), EM_CONNECTION_COMPLETED, "", 0);
 
 			// 5May09: Moved epoll/kqueue read/write arming into SetConnectPending, so it can be called
 			// from EventMachine_t::AttachFD as well.
@@ -686,10 +839,14 @@ void ConnectionDescriptor::Write()
 
 		if (bNotifyWritable) {
 			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_NOTIFY_WRITABLE, NULL, 0);
+				(*EventCallback)(GetBinding(), EM_CONNECTION_NOTIFY_WRITABLE, NULL, 0);
+
+			_UpdateEvents(false, true);
 			return;
 		}
 
+		assert(!bWatchOnly);
+
 		/* 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
@@ -796,9 +953,12 @@ void ConnectionDescriptor::_WriteOutboundData()
 	assert (bytes_written >= 0);
 	OutboundDataSize -= bytes_written;
 
+	if (ProxiedFrom && MaxOutboundBufSize && GetOutboundDataSize() < MaxOutboundBufSize && ProxiedFrom->IsPaused())
+		ProxiedFrom->Resume();
+
 	#ifdef HAVE_WRITEV
 	if (!err) {
-		int sent = bytes_written;
+		unsigned int sent = bytes_written;
 		deque<OutboundPage>::iterator op = OutboundPages.begin();
 
 		for (int i = 0; i < iovcnt; i++) {
@@ -831,16 +991,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	}
 	#endif
 
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = (EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0));
-	assert (MyEventMachine);
-	MyEventMachine->Modify (this);
-	#endif
-	#ifdef HAVE_KQUEUE
-	if (SelectForWrite())
-		MyEventMachine->ArmKqueueWriter (this);
-	#endif
-
+	_UpdateEvents(false, true);
 
 	if (err) {
 		#ifdef OS_UNIX
@@ -886,7 +1037,7 @@ void ConnectionDescriptor::StartTls()
 	if (SslBox)
 		throw std::runtime_error ("SSL/TLS already running on connection");
 
-	SslBox = new SslBox_t (bIsServer, PrivateKeyFilename, CertChainFilename, bSslVerifyPeer, GetBinding().c_str());
+	SslBox = new SslBox_t (bIsServer, PrivateKeyFilename, CertChainFilename, bSslVerifyPeer, GetBinding());
 	_DispatchCiphertext();
 	#endif
 
@@ -942,7 +1093,7 @@ bool ConnectionDescriptor::VerifySslPeer(const char *cert)
 	bSslPeerAccepted = false;
 
 	if (EventCallback)
-		(*EventCallback)(GetBinding().c_str(), EM_SSL_VERIFY, cert, strlen(cert));
+		(*EventCallback)(GetBinding(), EM_SSL_VERIFY, cert, strlen(cert));
 
 	return bSslPeerAccepted;
 }
@@ -1126,7 +1277,7 @@ AcceptorDescriptor::~AcceptorDescriptor()
 STATIC: AcceptorDescriptor::StopAcceptor
 ****************************************/
 
-void AcceptorDescriptor::StopAcceptor (const char *binding)
+void AcceptorDescriptor::StopAcceptor (const unsigned long binding)
 {
 	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
 	AcceptorDescriptor *ad = dynamic_cast <AcceptorDescriptor*> (Bindable_t::GetObject (binding));
@@ -1192,7 +1343,7 @@ void AcceptorDescriptor::Read()
 			throw std::runtime_error ("no newly accepted connection");
 		cd->SetServerMode();
 		if (EventCallback) {
-			(*EventCallback) (GetBinding().c_str(), EM_CONNECTION_ACCEPTED, cd->GetBinding().c_str(), cd->GetBinding().size());
+			(*EventCallback) (GetBinding(), EM_CONNECTION_ACCEPTED, NULL, cd->GetBinding());
 		}
 		#ifdef HAVE_EPOLL
 		cd->GetEpollEvent()->events = EPOLLIN | (cd->SelectForWrite() ? EPOLLOUT : 0);
@@ -1279,7 +1430,7 @@ DatagramDescriptor::DatagramDescriptor (int sd, EventMachine_t *parent_em):
 	 */
 
 	int oval = 1;
-	int sob = setsockopt (GetSocket(), SOL_SOCKET, SO_BROADCAST, (char*)&oval, sizeof(oval));
+	setsockopt (GetSocket(), SOL_SOCKET, SO_BROADCAST, (char*)&oval, sizeof(oval));
 
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = EPOLLIN;
@@ -1437,6 +1588,10 @@ void DatagramDescriptor::Write()
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+	#ifdef HAVE_KQUEUE
+	if (SelectForWrite())
+		MyEventMachine->ArmKqueueWriter (this);
+	#endif
 }
 
 
@@ -1485,6 +1640,9 @@ int DatagramDescriptor::SendOutboundData (const char *data, int length)
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueWriter (this);
+	#endif
 
 	return length;
 }
@@ -1540,6 +1698,9 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 	assert (MyEventMachine);
 	MyEventMachine->Modify (this);
 	#endif
+	#ifdef HAVE_KQUEUE
+	MyEventMachine->ArmKqueueWriter (this);
+	#endif
 
 	return length;
 }
@@ -1549,7 +1710,7 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 STATIC: DatagramDescriptor::SendDatagram
 ****************************************/
 
-int DatagramDescriptor::SendDatagram (const char *binding, const char *data, int length, const char *address, int port)
+int DatagramDescriptor::SendDatagram (const unsigned long binding, const char *data, int length, const char *address, int port)
 {
 	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
 	if (dd)