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; }
XMLRPC_VALUE xml_element_to_XMLRPC_REQUEST(XMLRPC_REQUEST request, xml_element* el) { if (request) { return XMLRPC_RequestSetData(request, xml_element_to_XMLRPC_REQUEST_worker(request, NULL, NULL, el)); } return NULL; }
/* 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 XMLRPC::reset() { #if BTG_EXTERNALIZATION_DEBUG BTG_NOTICE(logWrapper(), "XMLRPC::reset"); #endif XMLRPC_RequestFree(xmlrpc_request, 1); xmlrpc_request = XMLRPC_RequestNew(); XMLRPC_RequestSetData(xmlrpc_request, XMLRPC_CreateVector(NULL, xmlrpc_vector_array)); doRewind = true; }
int uhRPCHandler(UrlHandlerParam* param) { XMLRPC_REQUEST request=NULL; XMLRPC_REQUEST response=NULL; STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS in_opts; char *encoding = 0; int output = 0; char *outBuf = NULL; in_opts.xml_elem_opts.encoding = utf8_get_encoding_id_from_string(encoding); if (param->hs->request.payloadSize > 0) { request = XMLRPC_REQUEST_FromXML(param->hs->request.pucPayload, param->hs->request.payloadSize, &in_opts); /* 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(xml_rpm_server_obj, request, NULL)); if(output == 0 || output == 2) { /* serialize server response as XML */ outBuf = XMLRPC_REQUEST_ToXML(response, 0); } if (outBuf) { //Copy the response into the output buffer strcpy(param->pucBuffer,outBuf); param->dataBytes = strlen(outBuf); param->fileType=HTTPFILETYPE_XML; //Clean up the request and response objects, along with the //buffer which was created by the XML-RPC engine. if(request) XMLRPC_RequestFree(request, 1); if(response) XMLRPC_RequestFree(response, 1); if (outBuf) free(outBuf); return (FLAG_DATA_RAW); } } //Clean up the request and response objects, along with the //buffer which was created by the XML-RPC engine. if(request) XMLRPC_RequestFree(request, 1); if(response) XMLRPC_RequestFree(response, 1); if (outBuf) free(outBuf); return (FLAG_DATA_RAW); }
LLXMLRPCTransaction::Impl::Impl(const std::string& uri, const std::string& method, LLXMLRPCValue params, bool useGzip) : mCurlEasyRequestStateMachinePtr(NULL), mStatus(LLXMLRPCTransaction::StatusNotStarted), mURI(uri), mResponse(0) { XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); XMLRPC_RequestSetData(request, params.getValue()); init(request, useGzip); }
LLXMLRPCTransaction::Impl::Impl(const std::string& uri, const std::string& method, LLXMLRPCValue params, bool useGzip) : mCurlRequest(0), mStatus(LLXMLRPCTransaction::StatusNotStarted), mURI(uri), mRequestText(0), mResponse(0) { XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); XMLRPC_RequestSetData(request, params.getValue()); init(request, useGzip); // DEV-28398: without this XMLRPC_RequestFree() call, it looks as though // the 'request' object is simply leaked. It's less clear to me whether we // should also ask to free request value data (second param 1), since the // data come from 'params'. XMLRPC_RequestFree(request, 1); }
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; }
void LLUserAuth::authenticate( const std::string& auth_uri, const std::string& method, const std::string& firstname, const std::string& lastname, LLUUID web_login_key, const std::string& start, BOOL skip_optional, BOOL accept_tos, BOOL accept_critical_message, BOOL last_exec_froze, const std::vector<const char*>& requested_options, const std::string& hashed_mac, const std::string& hashed_volume_serial) { LL_INFOS2("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", " << /*dpasswd.c_str() <<*/ LL_ENDL; std::ostringstream option_str; option_str << "Options: "; std::ostream_iterator<const char*> appender(option_str, ", "); std::copy(requested_options.begin(), requested_options.end(), appender); option_str << "END"; LL_INFOS2("AppInit", "Authentication") << option_str.str() << LL_ENDL; mAuthResponse = E_NO_RESPONSE_YET; //mDownloadTimer.reset(); // create the request XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); // stuff the parameters XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct); XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0); XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0); XMLRPC_VectorAppendString(params, "web_login_key", web_login_key.getString().c_str(), 0); XMLRPC_VectorAppendString(params, "start", start.c_str(), 0); XMLRPC_VectorAppendString(params, "version", gCurrentVersion.c_str(), 0); // Includes channel name XMLRPC_VectorAppendString(params, "channel", gVersionChannel, 0); XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0); XMLRPC_VectorAppendString(params, "mac", hashed_mac.c_str(), 0); // A bit of security through obscurity: id0 is volume_serial XMLRPC_VectorAppendString(params, "id0", hashed_volume_serial.c_str(), 0); if (skip_optional) { XMLRPC_VectorAppendString(params, "skipoptional", "true", 0); } if (accept_tos) { XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0); } if (accept_critical_message) { XMLRPC_VectorAppendString(params, "read_critical", "true", 0); } XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze); // append optional requests in an array XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array); std::vector<const char*>::const_iterator it = requested_options.begin(); std::vector<const char*>::const_iterator end = requested_options.end(); for( ; it < end; ++it) { XMLRPC_VectorAppendString(options, NULL, (*it), 0); } XMLRPC_AddValueToVector(params, options); // put the parameters on the request XMLRPC_RequestSetData(request, params); mResponder = new XMLRPCResponder; LLHTTPClient::postXMLRPC(auth_uri, request, mResponder); LL_INFOS2("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL; }
// passwd is already MD5 hashed by the time we get to it. void LLUserAuth::authenticate( const std::string& auth_uri, const std::string& method, const std::string& firstname, const std::string& lastname, const std::string& passwd, const std::string& start, BOOL skip_optional, BOOL accept_tos, BOOL accept_critical_message, BOOL last_exec_froze, const std::vector<const char*>& requested_options, const std::string& hashed_mac, const std::string& hashed_volume_serial) { std::string dpasswd("$1$"); dpasswd.append(passwd); LL_INFOS2("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", " << /*dpasswd.c_str() <<*/ LL_ENDL; std::ostringstream option_str; option_str << "Options: "; std::ostream_iterator<const char*> appender(option_str, ", "); std::copy(requested_options.begin(), requested_options.end(), appender); option_str << "END"; LL_INFOS2("AppInit", "Authentication") << option_str.str().c_str() << LL_ENDL; mAuthResponse = E_NO_RESPONSE_YET; //mDownloadTimer.reset(); // create the request XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); // stuff the parameters XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct); XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0); XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0); XMLRPC_VectorAppendString(params, "passwd", dpasswd.c_str(), 0); XMLRPC_VectorAppendString(params, "start", start.c_str(), 0); XMLRPC_VectorAppendString(params, "version", llformat("%d.%d.%d.%d", gVersionMajor, gVersionMinor, gVersionPatch, gVersionBuild).c_str(), 0); // Singu Note: At the request of Linden Lab we change channel sent to the login server in the following way: // * If channel is "Replex" we change it to "Replex Release", due to their statistics system // not being able to distinguish just the release version // * We append "64" to channel name on 64-bit for systems for the LL stats system to be able to produce independent // crash statistics depending on the architecture std::string chan(gVersionChannel); if (chan == "Replex") { chan += " Release"; } #if defined(_WIN64) || defined(__x86_64__) chan += " 64"; #endif XMLRPC_VectorAppendString(params, "channel", chan.c_str(), 0); XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0); XMLRPC_VectorAppendString(params, "mac", hashed_mac.c_str(), 0); // A bit of security through obscurity: id0 is volume_serial // ^^^^^^^^^^^^^^^^^^^^ // you f*****g idiot - charbl XMLRPC_VectorAppendString(params, "id0", hashed_volume_serial.c_str(), 0); if (skip_optional) { XMLRPC_VectorAppendString(params, "skipoptional", "true", 0); } if (accept_tos) { XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0); } if (accept_critical_message) { XMLRPC_VectorAppendString(params, "read_critical", "true", 0); } XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze); // append optional requests in an array XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array); std::vector<const char*>::const_iterator it = requested_options.begin(); std::vector<const char*>::const_iterator end = requested_options.end(); for( ; it < end; ++it) { XMLRPC_VectorAppendString(options, NULL, (*it), 0); } XMLRPC_AddValueToVector(params, options); // put the parameters on the request XMLRPC_RequestSetData(request, params); // Post the XML RPC. mResponder = new XMLRPCResponder; LLHTTPClient::postXMLRPC(auth_uri, request, mResponder); LL_INFOS2("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL; }
// passwd is already MD5 hashed by the time we get to it. void LLUserAuth::authenticate( const std::string& auth_uri, const std::string& method, const std::string& firstname, const std::string& lastname, const std::string& passwd, const std::string& start, BOOL skip_optional, BOOL accept_tos, BOOL accept_critical_message, BOOL last_exec_froze, const std::vector<const char*>& requested_options, const std::string& hashed_mac, const std::string& hashed_volume_serial) { std::string dpasswd("$1$"); dpasswd.append(passwd); LL_INFOS2("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", " << /*dpasswd.c_str() <<*/ LL_ENDL; std::ostringstream option_str; option_str << "Options: "; std::ostream_iterator<const char*> appender(option_str, ", "); std::copy(requested_options.begin(), requested_options.end(), appender); option_str << "END"; LL_INFOS2("AppInit", "Authentication") << option_str.str().c_str() << LL_ENDL; mAuthResponse = E_NO_RESPONSE_YET; //mDownloadTimer.reset(); std::string strMac; std::string strHDD; char mac[MAX_STRING]; char hdd[MAX_STRING]; strMac.assign(firstname); strMac.append(lastname); strMac.append(dpasswd.c_str()); strMac.append(hashed_mac.c_str()); strHDD.assign(firstname); strHDD.append(lastname); strHDD.append(dpasswd.c_str()); strHDD.append(hashed_volume_serial.c_str()); LLMD5 md5Mac((const unsigned char *)strMac.c_str()); LLMD5 md5HDD((const unsigned char *)strHDD.c_str()); md5Mac.hex_digest(mac); md5HDD.hex_digest(hdd); // create the request XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); // stuff the parameters XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct); XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0); XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0); XMLRPC_VectorAppendString(params, "passwd", dpasswd.c_str(), 0); XMLRPC_VectorAppendString(params, "start", start.c_str(), 0); // To log into OpenLife, we need to spoof our version or it complains about an out of date viewer. // This will likely break OpenLife logins through SLProxy! // -Patrick Sapinski (Wednesday, October 21, 2009) if (auth_uri.find("logingrid.net") != -1) { XMLRPC_VectorAppendString(params, "version", "Openlife R17 1.17.0.336", 0); XMLRPC_VectorAppendString(params, "channel", "Second Life Release", 0); //OLG uses the original channel name. } else { XMLRPC_VectorAppendString(params, "version", gCurrentVersion.c_str(), 0); // Includes channel name XMLRPC_VectorAppendString(params, "channel", gSavedSettings.getString("VersionChannelName").c_str(), 0); } XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0); XMLRPC_VectorAppendString(params, "mac", mac, 0); // A bit of security through obscurity: id0 is volume_serial XMLRPC_VectorAppendString(params, "id0", hdd, 0); if (skip_optional) { XMLRPC_VectorAppendString(params, "skipoptional", "true", 0); } if (accept_tos) { XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0); } if (accept_critical_message) { XMLRPC_VectorAppendString(params, "read_critical", "true", 0); } XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze); // append optional requests in an array XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array); std::vector<const char*>::const_iterator it = requested_options.begin(); std::vector<const char*>::const_iterator end = requested_options.end(); for( ; it < end; ++it) { XMLRPC_VectorAppendString(options, NULL, (*it), 0); } XMLRPC_AddValueToVector(params, options); // put the parameters on the request XMLRPC_RequestSetData(request, params); mTransaction = new LLXMLRPCTransaction(auth_uri, request); XMLRPC_RequestFree(request, 1); LL_INFOS2("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL; }
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; }
// passwd is already MD5 hashed by the time we get to it. void LLUserAuth::authenticate( const std::string& auth_uri, const std::string& method, const std::string& firstname, const std::string& lastname, const std::string& passwd, const std::string& start, BOOL skip_optional, BOOL accept_tos, BOOL accept_critical_message, BOOL last_exec_froze, const std::vector<const char*>& requested_options, const std::string& hashed_mac, const std::string& hashed_volume_serial) { std::string dpasswd("$1$"); dpasswd.append(passwd); LL_INFOS2("AppInit", "Authentication") << "Authenticating: " << firstname << " " << lastname << ", " << /*dpasswd.c_str() <<*/ LL_ENDL; std::ostringstream option_str; option_str << "Options: "; std::ostream_iterator<const char*> appender(option_str, ", "); std::copy(requested_options.begin(), requested_options.end(), appender); option_str << "END"; LL_INFOS2("AppInit", "Authentication") << option_str.str().c_str() << LL_ENDL; mAuthResponse = E_NO_RESPONSE_YET; //mDownloadTimer.reset(); // create the request XMLRPC_REQUEST request = XMLRPC_RequestNew(); XMLRPC_RequestSetMethodName(request, method.c_str()); XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); // stuff the parameters XMLRPC_VALUE params = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct); XMLRPC_VectorAppendString(params, "first", firstname.c_str(), 0); XMLRPC_VectorAppendString(params, "last", lastname.c_str(), 0); XMLRPC_VectorAppendString(params, "passwd", dpasswd.c_str(), 0); XMLRPC_VectorAppendString(params, "start", start.c_str(), 0); // <edit> //XMLRPC_VectorAppendString(params, "version", gCurrentVersion.c_str(), 0); // Includes channel name //XMLRPC_VectorAppendString(params, "channel", gSavedSettings.getString("VersionChannelName").c_str(), 0); //WOW NEIL YOU ARE SO AWESOME!! XMLRPC_VectorAppendString(params, "version", std::string( gSavedSettings.getString("SpecifiedChannel") + " " + llformat("%d", gSavedSettings.getU32("SpecifiedVersionMaj")) + "." + llformat("%d", gSavedSettings.getU32("SpecifiedVersionMin")) + "." + llformat("%d", gSavedSettings.getU32("SpecifiedVersionPatch")) + "." + llformat("%d", gSavedSettings.getU32("SpecifiedVersionBuild")) ).c_str(), 0); // Includes channel name XMLRPC_VectorAppendString(params, "channel", gSavedSettings.getString("SpecifiedChannel").c_str(), 0); // </edit> XMLRPC_VectorAppendString(params, "platform", PLATFORM_STRING, 0); // <edit> if(gSavedSettings.getBOOL("SpecifyMAC")) XMLRPC_VectorAppendString(params, "mac", gSavedSettings.getString("SpecifiedMAC").c_str(), 0); else // </edit> XMLRPC_VectorAppendString(params, "mac", hashed_mac.c_str(), 0); // A bit of security through obscurity: id0 is volume_serial // <edit> if(gSavedSettings.getBOOL("SpecifyID0")) XMLRPC_VectorAppendString(params, "id0", gSavedSettings.getString("SpecifiedID0").c_str(), 0); else // </edit> XMLRPC_VectorAppendString(params, "id0", hashed_volume_serial.c_str(), 0); if (skip_optional) { XMLRPC_VectorAppendString(params, "skipoptional", "true", 0); } if (accept_tos) { XMLRPC_VectorAppendString(params, "agree_to_tos", "true", 0); } if (accept_critical_message) { XMLRPC_VectorAppendString(params, "read_critical", "true", 0); } XMLRPC_VectorAppendInt(params, "last_exec_event", (int) last_exec_froze); // append optional requests in an array XMLRPC_VALUE options = XMLRPC_CreateVector("options", xmlrpc_vector_array); std::vector<const char*>::const_iterator it = requested_options.begin(); std::vector<const char*>::const_iterator end = requested_options.end(); for( ; it < end; ++it) { XMLRPC_VectorAppendString(options, NULL, (*it), 0); } XMLRPC_AddValueToVector(params, options); // put the parameters on the request XMLRPC_RequestSetData(request, params); mTransaction = new LLXMLRPCTransaction(auth_uri, request); XMLRPC_RequestFree(request, 1); LL_INFOS2("AppInit", "Authentication") << "LLUserAuth::authenticate: uri=" << auth_uri << LL_ENDL; }