void CProConsoleHandle::handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
{
if(!result.success() || result.bytes_transferred()==0)
{
//链接断开
OUR_DEBUG ((LM_DEBUG,"[CConnectHandler::handle_write_stream] Connectid=[%d] begin(%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);
OUR_DEBUG((LM_DEBUG,"[CConnectHandler::handle_write_stream] Connectid=[%d] finish ok...\n", GetConnectID()));
m_atvOutput = ACE_OS::gettimeofday();
App_MessageBlockManager::instance()->Close(&result.message_block());
Close();
return;
}
else
{
//短读不考虑
m_blCanWrite = true;
m_atvOutput = ACE_OS::gettimeofday();
App_MessageBlockManager::instance()->Close(&result.message_block());
m_u4AllSendSize += (uint32)result.bytes_to_write();
Close();
return;
}
}
void
Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
this->trace_write_completion (result);
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ());
this->ref_cnt_w_--;
ACE_Message_Block & mb = result.message_block ();
mb.release ();
if (result.error () != 0 ||
result.bytes_transferred () == 0 ||
this->initiate_write_stream () != 0 ||
this->initiate_read_stream() != 0)
{
this->cancel_i ();
}
if (!this->is_safe_to_delete())
return;
}
this->manager()->destroy_session(this);
}
void
JAWS_Asynch_IO::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
result.message_block ().release ();
if (result.act () == (void *) CONFORMATION)
this->handler_->confirmation_message_complete ();
else
this->handler_->error_message_complete ();
}
virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
{
//trace_msg("handle output.");
result.message_block().release();
if (result.success() == false)
{
_peer.emit(kSignalClosed);
}
}
void
Peer_Handler::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
if (result.bytes_transferred () <= 0)
ACE_DEBUG ((LM_DEBUG, "(%t) %p bytes = %d\n", "Message failed",
result.bytes_transferred ()));
// This was allocated by the STDIN_Handler, queued, dequeued, passed
// to the proactor, and now passed back to us.
result.message_block ().release ();
}
void
Client_Handler::handle_write_stream
(const ACE_Asynch_Write_Stream::Result &result)
{
if (!result.success ())
{
errno = result.error ();
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) Client handle %d: %p\n"),
this->stream_.handle (),
ACE_TEXT ("write")));
delete this;
return;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Client %@ handle %d sent %B of %B bytes\n"),
this, this->stream_.handle (),
result.bytes_transferred (), result.bytes_to_write ()));
ACE_Message_Block &b = result.message_block ();
bool send_again = true;
if (b.length () == 0)
{
// All block's data sent; rewind the read pointer and send it again
// until we've sent the configured number of times.
++this->msgs_sent_;
if (this->msgs_sent_ == cli_req_no)
send_again = false; // All done
else
b.rd_ptr (b.base ());
}
if (send_again)
{
if (this->stream_.write (this->block_, this->block_.length ()) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) Client_Handler: %p\n"),
ACE_TEXT ("initiate write")));
delete this;
}
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Client handle %d done sending\n"),
this->stream_.handle ()));
delete this;
}
return;
}
void
PConnection::trace_write_completion (const ACE_Asynch_Write_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_write_stream() ****\n"),
this->get_name(),
this->index()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("bytes_to_write = %d\n"),
result.bytes_to_write ()));
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, false);
}
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 WRITE %p\n"),
this->get_name (),
this->index (),
ACE_TEXT ("ERROR"));
}
else if (loglevel == 1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) %s=%d write_bytes=%d OK\n"),
this->get_name (),
this->index (),
xfer_bytes));
}
}
void AIO_Output_Handler::handle_write_stream
(const ACE_Asynch_Write_Stream::Result &result) {
ACE_Message_Block &mblk = result.message_block ();
if (!result.success ()) {
mblk.rd_ptr (mblk.base ());
ungetq (&mblk);
}
else {
can_write_ = handle () == result.handle ();
if (mblk.length () == 0) {
mblk.release ();
if (can_write_) start_write ();
}
else if (can_write_) start_write (&mblk);
else { mblk.rd_ptr (mblk.base ()); ungetq (&mblk); }
}
}
// ************************************************************
// Internal IO handlers
// virtual from ACE_Service_Handler
// ************************************************************
void
ACE_SSL_Asynch_Stream::handle_write_stream (
const ACE_Asynch_Write_Stream::Result &result)
{
ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_));
this->bio_out_flag_ &= ~BF_AIO;
ACE_Message_Block & mb = result.message_block ();
size_t bytes_req = result.bytes_to_write ();
size_t bytes_trn = result.bytes_transferred ();
u_long errval = result.error ();
size_t len = bytes_req - bytes_trn;
if (errval != 0) // error ?
this->bio_out_errno_ = errval; // save err code
else if (len > 0) // TCP/IP overloaded ?
{ // continue, rd_ptr at right place
if (this->bio_ostream_.write (
mb, // message block
len, // priority
0, // act
0, // priority
ACE_SIGRTMIN // default signal
) == 0)
{
this->bio_out_flag_ |= BF_AIO;
return;
}
ACELIB_ERROR
((LM_ERROR,
ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"),
ACE_TEXT ("attempt write failed")
));
this->bio_out_errno_ = EINVAL;
}
this->do_SSL_state_machine ();
return;
}
void
PConnection::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
this->trace_write_completion (result);
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ());
this->update_last_time();
this->ref_cnt_w_--;
ACE_Message_Block & mb = result.message_block ();
int error = result.error();
size_t xfer_bytes = result.bytes_transferred ();
size_t req_bytes = result.bytes_to_write ();
// done in initiate_write_stream
// !!!! this->total_snd_ += xfer_bytes;
if (error == 0 && this->protocol_ != 0)
{
if (xfer_bytes < req_bytes) // Process partial write
{
this->do_initiate_write_stream (mb);
}
else
{
check_out_queue ();
this->protocol_->on_write_finished (mb, xfer_bytes, error);
}
}
else
{
this->free_msg (&mb);
this->cancel ();
}
if (!is_safe_to_delete())
return;
}
this->manager()->destroy_connection(this);
}
void
PConnection::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
this->trace_write_completion (result);
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ());
this->update_last_time();
this->ref_cnt_w_--;
int error = result.error();
size_t xfer_bytes = result.bytes_transferred ();
size_t req_bytes = result.bytes_to_write ();
this->total_snd_ += xfer_bytes;
if (error == 0 && this->protocol_ != 0)
{
char *buf = result.get_buffer ();
if (xfer_bytes < req_bytes) // Process partial write
{
this->initiate_write_stream (buf + xfer_bytes,
req_bytes - xfer_bytes);
}
else
{
this->protocol_->on_write_finished (buf,
xfer_bytes,
error);
}
}
else
{
this->cancel ();
}
if (!is_safe_to_delete())
return;
}
this->manager()->destroy_connection(this);
}
void
Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
ACE_Message_Block *mb = &result.message_block ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Sender::handle_write_stream - wrote %d bytes\n"),
result.bytes_transferred ()));
if (result.error () == 0 && result.bytes_transferred () != 0)
// verify sent all
ACE_TEST_ASSERT (0 == mb->total_length ());
else
ACE_TEST_ASSERT (0);
free_chunks_chain (mb);
--this->io_count_;
this->check_destroy ();
}
void CProConnectClient::handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
{
ACE_Message_Block& mblk = result.message_block();
if(!result.success() || result.bytes_transferred() == 0)
{
//处理数据发送出错
OUR_DEBUG((LM_DEBUG, "[CProConnectClient::handle_write_stream]Write error(%d).\n", ACE_OS::last_error()));
mblk.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();
m_pClientMessage->ConnectError((int)ACE_OS::last_error(), objServerIPInfo);
}
Close();
}
else
{
mblk.release();
}
}
void
Receiver::handle_write_stream (const ACE_Asynch_Write_Stream::Result
&result)
{
ACE_DEBUG ((LM_DEBUG, "handle_write_stream called\n"));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write",
result.bytes_to_write ()));
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"));
result.message_block ().release ();
if (result.success ())
{
// This code is not robust enough to deal with short file writes
// (which hardly ever happen) ;-)
//ACE_ASSERT (result.bytes_to_write () == result.bytes_transferred ());
if ( duplex == 0 )
{
initiate_read_stream () ;
}
}
{
ACE_Guard<MyMutex> locker (m_Mtx) ;
nIOCount-- ;
}
check_destroy () ;
}
void
JAWS_EC_AH_Adapter
::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
JAWS_Event_Result io_result;
io_result = this->make_io_result ( result
, JAWS_Event_Result::JE_SEND_OK
, JAWS_Event_Result::JE_SEND_FAIL
);
// More useful diagnostics not implemented yet.
void *act = const_cast<void *> (result.act ());
this->completer_->output_complete (io_result, act);
delete this;
}
void Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result
&result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_write_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr (result.message_block ().rd_ptr () -
result.bytes_transferred ());
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write",
result.bytes_to_write ()));
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 ()));
// Simplify just for Test
if (result.success () && result.bytes_transferred () != 0)
{
if ( duplex != 0 ) // full duplex, continue write
{
initiate_write_stream () ;
}
else // half-duplex read reply, after read we will start
// write
{
initiate_read_stream () ;
}
}
{
ACE_Guard<MyMutex> locker (m_Mtx) ;
nIOCount-- ;
}
}
void ProactorService::handle_write_stream( const ACE_Asynch_Write_Stream::Result& result )
{
result.message_block().release();
}
void
Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_write_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr (result.message_block ().rd_ptr () - result.bytes_transferred ());
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
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
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
#endif
if (result.success ())
{
// Partial write to socket
int unsent_data =
ACE_Utils::truncate_cast<int> (
result.bytes_to_write () - result.bytes_transferred ());
if (unsent_data != 0)
{
// Reset pointers
result.message_block ().rd_ptr (result.bytes_transferred ());
// Duplicate the message block and retry remaining data
if (this->ws_.write (*result.message_block ().duplicate (),
unsent_data) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Write_Stream::write"));
return;
}
}
else if (!(this->file_size_ > this->file_offset_))
{
this->stream_write_done_ = 1;
if (this->transmit_file_done_)
done = 1;
}
}
// Release message block.
result.message_block ().release ();
}
void
PSession::trace_write_completion (const ACE_Asynch_Write_Stream::Result &result)
{
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ());
this->update_last_time();
if (result.success())
this->total_snd_ += 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.rd_ptr();
char * first = last - xfer_bytes;
if (loglevel == 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) **** %s=%d handle_write_stream() ****\n"),
this->get_name(),
this->index()));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("bytes_to_write = %d\n"),
result.bytes_to_write ()));
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 WRITE %p\n"),
this->get_name (),
this->index (),
ACE_TEXT ("ERROR"));
}
else if (loglevel == 1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) %s=%d write_bytes=%d OK\n"),
this->get_name (),
this->index (),
xfer_bytes));
}
return;
}
void HttpdPeer::handle_write_stream( const ACE_Asynch_Write_Stream::Result &result )
{
ACE_Message_Block& mb=result.message_block();
size_t unsent_data;
if (result.success())
{
unsent_data = result.bytes_to_write() - result.bytes_transferred();
if (unsent_data != 0) //未写完
{
// Reset pointers
result.message_block ().rd_ptr (result.bytes_transferred ());
// Duplicate the message block and retry remaining data
if (writer_.write (*result.message_block ().duplicate (),
unsent_data) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p ",
"HttpPeer::Write"));
ACE_OS::printf("%d\n",ACE_OS::last_error());
result.message_block().release();
return;
}
result.message_block().release();
}
else
{
ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
mb.release();
if (bIsIniting_)
{
if (!delivered_header_ && lpMgr->mhdr_.len_>0)
{
//Push Header
ACE_Message_Block *lpMb = NULL;
ACE_NEW_NORETURN(lpMb,ACE_Message_Block(lpMgr->mhdr_.data_,lpMgr->mhdr_.len_));
lpMb->wr_ptr(lpMgr->mhdr_.len_);
putQ(lpMb);
//ACE_Time_Value tv;
//tv.msec(300);//
//ACE_OS::sleep(tv);
delivered_header_ = true;
}
else
{
sentinel_ = lpMgr->buffer_.start_seg_id_;
while(lpMgr->buffer_.get_data(sentinel_)!= NULL)
{
ACE_Message_Block *mb_ = lpMgr->buffer_.get_data(sentinel_);
if (mb_!=NULL)
{
mq_.push_back(mb_->duplicate());
}
sentinel_++;
}
bIsIniting_ = false;
}
}
init_write();
}
}
}
void Reciever::handle_write_dgram(const ACE_Asynch_Write_Stream::Result &result)
{
ACE_Message_Block &mb = result.message_block ();
mb.release();
return;
}
void
Client_Service_Handler::handle_write_stream (
const ACE_Asynch_Write_Stream::Result &result)
{
ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, guard, this->mtx_);
this->pending_writes_--;
if (!result.success () || 0 == result.bytes_transferred ())
{
// Error
result.message_block ().release ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (
"Client_Service_Handler::handle_write_stream: error: %d\n"),
result.error ()));
this->cancel_and_close ();
}
else if (result.bytes_transferred () < result.bytes_to_write ())
{
// More to write...
if (this->write (result.message_block(),
result.bytes_to_write () - result.bytes_transferred ()) < 0)
{
result.message_block ().release ();
this->cancel_and_close ();
}
}
else
{
// Wrote it all
result.message_block ().release ();
}
}