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
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();
}
}
}
int main(int argc, char *argv[])
{
/* update progname from argv[0] */
set_progname(argv[0]);
const struct ap_Option options[] = {
{'h', "help", ap_no, 0, 0},
{'v', "version", ap_no, 0, 0},
{0, 0, ap_no, 0, 0}
};
if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
critx("could not allocate memory for option parser");
if (ap_error(&parser)) {
errx("%s", ap_error(&parser));
usage(EXIT_FAILURE);
}
/* parse command line */
for (int argind = 0; argind < ap_arguments(&parser); argind++) {
const int code = ap_code(&parser, argind);
switch (code) {
case 0:
break;
case 'h':
usage(EXIT_SUCCESS);
break;
case 'v':
fprintf(stderr, "%s %s\n%s\n%s\n\n%s\n", progname,
FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
exit(EXIT_SUCCESS);
break;
default:
errx("uncaught option: %s", ap_argument(&parser, argind));
usage(EXIT_FAILURE);
break;
}
}
if (!ap_arguments(&parser)) {
errx("no address given");
usage(EXIT_FAILURE);
}
xmlrpc_env rpc_env;
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (int argind = 0; argind < ap_arguments(&parser); argind++)
/* if non-option, it is an address */
if (!ap_code(&parser, argind))
stop_flows(ap_argument(&parser, argind));
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
ap_free(&parser);
}
int main(int argc, char *argv[])
{
char ch, *tok;
int i;
xmlrpc_env rpc_env;
/* update progname from argv[0] */
if (argc > 0) {
/* Strip path */
tok = strrchr(argv[0], '/');
if (tok)
tok++;
else
tok = argv[0];
if (*tok) {
strncpy(progname, tok, sizeof(progname));
progname[sizeof(progname) - 1] = 0;
}
}
#ifdef HAVE_GETOPT_LONG
/* getopt_long isn't portable, it's GNU extension */
struct option lo[] = { {"help", 0, 0, 'h' },
{"version", 0, 0, 'v'},
{0, 0, 0, 0}
};
while ((ch = getopt_long(argc, argv, "hv", lo, 0)) != -1) {
#else
while ((ch = getopt(argc, argv, "hv")) != -1) {
#endif
switch (ch) {
case 'h':
usage(argv[0]);
break;
case 'v':
fprintf(stderr, "flowgrind version: %s\n", FLOWGRIND_VERSION);
exit(0);
break;
default:
usage(argv[0]);
break;
}
}
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (i = optind; i < argc; i++) {
stop_flows(argv[i]);
}
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
return 0;
}
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;
}
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;
}
static void
testGlobalConst(void) {
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
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
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);
}
