axis2_status_t AXIS2_CALL
adb_createReservation_deserialize(
adb_createReservation_t* _createReservation,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _createReservation, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for createReservation : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building sessionId element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
element_qname = axutil_qname_create(env, "sessionId", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("sessionId", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("sessionId", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_createReservation_set_sessionId(_createReservation, env,
text_value);
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element sessionId");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
status = adb_createReservation_set_sessionId(_createReservation, env,
"");
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for sessionId ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building bandwidthRequest element
*/
/*
* because elements are ordered this works fine
*/
if(current_node != NULL && is_early_node_valid)
{
current_node = axiom_node_get_next_sibling(current_node, env);
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
}
is_early_node_valid = AXIS2_FALSE;
element_qname = axutil_qname_create(env, "bandwidthRequest", NULL, NULL);
if (adb_bandwidthRequest_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bandwidthRequest", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bandwidthRequest", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)adb_bandwidthRequest_create(env);
status = adb_bandwidthRequest_deserialize((adb_bandwidthRequest_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element bandwidthRequest");
}
else
{
status = adb_createReservation_set_bandwidthRequest(_createReservation, env,
(adb_bandwidthRequest_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for bandwidthRequest ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building bidirectional element
*/
/*
* because elements are ordered this works fine
*/
if(current_node != NULL && is_early_node_valid)
{
current_node = axiom_node_get_next_sibling(current_node, env);
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
}
is_early_node_valid = AXIS2_FALSE;
element_qname = axutil_qname_create(env, "bidirectional", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bidirectional", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bidirectional", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
if (!axutil_strcasecmp(text_value , "true"))
{
status = adb_createReservation_set_bidirectional(_createReservation, env,
AXIS2_TRUE);
}
else
{
status = adb_createReservation_set_bidirectional(_createReservation, env,
AXIS2_FALSE);
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element bidirectional");
status = AXIS2_FAILURE;
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for bidirectional ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element bidirectional missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
/**
* Here we extract all operations defined in module.xml and built execution
* chains for them by calling axis2_phase_resolver_build_execution_chains_for_module_op()
* function. Within that function handlers of the modules defined for that
* operation are added to module operation chains appropriately.
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_module_ops(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axutil_hash_t *map = NULL;
axutil_hash_index_t *hash_idx = NULL;
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_op_t *op_desc = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
axis2_char_t *modname = NULL;
axis2_char_t *opname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_add_module_ops");
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
modname = axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc, env), env);
map = axis2_module_desc_get_all_ops(module_desc, env);
phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc);
if(!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
svcname);
return AXIS2_FAILURE;
}
for(hash_idx = axutil_hash_first(map, env); hash_idx; hash_idx = axutil_hash_next(env, hash_idx))
{
void *v = NULL;
axutil_hash_this(hash_idx, NULL, NULL, &v);
op_desc = (axis2_op_t *)v;
opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
status = axis2_phase_resolver_build_execution_chains_for_module_op(phase_resolver, env,
op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Builidng module operation %s failed for module %s", opname, modname);
return status;
}
status = axis2_svc_add_op(svc, env, op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding operation %s to service %s failed",
opname, svcname);
return status;
}
}
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_add_module_ops");
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_op_t *AXIS2_CALL
axis2_svc_get_op_with_qname(
const axis2_svc_t * svc,
const axutil_env_t * env,
const axutil_qname_t * op_qname)
{
axis2_op_t *op = NULL;
axis2_char_t *nc_name = NULL;
axis2_char_t *nc_tmp = NULL;
/* This is just for the sake of comparison,
* and must not be used to change the passed value
*/
axis2_bool_t is_matched = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, op_qname, NULL);
nc_name = axutil_qname_get_localpart(op_qname, env);
nc_tmp = nc_name;
op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING);
if(op)
{
return op;
}
op = axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING);
if(op)
{
return op;
}
if(*nc_tmp && svc->op_action_map)
{
axutil_hash_index_t *hi = NULL;
const void *key = NULL;
for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, NULL);
nc_tmp = nc_name;
if(key)
{
axis2_char_t *search = NULL;
axis2_bool_t match_start = AXIS2_TRUE;
axis2_char_t *search_tmp = NULL;
search = (axis2_char_t *)key;
if(!axutil_strchr(search, '*'))
{
if(axutil_strstr(nc_tmp, search))
{
axis2_char_t *comp_tmp = NULL;
comp_tmp = axutil_strstr(nc_tmp, search);
if(strlen(comp_tmp) == strlen(search))
{
nc_tmp = (axis2_char_t *)key;
is_matched = AXIS2_TRUE;
break;
}
}
continue;
}
if(search[0] == '*')
{
search++;
if(!*search)
{
nc_tmp = (axis2_char_t *)key;
is_matched = AXIS2_TRUE;
break;
}
else if(axutil_strchr(search, '*'))
{
continue;
}
match_start = AXIS2_FALSE;
}
while(search && *search)
{
size_t length = 0;
axis2_char_t *loc_tmp = NULL;
if(search_tmp)
{
AXIS2_FREE(env->allocator, search_tmp);
search_tmp = NULL;
}
loc_tmp = axutil_strchr(search, '*');
if(loc_tmp && *loc_tmp)
{
if(!loc_tmp[1])
{
is_matched = AXIS2_TRUE;
break;
}
length = (size_t)(loc_tmp - search);
/* We are sure that the difference lies within the int range */
search_tmp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator,
sizeof(axis2_char_t) * (length + 1)));
strncpy(search_tmp, search, length);
search_tmp[length] = '\0';
}
else if(axutil_strstr(nc_tmp, search))
{
axis2_char_t *comp_tmp = NULL;
comp_tmp = axutil_strstr(nc_tmp, search);
if(strlen(comp_tmp) == strlen(search))
{
nc_tmp = (axis2_char_t *)key;
is_matched = AXIS2_TRUE;
break;
}
break;
}
else
{
break;
}
if(search_tmp && axutil_strstr(nc_tmp, search_tmp))
{
if(match_start && !(axutil_strncmp(nc_tmp, search, (int)length) == 0))
{
break;
}
else if(!match_start)
{
match_start = AXIS2_TRUE;
}
}
else
{
break;
}
search += axutil_strlen(search_tmp) + 1;
nc_tmp = axutil_strstr(nc_tmp, search_tmp) + axutil_strlen(search_tmp);
}
if(search_tmp)
{
AXIS2_FREE(env->allocator, search_tmp);
search_tmp = NULL;
}
if(is_matched || !search || !*search)
{
nc_tmp = (axis2_char_t *)key;
is_matched = AXIS2_TRUE;
break;
}
}
}
}
if(!is_matched)
{
nc_tmp = nc_name;
}
op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING);
if(op)
{
return op;
}
return (axis2_op_t *)axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING);
}
axiom_node_t* AXIS2_CALL
adb_unsubscribeResponse_serialize_obj(
adb_unsubscribeResponse_t* _unsubscribeResponse,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t *text_value_1;
axis2_char_t *text_value_1_temp;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _unsubscribeResponse, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://mopevm.ru/axis2/services/types",
"n");
axutil_hash_set(namespaces, "http://mopevm.ru/axis2/services/types", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "unsubscribeResponse", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
p_prefix = NULL;
if (!_unsubscribeResponse->is_valid_message)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property message");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("message")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("message")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing message element
*/
sprintf(start_input_str, "<%s%smessage>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%smessage>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_1 = _unsubscribeResponse->property_message;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
if (text_value_1_temp)
{
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
AXIS2_FREE(env->allocator, text_value_1_temp);
}
else
{
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
int
test_hash_get(
const axutil_env_t * env)
{
axutil_hash_t *ht;
a *a1,
*a2,
*a3,
*a4;
axutil_hash_index_t *i = 0;
void *v = NULL;
char *key1 = "key1";
char *key2 = "key2";
char *key3 = "key3";
char *key4 = "key4";
int cnt = 0;
axis2_char_t ***rettt = NULL;
axis2_status_t stat = AXIS2_FAILURE;
stat = axutil_parse_rest_url_for_params(env, "ech{a}tring", "/echoString?text=Hello%20World%21", &cnt, &rettt);
stat = axutil_parse_rest_url_for_params(env, "{a}ny/mor/sum", "echoStringmany/mor/sum", &cnt, &rettt);
/* rettt = axutil_parse_rest_url_for_params(env, "echoString/{a}re/{b}?", "/echoString/more/sum/?");
rettt = axutil_parse_rest_url_for_params(env, "/ech{c}tring{a}more/{b}/", "/echoStringma/nymore/sum?");
rettt = axutil_parse_rest_url_for_params(env, "echoString/{a}/more/{b}?{c}", "echoString/many/more/sum/");
rettt = axutil_parse_rest_url_for_params(env, "echoString/{a}/more/{b}/?", "echoString/many/more/sum/?test=");*/
a1 = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
a2 = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
a3 = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
a4 = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
a1->value = axutil_strdup(env, "value1");
a2->value = axutil_strdup(env, "value2");
a3->value = axutil_strdup(env, "value3");
a4->value = axutil_strdup(env, "value4");
ht = axutil_hash_make(env);
axutil_hash_set(ht, key1, AXIS2_HASH_KEY_STRING, a1);
axutil_hash_set(ht, key2, AXIS2_HASH_KEY_STRING, a2);
axutil_hash_set(ht, key3, AXIS2_HASH_KEY_STRING, a3);
axutil_hash_set(ht, key4, AXIS2_HASH_KEY_STRING, a4);
axutil_hash_set(ht, key2, AXIS2_HASH_KEY_STRING, NULL);
axutil_hash_set(ht, key2, AXIS2_HASH_KEY_STRING, a2);
for (i = axutil_hash_first(ht, env); i; i = axutil_hash_next(env, i))
{
axutil_hash_this(i, NULL, NULL, &v);
printf("\n %s \n", ((a *) v)->value);
}
printf("\n demo get %s ",
((a *) axutil_hash_get(ht, key1, AXIS2_HASH_KEY_STRING))->value);
printf("\n demo get %s ",
((a *) axutil_hash_get(ht, key2, AXIS2_HASH_KEY_STRING))->value);
printf("\n demo get %s ",
((a *) axutil_hash_get(ht, key3, AXIS2_HASH_KEY_STRING))->value);
printf("\n demo get %s \n",
((a *) axutil_hash_get(ht, key4, AXIS2_HASH_KEY_STRING))->value);
axutil_hash_free(ht, env);
AXIS2_FREE(env->allocator, a1->value);
AXIS2_FREE(env->allocator, a2->value);
AXIS2_FREE(env->allocator, a3->value);
AXIS2_FREE(env->allocator, a4->value);
AXIS2_FREE(env->allocator, a1);
AXIS2_FREE(env->allocator, a2);
AXIS2_FREE(env->allocator, a3);
AXIS2_FREE(env->allocator, a4);
return 0;
}
axiom_node_t* AXIS2_CALL
adb_ProductComplete_serialize(
adb_ProductComplete_t* _ProductComplete,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t *current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[64];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _ProductComplete, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://webser.com",
"n");
axutil_hash_set(namespaces, "http://webser.com", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "ProductComplete", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://webser.com", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://webser.com", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://webser.com",
p_prefix));
}
if (!_ProductComplete->is_valid_productInfo)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("productInfo")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("productInfo")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing productInfo element
*/
sprintf(start_input_str, "<%s%sproductInfo",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sproductInfo>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_ProductCompleteType_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_ProductCompleteType_serialize(_ProductComplete->property_productInfo,
env, current_node, parent_element,
adb_ProductCompleteType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_ProductCompleteType_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axiom_node_t* AXIS2_CALL
adb_getSystemFaultCountResponse_serialize(
adb_getSystemFaultCountResponse_t* _getSystemFaultCountResponse,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t *current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _getSystemFaultCountResponse, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://org.apache.axis2/xsd",
"n");
axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "getSystemFaultCountResponse", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://org.apache.axis2/xsd",
p_prefix));
}
if (!_getSystemFaultCountResponse->is_valid_return)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("return")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing return element
*/
sprintf(start_input_str, "<%s%sreturn>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sreturn>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
sprintf (text_value_1, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _getSystemFaultCountResponse->property_return);
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axis2_status_t
wsf_wsdl_util_configure_security_for_service(
const axutil_env_t* env,
axutil_hash_t* script_client_options_hash,
axutil_hash_t* policies_hash,
axis2_svc_t* svc,
axis2_conf_ctx_t* worker_conf_ctx)
{
axis2_char_t* policy_xml_str = NULL;
axutil_hash_t* policy_hash = NULL;
axutil_hash_t* security_token_hash = NULL;
axiom_node_t* input_policy_node_axiom = NULL;
axiom_node_t* binding_policy_node_axiom = NULL;
neethi_policy_t* merged_neethi_policy = NULL;
axis2_status_t success = AXIS2_FAILURE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (script_client_options_hash)
{
policy_xml_str = (axis2_char_t*)axutil_hash_get(script_client_options_hash,
WSF_WSDL_HK_POLICY_STRING,
AXIS2_HASH_KEY_STRING);
policy_hash = (axutil_hash_t*)axutil_hash_get(script_client_options_hash,
WSF_WSDL_HK_POLICY_HASH,
AXIS2_HASH_KEY_STRING);
security_token_hash = (axutil_hash_t*)axutil_hash_get(script_client_options_hash,
WSF_WSDL_HK_SECURITY_TOKEN,
AXIS2_HASH_KEY_STRING);
}
if (policy_xml_str)
{
success = wsf_wsdl_util_policy_from_xml_string(env,
policy_xml_str,
&input_policy_node_axiom);
}
else if (policy_hash)
{
success = wsf_wsdl_util_policy_from_options_hash(env,
policy_hash,
&input_policy_node_axiom);
}
else if (policies_hash) /* TODO: correct this condition */
{
success = AXIS2_SUCCESS;
}
else
{
AXIS2_LOG_DEBUG_MSG(env->log, "No policies found! so security is not added");
return AXIS2_SUCCESS; /* this is not a failure case, simply security is ommitted */
}
if (success)
{
success = AXIS2_FAILURE;
if (security_token_hash)
{
axis2_char_t* op_name = NULL;
/* loop policies hash */
axutil_hash_index_t* hi = NULL;
void* val = NULL;
for (hi = axutil_hash_first(policies_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_t* wsdl_policy_hash = NULL;
axis2_ssize_t size;
op_name = NULL;
axutil_hash_this(hi, &op_name, &size, &val);
wsdl_policy_hash = (axutil_hash_t *)val;
if (!(op_name && wsdl_policy_hash))
{
continue;
}
success = wsf_wsdl_util_policy_from_wsdl_policy_hash(env,
wsdl_policy_hash,
&input_policy_node_axiom,
&binding_policy_node_axiom);
if (success)
{
if (wsf_wsdl_util_create_merged_neethi_policy(env,
input_policy_node_axiom,
binding_policy_node_axiom,
&merged_neethi_policy))
{
if (wsf_wsdl_util_insert_policy_to_svc(env,
merged_neethi_policy,
svc,
op_name))
{
if (wsf_wsdl_util_add_security_to_svc_configuration(env,
security_token_hash,
svc))
{
axis2_conf_t *conf = NULL;
conf = axis2_conf_ctx_get_conf (worker_conf_ctx, env);
wsf_wsdl_util_engage_module (conf,
WSF_WSDL_MODULE_SECURITY,
env,
svc);
}
}
}
}
}
}
}
return success;
}
/* This is the function where threads start running */
void *AXIS2_THREAD_FUNC
axis2_udp_receiver_thread_worker_func(
axutil_thread_t * thd,
void *data)
{
const axutil_env_t *env = NULL;
axis2_status_t status = AXIS2_FAILURE;
axis2_conf_t *conf = NULL;
axis2_svc_t *svc = NULL;
axis2_udp_recv_thd_args_t *args = NULL;
axis2_udp_response_t response;
axutil_hash_index_t *hi = NULL;
axutil_hash_t *ori_all_svcs = NULL, *all_svcs = NULL;
void *val = NULL;
args = (axis2_udp_recv_thd_args_t *) data;
env = (axutil_env_t *) args->env;
conf = axis2_conf_ctx_get_conf(args->conf_ctx, env);
/* Get all the service discriptions */
ori_all_svcs = axis2_conf_get_all_svcs(conf, env);
if (!ori_all_svcs)
{
return NULL;
}
all_svcs = axutil_hash_copy(ori_all_svcs, env);
if (args->is_multicast)
{
/* If multicast we go through every service and try to figure out weather they are
accepting multicast messages. If a service accepts a multicast message we send the
request to that service bypassing the normal dispatchers. Dispatchers cannot be
used since no dispatching information is found in the multicast messages
*/
for (hi = axutil_hash_first(all_svcs, env); hi;
hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
svc = (axis2_svc_t *) val;
if (svc)
{
axutil_param_t *param = NULL;
axis2_char_t *param_val = NULL;
/* Get the Multicast accept parameter from the services.xml */
param = axis2_svc_get_param(svc, env, AXIS2_UDP_MULTICAST_ACCEPT);
if (!param)
{
continue;
}
/* check weather this service accepts multicast requests */
param_val = axutil_param_get_value(param, env);
if (!param_val || !axutil_strcmp(param_val, "false") || axutil_strcmp(param_val, "true"))
{
continue;
}
response.buf_size = 0;
response.buff = NULL;
/* set the service to the request. This will bypass the dispatches */
args->request.svc = svc;
/* Process the request */
status = axis2_udp_receiver_process_request(args->env, args->conf_ctx,
&args->request, &response);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error processing the request.");
return NULL;
}
/* If we have a response send it */
if (response.buff)
{
status = axutil_network_handler_send_dgram(env, args->send_socket,
response.buff, &response.buf_size,
args->req_addr, args->req_port, NULL);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error sending the response.");
return NULL;
}
}
}
}
}
else
{
axis2_ctx_t *ctx = NULL;
axutil_property_t *prop = NULL;
axis2_udp_backchannel_info_t *binfo = NULL;
ctx = axis2_conf_ctx_get_base(args->conf_ctx, env);
prop = axis2_ctx_get_property(ctx, env, AXIS2_UDP_BACKCHANNEL_INFO);
if (prop)
{
binfo = axutil_property_get_value(prop, env);
}
/* Unicast case. In this case message contains dispatching information.
* So we send the request in the normal way
*/
response.buf_size = 0;
response.buff = NULL;
if (binfo)
{
args->request.svc = binfo->svc;
args->request.op = binfo->op;
}
/* Process the request */
status = axis2_udp_receiver_process_request(args->env, args->conf_ctx,
&args->request, &response);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error processing the request.");
return NULL;
}
/* If we have a response send it */
if (response.buff)
{
status = axutil_network_handler_send_dgram(env, args->send_socket,
response.buff, &response.buf_size,
args->req_addr, args->req_port, NULL);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error sending the response.");
return NULL;
}
}
}
return NULL;
}
AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
axiom_soap_header_get_header_blocks_with_namespace_uri(
axiom_soap_header_t * soap_header,
const axutil_env_t * env,
const axis2_char_t * ns_uri)
{
axutil_array_list_t *header_block_list = NULL;
axutil_hash_index_t *hash_index = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_om_node = NULL;
axiom_element_t *header_block_om_ele = NULL;
axiom_namespace_t *ns = NULL;
axis2_char_t *hb_namespace_uri = NULL;
int found = 0;
void *hb = NULL;
AXIS2_PARAM_CHECK(env->error, ns_uri, NULL);
if(!(soap_header->header_blocks))
{
return NULL;
}
header_block_list = axutil_array_list_create(env, 10);
if(!header_block_list)
{
return NULL;
}
for(hash_index = axutil_hash_first(soap_header->header_blocks, env); hash_index; hash_index
= axutil_hash_next(env, hash_index))
{
axutil_hash_this(hash_index, NULL, NULL, &hb);
if(hb)
{
header_block = (axiom_soap_header_block_t *)hb;
header_block_om_node = axiom_soap_header_block_get_base_node(header_block, env);
if(header_block_om_node)
{
header_block_om_ele = (axiom_element_t *)axiom_node_get_data_element(
header_block_om_node, env);
if(header_block_om_ele)
{
ns
= axiom_element_get_namespace(header_block_om_ele, env,
header_block_om_node);
if(ns)
{
hb_namespace_uri = axiom_namespace_get_uri(ns, env);
if(axutil_strcmp(hb_namespace_uri, ns_uri) == 0)
{
axutil_array_list_add(header_block_list, env, header_block);
found++;
}
}
}
}
hb = NULL;
header_block = NULL;
header_block_om_ele = NULL;
header_block_om_node = NULL;
ns = NULL;
hb_namespace_uri = NULL;
}
}
if(found > 0)
{
return header_block_list;
}
else
{
axutil_array_list_free(header_block_list, env);
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_header_remove_header_block(
axiom_soap_header_t * soap_header,
const axutil_env_t * env,
axutil_qname_t * qname)
{
axis2_char_t *qn_localname = NULL;
axis2_char_t *qname_ns = NULL;
axis2_char_t *qname_prefix = NULL;
axutil_hash_index_t *hi = NULL;
AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
qn_localname = axutil_qname_get_localpart(qname, env);
qname_ns = axutil_qname_get_uri(qname, env);
qname_prefix = axutil_qname_get_prefix(qname, env);
if(!soap_header->header_blocks)
{
return AXIS2_FAILURE;
}
for(hi = axutil_hash_first(soap_header->header_blocks, env); hi; hi = axutil_hash_next(env, hi))
{
const void *key = NULL;
void *val = NULL;
axutil_hash_this(hi, &key, NULL, &val);
if(val)
{
axiom_soap_header_block_t *header_block = NULL;
axiom_element_t *ele = NULL;
axiom_node_t *node = NULL;
header_block = (axiom_soap_header_block_t *)val;
node = axiom_soap_header_block_get_base_node(header_block, env);
if(node)
{
axutil_qname_t *element_qname = NULL;
ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
element_qname = axiom_element_get_qname(ele, env, node);
if(axiom_soap_header_qname_matches(env, element_qname, qname) == AXIS2_TRUE)
{
axiom_node_detach(node, env);
/* axiom_node_free_tree(node, env); */
axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, NULL);
axiom_soap_header_block_free(header_block, env);
axiom_node_free_tree(node, env);
break;
}
}
}
}
if(hi)
{
AXIS2_FREE(env->allocator, hi);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_conf_ctx_free(
axis2_conf_ctx_t * conf_ctx,
const axutil_env_t * env)
{
if(conf_ctx->base)
{
axis2_ctx_free(conf_ctx->base, env);
}
if(conf_ctx->op_ctx_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for(hi = axutil_hash_first(conf_ctx->op_ctx_map, env); hi; hi = axutil_hash_next(env, hi))
{
axis2_op_ctx_t *op_ctx = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
op_ctx = (axis2_op_ctx_t *)val;
if(op_ctx)
axis2_op_ctx_free(op_ctx, env);
val = NULL;
op_ctx = NULL;
}
axutil_hash_free(conf_ctx->op_ctx_map, env);
}
if(conf_ctx->svc_ctx_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for(hi = axutil_hash_first(conf_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, hi))
{
axis2_svc_ctx_t *svc_ctx = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
svc_ctx = (axis2_svc_ctx_t *)val;
if(svc_ctx)
axis2_svc_ctx_free(svc_ctx, env);
val = NULL;
svc_ctx = NULL;
}
axutil_hash_free(conf_ctx->svc_ctx_map, env);
}
if(conf_ctx->svc_grp_ctx_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for(hi = axutil_hash_first(conf_ctx->svc_grp_ctx_map, env); hi; hi = axutil_hash_next(env,
hi))
{
axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
svc_grp_ctx = (axis2_svc_grp_ctx_t *)val;
if(svc_grp_ctx)
axis2_svc_grp_ctx_free(svc_grp_ctx, env);
val = NULL;
svc_grp_ctx = NULL;
}
axutil_hash_free(conf_ctx->svc_grp_ctx_map, env);
}
if(conf_ctx->conf)
{
axis2_conf_free(conf_ctx->conf, env);
}
if(conf_ctx->mutex)
{
axutil_thread_mutex_destroy(conf_ctx->mutex);
}
if(conf_ctx->root_dir)
{
AXIS2_FREE(env->allocator, conf_ctx->root_dir);
}
AXIS2_FREE(env->allocator, conf_ctx);
}
axiom_node_t *
return_policy_element(
axis2_char_t * name,
const axutil_env_t * env,
axis2_char_t * wsdl_name)
{
axiom_element_t *ele1 = NULL,
*ele2 = NULL;
axiom_document_t *document = NULL;
axiom_node_t *node1 = NULL,
*node2 = NULL,
*policy_node = NULL;
axiom_namespace_t *ns = NULL;
axiom_xml_reader_t *reader = NULL;
axiom_stax_builder_t *builder = NULL;
char *buffer = NULL;
axiom_attribute_t *attr = NULL;
axis2_char_t *value = NULL;
axis2_char_t *val = NULL;
axutil_hash_t *attr_hash = NULL;
axis2_char_t *xml_output = NULL;
axutil_hash_index_t *hi;
/*
f = fopen(wsdl_name, "r");
if (!f)
return NULL;
reader = axiom_xml_reader_create_for_io(env, read_input, NULL , NULL, NULL);
*/
reader = axiom_xml_reader_create_for_file(env, wsdl_name, NULL);
if (!reader)
{
printf("ERROR CREATING PULLPARSER");
return NULL;
}
builder = axiom_stax_builder_create(env, reader);
if (!builder)
{
printf("ERROR CREATING PULL PARSER");
return NULL;
}
document = axiom_stax_builder_get_document(builder, env);
if (!document)
return NULL;
node1 = axiom_document_get_root_element(document, env);
if (!node1)
{
printf(" root element null ");
axiom_stax_builder_free(builder, env);
return NULL;
}
do
{
node2 = axiom_document_build_next(document, env);
if (!node2)
break;
if (axiom_node_get_node_type(node2, env) == AXIOM_ELEMENT)
{
ele2 = (axiom_element_t *) axiom_node_get_data_element(node2, env);
attr_hash = axiom_element_get_all_attributes(ele2, env);
if (attr_hash)
{
hi = axutil_hash_first(attr_hash, env);
axutil_hash_this(hi, NULL, NULL, &attr);
if (axutil_strcmp(axiom_attribute_get_value(attr, env), name) ==
0)
{
policy_node = node2;
}
}
}
}
while (node2);
return policy_node;
}
axis2_status_t AXIS2_CALL
adb_IssuerType_deserialize_obj(
adb_IssuerType_t* _IssuerType,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
status = AXIS2_FAILURE;
if(parent)
{
axis2_char_t *attrib_text = NULL;
attrib_text = axiom_element_get_attribute_value_by_name(axiom_node_get_data_element(parent, env), env, "nil");
if (attrib_text != NULL && !axutil_strcasecmp(attrib_text, "true"))
{
/* but the wsdl says that, this is non nillable */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element IssuerType");
status = AXIS2_FAILURE;
}
else
{
axiom_node_t *text_node = NULL;
axiom_text_t *text_element = NULL;
text_node = axiom_node_get_first_child(parent, env);
if (text_node &&
axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
text_element = (axiom_text_t*)axiom_node_get_data_element(text_node, env);
text_value = "";
if(text_element && axiom_text_get_value(text_element, env))
{
text_value = (axis2_char_t*)axiom_text_get_value(text_element, env);
}
status = adb_IssuerType_deserialize_from_string(_IssuerType, env, text_value, parent);
}
}
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "uid"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "uid", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "uid");
}
if(attrib_text != NULL)
{
element = (void*)adb_IdString_create(env);
adb_IdString_deserialize_from_string((adb_IdString_t*)element, env, attrib_text, parent);
adb_IssuerType_set_uid(_IssuerType,
env, (adb_IdString_t*)element);
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
remote_registry_resource_free(
remote_registry_resource_t *resource,
const axutil_env_t *env)
{
if(resource->author_name != NULL)
{
AXIS2_FREE(env->allocator, resource->author_name);
resource->author_name = NULL;
}
if(resource->created_time != NULL)
{
axutil_date_time_free(resource->created_time, env);
resource->created_time = NULL;
}
if(resource->last_updated_username != NULL)
{
AXIS2_FREE(env->allocator, resource->last_updated_username);
resource->last_updated_username = NULL;
}
if(resource->description != NULL)
{
AXIS2_FREE(env->allocator, resource->description);
resource->description = NULL;
}
if(resource->path != NULL)
{
AXIS2_FREE(env->allocator, resource->path);
resource->path = NULL;
}
if(resource->media_type != NULL)
{
AXIS2_FREE(env->allocator, resource->media_type);
resource->media_type = NULL;
}
if(resource->parent_path != NULL)
{
AXIS2_FREE(env->allocator, resource->parent_path);
resource->parent_path = NULL;
}
if(resource->properties != NULL)
{
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
for (hi = axutil_hash_first(resource->properties, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
AXIS2_FREE(env->allocator, key);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(resource->properties, env);
resource->properties = NULL;
}
if(resource->depends_on != NULL)
{
axutil_array_list_free(resource->depends_on, env);
resource->depends_on = NULL;
}
if(resource->depended_on_by != NULL)
{
AXIS2_FREE(env->allocator, resource->depended_on_by);
resource->depended_on_by = NULL;
}
if(resource->content != NULL)
{
AXIS2_FREE(env->allocator, resource->content);
resource->content = NULL;
}
if(resource->subtitle != NULL)
{
AXIS2_FREE(env->allocator, resource->subtitle);
resource->subtitle = NULL;
}
if(resource->title != NULL)
{
AXIS2_FREE(env->allocator, resource->title);
resource->title = NULL;
}
if(resource->collection != NULL)
{
AXIS2_FREE(env->allocator, resource->collection);
resource->collection = NULL;
}
if(resource->entries != NULL)
{
int i = 0;
/* needed to free all the resouces recursively */
for(i = 0; i < axutil_array_list_size(resource->entries, env); i ++ )
{
remote_registry_resource_t *res = NULL;
res = axutil_array_list_get(resource->entries, env, i);
remote_registry_resource_free(res, env);
}
axutil_array_list_free(resource->entries, env);
resource->entries = NULL;
}
if(resource->child_paths != NULL)
{
axutil_array_list_free(resource->child_paths, env);
resource->child_paths = NULL;
}
if(resource->link_self != NULL)
{
AXIS2_FREE(env->allocator, resource->link_self);
}
if(resource->link_alternate != NULL)
{
AXIS2_FREE(env->allocator, resource->link_alternate);
}
if(resource->link_path != NULL)
{
AXIS2_FREE(env->allocator, resource->link_path);
}
if(resource->link_edit != NULL)
{
AXIS2_FREE(env->allocator, resource->link_edit);
}
if(resource->link_edit_media != NULL)
{
AXIS2_FREE(env->allocator, resource->link_edit_media);
}
if(resource->content_src_url != NULL)
{
AXIS2_FREE(env->allocator, resource->content_src_url);
}
AXIS2_FREE(env->allocator, resource);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
remote_registry_rest_client_free(
remote_registry_rest_client_t *rest_client,
const axutil_env_t *env)
{
if(rest_client->conf)
{
remote_registry_conf_free(rest_client->conf, env);
rest_client->conf = NULL;
}
if(rest_client->last_response_content_type)
{
AXIS2_FREE(env->allocator, rest_client->last_response_content_type);
rest_client->last_response_content_type = NULL;
}
if(rest_client->cached_entries)
{
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
for (hi = axutil_hash_first(rest_client->cached_entries, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
AXIS2_FREE(env->allocator, key);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(rest_client->cached_entries, env);
}
/* freeing the keys, and the value are just numbers */
if(rest_client->cached_entries_len)
{
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
for (hi = axutil_hash_first(rest_client->cached_entries_len, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
AXIS2_FREE(env->allocator, key);
}
axutil_hash_free(rest_client->cached_entries_len, env);
}
/* freeing the keys, and the value are also should be freed*/
if(rest_client->etags)
{
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
for (hi = axutil_hash_first(rest_client->etags, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
AXIS2_FREE(env->allocator, key);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(rest_client->etags, env);
}
if(rest_client->cached_order)
{
int i;
void *cached_url;
for(i = 0; i < axutil_array_list_size(rest_client->cached_order, env); i ++)
{
cached_url = axutil_array_list_get(rest_client->cached_order, env, i);
AXIS2_FREE(env->allocator, cached_url);
}
axutil_array_list_free(rest_client->cached_order, env);
}
if(rest_client->reverse_cached_order)
{
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
for (hi = axutil_hash_first(rest_client->reverse_cached_order, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
AXIS2_FREE(env->allocator, key);
}
axutil_hash_free(rest_client->reverse_cached_order, env);
}
/* we are keeping the cached entries key to the cached_entries_len
* so no need to re free */
axutil_hash_free(rest_client->cached_entries_len, env);
AXIS2_FREE(env->allocator, rest_client);
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
adb_lang_type0_deserialize_from_string(
adb_lang_type0_t* _lang_type0,
const axutil_env_t *env,
const axis2_char_t *node_value,
axiom_node_t *parent)
{
axis2_status_t status = AXIS2_SUCCESS;
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "type", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
axiom_element_t *current_element = NULL;
current_element = (axiom_element_t*)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "lang|http://www.w3.org/XML/1998/namespace"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "type");
}
if(attrib_text)
{
/* skipping the namespace prefix */
axis2_char_t *temp_attrib = NULL;
temp_attrib = strchr(attrib_text, ':');
if(temp_attrib)
{
/* take the string after the ':' character */
attrib_text = temp_attrib + 1;
}
}
if(!attrib_text) {
/* nothing is here, reset things */
status = adb_lang_type0_reset_members(_lang_type0, env);
}
else
{
status = adb_lang_type0_set_language(_lang_type0,
env, attrib_text);
}
return status;
}
axiom_node_t* AXIS2_CALL
adb_listPublishedOperationsResponse_serialize_obj(
adb_listPublishedOperationsResponse_t* _listPublishedOperationsResponse,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
int i = 0;
int count = 0;
void *element = NULL;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _listPublishedOperationsResponse, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://org.apache.axis2/xsd",
"n");
axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "listPublishedOperationsResponse", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://org.apache.axis2/xsd",
p_prefix));
}
if (!_listPublishedOperationsResponse->is_valid_return)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("return")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* Parsing return array
*/
if (_listPublishedOperationsResponse->property_return != NULL)
{
sprintf(start_input_str, "<%s%sreturn",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sreturn>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
count = axutil_array_list_size(_listPublishedOperationsResponse->property_return, env);
for(i = 0; i < count; i ++)
{
element = axutil_array_list_get(_listPublishedOperationsResponse->property_return, env, i);
if(NULL == element)
{
continue;
}
/*
* parsing return element
*/
if(!adb_OperationMetaData_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_OperationMetaData_serialize((adb_OperationMetaData_t*)element,
env, current_node, parent_element,
adb_OperationMetaData_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_OperationMetaData_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
}
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axis2_status_t AXIS2_CALL
adb_serviceProvider_type0_deserialize_obj(
adb_serviceProvider_type0_t* _serviceProvider_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _serviceProvider_type0, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for serviceProvider_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
/*
* building label element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
element_qname = axutil_qname_create(env, "label", "http://www.daisy.org/ns/daisy-online/", NULL);
if (adb_label_type0_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_label_type0");
status = adb_label_type0_deserialize((adb_label_type0_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element label");
}
else
{
status = adb_serviceProvider_type0_set_label(_serviceProvider_type0, env,
(adb_label_type0_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for label ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "id"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "id", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "id");
}
if(attrib_text != NULL)
{
adb_serviceProvider_type0_set_id(_serviceProvider_type0,
env, attrib_text);
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute id missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t
axis2_engine_check_must_understand_headers(
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_header_t *soap_header = NULL;
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
if(!soap_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap envelope not found in message context");
return AXIS2_FAILURE;
}
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if(!soap_header)
return AXIS2_SUCCESS;
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if(!header_block_ht)
return AXIS2_SUCCESS;
for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index
= axutil_hash_next(env, hash_index))
{
void *hb = NULL;
axiom_soap_header_block_t *header_block = NULL;
axis2_char_t *role = NULL;
axutil_hash_this(hash_index, NULL, NULL, &hb);
header_block = (axiom_soap_header_block_t *)hb;
if(header_block)
{
if(axiom_soap_header_block_is_processed(header_block, env)
|| !axiom_soap_header_block_get_must_understand(header_block, env))
{
continue;
}
/* If this header block is not targeted to me then its not my
problem. Currently this code only supports the "next" role; we
need to fix this to allow the engine/service to be in one or more
additional roles and then to check that any headers targeted for
that role too have been dealt with. */
role = axiom_soap_header_block_get_role(header_block, env);
if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env) != AXIS2_TRUE)
{
/* SOAP 1.2 */
if(!role || axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NEXT) != 0)
{
axiom_soap_envelope_t *temp_env =
axiom_soap_envelope_create_default_soap_fault_envelope(env,
"soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP12, NULL,
NULL);
axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env);
axis2_msg_ctx_set_wsa_action(msg_ctx, env,
"http://www.w3.org/2005/08/addressing/fault");
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured");
return AXIS2_FAILURE;
}
}
else
{
/* SOAP 1.1 */
if(!role || axutil_strcmp(role, AXIOM_SOAP11_SOAP_ACTOR_NEXT) != 0)
{
axiom_soap_envelope_t *temp_env =
axiom_soap_envelope_create_default_soap_fault_envelope(env,
"soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP11, NULL,
NULL);
axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env);
axis2_msg_ctx_set_wsa_action(msg_ctx, env,
"http://www.w3.org/2005/08/addressing/fault");
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured");
return AXIS2_FAILURE;
}
}
}
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
adb_unsubscribeResponse_deserialize_obj(
adb_unsubscribeResponse_t* _unsubscribeResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _unsubscribeResponse, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for unsubscribeResponse : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
qname = axiom_element_get_qname(current_element, env, parent);
if (axutil_qname_equals(qname, env, _unsubscribeResponse-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for unsubscribeResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_unsubscribeResponse-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building message element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
element_qname = axutil_qname_create(env, "message", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_unsubscribeResponse_set_message(_unsubscribeResponse, env,
text_value);
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element message");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
status = adb_unsubscribeResponse_set_message(_unsubscribeResponse, env,
"");
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for message ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element message missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axiom_node_t* AXIS2_CALL
adb_type_serialize_obj(
adb_type_t* _type,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t *text_value_1;
axis2_char_t *text_value_1_temp;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _type, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://purl.org/dc/elements/1.1/",
"n");
axutil_hash_set(namespaces, "http://purl.org/dc/elements/1.1/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "type", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://purl.org/dc/elements/1.1/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://purl.org/dc/elements/1.1/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://purl.org/dc/elements/1.1/",
p_prefix));
}
if (!_type->is_valid_type)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property type");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("type")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("type")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing type element
*/
sprintf(start_input_str, "<%s%stype>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%stype>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_1 = NULL; /* just to bypass the warning unused variable */
axiom_node_add_child(parent, env, _type->property_type);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axiom_node_t* AXIS2_CALL
adb_getServiceAnnouncementsResponse_serialize_obj(
adb_getServiceAnnouncementsResponse_t* _getServiceAnnouncementsResponse,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _getServiceAnnouncementsResponse, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
"n");
axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "getServiceAnnouncementsResponse", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
p_prefix));
}
if (!_getServiceAnnouncementsResponse->is_valid_announcements)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property announcements");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("announcements")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("announcements")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing announcements element
*/
sprintf(start_input_str, "<%s%sannouncements",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sannouncements>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_announcements_type0_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_announcements_type0_serialize(_getServiceAnnouncementsResponse->property_announcements,
env, current_node, parent_element,
adb_announcements_type0_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_announcements_type0_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axiom_node_t* AXIS2_CALL
adb_UserNotRegisteredException1_serialize(
adb_UserNotRegisteredException1_t* _UserNotRegisteredException1,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t *current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[64];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _UserNotRegisteredException1, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://esb.callbackservice.services.hdviper.psnc.pl/",
"n");
axutil_hash_set(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "UserNotRegisteredException", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://esb.callbackservice.services.hdviper.psnc.pl/",
p_prefix));
}
if (!_UserNotRegisteredException1->is_valid_UserNotRegisteredException)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property UserNotRegisteredException");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("UserNotRegisteredException")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("UserNotRegisteredException")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing UserNotRegisteredException element
*/
sprintf(start_input_str, "<%s%sUserNotRegisteredException",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sUserNotRegisteredException>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
adb_UserNotRegisteredException_serialize(_UserNotRegisteredException1->property_UserNotRegisteredException,
env, current_node, parent_element,
adb_UserNotRegisteredException_is_particle() || AXIS2_TRUE, namespaces, next_ns_index);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
static void
ngx_squ_xml_parse_children(squ_State *l, axutil_env_t *env,
axiom_node_t *parent, axiom_element_t *parent_elem)
{
int n;
char *uri, *prefix, *name, *text, *value;
axiom_node_t *node;
axutil_hash_t *attrs;
axiom_element_t *elem;
ngx_squ_thread_t *thr;
axiom_attribute_t *attr;
axiom_namespace_t *ns;
axutil_hash_index_t *hi;
axiom_child_element_iterator_t *it;
thr = ngx_squ_thread(l);
ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse children");
it = axiom_element_get_child_elements(parent_elem, env, parent);
if (it == NULL) {
return;
}
n = 1;
do {
node = axiom_child_element_iterator_next(it, env);
elem = axiom_node_get_data_element(node, env);
name = axiom_element_get_localname(elem, env);
squ_createtable(l, 2, 4);
squ_pushstring(l, name);
squ_setfield(l, -2, "name");
ns = axiom_element_get_namespace(elem, env, node);
if (ns != NULL) {
uri = axiom_namespace_get_uri(ns, env);
if (uri != NULL) {
squ_pushstring(l, uri);
squ_setfield(l, -2, "uri");
}
prefix = axiom_namespace_get_prefix(ns, env);
if (prefix != NULL) {
squ_pushstring(l, prefix);
squ_setfield(l, -2, "prefix");
}
}
attrs = axiom_element_get_all_attributes(elem, env);
if (attrs != NULL) {
squ_newtable(l);
hi = axutil_hash_first(attrs, env);
do {
if (hi == NULL) {
break;
}
axutil_hash_this(hi, NULL, NULL, (void **) &attr);
name = axiom_attribute_get_localname(attr, env);
value = axiom_attribute_get_value(attr, env);
squ_pushstring(l, value);
squ_setfield(l, -2, name);
hi = axutil_hash_next(env, hi);
} while (1);
squ_setfield(l, -2, "attributes");
}
text = axiom_element_get_text(elem, env, node);
if (text != NULL) {
squ_pushstring(l, text);
squ_setfield(l, -2, "text");
} else {
squ_newtable(l);
ngx_squ_xml_parse_children(l, env, node, elem);
squ_setfield(l, -2, "children");
}
squ_setfield(l, -2, name);
squ_getfield(l, -1, name);
squ_rawseti(l, -2, n++);
} while (axiom_child_element_iterator_has_next(it, env) == AXIS2_TRUE);
}
axis2_status_t AXIS2_CALL
adb_additionalTransferProtocols_type0_deserialize_obj(
adb_additionalTransferProtocols_type0_t* _additionalTransferProtocols_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _additionalTransferProtocols_type0, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for additionalTransferProtocols_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building protocol array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building protocol element
*/
element_qname = axutil_qname_create(env, "protocol", "http://www.daisy.org/ns/daisy-online/", NULL);
for (i = 0, sequence_broken = 0, current_node = first_node; !sequence_broken && current_node != NULL;)
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node =axiom_node_get_next_sibling(current_node, env);
is_early_node_valid = AXIS2_FALSE;
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element protocol");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for protocol ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i < 1)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "protocol (@minOccurs = '1') only have %d elements", i);
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_additionalTransferProtocols_type0_set_protocol(_additionalTransferProtocols_type0, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_svc_free(
axis2_svc_t * svc,
const axutil_env_t * env)
{
if(!svc)
{
return;
}
if(svc->impl_class)
{
AXIS2_SVC_SKELETON_FREE((axis2_svc_skeleton_t *)svc->impl_class, env);
}
if(svc->param_container)
{
axutil_param_container_free(svc->param_container, env);
}
if(svc->flow_container)
{
axis2_flow_container_free(svc->flow_container, env);
}
if(svc->filename)
{
AXIS2_FREE(env->allocator, svc->filename);
svc->filename = NULL;
}
if(svc->svc_desc)
{
AXIS2_FREE(env->allocator, svc->svc_desc);
svc->svc_desc = NULL;
}
svc->parent = NULL;
if(svc->module_list)
{
int i = 0;
int size = 0;
size = axutil_array_list_size(svc->module_list, env);
for(i = 0; i < size; i++)
{
axutil_qname_t *qname = NULL;
qname = axutil_array_list_get(svc->module_list, env, i);
if(qname)
{
axutil_qname_free(qname, env);
}
}
axutil_array_list_free(svc->module_list, env);
}
if(svc->schema_list)
{
axutil_array_list_free(svc->schema_list, env);
}
if(svc->engaged_module_list)
{
axutil_array_list_free(svc->engaged_module_list, env);
}
if(svc->axis_svc_name)
{
AXIS2_FREE(env->allocator, svc->axis_svc_name);
svc->axis_svc_name = NULL;
}
if(svc->op_alias_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for(hi = axutil_hash_first(svc->op_alias_map, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
if(val)
{
if(axis2_op_is_from_module((axis2_op_t *)val, env) == AXIS2_FALSE)
{
axis2_op_free((axis2_op_t *)val, env);
}
val = NULL;
}
}
axutil_hash_free(svc->op_alias_map, env);
}
if(svc->op_action_map)
{
axutil_hash_index_t *hi = NULL;
const void *key = NULL;
for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, NULL);
if(key)
{
AXIS2_FREE(env->allocator, (axis2_char_t *)key);
key = NULL;
}
}
axutil_hash_free(svc->op_action_map, env);
}
if(svc->op_rest_map)
{
axis2_core_utils_free_rest_map(env, svc->op_rest_map);
}
if(svc->schema_target_ns_prefix)
{
AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix);
svc->schema_target_ns_prefix = NULL;
}
if(svc->target_ns)
{
AXIS2_FREE(env->allocator, svc->target_ns);
svc->target_ns = NULL;
}
if(svc->wsdl_path)
{
AXIS2_FREE(env->allocator, svc->wsdl_path);
svc->wsdl_path = NULL;
}
if(svc->folder_path)
{
AXIS2_FREE(env->allocator, svc->folder_path);
svc->folder_path = NULL;
}
if(svc->target_ns_prefix)
{
AXIS2_FREE(env->allocator, svc->target_ns_prefix);
svc->target_ns_prefix = NULL;
}
if(svc->qname)
{
axutil_qname_free(svc->qname, env);
}
if(svc->style)
{
AXIS2_FREE(env->allocator, svc->style);
}
if(svc->base)
{
axis2_desc_free(svc->base, env);
}
if(svc->mutex)
{
axutil_thread_mutex_destroy(svc->mutex);
}
AXIS2_FREE(env->allocator, svc);
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
remote_registry_resource_serialize(
remote_registry_resource_t *resource,
const axutil_env_t *env)
{
axiom_node_t *entry_node = NULL;
axiom_element_t *entry_element = NULL;
axiom_namespace_t *ns1 = NULL;
axiom_namespace_t *ns2 = NULL;
axis2_char_t *description = NULL;
axis2_char_t *author = NULL;
axutil_hash_t *properties = NULL;
axis2_char_t *content = NULL;
int collection = 0;
int content_modified= 0;
axis2_char_t *id = NULL;
axis2_char_t *title = NULL;
axis2_char_t *media_type = NULL;
axis2_char_t *parent_path = NULL;
axutil_date_time_t *modified_date = NULL;
ns1 = axiom_namespace_create(env, REMOTE_REGISTRY_ATOM_NS, REMOTE_REGISTRY_ATOM_NS_PREFIX);
ns2 = axiom_namespace_create(env, REMOTE_REGISTRY_REGISTRY_NS, REMOTE_REGISTRY_REGISTRY_NS_PREFIX);
if(resource->is_collection)
{
entry_element = axiom_element_create(env, NULL, REMOTE_REGISTRY_FEED_KEY_FEED, ns1, &entry_node);
}
else
{
entry_element = axiom_element_create(env, NULL, REMOTE_REGISTRY_FEED_KEY_ENTRY, ns1, &entry_node);
}
axiom_element_declare_namespace(entry_element, env, entry_node, ns1);
axiom_element_declare_namespace(entry_element, env, entry_node, ns2);
/* getting variables from the structure and rendering into an XML */
id = remote_registry_resource_get_id(resource, env);
if(id)
{
axiom_node_t *id_node = NULL;
axiom_element_t *id_element = NULL;
id_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_ID, ns1, &id_node);
axiom_element_set_text(id_element, env, id, id_node);
}
title = remote_registry_resource_get_title(resource, env);
if(title)
{
axiom_node_t *title_node = NULL;
axiom_element_t *title_element = NULL;
axiom_attribute_t *type_attr = NULL;
title_element = axiom_element_create(env, entry_node,
REMOTE_REGISTRY_FEED_KEY_TITLE, ns1, &title_node);
axiom_element_set_text(title_element, env, title, title_node);
type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE,
REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT, NULL);
axiom_element_add_attribute(title_element, env, type_attr, title_node);
}
description = remote_registry_resource_get_description(resource, env);
if(description)
{
axiom_node_t *summary_node = NULL;
axiom_element_t *summary_element = NULL;
axiom_attribute_t *type_attr = NULL;
summary_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_SUMMARY, ns1, &summary_node);
axiom_element_set_text(summary_element, env, description, summary_node);
type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE,
REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT, NULL);
axiom_element_add_attribute(summary_element, env, type_attr, summary_node);
}
author = remote_registry_resource_get_author_name(resource, env);
if(author)
{
axiom_node_t *author_node = NULL;
axiom_node_t *name_node = NULL;
axiom_element_t *name_ele = NULL;
axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_AUTHOR, ns1, &author_node);
name_ele = axiom_element_create(env, author_node, REMOTE_REGISTRY_FEED_KEY_NAME, ns1, &name_node);
axiom_element_set_text(name_ele, env, author, name_node);
}
modified_date = remote_registry_resource_get_last_modified_time(resource, env);
if(!modified_date) {
modified_date = axutil_date_time_create(env);
remote_registry_resource_set_last_modified_time(resource, env, modified_date);
}
if(modified_date)
{
axiom_node_t *date_node = NULL;
axiom_element_t *date_ele = NULL;
axis2_char_t *modified_date_str = NULL;
modified_date_str = axutil_date_time_serialize_date_time(modified_date, env);
date_ele = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_UPDATED, ns1, &date_node);
axiom_element_set_text(date_ele, env, modified_date_str, date_node);
AXIS2_FREE(env->allocator, modified_date_str);
}
content = remote_registry_resource_get_content(resource, env);
if(content)
{
axiom_node_t *content_node = NULL;
axiom_element_t *content_element = NULL;
axiom_attribute_t *type_attr = NULL;
axis2_char_t *base64_content = NULL;
int base64_len = 0;
int content_len = -1;
content_len = remote_registry_resource_get_content_len(resource, env);
if(content_len == -1) /* which mean we have to derive the content length */
{
content_len = axutil_strlen(content);
}
base64_len = axutil_base64_encode_len(content_len);
base64_content = AXIS2_MALLOC(env->allocator, base64_len+ 1);
if(base64_content)
{
axutil_base64_encode(base64_content, content, content_len);
base64_content[base64_len] = '\0';
content_element = axiom_element_create(env, entry_node,
REMOTE_REGISTRY_FEED_KEY_CONTENT, ns1, &content_node);
axiom_element_set_text(content_element, env, base64_content, content_node);
type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE,
REMOTE_REGISTRY_FEED_ATTR_TYPE_BASE64_VALUE, NULL);
axiom_element_add_attribute(content_element, env, type_attr, content_node);
AXIS2_FREE(env->allocator, base64_content);
}
}
else if(!resource->is_collection)
{
axiom_node_t *content_node = NULL;
axiom_element_t *content_element = NULL;
axiom_attribute_t *type_attr = NULL;
content_element = axiom_element_create(env, entry_node,
REMOTE_REGISTRY_FEED_KEY_CONTENT, ns1, &content_node);
axiom_element_set_text(content_element, env,
REMOTE_REGISTRY_FEED_VALUE_EMPTY_CONTENT, content_node);
type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE,
REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT_VALUE, NULL);
axiom_element_add_attribute(content_element, env, type_attr, content_node);
}
properties = remote_registry_resource_get_properties(resource, env);
if(properties)
{
axiom_node_t *properties_node = NULL;
axiom_node_t *property_node = NULL;
axiom_node_t *name_node = NULL;
axiom_node_t *value_node = NULL;
axiom_element_t *name_element = NULL;
axiom_element_t *value_element = NULL;
axutil_hash_index_t *hi;
void *val;
void *key;
int sum = 0;
axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_PROPERTIES, ns2, &properties_node);
for (hi = axutil_hash_first(resource->properties, env); hi; hi = axutil_hash_next(env, hi)) {
axutil_hash_this(hi, (const void**)&key, NULL, &val);
axiom_element_create(env, properties_node, REMOTE_REGISTRY_FEED_KEY_PROPERTY, ns2, &property_node);
name_element = axiom_element_create(env, property_node,
REMOTE_REGISTRY_FEED_KEY_PROPERTY_KEY_NAME, ns2, &name_node);
axiom_element_set_text(name_element, env, (axis2_char_t*)key, name_node);
value_element = axiom_element_create(env, property_node,
REMOTE_REGISTRY_FEED_KEY_PROPERTY_KEY_VALUE, ns2, &value_node);
axiom_element_set_text(value_element, env, (axis2_char_t*)val, value_node);
}
}
media_type = remote_registry_resource_get_media_type(resource, env);
if(media_type)
{
axiom_element_t *media_element = NULL;
axiom_node_t *media_node = NULL;
media_element = axiom_element_create(env, entry_node,
REMOTE_REGISTRY_FEED_KEY_MEDIA_TYPE, ns2, &media_node);
axiom_element_set_text(media_element, env, media_type, media_node);
}
parent_path = remote_registry_resource_get_parent_path(resource, env);
if(parent_path)
{
axiom_element_t *parent_path_element = NULL;
axiom_node_t *parent_path_node = NULL;
parent_path_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_PARENT_PATH, ns2, &parent_path_node);
if(resource->is_collection)
{
/* for collection parent path is always sent at the http request header */
parent_path = "";
}
axiom_element_set_text(parent_path_element, env, parent_path, parent_path_node);
}
if(resource->is_collection)
{
axiom_element_t *content_modified_element = NULL;
axiom_node_t *content_modified_node = NULL;
content_modified_element = axiom_element_create(env, entry_node,
REMOTE_REGISTRY_FEED_KEY_CONTENT_MODIFIED, ns2, &content_modified_node);
axiom_element_set_text(content_modified_element, env,
REMOTE_REGISTRY_FEED_KEY_TRUE_VALUE, content_modified_node);
}
return entry_node;
}
axiom_node_t* AXIS2_CALL
adb_changePassword_serialize_obj(
adb_changePassword_t* _changePassword,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t *text_value_1;
axis2_char_t *text_value_1_temp;
axis2_char_t *text_value_2;
axis2_char_t *text_value_2_temp;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _changePassword, NULL);
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"http://service.mgt.user.carbon.wso2.org",
"n");
axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
parent_element = axiom_element_create (env, NULL, "changePassword", ns1 , &parent);
axiom_element_set_namespace(parent_element, env, ns1, parent);
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://service.mgt.user.carbon.wso2.org",
p_prefix));
}
if (!_changePassword->is_valid_userName)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("userName")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("userName")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing userName element
*/
sprintf(start_input_str, "<%s%suserName>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%suserName>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_1 = _changePassword->property_userName;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
if (text_value_1_temp)
{
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
AXIS2_FREE(env->allocator, text_value_1_temp);
}
else
{
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://service.mgt.user.carbon.wso2.org",
p_prefix));
}
if (!_changePassword->is_valid_newPassword)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("newPassword")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("newPassword")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing newPassword element
*/
sprintf(start_input_str, "<%s%snewPassword>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%snewPassword>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_2 = _changePassword->property_newPassword;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
if (text_value_2_temp)
{
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
AXIS2_FREE(env->allocator, text_value_2_temp);
}
else
{
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axis2_status_t
axis2_addr_in_extract_to_epr_ref_params(
const axutil_env_t * env,
axis2_endpoint_ref_t * to_epr,
axiom_soap_header_t * soap_header,
const axis2_char_t * addr_ns_str)
{
axutil_hash_t *header_blocks_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axutil_qname_t *is_ref_qn = NULL;
AXIS2_PARAM_CHECK(env->error, to_epr, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE);
header_blocks_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if(!header_blocks_ht)
{
return AXIS2_FAILURE;
}
is_ref_qn = axutil_qname_create(env, "IsReferenceParameter", addr_ns_str, NULL);
if(!is_ref_qn)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create qname for %s",
addr_ns_str);
return AXIS2_FAILURE;
}
for(hash_index = axutil_hash_first(header_blocks_ht, env); hash_index; hash_index
= axutil_hash_next(env, hash_index))
{
axiom_element_t *header_block_ele = NULL;
axiom_node_t *header_block_node = NULL;
axiom_soap_header_block_t *header_block = NULL;
void *hb = NULL;
axiom_attribute_t *is_ref_param_attr = NULL;
axis2_char_t *attr_value = NULL;
axutil_hash_this(hash_index, NULL, NULL, &hb);
if(hb)
{
header_block = (axiom_soap_header_block_t *)hb;
header_block_node = axiom_soap_header_block_get_base_node(header_block, env);
header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node,
env);
is_ref_param_attr = axiom_element_get_attribute(header_block_ele, env, is_ref_qn);
if(is_ref_param_attr)
{
attr_value = axiom_attribute_get_localname(is_ref_param_attr, env);
if(!axutil_strcmp("true", attr_value))
{
axis2_endpoint_ref_add_ref_param(to_epr, env, header_block_node);
}
}
}
}
axutil_qname_free(is_ref_qn, env);
return AXIS2_SUCCESS;
}
