int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
.methodName = "sample.add",
.methodFunction = &sample_add,
.serverInfo = NULL
};
TServer abyssServer;
xmlrpc_registry * registryP;
xmlrpc_env env;
int terminationRequested; /* A boolean value */
const char * error;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port number "
"on which to listen for XML-RPC calls. "
"You specified %d.\n", argc-1);
exit(1);
}
AbyssInit(&error);
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
xmlrpc_registry_set_shutdown(registryP,
&requestShutdown, &terminationRequested);
ServerCreate(&abyssServer, "XmlRpcServer", atoi(argv[1]), NULL, NULL);
xmlrpc_server_abyss_set_handlers2(&abyssServer, "/RPC2", registryP);
ServerInit(&abyssServer);
setupSignalHandlers();
terminationRequested = 0;
while (!terminationRequested) {
printf("Waiting for next RPC...\n");
ServerRunOnce(&abyssServer);
/* This waits for the next connection, accepts it, reads the
HTTP POST request, executes the indicated RPC, and closes
the connection.
*/
}
ServerFree(&abyssServer);
AbyssTerm();
return 0;
}
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;
}
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)
{
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;
}
static void *
xr_rpcListener (Server *svr)
{
struct xmlrpc_method_info3 const methodInfo[] = {
/* .methodName .methodFunction */
{ "svrping", &test_ping, },
/*
{ "sys.abort", &xr_requestAbort, },
{ "sys.shutdown", &xr_requestShutdown, }
*/
};
register int i = 0;
TServer abyssServer;
xmlrpc_registry * registryP;
xmlrpc_env env;
const char * error;
extern void xr_serverRunOnce ();
extern int xr_requestAbort ();
AbyssInit (&error); /* initialize */
xmlrpc_env_init (&env);
registryP = xmlrpc_registry_new (&env);
if (SRVR_DEBUG)
fprintf (stderr, "single_run_server rpcListener ....\n");
/* Setup a test ping method and install the special shutdown handlers.
*/
for (i=0; i < 1; i++)
xmlrpc_registry_add_method3 (&env, registryP, &methodInfo[i]);
/* Set default shutdown method.
*/
xmlrpc_registry_set_shutdown (registryP, &xr_requestShutdown, &svr_done);
xr_addServerMethod ("sys.abort", xr_requestAbort, NULL);
/* Set the default method we'll use to dispatch calls.
*/
svr->serverparm.enable_shutdown = (xmlrpc_bool) 1;
xmlrpc_registry_set_default_method (&svr->env,
(svr->serverparm.registryP = svr->registry = registryP),
(xmlrpc_default_method) &xr_defaultMethod, svr);
/* Create the server instance.
*/
ServerCreate (&abyssServer, "XmlRpcServer",
svr->serverparm.port_number, NULL, NULL);
xmlrpc_server_abyss_set_handlers2 (&abyssServer, "/RPC2",
svr->serverparm.registryP);
ServerInit (&abyssServer);
#ifdef XR_SIGPIPE_IGN
xr_setupSigpipeHandlers ();
#endif
while (! svr_done ) {
/* This waits for the next connection, accepts it, reads the
* HTTP POST request, executes the indicated RPC, and closes
* the connection.
ServerRunOnce (&abyssServer);
*/
// ServerRunOnce(&abyssServer);
(void) xr_serverRunOnce (&abyssServer);
}
ServerFree (&abyssServer); /* shut down */
AbyssTerm ();
return ((void *) ERR);
}
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();
}
