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 */ }