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