自学教程：C++ xmlrpc_DECREF函数代码示例

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

voidxr_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 voidtest_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 voidtest_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 voidtest_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 voidtest_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);}

voidxr_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));}

intxr_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) );}

doublexr_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 voidtestOneDouble(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);}

voidxmlrpc_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 );}

voidxmlrpc_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 );}

voidxr_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 voidinterpretFaultValue(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 voidtest_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 voidparseCallChildren(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 voidtest_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 voidtest_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 voidtest_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 voidtest_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);}

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