| /* |
| * 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_soap_builder.h> |
| #include <axis2_soap_message.h> |
| #include <axis2_soap_envelope.h> |
| #include <axis2_soap_header.h> |
| #include <axis2_soap11_builder_helper.h> |
| #include <axis2_soap12_builder_helper.h> |
| #include <axis2_soap.h> |
| #include <axis2_soap_body.h> |
| #include <axis2_soap_header_block.h> |
| |
| /*********************** impl struct *****************************************/ |
| |
| typedef struct axis2_soap_builder_impl_t |
| { |
| axis2_soap_builder_t soap_builder; |
| |
| axis2_om_stax_builder_t *om_builder; |
| |
| axis2_soap_message_t *soap_message; |
| |
| axis2_soap_envelope_t *soap_envelope; |
| |
| axis2_bool_t header_present; |
| |
| axis2_bool_t body_present; |
| |
| int element_level; |
| |
| axis2_bool_t processing_fault; |
| |
| axis2_bool_t processing_detail_elements; |
| |
| axis2_char_t* sender_fault_code; |
| |
| axis2_char_t* receiver_fault_code; |
| |
| axis2_bool_t processing_mandatory_fault_elements; |
| |
| void *builder_helper; |
| |
| axis2_om_namespace_t *envelope_ns; |
| |
| int soap_version; |
| |
| int last_node_status; |
| |
| axis2_bool_t done; |
| }axis2_soap_builder_impl_t; |
| |
| typedef enum axis2_builder_last_node_states |
| { |
| AXIS2_BUILDER_LAST_NODE_NULL = 0, |
| AXIS2_BUILDER_LAST_NODE_DONE_TRUE, |
| AXIS2_BUILDER_LAST_NODE_DONE_FALSE |
| }axis2_builder_last_node_states; |
| |
| #define AXIS2_MAX_EVENT 100 |
| |
| |
| /***************** Macro ******************************************************/ |
| |
| #define AXIS2_INTF_TO_IMPL(builder) ((axis2_soap_builder_impl_t*)builder) |
| |
| /**************** function prototypes ****************************************/ |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_free(axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| axis2_soap_envelope_t* AXIS2_CALL |
| axis2_soap_builder_get_soap_envelope |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| axis2_om_document_t* AXIS2_CALL |
| axis2_soap_builder_get_document |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_next(axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| axis2_om_node_t* AXIS2_CALL |
| axis2_soap_builder_get_document_element |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| axis2_status_t |
| axis2_soap_builder_create_om_element |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *current_node); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_process_namespace_data |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *om_node, |
| int is_soap_element); |
| |
| static axis2_status_t |
| axis2_soap_builder_identify_soap_version(axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_char_t* soap_version_uri_from_transport); |
| |
| static axis2_status_t |
| axis2_soap_builder_construct_node(axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *parent, |
| axis2_om_node_t *element_node, |
| axis2_bool_t is_soap_envelope); |
| |
| static axis2_status_t |
| axis2_soap_builder_parse_headers(axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_set_bool_processing_mandatory_fault_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_bool_t value); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_set_processing_detail_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_bool_t value); |
| |
| axis2_bool_t AXIS2_CALL |
| axis2_soap_builder_is_processing_detail_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| int AXIS2_CALL |
| axis2_soap_builder_get_soap_version (axis2_soap_builder_t *builder, |
| axis2_env_t **env); |
| |
| /***************** function implementations ***********************************/ |
| |
| AXIS2_DECLARE(axis2_soap_builder_t *) |
| axis2_soap_builder_create(axis2_env_t **env, |
| axis2_om_stax_builder_t *builder, |
| axis2_char_t *soap_version) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK((*env)->error, builder, NULL); |
| |
| builder_impl = (axis2_soap_builder_impl_t*)AXIS2_MALLOC((*env)->allocator, |
| sizeof(axis2_soap_builder_impl_t)); |
| if(builder_impl == NULL) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| builder_impl->done = AXIS2_FALSE; |
| builder_impl->body_present = AXIS2_FALSE; |
| builder_impl->builder_helper = NULL; |
| builder_impl->element_level= 0; |
| builder_impl->header_present = AXIS2_FALSE; |
| builder_impl->om_builder = NULL; |
| builder_impl->processing_detail_elements = AXIS2_FALSE; |
| builder_impl->processing_fault = AXIS2_FALSE; |
| builder_impl->processing_mandatory_fault_elements = AXIS2_FALSE; |
| builder_impl->receiver_fault_code = NULL; |
| builder_impl->sender_fault_code = NULL; |
| builder_impl->soap_version = AXIS2_SOAP12; |
| builder_impl->soap_builder.ops = NULL; |
| builder_impl->last_node_status = -1; |
| builder_impl->envelope_ns = NULL; |
| builder_impl->soap_envelope = NULL; |
| builder_impl->soap_message = NULL; |
| builder_impl->soap_builder.ops = (axis2_soap_builder_ops_t*) |
| AXIS2_MALLOC((*env)->allocator, sizeof(axis2_soap_builder_ops_t)); |
| if(!(builder_impl->soap_builder.ops)) |
| { |
| AXIS2_FREE((*env)->allocator, builder_impl); |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| builder_impl->om_builder = builder; |
| builder_impl->soap_builder.ops->free = |
| axis2_soap_builder_free; |
| builder_impl->soap_builder.ops->next = |
| axis2_soap_builder_next; |
| builder_impl->soap_builder.ops->get_soap_envelope = |
| axis2_soap_builder_get_soap_envelope; |
| builder_impl->soap_builder.ops->get_document = |
| axis2_soap_builder_get_document; |
| builder_impl->soap_builder.ops->set_bool_processing_mandatory_fault_elements = |
| axis2_soap_builder_set_bool_processing_mandatory_fault_elements; |
| builder_impl->soap_builder.ops->set_processing_detail_elements = |
| axis2_soap_builder_set_processing_detail_elements; |
| builder_impl->soap_builder.ops->is_processing_detail_elements = |
| axis2_soap_builder_is_processing_detail_elements; |
| builder_impl->soap_builder.ops->get_soap_version = |
| axis2_soap_builder_get_soap_version; |
| builder_impl->soap_builder.ops->process_namespace_data = |
| axis2_soap_builder_process_namespace_data; |
| |
| status = axis2_soap_builder_identify_soap_version(&(builder_impl->soap_builder), env, soap_version); |
| if(status == AXIS2_FAILURE) |
| { |
| axis2_soap_builder_free(&(builder_impl->soap_builder), env); |
| return NULL; |
| } |
| status = axis2_soap_builder_parse_headers(&(builder_impl->soap_builder), env); |
| if(status == AXIS2_FAILURE) |
| { |
| axis2_soap_builder_free(&(builder_impl->soap_builder), env); |
| return NULL; |
| } |
| return &(builder_impl->soap_builder); |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_free(axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| if(builder_impl->builder_helper) |
| { |
| if(builder_impl->soap_version == AXIS2_SOAP11 && builder_impl->builder_helper) |
| { |
| AXIS2_SOAP11_BUILDER_HELPER_FREE((axis2_soap11_builder_helper_t *)(builder_impl->builder_helper), env); |
| } |
| else if(builder_impl->soap_version == AXIS2_SOAP12 && builder_impl->builder_helper) |
| { |
| AXIS2_SOAP12_BUILDER_HELPER_FREE((axis2_soap12_builder_helper_t *)(builder_impl->builder_helper), env); |
| } |
| } |
| if(builder->ops) |
| { |
| AXIS2_FREE((*env)->allocator, builder->ops); |
| } |
| AXIS2_FREE((*env)->allocator, builder_impl); |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| axis2_soap_envelope_t* AXIS2_CALL |
| axis2_soap_builder_get_soap_envelope |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| int status = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, NULL); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| |
| if(!(builder_impl->om_builder)) |
| return NULL; |
| |
| while(!(builder_impl->soap_envelope) && |
| !AXIS2_OM_STAX_BUILDER_IS_COMPLETE(builder_impl->om_builder, env)) |
| { |
| status = axis2_soap_builder_next(builder, env); |
| if(status == AXIS2_FAILURE) |
| break; |
| } |
| |
| return builder_impl->soap_envelope; |
| } |
| |
| axis2_om_document_t* AXIS2_CALL |
| axis2_soap_builder_get_document |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| return AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(builder_impl->om_builder, env); |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_next(axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| axis2_om_node_t *lastnode = NULL; |
| int current_event = AXIS2_MAX_EVENT; |
| axis2_om_node_t *current_node = NULL; |
| int status = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| if(builder_impl->done) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| lastnode = AXIS2_OM_STAX_BUILDER_GET_LAST_NODE(builder_impl->om_builder, env); |
| |
| if(!lastnode) |
| { |
| builder_impl->last_node_status = AXIS2_BUILDER_LAST_NODE_NULL; |
| }/*else if(AXIS2_OM_NODE_GET_BUILD_STATUS(lastnode, env)) |
| { |
| builder_impl->last_node_status = AXIS2_BUILDER_LAST_NODE_DONE_TRUE; |
| }*/ |
| else |
| { |
| builder_impl->last_node_status = AXIS2_BUILDER_LAST_NODE_DONE_FALSE; |
| } |
| /* |
| current_node = AXIS2_OM_STAX_BUILDER_NEXT(builder_impl->om_builder, env); |
| */ |
| current_event = AXIS2_OM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_impl->om_builder, env); |
| /* |
| current_event = AXIS2_OM_STAX_BUILDER_GET_CURRENT_EVENT(builder_impl->om_builder, env); |
| */ |
| if(current_event == -1) |
| { |
| builder_impl->done = AXIS2_TRUE; |
| return AXIS2_FAILURE; |
| } |
| if(current_event == AXIS2_XML_READER_EMPTY_ELEMENT || |
| current_event == AXIS2_XML_READER_START_ELEMENT) |
| { |
| current_node = AXIS2_OM_STAX_BUILDER_GET_LAST_NODE(builder_impl->om_builder, env); |
| |
| status = axis2_soap_builder_create_om_element(builder, env, current_node); |
| } |
| |
| return status; |
| } |
| |
| axis2_om_node_t* AXIS2_CALL |
| axis2_soap_builder_get_document_element |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| return AXIS2_SOAP_ENVELOPE_GET_BASE_NODE(builder_impl->soap_envelope, env); |
| } |
| |
| |
| |
| axis2_status_t |
| axis2_soap_builder_create_om_element |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *current_node) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| int ret_val = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, current_node, AXIS2_FAILURE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| if(builder_impl->last_node_status == AXIS2_BUILDER_LAST_NODE_NULL) |
| { |
| |
| ret_val = axis2_soap_builder_construct_node(builder, env, NULL, current_node, AXIS2_TRUE); |
| |
| }/*else if(builder_impl->last_node_status == AXIS2_BUILDER_LAST_NODE_DONE_TRUE) |
| { |
| ret_val = axis2_soap_builder_construct_node(builder, env, |
| AXIS2_OM_NODE_GET_PARENT(current_node, env), current_node, AXIS2_FALSE); |
| |
| }*/ |
| else |
| { |
| ret_val = axis2_soap_builder_construct_node(builder, env, |
| AXIS2_OM_NODE_GET_PARENT(current_node, env), current_node, AXIS2_FALSE); |
| } |
| return ret_val; |
| } |
| |
| static axis2_status_t |
| axis2_soap_builder_construct_node(axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *parent, |
| axis2_om_node_t *om_element_node, |
| axis2_bool_t is_soap_envelope) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| |
| axis2_om_element_t *parent_ele = NULL; |
| axis2_char_t *parent_localname = NULL; |
| |
| axis2_om_element_t *om_element = NULL; |
| axis2_char_t *ele_localname = NULL; |
| |
| int element_level = 0; |
| int status = AXIS2_SUCCESS; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, om_element_node, AXIS2_FAILURE); |
| |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| |
| |
| element_level = AXIS2_OM_STAX_BUILDER_GET_ELEMENT_LEVEL( |
| builder_impl->om_builder, env); |
| |
| om_element = (axis2_om_element_t *) |
| AXIS2_OM_NODE_GET_DATA_ELEMENT(om_element_node, env); |
| |
| ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_element, env); |
| |
| |
| if(parent) |
| { |
| parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(parent, env); |
| parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_ele, env); |
| } |
| if(!parent && is_soap_envelope) |
| { |
| |
| if(AXIS2_STRCASECMP(ele_localname, AXIS2_SOAP_ENVELOPE_LOCAL_NAME) != 0) |
| { |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_MESSAGE_FIRST_ELEMENT_MUST_CONTAIN_LOCAL_NAME, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| builder_impl->soap_envelope = axis2_soap_envelope_create_null(env); |
| |
| status = AXIS2_SOAP_ENVELOPE_SET_BASE_NODE(builder_impl->soap_envelope, |
| env, om_element_node); |
| |
| AXIS2_SOAP_ENVELOPE_SET_BUILDER(builder_impl->soap_envelope, env, builder); |
| |
| status = axis2_soap_builder_process_namespace_data(builder, env, om_element_node, AXIS2_TRUE); |
| if(status == AXIS2_FAILURE) |
| return AXIS2_FAILURE; |
| } |
| else if(element_level == 2) |
| { |
| if(AXIS2_STRCMP(ele_localname, AXIS2_SOAP_HEADER_LOCAL_NAME) == 0) |
| { |
| axis2_soap_header_t *soap_header = NULL; |
| if(builder_impl->header_present) |
| { |
| printf("AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED"); |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| if(builder_impl->body_present) |
| { |
| printf("AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER"); |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| builder_impl->header_present = AXIS2_TRUE; |
| soap_header = axis2_soap_header_create(env); |
| AXIS2_SOAP_HEADER_SET_BASE_NODE(soap_header, env, om_element_node); |
| AXIS2_SOAP_HEADER_SET_SOAP_VERSION(soap_header, env, builder_impl->soap_version); |
| AXIS2_SOAP_ENVELOPE_SET_HEADER(builder_impl->soap_envelope, env, soap_header); |
| AXIS2_SOAP_HEADER_SET_BUILDER(soap_header, env, builder); |
| status = axis2_soap_builder_process_namespace_data(builder, env, |
| om_element_node, AXIS2_TRUE); |
| if(status == AXIS2_FAILURE) |
| return AXIS2_FAILURE; |
| |
| } |
| else if(AXIS2_STRCMP(ele_localname, AXIS2_SOAP_BODY_LOCAL_NAME) == 0) |
| { |
| |
| axis2_soap_body_t *soap_body = NULL; |
| if(builder_impl->body_present) |
| { |
| printf("AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED"); |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| |
| } |
| builder_impl->body_present = AXIS2_TRUE; |
| soap_body = axis2_soap_body_create(env); |
| AXIS2_SOAP_BODY_SET_BASE_NODE(soap_body, env, om_element_node); |
| AXIS2_SOAP_BODY_SET_SOAP_VERSION(soap_body, env, builder_impl->soap_version); |
| AXIS2_SOAP_BODY_SET_BUILDER(soap_body, env, builder); |
| AXIS2_SOAP_ENVELOPE_SET_BODY(builder_impl->soap_envelope, env, soap_body); |
| status = axis2_soap_builder_process_namespace_data(builder, env, |
| om_element_node, AXIS2_TRUE); |
| if(status == AXIS2_FAILURE) |
| return AXIS2_FAILURE; |
| } |
| else |
| { |
| printf("AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY"); |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| } |
| else if((element_level == 3) && AXIS2_STRCASECMP(parent_localname, |
| AXIS2_SOAP_HEADER_LOCAL_NAME) == 0) |
| { |
| axis2_soap_header_block_t *header_block = NULL; |
| axis2_soap_header_t *soap_header = NULL; |
| header_block = axis2_soap_header_block_create(env); |
| AXIS2_SOAP_HEADER_BLOCK_SET_BASE_NODE(header_block, env, om_element_node); |
| AXIS2_SOAP_HEADER_BLOCK_SET_SOAP_VERSION(header_block, env, builder_impl->soap_version); |
| soap_header = AXIS2_SOAP_ENVELOPE_GET_HEADER(builder_impl->soap_envelope, env); |
| AXIS2_SOAP_HEADER_SET_HEADER_BLOCK(soap_header, env, header_block); |
| |
| } |
| else if((element_level == 3) && |
| AXIS2_STRCASECMP(parent_localname, AXIS2_SOAP_BODY_LOCAL_NAME) == 0 && |
| AXIS2_STRCASECMP(ele_localname, AXIS2_SOAP_BODY_FAULT_LOCAL_NAME) == 0) |
| { |
| axis2_soap_body_t *soap_body = NULL; |
| axis2_soap_fault_t *soap_fault = NULL; |
| axis2_om_node_t *envelope_node = NULL; |
| axis2_om_element_t *envelope_ele = NULL; |
| axis2_om_namespace_t *env_ns = NULL; |
| envelope_node = AXIS2_SOAP_ENVELOPE_GET_BASE_NODE( |
| builder_impl->soap_envelope, env); |
| envelope_ele = (axis2_om_element_t *) |
| AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_node, env); |
| env_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(envelope_ele, env); |
| |
| soap_body = AXIS2_SOAP_ENVELOPE_GET_BODY(builder_impl->soap_envelope, env); |
| if(!soap_body ) |
| return AXIS2_FAILURE; |
| soap_fault = axis2_soap_fault_create(env); |
| if(!soap_fault) |
| return AXIS2_FAILURE; |
| AXIS2_SOAP_FAULT_SET_BASE_NODE(soap_fault, env, om_element_node); |
| |
| AXIS2_SOAP_FAULT_SET_SOAP_VERSION(soap_fault, env, builder_impl->soap_version); |
| |
| AXIS2_SOAP_BODY_SET_FAULT(soap_body, env, soap_fault); |
| |
| builder_impl->processing_fault = AXIS2_TRUE; |
| builder_impl->processing_mandatory_fault_elements = AXIS2_TRUE; |
| if(AXIS2_STRCMP(AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_OM_NAMESPACE_GET_URI(env_ns , env)) == 0) |
| { |
| builder_impl->builder_helper = axis2_soap12_builder_helper_create(env, builder); |
| |
| } |
| else if(AXIS2_STRCMP(AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_OM_NAMESPACE_GET_URI(env_ns , env)) == 0) |
| { |
| builder_impl->builder_helper = axis2_soap11_builder_helper_create(env, builder, builder_impl->om_builder); |
| } |
| |
| } |
| else if(element_level > 3 && builder_impl->processing_fault) |
| { |
| if(builder_impl->soap_version == AXIS2_SOAP11) |
| { |
| status = AXIS2_SOAP11_BUILDER_HELPER_HANDLE_EVENT(((axis2_soap11_builder_helper_t*)(builder_impl->builder_helper)), |
| env, om_element_node , element_level); |
| |
| } |
| if(builder_impl->soap_version == AXIS2_SOAP12) |
| { |
| status = AXIS2_SOAP12_BUILDER_HELPER_HANDLE_EVENT(((axis2_soap12_builder_helper_t *) |
| (builder_impl->builder_helper)), env, om_element_node , element_level); |
| } |
| |
| } |
| return status; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_process_namespace_data |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_om_node_t *om_node, |
| int is_soap_element) |
| { |
| axis2_om_element_t *om_ele = NULL; |
| axis2_om_namespace_t *om_ns = NULL; |
| axis2_char_t *ns_uri = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, om_node, AXIS2_FAILURE); |
| if(!is_soap_element) |
| return AXIS2_SUCCESS; |
| if(AXIS2_OM_NODE_GET_NODE_TYPE(om_node, env) == AXIS2_OM_ELEMENT) |
| { |
| om_ele = (axis2_om_element_t *) AXIS2_OM_NODE_GET_DATA_ELEMENT(om_node, env); |
| om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env); |
| ns_uri = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env); |
| if(om_ns && |
| (AXIS2_STRCMP(ns_uri, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) != 0) && |
| (AXIS2_STRCMP(ns_uri, AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) != 0)) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI, AXIS2_FAILURE); |
| AXIS2_LOG_WRITE((*env)->log,"AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI", AXIS2_LOG_LEVEL_DEBUG); |
| return AXIS2_FAILURE; |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| static axis2_status_t |
| axis2_soap_builder_identify_soap_version(axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_char_t* soap_version_uri_from_transport) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| axis2_om_namespace_t *om_ns = NULL; |
| axis2_om_node_t *envelope_node = NULL; |
| axis2_om_element_t *om_ele = NULL; |
| axis2_char_t *ns_uri = NULL; |
| AXIS2_PARAM_CHECK((*env)->error, soap_version_uri_from_transport, AXIS2_FAILURE); |
| |
| |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| builder_impl->soap_envelope = |
| axis2_soap_builder_get_soap_envelope(builder, env); |
| if(builder_impl->soap_envelope == NULL) |
| { |
| AXIS2_ERROR_SET((*env)->error, |
| AXIS2_ERROR_SOAP_MESSAGE_DOES_NOT_CONTAIN_AN_ENVELOPE, AXIS2_FAILURE); |
| AXIS2_LOG_WRITE((*env)->log, " soap message does not have a soap envelope element ", |
| AXIS2_LOG_LEVEL_CRITICAL); |
| return AXIS2_FAILURE; |
| } |
| envelope_node = AXIS2_SOAP_ENVELOPE_GET_BASE_NODE(builder_impl->soap_envelope, env); |
| om_ele = (axis2_om_element_t *) AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_node, env); |
| |
| om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env); |
| |
| ns_uri = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env); |
| if(ns_uri != NULL) |
| { |
| if(soap_version_uri_from_transport && AXIS2_STRCMP(soap_version_uri_from_transport, ns_uri) != 0) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP, AXIS2_FAILURE); |
| AXIS2_LOG_WRITE((*env)->log , "AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP", |
| AXIS2_LOG_LEVEL_ERROR); |
| return AXIS2_FAILURE; |
| } |
| if(AXIS2_STRCMP(AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri) == 0) |
| { |
| builder_impl->soap_version = AXIS2_SOAP11; |
| AXIS2_LOG_WRITE((*env)->log,"Identified soap version is soap11", AXIS2_LOG_LEVEL_DEBUG); |
| } |
| else if(AXIS2_STRCMP(AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri) == 0) |
| { |
| builder_impl->soap_version = AXIS2_SOAP12; |
| AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "identified soap version is soap12"); |
| |
| } |
| AXIS2_SOAP_ENVELOPE_SET_SOAP_VERSION(builder_impl->soap_envelope, env, builder_impl->soap_version); |
| |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| static axis2_status_t |
| axis2_soap_builder_parse_headers(axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| axis2_om_node_t *om_node = NULL; |
| axis2_soap_header_t *soap_header = NULL; |
| int status = AXIS2_SUCCESS; |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| soap_header = AXIS2_SOAP_ENVELOPE_GET_HEADER(builder_impl->soap_envelope, env); |
| if(soap_header != NULL) |
| { |
| om_node = AXIS2_SOAP_HEADER_GET_BASE_NODE(soap_header, env); |
| while(!AXIS2_OM_NODE_GET_BUILD_STATUS(om_node, env)) |
| { |
| status = axis2_soap_builder_next(builder, env); |
| if(status == AXIS2_FAILURE) |
| return AXIS2_FAILURE; |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_set_bool_processing_mandatory_fault_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_bool_t value) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| builder_impl->processing_mandatory_fault_elements = value; |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_builder_set_processing_detail_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env, |
| axis2_bool_t value) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| builder_impl->processing_detail_elements = value; |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_bool_t AXIS2_CALL |
| axis2_soap_builder_is_processing_detail_elements |
| (axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| return builder_impl->processing_detail_elements ; |
| } |
| |
| int AXIS2_CALL |
| axis2_soap_builder_get_soap_version (axis2_soap_builder_t *builder, |
| axis2_env_t **env) |
| { |
| axis2_soap_builder_impl_t *builder_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| builder_impl = AXIS2_INTF_TO_IMPL(builder); |
| return builder_impl->soap_version ; |
| } |
