#include "config.h"
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#include <process.h>
#endif
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include "cmrpc.h"
CManager cm;
static int quiet = 0;
static int regression_master = 1;
static int keep_server_going = 1;
static int forked;
static int status = 0;
static int fork_client = 1;
typedef struct call1_struct
{
int i1;
int i2;
char* s1;
} call1, *call1_ptr;
typedef struct resp1_struct
{
int result;
char* res_str;
} resp1, *resp1_ptr;
IOField call1_flds[] =
{
{ "i1", "integer", sizeof (int), IOOffset (call1_ptr, i1) },
{ "i2", "integer", sizeof (int), IOOffset (call1_ptr, i2) },
{ "s1", "string", sizeof (char*), IOOffset (call1_ptr, s1) },
{ (char*)0, (char*)0, 0, 0 }
};
IOField resp1_flds[] =
{
{ "result", "integer", sizeof (int), IOOffset (resp1_ptr, result) },
{ "res_str", "string", sizeof (char*), IOOffset (resp1_ptr, res_str) },
{ (char*)0, (char*)0, 0, 0 }
};
static
pid_t
run_subprocess(args)
char **args;
{
#ifdef HAVE_WINDOWS_H
int child;
child = _spawnv(_P_NOWAIT, "./ts.exe", args);
if (child == -1) {
perror("spawnv");
}
return child;
#else
pid_t child = fork();
if (child == 0) {
execv("./ts", args);
}
return child;
#endif
}
void
handler (void* in_msg, void* out_msg, CMrpc_options options)
{
call1* pc;
resp1* pr;
pc = (call1*)in_msg;
pr = (resp1*)out_msg;
pr->result = pc->i1 + pc->i2;
pr->res_str = strdup (pc->s1);
pr->res_str[0] = toupper (pr->res_str[0]);
CMrpc_clear_option(options, CMrpc_call_cleanup_function);
}
void
oneway_handler (void* in_msg, CMrpc_options options)
{
call1* pc;
pc = (call1*)in_msg;
if (pc->i1 == -1000
&& pc->i2 == -1000
&& strcmp (pc->s1, "shutdown") == 0)
{
keep_server_going = 0;
if (!quiet)
fprintf (stderr, "oneway shutdown msg received...\n");
CMrpc_shutdown();
}
}
void
cleanup_handler (CManager cm, void* msg)
{
resp1* pr;
pr = (resp1*)msg;
if (!quiet) fprintf (stderr, "In cleanup handler, about to free memory...\n");
free (pr->res_str);
if (!quiet) fprintf (stderr, "DONE\n");
}
int
check_result (call1_ptr pc, resp1_ptr pr)
{
int r = 0;
char *t;
t = strdup (pc->s1);
*t = (unsigned char) toupper (*t);
r = ((pc->i1 + pc->i2 != pr->result
|| strcmp (t, pr->res_str) != 0));
if (!quiet)
{
fprintf (stderr, "result is %d:%s, should be %d:%s\n",
pr->result, pr->res_str,
pc->i1 + pc->i2, t);
if (r)
fprintf (stderr, "test error\n");
}
free (t);
return r;
}
static pid_t client_proc = 0;
static void
fail_and_die(signal)
int signal;
{
fprintf(stderr, "Test failed to complete in reasonable time\n");
if (client_proc != 0) {
kill(client_proc, 9);
}
exit(1);
}
int
main (int argc, char** argv)
{
int reps;
attr_list attrs;
char* test_str = "snuggle!";
char* shutdown_str = "shutdown";
char* test_rpc_name = "addemup";
char* test_server = "localhost";
#ifdef HAVE_WINDOWS_H
SetTimer(NULL, 5, 1000, (TIMERPROC) fail_and_die);
#else
struct sigaction sigact;
sigact.sa_flags = 0;
sigact.sa_handler = fail_and_die;
sigemptyset(&sigact.sa_mask);
sigaddset(&sigact.sa_mask, SIGALRM);
sigaction(SIGALRM, &sigact, NULL);
alarm(300);
#endif
while (argv[1] && (argv[1][0] == '-'))
{
if (argv[1][1] == 'c')
{
regression_master = 0;
}
else if (argv[1][1] == 's')
{
regression_master = 1;
}
else if (argv[1][1] == 'q')
{
quiet = 1;
}
else if (argv[1][1] == 'v')
{
quiet = 0;
}
else if (argv[1][1] == 'n')
{
fork_client = 0;
}
else if (argv[1][1] == 'h')
{
test_server = argv[2];
argv++;
}
argv++;
}
gen_pthread_init();
cm = CManager_create();
attrs = create_attr_list();
set_attr (attrs,
CM_IP_HOSTNAME,
Attr_String,
test_server);
set_attr (attrs,
CM_IP_PORT,
Attr_Int4,
(attr_value*)6969);
if (!regression_master)
{
call1 call_struct;
resp1 response_struct;
CMrpc_ticket t;
IOContext ic, oc;
call_struct.i1 = 5;
call_struct.i2 = 5;
call_struct.s1 = test_str;
response_struct.result = 0;
CMrpc_register_rpc_format (cm, test_rpc_name,
call1_flds, NULL,
resp1_flds, NULL);
CMrpc_register_rpc_contact_info (cm, test_rpc_name, attrs);
CMrpc_call_rpc (cm, test_rpc_name, NULL, &call_struct, &response_struct, 0);
status += check_result (&call_struct, &response_struct);
if (!quiet) printf ("first call complete\n");
call_struct.i1 = 12;
call_struct.i2 = 30;
t = CMrpc_call_rpc (cm, test_rpc_name, NULL, &call_struct, &response_struct, CMrpc_async_call);
CMrpc_redeem_ticket (cm, t, &response_struct, 1);
status += check_result (&call_struct, &response_struct);
if (!quiet) printf ("second call complete\n");
call_struct.i1 = 100;
call_struct.i2 = 25;
ic = CMget_user_type_context (cm);
oc = CMget_user_type_context (cm);
CMregister_user_format (cm, ic, "addemup", call1_flds, NULL);
CMregister_user_format (cm, oc, "addemup", resp1_flds, NULL);
t = CMrpc_call_anon_rpc (cm, "addemup", attrs,
ic, &call_struct,
oc, &response_struct,
CMrpc_async_call);
reps = 0;
while (reps++ < 5 && CMrpc_redeem_ticket (cm, t, &response_struct, 0) != 1)
{
if (!quiet) {
fprintf (stderr, "Async/no-wait result wasn't available, sleeping....\n");
}
CMusleep (cm,1000);
}
if (reps >= 5)
{
if (!quiet) fprintf (stderr, "Async/no-wait result never arrived!\n");
}
else
{
status += check_result (&call_struct, &response_struct);
}
CMfree_user_type_context (cm, ic);
CMfree_user_type_context (cm, oc);
if (!quiet) printf ("third call complete\n");
call_struct.i1 = call_struct.i2 = -1000;
call_struct.s1 = shutdown_str;
CMrpc_call_rpc_oneway (cm, test_rpc_name, attrs, &call_struct, 0);
if (!quiet) printf ("shutdown call complete\n");
CManager_close (cm);
free_attr_list (attrs);
}
else
{
char *args[] = { "ts", "-q", "-c", NULL };
CMlisten_specific (cm, attrs);
CMrpc_register_rpc_format (cm, test_rpc_name,
call1_flds, NULL,
resp1_flds, NULL);
CMrpc_register_rpc_handler (cm, test_rpc_name, &handler, &oneway_handler, &cleanup_handler);
if (fork_client)
{
client_proc = run_subprocess (args);
}
while (keep_server_going)
{
if (!forked)
{
CMsleep(cm, 1);
}
else
{
sleep(1);
}
}
CManager_close (cm);
}
return status;
}
