void xr_setBoolInResult (void *data, int val) { CallerP c = (Caller *) data; if (c->result) xmlrpc_DECREF (c->result); if (!xr_errstat) c->result = xmlrpc_bool_new (c->env, (xmlrpc_bool)val); }
/**************************************************************************** ** Set result for the caller. These procedures are used in the method ** implementation to create a result object and append values. The ** server then unpacks the result array when building the array for ** the return. ***************************************************************************** */ void xr_setIntInResult (void *data, int val) { CallerP c = (Caller *) data; if (c->result) xmlrpc_DECREF (c->result); if (!xr_errstat) c->result = xmlrpc_int_new (c->env, val); }
void xr_setDoubleInResult (void *data, double val) { CallerP c = (Caller *) data; if (c->result) xmlrpc_DECREF (c->result); if (!xr_errstat) c->result = xmlrpc_double_new (c->env, val); }
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; }
static void test_serialize_double(void) { /* Test serialize of a double. */ xmlrpc_env env; xmlrpc_value * v; xmlrpc_mem_block *output; char * result; /* serialized result, as asciiz string */ size_t resultLength; /* Length in characters of the serialized result */ float serializedValue; char nextChar; int itemsMatched; xmlrpc_env_init(&env); /* Build a double to serialize */ v = xmlrpc_build_value(&env, "d", 3.14159); TEST_NO_FAULT(&env); /* Serialize the value. */ output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, &env, 0); TEST_NO_FAULT(&env); xmlrpc_serialize_value(&env, output, v); TEST_NO_FAULT(&env); /* Make sure we serialized the correct value. Note that because doubles aren't precise, this might serialize as 3.1415899999 or something like that. So we check it arithmetically. */ resultLength = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output); result = malloc(resultLength + 1); memcpy(result, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output), resultLength); result[resultLength] = '\0'; itemsMatched = sscanf(result, "<value><double>%f</double></value>\r\n%c", &serializedValue, &nextChar); TEST(itemsMatched == 1); TEST(serializedValue - 3.14159 < .000001); /* We'd like to test more precision, but sscanf doesn't do doubles */ free(result); /* Clean up our value. */ XMLRPC_TYPED_MEM_BLOCK_FREE(char, output); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_value_array(void) { xmlrpc_value *v; xmlrpc_env env; size_t len; xmlrpc_value * itemP; /* Basic array-building test. */ xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_ARRAY), "ARRAY")); v = xmlrpc_array_new(&env); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v)); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 0); itemP = xmlrpc_int_new(&env, 7); TEST_NO_FAULT(&env); xmlrpc_array_append_item(&env, v, itemP); TEST_NO_FAULT(&env); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 1); xmlrpc_DECREF(itemP); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "()"); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v)); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 0); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_value_string_wide_build(void) { xmlrpc_env env; xmlrpc_value * valueP; const wchar_t * wcs; size_t len; xmlrpc_env_init(&env); /* Build with build_value w# */ valueP = xmlrpc_build_value(&env, "w#", wcs_data, (size_t)3); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Verify it */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_DECREF(valueP); /* Build with build_value w */ valueP = xmlrpc_build_value(&env, "w", wcs_data); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Verify it */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_DECREF(valueP); }
xmlrpc_value * server_status(xmlrpc_env * envP, struct call_info *cip, char ** statusp) { xmlrpc_value *resultP = NULL; struct client_method_info *cmi = NULL; struct meths_tab *meth = NULL; struct call_info *cip_status = callinfo_clone(cip); cip_status->files = NULL; cip_status->methodargs = NULL; cip_status->method = "status"; if (!(meth = meths(cip_status->method, strlen(cip_status->method)))) { fprintf(stderr, "oracc-client: unknown method name `%s'\n", cip_status->method); exit(1); } cmi = meth->info; meth->info->instance = cip_status; resultP = cmi->call(envP, cmi); dieIfFaultOccurred(envP); if (resultP) { char *str = NULL; xmlrpc_value *status = NULL; xmlrpc_struct_find_value(envP, resultP, "method-status", &status); if (status) { trace(); xmlrpc_read_string(envP, status, (const char **)&str); /* This diagnostic needs to be suppressable */ fprintf(stderr, "server-status: status=%s\n", str); *statusp = NULL; if (!strcmp(str, "completed")) return resultP; } else { fprintf(stderr, "!server-status: no method-status\n"); *statusp = "no method status returned by status request"; /* should return an error condition to caller here so that when server bombs/loses session client can terminate gracefully */ } } else *statusp = "!no result from status request"; /* Dispose of our result value. */ xmlrpc_DECREF(resultP); return NULL; }
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 test_value_string_no_null(void) { xmlrpc_value * v; xmlrpc_env env; const char * str; size_t len; /* Test strings (without '\0' bytes). */ xmlrpc_env_init(&env); v = xmlrpc_string_new(&env, test_string_1); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v)); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(strcmp(str, test_string_1) == 0); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_build_value(&env, "s", test_string_1); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "s", &str); TEST_NO_FAULT(&env); TEST(strcmp(str, test_string_1) == 0); strfree(str); xmlrpc_decompose_value(&env, v, "s#", &str, &len); TEST_NO_FAULT(&env); TEST(memcmp(str, test_string_1, strlen(test_string_1)) == 0); TEST(strlen(str) == strlen(test_string_1)); strfree(str); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
void xr_setStructInResult (void *data, int snum) { CallerP c = (Caller *) data; extern int res_snum; res_snum = snum; if (c->result) xmlrpc_DECREF (c->result); if (!xr_errstat) c->result = xr_getSParam (snum); }
char * xr_getDatetimeFromParam (void *data, int index) { CallerP c = (Caller *) data; xmlrpc_value *val = xr_getArrValue (c->param, index); const char *s; xmlrpc_read_datetime_str (c->env, val, &s); xmlrpc_DECREF (val); return (((xr_errstat=c->env->fault_occurred) ? (char *)NULL : (char *)s)); }
int xr_getBoolFromParam (void *data, int index) { CallerP c = (Caller *) data; xmlrpc_value *val = xr_getArrValue (c->param, index); xmlrpc_bool bval; xmlrpc_read_bool (c->env, val, &bval); xmlrpc_DECREF (val); return ( ((xr_errstat=c->env->fault_occurred) ? (int)NULL : bval) ); }
double xr_getDoubleFromParam (void *data, int index) { CallerP c = (Caller *) data; xmlrpc_value *val = xr_getArrValue (c->param, index); double dval; xmlrpc_read_double (c->env, val, &dval); xmlrpc_DECREF (val); return ( ((xr_errstat=c->env->fault_occurred) ? (double)0.0 : dval) ); }
void LogEvent_clean() { #ifdef DEFINE_XMLRPC /* Dispose of our result value. */ xmlrpc_DECREF(_xmlrpc_result); /* Clean up our error-handling environment. */ xmlrpc_env_clean(&_xmlrpc_env); /* Shutdown our XML-RPC client library. */ xmlrpc_client_cleanup(); #endif /* DEFINE_XMLRPC */ }
static void testOneDouble(double const value) { /* Test serialize of a double. */ xmlrpc_env env; xmlrpc_value * valueP; xmlrpc_mem_block * serializedP; char * result; /* serialized result, as asciiz string */ size_t resultLength; /* Length in characters of the serialized result */ double serializedValue; char nextChar; int itemsMatched; xmlrpc_env_init(&env); /* Build a double to serialize */ valueP = xmlrpc_double_new(&env, value); TEST_NO_FAULT(&env); /* Serialize the value. */ serializedP = XMLRPC_MEMBLOCK_NEW(char, &env, 0); TEST_NO_FAULT(&env); xmlrpc_serialize_value(&env, serializedP, valueP); TEST_NO_FAULT(&env); /* Make sure we serialized the correct value. Note that because doubles aren't precise, this might serialize as 3.1415899999 or something like that. So we check it arithmetically. */ resultLength = XMLRPC_MEMBLOCK_SIZE(char, serializedP); result = malloc(resultLength + 1); memcpy(result, XMLRPC_MEMBLOCK_CONTENTS(char, serializedP), resultLength); result[resultLength] = '\0'; itemsMatched = sscanf(result, "<value><double>%lf</double></value>\r\n%c", &serializedValue, &nextChar); TEST(itemsMatched == 1); TESTFLOATEQUAL(serializedValue, value); free(result); /* Clean up our value. */ XMLRPC_TYPED_MEM_BLOCK_FREE(char, serializedP); xmlrpc_DECREF(valueP); xmlrpc_env_clean(&env); }
void xmlrpc_set_struct_string( xmlrpc_env * const envP, xmlrpc_value *pstruct, const char *key, const char *val ) { xmlrpc_value *str_val = xmlrpc_string_new( envP, val ); assertValue( str_val ); xmlrpc_struct_set_value( envP, pstruct, key, str_val ); xmlrpc_DECREF( str_val ); }
void xmlrpc_set_struct_int( xmlrpc_env * const envP, xmlrpc_value *pstruct, const char *key, int val ) { xmlrpc_value *int_val = xmlrpc_int_new( envP, val ); assertValue( int_val ); xmlrpc_struct_set_value( envP, pstruct, key, int_val ); xmlrpc_DECREF( int_val ); }
void xr_setArrayInResult (void *data, int anum) { CallerP c = (Caller *) data; extern int res_anum; res_anum = anum; if (c->result) xmlrpc_DECREF (c->result); if (!xr_errstat) c->result = xr_getAElement (anum); }
static void stop_flows(const char* address) { xmlrpc_env env; xmlrpc_client *client = 0; xmlrpc_value * resultP = 0; int port = DEFAULT_LISTEN_PORT; bool is_ipv6 = false; char *arg, *url = 0; int rc; char *rpc_address = arg = strdup(address); struct sockaddr_in6 source_in6; source_in6.sin6_family = AF_INET6; parse_rpc_address(&rpc_address, &port, &is_ipv6); if (is_ipv6 && (inet_pton(AF_INET6, rpc_address, (char*)&source_in6.sin6_addr) <= 0)) errx("invalid IPv6 address '%s' for RPC", rpc_address); if (port < 1 || port > 65535) errx("invalid port for RPC"); if (is_ipv6) rc = asprintf(&url, "http://[%s]:%d/RPC2", rpc_address, port); else rc = asprintf(&url, "http://%s:%d/RPC2", rpc_address, port); if (rc==-1) critx("failed to build RPC URL"); printf("Stopping all flows on %s\n", url); /* Stop the flows */ xmlrpc_env_init(&env); xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, "Flowgrind", FLOWGRIND_VERSION, NULL, 0, &client); if (env.fault_occurred) goto cleanup; xmlrpc_client_call2f(&env, client, url, "stop_flow", &resultP, "({s:i})", "flow_id", -1); /* -1 stops all flows */ if (resultP) xmlrpc_DECREF(resultP); cleanup: if (env.fault_occurred) { warnx("could not stop flows on %s: %s (%d)", url, env.fault_string, env.fault_code); } if (client) xmlrpc_client_destroy(client); xmlrpc_env_clean(&env); free_all(arg, url); }
static void interpretFaultValue(xmlrpc_env * const envP, xmlrpc_value * const faultVP, int * const faultCodeP, const char ** const faultStringP) { if (faultVP->_type != XMLRPC_TYPE_STRUCT) setParseFault(envP, "<value> element of <fault> response is not " "of structure type"); else { xmlrpc_value * faultCodeVP; xmlrpc_env fvEnv; xmlrpc_env_init(&fvEnv); xmlrpc_struct_read_value(&fvEnv, faultVP, "faultCode", &faultCodeVP); if (!fvEnv.fault_occurred) { interpretFaultCode(&fvEnv, faultCodeVP, faultCodeP); if (!fvEnv.fault_occurred) { xmlrpc_value * faultStringVP; xmlrpc_struct_read_value(&fvEnv, faultVP, "faultString", &faultStringVP); if (!fvEnv.fault_occurred) { interpretFaultString(&fvEnv, faultStringVP, faultStringP); xmlrpc_DECREF(faultStringVP); } } xmlrpc_DECREF(faultCodeVP); } if (fvEnv.fault_occurred) setParseFault(envP, "Invalid struct for <fault> value. %s", fvEnv.fault_string); xmlrpc_env_clean(&fvEnv); } }
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); }
static void parseCallChildren(xmlrpc_env * const envP, xml_element * const callElemP, const char ** const methodNameP, xmlrpc_value ** const paramArrayPP ) { /*---------------------------------------------------------------------------- Parse the children of a <methodCall> XML element *callElemP. They should be <methodName> and <params>. -----------------------------------------------------------------------------*/ size_t const callChildCount = xml_element_children_size(callElemP); xml_element * nameElemP; XMLRPC_ASSERT(xmlrpc_streq(xml_element_name(callElemP), "methodCall")); nameElemP = getChildByName(envP, callElemP, "methodName"); if (!envP->fault_occurred) { parseMethodNameElement(envP, nameElemP, methodNameP); if (!envP->fault_occurred) { /* Convert our parameters. */ if (callChildCount > 1) { xml_element * paramsElemP; paramsElemP = getChildByName(envP, callElemP, "params"); if (!envP->fault_occurred) *paramArrayPP = convertParams(envP, paramsElemP); } else { /* Workaround for Ruby XML-RPC and old versions of xmlrpc-epi. Future improvement: Instead of looking at child count, we should just check for existence of <params>. */ *paramArrayPP = xmlrpc_array_new(envP); } if (!envP->fault_occurred) { if (callChildCount > 2) setParseFault(envP, "<methodCall> has extraneous " "children, other than <methodName> and " "<params>. Total child count = %u", callChildCount); if (envP->fault_occurred) xmlrpc_DECREF(*paramArrayPP); } if (envP->fault_occurred) xmlrpc_strfree(*methodNameP); } } }
static void test_value_nil(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_env_init(&env); v = xmlrpc_nil_new(&env); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_NIL == xmlrpc_value_type(v)); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "n"); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_NIL == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "n"); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); xmlrpc_env_clean(&env); }
static void test_value_base64(void) { /* Test <base64> data. */ unsigned char const data1[5] = {'a', '\0', 'b', '\n', 'c'}; unsigned char const data2[3] = {'a', '\0', 'b'}; xmlrpc_value * v; xmlrpc_env env; const unsigned char * data; size_t len; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BASE64), "BASE64")); v = xmlrpc_base64_new(&env, sizeof(data1), data1); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v)); xmlrpc_read_base64(&env, v, &len, &data); TEST_NO_FAULT(&env); TEST(memeq(data, data1, sizeof(data1))); TEST(len == sizeof(data1)); xmlrpc_DECREF(v); free((void*)data); v = xmlrpc_build_value(&env, "6", data2, sizeof(data2)); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "6", &data, &len); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(len == sizeof(data2)); TEST(memeq(data, data1, sizeof(data2))); free((void *)data); xmlrpc_env_clean(&env); }
static void test_value_cptr(void) { int destroyConfirmation; xmlrpc_value * v; xmlrpc_env env; void * ptr; int myObject; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_C_PTR), "C_PTR")); myObject = 7; v = xmlrpc_cptr_new(&env, &myObject); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_C_PTR); xmlrpc_DECREF(v); v = xmlrpc_cptr_new_dtor(&env, &myObject, &destroyMyCptr, &destroyConfirmation); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_C_PTR); destroyConfirmation = 3; xmlrpc_DECREF(v); TEST(destroyConfirmation == 7); // the destructor has set this v = xmlrpc_build_value(&env, "p", (void*) 0x00000017); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_C_PTR == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "p", &ptr); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(ptr == (void*) 0x00000017); 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; }
static void test_value_int(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_int32 i; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_INT), "INT")); v = xmlrpc_int_new(&env, (xmlrpc_int32) 25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_INT); xmlrpc_read_int(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == 25); xmlrpc_DECREF(v); v = xmlrpc_int_new(&env, (xmlrpc_int32) -25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_INT); 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_value_type(v) == XMLRPC_TYPE_INT); xmlrpc_decompose_value(&env, v, "i", &i); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(i == 10); xmlrpc_env_clean(&env); }
/// Set to (different) pointer. /// /// Will decrement reference to current one. void set(xmlrpc_value *nval) { if (val) { #ifdef DEBUG_AUTOXMLRPCVALUE LOG_MSG("AutoXmlRpcValue 0x%lX released\n", (unsigned long)val); #endif xmlrpc_DECREF(val); } val = nval; #ifdef DEBUG_AUTOXMLRPCVALUE LOG_MSG("AutoXmlRpcValue 0x%lX\n", (unsigned long)val); #endif }
/* 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; }