/*
* This method invokes the right service method
*/
axiom_node_t *AXIS2_CALL
mul_invoke(
axis2_svc_skeleton_t * svc_skeleton,
const axutil_env_t * env,
axiom_node_t * node,
axis2_msg_ctx_t * msg_ctx)
{
/* Depending on the function name invoke the
* corresponding mul method
*/
if (node)
{
if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
axiom_element_t *element = NULL;
element =
(axiom_element_t *) axiom_node_get_data_element(node, env);
if (element)
{
axis2_char_t *op_name =
axiom_element_get_localname(element, env);
if (op_name)
{
if (axutil_strcmp(op_name, "mul") == 0)
return axis2_mul_mul(env, node);
}
}
}
}
printf("Math service ERROR: invalid OM parameters in request\n");
/** Note: return a SOAP fault here */
return node;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_algorithmsuite_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_algorithmsuite_t *algorithmsuite = NULL;
axiom_node_t *child_node = NULL;
axiom_node_t *algo_node = NULL;
axiom_element_t *algo_element = NULL;
neethi_assertion_t *assertion = NULL;
(void)element;
algorithmsuite = rp_algorithmsuite_create(env);
child_node = axiom_node_get_first_element(node, env);
if(child_node)
{
algo_node = axiom_node_get_first_element(child_node, env);
if(!algo_node)
{
return NULL;
}
}
else
{
return NULL;
}
if(axiom_node_get_node_type(algo_node, env) == AXIOM_ELEMENT)
{
algo_element = (axiom_element_t *)axiom_node_get_data_element(algo_node, env);
if(algo_element)
{
axis2_status_t status = AXIS2_FAILURE;
axis2_char_t *algosuite_string = NULL;
algosuite_string = axiom_element_get_localname(algo_element, env);
if(!algosuite_string)
{
return NULL;
}
status = rp_algorithmsuite_set_algosuite(algorithmsuite, env, algosuite_string);
if(AXIS2_FAILURE == status)
{
return NULL;
}
assertion = neethi_assertion_create_with_args(env,
(AXIS2_FREE_VOID_ARG)rp_algorithmsuite_free, algorithmsuite,
ASSERTION_TYPE_ALGORITHM_SUITE);
return assertion;
}
else
return NULL;
}
else
return NULL;
}
/** Find the most recent named node.
* @param env
* @param root_node
* @param local_name
* @param node_time return parameter, is set the time timePosition of the node.
* @return the most recent.
*/
axiom_node_t *sp_latest_named(
const axutil_env_t *env,
axiom_node_t *root_node,
const axis2_char_t *local_name,
time_t *node_time
)
{
axiom_node_t *ret_node = NULL;
axis2_char_t last_time[MAX_LAST_TIMELEN];
strcpy(last_time, "0");
axiom_children_iterator_t *chit =
axiom_children_iterator_create (env,
axiom_node_get_first_child(root_node, env));
if (NULL != chit)
{
axiom_node_t *curr_node = NULL;
while (axiom_children_iterator_has_next(chit, env))
{
curr_node = axiom_children_iterator_next(chit, env);
if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT)
{
axiom_element_t * el = (axiom_element_t *)
axiom_node_get_data_element (curr_node, env);
axis2_char_t *el_name = axiom_element_get_localname( el, env);
if ( 0 == strncasecmp(local_name, el_name, strlen(local_name)))
{
axiom_node_t *t_node =
rp_find_named_child(env, curr_node, "timePosition", 1);
const axis2_char_t *txt = sp_get_text_el(t_node, env);
if (strncmp(last_time, txt, strlen(last_time)) < 0)
{
if (strlen(txt) >= MAX_LAST_TIMELEN)
{
rp_log_error(env,
"*WARNING sp_util.c(%s %d):"
" timePosition text too long (%d)\n",
__FILE__, __LINE__, strlen(txt));
}
strncpy(last_time, txt, MAX_LAST_TIMELEN-1);
ret_node = curr_node;
}
}
} // if
} // while
axiom_children_iterator_free (chit, env);
}
*node_time = sp_parse_time_str(last_time);
return ret_node;
}
axutil_array_list_t* AXIS2_CALL
remote_registry_comment_load_from_feed(
const axutil_env_t *env,
axis2_char_t *buffer)
{
axiom_children_iterator_t *node_it = NULL;
axiom_node_t *feed_node = NULL;
axiom_element_t *feed_ele = NULL;
axutil_array_list_t *comment_list = NULL;
feed_node = axiom_node_create_from_buffer(env, buffer);
if(!feed_node)
{
return NULL;
}
comment_list = axutil_array_list_create(env, 10);
if(!comment_list)
{
return NULL;
}
feed_ele = axiom_node_get_data_element(feed_node, env);
node_it = axiom_element_get_children(feed_ele, env, feed_node);
/* iterate all the children */
while(axiom_children_iterator_has_next(node_it, env))
{
axiom_node_t *child = NULL;
axiom_element_t *child_ele = NULL;
axis2_char_t *local_name = NULL;
child = axiom_children_iterator_next(node_it, env);
if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT)
{
continue;
}
child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
local_name = axiom_element_get_localname(child_ele, env);
/* retriving the attribute one by one */
if(!axutil_strcmp(local_name, "entry"))
{
remote_registry_comment_t *comment = NULL;
comment = remote_registry_comment_create_from_entry_node(env, child);
axutil_array_list_add(comment_list, env, comment);
}
}
return comment_list;
}
static int
ngx_squ_xml_parse(squ_State *l)
{
char *name;
ngx_str_t xml;
axiom_node_t *node;
axutil_env_t *env;
axutil_log_t *log;
axutil_error_t *error;
axiom_element_t *elem;
axiom_document_t *doc;
ngx_squ_thread_t *thr;
axutil_allocator_t *a;
axiom_xml_reader_t *reader;
axiom_stax_builder_t *builder;
thr = ngx_squ_thread(l);
ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse");
xml.data = (u_char *) squL_checklstring(l, -1, &xml.len);
squ_createtable(l, 2, 2);
a = ngx_squ_axis2c_allocator_create(thr);
log = ngx_squ_axis2c_log_create(thr);
error = axutil_error_create(a);
env = axutil_env_create_with_error_log(a, error, log);
reader = axiom_xml_reader_create_for_memory(env, xml.data, xml.len, NULL,
AXIS2_XML_PARSER_TYPE_BUFFER);
builder = axiom_stax_builder_create(env, reader);
doc = axiom_stax_builder_get_document(builder, env);
node = axiom_document_get_root_element(doc, env);
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) {
return 1;
}
elem = axiom_node_get_data_element(node, env);
name = axiom_element_get_localname(elem, env);
squ_newtable(l);
ngx_squ_xml_parse_children(l, env, node, elem);
squ_setfield(l, -2, name);
return 1;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_layout_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_layout_t *layout = NULL;
axiom_node_t *child_node = NULL;
axiom_node_t *layout_node = NULL;
axiom_element_t *layout_element = NULL;
neethi_assertion_t *assertion = NULL;
layout = rp_layout_create(env);
child_node = axiom_node_get_first_element(node, env);
if(child_node)
{
layout_node = axiom_node_get_first_element(child_node, env);
if(!layout_node)
{
return NULL;
}
}
else
{
return NULL;
}
if(axiom_node_get_node_type(layout_node, env) == AXIOM_ELEMENT)
{
layout_element = (axiom_element_t *)axiom_node_get_data_element(layout_node, env);
if(layout_element)
{
axis2_char_t *local_name = NULL;
local_name = axiom_element_get_localname(layout_element, env);
if(!local_name)
return NULL;
rp_layout_set_value(layout, env, local_name);
assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_layout_free,
layout, ASSERTION_TYPE_LAYOUT);
return assertion;
}
else
return NULL;
}
else
return NULL;
}
/**
* Find the first child of 'root_node' with a matching 'local_name',
* non-recursive.
*
* @param env
* @param root_node
* @param local_name
* @param search_str
* @return the first matching child of 'root_node', or NULL if none found.
*/
axiom_node_t *rp_find_named_node_nr(
const axutil_env_t * env,
axiom_node_t *root_node,
const axis2_char_t *local_name,
const axis2_char_t *search_str)
{
axiom_node_t *found_node = NULL;
axiom_children_iterator_t *chit =
axiom_children_iterator_create (env, root_node);
if (NULL != chit)
{
axiom_node_t *curr_node = NULL;
while (axiom_children_iterator_has_next(chit, env))
{
curr_node = axiom_children_iterator_next(chit, env);
if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT)
{
axiom_element_t * el = (axiom_element_t *)
axiom_node_get_data_element (curr_node, env);
axis2_char_t *el_name = axiom_element_get_localname( el, env);
if ( 0 == strncasecmp( local_name, el_name, strlen(local_name) ) )
{
if ( search_str )
{
axis2_char_t *txt =
axiom_element_get_text (el, env, curr_node);
if ( 0 == strncmp(search_str, txt, strlen(search_str)))
{
found_node = curr_node;
break;
}
}
else
{
found_node = curr_node;
break;
}
}
} // if
} // while
axiom_children_iterator_free (chit, env);
}
return found_node;
}
AXIS2_EXTERN int AXIS2_CALL
remote_registry_util_get_ratings_from_feed(
const axutil_env_t *env,
axis2_char_t *feed)
{
axiom_node_t *entry_node;
axiom_children_iterator_t *entry_it = NULL;
axiom_element_t *entry_ele = NULL;
int rating = -1;
entry_node = axiom_node_create_from_buffer(env, feed);
if(!entry_node) {
return -1;
}
entry_ele = axiom_node_get_data_element(entry_node, env);
entry_it = axiom_element_get_children(entry_ele, env, entry_node);
while(axiom_children_iterator_has_next(entry_it, env))
{
axiom_node_t *child = NULL;
axiom_element_t *child_ele = NULL;
axis2_char_t *local_name = NULL;
child = axiom_children_iterator_next(entry_it, env);
if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT)
{
continue;
}
child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
local_name = axiom_element_get_localname(child_ele, env);
if(!axutil_strcmp(local_name, "AverageRating"))
{
axis2_char_t *rating_str = NULL;
rating_str = axiom_element_get_text(child_ele, env, child);
rating = atoi(rating_str);
break;
}
}
return rating;
}
AXIS2_EXTERN int AXIS2_CALL saml_subject_query_build(saml_subject_query_t* subject_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axiom_element_t *element = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node = NULL;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(subject_query->subject)
return saml_subject_build(subject_query->subject, child_node, env);
else
return AXIS2_FAILURE; /*subject query saml subject does not exist*/
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
axis2_char_t *
get_policy_ref(
axiom_node_t * node,
const axutil_env_t * env)
{
axiom_element_t *policy_element = NULL;
axiom_children_iterator_t *children_iter = NULL;
axiom_node_t *child_node = NULL;
axutil_qname_t *qname = NULL;
axis2_char_t *value = NULL;
axis2_char_t *val = NULL;
axiom_attribute_t *attr = NULL;
policy_element = (axiom_element_t *) axiom_node_get_data_element(node, env);
children_iter = axiom_element_get_children(policy_element, env, node);
while (axiom_children_iterator_has_next(children_iter, env))
{
child_node = axiom_children_iterator_next(children_iter, env);
if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
policy_element =
(axiom_element_t *) axiom_node_get_data_element(child_node,
env);
if (axutil_strcmp
(axiom_element_get_localname(policy_element, env),
"PolicyReference") == 0)
{
qname = axutil_qname_create(env, "URI", NULL, NULL);
attr = axiom_element_get_attribute(policy_element, env, qname);
if (attr)
{
value = axiom_attribute_get_value(attr, env);
val = axutil_string_substring_starting_at(value, 1);
return val;
}
}
}
}
return NULL;
}
/** Excecute 'func' on all immediate children of 'root_node' with 'local_name'.
* @param env
* @param root_node
* @param local_name
* @param func
* Takes 3 args: const axutil_env_t * env, axiom_node_t *node, void *arg3
* node is the ptr to the node matching 'local_name', arg3 is func_arg.
* The function should return zero if successful, non-zero otherwise.
* @param func_arg passed as the third arg to the function.
* @return the number of times func returned 0.
*/
int sp_func_at_nodes(
const axutil_env_t *env,
axiom_node_t *root_node,
const axis2_char_t *local_name,
int (* func)(const axutil_env_t * env, axiom_node_t *node, void *arg3),
void *func_arg
)
{
int num_executed = 0;
axiom_children_iterator_t *chit =
axiom_children_iterator_create (env, root_node);
if (NULL != chit)
{
axiom_node_t *curr_node = NULL;
while (axiom_children_iterator_has_next(chit, env))
{
curr_node = axiom_children_iterator_next(chit, env);
if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT)
{
axiom_element_t * el = (axiom_element_t *)
axiom_node_get_data_element (curr_node, env);
axis2_char_t *el_name = axiom_element_get_localname( el, env);
if ( 0 == strncasecmp(local_name, el_name, strlen(local_name)))
{
if (0 == func(env, curr_node, func_arg)) num_executed++;
}
} // if
} // while
axiom_children_iterator_free (chit, env);
}
return num_executed;
}
AXIS2_EXTERN int AXIS2_CALL saml_attr_query_build(saml_attr_query_t* attribute_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
saml_attr_desig_t *attr_desig = NULL;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
/*One resource attribute relate to the attibute query*/
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env),SAML_RESOURCE))
{
attribute_query->resource = attr_val;
break;
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(attribute_query->subject)
saml_subject_build(attribute_query->subject, child_node, env);
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_ATTRIBUTE_DESIGNATOR)))
{
/*attr_desig = saml_attr_desig_create(env);
*/
attr_desig = (saml_attr_desig_t*)AXIS2_MALLOC(env->allocator,
sizeof(saml_attr_desig_t));
if( AXIS2_SUCCESS == saml_attr_desig_build(attr_desig, child_node, env))
{
axutil_array_list_add(attribute_query->attr_desigs,env, attr_desig);
}
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
axis2_status_t AXIS2_CALL
adb_SnakeException_deserialize(
adb_SnakeException_t* _SnakeException,
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;
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, _SnakeException, 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 SnakeException : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* 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_SnakeException_set_message(_SnakeException, 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_SnakeException_set_message(_SnakeException, 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;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t
axis2_addr_in_extract_addr_params(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_info_headers_t ** msg_info_headers_p,
axutil_array_list_t * addr_headers,
const axis2_char_t * addr_ns_str,
axis2_msg_ctx_t * msg_ctx)
{
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p);
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t to_found = AXIS2_FALSE;
axis2_bool_t reply_to_found = AXIS2_FALSE;
axis2_bool_t fault_to_found = AXIS2_FALSE;
axis2_bool_t action_found = AXIS2_FALSE;
axis2_bool_t msg_id_found = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_info_headers_p, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_headers, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE);
if (!msg_info_headers)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No messgae info header. Creating new");
msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
if (!msg_info_headers)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MSG_INFO_HEADERS, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"No message information headers available");
return AXIS2_FAILURE;
}
}
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if (!header_block_ht)
{
return AXIS2_FAILURE;
}
/* Iterate thru header blocks */
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;
axiom_node_t *header_block_node = NULL;
axiom_element_t *header_block_ele = NULL;
axis2_char_t *ele_localname = NULL;
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *role = NULL;
axutil_hash_this(hash_index, NULL, NULL, &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);
ele_localname = axiom_element_get_localname(header_block_ele, env);
role = axiom_soap_header_block_get_role(header_block, env);
if (role && !axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NONE))
{
/* Role is none, no need of processing */
continue;
}
if (!axutil_strcmp(ele_localname, AXIS2_WSA_TO))
{
/* Here the addressing epr overidde what ever already there in the message context */
epr =
axis2_endpoint_ref_create(env,
axiom_element_get_text
(header_block_ele, env,
header_block_node));
if (AXIS2_TRUE == to_found)
{
/* Duplicate To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
axis2_msg_info_headers_set_to(msg_info_headers, env, epr);
axis2_addr_in_extract_to_epr_ref_params(env, epr, soap_header,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FROM))
{
epr = axis2_msg_info_headers_get_from(msg_info_headers, env);
if (!epr)
{
/* The address is not known now. Pass the empty
string and fill this once the element
under this is processed. */
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_from(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_REPLY_TO))
{
epr = axis2_msg_info_headers_get_reply_to(msg_info_headers, env);
if (reply_to_found == AXIS2_TRUE)
{
/* Duplicate Reply To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_REPLY_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
reply_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FAULT_TO))
{
epr = axis2_msg_info_headers_get_fault_to(msg_info_headers, env);
if (fault_to_found == AXIS2_TRUE)
{
/* Duplicate Fault To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_FAULT_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
axis2_msg_info_headers_set_fault_to(msg_info_headers, env,
NULL);
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_fault_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
fault_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_MESSAGE_ID))
{
axis2_char_t *text = NULL;
if (msg_id_found == AXIS2_TRUE)
{
/* Duplicate Message ID */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_MESSAGE_ID,
addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_in_message_id(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
msg_id_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_ACTION))
{
axis2_char_t *text = NULL;
if (action_found == AXIS2_TRUE)
{
/* Duplicate Action */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_action(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
action_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_RELATES_TO))
{
axis2_char_t *address = NULL;
axutil_qname_t *rqn = NULL;
axiom_attribute_t *relationship_type = NULL;
const axis2_char_t *relationship_type_default_value = NULL;
const axis2_char_t *relationship_type_value = NULL;
axis2_relates_to_t *relates_to = NULL;
if (!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns_str))
{
relationship_type_default_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_default_value =
AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
rqn =
axutil_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
NULL, NULL);
relationship_type =
axiom_element_get_attribute(header_block_ele, env, rqn);
if (!relationship_type)
{
relationship_type_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_value =
axiom_attribute_get_value(relationship_type, env);
}
address =
axiom_element_get_text(header_block_ele, env,
header_block_node);
relates_to =
axis2_relates_to_create(env, address, relationship_type_value);
axis2_msg_info_headers_set_relates_to(msg_info_headers, env,
relates_to);
axiom_soap_header_block_set_processed(header_block, env);
axutil_qname_free(rqn, env);
}
}
/* If an action is not found, it's a false*/
if (action_found == AXIS2_FALSE)
{
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
}
return status;
}
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_EXTERN axis2_status_t AXIS2_CALL
axiom_soap11_builder_helper_handle_event(
axiom_soap11_builder_helper_t * builder_helper,
const axutil_env_t * env,
axiom_node_t * om_element_node,
int element_level)
{
axiom_element_t *om_ele = NULL;
axis2_char_t *ele_localname = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
AXIS2_PARAM_CHECK(env->error, om_element_node, AXIS2_FAILURE);
om_ele = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env);
ele_localname = axiom_element_get_localname(om_ele, env);
if(!ele_localname)
{
return AXIS2_FAILURE;
}
soap_envelope = axiom_soap_builder_get_soap_envelope(builder_helper->soap_builder, env);
if(!soap_envelope)
{
return AXIS2_FAILURE;
}
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if(!soap_body)
{
return AXIS2_FAILURE;
}
soap_fault = axiom_soap_body_get_fault(soap_body, env);
if(!soap_fault)
{
return AXIS2_FAILURE;
}
if(element_level == 4)
{
axiom_soap_fault_code_t *fault_code = NULL;
axiom_soap_fault_value_t *fault_value = NULL;
axiom_node_t *fault_value_node = NULL;
axiom_element_t *fault_value_ele = NULL;
if(axutil_strcmp(ele_localname, AXIOM_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME) == 0)
{
axis2_status_t status = AXIS2_SUCCESS;
if(builder_helper->fault_string_present)
{
axiom_soap_builder_set_bool_processing_mandatory_fault_elements(
builder_helper->soap_builder, env, AXIS2_FALSE);
}
fault_code = axiom_soap_fault_code_create(env);
if(!fault_code)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_code_set_base_node(fault_code, env, om_element_node);
axiom_soap_fault_set_code(soap_fault, env, fault_code);
axiom_soap_fault_code_set_builder(fault_code, env, builder_helper->soap_builder);
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
fault_value = axiom_soap_fault_value_create_with_code(env, fault_code);
if(!fault_value)
{
return AXIS2_FAILURE;
}
fault_value_node = axiom_soap_fault_value_get_base_node(fault_value, env);
if(!fault_value_node)
{
return AXIS2_FAILURE;
}
fault_value_ele = (axiom_element_t *)axiom_node_get_data_element(fault_value_node, env);
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_value_node);
status = axiom_soap11_builder_helper_process_text(builder_helper, env);
if(status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node);
axiom_node_set_complete(om_element_node, env, AXIS2_TRUE);
axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level
- 1));
builder_helper->fault_code_present = AXIS2_TRUE;
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_reason_t *fault_reason = NULL;
axiom_soap_fault_text_t *fault_text = NULL;
axiom_node_t *fault_text_node = NULL;
int status = AXIS2_SUCCESS;
if(builder_helper->fault_code_present)
{
axiom_soap_builder_set_bool_processing_mandatory_fault_elements(
builder_helper->soap_builder, env, AXIS2_FALSE);
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
fault_reason = axiom_soap_fault_reason_create(env);
if(!fault_reason)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_reason_set_base_node(fault_reason, env, om_element_node);
axiom_soap_fault_set_reason(soap_fault, env, fault_reason);
fault_text = axiom_soap_fault_text_create_with_parent(env, fault_reason);
if(!fault_text)
{
return AXIS2_FAILURE;
}
fault_text_node = axiom_soap_fault_text_get_base_node(fault_text, env);
if(!fault_text_node)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_text_node);
status = axiom_soap11_builder_helper_process_text(builder_helper, env);
if(status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node);
axiom_node_set_complete(om_element_node, env, AXIS2_TRUE);
axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level
- 1));
builder_helper->fault_string_present = AXIS2_TRUE;
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_role_t *fault_role = NULL;
fault_role = axiom_soap_fault_role_create(env);
if(!fault_role)
{
return AXIS2_FAILURE;
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
axiom_soap_fault_role_set_base_node(fault_role, env, om_element_node);
axiom_soap_fault_set_role(soap_fault, env, fault_role);
/*
Role element may not have a namespace associated, hence commented, else it segfaults here - Samisa
status = axiom_soap_builder_process_namespace_data(
builder_helper->soap_builder, env, om_element_node, AXIS2_TRUE);
if(status == AXIS2_FAILURE)
return AXIS2_FAILURE; */
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_detail_t *fault_detail = NULL;
fault_detail = axiom_soap_fault_detail_create(env);
if(!fault_detail)
{
return AXIS2_FAILURE;
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
axiom_soap_fault_detail_set_base_node(fault_detail, env, om_element_node);
axiom_soap_fault_set_detail(soap_fault, env, fault_detail);
}
else
{
return AXIS2_SUCCESS;
}
}
else if(element_level == 5)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *parent_localname = NULL;
parent_node = axiom_node_get_parent(om_element_node, env);
if(!parent_node)
{
return AXIS2_FAILURE;
}
parent_element = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env);
parent_localname = axiom_element_get_localname(parent_element, env);
if(!parent_localname)
{
return AXIS2_FAILURE;
}
if(axutil_strcmp(parent_localname, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME) == 0)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP11_FAULT_ACTOR_SHOULD_NOT_HAVE_CHILD_ELEMENTS, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "SOAP 1.1 Actor should not have child elements");
return AXIS2_FAILURE;
}
}
return AXIS2_SUCCESS;
}
int
main(
int argc,
char **argv)
{
axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
axiom_element_t *ret_ele = NULL;
axis2_char_t *om_str = NULL;
axis2_char_t *result = NULL;
const axis2_char_t *echo_operation = NULL;
const axis2_char_t *word_to_echo = NULL;
const axis2_char_t *echo_type = NULL;
axis2_char_t operation[32];
axis2_char_t echo_response_buff[32];
echo_operation = "String";
word_to_echo = "helloworld";
echo_type = "string";
if ((argc > 1) && (axutil_strcmp("-h", argv[1]) == 0))
{
printf("\nUsage : %s [echo_operation] [echo_value] [XSD_type]\n",
argv[0]);
printf("use -h for help\n");
return 0;
}
if (argc > 1)
echo_operation = argv[1];
if (argc > 2)
word_to_echo = argv[2];
if (argc > 3)
echo_type = argv[3];
/* address = "http://localhost:7070/cgi-bin/interopserver"; */
address = "http://easysoap.sourceforge.net/cgi-bin/interopserver";
sprintf(operation, "echo%s", echo_operation);
printf("Using endpoint : %s\n", address);
printf("Invoking %s with param %s\n", operation, word_to_echo);
/* Set up the environment */
env = axutil_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE);
/* Create EPR with given address */
endpoint_ref = axis2_endpoint_ref_create(env, address);
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
/* this itest requried soap 1.1 message */
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home)
client_home = "../../deploy";
/* Create service client */
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf("Error creating service client\n");
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
axutil_error_get_message(env->error));
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
payload = build_soap_body_content(env, echo_operation,
echo_type, word_to_echo);
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (ret_node)
{
om_str = AXIOM_NODE_TO_STRING(ret_node, env);
if (om_str)
printf("\nRecieving OM : %s\n", om_str);
if (AXIOM_NODE_GET_NODE_TYPE(ret_node, env) == AXIOM_ELEMENT)
{
sprintf(echo_response_buff, "echo%sResponse", echo_operation);
ret_ele =
(axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env);
if (axutil_strcmp
(axiom_element_get_localname(ret_ele, env),
echo_response_buff) != 0)
{
printf("%s != %s\n", axiom_element_get_localname(ret_ele, env),
echo_response_buff);
printf("\nFAIL\n\n");
return AXIS2_FAILURE;
}
ret_node = AXIOM_NODE_GET_FIRST_CHILD(ret_node, env);
ret_ele =
(axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env);
result = axiom_element_get_text(ret_ele, env, ret_node);
if (!strcmp(word_to_echo, result))
{
printf("\nSUCCESS\n\n");
}
else
{
printf("\nFAIL\n\n");
}
}
else
{
printf("\nFAIL\n\n");
return AXIS2_FAILURE;
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
axutil_error_get_message(env->error));
printf("round1 stub invoke FAILED!\n");
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
/**
* Builts EncryptedParts or SignedParts assertion
* @param env Pointer to environment struct
* @param node Assertion node
* @param element Assertion element
* @param is_signed boolean showing whether signing or encryption
* @returns neethi assertion created. NULL if failure.
*/
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_signed_encrypted_parts_builder_build(
const axutil_env_t *env,
axiom_node_t *parts,
axiom_element_t *parts_ele,
axis2_bool_t is_signed)
{
rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
axiom_children_iterator_t *children_iter = NULL;
neethi_assertion_t *assertion = NULL;
axis2_status_t status = AXIS2_SUCCESS;
signed_encrypted_parts = rp_signed_encrypted_parts_create(env);
if (!signed_encrypted_parts)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot create signed_encrypted_parts.");
return NULL;
}
rp_signed_encrypted_parts_set_signedparts(signed_encrypted_parts, env, is_signed);
children_iter = axiom_element_get_children(parts_ele, env, parts);
if (children_iter)
{
while (axiom_children_iterator_has_next(children_iter, env))
{
axiom_node_t *node = NULL;
axiom_element_t *ele = NULL;
axis2_char_t *local_name = NULL;
node = axiom_children_iterator_next(children_iter, env);
if (node)
{
if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
ele = (axiom_element_t *) axiom_node_get_data_element(node, env);
if (ele)
{
local_name = axiom_element_get_localname(ele, env);
if (local_name)
{
status = rp_signed_encrypted_parts_builder_set_properties
(node, ele, local_name, signed_encrypted_parts, env);
if (status != AXIS2_SUCCESS)
{
rp_signed_encrypted_parts_free (signed_encrypted_parts, env);
signed_encrypted_parts = NULL;
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot create signed_encrypted_parts. "
"Error in processing child element %s", local_name);
return NULL;
}
}
}
}
}
}
}
assertion = neethi_assertion_create_with_args(
env, (AXIS2_FREE_VOID_ARG)rp_signed_encrypted_parts_free,
signed_encrypted_parts, ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS);
return assertion;
}
AXIS2_EXTERN int AXIS2_CALL saml_authentication_query_build(saml_authentication_query_t* authentication_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
if(attr_hash)
{
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_AUTHENTICATION_METHOD))
{
authentication_query->auth_method = attr_val;
break;
}
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(authentication_query->subject)
return saml_subject_build(authentication_query->subject, child_node, env);
else
return AXIS2_FAILURE;
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
static axis2_status_t AXIS2_CALL
axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axis2_msg_ctx_t * new_msg_ctx)
{
axis2_svc_skeleton_t *svc_obj = NULL;
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
const axis2_char_t *style = NULL;
axiom_node_t *om_node = NULL;
axiom_element_t *om_element = NULL;
axis2_char_t *local_name = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *body_content_node = NULL;
axiom_element_t *body_content_element = NULL;
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axiom_node_t *out_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
int soap_version = AXIOM_SOAP12;
axiom_namespace_t *env_ns = NULL;
axiom_node_t *fault_node = NULL;
axiom_soap_fault_detail_t *fault_detail;
axis2_bool_t is_fault = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
/* get the implementation class for the Web Service */
svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx);
if(!svc_obj)
{
const axis2_char_t *svc_name = NULL;
axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
else
{
svc_name = "unknown";
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Impl object for service '%s' not set in message receiver. %d :: %s", svc_name,
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
{
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
om_node = axiom_soap_body_get_base_node(body, env);
om_element = axiom_node_get_data_element(om_node, env);
om_node = axiom_node_get_first_element(om_node, env);
}
else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
op_node = axiom_soap_body_get_base_node(body, env);
op_element = axiom_node_get_data_element(op_node, env);
if(op_element)
{
local_name = axiom_element_get_localname(op_element, env);
if(local_name)
{
axutil_array_list_t *function_arr = NULL;
int i = 0;
int size = 0;
axis2_bool_t matches = AXIS2_FALSE;
function_arr = svc_obj->func_array;
if(function_arr)
{
size = axutil_array_list_size(function_arr, env);
}
for(i = 0; i < size; i++)
{
axis2_char_t *function_name = NULL;
function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i);
if(!axutil_strcmp(function_name, local_name))
{
matches = AXIS2_TRUE;
}
}
if(matches)
{
om_node = axiom_node_get_first_child(op_node, env);
om_element = axiom_node_get_data_element(om_node, env);
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
if(status == AXIS2_SUCCESS)
{
skel_invoked = AXIS2_TRUE;
result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
}
if(result_node)
{
if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *res_name = NULL;
res_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if(!ns)
{
status = AXIS2_FAILURE;
}
else
{
body_content_element = axiom_element_create(env, NULL, res_name, ns,
&body_content_node);
axiom_node_add_child(body_content_node, env, result_node);
}
}
else
{
body_content_node = result_node;
}
}
else
{
axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env);
if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep,
AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
}
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
else
{
/* If we have a in only message result node is NULL. We create fault only if
* an error is set
*/
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) ||
(!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)))
{
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
}
}
}
}
if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
{
/* service implementation has set the envelope,
useful when setting a SOAP fault.
No need to further process */
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, "soapenv");
if(!env_ns)
{
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
axiom_namespace_free(env_ns, env);
if(!default_envelope)
{
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if(!out_header)
{
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if(!out_body)
{
return AXIS2_FAILURE;
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if(!out_node)
{
return AXIS2_FAILURE;
}
if(status != AXIS2_SUCCESS || is_fault)
{
/* something went wrong. set a SOAP Fault */
const axis2_char_t *fault_value_str = "soapenv:Sender";
const axis2_char_t *fault_reason_str = NULL;
const axis2_char_t *err_msg = NULL;
if(!skel_invoked)
{
if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP11_FAULT_CODE_RECEIVER;
}
else
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
}
}
err_msg = AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg && axutil_strcmp(err_msg, ""))
{
if(!axutil_strcmp(err_msg, "No Error"))
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
else
{
fault_reason_str = err_msg;
}
}
else
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str,
fault_reason_str, soap_version);
if (fault_node)
{
axiom_node_t *fault_detail_node = NULL;
axis2_char_t *om_str = NULL;
fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault);
fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env);
om_str = axiom_node_to_string(fault_detail_node, env);
if (om_str)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node);
}
}
if (body_content_node)
{
axiom_node_add_child(out_node, env, body_content_node);
status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
}
else if (soap_fault)
{
axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
status = AXIS2_SUCCESS;
}
else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
return status;
}
/**
* Traverse thru the node and its children. Check if the element has the
* given qname and has a id attribute equal to the given value.
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param e_name element name
* @param e_ns element namespace. If NULL doesn't consider the namespaces
* @param attr_name the attribute name of the node
* @param attr_val the attribute value of the node
* @param attr_ns the attribute namespace. If NULL doesn't consider namespaces.
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_axiom_get_first_node_by_name_and_attr_val(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *e_name,
axis2_char_t *e_ns,
axis2_char_t *attr_name,
axis2_char_t *attr_val,
axis2_char_t *attr_ns)
{
axis2_char_t *attribute_value = NULL;
axis2_char_t *localname = NULL;
axiom_namespace_t *nmsp = NULL;
axiom_element_t *element = NULL;
axis2_bool_t element_match = AXIS2_FALSE;
axiom_node_t *temp_node = NULL;
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return NULL;
}
element = axiom_node_get_data_element(node, env);
localname = axiom_element_get_localname(element, env);
if(localname && !axutil_strcmp(localname, e_name))
{
element_match = AXIS2_TRUE;
if(e_ns)
{
nmsp = axiom_element_get_namespace(element, env, node);
if(nmsp)
{
axis2_char_t *namespacea = NULL;
namespacea = axiom_namespace_get_uri(nmsp, env);
if(axutil_strcmp(e_ns, namespacea))
{
element_match = AXIS2_FALSE;
}
}
}
/* element is ok. So, we have to check the attribute value */
if(element_match)
{
if(attr_ns)
{
axiom_attribute_t *attr = NULL;
axutil_qname_t *qname = axutil_qname_create(env, attr_name, attr_ns, NULL);
attr = axiom_element_get_attribute(element, env, qname);
if(attr)
{
attribute_value = axiom_attribute_get_value(attr, env);
}
axutil_qname_free(qname, env);
}
else
{
attribute_value = axiom_element_get_attribute_value_by_name(
element, env, attr_name);
}
}
if (attribute_value && !axutil_strcmp(attribute_value, attr_val))
{
return node;
}
}
/* Doesn't match? Get the children and search */
temp_node = axiom_node_get_first_element(node, env);
while (temp_node)
{
axiom_node_t *res_node = NULL;
res_node = oxs_axiom_get_first_node_by_name_and_attr_val(
env, temp_node, e_name, e_ns, attr_name, attr_val, attr_ns);
if (res_node)
{
return res_node;
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
return NULL;
}
AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL
remote_registry_util_get_tags_from_feed(
const axutil_env_t *env,
axis2_char_t *feed)
{
axiom_node_t *entry_node = NULL;
axiom_children_iterator_t *entry_it = NULL;
axiom_element_t *entry_ele = NULL;
axutil_array_list_t *tags = NULL;
entry_node = axiom_node_create_from_buffer(env, feed);
if(!entry_node) {
return NULL;
}
entry_ele = axiom_node_get_data_element(entry_node, env);
entry_it = axiom_element_get_children(entry_ele, env, entry_node);
while(axiom_children_iterator_has_next(entry_it, env))
{
axiom_node_t *child = NULL;
axiom_element_t *child_ele = NULL;
axis2_char_t *local_name = NULL;
child = axiom_children_iterator_next(entry_it, env);
if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT)
{
continue;
}
child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
local_name = axiom_element_get_localname(child_ele, env);
if(!axutil_strcmp(local_name, "entry"))
{
axiom_children_iterator_t *entry_child_it = NULL;
axis2_char_t *is_tagging = NULL;
entry_child_it = axiom_element_get_children(entry_ele, env, entry_node);
while(axiom_children_iterator_has_next(entry_child_it, env))
{
axiom_element_t *entry_child_ele = NULL;
axiom_node_t *entry_child = NULL;
entry_child = axiom_children_iterator_next(entry_child_it, env);
if(axiom_node_get_node_type(entry_child, env) != AXIOM_ELEMENT)
{
continue;
}
entry_child_ele = (axiom_element_t*)axiom_node_get_data_element(entry_child, env);
local_name = axiom_element_get_localname(entry_child_ele, env);
if(!axutil_strcmp(local_name, "taggings"))
{
is_tagging = axiom_element_get_text(entry_child_ele, env, entry_child);
}
}
if(!axutil_strcmp("1", is_tagging))
{
axiom_children_iterator_reset(entry_child_it, env);
while(axiom_children_iterator_has_next(entry_child_it, env))
{
axiom_element_t *entry_child_ele = NULL;
axiom_node_t *entry_child = NULL;
entry_child = axiom_children_iterator_next(entry_child_it, env);
if(axiom_node_get_node_type(entry_child, env) != AXIOM_ELEMENT)
{
continue;
}
entry_child_ele = (axiom_element_t*)axiom_node_get_data_element(entry_child, env);
local_name = axiom_element_get_localname(entry_child_ele, env);
if(!axutil_strcmp(local_name, "title"))
{
axis2_char_t *tag_name = NULL;
tag_name = axiom_element_get_text(entry_child_ele, env, entry_child);
axutil_array_list_add(tags, env, tag_name);
}
}
}
}
}
return tags;
}
AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_build(saml_autho_decision_query_t* autho_decision_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
saml_action_t *action;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RESOURCE))
{
if(autho_decision_query->resource)
{
autho_decision_query->resource = attr_val;
break;
}
else
return AXIS2_FAILURE;
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(autho_decision_query->subject)
saml_subject_build(autho_decision_query->subject, child_node, env);
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_ACTION)))
{
if(autho_decision_query->saml_actions)
{
action = saml_action_create(env);
saml_action_build(action, child_node, env);
axutil_array_list_add(autho_decision_query->saml_actions, env, action);
}
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_EVIDENCE)))
{
if(autho_decision_query->evidence)
saml_evidence_build(autho_decision_query->evidence, child_node, env);
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
axis2_status_t AXIS2_CALL
adb_createReservationResponse_deserialize(
adb_createReservationResponse_t* _createReservationResponse,
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, _createReservationResponse, 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 createReservationResponse : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building ReservationStatus 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, "ReservationStatus", NULL, NULL);
if (adb_ReservationStatus_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("ReservationStatus", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("ReservationStatus", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)adb_ReservationStatus_create(env);
status = adb_ReservationStatus_deserialize((adb_ReservationStatus_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 ReservationStatus");
}
else
{
status = adb_createReservationResponse_set_ReservationStatus(_createReservationResponse, env,
(adb_ReservationStatus_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for ReservationStatus ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_deserialize_obj(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
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;
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, _CanonicalizationMethodType, 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 CanonicalizationMethodType : "
"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 extraElement array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building extraElement element
*/
/* 'any' arrays are not handling correctly when there are other elements mixed with the 'any' element. */
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;
}
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("extraElement", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for extraElement ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_CanonicalizationMethodType_set_extraElement(_CanonicalizationMethodType, env,
arr_list);
}
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, "Algorithm"))
{
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 "Algorithm", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "Algorithm");
}
if(attrib_text != NULL)
{
adb_CanonicalizationMethodType_set_Algorithm(_CanonicalizationMethodType,
env, axutil_uri_parse_string(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 Algorithm missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
wsf_xml_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * in_msg_ctx,
axis2_msg_ctx_t * out_msg_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
axiom_namespace_t *env_ns = NULL;
int soap_version = AXIOM_SOAP12;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *style = NULL;
axis2_char_t *local_name = NULL;
axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
axis2_char_t *operation_name = NULL;
char *classname = NULL;
axutil_property_t *svc_info_prop = NULL;
axutil_property_t *req_info_prop = NULL;
wsf_svc_info_t *svc_info = NULL;
wsf_request_info_t *req_info = NULL;
/** store in_msg_ctx envelope */
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *in_body_node = NULL;
/* store out_msg_ctx envelope */
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *out_soap_fault = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *out_body_content_node = NULL;
axiom_element_t *out_body_content_element = NULL;
axiom_node_t *out_node = NULL;
zval **output_headers_zval = NULL;
TSRMLS_FETCH();
AXIS2_PARAM_CHECK(env->error, in_msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, out_msg_ctx, AXIS2_FAILURE);
op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
envelope = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
in_body_node = axiom_soap_body_get_base_node(body, env);
if (0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
local_name = wsf_xml_msg_recv_get_method_name(in_msg_ctx, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
} else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
op_node = axiom_node_get_first_child(in_body_node, env);
if (!op_node)
{
return AXIS2_FAILURE;
}
op_element = axiom_node_get_data_element(op_node, env);
if (!op_element)
{
return AXIS2_FAILURE;
}
local_name = axiom_element_get_localname(op_element, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
}
/** set soap version and soap namespace to local variables */
if (in_msg_ctx && axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
svc_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_SVC_INFO);
if (svc_info_prop)
{
svc_info = (wsf_svc_info_t *) axutil_property_get_value(svc_info_prop, env);
if (svc_info)
{
operation_name = axutil_hash_get(svc_info->ops_to_functions, local_name,
AXIS2_HASH_KEY_STRING);
if (!operation_name)
{
return AXIS2_FAILURE;
}
} else
{
return AXIS2_FAILURE;
}
if (svc_info->ops_to_classes)
{
classname = axutil_hash_get(svc_info->ops_to_classes, local_name, AXIS2_HASH_KEY_STRING);
}
}
req_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_REQ_INFO);
if (req_info_prop)
{
req_info = (wsf_request_info_t *) axutil_property_get_value(req_info_prop, env);
if (axis2_msg_ctx_get_doing_rest(in_msg_ctx, env))
{
axis2_op_t *op = NULL;
axiom_node_t *body_child_node = NULL;
axiom_element_t *body_child = NULL;
int i = 0;
body_child_node = axiom_node_get_first_child(in_body_node, env);
if (!body_child_node)
{
op = axis2_msg_ctx_get_op(in_msg_ctx, env);
if (op)
{
body_child = axiom_element_create_with_qname(env, NULL,
axis2_op_get_qname(op, env), &body_child_node);
axiom_soap_body_add_child(body, env, body_child_node);
}
}
if (req_info->param_keys && req_info->param_values)
{
int i = 0;
for (i = 0; i < axutil_array_list_size(req_info->param_keys, env); i++)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
axis2_char_t *param_key = NULL;
axis2_char_t *param_value = NULL;
param_key = axutil_array_list_get(req_info->param_keys, env, i);
param_value = axutil_array_list_get(req_info->param_values, env, i);
element = axiom_element_create(env, NULL, param_key,
NULL, &node);
axiom_element_set_text(element, env, param_value, node);
axiom_node_add_child(body_child_node, env, node);
AXIS2_FREE(env->allocator, param_key);
AXIS2_FREE(env->allocator, param_value);
}
axutil_array_list_free(req_info->param_keys, env);
axutil_array_list_free(req_info->param_values, env);
}
}
}
if (svc_info->ht_op_params)
{
zval **tmp;
char *function_type = NULL;
if (zend_hash_find(svc_info->ht_op_params,
operation_name, strlen(operation_name) + 1,
(void **) & tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING)
{
function_type = Z_STRVAL_PP(tmp);
if (strcmp(function_type, WSF_MIXED) == 0)
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
} else if (strcmp(function_type, WSF_WSMESSAGE) == 0)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
}
}
} else
{
/* this is where the default value for opParam is set,
If the wsdl option is set go for the MIXED mode by default */
if (svc_info->wsdl == NULL || svc_info->omit_wsdl)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
} else
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
}
}
if (!result_node)
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
} else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "Response node is not null");
}
if (result_node)
{
if (0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *response_name = NULL;
response_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if (!ns)
{
return AXIS2_FAILURE;
}
out_body_content_element = axiom_element_create(env, NULL, response_name,
ns, &out_body_content_node);
axiom_node_add_child(out_body_content_node, env, result_node);
} else
{
out_body_content_node = result_node;
}
}
if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env))
{
/* service implementation has set the envelope, useful when setting a SOAP fault.
No need to further process */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "soap fault is set");
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
if (!env_ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] error seting the namespces for the "
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
if (!default_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap envelope");
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if (!out_body)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in creating the response soap body");
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if (!out_header)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap headers");
return AXIS2_FAILURE;
}
if (output_headers_zval)
{
axiom_node_t *header_base_node = NULL;
HashPosition pos;
zval **param;
char *header_str;
axiom_node_t *header_node;
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(output_headers_zval), &pos);
zend_hash_get_current_data_ex(Z_ARRVAL_PP(output_headers_zval),
(void **) & param, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_PP(output_headers_zval), &pos))
{
if (Z_TYPE_PP(param) == IS_STRING)
{
header_base_node = axiom_soap_header_get_base_node(out_header, env);
if (header_base_node)
{
header_str = Z_STRVAL_PP(param);
header_node = wsf_util_deserialize_buffer(env, header_str);
axiom_node_add_child(header_base_node, env, header_node);
} else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap headers node");
return AXIS2_FAILURE;
}
}
}
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if (!out_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap body node");
return AXIS2_FAILURE;
}
if (status != AXIS2_SUCCESS)
{
/* something went wrong, set a SOAP Fault */
axis2_char_t *fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER;
axis2_char_t *fault_reason_str = NULL;
axis2_char_t *err_msg = NULL;
if (!skel_invoked)
fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
;
err_msg = (char *) AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg)
{
fault_reason_str = err_msg;
} else
{
fault_reason_str = "Error occurred while processing SOAP message";
}
out_soap_fault = axiom_soap_fault_create_default_fault(env, out_body,
fault_value_str, fault_reason_str, soap_version);
}
if (out_body_content_node)
{
axiom_node_add_child(out_node, env, out_body_content_node);
status = axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env,
default_envelope);
} else if (out_soap_fault)
{
axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope);
status = AXIS2_FAILURE; /* if there is a failure we have to return a failure code */
} else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
return AXIS2_SUCCESS;
}
int
main(
int argc,
char **argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *google_key = NULL;
const axis2_char_t *word_to_spell = NULL;
const axis2_char_t *operation = NULL;
operation = "doSpellingSuggestion";
google_key = "00000000000000000000000000000000";
word_to_spell = "salvasion";
/* Set up the environment */
env = axutil_env_create_all("google_client.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of google service */
address = "http://api.google.com/search/beta2";
if ((argc > 1) && (axutil_strcmp("-h", argv[1]) == 0))
{
printf("\nUsage : %s [google_key] [word_to_spell] \n", argv[0]);
printf
("\tgoogle_key Your Google license key. Default value won't work. You must use your key here.\n");
printf
("\tword_to_spell Word to be spelled by Google service. Default is %s\n",
word_to_spell);
printf
("NOTE: command line arguments must appear in given order, with trailing ones being optional\n");
printf("\tUse -h for help\n");
return 0;
}
if (argc > 1)
google_key = argv[1];
if (argc > 2)
word_to_spell = argv[2];
if (argc > 3)
address = argv[3];
printf("Using endpoint : %s\n", address);
printf("\nInvoking operation %s with params %s and %s\n", operation,
google_key, word_to_spell);
/* Create EPR with given address */
endpoint_ref = axis2_endpoint_ref_create(env, address);
/* Setup options */
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
/* Set up deploy folder. */
client_home = AXIS2_GETENV("WSFC_HOME");
if (!client_home || !strcmp(client_home, ""))
client_home = "../..";
/* Create service client */
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf
("Error creating service client, Please check WSFC_HOME again\n");
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return -1;
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
/* Build the SOAP request message payload using OM API. */
payload =
build_soap_body_content(env, operation, google_key, word_to_spell);
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (axis2_svc_client_get_last_response_has_fault(svc_client, env))
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axis2_char_t *fault_string = NULL;
printf("\nResponse has a SOAP fault\n");
soap_envelope =
axis2_svc_client_get_last_response_soap_envelope(svc_client, env);
if (soap_envelope)
{
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
}
if (soap_body)
{
soap_fault = axiom_soap_body_get_fault(soap_body, env);
}
if (soap_fault)
{
fault_string = axiom_node_to_string(axiom_soap_fault_get_base_node
(soap_fault, env), env);
printf("\nReturned SOAP fault: %s\n", fault_string);
AXIS2_FREE (env->allocator, fault_string);
}
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return -1;
}
if (ret_node)
{
if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT)
{
axis2_char_t *result = NULL;
axiom_element_t *result_ele = NULL;
axiom_node_t *ret_node1 = NULL;
result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node, env);
if (axutil_strcmp
(axiom_element_get_localname(result_ele, env),
"doSpellingSuggestionResponse") != 0)
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
ret_node1 = axiom_node_get_first_element(ret_node, env); /*return */
if (!ret_node1)
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node1, env);
result = axiom_element_get_text(result_ele, env, ret_node1);
printf("\nResult = %s\n", result);
}
else
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("Google client invoke FAILED!\n");
}
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return 0;
}
axis2_status_t AXIS2_CALL
adb_getReservationStatusesResponse_deserialize(
adb_getReservationStatusesResponse_t* _getReservationStatusesResponse,
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;
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, _getReservationStatusesResponse, 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 getReservationStatusesResponse : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building reservationStatuses array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building reservationStatuses element
*/
element_qname = axutil_qname_create(env, "reservationStatuses", NULL, 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 (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("reservationStatuses", axiom_element_get_localname(current_element, env)))
{
is_early_node_valid = AXIS2_TRUE;
element = (void*)adb_ReservationStatus_create(env);
status = adb_ReservationStatus_deserialize((adb_ReservationStatus_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 element reservationStatuses ");
}
else
{
axutil_array_list_add_at(arr_list, env, i, element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for reservationStatuses ");
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 < 0)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "reservationStatuses (@minOccurs = '0') 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_getReservationStatusesResponse_set_reservationStatuses(_getReservationStatusesResponse, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_subscriberRequest_deserialize_obj(
adb_subscriberRequest_t* _subscriberRequest,
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, _subscriberRequest, 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 subscriberRequest : "
"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, _subscriberRequest-> 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 subscriberRequest : "
"Expected %s but returned %s",
axutil_qname_to_string(_subscriberRequest-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building number 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, "number", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("number", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("number", 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_subscriberRequest_set_number(_subscriberRequest, env,
atoi(text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element number");
status = AXIS2_FAILURE;
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for number ");
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 number missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
void wsf_util_pack_attachments (
axutil_env_t *env,
axiom_node_t *node,
VALUE attach_ht,
int enable_mtom,
char *default_cnt_type)
{
axiom_element_t *node_element = NULL;
axiom_element_t *child_element = NULL;
axiom_child_element_iterator_t *child_element_ite = NULL;
axiom_node_t *child_node = NULL;
int attachment_done = 0;
axis2_char_t *element_localname = NULL;
axiom_namespace_t *element_namespace = NULL;
axis2_char_t *namespace_uri = NULL;
if (!node)
return;
if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
node_element = axiom_node_get_data_element(node, env);
if (node_element)
{
child_element_ite = axiom_element_get_child_elements(node_element, env, node);
if (child_element_ite)
{
child_node = axiom_child_element_iterator_next(child_element_ite, env);
attachment_done = 0;
while (child_node && !attachment_done)
{
child_element = axiom_node_get_data_element(child_node, env);
element_localname = axiom_element_get_localname(child_element, env);
if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0))
{
element_namespace = axiom_element_get_namespace(child_element, env, child_node);
if (element_namespace)
{
namespace_uri = axiom_namespace_get_uri(element_namespace, env);
if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0))
{
axis2_char_t *cnt_type = NULL;
axis2_char_t *content_type = NULL;
axis2_char_t *href = NULL;
axis2_char_t* pos = NULL;
cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE);
content_type = !cnt_type ? default_cnt_type : cnt_type;
href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF);
if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:")))
{
axis2_char_t* cid = NULL;
VALUE content_tmp;
void* content = NULL;
unsigned int content_length = 0;
cid = href + 4;
content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid));
content_length = RSTRING(content_tmp)->len;
content = malloc(sizeof (char) * content_length);
memcpy (content, (const void*)STR2CSTR(content_tmp), content_length);
if (content)
{
void *data_buffer = NULL;
axiom_data_handler_t *data_handler = NULL;
axiom_node_t *text_node = NULL;
axiom_text_t *text = NULL;
data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length);
if (data_buffer)
{
memcpy (data_buffer, content, content_length);
data_handler = axiom_data_handler_create (env, NULL, content_type);
if (data_handler)
{
axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length);
text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node);
if (enable_mtom == AXIS2_FALSE)
axiom_text_set_optimize (text, env, AXIS2_FALSE);
axiom_node_detach (child_node, env);
}
}
attachment_done = 1;
}
}
}
}
}
child_node = axiom_child_element_iterator_next(child_element_ite, env);
}
}
}
}
// Process child nodes
child_node = axiom_node_get_first_child(node, env);
while (child_node)
{
wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type);
child_node = axiom_node_get_next_sibling(child_node, env);
}
}