ACE_SSL_Asynch_Stream Class Reference

This class is a factory for initiating asynchronous reads and writes on an SSL stream. More...

#include <SSL_Asynch_Stream.h>

Collaboration diagram for ACE_SSL_Asynch_Stream:

[legend]List of all members.

Public Types
enum	Stream_Type { ST_CLIENT = 0x0001, ST_SERVER = 0x0002 }
Public Member Functions
	ACE_SSL_Asynch_Stream (Stream_Type s_type=ST_SERVER, ACE_SSL_Context *context=0)
	Constructor.
virtual	~ACE_SSL_Asynch_Stream (void)
	Destructor.
int	cancel (void)
int	close (void)
int	open (ACE_Handler &handler, ACE_HANDLE handle=ACE_INVALID_HANDLE, const void *completion_key=0, ACE_Proactor *proactor=0)
int	read (ACE_Message_Block &message_block, size_t num_bytes_to_read, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
int	write (ACE_Message_Block &message_block, size_t bytes_to_write, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
Protected Types
enum	Stream_Flag {   SF_STREAM_OPEN = 0x0001, SF_REQ_SHUTDOWN = 0x0002, SF_SHUTDOWN_DONE = 0x0004, SF_CLOSE_NTF_SENT = 0x0008,   SF_DELETE_ENABLE = 0x0010 }
	Stream state/flags. More...
enum	BIO_Flag { BF_EOS = 0x01, BF_AIO = 0x02 }
Protected Member Functions
virtual ACE_Asynch_Operation_Impl *	implementation (void) const
virtual void	handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
	virtual from ACE_Handler
virtual void	handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
virtual void	handle_wakeup (void)
void	print_error (int err_ssl, const ACE_TCHAR *pText)
int	pending_BIO_count (void)
int	notify_read (int bytes_transferred, int error)
int	notify_write (int bytes_transferred, int error)
int	notify_close (void)
SSL State Machine
int	do_SSL_state_machine (void)
int	do_SSL_handshake (void)
int	do_SSL_read (void)
int	do_SSL_write (void)
int	do_SSL_shutdown (void)
BIO Helpers
int	ssl_bio_read (char *buf, size_t len, int &errval)
int	ssl_bio_write (const char *buf, size_t len, int &errval)
Protected Attributes
Stream_Type	type_
	Stream Type ST_CLIENT/ST_SERVER.
ACE_HANDLE	handle_
	The real file/socket handle.
ACE_Proactor *	proactor_
	The proactor.
ACE_Handler *	ext_handler_
	External,i.e user handler.
ACE_SSL_Asynch_Read_Stream_Result *	ext_read_result_
	External, i.e. read result faked for user.
ACE_SSL_Asynch_Write_Stream_Result *	ext_write_result_
	External, i.e. write result faked for user.
int	flags_
SSL *	ssl_
	The SSL session.
BIO *	bio_
	The BIO implementation.
ACE_SYNCH_MUTEX	mutex_
	Mutex to protect work.
Internal stream, buffer and info for BIO read
ACE_Asynch_Read_Stream	bio_istream_
ACE_Message_Block	bio_inp_msg_
int	bio_inp_errno_
int	bio_inp_flag_
Internal stream, buffer and info for BIO write
ACE_Asynch_Write_Stream	bio_ostream_
ACE_Message_Block	bio_out_msg_
int	bio_out_errno_
int	bio_out_flag_
Private Member Functions
	ACE_SSL_Asynch_Stream (ACE_SSL_Asynch_Stream const &)
ACE_SSL_Asynch_Stream &	operator= (ACE_SSL_Asynch_Stream const &)
Friends
struct	ACE_SSL_Asynch_Stream_Accessor

---

Detailed Description

This class is a factory for initiating asynchronous reads and writes on an SSL stream.

Once open() is called, multiple asynchronous read and write operations can be started using this class. The handler object (derived from ACE_Handler) specified in open() will receive completion events for the operations initiated via this class.

Definition at line 144 of file SSL_Asynch_Stream.h.

---

Member Enumeration Documentation

enum ACE_SSL_Asynch_Stream::BIO_Flag [protected]

The real streams which work under the ssl connection. BIO performs I/O via this streams Enumeration values: BF_EOS  End of stream. BF_AIO  Real AIO in progress. Definition at line 385 of file SSL_Asynch_Stream.h. { /// End of stream BF_EOS = 0x01, /// Real AIO in progress BF_AIO = 0x02 };

enum ACE_SSL_Asynch_Stream::Stream_Flag [protected]

Stream state/flags. Enumeration values: SF_STREAM_OPEN  istream_ open OK SF_REQ_SHUTDOWN  request to SSL shutdown SF_SHUTDOWN_DONE  SSL shutdown finished. SF_CLOSE_NTF_SENT  Close notification sent. SF_DELETE_ENABLE  Stream can be safely destroyed. Definition at line 361 of file SSL_Asynch_Stream.h. { /// istream_ open OK SF_STREAM_OPEN = 0x0001, /// request to SSL shutdown SF_REQ_SHUTDOWN = 0x0002, /// SSL shutdown finished SF_SHUTDOWN_DONE = 0x0004, /// Close notification sent SF_CLOSE_NTF_SENT = 0x0008, /// Stream can be safely destroyed SF_DELETE_ENABLE = 0x0010 };

enum ACE_SSL_Asynch_Stream::Stream_Type

Enumeration values: ST_CLIENT  ST_SERVER  Definition at line 162 of file SSL_Asynch_Stream.h. { ST_CLIENT = 0x0001, ST_SERVER = 0x0002 };

---

Constructor & Destructor Documentation

ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream (  Stream_Type  s_type = ST_SERVER, ACE_SSL_Context *  context = 0 )

Constructor. context Pointer to an ACE_SSL_Context instance containing the OpenSSL information to be associated with this ACE_SSL_Asynch_Stream. The needed SSL data will be copied before return. Therefore, this object can be reused, modified, or deleted upon return. If a 0 pointer is passed, the ACE_SSL_Context::instance() method will be called to get access to a singleton. Definition at line 91 of file SSL_Asynch_Stream.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, ACE_SSL_Context::context(), ACE_SSL_Context::instance(), LM_ERROR, and ssl_. : type_ (s_type), handle_ (ACE_INVALID_HANDLE), proactor_ (0), ext_handler_ (0), ext_read_result_ (0), ext_write_result_(0), flags_ (0), ssl_ (0), bio_ (0), bio_istream_ (), bio_inp_msg_ (), bio_inp_errno_(0), bio_inp_flag_ (0), bio_ostream_ (), bio_out_msg_ (), bio_out_errno_(0), bio_out_flag_ (0), mutex_ () { ACE_TRACE ("ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream"); // was honestly copied from ACE_SSL_SOCK_Stream :) ACE_SSL_Context * ctx = (context == 0 ? ACE_SSL_Context::instance () : context); this->ssl_ = ::SSL_new (ctx->context ()); if (this->ssl_ == 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("- cannot allocate new SSL structure") )); }

ACE_SSL_Asynch_Stream::~ACE_SSL_Asynch_Stream (  void   )  [virtual]

Destructor. Definition at line 130 of file SSL_Asynch_Stream.cpp. References ACE_DEBUG, ACE_TEXT, ACE_TRACE, LM_DEBUG, SF_DELETE_ENABLE, SF_STREAM_OPEN, and ssl_. { ACE_TRACE ("ACE_SSL_Asynch_Stream::~ACE_SSL_Asynch_Stream"); // It is safe to delete stream if all notifications are received, // i.e., state is SF_DELETE_ENABLE or if proactor event loop is // done. if (this->flags_ & SF_STREAM_OPEN) // open if ((this->flags_ & SF_DELETE_ENABLE) == 0) // but .. ACE_DEBUG ((LM_DEBUG, ACE_TEXT("ACE_SSL_Asynch_Stream::DTOR-") ACE_TEXT("possible access violation ") ACE_TEXT("if proactor still handles events\n"))); ::SSL_free (this->ssl_); // Was honestly copied from ACE_SSL_SOCK_Stream :) // @@ Question: should we reference count the Context object or // leave that to the application developer? We do not reference // count reactors (for example) and following some simple rules // seems to work fine! }

ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream (  ACE_SSL_Asynch_Stream const &   )  [private]

---

Member Function Documentation

int ACE_SSL_Asynch_Stream::cancel (  void   )

Definition at line 187 of file SSL_Asynch_Stream.cpp. References ACE_GUARD_RETURN, ACE_SYNCH_MUTEX, bio_istream_, bio_ostream_, ERR_CANCELED, notify_read(), notify_write(), and SF_STREAM_OPEN. { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); if ((flags_ & SF_STREAM_OPEN) == 0) // not open return 1; // AIO_ALLDONE // attempt to cancel internal, i.e. user's read/write int rc_r_int = bio_istream_.cancel(); int rc_w_int = bio_ostream_.cancel(); // attempt to cancel external, i.e. bio_ssl read/write int rc_r_ext = notify_read (0, ERR_CANCELED); int rc_w_ext = notify_write (0, ERR_CANCELED); if (rc_r_int < 0 || rc_w_int < 0 && rc_r_ext < 0 || rc_w_ext < 0) return -1; // at least one error if (rc_r_int == 1 && rc_w_int == 1 && rc_r_ext == 1 && rc_w_ext == 1) return 1; // AIO_ALLDONE if (rc_r_int == 2 || rc_w_int == 2 && rc_r_ext == 2 || rc_w_ext == 2) return 2; // AIO_NOT_CANCELED , at least one not canceled return 0; // AIO_CANCELED, at least will be one notification }

int ACE_SSL_Asynch_Stream::close (  void   )

Definition at line 165 of file SSL_Asynch_Stream.cpp. References ACE_GUARD_RETURN, ACE_SYNCH_MUTEX, do_SSL_state_machine(), SF_DELETE_ENABLE, SF_REQ_SHUTDOWN, and SF_STREAM_OPEN. { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); if ((flags_ & SF_STREAM_OPEN) == 0) // not open flags_ |= SF_DELETE_ENABLE; if (flags_ & SF_DELETE_ENABLE) return 0; flags_ |= SF_REQ_SHUTDOWN; this->do_SSL_state_machine (); return -1; }

int ACE_SSL_Asynch_Stream::do_SSL_handshake (  void   )  [protected]

Definition at line 482 of file SSL_Asynch_Stream.cpp. References ACE_ERROR_RETURN, ACE_TEXT, LM_ERROR, print_error(), SF_REQ_SHUTDOWN, ssl_, ST_CLIENT, and ST_SERVER. Referenced by do_SSL_state_machine(). { if (SSL_is_init_finished (this->ssl_)) return 1; if (this->flags_ & SF_REQ_SHUTDOWN) return -1; int retval = -1; switch (this->type_) { case ST_CLIENT: retval = ::SSL_connect (this->ssl_); break; case ST_SERVER: retval = ::SSL_accept (this->ssl_); break; default: ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("- invalid stream type")), -1); } int status = ::SSL_get_error (this->ssl_, retval); switch (status) { case SSL_ERROR_NONE: break; case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_CONNECT: //case SSL_ERROR_WANT_ACCEPT: case SSL_ERROR_WANT_X509_LOOKUP: return 0; case SSL_ERROR_ZERO_RETURN: case SSL_ERROR_SYSCALL: default: this->print_error (status, ACE_TEXT ("Handshake error")); return -1; } return 1; }

int ACE_SSL_Asynch_Stream::do_SSL_read (  void   )  [protected]

Definition at line 539 of file SSL_Asynch_Stream.cpp. References ACE_TEXT, ERR_CANCELED, ext_read_result_, notify_read(), print_error(), SF_REQ_SHUTDOWN, ssl_, and ACE_Message_Block::wr_ptr(). Referenced by do_SSL_state_machine(). { if (this->ext_read_result_ == 0) // nothing to do return 0; if (this->flags_ & SF_REQ_SHUTDOWN) { this->notify_read (0, ERR_CANCELED); return -1; } ACE_Message_Block & mb = this->ext_read_result_->message_block (); size_t bytes_req = this->ext_read_result_->bytes_to_read (); ERR_clear_error(); const int bytes_trn = ::SSL_read (this->ssl_, mb.wr_ptr (), bytes_req); int const status = ::SSL_get_error (this->ssl_, bytes_trn); switch (status) { case SSL_ERROR_NONE: this->notify_read (bytes_trn, 0); return 1; case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: return 0; case SSL_ERROR_ZERO_RETURN: this->notify_read (0, 0); return 1; case SSL_ERROR_SYSCALL: if (bytes_trn == 0) { this->notify_read (0, 0); return 1; } // If not an EOF, then fall through to "default" case. default: break; } this->notify_read (0, EFAULT); this->print_error (status, ACE_TEXT ("SSL_read error")); return -1; }

int ACE_SSL_Asynch_Stream::do_SSL_shutdown (  void   )  [protected]

Definition at line 431 of file SSL_Asynch_Stream.cpp. References ACE_TEXT, ERR_CANCELED, notify_read(), notify_write(), print_error(), SF_REQ_SHUTDOWN, SF_SHUTDOWN_DONE, and ssl_. Referenced by do_SSL_state_machine(). { if (this->flags_ & SF_SHUTDOWN_DONE) // already done return 1; this->flags_ |= SF_REQ_SHUTDOWN; // if we have any uncompleted user requests // than cancel its this->notify_read (0, ERR_CANCELED); this->notify_write (0, ERR_CANCELED); int retval = ::SSL_shutdown (this->ssl_); int status = ::SSL_get_error (this->ssl_, retval); switch (status) { case SSL_ERROR_NONE: case SSL_ERROR_ZERO_RETURN: case SSL_ERROR_SYSCALL: retval = 1; break; case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_CONNECT: // case SSL_ERROR_WANT_ACCEPT: case SSL_ERROR_WANT_X509_LOOKUP: return 0; default: this->print_error (status, ACE_TEXT ("Shutdown error")); retval = -1; break; } this->flags_ |= SF_SHUTDOWN_DONE; return retval; }

int ACE_SSL_Asynch_Stream::do_SSL_state_machine (  void   )  [protected]

Definition at line 397 of file SSL_Asynch_Stream.cpp. References do_SSL_handshake(), do_SSL_read(), do_SSL_shutdown(), do_SSL_write(), notify_close(), and SF_REQ_SHUTDOWN. Referenced by close(), handle_read_stream(), handle_write_stream(), open(), read(), and write(). { // this protected member should be called // with locked mutex_ int retval = this->do_SSL_handshake (); if (retval == 0) // handshake in progress ? return 0; if (retval < 0) this->flags_ |= SF_REQ_SHUTDOWN; this->do_SSL_read (); // execute user read request this->do_SSL_write (); // execute user write request if ((this->flags_ & SF_REQ_SHUTDOWN) == 0) // Do we have any errors return 0; this->do_SSL_shutdown (); this->notify_close (); return 0; }

int ACE_SSL_Asynch_Stream::do_SSL_write (  void   )  [protected]

Definition at line 598 of file SSL_Asynch_Stream.cpp. References ACE_TEXT, ERR_CANCELED, ext_write_result_, notify_write(), print_error(), ACE_Message_Block::rd_ptr(), SF_REQ_SHUTDOWN, and ssl_. Referenced by do_SSL_state_machine(). { if (this->ext_write_result_ == 0) // nothing to do return 0; if (this->flags_ & SF_REQ_SHUTDOWN) { this->notify_write (0, ERR_CANCELED); return -1; } ACE_Message_Block & mb = this->ext_write_result_->message_block (); size_t bytes_req = this->ext_write_result_->bytes_to_write (); ERR_clear_error(); const int bytes_trn = ::SSL_write (this->ssl_, mb.rd_ptr (), bytes_req); int const status = ::SSL_get_error (this->ssl_, bytes_trn); switch (status) { case SSL_ERROR_NONE: this->notify_write (bytes_trn, 0); return 1; case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: return 0; case SSL_ERROR_ZERO_RETURN: this->notify_write (bytes_trn, 0); return 1; case SSL_ERROR_SYSCALL: default: break; } this->notify_write(0, EFAULT); this->print_error (status, ACE_TEXT ("SSL_write error")); return -1; }

void ACE_SSL_Asynch_Stream::handle_read_stream (  const ACE_Asynch_Read_Stream::Result &  result  )  [protected, virtual]

This method is called when BIO read request is completed. It processes the IO completion and calls do_SSL_state_machine(). Definition at line 988 of file SSL_Asynch_Stream.cpp. References ACE_GUARD, ACE_SYNCH_MUTEX, BF_AIO, BF_EOS, bio_inp_errno_, bio_inp_flag_, and do_SSL_state_machine(). { 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 ACE_SSL_Asynch_Stream::handle_wakeup (  void   )  [protected, virtual]

This method is called when all SSL sessions are closed and no more pending AIOs exist. It also calls users handle_wakeup(). Definition at line 1009 of file SSL_Asynch_Stream.cpp. References ACE_GUARD, ACE_SYNCH_MUTEX, ext_handler_, and SF_DELETE_ENABLE. { ACE_Handler * user_handler = 0; { ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_)); this->flags_ |= SF_DELETE_ENABLE; user_handler = this->ext_handler_; } if (user_handler != 0) user_handler->handle_wakeup(); }

void ACE_SSL_Asynch_Stream::handle_write_stream (  const ACE_Asynch_Write_Stream::Result &  result  )  [protected, virtual]

virtual from ACE_Handler This method is called when BIO write request is completed. It processes the IO completion and calls do_SSL_state_machine(). Definition at line 943 of file SSL_Asynch_Stream.cpp. References ACE_ERROR, ACE_GUARD, ACE_SIGRTMIN, ACE_SYNCH_MUTEX, ACE_TEXT, BF_AIO, bio_ostream_, bio_out_errno_, bio_out_flag_, do_SSL_state_machine(), and LM_ERROR. { 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; } ACE_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; }

virtual ACE_Asynch_Operation_Impl* ACE_SSL_Asynch_Stream::implementation (  void   )  const [inline, protected, virtual]

Virtual from ACE_Asynch_Operation. Since this class is essentially an implementation class, simply return 0. Definition at line 279 of file SSL_Asynch_Stream.h. { return 0; }

int ACE_SSL_Asynch_Stream::notify_close (  void   )  [protected]

This method is called to notify ourself that SSL session is shutdown and that there is no more I/O activity now and in the future. Definition at line 655 of file SSL_Asynch_Stream.cpp. References ACE_NEW_RETURN, pending_BIO_count(), SF_CLOSE_NTF_SENT, and SF_SHUTDOWN_DONE. Referenced by do_SSL_state_machine(). { if (this->flags_ & SF_CLOSE_NTF_SENT) // already sent return 1; if ((this->flags_ & SF_SHUTDOWN_DONE) == 0) // only after shutdown return 2; // too early , we will do later if (this->pending_BIO_count () != 0) // wait for all internal IO return 2; // too early , we will do later // create result for future notification ACE_SSL_Asynch_Result * close_result = 0; ACE_NEW_RETURN (close_result, ACE_SSL_Asynch_Result (*this), 2); //@@ Not exception safe! int retval = close_result->post_completion (this->proactor_->implementation ()); if (retval == 0) { this->flags_ |= SF_CLOSE_NTF_SENT; return 0; } delete close_result; return 2; }

int ACE_SSL_Asynch_Stream::notify_read (  int  bytes_transferred, int  error )  [protected]

This method is called to notify user handler when user's read in done. Definition at line 696 of file SSL_Asynch_Stream.cpp. References ext_read_result_. Referenced by cancel(), do_SSL_read(), and do_SSL_shutdown(). { if (ext_read_result_ == 0) //nothing to notify return 1; this->ext_read_result_->set_bytes_transferred (bytes_transferred); this->ext_read_result_->set_error (error); int retval = this->ext_read_result_->post_completion (proactor_->implementation ()); if (retval == 0) { this->ext_read_result_ = 0; return 0; // success } return 2; // unable to notify }

int ACE_SSL_Asynch_Stream::notify_write (  int  bytes_transferred, int  error )  [protected]

This method is called to notify user handler when user's write in done. Definition at line 726 of file SSL_Asynch_Stream.cpp. References ext_write_result_. Referenced by cancel(), do_SSL_shutdown(), and do_SSL_write(). { if (this->ext_write_result_ == 0) //nothing to notify return 1; this->ext_write_result_->set_bytes_transferred (bytes_transferred); this->ext_write_result_->set_error (error); int retval = this->ext_write_result_->post_completion ( this->proactor_->implementation ()); if (retval == 0) { this->ext_write_result_ = 0; return 0; // success } return 2; // unable to notify }

int ACE_SSL_Asynch_Stream::open (  ACE_Handler &  handler, ACE_HANDLE  handle = ACE_INVALID_HANDLE, const void *  completion_key = 0, ACE_Proactor *  proactor = 0 )

Initializes the factory with information which will be used with each asynchronous call. handler The ACE_Handler that will be called to handle completions for operations initiated using this factory. handle The handle that future read/write operations will use. Return values: 0  for success. -1  for failure; consult errno for further information. Definition at line 222 of file SSL_Asynch_Stream.cpp. References ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_SSL_make_BIO(), ACE_SYNCH_MUTEX, ACE_TEXT, bio_, bio_istream_, bio_ostream_, do_SSL_state_machine(), ext_handler_, LM_ERROR, SF_STREAM_OPEN, ssl_, ST_CLIENT, and ST_SERVER. { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); if (this->flags_ & SF_STREAM_OPEN) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"), ACE_TEXT ("- already opened")), -1); if (this->ssl_ == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"), ACE_TEXT ("- SSL structure is absent")), -1); if (handle == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"), ACE_TEXT ("- invalid handle")), -1); // Get a proactor for/from the user. this->proactor_ = this->get_proactor (proactor, handler); this->ext_handler_ = & handler; this->handle_ = handle; // Open internal input stream if (this->bio_istream_.open (*this, // real callbacks to this handle, completion_key, this->proactor_) != 0) return -1; // Open internal output stream if (this->bio_ostream_.open (*this, // real callbacks to this handle, completion_key, this->proactor_) != 0) return -1; this->bio_ = ACE_SSL_make_BIO (this); if (this->bio_ == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"), ACE_TEXT ("- cannot allocate new BIO structure")), -1); ::SSL_set_bio (this->ssl_ , this->bio_ , this->bio_); switch (this->type_) { case ST_CLIENT: ::SSL_set_connect_state (this->ssl_); break; case ST_SERVER: ::SSL_set_accept_state (this->ssl_); break; default: ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"), ACE_TEXT ("- invalid stream type")), -1); } this->flags_ |= SF_STREAM_OPEN; this->do_SSL_state_machine (); return 0; }

ACE_SSL_Asynch_Stream& ACE_SSL_Asynch_Stream::operator= (  ACE_SSL_Asynch_Stream const &   )  [private]

int ACE_SSL_Asynch_Stream::pending_BIO_count (  void   )  [protected]

Definition at line 1026 of file SSL_Asynch_Stream.cpp. References BF_AIO, bio_inp_flag_, and bio_out_flag_. Referenced by notify_close(). { int ret = 0; if (this->bio_inp_flag_ & BF_AIO) ++ret; if (this->bio_out_flag_ & BF_AIO) ++ret; return ret; }

void ACE_SSL_Asynch_Stream::print_error (  int  err_ssl, const ACE_TCHAR *  pText )  [protected]

Definition at line 752 of file SSL_Asynch_Stream.cpp. References ACE_DEBUG, and LM_DEBUG. Referenced by do_SSL_handshake(), do_SSL_read(), do_SSL_shutdown(), and do_SSL_write(). { ACE_DEBUG ((LM_DEBUG, "SSL-error:%d %s\n" , err_ssl, pText)); #if OPENSSL_VERSION_NUMBER >= 0x0090601fL // OpenSSL < 0.9.6a doesn't have ERR_error_string_n() function. unsigned long lerr = 0; char buf[1024]; while ((lerr = ERR_get_error()) != 0) { ERR_error_string_n (lerr, buf, sizeof buf); ACE_DEBUG ((LM_DEBUG, "%s\n", buf)); } #endif /* OPENSSL_VERSION_NUMBER */ }

int ACE_SSL_Asynch_Stream::read (  ACE_Message_Block &  message_block, size_t  num_bytes_to_read, const void *  act = 0, int  priority = 0, int  signal_number = ACE_SIGRTMIN )

Initiates an asynchronous read. If the operation is successfully initiated, the handle_read_stream() method will be called on the ACE_Handler object passed to open() when the operation completes. Data is read into the specified ACE_Message_Block beginning at its write pointer; the block's write pointer is updated to reflect any added data when the operation completes. message_block The specified ACE_Message_Block will receive any data that is read. Data will be read into the block beginning at the block's write pointer. num_bytes_to_read The maximum number of bytes to read. The actual amount read may be less. act ACT which is passed to the completion handler in the result object. priority Specifies the operation priority. This has an affect on POSIX only. Works like nice in Unix. Negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than process, and so forth. This parameter has no affect on Win32. signal_number The POSIX4 real-time signal number to be used for the operation. signal_number ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is unused on non-POSIX4 systems. Return values: 0  for success. -1  for failure; consult errno for further information. Definition at line 312 of file SSL_Asynch_Stream.cpp. References ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_SYNCH_MUTEX, do_SSL_state_machine(), ext_read_result_, SF_REQ_SHUTDOWN, and SF_STREAM_OPEN. { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); if ((this->flags_ & SF_STREAM_OPEN) == 0) // not open return -1; if (this->flags_ & SF_REQ_SHUTDOWN) return -1; // only one read operation is allowed now // later it will be possible to make a queue if (this->ext_read_result_ != 0) return -1; // create result for future notification ACE_NEW_RETURN (this->ext_read_result_, ACE_SSL_Asynch_Read_Stream_Result ( *this->ext_handler_, this->handle_, message_block, bytes_to_read, act, this->proactor_->get_handle(), priority, signal_number), -1); this->do_SSL_state_machine (); // ignore return code return 0; }

int ACE_SSL_Asynch_Stream::ssl_bio_read (  char *  buf, size_t  len, int &  errval )  [protected]

Definition at line 780 of file SSL_Asynch_Stream.cpp. References ACE_ERROR, ACE_SIGRTMIN, ACE_TEXT, ACE_Message_Block::base(), BF_AIO, BF_EOS, bio_inp_errno_, bio_inp_flag_, bio_inp_msg_, bio_istream_, EINPROGRESS, ACE_Message_Block::length(), LM_ERROR, ACE_OS::memcpy(), ACE_Message_Block::rd_ptr(), ACE_Message_Block::size(), and ACE_Message_Block::wr_ptr(). Referenced by ACE_SSL_Asynch_Stream_Accessor::read(). { // We do not have to acquire mutex // as we called already with locked mutex // from do_SSL_state_machine() errval = 0; size_t cur_len = this->bio_inp_msg_.length (); if (cur_len > 0) // there are more data buffered { const char * rd_ptr = this->bio_inp_msg_.rd_ptr (); if (cur_len > len) cur_len = len; ACE_OS::memcpy (buf, rd_ptr, cur_len); this->bio_inp_msg_.rd_ptr (cur_len); // go ahead return cur_len; } if (this->bio_inp_errno_ != 0) // if was error - it is permanent ! { errval = this->bio_inp_errno_; return -1; } if (this->bio_inp_flag_ & BF_EOS) // End of stream return 0; errval = EINPROGRESS; // SSL will try later if (this->bio_inp_flag_ & BF_AIO) // we are busy return -1; if (this->bio_inp_msg_.size (len) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("error in ACE_Message_Block::size() ") )); errval = EINVAL; return -1; } char * base = this->bio_inp_msg_.base (); this->bio_inp_msg_.rd_ptr (base); this->bio_inp_msg_.wr_ptr (base); if (this->bio_istream_.read ( bio_inp_msg_, // message block len, // priority 0, // act 0, // priority ACE_SIGRTMIN // default signal ) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%N:%l (%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("attempt read failed") )); errval = EINVAL; // may be leave EINPROGRESS ?? return -1; // to try later } this->bio_inp_flag_ |= BF_AIO; // AIO is active return -1; }

int ACE_SSL_Asynch_Stream::ssl_bio_write (  const char *  buf, size_t  len, int &  errval )  [protected]

Definition at line 862 of file SSL_Asynch_Stream.cpp. References ACE_ERROR, ACE_SIGRTMIN, ACE_TEXT, ACE_Message_Block::base(), BF_AIO, bio_ostream_, bio_out_errno_, bio_out_flag_, bio_out_msg_, ACE_Message_Block::copy(), EINPROGRESS, LM_ERROR, ACE_Message_Block::rd_ptr(), ACE_Message_Block::size(), and ACE_Message_Block::wr_ptr(). Referenced by ACE_SSL_Asynch_Stream_Accessor::write(). { // We do not have to acquire mutex // as we called already with locked mutex // from do_SSL_state_machine errval = 0; if (this->bio_out_flag_ & BF_AIO) // sorry, we are busy { errval = EINPROGRESS; // try later return -1; } if (this->bio_out_errno_ != 0) // no recovery { errval = this->bio_out_errno_; return -1; } if (this->bio_out_msg_.size (len) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("error in ACE_Message_Block::size() ") )); errval = EINVAL; return -1; } char * base = this->bio_out_msg_.base (); this->bio_out_msg_.rd_ptr (base); this->bio_out_msg_.wr_ptr (base); if (this->bio_out_msg_.copy (buf, len) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("error in ACE_Message_Block::copy() ") )); errval = EINVAL; return -1; } if (this->bio_ostream_.write ( this->bio_out_msg_, // message block len, // priority 0, // act 0, // priority ACE_SIGRTMIN // default signal ) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"), ACE_TEXT ("attempt write failed") )); errval = EINVAL; // may be leave EINPROGRESS ?? return -1; // to try later } this->bio_out_flag_ |= BF_AIO; // AIO is active errval = 0; // Ok, go ahead return len; }

int ACE_SSL_Asynch_Stream::write (  ACE_Message_Block &  message_block, size_t  bytes_to_write, const void *  act = 0, int  priority = 0, int  signal_number = ACE_SIGRTMIN )

Initiates an asynchronous write. If the operation is successfully initiated, the handle_write_stream() method will be called on the ACE_Handler object passed to open() when the operation completes. Data is taken from the specified ACE_Message_Block beginning at its read pointer; the block's read pointer is updated to reflect any data successfully sent when the operation completes. message_block The specified ACE_Message_Block is the source of data that is written. Data will be taken from the block beginning at the block's read pointer. bytes_to_write The maximum number of bytes to write. The actual amount written may be less. act ACT which is passed to the completion handler in the result object. priority Specifies the operation priority. This has an affect on POSIX only. Works like nice in Unix. Negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than process, and so forth. This parameter has no affect on Win32. signal_number The POSIX4 real-time signal number to be used for the operation. signal_number ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is unused on non-POSIX4 systems. Return values: 0  for success. -1  for failure; consult errno for further information. Definition at line 355 of file SSL_Asynch_Stream.cpp. References ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_SYNCH_MUTEX, do_SSL_state_machine(), ext_write_result_, SF_REQ_SHUTDOWN, and SF_STREAM_OPEN. { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); if ((this->flags_ & SF_STREAM_OPEN) == 0) // not open return -1; if (this->flags_ & SF_REQ_SHUTDOWN) return -1; // only one read operation is allowed now // later it will be possible to make a queue if (this->ext_write_result_ != 0) return -1; // create result for future notification ACE_NEW_RETURN (this->ext_write_result_, ACE_SSL_Asynch_Write_Stream_Result ( *this->ext_handler_, this->handle_, message_block, bytes_to_write, act, this->proactor_->get_handle(), priority, signal_number), -1); this->do_SSL_state_machine (); return 0; }

---

Friends And Related Function Documentation

friend struct ACE_SSL_Asynch_Stream_Accessor [friend]

Definition at line 160 of file SSL_Asynch_Stream.h.

---

Member Data Documentation

BIO* ACE_SSL_Asynch_Stream::bio_ [protected]

The BIO implementation. Definition at line 381 of file SSL_Asynch_Stream.h. Referenced by open().

int ACE_SSL_Asynch_Stream::bio_inp_errno_ [protected]

Definition at line 399 of file SSL_Asynch_Stream.h. Referenced by handle_read_stream(), and ssl_bio_read().

int ACE_SSL_Asynch_Stream::bio_inp_flag_ [protected]

Definition at line 400 of file SSL_Asynch_Stream.h. Referenced by handle_read_stream(), pending_BIO_count(), and ssl_bio_read().

ACE_Message_Block ACE_SSL_Asynch_Stream::bio_inp_msg_ [protected]

Definition at line 398 of file SSL_Asynch_Stream.h. Referenced by ssl_bio_read().

ACE_Asynch_Read_Stream ACE_SSL_Asynch_Stream::bio_istream_ [protected]

Definition at line 397 of file SSL_Asynch_Stream.h. Referenced by cancel(), open(), and ssl_bio_read().

ACE_Asynch_Write_Stream ACE_SSL_Asynch_Stream::bio_ostream_ [protected]

Definition at line 407 of file SSL_Asynch_Stream.h. Referenced by cancel(), handle_write_stream(), open(), and ssl_bio_write().

int ACE_SSL_Asynch_Stream::bio_out_errno_ [protected]

Definition at line 409 of file SSL_Asynch_Stream.h. Referenced by handle_write_stream(), and ssl_bio_write().

int ACE_SSL_Asynch_Stream::bio_out_flag_ [protected]

Definition at line 410 of file SSL_Asynch_Stream.h. Referenced by handle_write_stream(), pending_BIO_count(), and ssl_bio_write().

ACE_Message_Block ACE_SSL_Asynch_Stream::bio_out_msg_ [protected]

Definition at line 408 of file SSL_Asynch_Stream.h. Referenced by ssl_bio_write().

ACE_Handler* ACE_SSL_Asynch_Stream::ext_handler_ [protected]

External,i.e user handler. Definition at line 352 of file SSL_Asynch_Stream.h. Referenced by handle_wakeup(), and open().

ACE_SSL_Asynch_Read_Stream_Result* ACE_SSL_Asynch_Stream::ext_read_result_ [protected]

External, i.e. read result faked for user. Definition at line 355 of file SSL_Asynch_Stream.h. Referenced by do_SSL_read(), notify_read(), and read().

ACE_SSL_Asynch_Write_Stream_Result* ACE_SSL_Asynch_Stream::ext_write_result_ [protected]

External, i.e. write result faked for user. Definition at line 358 of file SSL_Asynch_Stream.h. Referenced by do_SSL_write(), notify_write(), and write().

int ACE_SSL_Asynch_Stream::flags_ [protected]

Definition at line 375 of file SSL_Asynch_Stream.h.

ACE_HANDLE ACE_SSL_Asynch_Stream::handle_ [protected]

The real file/socket handle. Definition at line 346 of file SSL_Asynch_Stream.h.

ACE_SYNCH_MUTEX ACE_SSL_Asynch_Stream::mutex_ [protected]

Mutex to protect work. Definition at line 414 of file SSL_Asynch_Stream.h.

ACE_Proactor* ACE_SSL_Asynch_Stream::proactor_ [protected]

The proactor. Definition at line 349 of file SSL_Asynch_Stream.h.

SSL* ACE_SSL_Asynch_Stream::ssl_ [protected]

The SSL session. Definition at line 378 of file SSL_Asynch_Stream.h. Referenced by ACE_SSL_Asynch_Stream(), do_SSL_handshake(), do_SSL_read(), do_SSL_shutdown(), do_SSL_write(), open(), and ~ACE_SSL_Asynch_Stream().

Stream_Type ACE_SSL_Asynch_Stream::type_ [protected]

Stream Type ST_CLIENT/ST_SERVER. Definition at line 343 of file SSL_Asynch_Stream.h.

---

The documentation for this class was generated from the following files:

• SSL_Asynch_Stream.h
• SSL_Asynch_Stream.cpp

---