static void test_nesting_limit (void)
{
xmlrpc_env env;
xmlrpc_value *val;
xmlrpc_env_init(&env);
/* Test with an adequate limit for a result value which is an
array which contains an element which is a struct, whose values
are simple: 3.
*/
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 3);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_NO_FAULT(&env);
TEST(val != NULL);
xmlrpc_DECREF(val);
/* Test with an inadequate limit. */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 2);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR); /* BREAKME - Will change. */
TEST(val == NULL);
/* Reset the default limit. */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, XMLRPC_NESTING_LIMIT_DEFAULT);
TEST(xmlrpc_limit_get(XMLRPC_NESTING_LIMIT_ID)
== XMLRPC_NESTING_LIMIT_DEFAULT);
xmlrpc_env_clean(&env);
}
void
rcd_rpc_init(void)
{
xmlrpc_env env;
rc_debug (RC_DEBUG_LEVEL_MESSAGE, "Initializing RPC system");
xmlrpc_env_init(&env);
registry = xmlrpc_registry_new(&env);
if (env.fault_occurred) {
rc_debug (RC_DEBUG_LEVEL_ERROR,
"Unable to initialize the XML-RPC server registry: %s (%d)",
env.fault_string, env.fault_code);
exit (-1);
}
rcd_shutdown_add_handler ((RCDShutdownFn) xmlrpc_registry_free, registry);
/* The xmlrpc-c limit for XML size is 512k. Bump it up to 10 megs */
xmlrpc_limit_set (XMLRPC_XML_SIZE_LIMIT_ID, 10*1024*1024);
/* Create a hash which will be used for registering RPC methods */
method_info_hash = g_hash_table_new (g_str_hash, g_str_equal);
/* Register the basic RPC calls (ping, querying for modules, etc.) */
rcd_rpc_system_register_methods();
/* Register a shutdown function for the soup server (if it's started) */
rcd_shutdown_add_handler (soup_shutdown_cb, NULL);
} /* rcd_rpc_init */
ArchiveDataClient::ArchiveDataClient(const char *URL)
: URL(URL)
{
// W/o this call, we can't get more than ~ 4 x 300 values
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 10000*1024);
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, "ArchiveDataClient", "1");
xmlrpc_env_init(&env);
}
XmlResponse XmlRPC::run(std::string methodName, std::vector<xmlrpc_c::value> parameters ){
try {
// Construct our client from our Transport object
xmlrpc_c::client_xml client(&transport);
std::string const method(methodName);
// Parse through our parameters list
xmlrpc_c::paramList params;
for(int i=0; i < parameters.size(); i++){
xmlrpc_c::value newParameter(parameters.at(i));
params.addc(newParameter);
}
// Construct the Server URL
std::string const serverUrl(m_serverurl + ":" + std::to_string(m_port));
xmlrpc_c::carriageParm_http0 carriageParams(serverUrl);
// Check That Auth Requirements have been met
if(m_authrequired){
if(!m_authset){
std::cout << "Error: XML-RPC Auth is required but has not been set" << std::endl;
return std::make_pair(false,xmlrpc_c::value_string(""));
}
else{
carriageParams.setUser(m_authuser, m_authpass);
carriageParams.allowAuthBasic();
}
}
// Uncomment this to expand the size limit, I will move this elsewhere later into a function
// similar to the timeout setting one.
//
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 5e6);
// Run our RPC Call
xmlrpc_c::rpcPtr rpc(method, params);
rpc->call(&client, &carriageParams);
assert(rpc->isFinished());
xmlrpc_c::value const response(rpc->getResult());
return std::make_pair(true,response);
} catch (std::exception const& e) {
std::cerr << "Client threw error: " << e.what() << std::endl;
return std::make_pair(false,xmlrpc_c::value_string(""));
} catch (...) {
std::cerr << "Client threw unexpected error." << std::endl;
return std::make_pair(false,xmlrpc_c::value_string(""));
}
}
/**
* @brief initialize the encapsulated xmlrpc_c RPC handler
*/
void
OneRPCManager::initXmlRpcEnvironment()
{
XMLRPC_TRY;
mrpcEnv = new xmlrpc_env;
xmlrpc_env_init(mrpcEnv);
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 1024*MAX_MESSAGE_SIZE);
XMLRPC_CATCH
}
void abrt_xmlrpc_conn::new_xmlrpc_client(const char* url, bool ssl_verify)
{
m_pClient = NULL;
m_pServer_info = NULL;
xmlrpc_env env;
xmlrpc_env_init(&env);
/* This should be done at program startup, once. We do it in main */
/* xmlrpc_client_setup_global_const(&env); */
/* URL - bugzilla.redhat.com/show_bug.cgi?id=666893 Unable to make sense of
* XML-RPC response from server
*
* By default, XML data from the network may be no larger than 512K.
* XMLRPC_XML_SIZE_LIMIT_DEFAULT is #defined to (512*1024) in xmlrpc-c/base.h
*
* Users reported trouble with 733402 byte long responses, hope raising the
* limit to 2*512k is enough
*/
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 2 * XMLRPC_XML_SIZE_LIMIT_DEFAULT);
struct xmlrpc_curl_xportparms curlParms;
memset(&curlParms, 0, sizeof(curlParms));
/* curlParms.network_interface = NULL; - done by memset */
curlParms.no_ssl_verifypeer = !ssl_verify;
curlParms.no_ssl_verifyhost = !ssl_verify;
#ifdef VERSION
curlParms.user_agent = PACKAGE_NAME"/"VERSION;
#else
curlParms.user_agent = "abrt";
#endif
struct xmlrpc_clientparms clientParms;
memset(&clientParms, 0, sizeof(clientParms));
clientParms.transport = "curl";
clientParms.transportparmsP = &curlParms;
clientParms.transportparm_size = XMLRPC_CXPSIZE(user_agent);
xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS,
PACKAGE_NAME, VERSION,
&clientParms, XMLRPC_CPSIZE(transportparm_size),
&m_pClient);
if (env.fault_occurred)
throw_xml_fault(&env);
m_pServer_info = xmlrpc_server_info_new(&env, url);
if (env.fault_occurred)
{
xmlrpc_client_destroy(m_pClient);
m_pClient = NULL;
throw_xml_fault(&env);
}
}
static void
test_xml_size_limit(void) {
xmlrpc_env env;
const char * methodName;
xmlrpc_value * paramsP;
/* NOTE - This test suite only verifies the last-ditch size-checking
code. There should also be matching code in all server (and
preferably all client) modules as well.
*/
/* Set our XML size limit to something ridiculous. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 6);
/* Attempt to parse a call. */
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call),
&methodName, ¶msP);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
xmlrpc_env_clean(&env);
{
xmlrpc_value * resultP;
int faultCode;
const char * faultString;
/* Attempt to parse a response. */
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env,
good_response_xml, strlen(good_response_xml),
&resultP, &faultCode, &faultString);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
xmlrpc_env_clean(&env);
}
/* Reset the default limit. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, XMLRPC_XML_SIZE_LIMIT_DEFAULT);
}
static int main(int argc, char** argv) {
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 5e6);
}
