ACE_Asynch_Connector< HANDLER > Class Template Reference

This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections. More...

#include <Asynch_Connector.h>

Inheritance diagram for ACE_Asynch_Connector< HANDLER >:

[legend]Collaboration diagram for ACE_Asynch_Connector< HANDLER >:

[legend]List of all members.

Public Member Functions
	ACE_Asynch_Connector (void)
	A do nothing constructor.
virtual	~ACE_Asynch_Connector (void)
	Virtual destruction.
virtual int	open (int pass_addresses=0, ACE_Proactor *proactor=0, int validate_new_connection=1)
virtual int	connect (const ACE_INET_Addr &remote_sap, const ACE_INET_Addr &local_sap=(const ACE_INET_Addr &) ACE_Addr::sap_any, int reuse_addr=1, const void *act=0)
	This initiates a new asynchronous connect.
virtual int	cancel (void)
virtual int	validate_connection (const ACE_Asynch_Connect::Result &result, const ACE_INET_Addr &remote, const ACE_INET_Addr &local)
virtual int	pass_addresses (void) const
virtual void	pass_addresses (int new_value)
virtual int	validate_new_connection (void) const
virtual void	validate_new_connection (int new_value)
Protected Member Functions
virtual void	handle_connect (const ACE_Asynch_Connect::Result &result)
	This is called when an outstanding accept completes.
void	parse_address (const ACE_Asynch_Connect::Result &result, ACE_INET_Addr &remote_address, ACE_INET_Addr &local_address)
	This parses the address from read buffer.
ACE_Asynch_Connect &	asynch_connect (void)
	Return the asynch Connect object.
virtual HANDLER *	make_handler (void)
Private Attributes
ACE_Asynch_Connect	asynch_connect_
	Asynch_Connect used to make life easier :-).
int	pass_addresses_
	Flag that indicates if parsing of addresses is necessary.
int	validate_new_connection_
	Flag that indicates if address validation is required.

---

Detailed Description

template<class HANDLER>
class ACE_Asynch_Connector< HANDLER >

This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections.

Unlike the ACE_Connector, however, this class is designed to be used asynchronously with the ACE Proactor framework.

Definition at line 46 of file Asynch_Connector.h.

---

Constructor & Destructor Documentation

template<class HANDLER> ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Asynch_Connector< HANDLER >::ACE_Asynch_Connector (  void   )

A do nothing constructor. Definition at line 25 of file Asynch_Connector.cpp. : pass_addresses_ (0), validate_new_connection_ (0) { }

template<class HANDLER> ACE_Asynch_Connector< HANDLER >::~ACE_Asynch_Connector (  void   )  [virtual]

Virtual destruction. Definition at line 32 of file Asynch_Connector.cpp. { //this->asynch_connect_.close (); }

---

Member Function Documentation

template<class HANDLER> ACE_Asynch_Connect & ACE_Asynch_Connector< HANDLER >::asynch_connect (  void   )  [protected]

Return the asynch Connect object. Definition at line 255 of file Asynch_Connector.cpp. References ACE_Asynch_Connector< HANDLER >::asynch_connect_. { return this->asynch_connect_; }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::cancel (  void   )  [virtual]

This cancels all pending accepts operations that were issued by the calling thread. Note: On Windows, this method does not cancel connect operations issued by other threads. On POSIX, delegates cancelation to ACE_POSIX_Asynch_Connect. Definition at line 178 of file Asynch_Connector.cpp. References ACE_Asynch_Connector< HANDLER >::asynch_connect_, and ACE_Asynch_Operation::cancel(). { return this->asynch_connect_.cancel (); }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::connect (  const ACE_INET_Addr &  remote_sap, const ACE_INET_Addr &  local_sap = (const ACE_INET_Addr &) ACE_Addr::sap_any, int  reuse_addr = 1, const void *  act = 0 )  [virtual]

This initiates a new asynchronous connect. Definition at line 59 of file Asynch_Connector.cpp. References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_Asynch_Connector< HANDLER >::asynch_connect_, ACE_Asynch_Connect::connect(), and LM_ERROR. { // Initiate asynchronous connect if (this->asynch_connect_.connect (ACE_INVALID_HANDLE, remote_sap, local_sap, reuse_addr, act) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Connect::connect")), -1); return 0; }

template<class HANDLER> void ACE_Asynch_Connector< HANDLER >::handle_connect (  const ACE_Asynch_Connect::Result &  result  )  [protected, virtual]

This is called when an outstanding accept completes. Reimplemented from ACE_Handler. Definition at line 78 of file Asynch_Connector.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_NONBLOCK, ACE_Asynch_Result::act(), ACE_OS::closesocket(), ACE_Asynch_Connect::Result::connect_handle(), ACE_Asynch_Result::error(), LM_ERROR, ACE_Asynch_Connector< HANDLER >::make_handler(), ACE_Asynch_Connector< HANDLER >::parse_address(), ACE_Asynch_Result::success(), and ACE_Asynch_Connector< HANDLER >::validate_connection(). { // Variable for error tracking int error = 0; // If the asynchronous connect fails. if (!result.success () || result.connect_handle () == ACE_INVALID_HANDLE) { error = 1; } if (result.error () != 0) { error = 1; } // set blocking mode if (!error && ACE::clr_flags (result.connect_handle (), ACE_NONBLOCK) != 0) { error = 1; ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Connector::handle_connect : Set blocking mode"))); } // Parse the addresses. ACE_INET_Addr local_address; ACE_INET_Addr remote_address; if (!error && (this->validate_new_connection_ || this->pass_addresses_)) this->parse_address (result, remote_address, local_address); // Call validate_connection even if there was an error - it's the only // way the application can learn the connect disposition. if (this->validate_new_connection_ && this->validate_connection (result, remote_address, local_address) == -1) { error = 1; } HANDLER *new_handler = 0; if (!error) { // The Template method new_handler = this->make_handler (); if (new_handler == 0) { error = 1; ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Connector::handle_connect : Making of new handler failed"))); } } // If no errors if (!error) { // Update the Proactor. new_handler->proactor (this->proactor ()); // Pass the addresses if (this->pass_addresses_) new_handler->addresses (remote_address, local_address); // Pass the ACT if (result.act () != 0) new_handler->act (result.act ()); // Set up the handler's new handle value new_handler->handle (result.connect_handle ()); ACE_Message_Block mb; // Initiate the handler with empty message block; new_handler->open (result.connect_handle (), mb); } // On failure, no choice but to close the socket if (error && result.connect_handle() != ACE_INVALID_HANDLE) ACE_OS::closesocket (result.connect_handle ()); }

template<class HANDLER> HANDLER * ACE_Asynch_Connector< HANDLER >::make_handler (  void   )  [protected, virtual]

This is the template method used to create new handler. Subclasses must overwrite this method if a new handler creation strategy is required. Definition at line 261 of file Asynch_Connector.cpp. References ACE_NEW_RETURN. Referenced by ACE_Asynch_Connector< HANDLER >::handle_connect(). { // Default behavior HANDLER *handler = 0; ACE_NEW_RETURN (handler, HANDLER, 0); return handler; }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::open (  int  pass_addresses = 0, ACE_Proactor *  proactor = 0, int  validate_new_connection = 1 )  [virtual]

This opens asynch connector Definition at line 38 of file Asynch_Connector.cpp. References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_Asynch_Connector< HANDLER >::asynch_connect_, LM_ERROR, ACE_Asynch_Connect::open(), and ACE_Handler::proactor(). { this->proactor (proactor); this->pass_addresses_ = pass_addresses; this->validate_new_connection_ = validate_new_connection; // Initialize the ACE_Asynch_Connect if (this->asynch_connect_.open (*this, ACE_INVALID_HANDLE, 0, this->proactor ()) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Connect::open")), -1); return 0; }

template<class HANDLER> void ACE_Asynch_Connector< HANDLER >::parse_address (  const ACE_Asynch_Connect::Result &  result, ACE_INET_Addr &  remote_address, ACE_INET_Addr &  local_address )  [protected]

This parses the address from read buffer. Definition at line 184 of file Asynch_Connector.cpp. References ACE_DEBUG, ACE_ERROR, ACE_LIB_TEXT, ACE_INET_Addr::addr_to_string(), ACE_Asynch_Connect::Result::connect_handle(), ACE_OS::getpeername(), ACE_OS::getsockname(), LM_DEBUG, LM_ERROR, and ACE_INET_Addr::set(). Referenced by ACE_Asynch_Connector< HANDLER >::handle_connect(). { #if defined (ACE_HAS_IPV6) // Getting the addresses. sockaddr_in6 local_addr; sockaddr_in6 remote_addr; #else // Getting the addresses. sockaddr_in local_addr; sockaddr_in remote_addr; #endif /* ACE_HAS_IPV6 */ // Get the length. int local_size = sizeof (local_addr); int remote_size = sizeof (remote_addr); // Get the local address. if (ACE_OS::getsockname (result.connect_handle (), reinterpret_cast<sockaddr *> (&local_addr), &local_size) < 0) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT("%p\n"), ACE_LIB_TEXT("ACE_Asynch_Connector::<getsockname> failed"))); // Get the remote address. if (ACE_OS::getpeername (result.connect_handle (), reinterpret_cast<sockaddr *> (&remote_addr), &remote_size) < 0) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT("%p\n"), ACE_LIB_TEXT("ACE_Asynch_Connector::<getpeername> failed"))); // Set the addresses. local_address.set (reinterpret_cast<sockaddr_in *> (&local_addr), local_size); remote_address.set (reinterpret_cast<sockaddr_in *> (&remote_addr), remote_size); #if 0 // @@ Just debugging. char local_address_buf [BUFSIZ]; char remote_address_buf [BUFSIZ]; if (local_address.addr_to_string (local_address_buf, sizeof local_address_buf) == -1) ACE_ERROR ((LM_ERROR, "Error:%m:can't obtain local_address's address string")); ACE_DEBUG ((LM_DEBUG, "ACE_Asynch_Connector<HANDLER>::parse_address : " "Local address %s\n", local_address_buf)); if (remote_address.addr_to_string (remote_address_buf, sizeof remote_address_buf) == -1) ACE_ERROR ((LM_ERROR, "Error:%m:can't obtain remote_address's address string")); ACE_DEBUG ((LM_DEBUG, "ACE_Asynch_Connector<HANDLER>::parse_address : " "Remote address %s\n", remote_address_buf)); #endif /* 0 */ return; }

template<class HANDLER> void ACE_Asynch_Connector< HANDLER >::pass_addresses (  int  new_value  )  [virtual]

Definition at line 276 of file Asynch_Connector.cpp. { this->pass_addresses_ = new_value; }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::pass_addresses (  void   )  const [virtual]

Set and get flag that indicates if parsing and passing of addresses to the service_handler is necessary. Definition at line 270 of file Asynch_Connector.cpp. { return this->pass_addresses_; }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::validate_connection (  const ACE_Asynch_Connect::Result &  result, const ACE_INET_Addr &  remote, const ACE_INET_Addr &  local )  [virtual]

Template method to validate peer before service is opened. This method is called when the connection attempt completes, whether it succeeded or failed, if the validate_connection argument to open() was non-zero or the validate_new_connection() method is called to turn this feature on. The default implementation returns 0. Users can (and probably should) reimplement this method to learn about the success or failure of the connection attempt. If the connection completed successfully, this method can be used to perform validation of the peer using it's address, running an authentication procedure (such as SSL) or anything else necessary or desireable. The return value from this method determines whether or not ACE will continue opening the service or abort the connection. Parameters: result  Result of the connection acceptance. Use result.success() to determine success or failure of the connection attempt. remote  Peer's address. If the connection failed, this object is undefined. local  Local address connection was completed from. If the connection failed, this object is undefined. Return values: -1  ACE_Asynch_Connector will close the connection, and the service will not be opened. 0  Service opening will proceeed. Returns: Return value is ignored if the connection attempt failed. Definition at line 169 of file Asynch_Connector.cpp. References ACE_INET_Addr. Referenced by ACE_Asynch_Connector< HANDLER >::handle_connect(). { // Default implementation always validates the remote address. return 0; }

template<class HANDLER> void ACE_Asynch_Connector< HANDLER >::validate_new_connection (  int  new_value  )  [virtual]

Definition at line 288 of file Asynch_Connector.cpp. { this->validate_new_connection_ = new_value; }

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::validate_new_connection (  void   )  const [virtual]

Set and get flag that indicates if address validation is required. Definition at line 282 of file Asynch_Connector.cpp. { return this->validate_new_connection_; }

---

Member Data Documentation

template<class HANDLER> ACE_Asynch_Connect ACE_Asynch_Connector< HANDLER >::asynch_connect_ [private]

Asynch_Connect used to make life easier :-). Definition at line 150 of file Asynch_Connector.h. Referenced by ACE_Asynch_Connector< HANDLER >::asynch_connect(), ACE_Asynch_Connector< HANDLER >::cancel(), ACE_Asynch_Connector< HANDLER >::connect(), and ACE_Asynch_Connector< HANDLER >::open().

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::pass_addresses_ [private]

Flag that indicates if parsing of addresses is necessary. Definition at line 153 of file Asynch_Connector.h.

template<class HANDLER> int ACE_Asynch_Connector< HANDLER >::validate_new_connection_ [private]

Flag that indicates if address validation is required. Definition at line 156 of file Asynch_Connector.h.

---

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

• Asynch_Connector.h
• Asynch_Connector.cpp

---