int
wpCreatePostStruct(xmlrpc_env *env, char *username, char*password, wppost_t *post, xmlrpc_value **paramArray, int mode) {
int retval = 0;
xmlrpc_value *blogidP, *postidP, *usernameP, *passwordP, *titleP, *descriptionP, *dateP, *publishP, *categoryP, *contentP, *tokenP;
char *token;
char *categories = NULL, *catPtr;
if ( mode == 0 ) {
post->blogid = wpGetBlogId(username, password, post->url);
if (post->blogid == NULL) {
fprintf(stderr, "NULL Blog Id\n");
retval = 1;
goto out;
}
blogidP = xmlrpc_string_new(env, post->blogid);
postidP = NULL;
} else {
blogidP = NULL;
postidP = xmlrpc_string_new(env, post->postid);
}
usernameP = xmlrpc_string_new(env, username);
passwordP = xmlrpc_string_new(env, password);
titleP = xmlrpc_string_new(env, post->subject);
descriptionP = xmlrpc_string_new(env, post->body);
if(!strcmp(post->status, "draft")) {
publishP = xmlrpc_bool_new(env, FALSE);
} else {
publishP = xmlrpc_bool_new(env, TRUE);
}
dateP = xmlrpc_datetime_new_sec(env, time(NULL));
asprintf(&categories, "%s", post->categories);
catPtr = categories;
categoryP = xmlrpc_array_new(env);
token = strtok(categories, ",");
tokenP = xmlrpc_string_new(env, token);
xmlrpc_array_append_item(env, categoryP, tokenP);
while( (token = strtok( (char *) NULL, ",") ) != NULL ) {
tokenP = xmlrpc_string_new(env, token);
xmlrpc_array_append_item(env, categoryP, tokenP);
}
free(catPtr);
contentP = xmlrpc_struct_new(env);
xmlrpc_struct_set_value(env, contentP, "title", titleP);
xmlrpc_struct_set_value(env, contentP, "description", descriptionP);
xmlrpc_struct_set_value(env, contentP, "dateCreated", dateP);
xmlrpc_struct_set_value(env, contentP, "categories", categoryP);
/* Populate the Parameter Array */
*paramArray = xmlrpc_array_new(env);
if (mode == 0)
xmlrpc_array_append_item(env, *paramArray, blogidP);
else
xmlrpc_array_append_item(env, *paramArray, postidP);
xmlrpc_array_append_item(env, *paramArray, usernameP);
xmlrpc_array_append_item(env, *paramArray, passwordP);
xmlrpc_array_append_item(env, *paramArray, contentP);
xmlrpc_array_append_item(env, *paramArray, publishP);
out:
return retval;
}
/* Pack the information from any client method into a generic xmlrpc
struct to send to the server */
xmlrpc_value *
callinfo_pack(xmlrpc_env *envP, struct call_info *cip)
{
xmlrpc_value *s = xmlrpc_struct_new(envP);
xmlrpc_value *methargs = xmlrpc_array_new(envP);
xmlrpc_value *files = xmlrpc_array_new(envP);
int i;
xmlrpc_struct_set_value(envP, s, "clientIP", xmlrpc_string_new(envP, nonull(cip->clientIP)));
xmlrpc_struct_set_value(envP, s, "serverURL", xmlrpc_string_new(envP, nonull(cip->serverURL)));
xmlrpc_struct_set_value(envP, s, "session", xmlrpc_string_new(envP, nonull(cip->session)));
xmlrpc_struct_set_value(envP, s, "method", xmlrpc_string_new(envP, nonull(cip->method)));
xmlrpc_struct_set_value(envP, s, "user", xmlrpc_string_new(envP, nonull(cip->user)));
xmlrpc_struct_set_value(envP, s, "password", xmlrpc_string_new(envP, nonull(cip->password)));
xmlrpc_struct_set_value(envP, s, "project", xmlrpc_string_new(envP, nonull(cip->project)));
xmlrpc_struct_set_value(envP, s, "version", xmlrpc_string_new(envP, nonull(cip->version)));
if (cip->methodargs)
{
for (i = 0; cip->methodargs[i]; ++i)
{
if (!strncmp(cip->methodargs[i], "file:", 5))
{
char *file_what, *file_name;
file_what = strdup(&cip->methodargs[i][5]);
file_name = strchr(file_what, '=');
if (file_name)
{
xmlrpc_value * fstruct;
*file_name++ = '\0';
fstruct = file_pack(envP, file_what, file_name);
xmlrpc_array_append_item(envP, files, fstruct);
}
else
{
fprintf(stderr, "oracc-client: bad -Mfile arg, expected -Mfile:WHAT=NAME\n");
exit(1);
}
}
else
xmlrpc_array_append_item(envP, methargs, xmlrpc_string_new(envP, cip->methodargs[i]));
}
}
xmlrpc_struct_set_value(envP, s, "method-args", methargs);
xmlrpc_struct_set_value(envP, s, "method-data", files);
return s;
}
void
xr_setStringInResult (void *data, char *val)
{
CallerP c = (Caller *) data;
if (c->result)
xmlrpc_DECREF (c->result);
if (!xr_errstat)
c->result = xmlrpc_string_new (c->env, (const char *)val);
}
void
xmlrpc_set_struct_string( xmlrpc_env * const envP,
xmlrpc_value *pstruct,
const char *key,
const char *val )
{
xmlrpc_value *str_val = xmlrpc_string_new( envP, val );
assertValue( str_val );
xmlrpc_struct_set_value( envP, pstruct, key, str_val );
xmlrpc_DECREF( str_val );
}
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);
}
static void
createMethodListArray(xmlrpc_env * const envP,
xmlrpc_registry * const registryP,
xmlrpc_value ** const methodListPP) {
/*----------------------------------------------------------------------------
Create as an XML-RPC array value a list of names of methods registered
in registry 'registryP'.
This is the type of value that the system.listMethods method is supposed
to return.
-----------------------------------------------------------------------------*/
xmlrpc_value * methodListP;
methodListP = xmlrpc_array_new(envP);
if (!envP->fault_occurred) {
xmlrpc_methodNode * methodNodeP;
for (methodNodeP = registryP->methodListP->firstMethodP;
methodNodeP && !envP->fault_occurred;
methodNodeP = methodNodeP->nextP) {
xmlrpc_value * methodNameVP;
methodNameVP = xmlrpc_string_new(envP, methodNodeP->methodName);
if (!envP->fault_occurred) {
xmlrpc_array_append_item(envP, methodListP, methodNameVP);
xmlrpc_DECREF(methodNameVP);
}
}
if (envP->fault_occurred)
xmlrpc_DECREF(methodListP);
}
*methodListPP = methodListP;
}
static xmlrpc_value *
xr_defaultMethod (xmlrpc_env *envP, char *host, char *methodName,
xmlrpc_value *paramArrayP, void *serverInfo)
{
int status;
ServerP svr = (Server *) serverInfo;
MethodP m = (Method *) NULL;
extern int xr_errstat;
if (DEBUG)
fprintf (stderr, "DEFAULT: method='%s' data= 0x%lx\n",
methodName, (unsigned long) serverInfo);
/* Now look for the method in the interface registry.
*/
for (m=svr->method_head; m; m = m->next) {
if (strcmp (m->name, methodName) == 0) {
Caller *c = (Caller *) NULL;
xmlrpc_value *result = (xmlrpc_value *) NULL;
(void) pthread_mutex_lock (&svr_mutex);
c = &cs[(cindex = (cindex + 1) % SZ_CALL_RING)];
(void) pthread_mutex_unlock (&svr_mutex);
#ifdef FREE_RES
/* Free old result values.
*/
if (res_anum >= 0) {
xr_freeArray (res_anum);
res_anum = -1;
}
if (res_snum >= 0) {
xr_freeStruct (res_snum);
res_snum = -1;
}
#endif
memset (c, 0, sizeof(Caller));
c->env = envP; /* setup the calling parameters */
c->host = host;
c->name = methodName;
c->param = paramArrayP;
c->info = serverInfo;
/* Call the function.
*/
xr_setStat (2);
if ( (status = (*(PFI)(*m->methodFunc))((void *)c)) ) {
fprintf (stderr, "Matched failed '%s'...\n", m->name);
xr_errstat = ERR;
} else {
xr_errstat = OK;
xmlrpc_DECREF(paramArrayP);
result = (c->result ? c->result : (xmlrpc_value *) NULL);
}
xmlrpc_INCREF(result);
return ( result ); /* return our result */
}
}
if (!m) {
char msg[256];
memset (msg, 0, 256);
sprintf (msg, "No such method '%s'", methodName);
xmlrpc_value *result = xmlrpc_string_new (envP, msg);
return ( result );
} else
return ((xmlrpc_value *) NULL); /* should never happen */
}
static void
test_value_string_wide(void) {
#if HAVE_UNICODE_WCHAR
xmlrpc_env env;
xmlrpc_value * valueP;
const wchar_t * wcs;
size_t len;
xmlrpc_env_init(&env);
/* Build a string from wchar_t data. */
valueP = xmlrpc_string_w_new_lp(&env, 3, wcs_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_read_string_w(&env, valueP, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(wcs[3] == '\0');
TEST(wcsneq(wcs, wcs_data, 3));
free((void*)wcs);
xmlrpc_decompose_value(&env, valueP, "w#", &wcs, &len);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
{
/* Extract it as a UTF-8 string. */
const char * str;
size_t len;
xmlrpc_read_string_lp(&env, valueP, &len, &str);
TEST_NO_FAULT(&env);
TEST(str != NULL);
TEST(len == 4);
TEST(str[len] == '\0');
TEST(xmlrpc_strneq(str, utf8_data, len));
free((void*)str);
}
xmlrpc_DECREF(valueP);
/* Build from null-terminated wchar_t string */
valueP = xmlrpc_string_w_new(&env, wcs_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Verify it */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_DECREF(valueP);
test_value_string_wide_build();
/* Build a string from UTF-8 data. */
valueP = xmlrpc_string_new(&env, utf8_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 3);
TEST(wcs[len] == 0x0000);
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_DECREF(valueP);
/* Test with embedded NUL. We use a length of 4 so that the terminating
NUL actually becomes part of the string.
*/
valueP = xmlrpc_string_w_new_lp(&env, 4, wcs_data);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Extract it as a wchar_t string. */
xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs);
TEST_NO_FAULT(&env);
TEST(wcs != NULL);
TEST(len == 4);
TEST(wcs[len] == '\0');
TEST(wcsneq(wcs, wcs_data, len));
free((void*)wcs);
xmlrpc_read_string_w(&env, valueP, &wcs);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_DECREF(valueP);
test_value_string_wide_line();
xmlrpc_env_clean(&env);
#endif /* HAVE_UNICODE_WCHAR */
}
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);
}
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 get_torrent_list(torrent_array **result) {
size_t size;
xmlrpc_value *xml_array, *params;
params = xmlrpc_array_new(&env);
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "main"));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.hash="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.name="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.is_active="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.state="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.bytes_done="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.size_bytes="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.up.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.total="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.ratio="));
check_fault();
execute_proxy_method(&xml_array, "d.multicall", params);
check_fault(&env);
assert(xmlrpc_value_type(xml_array) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(xml_array);
size = xmlrpc_array_size(&env, xml_array);
check_fault(&env);
if (size <= 0)
goto finish;
*result = torrent_array_new(size);
for (size_t i = 0; i < size; ++i) {
size_t tarray_size;
xmlrpc_value *tarray = NULL;
xmlrpc_array_read_item(&env, xml_array, i, &tarray);
check_fault(&env);
assert(xmlrpc_value_type(tarray) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(tarray);
tarray_size = xmlrpc_array_size(&env, tarray);
for (size_t j = 0; j < tarray_size; ++j) {
xmlrpc_value *item = NULL;
xmlrpc_array_read_item(&env, tarray, j, &item);
check_fault(&env);
switch (j) {
case 0:
get_string(item, &(*result)->torrents[i]->hash);
break;
case 1:
get_string(item, &(*result)->torrents[i]->name);
break;
case 2:
get_bool_from_int64(item, &(*result)->torrents[i]->active);
break;
case 3:
get_bool_from_int64(item, &(*result)->torrents[i]->started);
break;
case 4:
get_int64(item, &(*result)->torrents[i]->done_bytes);
break;
case 5:
get_int64(item, &(*result)->torrents[i]->size_bytes);
break;
case 6:
get_int64(item, &(*result)->torrents[i]->up_rate);
break;
case 7:
get_int64(item, &(*result)->torrents[i]->down_rate);
break;
case 8:
get_int64(item, &(*result)->torrents[i]->down_total);
break;
case 9:
get_int64(item, &(*result)->torrents[i]->ratio);
break;
default:
;
}
xmlrpc_DECREF(item);
}
xmlrpc_DECREF(tarray);
}
finish:
xmlrpc_DECREF(xml_array);
}
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;
}
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_serialize_string(void) {
/* Test serialize of a string, including all the line ending
complexity.
*/
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block * xmlP; /* Serialized result */
xmlrpc_env_init(&env);
TEST_NO_FAULT(&env);
v = xmlrpc_string_new(&env, "hello world");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>hello world</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string></string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\0bar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\0bar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\nbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 8, "foo\r\nbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\rbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp_cr(&env, 7, "foo\rbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo
bar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
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;
}
/*
* Write accounting information to this modules database.
*/
static int xmlrpc_accounting(void *instance, REQUEST * request)
{
rlm_xmlrpc_t *inst = instance;
rlm_xmlrpc_client_t *client;
VALUE_PAIR *vps = request->packet->vps;
xmlrpc_value *array_param;
xmlrpc_value *array_string;
xmlrpc_value *resultP;
char *const methodName = inst->method;
int error;
VALUE_PAIR *status_type_pair;
if ((status_type_pair = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE)) == NULL) {
radlog(L_ERR, "rlm_xmlrpc: No Accounting-Status-Type record.");
return RLM_MODULE_NOOP;
}
client = get_client(instance);
/*
* Xmlrpc wants method params in an array, so we build an array
* with a pointer in index 0. This pointer contains a sub array
* filled whith strings each one for packet attributes.
*/
array_param = xmlrpc_array_new(&client->env);
error = check_error(&client->env);
if (error != RLM_MODULE_OK)
return error;
array_string = xmlrpc_array_new(&client->env);
error = check_error(&client->env);
if (error != RLM_MODULE_OK)
return error;
/*
* The array of strings is built whit vp_prints
*/
VALUE_PAIR *vp = vps;
for (; vp; vp = vp->next) {
char buf[1024];
vp_prints(buf, sizeof(buf), vp);
xmlrpc_array_append_item(&client->env, array_string,
xmlrpc_string_new(&client->env, buf));
int error = check_error(&client->env);
if (error != RLM_MODULE_OK)
return error;
}
xmlrpc_array_append_item(&client->env, array_param, array_string);
error = check_error(&client->env);
if (error != RLM_MODULE_OK)
return error;
xmlrpc_client_call2(&client->env, client->clientP, client->serverInfoP,
methodName, array_param, &resultP);
error = check_error(&client->env);
if (error != RLM_MODULE_OK)
return error;
/*
* We don't check for method return value. If an accounting packet is
* dispatched without errors, it should be processed by server
* without any further notification.
*/
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(array_param);
xmlrpc_DECREF(array_string);
return RLM_MODULE_OK;
}
xmlrpc_value *xmlrpccmd_core_get_version(xmlrpc_env * const envP, xmlrpc_value * const paramArrayP, void * const userData) {
return xmlrpc_string_new(envP, VERSION);
}
int bugzilla_submit_bug(BugzillaData *data,
const char *product,
const char *component,
const char *summary,
const char *version,
const char *description,
const char *op_sys,
const char *platform,
const char *priority,
const char *severity,
const char *cc)
{
E_ASSERT(data != NULL);
int bug_id = -1;
xmlrpc_value *result;
/* if given CC, add it so bugzilla assign that email as notification receiver */
if(cc) {
/* as for now we only support single email address */
xmlrpc_value *cc_array, *cc_str;
cc_array = xmlrpc_array_new(&data->xenv);
cc_str = xmlrpc_string_new(&data->xenv, (const char *const)cc);
xmlrpc_array_append_item(&data->xenv, cc_array, cc_str);
xmlrpc_DECREF(cc_str);
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bug.create", &result,
"({s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:A})",
"product", product,
"component", component,
"summary", summary,
"version", version,
"description", description,
"op_sys", op_sys,
"platform", platform,
"priority", priority,
"severity", severity,
"cc", cc_array);
xmlrpc_DECREF(cc_array);
} else {
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bug.create", &result,
"({s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s,s:s})",
"product", product,
"component", component,
"summary", summary,
"version", version,
"description", description,
"op_sys", op_sys,
"platform", platform,
"priority", priority,
"severity", severity);
}
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to perform submit function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return bug_id;
}
xmlrpc_decompose_value(&data->xenv, result, "{s:i,*}", "id", &bug_id);
xmlrpc_DECREF(result);
return bug_id;
}
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;
}
