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 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);
}
void
xmlrpc_destroyArrayContents(xmlrpc_value * const arrayP) {
/*----------------------------------------------------------------------------
Dispose of the contents of an array (but not the array value itself).
The value is not valid after this.
-----------------------------------------------------------------------------*/
size_t const arraySize =
XMLRPC_MEMBLOCK_SIZE(xmlrpc_value*, &arrayP->_block);
xmlrpc_value ** const contents =
XMLRPC_MEMBLOCK_CONTENTS(xmlrpc_value*, &arrayP->_block);
size_t index;
XMLRPC_ASSERT_ARRAY_OK(arrayP);
/* Release our reference to each item in the array */
for (index = 0; index < arraySize; ++index) {
xmlrpc_value * const itemP = contents[index];
xmlrpc_DECREF(itemP);
}
XMLRPC_MEMBLOCK_CLEAN(xmlrpc_value *, &arrayP->_block);
}
static void get_torrent_list(torrent_array **result) {
size_t size;
xmlrpc_value *xml_array, *params;
params = xmlrpc_array_new(&env);
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "main"));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.hash="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.name="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.is_active="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.state="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.bytes_done="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.size_bytes="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.up.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.total="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.ratio="));
check_fault();
execute_proxy_method(&xml_array, "d.multicall", params);
check_fault(&env);
assert(xmlrpc_value_type(xml_array) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(xml_array);
size = xmlrpc_array_size(&env, xml_array);
check_fault(&env);
if (size <= 0)
goto finish;
*result = torrent_array_new(size);
for (size_t i = 0; i < size; ++i) {
size_t tarray_size;
xmlrpc_value *tarray = NULL;
xmlrpc_array_read_item(&env, xml_array, i, &tarray);
check_fault(&env);
assert(xmlrpc_value_type(tarray) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(tarray);
tarray_size = xmlrpc_array_size(&env, tarray);
for (size_t j = 0; j < tarray_size; ++j) {
xmlrpc_value *item = NULL;
xmlrpc_array_read_item(&env, tarray, j, &item);
check_fault(&env);
switch (j) {
case 0:
get_string(item, &(*result)->torrents[i]->hash);
break;
case 1:
get_string(item, &(*result)->torrents[i]->name);
break;
case 2:
get_bool_from_int64(item, &(*result)->torrents[i]->active);
break;
case 3:
get_bool_from_int64(item, &(*result)->torrents[i]->started);
break;
case 4:
get_int64(item, &(*result)->torrents[i]->done_bytes);
break;
case 5:
get_int64(item, &(*result)->torrents[i]->size_bytes);
break;
case 6:
get_int64(item, &(*result)->torrents[i]->up_rate);
break;
case 7:
get_int64(item, &(*result)->torrents[i]->down_rate);
break;
case 8:
get_int64(item, &(*result)->torrents[i]->down_total);
break;
case 9:
get_int64(item, &(*result)->torrents[i]->ratio);
break;
default:
;
}
xmlrpc_DECREF(item);
}
xmlrpc_DECREF(tarray);
}
finish:
xmlrpc_DECREF(xml_array);
}
