/**************************************
* XmlHandler
* Constructor
*************************************/
XmlHandler::XmlHandler(XmlHandlerCmd *cmd,void *user_data)
{
xmlrpc_env env;
//Build the enviroment
xmlrpc_env_init(&env);
//Creamos el registro
registry = xmlrpc_registry_new(&env);
//Clean env
xmlrpc_env_clean(&env);
//Append commands
while (cmd && cmd->name)
{
//Append methods
AddMethod(cmd->name,cmd->func,user_data);
//Next
cmd++;
}
}
static void
parseDouble(xmlrpc_env * const envP,
const char * const str,
xmlrpc_value ** const valuePP) {
/*----------------------------------------------------------------------------
Parse the content of a <double> XML-RPC XML element, e.g. "34.5".
'str' is that content.
-----------------------------------------------------------------------------*/
xmlrpc_env parseEnv;
double valueDouble;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(str);
xmlrpc_env_init(&parseEnv);
parseDoubleString(&parseEnv, str, &valueDouble);
if (parseEnv.fault_occurred) {
/* As an alternative, try a strtod() parsing. strtod()
accepts other forms, e.g. "3.4E6"; "3,4"; " 3.4". These
are not permitted by XML-RPC, but an almost-XML-RPC partner
might use one. In fact, for many years, Xmlrpc-c generated
such alternatives (by mistake).
*/
bool failed;
parseDoubleStringStrtod(str, &failed, &valueDouble);
if (failed)
setParseFault(envP, "<double> element value '%s' is not a valid "
"floating point number. %s",
str, parseEnv.fault_string);
}
if (!envP->fault_occurred)
*valuePP = xmlrpc_double_new(envP, valueDouble);
xmlrpc_env_clean(&parseEnv);
}
static void
test_serialize_methodResponse(void) {
/* Serialize a methodResponse. */
char const serialized_response[] =
XML_PROLOGUE
"<methodResponse>\r\n"
"<params>\r\n"
"<param><value><i4>30</i4></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
size_t size;
xmlrpc_env_init(&env);
output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 30);
TEST_NO_FAULT(&env);
xmlrpc_serialize_response(&env, output, v);
TEST_NO_FAULT(&env);
/* Make sure we serialized the correct value. */
size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
TEST(size == strlen(serialized_response));
TEST(memcmp(XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
serialized_response, size) == 0);
/* Clean up our methodResponse. */
xmlrpc_DECREF(v);
XMLRPC_TYPED_MEM_BLOCK_FREE(char, output);
xmlrpc_env_clean(&env);
}
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_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);
}
static void test_sample_files (void)
{
xmlrpc_env env;
char **paths, *path;
char *data;
size_t data_len;
const char *method_name;
xmlrpc_value *params;
xmlrpc_env_init(&env);
/* Test our good requests. */
for (paths = good_requests; *paths != NULL; paths++) {
path = *paths;
read_file(path, &data, &data_len);
xmlrpc_parse_call(&env, data, data_len, &method_name, ¶ms);
TEST_NO_FAULT(&env);
strfree(method_name);
xmlrpc_DECREF(params);
}
xmlrpc_env_clean(&env);
}
static void
test_value_cptr(void) {
xmlrpc_value * v;
xmlrpc_env env;
void * ptr;
/* Test C pointer storage using 'p'.
We don't have cleanup functions (yet).
*/
xmlrpc_env_init(&env);
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);
}
void
xmlrpc_client_init(int const flags,
const char * const appname,
const char * const appversion) {
/*----------------------------------------------------------------------------
This function is not thread-safe.
-----------------------------------------------------------------------------*/
struct xmlrpc_clientparms clientparms;
/* As our interface does not allow for failure, we just fail silently ! */
xmlrpc_env env;
xmlrpc_env_init(&env);
clientparms.transport = NULL;
/* The following call is not thread-safe */
xmlrpc_client_init2(&env, flags,
appname, appversion,
&clientparms, XMLRPC_CPSIZE(transport));
xmlrpc_env_clean(&env);
}
static void
test_serialize_struct(void) {
/* Serialize a simple struct. */
char const serialized_struct[] =
"<value><struct>\r\n" \
"<member><name><&></name>\r\n" \
"<value><i4>10</i4></value></member>\r\n" \
"</struct></value>";
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
size_t size;
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "{s:i}", "<&>", (xmlrpc_int32) 10);
TEST_NO_FAULT(&env);
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. */
size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
TEST(size == strlen(serialized_struct));
TEST(memcmp(XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
serialized_struct, size) == 0);
/* Clean up our struct. */
XMLRPC_TYPED_MEM_BLOCK_FREE(char, output);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_serialize_apache_response(void) {
char const serializedData[] =
XML_PROLOGUE
"<methodResponse " XMLNS_APACHE ">\r\n"
"<params>\r\n"
"<param><value><ex:i8>8</ex:i8></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_mem_block * outputP;
size_t size;
xmlrpc_env_init(&env);
resultP = xmlrpc_i8_new(&env, 8);
TEST_NO_FAULT(&env);
outputP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_response2(&env, outputP, resultP,
xmlrpc_dialect_apache);
TEST_NO_FAULT(&env);
size = XMLRPC_MEMBLOCK_SIZE(char, outputP);
TEST(size == strlen(serializedData));
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, outputP), serializedData, size));
XMLRPC_MEMBLOCK_FREE(char, outputP);
xmlrpc_DECREF(resultP);
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);
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(memcmp(data, data1, sizeof(data1)) == 0);
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(memcmp(data, data1, sizeof(data2)) == 0);
strfree(data);
xmlrpc_env_clean(&env);
}
static void
test_value_value(void) {
xmlrpc_value *v, *v2, *v3;
xmlrpc_env env;
/* Test 'V' with building and parsing. */
xmlrpc_env_init(&env);
v2 = xmlrpc_int_new(&env, (xmlrpc_int32) 5);
TEST_NO_FAULT(&env);
v = xmlrpc_build_value(&env, "V", v2);
TEST_NO_FAULT(&env);
TEST(v == v2);
xmlrpc_decompose_value(&env, v2, "V", &v3);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(v2 == v3);
xmlrpc_DECREF(v3);
xmlrpc_DECREF(v2);
xmlrpc_env_clean(&env);
}
static void
testParseBadResponseXmlRpc(void) {
/*----------------------------------------------------------------------------
Test parsing of data that is supposed to be a response, and is valid
XML, but is not valid XML-RPC.
-----------------------------------------------------------------------------*/
unsigned int i;
/* For this test, we test up to but not including the <value> in a
successful RPC response.
*/
/* Next, check for bogus responses. These are all well-formed XML, but
** they aren't legal XML-RPC. */
for (i = 15; bad_responses[i] != NULL; ++i) {
const char * const bad_resp = bad_responses[i];
xmlrpc_env env;
xmlrpc_value * v;
xml_element *elem;
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. */
v = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp));
TEST(env.fault_occurred);
TEST(env.fault_code != 0); /* We use 0 as a code in our bad faults. */
TEST(v == NULL);
xmlrpc_env_clean(&env);
}
}
int
main(int argc, const char ** argv) {
const char * xml;
xmlrpc_env env;
xml_element * elemP;
xmlrpc_env_init(&env);
xml = getStdin();
xml_parse(&env, xml, strlen(xml), &elemP);
if (env.fault_occurred)
printf("xml_parse failed. %s\n", env.fault_string);
else {
printf("Parsed successfully.\n");
describeXmlElement(elemP, "");
}
xmlrpc_env_clean(&env);
return 0;
}
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
validateParseResponseResult(xmlrpc_value * const valueP) {
xmlrpc_env env;
xmlrpc_value * s;
xmlrpc_int32 int_max;
xmlrpc_int32 int_min;
xmlrpc_int32 int_one;
xmlrpc_bool bool_false;
xmlrpc_bool bool_true;
char * str_hello;
char * str_untagged;
char * datetime;
unsigned char * b64_data;
size_t b64_len;
double negone;
double zero;
double one;
xmlrpc_env_init(&env);
xmlrpc_decompose_value(
&env, valueP, "((iibbs68())idddSs)",
&int_max, &int_min,
&bool_false, &bool_true, &str_hello,
&b64_data, &b64_len, &datetime,
&int_one, &negone, &zero, &one, &s, &str_untagged);
TEST_NO_FAULT(&env);
TEST(int_max == INT_MAX);
TEST(int_min == INT_MIN);
TEST(!bool_false);
TEST(bool_true);
TEST(strlen(str_hello) == strlen("Hello, world! <&>"));
TEST(streq(str_hello, "Hello, world! <&>"));
TEST(b64_len == 11);
TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
TEST(streq(datetime, "19980717T14:08:55"));
TEST(int_one == 1);
TEST(negone == -1.0);
TEST(zero == 0.0);
TEST(one == 1.0);
TEST(streq(str_untagged, "Untagged string"));
free(str_hello);
free(b64_data);
free(datetime);
free(str_untagged);
{
/* Analyze the contents of our struct. */
xmlrpc_value * sval;
int size, sval_int;
TEST(s != NULL);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 2);
sval = xmlrpc_struct_get_value(&env, s, "ten <&>");
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, sval, "i", &sval_int);
TEST_NO_FAULT(&env);
TEST(sval_int == 10);
sval = xmlrpc_struct_get_value(&env, s, "twenty");
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, sval, "i", &sval_int);
TEST_NO_FAULT(&env);
TEST(sval_int == 20);
xmlrpc_DECREF(s);
}
xmlrpc_env_clean(&env);
}
static void
testParseMiscSimpleValue(void) {
char const xmldata[] =
XML_PROLOGUE
"<methodCall>\r\n"
"<methodName>test</methodName>\r\n"
"<params>\r\n"
"<param><value><string>hello</string></value></param>\r\n"
"<param><value><boolean>0</boolean></value></param>\r\n"
"<param><value><boolean>1</boolean></value></param>\r\n"
"<param><value><dateTime.iso8601>19980717T14:08:55</dateTime.iso8601>"
"</value></param>\r\n"
"<param><value>"
"<dateTime.iso8601>19980717T14:08:55.123456</dateTime.iso8601>"
"</value></param>\r\n"
"<param><value><base64>YmFzZTY0IGRhdGE=</base64></value></param>\r\n"
"<param><value><nil/></value></param>\r\n"
"<param><value><ex:nil/></value></param>\r\n"
"</params>\r\n"
"</methodCall>\r\n";
xmlrpc_env env;
xmlrpc_value * paramArrayP;
const char * methodName;
int arraySize;
const char * str_hello;
xmlrpc_bool b_false, b_true;
const char * datetime_sec;
const char * datetime_usec;
unsigned char * b64_data;
size_t b64_len;
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, xmldata, strlen(xmldata),
&methodName, ¶mArrayP);
TEST_NO_FAULT(&env);
arraySize = xmlrpc_array_size(&env, paramArrayP);
TEST_NO_FAULT(&env);
TEST(arraySize == 8);
xmlrpc_decompose_value(
&env, paramArrayP, "(sbb886nn)",
&str_hello, &b_false, &b_true, &datetime_sec, &datetime_usec,
&b64_data, &b64_len);
TEST_NO_FAULT(&env);
TEST(streq(str_hello, "hello"));
TEST(!b_false);
TEST(b_true);
TEST(streq(datetime_sec, "19980717T14:08:55"));
TEST(streq(datetime_usec, "19980717T14:08:55.123456"));
TEST(b64_len == 11);
TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
free(b64_data);
strfree(str_hello);
strfree(datetime_sec);
strfree(datetime_usec);
xmlrpc_DECREF(paramArrayP);
strfree(methodName);
xmlrpc_env_clean(&env);
}
ArchiveDataClient::~ArchiveDataClient()
{
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
}
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_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_value_string_multiline(void) {
xmlrpc_env env;
xmlrpc_value * v;
const char * str;
size_t len;
xmlrpc_env_init(&env);
/* LF line ending */
v = xmlrpc_string_new(&env, "foo\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\n\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\n\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar\r\nbaz"));
strfree(str);
xmlrpc_DECREF(v);
/* CR line ending */
v = xmlrpc_string_new(&env, "foo\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar\rbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
xmlrpc_DECREF(v);
strfree(str);
/* CRLF line ending */
v = xmlrpc_string_new(&env, "foo\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\n\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar\r\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
xmlrpc_DECREF(v);
strfree(str);
/* Embedded null */
v = xmlrpc_string_new_lp(&env, 14, "foo\r\n\0bar\r\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string_lp(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 12);
TEST(memeq(str, "foo\n\0bar\nbaz", len));
strfree(str);
xmlrpc_read_string_lp_crlf(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 14);
TEST(memeq(str, "foo\r\n\0bar\r\nbaz", len));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_value_string_no_null(void) {
/* Test strings (without '\0' bytes). */
xmlrpc_value * v;
xmlrpc_env env;
const char * str;
size_t len;
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_STRING), "STRING"));
{
const char * const simpleAsciiString = "foo";
v = xmlrpc_string_new(&env, simpleAsciiString);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, simpleAsciiString));
xmlrpc_DECREF(v);
strfree(str);
}
{
const char * const utf8String = "KOŚĆ";
v = xmlrpc_string_new(&env, utf8String);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, utf8String));
xmlrpc_DECREF(v);
strfree(str);
}
v = xmlrpc_string_new_f(&env, "String %s, number %d", "xyz", 7);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "String xyz, number 7"));
xmlrpc_DECREF(v);
strfree(str);
v = test_string_new_va(&env, "String %s, number %d", "xyz", 7);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "String xyz, number 7"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s", "foo");
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(streq(str, "foo"));
strfree(str);
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(len == strlen("foo"));
TEST(xmlrpc_streq(str, "foo"));
TEST(strlen(str) == strlen("foo"));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
int main( int argc, char *argv[] )
{
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_value * keyP;
xmlrpc_value * valueP;
int struct_size;
int i, j;
size_t length;
const char * str_key_value;
xmlrpc_int int_key_value;
unsigned int max_hits = 0;
unsigned int rows = 0;
int rv;
char *uri;
int options; /* what kind of nodes should be processed */
int uri_pos; /* position of first non option argument */
char stropts[16];
int pos = 0;
int mask_length = 32; /* 32 means NO aggregate */
if (argc-1 < 1) {
print_help();
exit(0);
}
uri_pos = process_options(argc, argv, &options, &mask_length);
switch (options) {
case OPT_HOT:
sprintf(stropts, "HOT");
break;
case OPT_ALL:
sprintf(stropts, "ALL");
break;
case OPT_WARM:
sprintf(stropts, "WARM");
break;
}
printf("Nodes = %s\n", stropts);
printf("Mask = /%d\n", mask_length);
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* prototype:
xmlrpc_value * xmlrpc_client_call(xmlrpc_env * const envP,
const char * const server_url, const char * const method_name,
const char * const format, ...);
*/
asprintf(&uri, "http://%s/RPC2", argv[uri_pos]);
resultP = xmlrpc_client_call(&env, uri,
"pike.top",
"(s)", stropts);
free(uri);
die_if_fault_occurred_line(&env, __LINE__);
/* parse returned structure */
if ( xmlrpc_value_type(resultP) != XMLRPC_TYPE_STRUCT ) {
printf("unexpected result - should be structure\n");
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
exit(1);
}
struct_size = xmlrpc_struct_size(&env, resultP);
die_if_fault_occurred_line(&env, __LINE__);
// printf("Struct size: %d\n", struct_size);
if ( ! get_int_from_struct_by_name(resultP, MAX_HITS, &max_hits) ) {
fprintf(stderr, "ERROR: %s not foung in result\n", MAX_HITS);
exit (1);
}
printf("max_hits = %d\n", max_hits);
if ( ! get_int_from_struct_by_name(resultP, NUMBER_OF_ROWS, &rows) ) {
fprintf(stderr, "ERROR: %s not foung in result\n", NUMBER_OF_ROWS);
exit (1);
}
printf("rows = %d\n", rows);
TopItem top_items[rows];
TopItem *item; /* tmp item ptr */
TopItem *result_items = top_items; /* if no aggregation use this */
memset(top_items, 0, sizeof(top_items));
/* aggregated values */
if ( rows == 0 )
return 0;
for ( i = 0, item = top_items; i < rows; ++i, ++item ) {
if ( ! read_row(resultP, i, item) ) {
fprintf(stderr, "ERROR: while reading row number %d\n", i);
}
/* fill in ipv4 addr */
// printf("item[%d].ip_addr = %s, len = %d\n", i, item->ip_addr, strlen(item->ip_addr));
rv = inet_pton(AF_INET, item->ip_addr, &item->ipv4_addr);
if ( rv > 0 ) {
// printf("IPv4 addr: %x\n", item->ipv4_addr);
} else {
fprintf(stderr, "IP conversion failed - not an IPv4 address: '%s'\n", item->ip_addr); /* conversion failed from any reason */
printf("item[%d].ipv4_addr = %x\n", i, item->ipv4_addr);
}
}
assert( rows > 0 );
/* if IP mask length is shorter than 32 then aggregate list according to the mask */
if ( mask_length < 32 ) {
uint32_t ip_mask = htonl(mask(mask_length));
qsort(top_items, rows, sizeof(TopItem), compare_TopItem_ipv4_addr); /* sort by IPv4 */
/* skip items without ipv4 address */
i = 0; /* index of non aggregated items */
while (!top_items[i].ipv4_addr && i < rows ) {
printf("Skip item[%d] - do not has IPv4 address: %s\n", i, top_items[i].ip_addr);
memset(&top_items[i], 0, sizeof(TopItem));
++i;
}
j = 0; /* index of aggregated items */
if ( i == 0 )
++i;
top_items[0].ipv4_addr &= ip_mask;
top_items[0].num_of_ips = 1;
inet_ntop(AF_INET, &top_items[0].ipv4_addr, top_items[0].ip_addr, sizeof(top_items[0].ip_addr));
while ( i < rows ) {
top_items[i].ipv4_addr &= ip_mask;
if ( top_items[j].ipv4_addr == top_items[i].ipv4_addr ) {
top_items[j].leaf_hits[0] += top_items[i].leaf_hits[0];
top_items[j].leaf_hits[1] += top_items[i].leaf_hits[1];
++(top_items[j].num_of_ips);
++i;
}
else {
++j;
top_items[j] = top_items[i];
top_items[j].num_of_ips = 1;
inet_ntop(AF_INET, &top_items[j].ipv4_addr, top_items[j].ip_addr, sizeof(top_items[j].ip_addr));
++i;
}
}
rows = j + 1;
}
qsort(top_items, rows, sizeof(TopItem), compare_TopItem_hits_reverse);
print_rows( top_items, rows, mask_length );
/* 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;
}
static void
test_value_datetime_varytime(const char * const datestring,
time_t const datetime,
unsigned int const usec) {
xmlrpc_value * v;
xmlrpc_env env;
const char * readBackString;
time_t readBackDt;
unsigned int readBackUsec;
const char * datestringSec;
#if XMLRPC_HAVE_TIMEVAL
struct timeval const dtTimeval = makeTv(datetime, usec);
struct timeval readBackTv;
#endif
#if XMLRPC_HAVE_TIMESPEC
struct timespec const dtTimespec = makeTs(datetime, usec);
struct timespec readBackTs;
#endif
const char * const dt8601 = make8601(datetime, usec);
const char * readBack8601;
datestringSec = truncateFracSec(datestring);
xmlrpc_env_init(&env);
/* Test xmlrpc_datetime_new_str and time read functions*/
v = xmlrpc_datetime_new_str(&env, datestring);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_sec(&env, v, &readBackDt);
TEST_NO_FAULT(&env);
TEST(readBackDt == datetime);
xmlrpc_read_datetime_usec(&env, v, &readBackDt, &readBackUsec);
TEST_NO_FAULT(&env);
TEST(readBackDt == datetime);
TEST(readBackUsec == usec);
#if XMLRPC_HAVE_TIMEVAL
xmlrpc_read_datetime_timeval(&env, v, &readBackTv);
TEST_NO_FAULT(&env);
TEST(tvIsEqual(dtTimeval, readBackTv));
#endif
#if XMLRPC_HAVE_TIMESPEC
xmlrpc_read_datetime_timespec(&env, v, &readBackTs);
TEST_NO_FAULT(&env);
TEST(tsIsEqual(dtTimespec, readBackTs));
#endif
xmlrpc_read_datetime_8601(&env, v, &readBack8601);
TEST_NO_FAULT(&env);
TEST(xmlrpc_streq(dt8601, readBack8601));
strfree(readBack8601);
xmlrpc_DECREF(v);
/* Test xmlrpc_datetime_new_sec */
v = xmlrpc_datetime_new_sec(&env, datetime);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestringSec));
strfree(readBackString);
xmlrpc_DECREF(v);
/* Test xmlrpc_datetime_new_usec */
v = xmlrpc_datetime_new_usec(&env, datetime, usec);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#if XMLRPC_HAVE_TIMEVAL
/* Test xmlrpc_datetime_new_timeval */
v = xmlrpc_datetime_new_timeval(&env, dtTimeval);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#endif
#if XMLRPC_HAVE_TIMESPEC
/* Test xmlrpc_datetime_new_timespec */
v = xmlrpc_datetime_new_timespec(&env, dtTimespec);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#endif
xmlrpc_env_clean(&env);
strfree(datestringSec);
}
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
testParseNumberValue(void) {
char const xmldata[] =
XML_PROLOGUE
"<methodCall>\r\n"
"<methodName>test</methodName>\r\n"
"<params>\r\n"
"<param><value><int>2147483647</int></value></param>\r\n" \
"<param><value><int>-2147483648</int></value></param>\r\n" \
"<param><value><i1>10</i1></value></param>\r\n"
"<param><value><i2>10</i2></value></param>\r\n"
"<param><value><i4>10</i4></value></param>\r\n"
"<param><value><i8>10</i8></value></param>\r\n"
"<param><value><ex:i8>10</ex:i8></value></param>\r\n"
"<param><value><double>10</double></value></param>\r\n"
"<param><value><double>10.1</double></value></param>\r\n"
"<param><value><double>-10.1</double></value></param>\r\n"
"<param><value><double>+10.1</double></value></param>\r\n"
"<param><value><double>0</double></value></param>\r\n"
"<param><value><double>.01</double></value></param>\r\n"
"<param><value><double>5.</double></value></param>\r\n"
"<param><value><double>5.3E6</double></value></param>\r\n"
"<param><value><double> 1</double></value></param>\r\n"
"</params>\r\n"
"</methodCall>\r\n";
xmlrpc_env env;
xmlrpc_value * paramArrayP;
const char * methodName;
int arraySize;
xmlrpc_int int_max, int_min;
xmlrpc_int32 i_i1, i_i2, i_i4;
xmlrpc_int64 i_i8, i_ex_i8;
double d1, d2, d3, d4, d5, d6, d7, d8, d9;
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, xmldata, strlen(xmldata),
&methodName, ¶mArrayP);
TEST_NO_FAULT(&env);
arraySize = xmlrpc_array_size(&env, paramArrayP);
TEST_NO_FAULT(&env);
TEST(arraySize == 16);
xmlrpc_decompose_value(
&env, paramArrayP, "(iiiiiIIddddddddd)",
&int_max, &int_min, &i_i1, &i_i2, &i_i4, &i_i8, &i_ex_i8,
&d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9);
TEST_NO_FAULT(&env);
TEST(int_max == INT_MAX);
TEST(int_min == INT_MIN);
TEST(i_i1 == 10);
TEST(i_i2 == 10);
TEST(i_i4 == 10);
TEST(i_i8 == 10);
TEST(i_ex_i8 == 10);
TESTFLOATEQUAL(d1, 10.0);
TESTFLOATEQUAL(d2, 10.1);
TESTFLOATEQUAL(d3, -10.1);
TESTFLOATEQUAL(d4, +10.1);
TESTFLOATEQUAL(d5, 0.0);
TESTFLOATEQUAL(d6, 0.01);
TESTFLOATEQUAL(d7, 5.0);
TESTFLOATEQUAL(d8, 5.3E6);
TESTFLOATEQUAL(d9, 1.0);
xmlrpc_DECREF(paramArrayP);
strfree(methodName);
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);
}
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 */
}
void
test_value_datetime(void) {
const char * datestring = "19980717T14:08:55";
time_t const datetime = 900684535;
xmlrpc_env env;
printf("\n Running datetime value tests");
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_DATETIME), "DATETIME"));
test_value_datetime_basic();
/* Valid datetime, generated from XML-RPC string, time_t, and
time_t + microseconds
*/
test_value_datetime_varytime(datestring, datetime, 0);
/* test microseconds */
test_value_datetime_varytime("20000301T00:00:00.654321",
951868800, 654321);
test_value_datetime_varytime("20040229T23:59:59.123000",
1078099199, 123000);
test_value_datetime_varytime("20000229T23:59:59.000123",
951868799, 123);
/* Leap years */
test_value_datetime_varytime("20000229T23:59:59", 951868799, 0);
test_value_datetime_varytime("20000301T00:00:00", 951868800, 0);
test_value_datetime_varytime("20010228T23:59:59", 983404799, 0);
test_value_datetime_varytime("20010301T00:00:00", 983404800, 0);
test_value_datetime_varytime("20040229T23:59:59", 1078099199, 0);
test_value_datetime_varytime("20040301T00:00:00", 1078099200, 0);
/* Datetimes that can't be represented as time_t */
test_value_datetime_not_unix("19691231T23:59:59");
/* Invalid datetimes */
/* Note that the code today does a pretty weak job of validating datetimes,
so we test only the validation that we know is implemented.
*/
test_value_datetime_str_invalid1("19700101T25:00:00");
test_value_datetime_str_invalid1("19700101T10:61:01");
test_value_datetime_str_invalid1("19700101T10:59:61");
test_value_datetime_str_invalid1("19700001T10:00:00");
test_value_datetime_str_invalid1("19701301T10:00:00");
test_value_datetime_str_invalid1("19700132T10:00:00");
test_value_datetime_str_invalid2("19700132T10:00:00.");
test_value_datetime_str_invalid2("19700132T10:00:00,123");
test_build_decomp_datetime();
xmlrpc_env_clean(&env);
printf("\n");
printf(" datetime value tests done.\n");
}
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);
}
