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);
}
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);
}
/* die or return bug id; each bug must have bug id otherwise xml is corrupted */
int rhbz_get_bug_id_from_array0(xmlrpc_value* xml, unsigned ver)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *item = NULL;
xmlrpc_array_read_item(&env, xml, 0, &item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
const char *id;
if (ver >= BUGZILLA_VERSION(4,2,0))
id = "id";
else
id = "bug_id";
xmlrpc_value *bug;
bug = rhbz_get_member(id, item);
xmlrpc_DECREF(item);
if (!bug)
error_msg_and_die("Can't get member '%s' from bug data", id);
int bug_id = -1;
xmlrpc_read_int(&env, bug, &bug_id);
xmlrpc_DECREF(bug);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
VERB3 log("found bug_id %i", bug_id);
return bug_id;
}
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 xmlrpc_value *
xr_getParam (Caller *c, int index)
{
xmlrpc_value *v;
xmlrpc_array_read_item (c->env, c->param, index, &v);
return (v);
}
cWrapper(xmlrpc_value *const arrayP,
unsigned int const index) {
env_wrap env;
xmlrpc_array_read_item(&env.env_c, arrayP, index, &valueP);
throwIfError(env);
}
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();
}
int c_oneAllocateTemplate(char* vm_template)
{
xmlrpc_value *resultP;
xmlrpc_value *valueP;
int return_code;
char *return_string;
int vmid;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmallocate", "(ss)", one_client.session, vm_template);
xmlrpc_array_read_item(&one_client.env, resultP, 0, &valueP);
xmlrpc_read_bool(&one_client.env, valueP, &return_code);
if( return_code )
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_int(&one_client.env, valueP, &vmid);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
return vmid;
}
else
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_string(&one_client.env, valueP,
(const char **)&return_string);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
VIR_FREE(one_client.error);
one_client.error=return_string;
return -1;
}
}
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);
}
/* Utility routine to get the value of an array by its index.
*/
static xmlrpc_value *
xr_getArrValue (xmlrpc_value *val, int index)
{
xmlrpc_value *v;
xmlrpc_env env;
if (xmlrpc_value_type (val) == XMLRPC_TYPE_ARRAY) {
xmlrpc_array_read_item (&env, val, index, &v);
return (v);
} else {
xmlrpc_INCREF(val);
return (val);
}
}
xmlrpc_value *rhbz_array_item_at(xmlrpc_value *xml, int pos)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value* item = NULL;
xmlrpc_array_read_item(&env, xml, pos, &item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
xmlrpc_env_clean(&env);
return item;
}
GList *rhbz_bug_cc(xmlrpc_value* result_xml)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value* cc_member = rhbz_get_member("cc", result_xml);
if (!cc_member)
return NULL;
unsigned array_size = rhbz_array_size(cc_member);
VERB3 log("count members on cc %i", array_size);
GList *cc_list = NULL;
for (unsigned i = 0; i < array_size; ++i)
{
xmlrpc_value* item = NULL;
xmlrpc_array_read_item(&env, cc_member, i, &item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (!item)
continue;
const char* cc = NULL;
xmlrpc_read_string(&env, item, &cc);
xmlrpc_DECREF(item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (*cc != '\0')
{
cc_list = g_list_append(cc_list, (char*)cc);
VERB3 log("member on cc is %s", cc);
continue;
}
free((char*)cc);
}
xmlrpc_DECREF(cc_member);
return cc_list;
}
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;
}
static void
parsearray(xmlrpc_env *const envP,
const xmlrpc_value *const arrayP,
struct arrayDecomp const arrayDecomp,
bool const oldstyleMemMgmt) {
validateArraySize(envP, arrayP, arrayDecomp);
if (!envP->fault_occurred) {
unsigned int doneCnt;
doneCnt = 0;
while (doneCnt < arrayDecomp.itemCnt && !envP->fault_occurred) {
xmlrpc_value *itemP;
xmlrpc_array_read_item(envP, arrayP, doneCnt, &itemP);
if (!envP->fault_occurred) {
XMLRPC_ASSERT(doneCnt < ARRAY_SIZE(arrayDecomp.itemArray));
decomposeValueWithTree(envP, itemP, oldstyleMemMgmt,
arrayDecomp.itemArray[doneCnt]);
if (!envP->fault_occurred)
++doneCnt;
xmlrpc_DECREF(itemP);
}
}
if (envP->fault_occurred) {
if (!oldstyleMemMgmt) {
/* Release the items we completed before we failed. */
unsigned int i;
for (i = 0; i < doneCnt; ++i)
releaseDecomposition(arrayDecomp.itemArray[i]);
}
}
}
}
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);
}
node_t * xmlrpc_client_callmethod(const char * serverUrl, const char * methodName, unsigned int argVersion){
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFailed("Client initialization", &env);
xmlrpc_value * ID, * PORT, * DATA, * DATAP, * IP;
ID = xmlrpc_int_new(&env, 23121);
IP = xmlrpc_string_new(&env, "127.0.0.1");
PORT = xmlrpc_int_new(&env, 8085);
DATA = xmlrpc_int_new(&env, 123);
DATAP = xmlrpc_struct_new(&env);
xmlrpc_struct_set_value(&env, DATAP, "ID", ID);
xmlrpc_struct_set_value(&env, DATAP, "IP", IP);
xmlrpc_struct_set_value(&env, DATAP, "PORT", PORT);
xmlrpc_struct_set_value(&env, DATAP, "DATA", DATA);
xmlrpc_DECREF(ID);
xmlrpc_DECREF(IP);
xmlrpc_DECREF(PORT);
xmlrpc_DECREF(DATA);
/* Make the call */
xmlrpc_value * resultArray = xmlrpc_client_call(&env, serverUrl, methodName, "(iS)", (xmlrpc_int32) argVersion, DATAP);
xmlrpc_value * OutID_t, *OutPORT_t, *OutDATA_t, *OutIP_t;
xmlrpc_int OutID, OutPORT, OutDATA;
char * OutIP;
unsigned int const resultCt = xmlrpc_array_size(&env, resultArray);
unsigned int i;
node_t * resultnode = (node_t *) malloc(3*sizeof(node_t));
for(i = 0; i < resultCt; ++i){
xmlrpc_value * resultP;
xmlrpc_array_read_item(&env, resultArray, i, &resultP);
xmlrpc_struct_find_value(&env, resultP, "ID", &OutID_t);
xmlrpc_struct_find_value(&env, resultP, "IP", &OutIP_t);
xmlrpc_struct_find_value(&env, resultP, "PORT", &OutPORT_t);
xmlrpc_struct_find_value(&env, resultP, "DATA", &OutDATA_t);
xmlrpc_read_int(&env, OutID_t, &OutID);
xmlrpc_read_string(&env, OutIP_t, &OutIP);
xmlrpc_read_int(&env, OutPORT_t, &OutPORT);
xmlrpc_read_int(&env, OutDATA_t, &OutDATA);
resultnode[i].ID = OutID;
strcpy(resultnode[i].IP, OutIP);
resultnode[i].PORT = OutPORT;
resultnode[i].DATA = OutDATA;
}
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return resultnode;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 number_of_links;
const char * const serverUrl = "http://localhost:4567/RPC2";
const char * const methodName = "get_number_of_links";
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFaultOccurred(&env);
printf("Making XMLRPC call to server url '%s' method '%s'\n", serverUrl, "get_number_of_links");
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_number_of_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &number_of_links);
dieIfFaultOccurred(&env);
printf("Number of links defined: %d\n", number_of_links);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
int array_size =xmlrpc_array_size(&env, resultP);
while(array_size>0) {
--array_size;
xmlrpc_value *value;
const char *link;
xmlrpc_array_read_item(&env, resultP, 0, &value);
xmlrpc_read_string(&env, value, &link);
printf("Link %u: %s\n", array_size, link);
xmlrpc_DECREF(value);
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "add_target", "(i)",
(xmlrpc_int32) 1);
xmlrpc_int64 targetID = 0;
xmlrpc_read_i8(&env, resultP, &targetID);
if(targetID) {
printf("New target added with ID: %"PRIx64"\n", targetID);
} else {
printf("Failed to add new target!\n");
goto done;
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "remove_target", "(i)",
(xmlrpc_int64) targetID);
xmlrpc_int32 res;
xmlrpc_read_int(&env, resultP, &res);
printf("Target %"PRIx64" remove: %"PRIx32"\n", targetID, res);
done:
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
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);
}
static int
join_krb5(const char *ipaserver, char *hostname, char **hostdn, const char **princ, const char **subject, int force, int quiet) {
xmlrpc_env env;
xmlrpc_value * argArrayP = NULL;
xmlrpc_value * paramArrayP = NULL;
xmlrpc_value * paramP = NULL;
xmlrpc_value * optionsP = NULL;
xmlrpc_value * resultP = NULL;
xmlrpc_value * structP = NULL;
xmlrpc_server_info * serverInfoP = NULL;
struct utsname uinfo;
xmlrpc_value *princP = NULL;
xmlrpc_value *krblastpwdchangeP = NULL;
xmlrpc_value *subjectP = NULL;
xmlrpc_value *hostdnP = NULL;
const char *krblastpwdchange = NULL;
char * url = NULL;
char * user_agent = NULL;
int rval = 0;
int ret;
*hostdn = NULL;
*subject = NULL;
*princ = NULL;
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
uname(&uinfo);
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
#if 1
ret = asprintf(&url, "https://%s:443/ipa/xml", ipaserver);
#else
ret = asprintf(&url, "http://%s:8888/", ipaserver);
#endif
if (ret == -1)
{
if (!quiet)
fprintf(stderr, _("Out of memory!\n"));
rval = 3;
goto cleanup;
}
serverInfoP = xmlrpc_server_info_new(&env, url);
argArrayP = xmlrpc_array_new(&env);
paramArrayP = xmlrpc_array_new(&env);
if (hostname == NULL)
paramP = xmlrpc_string_new(&env, uinfo.nodename);
else
paramP = xmlrpc_string_new(&env, hostname);
xmlrpc_array_append_item(&env, argArrayP, paramP);
#ifdef REALM
if (!quiet)
printf("Joining %s to IPA realm %s\n", uinfo.nodename, iparealm);
#endif
xmlrpc_array_append_item(&env, paramArrayP, argArrayP);
xmlrpc_DECREF(paramP);
optionsP = xmlrpc_build_value(&env, "{s:s,s:s}",
"nsosversion", uinfo.release,
"nshardwareplatform", uinfo.machine);
xmlrpc_array_append_item(&env, paramArrayP, optionsP);
xmlrpc_DECREF(optionsP);
if ((user_agent = set_user_agent(ipaserver)) == NULL) {
rval = 3;
goto cleanup;
}
callRPC(user_agent, &env, serverInfoP, "join", paramArrayP, &resultP);
if (handle_fault(&env)) {
rval = 17;
goto cleanup_xmlrpc;
}
/* Return value is the form of an array. The first value is the
* DN, the second a struct of attribute values
*/
xmlrpc_array_read_item(&env, resultP, 0, &hostdnP);
xmlrpc_read_string(&env, hostdnP, (const char **)hostdn);
xmlrpc_DECREF(hostdnP);
xmlrpc_array_read_item(&env, resultP, 1, &structP);
xmlrpc_struct_find_value(&env, structP, "krbprincipalname", &princP);
if (princP) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, princP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, &*princ);
xmlrpc_DECREF(princP);
xmlrpc_DECREF(singleprincP);
} else {
if (!quiet)
fprintf(stderr, _("principal not found in XML-RPC response\n"));
rval = 12;
goto cleanup;
}
xmlrpc_struct_find_value(&env, structP, "krblastpwdchange", &krblastpwdchangeP);
if (krblastpwdchangeP && !force) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, krblastpwdchangeP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, &krblastpwdchange);
xmlrpc_DECREF(krblastpwdchangeP);
if (!quiet)
fprintf(stderr, _("Host is already joined.\n"));
rval = 13;
goto cleanup;
}
xmlrpc_struct_find_value(&env, structP, "ipacertificatesubjectbase", &subjectP);
if (subjectP) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, subjectP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, *&subject);
xmlrpc_DECREF(subjectP);
}
cleanup:
if (argArrayP) xmlrpc_DECREF(argArrayP);
if (paramArrayP) xmlrpc_DECREF(paramArrayP);
if (resultP) xmlrpc_DECREF(resultP);
cleanup_xmlrpc:
free(user_agent);
free(url);
free((char *)krblastpwdchange);
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return rval;
}
/* Unpack caller's information on the server,
or server's information returned to the client */
struct call_info *
callinfo_unpack(xmlrpc_env *envP, xmlrpc_value *s)
{
struct call_info *cip = callinfo_new();
xmlrpc_value *methargs, *files;
int i;
unpack(envP, s, "clientIP", (char **)&cip->clientIP);
unpack(envP, s, "serverURL", &cip->serverURL);
unpack(envP, s, "session", &cip->session);
unpack(envP, s, "method", &cip->method);
unpack(envP, s, "user", &cip->user);
unpack(envP, s, "password", &cip->password);
unpack(envP, s, "project", &cip->project);
unpack(envP, s, "version", &cip->version);
xmlrpc_struct_find_value(envP, s, "method-args", &methargs);
if (methargs)
{
cip->nargs = xmlrpc_array_size(envP, methargs);
cip->methodargs = malloc((cip->nargs + 1) * sizeof(char *));
for (i = 0; i < cip->nargs; ++i)
{
xmlrpc_value *v;
char *arg;
xmlrpc_array_read_item(envP, methargs, i, &v);
xmlrpc_read_string(envP, v, (const char **const)&arg);
cip->methodargs[i] = arg;
fprintf(stderr, "unpacked methodargs[%d] as %s\n", i, arg);
}
cip->methodargs[cip->nargs] = NULL;
}
else
{
cip->nargs = 0;
cip->methodargs = NULL;
}
xmlrpc_struct_find_value(envP, s, "method-data", &files);
if (files)
{
for (i = 0; i < xmlrpc_array_size(envP, files); ++i)
{
struct file_data *this_file;
xmlrpc_value * fstruct;
xmlrpc_array_read_item(envP, files, i, &fstruct);
this_file = file_unpack(envP, fstruct);
if (cip->files == NULL)
{
cip->files = this_file;
cip->files_last = cip->files->next;
}
else
{
cip->files_last->next = this_file;
cip->files_last = cip->files->next;
}
}
}
return cip;
}
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;
}
static GList *rhbz_comments(struct abrt_xmlrpc *ax, int bug_id)
{
func_entry();
/* http://www.bugzilla.org/docs/4.2/en/html/api/Bugzilla/WebService/Bug.html#comments */
/*
* <methodResponse>
* <params><param>
* <value><struct>
* <member><name>bugs</name>
* <value><struct>
* <member><name>BUG_ID</name>
* <value><struct>
* <member><name>comments</name>
* <value><array>
* ...
*/
xmlrpc_value *xml_response = abrt_xmlrpc_call(ax, "Bug.comments", "({s:(i)})",
"ids", bug_id);
/* bugs
* This is used for bugs specified in ids. This is a hash, where the
* keys are the numeric ids of the bugs, and the value is a hash with a
* single key, comments, which is an array of comments.
*/
xmlrpc_value *bugs_memb = rhbz_get_member("bugs", xml_response);
/* Get hash value assigned to bug_id key */
char *item = xasprintf("%d", bug_id);
xmlrpc_value *item_memb = rhbz_get_member(item, bugs_memb);
free(item);
/* Get array of comments */
xmlrpc_value *comments_memb = rhbz_get_member("comments", item_memb);
xmlrpc_env env;
xmlrpc_env_init(&env);
int comments_memb_size = rhbz_array_size(comments_memb);
GList *comments = NULL;
for (int i = 0; i < comments_memb_size; ++i)
{
xmlrpc_value* item = NULL;
xmlrpc_array_read_item(&env, comments_memb, i, &item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
char *comment_body = rhbz_bug_read_item("text", item, RHBZ_READ_STR);
/* attachments are sometimes without comments -- skip them */
if (comment_body)
comments = g_list_prepend(comments, comment_body);
xmlrpc_DECREF(item);
}
xmlrpc_env_clean(&env);
xmlrpc_DECREF(comments_memb);
xmlrpc_DECREF(item_memb);
xmlrpc_DECREF(bugs_memb);
xmlrpc_DECREF(xml_response);
return g_list_reverse(comments);
}
