int
xmlrpc_struct_size(xmlrpc_env * const envP,
xmlrpc_value * const structP) {
int retval;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_VALUE_OK(structP);
if (structP->_type != XMLRPC_TYPE_STRUCT) {
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value is not a struct. It is type #%d",
structP->_type);
retval = -1;
} else {
size_t const size =
XMLRPC_MEMBLOCK_SIZE(_struct_member, &structP->_block);
assert((size_t)(int)size == size);
/* Because structs are defined to have few enough members */
retval = (int)size;
}
return retval;
}
static void
makeCallXml(xmlrpc_env * const envP,
const char * const methodName,
xmlrpc_value * const paramArrayP,
xmlrpc_dialect const dialect,
xmlrpc_mem_block ** const callXmlPP) {
XMLRPC_ASSERT_VALUE_OK(paramArrayP);
XMLRPC_ASSERT_PTR_OK(callXmlPP);
if (methodName == NULL)
xmlrpc_faultf(envP, "method name argument is NULL pointer");
else {
xmlrpc_mem_block * callXmlP;
callXmlP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
if (!envP->fault_occurred) {
xmlrpc_serialize_call2(envP, callXmlP, methodName, paramArrayP,
dialect);
*callXmlPP = callXmlP;
if (envP->fault_occurred)
XMLRPC_MEMBLOCK_FREE(char, callXmlP);
}
}
}
static void
findMember(xmlrpc_value * const structP,
const char * const key,
size_t const keyLen,
bool * const foundP,
unsigned int * const indexP) {
size_t size, i;
uint32_t searchHash;
_struct_member * contents; /* array */
bool found;
size_t foundIndex; /* Meaningful only when 'found' is true */
XMLRPC_ASSERT_VALUE_OK(structP);
XMLRPC_ASSERT(key != NULL);
foundIndex = 0; /* defeat used-before-set compiler warning */
/* Look for our key. */
searchHash = hashStructKey(key, keyLen);
size = XMLRPC_MEMBLOCK_SIZE(_struct_member, &structP->_block);
contents = XMLRPC_MEMBLOCK_CONTENTS(_struct_member, &structP->_block);
for (i = 0, found = false; i < size && !found; ++i) {
if (contents[i].keyHash == searchHash) {
xmlrpc_value * const keyvalP = contents[i].key;
const char * const keystr =
XMLRPC_MEMBLOCK_CONTENTS(char, &keyvalP->_block);
size_t const keystrSize =
XMLRPC_MEMBLOCK_SIZE(char, &keyvalP->_block)-1;
if (keystrSize == keyLen && memcmp(key, keystr, keyLen) == 0) {
found = true;
foundIndex = i;
}
}
}
void
xmlrpc_INCREF (xmlrpc_value * const valueP) {
XMLRPC_ASSERT_VALUE_OK(valueP);
XMLRPC_ASSERT(valueP->_refcount > 0);
++valueP->_refcount;
}
void
xmlrpc_DECREF (xmlrpc_value * const valueP) {
XMLRPC_ASSERT_VALUE_OK(valueP);
XMLRPC_ASSERT(valueP->_refcount > 0);
XMLRPC_ASSERT(valueP->_type != XMLRPC_TYPE_DEAD);
valueP->_refcount--;
/* If we have no more refs, we need to deallocate this value. */
if (valueP->_refcount == 0)
destroyValue(valueP);
}
void
xmlrpc_client_call2(xmlrpc_env * const envP,
struct xmlrpc_client * const clientP,
const xmlrpc_server_info * const serverInfoP,
const char * const methodName,
xmlrpc_value * const paramArrayP,
xmlrpc_value ** const resultPP) {
xmlrpc_mem_block * callXmlP;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(clientP);
XMLRPC_ASSERT_PTR_OK(serverInfoP);
XMLRPC_ASSERT_PTR_OK(paramArrayP);
makeCallXml(envP, methodName, paramArrayP, clientP->dialect, &callXmlP);
if (!envP->fault_occurred) {
xmlrpc_mem_block * respXmlP;
xmlrpc_traceXml("XML-RPC CALL",
XMLRPC_MEMBLOCK_CONTENTS(char, callXmlP),
XMLRPC_MEMBLOCK_SIZE(char, callXmlP));
clientP->transportOps.call(
envP, clientP->transportP, serverInfoP, callXmlP, &respXmlP);
if (!envP->fault_occurred) {
int faultCode;
const char * faultString;
xmlrpc_traceXml("XML-RPC RESPONSE",
XMLRPC_MEMBLOCK_CONTENTS(char, respXmlP),
XMLRPC_MEMBLOCK_SIZE(char, respXmlP));
parseResponse(envP, respXmlP, resultPP, &faultCode, &faultString);
if (!envP->fault_occurred) {
if (faultString) {
xmlrpc_env_set_fault_formatted(
envP, faultCode,
"RPC failed at server. %s", faultString);
xmlrpc_strfree(faultString);
} else
XMLRPC_ASSERT_VALUE_OK(*resultPP);
}
XMLRPC_MEMBLOCK_FREE(char, respXmlP);
}
int
xmlrpc_array_size(xmlrpc_env * const envP,
const xmlrpc_value * const arrayP) {
int retval;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_VALUE_OK(arrayP);
if (arrayP->_type != XMLRPC_TYPE_ARRAY) {
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value is not an array");
retval = -1;
} else {
size_t const size =
XMLRPC_MEMBLOCK_SIZE(xmlrpc_value *, &arrayP->_block);
assert((size_t)(int)(size) == size);
retval = (int)size;
}
return retval;
}
void
xmlrpc_array_append_item(xmlrpc_env * const envP,
xmlrpc_value * const arrayP,
xmlrpc_value * const valueP) {
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_VALUE_OK(arrayP);
if (xmlrpc_value_type(arrayP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value is not an array");
else {
size_t const size =
XMLRPC_MEMBLOCK_SIZE(xmlrpc_value *, &arrayP->_block);
XMLRPC_MEMBLOCK_RESIZE(xmlrpc_value *, envP, &arrayP->_block, size+1);
if (!envP->fault_occurred) {
xmlrpc_value ** const contents =
XMLRPC_MEMBLOCK_CONTENTS(xmlrpc_value*, &arrayP->_block);
xmlrpc_INCREF(valueP);
contents[size] = valueP;
}
}
