void
xmlrpc_authcookie_set(xmlrpc_env *const envP,
const char *const username,
const char *const password) {
char *unencoded;
xmlrpc_mem_block *token;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(username);
XMLRPC_ASSERT_PTR_OK(password);
/* Create unencoded string/hash. */
MALLOCARRAY(unencoded, (strlen(username) + strlen(password) + 1 + 1));
sprintf(unencoded, "%s:%s", username, password);
/* Create encoded string. */
token = xmlrpc_base64_encode_without_newlines(
envP, (unsigned char *) unencoded, strlen(unencoded));
if (!envP->fault_occurred) {
/* Set HTTP_COOKIE_AUTH to the character representation of the
encoded string.
*/
#if HAVE_SETENV
setenv("HTTP_COOKIE_AUTH",
XMLRPC_MEMBLOCK_CONTENTS(char, token),
1);
#endif
xmlrpc_mem_block_free(token);
}
/* set cookie function */
void xmlrpc_authcookie_set ( xmlrpc_env *env,
const char *username,
const char *password ) {
char *unencoded;
xmlrpc_mem_block *token;
static char env_buffer[1024];
const char* block;
/* Check asserts. */
XMLRPC_ASSERT_ENV_OK(env);
XMLRPC_ASSERT_PTR_OK(username);
XMLRPC_ASSERT_PTR_OK(password);
/* Clear out memory. */
unencoded = (char *) malloc ( sizeof ( char * ) );
/* Create unencoded string/hash. */
sprintf(unencoded, "%s:%s", username, password);
/* Create encoded string. */
token = xmlrpc_base64_encode_without_newlines(env, (unsigned char*)unencoded,
strlen(unencoded));
XMLRPC_FAIL_IF_FAULT(env);
/* Set HTTP_COOKIE_AUTH to the character representation of the
** encoded string. */
block = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, token);
sprintf(env_buffer, "HTTP_COOKIE_AUTH=%s", block);
putenv(env_buffer);
cleanup:
if (token) xmlrpc_mem_block_free(token);
}
/* MRB-WARNING: Only call when you have successfully
** acquired the Lock/Unlock mutex! */
void register_asynch_thread (running_thread_list *list, pthread_t *thread)
{
running_thread_info* info = (running_thread_info *) malloc(sizeof(running_thread_info));
XMLRPC_ASSERT_PTR_OK(thread);
XMLRPC_ASSERT_PTR_OK(list);
tdbg_printf("register_asynch_thread: &pthread_id = %08X *(%08X)\n", thread, *thread);
info->_thread = *thread;
/* Insertion */
/* Lock (); */
if (list->AsyncThreadHead == NULL)
{
list->AsyncThreadHead = list->AsyncThreadTail = info;
list->AsyncThreadTail->Next = list->AsyncThreadHead->Next = NULL;
list->AsyncThreadTail->Last = list->AsyncThreadHead->Last = NULL;
}
else
{
info->Last = list->AsyncThreadTail;
list->AsyncThreadTail->Next = info;
list->AsyncThreadTail = list->AsyncThreadTail->Next;
list->AsyncThreadTail->Next = NULL;
}
/* Unlock (); */
}
static void
initRequestInfo(TRequestInfo * const requestInfoP,
httpVersion const httpVersion,
const char * const requestLine,
TMethod const httpMethod,
const char * const host,
unsigned int const port,
const char * const path,
const char * const query) {
/*----------------------------------------------------------------------------
Set up the request info structure. For information that is
controlled by headers, use the defaults -- I.e. the value that
applies if the request contains no applicable header.
-----------------------------------------------------------------------------*/
XMLRPC_ASSERT_PTR_OK(requestLine);
XMLRPC_ASSERT_PTR_OK(path);
requestInfoP->requestline = strdup(requestLine);
requestInfoP->method = httpMethod;
requestInfoP->host = xmlrpc_strdupnull(host);
requestInfoP->port = port;
requestInfoP->uri = strdup(path);
requestInfoP->query = xmlrpc_strdupnull(query);
requestInfoP->from = NULL;
requestInfoP->useragent = NULL;
requestInfoP->referer = NULL;
requestInfoP->user = NULL;
if (httpVersion.major > 1 ||
(httpVersion.major == 1 && httpVersion.minor >= 1))
requestInfoP->keepalive = TRUE;
else
requestInfoP->keepalive = FALSE;
}
void
xmlrpc_registry_set_preinvoke_method(xmlrpc_env *env,
xmlrpc_registry *registry,
xmlrpc_preinvoke_method handler,
void *user_data) {
xmlrpc_value *method_info;
XMLRPC_ASSERT_ENV_OK(env);
XMLRPC_ASSERT_PTR_OK(registry);
XMLRPC_ASSERT_PTR_OK(handler);
/* Error-handling preconditions. */
method_info = NULL;
/* Store our method and user data into our hash table. */
method_info = xmlrpc_build_value(env, "(pp)", (void*) handler, user_data);
XMLRPC_FAIL_IF_FAULT(env);
/* Dispose of any pre-existing preinvoke method and install ours. */
if (registry->_preinvoke_method)
xmlrpc_DECREF(registry->_preinvoke_method);
registry->_preinvoke_method = method_info;
cleanup:
if (env->fault_occurred) {
if (method_info)
xmlrpc_DECREF(method_info);
}
}
void
xmlrpc_registry_add_method_w_doc(xmlrpc_env *env,
xmlrpc_registry *registry,
const char *host,
const char *method_name,
xmlrpc_method method,
void *user_data,
const char *signature,
const char *help) {
xmlrpc_value *method_info;
XMLRPC_ASSERT_ENV_OK(env);
XMLRPC_ASSERT_PTR_OK(registry);
XMLRPC_ASSERT(host == NULL);
XMLRPC_ASSERT_PTR_OK(method_name);
XMLRPC_ASSERT_PTR_OK(method);
/* Error-handling preconditions. */
method_info = NULL;
/* Store our method and user data into our hash table. */
method_info = xmlrpc_build_value(env, "(ppss)", (void*) method, user_data,
signature, help);
XMLRPC_FAIL_IF_FAULT(env);
xmlrpc_struct_set_value(env, registry->_methods, method_name, method_info);
XMLRPC_FAIL_IF_FAULT(env);
cleanup:
if (method_info)
xmlrpc_DECREF(method_info);
}
/* MRB-WARNING: Only call when you have successfully
** acquired the Lock/Unlock mutex! */
void unregister_asynch_thread (running_thread_list *list, pthread_t *thread)
{
running_thread_info * pCur = NULL;
XMLRPC_ASSERT_PTR_OK(thread);
XMLRPC_ASSERT_PTR_OK(list);
tdbg_printf("unregister_asynch_thread: &pthread_id = %08X *(%08X)\n", thread, *thread);
/* Removal */
/* Lock (); */
for (pCur = list->AsyncThreadHead; pCur != NULL; pCur = (running_thread_info *)pCur->Next)
{
if (pCur->_thread == *thread)
{
if (pCur == list->AsyncThreadHead)
list->AsyncThreadHead = pCur->Next;
if (pCur == list->AsyncThreadTail)
list->AsyncThreadTail = pCur->Last;
if (pCur->Last)
((running_thread_info *)(pCur->Last))->Next = pCur->Next;
if (pCur->Next)
((running_thread_info *)(pCur->Next))->Last = pCur->Last;
/* Free malloc'd running_thread_info */
free (pCur);
return;
}
}
/* This is a serious progmatic error, since the thread
** should be in that list! */
XMLRPC_ASSERT_PTR_OK(0x0000);
/* Unlock (); */
}
xmlrpc_server_info *
xmlrpc_server_info_new(xmlrpc_env * const envP,
const char * const serverUrl) {
xmlrpc_server_info * serverInfoP;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(serverUrl);
MALLOCVAR(serverInfoP);
if (serverInfoP == NULL)
xmlrpc_faultf(envP, "Couldn't allocate memory for xmlrpc_server_info");
else {
serverInfoP->serverUrl = strdup(serverUrl);
if (serverInfoP->serverUrl == NULL)
xmlrpc_faultf(envP, "Couldn't allocate memory for server URL");
else {
serverInfoP->allowedAuth.basic = false;
serverInfoP->allowedAuth.digest = false;
serverInfoP->allowedAuth.gssnegotiate = false;
serverInfoP->allowedAuth.ntlm = false;
serverInfoP->userNamePw = NULL;
serverInfoP->basicAuthHdrValue = NULL;
if (envP->fault_occurred)
xmlrpc_strfree(serverInfoP->serverUrl);
}
if (envP->fault_occurred)
free(serverInfoP);
}
return serverInfoP;
}
static void
parseBase64(xmlrpc_env * const envP,
const char * const str,
size_t const strLength,
xmlrpc_value ** const valuePP) {
/*----------------------------------------------------------------------------
Parse the content of a <base64> XML-RPC XML element, e.g. "FD32YY".
'str' is that content.
-----------------------------------------------------------------------------*/
xmlrpc_mem_block * decoded;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(str);
decoded = xmlrpc_base64_decode(envP, str, strLength);
if (!envP->fault_occurred) {
unsigned char * const bytes =
XMLRPC_MEMBLOCK_CONTENTS(unsigned char, decoded);
size_t const byteCount =
XMLRPC_MEMBLOCK_SIZE(unsigned char, decoded);
*valuePP = xmlrpc_base64_new(envP, byteCount, bytes);
XMLRPC_MEMBLOCK_FREE(unsigned char, decoded);
}
void
xmlrpc_registry_disable_introspection(xmlrpc_registry * const registryP) {
XMLRPC_ASSERT_PTR_OK(registryP);
registryP->introspectionEnabled = false;
}
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);
}
}
}
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);
}
void
xmlrpc_server_info_set_user(xmlrpc_env * const envP,
xmlrpc_server_info * const serverInfoP,
const char * const username,
const char * const password) {
const char * userNamePw;
xmlrpc_mem_block * userNamePw64;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(serverInfoP);
XMLRPC_ASSERT_PTR_OK(username);
XMLRPC_ASSERT_PTR_OK(password);
xmlrpc_asprintf(&userNamePw, "%s:%s", username, password);
userNamePw64 =
xmlrpc_base64_encode_without_newlines(envP,
(unsigned char*) userNamePw,
strlen(userNamePw));
if (!envP->fault_occurred) {
const char * const data = XMLRPC_MEMBLOCK_CONTENTS(char, userNamePw64);
size_t const len = XMLRPC_MEMBLOCK_SIZE(char, userNamePw64);
const char * const authType = "Basic ";
char * hdrValue;
hdrValue = malloc(strlen(authType) + len + 1);
if (hdrValue == NULL)
xmlrpc_faultf(envP, "Could not allocate memory to store "
"authorization header value.");
else {
strcpy(hdrValue, authType);
strncat(hdrValue, data, len);
if (serverInfoP->basicAuthHdrValue)
xmlrpc_strfree(serverInfoP->basicAuthHdrValue);
serverInfoP->basicAuthHdrValue = hdrValue;
}
XMLRPC_MEMBLOCK_FREE(char, userNamePw64);
}
if (serverInfoP->userNamePw)
xmlrpc_strfree(serverInfoP->userNamePw);
serverInfoP->userNamePw = userNamePw;
}
void
xmlrpc_client_transport_call2(
xmlrpc_env * const envP,
xmlrpc_client * const clientP,
const xmlrpc_server_info * const serverP,
xmlrpc_mem_block * const callXmlP,
xmlrpc_mem_block ** const respXmlPP) {
XMLRPC_ASSERT_PTR_OK(clientP);
XMLRPC_ASSERT_PTR_OK(serverP);
XMLRPC_ASSERT_PTR_OK(callXmlP);
XMLRPC_ASSERT_PTR_OK(respXmlPP);
clientP->transportOps.call(
envP, clientP->transportP, serverP, callXmlP,
respXmlPP);
}
static void
parseInt(xmlrpc_env * const envP,
const char * const str,
xmlrpc_value ** const valuePP) {
/*----------------------------------------------------------------------------
Parse the content of a <int> XML-RPC XML element, e.g. "34".
'str' is that content.
-----------------------------------------------------------------------------*/
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(str);
if (str[0] == '\0')
setParseFault(envP, "<int> XML element content is empty");
else if (isspace(str[0]))
setParseFault(envP, "<int> content '%s' starts with white space",
str);
else {
long i;
char * tail;
errno = 0;
i = strtol(str, &tail, 10);
/* Look for ERANGE. */
if (errno == ERANGE)
setParseFault(envP, "<int> XML element value '%s' represents a "
"number beyond the range that "
"XML-RPC allows (%d - %d)", str,
XMLRPC_INT32_MIN, XMLRPC_INT32_MAX);
else if (errno != 0)
setParseFault(envP, "unexpected error parsing <int> XML element "
"value '%s'. strtol() failed with errno %d (%s)",
str, errno, strerror(errno));
else {
/* Look for out-of-range errors which didn't produce ERANGE. */
if (i < XMLRPC_INT32_MIN)
setParseFault(envP,
"<int> value %ld is below the range allowed "
"by XML-RPC (minimum is %d)",
i, XMLRPC_INT32_MIN);
else if (i > XMLRPC_INT32_MAX)
setParseFault(envP,
"<int> value %ld is above the range allowed "
"by XML-RPC (maximum is %d)",
i, XMLRPC_INT32_MAX);
else {
if (tail[0] != '\0')
setParseFault(envP,
"<int> value '%s' contains non-numerical "
"junk: '%s'", str, tail);
else
*valuePP = xmlrpc_int_new(envP, i);
}
}
}
}
void
xmlrpc_client_destroy(xmlrpc_client * const clientP) {
XMLRPC_ASSERT_PTR_OK(clientP);
if (clientP->myTransport)
clientP->transportOps.destroy(clientP->transportP);
free(clientP);
}
static void
clientCreate(
xmlrpc_env * const envP,
bool const myTransport,
const struct xmlrpc_client_transport_ops * const transportOpsP,
struct xmlrpc_client_transport * const transportP,
xmlrpc_dialect const dialect,
xmlrpc_progress_fn * const progressFn,
xmlrpc_client ** const clientPP) {
XMLRPC_ASSERT_PTR_OK(transportOpsP);
XMLRPC_ASSERT_PTR_OK(transportP);
XMLRPC_ASSERT_PTR_OK(clientPP);
if (constSetupCount == 0) {
xmlrpc_faultf(envP,
"You have not called "
"xmlrpc_client_setup_global_const().");
/* Impl note: We can't just call it now because it isn't
thread-safe.
*/
} else {
xmlrpc_client * clientP;
MALLOCVAR(clientP);
if (clientP == NULL)
xmlrpc_faultf(envP, "Unable to allocate memory for "
"client descriptor.");
else {
clientP->myTransport = myTransport;
clientP->transportOps = *transportOpsP;
clientP->transportP = transportP;
clientP->dialect = dialect;
clientP->progressFn = progressFn;
*clientPP = clientP;
}
}
}
void
xmlrpc_client_create(xmlrpc_env * const envP,
int const flags,
const char * const appname,
const char * const appversion,
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize,
xmlrpc_client ** const clientPP) {
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(clientPP);
if (constSetupCount == 0) {
xmlrpc_faultf(envP,
"You have not called "
"xmlrpc_client_setup_global_const().");
/* Impl note: We can't just call it now because it isn't
thread-safe.
*/
} else {
const char * transportName;
struct xportParms transportparms;
const struct xmlrpc_client_transport_ops * transportOpsP;
xmlrpc_client_transport * transportP;
xmlrpc_dialect dialect;
xmlrpc_progress_fn * progressFn;
getTransportInfo(envP, clientparmsP, parmSize, &transportName,
&transportparms, &transportOpsP, &transportP);
getDialectFromClientParms(clientparmsP, parmSize, &dialect);
progressFn = parmSize >= XMLRPC_CPSIZE(progressFn) ?
clientparmsP->progressFn : NULL;
if (!envP->fault_occurred) {
if (transportName)
createTransportAndClient(envP, transportName,
transportparms.parmsP,
transportparms.size,
flags, appname, appversion, dialect,
progressFn,
clientPP);
else {
bool myTransportFalse = false;
clientCreate(envP, myTransportFalse,
transportOpsP, transportP, dialect, progressFn,
clientPP);
}
}
}
}
static xmlrpc_value *
system_multicall(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const callInfo) {
xmlrpc_registry * registryP;
xmlrpc_value * resultsP;
xmlrpc_value * methlistP;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_ARRAY_OK(paramArrayP);
XMLRPC_ASSERT_PTR_OK(serverInfo);
resultsP = NULL; /* defeat compiler warning */
/* Turn our arguments into something more useful. */
registryP = (xmlrpc_registry*) serverInfo;
getMethListFromMulticallPlist(envP, paramArrayP, &methlistP);
if (!envP->fault_occurred) {
/* Create an initially empty result list. */
resultsP = xmlrpc_array_new(envP);
if (!envP->fault_occurred) {
/* Loop over our input list, calling each method in turn. */
unsigned int const methodCount =
xmlrpc_array_size(envP, methlistP);
unsigned int i;
for (i = 0; i < methodCount && !envP->fault_occurred; ++i) {
xmlrpc_value * const methinfoP =
xmlrpc_array_get_item(envP, methlistP, i);
xmlrpc_value * resultP;
XMLRPC_ASSERT_ENV_OK(envP);
callOneMethod(envP, registryP, methinfoP, callInfo, &resultP);
if (!envP->fault_occurred) {
/* Append this method result to our master array. */
xmlrpc_array_append_item(envP, resultsP, resultP);
xmlrpc_DECREF(resultP);
}
}
if (envP->fault_occurred)
xmlrpc_DECREF(resultsP);
xmlrpc_DECREF(methlistP);
}
}
return resultsP;
}
void
xmlrpc_registry_free(xmlrpc_registry * registry) {
XMLRPC_ASSERT_PTR_OK(registry);
XMLRPC_ASSERT(registry->_methods != XMLRPC_BAD_POINTER);
xmlrpc_DECREF(registry->_methods);
registry->_methods = XMLRPC_BAD_POINTER;
if (registry->_default_method != NULL)
xmlrpc_DECREF(registry->_default_method);
if (registry->_preinvoke_method != NULL)
xmlrpc_DECREF(registry->_preinvoke_method);
free(registry);
}
void
xmlrpc_server_info_free(xmlrpc_server_info * const serverInfoP) {
XMLRPC_ASSERT_PTR_OK(serverInfoP);
XMLRPC_ASSERT(serverInfoP->serverUrl != XMLRPC_BAD_POINTER);
if (serverInfoP->userNamePw)
xmlrpc_strfree(serverInfoP->userNamePw);
serverInfoP->userNamePw = XMLRPC_BAD_POINTER;
if (serverInfoP->basicAuthHdrValue)
xmlrpc_strfree(serverInfoP->basicAuthHdrValue);
serverInfoP->basicAuthHdrValue = XMLRPC_BAD_POINTER;
xmlrpc_strfree(serverInfoP->serverUrl);
serverInfoP->serverUrl = XMLRPC_BAD_POINTER;
free(serverInfoP);
}
static void
parseBoolean(xmlrpc_env * const envP,
const char * const str,
xmlrpc_value ** const valuePP) {
/*----------------------------------------------------------------------------
Parse the content of a <boolean> XML-RPC XML element, e.g. "1".
'str' is that content.
-----------------------------------------------------------------------------*/
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(str);
if (xmlrpc_streq(str, "0") || xmlrpc_streq(str, "1"))
*valuePP = xmlrpc_bool_new(envP, xmlrpc_streq(str, "1") ? 1 : 0);
else
setParseFault(envP, "<boolean> XML element content must be either "
"'0' or '1' according to XML-RPC. This one has '%s'",
str);
}
xmlrpc_server_info *
xmlrpc_server_info_copy(xmlrpc_env * const envP,
xmlrpc_server_info * const srcP) {
xmlrpc_server_info * serverInfoP;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(srcP);
MALLOCVAR(serverInfoP);
if (serverInfoP == NULL)
xmlrpc_faultf(envP,
"Couldn't allocate memory for xmlrpc_server_info");
else {
copyServerInfoContent(envP, serverInfoP, srcP);
if (envP->fault_occurred)
free(serverInfoP);
}
return serverInfoP;
}
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
decodeUtf8(xmlrpc_env *const envP,
const char *const utf8_data,
size_t const utf8_len,
wchar_t *const ioBuff,
size_t *const outBuffLenP) {
/*----------------------------------------------------------------------------
Decode to UCS-2 (or validate as UTF-8 that can be decoded to UCS-2)
a UTF-8 string. To validate, set ioBuff and outBuffLenP to NULL.
To decode, allocate a sufficiently large buffer, pass it as ioBuff,
and pass a pointer as as outBuffLenP. The data will be written to
the buffer, and the length to outBuffLenP.
We assume that wchar_t holds a single UCS-2 character in native-endian
byte ordering.
-----------------------------------------------------------------------------*/
size_t utf8Cursor;
size_t outPos;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(utf8_data);
XMLRPC_ASSERT((!ioBuff && !outBuffLenP) || (ioBuff && outBuffLenP));
for (utf8Cursor = 0, outPos = 0;
utf8Cursor < utf8_len && !envP->fault_occurred;
) {
char const init = utf8_data[utf8Cursor];
/* Initial byte of the UTF-8 sequence */
wchar_t wc;
if ((init & 0x80) == 0x00) {
/* Convert ASCII character to wide character. */
wc = init;
++utf8Cursor;
} else {
/* Look up the length of this UTF-8 sequence. */
size_t const length = utf8SeqLength[(unsigned char) init];
/* Special value 0 means no length could be determined because
it is not a valid initial byte for a UTF-8 sequence.
*/
if (length == 0)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_INVALID_UTF8_ERROR,
"Unrecognized UTF-8 initial byte value 0x%02x",
(unsigned char) init);
else {
/* Make sure we have enough bytes to convert. */
if (utf8Cursor + length > utf8_len) {
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_INVALID_UTF8_ERROR,
"Invalid UTF-8 sequence indicates a %u-byte sequence "
"when only %u bytes are left in the string",
(unsigned) length, (unsigned) (utf8_len - utf8Cursor));
} else {
decodeMultibyte(envP, &utf8_data[utf8Cursor], length, &wc);
/* Advance to the end of the sequence. */
utf8Cursor += length;
}
}
}
if (!envP->fault_occurred) {
/* If we have a buffer, write our character to it. */
if (ioBuff)
ioBuff[outPos++] = wc;
}
}
if (outBuffLenP)
*outBuffLenP = envP->fault_occurred ? 0 : outPos;
}
void
xmlrpc_registry_disable_introspection(xmlrpc_registry * registry) {
XMLRPC_ASSERT_PTR_OK(registry);
registry->_introspection_enabled = 0;
}
