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