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
wpNewPost(char *username, char *password, wppost_t *post) {
int retval = 0;
char *postid = NULL;
xmlrpc_env env;
xmlrpc_client *clientP;
xmlrpc_server_info * serverInfoP;
xmlrpc_value *paramArrayP = NULL;
char *methodName = "metaWeblog.newPost";
xmlrpc_value *resultP;
wp_env_init(&env, &clientP);
retval = wpCreatePostStruct(&env, username, password, post, ¶mArrayP, 0);
if (retval != 0) {
fprintf(stderr, "Error creating post structure, exiting\n");
goto out;
}
serverInfoP = xmlrpc_server_info_new(&env, post->url);
xmlrpc_client_call2(&env, clientP, serverInfoP, methodName, paramArrayP, &resultP);
xmlrpc_read_string(&env, resultP,(const char **) &postid);
post->postid = postid;
xmlrpc_DECREF(resultP);
out:
xmlrpc_DECREF(paramArrayP);
wp_env_clean(&env, &clientP);
return retval;
}
char *
xr_getStringFromParam (void *data, int index)
{
CallerP c = (Caller *) data;
xmlrpc_value *val = xr_getArrValue (c->param, index);
const char *s = (char *) NULL;
size_t len;
#ifdef OLD_SFP
xmlrpc_read_string_lp (c->env, val, &len, &s);
/* xmlrpc_read_string (c->env, val, &s); */
xmlrpc_DECREF (val);
return (((xr_errstat=c->env->fault_occurred) ? (char *)NULL : (char *)s));
#else
int lock;
char *str = (char *) NULL;
lock = pthread_mutex_lock (&method_mutex);
xmlrpc_read_string (c->env, val, (const char **)&s);
if (s) {
len = strlen (s);
str = calloc (1, (len + 1));
strcpy (str, s);
free ((void *) s);
}
xmlrpc_DECREF (val);
lock = pthread_mutex_unlock (&method_mutex);
return ((char *) str);
#endif
}
static void
test_value_string_cr(void) {
xmlrpc_env env;
xmlrpc_value * v;
const char * str;
size_t len;
xmlrpc_env_init(&env);
v = xmlrpc_string_new_cr(&env, "foo\r\nbar\r\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar\r\nbaz"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new_lp_cr(&env, 7, "\0foo\rbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string_lp(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 7);
TEST(memeq(str, "\0foo\rbar", len));
xmlrpc_DECREF(v);
strfree(str);
xmlrpc_env_clean(&env);
}
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;
}
static void
readString(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
const char ** const stringValueP,
bool const oldstyleMemMgmt) {
if (oldstyleMemMgmt) {
xmlrpc_read_string_old(envP, valueP, stringValueP);
} else
xmlrpc_read_string(envP, valueP, stringValueP);
}
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;
}
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;
}
/* FIXME terminates the programm if it fails */
int get_struct_item_by_idx(xmlrpc_value *structP, int index, key_value_pair *rv)
{
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *keyP;
xmlrpc_value *valueP;
int length;
const char *string;
xmlrpc_struct_read_member(&env, structP, index, &keyP, &valueP); /* increment refcount of returned values */
die_if_fault_occurred_line(&env, __LINE__);
xmlrpc_read_string(&env, keyP, (const char **)&rv->key);
/* handle value type */
switch ( xmlrpc_value_type(valueP) ) {
case XMLRPC_TYPE_INT:
xmlrpc_read_int(&env, valueP, &rv->value.integer);
die_if_fault_occurred_line(&env, __LINE__);
rv->type = TYPE_INTEGER;
break;
case XMLRPC_TYPE_STRING:
xmlrpc_read_string(&env, valueP, &string);
printf("get_struct_item_by_idx: ptr = %p, string value = '%s'\n", string, string);
die_if_fault_occurred_line(&env, __LINE__);
rv->value.string = (char *)string;
rv->type = TYPE_STRING;
break;
default:
fprintf(stderr, "Wrong type of return value in key: '%s', exiting...\n", rv->key);
exit(1);
}
xmlrpc_DECREF(keyP); /* decrement refcount */
xmlrpc_DECREF(valueP);
die_if_fault_occurred_line(&env, __LINE__);
/* FIXME add error handling */
return 1;
}
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);
}
static void
interpretFaultString(xmlrpc_env * const envP,
xmlrpc_value * const faultStringVP,
const char ** const faultStringP) {
xmlrpc_env fsEnv;
xmlrpc_env_init(&fsEnv);
xmlrpc_read_string(&fsEnv, faultStringVP, faultStringP);
if (fsEnv.fault_occurred)
xmlrpc_faultf(envP, "Invalid value for 'faultString' member. %s",
fsEnv.fault_string);
xmlrpc_env_clean(&fsEnv);
}
// TODO: npajkovs: add flag to read xmlrpc_read_array_item first
void *rhbz_bug_read_item(const char *memb, xmlrpc_value *xml, int flags)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *member = rhbz_get_member(memb, xml);
const char *string = NULL;
if (!member)
goto die;
if (IS_READ_STR(flags))
{
xmlrpc_read_string(&env, member, &string);
xmlrpc_DECREF(member);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (!*string)
goto die;
VERB3 log("found %s: '%s'", memb, string);
return (void*)string;
}
if (IS_READ_INT(flags))
{
int *integer = xmalloc(sizeof(int));
xmlrpc_read_int(&env, member, integer);
xmlrpc_DECREF(member);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
VERB3 log("found %s: '%i'", memb, *integer);
return (void*)integer;
}
die:
free((void*)string);
if (IS_MANDATORY(flags))
error_msg_and_die(_("Looks like corrupted xml response, because '%s'"
" member is missing."), memb);
return NULL;
}
GList *rhbz_bug_cc(xmlrpc_value* result_xml)
{
func_entry();
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value* cc_member = rhbz_get_member("cc", result_xml);
if (!cc_member)
return NULL;
unsigned array_size = rhbz_array_size(cc_member);
VERB3 log("count members on cc %i", array_size);
GList *cc_list = NULL;
for (unsigned i = 0; i < array_size; ++i)
{
xmlrpc_value* item = NULL;
xmlrpc_array_read_item(&env, cc_member, i, &item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (!item)
continue;
const char* cc = NULL;
xmlrpc_read_string(&env, item, &cc);
xmlrpc_DECREF(item);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
if (*cc != '\0')
{
cc_list = g_list_append(cc_list, (char*)cc);
VERB3 log("member on cc is %s", cc);
continue;
}
free((char*)cc);
}
xmlrpc_DECREF(cc_member);
return cc_list;
}
int c_oneAllocateTemplate(char* vm_template)
{
xmlrpc_value *resultP;
xmlrpc_value *valueP;
int return_code;
char *return_string;
int vmid;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmallocate", "(ss)", one_client.session, vm_template);
xmlrpc_array_read_item(&one_client.env, resultP, 0, &valueP);
xmlrpc_read_bool(&one_client.env, valueP, &return_code);
if( return_code )
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_int(&one_client.env, valueP, &vmid);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
return vmid;
}
else
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_string(&one_client.env, valueP,
(const char **)&return_string);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
VIR_FREE(one_client.error);
one_client.error=return_string;
return -1;
}
}
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;
}
static void
test_value_string_no_null(void) {
xmlrpc_value * v;
xmlrpc_env env;
const char * str;
size_t len;
/* Test strings (without '\0' bytes). */
xmlrpc_env_init(&env);
v = xmlrpc_string_new(&env, test_string_1);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(strcmp(str, test_string_1) == 0);
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s", test_string_1);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "s", &str);
TEST_NO_FAULT(&env);
TEST(strcmp(str, test_string_1) == 0);
strfree(str);
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(memcmp(str, test_string_1, strlen(test_string_1)) == 0);
TEST(strlen(str) == strlen(test_string_1));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
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);
}
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 */
}
static void get_string(xmlrpc_value *value, const char **string) {
assert(xmlrpc_value_type(value) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, value, string);
check_fault();
}
struct mi_root * xr_parse_tree( xmlrpc_env * env, xmlrpc_value * paramArray ) {
struct mi_root * mi_root;
int size, i;
size_t length;
xmlrpc_int32 intValue;
xmlrpc_bool boolValue;
#ifdef XMLRPC_OLD_VERSION
double doubleValue;
char * contents;
#else
xmlrpc_double doubleValue;
#endif
char * stringValue = 0;
char * byteStringValue =0;
xmlrpc_value * item;
mi_root = init_mi_tree(0, 0, 0);
if ( !mi_root ) {
LM_ERR("the MI tree cannot be initialized!\n");
goto error;
}
size = xmlrpc_array_size(env, paramArray);
for (i=0 ; i< size ; i++) {
item = xmlrpc_array_get_item(env, paramArray, i);
if ( env->fault_occurred ) {
LM_ERR("failed to get array item: %s\n", env->fault_string);
goto error;
}
switch ( xmlrpc_value_type(item) ) {
case (XMLRPC_TYPE_INT):
#ifdef XMLRPC_OLD_VERSION
intValue = item->_value.i;
#else
xmlrpc_read_int(env,item,&intValue);
#endif
if (addf_mi_node_child(&mi_root->node,0,0,0,"%d",intValue)==NULL) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_BOOL):
#ifdef XMLRPC_OLD_VERSION
boolValue = item->_value.b;
#else
xmlrpc_read_bool(env,item,&boolValue);
#endif
if (addf_mi_node_child(&mi_root->node,0,0,0,"%u",boolValue)==NULL){
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_DOUBLE):
#ifdef XMLRPC_OLD_VERSION
doubleValue = item->_value.d;
#else
xmlrpc_read_double(env,item,&doubleValue);
#endif
if ( addf_mi_node_child(&mi_root->node, 0, 0, 0, "%lf",
doubleValue) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_STRING):
#if HAVE_UNICODE_WCHAR
#ifdef XMLRPC_OLD_VERSION
xmlrpc_read_string_w(env, item, &stringValue);
#else
xmlrpc_read_string_w(env, item , (const char **)&stringValue);
#endif
#else
#ifdef XMLRPC_OLD_VERSION
xmlrpc_read_string(env, item, &stringValue);
#else
xmlrpc_read_string(env, item, (const char **)&stringValue);
#endif
#endif
if ( env->fault_occurred ) {
LM_ERR("failed to read stringValue: %s!\n", env->fault_string);
goto error;
}
if ( add_mi_node_child(&mi_root->node, 0, 0, 0,
stringValue,
lflf_to_crlf_hack(stringValue)) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
break;
case (XMLRPC_TYPE_BASE64):
#ifdef XMLRPC_OLD_VERSION
length = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, &item->_block);
contents = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, &item->_block);
byteStringValue = pkg_malloc(length);
if ( !byteStringValue ){
xmlrpc_env_set_fault_formatted(env, XMLRPC_INTERNAL_ERROR,
"Unable to allocate %u bytes for byte string.", length);
LM_ERR("pkg_malloc cannot allocate any more memory!\n");
goto error;
} else
memcpy(byteStringValue, contents, length);
if ( add_mi_node_child(&mi_root->node, 0, 0, 0, byteStringValue,
length) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
#else
xmlrpc_read_base64(env, item, &length,
(const unsigned char **)(void*)&byteStringValue);
if ( env->fault_occurred ) {
LM_ERR("failed to read byteStringValue: %s!\n",
env->fault_string);
goto error;
}
if ( add_mi_node_child(&mi_root->node, MI_DUP_VALUE, 0, 0,
byteStringValue, length) == NULL ) {
LM_ERR("failed to add node to the MI tree.\n");
goto error;
}
free(byteStringValue);
#endif
break;
default :
LM_ERR("unsupported node type %d\n", xmlrpc_value_type(item) );
xmlrpc_env_set_fault_formatted( env, XMLRPC_TYPE_ERROR,
"Unsupported value of type %d supplied",
xmlrpc_value_type(item));
goto error;
}
}
return mi_root;
error:
if ( mi_root ) free_mi_tree(mi_root);
if ( byteStringValue ) pkg_free(byteStringValue);
return 0;
}
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;
}
static void
test_value_string_multiline(void) {
xmlrpc_env env;
xmlrpc_value * v;
const char * str;
size_t len;
xmlrpc_env_init(&env);
/* LF line ending */
v = xmlrpc_string_new(&env, "foo\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\n\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\n\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar\r\n"));
strfree(str);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "foo\nbar\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
strfree(str);
xmlrpc_read_string_crlf(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\r\nbar\r\nbaz"));
strfree(str);
xmlrpc_DECREF(v);
/* CR line ending */
v = xmlrpc_string_new(&env, "foo\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar\r");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\rbar\rbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
xmlrpc_DECREF(v);
strfree(str);
/* CRLF line ending */
v = xmlrpc_string_new(&env, "foo\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\n\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\n\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar\r\n");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\n"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_string_new(&env, "foo\r\nbar\r\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo\nbar\nbaz"));
xmlrpc_DECREF(v);
strfree(str);
/* Embedded null */
v = xmlrpc_string_new_lp(&env, 14, "foo\r\n\0bar\r\nbaz");
TEST_NO_FAULT(&env);
xmlrpc_read_string_lp(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 12);
TEST(memeq(str, "foo\n\0bar\nbaz", len));
strfree(str);
xmlrpc_read_string_lp_crlf(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 14);
TEST(memeq(str, "foo\r\n\0bar\r\nbaz", len));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_value_string_no_null(void) {
/* Test strings (without '\0' bytes). */
xmlrpc_value * v;
xmlrpc_env env;
const char * str;
size_t len;
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_STRING), "STRING"));
{
const char * const simpleAsciiString = "foo";
v = xmlrpc_string_new(&env, simpleAsciiString);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, simpleAsciiString));
xmlrpc_DECREF(v);
strfree(str);
}
{
const char * const utf8String = "KOŚĆ";
v = xmlrpc_string_new(&env, utf8String);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, utf8String));
xmlrpc_DECREF(v);
strfree(str);
}
v = xmlrpc_string_new_f(&env, "String %s, number %d", "xyz", 7);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "String xyz, number 7"));
xmlrpc_DECREF(v);
strfree(str);
v = test_string_new_va(&env, "String %s, number %d", "xyz", 7);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "String xyz, number 7"));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s", "foo");
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "s", &str);
TEST_NO_FAULT(&env);
TEST(streq(str, "foo"));
strfree(str);
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(len == strlen("foo"));
TEST(xmlrpc_streq(str, "foo"));
TEST(strlen(str) == strlen("foo"));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
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;
}
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;
}
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;
}
/* 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;
}
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;
}
