void
Svc_Handler::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
if (result.success () && result.bytes_transferred () > 0)
{
result.message_block ().rd_ptr ()[result.message_block ().length ()] = '\0';
// Print out the message received from the server.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) message size %d.\n"),
result.message_block ().length ()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%C"),
result.message_block ().rd_ptr ()));
// Reset the message block here to make sure multiple writes to
// the pipe don't keep appending to the message_block!
this->mb_.reset ();
this->ar_.read (this->mb_, this->mb_.size ());
}
else
ACE_Proactor::end_event_loop ();
}
void ProactorService::handle_read_stream( const ACE_Asynch_Read_Stream::Result& result )
{
ACE_Message_Block& block = result.message_block();
if (!result.success() || result.bytes_transferred() == 0)
{
block.release();
ReserveClose();
}
else
{
if (false == ISession::OnReceive(block.rd_ptr(), (unsigned short)block.length(), m_sessionDesc))
{
block.release();
ReserveClose();
return;
}
//20150322 memory leak fix
SendInternal(block.rd_ptr(), (unsigned short)block.length());
block.release();
PostRecv();
}
}
void
PSession::trace_read_completion (const ACE_Asynch_Read_Stream::Result &result)
{
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ());
this->update_last_time();
if (result.success())
this->total_rcv_ += result.bytes_transferred ();
}
int loglevel = this->config().loglevel ();
ACE_Message_Block & mb = result.message_block ();
size_t xfer_bytes = result.bytes_transferred();
char * last = mb.wr_ptr();
char * first = last - xfer_bytes;
if (loglevel == 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) **** %s=%d handle_read_stream() ****\n"),
this->get_name(),
this->index()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("bytes_to_read = %d\n"),
result.bytes_to_read ()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("handle = %d\n"),
result.handle ()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("bytes_transfered = %d\n"),
xfer_bytes));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("error = %d\n"),
result.error ()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("message_block:\n")));
ACE_HEX_DUMP ((LM_DEBUG, first, xfer_bytes));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("**** end of message ****************\n")));
}
else if (result.error () != 0 )
{
LogLocker log_lock;
ACE_Log_Msg::instance ()->errnum (result.error ());
ACE_OS::last_error (result.error ());
ACE_Log_Msg::instance ()->log (LM_ERROR,
ACE_TEXT ("(%t) %s=%d READ %p\n"),
this->get_name (),
this->index (),
ACE_TEXT ("ERROR"));
}
else if (loglevel == 1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) %s=%d read_bytes=%d OK\n"),
this->get_name (),
this->index (),
xfer_bytes));
}
return;
}
void Reciever::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_Message_Block &mb = result.message_block ();
//if the connection is failed£¬release the connection resource to the client
if (!result.success () || result.bytes_transferred () == 0)
{
mb.release ();
delete this;
return;
}
ACE_OS::printf("In read data\n");
dispatcher = new MessageDispatcher();
dispatcher->dispatchMessage(mb);
handler = new MessageHandler();
ACE_UINT32 cmd = dispatcher->getCmd();
ACE_Message_Block* smb;
//case CONNECT_SERVER
//------------------------------------------------------------------------//
if(cmd == COM::CONNECT_SERVER)
{
ACE_OS::printf("In CONNECT_SERVER\n");
pair<ACE_UINT16,ACE_UINT16> randomPos = handler->handleConnectionSever(dispatcher->getIP(),dispatcher->getPort());
if(randomPos.first != 0 && randomPos.second != 0)
{
MessageConstructor::getInstance()->setAddress(this->local_address);
smb = MessageConstructor::getInstance()->createConnectionAck(randomPos.first,randomPos.second,DEFAULT_AOI_RADIUS);
}
}
//case GET_SCENE_DATA
//------------------------------------------------------------------------//
else if(cmd == COM::GET_SCENE_DATA)
{
}
//case CONNECT_FAIL_REPORT
//------------------------------------------------------------------------//
//case CLIENT_MOVE
//------------------------------------------------------------------------//
//case CLIENT_QUIT
//------------------------------------------------------------------------//
//case MORE_COMMAND
//------------------------------------------------------------------------//
dispatcher->setMB_NULL();
mb.release();
ACE_OS::printf("\nMMB data:%s\n",smb->rd_ptr());
if (this->writer_.write(*smb,smb->length()) != 0)
{
ACE_OS::printf("Write Failed!");
//MessageConstructor::getInstance()->setMB_NULL();
smb->release();
delete this;
return;
}
MessageConstructor::getInstance()->setMB_NULL();
if(handler != NULL)
delete handler;
if(dispatcher != NULL)
delete dispatcher;
smb->release();
}
void
Client_Service_Handler::handle_read_stream (
const ACE_Asynch_Read_Stream::Result &result)
{
ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, guard, this->mtx_);
this->pending_reads_--;
if (!result.success () || 0 == result.bytes_transferred ())
{
// Error or remote disconnect
result.message_block ().release ();
if (!this->closing_)
{
// No error message when shutting down
if (!result.success ())
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (
"Client_Service_Handler::handle_read_stream: error: %d\n"),
result.error ()));
}
else
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (
"Client_Service_Handler::handle_read_stream: remote disconnect\n")));
}
}
this->read_completed_.signal ();
this->cancel_and_close ();
}
else if (result.bytes_transferred () < result.bytes_to_read ())
{
// More to read...
if (this->read (result.message_block(),
result.bytes_to_read () - result.bytes_transferred ()) < 0)
{
result.message_block ().release ();
this->cancel_and_close ();
}
}
else
{
// Read it all
this->completed_reads_++;
result.message_block ().release ();
// We now have sent and received data in the proactor thread. Signal the
// main thread to try sending data in the main thread.
if (this->completed_reads_ == 1)
{
this->ready_for_external_write_.signal ();
}
else
{
// The main thread wrote data that was echoed back to us on our
// second read. If we get here, the test was successful in that
// the main thread successfully sent data to the server.
this->read_successful_ = 1;
this->read_completed_.signal ();
}
// Next read
if (this->read_data () < 0)
{
this->cancel_and_close ();
}
}
}
void
Server_Service_Handler::handle_read_stream(
const ACE_Asynch_Read_Stream::Result &result)
{
ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, guard, this->mtx_);
this->pending_reads_--;
if (!result.success () || 0 == result.bytes_transferred ())
{
// Error or remote disconnect
result.message_block ().release ();
if (!this->closing_)
{
// No error message when shutting down
if (!result.success ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Server_Service_Handler::handle_read_stream: error: %d\n"),
result.error ()));
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Server_Service_Handler::handle_read_stream: remote disconnect\n")));
}
}
this->cancel_and_close ();
}
else if (result.bytes_transferred () < result.bytes_to_read ())
{
// More to read...
if (this->read (result.message_block (),
result.bytes_to_read () - result.bytes_transferred ()) < 0)
{
result.message_block ().release ();
this->cancel_and_close ();
}
}
else
{
// Read it all
result.message_block ().release ();
// Send data back
if (this->write_data () < 0)
{
this->cancel_and_close ();
}
// Next read
else if (this->read_data () < 0)
{
this->cancel_and_close ();
}
}
}
void CProConnectClient::handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
{
ACE_Message_Block& mb = result.message_block();
uint32 u4PacketLen = (uint32)result.bytes_transferred();
//OUR_DEBUG((LM_DEBUG,"[CProConnectClient::handle_read_stream] m_nServerID=%d, bytes_transferred=%d, this=0x%08x.\n",
// m_nServerID,
// u4PacketLen,
// this));
if(!result.success() || u4PacketLen == 0)
{
mb.release();
if(NULL != m_pClientMessage)
{
_ClientIPInfo objServerIPInfo;
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_20, "%s", m_AddrRemote.get_host_addr());
objServerIPInfo.m_nPort = m_AddrRemote.get_port_number();
//这里只处理远端服务器断开连接的消息，回调ConnectError
//服务器主动关闭不在回调ConnectError
if(S2S_NEED_CALLBACK == m_ems2s)
{
m_pClientMessage->ConnectError((int)ACE_OS::last_error(), objServerIPInfo);
}
}
//OUR_DEBUG((LM_INFO, "[CProConnectClient::handle_read_stream]m_ems2s=%d.\n", m_ems2s));
Close();
return;
}
else
{
//处理接收数据(这里不区分是不是完整包，交给上层逻辑自己去判定)
if(NULL != m_pClientMessage)
{
_ClientIPInfo objServerIPInfo;
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_20, "%s", m_AddrRemote.get_host_addr());
objServerIPInfo.m_nPort = m_AddrRemote.get_port_number();
//m_pClientMessage->RecvData(&mb, objServerIPInfo);
//这里处理一下是不是完整包
uint16 u2CommandID = 0;
ACE_Message_Block* pRecvFinish = NULL;
m_atvRecv = ACE_OS::gettimeofday();
m_emRecvState = SERVER_RECV_BEGIN;
while(true)
{
bool blRet = m_pClientMessage->Recv_Format_data(&mb, App_MessageBlockManager::instance(), u2CommandID, pRecvFinish);
if(true == blRet)
{
if(App_MainConfig::instance()->GetConnectServerRunType() == 0)
{
//调用数据包处理
m_pClientMessage->RecvData(u2CommandID, pRecvFinish, objServerIPInfo);
//回收处理包
App_MessageBlockManager::instance()->Close(pRecvFinish);
}
else
{
//异步消息处理
_Server_Message_Info* pServer_Message_Info = new _Server_Message_Info();
pServer_Message_Info->m_pClientMessage = m_pClientMessage;
pServer_Message_Info->m_objServerIPInfo = objServerIPInfo;
pServer_Message_Info->m_pRecvFinish = pRecvFinish;
pServer_Message_Info->m_u2CommandID = u2CommandID;
App_ServerMessageTask::instance()->PutMessage(pServer_Message_Info);
}
}
else
{
break;
}
}
}
mb.release();
m_emRecvState = SERVER_RECV_END;
//接受下一个数据包
RecvData(App_MainConfig::instance()->GetConnectServerRecvBuffer());
}
}
void
Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_Message_Block *mb = &result.message_block ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Receiver::handle_read_stream - (%s) read %d\n"),
this->odd_ ? ACE_TEXT ("ODD ") : ACE_TEXT ("EVEN"),
result.bytes_transferred ()));
// Transfer only complete chunks to the writer.
// Save last partial chunk for the next call.
// On disconnect (error or 0 transferred), transfer whatever we have.
// at this stage there should not be anything there
ACE_TEST_ASSERT (!this->partial_chunk_);
// first, remove the empty chunks
remove_empty_chunks (mb);
if (mb && Receiver::writer_)
{ // there's something to write, and who to write to
// write everything or only complete chunks?
// write everything - when no new bytes were transferred
int write_everything = 0;
if (!result.bytes_transferred ())
write_everything = 1;
if (write_everything)
Receiver::writer_->handle_read_chunks_chain (mb,
this->odd_ ? ODD : EVEN);
else
{ // filter out the partial chunk at the end (if present)
// and save it for later before writing the full chunks
// have this->partial_chunk_ point to the last chunk in the chain
size_t last_index = last_chunk (mb, this->partial_chunk_);
if (this->partial_chunk_ &&
this->partial_chunk_->length () < chunk_size)
{ // found partial chunk at end of chain
// detach it from the chain
if (last_index > 1) // chain bigger than 1
{
ACE_Message_Block *pre_last = mb;
for (size_t index = 1; index < last_index - 1; ++index)
pre_last = pre_last->cont ();
// detach partial chunk from chain
pre_last->cont (0);
}
else
// chain in length of 1 - so we need to zero mb
mb = 0;
}
else // last is a full chunk, so hand it over with the rest
this->partial_chunk_ = 0;
// transfer (if there's anything left)
if (mb && mb->total_length ())
Receiver::writer_->handle_read_chunks_chain (
mb,
this->odd_ ? ODD : EVEN);
// initiate more reads only if no error
if (!result.error ())
this->initiate_read_stream ();
else
ACE_TEST_ASSERT (0);
}
}
else if (mb && !Receiver::writer_)
// no one to write to
free_chunks_chain (mb);
--this->io_count_;
this->check_destroy ();
}
void CProConsoleHandle::handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
{
ACE_Message_Block& mb = result.message_block();
uint32 u4PacketLen = (uint32)result.bytes_transferred();
int nTran = (int)result.bytes_transferred();
if(!result.success() || result.bytes_transferred() == 0)
{
//链接断开
if(m_pPacketParse->GetMessageHead() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageHead());
}
if(m_pPacketParse->GetMessageBody() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageBody());
}
if(&mb != m_pPacketParse->GetMessageHead() && &mb != m_pPacketParse->GetMessageBody())
{
//OUR_DEBUG((LM_DEBUG,"[CProConsoleHandle::handle_read_stream] Message_block release.\n"));
App_MessageBlockManager::instance()->Close(&mb);
}
SAFE_DELETE(m_pPacketParse);
OUR_DEBUG((LM_DEBUG,"[%tCConnectHandler::handle_read_stream]Connectid=[%d] error(%d)...\n", GetConnectID(), errno));
//AppLogManager::instance()->WriteLog(LOG_SYSTEM_CONNECT, "Close Connection from [%s:%d] RecvSize = %d, RecvCount = %d, SendSize = %d, SendCount = %d.",m_addrRemote.get_host_addr(), m_addrRemote.get_port_number(), m_u4AllRecvSize, m_u4AllRecvCount, m_u4AllSendSize, m_u4AllSendCount);
//因为是要关闭连接，所以要多关闭一次IO，对应Open设置的1的初始值
Close(2);
return;
}
m_atvInput = ACE_OS::gettimeofday();
if(result.bytes_transferred() < result.bytes_to_read())
{
//短读，继续读
int nRead = (int)result.bytes_to_read() - (int)result.bytes_transferred();
if(-1 == m_Reader.read(mb, nRead))
{
if(m_pPacketParse->GetMessageHead() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageHead());
}
if(m_pPacketParse->GetMessageBody() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageBody());
}
if(&mb != m_pPacketParse->GetMessageHead() && &mb != m_pPacketParse->GetMessageBody())
{
App_MessageBlockManager::instance()->Close(&mb);
}
SAFE_DELETE(m_pPacketParse);
OUR_DEBUG((LM_ERROR, "[CConnectHandler::handle_read_stream]Read Shoter error(%d).", errno));
//AppLogManager::instance()->WriteLog(LOG_SYSTEM_CONNECT, "Close Connection from [%s:%d] RecvSize = %d, RecvCount = %d, SendSize = %d, SendCount = %d.",m_addrRemote.get_host_addr(), m_addrRemote.get_port_number(), m_u4AllRecvSize, m_u4AllRecvCount, m_u4AllSendSize, m_u4AllSendCount);
//因为是要关闭连接，所以要多关闭一次IO，对应Open设置的1的初始值
Close(2);
return;
}
}
else if(mb.length() == m_pPacketParse->GetPacketHeadLen() && m_pPacketParse->GetIsHead() == false)
{
//判断头的合法性
m_pPacketParse->SetPacketHead(GetConnectID(), &mb, App_MessageBlockManager::instance());
uint32 u4PacketBodyLen = m_pPacketParse->GetPacketBodyLen();
//如果超过了最大包长度，为非法数据
if(u4PacketBodyLen >= MAX_MSG_PACKETLENGTH || u4PacketBodyLen <= 0)
{
OUR_DEBUG((LM_ERROR, "[CConnectHandler::handle_read_stream]u4PacketHeadLen(%d) more than MAX_MSG_PACKETLENGTH.", u4PacketBodyLen));
if(m_pPacketParse->GetMessageHead() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageHead());
}
if(m_pPacketParse->GetMessageBody() != NULL)
{
App_MessageBlockManager::instance()->Close(m_pPacketParse->GetMessageBody());
}
if(&mb != m_pPacketParse->GetMessageHead() && &mb != m_pPacketParse->GetMessageBody())
{
App_MessageBlockManager::instance()->Close(&mb);
}
SAFE_DELETE(m_pPacketParse);
Close(2);
return;
}
else
{
Close();
RecvClinetPacket(u4PacketBodyLen);
}
}
else
{
//接受完整数据完成，开始分析完整数据包
m_pPacketParse->SetPacketBody(GetConnectID(), &mb, App_MessageBlockManager::instance());
CheckMessage();
m_pPacketParse = new CConsolePacketParse();
Close();
//接受下一个数据包
RecvClinetPacket(m_pPacketParse->GetPacketHeadLen());
}
return;
}
