static void
getMethListFromMulticallPlist(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
xmlrpc_value ** const methlistPP) {
if (xmlrpc_array_size(envP, paramArrayP) != 1)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_PARSE_ERROR,
"system.multicall takes one parameter, which is an "
"array, each element describing one RPC. You "
"supplied %u arguments",
xmlrpc_array_size(envP, paramArrayP));
else {
xmlrpc_value * methlistP;
xmlrpc_array_read_item(envP, paramArrayP, 0, &methlistP);
XMLRPC_ASSERT_ENV_OK(envP);
if (xmlrpc_value_type(methlistP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR,
"system.multicall's parameter should be an array, "
"each element describing one RPC. But it is type "
"%u instead.", xmlrpc_value_type(methlistP));
else
*methlistPP = methlistP;
if (envP->fault_occurred)
xmlrpc_DECREF(methlistP);
}
}
static void
test_value_array(void) {
xmlrpc_value *v;
xmlrpc_env env;
size_t len;
/* Basic array-building test. */
xmlrpc_env_init(&env);
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);
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);
}
bool ArchiveDataClient::getArchives(stdVector<ArchiveInfo> &archives)
{
xmlrpc_value *result, *element;
xmlrpc_int32 key;
const char *name, *path;
size_t count, i, n_len, p_len;
ArchiveInfo info;
result = xmlrpc_client_call(&env, (char *)URL, "archiver.archives", "()");
if (log_fault())
return false;
count = xmlrpc_array_size(&env, result);
archives.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, result, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "{s:i,s:s#,s:s#,*}",
"key", &key,
"name", &name, &n_len,
"path", &path, &p_len);
if (log_fault())
return false;
info.key = key;
info.name.assign(name, n_len);
info.path.assign(path, p_len);
archives.push_back(info);
}
xmlrpc_DECREF(result);
return true;
}
void cmd_list(xmlrpc_env *env, int argc, char **argv)
{
xmlrpc_value *response, *result;
char *username;
int len, i;
if (argc > 0)
username = argv[0];
else
username = "";
response = client_call("vxdb.list",
"{s:s}",
"username", username);
return_if_fault(env);
len = xmlrpc_array_size(env, response);
return_if_fault(env);
for (i = 0; i < len; i++) {
xmlrpc_array_read_item(env, response, i, &result);
return_if_fault(env);
xmlrpc_decompose_value(env, result, "s", &username);
return_if_fault(env);
xmlrpc_DECREF(result);
printf("%s\n", username);
}
xmlrpc_DECREF(response);
}
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);
}
void cmd_vx_bcaps_get(xmlrpc_env *env, int argc, char **argv)
{
xmlrpc_value *response, *result;
char *name, *bcap;
int len, i;
if (argc < 1)
usage(EXIT_FAILURE);
name = argv[0];
response = client_call("vxdb.vx.bcaps.get",
"{s:s}",
"name", name);
return_if_fault(env);
len = xmlrpc_array_size(env, response);
return_if_fault(env);
for (i = 0; i < len; i++) {
xmlrpc_array_read_item(env, response, i, &result);
return_if_fault(env);
xmlrpc_decompose_value(env, result, "s", &bcap);
return_if_fault(env);
xmlrpc_DECREF(result);
printf("%s\n", bcap);
}
xmlrpc_DECREF(response);
}
bool ArchiveDataClient::getNames(int key, const stdString &pattern,
stdVector<NameInfo> &names)
{
xmlrpc_value *result, *element;
const char *name;
xmlrpc_int32 start_sec, start_nano, end_sec, end_nano;
size_t count, i, len;
NameInfo info;
result = xmlrpc_client_call(&env, (char *)URL, "archiver.names", "(is)",
(xmlrpc_int32) key, pattern.c_str());
if (log_fault())
return false;
count = xmlrpc_array_size(&env, result);
names.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, result, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "{s:s#,s:i,s:i,s:i,s:i,*}",
"name", &name, &len,
"start_sec", &start_sec,
"start_nano", &start_nano,
"end_sec", &end_sec,
"end_nano", &end_nano);
if (log_fault())
return false;
info.name.assign(name, len);
pieces2epicsTime(start_sec, start_nano, info.start);
pieces2epicsTime(end_sec, end_nano, info.end);
names.push_back(info);
}
xmlrpc_DECREF(result);
return true;
}
static void getRecentPosts( const char *host, const char *username, const char *password )
{
xmlrpc_env env;
xmlrpc_value * resultP = NULL; // array item
xmlrpc_value * firstElementP = NULL; // first element in array
xmlrpc_value * varP = NULL;
const char * postResult = NULL;
int arrsize;
xmlrpc_client_init( XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION );
xmlrpc_env_init( &env );
resultP = xmlrpc_client_call( &env, host,
"blogger.getRecentPosts",
"(ssssi)",
"", /* key, not used */
username, /* journal unique name */
username, /* journal username */
password, /* journal password */
RECENT_POST_COUNT ); /* post count */
die_if_fault_occurred( &env );
arrsize = xmlrpc_array_size( &env, resultP );
die_if_fault_occurred( &env );
//fprintf( stderr, "Array size %d\n", arrsize );
for (int i = 0; i < arrsize; i++ )
{
xmlrpc_array_read_item( &env, resultP, i, &firstElementP);
xmlrpc_struct_find_value( &env, firstElementP, "title", &varP);
if (varP)
{
xmlrpc_read_string( &env, varP, &postResult);
printf( "%d %s\n\n", i, postResult );
free((char *)postResult);
xmlrpc_DECREF( varP );
}
die_if_fault_occurred( &env );
xmlrpc_struct_find_value( &env, firstElementP, "content", &varP);
if (varP)
{
xmlrpc_read_string( &env, varP, &postResult);
printf( "%s\n\n", postResult );
free((char *)postResult);
xmlrpc_DECREF( varP );
}
die_if_fault_occurred( &env );
xmlrpc_DECREF( firstElementP );
}
xmlrpc_DECREF( resultP );
xmlrpc_env_clean( &env );
xmlrpc_client_cleanup();
}
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);
}
size_t
value_array::size() const {
env_wrap env;
unsigned int arraySize;
arraySize = xmlrpc_array_size(&env.env_c, this->cValueP);
throwIfError(env);
return arraySize;
}
static void
test_value_array_nil(void) {
xmlrpc_value * arrayP;
xmlrpc_env env;
xmlrpc_int32 i1, i2;
xmlrpc_value * itemP;
size_t len;
xmlrpc_env_init(&env);
arrayP = xmlrpc_build_value(&env, "(nini)",
(xmlrpc_int32) 10, (xmlrpc_int32) 20);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
len = xmlrpc_array_size(&env, arrayP);
TEST_NO_FAULT(&env);
TEST(len == 4);
itemP = xmlrpc_array_get_item(&env, arrayP, 0);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "n");
TEST_NO_FAULT(&env);
itemP = xmlrpc_array_get_item(&env, arrayP, 1);
TEST_NO_FAULT(&env);
{
int i;
xmlrpc_decompose_value(&env, itemP, "i", &i);
TEST_NO_FAULT(&env);
TEST(i == 10);
}
xmlrpc_decompose_value(&env, arrayP, "(nini)", &i1, &i2);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20);
/* Test bounds check on xmlrpc_array_get_item. */
xmlrpc_array_read_item(&env, arrayP, 4, &itemP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_array_get_item(&env, arrayP, 4);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_DECREF(arrayP);
xmlrpc_env_clean(&env);
}
const char* extract_result (xmlrpc_env *env , xmlrpc_value *temp)
{
xmlrpc_value * arrayP;
xmlrpc_decompose_value(env, temp, "(A)", &arrayP);
size_t size = xmlrpc_array_size(env, arrayP);
xmlrpc_value * strctP;
strctP = xmlrpc_array_get_item(env, arrayP, 0);
const char *primeResult = (const char *)malloc (256);
size_t str1_len;
xmlrpc_read_string_lp(env, strctP, &str1_len, &primeResult);
return primeResult;
}
/* The only way this can fail is if arrayP is not actually an array XML-RPC
* value. So it is usually not worth checking *envP.
* die or return size of array
*/
unsigned rhbz_array_size(xmlrpc_value *xml)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
unsigned size = xmlrpc_array_size(&env, xml);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
return size;
}
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;
}
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;
}
void
clientSimple::call(string const serverUrl,
string const methodName,
string const format,
value * const resultP,
...) {
carriageParm_http0 carriageParm(serverUrl);
env_wrap env;
xmlrpc_value * paramArrayP;
va_list args;
va_start(args, resultP);
makeParamArray(format, ¶mArrayP, args);
va_end(args);
if (env.env_c.fault_occurred)
throw(error(env.env_c.fault_string));
else {
cValueWrapper paramArrayWrapper(paramArrayP); // ensure destruction
unsigned int const paramCount(
xmlrpc_array_size(&env.env_c, paramArrayP));
if (env.env_c.fault_occurred)
throw(error(env.env_c.fault_string));
paramList paramList;
for (unsigned int i = 0; i < paramCount; ++i) {
xmlrpc_value * paramP;
xmlrpc_array_read_item(&env.env_c, paramArrayP, i, ¶mP);
if (env.env_c.fault_occurred)
throw(error(env.env_c.fault_string));
else {
cValueWrapper paramWrapper(paramP); // ensure destruction
paramList.add(value(paramP));
}
}
rpcPtr rpcPtr(methodName, paramList);
rpcPtr->call(this->clientP.get(), &carriageParm);
*resultP = rpcPtr->getResult();
}
}
static void
parseParamsElement(xmlrpc_env * const envP,
const xml_element * const paramsElementP,
xmlrpc_value ** const resultPP) {
xmlrpc_value * paramsVP;
xmlrpc_env env;
xmlrpc_env_init(&env);
XMLRPC_ASSERT(xmlrpc_streq(xml_element_name(paramsElementP), "params"));
paramsVP = convertParams(envP, paramsElementP);
if (!envP->fault_occurred) {
int arraySize;
xmlrpc_env sizeEnv;
XMLRPC_ASSERT_ARRAY_OK(paramsVP);
xmlrpc_env_init(&sizeEnv);
arraySize = xmlrpc_array_size(&sizeEnv, paramsVP);
/* Since it's a valid array, as asserted above, can't fail */
XMLRPC_ASSERT(!sizeEnv.fault_occurred);
if (arraySize != 1)
setParseFault(envP, "Contains %d items. It should have 1.",
arraySize);
else {
xmlrpc_array_read_item(envP, paramsVP, 0, resultPP);
}
xmlrpc_DECREF(paramsVP);
xmlrpc_env_clean(&sizeEnv);
}
if (env.fault_occurred)
xmlrpc_env_set_fault_formatted(
envP, env.fault_code,
"Invalid <params> element. %s", env.fault_string);
xmlrpc_env_clean(&env);
}
char *
wpGetBlogId(char *username, char *password, char *url) {
char *blogid;
int i;
int noOfBlogs;
xmlrpc_env env;
xmlrpc_client *clientP;
char *methodName = "wp.getUsersBlogs";
xmlrpc_value *result, *result2;
wp_env_init(&env, &clientP);
/* Make the remote procedure call */
xmlrpc_client_call2f(&env, clientP, url, methodName, &result,
"(ss)", username, password);
die_if_fault_occurred(&env);
noOfBlogs = xmlrpc_array_size(&env, result);
if ( noOfBlogs > 1 ) {
fprintf(stderr, "Currently only single blog wp accounts are supported\n");
blogid = NULL;
goto out;
}
for(i = 0; i < noOfBlogs; i++) {
xmlrpc_value *blog_id_xml;
xmlrpc_array_read_item(&env, result, i, &result2);
xmlrpc_struct_read_value(&env, result2, "blogid", &blog_id_xml);
xmlrpc_read_string(&env, blog_id_xml,(const char **) &blogid);
xmlrpc_DECREF(blog_id_xml);
}
/* Dispose of our result value. */
xmlrpc_DECREF(result2);
out:
xmlrpc_DECREF(result);
/* Clean up our error-handling environment. */
wp_env_clean(&env, &clientP);
return blogid;
}
vector<xmlrpc_c::value>
value_array::vectorValueValue() const {
this->validateInstantiated();
env_wrap env;
unsigned int arraySize;
arraySize = xmlrpc_array_size(&env.env_c, this->cValueP);
throwIfError(env);
vector<xmlrpc_c::value> retval(arraySize);
for (unsigned int i = 0; i < arraySize; ++i) {
class cWrapper {
public:
xmlrpc_value *valueP;
cWrapper(xmlrpc_value *const arrayP,
unsigned int const index) {
env_wrap env;
xmlrpc_array_read_item(&env.env_c, arrayP, index, &valueP);
throwIfError(env);
}
~cWrapper() {
xmlrpc_DECREF(valueP);
}
};
cWrapper wrapper(this->cValueP, i);
retval[i].instantiate(wrapper.valueP);
}
return retval;
}
static void
validateArraySize(xmlrpc_env * const envP,
const xmlrpc_value * const arrayP,
struct arrayDecomp const arrayDecomp) {
unsigned int size;
size = xmlrpc_array_size(envP, arrayP);
if (!envP->fault_occurred) {
if (arrayDecomp.itemCnt > size)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_INDEX_ERROR,
"Format string requests %u items from array, but array "
"has only %u items.", arrayDecomp.itemCnt, size);
else if (arrayDecomp.itemCnt < size && !arrayDecomp.ignoreExcess)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_INDEX_ERROR,
"Format string requests exactly %u items from array, "
"but array has %u items. (A '*' at the end would avoid "
"this failure)", arrayDecomp.itemCnt, size);
}
}
static xmlrpc_value * add_flow_destination(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc, i;
xmlrpc_value *ret = 0;
char* cc_alg = 0;
char* bind_address = 0;
xmlrpc_value* extra_options = 0;
struct _flow_settings settings;
struct _request_add_flow_destination* request = 0;
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array,
"("
"{s:s,*}"
"{s:d,s:d,s:d,s:d,s:d,*}"
"{s:i,s:i,*}"
"{s:i,*}"
"{s:b,s:b,s:b,s:b,s:b,*}"
"{s:i,s:i,*}"
"{s:i,s:d,s:d,*}" /* request */
"{s:i,s:d,s:d,*}" /* response */
"{s:i,s:d,s:d,*}" /* interpacket_gap */
"{s:b,s:b,s:i,s:i,*}"
"{s:s,*}"
"{s:i,s:i,s:i,s:i,s:i,*}"
#ifdef HAVE_LIBPCAP
"{s:s,*}"
#endif /* HAVE_LIBPCAP */
"{s:i,s:A,*}"
")",
/* general settings */
"bind_address", &bind_address,
"write_delay", &settings.delay[WRITE],
"write_duration", &settings.duration[WRITE],
"read_delay", &settings.delay[READ],
"read_duration", &settings.duration[READ],
"reporting_interval", &settings.reporting_interval,
"requested_send_buffer_size", &settings.requested_send_buffer_size,
"requested_read_buffer_size", &settings.requested_read_buffer_size,
"maximum_block_size", &settings.maximum_block_size,
"traffic_dump", &settings.traffic_dump,
"so_debug", &settings.so_debug,
"route_record", &settings.route_record,
"pushy", &settings.pushy,
"shutdown", &settings.shutdown,
"write_rate", &settings.write_rate,
"random_seed",&settings.random_seed,
"traffic_generation_request_distribution", &settings.request_trafgen_options.distribution,
"traffic_generation_request_param_one", &settings.request_trafgen_options.param_one,
"traffic_generation_request_param_two", &settings.request_trafgen_options.param_two,
"traffic_generation_response_distribution", &settings.response_trafgen_options.distribution,
"traffic_generation_response_param_one", &settings.response_trafgen_options.param_one,
"traffic_generation_response_param_two", &settings.response_trafgen_options.param_two,
"traffic_generation_gap_distribution", &settings.interpacket_gap_trafgen_options.distribution,
"traffic_generation_gap_param_one", &settings.interpacket_gap_trafgen_options.param_one,
"traffic_generation_gap_param_two", &settings.interpacket_gap_trafgen_options.param_two,
"flow_control", &settings.flow_control,
"byte_counting", &settings.byte_counting,
"cork", &settings.cork,
"nonagle", &settings.nonagle,
"cc_alg", &cc_alg,
"elcn", &settings.elcn,
"lcd", &settings.lcd,
"mtcp", &settings.mtcp,
"dscp", &settings.dscp,
"ipmtudiscover", &settings.ipmtudiscover,
#ifdef HAVE_LIBPCAP
"dump_prefix", &dump_prefix,
#endif /* HAVE_LIBPCAP */
"num_extra_socket_options", &settings.num_extra_socket_options,
"extra_socket_options", &extra_options);
if (env->fault_occurred)
goto cleanup;
/* Check for sanity */
if (strlen(bind_address) >= sizeof(settings.bind_address) - 1 ||
settings.delay[WRITE] < 0 || settings.duration[WRITE] < 0 ||
settings.delay[READ] < 0 || settings.duration[READ] < 0 ||
settings.requested_send_buffer_size < 0 || settings.requested_read_buffer_size < 0 ||
settings.maximum_block_size < MIN_BLOCK_SIZE ||
settings.write_rate < 0 ||
strlen(cc_alg) > TCP_CA_NAME_MAX ||
settings.num_extra_socket_options < 0 || settings.num_extra_socket_options > MAX_EXTRA_SOCKET_OPTIONS ||
xmlrpc_array_size(env, extra_options) != settings.num_extra_socket_options) {
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Flow settings incorrect");
}
/* Parse extra socket options */
for (i = 0; i < settings.num_extra_socket_options; i++) {
const unsigned char* buffer = 0;
size_t len;
xmlrpc_value *option, *level = 0, *optname = 0, *value = 0;
xmlrpc_array_read_item(env, extra_options, i, &option);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "level", &level);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "optname", &optname);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "value", &value);
if (!env->fault_occurred)
xmlrpc_read_int(env, level, &settings.extra_socket_options[i].level);
if (!env->fault_occurred)
xmlrpc_read_int(env, optname, &settings.extra_socket_options[i].optname);
if (!env->fault_occurred)
xmlrpc_read_base64(env, value, &len, &buffer);
if (level)
xmlrpc_DECREF(level);
if (optname)
xmlrpc_DECREF(optname);
if (value)
xmlrpc_DECREF(value);
if (!env->fault_occurred) {
if (len > MAX_EXTRA_SOCKET_OPTION_VALUE_LENGTH) {
free((void *)buffer);
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Too long extra socket option length");
}
settings.extra_socket_options[i].optlen = len;
memcpy(settings.extra_socket_options[i].optval, buffer, len);
free((void *)buffer);
}
if (env->fault_occurred)
goto cleanup;
}
strcpy(settings.cc_alg, cc_alg);
strcpy(settings.bind_address, bind_address);
DEBUG_MSG(LOG_WARNING, "bind_address=%s", bind_address);
request = malloc(sizeof(struct _request_add_flow_destination));
request->settings = settings;
rc = dispatch_request((struct _request*)request, REQUEST_ADD_DESTINATION);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "{s:i,s:i,s:i,s:i}",
"flow_id", request->flow_id,
"listen_data_port", request->listen_data_port,
"real_listen_send_buffer_size", request->real_listen_send_buffer_size,
"real_listen_read_buffer_size", request->real_listen_read_buffer_size);
cleanup:
if (request)
free_all(request->r.error, request);
free_all(cc_alg, bind_address);
if (extra_options)
xmlrpc_DECREF(extra_options);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method add_flow_destination failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination successful");
}
return ret;
}
// very_complex_array = archiver.values(key, names[], start, end, ...)
xmlrpc_value *get_values(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
LOG_MSG("archiver.get_values\n");
#endif
xmlrpc_value *names;
xmlrpc_int32 key, start_sec, start_nano, end_sec, end_nano, count, how;
xmlrpc_int32 actual_count;
// Extract arguments
xmlrpc_parse_value(env, args, "(iAiiiiii)",
&key, &names,
&start_sec, &start_nano, &end_sec, &end_nano,
&count, &how);
if (env->fault_occurred)
return 0;
#ifdef LOGFILE
LOG_MSG("how=%d, count=%d\n", (int) how, (int) count);
#endif
if (count <= 1)
count = 1;
actual_count = count;
if (count > 10000) // Upper limit to avoid outrageous requests.
actual_count = 10000;
// Build start/end
epicsTime start, end;
pieces2epicsTime(start_sec, start_nano, start);
pieces2epicsTime(end_sec, end_nano, end);
// Pull names into vector for SpreadsheetReader and just because.
xmlrpc_value *name_val;
char *name;
int i;
xmlrpc_int32 name_count = xmlrpc_array_size(env, names);
stdVector<stdString> name_vector;
name_vector.reserve(name_count);
for (i=0; i<name_count; ++i)
{ // no new ref!
name_val = xmlrpc_array_get_item(env, names, i);
if (env->fault_occurred)
return 0;
xmlrpc_parse_value(env, name_val, "s", &name);
if (env->fault_occurred)
return 0;
name_vector.push_back(stdString(name));
}
// Build results
switch (how)
{
case HOW_RAW:
return get_channel_data(env, key, name_vector, start, end,
actual_count, ReaderFactory::Raw, 0.0);
case HOW_SHEET:
return get_sheet_data(env, key, name_vector, start, end,
actual_count, ReaderFactory::Raw, 0.0);
case HOW_AVERAGE:
return get_sheet_data(env, key, name_vector, start, end,
actual_count,
ReaderFactory::Average, (end-start)/count);
case HOW_PLOTBIN:
// 'count' = # of bins, resulting in up to 4*count samples
return get_channel_data(env, key, name_vector, start, end,
actual_count*4,
ReaderFactory::Plotbin, (end-start)/count);
case HOW_LINEAR:
return get_sheet_data(env, key, name_vector, start, end,
actual_count,
ReaderFactory::Linear, (end-start)/count);
}
xmlrpc_env_set_fault_formatted(env, ARCH_DAT_ARG_ERROR,
"Invalid how=%d", how);
return 0;
}
// {string name, int32 start_sec, int32 start_nano,
// int32 end_sec, int32 end_nano}[]
// = archiver.names(int32 key, string pattern)
xmlrpc_value *get_names(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
LOG_MSG("archiver.names\n");
#endif
// Get args, maybe setup pattern
AutoPtr<RegularExpression> regex;
xmlrpc_int32 key;
char *pattern = 0;
size_t pattern_len = 0;
xmlrpc_parse_value(env, args, "(is#)", &key, &pattern, &pattern_len);
if (env->fault_occurred)
return 0;
// Create result
AutoXmlRpcValue result(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
try
{
if (pattern_len > 0)
regex.assign(new RegularExpression(pattern));
// Open Index
stdString directory;
AutoPtr<Index> index(open_index(env, key));
if (env->fault_occurred)
return 0;
// Put all names in binary tree
Index::NameIterator ni;
BinaryTree<ChannelInfo> channels;
ChannelInfo info;
bool ok;
for (ok = index->getFirstChannel(ni);
ok; ok = index->getNextChannel(ni))
{
if (regex && !regex->doesMatch(ni.getName()))
continue; // skip what doesn't match regex
info.name = ni.getName();
AutoPtr<RTree> tree(index->getTree(info.name, directory));
if (tree)
tree->getInterval(info.start, info.end);
else // Is this an error?
info.start = info.end = nullTime;
channels.add(info);
}
index->close();
// Sorted dump of names
ChannelInfo::UserArg user_arg;
user_arg.env = env;
user_arg.result = result;
channels.traverse(ChannelInfo::add_name_to_result, (void *)&user_arg);
#ifdef LOGFILE
LOG_MSG("get_names(%d, '%s') -> %d names\n",
key,
(pattern ? pattern : "<no pattern>"),
xmlrpc_array_size(env, result));
#endif
}
catch (GenericException &e)
{
xmlrpc_env_set_fault_formatted(env, ARCH_DAT_SERV_FAULT,
(char *) e.what());
return 0;
}
return result.release();
}
static xmlrpc_value *
service_refresh_blocking (xmlrpc_env *env,
xmlrpc_value *param_array,
void *user_data)
{
int size;
RCWorld *world;
RCPending *pending = NULL;
GSList *pending_list;
char *err_msg = NULL;
if (rcd_transaction_is_locked ()) {
xmlrpc_env_set_fault (env, RCD_RPC_FAULT_LOCKED,
"Transaction lock in place");
return NULL;
}
size = xmlrpc_array_size (env, param_array);
XMLRPC_FAIL_IF_FAULT (env);
if (size > 0) {
char *service_identifier;
xmlrpc_parse_value (env, param_array, "(s)", &service_identifier);
XMLRPC_FAIL_IF_FAULT (env);
world = RC_WORLD (service_lookup (service_identifier));
if (!world) {
xmlrpc_env_set_fault_formatted (env, RCD_RPC_FAULT_INVALID_SERVICE,
"Unable to find service '%s'",
service_identifier);
goto cleanup;
}
} else {
world = rc_get_world ();
}
/* FIXME: err_msg ? */
pending = rc_world_refresh (world);
if (err_msg) {
xmlrpc_env_set_fault_formatted (
env, RCD_RPC_FAULT_CANT_REFRESH,
"Unable to download channel data: %s", err_msg);
goto cleanup;
}
pending_list = g_slist_prepend (NULL, pending);
rcd_rpc_block_on_pending_list (env, pending_list, FALSE,
RCD_RPC_FAULT_CANT_REFRESH);
g_slist_free (pending_list);
cleanup:
if (pending)
g_object_unref (pending);
if (err_msg)
g_free (err_msg);
if (env->fault_occurred)
return NULL;
return xmlrpc_build_value (env, "i", 0);
}
static void
testParseNumberValue(void) {
char const xmldata[] =
XML_PROLOGUE
"<methodCall>\r\n"
"<methodName>test</methodName>\r\n"
"<params>\r\n"
"<param><value><int>2147483647</int></value></param>\r\n" \
"<param><value><int>-2147483648</int></value></param>\r\n" \
"<param><value><i1>10</i1></value></param>\r\n"
"<param><value><i2>10</i2></value></param>\r\n"
"<param><value><i4>10</i4></value></param>\r\n"
"<param><value><i8>10</i8></value></param>\r\n"
"<param><value><ex:i8>10</ex:i8></value></param>\r\n"
"<param><value><double>10</double></value></param>\r\n"
"<param><value><double>10.1</double></value></param>\r\n"
"<param><value><double>-10.1</double></value></param>\r\n"
"<param><value><double>+10.1</double></value></param>\r\n"
"<param><value><double>0</double></value></param>\r\n"
"<param><value><double>.01</double></value></param>\r\n"
"<param><value><double>5.</double></value></param>\r\n"
"<param><value><double>5.3E6</double></value></param>\r\n"
"<param><value><double> 1</double></value></param>\r\n"
"</params>\r\n"
"</methodCall>\r\n";
xmlrpc_env env;
xmlrpc_value * paramArrayP;
const char * methodName;
int arraySize;
xmlrpc_int int_max, int_min;
xmlrpc_int32 i_i1, i_i2, i_i4;
xmlrpc_int64 i_i8, i_ex_i8;
double d1, d2, d3, d4, d5, d6, d7, d8, d9;
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, xmldata, strlen(xmldata),
&methodName, ¶mArrayP);
TEST_NO_FAULT(&env);
arraySize = xmlrpc_array_size(&env, paramArrayP);
TEST_NO_FAULT(&env);
TEST(arraySize == 16);
xmlrpc_decompose_value(
&env, paramArrayP, "(iiiiiIIddddddddd)",
&int_max, &int_min, &i_i1, &i_i2, &i_i4, &i_i8, &i_ex_i8,
&d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9);
TEST_NO_FAULT(&env);
TEST(int_max == INT_MAX);
TEST(int_min == INT_MIN);
TEST(i_i1 == 10);
TEST(i_i2 == 10);
TEST(i_i4 == 10);
TEST(i_i8 == 10);
TEST(i_ex_i8 == 10);
TESTFLOATEQUAL(d1, 10.0);
TESTFLOATEQUAL(d2, 10.1);
TESTFLOATEQUAL(d3, -10.1);
TESTFLOATEQUAL(d4, +10.1);
TESTFLOATEQUAL(d5, 0.0);
TESTFLOATEQUAL(d6, 0.01);
TESTFLOATEQUAL(d7, 5.0);
TESTFLOATEQUAL(d8, 5.3E6);
TESTFLOATEQUAL(d9, 1.0);
xmlrpc_DECREF(paramArrayP);
strfree(methodName);
xmlrpc_env_clean(&env);
}
static void
testParseMiscSimpleValue(void) {
char const xmldata[] =
XML_PROLOGUE
"<methodCall>\r\n"
"<methodName>test</methodName>\r\n"
"<params>\r\n"
"<param><value><string>hello</string></value></param>\r\n"
"<param><value><boolean>0</boolean></value></param>\r\n"
"<param><value><boolean>1</boolean></value></param>\r\n"
"<param><value><dateTime.iso8601>19980717T14:08:55</dateTime.iso8601>"
"</value></param>\r\n"
"<param><value>"
"<dateTime.iso8601>19980717T14:08:55.123456</dateTime.iso8601>"
"</value></param>\r\n"
"<param><value><base64>YmFzZTY0IGRhdGE=</base64></value></param>\r\n"
"<param><value><nil/></value></param>\r\n"
"<param><value><ex:nil/></value></param>\r\n"
"</params>\r\n"
"</methodCall>\r\n";
xmlrpc_env env;
xmlrpc_value * paramArrayP;
const char * methodName;
int arraySize;
const char * str_hello;
xmlrpc_bool b_false, b_true;
const char * datetime_sec;
const char * datetime_usec;
unsigned char * b64_data;
size_t b64_len;
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, xmldata, strlen(xmldata),
&methodName, ¶mArrayP);
TEST_NO_FAULT(&env);
arraySize = xmlrpc_array_size(&env, paramArrayP);
TEST_NO_FAULT(&env);
TEST(arraySize == 8);
xmlrpc_decompose_value(
&env, paramArrayP, "(sbb886nn)",
&str_hello, &b_false, &b_true, &datetime_sec, &datetime_usec,
&b64_data, &b64_len);
TEST_NO_FAULT(&env);
TEST(streq(str_hello, "hello"));
TEST(!b_false);
TEST(b_true);
TEST(streq(datetime_sec, "19980717T14:08:55"));
TEST(streq(datetime_usec, "19980717T14:08:55.123456"));
TEST(b64_len == 11);
TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
free(b64_data);
strfree(str_hello);
strfree(datetime_sec);
strfree(datetime_usec);
xmlrpc_DECREF(paramArrayP);
strfree(methodName);
xmlrpc_env_clean(&env);
}
bool ArchiveDataClient::decode_data(const char *name,
xmlrpc_int32 type, xmlrpc_int32 count,
xmlrpc_value *data_array,
CtrlInfo &ctrlinfo,
size_t n,
value_callback callback,
void *callback_arg)
{
size_t i, num, v, v_num;
xmlrpc_int32 stat, sevr, secs, nano;
xmlrpc_value *data, *value_array, *value;
epicsTime stamp;
DbrType dbr_type;
RawValue::Data *raw_value;
switch (type)
{
case XML_STRING: dbr_type = DBR_TIME_STRING; break;
case XML_ENUM: dbr_type = DBR_TIME_ENUM; break;
case XML_INT: dbr_type = DBR_TIME_LONG; break;
case XML_DOUBLE: dbr_type = DBR_TIME_DOUBLE; break;
default:
LOG_MSG("Cannot decode data type %d\n", type);
return false;
}
raw_value = RawValue::allocate(dbr_type, count, 1);
num = xmlrpc_array_size(&env, data_array);
if (log_fault())
return false;
for (i=0; i<num; ++i)
{
data = xmlrpc_array_get_item(&env, data_array, i);
xmlrpc_parse_value(&env, data, "{s:i,s:i,s:i,s:i,s:A,*}",
"stat", &stat, "sevr", &sevr,
"secs", &secs, "nano", &nano,
"value", &value_array);
if (log_fault())
return false;
pieces2epicsTime(secs, nano, stamp);
RawValue::setStatus(raw_value, stat, sevr);
RawValue::setTime(raw_value, stamp);
v_num = xmlrpc_array_size(&env, value_array);
if (log_fault())
return false;
if (v_num != (size_t)count)
{
LOG_MSG("value size discrepancy, %zu != %zu\n", v_num, (size_t)count);
return false;
}
for (v=0; v<v_num; ++v)
{
value = xmlrpc_array_get_item(&env, value_array, v);
if (log_fault())
return false;
switch (dbr_type)
{
case DBR_TIME_STRING:
{
if (v > 0)
break;
const char *txt;
size_t len;
xmlrpc_parse_value(&env, value, "s#", &txt, &len);
if (len >= MAX_STRING_SIZE)
len = MAX_STRING_SIZE-1;
memcpy(((dbr_time_string *)raw_value)->value, txt, len);
((dbr_time_string *)raw_value)->value[len] = '\0';
}
break;
case DBR_TIME_ENUM:
{
dbr_enum_t *val = &((dbr_time_enum *)raw_value)->value;
xmlrpc_int32 ival;
xmlrpc_parse_value(&env, value, "i", &ival);
val[v] = ival;
if (log_fault())
return false;
}
break;
case DBR_TIME_LONG:
{
dbr_long_t *val = &((dbr_time_long *)raw_value)->value;
xmlrpc_int32 ival;
xmlrpc_parse_value(&env, value, "i", &ival);
val[v] = ival;
if (log_fault())
return false;
}
break;
case DBR_TIME_DOUBLE:
{
double *val = &((dbr_time_double *)raw_value)->value;
xmlrpc_parse_value(&env, value, "d", &val[v]);
if (log_fault())
return false;
}
break;
}
}
if (!callback(callback_arg, name, n, i,
ctrlinfo, dbr_type, count, raw_value))
break;
}
RawValue::free(raw_value);
return true;
}
bool ArchiveDataClient::getInfo(int &version,
stdString &description,
stdVector<stdString> &how_strings,
stdVector<stdString> &stat_strings,
stdVector<SeverityInfo> &sevr_infos)
{
xmlrpc_value *result, *hows, *stats, *sevrs, *element;
xmlrpc_int32 num;
xmlrpc_bool has_value, txt_stat;
const char *str;
size_t count, len, i;
result = xmlrpc_client_call(&env, (char *)URL, "archiver.info", "()");
if (log_fault())
return false;
xmlrpc_parse_value(&env, result, "{s:i,s:s#,s:A,s:A,s:A,*}",
"ver", &num,
"desc", &str, &len,
"how", &hows,
"stat", &stats,
"sevr", &sevrs);
if (log_fault())
return false;
version = num;
description.assign(str, len);
// 'how' array
count = xmlrpc_array_size(&env, hows);
how_strings.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, hows, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s", &str);
if (log_fault())
return false;
how_strings.push_back(stdString(str));
}
// 'stat' array
count = xmlrpc_array_size(&env, stats);
stat_strings.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, stats, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s", &str);
if (log_fault())
return false;
stat_strings.push_back(stdString(str));
}
// 'sevr' array
count = xmlrpc_array_size(&env, sevrs);
stat_strings.reserve(count);
SeverityInfo info;
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, sevrs, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "{s:i,s:s#,s:b,s:b,*}",
"num", &num,
"sevr", &str, &len,
"has_value", &has_value,
"txt_stat", &txt_stat);
if (log_fault())
return false;
info.num = num;
info.text.assign(str, len);
info.has_value = has_value;
info.txt_stat = txt_stat;
sevr_infos.push_back(info);
}
xmlrpc_DECREF(result);
return true;
}
// Dump 'meta' part of returned value
bool ArchiveDataClient::decode_meta(xmlrpc_value *meta, CtrlInfo &ctrlinfo)
{
xmlrpc_int32 type;
xmlrpc_parse_value(&env, meta, "{s:i,*}", "type", &type);
if (log_fault())
return false;
if (type == 0)
{
xmlrpc_value *element, *states;
xmlrpc_parse_value(&env, meta, "{s:A,*}", "states", &states);
if (log_fault())
return false;
size_t i, total, len, count = xmlrpc_array_size(&env, states);
const char *str;
total = 0;
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, states, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s#", &str, &len);
if (log_fault())
return false;
total += len+1;
}
ctrlinfo.allocEnumerated(count, total);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, states, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s", &str);
if (log_fault())
return false;
ctrlinfo.setEnumeratedString(i, str);
}
}
else if (type == 1)
{
double disp_high, disp_low, alarm_high, alarm_low, warn_high, warn_low;
xmlrpc_int32 prec;
char *units;
xmlrpc_parse_value(&env, meta, "{s:d,s:d,s:d,s:d,s:d,s:d,s:i,s:s,*}",
"disp_high", &disp_high,
"disp_low", &disp_low,
"alarm_high", &alarm_high,
"alarm_low", &alarm_low,
"warn_high", &warn_high,
"warn_low", &warn_low,
"prec", &prec,
"units", &units);
if (log_fault())
return false;
ctrlinfo.setNumeric(prec, units, disp_low, disp_high,
alarm_low, warn_low, warn_high, alarm_high);
}
else
{
LOG_MSG("unknown meta type %d\n", type);
return false;
}
return true;
}
static void
test_value_array2(void) {
xmlrpc_value * arrayP;
xmlrpc_env env;
xmlrpc_int32 i, i1, i2, i3, i4, i5;
xmlrpc_value * itemP;
xmlrpc_value * subarrayP;
size_t len;
/* A more complex array. */
xmlrpc_env_init(&env);
arrayP = xmlrpc_build_value(&env, "(i(ii)i)",
(xmlrpc_int32) 10, (xmlrpc_int32) 20,
(xmlrpc_int32) 30, (xmlrpc_int32) 40);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
len = xmlrpc_array_size(&env, arrayP);
TEST_NO_FAULT(&env);
TEST(len == 3);
xmlrpc_array_read_item(&env, arrayP, 1, &subarrayP);
TEST_NO_FAULT(&env);
len = xmlrpc_array_size(&env, subarrayP);
TEST_NO_FAULT(&env);
TEST(len == 2);
xmlrpc_array_read_item(&env, subarrayP, 0, &itemP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
xmlrpc_DECREF(itemP);
TEST_NO_FAULT(&env);
TEST(i == 20);
xmlrpc_DECREF(subarrayP);
itemP = xmlrpc_array_get_item(&env, arrayP, 0);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
TEST_NO_FAULT(&env);
TEST(i == 10);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 30 && i4 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(i*)i)", &i1, &i2, &i3);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(ii*)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, arrayP, "(i(iii)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(i)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(iiQ)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i*",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Test bounds check on xmlrpc_array_get_item. */
xmlrpc_array_read_item(&env, arrayP, 3, &itemP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, 3);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, -1);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(arrayP);
xmlrpc_env_clean(&env);
}
