int Handler_Factory::init_acceptors (void) { // Create the oneway and twoway server addresses. ACE_INET_Addr twoway_server_addr (OPTIONS::instance ()->port ()); ACE_INET_Addr oneway_server_addr (OPTIONS::instance ()->port () + 1); // Create acceptors, reuse the address. if (this->twoway_acceptor_.open (twoway_server_addr, 1) == -1 || this->oneway_acceptor_.open (oneway_server_addr, 1) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("open")), -1); else if (this->twoway_acceptor_.get_local_addr (twoway_server_addr) == -1 || this->oneway_acceptor_.get_local_addr (oneway_server_addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("get_local_addr")), -1); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) starting twoway server at port %d and oneway server at port %d\n"), twoway_server_addr.get_port_number (), oneway_server_addr.get_port_number ())); return 0; }
static int run_event_loop (u_short port) { // Raise the socket handle limit to the maximum. ACE::set_handle_limit (); // Create the oneway and twoway acceptors. ACE_SSL_SOCK_Acceptor twoway_acceptor; ACE_SSL_SOCK_Acceptor oneway_acceptor; // Create the oneway and twoway server addresses. ACE_INET_Addr twoway_server_addr (port); ACE_INET_Addr oneway_server_addr (port + 1); // Create acceptors, reuse the address. if (twoway_acceptor.open (twoway_server_addr, 1) == -1 || oneway_acceptor.open (oneway_server_addr, 1) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), 1); else if (twoway_acceptor.get_local_addr (twoway_server_addr) == -1 || oneway_acceptor.get_local_addr (oneway_server_addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_local_addr"), 1); ACE_DEBUG ((LM_DEBUG, "(%P|%t) starting twoway server at port %d and oneway server at port %d\n", twoway_server_addr.get_port_number (), oneway_server_addr.get_port_number ())); // Keep these objects out here to prevent excessive constructor // calls within the loop. ACE_SSL_SOCK_Stream new_stream; ACE_Handle_Set handle_set; handle_set.set_bit (twoway_acceptor.get_handle ()); handle_set.set_bit (oneway_acceptor.get_handle ()); // Performs the iterative server activities. for (;;) { ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); ACE_Handle_Set temp = handle_set; int maxfd = int(oneway_acceptor.get_handle ()); if (maxfd < int(twoway_acceptor.get_handle ())) maxfd = int(twoway_acceptor.get_handle ()); int result = ACE_OS::select (maxfd + 1, (fd_set *) temp, 0, 0, timeout); if (result == -1) ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "select")); else if (result == 0 && verbose) ACE_DEBUG ((LM_DEBUG, "(%P|%t) select timed out\n")); else { if (temp.is_set (twoway_acceptor.get_handle ())) { int r = twoway_acceptor.accept (new_stream); while (r == -1 && errno == EAGAIN) r = twoway_acceptor.accept (new_stream); if (r == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); continue; } else ACE_DEBUG ((LM_DEBUG, "(%P|%t) spawning twoway server\n")); // Run the twoway server. twoway_server (new_stream); } if (temp.is_set (oneway_acceptor.get_handle ())) { if (oneway_acceptor.accept (new_stream) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); continue; } else ACE_DEBUG ((LM_DEBUG, "(%P|%t) spawning oneway server\n")); // Run the oneway server. oneway_server (new_stream); } } } /* NOTREACHED */ }
static int run_event_loop (u_short port) { // Raise the socket handle limit to the maximum. ACE::set_handle_limit (); // Create the oneway and twoway acceptors. ACE_SSL_SOCK_Acceptor twoway_acceptor; ACE_SSL_SOCK_Acceptor oneway_acceptor; // Create the oneway and twoway server addresses. ACE_INET_Addr twoway_server_addr (port); ACE_INET_Addr oneway_server_addr (port + 1); // Create acceptors, reuse the address. if (twoway_acceptor.open (twoway_server_addr, 1) == -1 || oneway_acceptor.open (oneway_server_addr, 1) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), 1); else if (twoway_acceptor.get_local_addr (twoway_server_addr) == -1 || oneway_acceptor.get_local_addr (oneway_server_addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_local_addr"), 1); ACE_DEBUG ((LM_DEBUG, "(%P|%t) starting twoway server at port %d and oneway server at port %d\n", twoway_server_addr.get_port_number (), oneway_server_addr.get_port_number ())); // Keep these objects out here to prevent excessive constructor // calls within the loop. ACE_Handle_Set handle_set; handle_set.set_bit (twoway_acceptor.get_handle ()); handle_set.set_bit (oneway_acceptor.get_handle ()); ACE_SSL_SOCK_Stream * new_stream = 0; // Performs the iterative server activities. for (;;) { ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); ACE_Handle_Set temp = handle_set; int result = ACE_OS::select (int (oneway_acceptor.get_handle ()) + 1, (fd_set *) temp, 0, 0, timeout); if (result == -1) ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "select")); else if (result == 0 && verbose) ACE_DEBUG ((LM_DEBUG, "(%P|%t) select timed out\n")); else { // A new ACE_SSL_SOCK_Stream must be initialized for each // connection. However, it retains (SSL) state so simply // initializing a new ACE_SSL_SOCK_Stream by passing it a // handle isn't enough, nor is it allowed. Such a scheme is // is sometimes done with the non-SSL aware // ACE_SOCK_Stream. An ACE_SSL_SOCK_Stream should only be // initialized by an ACE_SSL_SOCK_Acceptor (server side), or an // ACE_SSL_SOCK_Connector (client side). // // It is also possible to copy or assign an // ACE_SSL_SOCK_Stream since it implements both // methods/operators. However, the user must ensure that // the copy or assignment is atomic. if (temp.is_set (twoway_acceptor.get_handle ())) { ACE_NEW_RETURN (new_stream, ACE_SSL_SOCK_Stream, -1); if (twoway_acceptor.accept (*new_stream) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); delete new_stream; continue; } else ACE_DEBUG ((LM_DEBUG, "(%P|%t) spawning twoway server\n")); // Run the twoway server. run_server (twoway_server, new_stream); } if (temp.is_set (oneway_acceptor.get_handle ())) { ACE_NEW_RETURN (new_stream, ACE_SSL_SOCK_Stream, -1); if (oneway_acceptor.accept (*new_stream) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); delete new_stream; continue; } else ACE_DEBUG ((LM_DEBUG, "(%P|%t) spawning oneway server\n")); // Run the oneway server. run_server (oneway_server, new_stream); } } } /* NOTREACHED */ }