static void
readBase64(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
size_t * const lengthP,
const unsigned char ** const byteStringValueP,
bool const oldstyleMemMgmt) {
if (oldstyleMemMgmt)
xmlrpc_read_base64_old(envP, valueP, lengthP, byteStringValueP);
else
xmlrpc_read_base64(envP, valueP, lengthP, byteStringValueP);
}
static void
test_value_base64(void) {
/* Test <base64> data. */
unsigned char const data1[5] = {'a', '\0', 'b', '\n', 'c'};
unsigned char const data2[3] = {'a', '\0', 'b'};
xmlrpc_value * v;
xmlrpc_env env;
const unsigned char * data;
size_t len;
xmlrpc_env_init(&env);
TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BASE64), "BASE64"));
v = xmlrpc_base64_new(&env, sizeof(data1), data1);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v));
xmlrpc_read_base64(&env, v, &len, &data);
TEST_NO_FAULT(&env);
TEST(memeq(data, data1, sizeof(data1)));
TEST(len == sizeof(data1));
xmlrpc_DECREF(v);
free((void*)data);
v = xmlrpc_build_value(&env, "6", data2, sizeof(data2));
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "6", &data, &len);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(len == sizeof(data2));
TEST(memeq(data, data1, sizeof(data2)));
free((void *)data);
xmlrpc_env_clean(&env);
}
static xmlrpc_value * add_flow_destination(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc, i;
xmlrpc_value *ret = 0;
char* cc_alg = 0;
char* bind_address = 0;
xmlrpc_value* extra_options = 0;
struct _flow_settings settings;
struct _request_add_flow_destination* request = 0;
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array,
"("
"{s:s,*}"
"{s:d,s:d,s:d,s:d,s:d,*}"
"{s:i,s:i,*}"
"{s:i,*}"
"{s:b,s:b,s:b,s:b,s:b,*}"
"{s:i,s:i,*}"
"{s:i,s:d,s:d,*}" /* request */
"{s:i,s:d,s:d,*}" /* response */
"{s:i,s:d,s:d,*}" /* interpacket_gap */
"{s:b,s:b,s:i,s:i,*}"
"{s:s,*}"
"{s:i,s:i,s:i,s:i,s:i,*}"
#ifdef HAVE_LIBPCAP
"{s:s,*}"
#endif /* HAVE_LIBPCAP */
"{s:i,s:A,*}"
")",
/* general settings */
"bind_address", &bind_address,
"write_delay", &settings.delay[WRITE],
"write_duration", &settings.duration[WRITE],
"read_delay", &settings.delay[READ],
"read_duration", &settings.duration[READ],
"reporting_interval", &settings.reporting_interval,
"requested_send_buffer_size", &settings.requested_send_buffer_size,
"requested_read_buffer_size", &settings.requested_read_buffer_size,
"maximum_block_size", &settings.maximum_block_size,
"traffic_dump", &settings.traffic_dump,
"so_debug", &settings.so_debug,
"route_record", &settings.route_record,
"pushy", &settings.pushy,
"shutdown", &settings.shutdown,
"write_rate", &settings.write_rate,
"random_seed",&settings.random_seed,
"traffic_generation_request_distribution", &settings.request_trafgen_options.distribution,
"traffic_generation_request_param_one", &settings.request_trafgen_options.param_one,
"traffic_generation_request_param_two", &settings.request_trafgen_options.param_two,
"traffic_generation_response_distribution", &settings.response_trafgen_options.distribution,
"traffic_generation_response_param_one", &settings.response_trafgen_options.param_one,
"traffic_generation_response_param_two", &settings.response_trafgen_options.param_two,
"traffic_generation_gap_distribution", &settings.interpacket_gap_trafgen_options.distribution,
"traffic_generation_gap_param_one", &settings.interpacket_gap_trafgen_options.param_one,
"traffic_generation_gap_param_two", &settings.interpacket_gap_trafgen_options.param_two,
"flow_control", &settings.flow_control,
"byte_counting", &settings.byte_counting,
"cork", &settings.cork,
"nonagle", &settings.nonagle,
"cc_alg", &cc_alg,
"elcn", &settings.elcn,
"lcd", &settings.lcd,
"mtcp", &settings.mtcp,
"dscp", &settings.dscp,
"ipmtudiscover", &settings.ipmtudiscover,
#ifdef HAVE_LIBPCAP
"dump_prefix", &dump_prefix,
#endif /* HAVE_LIBPCAP */
"num_extra_socket_options", &settings.num_extra_socket_options,
"extra_socket_options", &extra_options);
if (env->fault_occurred)
goto cleanup;
/* Check for sanity */
if (strlen(bind_address) >= sizeof(settings.bind_address) - 1 ||
settings.delay[WRITE] < 0 || settings.duration[WRITE] < 0 ||
settings.delay[READ] < 0 || settings.duration[READ] < 0 ||
settings.requested_send_buffer_size < 0 || settings.requested_read_buffer_size < 0 ||
settings.maximum_block_size < MIN_BLOCK_SIZE ||
settings.write_rate < 0 ||
strlen(cc_alg) > TCP_CA_NAME_MAX ||
settings.num_extra_socket_options < 0 || settings.num_extra_socket_options > MAX_EXTRA_SOCKET_OPTIONS ||
xmlrpc_array_size(env, extra_options) != settings.num_extra_socket_options) {
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Flow settings incorrect");
}
/* Parse extra socket options */
for (i = 0; i < settings.num_extra_socket_options; i++) {
const unsigned char* buffer = 0;
size_t len;
xmlrpc_value *option, *level = 0, *optname = 0, *value = 0;
xmlrpc_array_read_item(env, extra_options, i, &option);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "level", &level);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "optname", &optname);
if (!env->fault_occurred)
xmlrpc_struct_read_value(env, option, "value", &value);
if (!env->fault_occurred)
xmlrpc_read_int(env, level, &settings.extra_socket_options[i].level);
if (!env->fault_occurred)
xmlrpc_read_int(env, optname, &settings.extra_socket_options[i].optname);
if (!env->fault_occurred)
xmlrpc_read_base64(env, value, &len, &buffer);
if (level)
xmlrpc_DECREF(level);
if (optname)
xmlrpc_DECREF(optname);
if (value)
xmlrpc_DECREF(value);
if (!env->fault_occurred) {
if (len > MAX_EXTRA_SOCKET_OPTION_VALUE_LENGTH) {
free((void *)buffer);
XMLRPC_FAIL(env, XMLRPC_TYPE_ERROR, "Too long extra socket option length");
}
settings.extra_socket_options[i].optlen = len;
memcpy(settings.extra_socket_options[i].optval, buffer, len);
free((void *)buffer);
}
if (env->fault_occurred)
goto cleanup;
}
strcpy(settings.cc_alg, cc_alg);
strcpy(settings.bind_address, bind_address);
DEBUG_MSG(LOG_WARNING, "bind_address=%s", bind_address);
request = malloc(sizeof(struct _request_add_flow_destination));
request->settings = settings;
rc = dispatch_request((struct _request*)request, REQUEST_ADD_DESTINATION);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "{s:i,s:i,s:i,s:i}",
"flow_id", request->flow_id,
"listen_data_port", request->listen_data_port,
"real_listen_send_buffer_size", request->real_listen_send_buffer_size,
"real_listen_read_buffer_size", request->real_listen_read_buffer_size);
cleanup:
if (request)
free_all(request->r.error, request);
free_all(cc_alg, bind_address);
if (extra_options)
xmlrpc_DECREF(extra_options);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method add_flow_destination failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method add_flow_destination successful");
}
return ret;
}
cWrapper(xmlrpc_value *const valueP) {
env_wrap env;
xmlrpc_read_base64(&env.env_c, valueP, &length, &contents);
throwIfError(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;
}
