/* 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;
}
void XmlRpcCall::Initialize(const std::string& method)
{
assert(method != "");
// Create a new request object
request_ = XMLRPC_RequestNew();
// Assure that request was done correctly
assert(request_);
// Set the method name and tell it we are making a request
XMLRPC_RequestSetMethodName(request_, method.c_str());
XMLRPC_RequestSetRequestType(request_, xmlrpc_request_call);
memset(&output_, 0, sizeof(output_));
// Tell it to write out xml-rpc (default).
output_.version = xmlrpc_version_1_0;
// Other options are:
// xmlrpc_version_1_0 // xmlrpc 1.0
// xmlrpc_version_simple // simpleRPC
// xmlrpc_version_soap_1_1 // soap 1.1
XMLRPC_RequestSetOutputOptions(request_, &output_);
// Create a parameter list vector
paramList_ = XMLRPC_CreateVector(0, xmlrpc_vector_struct);
assert(paramList_);
XMLRPC_RequestSetData(request_, paramList_);
}
/* 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;
}
int main(int argc, char **argv)
{
int i;
XMLRPC_SERVER server;
XMLRPC_REQUEST xRequest=0;
XMLRPC_REQUEST response;
STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS call_options;
/* args */
int verbosity = 0;
int version = 0;
int escaping = 0;
int output = 0;
char *methodName = "method_TestNormal";
char *encoding = 0;
/* for every argument (after the program name) */
for(i=1; i<argc; i++) {
char* arg = argv[i];
if(*arg == '-') {
char* key = arg + 1;
char* val = argv[i+1];
if(key && (!strcmp(key, "help") || !strcmp(key, "-help"))) {
print_help();
return 0;
}
if(key && val) {
if(!strcmp(key, "verbosity")) {
if(!strcmp(val, "pretty")) {
verbosity = 0;
}
else if(!strcmp(val, "none")) {
verbosity = 1;
}
else if(!strcmp(val, "newlines")) {
verbosity = 2;
}
}
else if(!strcmp(key, "version")) {
if(!strcmp(val, "xmlrpc")) {
version = 0;
}
else if(!strcmp(val, "simple")) {
version = 1;
}
}
else if(!strcmp(key, "escaping")) {
if(!strcmp(val, "markup")) {
escaping |= xml_elem_markup_escaping ;
}
else if(!strcmp(val, "cdata")) {
escaping |= xml_elem_cdata_escaping;
}
else if(!strcmp(val, "non-ascii")) {
escaping |= xml_elem_non_ascii_escaping;
}
else if(!strcmp(val, "non-print")) {
escaping |= xml_elem_non_print_escaping;
}
}
else if(!strcmp(key, "encoding")) {
encoding = val;
}
else if(!strcmp(key, "output")) {
if(!strcmp(val, "response")) {
output = 0;
}
else if(!strcmp(val, "xRequest")) {
output = 1;
}
else if(!strcmp(val, "both")) {
output = 2;
}
}
else if(!strcmp(key, "method")) {
methodName = val;
}
i++;
}
}
}
/* create a new server object */
server = XMLRPC_ServerCreate();
XMLRPC_ServerRegisterMethod(server, "validator1.arrayOfStructsTest", validator1_arrayOfStructsTest);
XMLRPC_ServerRegisterMethod(server, "validator1.countTheEntities", validator1_countTheEntities);
XMLRPC_ServerRegisterMethod(server, "validator1.easyStructTest", validator1_easyStructTest);
XMLRPC_ServerRegisterMethod(server, "validator1.echoStructTest", validator1_echoStructTest);
XMLRPC_ServerRegisterMethod(server, "validator1.manyTypesTest", validator1_manyTypesTest);
XMLRPC_ServerRegisterMethod(server, "validator1.moderateSizeArrayCheck", validator1_moderateSizeArrayCheck);
XMLRPC_ServerRegisterMethod(server, "validator1.nestedStructTest", validator1_nestedStructTest);
XMLRPC_ServerRegisterMethod(server, "validator1.simpleStructReturnTest", validator1_simpleStructReturnTest);
/* Now, let's get the client's xRequest from stdin.... */
{
char* filebuf[1024 * 100];
int len = fread(filebuf, sizeof(char), sizeof(filebuf)-1, stdin);
if(len) {
filebuf[len] = 0;
xRequest = XMLRPC_REQUEST_FromXML((const char*)filebuf, len, NULL);
}
}
if(!xRequest) {
fprintf(stderr, "bogus xmlrpc xRequest\n");
return 1;
}
/* create a response struct */
response = XMLRPC_RequestNew();
XMLRPC_RequestSetRequestType(response, xmlrpc_request_response);
/* Set various xml output options. Or we could just use defaults. */
call_options.xml_elem_opts.verbosity = verbosity == 1 ? xml_elem_no_white_space : (verbosity == 2 ? xml_elem_newlines_only : xml_elem_pretty);
call_options.xml_elem_opts.escaping = escaping;
call_options.version = (version == 1) ? xmlrpc_version_simple : xmlrpc_version_1_0;
call_options.xml_elem_opts.encoding = encoding;
XMLRPC_RequestSetOutputOptions(response, &call_options);
/* call server method with client xRequest and assign the response to our response struct */
XMLRPC_RequestSetData(response, XMLRPC_ServerCallMethod(server, xRequest, NULL));
if(output == 1 || output == 2) {
/* serialize client request as XML */
char *outBuf;
XMLRPC_RequestSetOutputOptions(xRequest, &call_options);
outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0);
if(outBuf) {
printf("%s\n\n --- \n\n", outBuf);
free(outBuf);
}
}
if(output == 0 || output == 2) {
/* serialize server response as XML */
char *outBuf = XMLRPC_REQUEST_ToXML(response, 0);
if(outBuf) {
printf(outBuf);
free(outBuf);
}
}
if(xRequest) {
/* Free xRequest */
XMLRPC_RequestFree(xRequest, 1);
}
if(response) {
/* free response */
XMLRPC_RequestFree(response, 1);
}
if(server) {
XMLRPC_ServerDestroy(server);
}
return 0;
}
