template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
(const ACE_PEER_ACCEPTOR_ADDR &local_addr,
ACE_Reactor *reactor,
ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> *acc_s,
ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
ACE_Scheduling_Strategy<SVC_HANDLER> *sch_s,
const ACE_TCHAR *service_name,
const ACE_TCHAR *service_description,
int use_select,
int reuse_addr)
{
ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
if (this->service_name_ == 0 && service_name != 0)
ACE_ALLOCATOR_RETURN (this->service_name_,
ACE_OS::strdup (service_name),
-1);
if (this->service_description_ == 0 && service_description != 0)
ACE_ALLOCATOR_RETURN (this->service_description_,
ACE_OS::strdup (service_description),
-1);
this->reactor (reactor);
// Must supply a valid Reactor to Acceptor::open()...
if (reactor == 0)
{
errno = EINVAL;
return -1;
}
// Initialize the creation strategy.
if (cre_s == 0)
{
ACE_NEW_RETURN (cre_s,
CREATION_STRATEGY,
-1);
this->delete_creation_strategy_ = 1;
}
this->creation_strategy_ = cre_s;
// Initialize the accept strategy.
if (acc_s == 0)
{
ACE_NEW_RETURN (acc_s,
ACCEPT_STRATEGY (this->reactor ()),
-1);
this->delete_accept_strategy_ = 1;
}
this->accept_strategy_ = acc_s;
if (this->accept_strategy_->open (local_addr, reuse_addr) == -1)
return -1;
// Set the peer acceptor's handle into non-blocking mode. This is a
// safe-guard against the race condition that can otherwise occur
// between the time when <select> indicates that a passive-mode
// socket handle is "ready" and when we call <accept>. During this
// interval, the client can shutdown the connection, in which case,
// the <accept> call can hang!
if (this->accept_strategy_->acceptor ().enable (ACE_NONBLOCK) != 0)
return -1;
// Initialize the concurrency strategy.
if (con_s == 0)
{
ACE_NEW_RETURN (con_s,
CONCURRENCY_STRATEGY,
-1);
this->delete_concurrency_strategy_ = 1;
}
this->concurrency_strategy_ = con_s;
// Initialize the scheduling strategy.
if (sch_s == 0)
{
ACE_NEW_RETURN (sch_s,
SCHEDULING_STRATEGY,
-1);
this->delete_scheduling_strategy_ = 1;
}
this->scheduling_strategy_ = sch_s;
this->use_select_ = use_select;
return this->reactor ()->register_handler
(this,
ACE_Event_Handler::ACCEPT_MASK);
}
int
TAO::SSLIOP::Acceptor::ssliop_open_i (TAO_ORB_Core *orb_core,
const ACE_INET_Addr& addr,
ACE_Reactor *reactor)
{
this->orb_core_ = orb_core;
ACE_NEW_RETURN (this->creation_strategy_,
CREATION_STRATEGY (this->orb_core_),
-1);
ACE_NEW_RETURN (this->concurrency_strategy_,
CONCURRENCY_STRATEGY (this->orb_core_),
-1);
ACE_NEW_RETURN (this->accept_strategy_,
ACCEPT_STRATEGY (this->orb_core_,
this->timeout_),
-1);
u_short requested_port = addr.get_port_number ();
if (requested_port == 0)
{
// don't care, i.e., let the OS choose an ephemeral port
if (this->ssl_acceptor_.open (addr,
reactor,
this->creation_strategy_,
this->accept_strategy_,
this->concurrency_strategy_,
0, 0, 0, 1,
this->reuse_addr_) == -1)
{
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n\nTAO (%P|%t) ")
ACE_TEXT ("SSLIOP_Acceptor::open_i - %p\n\n"),
ACE_TEXT ("cannot open acceptor")));
return -1;
}
}
else
{
ACE_INET_Addr a(addr);
int found_a_port = 0;
ACE_UINT32 last_port = requested_port + this->port_span_ - 1;
if (last_port > ACE_MAX_DEFAULT_PORT)
{
last_port = ACE_MAX_DEFAULT_PORT;
}
for (ACE_UINT32 p = requested_port; p <= last_port; p++)
{
if (TAO_debug_level > 5)
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) IIOP_Acceptor::open_i() ")
ACE_TEXT ("trying to listen on port %d\n"), p));
// Now try to actually open on that port
a.set_port_number ((u_short)p);
if (this->ssl_acceptor_.open (a,
reactor,
this->creation_strategy_,
this->accept_strategy_,
this->concurrency_strategy_,
0, 0, 0, 1,
this->reuse_addr_) != -1)
{
found_a_port = 1;
break;
}
}
// Now, if we couldn't locate a port, we punt
if (! found_a_port)
{
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n\nTAO (%P|%t) ")
ACE_TEXT ("SSLIOP_Acceptor::open_i - %p\n\n"),
ACE_TEXT ("cannot open acceptor")));
return -1;
}
}
ACE_INET_Addr ssl_address;
// We do this to make sure the port number the endpoint is listening
// on gets set in the addr.
if (this->ssl_acceptor_.acceptor ().get_local_addr (ssl_address) != 0)
{
// @@ Should this be a catastrophic error???
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n\nTAO (%P|%t) ")
ACE_TEXT ("SSLIOP_Acceptor::open_i - %p\n\n"),
ACE_TEXT ("cannot get local addr")));
return -1;
}
// Reset the SSL endpoint port to the one chosen by the OS (or by
// the user if provided.
this->ssl_component_.port = ssl_address.get_port_number ();
(void) this->ssl_acceptor_.acceptor().enable (ACE_CLOEXEC);
// This avoids having child processes acquire the listen socket
// thereby denying the server the opportunity to restart on a
// well-known endpoint. This does not affect the aberrent behavior
// on Win32 platforms.
if (TAO_debug_level > 5)
{
for (size_t i = 0; i < this->endpoint_count_; ++i)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) ")
ACE_TEXT ("SSLIOP_Acceptor::open_i - ")
ACE_TEXT ("listening on: <%C:%u>\n"),
this->hosts_[i],
this->ssl_component_.port));
}
}
// In the event that an accept() fails, we can examine the reason. If
// the reason warrants it, we can try accepting again at a later time.
// The amount of time we wait to accept again is governed by this orb
// parameter.
this->set_error_retry_delay (
this->orb_core_->orb_params ()->accept_error_delay());
return 0;
}
