eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/ext/ed.cpp

@@ -54,6 +54,7 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	bCloseNow (false),
 	bCloseAfterWriting (false),
 	MySocket (sd),
+	bWatchOnly (false),
 	EventCallback (NULL),
 	bCallbackUnbind (true),
 	UnbindReasonCode (0),
@@ -61,7 +62,8 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	ProxiedFrom(NULL),
 	MaxOutboundBufSize(0),
 	MyEventMachine (em),
-	PendingConnectTimeout(20000000)
+	PendingConnectTimeout(20000000),
+	InactivityTimeout (0)
 {
 	/* There are three ways to close a socket, all of which should
 	 * automatically signal to the event machine that this object
@@ -88,12 +90,13 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 		throw std::runtime_error ("bad eventable descriptor");
 	if (MyEventMachine == NULL)
 		throw std::runtime_error ("bad em in eventable descriptor");
-	CreatedAt = gCurrentLoopTime;
+	CreatedAt = MyEventMachine->GetCurrentLoopTime();
 
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = 0;
 	EpollEvent.data.ptr = this;
 	#endif
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 }
 
 
@@ -103,6 +106,8 @@ EventableDescriptor::~EventableDescriptor
 
 EventableDescriptor::~EventableDescriptor()
 {
+	if (NextHeartbeat)
+		MyEventMachine->ClearHeartbeat(NextHeartbeat, this);
 	if (EventCallback && bCallbackUnbind)
 		(*EventCallback)(GetBinding(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
 	if (ProxiedFrom) {
@@ -118,7 +123,7 @@ EventableDescriptor::~EventableDescriptor()
 EventableDescriptor::SetEventCallback
 *************************************/
 
-void EventableDescriptor::SetEventCallback (void(*cb)(const unsigned long, int, const char*, const unsigned long))
+void EventableDescriptor::SetEventCallback (EMCallback cb)
 {
 	EventCallback = cb;
 }
@@ -130,10 +135,46 @@ EventableDescriptor::Close
 
 void EventableDescriptor::Close()
 {
+	/* EventMachine relies on the fact that when close(fd)
+	 * is called that the fd is removed from any
+	 * epoll event queues.
+	 *
+	 * However, this is not *always* the behavior of close(fd)
+	 *
+	 * See man 4 epoll Q6/A6 and then consider what happens
+	 * when using pipes with eventmachine.
+	 * (As is often done when communicating with a subprocess)
+	 *
+	 * The pipes end up looking like:
+	 *
+	 * ls -l /proc/<pid>/fd
+	 * ...
+	 * lr-x------ 1 root root 64 2011-08-19 21:31 3 -> pipe:[940970]
+	 * l-wx------ 1 root root 64 2011-08-19 21:31 4 -> pipe:[940970]
+	 *
+	 * This meets the critera from man 4 epoll Q6/A4 for not
+	 * removing fds from epoll event queues until all fds
+	 * that reference the underlying file have been removed.
+	 *
+	 * If the EventableDescriptor associated with fd 3 is deleted,
+	 * its dtor will call EventableDescriptor::Close(),
+	 * which will call ::close(int fd).
+	 *
+	 * However, unless the EventableDescriptor associated with fd 4 is
+	 * also deleted before the next call to epoll_wait, events may fire
+	 * for fd 3 that were registered with an already deleted
+	 * EventableDescriptor.
+	 *
+	 * Therefore, it is necessary to notify EventMachine that
+	 * the fd associated with this EventableDescriptor is
+	 * closing.
+	 */
+
 	// Close the socket right now. Intended for emergencies.
-	if (MySocket != INVALID_SOCKET) {
+	if (MySocket != INVALID_SOCKET && !bWatchOnly) {
+		MyEventMachine->Closing (this);
 		shutdown (MySocket, 1);
-		closesocket (MySocket);
+		close (MySocket);
 		MySocket = INVALID_SOCKET;
 	}
 }
@@ -187,12 +228,13 @@ bool EventableDescriptor::IsCloseScheduled()
 EventableDescriptor::StartProxy
 *******************************/
 
-void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long bufsize)
+void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long bufsize, const unsigned long length)
 {
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (to));
 	if (ed) {
 		StopProxy();
 		ProxyTarget = ed;
+		BytesToProxy = length;
 		ed->SetProxiedFrom(this, bufsize);
 		return;
 	}
@@ -219,6 +261,9 @@ EventableDescriptor::SetProxiedFrom
 
 void EventableDescriptor::SetProxiedFrom(EventableDescriptor *from, const unsigned long bufsize)
 {
+	if (from != NULL && ProxiedFrom != NULL)
+		throw std::runtime_error ("Tried to proxy to a busy target");
+
 	ProxiedFrom = from;
 	MaxOutboundBufSize = bufsize;
 }
@@ -232,10 +277,24 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 {
 	assert(EventCallback);
 
-	if (ProxyTarget)
-		ProxyTarget->SendOutboundData(buf, size);
-	else
+	if (ProxyTarget) {
+		if (BytesToProxy > 0) {
+			unsigned long proxied = min(BytesToProxy, (unsigned long) size);
+			ProxyTarget->SendOutboundData(buf, proxied);
+			BytesToProxy -= proxied;
+			if (BytesToProxy == 0) {
+				StopProxy();
+				(*EventCallback)(GetBinding(), EM_PROXY_COMPLETED, NULL, 0);
+				if (proxied < size) {
+					(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf + proxied, size - proxied);
+				}
+			}
+		} else {
+			ProxyTarget->SendOutboundData(buf, size);
+		}
+	} else {
 		(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf, size);
+	}
 }
 
 
@@ -243,9 +302,9 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 EventableDescriptor::GetPendingConnectTimeout
 *********************************************/
 
-float EventableDescriptor::GetPendingConnectTimeout()
+uint64_t EventableDescriptor::GetPendingConnectTimeout()
 {
-	return ((float)PendingConnectTimeout / 1000000);
+	return PendingConnectTimeout / 1000;
 }
 
 
@@ -253,16 +312,43 @@ float EventableDescriptor::GetPendingConnectTimeout()
 EventableDescriptor::SetPendingConnectTimeout
 *********************************************/
 
-int EventableDescriptor::SetPendingConnectTimeout (float value)
+int EventableDescriptor::SetPendingConnectTimeout (uint64_t value)
 {
 	if (value > 0) {
-		PendingConnectTimeout = (Int64)(value * 1000000);
+		PendingConnectTimeout = value * 1000;
+		MyEventMachine->QueueHeartbeat(this);
 		return 1;
 	}
 	return 0;
 }
 
 
+/*************************************
+EventableDescriptor::GetNextHeartbeat
+*************************************/
+
+uint64_t EventableDescriptor::GetNextHeartbeat()
+{
+	if (NextHeartbeat)
+		MyEventMachine->ClearHeartbeat(NextHeartbeat, this);
+
+	NextHeartbeat = 0;
+
+	if (!ShouldDelete()) {
+		uint64_t time_til_next = InactivityTimeout;
+		if (IsConnectPending()) {
+			if (time_til_next == 0 || PendingConnectTimeout < time_til_next)
+				time_til_next = PendingConnectTimeout;
+		}
+		if (time_til_next == 0)
+			return 0;
+		NextHeartbeat = time_til_next + MyEventMachine->GetRealTime();
+	}
+
+	return NextHeartbeat;
+}
+
+
 /******************************************
 ConnectionDescriptor::ConnectionDescriptor
 ******************************************/
@@ -273,7 +359,6 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	bConnectPending (false),
 	bNotifyReadable (false),
 	bNotifyWritable (false),
-	bWatchOnly (false),
 	bReadAttemptedAfterClose (false),
 	bWriteAttemptedAfterClose (false),
 	OutboundDataSize (0),
@@ -286,9 +371,7 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	#ifdef HAVE_KQUEUE
 	bGotExtraKqueueEvent(false),
 	#endif
-	bIsServer (false),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0)
+	bIsServer (false)
 {
 	// 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
@@ -312,57 +395,6 @@ ConnectionDescriptor::~ConnectionDescriptor()
 }
 
 
-/**************************************************
-STATIC: ConnectionDescriptor::SendDataToConnection
-**************************************************/
-
-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
-	// instead of hacking out the runtime information of the target object.
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-	if (cd)
-		return cd->SendOutboundData (data, data_length);
-	DatagramDescriptor *ds = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
-	if (ds)
-		return ds->SendOutboundData (data, data_length);
-	#ifdef OS_UNIX
-	PipeDescriptor *ps = dynamic_cast <PipeDescriptor*> (Bindable_t::GetObject (binding));
-	if (ps)
-		return ps->SendOutboundData (data, data_length);
-	#endif
-	return -1;
-}
-
-
-/*********************************************
-STATIC: ConnectionDescriptor::CloseConnection
-*********************************************/
-
-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));
-	if (ed)
-		ed->ScheduleClose (after_writing);
-}
-
-/***********************************************
-STATIC: ConnectionDescriptor::ReportErrorStatus
-***********************************************/
-
-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
-	// instead of hacking out the runtime information of the target object.
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-	if (cd)
-		return cd->_ReportErrorStatus();
-	return -1;
-}
-
 /***********************************
 ConnectionDescriptor::_UpdateEvents
 ************************************/
@@ -500,7 +532,7 @@ 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)
+	if (ProxiedFrom && MaxOutboundBufSize && (unsigned int)(GetOutboundDataSize() + length) > MaxOutboundBufSize)
 		ProxiedFrom->Pause();
 
 	#ifdef WITH_SSL
@@ -541,7 +573,11 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	// (Well, not so bad, small pages are coalesced in ::Write)
 
 	if (IsCloseScheduled())
-	//if (bCloseNow || bCloseAfterWriting)
+		return 0;
+
+	// 25Mar10: Ignore 0 length packets as they are not meaningful in TCP (as opposed to UDP)
+	// and can cause the assert(nbytes>0) to fail when OutboundPages has a bunch of 0 length pages.
+	if (length == 0)
 		return 0;
 
 	if (!data && (length > 0))
@@ -688,7 +724,7 @@ void ConnectionDescriptor::Read()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	int total_bytes_read = 0;
 	char readbuffer [16 * 1024 + 1];
@@ -703,6 +739,7 @@ void ConnectionDescriptor::Read()
 		
 
 		int r = read (sd, readbuffer, sizeof(readbuffer) - 1);
+		int e = errno;
 		//cerr << "<R:" << r << ">";
 
 		if (r > 0) {
@@ -721,8 +758,21 @@ void ConnectionDescriptor::Read()
 			break;
 		}
 		else {
-			// Basically a would-block, meaning we've read everything there is to read.
-			break;
+			#ifdef OS_UNIX
+			if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EAGAIN) && (e != EINTR)) {
+			#endif
+			#ifdef OS_WIN32
+			if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
+			#endif
+				// 26Mar11: Previously, all read errors were assumed to be EWOULDBLOCK and ignored.
+				// Now, instead, we call Close() on errors like ECONNRESET and ENOTCONN.
+				UnbindReasonCode = e;
+				Close();
+				break;
+			} else {
+				// Basically a would-block, meaning we've read everything there is to read.
+				break;
+			}
 		}
 
 	}
@@ -831,9 +881,12 @@ void ConnectionDescriptor::Write()
 			// from EventMachine_t::AttachFD as well.
 			SetConnectPending (false);
 		}
-		else
+		else {
+			if (o == 0)
+				UnbindReasonCode = error;
 			ScheduleClose (false);
 			//bCloseNow = true;
+		}
 	}
 	else {
 
@@ -894,7 +947,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 	size_t nbytes = 0;
 
 	#ifdef HAVE_WRITEV
@@ -902,11 +955,19 @@ void ConnectionDescriptor::_WriteOutboundData()
 	// Max of 16 outbound pages at a time
 	if (iovcnt > 16) iovcnt = 16;
 
+	#ifdef CC_SUNWspro
+	struct iovec iov[16];
+	#else
 	struct iovec iov[ iovcnt ];
+	#endif
 
 	for(int i = 0; i < iovcnt; i++){
 		OutboundPage *op = &(OutboundPages[i]);
+		#ifdef CC_SUNWspro
+		iov[i].iov_base = (char *)(op->Buffer + op->Offset);
+		#else
 		iov[i].iov_base = (void *)(op->Buffer + op->Offset);
+		#endif
 		iov[i].iov_len	= op->Length - op->Offset;
 
 		nbytes += iov[i].iov_len;
@@ -945,6 +1006,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	#endif
 
 	bool err = false;
+	int e = errno;
 	if (bytes_written < 0) {
 		err = true;
 		bytes_written = 0;
@@ -953,7 +1015,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	assert (bytes_written >= 0);
 	OutboundDataSize -= bytes_written;
 
-	if (ProxiedFrom && MaxOutboundBufSize && GetOutboundDataSize() < MaxOutboundBufSize && ProxiedFrom->IsPaused())
+	if (ProxiedFrom && MaxOutboundBufSize && (unsigned int)GetOutboundDataSize() < MaxOutboundBufSize && ProxiedFrom->IsPaused())
 		ProxiedFrom->Resume();
 
 	#ifdef HAVE_WRITEV
@@ -995,22 +1057,28 @@ void ConnectionDescriptor::_WriteOutboundData()
 
 	if (err) {
 		#ifdef OS_UNIX
-		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
+		if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EINTR)) {
 		#endif
 		#ifdef OS_WIN32
-		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
+		if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
 		#endif
+			UnbindReasonCode = e;
 			Close();
+		}
 	}
 }
 
 
-/****************************************
-ConnectionDescriptor::_ReportErrorStatus
-****************************************/
+/***************************************
+ConnectionDescriptor::ReportErrorStatus
+***************************************/
 
-int ConnectionDescriptor::_ReportErrorStatus()
+int ConnectionDescriptor::ReportErrorStatus()
 {
+	if (MySocket == INVALID_SOCKET) {
+		return -1;
+	}
+
 	int error;
 	socklen_t len;
 	len = sizeof(error);
@@ -1022,8 +1090,10 @@ int ConnectionDescriptor::_ReportErrorStatus()
 	#endif
 	if ((o == 0) && (error == 0))
 		return 0;
+	else if (o == 0)
+		return error;
 	else
-		return 1;
+		return -1;
 }
 
 
@@ -1190,14 +1260,18 @@ void ConnectionDescriptor::Heartbeat()
 	 */
 
 	if (bConnectPending) {
-		if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout)
+		if ((MyEventMachine->GetCurrentLoopTime() - CreatedAt) >= PendingConnectTimeout) {
+			UnbindReasonCode = ETIMEDOUT;
 			ScheduleClose (false);
 			//bCloseNow = true;
+    }
 	}
 	else {
-		if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+		if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout)) {
+			UnbindReasonCode = ETIMEDOUT;
 			ScheduleClose (false);
 			//bCloseNow = true;
+    }
 	}
 }
 
@@ -1328,7 +1402,7 @@ void AcceptorDescriptor::Read()
 		//int val = fcntl (sd, F_GETFL, 0);
 		//if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
 			shutdown (sd, 1);
-			closesocket (sd);
+			close (sd);
 			continue;
 		}
 
@@ -1385,12 +1459,11 @@ void AcceptorDescriptor::Heartbeat()
 AcceptorDescriptor::GetSockname
 *******************************/
 
-bool AcceptorDescriptor::GetSockname (struct sockaddr *s)
+bool AcceptorDescriptor::GetSockname (struct sockaddr *s, socklen_t *len)
 {
 	bool ok = false;
 	if (s) {
-		socklen_t len = sizeof(*s);
-		int gp = getsockname (GetSocket(), s, &len);
+		int gp = getsockname (GetSocket(), s, len);
 		if (gp == 0)
 			ok = true;
 	}
@@ -1405,9 +1478,7 @@ DatagramDescriptor::DatagramDescriptor
 
 DatagramDescriptor::DatagramDescriptor (int sd, EventMachine_t *parent_em):
 	EventableDescriptor (sd, parent_em),
-	OutboundDataSize (0),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0)
+	OutboundDataSize (0)
 {
 	memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 
@@ -1461,7 +1532,7 @@ void DatagramDescriptor::Heartbeat()
 {
 	// Close it if its inactivity timer has expired.
 
-	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+	if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout))
 		ScheduleClose (false);
 		//bCloseNow = true;
 }
@@ -1475,7 +1546,7 @@ void DatagramDescriptor::Read()
 {
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	// This is an extremely large read buffer.
 	// In many cases you wouldn't expect to get any more than 4K.
@@ -1552,7 +1623,7 @@ void DatagramDescriptor::Write()
 
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	assert (OutboundPages.size() > 0);
 
@@ -1577,6 +1648,7 @@ void DatagramDescriptor::Write()
 			#ifdef OS_WIN32
 			if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
 			#endif
+				UnbindReasonCode = e;
 				Close();
 				break;
 			}
@@ -1618,11 +1690,11 @@ DatagramDescriptor::SendOutboundData
 
 int DatagramDescriptor::SendOutboundData (const char *data, int length)
 {
-	// This is an exact clone of ConnectionDescriptor::SendOutboundData.
-	// That means it needs to move to a common ancestor.
+	// This is almost an exact clone of ConnectionDescriptor::_SendRawOutboundData.
+	// That means most of it could be factored to a common ancestor. Note that
+	// empty datagrams are meaningful, which isn't the case for TCP streams.
 
 	if (IsCloseScheduled())
-	//if (bCloseNow || bCloseAfterWriting)
 		return 0;
 
 	if (!data && (length > 0))
@@ -1706,30 +1778,15 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 }
 
 
-/****************************************
-STATIC: DatagramDescriptor::SendDatagram
-****************************************/
-
-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)
-		return dd->SendOutboundDatagram (data, length, address, port);
-	else
-		return -1;
-}
-
-
 /*********************************
 ConnectionDescriptor::GetPeername
 *********************************/
 
-bool ConnectionDescriptor::GetPeername (struct sockaddr *s)
+bool ConnectionDescriptor::GetPeername (struct sockaddr *s, socklen_t *len)
 {
 	bool ok = false;
 	if (s) {
-		socklen_t len = sizeof(*s);
-		int gp = getpeername (GetSocket(), s, &len);
+		int gp = getpeername (GetSocket(), s, len);
 		if (gp == 0)
 			ok = true;
 	}
@@ -1740,12 +1797,11 @@ bool ConnectionDescriptor::GetPeername (struct sockaddr *s)
 ConnectionDescriptor::GetSockname
 *********************************/
 
-bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
+bool ConnectionDescriptor::GetSockname (struct sockaddr *s, socklen_t *len)
 {
 	bool ok = false;
 	if (s) {
-		socklen_t len = sizeof(*s);
-		int gp = getsockname (GetSocket(), s, &len);
+		int gp = getsockname (GetSocket(), s, len);
 		if (gp == 0)
 			ok = true;
 	}
@@ -1757,9 +1813,9 @@ bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
 ConnectionDescriptor::GetCommInactivityTimeout
 **********************************************/
 
-float ConnectionDescriptor::GetCommInactivityTimeout()
+uint64_t ConnectionDescriptor::GetCommInactivityTimeout()
 {
-	return ((float)InactivityTimeout / 1000000);
+	return InactivityTimeout / 1000;
 }
 
 
@@ -1767,23 +1823,22 @@ float ConnectionDescriptor::GetCommInactivityTimeout()
 ConnectionDescriptor::SetCommInactivityTimeout
 **********************************************/
 
-int ConnectionDescriptor::SetCommInactivityTimeout (float value)
+int ConnectionDescriptor::SetCommInactivityTimeout (uint64_t value)
 {
-	if (value > 0) {
-		InactivityTimeout = (Int64)(value * 1000000);
-		return 1;
-	}
-	return 0;
+	InactivityTimeout = value * 1000;
+	MyEventMachine->QueueHeartbeat(this);
+	return 1;
 }
 
 /*******************************
 DatagramDescriptor::GetPeername
 *******************************/
 
-bool DatagramDescriptor::GetPeername (struct sockaddr *s)
+bool DatagramDescriptor::GetPeername (struct sockaddr *s, socklen_t *len)
 {
 	bool ok = false;
 	if (s) {
+		*len = sizeof(struct sockaddr);
 		memset (s, 0, sizeof(struct sockaddr));
 		memcpy (s, &ReturnAddress, sizeof(ReturnAddress));
 		ok = true;
@@ -1795,12 +1850,11 @@ bool DatagramDescriptor::GetPeername (struct sockaddr *s)
 DatagramDescriptor::GetSockname
 *******************************/
 
-bool DatagramDescriptor::GetSockname (struct sockaddr *s)
+bool DatagramDescriptor::GetSockname (struct sockaddr *s, socklen_t *len)
 {
 	bool ok = false;
 	if (s) {
-		socklen_t len = sizeof(*s);
-		int gp = getsockname (GetSocket(), s, &len);
+		int gp = getsockname (GetSocket(), s, len);
 		if (gp == 0)
 			ok = true;
 	}
@@ -1813,19 +1867,20 @@ bool DatagramDescriptor::GetSockname (struct sockaddr *s)
 DatagramDescriptor::GetCommInactivityTimeout
 ********************************************/
 
-float DatagramDescriptor::GetCommInactivityTimeout()
+uint64_t DatagramDescriptor::GetCommInactivityTimeout()
 {
-	return ((float)InactivityTimeout / 1000000);
+	return InactivityTimeout / 1000;
 }
 
 /********************************************
 DatagramDescriptor::SetCommInactivityTimeout
 ********************************************/
 
-int DatagramDescriptor::SetCommInactivityTimeout (float value)
+int DatagramDescriptor::SetCommInactivityTimeout (uint64_t value)
 {
 	if (value > 0) {
-		InactivityTimeout = (Int64)(value * 1000000);
+		InactivityTimeout = value * 1000;
+		MyEventMachine->QueueHeartbeat(this);
 		return 1;
 	}
 	return 0;