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); }