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 */
}
