diff options
Diffstat (limited to 'axiom/src/soap/soap_header.c')
| -rw-r--r-- | axiom/src/soap/soap_header.c | 655 |
1 files changed, 655 insertions, 0 deletions
diff --git a/axiom/src/soap/soap_header.c b/axiom/src/soap/soap_header.c new file mode 100644 index 0000000..6c6a71c --- /dev/null +++ b/axiom/src/soap/soap_header.c @@ -0,0 +1,655 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 "_axiom_soap_envelope.h" +#include "_axiom_soap_header.h" +#include "_axiom_soap_body.h" +#include <axiom_soap_header_block.h> +#include <axutil_hash.h> +#include <axiom_soap_const.h> +#include <axiom_soap_builder.h> +#include <stdio.h> +#include <axiom_node_internal.h> +#include <axutil_array_list.h> + +struct axiom_soap_header +{ + axiom_node_t *om_ele_node; + + int soap_version; + + axutil_hash_t *header_blocks; + + int hbnumber; + + axiom_soap_builder_t *soap_builder; + + axiom_soap_envelope_t *soap_envelope; + + axutil_array_list_t *header_block_keys; +}; + +static axis2_bool_t AXIS2_CALL axiom_soap_header_qname_matches( + const axutil_env_t * env, + axutil_qname_t * element_qname, + axutil_qname_t * qname_to_match); + +AXIS2_EXTERN axiom_soap_header_t *AXIS2_CALL +axiom_soap_header_create( + const axutil_env_t * env) +{ + axiom_soap_header_t *soap_header = NULL; + + soap_header = (axiom_soap_header_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_soap_header_t)); + if(!soap_header) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create SOAP header"); + return NULL; + } + + soap_header->om_ele_node = NULL; + soap_header->soap_envelope = NULL; + soap_header->hbnumber = 0; + soap_header->header_blocks = NULL; + + /** default value */ + soap_header->soap_version = AXIOM_SOAP12; + soap_header->header_block_keys = NULL; + + soap_header->header_block_keys = axutil_array_list_create(env, 10); + if(!soap_header->header_block_keys) + { + AXIS2_FREE(env->allocator, soap_header); + return NULL; + } + + return soap_header; +} + +AXIS2_EXTERN axiom_soap_header_t *AXIS2_CALL +axiom_soap_header_create_with_parent( + const axutil_env_t * env, + axiom_soap_envelope_t * envelope) +{ + axiom_soap_header_t *soap_header = NULL; + + /*axiom_element_t *this_ele = NULL; + axiom_node_t *this_node = NULL;*/ + axiom_node_t *body_node = NULL; + axiom_node_t *parent_node = NULL; + axiom_element_t *parent_ele = NULL; + + /*axiom_namespace_t *parent_ns = NULL;*/ + + AXIS2_PARAM_CHECK(env->error, envelope, NULL); + + soap_header = axiom_soap_header_create(env); + if(!soap_header) + { + return NULL; + } + soap_header->soap_version = axiom_soap_envelope_get_soap_version(envelope, env); + + parent_node = axiom_soap_envelope_get_base_node(envelope, env); + + if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + + parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env); + if(!parent_ele) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + if(axiom_node_get_first_element(parent_node, env)) + { + body_node = axiom_node_get_first_element(parent_node, env); + axiom_node_detach(body_node, env); + } + + /*parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node); + this_ele = axiom_element_create(env, parent_node, + AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns, + &this_node); + if (!this_ele) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + + soap_header->om_ele_node = this_node;*/ + + axiom_soap_envelope_set_header(envelope, env, soap_header); + + if(body_node) + { + axiom_node_add_child(parent_node, env, body_node); + } + + soap_header->soap_envelope = envelope; + + return soap_header; +} + +AXIS2_EXTERN void AXIS2_CALL +axiom_soap_header_free( + axiom_soap_header_t * soap_header, + const axutil_env_t * env) +{ + + if(soap_header->header_blocks) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(soap_header->header_blocks, env); hi; hi = axutil_hash_next(env, + hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + + if(val) + { + axiom_soap_header_block_free((axiom_soap_header_block_t *)val, env); + val = NULL; + } + } + + axutil_hash_free(soap_header->header_blocks, env); + } + if(soap_header->header_block_keys) + { + int size = 0; + void *val = NULL; + int i = 0; + size = axutil_array_list_size(soap_header->header_block_keys, env); + for(i = 0; i < size; i++) + { + val = axutil_array_list_get(soap_header->header_block_keys, env, i); + if(val) + { + AXIS2_FREE(env->allocator, (char *)val); + val = NULL; + } + } + axutil_array_list_free(soap_header->header_block_keys, env); + soap_header->header_block_keys = NULL; + } + AXIS2_FREE(env->allocator, soap_header); + + soap_header = NULL; + + return; +} + +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_EXTERN axutil_hash_t *AXIS2_CALL axiom_soap_header_examine_header_blocks( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + axis2_char_t * param_role) +{ + AXIS2_PARAM_CHECK(env->error, param_role, NULL); + + return soap_header->header_blocks; +} + +AXIS2_EXTERN axiom_children_qname_iterator_t *AXIS2_CALL +axiom_soap_header_examine_all_header_blocks( + axiom_soap_header_t * soap_header, + const axutil_env_t * env) +{ + axiom_element_t *om_ele = NULL; + + if(!soap_header->om_ele_node) + { + return NULL; + } + om_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header-> om_ele_node, env); + + if(om_ele) + { + return axiom_element_get_children_with_qname(om_ele, env, NULL, soap_header->om_ele_node); + } + else + return NULL; +} + +AXIS2_EXTERN axiom_children_with_specific_attribute_iterator_t *AXIS2_CALL +axiom_soap_header_extract_header_blocks( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + axis2_char_t * role) +{ + const axis2_char_t *localname = NULL; + const axis2_char_t *nsuri = NULL; + + axiom_node_t *first_node = NULL; + axiom_element_t *first_ele = NULL; + + axutil_qname_t *qn = NULL; + + axiom_element_t *header_om_ele = NULL; + axiom_children_with_specific_attribute_iterator_t *iter = NULL; + + if(soap_header->soap_version == AXIOM_SOAP_VERSION_NOT_SET) + { + return NULL; + } + if(soap_header->soap_version == AXIOM_SOAP11) + { + localname = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; + nsuri = AXIOM_SOAP11_ATTR_ACTOR; + } + if(soap_header->soap_version == AXIOM_SOAP12) + { + localname = AXIOM_SOAP12_SOAP_ROLE; + nsuri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + } + + qn = axutil_qname_create(env, localname, nsuri, NULL); + if(!qn) + { + return NULL; + } + header_om_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header->om_ele_node, env); + + if(header_om_ele) + { + first_ele = axiom_element_get_first_element(header_om_ele, env, soap_header->om_ele_node, + &first_node); + if(first_node) + { + return axiom_children_with_specific_attribute_iterator_create(env, first_node, qn, + role, AXIS2_TRUE); + } + } + + axutil_qname_free(qn, env); + + return iter; + +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_soap_header_set_base_node( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + axiom_node_t * node) +{ + AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE); + + if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + soap_header->om_ele_node = node; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axiom_node_t *AXIS2_CALL +axiom_soap_header_get_base_node( + axiom_soap_header_t * soap_header, + const axutil_env_t * env) +{ + if(!soap_header->om_ele_node) + { + axiom_node_t *parent_node = NULL; + axiom_element_t *parent_ele = NULL; + axiom_namespace_t *parent_ns = NULL; + axiom_element_t *this_ele = NULL; + axiom_node_t *this_node = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_node_t *body_node = NULL; + + parent_node = axiom_soap_envelope_get_base_node(soap_header->soap_envelope, env); + + if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + + parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env); + if(!parent_ele) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + + parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node); + this_ele = axiom_element_create(env, NULL, AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns, + &this_node); + if(!this_ele) + { + axiom_soap_header_free(soap_header, env); + return NULL; + } + + soap_body = axiom_soap_envelope_get_body(soap_header->soap_envelope, env); + if(soap_body) + { + body_node = axiom_soap_body_get_base_node(soap_body, env); + axiom_node_insert_sibling_before(body_node, env, this_node); + } + else + { + axiom_node_add_child(parent_node, env, this_node); + } + soap_header->om_ele_node = this_node; + } + + return soap_header->om_ele_node; +} + +/** + set soap version and get soap version are internal functions + + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_soap_header_get_soap_version( + axiom_soap_header_t * soap_header, + const axutil_env_t * env) +{ + return soap_header->soap_version; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_soap_header_set_soap_version( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + int soap_version) +{ + soap_header->soap_version = soap_version; + return AXIS2_SUCCESS; + +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_soap_header_set_header_block( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + struct axiom_soap_header_block * header_block) +{ + axis2_char_t *key = NULL; + AXIS2_PARAM_CHECK(env->error, header_block, AXIS2_FAILURE); + + key = (axis2_char_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 10); + + if(!key) + { + return AXIS2_FAILURE; + } + sprintf(key, "%d", soap_header->hbnumber++); + + if(soap_header->header_blocks) + { + axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, header_block); + } + else + { + soap_header->header_blocks = axutil_hash_make(env); + axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, header_block); + } + if(soap_header->header_block_keys) + { + axutil_array_list_add(soap_header->header_block_keys, env, key); + } + return AXIS2_SUCCESS; + +} +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_soap_header_set_builder( + axiom_soap_header_t * soap_header, + const axutil_env_t * env, + struct axiom_soap_builder * builder) +{ + AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE); + + soap_header->soap_builder = builder; + 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_EXTERN axutil_hash_t *AXIS2_CALL +axiom_soap_header_get_all_header_blocks( + axiom_soap_header_t * soap_header, + const axutil_env_t * env) +{ + return soap_header->header_blocks; +} + +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; +} + +static axis2_bool_t AXIS2_CALL +axiom_soap_header_qname_matches( + const axutil_env_t * env, + axutil_qname_t * element_qname, + axutil_qname_t * qname_to_match) +{ + int lparts_match = 0; + int uris_match = 0; + axis2_char_t *ele_lpart = NULL; + axis2_char_t *match_lpart = NULL; + axis2_char_t *ele_nsuri = NULL; + axis2_char_t *match_nsuri = NULL; + + if(!(qname_to_match)) + { + return AXIS2_TRUE; + } + if(qname_to_match) + { + match_lpart = axutil_qname_get_localpart(qname_to_match, env); + match_nsuri = axutil_qname_get_uri(qname_to_match, env); + } + if(element_qname) + { + ele_lpart = axutil_qname_get_localpart(element_qname, env); + ele_nsuri = axutil_qname_get_uri(element_qname, env); + } + + lparts_match = (!match_lpart || (axutil_strcmp(match_lpart, "") == 0) || (element_qname + && (axutil_strcmp(ele_lpart, match_lpart) == 0))); + + uris_match = (!match_nsuri || (axutil_strcmp(match_nsuri, "") == 0) || (element_qname + && (axutil_strcmp(ele_nsuri, match_nsuri) == 0))); + + return lparts_match && uris_match; +} |