static void
handle_sample_add_response(const char * const serverUrl,
const char * const methodName,
xmlrpc_value * const paramArrayP,
void * const user_data,
xmlrpc_env * const faultP,
xmlrpc_value * const resultP) {
xmlrpc_env env;
xmlrpc_int addend, adder;
/* Initialize our error environment variable */
xmlrpc_env_init(&env);
/* Our first four arguments provide helpful context. Let's grab the
addends from our parameter array.
*/
xmlrpc_decompose_value(&env, paramArrayP, "(ii)", &addend, &adder);
die_if_fault_occurred(&env);
printf("RPC with method '%s' at URL '%s' to add %d and %d "
"has completed\n", methodName, serverUrl, addend, adder);
if (faultP->fault_occurred)
printf("The RPC failed. %s\n", faultP->fault_string);
else {
xmlrpc_int sum;
xmlrpc_read_int(&env, resultP, &sum);
die_if_fault_occurred(&env);
printf("The sum is %d\n", sum);
}
}
static void getRecentPosts( const char *host, const char *username, const char *password )
{
xmlrpc_env env;
xmlrpc_value * resultP = NULL; // array item
xmlrpc_value * firstElementP = NULL; // first element in array
xmlrpc_value * varP = NULL;
const char * postResult = NULL;
int arrsize;
xmlrpc_client_init( XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION );
xmlrpc_env_init( &env );
resultP = xmlrpc_client_call( &env, host,
"blogger.getRecentPosts",
"(ssssi)",
"", /* key, not used */
username, /* journal unique name */
username, /* journal username */
password, /* journal password */
RECENT_POST_COUNT ); /* post count */
die_if_fault_occurred( &env );
arrsize = xmlrpc_array_size( &env, resultP );
die_if_fault_occurred( &env );
//fprintf( stderr, "Array size %d\n", arrsize );
for (int i = 0; i < arrsize; i++ )
{
xmlrpc_array_read_item( &env, resultP, i, &firstElementP);
xmlrpc_struct_find_value( &env, firstElementP, "title", &varP);
if (varP)
{
xmlrpc_read_string( &env, varP, &postResult);
printf( "%d %s\n\n", i, postResult );
free((char *)postResult);
xmlrpc_DECREF( varP );
}
die_if_fault_occurred( &env );
xmlrpc_struct_find_value( &env, firstElementP, "content", &varP);
if (varP)
{
xmlrpc_read_string( &env, varP, &postResult);
printf( "%s\n\n", postResult );
free((char *)postResult);
xmlrpc_DECREF( varP );
}
die_if_fault_occurred( &env );
xmlrpc_DECREF( firstElementP );
}
xmlrpc_DECREF( resultP );
xmlrpc_env_clean( &env );
xmlrpc_client_cleanup();
}
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;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_server_info * serverP;
xmlrpc_value * resultP;
xmlrpc_int sum;
if (argc-1 > 0) {
fprintf(stderr, "There are no arguments. You specified %d", argc-1);
exit(1);
}
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
xmlrpc_env_init(&env);
/* Make a new object to represent our XML-RPC server. */
serverP = xmlrpc_server_info_new(&env, SERVER_URL);
die_if_fault_occurred(&env);
/* Set up our authentication information. */
xmlrpc_server_info_set_basic_auth(&env, serverP, "jrandom", "secret");
die_if_fault_occurred(&env);
resultP =
xmlrpc_client_call_server(
&env, serverP, "sample.add", "(ii)",
(xmlrpc_int32) 5, (xmlrpc_int32) 7);
die_if_fault_occurred(&env);
/* Dispose of our server object. */
xmlrpc_server_info_free(serverP);
/* Get the result of the RPC 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);
/* Shut down our XML-RPC client library. */
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return 0;
}
int
main(int const argc,
const char ** const argv) {
struct cmdlineInfo cmdline;
xmlrpc_env env;
xmlrpc_mem_block * callXmlP;
xmlrpc_mem_block * respXmlP;
const char * url;
xmlrpc_server_info * serverInfoP;
xmlrpc_env_init(&env);
parseCommandLine(&env, argc, argv, &cmdline);
die_if_fault_occurred(&env);
computeUrl(cmdline.url, &url);
createServerInfo(&env, url, cmdline.username, cmdline.password,
&serverInfoP);
die_if_fault_occurred(&env);
fprintf(stderr, "Reading call data from Standard Input...\n");
readFile(&env, stdin, &callXmlP);
die_if_fault_occurred(&env);
fprintf(stderr, "Making call...\n");
doCall(&env, cmdline.transport, serverInfoP, callXmlP,
&respXmlP);
die_if_fault_occurred(&env);
fprintf(stderr, "Writing response data to Standard Output\n");
writeFile(&env, stdout, respXmlP);
die_if_fault_occurred(&env);
XMLRPC_MEMBLOCK_FREE(char, callXmlP);
XMLRPC_MEMBLOCK_FREE(char, respXmlP);
strfree(url);
freeCmdline(cmdline);
xmlrpc_env_clean(&env);
return 0;
}
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 ubigraph_clear()
{
char* const methodName = "ubigraph.clear";
xmlrpc_value * resultP;
if (!xmlrpc_initialized)
init_xmlrpc(0);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,
"()");
die_if_fault_occurred(&env);
xmlrpc_int32 status;
xmlrpc_parse_value(&env, resultP, "i", &status);
die_if_fault_occurred(&env);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
}
void LogEvent_log(char *msg) {
#ifdef DEFINE_XMLRPC
const char *response;
/* printf("Making XMLRPC call to server url '%s' method '%s' "
"to update msg '%s'...\n",
XMLRPC_SERVER_URL, XMLRPC_METHOD_UPDATE, msg);
*/
/* Make the remote procedure call */
_xmlrpc_result = xmlrpc_client_call(&_xmlrpc_env, _xmlrpc_server_url, XMLRPC_METHOD_UPDATE,
"(s)", msg);
die_if_fault_occurred(&_xmlrpc_env);
/* Get our response text and print it out. */
xmlrpc_read_string(&_xmlrpc_env, _xmlrpc_result, &response);
die_if_fault_occurred(&_xmlrpc_env);
//printf("The response is '%s'\n", response);
#endif /* DEFINE_XMLRPC */
printf("%s\n", msg);
}
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);
}
void LogEvent_read(char *buf) {
#ifdef DEFINE_XMLRPC
const char *response;
/* printf("Making XMLRPC call to server url '%s' method '%s' "
"to request GUI events...\n",
XMLRPC_SERVER_URL, XMLRPC_METHOD_POLLGUI);
*/
/* Make the remote procedure call, passing 'true' to block until event! */
_xmlrpc_result = xmlrpc_client_call(&_xmlrpc_env, _xmlrpc_server_url, XMLRPC_METHOD_POLLGUI,
"(b)", 1);
die_if_fault_occurred(&_xmlrpc_env);
/* Get our response text and return it. */
xmlrpc_read_string(&_xmlrpc_env, _xmlrpc_result, &response);
die_if_fault_occurred(&_xmlrpc_env);
strcpy(buf, response);
printf("%s\n", buf);
#else
(void)buf;
#endif /* DEFINE_XMLRPC */
}
result_t ubigraph_new_edge_w_id(edge_id_t e, vertex_id_t x, vertex_id_t y)
{
char* const methodName = "ubigraph.new_edge_w_id";
xmlrpc_value * resultP;
if (!xmlrpc_initialized)
init_xmlrpc(0);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,
"(iii)", (xmlrpc_int32)e, (xmlrpc_int32)x, (xmlrpc_int32)y);
die_if_fault_occurred(&env);
xmlrpc_int32 status;
xmlrpc_parse_value(&env, resultP, "i", &status);
die_if_fault_occurred(&env);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
return status;
}
void init_xmlrpc(const char* url)
{
if (url != NULL)
ubigraph_url = url;
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
die_if_fault_occurred(&env);
xmlrpc_initialized = 1;
}
result_t ubigraph_set_edge_attribute(edge_id_t s, const char* attribute,
const char* value)
{
char* const methodName = "ubigraph.set_edge_attribute";
xmlrpc_value * resultP;
if (!xmlrpc_initialized)
init_xmlrpc(0);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,
"(iss)", (xmlrpc_int32)s, attribute, value);
die_if_fault_occurred(&env);
xmlrpc_int32 status;
xmlrpc_parse_value(&env, resultP, "i", &status);
die_if_fault_occurred(&env);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
return status;
}
int
main(int argc, const char ** argv) {
xmlrpc_env env;
const char * methodName;
xmlrpc_value * paramArrayP;
xmlrpc_mem_block * callXmlP;
if (argc-1 > 0) {
fprintf(stderr, "No arguments. Input is from Standard Input\n");
if (argv){} /* defeat compiler warning */
exit(99);
}
xmlrpc_env_init(&env);
fprintf(stderr, "Reading call data from Standard Input...\n");
readFile(&env, stdin, &callXmlP);
die_if_fault_occurred(&env);
xmlrpc_parse_call(&env,
XMLRPC_MEMBLOCK_CONTENTS(char, callXmlP),
XMLRPC_MEMBLOCK_SIZE(char, callXmlP),
&methodName,
¶mArrayP);
if (env.fault_occurred)
printf("Invalid call. %s\n", env.fault_string);
else {
printf("Parsed successfully as XML-RPC call.\n");
printf("Method name: '%s'\n", methodName);
printf("Parameter array:\n");
dumpValue(" ", paramArrayP);
strfree(methodName);
xmlrpc_DECREF(paramArrayP);
}
XMLRPC_MEMBLOCK_FREE(char, callXmlP);
xmlrpc_env_clean(&env);
return 0;
}
void LogEvent_init(int port) {
#ifdef DEFINE_XMLRPC
char urlBuf[128]; // to store URL built from pattern
/* Construct the server URL from pattern and port, then store it. */
_xmlrpc_server_port = port;
sprintf(urlBuf, XMLRPC_SERVER_URL, _xmlrpc_server_port);
strcpy(_xmlrpc_server_url, urlBuf);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&_xmlrpc_env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&_xmlrpc_env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
die_if_fault_occurred(&_xmlrpc_env);
#else
(void)port;
#endif /* DEFINE_XMLRPC */
}
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;
}
int main( int argc, char *argv[] )
{
xmlrpc_env env;
xmlrpc_value * resultP = NULL;
const char * postResult = NULL;
char username[USERLEN];
char password[PASSLEN];
char entry[ENTRY_MAX];
char host[HOSTLEN];
char * title = NULL;
size_t titlelen;
int c;
size_t i;
bool debug = false;
bool hflag = false;
bool uflag = false;
bool pflag = false;
bool rflag = false;
if ( argc < 3 )
usage( argv[0] );
while ((c = getopt( argc, argv, "h:u:p:s:dr" )) != -1) {
switch( c )
{
case 'h': /* host */
if ( strlen(optarg) > HOSTLEN - 16)
{
fprintf( stderr, "host name is too long" );
exit(EXIT_FAILURE);
}
(void) snprintf(host, HOSTLEN, "http://%s/xml-rpc", optarg);
hflag = true;
break;
case 'u': /* username */
strncpy( username, optarg, USERLEN - 1 );
username[USERLEN -1] = '\0';
uflag = true;
break;
case 'p': /* password */
strncpy( password, optarg, PASSLEN - 1 );
password[PASSLEN -1] = '\0';
pflag = true;
break;
case 's': /* subject */
titlelen = strlen(optarg);
if ( (title = malloc((titlelen * sizeof(char)) + 1)) == NULL )
{
fprintf( stderr, "Unable to allocate memory." );
exit(EXIT_FAILURE);
}
strncpy( title, optarg, titlelen );
title[titlelen] = '\0';
break;
case 'r': /* recent entries */
rflag = true;
break;
case 'd': /* debug */
debug = true;
fprintf( stderr, "Debug enabled.\n");
break;
case '?': /* fall through */
default:
usage( argv[0] );
}
}
argc -= optind;
if ( !uflag || !pflag )
{
fprintf( stderr, "Username and password are required.\n" );
usage( argv[0] );
}
/* set host if it's not defined */
if ( !hflag )
(void) snprintf(host, HOSTLEN, "http://%s/xml-rpc", HOST);
if ( debug && hflag )
fprintf( stderr, "host is set to: %s\n", host );
if ( rflag )
{
getRecentPosts( host, username, password );
exit(0);
}
/* Copy the title into the top of entry if it's requested */
entry[0] = '\0';
if ( title != NULL )
(void) snprintf( entry, ENTRY_MAX, "<title>%s</title>", title );
/* Start from title or the beginning and copy the entry from stdin */
for ( i = strlen(entry); i < ENTRY_MAX -1; i++ )
{
c = getchar();
if ( c == EOF )
break;
entry[i] = (char) c;
}
entry[i] = '\0';
if ( i == 0 )
{
fprintf( stderr, "No entry specified." );
exit(EXIT_FAILURE);
}
xmlrpc_client_init( XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION );
xmlrpc_env_init( &env );
resultP = xmlrpc_client_call( &env, host,
"blogger.newPost",
"(sssssb)",
"", /* key, not used */
username, /* journal unique name */
username, /* journal username */
password, /* journal password */
entry, /* blog content */
true ); /* post now */
die_if_fault_occurred( &env );
xmlrpc_read_string( &env, resultP, &postResult );
if ( debug && postResult != NULL )
fprintf( stderr, "Debug: post result is: %s\n", postResult );
die_if_fault_occurred( &env );
free((char *)postResult);
xmlrpc_DECREF( resultP );
xmlrpc_env_clean( &env );
xmlrpc_client_cleanup();
return 0;
}
static void die_if_fault_occurred_line (xmlrpc_env *env, int line)
{
if (env->fault_occurred)
fprintf(stderr, "LINE: %d\n", line);
die_if_fault_occurred(env);
}
