bool UDPPacketReceiver::processRecv(bool expectingPacket)
{
Address srcAddr;
UDPPacket* pChannelReceiveWindow = CREATE_POOL_OBJECT(UDPPacket);
int len = pChannelReceiveWindow->recvFromEndPoint(*m_pEndPoint, &srcAddr);
if(len <= 0)
{
RELEASE_POOL_OBJECT(UDPPacket, pChannelReceiveWindow);
PacketReceiver::RecvState rstate = this->checkSocketErrors(len, expectingPacket);
return rstate == PacketReceiver::RECV_STATE_CONTINUE;
}
Channel* pSrcChannel = m_pNetworkInterface->findChannel(srcAddr);
if(pSrcChannel == NULL)
{
EndPoint* pNewEndPoint = CREATE_POOL_OBJECT(EndPoint);
pNewEndPoint->addr(srcAddr.m_port, srcAddr.m_ip);
pSrcChannel = CREATE_POOL_OBJECT(Channel, m_pNetworkInterface, pNewEndPoint, nullptr, PROTOCOL_UDP);
if (!pSrcChannel)
{
pSrcChannel->destroy();
RELEASE_POOL_OBJECT(Channel, pSrcChannel);
RELEASE_POOL_OBJECT(UDPPacket, pChannelReceiveWindow);
return false;
}
if(!m_pNetworkInterface->registerChannel(pSrcChannel))
{
RELEASE_POOL_OBJECT(UDPPacket, pChannelReceiveWindow);
pSrcChannel->destroy();
RELEASE_POOL_OBJECT(Channel, pSrcChannel);
return false;
}
}
SLASSERT(pSrcChannel != NULL, "wtf");
if(pSrcChannel->isCondemn())
{
RELEASE_POOL_OBJECT(UDPPacket, pChannelReceiveWindow);
m_pNetworkInterface->deregisterChannel(pSrcChannel);
pSrcChannel->destroy();
RELEASE_POOL_OBJECT(Channel, pSrcChannel);
return false;
}
Reason ret = this->processPacket(pSrcChannel, pChannelReceiveWindow);
if(ret != REASON_SUCCESS)
{
}
return true;
}
//-------------------------------------------------------------------------------------
bool UDPPacketReceiver::processSocket(bool expectingPacket)
{
// Channel* pChannel = networkInterface_.findChannel(endpoint_.addr());
// KBE_ASSERT(pChannel != NULL);
Address srcAddr;
UDPPacket* pChannelReceiveWindow = UDPPacket::ObjPool().createObject();
int len = pChannelReceiveWindow->recvFromEndPoint(*pEndpoint_, &srcAddr);
if (len <= 0)
{
UDPPacket::ObjPool().reclaimObject(pChannelReceiveWindow);
PacketReceiver::RecvState rstate = this->checkSocketErrors(len, expectingPacket);
return rstate == PacketReceiver::RECV_STATE_CONTINUE;
}
Channel* pSrcChannel = pNetworkInterface_->findChannel(srcAddr);
if(pSrcChannel == NULL)
{
EndPoint* pNewEndPoint = new EndPoint(srcAddr.ip, srcAddr.port);
pSrcChannel = new Channel(*pNetworkInterface_, pNewEndPoint, Channel::EXTERNAL, PROTOCOL_UDP);
if(!pNetworkInterface_->registerChannel(pSrcChannel))
{
ERROR_MSG(boost::format("UDPPacketReceiver::processSocket:registerChannel(%1%) is failed!\n") %
pSrcChannel->c_str());
UDPPacket::ObjPool().reclaimObject(pChannelReceiveWindow);
pSrcChannel->destroy();
return false;
}
}
KBE_ASSERT(pSrcChannel != NULL);
if(pSrcChannel->isCondemn())
{
UDPPacket::ObjPool().reclaimObject(pChannelReceiveWindow);
pNetworkInterface_->deregisterChannel(pSrcChannel);
pSrcChannel->destroy();
return false;
}
pSrcChannel->addReceiveWindow(pChannelReceiveWindow);
Reason ret = this->processPacket(pSrcChannel, pChannelReceiveWindow);
if(ret != REASON_SUCCESS)
this->dispatcher().errorReporter().reportException(ret, pEndpoint_->addr());
return true;
}
//-------------------------------------------------------------------------------------
bool UDPPacketReceiver::processRecv(bool expectingPacket)
{
Address srcAddr;
UDPPacket* pChannelReceiveWindow = UDPPacket::createPoolObject();
int len = pChannelReceiveWindow->recvFromEndPoint(*pEndpoint_, &srcAddr);
if (len <= 0)
{
UDPPacket::reclaimPoolObject(pChannelReceiveWindow);
PacketReceiver::RecvState rstate = this->checkSocketErrors(len, expectingPacket);
return rstate == PacketReceiver::RECV_STATE_CONTINUE;
}
Channel* pSrcChannel = pNetworkInterface_->findChannel(srcAddr);
if(pSrcChannel == NULL)
{
EndPoint* pNewEndPoint = EndPoint::createPoolObject();
pNewEndPoint->addr(srcAddr.port, srcAddr.ip);
pSrcChannel = Network::Channel::createPoolObject();
bool ret = pSrcChannel->initialize(*pNetworkInterface_, pNewEndPoint, Channel::EXTERNAL, PROTOCOL_UDP);
if(!ret)
{
ERROR_MSG(fmt::format("UDPPacketReceiver::processRecv: initialize({}) is failed!\n",
pSrcChannel->c_str()));
pSrcChannel->destroy();
Network::Channel::reclaimPoolObject(pSrcChannel);
UDPPacket::reclaimPoolObject(pChannelReceiveWindow);
return false;
}
if(!pNetworkInterface_->registerChannel(pSrcChannel))
{
ERROR_MSG(fmt::format("UDPPacketReceiver::processRecv: registerChannel({}) is failed!\n",
pSrcChannel->c_str()));
UDPPacket::reclaimPoolObject(pChannelReceiveWindow);
pSrcChannel->destroy();
Network::Channel::reclaimPoolObject(pSrcChannel);
return false;
}
}
KBE_ASSERT(pSrcChannel != NULL);
if(pSrcChannel->isCondemn())
{
UDPPacket::reclaimPoolObject(pChannelReceiveWindow);
pNetworkInterface_->deregisterChannel(pSrcChannel);
pSrcChannel->destroy();
Network::Channel::reclaimPoolObject(pSrcChannel);
return false;
}
Reason ret = this->processPacket(pSrcChannel, pChannelReceiveWindow);
if(ret != REASON_SUCCESS)
this->dispatcher().errorReporter().reportException(ret, pEndpoint_->addr());
return true;
}
