void free_instance(rlm_xmlrpc_t * instance)
{
rlm_xmlrpc_t *inst = instance;
rlm_xmlrpc_client_t *next;
rlm_xmlrpc_client_t *cur;
cur = inst->client;
while (cur->next) {
next = cur->next;
xmlrpc_env_clean(&cur->env);
xmlrpc_server_info_free(cur->serverInfoP);
xmlrpc_client_destroy(cur->clientP);
free(cur);
cur = next;
}
if (cur) {
xmlrpc_env_clean(&cur->env);
xmlrpc_server_info_free(cur->serverInfoP);
xmlrpc_client_destroy(cur->clientP);
free(cur);
}
xmlrpc_client_teardown_global_const();
pthread_mutex_destroy(&inst->client_mutex);
free(inst);
}
void bugzilla_free(BugzillaData *data) {
if(data == NULL)
return;
xmlrpc_client_destroy(data->xcli);
xmlrpc_env_clean(&data->xenv);
delete data;
}
void stop_flows(char* address)
{
xmlrpc_env env;
xmlrpc_client *client = 0;
xmlrpc_value * resultP = 0;
char* p;
int port = DEFAULT_LISTEN_PORT;
char host[1000], url[1000];
if (strlen(address) > sizeof(url) - 50) {
fprintf(stderr, "Address too long: %s\n", address);
return;
}
/* Construct canonical address and URL */
strncpy(host, address, 1000);
p = strchr(host, ':');
if (p) {
if (p == host) {
fprintf(stderr, "Error, no address given: %s\n", address);
return;
}
port = atoi(p + 1);
if (port < 1 || port > 65535) {
fprintf(stderr, "Error, invalid port given: %s\n", address);
return;
}
*p = 0;
}
sprintf(url, "http://%s:%d/RPC2", host, port);
sprintf(host, "%s:%d", host, port);
printf("Stopping all flows on %s\n", host);
/* Stop the flows */
xmlrpc_env_init(&env);
xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, "Flowgrind", FLOWGRIND_VERSION, NULL, 0, &client);
if (env.fault_occurred)
goto cleanup;
xmlrpc_client_call2f(&env, client, url, "stop_flow", &resultP,
"({s:i})", "flow_id", -1); /* -1 stops all flows */
if (resultP)
xmlrpc_DECREF(resultP);
cleanup:
if (env.fault_occurred) {
fprintf(stderr, "Could not stop flows on %s: %s (%d)\n",
host, env.fault_string, env.fault_code);
}
if (client)
xmlrpc_client_destroy(client);
xmlrpc_env_clean(&env);
}
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://oracc.bfos:80/xmlrpc";
const char *const methodName = "sample.add";
xmlrpc_env env;
xmlrpc_client *clientP;
xmlrpc_int adder;
if (argc - 1 > 0)
{
fprintf (stderr, "This program has no arguments\n");
exit (1);
}
/* Initialize our error environment variable */
xmlrpc_env_init (&env);
/* Required before any use of Xmlrpc-c client library: */
xmlrpc_client_setup_global_const (&env);
die_if_fault_occurred (&env);
xmlrpc_client_create (&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0,
&clientP);
die_if_fault_occurred (&env);
for (adder = 0; adder < 3; ++adder)
{
printf ("Making XMLRPC call to server url '%s' method '%s' "
"to request the sum "
"of 5 and %d...\n", serverUrl, methodName, adder);
/* request the remote procedure call */
xmlrpc_client_start_rpcf (&env, clientP, serverUrl, methodName,
handle_sample_add_response, NULL,
"(ii)", (xmlrpc_int32) 5, adder);
die_if_fault_occurred (&env);
}
printf ("RPCs all requested. Waiting for & handling responses...\n");
/*
* Wait for all RPCs to be done. With some transports, this is also
* what causes them to go.
*/
xmlrpc_client_event_loop_finish (clientP);
printf ("All RPCs finished.\n");
xmlrpc_client_destroy (clientP);
xmlrpc_client_teardown_global_const ();
return 0;
}
static void stop_flows(const char* address)
{
xmlrpc_env env;
xmlrpc_client *client = 0;
xmlrpc_value * resultP = 0;
int port = DEFAULT_LISTEN_PORT;
bool is_ipv6 = false;
char *arg, *url = 0;
int rc;
char *rpc_address = arg = strdup(address);
struct sockaddr_in6 source_in6;
source_in6.sin6_family = AF_INET6;
parse_rpc_address(&rpc_address, &port, &is_ipv6);
if (is_ipv6 && (inet_pton(AF_INET6, rpc_address,
(char*)&source_in6.sin6_addr) <= 0))
errx("invalid IPv6 address '%s' for RPC", rpc_address);
if (port < 1 || port > 65535)
errx("invalid port for RPC");
if (is_ipv6)
rc = asprintf(&url, "http://[%s]:%d/RPC2", rpc_address, port);
else
rc = asprintf(&url, "http://%s:%d/RPC2", rpc_address, port);
if (rc==-1)
critx("failed to build RPC URL");
printf("Stopping all flows on %s\n", url);
/* Stop the flows */
xmlrpc_env_init(&env);
xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, "Flowgrind", FLOWGRIND_VERSION, NULL, 0, &client);
if (env.fault_occurred)
goto cleanup;
xmlrpc_client_call2f(&env, client, url, "stop_flow", &resultP,
"({s:i})", "flow_id", -1); /* -1 stops all flows */
if (resultP)
xmlrpc_DECREF(resultP);
cleanup:
if (env.fault_occurred) {
warnx("could not stop flows on %s: %s (%d)",
url, env.fault_string, env.fault_code);
}
if (client)
xmlrpc_client_destroy(client);
xmlrpc_env_clean(&env);
free_all(arg, url);
}
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;
}
/*
* Make an XML-RPC call to methodName. This uses the curl client to make
* a connection over SSL using the CA cert that should have been installed
* by ipa-client-install.
*/
static void
callRPC(char * user_agent,
xmlrpc_env * const envP,
xmlrpc_server_info * const serverInfoP,
const char * const methodName,
xmlrpc_value * const paramArrayP,
xmlrpc_value ** const resultPP) {
struct xmlrpc_clientparms clientparms;
struct xmlrpc_curl_xportparms * curlXportParmsP = NULL;
xmlrpc_client * clientP = NULL;
memset(&clientparms, 0, sizeof(clientparms));
XMLRPC_ASSERT(xmlrpc_value_type(paramArrayP) == XMLRPC_TYPE_ARRAY);
curlXportParmsP = malloc(sizeof(*curlXportParmsP));
if (curlXportParmsP == NULL) {
xmlrpc_env_set_fault(envP, XMLRPC_INTERNAL_ERROR, _("Out of memory!"));
return;
}
memset(curlXportParmsP, 0, sizeof(*curlXportParmsP));
/* Have curl do SSL certificate validation */
curlXportParmsP->no_ssl_verifypeer = 0;
curlXportParmsP->no_ssl_verifyhost = 0;
curlXportParmsP->cainfo = "/etc/ipa/ca.crt";
curlXportParmsP->user_agent = user_agent;
/* Enable GSSAPI credentials delegation */
curlXportParmsP->gssapi_delegation = 1;
clientparms.transport = "curl";
clientparms.transportparmsP = (struct xmlrpc_xportparms *)
curlXportParmsP;
clientparms.transportparm_size = XMLRPC_CXPSIZE(gssapi_delegation);
xmlrpc_client_create(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION,
&clientparms, sizeof(clientparms),
&clientP);
/* Set up kerberos negotiate authentication in curl. */
xmlrpc_server_info_set_user(envP, serverInfoP, ":", "");
xmlrpc_server_info_allow_auth_negotiate(envP, serverInfoP);
/* Perform the XML-RPC call */
if (!envP->fault_occurred) {
xmlrpc_client_call2(envP, clientP, serverInfoP, methodName, paramArrayP, resultPP);
}
/* Cleanup */
xmlrpc_server_info_free(serverInfoP);
xmlrpc_client_destroy(clientP);
free((void*)clientparms.transportparmsP);
}
void abrt_xmlrpc_conn::destroy_xmlrpc_client()
{
if (m_pServer_info)
{
xmlrpc_server_info_free(m_pServer_info);
m_pServer_info = NULL;
}
if (m_pClient)
{
xmlrpc_client_destroy(m_pClient);
m_pClient = NULL;
}
}
void
xmlrpc_client_cleanup() {
/*----------------------------------------------------------------------------
This function is not thread-safe
-----------------------------------------------------------------------------*/
XMLRPC_ASSERT(globalClientExists);
xmlrpc_client_destroy(globalClientP);
globalClientExists = false;
/* The following call is not thread-safe */
xmlrpc_client_teardown_global_const();
}
bool initializeXmlRpc(xmlrpc_env *envP, xmlrpc_client **clientPP)
{
//xmlrpc_client_init2(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
if (*clientPP != NULL)
{
xmlrpc_client_teardown_global_const();
xmlrpc_client_destroy(*clientPP);
*clientPP = NULL;
}
if (*clientPP == NULL)
{
xmlrpc_client_setup_global_const(envP);
xmlrpc_client_create(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0, clientPP);
}
if (envP->fault_occurred)
return false;
return true;
}
static void
testSynchCall(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
xmlrpc_value * resultP;
xmlrpc_value * emptyArrayP;
xmlrpc_server_info * noSuchServerInfoP;
xmlrpc_env_init(&env);
emptyArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
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);
noSuchServerInfoP = xmlrpc_server_info_new(&env, "nosuchserver");
TEST_NO_FAULT(&env);
xmlrpc_client_call2(&env, clientP, noSuchServerInfoP, "nosuchmethod",
emptyArrayP, &resultP);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_client_call2f(&env, clientP, "nosuchserver", "nosuchmethod",
&resultP, "(i)", 7);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_server_info_free(noSuchServerInfoP);
xmlrpc_client_destroy(clientP);
xmlrpc_DECREF(emptyArrayP);
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
void
wp_env_clean(xmlrpc_env *env, xmlrpc_client **clientP) {
xmlrpc_env_clean(env);
xmlrpc_client_destroy(*clientP);
xmlrpc_client_teardown_global_const();
}
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
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 */
}
