Exemple #1
0
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);

}
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);
}
Exemple #3
0
void bugzilla_logout(BugzillaData *data) {
	E_ASSERT(data != NULL);

	xmlrpc_value *result;
	xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "User.logout", &result, "()");

	if(data->xenv.fault_occurred) {
		E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
		if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
		return;
	}

	xmlrpc_DECREF(result);
}
Exemple #4
0
char *bugzilla_get_version(BugzillaData *data) {
	E_ASSERT(data != NULL);

	xmlrpc_value *result;
	xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bugzilla.version", &result, "()");

	if(data->xenv.fault_occurred) {
		E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
		if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
		return (char*)"";
	}

	/* this value will be malloc()-ated by xmlrpc_decompose_value() and should be freeed by user */
	char *ret;
	xmlrpc_decompose_value(&data->xenv, result, "{s:s,*}", "version", &ret);
	xmlrpc_DECREF(result);

	return ret;
}
char *
wpGetBlogId(char *username, char *password, char *url) {
	char *blogid;
	int i;
	int noOfBlogs;
	xmlrpc_env env;
	xmlrpc_client *clientP;
	char *methodName = "wp.getUsersBlogs";
	xmlrpc_value *result, *result2;

	wp_env_init(&env, &clientP);

	/* Make the remote procedure call */
	xmlrpc_client_call2f(&env, clientP, url, methodName, &result,
							"(ss)", username, password);
	die_if_fault_occurred(&env);
	noOfBlogs = xmlrpc_array_size(&env, result);
	if ( noOfBlogs > 1 ) {
		fprintf(stderr, "Currently only single blog wp accounts are supported\n");
		blogid = NULL;
		goto out;
	}
	for(i = 0; i < noOfBlogs; i++) {
		xmlrpc_value *blog_id_xml;
		xmlrpc_array_read_item(&env, result, i, &result2);
		xmlrpc_struct_read_value(&env, result2, "blogid", &blog_id_xml);
		xmlrpc_read_string(&env, blog_id_xml,(const char **) &blogid);
		xmlrpc_DECREF(blog_id_xml);
	}

	/* Dispose of our result value. */
	xmlrpc_DECREF(result2);

out:
	xmlrpc_DECREF(result);

	/* Clean up our error-handling environment. */
	wp_env_clean(&env, &clientP);
	
	return blogid;
}
Exemple #6
0
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);
}
static void
addInterruptibly(xmlrpc_client * const clientP,
                 const char *    const serverUrl,
                 int             const addend,
                 int             const adder) {

    const char * const methodName = "sample.add";

    xmlrpc_env env;
    xmlrpc_value * resultP;
    xmlrpc_int32 sum;

    xmlrpc_env_init(&env);

    printf("Making XMLRPC call to server url '%s' method '%s' "
           "to request the sum "
           "of %d and %d...\n", serverUrl, methodName, addend, adder);

    interrupt = 0;  /* Global variable */

    alarm(2); /* Interrupt the call if it hasn't finished 2 seconds from now */

    /* Make the remote procedure call */

    xmlrpc_client_call2f(&env, clientP, serverUrl, methodName, &resultP,
                         "(ii)", (xmlrpc_int32) addend, (xmlrpc_int32) adder);
    die_if_fault_occurred(&env);

    alarm(0);  /* Cancel alarm, if it hasn't happened yet */
    
    /* Get our sum and print it out. */
    xmlrpc_read_int(&env, resultP, &sum);
    die_if_fault_occurred(&env);
    printf("The sum is %d\n", sum);
    
    /* Dispose of our result value. */
    xmlrpc_DECREF(resultP);

    xmlrpc_env_clean(&env);
}
Exemple #8
0
int bugzilla_login(BugzillaData *data, const char *user, const char *passwd) {
	E_ASSERT(data != NULL);

	xmlrpc_value *result;
	int remember = 0;  /* remember login data */
	int id = -1; /* bugzilla user id */

	xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "User.login", &result,
			"({s:s,s:s,s:b})",
			"login", user,
			"password", passwd,
			"remember", remember);

	if(data->xenv.fault_occurred) {
		E_WARNING(E_STRLOC ": Unable to perform login function (%s)\n", data->xenv.fault_string);
		if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
		return id;
	}

	xmlrpc_decompose_value(&data->xenv, result, "{s:i,*}", "id", &id);
	xmlrpc_DECREF(result);

	return id;
}
Exemple #9
0
int bugzilla_submit_bug(BugzillaData *data,
						const char *product,
						const char *component,
						const char *summary,
						const char *version,
						const char *description,
						const char *op_sys,
						const char *platform,
						const char *priority,
						const char *severity,
						const char *cc)
{
	E_ASSERT(data != NULL);

	int bug_id = -1;
	xmlrpc_value *result;

	/* if given CC, add it so bugzilla assign that email as notification receiver */
	if(cc) {
		/* as for now we only support single email address */
		xmlrpc_value *cc_array, *cc_str;

		cc_array = xmlrpc_array_new(&data->xenv);
		cc_str = xmlrpc_string_new(&data->xenv, (const char *const)cc);
		xmlrpc_array_append_item(&data->xenv, cc_array, cc_str);
		xmlrpc_DECREF(cc_str);

		xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bug.create", &result,
							 "({s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:A})",
							 "product", product,
							 "component", component,
							 "summary", summary,
							 "version", version,
							 "description", description,
							 "op_sys", op_sys,
							 "platform", platform,
							 "priority", priority,
							 "severity", severity,
							 "cc", cc_array);
		xmlrpc_DECREF(cc_array);
	} else {
		xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bug.create", &result,
							 "({s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s})",
							 "product", product,
							 "component", component,
							 "summary", summary,
							 "version", version,
							 "description", description,
							 "op_sys", op_sys,
							 "platform", platform,
							 "priority", priority,
							 "severity", severity);
	}

	if(data->xenv.fault_occurred) {
		E_WARNING(E_STRLOC ": Unable to perform submit function (%s)\n", data->xenv.fault_string);
		if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
		return bug_id;
	}

	xmlrpc_decompose_value(&data->xenv, result, "{s:i,*}", "id", &bug_id);
	xmlrpc_DECREF(result);

	return bug_id;
}