diff options
Diffstat (limited to 'src/core/description/policy_include.c')
| -rw-r--r-- | src/core/description/policy_include.c | 612 |
1 files changed, 612 insertions, 0 deletions
diff --git a/src/core/description/policy_include.c b/src/core/description/policy_include.c new file mode 100644 index 0000000..5ce93f8 --- /dev/null +++ b/src/core/description/policy_include.c @@ -0,0 +1,612 @@ +/* + * 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 <axis2_policy_include.h> +#include <neethi_policy.h> +#include <neethi_engine.h> + +struct axis2_policy_include +{ + neethi_policy_t *policy; + + neethi_policy_t *effective_policy; + + neethi_registry_t *registry; + + axis2_desc_t *desc; + + axutil_hash_t *wrapper_elements; +}; + +typedef struct axis2_policy_wrapper +{ + int type; + void *value; +} axis2_policy_wrapper_t; + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_create( + const axutil_env_t * env) +{ + axis2_policy_include_t *policy_include = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + policy_include = (axis2_policy_include_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_include_t)); + + if(!policy_include) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + policy_include->policy = NULL; + policy_include->effective_policy = NULL; + policy_include->registry = NULL; + policy_include->desc = NULL; + policy_include->wrapper_elements = NULL; + + policy_include->registry = neethi_registry_create(env); + if(!policy_include->registry) + { + axis2_policy_include_free(policy_include, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + policy_include->wrapper_elements = axutil_hash_make(env); + if(!policy_include->wrapper_elements) + { + axis2_policy_include_free(policy_include, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return policy_include; +} + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_create_with_desc( + const axutil_env_t * env, + axis2_desc_t * desc) +{ + axis2_policy_include_t *policy_include = NULL; + axis2_desc_t *parent_desc = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + policy_include = (axis2_policy_include_t *)axis2_policy_include_create(env); + + parent_desc = axis2_desc_get_parent(desc, env); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + policy_include->registry = NULL; + } + + if(parent_desc) + { + axis2_policy_include_t *preant_policy_include = axis2_desc_get_policy_include(parent_desc, + env); + if(preant_policy_include) + { + policy_include->registry = neethi_registry_create_with_parent(env, + axis2_policy_include_get_registry(preant_policy_include, env)); + } + else + { + policy_include->registry = neethi_registry_create(env); + } + } + else + { + policy_include->registry = neethi_registry_create(env); + } + + policy_include->desc = desc; + + return policy_include; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_policy_include_free( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + } + + if(policy_include->wrapper_elements) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi + = axutil_hash_next(env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + if(wrapper) + AXIS2_FREE(env->allocator, wrapper); + val = NULL; + wrapper = NULL; + } + axutil_hash_free(policy_include->wrapper_elements, env); + } + + if(policy_include) + { + AXIS2_FREE(env->allocator, policy_include); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_set_registry( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_registry_t * registry) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + } + + policy_include->registry = registry; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN neethi_registry_t *AXIS2_CALL +axis2_policy_include_get_registry( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + return policy_include->registry; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_set_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * policy) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(policy_include->wrapper_elements) + { + axutil_hash_free(policy_include->wrapper_elements, env); + policy_include->wrapper_elements = NULL; + } + + policy_include->wrapper_elements = axutil_hash_make(env); + + if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env)) + { + neethi_policy_set_id(policy, env, axutil_uuid_gen(env)); + } + + if(policy_include->wrapper_elements) + { + axis2_policy_wrapper_t *wrapper = NULL; + + wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + axis2_char_t *policy_name = NULL; + wrapper->type = AXIS2_ANON_POLICY; + wrapper->value = policy; + + policy_name = neethi_policy_get_name(policy, env); + + if(policy_name) + { + axutil_hash_set(policy_include->wrapper_elements, policy_name, + AXIS2_HASH_KEY_STRING, wrapper); + } + else + { + axutil_hash_set(policy_include->wrapper_elements, + neethi_policy_get_id(policy, env), AXIS2_HASH_KEY_STRING, wrapper); + } + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_update_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * policy) +{ + axis2_char_t *key; + axis2_policy_wrapper_t *wrapper = NULL; + + key = neethi_policy_get_name(policy, env); + if(!key) + key = neethi_policy_get_id(policy, env); + + if(!key) + { + return AXIS2_FAILURE; + } + + wrapper = axutil_hash_get(policy_include->wrapper_elements, key, AXIS2_HASH_KEY_STRING); + if(wrapper) + { + wrapper->value = policy; + return AXIS2_SUCCESS; + } + + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_set_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * effective_policy) +{ + policy_include->effective_policy = effective_policy; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_set_desc( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_desc_t * desc) +{ + policy_include->desc = desc; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_policy_include_get_desc( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + return policy_include->desc; +} + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_get_parent( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + if(policy_include->desc) + { + axis2_desc_t *parent = NULL; + parent = axis2_desc_get_parent(policy_include->desc, env); + if(parent) + { + return axis2_desc_get_policy_include(parent, env); + } + } + + return NULL; +} + +static axis2_status_t +axis2_policy_include_calculate_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + neethi_policy_t *result = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper) + { + neethi_policy_t *policy = NULL; + if(wrapper->type == AXIS2_POLICY_REF) + { + neethi_reference_t *reference = (neethi_reference_t *)wrapper->value; + if(reference) + { + /* TOOD add neethi_reference_normalize + policy = (neethi_policy_t*) neethi_reference_normalize( + reference, env, policy_include->registry, AXIS2_FALSE); + */ + } + } + else + { + policy = (neethi_policy_t *)wrapper->value; + } + + result = (result == NULL) ? (neethi_policy_t *)policy + : (neethi_policy_t *)neethi_engine_merge(env, result, policy); + } + } + + policy_include->policy = result; + return AXIS2_SUCCESS; +} + +static neethi_policy_t * +axis2_policy_include_calculate_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + neethi_policy_t *result; + axis2_policy_include_t *parent = NULL; + + parent = axis2_policy_include_get_parent(policy_include, env); + + if(parent) + { + neethi_policy_t *parent_policy = axis2_policy_include_get_effective_policy(parent, env); + + if(!parent_policy) + { + result = axis2_policy_include_get_policy(policy_include, env); + + } + else + { + if(axis2_policy_include_get_policy(policy_include, env)) + { + neethi_policy_t *temp_policy = NULL; + parent_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE, + parent_policy); + temp_policy = axis2_policy_include_get_policy(policy_include, env); + temp_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE, + temp_policy); + /* result = (neethi_policy_t*) neethi_engine_merge(env, parent_policy, + axis2_policy_include_get_policy(policy_include, env)); */ + result = (neethi_policy_t *)neethi_engine_merge(env, parent_policy, temp_policy); + + } + else + { + result = parent_policy; + } + } + } + else + { + result = axis2_policy_include_get_policy(policy_include, env); + } + + return result; + /*policy_include->effective_policy = result; + return AXIS2_SUCCESS; */ +} + +AXIS2_EXTERN neethi_policy_t *AXIS2_CALL +axis2_policy_include_get_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + axis2_policy_include_calculate_policy(policy_include, env); + return policy_include->policy; +} + +AXIS2_EXTERN neethi_policy_t *AXIS2_CALL +axis2_policy_include_get_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + /*if (policy_include->effective_policy) + return policy_include->effective_policy; + */ + return axis2_policy_include_calculate_effective_policy(policy_include, env); + /*return policy_include->effective_policy; */ +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_policy_include_get_policy_elements( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + axutil_array_list_t *policy_elements_list = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + policy_elements_list = axutil_array_list_create(env, 10); + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper) + { + axutil_array_list_add(policy_elements_list, env, wrapper->value); + } + } + return policy_elements_list; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_policy_include_get_policy_elements_with_type( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type) +{ + axutil_array_list_t *policy_elements_list = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + policy_elements_list = axutil_array_list_create(env, 10); + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper && wrapper->type == type) + { + axutil_array_list_add(policy_elements_list, env, wrapper->value); + } + } + return policy_elements_list; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_register_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * key, + neethi_policy_t * policy) +{ + if(policy_include->registry) + { + return neethi_registry_register(policy_include->registry, env, key, policy); + } + return AXIS2_FAILURE; +} + +AXIS2_EXTERN neethi_policy_t *AXIS2_CALL +axis2_policy_include_get_policy_with_key( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * key) +{ + if(policy_include->registry) + { + return neethi_registry_lookup(policy_include->registry, env, key); + } + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_add_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type, + neethi_policy_t * policy) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env)) + { + axis2_char_t *uuid = axutil_uuid_gen(env); + neethi_policy_set_id(policy, env, uuid); + if(uuid) + { + AXIS2_FREE(env->allocator, uuid); + uuid = NULL; + } + } + + if(policy_include->wrapper_elements) + { + axis2_policy_wrapper_t *wrapper = NULL; + + wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + axis2_char_t *policy_name = NULL; + wrapper->type = type; + wrapper->value = policy; + + policy_name = neethi_policy_get_name(policy, env); + if(!policy_name) + policy_name = neethi_policy_get_id(policy, env); + + if(policy_name) + { + axutil_hash_set(policy_include->wrapper_elements, policy_name, + AXIS2_HASH_KEY_STRING, wrapper); + if(policy_include->registry) + { + neethi_registry_register(policy_include->registry, env, policy_name, policy); + } + return AXIS2_SUCCESS; + } + } + } + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_add_policy_reference_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type, + neethi_reference_t * reference) +{ + axis2_policy_wrapper_t *wrapper = NULL; + + wrapper + = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + wrapper->type = type; + wrapper->value = reference; + axutil_hash_set(policy_include->wrapper_elements, neethi_reference_get_uri(reference, env), + AXIS2_HASH_KEY_STRING, wrapper); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_remove_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * policy_uri) +{ + if(policy_include->wrapper_elements) + { + axutil_hash_set(policy_include->wrapper_elements, policy_uri, AXIS2_HASH_KEY_STRING, NULL); + } + if(policy_include->registry) + { + neethi_registry_register(policy_include->registry, env, policy_uri, NULL); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_policy_include_remove_all_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + if(policy_include->wrapper_elements) + { + axutil_hash_free(policy_include->wrapper_elements, env); + } + return AXIS2_SUCCESS; +} |