/* 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
handle_sample_add_response(const char * const serverUrl,
const char * const methodName,
xmlrpc_value * const paramArrayP,
void * const user_data,
xmlrpc_env * const faultP,
xmlrpc_value * const resultP) {
xmlrpc_env env;
xmlrpc_int addend, adder;
/* Initialize our error environment variable */
xmlrpc_env_init(&env);
/* Our first four arguments provide helpful context. Let's grab the
addends from our parameter array.
*/
xmlrpc_decompose_value(&env, paramArrayP, "(ii)", &addend, &adder);
die_if_fault_occurred(&env);
printf("RPC with method '%s' at URL '%s' to add %d and %d "
"has completed\n", methodName, serverUrl, addend, adder);
if (faultP->fault_occurred)
printf("The RPC failed. %s\n", faultP->fault_string);
else {
xmlrpc_int sum;
xmlrpc_read_int(&env, resultP, &sum);
die_if_fault_occurred(&env);
printf("The sum is %d\n", sum);
}
}
static void
test_value_integer(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_int32 i;
xmlrpc_env_init(&env);
v = xmlrpc_int_new(&env, (xmlrpc_int32) 25);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_INT == xmlrpc_value_type(v));
xmlrpc_read_int(&env, v, &i);
TEST_NO_FAULT(&env);
TEST(i == 25);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 10);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_INT == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "i", &i);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(i == 10);
xmlrpc_env_clean(&env);
}
value_int::operator int() const {
int retval;
env_wrap env;
xmlrpc_read_int(&env.env_c, this->cValueP, &retval);
throwIfError(env);
return retval;
}
int
xr_getIntFromParam (void *data, int index)
{
CallerP c = (Caller *) data;
xmlrpc_value *val = xr_getArrValue (c->param, index);
int ival;
xmlrpc_read_int (c->env, val, &ival);
xmlrpc_DECREF (val);
return ( ((xr_errstat=c->env->fault_occurred) ? (int)NULL : ival) );
}
/* FIXME terminates the program if it fails */
int get_int_from_struct_by_idx(xmlrpc_value *structP, int index, int *rv)
{
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *keyP;
xmlrpc_value *valueP;
xmlrpc_struct_read_member(&env, structP, index, &keyP, &valueP); /* increment refcount of returned values */
die_if_fault_occurred_line(&env, __LINE__);
xmlrpc_read_int(&env, valueP, rv);
die_if_fault_occurred_line(&env, __LINE__);
xmlrpc_DECREF(valueP);
return 1;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_server_info * serverP;
xmlrpc_value * resultP;
xmlrpc_int sum;
if (argc-1 > 0) {
fprintf(stderr, "There are no arguments. You specified %d", argc-1);
exit(1);
}
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
xmlrpc_env_init(&env);
/* Make a new object to represent our XML-RPC server. */
serverP = xmlrpc_server_info_new(&env, SERVER_URL);
die_if_fault_occurred(&env);
/* Set up our authentication information. */
xmlrpc_server_info_set_basic_auth(&env, serverP, "jrandom", "secret");
die_if_fault_occurred(&env);
resultP =
xmlrpc_client_call_server(
&env, serverP, "sample.add", "(ii)",
(xmlrpc_int32) 5, (xmlrpc_int32) 7);
die_if_fault_occurred(&env);
/* Dispose of our server object. */
xmlrpc_server_info_free(serverP);
/* Get the result of the RPC and print it out. */
xmlrpc_read_int(&env, resultP, &sum);
die_if_fault_occurred(&env);
printf("The sum is %d\n", sum);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Shut down our XML-RPC client library. */
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return 0;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 sum;
const char * const serverUrl = "http://localhost:8080/RPC2";
const char * const serverUrl2 = "http://localhost:8081/RPC2";
const char * const serverUrl3 = "http://localhost:8082/RPC2";
const char * const methodName = "sample.add";
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' "
"to request the sum "
"of 5 and 7...\n", serverUrl, methodName);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, methodName, "(sssii)", 1, 3, serverUrl, serverUrl2, serverUrl3,
(xmlrpc_int32) 5, (xmlrpc_int32) 7);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &sum);
dieIfFaultOccurred(&env);
printf("The sum is %d\n", sum);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
int getIntFromXmlRpcStruct(xmlrpc_env *const envP,
QString memberName,
xmlrpc_value *const xmlrpcStructP) throw (QString)
{
int ret;
xmlrpc_value *structMemberP;
xmlrpc_struct_find_value(envP, xmlrpcStructP, memberName.toAscii(), &structMemberP);
assertOk(envP);
xmlrpc_read_int(envP, structMemberP, &ret);
assertOk(envP);
return ret;
}
static void
interpretFaultCode(xmlrpc_env * const envP,
xmlrpc_value * const faultCodeVP,
int * const faultCodeP) {
xmlrpc_env fcEnv;
xmlrpc_env_init(&fcEnv);
xmlrpc_read_int(&fcEnv, faultCodeVP, faultCodeP);
if (fcEnv.fault_occurred)
xmlrpc_faultf(envP, "Invalid value for 'faultCode' member. %s",
fcEnv.fault_string);
xmlrpc_env_clean(&fcEnv);
}
// TODO: npajkovs: add flag to read xmlrpc_read_array_item first
void *rhbz_bug_read_item(const char *memb, xmlrpc_value *xml, int flags)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *member = rhbz_get_member(memb, xml);
const char *string = NULL;
if (!member)
goto die;
if (IS_READ_STR(flags))
{
xmlrpc_read_string(&env, member, &string);
xmlrpc_DECREF(member);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (!*string)
goto die;
VERB3 log("found %s: '%s'", memb, string);
return (void*)string;
}
if (IS_READ_INT(flags))
{
int *integer = xmalloc(sizeof(int));
xmlrpc_read_int(&env, member, integer);
xmlrpc_DECREF(member);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
VERB3 log("found %s: '%i'", memb, *integer);
return (void*)integer;
}
die:
free((void*)string);
if (IS_MANDATORY(flags))
error_msg_and_die(_("Looks like corrupted xml response, because '%s'"
" member is missing."), memb);
return NULL;
}
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
addInterruptibly(xmlrpc_client * const clientP,
const char * const serverUrl,
int const addend,
int const adder) {
const char * const methodName = "sample.add";
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 sum;
xmlrpc_env_init(&env);
printf("Making XMLRPC call to server url '%s' method '%s' "
"to request the sum "
"of %d and %d...\n", serverUrl, methodName, addend, adder);
interrupt = 0; /* Global variable */
alarm(2); /* Interrupt the call if it hasn't finished 2 seconds from now */
/* Make the remote procedure call */
xmlrpc_client_call2f(&env, clientP, serverUrl, methodName, &resultP,
"(ii)", (xmlrpc_int32) addend, (xmlrpc_int32) adder);
die_if_fault_occurred(&env);
alarm(0); /* Cancel alarm, if it hasn't happened yet */
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &sum);
die_if_fault_occurred(&env);
printf("The sum is %d\n", sum);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
xmlrpc_env_clean(&env);
}
/* Get an integer value from struct result of xmlrpc_client_call()
* @param structP pointer to a result struct
* @param element_name name of structure item
* @param rv returned value
* @return 1 if succeed and 0 otherwise
*/
int get_int_from_struct_by_name(xmlrpc_value *structP, const char *element_name, int *rv)
{
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *valueP;
xmlrpc_struct_find_value(&env, structP, element_name, &valueP);
if ( env.fault_occurred )
goto error;
xmlrpc_read_int(&env, valueP, rv);
if ( env.fault_occurred )
goto error1;
xmlrpc_DECREF(valueP);
return 1;
error1:
xmlrpc_DECREF(valueP);
error:
return 0;
}
/* FIXME terminates the programm if it fails */
int get_struct_item_by_idx(xmlrpc_value *structP, int index, key_value_pair *rv)
{
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *keyP;
xmlrpc_value *valueP;
int length;
const char *string;
xmlrpc_struct_read_member(&env, structP, index, &keyP, &valueP); /* increment refcount of returned values */
die_if_fault_occurred_line(&env, __LINE__);
xmlrpc_read_string(&env, keyP, (const char **)&rv->key);
/* handle value type */
switch ( xmlrpc_value_type(valueP) ) {
case XMLRPC_TYPE_INT:
xmlrpc_read_int(&env, valueP, &rv->value.integer);
die_if_fault_occurred_line(&env, __LINE__);
rv->type = TYPE_INTEGER;
break;
case XMLRPC_TYPE_STRING:
xmlrpc_read_string(&env, valueP, &string);
printf("get_struct_item_by_idx: ptr = %p, string value = '%s'\n", string, string);
die_if_fault_occurred_line(&env, __LINE__);
rv->value.string = (char *)string;
rv->type = TYPE_STRING;
break;
default:
fprintf(stderr, "Wrong type of return value in key: '%s', exiting...\n", rv->key);
exit(1);
}
xmlrpc_DECREF(keyP); /* decrement refcount */
xmlrpc_DECREF(valueP);
die_if_fault_occurred_line(&env, __LINE__);
/* FIXME add error handling */
return 1;
}
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;
}
struct mi_root * xr_parse_tree( xmlrpc_env * env, xmlrpc_value * paramArray ) {
struct mi_root * mi_root;
int size, i;
size_t length;
xmlrpc_int32 intValue;
xmlrpc_bool boolValue;
#ifdef XMLRPC_OLD_VERSION
double doubleValue;
char * contents;
#else
xmlrpc_double doubleValue;
#endif
char * stringValue = 0;
char * byteStringValue =0;
xmlrpc_value * item;
mi_root = init_mi_tree(0, 0, 0);
if ( !mi_root ) {
LM_ERR("the MI tree cannot be initialized!\n");
goto error;
}
size = xmlrpc_array_size(env, paramArray);
for (i=0 ; i< size ; i++) {
item = xmlrpc_array_get_item(env, paramArray, i);
if ( env->fault_occurred ) {
LM_ERR("failed to get array item: %s\n", env->fault_string);
goto error;
}
switch ( xmlrpc_value_type(item) ) {
case (XMLRPC_TYPE_INT):
#ifdef XMLRPC_OLD_VERSION
intValue = item->_value.i;
#else
xmlrpc_read_int(env,item,&intValue);
#endif
if (addf_mi_node_child(&mi_root->node,0,0,0,"%d",intValue)==NULL) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_BOOL):
#ifdef XMLRPC_OLD_VERSION
boolValue = item->_value.b;
#else
xmlrpc_read_bool(env,item,&boolValue);
#endif
if (addf_mi_node_child(&mi_root->node,0,0,0,"%u",boolValue)==NULL){
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_DOUBLE):
#ifdef XMLRPC_OLD_VERSION
doubleValue = item->_value.d;
#else
xmlrpc_read_double(env,item,&doubleValue);
#endif
if ( addf_mi_node_child(&mi_root->node, 0, 0, 0, "%lf",
doubleValue) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_STRING):
#if HAVE_UNICODE_WCHAR
#ifdef XMLRPC_OLD_VERSION
xmlrpc_read_string_w(env, item, &stringValue);
#else
xmlrpc_read_string_w(env, item , (const char **)&stringValue);
#endif
#else
#ifdef XMLRPC_OLD_VERSION
xmlrpc_read_string(env, item, &stringValue);
#else
xmlrpc_read_string(env, item, (const char **)&stringValue);
#endif
#endif
if ( env->fault_occurred ) {
LM_ERR("failed to read stringValue: %s!\n", env->fault_string);
goto error;
}
if ( add_mi_node_child(&mi_root->node, 0, 0, 0,
stringValue,
lflf_to_crlf_hack(stringValue)) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_BASE64):
#ifdef XMLRPC_OLD_VERSION
length = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, &item->_block);
contents = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, &item->_block);
byteStringValue = pkg_malloc(length);
if ( !byteStringValue ){
xmlrpc_env_set_fault_formatted(env, XMLRPC_INTERNAL_ERROR,
"Unable to allocate %u bytes for byte string.", length);
LM_ERR("pkg_malloc cannot allocate any more memory!\n");
goto error;
} else
memcpy(byteStringValue, contents, length);
if ( add_mi_node_child(&mi_root->node, 0, 0, 0, byteStringValue,
length) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
#else
xmlrpc_read_base64(env, item, &length,
(const unsigned char **)(void*)&byteStringValue);
if ( env->fault_occurred ) {
LM_ERR("failed to read byteStringValue: %s!\n",
env->fault_string);
goto error;
}
if ( add_mi_node_child(&mi_root->node, MI_DUP_VALUE, 0, 0,
byteStringValue, length) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
free(byteStringValue);
#endif
break;
default :
LM_ERR("unsupported node type %d\n", xmlrpc_value_type(item) );
xmlrpc_env_set_fault_formatted( env, XMLRPC_TYPE_ERROR,
"Unsupported value of type %d supplied",
xmlrpc_value_type(item));
goto error;
}
}
return mi_root;
error:
if ( mi_root ) free_mi_tree(mi_root);
if ( byteStringValue ) pkg_free(byteStringValue);
return 0;
}
static void
decomposeValueWithTree(xmlrpc_env * const envP,
xmlrpc_value * const valueP,
bool const oldstyleMemMgmt,
const struct decompTreeNode * const decompRootP) {
/*----------------------------------------------------------------------------
Decompose XML-RPC value *valueP, given the decomposition tree
*decompRootP. The decomposition tree tells what structure *valueP
is expected to have and where to put the various components of it
(e.g. it says "it's an array of 3 integers. Put their values at
locations x, y, and z")
-----------------------------------------------------------------------------*/
switch (decompRootP->formatSpecChar) {
case '-':
/* There's nothing to validate or return */
break;
case 'i':
xmlrpc_read_int(envP, valueP, decompRootP->store.Tinteger.valueP);
break;
case 'b':
xmlrpc_read_bool(envP, valueP, decompRootP->store.Tbool.valueP);
break;
case 'd':
xmlrpc_read_double(envP, valueP, decompRootP->store.Tdouble.valueP);
break;
case 't':
xmlrpc_read_datetime_sec(envP, valueP,
decompRootP->store.TdatetimeT.valueP);
break;
case '8':
readDatetime8Str(envP, valueP, decompRootP->store.Tdatetime8.valueP,
oldstyleMemMgmt);
break;
case 's':
if (decompRootP->store.Tstring.sizeP)
readStringLp(envP, valueP,
decompRootP->store.Tstring.sizeP,
decompRootP->store.Tstring.valueP,
oldstyleMemMgmt);
else
readString(envP, valueP, decompRootP->store.Tstring.valueP,
oldstyleMemMgmt);
break;
case 'w':
#if HAVE_UNICODE_WCHAR
if (decompRootP->store.Tstring.sizeP)
readStringWLp(envP, valueP,
decompRootP->store.TwideString.sizeP,
decompRootP->store.TwideString.valueP,
oldstyleMemMgmt);
else
readStringW(envP, valueP, decompRootP->store.TwideString.valueP,
oldstyleMemMgmt);
#else
XMLRPC_ASSERT(false);
#endif /* HAVE_UNICODE_WCHAR */
break;
case '6':
readBase64(envP, valueP,
decompRootP->store.TbitString.sizeP,
decompRootP->store.TbitString.valueP,
oldstyleMemMgmt);
break;
case 'n':
xmlrpc_read_nil(envP, valueP);
break;
case 'I':
xmlrpc_read_i8(envP, valueP, decompRootP->store.Ti8.valueP);
break;
case 'p':
xmlrpc_read_cptr(envP, valueP, decompRootP->store.Tcptr.valueP);
break;
case 'V':
*decompRootP->store.Tvalue.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
break;
case 'A':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the 'A' specifier requires type ARRAY",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else {
*decompRootP->store.TarrayVal.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
}
break;
case 'S':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the 'S' specifier requires type STRUCT.",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else {
*decompRootP->store.TstructVal.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
}
break;
case '(':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the '(...)' specifier requires type ARRAY",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else
parsearray(envP, valueP, decompRootP->store.Tarray,
oldstyleMemMgmt);
break;
case '{':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the '{...}' specifier requires type STRUCT",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else
parsestruct(envP, valueP, decompRootP->store.Tstruct,
oldstyleMemMgmt);
break;
default:
/* Every format character that is allowed in a decomposition tree
node is handled above.
*/
XMLRPC_ASSERT(false);
}
}
void getDataBlock(xmlrpc_env * envP,
xmlrpc_value * DataStructP,
xmlrpc_value ** OutDataStructPP) {
xmlrpc_value * ID_t, * PORT_t, * DATA_t, * IP_t;
xmlrpc_struct_find_value(envP, DataStructP, "ID", &ID_t);
xmlrpc_struct_find_value(envP, DataStructP, "IP", &IP_t);
xmlrpc_struct_find_value(envP, DataStructP, "PORT", &PORT_t);
xmlrpc_struct_find_value(envP, DataStructP, "DATA", &DATA_t);
xmlrpc_int ID, PORT, DATA;
char* IP;
xmlrpc_read_int(envP, ID_t, &ID);
xmlrpc_read_string(envP, IP_t, &IP);
xmlrpc_read_int(envP, PORT_t, &PORT);
xmlrpc_read_int(envP, DATA_t, &DATA);
xmlrpc_DECREF(ID_t);
xmlrpc_DECREF(IP_t);
xmlrpc_DECREF(PORT_t);
xmlrpc_DECREF(DATA_t);
printf("The value of ID is %d\n", ID);
printf("The value of ID is %s\n", IP);
printf("The value of PORT is %d\n", PORT);
printf("The value of DATA is %d\n", DATA);
xmlrpc_value * ID_out, * IP_out, * PORT_out, * DATA_out, *DATAP_out;
xmlrpc_value * ID1_out, * IP1_out, * PORT1_out, * DATA1_out, *DATAP1_out;
xmlrpc_value * ID2_out, * IP2_out, * PORT2_out, * DATA2_out, *DATAP2_out;
xmlrpc_value * structArray;
structArray = xmlrpc_array_new(envP);
ID_out = xmlrpc_int_new(envP, 78654);
IP_out = xmlrpc_string_new(envP, "127.0.0.1");
PORT_out = xmlrpc_int_new(envP, 8090);
DATA_out = xmlrpc_int_new(envP, 45425);
ID1_out = xmlrpc_int_new(envP, 78764);
IP1_out = xmlrpc_string_new(envP, "127.0.0.1");
PORT1_out = xmlrpc_int_new(envP, 8091);
DATA1_out = xmlrpc_int_new(envP, 452135);
ID2_out = xmlrpc_int_new(envP, 78123);
IP2_out = xmlrpc_string_new(envP, "127.0.0.1");
PORT2_out = xmlrpc_int_new(envP, 8092);
DATA2_out = xmlrpc_int_new(envP, 45563);
DATAP_out = xmlrpc_struct_new(envP);
DATAP1_out = xmlrpc_struct_new(envP);
DATAP2_out = xmlrpc_struct_new(envP);
xmlrpc_struct_set_value(envP, DATAP_out, "ID", ID_out);
xmlrpc_struct_set_value(envP, DATAP_out, "IP", IP_out);
xmlrpc_struct_set_value(envP, DATAP_out, "PORT", PORT_out);
xmlrpc_struct_set_value(envP, DATAP_out, "DATA", DATA_out);
xmlrpc_struct_set_value(envP, DATAP1_out, "ID", ID1_out);
xmlrpc_struct_set_value(envP, DATAP1_out, "IP", IP1_out);
xmlrpc_struct_set_value(envP, DATAP1_out, "PORT", PORT1_out);
xmlrpc_struct_set_value(envP, DATAP1_out, "DATA", DATA1_out);
xmlrpc_struct_set_value(envP, DATAP2_out, "ID", ID2_out);
xmlrpc_struct_set_value(envP, DATAP2_out, "IP", IP2_out);
xmlrpc_struct_set_value(envP, DATAP2_out, "PORT", PORT2_out);
xmlrpc_struct_set_value(envP, DATAP2_out, "DATA", DATA2_out);
xmlrpc_array_append_item(envP, structArray, DATAP_out);
xmlrpc_array_append_item(envP, structArray, DATAP1_out);
xmlrpc_array_append_item(envP, structArray, DATAP2_out);
xmlrpc_DECREF(ID_out);
xmlrpc_DECREF(IP_out);
xmlrpc_DECREF(PORT_out);
xmlrpc_DECREF(DATA_out);
xmlrpc_DECREF(ID1_out);
xmlrpc_DECREF(IP1_out);
xmlrpc_DECREF(PORT1_out);
xmlrpc_DECREF(DATA1_out);
xmlrpc_DECREF(ID2_out);
xmlrpc_DECREF(IP2_out);
xmlrpc_DECREF(PORT2_out);
xmlrpc_DECREF(DATA2_out);
*OutDataStructPP = structArray;
}
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;
}
