ACE
6.4.2
|
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>
Public Member Functions | |
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, bool pass_addresses=false, int backlog=ACE_DEFAULT_ASYNCH_BACKLOG, int reuse_addr=1, ACE_Proactor *proactor=0, bool validate_new_connection=false, int reissue_accept=1, int number_of_initial_accepts=-1) |
virtual ACE_HANDLE | get_handle (void) const |
Get the underlying handle. More... | |
virtual int | 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 | should_reissue_accept (void) |
virtual bool | pass_addresses (void) const |
virtual void | pass_addresses (bool new_value) |
virtual bool | validate_new_connection (void) const |
Get flag that indicates if address validation is required. More... | |
virtual void | validate_new_connection (bool new_value) |
Set flag that indicates if address validation is required. More... | |
virtual int | reissue_accept (void) const |
virtual void | reissue_accept (int new_value) |
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... | |
Public Member Functions inherited from ACE_Handler | |
ACE_Handler (void) | |
A do nothing constructor. More... | |
ACE_Handler (ACE_Proactor *p) | |
A do nothing constructor which allows proactor to be set to <p>. More... | |
virtual | ~ACE_Handler (void) |
Virtual destruction. More... | |
virtual void | handle_read_stream (const ACE_Asynch_Read_Stream::Result &result) |
virtual void | handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result) |
virtual void | handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result) |
virtual void | handle_write_stream (const ACE_Asynch_Write_Stream::Result &result) |
virtual void | handle_read_file (const ACE_Asynch_Read_File::Result &result) |
virtual void | handle_write_file (const ACE_Asynch_Write_File::Result &result) |
virtual void | handle_connect (const ACE_Asynch_Connect::Result &result) |
This method will be called when an asynchronous connect completes. More... | |
virtual void | handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result) |
virtual void | handle_time_out (const ACE_Time_Value &tv, const void *act=0) |
virtual void | handle_wakeup (void) |
ACE_Proactor * | proactor (void) |
Get the proactor associated with this handler. More... | |
void | proactor (ACE_Proactor *p) |
Set the proactor. More... | |
Proxy_Ptr & | proxy (void) |
Protected Member Functions | |
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... | |
bool | pass_addresses_ |
Flag that indicates if parsing of addresses is necessary. More... | |
bool | validate_new_connection_ |
Flag that indicates if address validation is required. More... | |
int | reissue_accept_ |
size_t | bytes_to_read_ |
Bytes to be read with the <accept> call. More... | |
int | addr_family_ |
Additional Inherited Members | |
Public Types inherited from ACE_Handler | |
typedef ACE_Refcounted_Auto_Ptr< Proxy, ACE_SYNCH_MUTEX > | Proxy_Ptr |
Protected Attributes inherited from ACE_Handler | |
ACE_Proactor * | proactor_ |
The proactor associated with this handler. More... | |
ACE_HANDLE | handle_ |
The ACE_HANDLE in use with this handler. More... | |
ACE_Refcounted_Auto_Ptr< Proxy, ACE_SYNCH_MUTEX > | proxy_ |
Refers to proxy for this handler. More... | |
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.
ACE_Asynch_Acceptor< HANDLER >::ACE_Asynch_Acceptor | ( | void | ) |
A do nothing constructor.
|
virtual |
Virtual destruction.
|
virtual |
This initiates a new asynchronous accept operation.
You need only call this method if the reissue_accept argument passed to open()
was 0.
|
protected |
Return the asynch accept object.
|
virtual |
Get bytes to be read with the <accept> call.
|
virtual |
Set bytes to be read with the <accept> call.
|
virtual |
Cancels all pending accepts operations issued by this object.
|
virtual |
Get the underlying handle.
|
protectedvirtual |
Return the listen handle.
Reimplemented from ACE_Handler.
|
protectedvirtual |
Set the listen handle.
Reimplemented from ACE_Handler.
|
protectedvirtual |
This is called when an outstanding accept completes.
Reimplemented from ACE_Handler.
|
protectedvirtual |
This is the template method used to create new handler. Subclasses must overwrite this method if a new handler creation strategy is required.
|
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.
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_ASYNCH_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 true, 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. |
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.
|
protected |
This parses the address from read buffer.
|
virtual |
Get flag that indicates if parsing and passing of addresses to the service_handler is necessary.
|
virtual |
Set flag that indicates if parsing and passing of addresses to the service_handler is necessary.
|
virtual |
Get flag that indicates if a new accept should be reissued when a accept completes.
|
virtual |
Set flag that indicates if a new accept should be reissued when a accept completes.
|
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.
|
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 implementation always returns the value passed as the open()
method's reissue_accept argument. That value can also be changed using the reissue_accept()
method.
|
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.
result | Result of the connection acceptance. |
remote | Peer's address. |
local | Local address connection was accepted at. |
-1 | ACE_Asynch_Acceptor will close the connection, and the service will not be opened. |
0 | Service opening will proceeed. |
|
virtual |
Get flag that indicates if address validation is required.
|
virtual |
Set flag that indicates if address validation is required.
|
private |
Address family used to open this object. Obtained from address passed to open()
.
|
private |
Asynch_Accept used to make life easier :-)
|
private |
Bytes to be read with the <accept> call.
|
private |
Handle used to listen for new connections.
|
private |
Flag that indicates if parsing of addresses is necessary.
|
private |
Flag that indicates if a new accept should be reissued when a accept completes.
|
private |
Flag that indicates if address validation is required.