| /* |
| * 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_envelope.h> |
| #include <axis2_soap_body.h> |
| #include <axis2_soap_header.h> |
| #include <axis2_soap_header_block.h> |
| #include <axis2_hash.h> |
| #include <axis2_soap.h> |
| #include <axis2_soap_builder.h> |
| #include <axis2_soap_fault_code.h> |
| #include <axis2_soap_fault_reason.h> |
| #include <axis2_soap_fault_detail.h> |
| #include <axis2_soap_fault_role.h> |
| |
| /******************* impl struct *********************************************/ |
| |
| typedef struct axis2_soap_envelope_impl_t |
| { |
| axis2_soap_envelope_t soap_envelope; |
| /* corresponding om element node */ |
| axis2_om_node_t *om_ele_node; |
| /* soap version */ |
| int soap_version; |
| /* soap header */ |
| axis2_soap_header_t *header; |
| /* soap body */ |
| axis2_soap_body_t *body; |
| /* pointer to soap builder */ |
| axis2_soap_builder_t *soap_builder; |
| |
| }axis2_soap_envelope_impl_t; |
| |
| /****************** Macro ****************************************************/ |
| |
| #define AXIS2_INTF_TO_IMPL(envelope) ((axis2_soap_envelope_impl_t*)envelope) |
| |
| /****************** Function prototypes **************************************/ |
| |
| axis2_soap_header_t* AXIS2_CALL |
| axis2_soap_envelope_get_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| |
| |
| axis2_soap_header_block_t* AXIS2_CALL |
| axis2_soap_envelope_add_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_char_t *namespace_uri, |
| axis2_char_t *name); |
| |
| axis2_soap_body_t* AXIS2_CALL |
| axis2_soap_envelope_get_body(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_serialize(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_om_output_t *om_output, |
| axis2_bool_t cache); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_free(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| axis2_om_node_t* AXIS2_CALL |
| axis2_soap_envelope_get_base_node(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_base_node(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_om_node_t *om_node); |
| |
| int AXIS2_CALL |
| axis2_soap_envelope_get_soap_version(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_soap_version(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| int soap_version); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_body(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_soap_body_t *body); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_soap_header_t *header); |
| |
| axis2_om_namespace_t* AXIS2_CALL |
| axis2_soap_envelope_get_namespace(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env); |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_builder(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_soap_builder_t *soap_builder); |
| |
| |
| /*************** function implementations *************************************/ |
| |
| AXIS2_DECLARE(axis2_soap_envelope_t*) |
| axis2_soap_envelope_create_null(axis2_env_t **env) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = (axis2_soap_envelope_impl_t*)AXIS2_MALLOC( |
| (*env)->allocator, |
| sizeof(axis2_soap_envelope_impl_t)); |
| if(!envelope_impl) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| envelope_impl->soap_envelope.ops = NULL; |
| envelope_impl->om_ele_node = NULL; |
| envelope_impl->soap_version = AXIS2_SOAP12; |
| envelope_impl->header = NULL; |
| envelope_impl->body = NULL; |
| envelope_impl->soap_builder = NULL; |
| |
| envelope_impl->soap_envelope.ops = AXIS2_MALLOC( (*env)->allocator, |
| sizeof(axis2_soap_envelope_ops_t) ); |
| if (!envelope_impl->soap_envelope.ops) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| axis2_soap_envelope_free(&(envelope_impl->soap_envelope), env); |
| return NULL; |
| } |
| |
| envelope_impl->soap_envelope.ops->free = |
| axis2_soap_envelope_free; |
| |
| envelope_impl->soap_envelope.ops->get_base_node = |
| axis2_soap_envelope_get_base_node; |
| envelope_impl->soap_envelope.ops->set_base_node = |
| axis2_soap_envelope_set_base_node; |
| envelope_impl->soap_envelope.ops->get_soap_version = |
| axis2_soap_envelope_get_soap_version; |
| envelope_impl->soap_envelope.ops->set_soap_version = |
| axis2_soap_envelope_set_soap_version; |
| envelope_impl->soap_envelope.ops->get_body = |
| axis2_soap_envelope_get_body; |
| envelope_impl->soap_envelope.ops->set_body = |
| axis2_soap_envelope_set_body; |
| |
| envelope_impl->soap_envelope.ops->get_header = |
| axis2_soap_envelope_get_header; |
| /* envelope_impl->soap_envelope.ops->add_header = axis2_soap_envelope_add_header; */ |
| envelope_impl->soap_envelope.ops->set_header = |
| axis2_soap_envelope_set_header; |
| envelope_impl->soap_envelope.ops->get_namespace = |
| axis2_soap_envelope_get_namespace; |
| envelope_impl->soap_envelope.ops->set_builder = |
| axis2_soap_envelope_set_builder; |
| envelope_impl->soap_envelope.ops->serialize = |
| axis2_soap_envelope_serialize; |
| |
| return &(envelope_impl->soap_envelope); |
| } |
| |
| |
| AXIS2_DECLARE(axis2_soap_envelope_t*) |
| axis2_soap_envelope_create(axis2_env_t **env, |
| axis2_om_namespace_t *ns) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| axis2_om_element_t *ele = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = (axis2_soap_envelope_impl_t*)AXIS2_MALLOC( |
| (*env)->allocator, |
| sizeof(axis2_soap_envelope_impl_t)); |
| if(!envelope_impl) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| envelope_impl->soap_envelope.ops = NULL; |
| envelope_impl->om_ele_node = NULL; |
| envelope_impl->soap_version = AXIS2_SOAP12; |
| envelope_impl->header = NULL; |
| envelope_impl->body = NULL; |
| envelope_impl->soap_builder = NULL; |
| |
| ele = axis2_om_element_create(env, NULL, |
| AXIS2_SOAP_ENVELOPE_LOCAL_NAME, ns, |
| &(envelope_impl->om_ele_node)); |
| if (!ele) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| axis2_soap_envelope_free(&(envelope_impl->soap_envelope), env); |
| return NULL; |
| } |
| |
| envelope_impl->soap_envelope.ops = AXIS2_MALLOC( (*env)->allocator, |
| sizeof(axis2_soap_envelope_ops_t) ); |
| if (!envelope_impl->soap_envelope.ops) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| axis2_soap_envelope_free(&(envelope_impl->soap_envelope), env); |
| return NULL; |
| } |
| |
| envelope_impl->soap_envelope.ops->free = |
| axis2_soap_envelope_free; |
| |
| envelope_impl->soap_envelope.ops->get_base_node = |
| axis2_soap_envelope_get_base_node; |
| envelope_impl->soap_envelope.ops->set_base_node = |
| axis2_soap_envelope_set_base_node; |
| envelope_impl->soap_envelope.ops->get_soap_version = |
| axis2_soap_envelope_get_soap_version; |
| envelope_impl->soap_envelope.ops->set_soap_version = |
| axis2_soap_envelope_set_soap_version; |
| envelope_impl->soap_envelope.ops->get_body = |
| axis2_soap_envelope_get_body; |
| envelope_impl->soap_envelope.ops->set_body = |
| axis2_soap_envelope_set_body; |
| |
| envelope_impl->soap_envelope.ops->get_header = |
| axis2_soap_envelope_get_header; |
| /* envelope_impl->soap_envelope.ops->add_header = axis2_soap_envelope_add_header; */ |
| envelope_impl->soap_envelope.ops->set_header = |
| axis2_soap_envelope_set_header; |
| envelope_impl->soap_envelope.ops->get_namespace = |
| axis2_soap_envelope_get_namespace; |
| envelope_impl->soap_envelope.ops->set_builder = |
| axis2_soap_envelope_set_builder; |
| envelope_impl->soap_envelope.ops->serialize = |
| axis2_soap_envelope_serialize; |
| |
| return &(envelope_impl->soap_envelope); |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_free(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| if(envelope_impl->header) |
| { |
| AXIS2_SOAP_HEADER_FREE(envelope_impl->header, env); |
| envelope_impl->header = NULL; |
| } |
| if(envelope_impl->body) |
| { |
| AXIS2_SOAP_BODY_FREE(envelope_impl->body, env); |
| envelope_impl->body = NULL; |
| } |
| if(envelope->ops) |
| { |
| AXIS2_FREE((*env)->allocator, envelope->ops); |
| envelope->ops = NULL; |
| } |
| if(envelope_impl->om_ele_node) |
| { |
| AXIS2_OM_NODE_FREE_TREE(envelope_impl->om_ele_node, env); |
| envelope_impl->om_ele_node = NULL; |
| } |
| |
| AXIS2_FREE((*env)->allocator, envelope_impl); |
| envelope_impl = NULL; |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_om_node_t* AXIS2_CALL |
| axis2_soap_envelope_get_base_node(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| return AXIS2_INTF_TO_IMPL(envelope)->om_ele_node; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_base_node(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_om_node_t *node) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, node, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT) |
| { |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| envelope_impl->om_ele_node = node; |
| return AXIS2_SUCCESS; |
| } |
| |
| int AXIS2_CALL |
| axis2_soap_envelope_get_soap_version(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return AXIS2_INTF_TO_IMPL(envelope)->soap_version; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_soap_version(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| int soap_version) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_INTF_TO_IMPL(envelope)->soap_version = soap_version; |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_soap_header_t* AXIS2_CALL |
| axis2_soap_envelope_get_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| int status = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| if(envelope_impl->header) |
| { |
| return envelope_impl->header; |
| } |
| else if(envelope_impl->soap_builder) |
| { |
| while(!(envelope_impl->header) && !AXIS2_OM_NODE_GET_BUILD_STATUS( |
| envelope_impl->om_ele_node, env)) |
| { |
| status = AXIS2_SOAP_BUILDER_NEXT(envelope_impl->soap_builder, env); |
| if(status == AXIS2_FAILURE) |
| break; |
| } |
| } |
| return envelope_impl->header; |
| } |
| |
| axis2_soap_header_block_t* AXIS2_CALL |
| axis2_soap_envelope_add_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_char_t *namespace_uri, |
| axis2_char_t *name) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| axis2_om_namespace_t *ns = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| |
| /* TODO : cache SOAP header and envelope instead of looking them up?*/ |
| |
| if (namespace_uri) |
| { |
| ns = axis2_om_namespace_create(env, namespace_uri, NULL); |
| } |
| |
| return axis2_soap_header_block_create_with_parent(env, name, ns, envelope_impl->header); |
| } |
| |
| axis2_soap_body_t* AXIS2_CALL |
| axis2_soap_envelope_get_body(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| int status = AXIS2_SUCCESS; |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| |
| if(envelope_impl->body) |
| { |
| return envelope_impl->body; |
| } |
| else if(envelope_impl->soap_builder) |
| { |
| while(!(envelope_impl->body) && !AXIS2_OM_NODE_GET_BUILD_STATUS(envelope_impl->om_ele_node, env)) |
| { |
| status = AXIS2_SOAP_BUILDER_NEXT(envelope_impl->soap_builder, env); |
| if(status == AXIS2_FAILURE) |
| { |
| return NULL; |
| } |
| } |
| } |
| return envelope_impl->body; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_serialize(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_om_output_t *om_output, |
| axis2_bool_t cache) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| /* |
| if soap version is soap11 we modify the soap fault part. |
| This is done because the builder construct a soap12 fault all |
| the time. So when serializing if the soap version is soap11 |
| we should convert it back to soap11 fault |
| */ |
| if(envelope_impl->soap_version == AXIS2_SOAP11) |
| { |
| axis2_soap_body_t *soap_body = NULL; |
| soap_body = AXIS2_SOAP_ENVELOPE_GET_BODY(envelope, env); |
| if(soap_body) |
| { |
| axis2_soap_fault_t *soap_fault = NULL; |
| if(AXIS2_SOAP_BODY_HAS_FAULT(soap_body, env)) |
| { |
| soap_fault = AXIS2_SOAP_BODY_GET_FAULT(soap_body, env); |
| if(soap_fault) |
| { |
| axis2_soap_fault_code_t *fault_code = NULL; |
| axis2_soap_fault_reason_t *fault_reason = NULL; |
| axis2_soap_fault_detail_t *fault_detail = NULL; |
| axis2_soap_fault_role_t *fault_role = NULL; |
| fault_code = AXIS2_SOAP_FAULT_GET_CODE(soap_fault, env); |
| if(fault_code) |
| { |
| axis2_om_node_t *fault_code_om_node = NULL; |
| axis2_om_element_t *fault_code_om_ele = NULL; |
| axis2_om_node_t *fault_value_om_node = NULL; |
| axis2_om_element_t *fault_value_om_ele = NULL; |
| axis2_char_t *text = NULL; |
| fault_code_om_node = AXIS2_SOAP_FAULT_CODE_GET_BASE_NODE(fault_code, env); |
| fault_code_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_code_om_node, env); |
| AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_code_om_ele, env, AXIS2_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME); |
| fault_value_om_node = AXIS2_OM_NODE_GET_FIRST_CHILD(fault_code_om_node, env); |
| AXIS2_OM_NODE_DETACH(fault_value_om_node, env); |
| fault_value_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_value_om_node, env); |
| text = AXIS2_OM_ELEMENT_GET_TEXT(fault_value_om_ele, env, fault_value_om_node); |
| AXIS2_OM_ELEMENT_SET_TEXT(fault_code_om_ele, env, text, fault_code_om_node); |
| |
| AXIS2_OM_NODE_FREE_TREE(fault_value_om_node, env); |
| } |
| fault_reason = AXIS2_SOAP_FAULT_GET_REASON(soap_fault, env); |
| if(fault_reason) |
| { |
| axis2_om_node_t *fault_reason_om_node = NULL; |
| axis2_om_element_t *fault_reason_om_ele = NULL; |
| |
| axis2_om_node_t *fault_text_om_node = NULL; |
| axis2_om_element_t *fault_text_om_ele = NULL; |
| |
| axis2_char_t *text = NULL; |
| |
| fault_reason_om_node = AXIS2_SOAP_FAULT_REASON_GET_BASE_NODE(fault_reason, env); |
| fault_reason_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_reason_om_node, env); |
| AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_reason_om_ele, env, AXIS2_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME); |
| |
| |
| fault_text_om_node = AXIS2_OM_NODE_GET_FIRST_CHILD(fault_reason_om_node, env); |
| fault_text_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_text_om_node, env); |
| AXIS2_OM_NODE_DETACH(fault_text_om_node, env); |
| |
| text = AXIS2_OM_ELEMENT_GET_TEXT(fault_text_om_ele, env, fault_text_om_node); |
| AXIS2_OM_ELEMENT_SET_TEXT( fault_reason_om_ele, env, text, fault_reason_om_node); |
| |
| AXIS2_OM_NODE_FREE_TREE(fault_text_om_node, env); |
| } |
| |
| fault_role = AXIS2_SOAP_FAULT_GET_ROLE(soap_fault, env); |
| if(fault_role) |
| { |
| axis2_om_node_t *fault_role_om_node = NULL; |
| axis2_om_element_t *fault_role_om_ele = NULL; |
| |
| fault_role_om_node = AXIS2_SOAP_FAULT_ROLE_GET_BASE_NODE(fault_role, env); |
| fault_role_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_role_om_node, env); |
| AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_role_om_ele, env, AXIS2_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME); |
| } |
| |
| fault_detail = AXIS2_SOAP_FAULT_GET_DETAIL(soap_fault, env); |
| if(fault_detail) |
| { |
| axis2_om_node_t *fault_detail_om_node = NULL; |
| axis2_om_element_t *fault_detail_om_ele = NULL; |
| |
| fault_detail_om_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(fault_detail, env); |
| fault_detail_om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_detail_om_node, env); |
| AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_detail_om_ele, env, AXIS2_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME); |
| } |
| } |
| } |
| } |
| } |
| /* write the xml version and encoding |
| These should be set so om output before calling the serialize function |
| Otherwise default values will be written |
| */ |
| AXIS2_OM_OUTPUT_WRITE_XML_VERSION_ENCODING(om_output, env); |
| return AXIS2_OM_NODE_SERIALIZE(envelope_impl->om_ele_node, env, om_output); |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_body(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_soap_body_t *body) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| |
| if (!(envelope_impl->body)) |
| { |
| envelope_impl->body = body; |
| } |
| else |
| { |
| AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, "trying to set a soap bedy to envelope when a soap body alrady exists"); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t AXIS2_CALL axis2_soap_envelope_set_header(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, axis2_soap_header_t *header) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| |
| if (!(envelope_impl->header)) |
| { |
| envelope_impl->header = header; |
| } |
| else |
| { |
| AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, " trying to set a soap header to envelope when a soap header alrady exists"); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_om_namespace_t* AXIS2_CALL |
| axis2_soap_envelope_get_namespace(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| |
| if (envelope_impl->om_ele_node) |
| { |
| axis2_om_element_t *ele = NULL; |
| if (AXIS2_OM_NODE_GET_NODE_TYPE(envelope_impl->om_ele_node, env) == AXIS2_OM_ELEMENT) |
| { |
| ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_impl->om_ele_node, env); |
| if (ele) |
| { |
| return AXIS2_OM_ELEMENT_GET_NAMESPACE(ele, env); |
| } |
| } |
| } |
| return NULL; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| axis2_soap_envelope_set_builder(axis2_soap_envelope_t *envelope, |
| axis2_env_t **env, |
| axis2_soap_builder_t *soap_builder) |
| { |
| axis2_soap_envelope_impl_t *envelope_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK((*env)->error, soap_builder, AXIS2_FAILURE); |
| envelope_impl = AXIS2_INTF_TO_IMPL(envelope); |
| envelope_impl->soap_builder = soap_builder; |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_DECLARE(axis2_soap_envelope_t *) |
| axis2_soap_envelope_create_default_soap_envelope(axis2_env_t **env, |
| int soap_version) |
| { |
| axis2_soap_envelope_t *soap_env = NULL; |
| axis2_soap_header_t *soap_header = NULL; |
| axis2_soap_body_t *soap_body = NULL; |
| axis2_om_namespace_t *om_ns = NULL; |
| axis2_soap_envelope_impl_t *env_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| if(soap_version == AXIS2_SOAP11) |
| { |
| om_ns = axis2_om_namespace_create(env, |
| AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX); |
| if(!om_ns) |
| return NULL; |
| soap_env = axis2_soap_envelope_create(env, om_ns); |
| env_impl = AXIS2_INTF_TO_IMPL(soap_env); |
| |
| AXIS2_SOAP_ENVELOPE_SET_SOAP_VERSION(soap_env, env, AXIS2_SOAP11); |
| soap_header = axis2_soap11_header_create_with_parent(env, soap_env); |
| soap_body = axis2_soap_body_create_with_parent(env, soap_env); |
| env_impl->body = soap_body; |
| env_impl->header = soap_header; |
| AXIS2_SOAP_BODY_SET_SOAP_VERSION(soap_body, env, AXIS2_SOAP11); |
| return soap_env; |
| } |
| else if(soap_version == AXIS2_SOAP12) |
| { |
| om_ns = axis2_om_namespace_create(env, |
| AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX); |
| if(!om_ns) |
| return NULL; |
| soap_env = axis2_soap_envelope_create(env, om_ns); |
| env_impl = AXIS2_INTF_TO_IMPL(soap_env); |
| |
| AXIS2_SOAP_ENVELOPE_SET_SOAP_VERSION(soap_env, env, AXIS2_SOAP12); |
| soap_header = axis2_soap12_header_create_with_parent(env, soap_env); |
| soap_body = axis2_soap_body_create_with_parent(env, soap_env); |
| env_impl->body = soap_body; |
| env_impl->header = soap_header; |
| |
| AXIS2_SOAP_BODY_SET_SOAP_VERSION(soap_body, env, AXIS2_SOAP12); |
| return soap_env; |
| } |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| AXIS2_DECLARE(axis2_soap_envelope_t *) |
| axis2_soap_envelope_create_default_soap_fault_envelope(axis2_env_t **env, |
| int soap_version) |
| { |
| axis2_soap_envelope_t *soap_env = NULL; |
| axis2_soap_body_t *soap_body = NULL; |
| axis2_om_namespace_t *om_ns = NULL; |
| axis2_soap_envelope_impl_t *env_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| if(soap_version == AXIS2_SOAP11) |
| { |
| om_ns = axis2_om_namespace_create(env, |
| AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX); |
| if(!om_ns) |
| return NULL; |
| soap_env = axis2_soap_envelope_create(env, om_ns); |
| env_impl = AXIS2_INTF_TO_IMPL(soap_env); |
| |
| AXIS2_SOAP_ENVELOPE_SET_SOAP_VERSION(soap_env, env, AXIS2_SOAP11); |
| soap_body = axis2_soap_body_create_with_parent(env, soap_env); |
| env_impl->body = soap_body; |
| AXIS2_SOAP_BODY_SET_SOAP_VERSION(soap_body, env, AXIS2_SOAP11); |
| return soap_env; |
| } |
| else if(soap_version == AXIS2_SOAP12) |
| { |
| om_ns = axis2_om_namespace_create(env, |
| AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, |
| AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX); |
| if(!om_ns) |
| return NULL; |
| soap_env = axis2_soap_envelope_create(env, om_ns); |
| env_impl = AXIS2_INTF_TO_IMPL(soap_env); |
| |
| AXIS2_SOAP_ENVELOPE_SET_SOAP_VERSION(soap_env, env, AXIS2_SOAP12); |
| soap_body = axis2_soap_body_create_with_parent(env, soap_env); |
| env_impl->body = soap_body; |
| AXIS2_SOAP_BODY_SET_SOAP_VERSION(soap_body, env, AXIS2_SOAP12); |
| return soap_env; |
| } |
| AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE); |
| return NULL; |
| } |
