static void
testSetHandlers(TServer * const abyssServerP) {
xmlrpc_env env;
xmlrpc_registry * registryP;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
TEST(registryP != NULL);
xmlrpc_server_abyss_set_handler(&env, abyssServerP, "/RPC3", registryP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_set_handlers2(abyssServerP, "/RPC4", registryP);
xmlrpc_registry_free(registryP);
{
xmlrpc_registry * registryP;
registryP = xmlrpc_registry_new(&env);
xmlrpc_server_abyss_set_handlers(abyssServerP, registryP);
xmlrpc_registry_free(registryP);
}
xmlrpc_env_clean(&env);
}
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);
}
int xmlrpcsrv_cleanup() {
xmlrpccmd_cleanup();
if (xmlrpcsrv_registry) {
xmlrpc_registry_free(xmlrpcsrv_registry);
xmlrpcsrv_registry = NULL;
}
// Cleanup libxml2 stuff
xmlCleanupCharEncodingHandlers();
xmlCleanupParser();
return POM_OK;
}
xmlrpc_registry *
xmlrpc_registry_new(xmlrpc_env *env) {
xmlrpc_value *methods;
xmlrpc_registry *registry;
int registry_valid;
XMLRPC_ASSERT_ENV_OK(env);
/* Error-handling preconditions. */
methods = NULL;
registry = NULL;
registry_valid = 0;
/* Allocate our memory. */
methods = xmlrpc_struct_new(env);
XMLRPC_FAIL_IF_FAULT(env);
registry = (xmlrpc_registry*) malloc(sizeof(xmlrpc_registry));
XMLRPC_FAIL_IF_NULL(registry, env, XMLRPC_INTERNAL_ERROR,
"Could not allocate memory for registry");
/* Set everything up. */
registry->_introspection_enabled = 1;
registry->_methods = methods;
registry->_default_method = NULL;
registry->_preinvoke_method = NULL;
registry_valid = 1;
/* Install our system methods. */
install_system_methods(env, registry);
XMLRPC_FAIL_IF_FAULT(env);
cleanup:
if (env->fault_occurred) {
if (registry_valid) {
xmlrpc_registry_free(registry);
} else {
if (methods)
xmlrpc_DECREF(methods);
if (registry)
free(registry);
}
return NULL;
}
return registry;
}
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);
}
int __cdecl wmain( int argc, wchar_t * argv[])
{
xmlrpc_server_httpsys_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method(
&env, registryP, NULL, "sample.add", &sample_add, NULL);
wprintf(L"Starting XML-RPC server...\n");
//Sets the port number we are listening on
serverparm.portNum=8080;
//if this is set, we will use the authorization function
serverparm.authfn=NULL;
//serverparm.authfn=&handleAuthorization;
//set the logging level and log file
serverparm.logLevel=2;
serverparm.logFile="C:\\httpsysserverlog.txt";
//set the use of SSL
serverparm.useSSL=0;
serverparm.registryP = registryP;
xmlrpc_server_httpsys(&env, &serverparm, XMLRPC_HSSIZE(authfn));
wprintf(L"Stopping XML-RPC server...\n");
xmlrpc_registry_free(registryP);
xmlrpc_env_clean(&env);
return 0;
}
void method_registry_atexit(void)
{
LOG_TRACEME
xmlrpc_registry_free(registry);
}
XmlHandler::~XmlHandler()
{
//Destroy
xmlrpc_registry_free(registry);
}
/**
* 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);;
}
inline XmlRpcGenSrv::~XmlRpcGenSrv (void) {
xmlrpc_registry_free (mRegistry);
}
