void
test_server_abyss(void) {
TServer abyssServer;
printf("Running Abyss XML-RPC server tests...\n");
ServerCreate(&abyssServer, "testserver", 8080, NULL, NULL);
testSetHandlers(&abyssServer);
ServerSetKeepaliveTimeout(&abyssServer, 60);
ServerSetKeepaliveMaxConn(&abyssServer, 10);
ServerSetTimeout(&abyssServer, 0);
ServerSetAdvertise(&abyssServer, FALSE);
ServerFree(&abyssServer);
testServerParms();
testObject();
printf("\n");
printf("Abyss XML-RPC server tests done.\n");
}
/**************************************
* XmlRpcServer
* Constructor
**************************************/
XmlRpcServer::XmlRpcServer(int port)
{
char name[65];
//Iniciamos la fecha
DateInit();
//Los mime tipes
MIMETypeInit();
//Le pasamos como nombre un puntero a nosotros mismos
sprintf(name,"%p",this);
//Creamos el servidor
ServerCreate(&srv,name, port, DEFAULT_DOCS, "http.log");
//Iniciamos el servidor
ServerInit(&srv);
//Set the handler
abyss_bool ret;
//Create abyss handler
ServerReqHandler3 abbysHndlr;
//Set
abbysHndlr.userdata = (void*)this;
abbysHndlr.handleReq = RequestHandler;
abbysHndlr.term = NULL;
abbysHndlr.handleReqStackSize = 0;
//Add handler
ServerAddHandler3(&srv,&abbysHndlr,&ret);
}
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 argc, const char * argv[]) {
ServerContext c = {NULL, NULL, NULL, NULL};
ServerRef server = ServerCreate(NULL, AcceptConnection, &c);
if (server != NULL && ServerConnect(server, NULL, kServiceType, 0))
CFRunLoopRun();
return 0;
}
void PipeInstanceProc()
{
while(ServerCreate() == 1)
{
Sleep(1000);
}
ConnectNamedPipe(hPipe, NULL);
startread=TRUE;
for(;;)
{
if( ConnectNamedPipe(hPipe, NULL)==0)
{
if(GetLastError()==ERROR_NO_DATA)
{
DisconnectNamedPipe(hPipe);
ConnectNamedPipe(hPipe, NULL);
}
Sleep(1000);
}
}
}
static void xmlrpc_process(int rank)
{
/* install handler to catch termination of child processes */
if (signal(SIGCHLD, xmlrpc_sigchld)==SIG_ERR) {
LM_ERR("failed to install signal handler for SIGCHLD\n");
goto error;
}
/* Server Abyss init */
xmlrpc_env_init(&env);
#ifdef XMLRPC_OLD_VERSION
xmlrpc_server_abyss_init_registry();
registryP= xmlrpc_server_abyss_registry();
#else
registryP = xmlrpc_registry_new(&env);
#endif
DateInit();
MIMETypeInit();
if (!ServerCreate(&srv, "XmlRpcServer", port, "", log_file)) {
LM_ERR("failed to create XMLRPC server\n");
goto error;
}
#ifdef XMLRPC_OLD_VERSION
if (!ServerAddHandler(&srv, xmlrpc_server_abyss_rpc2_handler)) {
LM_ERR("failed to add handler to server\n");
goto error;
}
ServerDefaultHandler(&srv, xmlrpc_server_abyss_default_handler);
#else
xmlrpc_server_abyss_set_handlers2(&srv, "/RPC2", registryP);
#endif
ServerInit(&srv);
if( init_mi_child() != 0 ) {
LM_CRIT("failed to init the mi process\n");
goto error;
}
if ( xr_writer_init(read_buf_size) != 0 ) {
LM_ERR("failed to init the reply writer\n");
goto error;
}
#ifdef XMLRPC_OLD_VERSION
xmlrpc_env_init(&env);
#endif
if ( rpl_opt == 1 ) {
xr_response = xmlrpc_build_value(&env, "()");
if ( env.fault_occurred ){
LM_ERR("failed to create an empty array: %s\n", env.fault_string);
goto cleanup;
}
}
if ( set_default_method(&env,registryP) != 0 ) {
LM_ERR("failed to set up the default method!\n");
goto cleanup;
}
/* Run server abyss */
LM_INFO("starting xmlrpc server\n");
ServerRun(&srv);
LM_CRIT("Server terminated!!!\n");
cleanup:
xmlrpc_env_clean(&env);
if ( xr_response ) xmlrpc_DECREF(xr_response);
error:
exit(-1);
}
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)
{
const char * const name = argv[0];
TServer srv;
char * p;
const char * conffile;
bool err;
conffile = DEFAULT_CONF_FILE; /* initial value */
err = FALSE; /* initial value */
while (p=*(++argv))
{
if ((*p=='-') && (*(p+1)))
if (*(p+2)=='\0')
switch (*(p+1))
{
case 'c':
argv++;
if (*argv)
conffile=*argv;
else
err=TRUE;
break;
default:
err=TRUE;
}
else
err=TRUE;
else
err=TRUE;
};
if (err)
{
help(name);
exit(1);
};
DateInit();
MIMETypeInit();
ServerCreate(&srv,"HTTPServer",80,DEFAULT_DOCS,NULL);
ConfReadServerFile(conffile,&srv);
ServerAddHandler(&srv,HandleTime);
ServerAddHandler(&srv,HandleDump);
ServerAddHandler(&srv,HandleStatus);
ServerAddHandler(&srv,HandleMIMEType);
ServerInit(&srv);
#ifdef _UNIX
/* Catch various termination signals. */
signal(SIGTERM,sigterm);
signal(SIGINT,sigterm);
signal(SIGHUP,sigterm);
signal(SIGUSR1,sigterm);
/* Catch defunct children. */
signal(SIGCHLD,sigchld);
#endif
ServerDaemonize(srv);
ServerRun(&srv);
return 0;
}
