/**
* Checks whether given node is having same name and namespace as given
* @param env Environment. Must not be null
* @param node node to be checked for name and namespace
* @param name local name to be checked against given node
* @param ns namespace to be checked against given node. Can be null. If null, will be omitted
* @return AXIS2_TRUE if given name/ns is same as in the node. AXIS2_FALSE otherwise.
*/
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
oxs_axiom_check_node_name(
const axutil_env_t *env,
axiom_node_t* node,
axis2_char_t* name,
axis2_char_t* ns)
{
axiom_element_t * ele = NULL;
axis2_char_t* namestr = NULL;
axis2_char_t* ns_str = NULL;
axutil_qname_t* qname = NULL;
ele = axiom_node_get_data_element(node, env);
qname = axiom_element_get_qname(ele, env, node);
namestr = axutil_qname_get_localpart(qname, env);
if(axutil_strcmp(namestr, name))
{
return AXIS2_FALSE;
}
if(ns)
{
ns_str = axutil_qname_get_uri(qname, env);
if(axutil_strcmp(ns_str, ns))
{
return AXIS2_FALSE;
}
}
return AXIS2_TRUE;
}
axis2_bool_t axis2_json_element_is_nil(axiom_element_t* om_element, const axutil_env_t* env)
{
axiom_attribute_t* attr = NULL;
axutil_hash_index_t* index;
axutil_hash_t* attr_hash = axiom_element_get_all_attributes(om_element, env);
if (!attr_hash)
return AXIS2_FALSE;
for (index = axutil_hash_first(attr_hash, env);
index; index = axutil_hash_next(env, index))
{
axutil_hash_this(index, NULL, NULL, (void**)&attr);
if (attr && !strcmp(axiom_attribute_get_localname(attr, env), "nil"))
{
/* found some "nil" attribute, check it namespace */
axutil_qname_t* qname =
axiom_attribute_get_qname(attr, env);
if (qname && !strcmp(axutil_qname_get_uri(qname, env), AXIS2_JSON_XSI_URI))
{
axis2_char_t* attr_value =
axiom_attribute_get_value(attr, env);
return (!strcmp(attr_value, "true") || !strcmp(attr_value, "1")) ?
AXIS2_TRUE : AXIS2_FALSE;
}
}
}
return AXIS2_FALSE;
}
static axis2_bool_t AXIS2_CALL
axiom_soap_header_qname_matches(
const axutil_env_t * env,
axutil_qname_t * element_qname,
axutil_qname_t * qname_to_match)
{
int lparts_match = 0;
int uris_match = 0;
axis2_char_t *ele_lpart = NULL;
axis2_char_t *match_lpart = NULL;
axis2_char_t *ele_nsuri = NULL;
axis2_char_t *match_nsuri = NULL;
if(!(qname_to_match))
{
return AXIS2_TRUE;
}
if(qname_to_match)
{
match_lpart = axutil_qname_get_localpart(qname_to_match, env);
match_nsuri = axutil_qname_get_uri(qname_to_match, env);
}
if(element_qname)
{
ele_lpart = axutil_qname_get_localpart(element_qname, env);
ele_nsuri = axutil_qname_get_uri(element_qname, env);
}
lparts_match = (!match_lpart || (axutil_strcmp(match_lpart, "") == 0) || (element_qname
&& (axutil_strcmp(ele_lpart, match_lpart) == 0)));
uris_match = (!match_nsuri || (axutil_strcmp(match_nsuri, "") == 0) || (element_qname
&& (axutil_strcmp(ele_nsuri, match_nsuri) == 0)));
return lparts_match && uris_match;
}
/**
* Traverse thru the node and its descendents. Check if the node has a particular attribute with
* qname as in @qname. Returns the attribute value.
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param qname the qname of the attribute
* @return the attribute value if found, else NULL
*/
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
oxs_axiom_get_attribute_val_of_node_by_qname(
const axutil_env_t *env,
axiom_node_t *node,
axutil_qname_t *qname)
{
axis2_char_t *local_name = NULL;
axis2_char_t *ns_uri = NULL;
/* Get localname of the qname */
local_name = axutil_qname_get_localpart(qname, env);
/* Get namespace uri of the qname */
ns_uri = axutil_qname_get_uri(qname, env);
return oxs_axiom_get_attribute_value_of_node_by_name(env, node, local_name, ns_uri);
}
static axis2_status_t AXIS2_CALL
rp_signed_encrypted_parts_builder_set_properties(
axiom_node_t *node,
axiom_element_t *element,
axis2_char_t *local_name,
rp_signed_encrypted_parts_t * signed_encrypted_parts,
const axutil_env_t *env)
{
axis2_char_t *ns = NULL;
axutil_qname_t *node_qname = NULL;
node_qname = axiom_element_get_qname(element, env, node);
if(!node_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get qname from element %s.", local_name);
return AXIS2_FAILURE;
}
ns = axutil_qname_get_uri(node_qname, env);
if(!ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get namespace from element %s.", local_name);
return AXIS2_FAILURE;
}
/* process assertions common for WS-SecPolicy 1.1 and 1.2 */
if(!(axutil_strcmp(ns, RP_SP_NS_11) && axutil_strcmp(ns, RP_SP_NS_12)))
{
/* this assertion is in WS-SecurityPolicy namespace */
if(!strcmp(local_name, RP_BODY))
{
rp_signed_encrypted_parts_set_body(signed_encrypted_parts, env, AXIS2_TRUE);
return AXIS2_SUCCESS;
}
else if(!strcmp(local_name, RP_HEADER))
{
rp_header_t *header = NULL;
header = rp_signed_encrypted_parts_builder_build_header(element, env);
if(!header)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Failed to process Header Assertion.");
return AXIS2_FAILURE;
}
return rp_signed_encrypted_parts_add_header(signed_encrypted_parts, env, header);
}
}
/* process assertions specific to WS-SecPolicy 1.2 */
if(!axutil_strcmp(ns, RP_SP_NS_12))
{
if(!strcmp(local_name, RP_ATTACHMENTS))
{
rp_signed_encrypted_parts_set_attachments(signed_encrypted_parts, env, AXIS2_TRUE);
return AXIS2_SUCCESS;
}
}
/* either namespace or assertion is not understood */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Unknown Assertion %s with namespace %s", local_name, ns);
return AXIS2_FAILURE;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_header_remove_header_block(
axiom_soap_header_t * soap_header,
const axutil_env_t * env,
axutil_qname_t * qname)
{
axis2_char_t *qn_localname = NULL;
axis2_char_t *qname_ns = NULL;
axis2_char_t *qname_prefix = NULL;
axutil_hash_index_t *hi = NULL;
AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
qn_localname = axutil_qname_get_localpart(qname, env);
qname_ns = axutil_qname_get_uri(qname, env);
qname_prefix = axutil_qname_get_prefix(qname, env);
if(!soap_header->header_blocks)
{
return AXIS2_FAILURE;
}
for(hi = axutil_hash_first(soap_header->header_blocks, env); hi; hi = axutil_hash_next(env, hi))
{
const void *key = NULL;
void *val = NULL;
axutil_hash_this(hi, &key, NULL, &val);
if(val)
{
axiom_soap_header_block_t *header_block = NULL;
axiom_element_t *ele = NULL;
axiom_node_t *node = NULL;
header_block = (axiom_soap_header_block_t *)val;
node = axiom_soap_header_block_get_base_node(header_block, env);
if(node)
{
axutil_qname_t *element_qname = NULL;
ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
element_qname = axiom_element_get_qname(ele, env, node);
if(axiom_soap_header_qname_matches(env, element_qname, qname) == AXIS2_TRUE)
{
axiom_node_detach(node, env);
/* axiom_node_free_tree(node, env); */
axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, NULL);
axiom_soap_header_block_free(header_block, env);
axiom_node_free_tree(node, env);
break;
}
}
}
}
if(hi)
{
AXIS2_FREE(env->allocator, hi);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
axis2_rm_assertion_builder_build(
const axutil_env_t *env,
axiom_node_t *rm_assertion_node,
axiom_element_t *rm_assertion_ele)
{
axis2_rm_assertion_t *rm_assertion = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axiom_children_iterator_t *children_iter = NULL;
neethi_assertion_t *assertion = NULL;
axis2_char_t *ns = NULL;
axutil_qname_t *node_qname = NULL;
node_qname = axiom_element_get_qname(rm_assertion_ele, env, rm_assertion_node);
if(!node_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get qname from element");
return NULL;
}
ns = axutil_qname_get_uri(node_qname, env);
if(!ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get namespace from element.");
return NULL;
}
rm_assertion = axis2_rm_assertion_create(env);
if(!rm_assertion)
{
return NULL;
}
/* First we check whether this is in 1.0 or 1.1
* namespace. Then we called the appropriate builder */
children_iter = axiom_element_get_children(rm_assertion_ele, env, rm_assertion_node);
if(!axutil_strcmp(ns, AXIS2_RM_POLICY_10_NS))
{
status = axis2_rm_assertion_builder_populate_for_10(env, rm_assertion, rm_assertion_node,
rm_assertion_ele);
axiom_children_iterator_reset(children_iter, env);
}
else if(!axutil_strcmp(ns, AXIS2_RM_POLICY_11_NS))
{
status = axis2_rm_assertion_builder_populate_for_11(env, rm_assertion, rm_assertion_node,
rm_assertion_ele);
}
if(status == AXIS2_FAILURE)
{
axis2_rm_assertion_free(rm_assertion, env);
rm_assertion = NULL;
return NULL;
}
/*children_iter = axiom_element_get_children(rm_assertion_ele, env, rm_assertion_node);*/
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;
axutil_qname_t *node_qn = 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);
node_qn = axiom_element_get_qname(ele, env, node);
if(!node_qn)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get qname from element %s.", local_name);
return NULL;
}
ns = axutil_qname_get_uri(node_qn, env);
if(!ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get namespace from element %s.", local_name);
return NULL;
}
if(!axutil_strcmp(ns, AXIS2_SANDESHA2_NS))
{
status = axis2_rm_assertion_builder_process_sandesha2_assertions(env,
rm_assertion, node, ele);
if(status == AXIS2_FAILURE)
{
axis2_rm_assertion_free(rm_assertion, env);
rm_assertion = NULL;
return NULL;
}
}
}
}
}
}
assertion = neethi_assertion_create_with_args(env,
(AXIS2_FREE_VOID_ARG)axis2_rm_assertion_free, rm_assertion, ASSERTION_TYPE_RM_ASSERTION);
return assertion;
}
static axis2_status_t AXIS2_CALL
axis2_rm_assertion_builder_populate_for_11(
const axutil_env_t *env,
axis2_rm_assertion_t *rm_assertion,
axiom_node_t *rm_assertion_node,
axiom_element_t *rm_assertion_element)
{
axiom_children_iterator_t *children_iter = NULL;
axis2_status_t status = AXIS2_FAILURE;
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
(void)rm_assertion_element;
status = axis2_rm_assertion_set_spec_version(rm_assertion, env, RM_SPEC_VERSION_1_1);
child_node = axiom_node_get_first_element(rm_assertion_node, env);
if(child_node)
{
child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(child_element)
{
children_iter = axiom_element_get_children(child_element, env, child_node);
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)
{
axutil_qname_t *node_qname = NULL;
axis2_char_t *ns = NULL;
node_qname = axiom_element_get_qname(ele, env, node);
if(!node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get qname from element");
return AXIS2_FAILURE;
}
ns = axutil_qname_get_uri(node_qname, env);
if(!ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get namespace from element.");
return AXIS2_FAILURE;
}
if(axutil_strcmp(ns, AXIS2_RM_POLICY_11_NS))
{
continue;
}
local_name = axiom_element_get_localname(ele, env);
if(local_name)
{
if(!axutil_strcmp(local_name, AXIS2_RM_SEQUENCE_STR))
{
status = axis2_rm_assertion_set_is_sequence_str(
rm_assertion, env, AXIS2_TRUE);
}
else if(!axutil_strcmp(local_name,
AXIS2_RM_SEQUENCE_TRANSPORT_SECURITY))
{
status
= axis2_rm_assertion_set_is_sequence_transport_security(
rm_assertion, env, AXIS2_TRUE);
}
else if(!axutil_strcmp(local_name, AXIS2_RM_DELIVERY_ASSURANCE))
{
status
= axis2_rm_assertion_builder_process_delivery_assuarance(
env, rm_assertion, node, ele);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Unknown Assertion %s ", local_name);
return AXIS2_FAILURE;
}
}
}
}
}
}
}
}
}
return status;
}
static axis2_status_t AXIS2_CALL
axis2_rm_assertion_builder_populate_for_10(
const axutil_env_t *env,
axis2_rm_assertion_t *rm_assertion,
axiom_node_t *rm_assertion_node,
axiom_element_t *rm_assertion_element)
{
axiom_children_iterator_t *children_iter = NULL;
axis2_status_t status = AXIS2_FAILURE;
/* In rm 1.0 it is just child elements which inside
* rm_assertion contains all the properties. */
status = axis2_rm_assertion_set_spec_version(rm_assertion, env, RM_SPEC_VERSION_1_0);
children_iter = axiom_element_get_children(rm_assertion_element, env, rm_assertion_node);
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)
{
axutil_qname_t *node_qname = NULL;
axis2_char_t *ns = NULL;
node_qname = axiom_element_get_qname(ele, env, node);
if(!node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get qname from element");
return AXIS2_FAILURE;
}
ns = axutil_qname_get_uri(node_qname, env);
if(!ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot get namespace from element.");
return AXIS2_FAILURE;
}
if(axutil_strcmp(ns, AXIS2_RM_POLICY_10_NS))
{
continue;
}
local_name = axiom_element_get_localname(ele, env);
if(local_name)
{
if(!axutil_strcmp(local_name, AXIS2_RM_INACTIVITY_TIMEOUT))
{
axis2_char_t *inactivity_timeout = NULL;
axutil_qname_t *qname = NULL;
qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
inactivity_timeout = axiom_element_get_attribute_value(ele, env,
qname);
if(qname)
{
axutil_qname_free(qname, env);
qname = NULL;
}
status = axis2_rm_assertion_set_inactivity_timeout(rm_assertion,
env, inactivity_timeout);
}
else if(!axutil_strcmp(local_name,
AXIS2_RM_BASE_RETRANSMISSION_INTERVAL))
{
axis2_char_t *rti = NULL;
axutil_qname_t *qname = NULL;
qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
rti = axiom_element_get_attribute_value(ele, env, qname);
if(qname)
{
axutil_qname_free(qname, env);
qname = NULL;
}
status = axis2_rm_assertion_set_retrans_interval(rm_assertion, env,
rti);
}
else if(!axutil_strcmp(local_name, AXIS2_RM_EXPONENTIAL_BACK_OFF))
{
status = axis2_rm_assertion_set_is_exp_backoff(rm_assertion, env,
AXIS2_TRUE);
}
else if(!axutil_strcmp(local_name, AXIS2_RM_ACKNOWLEDGEMENT_INTERVAL))
{
axis2_char_t *ack_interval = NULL;
axutil_qname_t *qname = NULL;
qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
ack_interval = axiom_element_get_attribute_value(ele, env, qname);
if(qname)
{
axutil_qname_free(qname, env);
qname = NULL;
}
status = axis2_rm_assertion_set_ack_interval(rm_assertion, env,
ack_interval);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Unknown Assertion %s ", local_name);
return AXIS2_FAILURE;
}
}
}
}
}
}
}
return status;
}
