// {int32 key, string name, string path}[] = archiver.archives()
xmlrpc_value *get_archives(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
LOG_MSG("archiver.archives\n");
#endif
// Get Configuration
ServerConfig config;
if (!get_config(env, config))
return 0;
// Create result
AutoXmlRpcValue result(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
stdList<ServerConfig::Entry>::const_iterator i;
for (i=config.config.begin(); i!=config.config.end(); ++i)
{
AutoXmlRpcValue archive(
xmlrpc_build_value(env, "{s:i,s:s,s:s}",
"key", i->key,
"name", i->name.c_str(),
"path", i->path.c_str()));
xmlrpc_array_append_item(env, result, archive);
}
return result.release();
}
static void
test_value_invalid_struct(void) {
xmlrpc_value * v;
xmlrpc_env env;
/* Note that even though the format strings are invalid, we have
to supply the variable arguments that xmlrpc_build_value() will
be looking for as it tries to parse it. Otherwise, we get wild
memory references and consequent Valgrind flags.
*/
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "{s:ii", "key1", 9, 9);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{si:", "key1", 9);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{s", "key1");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
xmlrpc_value *tcos_lockscreen(xmlrpc_env *env, xmlrpc_value *in, void *ud)
#endif
{
char *user;
char *pass;
char *login_ok;
/* Parse app string */
xmlrpc_parse_value(env, in, "(ss)", &user, &pass);
if (env->fault_occurred)
return xmlrpc_build_value(env, "s", "params error");
/* need login first */
login_ok=validate_login(user,pass);
if( strcmp(login_ok, LOGIN_OK ) != 0 )
return xmlrpc_build_value(env, "s", login_ok );
if ( strcmp(TCOS_PATH, "/sbin" ) )
job_exe(TCOS_PATH"/lockscreen");
else
job_exe("lockscreen");
return xmlrpc_build_value(env, "s", "OK" );
}
static void
callOneMethod(xmlrpc_env * const envP,
xmlrpc_registry * const registryP,
xmlrpc_value * const rpcDescP,
void * const callInfo,
xmlrpc_value ** const resultPP) {
const char * methodName;
xmlrpc_value * paramArrayP;
XMLRPC_ASSERT_ENV_OK(envP);
if (xmlrpc_value_type(rpcDescP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR,
"An element of the multicall array is type %u, but should "
"be a struct (with members 'methodName' and 'params')",
xmlrpc_value_type(rpcDescP));
else {
xmlrpc_decompose_value(envP, rpcDescP, "{s:s,s:A,*}",
"methodName", &methodName,
"params", ¶mArrayP);
if (!envP->fault_occurred) {
/* Watch out for a deep recursion attack. */
if (xmlrpc_streq(methodName, "system.multicall"))
xmlrpc_env_set_fault_formatted(
envP,
XMLRPC_REQUEST_REFUSED_ERROR,
"Recursive system.multicall forbidden");
else {
xmlrpc_env env;
xmlrpc_value * resultValP;
xmlrpc_env_init(&env);
xmlrpc_dispatchCall(&env, registryP, methodName, paramArrayP,
callInfo,
&resultValP);
if (env.fault_occurred) {
/* Method failed, so result is a fault structure */
*resultPP =
xmlrpc_build_value(
envP, "{s:i,s:s}",
"faultCode", (xmlrpc_int32) env.fault_code,
"faultString", env.fault_string);
} else {
*resultPP = xmlrpc_build_value(envP, "(V)", resultValP);
xmlrpc_DECREF(resultValP);
}
xmlrpc_env_clean(&env);
}
xmlrpc_DECREF(paramArrayP);
xmlrpc_strfree(methodName);
}
}
}
static xmlrpc_value *freeswitch_api(xmlrpc_env * const envP, xmlrpc_value * const paramArrayP, void *const userData, void *const callInfo)
{
char *command = NULL, *arg = NULL;
switch_stream_handle_t stream = { 0 };
xmlrpc_value *val = NULL;
switch_bool_t freed = 0;
/* Parse our argument array. */
xmlrpc_decompose_value(envP, paramArrayP, "(ss)", &command, &arg);
if (envP->fault_occurred) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Request!\n");
return NULL;
}
if (!is_authorized((const TSession *) callInfo, command)) {
val = xmlrpc_build_value(envP, "s", "UNAUTHORIZED!");
goto end;
}
if (switch_stristr("unload", command) && switch_stristr("mod_xml_rpc", arg)) {
switch_safe_free(command);
switch_safe_free(arg);
freed = 1;
command = "bgapi";
arg = "unload mod_xml_rpc";
} else if (switch_stristr("reload", command) && switch_stristr("mod_xml_rpc", arg)) {
switch_safe_free(command);
switch_safe_free(arg);
freed = 1;
command = "bgapi";
arg = "reload mod_xml_rpc";
}
SWITCH_STANDARD_STREAM(stream);
if (switch_api_execute(command, arg, NULL, &stream) == SWITCH_STATUS_SUCCESS) {
/* Return our result. */
val = xmlrpc_build_value(envP, "s", stream.data);
free(stream.data);
} else {
val = xmlrpc_build_value(envP, "s", "ERROR!");
}
end:
/* xmlrpc-c requires us to free memory it malloced from xmlrpc_decompose_value */
if (!freed) {
switch_safe_free(command);
switch_safe_free(arg);
}
return val;
}
xmlrpc_value *tcos_standalone(xmlrpc_env *env, xmlrpc_value *in, void *ud)
#endif
{
FILE *fp;
char line[BIG_BUFFER];
char *info;
char *group;
size_t *len;
char *fret;
UNUSED(fret);
/* read what info search */
xmlrpc_parse_value(env, in, "(ss#)", &info, &group, &len);
dbgtcos("tcosxmlrpc::tcos_standalone() searching for standalone=\"%s\"\n", info);
if ( strcmp(info, "get_user") == 0 )
fp=(FILE*)popen(STANDALONE_USER, "r");
else if ( strcmp(info, "get_exclude") == 0 ) {
snprintf( line, BSIZE, "%s=%s 2>/dev/null", STANDALONE_EXCLUDE, group);
fp=(FILE*)popen(line, "r");
}
else if ( strcmp(info, "get_process") == 0 )
fp=(FILE*)popen(STANDALONE_PROCESS, "r");
else if ( strcmp(info, "get_server") == 0 ) {
snprintf( line, BSIZE, "%s %s 2>/dev/null", STANDALONE_SERVER, group);
fp=(FILE*)popen(line, "r");
}
else if ( strcmp(info, "get_multiseat") == 0 ) {
snprintf( line, BSIZE, "%s %s 2>/dev/null", STANDALONE_MULTISEAT, group);
fp=(FILE*)popen(line, "r");
}
else if ( strcmp(info, "get_time") == 0 )
fp=(FILE*)popen(STANDALONE_TIME, "r");
/* default method = error */
else
return xmlrpc_build_value(env, "s", STANDALONE_UNKNOW );
if (fp == NULL)
return xmlrpc_build_value(env, "s", STANDALONE_UNKNOW );
/* put error into line */
strncpy(line, STANDALONE_ERROR, BIG_BUFFER);
fret=fgets( line, sizeof line, fp);
remove_line_break(line);
pclose(fp);
dbgtcos("tcosxmlrpc::tcos_standalone() line=\"%s\"\n", line);
return xmlrpc_build_value(env, "s", line );
}
xmlrpc_value *tcos_dpms(xmlrpc_env *env, xmlrpc_value *in, void *ud)
#endif
{
FILE *fp;
char line[BIG_BUFFER];
char *action;
char *user;
char *pass;
char *login_ok;
char cmd[BIG_BUFFER];
char *fret;
UNUSED(fret);
/* read what info search */
xmlrpc_parse_value(env, in, "(sss)", &action, &user, &pass);
if (env->fault_occurred)
return xmlrpc_build_value(env, "s", "params error");
/* need login first */
login_ok=validate_login(user,pass);
if( strcmp(login_ok, LOGIN_OK ) != 0 )
return xmlrpc_build_value(env, "s", login_ok );
dbgtcos("tcosxmlrpc::tcos_dpms() login ok, action=%s \n", action);
/* read action */
if( strcmp(action, "off" ) == 0 ) {
sprintf( cmd , "%s dpms force off; echo $?", DPMS_CONTROLLER);
}
else if( strcmp(action, "on" ) == 0 ) {
sprintf( cmd , "%s dpms force on; echo $?", DPMS_CONTROLLER);
}
else {
/* show status */
sprintf( cmd , "%s q| awk '/Monitor/ {print $3}'", DPMS_CONTROLLER);
}
dbgtcos("tcosxmlrpc::tcos_dpms() cmd=\"%s\"\n", cmd);
/* put error in line */
strncpy(line, DPMS_CMD_ERROR, BIG_BUFFER);
fp=(FILE*)popen(cmd, "r");
fret=fgets( line, sizeof line, fp);
remove_line_break(line);
pclose(fp);
dbgtcos("tcosxmlrpc::tcos_dpms() line=\"%s\"\n", line);
return xmlrpc_build_value(env, "s", line );
}
// Return CtrlInfo encoded a per "meta" returned by archiver.get_values
static xmlrpc_value *encode_ctrl_info(xmlrpc_env *env, const CtrlInfo *info)
{
if (info && info->getType() == CtrlInfo::Enumerated)
{
AutoXmlRpcValue states(xmlrpc_build_value(env, "()"));
stdString state_txt;
size_t i, num = info->getNumStates();
for (i=0; i<num; ++i)
{
info->getState(i, state_txt);
AutoXmlRpcValue state(
xmlrpc_build_value(env, "s#",
state_txt.c_str(), state_txt.length()));
xmlrpc_array_append_item(env, states, state);
}
xmlrpc_value *meta = xmlrpc_build_value(
env, "{s:i,s:V}",
"type", (xmlrpc_int32)META_TYPE_ENUM,
"states", (xmlrpc_value *)states);
return meta;
}
if (info && info->getType() == CtrlInfo::Numeric)
{
return xmlrpc_build_value(
env, "{s:i,s:d,s:d,s:d,s:d,s:d,s:d,s:i,s:s}",
"type", (xmlrpc_int32)META_TYPE_NUMERIC,
"disp_high", make_finite(info->getDisplayHigh()),
"disp_low", make_finite(info->getDisplayLow()),
"alarm_high", make_finite(info->getHighAlarm()),
"warn_high", make_finite(info->getHighWarning()),
"warn_low", make_finite(info->getLowWarning()),
"alarm_low", make_finite(info->getLowAlarm()),
"prec", (xmlrpc_int32)info->getPrecision(),
"units", info->getUnits());
}
return xmlrpc_build_value(
env, "{s:i,s:d,s:d,s:d,s:d,s:d,s:d,s:i,s:s}",
"type", (xmlrpc_int32)META_TYPE_NUMERIC,
"disp_high", 10.0,
"disp_low", 0.0,
"alarm_high", 0.0,
"warn_high", 0.0,
"warn_low", 0.0,
"alarm_low", 0.0,
"prec", (xmlrpc_int32) 1,
"units", "<NO DATA>");
/*
return xmlrpc_build_value(env, "{s:i,s:(s)}",
"type", (xmlrpc_int32)META_TYPE_ENUM,
"states", "<NO DATA>");
*/
}
static void
test_build_decomp_datetime(void) {
const char * datestring = "19980717T14:08:55";
time_t const datetime = 900684535;
xmlrpc_env env;
xmlrpc_value * v;
time_t dt;
const char * ds;
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "t", datetime);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
dt = 0;
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST(dt == datetime);
dt = 0;
xmlrpc_decompose_value(&env, v, "t", &dt);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(dt == datetime);
v = xmlrpc_int_new(&env, 9);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, v, "t", &dt);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_decompose_value(&env, v, "8", &ds);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "8", datestring);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
xmlrpc_decompose_value(&env, v, "8", &ds);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(streq(ds, datestring));
strfree(ds);
xmlrpc_env_clean(&env);
}
xmlrpc_value* xmlok (xmlrpc_env *env,xmlrpc_value *array)
{
//Si es null ponemos uno vacio
if (array==NULL)
array = xmlrpc_build_value(env,"()");
//Creamos el valor de retorno
xmlrpc_value *ret = xmlrpc_build_value(env,"{s:i,s:A}","returnCode",1,"returnVal",array);
//Decrementamos el contador
xmlrpc_DECREF(array);
//Y salimos
return ret;
}
static xmlrpc_value *
you_license (xmlrpc_env *env,
xmlrpc_value *param_array,
void *user_data)
{
xmlrpc_value *xmlrpc_patches = NULL;
RCYouPatchSList *patches = NULL;
GSList *licenses = NULL;
xmlrpc_value *xmlrpc_licenses = NULL;
GSList *iter;
xmlrpc_parse_value (env, param_array, "(A)", &xmlrpc_patches);
XMLRPC_FAIL_IF_FAULT (env);
patches = rc_xmlrpc_array_to_rc_you_patch_slist
(xmlrpc_patches, env, RC_YOU_PATCH_FROM_XMLRPC_PATCH);
XMLRPC_FAIL_IF_FAULT (env);
licenses = rc_you_patch_slist_lookup_licenses (patches);
xmlrpc_licenses = xmlrpc_build_value (env, "()");
XMLRPC_FAIL_IF_FAULT (env);
for (iter = licenses; iter; iter = iter->next) {
xmlrpc_value *xmlrpc_text;
xmlrpc_text = xmlrpc_build_value (env, "s", (char *) iter->data);
XMLRPC_FAIL_IF_FAULT (env);
xmlrpc_array_append_item (env, xmlrpc_licenses, xmlrpc_text);
XMLRPC_FAIL_IF_FAULT (env);
xmlrpc_DECREF (xmlrpc_text);
}
cleanup:
if (patches) {
rc_you_patch_slist_unref (patches);
g_slist_free (patches);
}
g_slist_free (licenses);
if (env->fault_occurred)
return NULL;
return xmlrpc_licenses;
}
static xmlrpc_value *
license_lookup_from_packages (xmlrpc_env *env,
xmlrpc_value *param_array,
void *user_data)
{
xmlrpc_value *xmlrpc_packages;
RCPackageSList *packages = NULL;
GSList *licenses = NULL;
xmlrpc_value *license_texts = NULL;
GSList *iter;
xmlrpc_parse_value (env, param_array, "(A)", &xmlrpc_packages);
XMLRPC_FAIL_IF_FAULT (env);
packages = rcd_xmlrpc_array_to_rc_package_slist (xmlrpc_packages, env,
RCD_PACKAGE_FROM_XMLRPC_PACKAGE);
XMLRPC_FAIL_IF_FAULT (env);
licenses = rcd_license_lookup_from_package_slist (packages);
license_texts = xmlrpc_build_value (env, "()");
XMLRPC_FAIL_IF_FAULT (env);
for (iter = licenses; iter; iter = iter->next) {
xmlrpc_value *xmlrpc_text;
xmlrpc_text = xmlrpc_build_value (env, "s", (char *) iter->data);
XMLRPC_FAIL_IF_FAULT (env);
xmlrpc_array_append_item (env, license_texts, xmlrpc_text);
XMLRPC_FAIL_IF_FAULT (env);
xmlrpc_DECREF (xmlrpc_text);
}
cleanup:
if (packages) {
rc_package_slist_unref (packages);
g_slist_free (packages);
}
g_slist_free (licenses);
if (env->fault_occurred)
return NULL;
return license_texts;
}
static int recur_build_response_array( xmlrpc_env * env, struct mi_node * tree,
str * buf )
{
for ( ; tree ; tree = tree->next ) {
if (!(tree->flags & MI_WRITTEN)) {
if ( xr_write_node( buf, tree ) != 0 ) {
LM_ERR("failed to get MI node data!\n");
return -1;
}
/* we are sure that this node has been written
* => avoid writing it again */
tree->flags |= MI_WRITTEN;
}
reply_buffer[reply_buffer_len-buf->len] = 0;
reply_item = xmlrpc_build_value(env, "s", reply_buffer);
xmlrpc_array_append_item(env, xr_response, reply_item);
buf->s = reply_buffer;
buf->len = reply_buffer_len;
if ( tree->kids ) {
if ( recur_build_response_array(env, tree->kids, buf) != 0 )
return -1;
}
}
return 0;
}
xmlrpc_value* FLVStartReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
FLVServer *flv = (FLVServer *)user_data;
FLVSession *session = NULL;
//Parseamos
int sessionId;
xmlrpc_parse_value(env, param_array, "(i)", &sessionId);
//Comprobamos si ha habido error
if(env->fault_occurred)
return 0;
//Obtenemos la referencia
if(!flv->GetSessionRef(sessionId,&session))
return xmlerror(env,"La sessionerencia no existe\n");
//La borramos
int recVideoPort = session->StartReceivingVideo();
//Liberamos la referencia
flv->ReleaseSessionRef(sessionId);
//Salimos
if(!recVideoPort)
return xmlerror(env,"No se ha podido terminar la sessionerencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",recVideoPort));
}
//CreateSession
xmlrpc_value* FLVCreateSession(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
FLVServer *flv = (FLVServer *)user_data;
FLVSession *session = NULL;
//Parseamos
char *str;
xmlrpc_parse_value(env, param_array, "(s)", &str);
//Creamos la sessionerencia
int sessionId = flv->CreateSession(str);
//Si error
if (!sessionId>0)
return xmlerror(env,"No se puede crear la sessionerencia");
//Obtenemos la referencia
if(!flv->GetSessionRef(sessionId,&session))
return xmlerror(env,"Conferencia borrada antes de poder iniciarse\n");
//La iniciamos
int port = session->Init();
//Liberamos la referencia
flv->ReleaseSessionRef(sessionId);
//Salimos
if(!port)
return xmlerror(env,"No se ha podido iniciar la sessionerencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(ii)",sessionId,port));
}
static void
test_value_bool(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_bool b;
/* Test booleans. */
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BOOL), "BOOL"));
v = xmlrpc_bool_new(&env, (xmlrpc_bool) 1);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v));
xmlrpc_read_bool(&env, v, &b);
TEST_NO_FAULT(&env);
TEST(b);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "b", (xmlrpc_bool) 0);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "b", &b);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(!b);
xmlrpc_env_clean(&env);
}
static void
test_value_AS(void) {
xmlrpc_value *v;
xmlrpc_value *v2;
xmlrpc_value *v3;
xmlrpc_env env;
size_t len;
/* Test parsing of 'A' and 'S'. */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "((){})");
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, v, "(AS)", &v2, &v3);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v2));
TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(v3));
len = xmlrpc_array_size(&env, v2);
TEST_NO_FAULT(&env);
TEST(len == 0);
len = xmlrpc_struct_size(&env, v3);
TEST_NO_FAULT(&env);
TEST(len == 0);
xmlrpc_DECREF(v2);
xmlrpc_DECREF(v3);
xmlrpc_env_clean(&env);
}
xmlrpc_value* DeleteMosaic(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int mosaicId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&mosaicId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->DeleteMosaic(mosaicId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Could reset overlay image\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",mosaicId));
}
xmlrpc_value* xmlerror (xmlrpc_env *env,const char *msg)
{
//Send error
Error("Error processing xml cmd [\"%s\"]\n",msg);
//Exit
return xmlrpc_build_value(env,"{s:i,s:s}","returnCode",0,"errorMsg",msg);
}
static xmlrpc_value *
sample_add(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const channelInfo) {
xmlrpc_int32 x, y, z;
/* Parse our argument array. */
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
if (envP->fault_occurred)
return NULL;
/* Add our two numbers. */
z = x + y;
/* Sometimes, make it look hard (so client can see what it's like
to do an RPC that takes a while).
*/
if (y == 1)
sleep(1);
/* Return our result. */
return xmlrpc_build_value(envP, "i", z);
}
static xmlrpc_value * weblab_xmlrpc_test_me(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {
char * arg;
xmlrpc_decompose_value(env, param_array, "(s)", &arg);
if (env->fault_occurred)
return NULL;
return xmlrpc_build_value(env, "s", arg);
}
xmlrpc_value* GetConferences(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MCU::ConferencesInfo list;
//Obtenemos la referencia
if(!mcu->GetConferenceList(list))
return xmlerror(env,"Could not retreive conference info list\n");
//Create array
xmlrpc_value* arr = xmlrpc_array_new(env);
//Process result
for (MCU::ConferencesInfo::iterator it = list.begin(); it!=list.end(); ++it)
{
//Create array
xmlrpc_value* val = xmlrpc_build_value(env,"(isi)",it->second.id,it->second.name.c_str(),it->second.numPart);
//Add it
xmlrpc_array_append_item(env,arr,val);
//Release
xmlrpc_DECREF(val);
}
//return
return xmlok(env,arr);
}
xmlrpc_value* StartBroadcaster(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
xmlrpc_parse_value(env, param_array, "(i)", &confId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int port = conf->StartBroadcaster();
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!port)
return xmlerror(env,"No se ha podido crear el watcher FLV\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",port));
}
xmlrpc_value* CreateSpy(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
UTF8Parser parser;
//Parseamos
int confId;
int spyeeId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&spyeeId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int spyId = conf->CreateSpy(spyeeId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!spyId)
return xmlerror(env,"Create spy failed \n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",spyId));
}
static void
rcd_transaction_send_log (RCDTransaction *transaction,
gboolean successful,
const char *message)
{
xmlrpc_env env;
xmlrpc_value *params;
xmlrpc_value *transaction_log = NULL;
xmlrpc_env_init (&env);
transaction_log = transaction_xml (&env, transaction,
successful, message);
XMLRPC_FAIL_IF_FAULT (&env);
params = xmlrpc_build_value (&env, "(V)", transaction_log);
XMLRPC_FAIL_IF_FAULT (&env);
rcd_xmlrpc_client_foreach_host (TRUE, "rcserver.transaction.log",
log_sent_cb, NULL,
params);
xmlrpc_DECREF (params);
cleanup:
xmlrpc_env_clean (&env);
if (transaction_log)
xmlrpc_DECREF (transaction_log);
} /* rcd_transaction_send_log */
static void
test_value_double(void) {
xmlrpc_value * v;
xmlrpc_env env;
double d;
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_DOUBLE), "DOUBLE"));
v = xmlrpc_double_new(&env, -3.25);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v));
xmlrpc_read_double(&env, v, &d);
TEST_NO_FAULT(&env);
TEST(d == -3.25);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "d", 1.0);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "d", &d);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(d == 1.0);
xmlrpc_env_clean(&env);
}
static xmlrpc_value * weblab_xmlrpc_dispose(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {
char * response;
if (env->fault_occurred)
return NULL;
response = weblab_handlers.dispose();
return xmlrpc_build_value(env, "s", response);
}
xmlrpc_value* CreateMosaic(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int comp;
int size;
xmlrpc_parse_value(env, param_array, "(iii)", &confId,&comp,&size);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int mosaicId = conf->CreateMosaic((Mosaic::Type)comp,size);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!mosaicId)
return xmlerror(env,"Could not create mosaic\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",mosaicId));
}
/* This method returns version information of flowgrindd and OS as an xmlrpc struct */
static xmlrpc_value * method_get_version(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(param_array);
UNUSED_ARGUMENT(user_data);
struct utsname buf;
xmlrpc_value *ret = 0;
DEBUG_MSG(LOG_WARNING, "Method get_version called");
if (uname(&buf)) {
logging_log(LOG_WARNING, "uname() failed %s", strerror(errno));
exit(1);
}
ret = xmlrpc_build_value(env, "{s:s,s:i,s:s,s:s}",
"version", FLOWGRIND_VERSION,
"api_version", FLOWGRIND_API_VERSION,
"os_name", buf.sysname,
"os_release", buf.release);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method get_version failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method get_version successful");
}
return ret;
}
static xmlrpc_value * weblab_xmlrpc_is_up_and_running(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {
int response;
if (env->fault_occurred)
return NULL;
response = weblab_handlers.is_up_and_running();
return xmlrpc_build_value(env, "b", response);
}
