int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
context->certificate ("./dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("./key.pem", SSL_FILETYPE_PEM);
OPTIONS::instance ()->parse_args (argc, argv);
Handler_Factory server;
return server.handle_events ();
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
context->certificate ("./dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("./key.pem", SSL_FILETYPE_PEM);
u_short port = ACE_DEFAULT_SERVER_PORT;
if (argc > 1)
port = ACE_OS::atoi (argv[1]);
return run_event_loop (port);
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("SSL_Asynch_Stream_Test"));
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
// Note - the next two strings are naked on purpose... the arguments to
// the ACE_SSL_Context methods are const char *, not ACE_TCHAR *.
context->certificate ("dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("key.pem", SSL_FILETYPE_PEM);
parse_args (argc, argv);
disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX);
disable_signal (SIGPIPE, SIGPIPE);
Server_Acceptor acceptor;
ACE_INET_Addr accept_addr (rendezvous);
if (acceptor.open (accept_addr) == -1)
return 1;
if (-1 == ACE_Reactor::instance ()->register_handler (&acceptor,
ACE_Event_Handler::ACCEPT_MASK))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%t) %p; aborting\n"),
ACE_TEXT ("register_handler")));
return 1;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Listening at %s\n"), rendezvous));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Spawning %d proactor threads\n"),
num_threads));
ACE_Thread_Manager::instance ()->spawn_n (num_threads, proactor_loop);
ACE_Thread_Manager::instance ()->spawn (start_clients);
ACE_Time_Value loop_limit (20);
ACE_Reactor::instance ()->run_reactor_event_loop (loop_limit);
ACE_Thread_Manager::instance ()->wait ();
// Check for num connections up/down.
ACE_END_TEST;
return 0;
}
ACE_SSL_SOCK_Stream::ACE_SSL_SOCK_Stream (ACE_SSL_Context *context)
: ssl_ (0),
stream_ ()
{
ACE_TRACE ("ACE_SSL_SOCK_Stream::ACE_SSL_SOCK_Stream");
ACE_SSL_Context * ctx =
(context == 0 ? ACE_SSL_Context::instance () : context);
this->ssl_ = ::SSL_new (ctx->context ());
if (this->ssl_ == 0)
{
ACELIB_ERROR ((LM_ERROR,
"(%P|%t) ACE_SSL_SOCK_Stream "
"- cannot allocate new SSL structure %p\n",
ACE_TEXT ("")));
}
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("Thread_Pool_Reactor_SSL_Test"));
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
// Note - the next two strings are naked on purpose... the arguments to
// the ACE_SSL_Context methods are const char *, not ACE_TCHAR *.
context->certificate ("dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("key.pem", SSL_FILETYPE_PEM);
parse_arg (argc, argv);
// Changed the default
ACE_TP_Reactor sr;
ACE_Reactor new_reactor (&sr);
ACE_Reactor::instance (&new_reactor);
ACCEPTOR acceptor;
ACE_INET_Addr accept_addr (rendezvous);
if (acceptor.open (accept_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("open")),
1);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("(%t) Spawning %d server threads...\n"),
svr_thrno));
ACE_Thread_Manager::instance ()->spawn_n (svr_thrno,
svr_worker);
ACE_Thread_Manager::instance ()->spawn (worker);
ACE_Thread_Manager::instance ()->wait ();
ACE_END_TEST;
return 0;
}
// ************************************************************
// ACE_SSL_Asynch_Stream Constructor / Destructor
// ************************************************************
ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream (
ACE_SSL_Asynch_Stream::Stream_Type s_type,
ACE_SSL_Context * context)
: type_ (s_type),
proactor_ (0),
ext_handler_ (0),
ext_read_result_ (0),
ext_write_result_(0),
flags_ (0),
ssl_ (0),
handshake_complete_(false),
bio_ (0),
bio_istream_ (),
bio_inp_msg_ (),
bio_inp_errno_(0),
bio_inp_flag_ (0),
bio_ostream_ (),
bio_out_msg_ (),
bio_out_errno_(0),
bio_out_flag_ (0),
mutex_ ()
{
ACE_TRACE ("ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream");
// was honestly copied from ACE_SSL_SOCK_Stream :)
ACE_SSL_Context * ctx =
(context == 0 ? ACE_SSL_Context::instance () : context);
this->ssl_ = ::SSL_new (ctx->context ());
if (this->ssl_ == 0)
ACELIB_ERROR
((LM_ERROR,
ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"),
ACE_TEXT ("- cannot allocate new SSL structure")
));
}
// *************************************************************
// Configuration helpers
// *************************************************************
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("PSSL_Test"));
if (cfg.parse_args (argc, argv) < 0)
return -1;
disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX);
disable_signal (SIGPIPE, SIGPIPE);
disable_signal (SIGIO, SIGIO);
//ACE_DEBUG ((LM_DEBUG,
// ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"),
// FD_SETSIZE,
// ACE_FD_SETSIZE));
ACE_DEBUG ((LM_DEBUG,
"s_blksize=%u r_blksize=%u win_size=%u\n",
cfg.s_blksize(),
cfg.r_blksize(),
cfg.w_size()));
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
// Note - the next two strings are naked on purpose... the arguments to
// the ACE_SSL_Context methods are const char *, not ACE_TCHAR *.
context->certificate ("dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("key.pem", SSL_FILETYPE_PEM);
{
int rc = 0;
ProactorTask task1(cfg);
RecvFactory r_factory;
SendFactory s_factory;
PSessionManager r_manager (task1, r_factory,"R_Manager");
PSessionManager s_manager (task1, s_factory,"S_Manager");
Acceptor acceptor (r_manager);
Connector connector (s_manager);
ACE_Time_Value time_begin = ACE_OS::gettimeofday ();
ACE_Time_Value time_end = ACE_OS::gettimeofday ();
ACE_Time_Value time_run;
if (task1.start () == 0)
{
ACE_Time_Value timeout (cfg.timeout(), 0);
r_manager.set_timeout (timeout);
s_manager.set_timeout (timeout);
if (cfg.both() != 0 || cfg.connections () == 0) // Acceptor
{
// Simplify, initial read with zero size
if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0)
rc = 1;
}
if (cfg.both() != 0 || cfg.connections () > 0) // Connector
{
ACE_INET_Addr addr;
addr.set (cfg.connect_port(), cfg.connect_host());
rc += connector.start (addr, cfg.connections ());
}
time_begin = ACE_OS::gettimeofday ();
if (rc > 0)
{
task1.enable_event_loop();
ACE_Time_Value sleep_time (cfg.seconds());
while ( sleep_time != ACE_Time_Value::zero)
{
ACE_Countdown_Time countdown ( & sleep_time );
ACE_OS::sleep (sleep_time );
}
if (cfg.seconds () == 0)
{
// comment this later
char c;
cout << "Press any key to stop=>" << flush;
cin.clear ();
cin >> c;
}
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("W_Test"));
if (cfg.parse_args (argc, argv) < 0)
return -1;
disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX);
disable_signal (SIGPIPE, SIGPIPE);
disable_signal (SIGIO, SIGIO);
//ACE_DEBUG ((LM_DEBUG,
// ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"),
// FD_SETSIZE,
// ACE_FD_SETSIZE));
ACE_DEBUG ((LM_DEBUG,
"s_blksize=%u r_blksize=%u win_size=%u\n",
cfg.s_blksize(),
cfg.r_blksize(),
cfg.w_size()));
ACE_SSL_Context *context = ACE_SSL_Context::instance ();
// Note - the next two strings are naked on purpose... the arguments to
// the ACE_SSL_Context methods are const char *, not ACE_TCHAR *.
context->certificate ("dummy.pem", SSL_FILETYPE_PEM);
context->private_key ("key.pem", SSL_FILETYPE_PEM);
{
int rc = 0;
ProactorTask task1(cfg);
RecvFactory r_factory;
RecvFactorySSL r_ssl_factory;
PConnectionManager r_manager (task1, r_factory,"R_Manager");
PConnectionManager r_ssl_manager (task1, r_ssl_factory,"R_SSL_Manager");
Acceptor acceptor (r_manager);
Acceptor acceptor_ssl (r_ssl_manager);
ACE_Time_Value time_begin = ACE_OS::gettimeofday ();
ACE_Time_Value time_end = ACE_OS::gettimeofday ();
ACE_Time_Value time_run;
if (task1.start () == 0)
{
ACE_Time_Value timeout (cfg.timeout(), 0);
r_manager.set_timeout (timeout);
// Simplify, initial read with zero size
if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0)
rc = 1;
if (acceptor_ssl.start (ACE_INET_Addr (cfg.listen_port()+1)) == 0)
rc = 1;
time_begin = ACE_OS::gettimeofday ();
if (rc > 0)
{
task1.enable_event_loop();
char c;
cout << "Press any key to stop=>" << flush;
cin.clear ();
cin >> c;
}
}