static void test_value_bool(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_bool b; /* Test booleans. */ xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BOOL), "BOOL")); v = xmlrpc_bool_new(&env, (xmlrpc_bool) 1); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v)); xmlrpc_read_bool(&env, v, &b); TEST_NO_FAULT(&env); TEST(b); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "b", (xmlrpc_bool) 0); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "b", &b); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(!b); xmlrpc_env_clean(&env); }
value_boolean::operator bool() const { xmlrpc_bool retval; env_wrap env; xmlrpc_read_bool(&env.env_c, this->cValueP, &retval); throwIfError(env); return (retval != false); }
int xr_getBoolFromParam (void *data, int index) { CallerP c = (Caller *) data; xmlrpc_value *val = xr_getArrValue (c->param, index); xmlrpc_bool bval; xmlrpc_read_bool (c->env, val, &bval); xmlrpc_DECREF (val); return ( ((xr_errstat=c->env->fault_occurred) ? (int)NULL : bval) ); }
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; } }
static void decomposeValueWithTree(xmlrpc_env * const envP, xmlrpc_value * const valueP, bool const oldstyleMemMgmt, const struct decompTreeNode * const decompRootP) { /*---------------------------------------------------------------------------- Decompose XML-RPC value *valueP, given the decomposition tree *decompRootP. The decomposition tree tells what structure *valueP is expected to have and where to put the various components of it (e.g. it says "it's an array of 3 integers. Put their values at locations x, y, and z") -----------------------------------------------------------------------------*/ switch (decompRootP->formatSpecChar) { case '-': /* There's nothing to validate or return */ break; case 'i': xmlrpc_read_int(envP, valueP, decompRootP->store.Tinteger.valueP); break; case 'b': xmlrpc_read_bool(envP, valueP, decompRootP->store.Tbool.valueP); break; case 'd': xmlrpc_read_double(envP, valueP, decompRootP->store.Tdouble.valueP); break; case 't': xmlrpc_read_datetime_sec(envP, valueP, decompRootP->store.TdatetimeT.valueP); break; case '8': readDatetime8Str(envP, valueP, decompRootP->store.Tdatetime8.valueP, oldstyleMemMgmt); break; case 's': if (decompRootP->store.Tstring.sizeP) readStringLp(envP, valueP, decompRootP->store.Tstring.sizeP, decompRootP->store.Tstring.valueP, oldstyleMemMgmt); else readString(envP, valueP, decompRootP->store.Tstring.valueP, oldstyleMemMgmt); break; case 'w': #if HAVE_UNICODE_WCHAR if (decompRootP->store.Tstring.sizeP) readStringWLp(envP, valueP, decompRootP->store.TwideString.sizeP, decompRootP->store.TwideString.valueP, oldstyleMemMgmt); else readStringW(envP, valueP, decompRootP->store.TwideString.valueP, oldstyleMemMgmt); #else XMLRPC_ASSERT(false); #endif /* HAVE_UNICODE_WCHAR */ break; case '6': readBase64(envP, valueP, decompRootP->store.TbitString.sizeP, decompRootP->store.TbitString.valueP, oldstyleMemMgmt); break; case 'n': xmlrpc_read_nil(envP, valueP); break; case 'I': xmlrpc_read_i8(envP, valueP, decompRootP->store.Ti8.valueP); break; case 'p': xmlrpc_read_cptr(envP, valueP, decompRootP->store.Tcptr.valueP); break; case 'V': *decompRootP->store.Tvalue.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); break; case 'A': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the 'A' specifier requires type ARRAY", xmlrpc_type_name(xmlrpc_value_type(valueP))); else { *decompRootP->store.TarrayVal.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); } break; case 'S': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the 'S' specifier requires type STRUCT.", xmlrpc_type_name(xmlrpc_value_type(valueP))); else { *decompRootP->store.TstructVal.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); } break; case '(': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the '(...)' specifier requires type ARRAY", xmlrpc_type_name(xmlrpc_value_type(valueP))); else parsearray(envP, valueP, decompRootP->store.Tarray, oldstyleMemMgmt); break; case '{': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the '{...}' specifier requires type STRUCT", xmlrpc_type_name(xmlrpc_value_type(valueP))); else parsestruct(envP, valueP, decompRootP->store.Tstruct, oldstyleMemMgmt); break; default: /* Every format character that is allowed in a decomposition tree node is handled above. */ XMLRPC_ASSERT(false); } }
static void test_struct (void) { xmlrpc_env env; xmlrpc_value * value1P; xmlrpc_value *s, *i, *i1, *i2, *i3, *key, *value; size_t size; int present; xmlrpc_bool bval; char const weirdKey[] = {'f', 'o', 'o', '\0', 'b', 'a', 'r'}; xmlrpc_env_init(&env); /* Create a struct. */ s = xmlrpc_struct_new(&env); TEST_NO_FAULT(&env); TEST(s != NULL); TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(s)); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 0); /* Create some elements to insert into our struct. */ i1 = xmlrpc_build_value(&env, "s", "Item #1"); TEST_NO_FAULT(&env); i2 = xmlrpc_build_value(&env, "s", "Item #2"); TEST_NO_FAULT(&env); i3 = xmlrpc_build_value(&env, "s", "Item #3"); TEST_NO_FAULT(&env); /* Insert a single item. */ xmlrpc_struct_set_value(&env, s, "foo", i1); TEST_NO_FAULT(&env); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 1); /* Insert an item whose key has the same hash value as "foo". */ xmlrpc_struct_set_value(&env, s, "qmdebdw", i2); TEST_NO_FAULT(&env); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 2); i = xmlrpc_struct_get_value(&env, s, "foo"); TEST_NO_FAULT(&env); TEST(i == i1); i = xmlrpc_struct_get_value(&env, s, "qmdebdw"); TEST_NO_FAULT(&env); TEST(i == i2); /* Replace an existing element with a different element. */ xmlrpc_struct_set_value(&env, s, "foo", i3); TEST_NO_FAULT(&env); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 2); i = xmlrpc_struct_get_value(&env, s, "foo"); TEST_NO_FAULT(&env); TEST(i == i3); /* Insert an item with a NUL in the key */ xmlrpc_struct_set_value_n(&env, s, weirdKey, sizeof(weirdKey), i2); TEST_NO_FAULT(&env); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 3); test_struct_get_element(s, i3, i2, weirdKey, sizeof(weirdKey)); /* Replace an existing element with the same element (tricky). */ xmlrpc_struct_set_value(&env, s, "foo", i3); TEST_NO_FAULT(&env); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 3); i = xmlrpc_struct_get_value(&env, s, "foo"); TEST_NO_FAULT(&env); TEST(i == i3); /* Test for the presence and absence of elements. */ present = xmlrpc_struct_has_key(&env, s, "foo"); TEST_NO_FAULT(&env); TEST(present); present = xmlrpc_struct_has_key(&env, s, "qmdebdw"); TEST_NO_FAULT(&env); TEST(present); present = xmlrpc_struct_has_key(&env, s, "bogus"); TEST_NO_FAULT(&env); TEST(!present); /* Make sure our typechecks work correctly. */ xmlrpc_struct_size(&env, i1); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); xmlrpc_struct_has_key(&env, i1, "foo"); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); xmlrpc_struct_set_value(&env, i1, "foo", i2); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); xmlrpc_struct_set_value_v(&env, s, s, i2); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* Test cleanup code (w/memprof). */ xmlrpc_DECREF(s); s = xmlrpc_build_value(&env, "{s:s,s:i,s:b}", "foo", "Hello!", "bar", (xmlrpc_int32) 1, "baz", (xmlrpc_bool) 0); TEST_NO_FAULT(&env); TEST(s != NULL); TEST(xmlrpc_value_type(s) == XMLRPC_TYPE_STRUCT); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 3); present = xmlrpc_struct_has_key(&env, s, "foo"); TEST_NO_FAULT(&env); TEST(present); present = xmlrpc_struct_has_key(&env, s, "bar"); TEST_NO_FAULT(&env); TEST(present); present = xmlrpc_struct_has_key(&env, s, "baz"); TEST_NO_FAULT(&env); TEST(present); xmlrpc_struct_read_value(&env, s, "baz", &value1P); TEST_NO_FAULT(&env); xmlrpc_read_bool(&env, value1P, &bval); TEST_NO_FAULT(&env); TEST(!bval); xmlrpc_DECREF(value1P); testStructReadout(s, 3); test_struct_decompose(s); /* Test type check. */ xmlrpc_struct_get_key_and_value(&env, i1, 0, &key, &value); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); TEST(key == NULL && value == NULL); /* Test bounds checks. */ xmlrpc_struct_get_key_and_value(&env, s, -1, &key, &value); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); TEST(key == NULL && value == NULL); xmlrpc_struct_get_key_and_value(&env, s, 3, &key, &value); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); TEST(key == NULL && value == NULL); /* Test cleanup code (w/memprof). */ xmlrpc_DECREF(s); xmlrpc_DECREF(i1); xmlrpc_DECREF(i2); xmlrpc_DECREF(i3); xmlrpc_env_clean(&env); }
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; }
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; }