int
ACE_SSL_SOCK_Acceptor::ssl_accept (ACE_SSL_SOCK_Stream &new_stream) const
{
if (SSL_is_init_finished (new_stream.ssl ()))
return 0;
if (!SSL_in_accept_init (new_stream.ssl ()))
::SSL_set_accept_state (new_stream.ssl ());
int status = ::SSL_accept (new_stream.ssl ());
switch (::SSL_get_error (new_stream.ssl (), status))
{
case SSL_ERROR_NONE:
break;
case SSL_ERROR_ZERO_RETURN:
// The peer has notified us that it is shutting down via
// the SSL "close_notify" message so we need to
// shutdown, too.
(void) new_stream.close ();
return -1;
default:
ACE_SSL_Context::report_error ();
return -1;
}
return 0;
}
static ACE_THR_FUNC_RETURN
start_clients (void *)
{
// Client thread function.
ACE_INET_Addr addr (rendezvous);
ACE_SSL_SOCK_Connector connect;
for (size_t i = 0 ; i < cli_conn_no; i++)
{
ACE_SSL_SOCK_Stream stream;
if (connect.connect (stream, addr) < 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) %p\n"),
ACE_TEXT ("connect")));
continue;
}
Client_Handler *new_handler = 0;
ACE_NEW_RETURN (new_handler, Client_Handler, (ACE_THR_FUNC_RETURN)-1);
if (new_handler->open (stream.get_handle ()) != 0)
{
delete new_handler;
stream.close ();
}
}
return 0;
}
static ACE_THR_FUNC_RETURN
worker (void *)
{
ACE_OS::sleep (3);
const ACE_TCHAR *msg = ACE_TEXT ("Message from Connection worker");
ACE_TCHAR buf [BUFSIZ];
buf[0] = ACE_OS::strlen (msg) + 1;
ACE_OS::strcpy (&buf[1], msg);
ACE_INET_Addr addr (rendezvous);
ACE_DEBUG((LM_DEBUG,
"(%t) Spawning %d client threads...\n",
cli_thrno));
int grp = ACE_Thread_Manager::instance ()->spawn_n (cli_thrno,
&cli_worker,
buf);
ACE_ASSERT (grp != -1);
ACE_Thread_Manager::instance ()->wait_grp (grp);
ACE_DEBUG ((LM_DEBUG,
"(%t) Client threads done; shutting down...\n"));
ACE_SSL_SOCK_Stream stream;
ACE_SSL_SOCK_Connector connect;
if (connect.connect (stream, addr) == -1)
ACE_ERROR ((LM_ERROR,
"(%t) %p Error while connecting\n",
"connect"));
const ACE_TCHAR *sbuf = ACE_TEXT ("\011shutdown");
ACE_DEBUG ((LM_DEBUG,
"shutdown stream handle = %x\n",
stream.get_handle ()));
if (stream.send_n (sbuf, (ACE_OS::strlen (sbuf) + 1) * sizeof (ACE_TCHAR)) == -1)
ACE_ERROR ((LM_ERROR,
"(%t) %p\n",
"send_n"));
stream.close ();
return 0;
}
static ACE_THR_FUNC_RETURN
cli_worker (void *arg)
{
// Client thread function.
ACE_INET_Addr addr (rendezvous);
ACE_SSL_SOCK_Stream stream;
ACE_SSL_SOCK_Connector connect;
ACE_Time_Value delay (0, req_delay);
size_t len = * reinterpret_cast<ACE_TCHAR *> (arg);
for (size_t i = 0 ; i < cli_conn_no; i++)
{
if (connect.connect (stream, addr) < 0)
{
ACE_ERROR ((LM_ERROR,
"(%t) %p\n",
"connect"));
continue;
}
for (size_t j = 0; j < cli_req_no; j++)
{
ACE_DEBUG ((LM_DEBUG,
"(%t) conn_worker handle 0x%x, req %d\n",
stream.get_handle (),
j+1));
if (stream.send_n (arg,
(len + 1) * sizeof (ACE_TCHAR)) == -1)
{
ACE_ERROR ((LM_ERROR,
"(%t) %p\n",
"send_n"));
continue;
}
ACE_OS::sleep (delay);
}
stream.close ();
}
return 0;
}
int
ACE_SSL_SOCK_Acceptor::accept (ACE_SSL_SOCK_Stream &new_stream,
ACE_Accept_QoS_Params qos_params,
ACE_Addr *remote_addr,
ACE_Time_Value *timeout,
int restart,
int reset_new_handle) const
{
ACE_TRACE ("ACE_SSL_SOCK_Acceptor::accept");
// Take into account the time to complete the basic TCP handshake
// and the SSL handshake.
ACE_Countdown_Time countdown (timeout);
ACE_SOCK_Stream temp_stream;
if (-1 == this->acceptor_.accept (temp_stream,
qos_params,
remote_addr,
timeout,
restart,
reset_new_handle))
return -1;
(void) countdown.update ();
new_stream.set_handle (temp_stream.get_handle ());
temp_stream.set_handle (ACE_INVALID_HANDLE);
if (this->ssl_accept (new_stream, timeout) == -1)
{
new_stream.close ();
new_stream.set_handle (ACE_INVALID_HANDLE);
return -1;
}
return 0;
}
int
twoway_server (ACE_SSL_SOCK_Stream &stream)
{
ACE_INET_Addr cli_addr;
// Make sure we're not in non-blocking mode.
if (stream.disable (ACE_NONBLOCK) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"disable"),
0);
else if (stream.get_remote_addr (cli_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"get_remote_addr"),
0);
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) client %s connected from %d\n",
cli_addr.get_host_name (),
cli_addr.get_port_number ()));
size_t total_bytes = 0;
size_t message_count = 0;
char *request = 0;
// Read data from client (terminate on error).
for (;;)
{
ACE_INT32 len;
ssize_t r_bytes = stream.recv_n ((void *) &len,
sizeof (ACE_INT32));
if (r_bytes == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"recv"));
break;
}
else if (r_bytes == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) reached end of input, connection closed by client\n"));
break;
}
else if (r_bytes != sizeof (ACE_INT32))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) %p\n",
"recv_n failed"));
break;
}
else
{
len = ntohl (len);
ACE_NEW_RETURN (request,
char [len],
0);
}
// Subtract off the sizeof the length prefix.
r_bytes = stream.recv_n (request,
len - sizeof (ACE_UINT32));
if (r_bytes == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"recv"));
break;
}
else if (r_bytes == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) reached end of input, connection closed by client\n"));
break;
}
else if (verbose
&& ACE::write_n (ACE_STDOUT,
request,
r_bytes) != r_bytes)
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE::write_n"));
else if (stream.send_n (request,
r_bytes) != r_bytes)
ACE_ERROR ((LM_ERROR,
"%p\n",
"send_n"));
total_bytes += size_t (r_bytes);
message_count++;
delete [] request;
request = 0;
}
// Close new endpoint (listening endpoint stays open).
stream.close ();
delete [] request;
return 0;
}
static int
oneway_server (ACE_SSL_SOCK_Stream &stream)
{
ACE_INET_Addr cli_addr;
// Make sure we're not in non-blocking mode.
if (stream.disable (ACE_NONBLOCK) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"disable"),
0);
else if (stream.get_remote_addr (cli_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"get_remote_addr"),
0);
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) client %s connected from %d\n",
cli_addr.get_host_name (),
cli_addr.get_port_number ()));
// Timer business
ACE_Profile_Timer timer;
timer.start ();
size_t total_bytes = 0;
size_t message_count = 0;
char *request = 0;
// Read data from client (terminate on error).
for (;;)
{
ACE_INT32 len;
ssize_t r_bytes = stream.recv_n ((void *) &len,
sizeof (ACE_INT32));
if (r_bytes == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"recv"));
break;
}
else if (r_bytes == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) reached end of input, connection closed by client\n"));
break;
}
else if (r_bytes != sizeof (ACE_INT32))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) %p\n",
"recv_n failed"));
break;
}
else
{
len = ntohl (len);
ACE_NEW_RETURN (request,
char [len],
0);
}
// Subtract off the sizeof the length prefix.
r_bytes = stream.recv_n (request,
len - sizeof (ACE_UINT32));
if (r_bytes == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"recv"));
break;
}
else if (r_bytes == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) reached end of input, connection closed by client\n"));
break;
}
else if (verbose
&& ACE::write_n (ACE_STDOUT, request, r_bytes) != r_bytes)
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE::write_n"));
total_bytes += size_t (r_bytes);
message_count++;
delete [] request;
request = 0;
}
timer.stop ();
ACE_Profile_Timer::ACE_Elapsed_Time et;
timer.elapsed_time (et);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\t\treal time = %f secs \n\t\tuser time = %f secs \n\t\tsystem time = %f secs\n"),
et.real_time,
et.user_time,
et.system_time));
double messages_per_sec = double (message_count) / et.real_time;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\t\tmessages = %d\n\t\ttotal bytes = %d\n\t\tmbits/sec = %f\n\t\tusec-per-message = %f\n\t\tmessages-per-second = %0.00f\n"),
message_count,
total_bytes,
(((double) total_bytes * 8) / et.real_time) / (double) (1024 * 1024),
(et.real_time / (double) message_count) * 1000000,
messages_per_sec < 0 ? 0 : messages_per_sec));
// Close new endpoint (listening endpoint stays open).
stream.close ();
delete [] request;
return 0;
}
