static void
getTransportInfo(
xmlrpc_env * const envP,
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize,
const char ** const transportNameP,
struct xportParms * const transportParmsP,
const struct xmlrpc_client_transport_ops ** const transportOpsPP,
xmlrpc_client_transport ** const transportPP) {
const char * transportNameParm;
xmlrpc_client_transport * transportP;
const struct xmlrpc_client_transport_ops * transportOpsP;
if (parmSize < XMLRPC_CPSIZE(transport))
transportNameParm = NULL;
else
transportNameParm = clientparmsP->transport;
if (parmSize < XMLRPC_CPSIZE(transportP))
transportP = NULL;
else
transportP = clientparmsP->transportP;
if (parmSize < XMLRPC_CPSIZE(transportOpsP))
transportOpsP = NULL;
else
transportOpsP = clientparmsP->transportOpsP;
if ((transportOpsP && !transportP) || (transportP && ! transportOpsP))
xmlrpc_faultf(envP, "'transportOpsP' and 'transportP' go together. "
"You must specify both or neither");
else if (transportNameParm && transportP)
xmlrpc_faultf(envP, "You cannot specify both 'transport' and "
"'transportP' transport parameters.");
else if (transportP)
*transportNameP = NULL;
else if (transportNameParm)
*transportNameP = transportNameParm;
else
*transportNameP = xmlrpc_client_get_default_transport(envP);
*transportOpsPP = transportOpsP;
*transportPP = transportP;
if (!envP->fault_occurred) {
getTransportParmsFromClientParms(
envP, clientparmsP, parmSize, transportParmsP);
if (!envP->fault_occurred) {
if (transportParmsP->parmsP && !transportNameParm)
xmlrpc_faultf(
envP,
"You specified transport parameters, but did not "
"specify a transport type. Parameters are specific "
"to a particular type.");
}
}
}
static void
getDialectFromClientParms(
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize,
xmlrpc_dialect * const dialectP) {
if (parmSize < XMLRPC_CPSIZE(dialect))
*dialectP = xmlrpc_dialect_i8;
else
*dialectP = clientparmsP->dialect;
}
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);
}
}
int
main(int const argc,
const char ** const argv) {
const char * const serverUrl = "http://localhost:8080/RPC2";
xmlrpc_env env;
struct xmlrpc_clientparms clientParms;
xmlrpc_client * clientP;
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
setupSignalHandlers();
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Required before any use of Xmlrpc-c client library: */
xmlrpc_client_setup_global_const(&env);
die_if_fault_occurred(&env);
clientParms.transport = "curl";
/* Create a client object */
xmlrpc_client_create(&env, 0, NULL, NULL,
&clientParms, XMLRPC_CPSIZE(transport),
&clientP);
die_if_fault_occurred(&env);
xmlrpc_client_set_interrupt(clientP, &interrupt);
/* If our server is running 'xmlrpc_sample_add_server' normally, the
RPC will finish almost instantly. UNLESS the adder is 1, in which
case said server is programmed to take 3 seconds to do the
computation, thus allowing us to demonstrate a timeout or CTL-C.
*/
addInterruptibly(clientP, serverUrl, 5, 7);
/* Should finish instantly */
addInterruptibly(clientP, serverUrl, 5, 1);
/* Should time out after 2 seconds */
xmlrpc_env_clean(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_client_teardown_global_const();
return 0;
}
void
xmlrpc_client_create(xmlrpc_env * const envP,
int const flags,
const char * const appname,
const char * const appversion,
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize,
xmlrpc_client ** const clientPP) {
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(clientPP);
if (constSetupCount == 0) {
xmlrpc_faultf(envP,
"You have not called "
"xmlrpc_client_setup_global_const().");
/* Impl note: We can't just call it now because it isn't
thread-safe.
*/
} else {
const char * transportName;
struct xportParms transportparms;
const struct xmlrpc_client_transport_ops * transportOpsP;
xmlrpc_client_transport * transportP;
xmlrpc_dialect dialect;
xmlrpc_progress_fn * progressFn;
getTransportInfo(envP, clientparmsP, parmSize, &transportName,
&transportparms, &transportOpsP, &transportP);
getDialectFromClientParms(clientparmsP, parmSize, &dialect);
progressFn = parmSize >= XMLRPC_CPSIZE(progressFn) ?
clientparmsP->progressFn : NULL;
if (!envP->fault_occurred) {
if (transportName)
createTransportAndClient(envP, transportName,
transportparms.parmsP,
transportparms.size,
flags, appname, appversion, dialect,
progressFn,
clientPP);
else {
bool myTransportFalse = false;
clientCreate(envP, myTransportFalse,
transportOpsP, transportP, dialect, progressFn,
clientPP);
}
}
}
}
static void
getTransportParmsFromClientParms(
xmlrpc_env * const envP,
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize,
struct xportParms * const xportParmsP) {
if (parmSize < XMLRPC_CPSIZE(transportparmsP) ||
clientparmsP->transportparmsP == NULL) {
xportParmsP->parmsP = NULL;
xportParmsP->size = 0;
} else {
xportParmsP->parmsP = clientparmsP->transportparmsP;
if (parmSize < XMLRPC_CPSIZE(transportparm_size))
xmlrpc_faultf(envP, "Your 'clientparms' argument contains the "
"transportparmsP member, "
"but no transportparms_size member");
else
xportParmsP->size = clientparmsP->transportparm_size;
}
}
void
xmlrpc_client_init(int const flags,
const char * const appname,
const char * const appversion) {
/*----------------------------------------------------------------------------
This function is not thread-safe.
-----------------------------------------------------------------------------*/
struct xmlrpc_clientparms clientparms;
/* As our interface does not allow for failure, we just fail silently ! */
xmlrpc_env env;
xmlrpc_env_init(&env);
clientparms.transport = NULL;
/* The following call is not thread-safe */
xmlrpc_client_init2(&env, flags,
appname, appversion,
&clientparms, XMLRPC_CPSIZE(transport));
xmlrpc_env_clean(&env);
}
static void
doCall(xmlrpc_env * const envP,
const char * const transport,
const xmlrpc_server_info * const serverInfoP,
xmlrpc_mem_block * const callXmlP,
xmlrpc_mem_block ** const respXmlPP) {
struct xmlrpc_clientparms clientparms;
clientparms.transport = transport;
clientparms.transportparmsP = NULL;
clientparms.transportparm_size = 0;
xmlrpc_client_init2(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION,
&clientparms, XMLRPC_CPSIZE(transportparm_size));
if (!envP->fault_occurred) {
xmlrpc_client_transport_call(envP, NULL, serverInfoP,
callXmlP, respXmlPP);
xmlrpc_client_cleanup();
}
}
/*
* Do any per-module initialization that is separate to each
* configured instance of the module. e.g. set up connections
* to external databases, read configuration files, set up
* dictionary entries, etc.
*
* If configuration information is given in the config section
* that must be referenced in later calls, store a handle to it
* in *instance otherwise put a null pointer there.
*/
static int xmlrpc_instantiate(CONF_SECTION * conf, void **instance)
{
rlm_xmlrpc_t *data;
rlm_xmlrpc_client_t *first_client;
rlm_xmlrpc_client_t *client;
xmlrpc_env env;
struct xmlrpc_clientparms clientParms;
struct xmlrpc_curl_xportparms curlParms;
int i, error;
void (*do_auth) ();
/*
* Set up a storage area for instance data
*/
data = rad_malloc(sizeof(*data));
if (!data) {
return -1;
}
memset(data, 0, sizeof(*data));
/*
* If the configuration parameters can't be parsed, then
* fail.
*/
if (cf_section_parse(conf, data, module_config) < 0) {
free(data);
return -1;
}
*instance = data;
#ifdef HAVE_PTHREAD_H
pthread_mutex_init(&data->client_mutex, NULL);
#endif
/*
* network_interface parameter cannot be omitted because the
* XMLRPC_CXPSIZE macro calcs the size from the first parameter
* to the last modified.
* Unfortunately is this the order.
*/
curlParms.network_interface = data->interface;
curlParms.no_ssl_verifypeer = data->no_ssl_verify_peer;
curlParms.no_ssl_verifyhost = data->no_ssl_verify_host;
clientParms.transport = "curl";
clientParms.transportparmsP = &curlParms;
clientParms.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
/*
* Choosing method authentication
*/
if (strcmp(data->auth_type, "auth_basic") == 0) {
do_auth = xmlrpc_server_info_allow_auth_basic;
} else if (strcmp(data->auth_type, "auth_digest") == 0) {
do_auth = xmlrpc_server_info_allow_auth_digest;
} else if (strcmp(data->auth_type, "auth_negotiate") == 0) {
do_auth = xmlrpc_server_info_allow_auth_negotiate;
} else if (strcmp(data->auth_type, "auth_ntlm") == 0) {
do_auth = xmlrpc_server_info_allow_auth_ntlm;
}
/*
* Clients are created into a circular linked list.
* Into this cycle we setup clients and server information objects.
* Server information contains a method to do html authentication.
*/
for (i = 0; i < data->xmlrpc_num_socks; i++) {
client = rad_malloc(sizeof(*client));
if (!client) {
return -1;
}
memset(client, 0, sizeof(*client));
env = client->env;
xmlrpc_env_init(&env);
if (i == 0) {
data->client = client;
first_client = client;
xmlrpc_client_setup_global_const(&env);
} else {
data->client->next = client;
data->client = data->client->next;
}
xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, NAME,
VERSION, &clientParms,
XMLRPC_CPSIZE(transportparm_size), &client->clientP);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
client->serverInfoP = xmlrpc_server_info_new(&env, data->url);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
if (strcmp(data->auth_type, "none") != 0) {
xmlrpc_server_info_set_user(&env, client->serverInfoP,
data->user, data->password);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
do_auth(&env, client->serverInfoP);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
radlog(L_INFO, "\trlm_xmlrpc: client #%d logged in as %s", i, data->user);
}
radlog(L_INFO, "\trlm_xmlrpc: client #%d initialized", i);
}
/*
* closing the circular linked list. data->client helds a pointer
* to the last client used by a thread.
*/
data->client->next = first_client;
data->client = data->client->next;
return 0;
}
static void
testCreateCurlParms(void) {
#if MUST_BUILD_CURL_CLIENT
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
xmlrpc_env_init(&env);
clientParms1.transport = "curl";
clientParms1.transportparmsP = &curlTransportParms1;
curlTransportParms1.network_interface = "eth0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(network_interface);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
curlTransportParms1.no_ssl_verifypeer = 1;
curlTransportParms1.no_ssl_verifyhost = 1;
clientParms1.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
curlTransportParms1.user_agent = "testprog/1.0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(user_agent);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
curlTransportParms1.ssl_cert = NULL;
curlTransportParms1.sslcerttype = NULL;
curlTransportParms1.sslcertpasswd = NULL;
curlTransportParms1.sslkey = NULL;
curlTransportParms1.sslkeytype = NULL;
curlTransportParms1.sslkeypasswd = NULL;
curlTransportParms1.sslengine = NULL;
curlTransportParms1.sslengine_default = false;
curlTransportParms1.sslversion = XMLRPC_SSLVERSION_DEFAULT;
curlTransportParms1.cainfo = NULL;
curlTransportParms1.capath = NULL;
curlTransportParms1.randomfile = NULL;
curlTransportParms1.egdsocket = NULL;
curlTransportParms1.ssl_cipher_list = NULL;
curlTransportParms1.timeout = 0;
curlTransportParms1.dont_advertise = 1;
curlTransportParms1.proxy = NULL;
curlTransportParms1.proxy_port = 0;
curlTransportParms1.proxy_type = XMLRPC_HTTPPROXY_HTTP;
curlTransportParms1.proxy_auth = XMLRPC_HTTPAUTH_NONE;
curlTransportParms1.proxy_userpwd = "mypassword";
curlTransportParms1.gssapi_delegation = 1;
curlTransportParms1.referer = "myreferer";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(referer);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_env_clean(&env);
#endif /* MUST_BUILD_CURL_CLIENT */
}
static void
testInitCleanup(void) {
xmlrpc_env env;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, 0, "testprog", "1.0", NULL, 0);
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_client_init2(&env, 0, "testprog", "1.0", &clientParms1, 0);
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transport = "curl";
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transport));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transportparmsP = NULL;
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transportparmsP = &curlTransportParms1;
/* Fails because we didn't include transportparm_size: */
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.network_interface = "eth0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(network_interface);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.no_ssl_verifypeer = 1;
curlTransportParms1.no_ssl_verifyhost = 1;
clientParms1.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.user_agent = "testprog/1.0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(user_agent);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_client_init(0, "testprog", "1.0");
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_env_clean(&env);
}
static void
testCreateDestroy(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
int interrupt;
xmlrpc_env_init(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Didn't set up global const */
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_client_create(&env, 0, "testprog", "1.0", &clientParms1, 0,
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transport = "curl";
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transport), &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = NULL;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
clientParms1.dialect = xmlrpc_dialect_apache;
clientParms1.progressFn = &myProgress;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(progressFn),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = &curlTransportParms1;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_set_interrupt(clientP, &interrupt);
xmlrpc_client_set_interrupt(clientP, NULL);
xmlrpc_client_destroy(clientP);
testCreateCurlParms();
testCreateSeparateXport();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static void
testCreateSeparateXport(void) {
#if MUST_BUILD_CURL_CLIENT
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
struct xmlrpc_client_transport * transportP;
xmlrpc_env_init(&env);
xmlrpc_curl_transport_ops.create(
&env, 0, "", "", &curlTransportParms1, 0,
&transportP);
TEST_NO_FAULT(&env);
clientParms1.transport = NULL;
clientParms1.transportparmsP = NULL;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transport = "curl";
clientParms1.transportparmsP = &curlTransportParms1;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportP = transportP;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Both transportP and transport specified */
clientParms1.transport = NULL;
clientParms1.transportparmsP = NULL;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = &xmlrpc_curl_transport_ops;
clientParms1.transportP = transportP;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportOpsP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* transportOpsP but no transportP */
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_curl_transport_ops.destroy(transportP);
xmlrpc_env_clean(&env);
#endif /* MUST_BUILD_CURL_CLIENT */
}
