BugzillaData *bugzilla_new(const char *url, BugzillaErrorCallback cb, void *cb_data) {
BugzillaData *data = new BugzillaData;
bugzilla_set_error_callback(data, cb, cb_data);
xmlrpc_env_init(&data->xenv);
xmlrpc_client_setup_global_const(&data->xenv);
data->url = url;
/*
* to allow https connections; curl by default refuse connections without valid certificate
* (at least docs says that ;))
*/
gparms_curl.no_ssl_verifypeer = 1;
gparms_curl.no_ssl_verifyhost = 1;
/* only curl transport is supported */
gparms.transport = "curl";
gparms.transportparmsP = &gparms_curl;
xmlrpc_client_create(&data->xenv, XMLRPC_CLIENT_NO_FLAGS, "ede-bug-report", "0.1", &gparms, sizeof(gparms), &data->xcli);
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to init xmlrpc client data (%s)\n", data->xenv.fault_string);
if(cb) cb(data->xenv.fault_string, cb_data);
delete data;
data = NULL;
}
return data;
}
void
xmlrpc_client_init2(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) {
/*----------------------------------------------------------------------------
This function is not thread-safe.
-----------------------------------------------------------------------------*/
if (globalClientExists)
xmlrpc_faultf(
envP,
"Xmlrpc-c global client instance has already been created "
"(need to call xmlrpc_client_cleanup() before you can "
"reinitialize).");
else {
/* The following call is not thread-safe */
xmlrpc_client_setup_global_const(envP);
if (!envP->fault_occurred) {
xmlrpc_client_create(envP, flags, appname, appversion,
clientparmsP, parmSize, &globalClientP);
if (!envP->fault_occurred)
globalClientExists = true;
if (envP->fault_occurred)
xmlrpc_client_teardown_global_const();
}
}
}
void
wp_env_init(xmlrpc_env *env, xmlrpc_client **clientP) {
xmlrpc_env_init(env);
xmlrpc_client_setup_global_const(env);
xmlrpc_client_create(env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0,
clientP);
die_if_fault_occurred(env);
}
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);
}
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);
}
/*
* 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
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 */
}
