void RoomService::start()
{
InternalMessage *imsg;
this->_run = true;
Logging::Message l("Service is running...", "RoomService", Logging::Message::NOTICE);
this->_log << l;
while (this->_run)
{
while (!this->_q.isEmpty())
{
imsg = this->_q.pop();
APacket *pck = imsg->getPacket();
Message *msg = reinterpret_cast<Message *>(pck->getData());
if (imsg->getProto() == ISocket::TCP)
(this->*_mfuncTCP[msg->getID()])(imsg->getFromTCP(), msg);
else
{
unsigned short id_room;
unsigned short id;
UDPPacket *pudp = reinterpret_cast<UDPPacket *>(pck);
UDPPacket::unpackID(pudp->getID(), id_room, id);
Room *room = Core::room_manager->getRoom(id_room);
if (room)
room->notify(new InternalMessage(pudp, imsg->getFromUDP()));
}
/* check delete */
delete imsg;
}
Ultra::Sleep::usleep(300);
}
}
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;
}
