void
PConnection::trace_read_completion (const ACE_Asynch_Read_Stream::Result &result)
{
int loglevel = this->config().loglevel ();
size_t xfer_bytes = result.bytes_transferred();
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 ()));
trace_buffers (result.get_buffer_info (), xfer_bytes, true);
}
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
Server_Handler::handle_read_stream
(const ACE_Asynch_Read_Stream::Result &result)
{
if (!result.success ())
{
errno = result.error ();
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) Server handle %d: %p\n"),
this->stream_.handle (),
ACE_TEXT ("read")));
delete this;
return;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Server %@ handle %d recv %B of %B bytes\n"),
this, this->stream_.handle (),
result.bytes_transferred (), result.bytes_to_read ()));
if (result.bytes_transferred () == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Server handle %d closed by peer\n"),
this->stream_.handle ()));
delete this;
return;
}
// Scan through the received data for the expected string. There may be
// multiples and/or partials. Count up how many arrive before the connection
// is closed.
// Remember that the client side sends the terminating nul; in case the
// whole thing didn't arrive, we add a nul to the end of the receive
// block so we don't run off the end. When the recv into this buffer was
// initiated, we left the last byte empty to facilitate this.
ACE_Message_Block &b = result.message_block ();
*(b.wr_ptr ()) = '\0';
size_t test_string_len = ACE_OS::strlen (test_string);
while (b.length () >= test_string_len)
{
if (0 != ACE_OS::strncmp (b.rd_ptr (), test_string, test_string_len))
ACE_ERROR_BREAK ((LM_ERROR,
ACE_TEXT ("(%t) Read string: %C; expected: %C\n"),
b.rd_ptr (),
test_string));
b.rd_ptr (test_string_len);
// That ran up over the string; can we also consume the nul?
if (b.length () > 0)
b.rd_ptr (1);
++this->msgs_rcvd_;
}
b.crunch ();
if (this->stream_.read (b, b.space () - 1) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) Server_Handler: %p\n"),
ACE_TEXT ("read")));
delete this;
}
return;
}
void
Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_read_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (uintptr_t) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (uintptr_t) result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
#if 0
// This can overrun the ACE_Log_Msg buffer and do bad things.
// Re-enable it at your risk.
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
#endif /* 0 */
if (result.success () && result.bytes_transferred () != 0)
{
// Successful read: write the data to the file asynchronously.
// Note how we reuse the <ACE_Message_Block> for the writing.
// Therefore, we do not delete this buffer because it is handled
// in <handle_write_stream>.
if (this->wf_.write (result.message_block (),
result.bytes_transferred (),
this->file_offset_) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Write_File::write"));
return;
}
// Initiate new read from the stream.
if (this->initiate_read_stream () == -1)
return;
}
else
{
ACE_DEBUG ((LM_DEBUG,
"Receiver completed\n"));
// No need for this message block anymore.
result.message_block ().release ();
// Note that we are done with the test.
done = 1;
// We are done: commit suicide.
delete this;
}
}
void
Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_read_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr ()[result.bytes_transferred ()] =
'\0';
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read
()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
result.message_block ().rd_ptr ()));
if ( result.success () && result.bytes_transferred () != 0)
{
// Successful read: write the data to the file asynchronously.
// Note how we reuse the <ACE_Message_Block> for the writing.
// Therefore, we do not delete this buffer because it is handled
// in <handle_write_stream>.
if(this->initiate_write_stream (result.message_block (),
result.bytes_transferred () ) == 0 )
{
if ( duplex != 0 )
{
// Initiate new read from the stream.
this->initiate_read_stream () ;
}
}
}
else
{
result.message_block ().release ();
ACE_DEBUG ((LM_DEBUG, "Receiver completed\n"));
}
{
ACE_Guard<MyMutex> locker (m_Mtx) ;
nIOCount-- ;
}
check_destroy () ;
}
void AIO_Input_Handler::handle_read_stream
(const ACE_Asynch_Read_Stream::Result &result) {
if (!result.success () || result.bytes_transferred () == 0)
delete this;
else if (result.bytes_transferred () < result.bytes_to_read ())
reader_.read (*mblk_, result.bytes_to_read () -
result.bytes_transferred ());
else if (mblk_->length () == LOG_HEADER_SIZE) {
ACE_InputCDR cdr (mblk_);
ACE_CDR::Boolean byte_order;
cdr >> ACE_InputCDR::to_boolean (byte_order);
cdr.reset_byte_order (byte_order);
ACE_CDR::ULong length;
cdr >> length;
mblk_->size (length + LOG_HEADER_SIZE);
reader_.read (*mblk_, length);
}
void
Sender::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_read_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr ()[result.bytes_transferred ()] =
'\0';
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read
()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
result.message_block ().rd_ptr ()));
result.message_block().release ();
if ( result.success () && result.bytes_transferred () != 0)
{
// Successful read: write the data to the file asynchronously.
// Note how we reuse the <ACE_Message_Block> for the writing.
// Therefore, we do not delete this buffer because it is handled
// in <handle_write_stream>.
if ( duplex != 0 ) // full duplex, continue read
{
initiate_read_stream () ;
}
else // half-duplex writey, after write we will start read
{
initiate_write_stream () ;
}
}
{
ACE_Guard<MyMutex> locker (m_Mtx) ;
nIOCount-- ;
}
}
void HD_CCU_Request_Handler::handle_read_stream(
const ACE_Asynch_Read_Stream::Result &result)
{
ACE_Message_Block & mb = result.message_block();
if(!result.success() || result.bytes_transferred() == 0)
{
// 认为接收数据失败
ACE_DEBUG((LM_ERROR,"读取 CCU 数据失败!!"));
free_handler();
return;
}
else
{
ACE_DEBUG((LM_DEBUG,"开始处理数据..."));
// 读取数据完成
ACE_InputCDR cdr(&mb);
ACE_CDR::UShort data_len;
cdr >> data_len;
if(mb.length() - MSG_BUF_LEN_HEADER >= data_len )
{
// 读取完成,处理业务
if( process_request(&mb)<= 0 )
{
// 处理失败或者不需要应答
free_handler();
}
return;
}
// 认为数据有问题
// 继续读取
if(mb.length() >= 65535)
{
ACE_DEBUG((LM_ERROR,"数据包长度不合法!!!!"));
free_handler();
return;
}
ACE_DEBUG((LM_DEBUG,"继续读取数据..."));
mb.wr_ptr(mb.length());
if( _reader.read(mb
,result.bytes_to_read() - result.bytes_transferred()) != 0)
{
ACE_DEBUG((LM_ERROR,"读取 CCU 数据失败!!"));
free_handler();
return;
}
}
}
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
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 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;
}