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; }