static void
testObject(void) {
xmlrpc_env env;
xmlrpc_server_abyss_parms parms;
xmlrpc_server_abyss_t * serverP;
xmlrpc_registry * registryP;
xmlrpc_server_abyss_sig * oldHandlersP;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
parms.config_file_name = NULL;
parms.registryP = registryP;
serverP = NULL;
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Global init not done */
xmlrpc_server_abyss_global_init(&env);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_NO_FAULT(&env);
TEST(serverP != NULL);
xmlrpc_server_abyss_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_reset_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_use_sigchld(serverP);
xmlrpc_server_abyss_restore_sig(oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_destroy(serverP);
xmlrpc_registry_free(registryP);
xmlrpc_server_abyss_global_term();
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Not globally initialized */
xmlrpc_env_clean(&env);
}
static void
extractSockAddrParms(xmlrpc_env * const envP,
const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize,
const struct sockaddr ** const sockAddrPP,
socklen_t * const sockAddrLenP,
unsigned int * const portNumberP) {
/*----------------------------------------------------------------------------
Return the server parameters that affect the address on which the server
socket shall listen.
There are two ways the arguments can specify this: 1) user supplies a
complete socket address, which specifies both a TCP port number and an IP
address (which determines on which interface, ergo which network, if any,
the server listens); and 2) just a TCP port number, which means he wants
to listen on all IPv4 interfaces and networks. (2) is legacy.
If the user specifies the 'sockaddrP' and 'sockaddrlen' arguments, he gets
(1) and we ignore his 'port' argument. We return his 'sockaddrP' and
'sockaddrlen' values as *sockAddrPP and *sockAddrLenP and nothing as
*portNumberP.
If the user doesn't specify 'sockaddrP', he gets (2). We return NULL as
*sockAddrP and his 'port_number' argument as *portNumberP. If he doesn't
specify 'port' either, we default it to 8080.
Specifying 'sockaddrP' and not 'sockaddrlen' is an error.
Note that the user's socket address may indicate "any IP address."
-----------------------------------------------------------------------------*/
if (parmSize >= XMLRPC_APSIZE(sockaddr_p)) {
if (parmSize < XMLRPC_APSIZE(sockaddrlen))
xmlrpc_faultf(envP, "You must specify 'sockaddrlen' when you "
"specify 'sockaddrP'");
else {
*sockAddrPP = parmsP->sockaddr_p;
*sockAddrLenP = parmsP->sockaddrlen;
}
} else
*sockAddrPP = NULL;
if (*sockAddrPP == NULL) {
unsigned int portNumber;
if (parmSize >= XMLRPC_APSIZE(port_number))
portNumber = parmsP->port_number;
else
portNumber = 8080;
if (portNumber > 0xffff)
xmlrpc_faultf(envP,
"TCP port number %u exceeds the maximum possible "
"TCP port number (65535)",
portNumber);
*portNumberP = portNumber;
}
}
void launch(int port, struct ExperimentServer handlers){
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
weblab_handlers.is_up_and_running = handlers.is_up_and_running;
weblab_handlers.start_experiment = handlers.start_experiment;
weblab_handlers.send_command = handlers.send_command;
weblab_handlers.send_file = handlers.send_file;
weblab_handlers.dispose = handlers.dispose;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.test_me", &weblab_xmlrpc_test_me, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.is_up_and_running", &weblab_xmlrpc_is_up_and_running, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.start_experiment", &weblab_xmlrpc_start_experiment, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.send_command", &weblab_xmlrpc_send_command_to_device, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.send_file", &weblab_xmlrpc_send_file_to_device, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.dispose", &weblab_xmlrpc_dispose, NULL);
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = port;
serverparm.log_file_name = "xmlrpc_log";
printf("Running XML-RPC server on port %i...\n", port);
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
}
static bool
expiresParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
return
parmSize >= XMLRPC_APSIZE(access_ctl_expires) ?
parmsP->access_ctl_expires : false;
}
static bool
enableShutdownParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
return
parmSize >= XMLRPC_APSIZE(enable_shutdown) &&
parmsP->enable_shutdown;
}
static bool
chunkResponseParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
return
parmSize >= XMLRPC_APSIZE(chunk_response) &&
parmsP->chunk_response;
}
static void
setAdditionalServerParms(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize,
TServer * const serverP) {
if (parmSize >= XMLRPC_APSIZE(keepalive_timeout) &&
parmsP->keepalive_timeout > 0)
ServerSetKeepaliveTimeout(serverP, parmsP->keepalive_timeout);
if (parmSize >= XMLRPC_APSIZE(keepalive_max_conn) &&
parmsP->keepalive_max_conn > 0)
ServerSetKeepaliveMaxConn(serverP, parmsP->keepalive_max_conn);
if (parmSize >= XMLRPC_APSIZE(timeout) &&
parmsP->timeout > 0)
ServerSetTimeout(serverP, parmsP->timeout);
if (parmSize >= XMLRPC_APSIZE(dont_advertise))
ServerSetAdvertise(serverP, !parmsP->dont_advertise);
}
static unsigned int
maxAgeParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
return
parmSize >= XMLRPC_APSIZE(access_ctl_max_age) ?
parmsP->access_ctl_max_age : 0;
}
static const char *
allowOriginParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
return
parmSize >= XMLRPC_APSIZE(allow_origin) ?
parmsP->allow_origin : NULL;
}
static const char *
uriPathParm(const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize) {
const char * uriPath;
if (parmSize >= XMLRPC_APSIZE(uri_path) && parmsP->uri_path)
uriPath = parmsP->uri_path;
else
uriPath = "/RPC2";
return uriPath;
}
int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
/* .methodName = */ "sample.add",
/* .methodFunction = */ &sample_add,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port "
"number on which the server will accept connections "
"for RPCs (8080 is a common choice). "
"You specified %d arguments.\n", argc-1);
exit(1);
}
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
if (env.fault_occurred) {
printf("xmlrpc_registry_new() failed. %s\n", env.fault_string);
exit(1);
}
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
if (env.fault_occurred) {
printf("xmlrpc_registry_add_method3() failed. %s\n",
env.fault_string);
exit(1);
}
serverparm.config_file_name = NULL; /* Select the modern normal API */
serverparm.registryP = registryP;
serverparm.port_number = atoi(argv[1]);
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Running XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
if (env.fault_occurred) {
printf("xmlrpc_server_abyss() failed. %s\n", env.fault_string);
exit(1);
}
/* xmlrpc_server_abyss() never returns unless it fails */
return 0;
}
static void
extractServerCreateParms(
xmlrpc_env * const envP,
const xmlrpc_server_abyss_parms * const parmsP,
unsigned int const parmSize,
bool * const socketBoundP,
const struct sockaddr ** const sockAddrPP,
socklen_t * const sockAddrLenP,
unsigned int * const portNumberP,
TOsSocket * const socketFdP,
const char ** const logFileNameP) {
if (parmSize >= XMLRPC_APSIZE(socket_bound))
*socketBoundP = parmsP->socket_bound;
else
*socketBoundP = FALSE;
if (*socketBoundP) {
if (parmSize < XMLRPC_APSIZE(socket_handle))
xmlrpc_faultf(envP, "socket_bound is true, but server parameter "
"structure does not contain socket_handle (it's too "
"short)");
else
*socketFdP = parmsP->socket_handle;
} else {
extractSockAddrParms(envP, parmsP, parmSize, sockAddrPP, sockAddrLenP,
portNumberP);
}
if (!envP->fault_occurred) {
if (parmSize >= XMLRPC_APSIZE(log_file_name) &&
parmsP->log_file_name)
*logFileNameP = strdup(parmsP->log_file_name);
else
*logFileNameP = NULL;
}
}
static void run_rpc_server(xmlrpc_env *env, unsigned int port)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
memset(&serverparm, 0, sizeof(serverparm));
registryP = xmlrpc_registry_new(env);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_destination", &add_flow_destination, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_source", &add_flow_source, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "start_flows", &start_flows, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_reports", &method_get_reports, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "stop_flow", &method_stop_flow, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_version", &method_get_version, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_status", &method_get_status, NULL);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.socket_bound = 1;
serverparm.log_file_name = NULL; /*"/tmp/xmlrpc_log";*/
/* Increase HTTP keep-alive duration. Using defaults the amount of
* sockets in TIME_WAIT state would become too high.
*/
serverparm.keepalive_timeout = 60;
serverparm.keepalive_max_conn = 1000;
/* Disable introspection */
serverparm.dont_advertise = 1;
logging_log(LOG_NOTICE, "Running XML-RPC server on port %u", port);
printf("Running XML-RPC server...\n");
serverparm.socket_handle = bind_rpc_server(rpc_bind_addr, port);
xmlrpc_server_abyss(env, &serverparm, XMLRPC_APSIZE(socket_handle));
if (env->fault_occurred) {
logging_log(LOG_ALERT, "XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
}
/* xmlrpc_server_abyss() never returns */
}
int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
/* .methodName = */ "calculate_modexp",
/* .methodFunction = */ &calculate_modexp,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port "
"number on which the server will accept connections "
"for RPCs (8080 is a common choice). "
"You specified %d arguments.\n", argc-1);
exit(1);
}
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = atoi(argv[1]);
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Running XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
/* xmlrpc_server_abyss() never returns */
return 0;
}
void init_rpc_server(struct xmlrpc_method_info3 const * methodInfo, int portnum ){
xmlrpc_server_abyss_parms serverparm;
xmlrpc_server_abyss_t * serverP;
xmlrpc_registry * registryP;
xmlrpc_env env;
xmlrpc_server_abyss_sig * oldHandlersP;
xmlrpc_env_init(&env);
xmlrpc_server_abyss_global_init(&env);
dieIfFailed((const char*)"xmlrpc_server_abyss_global_init", &env);
registryP = xmlrpc_registry_new(&env);
dieIfFailed((const char*)"xmlrpc_registry_new", &env);
xmlrpc_registry_add_method3(&env, registryP, methodInfo);
dieIfFailed((const char*)"xmlrpc_registry_add_method3", &env);
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = portnum;
xmlrpc_server_abyss_create(&env, &serverparm, XMLRPC_APSIZE(port_number), &serverP);
dieIfFailed((const char*)"xmlrpc_server_abyss_create", &env);
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
dieIfFailed((const char*)"xmlrpc_server_abyss_setup_sig", &env);
setupSigtermHandler(serverP);
printf("Running XML-RPC server...\n");
xmlrpc_server_abyss_run_server(&env, serverP);
dieIfFailed((const char*)"xmlrpc_server_abyss_run_server", &env);
restoreSigtermHandler();
xmlrpc_server_abyss_restore_sig(oldHandlersP);
xmlrpc_server_abyss_destroy(serverP);
xmlrpc_registry_free(registryP);
xmlrpc_server_abyss_global_term();
xmlrpc_env_clean(&env);
}
//--------------------------------------------------------------------------------------
DWORD WINAPI ServerThread(LPVOID lpParam)
{
struct xmlrpc_method_info3 const methodInfo =
{
/* .methodName = */ "vertex_callback",
/* .methodFunction = */ &vertex_callback,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry *registryP;
xmlrpc_env env;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = XMLRPC_SERVER_PORT;
serverparm.log_file_name = "./" LOG_NAME;
DbgMsg(
__FILE__, __LINE__,
__FUNCTION__"(): Running XML-RPC server at port %d...\n",
serverparm.port_number
);
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
/* xmlrpc_server_abyss() never returns */
return 0;
}
int main(int argc, char ** argv){
signal(SIGINT, stop_notifier);
signal(SIGTERM, stop_notifier);
notify_log("Info", "Strated scheduler");
//load in config
if (ini_parse("/etc/network-sensor-server/config.ini", handler, &config) < 0) {
notify_log("Error", "Can't load 'config.ini'\n");
return 1;
}
//make deamon
if(argc == 2)
deamonise();
/* */
/* -- RPC server -- */
/* */
struct xmlrpc_method_info3 const add_alarm_method = {
"add_alarm.request",
&add_alarm,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
xmlrpc_server_abyss_t * serverP;
xmlrpc_server_abyss_sig * oldHandlersP;
xmlrpc_env_init(&env);
xmlrpc_server_abyss_global_init(&env);
registryP = xmlrpc_registry_new(&env);
if (env.fault_occurred) {
notify_log("Error", "xmlrpc_registry_new() failed. %s", env.fault_string);
exit(1);
}
//add methods
xmlrpc_registry_add_method3(&env, registryP, &add_alarm_method);
if (env.fault_occurred) {
notify_log("Error", "xmlrpc_registry_add_method3() add_alarm failed. %s", env.fault_string);
exit(1);
}
serverparm.config_file_name = NULL; /* Select the modern normal API */
serverparm.registryP = registryP;
serverparm.port_number = config.notifier_rpc_port;
serverparm.runfirst = NULL;
serverparm.runfirst_arg = NULL;
serverparm.log_file_name = "/var/log/network-sensor-server/xmlrpc_log";
xmlrpc_server_abyss_create(&env, &serverparm, XMLRPC_APSIZE(log_file_name), &serverP);
notify_log("Info", "Started XML-RPC server");
xmlrpc_server_abyss_run_server(&env, serverP);
if (env.fault_occurred) {
printf("xmlrpc_server_abyss() failed. %s\n", env.fault_string);
exit(1);
}
notify_log("Info", "Stopping XML-RPC server");
xmlrpc_server_abyss_destroy(serverP);
xmlrpc_server_abyss_global_term();
}
int main(int argc, char **argv)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
int ii;
int c;
int dmn = 0;
char *config_file = NULL;
while ( ( c = getopt_long( argc, argv, short_opts, long_opts, NULL ) ) != -1 )
{
switch( c ) {
case 'd':
dmn = 1;
break;
case 'c':
config_file = strdup( optarg );
break;
case '?':
default:
fprintf(stderr, "unknown option\n");
fprintf(stderr, "%s", usage_txt);
exit(1);
}
}
if ( dmn && (0 != daemon( 0, 0 ) )) {
SYSLOG_FAULT("Failed to daemonize");
return 1;
}
if ( zw_api_init( "/dev/ttyUSB0", &hzr_ctx.zw_ctx ) ) {
SYSLOG_FAULT("zWave API Init failed");
return 1;
}
sleep(3);
zw_list_nodes();
if ( config_file )
xmlconfig_load( config_file );
xmlrpc_env_init(&env);
dieOnFault("init", &env);
registryP = xmlrpc_registry_new(&env);
dieOnFault("init_registry", &env);
for ( ii = 0; ii < ( sizeof( methodInfo ) / sizeof( struct xmlrpc_method_info3 ) ); ii++ )
{
xmlrpc_registry_add_method3(&env, registryP, &methodInfo[ii]);
dieOnFault("add_method", &env);
}
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = 8080;
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Starting XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(registryP));
if ( config_file ) free( config_file );
return 0;
}
/**
* Thread process created to run a listener for the methods being called.
*/
static void *
xr_rpcListener (Server *svr)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_server_abyss_t *serverP;
xmlrpc_server_abyss_sig *oldHandlersP;
xmlrpc_env_init (&svr->env);
if (SRVR_DEBUG)
fprintf (stderr, "NEW_ABYSS_SERVER rpcListener ....\n");
xmlrpc_server_abyss_global_init (&svr->env);
xr_dieIfFailed ("xmlrpc_server_abyss_global_init", svr->env);
svr->registry = xmlrpc_registry_new (&svr->env);
xr_dieIfFailed ("xmlrpc_registry_new", svr->env);
xmlrpc_registry_set_default_method (&svr->env,
(svr->serverparm.registryP = svr->registry),
(xmlrpc_default_method) &xr_defaultMethod, svr);
serverparm.config_file_name = NULL;
serverparm.registryP = svr->serverparm.registryP;
serverparm.port_number = svr->serverparm.port_number;
serverparm.log_file_name = svr->serverparm.log_file_name;
/*
serverparm.keepalive_timeout = 15;
serverparm.keepalive_max_conn = 4;
xmlrpc_server_abyss_create (&svr->env, &serverparm,
XMLRPC_APSIZE(keepalive_max_conn), &serverP);
*/
xmlrpc_server_abyss_create (&svr->env, &serverparm,
XMLRPC_APSIZE(log_file_name), &serverP);
xr_dieIfFailed ("xmlrpc_server_abyss_create", svr->env);
xmlrpc_server_abyss_setup_sig (&svr->env, serverP, &oldHandlersP);
xr_dieIfFailed ("xmlrpc_server_abyss_setup_sig", svr->env);
xr_setupSigtermHandler (serverP);
/* Launch the server.
*/
xmlrpc_server_abyss_run_server (&svr->env, serverP);
xr_dieIfFailed ("xmlrpc_server_abyss_run_server", svr->env);
/* We should never get here ....
*/
fprintf (stderr, "Server has terminated\n");
xr_restoreSigtermHandler ();
xmlrpc_server_abyss_restore_sig (oldHandlersP);
xmlrpc_server_abyss_destroy (serverP);
xmlrpc_registry_free (svr->registry);
xmlrpc_server_abyss_global_term ();
xmlrpc_env_clean (&svr->env);
return ((void *) ERR);;
}
/**
* Thread process created to run a listener for the methods being called.
*/
static void *
xr_rpcListener (Server *svr)
{
xmlrpc_server_abyss_parms serverparm;
/* Initialize the environment and install the default dispatcher method.
*/
xmlrpc_env_init (&svr->env); /* initialize XML-RPC interface */
if (SRVR_DEBUG)
fprintf (stderr, "GLOBAL_ABYSS_SERVER rpcListener ....\n");
svr->registry = xmlrpc_registry_new (&svr->env);
xmlrpc_registry_set_default_method (&svr->env,
(svr->serverparm.registryP = svr->registry),
(xmlrpc_default_method) &xr_defaultMethod, svr);
serverparm.config_file_name = NULL;
serverparm.registryP = svr->serverparm.registryP;
serverparm.port_number = svr->serverparm.port_number;
serverparm.log_file_name = svr->serverparm.log_file_name;
serverparm.keepalive_timeout = 0;
serverparm.keepalive_max_conn = 0;
/*
serverparm.keepalive_timeout = 30;
serverparm.keepalive_max_conn = 128;
*/
/* Never returns .....
*/
#ifndef OLD_METHOD
xmlrpc_server_abyss (&svr->env, &serverparm, XMLRPC_APSIZE(log_file_name));
#else
{
xmlrpc_server_abyss_t *serverP;
xmlrpc_server_abyss_sig *oldHandlersP;
xmlrpc_server_abyss_create (&svr->env, &serverparm,
XMLRPC_APSIZE(log_file_name), &serverP);
xmlrpc_server_abyss_setup_sig (&svr->env, serverP, &oldHandlersP);
printf ("Starting XML-RPC server...\n");
xmlrpc_server_abyss_run_server (&svr->env, &serverP);
xmlrpc_server_abyss_restore_sig (oldHandlersP);
free (oldHandlersP);
xmlrpc_server_abyss_destroy (serverP);
xmlrpc_server_abyss_global_term ();
}
#endif
/* Should never get here.
*/
if (svr->env.fault_occurred) {
fprintf (stderr, "xmlrpc_server_abyss terminates.....\n");
exit (1);
} else
return ((void *) OK);
}
