---

ACE_Asynch_Acceptor Class Template Reference

This class is an example of the Acceptor Pattern. This class will accept new connections and create new HANDLER to handle the new connections. More...

#include <Asynch_Acceptor.h>

Inheritance diagram for ACE_Asynch_Acceptor:

[legend]Collaboration diagram for ACE_Asynch_Acceptor:

[legend]List of all members.

Public Methods
	ACE_Asynch_Acceptor (void)
	A do nothing constructor. More...
virtual	~ACE_Asynch_Acceptor (void)
	Virtual destruction. More...
virtual int	open (const ACE_INET_Addr &address, size_t bytes_to_read=0, int pass_addresses=0, int backlog=ACE_DEFAULT_BACKLOG, int reuse_addr=1, ACE_Proactor *proactor=0, int validate_new_connection=0, int reissue_accept=1, int number_of_initial_accepts=-1)
virtual ACE_HANDLE	get_handle (void) const
	Get the underlying handle. More...
virtual void	set_handle (ACE_HANDLE handle)
virtual int	accept (size_t bytes_to_read=0, const void *act=0)
	This initiates a new asynchronous accept operation. More...
virtual int	cancel (void)
virtual int	validate_connection (const ACE_Asynch_Accept::Result &result, const ACE_INET_Addr &remote, const ACE_INET_Addr &local)
virtual int	validate_new_connection (const ACE_INET_Addr &remote_address)
virtual int	should_reissue_accept (void)
virtual int	pass_addresses (void) const
	Get flag that indicates if parsing and passing of addresses to the service_handler is necessary. More...
virtual void	pass_addresses (int new_value)
	Set flag that indicates if parsing and passing of addresses to the service_handler is necessary. More...
virtual int	validate_new_connection (void) const
	Get flag that indicates if address validation is required. More...
virtual void	validate_new_connection (int new_value)
	Set flag that indicates if address validation is required. More...
virtual int	reissue_accept (void) const
	Get flag that indicates if a new accept should be reissued when a accept completes. More...
virtual void	reissue_accept (int new_value)
	Set flag that indicates if a new accept should be reissued when a accept completes. More...
virtual size_t	bytes_to_read (void) const
	Get bytes to be read with the <accept> call. More...
virtual void	bytes_to_read (size_t new_value)
	Set bytes to be read with the <accept> call. More...
Static Public Methods
size_t	address_size (void)
	This is required by the AcceptEx call. More...
Protected Methods
virtual void	handle_accept (const ACE_Asynch_Accept::Result &result)
	This is called when an outstanding accept completes. More...
ACE_HANDLE	handle (void) const
	Return the listen handle. More...
void	handle (ACE_HANDLE h)
	Set the listen handle. More...
void	parse_address (const ACE_Asynch_Accept::Result &result, ACE_INET_Addr &remote_address, ACE_INET_Addr &local_address)
	This parses the address from read buffer. More...
ACE_Asynch_Accept &	asynch_accept (void)
	Return the asynch accept object. More...
virtual HANDLER *	make_handler (void)
Private Attributes
ACE_HANDLE	listen_handle_
	Handle used to listen for new connections. More...
ACE_Asynch_Accept	asynch_accept_
	<Asynch_Accept> used to make life easier :-). More...
int	pass_addresses_
	Flag that indicates if parsing of addresses is necessary. More...
int	validate_new_connection_
	Flag that indicates if address validation is required. More...
int	reissue_accept_
	Flag that indicates if a new accept should be reissued when a accept completes. More...
size_t	bytes_to_read_
	Bytes to be read with the <accept> call. More...

---

Detailed Description

template<class HANDLER>
class ACE_Asynch_Acceptor< HANDLER >

This class is an example of the Acceptor Pattern. This class will accept new connections and create new HANDLER to handle the new connections.

Unlike the <ACE_Acceptor>, however, this class is designed to be used asynchronously.

Definition at line 44 of file Asynch_Acceptor.h.

---

Constructor & Destructor Documentation

template<class HANDLER> ACE_Asynch_Acceptor< HANDLER >::ACE_Asynch_Acceptor (  void    )

A do nothing constructor. Definition at line 27 of file Asynch_Acceptor.cpp. : listen_handle_ (ACE_INVALID_HANDLE), pass_addresses_ (0), validate_new_connection_ (0), reissue_accept_ (1), bytes_to_read_ (0) { }

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

Virtual destruction. Definition at line 37 of file Asynch_Acceptor.cpp. { //this->asynch_accept_.close (); // Close down the listen socket // if (this->listen_handle_ != ACE_INVALID_HANDLE) // ACE_OS::closesocket (this->listen_handle_); }

---

Member Function Documentation

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::accept (  size_t    bytes_to_read = 0, const void *    act = 0 )  [virtual]

This initiates a new asynchronous accept operation. You need only call this method if the reissue_accept argument passed to open() was 0. Definition at line 162 of file Asynch_Acceptor.cpp. References ACE_Asynch_Accept::accept, ACE_NEW_RETURN, ACE_TRACE, address_size, asynch_accept_, bytes_to_read, and ACE_Message_Block::release. Referenced by handle_accept, and open. { ACE_TRACE ("ACE_Asynch_Acceptor<>::accept"); ACE_Message_Block *message_block = 0; size_t space_needed = bytes_to_read + 2 * this->address_size (); // Create a new message block big enough for the addresses and data ACE_NEW_RETURN (message_block, ACE_Message_Block (space_needed), -1); // Initiate asynchronous accepts if (this->asynch_accept_.accept (*message_block, bytes_to_read, ACE_INVALID_HANDLE, act) == -1) { // Cleanup on error message_block->release (); return -1; } return 0; }

template<class HANDLER> size_t ACE_Asynch_Acceptor< HANDLER >::address_size (  void    )  [static]

This is required by the AcceptEx call. Definition at line 401 of file Asynch_Acceptor.cpp. Referenced by accept. { return sizeof (sockaddr) + sizeof (sockaddr_in); }

template<class HANDLER> ACE_Asynch_Accept & ACE_Asynch_Acceptor< HANDLER >::asynch_accept (  void    )  [protected]

Return the asynch accept object. Definition at line 383 of file Asynch_Acceptor.cpp. References asynch_accept_. { return this->asynch_accept_; }

template<class HANDLER> void ACE_Asynch_Acceptor< HANDLER >::bytes_to_read (  size_t    new_value )  [virtual]

Set bytes to be read with the <accept> call. Definition at line 449 of file Asynch_Acceptor.cpp. References bytes_to_read_. { this->bytes_to_read_ = new_value; }

template<class HANDLER> size_t ACE_Asynch_Acceptor< HANDLER >::bytes_to_read (  void    )  const [virtual]

Get bytes to be read with the <accept> call. Definition at line 443 of file Asynch_Acceptor.cpp. References bytes_to_read_. Referenced by accept, and open. { return this->bytes_to_read_; }

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

Cancels all pending accepts operations issued by this object. Note: On Windows, only accept operations initiated by the calling thread are canceled. Definition at line 306 of file Asynch_Acceptor.cpp. References ACE_TRACE, asynch_accept_, ACE_Asynch_Operation::cancel, and listen_handle_. { ACE_TRACE ("ACE_Asynch_Acceptor<>::cancel"); // All I/O operations that are canceled will complete with the error // ERROR_OPERATION_ABORTED. All completion notifications for the I/O // operations will occur normally. #if (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) \ && ( (defined (_MSC_VER) && (_MSC_VER > 1020)) \ || (defined (__BORLANDC__) && (__BORLANDC__ >= 0x530))) return (int) ::CancelIo (this->listen_handle_); #else //ACE_NOTSUP_RETURN (-1); // Supported now return this->asynch_accept_.cancel(); #endif /* (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) && ((defined (_MSC_VER) && (_MSC_VER > 1020)) || (defined (__BORLANDC__) && (__BORLANDC__ >= 0x530))) */ }

template<class HANDLER> ACE_HANDLE ACE_Asynch_Acceptor< HANDLER >::get_handle (  void    )  const [virtual]

Get the underlying handle. Definition at line 156 of file Asynch_Acceptor.cpp. References listen_handle_. { return this->listen_handle_; }

template<class HANDLER> void ACE_Asynch_Acceptor< HANDLER >::handle (  ACE_HANDLE    h )  [protected, virtual]

Set the listen handle. Reimplemented from ACE_Handler. Definition at line 377 of file Asynch_Acceptor.cpp. References ACE_Handler::handle. { ACE_Handler::handle (h); }

template<class HANDLER> ACE_HANDLE ACE_Asynch_Acceptor< HANDLER >::handle (  void    )  const [protected, virtual]

Return the listen handle. Reimplemented from ACE_Handler. Definition at line 371 of file Asynch_Acceptor.cpp. References listen_handle_. { return this->listen_handle_; }

template<class HANDLER> void ACE_Asynch_Acceptor< HANDLER >::handle_accept (  const ACE_Asynch_Accept::Result &    result )  [protected, virtual]

This is called when an outstanding accept completes. Reimplemented from ACE_Handler. Definition at line 188 of file Asynch_Acceptor.cpp. References accept, ACE_Asynch_Accept::Result::accept_handle, ACE_TRACE, ACE_Asynch_Result::act, ACE_OS::closesocket, listen_handle_, make_handler, ACE_Asynch_Accept::Result::message_block, parse_address, pass_addresses_, ACE_Message_Block::release, ACE_OS::setsockopt, should_reissue_accept, ACE_Asynch_Result::success, validate_connection, validate_new_connection, and validate_new_connection_. { #if (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) || defined (ACE_HAS_AIO_CALLS) ACE_TRACE ("ACE_Asynch_Acceptor<>::handle_accept"); // Variable for error tracking int error = 0; // If the asynchronous accept fails. if (!result.success () || result.accept_handle() == ACE_INVALID_HANDLE ) { error = 1; } #if !defined (ACE_HAS_AIO_CALLS) // In order to use accept handle with other Window Sockets 1.1 // functions, we call the setsockopt function with the // SO_UPDATE_ACCEPT_CONTEXT option. This option initializes the // socket so that other Windows Sockets routines to access the // socket correctly. if (!error && ACE_OS::setsockopt (result.accept_handle (), SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *) &this->listen_handle_, sizeof (this->listen_handle_)) == -1) { error = 1; } #endif /* ACE_HAS_AIO_CALLS */ // Parse address. ACE_INET_Addr local_address; ACE_INET_Addr remote_address; if (!error && (this->validate_new_connection_ || this->pass_addresses_)) // Parse the addresses. this->parse_address (result, remote_address, local_address); // Validate remote address if (!error && this->validate_new_connection_ && (this->validate_connection (result, remote_address, local_address) == -1 || this->validate_new_connection (remote_address) == -1)) { error = 1; } HANDLER *new_handler = 0; if (!error) { // The Template method new_handler = this->make_handler (); if (new_handler == 0) { error = 1; } } // 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.accept_handle ()); // Initiate the handler new_handler->open (result.accept_handle (), result.message_block ()); } // On failure, no choice but to close the socket if (error && result.accept_handle() != ACE_INVALID_HANDLE ) ACE_OS::closesocket (result.accept_handle ()); // Delete the dynamically allocated message_block result.message_block ().release (); // Start off another asynchronous accept to keep the backlog going if (this->should_reissue_accept ()) this->accept (this->bytes_to_read_); #endif /* (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) || defined (ACE_HAS_AIO_CALLS */ }

template<class HANDLER> HANDLER * ACE_Asynch_Acceptor< 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 389 of file Asynch_Acceptor.cpp. References ACE_NEW_RETURN. Referenced by handle_accept. { // Default behavior HANDLER *handler = 0; ACE_NEW_RETURN (handler, HANDLER, 0); return handler; }

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::open (  const ACE_INET_Addr &    address, size_t    bytes_to_read = 0, int    pass_addresses = 0, int    backlog = ACE_DEFAULT_BACKLOG, int    reuse_addr = 1, ACE_Proactor *    proactor = 0, int    validate_new_connection = 0, int    reissue_accept = 1, int    number_of_initial_accepts = -1 )  [virtual]

open starts one or more asynchronous accept requests on a address. Each accept operation may optionally read an initial buffer from the new connection when accepted. Parameters: address  The address to listen/accept connections on. If the address does not specify a port, a random port is selected and bound. bytes_to_read  Optional, specifies the maximum number of bytes to read with the accept. The buffer for the initial data is allocated internally and passed to the ACE_Service_Handler::open() hook method. It is legitimate only during the open() method and must be copied if required after open() returns. This pre-read function works only on Windows. pass_addresses  Optional, a non-zero value indicates that the local and peer addresses should be passed to the associated ACE_Service_Handler::addresses() method after any call to validate_new_connection() and prior to the open() hook method call. backlog  Optional, defaulting to ACE_DEFAULT_BACKLOG (which can be adjusted in your platform's config.h file). Specifies the listening backlog for the listening socket. reuse_addr  Optional, indicates whether the SO_REUSEADDR option is set on the listening socket or not. proactor  Optional, pointer to the ACE_Proactor to use for demultiplexing asynchronous accepts. If 0, the process's singleton ACE_Proactor is used. validate_new_connection  Optional, if non-zero, this object's validate_connection() method is called after the accept completes, but before the service handler's open() hook method is called. If validate_connection() returns -1, the newly-accepted socket is immediately closed, and the addresses() method is not called. reissue_accept  Optional, if non-zero (the default), a new asynchronous accept operation is started after each completion, whether the completion is for success or failure, and whether or not a successfully-accepted connection is subsequently refused. number_of_initial_accepts  Optional, the number of asynchronous accepts that are started immediately. If -1 (the default), the value of backlog is used. Note: On Windows, the peer address is only available at the time the connection is accepted. Therefore, if you require the peer address on Windows, do not rely on the ACE_SOCK::get_remote_addr() method - it won't work. You must supply a non-zero value for pass_addresses and obtain the peer address in the ACE_Service_Handler::addresses() method. See also: ACE_INET_Addr , ACE_Service_Handler Definition at line 47 of file Asynch_Acceptor.cpp. References accept, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TRACE, asynch_accept_, ACE_OS::bind, ACE_Sock_Connect::bind_port, bytes_to_read, bytes_to_read_, ACE_INET_Addr::get_addr, ACE_Addr::get_size, ACE_Addr::get_type, ACE_OS::listen, listen_handle_, LM_ERROR, ACE_Asynch_Accept::open, pass_addresses, pass_addresses_, ACE_Handler::proactor, reissue_accept, reissue_accept_, ACE_OS::setsockopt, ACE_OS::socket, validate_new_connection, and validate_new_connection_. { ACE_TRACE ("ACE_Asynch_Acceptor<>::open"); this->proactor (proactor); this->pass_addresses_ = pass_addresses; this->bytes_to_read_ = bytes_to_read; this->validate_new_connection_ = validate_new_connection; this->reissue_accept_ = reissue_accept; // Create the listener socket this->listen_handle_ = ACE_OS::socket (address.get_type (), SOCK_STREAM, 0); if (this->listen_handle_ == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_OS::socket")), -1); // Initialize the ACE_Asynch_Accept if (this->asynch_accept_.open (*this, this->listen_handle_, 0, this->proactor ()) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Accept::open")), -1); if (reuse_addr) { // Reuse the address int one = 1; if (ACE_OS::setsockopt (this->listen_handle_, SOL_SOCKET, SO_REUSEADDR, (const char*) &one, sizeof one) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_OS::setsockopt")), -1); } // If port is not specified, bind to any port. static ACE_INET_Addr sa (ACE_sap_any_cast (const ACE_INET_Addr &)); if (address == sa && ACE_Sock_Connect::bind_port (this->listen_handle_) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE::bind_port")), -1); // Bind to the specified port. if (ACE_OS::bind (this->listen_handle_, ACE_reinterpret_cast (sockaddr *, address.get_addr ()), address.get_size ()) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_OS::bind"), -1); // Start listening. if (ACE_OS::listen (this->listen_handle_, backlog) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_OS::listen"), -1); // For the number of <intial_accepts>. if (number_of_initial_accepts == -1) number_of_initial_accepts = backlog; for (int i = 0; i < number_of_initial_accepts; i++) // Initiate accepts. if (this->accept (bytes_to_read) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Acceptor::accept"), -1); return 0; }

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

This parses the address from read buffer. Definition at line 326 of file Asynch_Acceptor.cpp. References ACE_Asynch_Accept::Result::accept_handle, ACE_TRACE, ENOTSUP, ACE_SOCK::get_local_addr, ACE_SOCK::get_remote_addr, ACE_Asynch_Accept::Result::message_block, ACE_Message_Block::rd_ptr, and ACE_INET_Addr::set. Referenced by handle_accept. { ACE_TRACE ("ACE_Asynch_Acceptor<>::parse_address"); #if defined (ACE_HAS_AIO_CALLS) // Use an ACE_SOCK to get the addresses - it knows how to deal with // ACE_INET_Addr objects and get IPv4/v6 addresses. ACE_SOCK_Stream str (result.accept_handle ()); str.get_local_addr (local_address); str.get_remote_addr (remote_address); #elif (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) ACE_Message_Block &message_block = result.message_block (); sockaddr *local_addr = 0; sockaddr *remote_addr = 0; int local_size = 0; int remote_size = 0; ::GetAcceptExSockaddrs (message_block.rd_ptr (), ACE_static_cast (DWORD, this->bytes_to_read_), ACE_static_cast (DWORD, this->address_size ()), ACE_static_cast (DWORD, this->address_size ()), &local_addr, &local_size, &remote_addr, &remote_size); local_address.set (ACE_reinterpret_cast (sockaddr_in *, local_addr), local_size); remote_address.set (ACE_reinterpret_cast (sockaddr_in *, remote_addr), remote_size); #else // just in case errno = ENOTSUP; #endif /* (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) */ return; }

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

Set flag that indicates if parsing and passing of addresses to the service_handler is necessary. Definition at line 413 of file Asynch_Acceptor.cpp. References pass_addresses_. { this->pass_addresses_ = new_value; }

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

Get flag that indicates if parsing and passing of addresses to the service_handler is necessary. Definition at line 407 of file Asynch_Acceptor.cpp. References pass_addresses_. Referenced by open. { return this->pass_addresses_; }

template<class HANDLER> void ACE_Asynch_Acceptor< HANDLER >::reissue_accept (  int    new_value )  [virtual]

Set flag that indicates if a new accept should be reissued when a accept completes. Definition at line 437 of file Asynch_Acceptor.cpp. References reissue_accept_. { this->reissue_accept_ = new_value; }

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::reissue_accept (  void    )  const [virtual]

Get flag that indicates if a new accept should be reissued when a accept completes. Definition at line 431 of file Asynch_Acceptor.cpp. References reissue_accept_. Referenced by open. { return this->reissue_accept_; }

template<class HANDLER> void ACE_Asynch_Acceptor< HANDLER >::set_handle (  ACE_HANDLE    handle )  [virtual]

Set the underlying listen handle. It is the user's responsibility to make sure that the old listen handle has been appropriately closed and the all outstanding asynchronous operations have either completed or have been canceled on the old listen handle. Definition at line 138 of file Asynch_Acceptor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, asynch_accept_, listen_handle_, LM_ERROR, and ACE_Asynch_Accept::open. { ACE_TRACE ("ACE_Asynch_Acceptor<>::set_handle"); // Take ownership of the <listen_handle> this->listen_handle_ = listen_handle; // Reinitialize the ACE_Asynch_Accept if (this->asynch_accept_.open (*this, this->listen_handle_, 0, this->proactor ()) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Asynch_Accept::open"))); }

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::should_reissue_accept (  void    )  [virtual]

Template method for deciding whether to reissue accept. This hook method is called after each accept completes to decide if another accept should be initiated. If the method returns a non-zero value, another accept is initiated. The default implemenation always returns the value passed as the open() method's reissue_accept argument. That value can also be changed using the reissue_accept() method. Definition at line 455 of file Asynch_Acceptor.cpp. References reissue_accept_. Referenced by handle_accept. { return this->reissue_accept_; }

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::validate_connection (  const ACE_Asynch_Accept::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 after a new connection is accepted 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 reimplement this method 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. remote  Peer's address. local  Local address connection was accepted at. Return values: -1  ACE_Asynch_Acceptor will close the connection, and the service will not be opened. 0  Service opening will proceeed. Definition at line 290 of file Asynch_Acceptor.cpp. Referenced by handle_accept. { // Default implementation always validates the remote address. return 0; }

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

Set flag that indicates if address validation is required. Definition at line 425 of file Asynch_Acceptor.cpp. References validate_new_connection_. { this->validate_new_connection_ = new_value; }

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

Get flag that indicates if address validation is required. Definition at line 419 of file Asynch_Acceptor.cpp. References validate_new_connection_. Referenced by handle_accept. { return this->validate_new_connection_; }

template<class HANDLER> int ACE_Asynch_Acceptor< HANDLER >::validate_new_connection (  const ACE_INET_Addr &    remote_address )  [virtual]

Deprecated: Use validate_connection() instead. Will be removed after ACE 5.3. Template method for address validation. This hook method is called after a connection is accepted if so specified on the call to the open() method. If this method returns -1, the connection is immediately closed and the service handler is not opened. The default implemenation always return 0. Definition at line 299 of file Asynch_Acceptor.cpp. Referenced by open. { // Default implementation always validates the remote address. return 0; }

---

Member Data Documentation

template<class HANDLER> ACE_Asynch_Accept ACE_Asynch_Acceptor::asynch_accept_ [private]

<Asynch_Accept> used to make life easier :-). Definition at line 260 of file Asynch_Acceptor.h. Referenced by accept, asynch_accept, cancel, open, and set_handle.

template<class HANDLER> size_t ACE_Asynch_Acceptor::bytes_to_read_ [private]

Bytes to be read with the <accept> call. Definition at line 273 of file Asynch_Acceptor.h. Referenced by bytes_to_read, and open.

template<class HANDLER> ACE_HANDLE ACE_Asynch_Acceptor::listen_handle_ [private]

Handle used to listen for new connections. Definition at line 257 of file Asynch_Acceptor.h. Referenced by cancel, get_handle, handle, handle_accept, open, and set_handle.

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

Flag that indicates if parsing of addresses is necessary. Definition at line 263 of file Asynch_Acceptor.h. Referenced by handle_accept, open, and pass_addresses.

template<class HANDLER> int ACE_Asynch_Acceptor::reissue_accept_ [private]

Flag that indicates if a new accept should be reissued when a accept completes. Definition at line 270 of file Asynch_Acceptor.h. Referenced by open, reissue_accept, and should_reissue_accept.

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

Flag that indicates if address validation is required. Definition at line 266 of file Asynch_Acceptor.h. Referenced by handle_accept, open, and validate_new_connection.

---

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

• Asynch_Acceptor.h
• Asynch_Acceptor.cpp

---