int UdpClientTransport::receive(
I_ClientTransportCallback &clientStub,
ByteBuffer &byteBuffer,
unsigned int timeoutMs)
{
// try to receive a UDP message from server, within the current timeout
RCF_LOG_4()(mSock)(mDestIp.string())(timeoutMs) << "UdpClientTransport - receiving data from socket.";
RCF_ASSERT(!mAsync);
unsigned int startTimeMs = getCurrentTimeMs();
unsigned int endTimeMs = startTimeMs + timeoutMs;
while (true)
{
unsigned int timeoutMs = generateTimeoutMs(endTimeMs);
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET( static_cast<SOCKET>(mSock), &fdSet);
timeval timeout;
timeout.tv_sec = timeoutMs/1000;
timeout.tv_usec = 1000*(timeoutMs%1000);
int ret = Platform::OS::BsdSockets::select(
mSock+1,
&fdSet,
NULL,
NULL,
&timeout);
int err = Platform::OS::BsdSockets::GetLastError();
RCF_ASSERT(-1 <= ret && ret <= 1)(ret);
if (ret == -1)
{
Exception e(
_RcfError_Socket("select()"),
err,
RcfSubsystem_Os);
RCF_THROW(e);
}
else if (ret == 0)
{
Exception e( _RcfError_ClientReadTimeout() );
RCF_THROW(e);
}
RCF_ASSERT_EQ(ret , 1);
if (mReadVecPtr.get() == NULL || !mReadVecPtr.unique())
{
mReadVecPtr.reset( new ReallocBuffer());
}
// TODO: optimize
ReallocBuffer &buffer = *mReadVecPtr;
buffer.resize(4);
SockAddrStorage fromAddr;
memset(&fromAddr, 0, sizeof(fromAddr));
int fromAddrLen = sizeof(fromAddr);
sockaddr * pDestAddr = NULL;
Platform::OS::BsdSockets::socklen_t destAddrSize = 0;
mDestIp.getSockAddr(pDestAddr, destAddrSize);
int len = Platform::OS::BsdSockets::recvfrom(
mSock,
&buffer[0],
4,
MSG_PEEK,
(sockaddr *) &fromAddr,
&fromAddrLen);
err = Platform::OS::BsdSockets::GetLastError();
if ( len == 4
|| (len == -1 && err == Platform::OS::BsdSockets::ERR_EMSGSIZE))
{
mFromIp.init( (sockaddr&) fromAddr, fromAddrLen, mDestIp.getType());
if (mDestIp.matches(mFromIp))
{
boost::uint32_t dataLength = 0;
memcpy( &dataLength, &buffer[0], 4);
RCF::networkToMachineOrder(&dataLength, 4, 1);
if (getMaxMessageLength())
{
RCF_VERIFY(
0 < dataLength && dataLength <= getMaxMessageLength(),
Exception(_RcfError_ClientMessageLength(dataLength, getMaxMessageLength())));
}
buffer.resize(4+dataLength);
memset(&fromAddr, 0, sizeof(fromAddr));
fromAddrLen = sizeof(fromAddr);
len = Platform::OS::BsdSockets::recvfrom(
mSock,
&buffer[0],
dataLength+4,
0,
(sockaddr *) &fromAddr,
&fromAddrLen);
if (len == static_cast<int>(dataLength+4))
{
mLastResponseSize = dataLength+4;
mRunningTotalBytesReceived += dataLength+4;
byteBuffer = ByteBuffer(
&buffer[4],
dataLength,
4,
mReadVecPtr);
clientStub.onReceiveCompleted();
return 1;
}
}
else
{
// The packet is not a valid response, but we need to read
// it so we can receive more packets.
const std::size_t BufferSize = 4096;
char Buffer[BufferSize];
Platform::OS::BsdSockets::recvfrom(
mSock,
Buffer,
BufferSize,
0,
NULL,
NULL);
}
}
else
{
RCF_THROW( Exception( _RcfError_ClientReadFail() ) )(len)(err);
}
}
}
void UdpServerTransport::cycle(int timeoutMs)
{
RCF::ThreadInfoPtr tiPtr = getTlsThreadInfoPtr();
RCF::ThreadPool & threadPool = tiPtr->getThreadPool();
if (threadPool.shouldStop())
{
return;
}
// poll the UDP socket for messages, and read a message if one is available
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET( static_cast<SOCKET>(mFd), &fdSet);
timeval timeout;
timeout.tv_sec = timeoutMs/1000;
timeout.tv_usec = 1000*(timeoutMs%1000);
int ret = Platform::OS::BsdSockets::select(
mFd+1,
&fdSet,
NULL,
NULL,
timeoutMs < 0 ? NULL : &timeout);
int err = Platform::OS::BsdSockets::GetLastError();
if (ret == 1)
{
SessionStatePtr sessionStatePtr = getTlsUdpSessionStatePtr();
if (sessionStatePtr.get() == NULL)
{
sessionStatePtr = SessionStatePtr(new SessionState(*this));
sessionStatePtr->mSessionPtr = getSessionManager().createSession();
sessionStatePtr->mSessionPtr->setSessionState(*sessionStatePtr);
setTlsUdpSessionStatePtr(sessionStatePtr);
}
{
// read a message
ReallocBufferPtr &readVecPtr =
sessionStatePtr->mReadVecPtr;
if (readVecPtr.get() == NULL || !readVecPtr.unique())
{
readVecPtr.reset( new ReallocBuffer());
}
ReallocBuffer &buffer = *readVecPtr;
SockAddrStorage from;
int fromlen = sizeof(from);
memset(&from, 0, sizeof(from));
buffer.resize(4);
int len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4,
MSG_PEEK,
(sockaddr *) &from,
&fromlen);
err = Platform::OS::BsdSockets::GetLastError();
sessionStatePtr->mRemoteAddress.init(
(sockaddr&) from,
fromlen,
mIpAddress.getType());
if (!isIpAllowed(sessionStatePtr->mRemoteAddress))
{
RCF_LOG_2()(sessionStatePtr->mRemoteAddress.getIp())
<< "Client IP does not match server's IP access rules. Closing connection.";
discardPacket(mFd);
}
else if ( len == 4
|| (len == -1 && err == Platform::OS::BsdSockets::ERR_EMSGSIZE))
{
unsigned int dataLength = 0;
memcpy(&dataLength, &buffer[0], 4);
networkToMachineOrder(&dataLength, 4, 1);
if (getMaxMessageLength() && dataLength > getMaxMessageLength())
{
ByteBuffer byteBuffer;
encodeServerError(getSessionManager(), byteBuffer, RcfError_ServerMessageLength);
byteBuffer.expandIntoLeftMargin(4);
* (boost::uint32_t *) ( byteBuffer.getPtr() ) =
static_cast<boost::uint32_t>(byteBuffer.getLength()-4);
RCF::machineToNetworkOrder(byteBuffer.getPtr(), 4, 1);
char *buffer = byteBuffer.getPtr();
std::size_t bufferLen = byteBuffer.getLength();
sockaddr * pRemoteAddr = NULL;
Platform::OS::BsdSockets::socklen_t remoteAddrSize = 0;
sessionStatePtr->mRemoteAddress.getSockAddr(pRemoteAddr, remoteAddrSize);
int len = sendto(
mFd,
buffer,
static_cast<int>(bufferLen),
0,
pRemoteAddr,
remoteAddrSize);
RCF_UNUSED_VARIABLE(len);
discardPacket(mFd);
}
else
{
buffer.resize(4+dataLength);
memset(&from, 0, sizeof(from));
fromlen = sizeof(from);
len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4+dataLength,
0,
(sockaddr *) &from,
&fromlen);
if (static_cast<unsigned int>(len) == 4+dataLength)
{
getSessionManager().onReadCompleted(sessionStatePtr->mSessionPtr);
}
}
}
else
{
discardPacket(mFd);
}
}
}
else if (ret == 0)
{
//RCF_LOG_4()(mFd)(mPort)(timeoutMs) << "UdpServerTransport - no messages received within polling interval.";
}
else if (ret == -1)
{
Exception e(
_RcfError_Socket("select()"),
err,
RcfSubsystem_Os);
RCF_THROW(e)(mFd)(mIpAddress.string())(err);
}
}
void UdpServerTransport::cycle(
int timeoutMs,
const volatile bool &) //stopFlag
{
// poll the UDP socket for messages, and read a message if one is available
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET( static_cast<SOCKET>(mFd), &fdSet);
timeval timeout;
timeout.tv_sec = timeoutMs/1000;
timeout.tv_usec = 1000*(timeoutMs%1000);
int ret = Platform::OS::BsdSockets::select(
mFd+1,
&fdSet,
NULL,
NULL,
timeoutMs < 0 ? NULL : &timeout);
int err = Platform::OS::BsdSockets::GetLastError();
if (ret == 1)
{
SessionStatePtr sessionStatePtr = getCurrentUdpSessionStatePtr();
if (sessionStatePtr.get() == NULL)
{
sessionStatePtr = SessionStatePtr(new SessionState(*this));
SessionPtr sessionPtr = getSessionManager().createSession();
sessionPtr->setProactor(*sessionStatePtr);
sessionStatePtr->mSessionPtr = sessionPtr;
setCurrentUdpSessionStatePtr(sessionStatePtr);
RcfSessionPtr rcfSessionPtr =
boost::static_pointer_cast<RcfSession>(sessionPtr);
rcfSessionPtr->mIoState = RcfSession::Reading;
}
{
// read a message
boost::shared_ptr<std::vector<char> > &readVecPtr =
sessionStatePtr->mReadVecPtr;
if (readVecPtr.get() == NULL || !readVecPtr.unique())
{
readVecPtr.reset( new std::vector<char>());
}
std::vector<char> &buffer = *readVecPtr;
sockaddr from;
int fromlen = sizeof(from);
memset(&from, 0, sizeof(from));
buffer.resize(4);
int len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4,
MSG_PEEK,
&from,
&fromlen);
err = Platform::OS::BsdSockets::GetLastError();
if (isClientAddrAllowed( *(sockaddr_in *) &from ) &&
(len == 4 || (len == -1 && err == Platform::OS::BsdSockets::ERR_EMSGSIZE)))
{
sockaddr_in *remoteAddr = reinterpret_cast<sockaddr_in*>(&from);
sessionStatePtr->remoteAddress = IpAddress(*remoteAddr);
unsigned int dataLength = 0;
memcpy(&dataLength, &buffer[0], 4);
networkToMachineOrder(&dataLength, 4, 1);
if (dataLength <= static_cast<unsigned int>(getMaxMessageLength()))
{
buffer.resize(4+dataLength);
memset(&from, 0, sizeof(from));
fromlen = sizeof(from);
len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4+dataLength,
0,
&from,
&fromlen);
if (static_cast<unsigned int>(len) == 4+dataLength)
{
getSessionManager().onReadCompleted(sessionStatePtr->mSessionPtr);
}
}
else
{
ByteBuffer byteBuffer;
encodeServerError(byteBuffer, RcfError_ServerMessageLength);
byteBuffer.expandIntoLeftMargin(4);
* (boost::uint32_t *) ( byteBuffer.getPtr() ) =
static_cast<boost::uint32_t>(byteBuffer.getLength()-4);
RCF::machineToNetworkOrder(byteBuffer.getPtr(), 4, 1);
char *buffer = byteBuffer.getPtr();
std::size_t bufferLen = byteBuffer.getLength();
const sockaddr_in &remoteAddr =
sessionStatePtr->remoteAddress.getSockAddr();
int len = sendto(
mFd,
buffer,
static_cast<int>(bufferLen),
0,
(const sockaddr *) &remoteAddr,
sizeof(remoteAddr));
RCF_UNUSED_VARIABLE(len);
discardPacket(mFd);
}
}
else
{
// discard the message (sender ip not allowed, or message format bad)
discardPacket(mFd);
}
}
}
else if (ret == 0)
{
RCF_TRACE("server udp poll - no messages")(mFd)(mPort);
}
else if (ret == -1)
{
RCF_THROW(
Exception(
RcfError_Socket,
err,
RcfSubsystem_Os,
"udp server select() failed "))
(mFd)(mPort)(err);
}
}
