#include <Acceptor.h>
Public Types | |
typedef ACE_PEER_ACCEPTOR_ADDR | addr_type |
typedef ACE_PEER_ACCEPTOR | acceptor_type |
typedef SVC_HANDLER | handler_type |
typedef SVC_HANDLER::stream_type | stream_type |
Public Member Functions | |
ACE_Acceptor (ACE_Reactor *=0, int use_select=1) | |
"Do-nothing" constructor. | |
ACE_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor=ACE_Reactor::instance(), int flags=0, int use_select=1, int reuse_addr=1) | |
virtual int | open (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor=ACE_Reactor::instance(), int flags=0, int use_select=1, int reuse_addr=1) |
virtual | ~ACE_Acceptor (void) |
Close down the Acceptor's resources. | |
virtual | operator ACE_PEER_ACCEPTOR & () const |
Return the underlying PEER_ACCEPTOR object. | |
virtual ACE_PEER_ACCEPTOR & | acceptor (void) const |
Return the underlying PEER_ACCEPTOR object. | |
virtual ACE_HANDLE | get_handle (void) const |
Returns the listening acceptor's {ACE_HANDLE}. | |
virtual int | close (void) |
Close down the Acceptor. | |
void | dump (void) const |
Dump the state of an object. | |
virtual int | suspend (void) |
This method calls {Reactor::suspend}. | |
virtual int | resume (void) |
This method calls {Reactor::resume}. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Member Functions | |
virtual int | make_svc_handler (SVC_HANDLER *&sh) |
virtual int | accept_svc_handler (SVC_HANDLER *svc_handler) |
virtual int | activate_svc_handler (SVC_HANDLER *svc_handler) |
virtual int | handle_close (ACE_HANDLE=ACE_INVALID_HANDLE, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK) |
virtual int | handle_input (ACE_HANDLE) |
virtual int | init (int argc, ACE_TCHAR *argv[]) |
virtual int | fini (void) |
Calls {handle_close}. | |
virtual int | info (ACE_TCHAR **buf, size_t) const |
Default version returns address info in {buf}. | |
Protected Attributes | |
ACE_PEER_ACCEPTOR | peer_acceptor_ |
Concrete factory for accepting connections from clients... | |
ACE_PEER_ACCEPTOR_ADDR | peer_acceptor_addr_ |
Needed to reopen the socket if {accept} fails. | |
int | flags_ |
int | use_select_ |
int | reuse_addr_ |
Needed to reopen the socket if {accept} fails. |
Implements the basic strategy for passively establishing connections with clients. An ACE_Acceptor is parameterized by concrete types that conform to the interfaces of PEER_ACCEPTOR and SVC_HANDLER. The PEER_ACCEPTOR is instantiated with a transport mechanism that passively establishes connections. The SVC_HANDLER is instantiated with a concrete type that performs the application-specific service. An ACE_Acceptor inherits from ACE_Service_Object, which in turn inherits from ACE_Event_Handler. This enables the ACE_Reactor to dispatch the ACE_Acceptor's handle_input method when connection events occur. The handle_input method performs the ACE_Acceptor's default creation, connection establishment, and service activation strategies. These strategies can be overridden by subclasses individually or as a group.
typedef ACE_PEER_ACCEPTOR_ADDR ACE_Acceptor< SVC_HANDLER, >::addr_type |
typedef ACE_PEER_ACCEPTOR ACE_Acceptor< SVC_HANDLER, >::acceptor_type |
typedef SVC_HANDLER ACE_Acceptor< SVC_HANDLER, >::handler_type |
typedef SVC_HANDLER::stream_type ACE_Acceptor< SVC_HANDLER, >::stream_type |
ACE_Acceptor< SVC_HANDLER, >::ACE_Acceptor | ( | ACE_Reactor * | = 0 , |
|
int | use_select = 1 | |||
) |
"Do-nothing" constructor.
ACE_Acceptor< SVC_HANDLER, >::ACE_Acceptor | ( | const ACE_PEER_ACCEPTOR_ADDR & | local_addr, | |
ACE_Reactor * | reactor = ACE_Reactor::instance() , |
|||
int | flags = 0 , |
|||
int | use_select = 1 , |
|||
int | reuse_addr = 1 | |||
) |
Open the contained PEER_ACCEPTOR
object to begin listening, and register with the specified reactor for accept events. An acceptor can only listen to one port at a time, so make sure to close()
the acceptor before calling open()
again.
The PEER_ACCEPTOR
handle is put into non-blocking mode as a safeguard against the race condition that can otherwise occur between the time when the passive-mode socket handle is "ready" and when the actual accept()
call is made. During this interval, the client can shutdown the connection, in which case, the accept()
call can hang.
local_addr | The address to listen at. | |
reactor | Pointer to the ACE_Reactor instance to register this object with. The default is the singleton. | |
flags | Flags to control what mode an accepted socket will be put into after it is accepted. The only legal value for this argument is ACE_NONBLOCK , which enables non-blocking mode on the accepted peer stream object in SVC_HANDLER . The default is 0. | |
use_select | Affects behavior when called back by the reactor when a connection can be accepted. If non-zero, this object will accept all pending connections, intead of just the one that triggered the reactor callback. Uses ACE_OS::select() internally to detect any remaining acceptable connections. The default is 1. | |
reuse_addr | Passed to the PEER_ACCEPTOR::open() method with local_addr . Generally used to request that the OS allow reuse of the listen port. The default is 1. |
virtual ACE_Acceptor< SVC_HANDLER, >::~ACE_Acceptor | ( | void | ) | [virtual] |
Close down the Acceptor's resources.
virtual int ACE_Acceptor< SVC_HANDLER, >::open | ( | const ACE_PEER_ACCEPTOR_ADDR & | local_addr, | |
ACE_Reactor * | reactor = ACE_Reactor::instance() , |
|||
int | flags = 0 , |
|||
int | use_select = 1 , |
|||
int | reuse_addr = 1 | |||
) | [virtual] |
Open the contained PEER_ACCEPTOR
object to begin listening, and register with the specified reactor for accept events. An acceptor can only listen to one port at a time, so make sure to close()
the acceptor before calling open()
again.
The PEER_ACCEPTOR
handle is put into non-blocking mode as a safeguard against the race condition that can otherwise occur between the time when the passive-mode socket handle is "ready" and when the actual accept()
call is made. During this interval, the client can shutdown the connection, in which case, the accept()
call can hang.
local_addr | The address to listen at. | |
reactor | Pointer to the ACE_Reactor instance to register this object with. The default is the singleton. | |
flags | Flags to control what mode an accepted socket will be put into after it is accepted. The only legal value for this argument is ACE_NONBLOCK , which enables non-blocking mode on the accepted peer stream object in SVC_HANDLER . The default is 0. | |
use_select | Affects behavior when called back by the reactor when a connection can be accepted. If non-zero, this object will accept all pending connections, intead of just the one that triggered the reactor callback. Uses ACE_OS::select() internally to detect any remaining acceptable connections. The default is 1. | |
reuse_addr | Passed to the PEER_ACCEPTOR::open() method with local_addr . Generally used to request that the OS allow reuse of the listen port. The default is 1. |
0 | Success | |
-1 | Failure, errno contains an error code. |
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual ACE_Acceptor< SVC_HANDLER, >::operator ACE_PEER_ACCEPTOR & | ( | ) | const [virtual] |
virtual ACE_PEER_ACCEPTOR& ACE_Acceptor< SVC_HANDLER, >::acceptor | ( | void | ) | const [virtual] |
virtual ACE_HANDLE ACE_Acceptor< SVC_HANDLER, >::get_handle | ( | void | ) | const [virtual] |
Returns the listening acceptor's {ACE_HANDLE}.
Reimplemented from ACE_Event_Handler.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::close | ( | void | ) | [virtual] |
Close down the Acceptor.
void ACE_Acceptor< SVC_HANDLER, >::dump | ( | void | ) | const |
virtual int ACE_Acceptor< SVC_HANDLER, >::make_svc_handler | ( | SVC_HANDLER *& | sh | ) | [protected, virtual] |
Bridge method for creating a SVC_HANDLER. The default is to create a new {SVC_HANDLER} if {sh} == 0, else {sh} is unchanged. However, subclasses can override this policy to perform SVC_HANDLER creation in any way that they like (such as creating subclass instances of SVC_HANDLER, using a singleton, dynamically linking the handler, etc.). Returns -1 on failure, else 0.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::accept_svc_handler | ( | SVC_HANDLER * | svc_handler | ) | [protected, virtual] |
Bridge method for accepting the new connection into the <svc_handler>. The default behavior delegates to the PEER_ACCEPTOR::accept.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::activate_svc_handler | ( | SVC_HANDLER * | svc_handler | ) | [protected, virtual] |
Bridge method for activating a {svc_handler} with the appropriate concurrency strategy. The default behavior of this method is to activate the SVC_HANDLER by calling its {open} method (which allows the SVC_HANDLER to define its own concurrency strategy). However, subclasses can override this strategy to do more sophisticated concurrency activations (such as making the SVC_HANDLER as an "active object" via multi-threading or multi-processing).
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::handle_close | ( | ACE_HANDLE | = ACE_INVALID_HANDLE , |
|
ACE_Reactor_Mask | = ACE_Event_Handler::ALL_EVENTS_MASK | |||
) | [protected, virtual] |
Perform termination activities when {this} is removed from the {reactor}.
Reimplemented from ACE_Event_Handler.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::handle_input | ( | ACE_HANDLE | ) | [protected, virtual] |
Accepts all pending connections from clients, and creates and activates SVC_HANDLERs.
Reimplemented from ACE_Event_Handler.
virtual int ACE_Acceptor< SVC_HANDLER, >::init | ( | int | argc, | |
ACE_TCHAR * | argv[] | |||
) | [protected, virtual] |
Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.
Reimplemented from ACE_Shared_Object.
virtual int ACE_Acceptor< SVC_HANDLER, >::fini | ( | void | ) | [protected, virtual] |
Calls {handle_close}.
Reimplemented from ACE_Shared_Object.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::info | ( | ACE_TCHAR ** | buf, | |
size_t | ||||
) | const [protected, virtual] |
Default version returns address info in {buf}.
Reimplemented from ACE_Shared_Object.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::suspend | ( | void | ) | [virtual] |
This method calls {Reactor::suspend}.
Reimplemented from ACE_Service_Object.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
virtual int ACE_Acceptor< SVC_HANDLER, >::resume | ( | void | ) | [virtual] |
This method calls {Reactor::resume}.
Reimplemented from ACE_Service_Object.
Reimplemented in ACE_Strategy_Acceptor< SVC_HANDLER, >.
ACE_Acceptor< SVC_HANDLER, >::ACE_ALLOC_HOOK_DECLARE |
ACE_PEER_ACCEPTOR ACE_Acceptor< SVC_HANDLER, >::peer_acceptor_ [protected] |
Concrete factory for accepting connections from clients...
ACE_PEER_ACCEPTOR_ADDR ACE_Acceptor< SVC_HANDLER, >::peer_acceptor_addr_ [protected] |
Needed to reopen the socket if {accept} fails.
int ACE_Acceptor< SVC_HANDLER, >::flags_ [protected] |
Flags that indicate how {SVC_HANDLER}'s should be initialized prior to being activated. Right now, the only flag that is processed is {ACE_NONBLOCK}, which enabled non-blocking I/O on the {SVC_HANDLER} when it is opened.
int ACE_Acceptor< SVC_HANDLER, >::use_select_ [protected] |
Flag that indicates whether it shall use {select} in the {accept}-loop.
int ACE_Acceptor< SVC_HANDLER, >::reuse_addr_ [protected] |
Needed to reopen the socket if {accept} fails.