result_t ubigraph_remove_edge(edge_id_t e)
{
char* const methodName = "ubigraph.remove_edge";
xmlrpc_value * resultP;
if (!xmlrpc_initialized)
init_xmlrpc(0);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,
"(i)", (xmlrpc_int32) e);
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;
}
result_t ubigraph_set_edge_style_attribute(style_id_t s, const char* attribute,
const char* value)
{
char* const methodName = "ubigraph.set_edge_style_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;
}
bool ArchiveDataClient::getInfo(int &version,
stdString &description,
stdVector<stdString> &how_strings,
stdVector<stdString> &stat_strings,
stdVector<SeverityInfo> &sevr_infos)
{
xmlrpc_value *result, *hows, *stats, *sevrs, *element;
xmlrpc_int32 num;
xmlrpc_bool has_value, txt_stat;
const char *str;
size_t count, len, i;
result = xmlrpc_client_call(&env, (char *)URL, "archiver.info", "()");
if (log_fault())
return false;
xmlrpc_parse_value(&env, result, "{s:i,s:s#,s:A,s:A,s:A,*}",
"ver", &num,
"desc", &str, &len,
"how", &hows,
"stat", &stats,
"sevr", &sevrs);
if (log_fault())
return false;
version = num;
description.assign(str, len);
// 'how' array
count = xmlrpc_array_size(&env, hows);
how_strings.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, hows, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s", &str);
if (log_fault())
return false;
how_strings.push_back(stdString(str));
}
// 'stat' array
count = xmlrpc_array_size(&env, stats);
stat_strings.reserve(count);
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, stats, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "s", &str);
if (log_fault())
return false;
stat_strings.push_back(stdString(str));
}
// 'sevr' array
count = xmlrpc_array_size(&env, sevrs);
stat_strings.reserve(count);
SeverityInfo info;
for (i=0; i<count; ++i)
{
element = xmlrpc_array_get_item(&env, sevrs, i);
if (log_fault())
return false;
xmlrpc_parse_value(&env, element, "{s:i,s:s#,s:b,s:b,*}",
"num", &num,
"sevr", &str, &len,
"has_value", &has_value,
"txt_stat", &txt_stat);
if (log_fault())
return false;
info.num = num;
info.text.assign(str, len);
info.has_value = has_value;
info.txt_stat = txt_stat;
sevr_infos.push_back(info);
}
xmlrpc_DECREF(result);
return true;
}
int main( int argc, char *argv[] )
{
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_value * keyP;
xmlrpc_value * valueP;
int struct_size;
int i, j;
size_t length;
const char * str_key_value;
xmlrpc_int int_key_value;
unsigned int max_hits = 0;
unsigned int rows = 0;
int rv;
char *uri;
int options; /* what kind of nodes should be processed */
int uri_pos; /* position of first non option argument */
char stropts[16];
int pos = 0;
int mask_length = 32; /* 32 means NO aggregate */
if (argc-1 < 1) {
print_help();
exit(0);
}
uri_pos = process_options(argc, argv, &options, &mask_length);
switch (options) {
case OPT_HOT:
sprintf(stropts, "HOT");
break;
case OPT_ALL:
sprintf(stropts, "ALL");
break;
case OPT_WARM:
sprintf(stropts, "WARM");
break;
}
printf("Nodes = %s\n", stropts);
printf("Mask = /%d\n", mask_length);
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* prototype:
xmlrpc_value * xmlrpc_client_call(xmlrpc_env * const envP,
const char * const server_url, const char * const method_name,
const char * const format, ...);
*/
asprintf(&uri, "http://%s/RPC2", argv[uri_pos]);
resultP = xmlrpc_client_call(&env, uri,
"pike.top",
"(s)", stropts);
free(uri);
die_if_fault_occurred_line(&env, __LINE__);
/* parse returned structure */
if ( xmlrpc_value_type(resultP) != XMLRPC_TYPE_STRUCT ) {
printf("unexpected result - should be structure\n");
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
exit(1);
}
struct_size = xmlrpc_struct_size(&env, resultP);
die_if_fault_occurred_line(&env, __LINE__);
// printf("Struct size: %d\n", struct_size);
if ( ! get_int_from_struct_by_name(resultP, MAX_HITS, &max_hits) ) {
fprintf(stderr, "ERROR: %s not foung in result\n", MAX_HITS);
exit (1);
}
printf("max_hits = %d\n", max_hits);
if ( ! get_int_from_struct_by_name(resultP, NUMBER_OF_ROWS, &rows) ) {
fprintf(stderr, "ERROR: %s not foung in result\n", NUMBER_OF_ROWS);
exit (1);
}
printf("rows = %d\n", rows);
TopItem top_items[rows];
TopItem *item; /* tmp item ptr */
TopItem *result_items = top_items; /* if no aggregation use this */
memset(top_items, 0, sizeof(top_items));
/* aggregated values */
if ( rows == 0 )
return 0;
for ( i = 0, item = top_items; i < rows; ++i, ++item ) {
if ( ! read_row(resultP, i, item) ) {
fprintf(stderr, "ERROR: while reading row number %d\n", i);
}
/* fill in ipv4 addr */
// printf("item[%d].ip_addr = %s, len = %d\n", i, item->ip_addr, strlen(item->ip_addr));
rv = inet_pton(AF_INET, item->ip_addr, &item->ipv4_addr);
if ( rv > 0 ) {
// printf("IPv4 addr: %x\n", item->ipv4_addr);
} else {
fprintf(stderr, "IP conversion failed - not an IPv4 address: '%s'\n", item->ip_addr); /* conversion failed from any reason */
printf("item[%d].ipv4_addr = %x\n", i, item->ipv4_addr);
}
}
assert( rows > 0 );
/* if IP mask length is shorter than 32 then aggregate list according to the mask */
if ( mask_length < 32 ) {
uint32_t ip_mask = htonl(mask(mask_length));
qsort(top_items, rows, sizeof(TopItem), compare_TopItem_ipv4_addr); /* sort by IPv4 */
/* skip items without ipv4 address */
i = 0; /* index of non aggregated items */
while (!top_items[i].ipv4_addr && i < rows ) {
printf("Skip item[%d] - do not has IPv4 address: %s\n", i, top_items[i].ip_addr);
memset(&top_items[i], 0, sizeof(TopItem));
++i;
}
j = 0; /* index of aggregated items */
if ( i == 0 )
++i;
top_items[0].ipv4_addr &= ip_mask;
top_items[0].num_of_ips = 1;
inet_ntop(AF_INET, &top_items[0].ipv4_addr, top_items[0].ip_addr, sizeof(top_items[0].ip_addr));
while ( i < rows ) {
top_items[i].ipv4_addr &= ip_mask;
if ( top_items[j].ipv4_addr == top_items[i].ipv4_addr ) {
top_items[j].leaf_hits[0] += top_items[i].leaf_hits[0];
top_items[j].leaf_hits[1] += top_items[i].leaf_hits[1];
++(top_items[j].num_of_ips);
++i;
}
else {
++j;
top_items[j] = top_items[i];
top_items[j].num_of_ips = 1;
inet_ntop(AF_INET, &top_items[j].ipv4_addr, top_items[j].ip_addr, sizeof(top_items[j].ip_addr));
++i;
}
}
rows = j + 1;
}
qsort(top_items, rows, sizeof(TopItem), compare_TopItem_hits_reverse);
print_rows( top_items, rows, mask_length );
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
xmlrpc_value *
build_call(xmlrpc_env *const envP, struct client_method_info *cmi)
{
return xmlrpc_client_call(envP, cmi->instance->serverURL, "build", "()", NULL);
}
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;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 number_of_links;
const char * const serverUrl = "http://localhost:4567/RPC2";
const char * const methodName = "get_number_of_links";
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
/* 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);
dieIfFaultOccurred(&env);
printf("Making XMLRPC call to server url '%s' method '%s'\n", serverUrl, "get_number_of_links");
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_number_of_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &number_of_links);
dieIfFaultOccurred(&env);
printf("Number of links defined: %d\n", number_of_links);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
int array_size =xmlrpc_array_size(&env, resultP);
while(array_size>0) {
--array_size;
xmlrpc_value *value;
const char *link;
xmlrpc_array_read_item(&env, resultP, 0, &value);
xmlrpc_read_string(&env, value, &link);
printf("Link %u: %s\n", array_size, link);
xmlrpc_DECREF(value);
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "add_target", "(i)",
(xmlrpc_int32) 1);
xmlrpc_int64 targetID = 0;
xmlrpc_read_i8(&env, resultP, &targetID);
if(targetID) {
printf("New target added with ID: %"PRIx64"\n", targetID);
} else {
printf("Failed to add new target!\n");
goto done;
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "remove_target", "(i)",
(xmlrpc_int64) targetID);
xmlrpc_int32 res;
xmlrpc_read_int(&env, resultP, &res);
printf("Target %"PRIx64" remove: %"PRIx32"\n", targetID, res);
done:
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
/* This function facilitates the capabilities of the proxy server
* by receiving data on one socket and immediately forwarding it
* on to the next socket. Given the vast memory requirements that
* could be needed to create a buffer to store an entire transmission
* before forwarding it on (a la recvAll()), this function streamlines
* that process by sending off each data chunk as it is received.
*
* @param fromSock The socket identifier on which it receives data.
* @param toSock The socket identifier to which data is sent.
* @param header The actual header received.
* @param headerLength This will contain the length of the header.
* @param bodyLength This will contain the length of the expected body.
* @param compression Indicates if incoming file is a JPG.
* @param env The XML-RPC environment.
* @param server The RPC server.
* @return The number of bytes forwarded, or -1 on failure.
*/
int recvAll_Forward(int fromSock, int toSock, void* header,
long int headerLength, long int bodyLength,
int compression, xmlrpc_env* env, char* server) {
char inputBuffer[20000];
long int bytesReceived = 0, bytesSent = 0;
int arbitraryReceive = 0; /* set this flag if bodyLength < 0 */
void* imgBuffer, *compImgBuffer;
long int compImgSize;
/* first, send out the header */
if (sendAll(toSock, header, &headerLength) < 0) {
return -1;
}
#ifdef DEBUG
printf("Length of body to receive: %ld\n", bodyLength);
#endif
/* do some checks...is there even a Content-Length? */
if (bodyLength < 0) { /* going to try... */
arbitraryReceive = 1;
}
/* now, grab the incoming body */
while (bytesReceived < bodyLength || arbitraryReceive) {
long int bytes;
memset(&inputBuffer, 0, sizeof(inputBuffer));
bytes = recv(fromSock, inputBuffer, (sizeof(inputBuffer) - 1), 0);
if (bytes < 0) {
#ifdef DEBUG
printf("Error receiving data on socket!\n");
#endif
return -1;
} else if (bytes == 0) { /* connection closed */
if (compression) { /* send it out */
xmlrpc_value* result;
char* methodName = "compress";
/* send RPC request */
result = xmlrpc_client_call(env, server, methodName, "(6)", imgBuffer, bytesReceived);
if (env->fault_occurred) {
#ifdef DEBUG
printf("proxy.c: Error making sudden RPC client call!\n");
#endif
free(compImgBuffer);
free(imgBuffer);
return -1;
}
xmlrpc_decompose_value(env, result, "(6)", &compImgBuffer, &compImgSize);
if (env->fault_occurred) {
#ifdef DEBUG
printf("proxy.c: Error decomposing sudden RPC server response!\n");
#endif
free(compImgBuffer);
free(imgBuffer);
xmlrpc_DECREF(result);
return -1;
}
if (sendAll(toSock, compImgBuffer, &compImgSize) < 0) {
#ifdef DEBUG
printf("proxy.c: Error sending sudden compressed image to client!\n");
#endif
free(compImgBuffer);
free(imgBuffer);
xmlrpc_DECREF(result);
return -1;
}
#ifdef DEBUG
printf("proxy.c: Sent %ld sudden compressed image bytes.\n", bytesSent);
#endif
bytesSent = compImgSize;
}
return bytesSent + headerLength;
}
/* got something valid. now send it back out */
bytesReceived += bytes;
if (!compression) { /* forward normally */
if (sendAll(toSock, inputBuffer, &bytes) < 0) {
return -1;
}
} else { /* need to buffer everything received */
#ifdef DEBUG
printf("proxy.c: Buffering - increasing size from %ld to %ld.\n", (bytesReceived - bytes), bytesReceived);
#endif
imgBuffer = realloc(imgBuffer, sizeof(char) * bytesReceived);
memcpy((char*)imgBuffer + (bytesReceived - bytes), inputBuffer, bytes);
}
#ifdef DEBUG
printf("Successfully sent %ld bytes!\n", bytes);
#endif
/* success! */
bytesSent += bytes;
}
if (compression && bytesReceived > 0) { /* now we need to send everything */
xmlrpc_value* result;
char* methodName = "compress";
/* send RPC request */
result = xmlrpc_client_call(env, server, methodName, "(6)", imgBuffer, bytesReceived);
if (env->fault_occurred) {
#ifdef DEBUG
printf("proxy.c: Error making final RPC client call!\n");
#endif
free(imgBuffer);
return -1;
}
xmlrpc_decompose_value(env, result, "(6)", &compImgBuffer, &compImgSize);
if (env->fault_occurred) {
#ifdef DEBUG
printf("proxy.c: Error decomposing final RPC server response!\n");
#endif
free(imgBuffer);
return -1;
}
/* send the image to the client */
if (sendAll(toSock, compImgBuffer, &compImgSize) < 0) {
#ifdef DEBUG
printf("proxy.c: Error sending final compressed image to client!\n");
#endif
free(compImgBuffer);
free(imgBuffer);
xmlrpc_DECREF(result);
return -1;
}
bytesSent = compImgSize;
#ifdef DEBUG
printf("proxy.c: Image of size %ld compressed to client.\n", bytesSent);
#endif
}
/* return the header length plus number of successful bytes sent */
return headerLength + bytesSent;
}
node_t * xmlrpc_client_callmethod(const char * serverUrl, const char * methodName, unsigned int argVersion){
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFailed("Client initialization", &env);
xmlrpc_value * ID, * PORT, * DATA, * DATAP, * IP;
ID = xmlrpc_int_new(&env, 23121);
IP = xmlrpc_string_new(&env, "127.0.0.1");
PORT = xmlrpc_int_new(&env, 8085);
DATA = xmlrpc_int_new(&env, 123);
DATAP = xmlrpc_struct_new(&env);
xmlrpc_struct_set_value(&env, DATAP, "ID", ID);
xmlrpc_struct_set_value(&env, DATAP, "IP", IP);
xmlrpc_struct_set_value(&env, DATAP, "PORT", PORT);
xmlrpc_struct_set_value(&env, DATAP, "DATA", DATA);
xmlrpc_DECREF(ID);
xmlrpc_DECREF(IP);
xmlrpc_DECREF(PORT);
xmlrpc_DECREF(DATA);
/* Make the call */
xmlrpc_value * resultArray = xmlrpc_client_call(&env, serverUrl, methodName, "(iS)", (xmlrpc_int32) argVersion, DATAP);
xmlrpc_value * OutID_t, *OutPORT_t, *OutDATA_t, *OutIP_t;
xmlrpc_int OutID, OutPORT, OutDATA;
char * OutIP;
unsigned int const resultCt = xmlrpc_array_size(&env, resultArray);
unsigned int i;
node_t * resultnode = (node_t *) malloc(3*sizeof(node_t));
for(i = 0; i < resultCt; ++i){
xmlrpc_value * resultP;
xmlrpc_array_read_item(&env, resultArray, i, &resultP);
xmlrpc_struct_find_value(&env, resultP, "ID", &OutID_t);
xmlrpc_struct_find_value(&env, resultP, "IP", &OutIP_t);
xmlrpc_struct_find_value(&env, resultP, "PORT", &OutPORT_t);
xmlrpc_struct_find_value(&env, resultP, "DATA", &OutDATA_t);
xmlrpc_read_int(&env, OutID_t, &OutID);
xmlrpc_read_string(&env, OutIP_t, &OutIP);
xmlrpc_read_int(&env, OutPORT_t, &OutPORT);
xmlrpc_read_int(&env, OutDATA_t, &OutDATA);
resultnode[i].ID = OutID;
strcpy(resultnode[i].IP, OutIP);
resultnode[i].PORT = OutPORT;
resultnode[i].DATA = OutDATA;
}
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return resultnode;
}
