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 Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result) { // Reset pointers. result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0'; if (result.bytes_transferred () == 0 || result.error () != 0) { ACE_DEBUG ((LM_DEBUG, "handle_read_stream called\n")); 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<ACE_Recursive_Thread_Mutex> locker (mutex_); io_count_--; } check_destroy (); }
void PConnection::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result) { this->trace_read_completion (result); { ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ()); this->update_last_time(); this->ref_cnt_r_--; ACE_Message_Block & mb = result.message_block (); int error = result.error(); size_t xfer_bytes = result.bytes_transferred (); this->total_rcv_ += xfer_bytes; if (error == 0 && this->protocol_ != 0) { this->protocol_->on_read_finished (mb, xfer_bytes, error); } else { this->free_msg (&mb); this->cancel (); } if (!this->is_safe_to_delete ()) return; } this->manager()->destroy_connection (this); }
void Sender::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result) { this->trace_read_completion (result); { ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex ()); this->ref_cnt_r_--; ACE_Message_Block & mb = result.message_block (); mb.release (); if (result.error () != 0) { this->cancel_i (); } else if (result.bytes_transferred () == 0) { this->shutdown_i (); } else if (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 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 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 ACE_SSL_Asynch_Stream::handle_read_stream ( const ACE_Asynch_Read_Stream::Result &result) { ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_)); this->bio_inp_flag_ &= ~BF_AIO; size_t bytes_trn = result.bytes_transferred (); u_long errval = result.error (); if (errval != 0) // error ? this->bio_inp_errno_ = errval; // save err code else if (bytes_trn == 0) // end of stream ? this->bio_inp_flag_ |= BF_EOS; // set flag EOS this->do_SSL_state_machine (); 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 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 (); }