void handle_echo(uint8_t* data, int data_len)
{
send_echo(data, data_len);
}
static int
ping_run (PING * ping, int (*finish) ())
{
fd_set fdset;
int fdmax;
struct timeval resp_time;
struct timeval last, intvl, now;
struct timeval *t = NULL;
int finishing = 0;
int nresp = 0;
int i;
signal (SIGINT, sig_int);
fdmax = ping->ping_fd + 1;
for (i = 0; i < preload; i++)
send_echo (ping);
if (options & OPT_FLOOD)
{
intvl.tv_sec = 0;
intvl.tv_usec = 10000;
}
else
PING_SET_INTERVAL (intvl, ping->ping_interval);
gettimeofday (&last, NULL);
send_echo (ping);
while (!stop)
{
int n;
FD_ZERO (&fdset);
FD_SET (ping->ping_fd, &fdset);
gettimeofday (&now, NULL);
resp_time.tv_sec = last.tv_sec + intvl.tv_sec - now.tv_sec;
resp_time.tv_usec = last.tv_usec + intvl.tv_usec - now.tv_usec;
while (resp_time.tv_usec < 0)
{
resp_time.tv_usec += 1000000;
resp_time.tv_sec--;
}
while (resp_time.tv_usec >= 1000000)
{
resp_time.tv_usec -= 1000000;
resp_time.tv_sec++;
}
if (resp_time.tv_sec < 0)
resp_time.tv_sec = resp_time.tv_usec = 0;
n = select (fdmax, &fdset, NULL, NULL, &resp_time);
if (n < 0)
{
if (errno != EINTR)
perror ("select");
continue;
}
else if (n == 1)
{
if (ping_recv (ping) == 0)
nresp++;
if (t == 0)
{
gettimeofday (&now, NULL);
t = &now;
}
if (ping_timeout_p (&ping->ping_start_time, timeout))
break;
if (ping->ping_count && nresp >= ping->ping_count)
break;
}
else
{
if (!ping->ping_count || ping->ping_num_xmit < ping->ping_count)
{
send_echo (ping);
if (!(options & OPT_QUIET) && options & OPT_FLOOD)
{
putchar ('.');
}
if (ping_timeout_p (&ping->ping_start_time, timeout))
break;
}
else if (finishing)
break;
else
{
finishing = 1;
intvl.tv_sec = MAXWAIT;
}
gettimeofday (&last, NULL);
}
}
ping_unset_data (ping);
if (finish)
return (*finish) ();
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT mid_value =
10000 * (min_timeout + max_timeout) / 2; // convert from msec to "TimeT" (0.1 usec units)
CORBA::Any any_orb;
any_orb <<= mid_value;
CORBA::Any any_thread;
any_thread <<= mid_value + 10000; // midvalue + 1 msec
CORBA::Any any_object;
any_object <<= mid_value + 20000; // midvalue + 2 msec
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_object);
object =
server->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Simple_Server_var timeout_server =
Simple_Server::_narrow (object.in ());
policy_list[0]->destroy ();
policy_list[0] = CORBA::Policy::_nil ();
ACE_DEBUG ((LM_DEBUG,
"client (%P) testing from %d to %d milliseconds\n",
min_timeout, max_timeout));
for (CORBA::Long t = min_timeout; t < max_timeout; ++t)
{
ACE_DEBUG ((LM_DEBUG,
"\n================================\n"
"Trying with timeout = %d msec\n", t));
ACE_DEBUG ((LM_DEBUG,
"Cleanup ORB/Thread/Object policies\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), t);
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the ORB policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_orb);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (orb1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the thread policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_thread);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (thread1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Use the object policies\n"));
send_echo (object1, orb.in (), timeout_server.in (), t);
}
ACE_DEBUG ((LM_DEBUG,
"\n\n\nclient(%P) Test completed, "
"resynch with server\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), 0);
server->shutdown ();
int timeout_count_total = 0;
int in_time_count_total = 0;
for (int i = 0; i < 4; i++) {
timeout_count_total += timeout_count[i];
in_time_count_total += in_time_count[i];
ACE_DEBUG ((LM_DEBUG, "in_time_count[%C]= %d timeout_count[%C]= %d\n",
to_type_names[i], in_time_count[i],
to_type_names[i], timeout_count[i]));
}
if (timeout_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages timed out\n"));
//FUZZ: disable check_for_lack_ACE_OS
if (in_time_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages on time (within time limit)\n"));
//FUZZ: enable check_for_lack_ACE_OS
ACE_DEBUG ((LM_DEBUG, "in_time_count_total = %d, timeout_count_total = %d\n",
in_time_count_total, timeout_count_total));
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
