bool XMLRPC::getCommand(t_int & _command)
{
doRewind = true;
t_byte cmd;
getByte(cmd);
_command = cmd;
if (XMLRPC_RequestGetRequestType(xmlrpc_request) == xmlrpc_request_call)
{
const char* str = XMLRPC_RequestGetMethodName(xmlrpc_request);
if (str)
{
_command = getCommandID(std::string(str));
}
}
return true;
}
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;
}
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;
}
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;
}
/* 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;
}