/* typically, most developer time will be spent writing these types of functions. */
XMLRPC_VALUE hello_callback(XMLRPC_SERVER server, XMLRPC_REQUEST request, void* userData)
{
char buf[1024];
#ifdef VERBOSE
XMLRPC_VALUE xParams = XMLRPC_RequestGetData(request); // obtain method params from request
XMLRPC_VALUE xFirstParam = XMLRPC_VectorRewind(xParams); // obtain first parameter
const char * name = XMLRPC_GetValueString(xFirstParam); // get string value
#else
const char* name = XMLRPC_GetValueString(XMLRPC_VectorRewind(XMLRPC_RequestGetData(request)));
#endif
snprintf(buf, sizeof(buf), "hello %s", name ? name : "stranger");
return XMLRPC_CreateValueString(NULL, buf, 0);
}
/*
* This handler takes a single parameter, which is an array containing
* between 100 and 200 elements. Each of the items is a string, your handler
* must return a string containing the concatenated text of the first and
* last elements.
*/
XMLRPC_VALUE validator1_moderateSizeArrayCheck (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xReturn = NULL;
simplestring buf;
simplestring_init(&buf);
if(xRequest) {
XMLRPC_VALUE xArray = XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest));
if(xArray) {
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xArray), xPrev = 0;
simplestring_add(&buf, XMLRPC_GetValueString(xIter));
/* TODO: Should add XMLRPC_VectorLast() call. Much more efficient */
while(xIter) {
xPrev = xIter;
xIter = XMLRPC_VectorNext(xArray);
}
simplestring_add(&buf, XMLRPC_GetValueString(xPrev));
}
}
xReturn = XMLRPC_CreateValueString(0, buf.str, buf.len);
return xReturn;
}
XMLRPC_VALUE xsm_system_multicall_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
XMLRPC_VALUE xArray = XMLRPC_VectorRewind(XMLRPC_RequestGetData(input));
XMLRPC_VALUE xReturn = XMLRPC_CreateVector(0, xmlrpc_vector_array);
if (xArray) {
XMLRPC_VALUE xMethodIter = XMLRPC_VectorRewind(xArray);
while (xMethodIter) {
XMLRPC_REQUEST request = XMLRPC_RequestNew();
if(request) {
const char* methodName = XMLRPC_VectorGetStringWithID(xMethodIter, "methodName");
XMLRPC_VALUE params = XMLRPC_VectorGetValueWithID(xMethodIter, "params");
if(methodName && params) {
XMLRPC_VALUE xRandomArray = XMLRPC_CreateVector(0, xmlrpc_vector_array);
XMLRPC_RequestSetMethodName(request, methodName);
XMLRPC_RequestSetData(request, params);
XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
XMLRPC_AddValueToVector(xRandomArray,
XMLRPC_ServerCallMethod(server, request, userData));
XMLRPC_AddValueToVector(xReturn, xRandomArray);
}
XMLRPC_RequestFree(request, 1);
}
xMethodIter = XMLRPC_VectorNext(xArray);
}
}
return xReturn;
}
/*
* This handler takes a single parameter, a string, that contains any number
* of predefined entities, namely <, >, &, ' and ".
*
* Your handler must return a struct that contains five fields, all numbers:
* ctLeftAngleBrackets, ctRightAngleBrackets, ctAmpersands, ctApostrophes,
* ctQuotes.
*
* To validate, the numbers must be correct.
*/
XMLRPC_VALUE validator1_countTheEntities (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xStruct = XMLRPC_CreateVector(0, xmlrpc_vector_struct);
int counts[256] = {0};
//returns struct
if(xRequest) {
XMLRPC_VALUE xString = XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest));
const char* pString = XMLRPC_GetValueString(xString);
if(pString) {
const unsigned char* p = (const unsigned char*)pString;
while(p && *p != 0) {
counts[*p] ++;
p++;
}
}
}
XMLRPC_VectorAppendInt(xStruct, "ctLeftAngleBrackets", counts['<']);
XMLRPC_VectorAppendInt(xStruct, "ctRightAngleBrackets", counts['>']);
XMLRPC_VectorAppendInt(xStruct, "ctAmpersands", counts['&']);
XMLRPC_VectorAppendInt(xStruct, "ctApostrophes", counts['\'']);
XMLRPC_VectorAppendInt(xStruct, "ctQuotes", counts['"']);
return xStruct;
}
LLUserAuth::UserAuthcode LLUserAuth::parseResponse()
{
// The job of this function is to parse sCurlDownloadArea and
// extract every member into either the mResponses or
// mOptions. For now, we will only be looking at mResponses, which
// will all be string => string pairs.
UserAuthcode rv = E_UNHANDLED_ERROR;
XMLRPC_REQUEST response = mResponder->response();
if(!response)
{
U32 status = mResponder->getStatus();
// Is it an HTTP error?
if (!(200 <= status && status < 400))
{
rv = E_HTTP_SERVER_ERROR;
}
return rv;
}
// clear out any old parsing
mResponses.clear();
// Now, parse everything
XMLRPC_VALUE param = XMLRPC_RequestGetData(response);
if (! param)
{
lldebugs << "Response contains no data" << LL_ENDL;
return rv;
}
// Now, parse everything
mResponses = parseValues(rv, "", param);
return rv;
}
t_int XMLRPC::genericSDTSerialize(sourceType *_source)
{
return XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueInt(NULL, static_cast<int>(*_source))
);
}
bool XMLRPC::stringToBytes(const std::string* _source)
{
XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueString(NULL, _source->c_str(), _source->size())
);
return true;
}
bool XMLRPC::floatToBytes(const t_float* _source)
{
XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueDouble(NULL, (*_source))
);
return true;
}
bool XMLRPC::addByte(t_byte const _byte)
{
XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueInt(NULL, _byte)
);
success();
return true;
}
/* this complies with system.methodSignature as defined at
* http://xmlrpc.usefulinc.com/doc/sysmethodsig.html
*/
static XMLRPC_VALUE xi_system_method_signature_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
const char* method = XMLRPC_GetValueString(XMLRPC_VectorRewind(XMLRPC_RequestGetData(input)));
XMLRPC_VALUE xResponse = NULL;
/* lazy loading of introspection data */
check_docs_loaded(server, userData);
if(method) {
server_method* sm = find_method(server, method);
if(sm && sm->desc) {
XMLRPC_VALUE xTypesArray = XMLRPC_CreateVector(NULL, xmlrpc_vector_array);
XMLRPC_VALUE xIter, xParams, xSig, xSigIter;
const char* type;
/* array of possible signatures. */
xResponse = XMLRPC_CreateVector(NULL, xmlrpc_vector_array);
/* find first signature */
xSig = XMLRPC_VectorGetValueWithID(sm->desc, xi_token_signatures);
xSigIter = XMLRPC_VectorRewind( xSig );
/* iterate through sigs */
while(xSigIter) {
/* first type is the return value */
type = XMLRPC_VectorGetStringWithID(XMLRPC_VectorRewind(
XMLRPC_VectorGetValueWithID(xSigIter, xi_token_returns)),
xi_token_type);
XMLRPC_AddValueToVector(xTypesArray,
XMLRPC_CreateValueString(NULL,
type ? type : type_to_str(xmlrpc_none, 0),
0));
/* the rest are parameters */
xParams = XMLRPC_VectorGetValueWithID(xSigIter, xi_token_params);
xIter = XMLRPC_VectorRewind(xParams);
/* iter through params, adding to types array */
while(xIter) {
XMLRPC_AddValueToVector(xTypesArray,
XMLRPC_CreateValueString(NULL,
XMLRPC_VectorGetStringWithID(xIter, xi_token_type),
0));
xIter = XMLRPC_VectorNext(xParams);
}
/* add types for this signature */
XMLRPC_AddValueToVector(xResponse, xTypesArray);
xSigIter = XMLRPC_VectorNext( xSig );
}
}
}
return xResponse;
}
xml_element* XMLRPC_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
xml_element* wrapper = NULL;
if (request) {
const char* pStr = NULL;
XMLRPC_REQUEST_TYPE request_type = XMLRPC_RequestGetRequestType(request);
XMLRPC_VALUE xParams = XMLRPC_RequestGetData(request);
wrapper = xml_elem_new();
if (request_type == xmlrpc_request_call) {
pStr = ELEM_METHODCALL;
}
else if (request_type == xmlrpc_request_response) {
pStr = ELEM_METHODRESPONSE;
}
if (pStr) {
wrapper->name = strdup(pStr);
}
if(request_type == xmlrpc_request_call) {
pStr = XMLRPC_RequestGetMethodName(request);
if (pStr) {
xml_element* method = xml_elem_new();
method->name = strdup(ELEM_METHODNAME);
simplestring_add(&method->text, pStr);
Q_PushTail(&wrapper->children, method);
}
}
if (xParams) {
Q_PushTail(&wrapper->children,
XMLRPC_to_xml_element_worker(NULL, XMLRPC_RequestGetData(request), XMLRPC_RequestGetRequestType(request), 0));
}
else {
/* Despite the spec, the xml-rpc list folk want me to send an empty params element */
xml_element* params = xml_elem_new();
params->name = strdup(ELEM_PARAMS);
Q_PushTail(&wrapper->children, params);
}
}
return wrapper;
}
// STATIC
ProtocolUtilities::BuddyListPtr BuddyListParser::ExtractBuddyListFromXMLRPCReply(XmlRpcEpi &call)
{
XmlRpcCall *xmlrpcCall = call.GetXMLRPCCall();
if (!xmlrpcCall)
throw XmlRpcException("Failed to read buddy list, no XMLRPC Reply to read!");
XMLRPC_REQUEST request = xmlrpcCall->GetReply();
if (!request)
throw XmlRpcException("Failed to read buddy list, no XMLRPC Reply to read!");
XMLRPC_VALUE result = XMLRPC_RequestGetData(request);
if (!result)
throw XmlRpcException("Failed to read buddy list, the XMLRPC Reply did not contain any data!");
XMLRPC_VALUE buddy_list_node = XMLRPC_VectorGetValueWithID(result, "buddy-list");
if (!buddy_list_node || XMLRPC_GetValueType(buddy_list_node) != xmlrpc_vector)
throw XmlRpcException("Failed to read buddy list, buddy-list in the reply was not properly formed!");
ProtocolUtilities::BuddyListPtr buddy_list = ProtocolUtilities::BuddyListPtr(new ProtocolUtilities::BuddyList());
XMLRPC_VALUE item = XMLRPC_VectorRewind(buddy_list_node);
while(item)
{
XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(item);
if (type == xmlrpc_vector) // xmlrpc-epi handles structs as arrays.
{
RexUUID id;
int rights_given = 0;
int rights_has = 0;
XMLRPC_VALUE val = XMLRPC_VectorGetValueWithID(item, "buddy_id");
if (val && XMLRPC_GetValueType(val) == xmlrpc_string)
id.FromString( XMLRPC_GetValueString(val) );
val = XMLRPC_VectorGetValueWithID(item, "buddy_rights_given");
if (val && XMLRPC_GetValueType(val) == xmlrpc_type_int)
rights_given = XMLRPC_GetValueInt(val);
val = XMLRPC_VectorGetValueWithID(item, "buddy_rights_has");
if (val && XMLRPC_GetValueType(val) == xmlrpc_type_int)
rights_has = XMLRPC_GetValueInt(val);
ProtocolUtilities::Buddy *buddy = new ProtocolUtilities::Buddy(id, rights_given, rights_has);
buddy_list->AddBuddy(buddy);
}
item = XMLRPC_VectorNext(buddy_list_node);
}
return buddy_list;
}
/*
* This handler takes one parameter, and returns a struct containing three
* elements, times10, times100 and times1000, the result of multiplying the
* number by 10, 100 and 1000.
*/
XMLRPC_VALUE validator1_simpleStructReturnTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xStruct = XMLRPC_CreateVector(0, xmlrpc_vector_struct);
int iIncoming = XMLRPC_GetValueInt(XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest)));
XMLRPC_AddValuesToVector(xStruct,
XMLRPC_CreateValueInt("times10", iIncoming * 10),
XMLRPC_CreateValueInt("times100", iIncoming * 100),
XMLRPC_CreateValueInt("times1000", iIncoming * 1000),
NULL);
return xStruct;
}
/* system.describeMethods() callback */
static XMLRPC_VALUE xi_system_describe_methods_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
XMLRPC_VALUE xParams = XMLRPC_VectorRewind(XMLRPC_RequestGetData(input));
XMLRPC_VALUE xResponse = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
XMLRPC_VALUE xMethodList = XMLRPC_CreateVector("methodList", xmlrpc_vector_array);
XMLRPC_VALUE xTypeList = NULL;
int bAll = 1;
/* lazy loading of introspection data */
check_docs_loaded(server, userData);
xTypeList = XMLRPC_VectorGetValueWithID(server->xIntrospection, "typeList");
XMLRPC_AddValueToVector(xResponse, xTypeList);
XMLRPC_AddValueToVector(xResponse, xMethodList);
/* check if we have any param */
if(xParams) {
/* check if string or vector (1 or n) */
XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(xParams);
if(type == xmlrpc_string) {
/* just one. spit it out. */
describe_method(server, xMethodList, XMLRPC_GetValueString(xParams));
bAll = 0;
}
else if(type == xmlrpc_vector) {
/* multiple. spit all out */
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xParams);
while(xIter) {
describe_method(server, xMethodList, XMLRPC_GetValueString(xIter));
xIter = XMLRPC_VectorNext(xParams);
}
bAll = 0;
}
}
/* otherwise, default to sending all methods */
if(bAll) {
q_iter qi = Q_Iter_Head_F(&server->methodlist);
while( qi ) {
server_method* sm = Q_Iter_Get_F(qi);
if(sm) {
XMLRPC_AddValueToVector(xMethodList, sm->desc);
}
qi = Q_Iter_Next_F(qi);
}
}
return xResponse;
}
bool XMLRPC::addBytes(t_byteCP _bytes, t_uint const _size)
{
t_uint size = _size;
BTG_ICHECK( genericSDTSerialize<t_uint>(&size) );
if(size == 0)
{
return true;
}
XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueBase64(NULL, reinterpret_cast<const char*>(_bytes), _size)
);
return true;
}
/*
* This handler takes six parameters, and returns an array containing all the
* parameters.
*/
XMLRPC_VALUE validator1_manyTypesTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xArray = XMLRPC_CreateVector(0, xmlrpc_vector_array);
if(xRequest && xArray) {
XMLRPC_VALUE xParams = XMLRPC_RequestGetData(xRequest);
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xParams);
while(xIter) {
XMLRPC_AddValueToVector(xArray, XMLRPC_CopyValue(xIter));
xIter = XMLRPC_VectorNext(xParams);
}
}
return xArray;
}
bool XMLRPC::boolToBytes(bool const _source)
{
int val=0;
if (_source)
val=1;
XMLRPC_AddValueToVector(
XMLRPC_RequestGetData(xmlrpc_request),
XMLRPC_CreateValueBoolean(NULL, val)
);
success();
return true;
}
XMLRPC_VALUE XMLRPC::getNextValue()
{
XMLRPC_VALUE params = XMLRPC_RequestGetData(xmlrpc_request);
XMLRPC_VALUE param;
if(doRewind)
{
doRewind = false;
param = XMLRPC_VectorRewind(params);
}else
param = XMLRPC_VectorNext(params);
#if BTG_EXTERNALIZATION_DEBUG
BTG_NOTICE(logWrapper(), "XMLRPC::getNextValue() retrieved param of type " << XMLRPC_GetValueType(param));
#endif
return param;
}
/*
* This handler takes a single parameter, a struct, containing at least three
* elements named moe, larry and curly, all <i4>s. Your handler must add the
* three numbers and return the result.
*/
XMLRPC_VALUE validator1_easyStructTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xReturn = NULL;
int iSum = 0;
if(xRequest) {
XMLRPC_VALUE xStruct = XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest));
if(xStruct) {
iSum += XMLRPC_VectorGetIntWithID(xStruct, "curly");
iSum += XMLRPC_VectorGetIntWithID(xStruct, "moe");
iSum += XMLRPC_VectorGetIntWithID(xStruct, "larry");
}
}
xReturn = XMLRPC_CreateValueInt(0, iSum);
return xReturn;
}
/* this complies with system.methodHelp as defined at
* http://xmlrpc.usefulinc.com/doc/sysmethhelp.html
*/
static XMLRPC_VALUE xi_system_method_help_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
const char* method = XMLRPC_GetValueString(XMLRPC_VectorRewind(XMLRPC_RequestGetData(input)));
XMLRPC_VALUE xResponse = NULL;
/* lazy loading of introspection data */
check_docs_loaded(server, userData);
if(method) {
server_method* sm = find_method(server, method);
if(sm && sm->desc) {
const char* help = XMLRPC_VectorGetStringWithID(sm->desc, xi_token_purpose);
/* returns a documentation string, or empty string */
xResponse = XMLRPC_CreateValueString(NULL, help ? help : xi_token_empty, 0);
}
}
return xResponse;
}
/*
* This handler takes a single parameter, a struct, that models a daily
* calendar. At the top level, there is one struct for each year. Each year
* is broken down into months, and months into days. Most of the days are
* empty in the struct you receive, but the entry for April 1, 2000 contains
* a least three elements named moe, larry and curly, all <i4>s. Your
* handler must add the three numbers and return the result.
*
* Ken MacLeod: "This description isn't clear, I expected '2000.April.1' when
* in fact it's '2000.04.01'. Adding a note saying that month and day are
* two-digits with leading 0s, and January is 01 would help." Done.
*/
XMLRPC_VALUE validator1_nestedStructTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xReturn = NULL;
XMLRPC_VALUE xParams = XMLRPC_RequestGetData(xRequest);
int iSum = 0;
XMLRPC_VALUE xStruct = XMLRPC_VectorRewind(xParams);
XMLRPC_VALUE xYear = XMLRPC_VectorGetValueWithID(xStruct, "2000");
XMLRPC_VALUE xMonth = XMLRPC_VectorGetValueWithID(xYear, "04");
XMLRPC_VALUE xDay = XMLRPC_VectorGetValueWithID(xMonth, "01");
iSum += XMLRPC_VectorGetIntWithID(xDay, "larry");
iSum += XMLRPC_VectorGetIntWithID(xDay, "curly");
iSum += XMLRPC_VectorGetIntWithID(xDay, "moe");
xReturn = XMLRPC_CreateValueInt(0, iSum);
return xReturn;
}
/*
* This handler takes a single parameter, an array of structs, each of which
* contains at least three elements named moe, larry and curly, all <i4>s.
* Your handler must add all the struct elements named curly and return the
* result.
*/
XMLRPC_VALUE validator1_arrayOfStructsTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xReturn = NULL;
int iCurly = 0;
if(xRequest) {
XMLRPC_VALUE xArray = XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest));
if(xArray) {
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xArray);
while(xIter) {
iCurly += XMLRPC_VectorGetIntWithID(xIter, "curly");
xIter = XMLRPC_VectorNext(xArray);
}
}
}
xReturn = XMLRPC_CreateValueInt(0, iCurly);
return xReturn;
}
xml_element* DANDARPC_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
xml_element* wrapper = NULL;
xml_element* root = NULL;
if(request) {
XMLRPC_REQUEST_TYPE request_type = XMLRPC_RequestGetRequestType(request);
const char* pStr = NULL;
xml_element_attr* version = emalloc(sizeof(xml_element_attr));
version->key = estrdup(ATTR_VERSION);
version->val = estrdup(VAL_VERSION_0_9);
wrapper = xml_elem_new();
if(request_type == xmlrpc_request_response) {
pStr = ELEM_METHODRESPONSE;
}
else if(request_type == xmlrpc_request_call) {
pStr = ELEM_METHODCALL;
}
if(pStr) {
wrapper->name = estrdup(pStr);
}
root = xml_elem_new();
root->name = estrdup(ELEM_ROOT);
Q_PushTail(&root->attrs, version);
Q_PushTail(&root->children, wrapper);
pStr = XMLRPC_RequestGetMethodName(request);
if(pStr) {
xml_element* method = xml_elem_new();
method->name = estrdup(ELEM_METHODNAME);
simplestring_add(&method->text, pStr);
Q_PushTail(&wrapper->children, method);
}
Q_PushTail(&wrapper->children,
DANDARPC_to_xml_element_worker(request, XMLRPC_RequestGetData(request)));
}
return root;
}
/* convert XMLRPC_REQUEST to soap xml dom. */
xml_element* SOAP_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
xml_element* root = xml_elem_new();
/* safety first. */
if (root) {
xml_element* body = xml_elem_new();
root->name = strdup("SOAP-ENV:Envelope");
/* silly namespace stuff */
Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"));
Q_PushTail(&root->attrs, new_attr("xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance"));
Q_PushTail(&root->attrs, new_attr("xmlns:xsd", "http://www.w3.org/1999/XMLSchema"));
Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"));
Q_PushTail(&root->attrs, new_attr("xmlns:si", "http://soapinterop.org/xsd"));
Q_PushTail(&root->attrs, new_attr("xmlns:ns6", "http://testuri.org"));
Q_PushTail(&root->attrs, new_attr("SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/"));
/* Q_PushHead(&root->attrs, new_attr("xmlns:ks", "http://kitchen.sink.org/soap/everything/under/sun"));
JUST KIDDING!! :-) ----> ------------------------------------------------- */
if (body) {
/* go ahead and serialize first... */
xml_element* el_serialized =
SOAP_to_xml_element_worker(request,
XMLRPC_RequestGetData(request));
/* check for fault, in which case, there is no intermediate element */
if (el_serialized && !strcmp(el_serialized->name, TOKEN_FAULT)) {
Q_PushTail(&body->children, el_serialized);
}
/* usual case: not a fault. Add Response element in between. */
else {
xml_element* rpc = xml_elem_new();
if (rpc) {
const char* methodname = XMLRPC_RequestGetMethodName(request);
XMLRPC_REQUEST_TYPE rtype = XMLRPC_RequestGetRequestType(request);
/* if we are making a request, we want to use the methodname as is. */
if (rtype == xmlrpc_request_call) {
if (methodname) {
rpc->name = strdup(methodname);
}
}
/* if it's a response, we append "Response". Also, given xmlrpc-epi
API/architecture, it's likely that we don't have a methodname for
the response, so we have to check that. */
else {
char buf[128];
snprintf(buf, sizeof(buf), "%s%s",
methodname ? methodname : "",
"Response");
rpc->name = strdup(buf);
}
/* add serialized data to method call/response.
add method call/response to body element */
if (rpc->name) {
if(el_serialized) {
if(Q_Size(&el_serialized->children) && rtype == xmlrpc_request_call) {
xml_element* iter = (xml_element*)Q_Head(&el_serialized->children);
while(iter) {
Q_PushTail(&rpc->children, iter);
iter = (xml_element*)Q_Next(&el_serialized->children);
}
xml_elem_free_non_recurse(el_serialized);
}
else {
Q_PushTail(&rpc->children, el_serialized);
}
}
Q_PushTail(&body->children, rpc);
}
else {
/* no method name?!
TODO: fault here...? */
}
}
}
body->name = strdup("SOAP-ENV:Body");
Q_PushTail(&root->children, body);
}
}
return root;
}
LLXMLRPCValue LLXMLRPCTransaction::responseValue()
{
return LLXMLRPCValue(XMLRPC_RequestGetData(impl.mResponse));
}
LLUserAuth::UserAuthcode LLUserAuth::parseResponse()
{
// The job of this function is to parse sCurlDownloadArea and
// extract every member into either the mResponses or
// mOptions. For now, we will only be looking at mResponses, which
// will all be string => string pairs.
UserAuthcode rv = E_UNHANDLED_ERROR;
XMLRPC_REQUEST response = mTransaction->response();
if(!response) return rv;
// clear out any old parsing
mResponses.clear();
mOptions.clear();
// Now, parse everything
std::string key;
std::string val;
XMLRPC_VALUE param = NULL;
XMLRPC_VALUE current = NULL;
XMLRPC_VALUE_TYPE_EASY type;
param = XMLRPC_RequestGetData(response);
if(!param) goto exit;
current = XMLRPC_VectorRewind(param);
while(current)
{
key.assign(XMLRPC_GetValueID(current));
lldebugs << "key: " << key << llendl;
type = XMLRPC_GetValueTypeEasy(current);
if(xmlrpc_type_string == type)
{
val.assign(XMLRPC_GetValueString(current));
lldebugs << "val: " << val << llendl;
mResponses.insert(response_t::value_type(key, val));
}
else if(xmlrpc_type_int == type)
{
val = llformat( "%d", XMLRPC_GetValueInt(current));
lldebugs << "val: " << val << llendl;
mResponses.insert(response_t::value_type(key, val));
}
else if(xmlrpc_type_array == type)
{
options_t options;
parseOptionInto(key, current, options);
mOptions.insert(all_options_t::value_type(key, options));
}
else
{
// whoops - bad response
llwarns << "Unhandled xmlrpc type, key, value: " << type << " "
<< key << " " << val << "." << llendl;
rv = E_UNHANDLED_ERROR;
break;
}
current = XMLRPC_VectorNext(param);
rv = E_OK;
}
exit:
return rv;
}
/*
* This handler takes a single parameter, a struct. Your handler must return
* the struct.
*/
XMLRPC_VALUE validator1_echoStructTest (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* userData) {
XMLRPC_VALUE xReturn = XMLRPC_CopyValue(XMLRPC_VectorRewind(XMLRPC_RequestGetData(xRequest)));
return xReturn;
}
LLIOPipe::EStatus LLFilterXMLRPCResponse2LLSD::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
LLFastTimer t(FTM_PROCESS_XMLRPC2LLSD_RESPONSE);
PUMP_DEBUG;
if(!eos) return STATUS_BREAK;
if(!buffer) return STATUS_ERROR;
PUMP_DEBUG;
// *FIX: This technique for reading data is far from optimal. We
// need to have some kind of istream interface into the xml
// parser...
S32 bytes = buffer->countAfter(channels.in(), NULL);
if(!bytes) return STATUS_ERROR;
char* buf = new char[bytes + 1];
buf[bytes] = '\0';
buffer->readAfter(channels.in(), NULL, (U8*)buf, bytes);
//lldebugs << "xmlrpc response: " << buf << llendl;
PUMP_DEBUG;
XMLRPC_REQUEST response = XMLRPC_REQUEST_FromXML(
buf,
bytes,
NULL);
if(!response)
{
llwarns << "XML -> SD Response unable to parse xml." << llendl;
delete[] buf;
return STATUS_ERROR;
}
PUMP_DEBUG;
LLBufferStream stream(channels, buffer.get());
stream.precision(DEFAULT_PRECISION);
if(XMLRPC_ResponseIsFault(response))
{
PUMP_DEBUG;
stream << LLSDRPC_FAULT_HADER_1
<< XMLRPC_GetResponseFaultCode(response)
<< LLSDRPC_FAULT_HADER_2;
const char* fault_str = XMLRPC_GetResponseFaultString(response);
std::string fault_string;
if(fault_str)
{
fault_string.assign(fault_str);
}
stream << "'" << LLSDNotationFormatter::escapeString(fault_string)
<< "'" <<LLSDRPC_FAULT_FOOTER << std::flush;
}
else
{
PUMP_DEBUG;
stream << LLSDRPC_RESPONSE_HEADER;
XMLRPC_VALUE param = XMLRPC_RequestGetData(response);
if(param)
{
stream_out(stream, param);
}
stream << LLSDRPC_RESPONSE_FOOTER << std::flush;
}
PUMP_DEBUG;
XMLRPC_RequestFree(response, 1);
delete[] buf;
PUMP_DEBUG;
return STATUS_DONE;
}
LLIOPipe::EStatus LLFilterXMLRPCRequest2LLSD::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
LLFastTimer t(FTM_PROCESS_XMLRPC2LLSD_REQUEST);
PUMP_DEBUG;
if(!eos) return STATUS_BREAK;
if(!buffer) return STATUS_ERROR;
PUMP_DEBUG;
// *FIX: This technique for reading data is far from optimal. We
// need to have some kind of istream interface into the xml
// parser...
S32 bytes = buffer->countAfter(channels.in(), NULL);
if(!bytes) return STATUS_ERROR;
char* buf = new char[bytes + 1];
buf[bytes] = '\0';
buffer->readAfter(channels.in(), NULL, (U8*)buf, bytes);
//lldebugs << "xmlrpc request: " << buf << llendl;
// Check the value in the buffer. XMLRPC_REQUEST_FromXML will report a error code 4 if
// values that are less than 0x20 are passed to it, except
// 0x09: Horizontal tab; 0x0a: New Line; 0x0d: Carriage
U8* cur_pBuf = (U8*)buf;
U8 cur_char;
for (S32 i=0; i<bytes; i++)
{
cur_char = *cur_pBuf;
if ( cur_char < 0x20
&& 0x09 != cur_char
&& 0x0a != cur_char
&& 0x0d != cur_char )
{
*cur_pBuf = '?';
}
++cur_pBuf;
}
PUMP_DEBUG;
XMLRPC_REQUEST request = XMLRPC_REQUEST_FromXML(
buf,
bytes,
NULL);
if(!request)
{
llwarns << "XML -> SD Request process parse error." << llendl;
delete[] buf;
return STATUS_ERROR;
}
PUMP_DEBUG;
LLBufferStream stream(channels, buffer.get());
stream.precision(DEFAULT_PRECISION);
const char* name = XMLRPC_RequestGetMethodName(request);
stream << LLSDRPC_REQUEST_HEADER_1 << (name ? name : "")
<< LLSDRPC_REQUEST_HEADER_2;
XMLRPC_VALUE param = XMLRPC_RequestGetData(request);
if(param)
{
PUMP_DEBUG;
S32 size = XMLRPC_VectorSize(param);
if(size > 1)
{
// if there are multiple parameters, stuff the values into
// an array so that the next step in the chain can read them.
stream << "[";
}
XMLRPC_VALUE current = XMLRPC_VectorRewind(param);
bool needs_comma = false;
while(current)
{
if(needs_comma)
{
stream << ",";
}
needs_comma = true;
stream_out(stream, current);
current = XMLRPC_VectorNext(param);
}
if(size > 1)
{
// close the array
stream << "]";
}
}
stream << LLSDRPC_REQUEST_FOOTER << std::flush;
XMLRPC_RequestFree(request, 1);
delete[] buf;
PUMP_DEBUG;
return STATUS_DONE;
}
LLXMLRPCValue XMLRPCResponder::responseValue(void) const
{
return LLXMLRPCValue(XMLRPC_RequestGetData(mResponse));
}
