xmlrpc_value* generate_request_array ( xmlrpc_env *env , xmlrpc_value *arr)
{
#if 1
Task task = gen_prime (task);
xmlrpc_value *v1 = xmlrpc_build_value(env, "s", task._clientid);
xmlrpc_value *v2 = xmlrpc_build_value(env, "s", task.p);
xmlrpc_value *v3 = xmlrpc_build_value(env, "s", task.m);
#endif
#if 0
char s[20];
sprintf(s,"%d",getpid());
Task task = gen_prime (task);
xmlrpc_value *v1 = xmlrpc_build_value(env, "s", s);
xmlrpc_value *v2 = xmlrpc_build_value(env, "s", "45");
xmlrpc_value *v3 = xmlrpc_build_value(env, "s", "54");
#endif
xmlrpc_array_append_item (env,arr,v1);
xmlrpc_array_append_item (env,arr,v2);
xmlrpc_array_append_item (env,arr,v3);
return arr;
}
/* Pack the information from any client method into a generic xmlrpc
struct to send to the server */
xmlrpc_value *
callinfo_pack(xmlrpc_env *envP, struct call_info *cip)
{
xmlrpc_value *s = xmlrpc_struct_new(envP);
xmlrpc_value *methargs = xmlrpc_array_new(envP);
xmlrpc_value *files = xmlrpc_array_new(envP);
int i;
xmlrpc_struct_set_value(envP, s, "clientIP", xmlrpc_string_new(envP, nonull(cip->clientIP)));
xmlrpc_struct_set_value(envP, s, "serverURL", xmlrpc_string_new(envP, nonull(cip->serverURL)));
xmlrpc_struct_set_value(envP, s, "session", xmlrpc_string_new(envP, nonull(cip->session)));
xmlrpc_struct_set_value(envP, s, "method", xmlrpc_string_new(envP, nonull(cip->method)));
xmlrpc_struct_set_value(envP, s, "user", xmlrpc_string_new(envP, nonull(cip->user)));
xmlrpc_struct_set_value(envP, s, "password", xmlrpc_string_new(envP, nonull(cip->password)));
xmlrpc_struct_set_value(envP, s, "project", xmlrpc_string_new(envP, nonull(cip->project)));
xmlrpc_struct_set_value(envP, s, "version", xmlrpc_string_new(envP, nonull(cip->version)));
if (cip->methodargs)
{
for (i = 0; cip->methodargs[i]; ++i)
{
if (!strncmp(cip->methodargs[i], "file:", 5))
{
char *file_what, *file_name;
file_what = strdup(&cip->methodargs[i][5]);
file_name = strchr(file_what, '=');
if (file_name)
{
xmlrpc_value * fstruct;
*file_name++ = '\0';
fstruct = file_pack(envP, file_what, file_name);
xmlrpc_array_append_item(envP, files, fstruct);
}
else
{
fprintf(stderr, "oracc-client: bad -Mfile arg, expected -Mfile:WHAT=NAME\n");
exit(1);
}
}
else
xmlrpc_array_append_item(envP, methargs, xmlrpc_string_new(envP, cip->methodargs[i]));
}
}
xmlrpc_struct_set_value(envP, s, "method-args", methargs);
xmlrpc_struct_set_value(envP, s, "method-data", files);
return s;
}
int
wpCreatePostStruct(xmlrpc_env *env, char *username, char*password, wppost_t *post, xmlrpc_value **paramArray, int mode) {
int retval = 0;
xmlrpc_value *blogidP, *postidP, *usernameP, *passwordP, *titleP, *descriptionP, *dateP, *publishP, *categoryP, *contentP, *tokenP;
char *token;
char *categories = NULL, *catPtr;
if ( mode == 0 ) {
post->blogid = wpGetBlogId(username, password, post->url);
if (post->blogid == NULL) {
fprintf(stderr, "NULL Blog Id\n");
retval = 1;
goto out;
}
blogidP = xmlrpc_string_new(env, post->blogid);
postidP = NULL;
} else {
blogidP = NULL;
postidP = xmlrpc_string_new(env, post->postid);
}
usernameP = xmlrpc_string_new(env, username);
passwordP = xmlrpc_string_new(env, password);
titleP = xmlrpc_string_new(env, post->subject);
descriptionP = xmlrpc_string_new(env, post->body);
if(!strcmp(post->status, "draft")) {
publishP = xmlrpc_bool_new(env, FALSE);
} else {
publishP = xmlrpc_bool_new(env, TRUE);
}
dateP = xmlrpc_datetime_new_sec(env, time(NULL));
asprintf(&categories, "%s", post->categories);
catPtr = categories;
categoryP = xmlrpc_array_new(env);
token = strtok(categories, ",");
tokenP = xmlrpc_string_new(env, token);
xmlrpc_array_append_item(env, categoryP, tokenP);
while( (token = strtok( (char *) NULL, ",") ) != NULL ) {
tokenP = xmlrpc_string_new(env, token);
xmlrpc_array_append_item(env, categoryP, tokenP);
}
free(catPtr);
contentP = xmlrpc_struct_new(env);
xmlrpc_struct_set_value(env, contentP, "title", titleP);
xmlrpc_struct_set_value(env, contentP, "description", descriptionP);
xmlrpc_struct_set_value(env, contentP, "dateCreated", dateP);
xmlrpc_struct_set_value(env, contentP, "categories", categoryP);
/* Populate the Parameter Array */
*paramArray = xmlrpc_array_new(env);
if (mode == 0)
xmlrpc_array_append_item(env, *paramArray, blogidP);
else
xmlrpc_array_append_item(env, *paramArray, postidP);
xmlrpc_array_append_item(env, *paramArray, usernameP);
xmlrpc_array_append_item(env, *paramArray, passwordP);
xmlrpc_array_append_item(env, *paramArray, contentP);
xmlrpc_array_append_item(env, *paramArray, publishP);
out:
return retval;
}
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* 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);
}
// {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 xmlrpc_value *
convert_params(xmlrpc_env * const envP,
const xml_element * const elemP) {
/*----------------------------------------------------------------------------
Convert an XML element representing a list of parameters (i.e. a
<params> element) to an xmlrpc_value of type array. Note that an
array is normally represented in XML by a <value> element. We use
type xmlrpc_value to represent the parameter list just for convenience.
-----------------------------------------------------------------------------*/
xmlrpc_value *array, *item;
int size, i;
xml_element **params, *param, *value;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT(elemP != NULL);
/* Set up our error-handling preconditions. */
array = item = NULL;
/* Allocate an array to hold our parameters. */
array = xmlrpc_build_value(envP, "()");
XMLRPC_FAIL_IF_FAULT(envP);
/* We're responsible for checking our own element name. */
CHECK_NAME(envP, elemP, "params");
/* Iterate over our children. */
size = xml_element_children_size(elemP);
params = xml_element_children(elemP);
for (i = 0; i < size; ++i) {
unsigned int const maxNest = xmlrpc_limit_get(XMLRPC_NESTING_LIMIT_ID);
param = params[i];
CHECK_NAME(envP, param, "param");
CHECK_CHILD_COUNT(envP, param, 1);
value = xml_element_children(param)[0];
CHECK_NAME(envP, value, "value");
xmlrpc_parseValue(envP, maxNest, value, &item);
XMLRPC_FAIL_IF_FAULT(envP);
xmlrpc_array_append_item(envP, array, item);
xmlrpc_DECREF(item);
item = NULL;
XMLRPC_FAIL_IF_FAULT(envP);
}
cleanup:
if (envP->fault_occurred) {
if (array)
xmlrpc_DECREF(array);
if (item)
xmlrpc_DECREF(item);
return NULL;
}
return array;
}
/* vxdb.mount.get(string name[, string dst]) */
xmlrpc_value *m_vxdb_mount_get(xmlrpc_env *env, xmlrpc_value *p, void *c)
{
xmlrpc_value *params, *response = NULL;
char *name, *dst;
int rc;
xid_t xid;
params = method_init(env, p, c, VCD_CAP_MOUNT, M_OWNER);
method_return_if_fault(env);
xmlrpc_decompose_value(env, params,
"{s:s,s:s,*}",
"name", &name,
"dst", &dst);
method_return_if_fault(env);
method_empty_params(1, &dst);
if (dst && !validate_path(dst))
method_return_faultf(env, MEINVAL,
"invalid dst value: %s", dst);
if (!(xid = vxdb_getxid(name)))
method_return_fault(env, MENOVPS);
if (dst)
rc = vxdb_prepare(&dbr,
"SELECT src,dst,type,opts FROM mount "
"WHERE xid = %d AND dst = '%s'",
xid, dst);
else
rc = vxdb_prepare(&dbr,
"SELECT src,dst,type,opts FROM mount "
"WHERE xid = %d ORDER BY dst ASC",
xid);
if (rc != VXDB_OK)
method_return_vxdb_fault(env);
response = xmlrpc_array_new(env);
vxdb_foreach_step(rc, dbr)
xmlrpc_array_append_item(env, response, xmlrpc_build_value(env,
"{s:s,s:s,s:s,s:s}",
"src", vxdb_column_text(dbr, 0),
"dst", vxdb_column_text(dbr, 1),
"type", vxdb_column_text(dbr, 2),
"opts", vxdb_column_text(dbr, 3)));
if (rc != VXDB_DONE)
method_set_vxdb_fault(env);
vxdb_finalize(dbr);
return response;
}
void
value::appendToCArray(xmlrpc_value * const arrayP) const {
/*----------------------------------------------------------------------------
Append this value to the C array 'arrayP'.
----------------------------------------------------------------------------*/
env_wrap env;
xmlrpc_array_append_item(&env.env_c, arrayP, this->cValueP);
throwIfError(env);
}
// 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 xmlrpc_value *
system_multicall(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const callInfo) {
xmlrpc_registry * registryP;
xmlrpc_value * resultsP;
xmlrpc_value * methlistP;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_ARRAY_OK(paramArrayP);
XMLRPC_ASSERT_PTR_OK(serverInfo);
resultsP = NULL; /* defeat compiler warning */
/* Turn our arguments into something more useful. */
registryP = (xmlrpc_registry*) serverInfo;
getMethListFromMulticallPlist(envP, paramArrayP, &methlistP);
if (!envP->fault_occurred) {
/* Create an initially empty result list. */
resultsP = xmlrpc_array_new(envP);
if (!envP->fault_occurred) {
/* Loop over our input list, calling each method in turn. */
unsigned int const methodCount =
xmlrpc_array_size(envP, methlistP);
unsigned int i;
for (i = 0; i < methodCount && !envP->fault_occurred; ++i) {
xmlrpc_value * const methinfoP =
xmlrpc_array_get_item(envP, methlistP, i);
xmlrpc_value * resultP;
XMLRPC_ASSERT_ENV_OK(envP);
callOneMethod(envP, registryP, methinfoP, callInfo, &resultP);
if (!envP->fault_occurred) {
/* Append this method result to our master array. */
xmlrpc_array_append_item(envP, resultsP, resultP);
xmlrpc_DECREF(resultP);
}
}
if (envP->fault_occurred)
xmlrpc_DECREF(resultsP);
xmlrpc_DECREF(methlistP);
}
}
return resultsP;
}
static int recur_flush_response_array(xmlrpc_env * env, struct mi_node *tree,
str *buf)
{
struct mi_node *kid, *tmp;
int ret;
for(kid = tree->kids ; kid ; ) {
/* write the current kid */
if (!(kid->flags & MI_WRITTEN)) {
if (xr_write_node( buf, kid)!=0) {
LM_ERR("failed to write - line too long!\n");
return -1;
}
/* we are sure that this node has been written
* => avoid writing it again */
kid->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;
/* write the current kid's children */
if ((ret = recur_flush_response_array(env, kid, buf))<0)
return -1;
else if (ret > 0)
return ret;
if (!(kid->flags & MI_NOT_COMPLETED)) {
tmp = kid;
kid = kid->next;
tree->kids = kid;
if(!tmp->kids) {
/* this node does not have any kids */
free_mi_node(tmp);
}
}
else {
/* the node will have more kids => to keep the tree shape, do not
* flush any other node for now */
return 1;
}
}
return 0;
}
xmlrpc_value* GetParticipantStatistics(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId, &partId);
//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");
//Get statistics
MultiConf::ParticipantStatistics *partStats = conf->GetParticipantStatistic(partId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!partStats)
return xmlerror(env,"Participant not found\n");
//Create array
xmlrpc_value* arr = xmlrpc_array_new(env);
//Process result
for (MultiConf::ParticipantStatistics::iterator it = partStats->begin(); it!=partStats->end(); ++it)
{
//Get media
std::string media = it->first;
//Get stats
MediaStatistics stats = it->second;
//Create array
xmlrpc_value* val = xmlrpc_build_value(env,"(siiiiiii)",media.c_str(),stats.isReceiving,stats.isSending,stats.lostRecvPackets,stats.numRecvPackets,stats.numSendPackets,stats.totalRecvBytes,stats.totalSendBytes);
//Add it
xmlrpc_array_append_item(env,arr,val);
//Release
xmlrpc_DECREF(val);
}
//return
return xmlok(env,arr);
}
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 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 void
get_priv_cb (RCDPrivileges priv,
const char *priv_name,
gpointer user_data)
{
struct GetPrivInfo *info = user_data;
xmlrpc_value *value;
value = xmlrpc_build_value (info->env, "s", priv_name);
xmlrpc_array_append_item (info->env, info->array, value);
XMLRPC_FAIL_IF_FAULT (info->env);
cleanup:
xmlrpc_DECREF (value);
}
bool ArchiveDataClient::getValues(int key, stdVector<stdString> &names,
const epicsTime &start, const epicsTime &end,
int count, int how,
value_callback callback, void *callback_arg)
{
xmlrpc_value *name_array, *result, *element;
size_t n;
name_array = xmlrpc_build_value(&env, "()");
if (log_fault())
return false;
for (n=0; n<names.size(); ++n)
{
element = xmlrpc_build_value(&env, "s", names[n].c_str());
if (log_fault())
return false;
xmlrpc_array_append_item(&env, name_array, element);
if (log_fault())
return false;
xmlrpc_DECREF(element);
}
xmlrpc_int32 start_sec, start_nano, end_sec, end_nano;
epicsTime2pieces(start, start_sec, start_nano);
epicsTime2pieces(end, end_sec, end_nano);
result = xmlrpc_client_call(&env, (char *)URL,
"archiver.values", "(iViiiiii)",
(xmlrpc_int32)key, name_array,
start_sec, start_nano, end_sec, end_nano,
(xmlrpc_int32)count, (xmlrpc_int32)how);
if (log_fault())
return false;
xmlrpc_DECREF(name_array);
size_t channel_count = xmlrpc_array_size(&env, result);
xmlrpc_value *channel_result;
for (n=0; n<channel_count; ++n)
{
channel_result = xmlrpc_array_get_item(&env, result, n);
if (log_fault())
return false;
if (!decode_channel(channel_result, n, callback, callback_arg))
return false;
}
xmlrpc_DECREF(result);
return true;
}
// "visitor" for BinaryTree of channel names
static void add_name_to_result(const ChannelInfo &info, void *arg)
{
UserArg *user_arg = (UserArg *)arg;
xmlrpc_int32 ss, sn, es, en;
epicsTime2pieces(info.start, ss, sn);
epicsTime2pieces(info.end, es, en);
LOG_MSG("Found name '%s'\n", info.name.c_str());
AutoXmlRpcValue channel(xmlrpc_build_value(
user_arg->env,
"{s:s,s:i,s:i,s:i,s:i}",
"name", info.name.c_str(),
"start_sec", ss, "start_nano", sn,
"end_sec", es, "end_nano", en));
if (user_arg->env->fault_occurred)
return;
xmlrpc_array_append_item(user_arg->env, user_arg->result, channel);
}
static void
add_mirror_cb (RCDMirror *mirror, gpointer user_data)
{
struct GetAllInfo *info = user_data;
xmlrpc_value *mirror_value;
if (info->failed)
return;
mirror_value = rcd_mirror_to_xmlrpc (mirror, info->env);
if (mirror_value) {
xmlrpc_array_append_item (info->env, info->array, mirror_value);
xmlrpc_DECREF (mirror_value);
return;
}
/* Fall through on error */
info->failed = TRUE;
}
static void
test_value_array(void) {
xmlrpc_value *v;
xmlrpc_env env;
size_t len;
xmlrpc_value * itemP;
/* Basic array-building test. */
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_ARRAY), "ARRAY"));
v = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v));
len = xmlrpc_array_size(&env, v);
TEST_NO_FAULT(&env);
TEST(len == 0);
itemP = xmlrpc_int_new(&env, 7);
TEST_NO_FAULT(&env);
xmlrpc_array_append_item(&env, v, itemP);
TEST_NO_FAULT(&env);
len = xmlrpc_array_size(&env, v);
TEST_NO_FAULT(&env);
TEST(len == 1);
xmlrpc_DECREF(itemP);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "()");
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v));
len = xmlrpc_array_size(&env, v);
TEST_NO_FAULT(&env);
TEST(len == 0);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
xmlrpc_value *xmlrpccmd_core_get_log(xmlrpc_env * const envP, xmlrpc_value * const paramArrayP, void * const userData) {
uint32_t last_id;
xmlrpc_decompose_value(envP, paramArrayP, "(i)", &last_id);
if (envP->fault_occurred)
return NULL;
xmlrpc_value *res = xmlrpc_array_new(envP);
if (envP->fault_occurred)
return NULL;
pomlog_rlock();
struct pomlog_entry *log = pomlog_get_tail();
if (log->id <= last_id) {
pomlog_unlock();
return res;
}
while (log && log->id > last_id + 1)
log = log->prev;
while (log) {
xmlrpc_value *entry = xmlrpc_build_value(envP, "{s:i,s:i,s:s,s:s}",
"id", log->id,
"level", log->level,
"file", log->file,
"data", log->data);
xmlrpc_array_append_item(envP, res, entry);
xmlrpc_DECREF(entry);
log = log->next;
}
pomlog_unlock();
return res;
}
static int recur_build_response_array( xmlrpc_env * env, struct mi_node * tree, str * buf )
{
for ( ; tree ; tree = tree->next ) {
if ( xr_write_node( buf, tree ) != 0 ) {
LM_ERR("failed to get MI node data!\n");
return -1;
}
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;
}
static void
parseArrayDataChild(xmlrpc_env * const envP,
xml_element * const childP,
unsigned int const maxRecursion,
xmlrpc_value * const arrayP) {
const char * const elemName = xml_element_name(childP);
if (!xmlrpc_streq(elemName, "value"))
setParseFault(envP, "<data> element has <%s> child. "
"Only <value> makes sense.", elemName);
else {
xmlrpc_value * itemP;
xmlrpc_parseValue(envP, maxRecursion-1, childP, &itemP);
if (!envP->fault_occurred) {
xmlrpc_array_append_item(envP, arrayP, itemP);
xmlrpc_DECREF(itemP);
}
}
}
static void
get_all_cb (RCDIdentity *id,
gpointer user_data)
{
struct GetAllInfo *info = user_data;
char *auth_str;
xmlrpc_value *value;
auth_str = rcd_privileges_to_string (id->privileges);
value = xmlrpc_build_value (info->env,
"(ss)",
id->username,
auth_str);
g_free (auth_str);
xmlrpc_array_append_item (info->env, info->array, value);
XMLRPC_FAIL_IF_FAULT (info->env);
cleanup:
xmlrpc_DECREF (value);
}
static void
createMethodListArray(xmlrpc_env * const envP,
xmlrpc_registry * const registryP,
xmlrpc_value ** const methodListPP) {
/*----------------------------------------------------------------------------
Create as an XML-RPC array value a list of names of methods registered
in registry 'registryP'.
This is the type of value that the system.listMethods method is supposed
to return.
-----------------------------------------------------------------------------*/
xmlrpc_value * methodListP;
methodListP = xmlrpc_array_new(envP);
if (!envP->fault_occurred) {
xmlrpc_methodNode * methodNodeP;
for (methodNodeP = registryP->methodListP->firstMethodP;
methodNodeP && !envP->fault_occurred;
methodNodeP = methodNodeP->nextP) {
xmlrpc_value * methodNameVP;
methodNameVP = xmlrpc_string_new(envP, methodNodeP->methodName);
if (!envP->fault_occurred) {
xmlrpc_array_append_item(envP, methodListP, methodNameVP);
xmlrpc_DECREF(methodNameVP);
}
}
if (envP->fault_occurred)
xmlrpc_DECREF(methodListP);
}
*methodListPP = methodListP;
}
static xmlrpc_value * method_get_reports(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
int has_more;
xmlrpc_value *ret = 0, *item = 0;
UNUSED_ARGUMENT(param_array);
UNUSED_ARGUMENT(user_data);
DEBUG_MSG(LOG_NOTICE, "Method get_reports called");
struct _report *report = get_reports(&has_more);
ret = xmlrpc_array_new(env);
/* Add information if there's more reports pending */
item = xmlrpc_int_new(env, has_more);
xmlrpc_array_append_item(env, ret, item);
xmlrpc_DECREF(item);
while (report) {
xmlrpc_value *rv = xmlrpc_build_value(env,
"("
"{s:i,s:i,s:i,s:i,s:i,s:i}" /* timeval */
"{s:i,s:i,s:i,s:i}" /* bytes */
"{s:i,s:i,s:i,s:i}" /* block counts */
"{s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d}" /* RTT, IAT, Delay */
"{s:i,s:i}" /* MTU */
"{s:i,s:i,s:i,s:i,s:i}" /* TCP info */
"{s:i,s:i,s:i,s:i,s:i}" /* ... */
"{s:i,s:i,s:i,s:i,s:i}" /* ... */
"{s:i}"
")",
"id", report->id,
"type", report->type,
"begin_tv_sec", (int)report->begin.tv_sec,
"begin_tv_nsec", (int)report->begin.tv_nsec,
"end_tv_sec", (int)report->end.tv_sec,
"end_tv_nsec", (int)report->end.tv_nsec,
"bytes_read_high", (int32_t)(report->bytes_read >> 32),
"bytes_read_low", (int32_t)(report->bytes_read & 0xFFFFFFFF),
"bytes_written_high", (int32_t)(report->bytes_written >> 32),
"bytes_written_low", (int32_t)(report->bytes_written & 0xFFFFFFFF),
"request_blocks_read", report->request_blocks_read,
"request_blocks_written", report->request_blocks_written,
"response_blocks_read", report->response_blocks_read,
"response_blocks_written", report->response_blocks_written,
"rtt_min", report->rtt_min,
"rtt_max", report->rtt_max,
"rtt_sum", report->rtt_sum,
"iat_min", report->iat_min,
"iat_max", report->iat_max,
"iat_sum", report->iat_sum,
"delay_min", report->delay_min,
"delay_max", report->delay_max,
"delay_sum", report->delay_sum,
"pmtu", report->pmtu,
"imtu", report->imtu,
/* Currently, not all members of the TCP_INFO socket option are used by the
* FreeBSD kernel. Other members will contain zeroes */
"tcpi_snd_cwnd", (int)report->tcp_info.tcpi_snd_cwnd,
"tcpi_snd_ssthresh", (int)report->tcp_info.tcpi_snd_ssthresh,
"tcpi_unacked", (int)report->tcp_info.tcpi_unacked,
"tcpi_sacked", (int)report->tcp_info.tcpi_sacked,
"tcpi_lost", (int)report->tcp_info.tcpi_lost,
"tcpi_retrans", (int)report->tcp_info.tcpi_retrans,
"tcpi_retransmits", (int)report->tcp_info.tcpi_retransmits,
"tcpi_fackets", (int)report->tcp_info.tcpi_fackets,
"tcpi_reordering", (int)report->tcp_info.tcpi_reordering,
"tcpi_rtt", (int)report->tcp_info.tcpi_rtt,
"tcpi_rttvar", (int)report->tcp_info.tcpi_rttvar,
"tcpi_rto", (int)report->tcp_info.tcpi_rto,
"tcpi_backoff", (int)report->tcp_info.tcpi_backoff,
"tcpi_ca_state", (int)report->tcp_info.tcpi_ca_state,
"tcpi_snd_mss", (int)report->tcp_info.tcpi_snd_mss,
"status", report->status
);
xmlrpc_array_append_item(env, ret, rv);
xmlrpc_DECREF(rv);
struct _report *next = report->next;
free(report);
report = next;
}
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method get_reports failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method get_reports successful");
}
return ret;
}
// { int32 ver, string desc } = archiver.info()
xmlrpc_value *get_info(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
LOG_MSG("archiver.info\n");
#endif
int i;
const char *config = get_config_name(env);
if (!config)
return 0;
#ifdef LOGFILE
LOG_MSG("config: '%s'\n", config);
#endif
char description[500];
sprintf(description,
"Channel Archiver Data Server V%d,\n"
"for " EPICS_VERSION_STRING ",\n"
"built " __DATE__ ", " __TIME__ "\n"
"from sources for version " ARCH_VERSION_TXT "\n"
"Config: '%s'\n",
ARCH_VER, config);
AutoXmlRpcValue how(xmlrpc_build_value(env, "(sssss)",
"raw",
"spreadsheet",
"average",
"plot-binning",
"linear"));
if (env->fault_occurred)
return 0;
// 'status': array of all status string.
AutoXmlRpcValue element;
AutoXmlRpcValue status(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
for (i=0; i<=lastEpicsAlarmCond; ++i)
{
element = xmlrpc_build_value(env, "s", epicsAlarmConditionStrings[i]);
xmlrpc_array_append_item(env, status, element);
if (env->fault_occurred)
return 0;
}
// 'severity': array of all severity strings.
AutoXmlRpcValue severity(xmlrpc_build_value(env, "()"));
for (i=0; i<=lastEpicsAlarmSev; ++i)
{
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)i,
"sevr", epicsAlarmSeverityStrings[i],
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
if (env->fault_occurred)
return 0;
}
// ... including the archive-specific ones.
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_EST_REPEAT,
"sevr", "Est_Repeat",
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 0);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_REPEAT,
"sevr", "Repeat",
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 0);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_DISCONNECT,
"sevr", "Disconnected",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_STOPPED,
"sevr", "Archive_Off",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_DISABLED,
"sevr", "Archive_Disabled",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
// Overall result.
return xmlrpc_build_value(env, "{s:i,s:s,s:V,s:V,s:V}",
"ver", ARCH_VER,
"desc", description,
"how", how.get(),
"stat", status.get(),
"sevr", severity.get());
}
// Return the data for all the names[], start .. end etc.
// as get_values() is supposed to return them.
//
// Returns raw values if interpol <= 0.0.
// Returns 0 on error.
xmlrpc_value *get_sheet_data(xmlrpc_env *env,
int key,
const stdVector<stdString> names,
const epicsTime &start, const epicsTime &end,
long count,
ReaderFactory::How how, double delta)
{
try
{
#ifdef LOGFILE
stdString txt;
LOG_MSG("get_sheet_data\n");
LOG_MSG("Start : %s\n", epicsTimeTxt(start, txt));
LOG_MSG("End : %s\n", epicsTimeTxt(end, txt));
LOG_MSG("Method: %s\n", ReaderFactory::toString(how, delta));
#endif
AutoPtr<Index> index(open_index(env, key));
if (env->fault_occurred)
return 0;
AutoPtr<SpreadsheetReader> sheet(new SpreadsheetReader(*index, how, delta));
AutoXmlRpcValue results(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
long name_count = names.size();
AutoArrayPtr<AutoXmlRpcValue> meta (new AutoXmlRpcValue[name_count]);
AutoArrayPtr<AutoXmlRpcValue> values (new AutoXmlRpcValue[name_count]);
AutoArrayPtr<xmlrpc_int32> xml_type (new xmlrpc_int32[name_count]);
AutoArrayPtr<xmlrpc_int32> xml_count(new xmlrpc_int32[name_count]);
AutoArrayPtr<size_t> ch_vals (new size_t[name_count]);
bool ok = sheet->find(names, &start);
long i;
// Per-channel meta-info.
for (i=0; i<name_count; ++i)
{
#ifdef LOGFILE
LOG_MSG("Handling '%s'\n", names[i].c_str());
#endif
ch_vals[i] = 0;
values[i] = xmlrpc_build_value(env, "()");
if (env->fault_occurred)
return 0;
if (sheet->found(i))
{ // Fix meta/type/count based on first value
meta[i] = encode_ctrl_info(env, &sheet->getInfo(i));
dbr_type_to_xml_type(sheet->getType(i), sheet->getCount(i),
xml_type[i], xml_count[i]);
#if 0
LOG_MSG("Ch %lu: type, count = %d, %d\n", i, (int)xml_type[i], (int)xml_count[i]);
#endif
}
else
{ // Channel exists, but has no data
meta[i] = encode_ctrl_info(env, 0);
xml_type[i] = XML_ENUM;
xml_count[i] = 1;
}
}
// Collect values
long num_vals = 0;
while (ok && num_vals < count && sheet->getTime() < end)
{
for (i=0; i<name_count; ++i)
{
if (sheet->get(i))
{
++ch_vals[i];
encode_value(env,
sheet->getType(i), sheet->getCount(i),
sheet->getTime(), sheet->get(i),
xml_type[i], xml_count[i], values[i]);
}
else
{ // Encode as no value, but one of them ;-)
// to avoid confusion w/ viewers that like to see some data in any case.
encode_value(env, 0, 1, sheet->getTime(), 0,
xml_type[i], xml_count[i], values[i]);
}
}
++num_vals;
ok = sheet->next();
}
// Assemble result = { name, meta, type, count, values }
for (i=0; i<name_count; ++i)
{
AutoXmlRpcValue result(
xmlrpc_build_value(env, "{s:s,s:V,s:i,s:i,s:V}",
"name", names[i].c_str(),
"meta", meta[i].get(),
"type", xml_type[i],
"count", xml_count[i],
"values", values[i].get()));
// Add to result array
xmlrpc_array_append_item(env, results, result);
#ifdef LOGFILE
LOG_MSG("Ch %lu: %zu values\n", i, ch_vals[i]);
#endif
}
#ifdef LOGFILE
LOG_MSG("%ld values total\n", num_vals);
#endif
return results.release();
}
catch (GenericException &e)
{
#ifdef LOGFILE
LOG_MSG("Error:\n%s\n", e.what());
#endif
xmlrpc_env_set_fault_formatted(env, ARCH_DAT_DATA_ERROR,
"%s", e.what());
}
return 0;
}
// Return the data for all the names[], start .. end etc.
// as get_values() is supposed to return them.
// Returns 0 on error.
xmlrpc_value *get_channel_data(xmlrpc_env *env,
int key,
const stdVector<stdString> names,
const epicsTime &start, const epicsTime &end,
long count,
ReaderFactory::How how, double delta)
{
AutoXmlRpcValue results;
try
{
#ifdef LOGFILE
stdString txt;
LOG_MSG("get_channel_data\n");
LOG_MSG("Method: %s\n", ReaderFactory::toString(how, delta));
LOG_MSG("Start: %s\n", epicsTimeTxt(start, txt));
LOG_MSG("End : %s\n", epicsTimeTxt(end, txt));
#endif
AutoPtr<Index> index(open_index(env, key));
if (env->fault_occurred)
return 0;
AutoPtr<DataReader> reader(ReaderFactory::create(*index, how, delta));
results = xmlrpc_build_value(env, "()");
if (env->fault_occurred)
return 0;
long i, name_count = names.size();
for (i=0; i<name_count; ++i)
{
#ifdef LOGFILE
LOG_MSG("Handling '%s'\n", names[i].c_str());
#endif
long num_vals = 0;
AutoXmlRpcValue values(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
const RawValue::Data *data = reader->find(names[i], &start);
AutoXmlRpcValue meta;
xmlrpc_int32 xml_type, xml_count;
if (data == 0)
{ // No exception from file error etc., just no data.
meta = encode_ctrl_info(env, 0);
xml_type = XML_ENUM;
xml_count = 1;
}
else
{
// Fix meta/type/count based on first value
meta = encode_ctrl_info(env, &reader->getInfo());
dbr_type_to_xml_type(reader->getType(), reader->getCount(),
xml_type, xml_count);
while (num_vals < count
&& data
&& RawValue::getTime(data) < end)
{
encode_value(env, reader->getType(), reader->getCount(),
RawValue::getTime(data), data,
xml_type, xml_count, values);
++num_vals;
data = reader->next();
}
}
// Assemble result = { name, meta, type, count, values }
AutoXmlRpcValue result(xmlrpc_build_value(
env, "{s:s,s:V,s:i,s:i,s:V}",
"name", names[i].c_str(),
"meta", (xmlrpc_value *)meta,
"type", xml_type,
"count", xml_count,
"values", (xmlrpc_value *)values));
// Add to result array
xmlrpc_array_append_item(env, results, result);
#ifdef LOGFILE
LOG_MSG("%ld values\n", num_vals);
#endif
} // for ( .. name .. )
}
catch (GenericException &e)
{
#ifdef LOGFILE
LOG_MSG("Error:\n%s\n", e.what());
#endif
xmlrpc_env_set_fault_formatted(env, ARCH_DAT_DATA_ERROR,
"%s", e.what());
return 0;
}
return results.release();
}
// Given a raw sample dbr_type/count/time/data,
// map it onto xml_type/count and add to values.
// Handles the special case data == 0,
// which happens for undefined cells in a SpreadsheetReader.
void encode_value(xmlrpc_env *env,
DbrType dbr_type, DbrCount dbr_count,
const epicsTime &time, const RawValue::Data *data,
xmlrpc_int32 xml_type, xmlrpc_int32 xml_count,
xmlrpc_value *values)
{
if (xml_count > dbr_count)
xml_count = dbr_count;
AutoXmlRpcValue val_array(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return;
int i;
switch (xml_type)
{
case XML_STRING:
{
stdString txt;
if (data)
RawValue::getValueString(txt, dbr_type, dbr_count, data, 0);
AutoXmlRpcValue element(xmlrpc_build_value(env, "s#",
txt.c_str(), txt.length()));
xmlrpc_array_append_item(env, val_array, element);
}
break;
case XML_INT:
case XML_ENUM:
{
long l;
for (i=0; i < xml_count; ++i)
{
if (!data ||
!RawValue::getLong(dbr_type, dbr_count, data, l, i))
l = 0;
AutoXmlRpcValue element(xmlrpc_build_value(env, "i", (xmlrpc_int32)l));
xmlrpc_array_append_item(env, val_array, element);
}
}
break;
case XML_DOUBLE:
{
double d;
for (i=0; i < xml_count; ++i)
{
if (data &&
RawValue::getDouble(dbr_type, dbr_count, data, d, i))
{ /* XML-RPC, being XML, sends all numbers as strings.
* Unfortunately, XML-RPC also insists in the simple 'dot'
* notation and prohibits exponential notation.
* A number like 1e-300 would turn into
* "0.0000000..." with 300 zeroes,
* which is too long for the internal print buffer of
* the xml-rpc C library.
* Since such huge and tiny numbers can't be transferred,
* they are replaced by 0 with stat/sevr UDF/INVALID.
*
* The cut-off point is somewhat arbitrary.
* The XML-RPC library uses an internal print buffer
* of about 120 characters.
* Since PVs are usually scaled to be human-readable,
* with only vacuum readings using exp. notation for
* data like "1e-8 Torr", exponents of +-50 seemed
* reasonable.
*/
if (d > 0.0)
{
if (d < 1e-50 || d > 1e50) { d = 0.0; data = 0; }
}
else if (d < 0.0)
{
if (d > -1e-50 || d < -1e50) { d = 0.0; data = 0; }
}
}
else
d = 0.0;
AutoXmlRpcValue element(xmlrpc_build_value(env, "d", d));
xmlrpc_array_append_item(env, val_array, element);
}
}
}
xmlrpc_int32 secs, nano;
epicsTime2pieces(time, secs, nano);
AutoXmlRpcValue value;
if (data)
value.set(xmlrpc_build_value(
env, "{s:i,s:i,s:i,s:i,s:V}",
"stat", (xmlrpc_int32)RawValue::getStat(data),
"sevr", (xmlrpc_int32)RawValue::getSevr(data),
"secs", secs,
"nano", nano,
"value", (xmlrpc_value *)val_array));
else
value.set(xmlrpc_build_value(
env, "{s:i,s:i,s:i,s:i,s:V}",
"stat", (xmlrpc_int32)UDF_ALARM,
"sevr", (xmlrpc_int32)INVALID_ALARM,
"secs", secs,
"nano", nano,
"value", (xmlrpc_value *)val_array));
xmlrpc_array_append_item(env, values, value);
}
