mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-08-14 01:49:05 +00:00
merged new xmlrpc-c revision 1472 from https://xmlrpc-c.svn.sourceforge.net/svnroot/xmlrpc-c/trunk
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8545 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris
@@ -14,7 +14,6 @@
|
||||
#include "xmlrpc-c/base_int.h"
|
||||
|
||||
|
||||
|
||||
static void
|
||||
destroyValue(xmlrpc_value * const valueP) {
|
||||
|
||||
@@ -34,11 +33,7 @@ destroyValue(xmlrpc_value * const valueP) {
|
||||
break;
|
||||
|
||||
case XMLRPC_TYPE_STRING:
|
||||
#ifdef HAVE_UNICODE_WCHAR
|
||||
if (valueP->_wcs_block)
|
||||
xmlrpc_mem_block_free(valueP->_wcs_block);
|
||||
#endif /* HAVE_UNICODE_WCHAR */
|
||||
xmlrpc_mem_block_clean(&valueP->_block);
|
||||
xmlrpc_destroyString(valueP);
|
||||
break;
|
||||
|
||||
case XMLRPC_TYPE_BASE64:
|
||||
@@ -59,11 +54,14 @@ destroyValue(xmlrpc_value * const valueP) {
|
||||
case XMLRPC_TYPE_NIL:
|
||||
break;
|
||||
|
||||
case XMLRPC_TYPE_I8:
|
||||
break;
|
||||
|
||||
case XMLRPC_TYPE_DEAD:
|
||||
XMLRPC_ASSERT(FALSE); /* Can't happen, per entry conditions */
|
||||
XMLRPC_ASSERT(false); /* Can't happen, per entry conditions */
|
||||
|
||||
default:
|
||||
XMLRPC_ASSERT(FALSE); /* There are no other possible values */
|
||||
XMLRPC_ASSERT(false); /* There are no other possible values */
|
||||
}
|
||||
|
||||
/* Next, we mark this value as invalid, to help catch refcount
|
||||
@@ -115,9 +113,9 @@ xmlrpc_DECREF (xmlrpc_value * const valueP) {
|
||||
=========================================================================*/
|
||||
|
||||
const char *
|
||||
xmlrpc_typeName(xmlrpc_type const type) {
|
||||
xmlrpc_type_name(xmlrpc_type const type) {
|
||||
|
||||
switch(type) {
|
||||
switch (type) {
|
||||
|
||||
case XMLRPC_TYPE_INT: return "INT";
|
||||
case XMLRPC_TYPE_BOOL: return "BOOL";
|
||||
@@ -129,56 +127,15 @@ xmlrpc_typeName(xmlrpc_type const type) {
|
||||
case XMLRPC_TYPE_STRUCT: return "STRUCT";
|
||||
case XMLRPC_TYPE_C_PTR: return "C_PTR";
|
||||
case XMLRPC_TYPE_NIL: return "NIL";
|
||||
case XMLRPC_TYPE_I8: return "I8";
|
||||
case XMLRPC_TYPE_DEAD: return "DEAD";
|
||||
default: return "???";
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
verifyNoNulls(xmlrpc_env * const envP,
|
||||
const char * const contents,
|
||||
unsigned int const len) {
|
||||
/*----------------------------------------------------------------------------
|
||||
Verify that the character array 'contents', which is 'len' bytes long,
|
||||
does not contain any NUL characters, which means it can be made into
|
||||
a passable ASCIIZ string just by adding a terminating NUL.
|
||||
|
||||
Fail if the array contains a NUL.
|
||||
-----------------------------------------------------------------------------*/
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < len && !envP->fault_occurred; i++)
|
||||
if (contents[i] == '\0')
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_TYPE_ERROR,
|
||||
"String must not contain NUL characters");
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef HAVE_UNICODE_WCHAR
|
||||
|
||||
static void
|
||||
verifyNoNullsW(xmlrpc_env * const envP,
|
||||
const wchar_t * const contents,
|
||||
unsigned int const len) {
|
||||
/*----------------------------------------------------------------------------
|
||||
Same as verifyNoNulls(), but for wide characters.
|
||||
-----------------------------------------------------------------------------*/
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < len && !envP->fault_occurred; i++)
|
||||
if (contents[i] == '\0')
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_TYPE_ERROR,
|
||||
"String must not contain NUL characters");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
static void
|
||||
validateType(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
@@ -188,7 +145,7 @@ validateType(xmlrpc_env * const envP,
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_TYPE_ERROR, "Value of type %s supplied where "
|
||||
"type %s was expected.",
|
||||
xmlrpc_typeName(valueP->_type), xmlrpc_typeName(expectedType));
|
||||
xmlrpc_type_name(valueP->_type), xmlrpc_type_name(expectedType));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -239,270 +196,10 @@ xmlrpc_read_double(xmlrpc_env * const envP,
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* datetime stuff is in xmlrpc_datetime.c */
|
||||
|
||||
static void
|
||||
accessStringValue(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const char ** const contentsP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
unsigned int const size =
|
||||
XMLRPC_MEMBLOCK_SIZE(char, &valueP->_block);
|
||||
const char * const contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(char, &valueP->_block);
|
||||
unsigned int const len = size - 1;
|
||||
/* The memblock has a null character added to the end */
|
||||
|
||||
verifyNoNulls(envP, contents, len);
|
||||
|
||||
*lengthP = len;
|
||||
*contentsP = contents;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
const char ** const stringValueP) {
|
||||
/*----------------------------------------------------------------------------
|
||||
Read the value of an XML-RPC string as an ASCIIZ string.
|
||||
|
||||
Return the string in newly malloc'ed storage that Caller must free.
|
||||
|
||||
Fail if the string contains null characters (which means it wasn't
|
||||
really a string, but XML-RPC doesn't seem to understand what a string
|
||||
is, and such values are possible).
|
||||
-----------------------------------------------------------------------------*/
|
||||
size_t length;
|
||||
const char * contents;
|
||||
|
||||
accessStringValue(envP, valueP, &length, &contents);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
char * stringValue;
|
||||
|
||||
stringValue = malloc(length+1);
|
||||
if (stringValue == NULL)
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_INTERNAL_ERROR, "Unable to allocate space "
|
||||
"for %u-character string", length);
|
||||
else {
|
||||
memcpy(stringValue, contents, length);
|
||||
stringValue[length] = '\0';
|
||||
|
||||
*stringValueP = stringValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_old(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
const char ** const stringValueP) {
|
||||
|
||||
size_t length;
|
||||
accessStringValue(envP, valueP, &length, stringValueP);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_lp(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const char ** const stringValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
unsigned int const size =
|
||||
XMLRPC_MEMBLOCK_SIZE(char, &valueP->_block);
|
||||
const char * const contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(char, &valueP->_block);
|
||||
|
||||
char * stringValue;
|
||||
|
||||
stringValue = malloc(size);
|
||||
if (stringValue == NULL)
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_INTERNAL_ERROR, "Unable to allocate %u bytes "
|
||||
"for string.", size);
|
||||
else {
|
||||
memcpy(stringValue, contents, size);
|
||||
*stringValueP = stringValue;
|
||||
*lengthP = size - 1; /* Size includes terminating NUL */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_lp_old(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const char ** const stringValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
*lengthP = XMLRPC_MEMBLOCK_SIZE(char, &valueP->_block) - 1;
|
||||
*stringValueP = XMLRPC_MEMBLOCK_CONTENTS(char, &valueP->_block);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef HAVE_UNICODE_WCHAR
|
||||
static void
|
||||
setupWcsBlock(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP) {
|
||||
/*----------------------------------------------------------------------------
|
||||
Add a wcs block (wchar_t string) to the indicated xmlrpc_value if it
|
||||
doesn't have one already.
|
||||
-----------------------------------------------------------------------------*/
|
||||
if (!valueP->_wcs_block) {
|
||||
char * const contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(char, &valueP->_block);
|
||||
size_t const len =
|
||||
XMLRPC_MEMBLOCK_SIZE(char, &valueP->_block) - 1;
|
||||
valueP->_wcs_block =
|
||||
xmlrpc_utf8_to_wcs(envP, contents, len + 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
accessStringValueW(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const wchar_t ** const stringValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
setupWcsBlock(envP, valueP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
wchar_t * const wcontents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(wchar_t, valueP->_wcs_block);
|
||||
size_t const len =
|
||||
XMLRPC_MEMBLOCK_SIZE(wchar_t, valueP->_wcs_block) - 1;
|
||||
|
||||
verifyNoNullsW(envP, wcontents, len);
|
||||
|
||||
*lengthP = len;
|
||||
*stringValueP = wcontents;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_w(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP,
|
||||
const wchar_t ** const stringValueP) {
|
||||
|
||||
size_t length;
|
||||
const wchar_t * wcontents;
|
||||
|
||||
accessStringValueW(envP, valueP, &length, &wcontents);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
wchar_t * stringValue;
|
||||
stringValue = malloc((length + 1) * sizeof(wchar_t));
|
||||
if (stringValue == NULL)
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_INTERNAL_ERROR,
|
||||
"Unable to allocate space for %u-byte string",
|
||||
length);
|
||||
else {
|
||||
memcpy(stringValue, wcontents, length * sizeof(wchar_t));
|
||||
stringValue[length] = '\0';
|
||||
|
||||
*stringValueP = stringValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_w_old(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP,
|
||||
const wchar_t ** const stringValueP) {
|
||||
|
||||
size_t length;
|
||||
|
||||
accessStringValueW(envP, valueP, &length, stringValueP);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_w_lp(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const wchar_t ** const stringValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
setupWcsBlock(envP, valueP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
wchar_t * const wcontents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(wchar_t, valueP->_wcs_block);
|
||||
size_t const size =
|
||||
XMLRPC_MEMBLOCK_SIZE(wchar_t, valueP->_wcs_block);
|
||||
|
||||
wchar_t * stringValue;
|
||||
|
||||
stringValue = malloc(size * sizeof(wchar_t));
|
||||
if (stringValue == NULL)
|
||||
xmlrpc_env_set_fault_formatted(
|
||||
envP, XMLRPC_INTERNAL_ERROR,
|
||||
"Unable to allocate space for %u-byte string",
|
||||
size);
|
||||
else {
|
||||
memcpy(stringValue, wcontents, size * sizeof(wchar_t));
|
||||
|
||||
*lengthP = size - 1; /* size includes terminating NUL */
|
||||
*stringValueP = stringValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_string_w_lp_old(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP,
|
||||
size_t * const lengthP,
|
||||
const wchar_t ** const stringValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_STRING);
|
||||
if (!envP->fault_occurred) {
|
||||
setupWcsBlock(envP, valueP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
wchar_t * const wcontents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(wchar_t, valueP->_wcs_block);
|
||||
size_t const size =
|
||||
XMLRPC_MEMBLOCK_SIZE(wchar_t, valueP->_wcs_block);
|
||||
|
||||
*lengthP = size - 1; /* size includes terminatnig NUL */
|
||||
*stringValueP = wcontents;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
/* string stuff is in xmlrpc_string.c */
|
||||
|
||||
|
||||
|
||||
@@ -565,6 +262,18 @@ xmlrpc_read_base64_size(xmlrpc_env * const envP,
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_cptr(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
void ** const ptrValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_C_PTR);
|
||||
if (!envP->fault_occurred)
|
||||
*ptrValueP = valueP->_value.c_ptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_nil(xmlrpc_env * const envP,
|
||||
xmlrpc_value * const valueP) {
|
||||
@@ -578,19 +287,19 @@ xmlrpc_read_nil(xmlrpc_env * const envP,
|
||||
|
||||
|
||||
|
||||
void
|
||||
xmlrpc_read_cptr(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
void ** const ptrValueP) {
|
||||
void
|
||||
xmlrpc_read_i8(xmlrpc_env * const envP,
|
||||
const xmlrpc_value * const valueP,
|
||||
xmlrpc_int64 * const intValueP) {
|
||||
|
||||
validateType(envP, valueP, XMLRPC_TYPE_C_PTR);
|
||||
validateType(envP, valueP, XMLRPC_TYPE_I8);
|
||||
if (!envP->fault_occurred)
|
||||
*ptrValueP = valueP->_value.c_ptr;
|
||||
*intValueP = valueP->_value.i8;
|
||||
}
|
||||
|
||||
|
||||
|
||||
xmlrpc_type xmlrpc_value_type (xmlrpc_value* value)
|
||||
xmlrpc_type xmlrpc_value_type (xmlrpc_value* const value)
|
||||
{
|
||||
XMLRPC_ASSERT_VALUE_OK(value);
|
||||
return value->_type;
|
||||
@@ -637,6 +346,23 @@ xmlrpc_int_new(xmlrpc_env * const envP,
|
||||
|
||||
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_i8_new(xmlrpc_env * const envP,
|
||||
xmlrpc_int64 const value) {
|
||||
|
||||
xmlrpc_value * valP;
|
||||
|
||||
xmlrpc_createXmlrpcValue(envP, &valP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
valP->_type = XMLRPC_TYPE_I8;
|
||||
valP->_value.i8 = value;
|
||||
}
|
||||
return valP;
|
||||
}
|
||||
|
||||
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_bool_new(xmlrpc_env * const envP,
|
||||
xmlrpc_bool const value) {
|
||||
@@ -671,109 +397,6 @@ xmlrpc_double_new(xmlrpc_env * const envP,
|
||||
|
||||
|
||||
|
||||
#ifdef HAVE_UNICODE_WCHAR
|
||||
#define MAKE_WCS_BLOCK_NULL(val) ((val)->_wcs_block = NULL)
|
||||
#else
|
||||
#define MAKE_WCS_BLOCK_NULL(val) while (0) do {};
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_string_new_lp(xmlrpc_env * const envP,
|
||||
size_t const length,
|
||||
const char * const value) {
|
||||
|
||||
xmlrpc_value * valP;
|
||||
|
||||
xmlrpc_createXmlrpcValue(envP, &valP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
valP->_type = XMLRPC_TYPE_STRING;
|
||||
MAKE_WCS_BLOCK_NULL(valP);
|
||||
XMLRPC_MEMBLOCK_INIT(char, envP, &valP->_block, length + 1);
|
||||
if (!envP->fault_occurred) {
|
||||
char * const contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(char, &valP->_block);
|
||||
memcpy(contents, value, length);
|
||||
contents[length] = '\0';
|
||||
}
|
||||
if (envP->fault_occurred)
|
||||
free(valP);
|
||||
}
|
||||
return valP;
|
||||
}
|
||||
|
||||
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_string_new(xmlrpc_env * const envP,
|
||||
const char * const value) {
|
||||
|
||||
return xmlrpc_string_new_lp(envP, strlen(value), value);
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_UNICODE_WCHAR
|
||||
xmlrpc_value *
|
||||
xmlrpc_string_w_new_lp(xmlrpc_env * const envP,
|
||||
size_t const length,
|
||||
const wchar_t * const value) {
|
||||
|
||||
xmlrpc_value * valP;
|
||||
|
||||
/* Initialize our XML-RPC value. */
|
||||
xmlrpc_createXmlrpcValue(envP, &valP);
|
||||
|
||||
if (!envP->fault_occurred) {
|
||||
valP->_type = XMLRPC_TYPE_STRING;
|
||||
|
||||
/* Build our wchar_t block first. */
|
||||
valP->_wcs_block =
|
||||
XMLRPC_MEMBLOCK_NEW(wchar_t, envP, length + 1);
|
||||
if (!envP->fault_occurred) {
|
||||
wchar_t * const wcs_contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(wchar_t, valP->_wcs_block);
|
||||
|
||||
xmlrpc_mem_block * utf8_block;
|
||||
|
||||
memcpy(wcs_contents, value, length * sizeof(wchar_t));
|
||||
wcs_contents[length] = '\0';
|
||||
|
||||
/* Convert the wcs block to UTF-8. */
|
||||
utf8_block = xmlrpc_wcs_to_utf8(envP, wcs_contents, length + 1);
|
||||
if (!envP->fault_occurred) {
|
||||
char * const utf8_contents =
|
||||
XMLRPC_MEMBLOCK_CONTENTS(char, utf8_block);
|
||||
size_t const utf8_len = XMLRPC_MEMBLOCK_SIZE(char, utf8_block);
|
||||
|
||||
/* XXX - We need an extra memcopy to initialize _block. */
|
||||
XMLRPC_MEMBLOCK_INIT(char, envP, &valP->_block, utf8_len);
|
||||
if (!envP->fault_occurred) {
|
||||
char * contents;
|
||||
contents = XMLRPC_MEMBLOCK_CONTENTS(char, &valP->_block);
|
||||
memcpy(contents, utf8_contents, utf8_len);
|
||||
}
|
||||
XMLRPC_MEMBLOCK_FREE(char, utf8_block);
|
||||
}
|
||||
if (envP->fault_occurred)
|
||||
XMLRPC_MEMBLOCK_FREE(wchar_t, valP->_wcs_block);
|
||||
}
|
||||
if (envP->fault_occurred)
|
||||
free(valP);
|
||||
}
|
||||
return valP;
|
||||
}
|
||||
|
||||
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_string_w_new(xmlrpc_env * const envP,
|
||||
const wchar_t * const value) {
|
||||
return xmlrpc_string_w_new_lp(envP, wcslen(value), value);
|
||||
}
|
||||
#endif
|
||||
|
||||
xmlrpc_value *
|
||||
xmlrpc_base64_new(xmlrpc_env * const envP,
|
||||
size_t const length,
|
||||
|
||||
Reference in New Issue
Block a user