/* 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; }