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; }