/**
* @param el_node of type AXIOM_ELEMENT
* @param env
* @return text contents of el_node
*/
const axis2_char_t *sp_get_text_el(
axiom_node_t *el_node,
const axutil_env_t *env)
{
axiom_node_t *val_node = NULL;
const axis2_char_t *ret_val = NULL;
if (el_node &&
axiom_node_get_node_type(el_node, env) == AXIOM_ELEMENT)
{
val_node = axiom_node_get_first_child(el_node, env);
if (val_node &&
axiom_node_get_node_type(val_node, env) == AXIOM_TEXT)
{
axiom_text_t *val_text = NULL;
val_text = (axiom_text_t *)
axiom_node_get_data_element(val_node, env);
if (val_text)
{
ret_val = axiom_text_get_value(val_text, env);
}
}
}
return ret_val;
}
/*
* 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_status_t AXIS2_CALL
load_policy_array(
axutil_array_list_t * arraylist,
axiom_node_t * root,
const axutil_env_t * env)
{
axiom_element_t *root_ele = NULL;
if (root)
{
if (axiom_node_get_node_type(root, env) == AXIOM_ELEMENT)
{
root_ele =
(axiom_element_t *) axiom_node_get_data_element(root, env);
if (root_ele)
{
neethi_policy_t *neethi_policy = NULL;
neethi_policy = neethi_engine_get_policy(env, root, root_ele);
if (!neethi_policy)
{
printf("Policy Creation fails\n");
return AXIS2_FAILURE;
}
axutil_array_list_add(arraylist, env, neethi_policy);
}
}
}
return AXIS2_SUCCESS;
}
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;
}
void
axis2_test_svc_client_blocking(
)
{
axutil_env_t *env = 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 *address = NULL;
axis2_endpoint_ref_t *endpoint_ref = NULL;
axutil_allocator_t *allocator = axutil_allocator_init(NULL);
axiom_element_t *result_ele = NULL;
const axis2_char_t *echo_text = "echo_text";
axis2_char_t *result = NULL;
env = axutil_env_create(allocator);
address = "http://localhost:9090/axis2/services/echo/echo";
endpoint_ref = axis2_endpoint_ref_create(env, address);
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home)
client_home = "../../deploy";
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf("axis2_test axis2_svc_client_create FAILURE\n");
printf
("Client repository path not properly set. Please check AXIS2C_HOME setting\n");
return;
}
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
axis2_svc_client_set_options(svc_client, env, options);
payload = build_om_payload_for_echo_svc(env, echo_text);
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (ret_node)
{
if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT)
{
ret_node = axiom_node_get_first_child(ret_node, env);
result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node, env);
result = axiom_element_get_text(result_ele, env, ret_node);
if (!strcmp(result, echo_text))
printf("axis2_test SVC_CLIENT_SEND_RECEIVE SUCCESS\n");
else
printf("axis2_test SVC_CLIENT_SEND_RECEIVE FAILURE\n");
}
}
axis2_svc_client_free(svc_client, env);
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_wss10_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_wss10_t *wss10 = NULL;
neethi_policy_t *policy = NULL;
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
neethi_all_t *all = NULL;
neethi_assertion_t *assertion = NULL;
neethi_policy_t *normalized_policy = NULL;
(void)element;
wss10 = rp_wss10_create(env);
child_node = axiom_node_get_first_element(node, env);
if(!child_node)
{
return NULL;
}
if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(child_element)
{
policy = neethi_engine_get_policy(env, child_node, child_element);
if(!policy)
{
return NULL;
}
normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
neethi_policy_free(policy, env);
policy = NULL;
alternatives = neethi_policy_get_alternatives(normalized_policy, env);
component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *)neethi_operator_get_value(component, env);
wss10_process_alternatives(env, all, wss10);
assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_wss10_free,
wss10, ASSERTION_TYPE_WSS10);
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return assertion;
}
else
return NULL;
}
else
return NULL;
}
axis2_status_t
axis2_addr_in_extract_svc_grp_ctx_id(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_ctx_t * msg_ctx)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
node = axiom_soap_header_get_base_node(soap_header, env);
if (node && axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
axutil_qname_t *qname = NULL;
element = (axiom_element_t *) axiom_node_get_data_element(node, env);
qname = axutil_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI,
AXIS2_NAMESPACE_PREFIX);
if (qname)
{
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
child_element =
axiom_element_get_first_child_with_qname(element, env, qname,
node, &child_node);
if (child_element)
{
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_char_t *grp_id =
axiom_element_get_text(child_element, env,
child_node);
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if (conf_ctx && grp_id)
{
axutil_string_t *svc_grp_ctx_id_str =
axutil_string_create(env, grp_id);
axis2_svc_grp_ctx_t *svc_ctx_grp_ctx =
axis2_conf_ctx_get_svc_grp_ctx(conf_ctx, env, grp_id);
if (!svc_ctx_grp_ctx)
{
return AXIS2_FAILURE;
}
axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env,
svc_grp_ctx_id_str);
axutil_string_free(svc_grp_ctx_id_str, env);
return AXIS2_SUCCESS;
}
}
}
axutil_qname_free(qname, env);
}
return AXIS2_FAILURE;
}
/** 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;
}
axis2_status_t
axis2_addr_in_extract_ref_params(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_info_headers_t * msg_info_headers)
{
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axutil_qname_t *wsa_qname = NULL;
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_info_headers, AXIS2_FAILURE);
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if(!header_block_ht)
{
return AXIS2_FAILURE;
}
wsa_qname = axutil_qname_create(env, AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE,
AXIS2_WSA_NAMESPACE, NULL);
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;
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);
if(header_block_node && (axiom_node_get_node_type(header_block_node, env) == AXIOM_ELEMENT))
{
axiom_attribute_t *om_attr = NULL;
axis2_char_t *attr_value = NULL;
header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node,
env);
om_attr = axiom_element_get_attribute(header_block_ele, env, wsa_qname);
if(om_attr)
{
attr_value = axiom_attribute_get_value(om_attr, env);
if(!axutil_strcmp(attr_value, AXIS2_WSA_TYPE_ATTRIBUTE_VALUE))
{
axis2_msg_info_headers_add_ref_param(msg_info_headers, env, header_block_node);
}
}
}
}
axutil_qname_free(wsa_qname, env);
return AXIS2_SUCCESS;
}
/** this method encapsulate searching logic */
static void
axiom_navigator_update_next_node(
axiom_navigator_t * om_navigator,
const axutil_env_t * env)
{
if (!om_navigator)
{
return;
}
if (!om_navigator->next)
{
return;
}
if ((AXIOM_ELEMENT == axiom_node_get_node_type(om_navigator->next, env)) &&
!(om_navigator->visited))
{
if (axiom_node_get_first_child(om_navigator->next, env))
{
om_navigator->next =
axiom_node_get_first_child(om_navigator->next, env);
}
else if (AXIS2_TRUE == axiom_node_is_complete(om_navigator->next, env))
{
om_navigator->backtracked = AXIS2_TRUE;
}
else
{
om_navigator->next = NULL;
}
}
else
{
axiom_node_t *parent = NULL;
axiom_node_t *next_sibling = NULL;
next_sibling = axiom_node_get_next_sibling(om_navigator->next, env);
parent = axiom_node_get_parent(om_navigator->next, env);
if (next_sibling)
{
om_navigator->next = next_sibling;
}
else if ((parent) && axiom_node_is_complete(parent, env))
{
om_navigator->next = parent;
om_navigator->backtracked = AXIS2_TRUE;
}
else
{
om_navigator->next = NULL;
}
}
}
void wsf_util_unpack_attachments (
const axutil_env_t *env,
axiom_node_t *node,
VALUE *message)
{
axiom_text_t * text_element = NULL;
axiom_data_handler_t *data_handler = NULL;
axis2_char_t *content = NULL;
unsigned int content_length = 0;
axis2_char_t *content_type = NULL;
axis2_char_t *cid = NULL;
axiom_node_t *child_node = NULL;
if (!node)
return;
// Process current node
if (axiom_node_get_node_type (node, env) == AXIOM_TEXT)
{
text_element = (axiom_text_t *)axiom_node_get_data_element(node, env);
if (text_element)
{
data_handler = axiom_text_get_data_handler (text_element, env);
if (data_handler)
{
axiom_data_handler_read_from (data_handler, env, &content, &content_length);
content_type = axiom_data_handler_get_content_type (data_handler, env);
cid = axiom_text_get_content_id (text_element, env);
if (content && content_type && cid)
{
VALUE cont_id;
VALUE cont;
VALUE cont_type;
cont_id = rb_str_new2(cid);
cont_type = rb_str_new2(content_type);
cont = rb_str_new(content, content_length);
rb_funcall(*message, rb_intern("add_attachment_content"), 2, cont_id, cont);
rb_funcall(*message, rb_intern("add_content_type"), 2, cont_id, cont_type);
}
}
}
}
// Process child nodes
child_node = axiom_node_get_first_child (node, env);
while (child_node)
{
wsf_util_unpack_attachments (env, child_node, message);
child_node = axiom_node_get_next_sibling (child_node, env);
}
}
axiom_node_t *
axis2_echo_echo(
const axutil_env_t * env,
axiom_node_t * node)
{
axiom_node_t *text_parent_node = NULL;
axiom_node_t *text_node = NULL;
axiom_node_t *ret_node = NULL;
AXIS2_ENV_CHECK(env, NULL);
/* Expected request format is :-
* <ns1:echoString xmlns:ns1="http://ws.apache.org/axis2/c/samples">
* <text>echo5</text>
* </ns1:echoString>
*/
if (!node) /* 'echoString' node */
{
set_custom_error(env, "Invalid payload; echoString node is NULL");
return NULL;
}
text_parent_node = axiom_node_get_first_element(node, env);
if (!text_parent_node)
{
set_custom_error(env, "Invalid payload; text node is NULL");
return NULL;
}
text_node = axiom_node_get_first_child(text_parent_node, env);
if (!text_node) /* actual text to echo */
{
set_custom_error(env, "Invalid payload; text to be echoed is NULL");
return NULL;
}
if (axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
{
axiom_text_t *text =
(axiom_text_t *) axiom_node_get_data_element(text_node, env);
if (text && axiom_text_get_value(text, env))
{
axis2_char_t *text_str =
(axis2_char_t *) axiom_text_get_value(text, env);
ret_node = build_om_programatically(env, text_str);
}
}
else
{
set_custom_error(env, "Invalid payload; invalid XML in request");
return NULL;
}
return ret_node;
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_soap_header_get_base_node(
axiom_soap_header_t * soap_header,
const axutil_env_t * env)
{
if(!soap_header->om_ele_node)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_namespace_t *parent_ns = NULL;
axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *body_node = NULL;
parent_node = axiom_soap_envelope_get_base_node(soap_header->soap_envelope, env);
if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
this_ele = axiom_element_create(env, NULL, AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns,
&this_node);
if(!this_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
soap_body = axiom_soap_envelope_get_body(soap_header->soap_envelope, env);
if(soap_body)
{
body_node = axiom_soap_body_get_base_node(soap_body, env);
axiom_node_insert_sibling_before(body_node, env, this_node);
}
else
{
axiom_node_add_child(parent_node, env, this_node);
}
soap_header->om_ele_node = this_node;
}
return soap_header->om_ele_node;
}
/**
* Auxiliary function to determine an ADB object type from its Axiom node.
* @param env pointer to environment struct
* @param node double pointer to the parent node to deserialize
* @return type name on success, else NULL
*/
axis2_char_t *AXIS2_CALL
axis2_extension_mapper_type_from_node(
const axutil_env_t *env,
axiom_node_t** node)
{
axiom_node_t *parent = *node;
axutil_qname_t *element_qname = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi;
void *val;
axiom_attribute_t *type_attr;
axutil_hash_t *ht;
axis2_char_t *temp;
axis2_char_t *type;
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 : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
ht = axiom_element_get_all_attributes(element, env);
if (ht == NULL)
return NULL;
for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
axis2_char_t *localpart;
axutil_hash_this(hi, NULL, NULL, &val);
type_attr = (axiom_attribute_t *)val;
localpart = axutil_qname_get_localpart(axiom_attribute_get_qname(type_attr, env), env);
if (axutil_strcmp(localpart, "type") == 0) break;
}
type = axiom_attribute_get_value(type_attr, env);
if (type != NULL && (temp = axutil_strchr(type, ':')) != NULL)
{
if (axutil_strchr(temp, ':') != NULL)
type = temp + 1; /* Pointer arithmetic */
}
return type;
}
static axiom_node_t *
axiom_stax_builder_create_om_processing_instruction(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axiom_node_t *pi_node = NULL;
axis2_char_t *target = NULL;
axis2_char_t *value = NULL;
target = axiom_xml_reader_get_pi_target(om_builder->parser, env);
value = axiom_xml_reader_get_pi_data(om_builder->parser, env);
if(!target)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL, AXIS2_FAILURE);
return NULL;
}
if(!om_builder->lastnode)
{
/* do nothing */
axiom_xml_reader_xml_free(om_builder->parser, env, target);
axiom_xml_reader_xml_free(om_builder->parser, env, value);
return NULL;
}
else if(axiom_node_is_complete(om_builder->lastnode, env)
|| (axiom_node_get_node_type(om_builder->lastnode, env) == AXIOM_TEXT))
{
axiom_processing_instruction_create(env, axiom_node_get_parent(om_builder-> lastnode, env),
target, value, &pi_node);
axiom_node_set_next_sibling(om_builder->lastnode, env, pi_node);
axiom_node_set_previous_sibling(pi_node, env, om_builder->lastnode);
}
else
{
axiom_processing_instruction_create(env, om_builder->lastnode, target, value, &pi_node);
axiom_node_set_first_child(om_builder->lastnode, env, pi_node);
axiom_node_set_parent(pi_node, env, om_builder->lastnode);
}
axiom_node_set_builder(pi_node, env, om_builder);
om_builder->element_level++;
if(target)
{
axiom_xml_reader_xml_free(om_builder->parser, env, target);
}
if(value)
{
axiom_xml_reader_xml_free(om_builder->parser, env, value);
}
om_builder->lastnode = pi_node;
return pi_node;
}
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
axiom_text_create(
const axutil_env_t * env,
axiom_node_t * parent,
const axis2_char_t * value,
axiom_node_t ** node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, node, NULL);
*node = axiom_node_create(env);
if(!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text = (axiom_text_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_text_t));
if(!om_text)
{
AXIS2_FREE(env->allocator, *node);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text->mime_type = NULL;
om_text->optimize = AXIS2_FALSE;
om_text->is_binary = AXIS2_FALSE;
om_text->is_swa = AXIS2_FALSE;
om_text->content_id = NULL;
om_text->om_attribute = NULL;
om_text->value = NULL;
om_text->ns = NULL;
om_text->data_handler = NULL;
om_text->mime_type = NULL;
if(value)
{
om_text->value = axutil_string_create(env, value);
}
axiom_node_set_data_element((*node), env, om_text);
axiom_node_set_node_type((*node), env, AXIOM_TEXT);
axiom_node_set_complete((*node), env, AXIS2_FALSE);
if(parent && axiom_node_get_node_type(parent, env) == AXIOM_ELEMENT)
{
axiom_node_add_child(parent, env, (*node));
}
return om_text;
}
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;
}
void
get_all_policy(
axis2_char_t * element_name,
const axutil_env_t * env,
axutil_array_list_t * policy_node_list,
axis2_char_t * wsdl_name)
{
axutil_hash_t *attr_hash = NULL;
axutil_hash_index_t *hi = NULL;
axiom_element_t *element = NULL;
axiom_attribute_t *attribute = NULL;
axis2_char_t *attribute_val = NULL;
axiom_node_t *parent_policy_node = NULL,
*parent_node = NULL;
parent_node = return_policy_element(element_name, env, wsdl_name);
if (!parent_node)
return;
parent_policy_node =
return_policy_element(get_policy_ref(parent_node, env), env, wsdl_name);
axutil_array_list_add(policy_node_list, env, parent_policy_node);
if (axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT)
{
element =
(axiom_element_t *) axiom_node_get_data_element(parent_node, env);
attr_hash = axiom_element_get_all_attributes(element, env);
if (attr_hash)
{
hi = axutil_hash_next(env, axutil_hash_first(attr_hash, env));
do
{
if (hi)
{
axutil_hash_this(hi, NULL, NULL, &attribute);
attribute_val = axiom_attribute_get_value(attribute, env);
attribute_val = axutil_rindex(attribute_val, ':');
attribute_val =
axutil_string_substring_starting_at(attribute_val, 1);
get_all_policy(attribute_val, env, policy_node_list,
wsdl_name);
hi = axutil_hash_next(env, hi);
}
}
while (hi);
}
}
return;
}
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;
}
axis2_status_t AXIS2_CALL
adb_data_type0_deserialize_obj(
adb_data_type0_t* _data_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;
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 data_type0");
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_data_type0_deserialize_from_string(_data_type0, env, text_value, parent);
}
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_fault_text_set_base_node(
axiom_soap_fault_text_t * fault_text,
const axutil_env_t * env,
axiom_node_t * node)
{
if(node && (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT))
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
fault_text->om_ele_node = node;
return AXIS2_SUCCESS;
}
//-----------------------------------------------------------------------------
axiom_node_t *
sp_get_last_text_node(
axiom_node_t *node,
const axutil_env_t *env)
{
if (NULL == node) return NULL;
axiom_node_t *child = axiom_node_get_last_child (node, env);
while (child != NULL &&
axiom_node_get_node_type(child, env) != AXIOM_TEXT)
{
child = axiom_node_get_previous_sibling(child, env);
}
return child;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_body_set_base_node(
axiom_soap_body_t * soap_body,
const axutil_env_t * env,
axiom_node_t * node)
{
AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
soap_body->om_ele_node = node;
return AXIS2_SUCCESS;
}
/**
* 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 axis2_status_t AXIS2_CALL
axiom_soap_fault_value_set_text(
axiom_soap_fault_value_t * fault_value,
const axutil_env_t * env,
axis2_char_t * text)
{
AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE);
if(fault_value->om_ele_node && axiom_node_get_node_type(fault_value->om_ele_node, env)
== AXIOM_ELEMENT)
{
axiom_element_t *om_ele = NULL;
om_ele = (axiom_element_t *)axiom_node_get_data_element(fault_value->om_ele_node, env);
return axiom_element_set_text(om_ele, env, text, fault_value->om_ele_node);
}
return AXIS2_FAILURE;
}
/**
* Traverse thru the node and its descendents. Check if the localname is equal to the given name
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param localname the local name of the node to be searched
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_axiom_get_node_by_local_name(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *local_name)
{
axis2_char_t *temp_name = NULL;
if(!node)
{
return NULL;
}
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return NULL;
}
temp_name = axiom_util_get_localname(node, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[rampart]Checking node %s for %s", temp_name, local_name );
if(!axutil_strcmp(temp_name, local_name))
{
/* Gottcha.. return this node */
return node;
}
else
{
/* Doesn't match? Get the children and search for them */
axiom_node_t *temp_node = NULL;
temp_node = axiom_node_get_first_element(node, env);
while(temp_node)
{
axiom_node_t *res_node = NULL;
res_node = oxs_axiom_get_node_by_local_name(env, temp_node, local_name);
if(res_node)
{
return res_node;
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
}
return NULL;
}
int
process_response_node(
const axutil_env_t * env,
axiom_node_t *node)
{
axiom_node_t *res_om_node = NULL;
res_om_node = axiom_node_get_first_child(node, env);
if(axiom_node_get_node_type(res_om_node, env) == AXIOM_TEXT)
{/** received mtom atttachment */
axiom_data_handler_t *data_handler = NULL;
axiom_text_t *axiom_text = (axiom_text_t*)axiom_node_get_data_element(res_om_node, env);
data_handler = axiom_text_get_data_handler(axiom_text, env);
if(axiom_data_handler_get_cached(data_handler, env))
{
axis2_char_t *mime_id = NULL;
printf("Attachment is cached.\n");
mime_id = axiom_data_handler_get_mime_id(data_handler, env);
if(mime_id)
{
/* The client implementer should know what to do with
* the attachment in the response. Becasue the attachment
* was stored using the callback given by the client */
/*axis2_char_t command[1000];
sprintf(command, "rm -f /opt/tmp/%s", mime_id);
system(command);*/
}
}
else
{
axiom_data_handler_set_file_name(data_handler, env, "test");
axiom_data_handler_write_to(data_handler, env);
}
}
else
{
printf("No attachemnt in the response\n");
}
return 0;
}
/**
* Traverse thru the node and its descendents. Check if the node has a particular attibure value,
* whose attribute name as in @attr and value as in @val
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param attr the attribute name of the node
* @param val the attribute value of the node
* @param ns namespace of the attribute
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_axiom_get_node_by_id(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *attr,
axis2_char_t *val,
axis2_char_t *ns)
{
axis2_char_t *attribute_value = NULL;
if(!node)
{
return NULL;
}
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return NULL;
}
attribute_value = oxs_axiom_get_attribute_value_of_node_by_name(env, node, attr, ns);
if(!axutil_strcmp(val, attribute_value))
{
/* Gottcha.. return this node */
return node;
}
else
{
/* Doesn't match? Get the children and search recursively. */
axiom_node_t *temp_node = NULL;
temp_node = axiom_node_get_first_element(node, env);
while (temp_node)
{
axiom_node_t *res_node = NULL;
res_node = oxs_axiom_get_node_by_id(env, temp_node, attr, val, ns);
if(res_node)
{
return res_node;
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
}
return NULL;
}
