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(); }
static void unpack(xmlrpc_env *envP, xmlrpc_value *s, const char *mem, char **valp) { xmlrpc_value *val; xmlrpc_struct_find_value(envP, s, mem, &val); if (val) xmlrpc_read_string(envP, val, (const char **const)valp); }
xmlrpc_value * server_status(xmlrpc_env * envP, struct call_info *cip, char ** statusp) { xmlrpc_value *resultP = NULL; struct client_method_info *cmi = NULL; struct meths_tab *meth = NULL; struct call_info *cip_status = callinfo_clone(cip); cip_status->files = NULL; cip_status->methodargs = NULL; cip_status->method = "status"; if (!(meth = meths(cip_status->method, strlen(cip_status->method)))) { fprintf(stderr, "oracc-client: unknown method name `%s'\n", cip_status->method); exit(1); } cmi = meth->info; meth->info->instance = cip_status; resultP = cmi->call(envP, cmi); dieIfFaultOccurred(envP); if (resultP) { char *str = NULL; xmlrpc_value *status = NULL; xmlrpc_struct_find_value(envP, resultP, "method-status", &status); if (status) { trace(); xmlrpc_read_string(envP, status, (const char **)&str); /* This diagnostic needs to be suppressable */ fprintf(stderr, "server-status: status=%s\n", str); *statusp = NULL; if (!strcmp(str, "completed")) return resultP; } else { fprintf(stderr, "!server-status: no method-status\n"); *statusp = "no method status returned by status request"; /* should return an error condition to caller here so that when server bombs/loses session client can terminate gracefully */ } } else *statusp = "!no result from status request"; /* Dispose of our result value. */ xmlrpc_DECREF(resultP); return NULL; }
char * result_method_status(xmlrpc_env *envP, xmlrpc_value *s) { char *str = NULL; if (s) { xmlrpc_value *status = NULL; xmlrpc_struct_find_value(envP, s, "method-status", &status); if (status) xmlrpc_read_string(envP, status, (const char **)&str); } return str; }
/* FIXME terminates the programm if it fails */ int get_string_from_struct_by_name(xmlrpc_value *structP, const char *element_name, char **rv) { xmlrpc_env env; xmlrpc_env_init(&env); xmlrpc_value *valueP; int length; xmlrpc_struct_find_value(&env, structP, element_name, &valueP); die_if_fault_occurred_line(&env, __LINE__); xmlrpc_read_string(&env, valueP, (const char **)rv); die_if_fault_occurred_line(&env, __LINE__); xmlrpc_DECREF(valueP); return 1; }
int result_method_file(xmlrpc_env *envP, xmlrpc_value *s, const char *member, const char *fname) { if (s) { xmlrpc_value *file = NULL; xmlrpc_struct_find_value(envP, s, member, &file); if (file) return file_dump(envP, file, fname); else fprintf(stderr, "oracc-client: result_method_file: %s not found\n", member); } return 0; }
char * result_request_status(xmlrpc_env *envP, xmlrpc_value *s) { char *str = NULL; if (s) { xmlrpc_value *status = NULL; xmlrpc_struct_find_value(envP, s, "status", &status); dieIfFaultOccurred(envP); if (status) xmlrpc_read_string(envP, status, (const char **)&str); } return str; }
int getIntFromXmlRpcStruct(xmlrpc_env *const envP, QString memberName, xmlrpc_value *const xmlrpcStructP) throw (QString) { int ret; xmlrpc_value *structMemberP; xmlrpc_struct_find_value(envP, xmlrpcStructP, memberName.toAscii(), &structMemberP); assertOk(envP); xmlrpc_read_int(envP, structMemberP, &ret); assertOk(envP); return ret; }
QString getStringFromXmlRpcStruct(xmlrpc_env *const envP, QString memberName, xmlrpc_value *const xmlrpcStructP) throw (QString) { const char *ret; xmlrpc_value *structMemberP; xmlrpc_struct_find_value(envP, xmlrpcStructP, memberName.toAscii(), &structMemberP); assertOk(envP); xmlrpc_read_string(envP, structMemberP, &ret); assertOk(envP); return QString(ret); }
xmlrpc_value *rhbz_get_member(const char *member, xmlrpc_value *xml) { func_entry_str(member); xmlrpc_env env; xmlrpc_env_init(&env); xmlrpc_value *value = NULL; /* The xmlrpc_struct_find_value functions consider "not found" to be * a normal result. If a member of the structure with the specified key * exists, it returns it as a handle to an xmlrpc_value. If not, it returns * NULL in place of that handle. */ xmlrpc_struct_find_value(&env, xml, member, &value); if (env.fault_occurred) abrt_xmlrpc_error(&env); return value; }
/* Get an integer value from struct result of xmlrpc_client_call() * @param structP pointer to a result struct * @param element_name name of structure item * @param rv returned value * @return 1 if succeed and 0 otherwise */ int get_int_from_struct_by_name(xmlrpc_value *structP, const char *element_name, int *rv) { xmlrpc_env env; xmlrpc_env_init(&env); xmlrpc_value *valueP; xmlrpc_struct_find_value(&env, structP, element_name, &valueP); if ( env.fault_occurred ) goto error; xmlrpc_read_int(&env, valueP, rv); if ( env.fault_occurred ) goto error1; xmlrpc_DECREF(valueP); return 1; error1: xmlrpc_DECREF(valueP); error: return 0; }
static void dispatch_call(xmlrpc_env * const envP, xmlrpc_registry * const registryP, const char * const methodName, xmlrpc_value * const paramArrayP, xmlrpc_value ** const resultPP) { callPreinvokeMethodIfAny(envP, registryP, methodName, paramArrayP); if (!envP->fault_occurred) { xmlrpc_value * method_info; /* Look up the method info for the named method. */ xmlrpc_struct_find_value(envP, registryP->_methods, methodName, &method_info); if (!envP->fault_occurred) { if (method_info) { callNamedMethod(envP, method_info, paramArrayP, resultPP); xmlrpc_DECREF(method_info); } else { if (registryP->_default_method) callDefaultMethod(envP, registryP->_default_method, methodName, paramArrayP, resultPP); else { /* No matching method, and no default. */ xmlrpc_env_set_fault_formatted( envP, XMLRPC_NO_SUCH_METHOD_ERROR, "Method '%s' not defined", methodName); } } } } /* For backward compatibility, for sloppy users: */ if (envP->fault_occurred) *resultPP = NULL; }
static int join_krb5(const char *ipaserver, char *hostname, char **hostdn, const char **princ, const char **subject, int force, int quiet) { xmlrpc_env env; xmlrpc_value * argArrayP = NULL; xmlrpc_value * paramArrayP = NULL; xmlrpc_value * paramP = NULL; xmlrpc_value * optionsP = NULL; xmlrpc_value * resultP = NULL; xmlrpc_value * structP = NULL; xmlrpc_server_info * serverInfoP = NULL; struct utsname uinfo; xmlrpc_value *princP = NULL; xmlrpc_value *krblastpwdchangeP = NULL; xmlrpc_value *subjectP = NULL; xmlrpc_value *hostdnP = NULL; const char *krblastpwdchange = NULL; char * url = NULL; char * user_agent = NULL; int rval = 0; int ret; *hostdn = NULL; *subject = NULL; *princ = NULL; /* Start up our XML-RPC client library. */ xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION); uname(&uinfo); xmlrpc_env_init(&env); xmlrpc_client_setup_global_const(&env); #if 1 ret = asprintf(&url, "https://%s:443/ipa/xml", ipaserver); #else ret = asprintf(&url, "http://%s:8888/", ipaserver); #endif if (ret == -1) { if (!quiet) fprintf(stderr, _("Out of memory!\n")); rval = 3; goto cleanup; } serverInfoP = xmlrpc_server_info_new(&env, url); argArrayP = xmlrpc_array_new(&env); paramArrayP = xmlrpc_array_new(&env); if (hostname == NULL) paramP = xmlrpc_string_new(&env, uinfo.nodename); else paramP = xmlrpc_string_new(&env, hostname); xmlrpc_array_append_item(&env, argArrayP, paramP); #ifdef REALM if (!quiet) printf("Joining %s to IPA realm %s\n", uinfo.nodename, iparealm); #endif xmlrpc_array_append_item(&env, paramArrayP, argArrayP); xmlrpc_DECREF(paramP); optionsP = xmlrpc_build_value(&env, "{s:s,s:s}", "nsosversion", uinfo.release, "nshardwareplatform", uinfo.machine); xmlrpc_array_append_item(&env, paramArrayP, optionsP); xmlrpc_DECREF(optionsP); if ((user_agent = set_user_agent(ipaserver)) == NULL) { rval = 3; goto cleanup; } callRPC(user_agent, &env, serverInfoP, "join", paramArrayP, &resultP); if (handle_fault(&env)) { rval = 17; goto cleanup_xmlrpc; } /* Return value is the form of an array. The first value is the * DN, the second a struct of attribute values */ xmlrpc_array_read_item(&env, resultP, 0, &hostdnP); xmlrpc_read_string(&env, hostdnP, (const char **)hostdn); xmlrpc_DECREF(hostdnP); xmlrpc_array_read_item(&env, resultP, 1, &structP); xmlrpc_struct_find_value(&env, structP, "krbprincipalname", &princP); if (princP) { xmlrpc_value * singleprincP = NULL; /* FIXME: all values are returned as lists currently. Once this is * fixed we can read the string directly. */ xmlrpc_array_read_item(&env, princP, 0, &singleprincP); xmlrpc_read_string(&env, singleprincP, &*princ); xmlrpc_DECREF(princP); xmlrpc_DECREF(singleprincP); } else { if (!quiet) fprintf(stderr, _("principal not found in XML-RPC response\n")); rval = 12; goto cleanup; } xmlrpc_struct_find_value(&env, structP, "krblastpwdchange", &krblastpwdchangeP); if (krblastpwdchangeP && !force) { xmlrpc_value * singleprincP = NULL; /* FIXME: all values are returned as lists currently. Once this is * fixed we can read the string directly. */ xmlrpc_array_read_item(&env, krblastpwdchangeP, 0, &singleprincP); xmlrpc_read_string(&env, singleprincP, &krblastpwdchange); xmlrpc_DECREF(krblastpwdchangeP); if (!quiet) fprintf(stderr, _("Host is already joined.\n")); rval = 13; goto cleanup; } xmlrpc_struct_find_value(&env, structP, "ipacertificatesubjectbase", &subjectP); if (subjectP) { xmlrpc_value * singleprincP = NULL; /* FIXME: all values are returned as lists currently. Once this is * fixed we can read the string directly. */ xmlrpc_array_read_item(&env, subjectP, 0, &singleprincP); xmlrpc_read_string(&env, singleprincP, *&subject); xmlrpc_DECREF(subjectP); } cleanup: if (argArrayP) xmlrpc_DECREF(argArrayP); if (paramArrayP) xmlrpc_DECREF(paramArrayP); if (resultP) xmlrpc_DECREF(resultP); cleanup_xmlrpc: free(user_agent); free(url); free((char *)krblastpwdchange); xmlrpc_env_clean(&env); xmlrpc_client_cleanup(); return rval; }
static void test_struct_get_element(xmlrpc_value * const structP, xmlrpc_value * const fooValueP, xmlrpc_value * const weirdValueP, const char * const weirdKey, unsigned int const weirdKeyLen) { xmlrpc_env env; xmlrpc_value * valueP; xmlrpc_value * fooStringP; xmlrpc_value * bogusKeyStringP; xmlrpc_env_init(&env); /* build test tools */ fooStringP = xmlrpc_build_value(&env, "s", "foo"); TEST_NO_FAULT(&env); bogusKeyStringP = xmlrpc_build_value(&env, "s", "doesn't_exist"); TEST_NO_FAULT(&env); /* "find" interface */ xmlrpc_struct_find_value(&env, structP, "foo", &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_find_value(&env, structP, "doesn't_exist", &valueP); TEST_NO_FAULT(&env); TEST(valueP == NULL); xmlrpc_struct_find_value_v(&env, structP, fooStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_find_value_v(&env, structP, bogusKeyStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == NULL); xmlrpc_struct_find_value(&env, fooValueP, "foo", &valueP); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* "read" interface */ xmlrpc_struct_read_value(&env, structP, "foo", &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_read_value(&env, structP, "doesn't_exist", &valueP); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); xmlrpc_struct_read_value_v(&env, structP, fooStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_read_value_v(&env, structP, bogusKeyStringP, &valueP); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); xmlrpc_struct_read_value(&env, fooValueP, "foo", &valueP); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* obsolete "get" interface. Note that it does not update the reference count of the xmlrpc_value it returns. */ valueP = xmlrpc_struct_get_value(&env, structP, "foo"); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); valueP = xmlrpc_struct_get_value(&env, structP, "doesn't_exist"); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); valueP = xmlrpc_struct_get_value(&env, fooValueP, "foo"); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); valueP = xmlrpc_struct_get_value_n(&env, structP, weirdKey, weirdKeyLen); TEST_NO_FAULT(&env); TEST(valueP == weirdValueP); /* Clean up */ xmlrpc_DECREF(fooStringP); xmlrpc_DECREF(bogusKeyStringP); xmlrpc_env_clean(&env); }
static int unenroll_host(const char *server, const char *hostname, const char *ktname, int quiet) { int rval = 0; int ret; char *ipaserver = NULL; char *host = NULL; struct utsname uinfo; char *principal = NULL; char *realm = NULL; krb5_context krbctx = NULL; krb5_keytab keytab = NULL; krb5_ccache ccache = NULL; krb5_principal princ = NULL; krb5_error_code krberr; krb5_creds creds; krb5_get_init_creds_opt gicopts; char tgs[LINE_MAX]; xmlrpc_env env; xmlrpc_value * argArrayP = NULL; xmlrpc_value * paramArrayP = NULL; xmlrpc_value * paramP = NULL; xmlrpc_value * resultP = NULL; xmlrpc_server_info * serverInfoP = NULL; xmlrpc_value *princP = NULL; char * url = NULL; char * user_agent = NULL; if (server) { ipaserver = strdup(server); } else { char * conf_data = read_config_file(IPA_CONFIG); if ((ipaserver = getIPAserver(conf_data)) == NULL) { if (!quiet) fprintf(stderr, _("Unable to determine IPA server from %s\n"), IPA_CONFIG); exit(1); } free(conf_data); } if (NULL == hostname) { uname(&uinfo); host = strdup(uinfo.nodename); } else { host = strdup(hostname); } if (NULL == strstr(host, ".")) { if (!quiet) fprintf(stderr, _("The hostname must be fully-qualified: %s\n"), host); rval = 16; goto cleanup; } krberr = krb5_init_context(&krbctx); if (krberr) { if (!quiet) fprintf(stderr, _("Unable to join host: " "Kerberos context initialization failed\n")); rval = 1; goto cleanup; } krberr = krb5_kt_resolve(krbctx, ktname, &keytab); if (krberr != 0) { if (!quiet) fprintf(stderr, _("Error resolving keytab: %s.\n"), error_message(krberr)); rval = 7; goto cleanup; } krberr = krb5_get_default_realm(krbctx, &realm); if (krberr != 0) { if (!quiet) fprintf(stderr, _("Error getting default Kerberos realm: %s.\n"), error_message(krberr)); rval = 21; goto cleanup; } ret = asprintf(&principal, "host/%s@%s", host, realm); if (ret == -1) { if (!quiet) fprintf(stderr, _("Out of memory!\n")); rval = 3; goto cleanup; } krberr = krb5_parse_name(krbctx, principal, &princ); if (krberr != 0) { if (!quiet) fprintf(stderr, _("Error parsing \"%1$s\": %2$s.\n"), principal, error_message(krberr)); return krberr; } strcpy(tgs, KRB5_TGS_NAME); snprintf(tgs + strlen(tgs), sizeof(tgs) - strlen(tgs), "/%.*s", (krb5_princ_realm(krbctx, princ))->length, (krb5_princ_realm(krbctx, princ))->data); snprintf(tgs + strlen(tgs), sizeof(tgs) - strlen(tgs), "@%.*s", (krb5_princ_realm(krbctx, princ))->length, (krb5_princ_realm(krbctx, princ))->data); memset(&creds, 0, sizeof(creds)); krb5_get_init_creds_opt_init(&gicopts); krb5_get_init_creds_opt_set_forwardable(&gicopts, 1); krberr = krb5_get_init_creds_keytab(krbctx, &creds, princ, keytab, 0, tgs, &gicopts); if (krberr != 0) { if (!quiet) fprintf(stderr, _("Error obtaining initial credentials: %s.\n"), error_message(krberr)); return krberr; } krberr = krb5_cc_resolve(krbctx, "MEMORY:ipa-join", &ccache); if (krberr == 0) { krberr = krb5_cc_initialize(krbctx, ccache, creds.client); } else { if (!quiet) fprintf(stderr, _("Unable to generate Kerberos Credential Cache\n")); rval = 19; goto cleanup; } krberr = krb5_cc_store_cred(krbctx, ccache, &creds); if (krberr != 0) { if (!quiet) fprintf(stderr, _("Error storing creds in credential cache: %s.\n"), error_message(krberr)); return krberr; } krb5_cc_close(krbctx, ccache); ccache = NULL; putenv("KRB5CCNAME=MEMORY:ipa-join"); /* Start up our XML-RPC client library. */ xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION); xmlrpc_env_init(&env); xmlrpc_client_setup_global_const(&env); #if 1 ret = asprintf(&url, "https://%s:443/ipa/xml", ipaserver); #else ret = asprintf(&url, "http://%s:8888/", ipaserver); #endif if (ret == -1) { if (!quiet) fprintf(stderr, _("Out of memory!\n")); rval = 3; goto cleanup; } serverInfoP = xmlrpc_server_info_new(&env, url); argArrayP = xmlrpc_array_new(&env); paramArrayP = xmlrpc_array_new(&env); paramP = xmlrpc_string_new(&env, host); xmlrpc_array_append_item(&env, argArrayP, paramP); xmlrpc_array_append_item(&env, paramArrayP, argArrayP); xmlrpc_DECREF(paramP); if ((user_agent = set_user_agent(ipaserver)) == NULL) { rval = 3; goto cleanup; } callRPC(user_agent, &env, serverInfoP, "host_disable", paramArrayP, &resultP); if (handle_fault(&env)) { rval = 17; goto cleanup; } xmlrpc_struct_find_value(&env, resultP, "result", &princP); if (princP) { xmlrpc_bool result; xmlrpc_read_bool(&env, princP, &result); if (result == 1) { if (!quiet) fprintf(stderr, _("Unenrollment successful.\n")); } else { if (!quiet) fprintf(stderr, _("Unenrollment failed.\n")); } xmlrpc_DECREF(princP); } else { fprintf(stderr, _("result not found in XML-RPC response\n")); rval = 20; goto cleanup; } cleanup: free(user_agent); if (keytab) krb5_kt_close(krbctx, keytab); free((char *)principal); free((char *)ipaserver); if (princ) krb5_free_principal(krbctx, princ); if (ccache) krb5_cc_close(krbctx, ccache); if (krbctx) krb5_free_context(krbctx); free(url); xmlrpc_env_clean(&env); xmlrpc_client_cleanup(); return rval; }
/* Unpack caller's information on the server, or server's information returned to the client */ struct call_info * callinfo_unpack(xmlrpc_env *envP, xmlrpc_value *s) { struct call_info *cip = callinfo_new(); xmlrpc_value *methargs, *files; int i; unpack(envP, s, "clientIP", (char **)&cip->clientIP); unpack(envP, s, "serverURL", &cip->serverURL); unpack(envP, s, "session", &cip->session); unpack(envP, s, "method", &cip->method); unpack(envP, s, "user", &cip->user); unpack(envP, s, "password", &cip->password); unpack(envP, s, "project", &cip->project); unpack(envP, s, "version", &cip->version); xmlrpc_struct_find_value(envP, s, "method-args", &methargs); if (methargs) { cip->nargs = xmlrpc_array_size(envP, methargs); cip->methodargs = malloc((cip->nargs + 1) * sizeof(char *)); for (i = 0; i < cip->nargs; ++i) { xmlrpc_value *v; char *arg; xmlrpc_array_read_item(envP, methargs, i, &v); xmlrpc_read_string(envP, v, (const char **const)&arg); cip->methodargs[i] = arg; fprintf(stderr, "unpacked methodargs[%d] as %s\n", i, arg); } cip->methodargs[cip->nargs] = NULL; } else { cip->nargs = 0; cip->methodargs = NULL; } xmlrpc_struct_find_value(envP, s, "method-data", &files); if (files) { for (i = 0; i < xmlrpc_array_size(envP, files); ++i) { struct file_data *this_file; xmlrpc_value * fstruct; xmlrpc_array_read_item(envP, files, i, &fstruct); this_file = file_unpack(envP, fstruct); if (cip->files == NULL) { cip->files = this_file; cip->files_last = cip->files->next; } else { cip->files_last->next = this_file; cip->files_last = cip->files->next; } } } return cip; }
void getDataBlock(xmlrpc_env * envP, xmlrpc_value * DataStructP, xmlrpc_value ** OutDataStructPP) { xmlrpc_value * ID_t, * PORT_t, * DATA_t, * IP_t; xmlrpc_struct_find_value(envP, DataStructP, "ID", &ID_t); xmlrpc_struct_find_value(envP, DataStructP, "IP", &IP_t); xmlrpc_struct_find_value(envP, DataStructP, "PORT", &PORT_t); xmlrpc_struct_find_value(envP, DataStructP, "DATA", &DATA_t); xmlrpc_int ID, PORT, DATA; char* IP; xmlrpc_read_int(envP, ID_t, &ID); xmlrpc_read_string(envP, IP_t, &IP); xmlrpc_read_int(envP, PORT_t, &PORT); xmlrpc_read_int(envP, DATA_t, &DATA); xmlrpc_DECREF(ID_t); xmlrpc_DECREF(IP_t); xmlrpc_DECREF(PORT_t); xmlrpc_DECREF(DATA_t); printf("The value of ID is %d\n", ID); printf("The value of ID is %s\n", IP); printf("The value of PORT is %d\n", PORT); printf("The value of DATA is %d\n", DATA); xmlrpc_value * ID_out, * IP_out, * PORT_out, * DATA_out, *DATAP_out; xmlrpc_value * ID1_out, * IP1_out, * PORT1_out, * DATA1_out, *DATAP1_out; xmlrpc_value * ID2_out, * IP2_out, * PORT2_out, * DATA2_out, *DATAP2_out; xmlrpc_value * structArray; structArray = xmlrpc_array_new(envP); ID_out = xmlrpc_int_new(envP, 78654); IP_out = xmlrpc_string_new(envP, "127.0.0.1"); PORT_out = xmlrpc_int_new(envP, 8090); DATA_out = xmlrpc_int_new(envP, 45425); ID1_out = xmlrpc_int_new(envP, 78764); IP1_out = xmlrpc_string_new(envP, "127.0.0.1"); PORT1_out = xmlrpc_int_new(envP, 8091); DATA1_out = xmlrpc_int_new(envP, 452135); ID2_out = xmlrpc_int_new(envP, 78123); IP2_out = xmlrpc_string_new(envP, "127.0.0.1"); PORT2_out = xmlrpc_int_new(envP, 8092); DATA2_out = xmlrpc_int_new(envP, 45563); DATAP_out = xmlrpc_struct_new(envP); DATAP1_out = xmlrpc_struct_new(envP); DATAP2_out = xmlrpc_struct_new(envP); xmlrpc_struct_set_value(envP, DATAP_out, "ID", ID_out); xmlrpc_struct_set_value(envP, DATAP_out, "IP", IP_out); xmlrpc_struct_set_value(envP, DATAP_out, "PORT", PORT_out); xmlrpc_struct_set_value(envP, DATAP_out, "DATA", DATA_out); xmlrpc_struct_set_value(envP, DATAP1_out, "ID", ID1_out); xmlrpc_struct_set_value(envP, DATAP1_out, "IP", IP1_out); xmlrpc_struct_set_value(envP, DATAP1_out, "PORT", PORT1_out); xmlrpc_struct_set_value(envP, DATAP1_out, "DATA", DATA1_out); xmlrpc_struct_set_value(envP, DATAP2_out, "ID", ID2_out); xmlrpc_struct_set_value(envP, DATAP2_out, "IP", IP2_out); xmlrpc_struct_set_value(envP, DATAP2_out, "PORT", PORT2_out); xmlrpc_struct_set_value(envP, DATAP2_out, "DATA", DATA2_out); xmlrpc_array_append_item(envP, structArray, DATAP_out); xmlrpc_array_append_item(envP, structArray, DATAP1_out); xmlrpc_array_append_item(envP, structArray, DATAP2_out); xmlrpc_DECREF(ID_out); xmlrpc_DECREF(IP_out); xmlrpc_DECREF(PORT_out); xmlrpc_DECREF(DATA_out); xmlrpc_DECREF(ID1_out); xmlrpc_DECREF(IP1_out); xmlrpc_DECREF(PORT1_out); xmlrpc_DECREF(DATA1_out); xmlrpc_DECREF(ID2_out); xmlrpc_DECREF(IP2_out); xmlrpc_DECREF(PORT2_out); xmlrpc_DECREF(DATA2_out); *OutDataStructPP = structArray; }
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; }