| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <axis2_addr_mod.h> |
| #include <axis2_addr.h> |
| #include <axis2_handler_desc.h> |
| #include <axis2_array_list.h> |
| #include <axis2_soap_envelope.h> |
| #include <axis2_soap_header.h> |
| #include <axis2_soap_header_block.h> |
| #include <axis2_op.h> |
| #include <axis2_msg_ctx.h> |
| #include <axis2_msg_info_headers.h> |
| #include <axis2_property.h> |
| |
| axis2_status_t AXIS2_CALL |
| axis2_addr_in_handler_invoke(struct axis2_handler *handler, |
| axis2_env_t **env, |
| struct axis2_msg_ctx *msg_ctx); |
| |
| axis2_bool_t |
| axis2_addr_in_check_element(axis2_env_t **env, axis2_qname_t *expected_qname, |
| axis2_qname_t *actual_qname); |
| |
| axis2_status_t |
| axis2_addr_in_extract_svc_grp_ctx_id(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_ctx_t *msg_ctx); |
| |
| axis2_status_t |
| axis2_addr_in_extract_ref_params(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t *msg_info_headers); |
| |
| axis2_status_t |
| axis2_addr_in_extract_addr_final_info(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers, |
| axis2_array_list_t *addr_headers); |
| |
| |
| axis2_status_t |
| axis2_addr_in_extract_to_epr_ref_params(axis2_env_t **env, |
| axis2_endpoint_ref_t * to_epr, |
| axis2_soap_header_t *soap_header, |
| axis2_char_t *addr_ns); |
| |
| axis2_status_t |
| axis2_addr_in_extract_epr_information(axis2_env_t **env, |
| axis2_soap_header_block_t *soap_header_block, |
| axis2_endpoint_ref_t *endpoint_ref, |
| axis2_char_t *addr_ns); |
| |
| axis2_status_t |
| axis2_addr_in_extract_addr_params(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers, |
| axis2_array_list_t *addr_headers, |
| axis2_char_t *addr_ns); |
| |
| axis2_status_t axis2_addr_in_extract_addr_submission_info(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers, |
| axis2_array_list_t *addr_headers); |
| |
| /******************************************************************************/ |
| |
| AXIS2_DECLARE(axis2_handler_t*) |
| axis2_addr_in_handler_create(axis2_env_t **env, |
| axis2_qname_t *qname) |
| { |
| axis2_handler_t *handler = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| handler = axis2_handler_create(env); |
| if (!handler) |
| { |
| return NULL; |
| } |
| |
| /* handler init is handled by conf loading, so no need to do it here */ |
| |
| /* set the base struct's invoke op */ |
| if (handler->ops) |
| handler->ops->invoke = axis2_addr_in_handler_invoke; |
| |
| return handler; |
| } |
| |
| |
| axis2_status_t AXIS2_CALL |
| axis2_addr_in_handler_invoke(struct axis2_handler *handler, |
| axis2_env_t **env, |
| struct axis2_msg_ctx *msg_ctx) |
| { |
| axis2_soap_envelope_t *soap_envelope = NULL; |
| axis2_soap_header_t *soap_header = NULL; |
| axis2_property_t *property = NULL; |
| |
| AXIS2_ENV_CHECK( env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE); |
| |
| /*op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env); |
| svc_ctx = AXIS2_MSG_CTX_GET_SVC_CTX(msg_ctx, env);*/ |
| |
| AXIS2_LOG_INFO((*env)->log, "Starting addressing in handler ........."); |
| |
| soap_envelope = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env); |
| |
| if (soap_envelope) |
| { |
| soap_header = AXIS2_SOAP_ENVELOPE_GET_HEADER(soap_envelope, env); |
| if (soap_header) |
| { |
| axis2_array_list_t *addr_headers = NULL; |
| axis2_ctx_t *ctx = NULL; |
| axis2_char_t *addr_ns_str = NULL; |
| axis2_msg_info_headers_t *msg_info_headers = AXIS2_MSG_CTX_GET_MSG_INFO_HEADERS(msg_ctx, env); |
| |
| addr_headers = AXIS2_SOAP_HEADER_GET_HEADER_BLOCKS_WITH_NAMESPACE_URI(soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION); |
| if (addr_headers) |
| { |
| addr_ns_str = AXIS2_STRDUP(AXIS2_WSA_NAMESPACE_SUBMISSION, env); |
| axis2_addr_in_extract_addr_submission_info(env, |
| soap_header, |
| &msg_info_headers, |
| addr_headers); |
| } |
| else |
| { |
| addr_headers = AXIS2_SOAP_HEADER_GET_HEADER_BLOCKS_WITH_NAMESPACE_URI(soap_header, env, AXIS2_WSA_NAMESPACE); |
| if (addr_headers) |
| { |
| addr_ns_str = AXIS2_STRDUP(AXIS2_WSA_NAMESPACE, env); |
| axis2_addr_in_extract_addr_final_info(env, |
| soap_header, |
| &msg_info_headers, |
| addr_headers); |
| axis2_addr_in_extract_ref_params(env, soap_header, AXIS2_MSG_CTX_GET_MSG_INFO_HEADERS(msg_ctx, env)); |
| |
| } |
| else |
| { |
| /* addressing headers are not present in the SOAP message*/ |
| /*logger.debug( |
| "No Addressing Headers present in the IN message. Addressing In Handler does nothing."); |
| */ |
| /** TODO : set the error */ |
| AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, "No Addressing Headers present in the IN message. Addressing In Handler cannot do anything."); |
| return AXIS2_FAILURE; |
| } |
| } |
| |
| ctx = AXIS2_MSG_CTX_GET_BASE(msg_ctx, env); |
| if (ctx) |
| { |
| property = axis2_property_create(env); |
| AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); |
| AXIS2_PROPERTY_SET_VALUE(property, env, addr_ns_str); |
| AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_WSA_VERSION, property, AXIS2_TRUE); |
| } |
| |
| /* extract service group context, if available */ |
| axis2_addr_in_extract_svc_grp_ctx_id(env, soap_header, msg_ctx); |
| |
| AXIS2_ARRAY_LIST_FREE(addr_headers, env); |
| return AXIS2_SUCCESS; |
| } |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t |
| axis2_addr_in_extract_svc_grp_ctx_id(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_ctx_t *msg_ctx) |
| { |
| axis2_om_node_t *node = NULL; |
| axis2_om_element_t *element = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| node = AXIS2_SOAP_HEADER_GET_BASE_NODE(soap_header, env); |
| if (node && AXIS2_OM_NODE_GET_NODE_TYPE(node, env) == AXIS2_OM_ELEMENT) |
| { |
| axis2_qname_t *qname = NULL; |
| element = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env); |
| qname = axis2_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI, |
| AXIS2_NAMESPACE_PREFIX); |
| if (qname) |
| { |
| axis2_om_node_t *child_node = NULL; |
| axis2_om_element_t *child_element = NULL; |
| child_element = AXIS2_OM_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 = AXIS2_OM_ELEMENT_GET_TEXT(child_element, env, |
| child_node); |
| conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env); |
| if (conf_ctx && 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) |
| { |
| /** TODO, set error */ |
| return AXIS2_FAILURE; |
| } |
| AXIS2_MSG_CTX_SET_SVC_GRP_CTX_ID(msg_ctx, env, grp_id); |
| return AXIS2_SUCCESS; |
| } |
| } |
| } |
| AXIS2_QNAME_FREE(qname, env); |
| } |
| /** TODO, set error */ |
| return AXIS2_FAILURE; |
| } |
| |
| |
| |
| axis2_status_t |
| axis2_addr_in_extract_addr_final_info(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers, |
| axis2_array_list_t *addr_headers) |
| { |
| return axis2_addr_in_extract_addr_params(env, |
| soap_header, |
| msg_info_headers, |
| addr_headers, |
| AXIS2_WSA_NAMESPACE); |
| } |
| |
| axis2_status_t axis2_addr_in_extract_addr_submission_info(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers, |
| axis2_array_list_t *addr_headers) |
| { |
| return axis2_addr_in_extract_addr_params(env, |
| soap_header, |
| msg_info_headers, |
| addr_headers, |
| AXIS2_WSA_NAMESPACE_SUBMISSION); |
| } |
| |
| axis2_status_t |
| axis2_addr_in_extract_addr_params(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t **msg_info_headers_p, |
| axis2_array_list_t *addr_headers, |
| axis2_char_t *addr_ns_str) |
| { |
| axis2_hash_t *header_block_ht = NULL; |
| axis2_hash_index_t *hash_index = NULL; |
| axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p); |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| 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) |
| msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); |
| if (!msg_info_headers) |
| return AXIS2_FAILURE; |
| |
| header_block_ht = AXIS2_SOAP_HEADER_GET_ALL_HEADER_BLOCKS(soap_header, env); |
| if(!header_block_ht) |
| return AXIS2_FAILURE; |
| |
| for(hash_index = axis2_hash_first(header_block_ht, env); hash_index; |
| hash_index = axis2_hash_next(env, hash_index)) |
| { |
| void *hb = NULL; |
| axis2_soap_header_block_t *header_block = NULL; |
| axis2_om_node_t *header_block_node = NULL; |
| axis2_om_element_t *header_block_ele = NULL; |
| axis2_char_t *ele_localname = NULL; |
| axis2_endpoint_ref_t *epr = NULL; |
| |
| axis2_hash_this(hash_index, NULL, NULL, &hb); |
| |
| header_block = (axis2_soap_header_block_t *)hb; |
| header_block_node = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE(header_block, env); |
| header_block_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(header_block_node, env); |
| ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(header_block_ele, env); |
| |
| if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_TO) == 0) |
| { |
| /* here the addressing epr overidde what ever already there in the message context */ |
| |
| epr = axis2_endpoint_ref_create(env, AXIS2_OM_ELEMENT_GET_TEXT(header_block_ele, env, header_block_node)); |
| 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); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_FROM) == 0) |
| { |
| epr = AXIS2_MSG_INFO_HEADERS_GET_FROM(msg_info_headers, env); |
| if(!epr) |
| { |
| /* I don't know the address now. Let me pass the empty |
| string now and fill this once I process the Elements under this. */ |
| |
| |
| 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); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if( AXIS2_STRCMP(ele_localname, AXIS2_WSA_REPLY_TO) == 0) |
| { |
| epr = AXIS2_MSG_INFO_HEADERS_GET_REPLY_TO(msg_info_headers, env); |
| 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); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_FAULT_TO) == 0) |
| { |
| epr = AXIS2_MSG_INFO_HEADERS_GET_FAULT_TO(msg_info_headers , env); |
| 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); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_MESSAGE_ID) == 0) |
| { |
| axis2_char_t *text = NULL; |
| text = AXIS2_OM_ELEMENT_GET_TEXT(header_block_ele, env, header_block_node); |
| AXIS2_MSG_INFO_HEADERS_SET_MESSAGE_ID(msg_info_headers, env, text); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_ACTION) == 0) |
| { |
| axis2_char_t *text = NULL; |
| text = AXIS2_OM_ELEMENT_GET_TEXT(header_block_ele, env, header_block_node); |
| AXIS2_MSG_INFO_HEADERS_SET_ACTION(msg_info_headers, env, text); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_WSA_RELATES_TO) == 0) |
| { |
| axis2_char_t *address = NULL; |
| axis2_qname_t *rqn = NULL; |
| axis2_om_attribute_t *relationship_type = NULL; |
| axis2_char_t *relationship_type_default_value = NULL; |
| axis2_char_t *relationship_type_value = NULL; |
| axis2_relates_to_t *relates_to = NULL; |
| if(AXIS2_STRCMP(AXIS2_WSA_NAMESPACE_SUBMISSION , addr_ns_str) == 0) |
| { |
| relationship_type_default_value = |
| AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION; |
| } |
| else |
| { |
| relationship_type_default_value = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; |
| } |
| rqn = axis2_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, NULL, NULL); |
| |
| relationship_type = AXIS2_OM_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 = AXIS2_OM_ATTRIBUTE_GET_VALUE(relationship_type, env); |
| } |
| |
| address = AXIS2_OM_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); |
| AXIS2_SOAP_HEADER_BLOCK_SET_PRECESSED(header_block, env); |
| |
| AXIS2_QNAME_FREE(rqn, env); |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t |
| axis2_addr_in_extract_epr_information(axis2_env_t **env, |
| axis2_soap_header_block_t *soap_header_block, |
| axis2_endpoint_ref_t *endpoint_ref, |
| axis2_char_t *addr_ns_str) |
| { |
| axis2_qname_t *epr_addr_qn = NULL; |
| axis2_qname_t *epr_ref_qn = NULL; |
| axis2_qname_t *wsa_meta_qn = NULL; |
| axis2_om_node_t *header_block_node = NULL; |
| axis2_om_element_t *header_block_ele = NULL; |
| axis2_om_child_element_iterator_t *child_ele_iter = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| 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 = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE(soap_header_block, env); |
| header_block_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(header_block_node, env); |
| |
| |
| child_ele_iter = AXIS2_OM_ELEMENT_GET_CHILD_ELEMENTS(header_block_ele, env, header_block_node); |
| if(!child_ele_iter) |
| return AXIS2_FAILURE; |
| epr_addr_qn = axis2_qname_create(env, EPR_ADDRESS, addr_ns_str, NULL); |
| epr_ref_qn = axis2_qname_create(env, EPR_REFERENCE_PARAMETERS, addr_ns_str, NULL); |
| wsa_meta_qn = axis2_qname_create(env, AXIS2_WSA_METADATA, addr_ns_str, NULL); |
| while(AXIS2_OM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(child_ele_iter, env)) |
| { |
| axis2_om_node_t *child_node = NULL; |
| axis2_om_element_t *child_ele = NULL; |
| axis2_qname_t *child_qn = NULL; |
| child_node = AXIS2_OM_CHILD_ELEMENT_ITERATOR_NEXT(child_ele_iter, env); |
| child_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(child_node, env); |
| |
| |
| child_qn = AXIS2_OM_ELEMENT_GET_QNAME(child_ele, env); |
| if(axis2_addr_in_check_element(env, epr_addr_qn, child_qn )) |
| { |
| AXIS2_ENDPOINT_REF_SET_ADDRESS(endpoint_ref, env, |
| AXIS2_OM_ELEMENT_GET_TEXT(child_ele, env, child_node)); |
| } |
| else if(axis2_addr_in_check_element(env, epr_ref_qn , child_qn)) |
| { |
| axis2_om_child_element_iterator_t *ref_param_iter = NULL; |
| |
| /*axis2_any_content_type_t *any_content_type = NULL; |
| any_content_type = AXIS2_ENDPOINT_REF_GET_REF_PARAMS(endpoint_ref, env); |
| if(any_content_type == NULL) |
| { |
| any_content_type = axis2_any_content_type_create(env); |
| AXIS2_ENDPOINT_REF_SET_REF_PARAMS(endpoint_ref, env, any_content_type); |
| } */ |
| |
| ref_param_iter = AXIS2_OM_ELEMENT_GET_CHILD_ELEMENTS(child_ele, env, child_node); |
| if(ref_param_iter) |
| { |
| while(AXIS2_OM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(ref_param_iter, env)) |
| { |
| axis2_om_node_t *om_node = NULL; |
| axis2_om_element_t *om_ele = NULL; |
| /*axis2_any_content_type_t *any_content = NULL;*/ |
| om_node = AXIS2_OM_CHILD_ELEMENT_ITERATOR_NEXT(ref_param_iter, env); |
| om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(om_node, env); |
| /*any_content = AXIS2_ENDPOINT_REF_GET_REF_PARAMS(endpoint_ref, env); |
| if(any_content && om_ele) |
| { |
| AXIS2_ANY_CONTENT_TYPE_ADD_VALUE(any_content, env, |
| AXIS2_OM_ELEMENT_GET_QNAME(om_ele, env), AXIS2_OM_ELEMENT_GET_TEXT(om_ele, env, om_node)); |
| |
| } */ |
| } |
| } |
| |
| }else if(axis2_addr_in_check_element(env, wsa_meta_qn, child_qn)) |
| { |
| /*axis2_any_content_type_t *any_content_type = AXIS2_ENDPOINT_REF_GET_METADATA(endpoint_ref, env); |
| if(any_content_type) |
| { |
| AXIS2_ANY_CONTENT_TYPE_ADD_VALUE(any_content_type, env, |
| child_qn , AXIS2_OM_ELEMENT_GET_TEXT(child_ele, env, child_node)); |
| } */ |
| |
| } |
| } |
| AXIS2_QNAME_FREE(epr_addr_qn, env); |
| AXIS2_QNAME_FREE(epr_ref_qn, env); |
| AXIS2_QNAME_FREE(wsa_meta_qn, env); |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| |
| |
| |
| /** |
| * WSA 1.0 specification mandates all the reference parameters to have a attribute as wsa:Type=???parameter???. So |
| * here this will check for soap_header blocks with the above attribute and will put them in message information soap_header collection |
| * |
| * @param soap_header |
| * @param messageInformationHeaders |
| */ |
| axis2_status_t |
| axis2_addr_in_extract_ref_params(axis2_env_t **env, |
| axis2_soap_header_t *soap_header, |
| axis2_msg_info_headers_t* msg_info_headers) |
| { |
| axis2_hash_t *header_block_ht = NULL; |
| axis2_hash_index_t *hash_index = NULL; |
| axis2_qname_t *wsa_qname = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, soap_header, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, msg_info_headers, AXIS2_FAILURE); |
| |
| header_block_ht = AXIS2_SOAP_HEADER_GET_ALL_HEADER_BLOCKS(soap_header, env); |
| if(!header_block_ht) |
| return AXIS2_FAILURE; |
| wsa_qname = axis2_qname_create(env, AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, |
| AXIS2_WSA_NAMESPACE, NULL); |
| |
| for(hash_index = axis2_hash_first(header_block_ht, env); hash_index; |
| hash_index = axis2_hash_next(env, hash_index)) |
| { |
| void *hb = NULL; |
| axis2_soap_header_block_t *header_block = NULL; |
| axis2_om_node_t *header_block_node = NULL; |
| axis2_om_element_t *header_block_ele = NULL; |
| |
| axis2_hash_this(hash_index, NULL, NULL, &hb); |
| |
| header_block = (axis2_soap_header_block_t *)hb; |
| header_block_node = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE(header_block, env); |
| |
| if(header_block_node && |
| (AXIS2_OM_NODE_GET_NODE_TYPE(header_block_node, env) == AXIS2_OM_ELEMENT)) |
| { |
| axis2_om_attribute_t *om_attr = NULL; |
| axis2_char_t *attr_value = NULL; |
| header_block_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(header_block_node, env); |
| om_attr = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(header_block_ele, env, wsa_qname); |
| if(om_attr) |
| { |
| attr_value = AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attr, env); |
| if(AXIS2_STRCMP(attr_value, AXIS2_WSA_TYPE_ATTRIBUTE_VALUE) == 0) |
| { |
| AXIS2_MSG_INFO_HEADERS_ADD_REF_PARAM(msg_info_headers, env, header_block_node); |
| } |
| } |
| } |
| } |
| |
| AXIS2_QNAME_FREE(wsa_qname, env); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| axis2_status_t |
| axis2_addr_in_extract_to_epr_ref_params(axis2_env_t **env, |
| axis2_endpoint_ref_t * to_epr, |
| axis2_soap_header_t *soap_header, |
| axis2_char_t *addr_ns_str) |
| { |
| axis2_hash_t *header_blocks_ht = NULL; |
| axis2_hash_index_t *hash_index = NULL; |
| axis2_qname_t *is_ref_qn = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| 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 = AXIS2_SOAP_HEADER_GET_ALL_HEADER_BLOCKS(soap_header, env); |
| if(!header_blocks_ht) |
| return AXIS2_FAILURE; |
| |
| is_ref_qn = axis2_qname_create(env, "IsReferenceParameter",addr_ns_str, NULL); |
| if(!is_ref_qn) |
| return AXIS2_FAILURE; |
| |
| for(hash_index = axis2_hash_first(header_blocks_ht, env); hash_index; |
| hash_index = axis2_hash_next( env, hash_index)) |
| { |
| axis2_om_element_t *header_block_ele = NULL; |
| axis2_om_node_t *header_block_node = NULL; |
| axis2_soap_header_block_t *header_block = NULL; |
| void *hb = NULL; |
| axis2_om_attribute_t *is_ref_param_attr = NULL; |
| axis2_char_t *attr_value = NULL; |
| |
| axis2_hash_this(hash_index, NULL, NULL, &hb); |
| if(hb) |
| { |
| header_block = (axis2_soap_header_block_t*)hb; |
| header_block_node = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE(header_block, env); |
| header_block_ele = (axis2_om_element_t*) |
| AXIS2_OM_NODE_GET_DATA_ELEMENT(header_block_node, env); |
| is_ref_param_attr = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(header_block_ele, env, is_ref_qn); |
| if(is_ref_param_attr) |
| { |
| attr_value = AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(is_ref_param_attr, env); |
| if(AXIS2_STRCMP("true", attr_value) == 0) |
| { |
| AXIS2_ENDPOINT_REF_ADD_REF_PARAM(to_epr, env, header_block_node); |
| /* |
| AXIS2_OM_ELEMENT_GET_QNAME(header_block_ele, env), |
| AXIS2_OM_ELEMENT_GET_TEXT(header_block_ele, env, header_block_node));*/ |
| } |
| } |
| } |
| } |
| |
| AXIS2_QNAME_FREE(is_ref_qn, env); |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| axis2_bool_t |
| axis2_addr_in_check_element(axis2_env_t **env, |
| axis2_qname_t *expected_qname, |
| axis2_qname_t *actual_qname) |
| { |
| axis2_char_t *exp_qn_lpart = NULL; |
| axis2_char_t *act_qn_lpart = NULL; |
| axis2_char_t *exp_qn_nsuri = NULL; |
| axis2_char_t *act_qn_nsuri = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, expected_qname, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, actual_qname, AXIS2_FAILURE); |
| |
| exp_qn_lpart = AXIS2_QNAME_GET_LOCALPART(expected_qname, env); |
| act_qn_lpart = AXIS2_QNAME_GET_LOCALPART(actual_qname, env); |
| |
| exp_qn_nsuri = AXIS2_QNAME_GET_LOCALPART(expected_qname, env); |
| act_qn_nsuri = AXIS2_QNAME_GET_LOCALPART(actual_qname, env); |
| |
| return ((AXIS2_STRCMP(exp_qn_lpart, act_qn_lpart) == 0) && |
| (AXIS2_STRCMP(exp_qn_nsuri,act_qn_nsuri) == 0)); |
| } |
