/** * 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; }