int
Sender::initiate_write (void)
{
if ( this->msg_queue ()->message_count () < 20) // flow control
{
size_t nbytes = ACE_OS::strlen (send_buf_);
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (nbytes+8),
-1);
mb->init (send_buf_, nbytes);
mb->rd_ptr (mb->base ());
mb->wr_ptr (mb->base ());
mb->wr_ptr (nbytes);
ACE_Time_Value tv = ACE_Time_Value::zero;
int qcount =this->putq (mb, & tv);
if (qcount <= 0)
{
ACE_Message_Block::release (mb);
return -1;
}
}
return initiate_io (ACE_Event_Handler::WRITE_MASK);
}
ctsIOTask ctsSocket::initiate_io() throw()
{
// *NOT* taking a ctsSocket lock before calling through io_pattern
// - as IOPattern can also initiate calls through ctsSocket, which can then deadlock
// default is an empty task to do nothing
ctsIOTask return_task;
auto ref_io_pattern(this->io_pattern);
if (ref_io_pattern) {
return_task = ref_io_pattern->initiate_io();
}
return return_task;
}
int
Receiver::open (void *)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Reactor *TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this, flg_mask_) == -1)
return -1;
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
int Sender::open (void *)
{
ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, locker, this->mutex_, -1);
ACE_Reactor * TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this,flg_mask_) == -1)
return -1;
if (this->initiate_write () == -1)
return -1;
if (duplex != 0)
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
int
Sender::handle_output (ACE_HANDLE h)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Time_Value tv = ACE_Time_Value::zero;
ACE_Message_Block *mb = 0;
int err=0;
ssize_t res=0;
size_t bytes=0;
int qcount = this->getq (mb , & tv);
if (mb != 0) // qcount >= 0
{
bytes = mb->length ();
res = this->peer ().send (mb->rd_ptr (), bytes);
this->total_w_++;
if (res < 0)
err = errno ;
else
this->total_snd_ += res;
if (loglevel == 0 || res <= 0 || err!= 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG, "**** Sender::handle_output () SessionId=%d****\n", index_));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", bytes));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", h));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transferred", res));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", err));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", mb->rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "**** end of message ****************\n"));
}
}
ACE_Message_Block::release (mb);
if (err != 0 || res < 0)
return -1;
int rc = 0;
if (qcount <= 0) // no more message blocks in queue
{
if (duplex != 0 && // full duplex, continue write
(this->total_snd_ - this->total_rcv_ ) < 1024*32 ) // flow control
rc = initiate_write ();
else
rc = terminate_io (ACE_Event_Handler::WRITE_MASK);
if (rc == -1)
return -1;
}
rc = initiate_io (ACE_Event_Handler::READ_MASK);
if (rc == -1)
return -1;
return check_destroy ();
}
int
Sender::handle_input (ACE_HANDLE h)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (BUFSIZ),
-1);
int err = 0;
ssize_t res = this->peer ().recv (mb->rd_ptr (),
BUFSIZ-1);
this->total_r_++;
if (res >= 0)
{
mb->wr_ptr (res);
this->total_rcv_ += res;
}
else
err = errno ;
mb->wr_ptr ()[0] = '\0';
if (loglevel == 0 || res <= 0 || err!= 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG, "**** Sender::handle_input () SessionId=%d****\n", index_));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", BUFSIZ));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", h));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transferred", res));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", err));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", mb->rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "**** end of message ****************\n"));
}
ACE_Message_Block::release (mb);
if (err == EWOULDBLOCK)
{
err=0;
res=0;
return check_destroy ();
}
if (err !=0 || res <= 0)
return -1;
int rc = 0;
if (duplex != 0) // full duplex, continue read
rc = initiate_io (ACE_Event_Handler::READ_MASK);
else
rc = terminate_io (ACE_Event_Handler::READ_MASK);
if (rc != 0)
return -1 ;
rc = initiate_write ();
if (rc != 0)
return -1;
return check_destroy ();
}