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); }