static void
test_value_invalid_struct(void) {
xmlrpc_value * v;
xmlrpc_env env;
/* Note that even though the format strings are invalid, we have
to supply the variable arguments that xmlrpc_build_value() will
be looking for as it tries to parse it. Otherwise, we get wild
memory references and consequent Valgrind flags.
*/
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "{s:ii", "key1", 9, 9);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{si:", "key1", 9);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{s", "key1");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void test_bounds_checks (void)
{
xmlrpc_env env;
xmlrpc_value *array;
int i1, i2, i3, i4;
/* Get an array to work with. */
xmlrpc_env_init(&env);
array = xmlrpc_build_value(&env, "(iii)", 100, 200, 300);
TEST_NO_FAULT(&env);
xmlrpc_env_clean(&env);
/* Test xmlrpc_decompose_value with too few values. */
xmlrpc_env_init(&env);
xmlrpc_decompose_value(&env, array, "(iiii)", &i1, &i2, &i3, &i4);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
/* Test xmlrpc_decompose_value with too many values. */
xmlrpc_env_init(&env);
xmlrpc_decompose_value(&env, array, "(ii)", &i1, &i2, &i3, &i4);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
/* Dispose of our array. */
xmlrpc_DECREF(array);
}
static void
testParseBadResponseXml(void) {
/*----------------------------------------------------------------------------
Test parsing of data that is supposed to be a response, but in not
even valid XML.
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * valueP;
int faultCode;
const char * faultString;
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env,
unparseable_value, strlen(unparseable_value),
&valueP, &faultCode, &faultString);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
/* And again with the old interface */
valueP = xmlrpc_parse_response(&env, unparseable_value,
strlen(unparseable_value));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env);
TEST(valueP == NULL);
}
static void
test_value_AS_typecheck(void) {
xmlrpc_env env;
xmlrpc_env env2;
xmlrpc_value *v;
xmlrpc_value *v2;
/* Test typechecks for 'A' and 'S'. */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "s", "foo");
TEST_NO_FAULT(&env);
xmlrpc_env_init(&env2);
xmlrpc_decompose_value(&env2, v, "A", &v2);
TEST_FAULT(&env2, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_env_init(&env2);
xmlrpc_decompose_value(&env2, v, "S", &v2);
TEST_FAULT(&env2, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
testObject(void) {
xmlrpc_env env;
xmlrpc_server_abyss_parms parms;
xmlrpc_server_abyss_t * serverP;
xmlrpc_registry * registryP;
xmlrpc_server_abyss_sig * oldHandlersP;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
parms.config_file_name = NULL;
parms.registryP = registryP;
serverP = NULL;
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Global init not done */
xmlrpc_server_abyss_global_init(&env);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_NO_FAULT(&env);
TEST(serverP != NULL);
xmlrpc_server_abyss_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_reset_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_use_sigchld(serverP);
xmlrpc_server_abyss_restore_sig(oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_destroy(serverP);
xmlrpc_registry_free(registryP);
xmlrpc_server_abyss_global_term();
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Not globally initialized */
xmlrpc_env_clean(&env);
}
static void
test_build_decomp_datetime(void) {
const char * datestring = "19980717T14:08:55";
time_t const datetime = 900684535;
xmlrpc_env env;
xmlrpc_value * v;
time_t dt;
const char * ds;
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "t", datetime);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
dt = 0;
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST(dt == datetime);
dt = 0;
xmlrpc_decompose_value(&env, v, "t", &dt);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(dt == datetime);
v = xmlrpc_int_new(&env, 9);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, v, "t", &dt);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_decompose_value(&env, v, "8", &ds);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "8", datestring);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
xmlrpc_decompose_value(&env, v, "8", &ds);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(streq(ds, datestring));
strfree(ds);
xmlrpc_env_clean(&env);
}
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
test_parse_xml_call(void) {
xmlrpc_env env;
const char *method_name;
xmlrpc_value *params;
int i1, i2;
const char **bad_call;
xml_element *elem;
xmlrpc_env_init(&env);
/* Parse a valid call. */
xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call),
&method_name, ¶ms);
TEST_NO_FAULT(&env);
TEST(params != NULL);
xmlrpc_decompose_value(&env, params, "(ii)", &i1, &i2);
xmlrpc_DECREF(params);
TEST_NO_FAULT(&env);
TEST(streq(method_name, "gloom&doom"));
TEST(i1 == 10 && i2 == 20);
strfree(method_name);
/* Test some poorly-formed XML data. */
xmlrpc_parse_call(&env, unparseable_value, strlen(unparseable_value),
&method_name, ¶ms);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
TEST(method_name == NULL && params == NULL);
/* Next, check for bogus values. These are all well-formed XML, but
they aren't legal XML-RPC.
*/
for (bad_call = bad_calls; *bad_call != NULL; ++bad_call) {
/* First, check to make sure that our test case is well-formed XML.
** (It's easy to make mistakes when writing the test cases!) */
xml_parse(&env, *bad_call, strlen(*bad_call), &elem);
TEST_NO_FAULT(&env);
xml_element_free(elem);
/* Now, make sure the higher-level routine barfs appropriately. */
xmlrpc_parse_call(&env, *bad_call, strlen(*bad_call),
&method_name, ¶ms);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
TEST(method_name == NULL && params == NULL);
}
xmlrpc_env_clean(&env);
}
static void
test_value_datetime_str_invalid1(const char * const datestring) {
/* Ideally, xmlrpc_datetime_new_str() would fail on these, but
the code doesn't implement that today. However,
xmlrpc_read_datetime_sec() does catch many cases, so we
use that.
Note that xmlrpc_read_datetime_sec() doesn't catch them all.
Sometimes it just returns garbage, e.g. returns July 1 for
June 31.
*/
xmlrpc_value * v;
xmlrpc_env env;
time_t dt;
xmlrpc_env_init(&env);
v = xmlrpc_datetime_new_str(&env, datestring);
TEST_NO_FAULT(&env);
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void test_nesting_limit (void)
{
xmlrpc_env env;
xmlrpc_value *val;
xmlrpc_env_init(&env);
/* Test with an adequate limit for a result value which is an
array which contains an element which is a struct, whose values
are simple: 3.
*/
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 3);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_NO_FAULT(&env);
TEST(val != NULL);
xmlrpc_DECREF(val);
/* Test with an inadequate limit. */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 2);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR); /* BREAKME - Will change. */
TEST(val == NULL);
/* Reset the default limit. */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, XMLRPC_NESTING_LIMIT_DEFAULT);
TEST(xmlrpc_limit_get(XMLRPC_NESTING_LIMIT_ID)
== XMLRPC_NESTING_LIMIT_DEFAULT);
xmlrpc_env_clean(&env);
}
static void
testStructReadout(xmlrpc_value * const structP,
unsigned int const expectedSize) {
xmlrpc_env env;
xmlrpc_value * keyP;
xmlrpc_value * valueP;
unsigned int index;
xmlrpc_env_init(&env);
for (index = 0; index < expectedSize; ++index) {
xmlrpc_struct_read_member(&env, structP, index, &keyP, &valueP);
TEST_NO_FAULT(&env);
xmlrpc_DECREF(keyP);
xmlrpc_DECREF(valueP);
}
xmlrpc_struct_read_member(&env, structP, expectedSize, &keyP, &valueP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
for (index = 0; index < expectedSize; ++index) {
xmlrpc_struct_get_key_and_value(&env, structP, index, &keyP, &valueP);
TEST_NO_FAULT(&env);
}
xmlrpc_env_clean(&env);
}
static void
testServerInfo(void) {
xmlrpc_env env;
xmlrpc_server_info * serverInfoP;
xmlrpc_server_info * serverInfo2P;
printf(" Running serverInfo tests...\n");
xmlrpc_env_init(&env);
serverInfoP = xmlrpc_server_info_new(&env, "testurl");
TEST_NO_FAULT(&env);
serverInfo2P = xmlrpc_server_info_copy(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_free(serverInfo2P);
/* Fails because we haven't set user/password yet: */
xmlrpc_server_info_allow_auth_basic(&env, serverInfoP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_server_info_set_basic_auth(&env, serverInfoP,
"username", "password");
TEST_NO_FAULT(&env);
xmlrpc_server_info_set_user(&env, serverInfoP, "username", "password");
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_basic(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_basic(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_digest(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_digest(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_negotiate(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_negotiate(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_ntlm(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_ntlm(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_free(serverInfoP);
xmlrpc_env_clean(&env);
}
static void
test_value_missing_array_delim(void) {
xmlrpc_value * v;
xmlrpc_env env;
/* Test missing close parenthesis on array */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "(");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "(i");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void
testParseBadResult(void) {
/*----------------------------------------------------------------------------
Test parsing of data that is supposed to be a response, but is not
valid. It looks like a valid success response, but the result value
is not valid XML-RPC.
-----------------------------------------------------------------------------*/
unsigned int i;
for (i = 0; bad_values[i] != NULL; ++i) {
const char * const bad_resp = bad_values[i];
xmlrpc_env env;
xmlrpc_value * valueP;
xml_element *elem;
int faultCode;
const char * faultString;
xmlrpc_env_init(&env);
/* First, check to make sure that our test case is well-formed XML.
** (It's easy to make mistakes when writing the test cases!) */
xml_parse(&env, bad_resp, strlen(bad_resp), &elem);
TEST_NO_FAULT(&env);
xml_element_free(elem);
/* Now, make sure the higher-level routine barfs appropriately. */
xmlrpc_parse_response2(&env, bad_resp, strlen(bad_resp),
&valueP, &faultCode, &faultString);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
/* And again with the old interface */
valueP = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
TEST(valueP == NULL);
xmlrpc_env_clean(&env);
}
}
static void
testSynchCall(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
xmlrpc_value * resultP;
xmlrpc_value * emptyArrayP;
xmlrpc_server_info * noSuchServerInfoP;
xmlrpc_env_init(&env);
emptyArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
noSuchServerInfoP = xmlrpc_server_info_new(&env, "nosuchserver");
TEST_NO_FAULT(&env);
xmlrpc_client_call2(&env, clientP, noSuchServerInfoP, "nosuchmethod",
emptyArrayP, &resultP);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_client_call2f(&env, clientP, "nosuchserver", "nosuchmethod",
&resultP, "(i)", 7);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_server_info_free(noSuchServerInfoP);
xmlrpc_client_destroy(clientP);
xmlrpc_DECREF(emptyArrayP);
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static void
test_value_datetime_str_invalid2(const char * const datestring) {
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_datetime_new_str(&env, datestring);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void
test_value_missing_struct_delim(void) {
xmlrpc_value * v;
xmlrpc_env env;
/* Test missing closing brace on struct */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "{");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{s:i", "key1", 7);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
v = xmlrpc_build_value(&env, "{s:i,s:i", "key1", 9, "key2", -4);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void
test_xml_size_limit(void) {
xmlrpc_env env;
const char * methodName;
xmlrpc_value * paramsP;
/* NOTE - This test suite only verifies the last-ditch size-checking
code. There should also be matching code in all server (and
preferably all client) modules as well.
*/
/* Set our XML size limit to something ridiculous. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 6);
/* Attempt to parse a call. */
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call),
&methodName, ¶msP);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
xmlrpc_env_clean(&env);
{
xmlrpc_value * resultP;
int faultCode;
const char * faultString;
/* Attempt to parse a response. */
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env,
good_response_xml, strlen(good_response_xml),
&resultP, &faultCode, &faultString);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
xmlrpc_env_clean(&env);
}
/* Reset the default limit. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, XMLRPC_XML_SIZE_LIMIT_DEFAULT);
}
static void
test_value_invalid_type(void) {
xmlrpc_value * v;
xmlrpc_env env;
/* Test invalid type specifier in format string */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "Q");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void
test_value_string_null(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_env env2;
const char * str;
size_t len;
/* Test a string with a '\0' byte. */
xmlrpc_env_init(&env);
v = xmlrpc_string_new_lp(&env, 7, "foo\0bar");
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_read_string_lp(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 7);
TEST(memeq(str, "foo\0bar", 7));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s#", "foo\0bar", (size_t) 7);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(memeq(str, "foo\0bar", 7));
TEST(len == 7);
strfree(str);
/* Test for type error when decoding a string with a zero byte to a
** regular C string. */
xmlrpc_env_init(&env2);
xmlrpc_decompose_value(&env2, v, "s", &str);
TEST_FAULT(&env2, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_value_datetime_not_unix(const char * const datestring) {
xmlrpc_value * v;
xmlrpc_env env;
time_t dt;
xmlrpc_env_init(&env);
v = xmlrpc_datetime_new_str(&env, datestring);
TEST_NO_FAULT(&env);
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_value_type_mismatch(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_env env2;
char * str;
/* Test for one, simple kind of type mismatch error. We assume that
** if one of these typechecks works, the rest work fine. */
xmlrpc_env_init(&env);
xmlrpc_env_init(&env2);
v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 5);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env2, v, "s", &str);
xmlrpc_DECREF(v);
TEST_FAULT(&env2, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_env_clean(&env);
}
static void
testFailedParseValue(void) {
xmlrpc_env env;
xmlrpc_value * valueP;
const char * stringval;
int integerval;
xmlrpc_env_init(&env);
valueP = xmlrpc_build_value(&env, "{s:s}", "string", "stringval");
TEST_NO_FAULT(&env);
/* Fail because "integer" member is missing */
xmlrpc_parse_value(&env, valueP, "{s:s,s:i,*}",
"string", &stringval, "integer", &integerval);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(valueP);
xmlrpc_env_clean(&env);
}
static void
test_utf8_coding(void) {
#if HAVE_UNICODE_WCHAR
xmlrpc_env env, env2;
utf8_and_wcs *good_data;
char **bad_data;
char *utf8;
wchar_t *wcs;
xmlrpc_mem_block *output;
xmlrpc_env_init(&env);
/* Test each of our valid UTF-8 sequences. */
for (good_data = good_utf8; good_data->utf8 != NULL; good_data++) {
utf8 = good_data->utf8;
wcs = good_data->wcs;
/* Attempt to validate the UTF-8 string. */
xmlrpc_validate_utf8(&env, utf8, strlen(utf8));
TEST_NO_FAULT(&env);
/* Attempt to decode the UTF-8 string. */
output = xmlrpc_utf8_to_wcs(&env, utf8, strlen(utf8));
TEST_NO_FAULT(&env);
TEST(output != NULL);
TEST(wcslen(wcs) == XMLRPC_TYPED_MEM_BLOCK_SIZE(wchar_t, output));
TEST(0 ==
wcsncmp(wcs, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(wchar_t, output),
wcslen(wcs)));
xmlrpc_mem_block_free(output);
/* Test the UTF-8 encoder, too. */
output = xmlrpc_wcs_to_utf8(&env, wcs, wcslen(wcs));
TEST_NO_FAULT(&env);
TEST(output != NULL);
TEST(strlen(utf8) == XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output));
TEST(0 ==
strncmp(utf8, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
strlen(utf8)));
xmlrpc_mem_block_free(output);
}
/* Test each of our illegal UTF-8 sequences. */
for (bad_data = bad_utf8; *bad_data != NULL; bad_data++) {
utf8 = *bad_data;
/* Attempt to validate the UTF-8 string. */
xmlrpc_env_init(&env2);
xmlrpc_validate_utf8(&env2, utf8, strlen(utf8));
TEST_FAULT(&env2, XMLRPC_INVALID_UTF8_ERROR);
/* printf("Fault: %s\n", env2.fault_string); --Hand-checked */
xmlrpc_env_clean(&env2);
/* Attempt to decode the UTF-8 string. */
xmlrpc_env_init(&env2);
output = xmlrpc_utf8_to_wcs(&env2, utf8, strlen(utf8));
TEST_FAULT(&env2, XMLRPC_INVALID_UTF8_ERROR);
TEST(output == NULL);
xmlrpc_env_clean(&env2);
}
xmlrpc_env_clean(&env);
#endif /* HAVE_UNICODE_WCHAR */
}
static void
test_value_array2(void) {
xmlrpc_value * arrayP;
xmlrpc_env env;
xmlrpc_int32 i, i1, i2, i3, i4, i5;
xmlrpc_value * itemP;
xmlrpc_value * subarrayP;
size_t len;
/* A more complex array. */
xmlrpc_env_init(&env);
arrayP = xmlrpc_build_value(&env, "(i(ii)i)",
(xmlrpc_int32) 10, (xmlrpc_int32) 20,
(xmlrpc_int32) 30, (xmlrpc_int32) 40);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
len = xmlrpc_array_size(&env, arrayP);
TEST_NO_FAULT(&env);
TEST(len == 3);
xmlrpc_array_read_item(&env, arrayP, 1, &subarrayP);
TEST_NO_FAULT(&env);
len = xmlrpc_array_size(&env, subarrayP);
TEST_NO_FAULT(&env);
TEST(len == 2);
xmlrpc_array_read_item(&env, subarrayP, 0, &itemP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
xmlrpc_DECREF(itemP);
TEST_NO_FAULT(&env);
TEST(i == 20);
xmlrpc_DECREF(subarrayP);
itemP = xmlrpc_array_get_item(&env, arrayP, 0);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
TEST_NO_FAULT(&env);
TEST(i == 10);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 30 && i4 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(i*)i)", &i1, &i2, &i3);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(ii*)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, arrayP, "(i(iii)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(i)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(iiQ)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i*",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Test bounds check on xmlrpc_array_get_item. */
xmlrpc_array_read_item(&env, arrayP, 3, &itemP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, 3);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, -1);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(arrayP);
xmlrpc_env_clean(&env);
}
static void
test_value_string_wide(void) {
#if HAVE_UNICODE_WCHAR
xmlrpc_env env;
xmlrpc_value * valueP;
const wchar_t * wcs;
size_t len;
xmlrpc_env_init(&env);
/* Build a string from wchar_t data. */
valueP = xmlrpc_string_w_new_lp(&env, 3, wcs_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
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_read_string_w(&env, valueP, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(wcs[3] == '\0');
TEST(wcsneq(wcs, wcs_data, 3));
free((void*)wcs);
xmlrpc_decompose_value(&env, valueP, "w#", &wcs, &len);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
{
/* Extract it as a UTF-8 string. */
const char * str;
size_t len;
xmlrpc_read_string_lp(&env, valueP, &len, &str);
TEST_NO_FAULT(&env);
TEST(str != NULL);
TEST(len == 4);
TEST(str[len] == '\0');
TEST(xmlrpc_strneq(str, utf8_data, len));
free((void*)str);
}
xmlrpc_DECREF(valueP);
/* Build from null-terminated wchar_t string */
valueP = xmlrpc_string_w_new(&env, 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);
test_value_string_wide_build();
/* Build a string from UTF-8 data. */
valueP = xmlrpc_string_new(&env, utf8_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == 0x0000);
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_DECREF(valueP);
/* Test with embedded NUL. We use a length of 4 so that the terminating
NUL actually becomes part of the string.
*/
valueP = xmlrpc_string_w_new_lp(&env, 4, wcs_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 4);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_read_string_w(&env, valueP, &wcs);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_DECREF(valueP);
test_value_string_wide_line();
xmlrpc_env_clean(&env);
#endif /* HAVE_UNICODE_WCHAR */
}
static void
test_struct_decompose_invalid_format_string(
xmlrpc_value * const testStructP) {
xmlrpc_env env;
xmlrpc_int32 ival;
xmlrpc_bool bval;
char * sval;
xmlrpc_env_init(&env);
/* Premature end of format string: */
xmlrpc_decompose_value(&env, testStructP, "{");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s", "baz");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s:", "baz");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s:", "baz");
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s:b", "baz", &bval);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s:b,", "baz", &bval);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, testStructP, "{s:b,*", "baz", &bval);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Key not 's' */
xmlrpc_decompose_value(&env, testStructP, "{i:s,s:i,*}",
"baz", &sval,
"foo", &ival);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Missing colon */
xmlrpc_decompose_value(&env, testStructP, "{is,s:i,*}",
"baz", &sval,
"foo", &ival);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Missing comma */
xmlrpc_decompose_value(&env, testStructP, "{i:ss:i,*}",
"baz", &sval,
"foo", &ival);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Undefined format specifier */
xmlrpc_decompose_value(&env, testStructP, "{s:Q,*}",
"baz", &sval);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* No * at end */
xmlrpc_decompose_value(&env, testStructP, "{s:b,s:s,s:i}",
"baz", &bval,
"foo", &sval,
"bar", &ival);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_env_clean(&env);
}
static void
test_struct (void) {
xmlrpc_env env;
xmlrpc_value * value1P;
xmlrpc_value *s, *i, *i1, *i2, *i3, *key, *value;
size_t size;
int present;
xmlrpc_bool bval;
char const weirdKey[] = {'f', 'o', 'o', '\0', 'b', 'a', 'r'};
xmlrpc_env_init(&env);
/* Create a struct. */
s = xmlrpc_struct_new(&env);
TEST_NO_FAULT(&env);
TEST(s != NULL);
TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(s));
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 0);
/* Create some elements to insert into our struct. */
i1 = xmlrpc_build_value(&env, "s", "Item #1");
TEST_NO_FAULT(&env);
i2 = xmlrpc_build_value(&env, "s", "Item #2");
TEST_NO_FAULT(&env);
i3 = xmlrpc_build_value(&env, "s", "Item #3");
TEST_NO_FAULT(&env);
/* Insert a single item. */
xmlrpc_struct_set_value(&env, s, "foo", i1);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 1);
/* Insert an item whose key has the same hash value as "foo". */
xmlrpc_struct_set_value(&env, s, "qmdebdw", i2);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 2);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i1);
i = xmlrpc_struct_get_value(&env, s, "qmdebdw");
TEST_NO_FAULT(&env);
TEST(i == i2);
/* Replace an existing element with a different element. */
xmlrpc_struct_set_value(&env, s, "foo", i3);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 2);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i3);
/* Insert an item with a NUL in the key */
xmlrpc_struct_set_value_n(&env, s, weirdKey, sizeof(weirdKey), i2);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
test_struct_get_element(s, i3, i2, weirdKey, sizeof(weirdKey));
/* Replace an existing element with the same element (tricky). */
xmlrpc_struct_set_value(&env, s, "foo", i3);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i3);
/* Test for the presence and absence of elements. */
present = xmlrpc_struct_has_key(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "qmdebdw");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "bogus");
TEST_NO_FAULT(&env);
TEST(!present);
/* Make sure our typechecks work correctly. */
xmlrpc_struct_size(&env, i1);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_has_key(&env, i1, "foo");
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_set_value(&env, i1, "foo", i2);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_set_value_v(&env, s, s, i2);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* Test cleanup code (w/memprof). */
xmlrpc_DECREF(s);
s = xmlrpc_build_value(&env, "{s:s,s:i,s:b}",
"foo", "Hello!",
"bar", (xmlrpc_int32) 1,
"baz", (xmlrpc_bool) 0);
TEST_NO_FAULT(&env);
TEST(s != NULL);
TEST(xmlrpc_value_type(s) == XMLRPC_TYPE_STRUCT);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
present = xmlrpc_struct_has_key(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "bar");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "baz");
TEST_NO_FAULT(&env);
TEST(present);
xmlrpc_struct_read_value(&env, s, "baz", &value1P);
TEST_NO_FAULT(&env);
xmlrpc_read_bool(&env, value1P, &bval);
TEST_NO_FAULT(&env);
TEST(!bval);
xmlrpc_DECREF(value1P);
testStructReadout(s, 3);
test_struct_decompose(s);
/* Test type check. */
xmlrpc_struct_get_key_and_value(&env, i1, 0, &key, &value);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
TEST(key == NULL && value == NULL);
/* Test bounds checks. */
xmlrpc_struct_get_key_and_value(&env, s, -1, &key, &value);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
TEST(key == NULL && value == NULL);
xmlrpc_struct_get_key_and_value(&env, s, 3, &key, &value);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
TEST(key == NULL && value == NULL);
/* Test cleanup code (w/memprof). */
xmlrpc_DECREF(s);
xmlrpc_DECREF(i1);
xmlrpc_DECREF(i2);
xmlrpc_DECREF(i3);
xmlrpc_env_clean(&env);
}
static void
test_struct_get_element(xmlrpc_value * const structP,
xmlrpc_value * const fooValueP,
xmlrpc_value * const weirdValueP,
const char * const weirdKey,
unsigned int const weirdKeyLen) {
xmlrpc_env env;
xmlrpc_value * valueP;
xmlrpc_value * fooStringP;
xmlrpc_value * bogusKeyStringP;
xmlrpc_env_init(&env);
/* build test tools */
fooStringP = xmlrpc_build_value(&env, "s", "foo");
TEST_NO_FAULT(&env);
bogusKeyStringP = xmlrpc_build_value(&env, "s", "doesn't_exist");
TEST_NO_FAULT(&env);
/* "find" interface */
xmlrpc_struct_find_value(&env, structP, "foo", &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == fooValueP);
xmlrpc_DECREF(valueP);
xmlrpc_struct_find_value(&env, structP, "doesn't_exist", &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == NULL);
xmlrpc_struct_find_value_v(&env, structP, fooStringP, &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == fooValueP);
xmlrpc_DECREF(valueP);
xmlrpc_struct_find_value_v(&env, structP, bogusKeyStringP, &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == NULL);
xmlrpc_struct_find_value(&env, fooValueP, "foo", &valueP);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* "read" interface */
xmlrpc_struct_read_value(&env, structP, "foo", &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == fooValueP);
xmlrpc_DECREF(valueP);
xmlrpc_struct_read_value(&env, structP, "doesn't_exist", &valueP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_struct_read_value_v(&env, structP, fooStringP, &valueP);
TEST_NO_FAULT(&env);
TEST(valueP == fooValueP);
xmlrpc_DECREF(valueP);
xmlrpc_struct_read_value_v(&env, structP, bogusKeyStringP, &valueP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_struct_read_value(&env, fooValueP, "foo", &valueP);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* obsolete "get" interface. Note that it does not update the
reference count of the xmlrpc_value it returns.
*/
valueP = xmlrpc_struct_get_value(&env, structP, "foo");
TEST_NO_FAULT(&env);
TEST(valueP == fooValueP);
valueP = xmlrpc_struct_get_value(&env, structP, "doesn't_exist");
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
valueP = xmlrpc_struct_get_value(&env, fooValueP, "foo");
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
valueP = xmlrpc_struct_get_value_n(&env, structP, weirdKey, weirdKeyLen);
TEST_NO_FAULT(&env);
TEST(valueP == weirdValueP);
/* Clean up */
xmlrpc_DECREF(fooStringP);
xmlrpc_DECREF(bogusKeyStringP);
xmlrpc_env_clean(&env);
}
static void
test_struct_decompose(xmlrpc_value * const testStructP) {
xmlrpc_env env;
xmlrpc_int32 ival;
xmlrpc_bool bval;
char * sval;
xmlrpc_value * topStructP;
xmlrpc_value * value1P;
xmlrpc_env_init(&env);
/* Make a test struct */
topStructP = xmlrpc_build_value(&env, "{s:S,s:s}",
"key1", testStructP,
"key2", "my_string_value");
TEST_NO_FAULT(&env);
test_struct_decompose_invalid_format_string(testStructP);
/* Decompose a struct */
xmlrpc_decompose_value(&env, testStructP, "{s:b,s:s,s:i,*}",
"baz", &bval,
"foo", &sval,
"bar", &ival);
TEST_NO_FAULT(&env);
TEST(ival == 1);
TEST(!bval);
TEST(streq(sval, "Hello!"));
free(sval);
/* Decompose a deep struct */
xmlrpc_decompose_value(&env, topStructP, "{s:S,*}", "key1", &value1P);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(value1P) == XMLRPC_TYPE_STRUCT);
xmlrpc_DECREF(value1P);
xmlrpc_decompose_value(&env, topStructP, "{s:{s:b,s:s,s:i,*},*}",
"key1",
"baz", &bval,
"foo", &sval,
"bar", &ival);
TEST_NO_FAULT(&env);
TEST(ival == 1);
TEST(!bval);
TEST(streq(sval, "Hello!"));
free(sval);
/* First value of wrong type */
xmlrpc_decompose_value(&env, testStructP, "{s:b,s:i,*}",
"baz", &sval,
"foo", &ival);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* Subsequent value of wrong type */
xmlrpc_decompose_value(&env, testStructP, "{s:s,s:i,*}",
"foo", &sval,
"baz", &bval);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* Nonexistent key */
xmlrpc_decompose_value(&env, testStructP, "{s:b,s:i,*}",
"baz", &bval,
"nosuch", &sval);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
/* Error subsequent to nested value */
xmlrpc_decompose_value(&env, topStructP, "{s:{s:s,*},s:i,*}",
"key1",
"foo", &sval,
"key2", &ival);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_DECREF(topStructP);
xmlrpc_env_clean(&env);
}
