static void
test_value_i8(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_int64 i;
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_I8), "I8"));
v = xmlrpc_i8_new(&env, (xmlrpc_int64) 25);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8);
xmlrpc_read_i8(&env, v, &i);
TEST_NO_FAULT(&env);
TEST(i == 25);
xmlrpc_DECREF(v);
v = xmlrpc_i8_new(&env, (xmlrpc_int64) -25);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8);
xmlrpc_read_i8(&env, v, &i);
TEST_NO_FAULT(&env);
TEST(i == -25);
xmlrpc_DECREF(v);
v = xmlrpc_i8_new(&env, (xmlrpc_int64)1 << 40);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8);
xmlrpc_read_i8(&env, v, &i);
TEST_NO_FAULT(&env);
TEST(i == (xmlrpc_int64)1 << 40);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "I", (xmlrpc_int64) 10);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8);
xmlrpc_decompose_value(&env, v, "I", &i);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(i == 10);
xmlrpc_env_clean(&env);
}
static void get_int64(xmlrpc_value *value, int64_t *num) {
xmlrpc_int64 tmp;
assert(xmlrpc_value_type(value) == XMLRPC_TYPE_I8);
xmlrpc_read_i8(&env, value, &tmp);
check_fault();
*num = (int64_t) tmp;
}
value_i8::operator xmlrpc_int64() const {
xmlrpc_int64 retval;
env_wrap env;
xmlrpc_read_i8(&env.env_c, this->cValueP, &retval);
throwIfError(env);
return retval;
}
static void
decomposeValueWithTree(xmlrpc_env * const envP,
xmlrpc_value * const valueP,
bool const oldstyleMemMgmt,
const struct decompTreeNode * const decompRootP) {
/*----------------------------------------------------------------------------
Decompose XML-RPC value *valueP, given the decomposition tree
*decompRootP. The decomposition tree tells what structure *valueP
is expected to have and where to put the various components of it
(e.g. it says "it's an array of 3 integers. Put their values at
locations x, y, and z")
-----------------------------------------------------------------------------*/
switch (decompRootP->formatSpecChar) {
case '-':
/* There's nothing to validate or return */
break;
case 'i':
xmlrpc_read_int(envP, valueP, decompRootP->store.Tinteger.valueP);
break;
case 'b':
xmlrpc_read_bool(envP, valueP, decompRootP->store.Tbool.valueP);
break;
case 'd':
xmlrpc_read_double(envP, valueP, decompRootP->store.Tdouble.valueP);
break;
case 't':
xmlrpc_read_datetime_sec(envP, valueP,
decompRootP->store.TdatetimeT.valueP);
break;
case '8':
readDatetime8Str(envP, valueP, decompRootP->store.Tdatetime8.valueP,
oldstyleMemMgmt);
break;
case 's':
if (decompRootP->store.Tstring.sizeP)
readStringLp(envP, valueP,
decompRootP->store.Tstring.sizeP,
decompRootP->store.Tstring.valueP,
oldstyleMemMgmt);
else
readString(envP, valueP, decompRootP->store.Tstring.valueP,
oldstyleMemMgmt);
break;
case 'w':
#if HAVE_UNICODE_WCHAR
if (decompRootP->store.Tstring.sizeP)
readStringWLp(envP, valueP,
decompRootP->store.TwideString.sizeP,
decompRootP->store.TwideString.valueP,
oldstyleMemMgmt);
else
readStringW(envP, valueP, decompRootP->store.TwideString.valueP,
oldstyleMemMgmt);
#else
XMLRPC_ASSERT(false);
#endif /* HAVE_UNICODE_WCHAR */
break;
case '6':
readBase64(envP, valueP,
decompRootP->store.TbitString.sizeP,
decompRootP->store.TbitString.valueP,
oldstyleMemMgmt);
break;
case 'n':
xmlrpc_read_nil(envP, valueP);
break;
case 'I':
xmlrpc_read_i8(envP, valueP, decompRootP->store.Ti8.valueP);
break;
case 'p':
xmlrpc_read_cptr(envP, valueP, decompRootP->store.Tcptr.valueP);
break;
case 'V':
*decompRootP->store.Tvalue.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
break;
case 'A':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the 'A' specifier requires type ARRAY",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else {
*decompRootP->store.TarrayVal.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
}
break;
case 'S':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the 'S' specifier requires type STRUCT.",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else {
*decompRootP->store.TstructVal.valueP = valueP;
if (!oldstyleMemMgmt)
xmlrpc_INCREF(valueP);
}
break;
case '(':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the '(...)' specifier requires type ARRAY",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else
parsearray(envP, valueP, decompRootP->store.Tarray,
oldstyleMemMgmt);
break;
case '{':
if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type "
"%s, but the '{...}' specifier requires type STRUCT",
xmlrpc_type_name(xmlrpc_value_type(valueP)));
else
parsestruct(envP, valueP, decompRootP->store.Tstruct,
oldstyleMemMgmt);
break;
default:
/* Every format character that is allowed in a decomposition tree
node is handled above.
*/
XMLRPC_ASSERT(false);
}
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 number_of_links;
const char * const serverUrl = "http://localhost:4567/RPC2";
const char * const methodName = "get_number_of_links";
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFaultOccurred(&env);
printf("Making XMLRPC call to server url '%s' method '%s'\n", serverUrl, "get_number_of_links");
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_number_of_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &number_of_links);
dieIfFaultOccurred(&env);
printf("Number of links defined: %d\n", number_of_links);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
int array_size =xmlrpc_array_size(&env, resultP);
while(array_size>0) {
--array_size;
xmlrpc_value *value;
const char *link;
xmlrpc_array_read_item(&env, resultP, 0, &value);
xmlrpc_read_string(&env, value, &link);
printf("Link %u: %s\n", array_size, link);
xmlrpc_DECREF(value);
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "add_target", "(i)",
(xmlrpc_int32) 1);
xmlrpc_int64 targetID = 0;
xmlrpc_read_i8(&env, resultP, &targetID);
if(targetID) {
printf("New target added with ID: %"PRIx64"\n", targetID);
} else {
printf("Failed to add new target!\n");
goto done;
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "remove_target", "(i)",
(xmlrpc_int64) targetID);
xmlrpc_int32 res;
xmlrpc_read_int(&env, resultP, &res);
printf("Target %"PRIx64" remove: %"PRIx32"\n", targetID, res);
done:
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
