void XMLRPC::getBuffer(dBuffer & _buffer) { char* buff; int buffsize; XMLRPC_REQUEST_OUTPUT_OPTIONS opt = XMLRPC_RequestGetOutputOptions(xmlrpc_request); opt->version = xmlrpc_version_1_0; opt->xml_elem_opts.encoding = encoding_utf_8; opt->xml_elem_opts.escaping = xml_elem_markup_escaping; // Skip this call, since we did a get we uses a ref to the actual opt struct anyway. // using set here would cause a "Source and destination overlap in memcpy" (valgrind) // unless we do a copy of opt and feed set with it. //XMLRPC_RequestSetOutputOptions(xmlrpc_request, opt); buff = XMLRPC_REQUEST_ToXML(xmlrpc_request, &buffsize); if (!buff) { return; } #if BTG_EXTERNALIZATION_DEBUG BTG_NOTICE(logWrapper(), "Serialized command to " << buff); #endif // BTG_EXTERNALIZATION_DEBUG _buffer.erase(); _buffer.addBytes(reinterpret_cast<t_byteCP>(buff), buffsize); free(buff); reset(); }
/* with the exception of the registration calls, most everything in main * only needs to be written once per server. */ int main(int argc, char **argv) { XMLRPC_SERVER server; XMLRPC_REQUEST request=0; XMLRPC_REQUEST response; /* create a new server object */ server = XMLRPC_ServerCreate(); /* Register public methods with the server */ XMLRPC_ServerRegisterMethod(server, "hello", hello_callback); /* Now, let's get the client's request from stdin.... */ { char filebuf[4096]; // not that intelligent. sue me. int len = fread(filebuf, sizeof(char), sizeof(filebuf)-1, stdin); if(len) { filebuf[len] = 0; // parse the xml into a request structure request = XMLRPC_REQUEST_FromXML((const char*)filebuf, len, NULL); } } if(!request) { fprintf(stderr, "bogus xmlrpc request\n"); return 1; } /* create a response struct */ response = XMLRPC_RequestNew(); XMLRPC_RequestSetRequestType(response, xmlrpc_request_response); /* call server method with client request and assign the response to our response struct */ XMLRPC_RequestSetData(response, XMLRPC_ServerCallMethod(server, request, NULL)); /* be courteous. reply in same vocabulary/manner as the request. */ XMLRPC_RequestSetOutputOptions(response, XMLRPC_RequestGetOutputOptions(request) ); /* serialize server response as XML */ if(1) { char *outBuf = XMLRPC_REQUEST_ToXML(response, 0); if(outBuf) { printf(outBuf); free(outBuf); } } // cleanup. null safe. XMLRPC_RequestFree(request, 1); XMLRPC_RequestFree(response, 1); XMLRPC_ServerDestroy(server); return 0; }
/* with the exception of the registration calls, most everything in main * only needs to be written once per server. */ char* clientCallback( char* filebuf ) { XMLRPC_SERVER server; XMLRPC_REQUEST request, response; /* create a new server object */ server = XMLRPC_ServerCreate( ); /* Register public methods with the server */ XMLRPC_ServerRegisterMethod( server, "start", x_startCallback ); XMLRPC_ServerRegisterMethod( server, "stop", x_stopCallback ); XMLRPC_ServerRegisterMethod( server, "rm", x_rmCallback ); XMLRPC_ServerRegisterMethod( server, "mkdir", x_mkdirCallback ); XMLRPC_ServerRegisterMethod( server, "execute", x_executeCallback ); XMLRPC_ServerRegisterMethod( server, "checkcore", x_checkCoreCallback ); XMLRPC_ServerRegisterMethod( server, "listTests", x_listTestsCallback ); XMLRPC_ServerRegisterMethod( server, "runTests", x_runTestsCallback ); XMLRPC_ServerRegisterMethod( server, "listMachines", x_listMachinesCallback ); XMLRPC_ServerRegisterMethod( server, "getConfig", x_getConfigCallback ); XMLRPC_ServerRegisterMethod( server, "setConfig", x_setConfigCallback ); /* Now, let's get the client's request from stdin.... * This will be read from a socket */ { /* char filebuf[4096]; // not that intelligent. sue me. int len = fread( filebuf, sizeof( char ), sizeof( filebuf ) - 1, if( len ) { filebuf[len] = 0; stdin ); */ // parse the xml into a request structure request = XMLRPC_REQUEST_FromXML( ( const char * )filebuf, strlen(filebuf), NULL ); // } } if( !request ) { fprintf( stderr, "bogus xmlrpc request\n" ); return 0; } /* * The interesting part is below */ /* create a response struct */ response = XMLRPC_RequestNew( ); XMLRPC_RequestSetRequestType( response, xmlrpc_request_response ); /* call server method with client request and assign the response to our response struct */ XMLRPC_RequestSetData( response, XMLRPC_ServerCallMethod( server, request, NULL ) ); /* be courteous. reply in same vocabulary/manner as the request. */ XMLRPC_RequestSetOutputOptions( response, XMLRPC_RequestGetOutputOptions ( request ) ); /* serialize server response as XML */ char *outBuf = XMLRPC_REQUEST_ToXML( response, 0 ); if( outBuf ) { printf( outBuf ); } // cleanup. null safe. XMLRPC_RequestFree( request, 1 ); XMLRPC_RequestFree( response, 1 ); XMLRPC_ServerDestroy( server ); return outBuf; }
xml_element* DANDARPC_to_xml_element_worker(XMLRPC_REQUEST request, XMLRPC_VALUE node) { #define BUF_SIZE 512 xml_element* root = NULL; if(node) { char buf[BUF_SIZE]; const char* id = XMLRPC_GetValueID(node); XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node); XMLRPC_REQUEST_OUTPUT_OPTIONS output = XMLRPC_RequestGetOutputOptions(request); int bNoAddType = (type == xmlrpc_string && request && output && output->xml_elem_opts.verbosity == xml_elem_no_white_space); xml_element* elem_val = xml_elem_new(); const char* pAttrType = NULL; xml_element_attr* attr_type = bNoAddType ? NULL : emalloc(sizeof(xml_element_attr)); if(attr_type) { attr_type->key = estrdup(ATTR_TYPE); attr_type->val = 0; Q_PushTail(&elem_val->attrs, attr_type); } elem_val->name = (type == xmlrpc_vector) ? estrdup(ATTR_VECTOR) : estrdup(ATTR_SCALAR); if(id && *id) { xml_element_attr* attr_id = emalloc(sizeof(xml_element_attr)); if(attr_id) { attr_id->key = estrdup(ATTR_ID); attr_id->val = estrdup(id); Q_PushTail(&elem_val->attrs, attr_id); } } switch(type) { case xmlrpc_string: pAttrType = ATTR_STRING; simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node)); break; case xmlrpc_int: pAttrType = ATTR_INT; snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node)); simplestring_add(&elem_val->text, buf); break; case xmlrpc_boolean: pAttrType = ATTR_BOOLEAN; snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node)); simplestring_add(&elem_val->text, buf); break; case xmlrpc_double: pAttrType = ATTR_DOUBLE; snprintf(buf, BUF_SIZE, "%f", XMLRPC_GetValueDouble(node)); simplestring_add(&elem_val->text, buf); break; case xmlrpc_datetime: pAttrType = ATTR_DATETIME; simplestring_add(&elem_val->text, XMLRPC_GetValueDateTime_ISO8601(node)); break; case xmlrpc_base64: { struct buffer_st buf; pAttrType = ATTR_BASE64; base64_encode_xmlrpc(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node)); simplestring_addn(&elem_val->text, buf.data, buf.offset ); buffer_delete(&buf); } break; case xmlrpc_vector: { XMLRPC_VECTOR_TYPE my_type = XMLRPC_GetVectorType(node); XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node); switch(my_type) { case xmlrpc_vector_array: pAttrType = ATTR_ARRAY; break; case xmlrpc_vector_mixed: pAttrType = ATTR_MIXED; break; case xmlrpc_vector_struct: pAttrType = ATTR_STRUCT; break; default: break; } /* recurse through sub-elements */ while( xIter ) { xml_element* next_el = DANDARPC_to_xml_element_worker(request, xIter); if(next_el) { Q_PushTail(&elem_val->children, next_el); } xIter = XMLRPC_VectorNext(node); } } break; default: break; } if(pAttrType && attr_type && !bNoAddType) { attr_type->val = estrdup(pAttrType); } root = elem_val; } return root; }