int set_default_method ( xmlrpc_env * env , xmlrpc_registry * registry)
{
xmlrpc_registry_set_default_method(env, registry, &default_method, NULL);
if ( env->fault_occurred ) {
LM_ERR("failed to add default method: %s\n", env->fault_string);
return -1;
}
return 0;
}
int method_registry_init(xmlrpc_env *env)
{
LOG_TRACEME
/* default method */
xmlrpc_registry_set_default_method(env, registry, &method_default, NULL);
/* helper */
MREGISTER("helper.netup", m_helper_netup);
MREGISTER("helper.restart", m_helper_restart);
MREGISTER("helper.shutdown", m_helper_shutdown);
MREGISTER("helper.startup", m_helper_startup);
/* vcd */
MREGISTER("vcd.hostinfo", m_vcd_hostinfo);
MREGISTER("vcd.login", m_vcd_login);
MREGISTER("vcd.status", m_vcd_status);
MREGISTER("vcd.user.caps.add", m_vcd_user_caps_add);
MREGISTER("vcd.user.caps.get", m_vcd_user_caps_get);
MREGISTER("vcd.user.caps.remove", m_vcd_user_caps_remove);
MREGISTER("vcd.user.get", m_vcd_user_get);
MREGISTER("vcd.user.remove", m_vcd_user_remove);
MREGISTER("vcd.user.set", m_vcd_user_set);
/* vg */
MREGISTER("vg.add", m_vg_add);
MREGISTER("vg.list", m_vg_list);
MREGISTER("vg.remove", m_vg_remove);
MREGISTER("vg.vx.reboot", m_vg_vx_reboot);
MREGISTER("vg.vx.restart", m_vg_vx_restart);
MREGISTER("vg.vx.start", m_vg_vx_start);
MREGISTER("vg.vx.stop", m_vg_vx_stop);
/* vx */
MREGISTER("vx.create", m_vx_create);
MREGISTER("vx.exec", m_vx_exec);
MREGISTER("vx.kill", m_vx_kill);
MREGISTER("vx.limstatus", m_vx_limstatus);
MREGISTER("vx.netstatus", m_vx_netstatus);
MREGISTER("vx.reboot", m_vx_reboot);
MREGISTER("vx.remove", m_vx_remove);
MREGISTER("vx.rename", m_vx_rename);
MREGISTER("vx.restart", m_vx_restart);
MREGISTER("vx.start", m_vx_start);
MREGISTER("vx.status", m_vx_status);
MREGISTER("vx.stop", m_vx_stop);
MREGISTER("vx.templates", m_vx_templates);
/* vxdb */
MREGISTER("vxdb.dx.limit.get", m_vxdb_dx_limit_get);
MREGISTER("vxdb.dx.limit.remove", m_vxdb_dx_limit_remove);
MREGISTER("vxdb.dx.limit.set", m_vxdb_dx_limit_set);
MREGISTER("vxdb.init.get", m_vxdb_init_get);
MREGISTER("vxdb.init.set", m_vxdb_init_set);
MREGISTER("vxdb.list", m_vxdb_list);
MREGISTER("vxdb.mount.get", m_vxdb_mount_get);
MREGISTER("vxdb.mount.remove", m_vxdb_mount_remove);
MREGISTER("vxdb.mount.set", m_vxdb_mount_set);
MREGISTER("vxdb.name.get", m_vxdb_name_get);
MREGISTER("vxdb.nx.addr.get", m_vxdb_nx_addr_get);
MREGISTER("vxdb.nx.addr.remove", m_vxdb_nx_addr_remove);
MREGISTER("vxdb.nx.addr.set", m_vxdb_nx_addr_set);
MREGISTER("vxdb.nx.broadcast.get", m_vxdb_nx_broadcast_get);
MREGISTER("vxdb.nx.broadcast.remove", m_vxdb_nx_broadcast_remove);
MREGISTER("vxdb.nx.broadcast.set", m_vxdb_nx_broadcast_set);
MREGISTER("vxdb.owner.add", m_vxdb_owner_add);
MREGISTER("vxdb.owner.get", m_vxdb_owner_get);
MREGISTER("vxdb.owner.remove", m_vxdb_owner_remove);
MREGISTER("vxdb.vdir.get", m_vxdb_vdir_get);
MREGISTER("vxdb.vx.bcaps.add", m_vxdb_vx_bcaps_add);
MREGISTER("vxdb.vx.bcaps.get", m_vxdb_vx_bcaps_get);
MREGISTER("vxdb.vx.bcaps.remove", m_vxdb_vx_bcaps_remove);
MREGISTER("vxdb.vx.ccaps.add", m_vxdb_vx_ccaps_add);
MREGISTER("vxdb.vx.ccaps.get", m_vxdb_vx_ccaps_get);
MREGISTER("vxdb.vx.ccaps.remove", m_vxdb_vx_ccaps_remove);
MREGISTER("vxdb.vx.cpuset.get", m_vxdb_vx_cpuset_get);
MREGISTER("vxdb.vx.cpuset.remove", m_vxdb_vx_cpuset_remove);
MREGISTER("vxdb.vx.cpuset.set", m_vxdb_vx_cpuset_set);
MREGISTER("vxdb.vx.flags.add", m_vxdb_vx_flags_add);
MREGISTER("vxdb.vx.flags.get", m_vxdb_vx_flags_get);
MREGISTER("vxdb.vx.flags.remove", m_vxdb_vx_flags_remove);
MREGISTER("vxdb.vx.limit.get", m_vxdb_vx_limit_get);
MREGISTER("vxdb.vx.limit.remove", m_vxdb_vx_limit_remove);
MREGISTER("vxdb.vx.limit.set", m_vxdb_vx_limit_set);
MREGISTER("vxdb.vx.sched.get", m_vxdb_vx_sched_get);
MREGISTER("vxdb.vx.sched.remove", m_vxdb_vx_sched_remove);
MREGISTER("vxdb.vx.sched.set", m_vxdb_vx_sched_set);
MREGISTER("vxdb.vx.uname.get", m_vxdb_vx_uname_get);
MREGISTER("vxdb.vx.uname.remove", m_vxdb_vx_uname_remove);
MREGISTER("vxdb.vx.uname.set", m_vxdb_vx_uname_set);
MREGISTER("vxdb.xid.get", m_vxdb_xid_get);
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);
}
/**
* 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);
}
int
xr_addServerMethod (char *name, void *method, void *userData)
{
char *arg_signature, *ret_signature;
if (DEBUG)
fprintf (stderr, "addMethod: '%s'\n", name);
/* Create a method in the server. We also use this to let the
** user set the default and shutdown methods.
*/
if (strcmp (name, "default") == 0) {
/* Set the default method.
*/
xmlrpc_registry_set_default_method (&svr->env, svr->registry,
(xmlrpc_default_method) &method, NULL);
} else if (strcmp (name, "shutdown") == 0) {
int shutdown;
xmlrpc_registry_set_shutdown (svr->registry, method, &shutdown);
} else {
/* All we really do at this stage is register the method with
** the interface registry. When a method is called, the default
** method is responsible for parsing the arguments and invoking
** the client code using the standard prototype.
*/
MethodP m = calloc (1, sizeof (Method));
if (svr->method_head == (MethodP) NULL) {
/* Initialize the list of methods;
*/
svr->method_head = svr->method_tail = m;
} else {
/* Add the mthod to the tail of the list.
*/
svr->method_tail->next = svr->method_tail = m;
}
/* Save information about the method. We force the argument
** signature to always be an array to simply the process of getting
** the parameters in the method. On return, we use the signature
** provided by the user and rely on the implementation to extract
** the results appropriately.
**
*/
arg_signature = ret_signature = "not_currently_used";
strcpy (m->name, name);
strcpy (m->ret_signature, ret_signature);
if (arg_signature[0] != '(') {
sprintf (m->arg_signature, "(%s)", arg_signature);
} else
strcpy (m->arg_signature, arg_signature);
m->methodFunc = method;
m->serverInfo = userData;
svr->num_methods++;
}
return (OK);
}
