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; }
axiom_node_t * axis2_addr_out_handler_process_string_info( const axutil_env_t * env, const axis2_char_t * value, const axis2_char_t * type, axiom_soap_header_t ** soap_header_p, const axis2_char_t * addr_ns, axis2_bool_t set_must_understand) { axiom_soap_header_t *soap_header = NULL; axiom_soap_header_block_t *header_block = NULL; axiom_node_t *header_block_node = NULL; axiom_element_t *header_block_ele = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, value, NULL); AXIS2_PARAM_CHECK(env->error, type, NULL); AXIS2_PARAM_CHECK(env->error, soap_header_p, NULL); AXIS2_PARAM_CHECK(env->error, addr_ns, NULL); soap_header = *(soap_header_p); if(value && *value) { axiom_namespace_t *addr_ns_obj = NULL; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj); 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); if(header_block_ele) { axiom_namespace_t *dec_ns = NULL; axiom_element_set_text(header_block_ele, env, value, header_block_node); dec_ns = axiom_element_find_declared_namespace(header_block_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(!dec_ns) { axiom_namespace_free(addr_ns_obj, env); addr_ns_obj = NULL; } } if(set_must_understand) { axiom_soap_header_block_set_must_understand_with_bool(header_block, env, AXIS2_TRUE); } } return header_block_node; }
AXIS2_EXTERN axiom_soap_header_block_t *AXIS2_CALL axiom_soap_header_add_header_block( axiom_soap_header_t * soap_header, const axutil_env_t * env, const axis2_char_t * localname, axiom_namespace_t * ns) { axiom_soap_header_block_t *header_block = NULL; axiom_namespace_t *cloned_ns = NULL; axiom_node_t *header_block_node = NULL; AXIS2_PARAM_CHECK(env->error, localname, NULL); AXIS2_PARAM_CHECK(env->error, ns, NULL); cloned_ns = axiom_namespace_clone(ns, env); if(!cloned_ns) { return NULL; } header_block = axiom_soap_header_block_create_with_parent(env, localname, cloned_ns, soap_header); if(!header_block) { return NULL; } header_block_node = axiom_soap_header_block_get_base_node(header_block, env); if(header_block_node) { axiom_node_set_complete(header_block_node, env, AXIS2_TRUE); return header_block; } else { return NULL; } }
axis2_status_t axis2_addr_in_extract_to_epr_ref_params( const axutil_env_t * env, axis2_endpoint_ref_t * to_epr, axiom_soap_header_t * soap_header, const axis2_char_t * addr_ns_str) { axutil_hash_t *header_blocks_ht = NULL; axutil_hash_index_t *hash_index = NULL; axutil_qname_t *is_ref_qn = NULL; AXIS2_PARAM_CHECK(env->error, to_epr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); header_blocks_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); if (!header_blocks_ht) { return AXIS2_FAILURE; } is_ref_qn = axutil_qname_create(env, "IsReferenceParameter", addr_ns_str, NULL); if (!is_ref_qn) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create qname for %s", addr_ns_str); return AXIS2_FAILURE; } for (hash_index = axutil_hash_first(header_blocks_ht, env); hash_index; hash_index = axutil_hash_next(env, hash_index)) { axiom_element_t *header_block_ele = NULL; axiom_node_t *header_block_node = NULL; axiom_soap_header_block_t *header_block = NULL; void *hb = NULL; axiom_attribute_t *is_ref_param_attr = NULL; axis2_char_t *attr_value = NULL; axutil_hash_this(hash_index, NULL, NULL, &hb); if (hb) { header_block = (axiom_soap_header_block_t *) hb; header_block_node = axiom_soap_header_block_get_base_node(header_block, env); header_block_ele = (axiom_element_t *) axiom_node_get_data_element(header_block_node, env); is_ref_param_attr = axiom_element_get_attribute(header_block_ele, env, is_ref_qn); if (is_ref_param_attr) { attr_value = axiom_attribute_get_localname(is_ref_param_attr, env); if (!axutil_strcmp("true", attr_value)) { axis2_endpoint_ref_add_ref_param(to_epr, env, header_block_node); } } } } axutil_qname_free(is_ref_qn, env); return AXIS2_SUCCESS; }
axis2_status_t axis2_addr_in_extract_epr_information( const axutil_env_t * env, axiom_soap_header_block_t * soap_header_block, axis2_endpoint_ref_t * endpoint_ref, const axis2_char_t * addr_ns_str) { axutil_qname_t *epr_addr_qn = NULL; axutil_qname_t *epr_ref_qn = NULL; axutil_qname_t *wsa_meta_qn = NULL; axiom_node_t *header_block_node = NULL; axiom_element_t *header_block_ele = NULL; axiom_child_element_iterator_t *child_ele_iter = NULL; AXIS2_PARAM_CHECK(env->error, soap_header_block, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); header_block_node = axiom_soap_header_block_get_base_node(soap_header_block, env); header_block_ele = (axiom_element_t *) axiom_node_get_data_element(header_block_node, env); child_ele_iter = axiom_element_get_child_elements(header_block_ele, env, header_block_node); if (!child_ele_iter) { return AXIS2_FAILURE; } epr_addr_qn = axutil_qname_create(env, EPR_ADDRESS, addr_ns_str, NULL); epr_ref_qn = axutil_qname_create(env, EPR_REFERENCE_PARAMETERS, addr_ns_str, NULL); wsa_meta_qn = axutil_qname_create(env, AXIS2_WSA_METADATA, addr_ns_str, NULL); while (AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(child_ele_iter, env)) { axiom_node_t *child_node = NULL; axiom_element_t *child_ele = NULL; axutil_qname_t *child_qn = NULL; child_node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(child_ele_iter, env); child_ele = (axiom_element_t *) axiom_node_get_data_element(child_node, env); child_qn = axiom_element_get_qname(child_ele, env, child_node); if (axis2_addr_in_check_element(env, epr_addr_qn, child_qn)) { axis2_endpoint_ref_set_address(endpoint_ref, env, axiom_element_get_text(child_ele, env, child_node)); } else if (axis2_addr_in_check_element(env, epr_ref_qn, child_qn)) { axiom_child_element_iterator_t *ref_param_iter = NULL; ref_param_iter = axiom_element_get_child_elements(child_ele, env, child_node); if (ref_param_iter) { while (AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT (ref_param_iter, env)) { axiom_node_t *om_node = NULL; axiom_element_t *om_ele = NULL; om_node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(ref_param_iter, env); om_ele = (axiom_element_t *) axiom_node_get_data_element(om_node, env); axis2_endpoint_ref_add_ref_param(endpoint_ref, env, om_node); } } } else if (axis2_addr_in_check_element(env, wsa_meta_qn, child_qn)) { /* FIXME : Can we remove this?*/ } } axutil_qname_free(epr_addr_qn, env); axutil_qname_free(epr_ref_qn, env); axutil_qname_free(wsa_meta_qn, env); return AXIS2_SUCCESS; }
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; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL rampart_shb_build_message( const axutil_env_t *env, axis2_msg_ctx_t *msg_ctx, rampart_context_t *rampart_context, axiom_soap_envelope_t *soap_envelope) { axis2_status_t status = AXIS2_SUCCESS; axiom_soap_header_t *soap_header = NULL; axiom_node_t *soap_header_node = NULL; axiom_element_t *soap_header_ele = NULL; axiom_soap_header_block_t *sec_header_block = NULL; axiom_namespace_t *sec_ns_obj = NULL; axiom_node_t *sec_node = NULL; axiom_element_t *sec_ele = NULL; axis2_bool_t server_side = AXIS2_FALSE; /* * sign parts list. Moved this up the building process. This was originally * in the rampart_sig_sign_message */ axutil_array_list_t *sign_parts_list = NULL; AXIS2_ENV_CHECK(env,AXIS2_FAILURE); soap_header = axiom_soap_envelope_get_header(soap_envelope, env); soap_header_node = axiom_soap_header_get_base_node(soap_header, env); soap_header_ele = (axiom_element_t *)axiom_node_get_data_element( soap_header_node, env); sec_ns_obj = axiom_namespace_create(env, RAMPART_WSSE_XMLNS, RAMPART_WSSE); sec_header_block = axiom_soap_header_add_header_block(soap_header, env, RAMPART_SECURITY, sec_ns_obj); /* sec_ns_obj is cloned there */ server_side = axis2_msg_ctx_get_server_side(msg_ctx, env); if(!sec_header_block) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Security header block is NULL"); axiom_namespace_free(sec_ns_obj, env); return AXIS2_SUCCESS; } axiom_soap_header_block_set_must_understand_with_bool(sec_header_block, env, AXIS2_TRUE); sec_node = axiom_soap_header_block_get_base_node(sec_header_block, env); sec_ele = (axiom_element_t *) axiom_node_get_data_element(sec_node, env); sign_parts_list = axutil_array_list_create(env, 4); /*Timestamp Inclusion*/ if(rampart_context_is_include_timestamp(rampart_context,env)) { int ttl = -1; axis2_bool_t need_millisecond = AXIS2_TRUE; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Building Timestamp Token"); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Using default timeToLive value %d", RAMPART_TIMESTAMP_TOKEN_DEFAULT_TIME_TO_LIVE); ttl = rampart_context_get_ttl(rampart_context,env); need_millisecond = rampart_context_get_need_millisecond_precision(rampart_context, env); status = rampart_timestamp_token_build(env, sec_node, ttl, need_millisecond); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Timestamp Token build failed. ERROR"); axiom_namespace_free(sec_ns_obj, env); return AXIS2_FAILURE; } } /*Check whether we need username token*/ /*User name tokens includes in messages sent from client to server*/ if(!axis2_msg_ctx_get_server_side(msg_ctx,env)) { if(rampart_context_is_include_username_token(rampart_context,env)) { /*Now we are passing rampart_context here so inside this method relevant parameters are extracted. */ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Building UsernameToken"); status = rampart_username_token_build( env, rampart_context, sec_node, sec_ns_obj); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] UsernameToken build failed. ERROR"); axiom_namespace_free(sec_ns_obj, env); return AXIS2_FAILURE; } } } /*Custom tokens are included if its available in the rampart context*/ if(!axis2_msg_ctx_get_server_side(msg_ctx,env)) { axutil_array_list_t *token_list = NULL; token_list = rampart_context_get_custom_tokens(rampart_context, env); if(token_list){ int size = 0, i = 0; size = axutil_array_list_size(token_list, env); for (i = 0; i < size; i++){ axiom_node_t *token_node = NULL; token_node = (axiom_node_t*)axutil_array_list_get(token_list, env, i); if(token_node){ axis2_status_t status = AXIS2_FAILURE; status = axiom_node_add_child(sec_node, env, token_node); if(status != AXIS2_SUCCESS){ return AXIS2_FAILURE; } } } } } if (rampart_context_is_include_supporting_token(rampart_context, env, server_side, AXIS2_FALSE, RP_PROPERTY_SAML_TOKEN)) { status = rampart_saml_supporting_token_build(env, rampart_context, sec_node, sign_parts_list); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] SAML Supporting token build failed. ERROR"); axutil_array_list_free(sign_parts_list, env); axiom_namespace_free(sec_ns_obj, env); return AXIS2_FAILURE; } } if (rampart_context_is_include_supporting_token(rampart_context, env, server_side, AXIS2_FALSE, RP_PROPERTY_ISSUED_TOKEN)) { status = rampart_issued_supporting_token_build(rampart_context, env, sec_node, sign_parts_list); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Issued supporting token build failed. ERROR"); axutil_array_list_free(sign_parts_list, env); axiom_namespace_free(sec_ns_obj, env); return AXIS2_FAILURE; } } /*Signature Confirmation support. Only in the server side*/ if(axis2_msg_ctx_get_server_side(msg_ctx,env)){ axis2_bool_t sign_conf_reqd = AXIS2_FALSE; /*Sign_conf_reqd <- Get from context <- policy*/ sign_conf_reqd = rampart_context_is_sig_confirmation_reqd(rampart_context, env); if(sign_conf_reqd){ status = rampart_sig_confirm_signature(env, msg_ctx, rampart_context, sec_node); } } /*check the binding*/ if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_ASYMMETRIC_BINDING) { axis2_status_t status = AXIS2_FAILURE; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Asymmetric Binding. "); status = rampart_shb_do_asymmetric_binding(env, msg_ctx, rampart_context, soap_envelope, sec_node, sec_ns_obj, sign_parts_list); axiom_namespace_free(sec_ns_obj, env); if(AXIS2_FAILURE == status){ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Asymmetric Binding failed"); if(axis2_msg_ctx_get_server_side(msg_ctx,env)){ AXIS2_ERROR_SET(env->error, RAMPART_ERROR_INVALID_SECURITY , AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] %s", AXIS2_ERROR_GET_MESSAGE(env->error)); rampart_create_fault_envelope(env, RAMPART_FAULT_INVALID_SECURITY, " Asymmetric Binding failed. Check configurations ", RAMPART_FAULT_IN_POLICY, msg_ctx); } axutil_array_list_free(sign_parts_list, env); return AXIS2_FAILURE; }else{ axutil_array_list_free(sign_parts_list, env); return AXIS2_SUCCESS; } } else if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_SYMMETRIC_BINDING) { axis2_status_t status = AXIS2_FAILURE; /*Do Symmetric_binding specific things*/ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Symmetric Binding. "); status = rampart_shb_do_symmetric_binding(env, msg_ctx, rampart_context, soap_envelope, sec_node, sec_ns_obj, sign_parts_list); axiom_namespace_free(sec_ns_obj, env); if(AXIS2_FAILURE == status){ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Symmetric Binding failed"); if(axis2_msg_ctx_get_server_side(msg_ctx,env)){ AXIS2_ERROR_SET(env->error, RAMPART_ERROR_INVALID_SECURITY, AXIS2_FAILURE); rampart_create_fault_envelope(env, RAMPART_FAULT_INVALID_SECURITY, " Symmetric Binding failed. Check configurations ", RAMPART_FAULT_IN_POLICY, msg_ctx); } axutil_array_list_free(sign_parts_list, env); return AXIS2_FAILURE; }else{ axutil_array_list_free(sign_parts_list, env); return AXIS2_SUCCESS; } } else if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_TRANSPORT_BINDING) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Using transport binding"); axiom_namespace_free(sec_ns_obj, env); axutil_array_list_free(sign_parts_list, env); return AXIS2_SUCCESS; }else{ axutil_array_list_free(sign_parts_list, env); axiom_namespace_free(sec_ns_obj, env); 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 axutil_array_list_t *AXIS2_CALL axiom_soap_header_get_header_blocks_with_namespace_uri( axiom_soap_header_t * soap_header, const axutil_env_t * env, const axis2_char_t * ns_uri) { axutil_array_list_t *header_block_list = NULL; axutil_hash_index_t *hash_index = NULL; axiom_soap_header_block_t *header_block = NULL; axiom_node_t *header_block_om_node = NULL; axiom_element_t *header_block_om_ele = NULL; axiom_namespace_t *ns = NULL; axis2_char_t *hb_namespace_uri = NULL; int found = 0; void *hb = NULL; AXIS2_PARAM_CHECK(env->error, ns_uri, NULL); if(!(soap_header->header_blocks)) { return NULL; } header_block_list = axutil_array_list_create(env, 10); if(!header_block_list) { return NULL; } for(hash_index = axutil_hash_first(soap_header->header_blocks, env); hash_index; hash_index = axutil_hash_next(env, hash_index)) { axutil_hash_this(hash_index, NULL, NULL, &hb); if(hb) { header_block = (axiom_soap_header_block_t *)hb; header_block_om_node = axiom_soap_header_block_get_base_node(header_block, env); if(header_block_om_node) { header_block_om_ele = (axiom_element_t *)axiom_node_get_data_element( header_block_om_node, env); if(header_block_om_ele) { ns = axiom_element_get_namespace(header_block_om_ele, env, header_block_om_node); if(ns) { hb_namespace_uri = axiom_namespace_get_uri(ns, env); if(axutil_strcmp(hb_namespace_uri, ns_uri) == 0) { axutil_array_list_add(header_block_list, env, header_block); found++; } } } } hb = NULL; header_block = NULL; header_block_om_ele = NULL; header_block_om_node = NULL; ns = NULL; hb_namespace_uri = NULL; } } if(found > 0) { return header_block_list; } else { axutil_array_list_free(header_block_list, env); } return NULL; }
axis2_status_t AXIS2_CALL axis2_addr_out_handler_invoke( struct axis2_handler * handler, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_char_t *addr_ver_from_msg_ctx = NULL; const axis2_char_t *addr_ns = NULL; axis2_msg_info_headers_t *msg_info_headers = NULL; axis2_ctx_t *ctx = NULL; axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_header_t *soap_header = NULL; axiom_node_t *soap_header_node = NULL; axiom_element_t *soap_header_ele = NULL; axis2_endpoint_ref_t *epr_to = NULL; axis2_endpoint_ref_t *epr_reply_to = NULL; axis2_endpoint_ref_t *epr_from = NULL; axis2_endpoint_ref_t *epr_fault_to = NULL; axutil_property_t *property = NULL; const axis2_char_t *wsa_action = NULL; axis2_bool_t set_must_understand = AXIS2_FALSE; axutil_property_t *must_understand_prop; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_LOG_INFO(env->log, "Starting addressing out handler"); soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_envelope) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP envelope. Stop processing addressing"); return AXIS2_SUCCESS; /* Can happen in case of ONE-WAY services/clients */ } msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env); if(msg_info_headers) { wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); } else { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No addressing in use"); return AXIS2_SUCCESS; /* No addressing in use */ } if(!wsa_action || !*wsa_action) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No action present. Stop processing addressing"); return AXIS2_SUCCESS; /* If no action present, assume no addressing in use */ } ctx = axis2_msg_ctx_get_base(msg_ctx, env); property = axis2_ctx_get_property(ctx, env, AXIS2_WSA_VERSION); if(property) { addr_ver_from_msg_ctx = axutil_property_get_value(property, env); property = NULL; } must_understand_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ADDR_ADD_MUST_UNDERSTAND_TO_ADDR_HEADERS); if(must_understand_prop) { axis2_char_t *value = axutil_property_get_value(must_understand_prop, env); if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0) set_must_understand = AXIS2_TRUE; } /* Setting version 1.0 as the default addressing namespace */ addr_ns = AXIS2_WSA_NAMESPACE; if(addr_ver_from_msg_ctx) { if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ver_from_msg_ctx)) { addr_ns = AXIS2_WSA_NAMESPACE_SUBMISSION; } } else if(axis2_msg_ctx_get_op_ctx(msg_ctx, env)) { axis2_op_ctx_t *op_ctx = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); } if(in_msg_ctx) { axis2_ctx_t *in_ctx = NULL; in_ctx = axis2_msg_ctx_get_base(in_msg_ctx, env); property = axis2_ctx_get_property(in_ctx, env, AXIS2_WSA_VERSION); if(property) { addr_ns = axutil_property_get_value(property, env); property = NULL; } if(!addr_ns || !*addr_ns) { addr_ns = AXIS2_WSA_NAMESPACE; } } } soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if(!soap_header) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP header. Stop processing addressing"); return AXIS2_SUCCESS; /* No SOAP header, so no point proceeding */ } else { /* By this time, we definitely have some addressing information to be sent. This is because, * we have tested at the start of this whether msg_info_headers are null or not. * So rather than declaring addressing namespace in each and every addressing header, lets * define that in the Header itself. */ const axis2_char_t *action = NULL; const axis2_char_t *address = NULL; const axis2_char_t *svc_group_context_id = NULL; const axis2_char_t *message_id = NULL; axis2_relates_to_t *relates_to = NULL; axiom_node_t *relates_to_header_node = NULL; axiom_element_t *relates_to_header_ele = NULL; axiom_namespace_t *addressing_namespace = NULL; soap_header_node = axiom_soap_header_get_base_node(soap_header, env); soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header_node, env); addressing_namespace = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); axiom_element_declare_namespace(soap_header_ele, env, soap_header_node, addressing_namespace); epr_to = axis2_msg_info_headers_get_to(msg_info_headers, env); if(epr_to) { axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env); if(body) { /* In case of a SOAP fault, we got to send the response to the adress specified by FaultTo */ if(axiom_soap_body_has_fault(body, env)) { axis2_endpoint_ref_t *epr_fault_to = axis2_msg_info_headers_get_fault_to( msg_info_headers, env); if(epr_fault_to) { const axis2_char_t *fault_to_address = axis2_endpoint_ref_get_address( epr_fault_to, env); if(fault_to_address) { if(axutil_strcmp(AXIS2_WSA_NONE_URL, fault_to_address) && axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, fault_to_address)) { axis2_endpoint_ref_set_address(epr_to, env, fault_to_address); } } } } } address = axis2_endpoint_ref_get_address(epr_to, env); if(address && *address) { axiom_node_t *to_header_block_node = NULL; axiom_soap_header_block_t *to_header_block = NULL; axutil_array_list_t *ref_param_list = NULL; int size = 0; to_header_block = axiom_soap_header_add_header_block(soap_header, env, AXIS2_WSA_TO, addressing_namespace); if(set_must_understand == AXIS2_TRUE) { axiom_soap_header_block_set_must_understand_with_bool(to_header_block, env, AXIS2_TRUE); } to_header_block_node = axiom_soap_header_block_get_base_node(to_header_block, env); if(to_header_block_node) { axiom_element_t *to_header_block_element = NULL; to_header_block_element = (axiom_element_t *)axiom_node_get_data_element( to_header_block_node, env); if(to_header_block_element) { axiom_element_set_text(to_header_block_element, env, address, to_header_block_node); } } ref_param_list = axis2_endpoint_ref_get_ref_param_list(epr_to, env); size = axutil_array_list_size(ref_param_list, env); if(ref_param_list && size > 0) { axiom_soap_header_block_t *reference_header_block = NULL; axiom_node_t *reference_node = NULL; int i = 0; for(i = 0; i < size; i++) { axiom_node_t *temp_node = NULL; temp_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i); if(temp_node) { axiom_element_t *temp_ele = NULL; temp_ele = axiom_node_get_data_element(temp_node, env); if(temp_ele) { reference_header_block = axiom_soap_header_add_header_block( soap_header, env, axiom_element_get_localname(temp_ele, env), axiom_element_get_namespace(temp_ele, env, temp_node)); if(set_must_understand) { axiom_soap_header_block_set_must_understand_with_bool(reference_header_block, env, AXIS2_TRUE); } reference_node = axiom_soap_header_block_get_base_node( reference_header_block, env); if(reference_node) { axiom_element_t *reference_ele = NULL; reference_ele = (axiom_element_t *)axiom_node_get_data_element( reference_node, env); if(reference_ele) { axiom_namespace_t *addr_ns_obj = NULL; axiom_attribute_t *reference_attr = NULL; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); reference_attr = axiom_attribute_create(env, /*"isReferenceParameter"*/ AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, "true", addr_ns_obj); axiom_element_add_attribute(reference_ele, env, reference_attr, reference_node); axiom_element_set_text(reference_ele, env, axiom_element_get_text(temp_ele, env, temp_node), reference_node); } } } } } } } }/* if(epr_to) */ axiom_namespace_free(addressing_namespace, env); action = axis2_msg_info_headers_get_action(msg_info_headers, env); if(action && *action) { axis2_addr_out_handler_process_string_info(env, action, AXIS2_WSA_ACTION, &soap_header, addr_ns, set_must_understand); } epr_reply_to = axis2_msg_info_headers_get_reply_to(msg_info_headers, env); if(!epr_reply_to) { const axis2_char_t *anonymous_uri = NULL; axis2_bool_t anonymous = axis2_msg_info_headers_get_reply_to_anonymous( msg_info_headers, env); axis2_bool_t none = axis2_msg_info_headers_get_reply_to_none(msg_info_headers, env); if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; } } else { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; } } if(anonymous_uri) { epr_reply_to = axis2_endpoint_ref_create(env, anonymous_uri); } if(epr_reply_to) { axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr_reply_to); } } /* add the service group id as a reference parameter */ svc_group_context_id = axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(msg_ctx, env), env); axis2_addr_out_handler_add_to_soap_header(env, epr_reply_to, AXIS2_WSA_REPLY_TO, soap_header, addr_ns); epr_from = axis2_msg_info_headers_get_from(msg_info_headers, env); if(epr_from) { axis2_addr_out_handler_add_to_soap_header(env, epr_from, AXIS2_WSA_FROM, soap_header, addr_ns); } epr_fault_to = axis2_msg_info_headers_get_fault_to(msg_info_headers, env); if(!epr_fault_to) { const axis2_char_t *anonymous_uri = NULL; axis2_bool_t anonymous = axis2_msg_info_headers_get_fault_to_anonymous( msg_info_headers, env); axis2_bool_t none = axis2_msg_info_headers_get_fault_to_none(msg_info_headers, env); if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; } } else { if(none) anonymous_uri = AXIS2_WSA_NONE_URL; else if(anonymous) anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; } if(anonymous_uri) { epr_fault_to = axis2_endpoint_ref_create(env, anonymous_uri); } } if(epr_fault_to) { /* optional */ axis2_addr_out_handler_add_to_soap_header(env, epr_fault_to, AXIS2_WSA_FAULT_TO, soap_header, addr_ns); } message_id = axis2_msg_info_headers_get_message_id(msg_info_headers, env); if(message_id) { axis2_addr_out_handler_process_string_info(env, message_id, AXIS2_WSA_MESSAGE_ID, &soap_header, addr_ns, set_must_understand); } relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env); if(relates_to) { const axis2_char_t *value = NULL; value = axis2_relates_to_get_value(relates_to, env); relates_to_header_node = axis2_addr_out_handler_process_string_info(env, value, AXIS2_WSA_RELATES_TO, &soap_header, addr_ns, set_must_understand); } if(relates_to_header_node) { const axis2_char_t *relationship_type = NULL; relationship_type = axis2_relates_to_get_relationship_type(relates_to, env); if(relationship_type && *relationship_type) { axiom_attribute_t *om_attr = NULL; axiom_namespace_t *addr_ns_obj = NULL; axiom_namespace_t *dec_ns = NULL; relates_to_header_ele = (axiom_element_t *)axiom_node_get_data_element( relates_to_header_node, env); if(relates_to_header_ele) { dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(dec_ns) { addr_ns_obj = dec_ns; } else { addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); } if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { om_attr = axiom_attribute_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION, addr_ns_obj); } else { om_attr = axiom_attribute_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE, addr_ns_obj); } axiom_element_add_attribute(relates_to_header_ele, env, om_attr, relates_to_header_node); dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(!dec_ns) { dec_ns = axiom_element_find_namespace(relates_to_header_ele, env, relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(dec_ns) { axiom_namespace_free(addr_ns_obj, env); addr_ns_obj = NULL; axiom_attribute_set_namespace(om_attr, env, dec_ns); } } } } } } return AXIS2_SUCCESS; }
axis2_status_t axis2_addr_out_handler_add_to_soap_header( const axutil_env_t * env, axis2_endpoint_ref_t * endpoint_ref, const axis2_char_t * type, axiom_soap_header_t * soap_header, const axis2_char_t * addr_ns) { axiom_soap_header_block_t *header_block = NULL; const axis2_char_t *address = NULL; axutil_array_list_t *ref_param_list = NULL; axutil_array_list_t *meta_data_list = NULL; axutil_array_list_t *extension_list = NULL; axiom_node_t *header_block_node = NULL; axiom_node_t *header_node = NULL; axiom_namespace_t *addr_ns_obj = NULL; int size = 0; AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, type, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); header_node = axiom_soap_header_get_base_node(soap_header, env); addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj); if(addr_ns_obj) { axiom_namespace_free(addr_ns_obj, env); addr_ns_obj = NULL; } address = axis2_endpoint_ref_get_address(endpoint_ref, env); if(address && *address) { axiom_node_t *hb_node = NULL; axiom_element_t *hb_ele = NULL; axiom_node_t *address_node = NULL; axiom_element_t *address_ele = NULL; hb_node = axiom_soap_header_block_get_base_node(header_block, env); hb_ele = (axiom_element_t *)axiom_node_get_data_element(hb_node, env); addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); address_ele = axiom_element_create(env, hb_node, EPR_ADDRESS, addr_ns_obj, &address_node); axiom_namespace_free(addr_ns_obj, env); if(address_ele) { axiom_namespace_t *dec_ns = NULL; axiom_element_set_text(address_ele, env, address, address_node); dec_ns = axiom_element_find_declared_namespace(address_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); } } header_block_node = axiom_soap_header_block_get_base_node(header_block, env); axis2_addr_out_handler_add_to_header(env, endpoint_ref, &header_block_node, addr_ns); ref_param_list = axis2_endpoint_ref_get_ref_param_list(endpoint_ref, env); if(ref_param_list && axutil_array_list_size(ref_param_list, env) > 0) { axiom_node_t *reference_node = NULL; axiom_element_t *reference_ele = NULL; axutil_array_list_t *ref_attribute_list = NULL; int i = 0; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); reference_ele = axiom_element_create(env, header_block_node, EPR_REFERENCE_PARAMETERS, addr_ns_obj, &reference_node); axiom_namespace_free(addr_ns_obj, env); ref_attribute_list = axis2_endpoint_ref_get_ref_attribute_list(endpoint_ref, env); if(ref_attribute_list) { int j = 0; size = axutil_array_list_size(ref_attribute_list, env); for(j = 0; j < size; j++) { axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get( ref_attribute_list, env, j); if(attr) { axiom_element_add_attribute(reference_ele, env, attr, reference_node); } } } size = axutil_array_list_size(ref_param_list, env); for(i = 0; i < size; i++) { axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i); if(ref_node) { axiom_node_add_child(reference_node, env, ref_node); } } } meta_data_list = axis2_endpoint_ref_get_metadata_list(endpoint_ref, env); if(meta_data_list && axutil_array_list_size(meta_data_list, env) > 0) { axiom_node_t *reference_node = NULL; axiom_element_t *reference_ele = NULL; axutil_array_list_t *meta_attribute_list = NULL; int i = 0; if(!reference_node) /* may be we alredy created this in ref params block */ { addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); reference_ele = axiom_element_create(env, header_block_node, AXIS2_WSA_METADATA, addr_ns_obj, &reference_node); axiom_namespace_free(addr_ns_obj, env); } meta_attribute_list = axis2_endpoint_ref_get_metadata_attribute_list(endpoint_ref, env); if(meta_attribute_list) { int j = 0; size = axutil_array_list_size(meta_attribute_list, env); for(j = 0; j < size; j++) { axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get( meta_attribute_list, env, j); if(attr) { axiom_element_add_attribute(reference_ele, env, attr, reference_node); } } } size = axutil_array_list_size(meta_data_list, env); for(i = 0; i < size; i++) { axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(meta_data_list, env, i); if(ref_node) { axiom_node_add_child(reference_node, env, ref_node); } } } extension_list = axis2_endpoint_ref_get_extension_list(endpoint_ref, env); if(extension_list && axutil_array_list_size(extension_list, env) > 0) { int i = 0; size = axutil_array_list_size(extension_list, env); for(i = 0; i < size; i++) { axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(extension_list, env, i); if(ref_node) { axiom_node_add_child(header_block_node, env, ref_node); } } } return AXIS2_SUCCESS; }