diff options
Diffstat (limited to 'src/core/context')
-rw-r--r-- | src/core/context/Makefile.am | 13 | ||||
-rw-r--r-- | src/core/context/conf_ctx.c | 599 | ||||
-rw-r--r-- | src/core/context/ctx.c | 197 | ||||
-rw-r--r-- | src/core/context/msg_ctx.c | 2768 | ||||
-rw-r--r-- | src/core/context/op_ctx.c | 420 | ||||
-rw-r--r-- | src/core/context/svc_ctx.c | 200 | ||||
-rw-r--r-- | src/core/context/svc_grp_ctx.c | 256 |
7 files changed, 4453 insertions, 0 deletions
diff --git a/src/core/context/Makefile.am b/src/core/context/Makefile.am new file mode 100644 index 0000000..30184e0 --- /dev/null +++ b/src/core/context/Makefile.am @@ -0,0 +1,13 @@ +noinst_LTLIBRARIES = libaxis2_context.la + +libaxis2_context_la_SOURCES = ctx.c \ + msg_ctx.c \ + op_ctx.c \ + svc_ctx.c \ + svc_grp_ctx.c \ + conf_ctx.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/context/conf_ctx.c b/src/core/context/conf_ctx.c new file mode 100644 index 0000000..9922649 --- /dev/null +++ b/src/core/context/conf_ctx.c @@ -0,0 +1,599 @@ +/* + * 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_conf_ctx.h> +#include <axis2_svc_grp.h> +#include <axis2_const.h> +#include <axutil_uuid_gen.h> + + +struct axis2_conf_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** engine configuration */ + axis2_conf_t *conf; + + /** root directory */ + /* should be handled as a URL string ? */ + axis2_char_t *root_dir; + + /** + * axutil_hash_t *containing message ID to + * operation context mapping. + */ + axutil_hash_t *op_ctx_map; + + axutil_hash_t *svc_ctx_map; + + axutil_hash_t *svc_grp_ctx_map; + + /* Mutex to synchronize the read/write operations */ + axutil_thread_mutex_t *mutex; +}; + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_conf_ctx_create( + const axutil_env_t * env, + axis2_conf_t * conf) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_conf_ctx_t)); + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + conf_ctx->base = NULL; + conf_ctx->conf = NULL; + conf_ctx->root_dir = NULL; + conf_ctx->op_ctx_map = NULL; + conf_ctx->svc_ctx_map = NULL; + conf_ctx->svc_grp_ctx_map = NULL; + conf_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + if(!conf_ctx->mutex) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create thread mutex"); + return NULL; + } + + if(conf) + conf_ctx->conf = conf; + + conf_ctx->base = axis2_ctx_create(env); + if(!(conf_ctx->base)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create base context"); + return NULL; + } + + conf_ctx->op_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->op_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create operation context map"); + return NULL; + } + + conf_ctx->svc_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->svc_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service context map"); + return NULL; + } + + conf_ctx->svc_grp_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->svc_grp_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service group context map"); + return NULL; + } + + return conf_ctx; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_set_conf( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + conf_ctx->conf = conf; /* We just maintain a shallow copy here */ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_conf_ctx_get_base( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->base; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_conf_ctx_get_conf( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->conf; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_ctx_get_op_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->op_ctx_map; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_ctx_get_svc_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->svc_ctx_map; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_ctx_get_svc_grp_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->svc_grp_ctx_map; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_register_op_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id, + axis2_op_ctx_t * op_ctx) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->op_ctx_map) + { + axutil_hash_set(conf_ctx->op_ctx_map, message_id, AXIS2_HASH_KEY_STRING, op_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL +axis2_conf_ctx_get_op_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id) +{ + axis2_op_ctx_t *rv = NULL; + + AXIS2_PARAM_CHECK(env->error, message_id, NULL); + + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->op_ctx_map) + { + rv = (axis2_op_ctx_t *)axutil_hash_get(conf_ctx->op_ctx_map, message_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_register_svc_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_id, + axis2_svc_ctx_t * svc_ctx) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_ctx_map) + { + axutil_hash_set(conf_ctx->svc_ctx_map, svc_id, AXIS2_HASH_KEY_STRING, svc_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL +axis2_conf_ctx_get_svc_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_id) +{ + axis2_svc_ctx_t *rv = NULL; + + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_ctx_map) + { + rv = (axis2_svc_ctx_t *)axutil_hash_get(conf_ctx->svc_ctx_map, svc_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_register_svc_grp_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_grp_id, + axis2_svc_grp_ctx_t * svc_grp_ctx) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_grp_ctx_map) + { + axutil_hash_set(conf_ctx->svc_grp_ctx_map, svc_grp_id, AXIS2_HASH_KEY_STRING, svc_grp_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL +axis2_conf_ctx_get_svc_grp_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_grp_id) +{ + axis2_svc_grp_ctx_t *rv = NULL; + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_grp_ctx_map) + { + rv = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, svc_grp_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_conf_ctx_get_root_dir( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + axis2_char_t *rv = NULL; + /* Do we need to lock here? - damitha */ + axutil_thread_mutex_lock(conf_ctx->mutex); + rv = conf_ctx->root_dir; + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_set_root_dir( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * path) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->root_dir) + { + AXIS2_FREE(env->allocator, conf_ctx->root_dir); + conf_ctx->root_dir = NULL; + } + + if(path) + { + conf_ctx->root_dir = axutil_strdup(env, path); + if(!(conf_ctx->root_dir)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axutil_thread_mutex_unlock(conf_ctx->mutex); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_init( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + axutil_hash_index_t *hi = NULL; + void *ctx = NULL; + + axutil_thread_mutex_lock(conf_ctx->mutex); + conf_ctx->conf = conf; + + for(hi = axutil_hash_first(conf_ctx->op_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_op_ctx_t *op_ctx = (axis2_op_ctx_t *)ctx; + axis2_op_ctx_init(op_ctx, env, conf); + } + } + + for(hi = axutil_hash_first(conf_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_svc_ctx_t *svc_ctx = (axis2_svc_ctx_t *)ctx; + axis2_svc_ctx_init(svc_ctx, env, conf); + } + } + + for(hi = axutil_hash_first(conf_ctx->svc_grp_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_svc_grp_ctx_t *svc_grp_ctx = (axis2_svc_grp_ctx_t *)ctx; + axis2_svc_grp_ctx_init(svc_grp_ctx, env, conf); + } + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_conf_ctx_free( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + if(conf_ctx->base) + { + axis2_ctx_free(conf_ctx->base, env); + } + + if(conf_ctx->op_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->op_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_op_ctx_t *op_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + op_ctx = (axis2_op_ctx_t *)val; + if(op_ctx) + axis2_op_ctx_free(op_ctx, env); + val = NULL; + op_ctx = NULL; + + } + axutil_hash_free(conf_ctx->op_ctx_map, env); + } + + if(conf_ctx->svc_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_svc_ctx_t *svc_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc_ctx = (axis2_svc_ctx_t *)val; + if(svc_ctx) + axis2_svc_ctx_free(svc_ctx, env); + + val = NULL; + svc_ctx = NULL; + + } + axutil_hash_free(conf_ctx->svc_ctx_map, env); + } + + if(conf_ctx->svc_grp_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->svc_grp_ctx_map, env); hi; hi = axutil_hash_next(env, + hi)) + { + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc_grp_ctx = (axis2_svc_grp_ctx_t *)val; + if(svc_grp_ctx) + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + + val = NULL; + svc_grp_ctx = NULL; + + } + axutil_hash_free(conf_ctx->svc_grp_ctx_map, env); + } + if(conf_ctx->conf) + { + axis2_conf_free(conf_ctx->conf, env); + } + if(conf_ctx->mutex) + { + axutil_thread_mutex_destroy(conf_ctx->mutex); + } + + if(conf_ctx->root_dir) + { + AXIS2_FREE(env->allocator, conf_ctx->root_dir); + } + + AXIS2_FREE(env->allocator, conf_ctx); +} + +AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL +axis2_conf_ctx_fill_ctxs( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_char_t *svc_grp_ctx_id = NULL; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_svc_t *svc = NULL; + axis2_svc_grp_t *svc_grp = NULL; + const axutil_qname_t *qname = NULL; + axis2_char_t *svc_id = NULL; + axis2_op_ctx_t *op_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + svc = axis2_msg_ctx_get_svc(msg_ctx, env); + if(!svc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_NOT_YET_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service not yet found in message context. Cannot proceed"); + + return NULL; + } + + qname = axis2_svc_get_qname(svc, env); + if(!qname) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); + return NULL; + } + + svc_id = axutil_qname_get_localpart(qname, env); + if(!svc_id) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); + return NULL; + } + + svc_grp = axis2_svc_get_parent(svc, env); + if(svc_grp) + { + svc_grp_ctx_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + + if(!svc_grp_ctx_id) + { + svc_grp_ctx_id = (axis2_char_t *)axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id( + msg_ctx, env), env); + } + + /* By this time service group context id must have a value, either from transport or from + * addressing + */ + if(svc_grp_ctx_id) + { + svc_grp_ctx = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, + svc_grp_ctx_id, AXIS2_HASH_KEY_STRING); + + if(svc_grp_ctx) + { + svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service group context has no servie context set for service %s", svc_id); + + return NULL; + } + } + } + + if(!svc_grp_ctx_id) + { + svc_grp_ctx_id = axutil_uuid_gen(env); + if(svc_grp_ctx_id) + { + axutil_string_t *svc_grp_ctx_id_str = axutil_string_create_assume_ownership(env, + &svc_grp_ctx_id); + + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + } + } + + if(!svc_grp_ctx) + { + axis2_svc_grp_t *svc_grp = NULL; + svc_grp = axis2_svc_get_parent(svc, env); + svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_grp, env, conf_ctx); + svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service group context has no servie context set for service %s", svc_id); + + return NULL; + } + + axis2_svc_grp_ctx_set_id(svc_grp_ctx, env, svc_grp_ctx_id); + axis2_conf_ctx_register_svc_grp_ctx(conf_ctx, env, svc_grp_ctx_id, svc_grp_ctx); + } + + /* When you come here operation context MUST have already been assigned + to the message context */ + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(!op_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MSG_CTX, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation context not set for message context"); + return NULL; + } + + axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); + axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx); + return svc_grp_ctx; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_set_property( + axis2_conf_ctx_t *conf_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value) +{ + axis2_status_t status = AXIS2_FAILURE; + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + + axutil_thread_mutex_lock(conf_ctx->mutex); + status = axis2_ctx_set_property(conf_ctx->base, env, key, value); + axutil_thread_mutex_unlock(conf_ctx->mutex); + + return status; +} + +AXIS2_EXTERN axutil_property_t *AXIS2_CALL +axis2_conf_ctx_get_property( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * key) +{ + axutil_property_t* property = NULL; + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, key, NULL); + + axutil_thread_mutex_lock(conf_ctx->mutex); + property = axis2_ctx_get_property(conf_ctx->base, env, key); + axutil_thread_mutex_unlock(conf_ctx->mutex); + + return property; +} diff --git a/src/core/context/ctx.c b/src/core/context/ctx.c new file mode 100644 index 0000000..df39a9b --- /dev/null +++ b/src/core/context/ctx.c @@ -0,0 +1,197 @@ +/* + * 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_ctx.h> +#include <axis2_const.h> +#include <axutil_hash.h> + +struct axis2_ctx +{ + + /** non persistent map */ + axutil_hash_t *property_map; + + /** non persistent map is a deep copy */ + axis2_bool_t property_map_deep_copy; +}; + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_ctx_create( + const axutil_env_t * env) +{ + axis2_ctx_t *ctx = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_ctx_t)); + if(!ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ctx->property_map = NULL; + + ctx->property_map = axutil_hash_make(env); + ctx->property_map_deep_copy = AXIS2_TRUE; + if(!(ctx->property_map)) + { + axis2_ctx_free(ctx, env); + return NULL; + } + + return ctx; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ctx_set_property( + struct axis2_ctx * ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(value) + { + /* handle the case where we are setting a new value with the + same key, we would have to free the existing value */ + axutil_property_t *temp_value = axutil_hash_get(ctx->property_map, key, + AXIS2_HASH_KEY_STRING); + if(temp_value) + { + void *temp_value_value = axutil_property_get_value(temp_value, env); + void *value_value = axutil_property_get_value(value, env); + if(temp_value_value != value_value) + { + axutil_property_free(temp_value, env); + } + } + } + if(ctx->property_map) + { + axutil_hash_set(ctx->property_map, key, AXIS2_HASH_KEY_STRING, value); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_property_t *AXIS2_CALL +axis2_ctx_get_property( + const axis2_ctx_t * ctx, + const axutil_env_t * env, + const axis2_char_t * key) +{ + axutil_property_t *ret = NULL; + + if(ctx->property_map) + { + ret = axutil_hash_get(ctx->property_map, key, AXIS2_HASH_KEY_STRING); + } + + /** it is the responsibility of the caller to look-up parent if key is not found here + Note that in C implementation it is the responsibility of the deriving struct to + handle the parent as we do not have the inheritance facility. In case of + context it is not worth trying to mimic inheritance. */ + + return ret; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_ctx_get_all_properties( + const axis2_ctx_t * ctx, + const axutil_env_t * env) +{ + return ctx->property_map; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_ctx_get_property_map( + const axis2_ctx_t * ctx, + const axutil_env_t * env) +{ + return ctx->property_map; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ctx_free( + struct axis2_ctx *ctx, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(ctx->property_map && ctx->property_map_deep_copy) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + for(hi = axutil_hash_first(ctx->property_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_property_t *property = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + property = (axutil_property_t *)val; + + if(property) + { + axutil_property_free(property, env); + } + } + axutil_hash_free(ctx->property_map, env); + } + + AXIS2_FREE(env->allocator, ctx); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ctx_set_property_map( + struct axis2_ctx * ctx, + const axutil_env_t * env, + axutil_hash_t * map) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(ctx->property_map && ctx->property_map_deep_copy) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + for(hi = axutil_hash_first(ctx->property_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_property_t *property = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + property = (axutil_property_t *)val; + + if(property) + { + axutil_property_free(property, env); + } + } + if(ctx->property_map != map) /* handle repeated invocation case */ + { + axutil_hash_free(ctx->property_map, env); + } + } + + ctx->property_map = map; + ctx->property_map_deep_copy = AXIS2_FALSE; + + return AXIS2_SUCCESS; +} diff --git a/src/core/context/msg_ctx.c b/src/core/context/msg_ctx.c new file mode 100644 index 0000000..c2342c4 --- /dev/null +++ b/src/core/context/msg_ctx.c @@ -0,0 +1,2768 @@ +/* + * 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_msg_ctx.h> +#include <axis2_conf_ctx.h> +#include <axis2_op.h> +#include <axis2_svc.h> +#include <axis2_svc_grp.h> +#include <axis2_conf.h> +#include <axis2_transport_in_desc.h> +#include <axis2_transport_out_desc.h> +#include <axis2_out_transport_info.h> +#include <axis2_http_accept_record.h> +#include <axis2_http_header.h> +#include <axiom_soap_envelope.h> +#include <axiom_soap_const.h> +#include <axis2_options.h> + + +struct axis2_msg_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of message context is an op context instance */ + struct axis2_op_ctx *parent; + + /** process fault enabled? */ + axis2_bool_t process_fault; + + /** + * Addressing Information for Axis 2 + * Following Properties will be kept inside this, these fields will be initially filled by + * the transport. Then later an addressing handler will make relevant changes to this, if addressing + * information is present in the SOAP header. + */ + axis2_msg_info_headers_t *msg_info_headers; + axis2_bool_t msg_info_headers_deep_copy; + + struct axis2_op_ctx *op_ctx; + struct axis2_svc_ctx *svc_ctx; + struct axis2_svc_grp_ctx *svc_grp_ctx; + struct axis2_conf_ctx *conf_ctx; + + /** op */ + axis2_op_t *op; + + /** service */ + axis2_svc_t *svc; + + /** service group */ + axis2_svc_grp_t *svc_grp; + + axis2_transport_in_desc_t *transport_in_desc; + axis2_transport_out_desc_t *transport_out_desc; + + /** SOAP envelope */ + axiom_soap_envelope_t *soap_envelope; + + /** Response SOAP envelope */ + axiom_soap_envelope_t *response_soap_envelope; + + /** SOAP Fault envelope */ + axiom_soap_envelope_t *fault_soap_envelope; + + /** in fault flow? */ + axis2_bool_t in_fault_flow; + + /** is this server side? */ + axis2_bool_t server_side; + + /** message ID */ + axis2_char_t *message_id; + + /** new thread required? */ + axis2_bool_t new_thread_required; + + /** paused */ + axis2_bool_t paused; + axis2_bool_t keep_alive; + + /** output written? */ + axis2_bool_t output_written; + + /** service context ID */ + axis2_char_t *svc_ctx_id; + + /** paused phase name */ + axis2_char_t *paused_phase_name; + + /** paused handler name */ + axutil_string_t *paused_handler_name; + + /** SOAP action */ + axutil_string_t *soap_action; + + /** REST HTTP Method */ + axis2_char_t *rest_http_method; + + /** + * Supported REST HTTP Methods + * Made use of in a 405 Error Scenario + */ + axutil_array_list_t *supported_rest_http_methods; + + /** are we doing MTOM now? */ + axis2_bool_t doing_mtom; + + /** are we doing REST now? */ + axis2_bool_t doing_rest; + + /** Rest through HTTP POST? */ + axis2_bool_t do_rest_through_post; + + /** Session management enabled? */ + axis2_bool_t manage_session; + + /* http status code */ + int status_code; + + /** use SOAP 1.1? */ + axis2_bool_t is_soap_11; + + /** service group context id */ + axutil_string_t *svc_grp_ctx_id; + + /** qname of transport in */ + AXIS2_TRANSPORT_ENUMS transport_in_desc_enum; + + /** qname of transport out */ + AXIS2_TRANSPORT_ENUMS transport_out_desc_enum; + + /** service group id */ + axis2_char_t *svc_grp_id; + + /** service description qname */ + axutil_qname_t *svc_qname; + + /** op qname */ + axutil_qname_t *op_qname; + /* To keep track of the direction */ + int flow; + + /** The chain of Handlers/Phases for processing this message */ + axutil_array_list_t *execution_chain; + + /** Index into the execution chain of the currently executing handler */ + int current_handler_index; + + /** Index of the paused handler */ + int paused_handler_index; + + /** Index of the paused phase */ + int paused_phase_index; + + /** Index into the current Phase of the currently executing handler (if any)*/ + int current_phase_index; + + /* axis2 options container */ + + axis2_options_t *options; + + /** + * Finds the service to be invoked. This function is used by dispatchers + * to locate the service to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to service to be invoked + */ + struct axis2_svc * + ( + AXIS2_CALL * find_svc) + ( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Finds the operation to be invoked in the given service. This function + * is used by dispatchers to locate the operation to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc pointer to service to whom the operation belongs + * @return pointer to the operation to be invoked + */ + struct axis2_op * + ( + AXIS2_CALL * find_op) + ( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc * svc); + + axutil_string_t *charset_encoding; + axutil_stream_t *transport_out_stream; + axis2_out_transport_info_t *out_transport_info; + axutil_hash_t *transport_headers; + axutil_array_list_t *output_headers; + axutil_array_list_t *accept_record_list; + axutil_array_list_t *accept_charset_record_list; + axutil_array_list_t *accept_language_record_list; + axis2_char_t *transfer_encoding; + axis2_char_t *content_language; + axis2_char_t *transport_url; + axis2_bool_t is_auth_failure; + axis2_bool_t required_auth_is_http; + axis2_char_t *auth_type; + axis2_bool_t no_content; + + axutil_array_list_t *mime_parts; + int ref; +}; + +AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL +axis2_msg_ctx_create( + const axutil_env_t * env, + struct axis2_conf_ctx *conf_ctx, + struct axis2_transport_in_desc *transport_in_desc, + struct axis2_transport_out_desc *transport_out_desc) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + + msg_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ctx_t)); + if(!msg_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)msg_ctx, 0, sizeof(axis2_msg_ctx_t)); + msg_ctx->base = NULL; + msg_ctx->process_fault = AXIS2_FALSE; + msg_ctx->msg_info_headers = NULL; + msg_ctx->op_ctx = NULL; + msg_ctx->svc_ctx = NULL; + msg_ctx->svc_grp_ctx = NULL; + msg_ctx->conf_ctx = NULL; + msg_ctx->op = NULL; + msg_ctx->svc = NULL; + msg_ctx->svc_grp = NULL; + msg_ctx->transport_in_desc = NULL; + msg_ctx->transport_out_desc = NULL; + msg_ctx->soap_envelope = NULL; + msg_ctx->fault_soap_envelope = NULL; + msg_ctx->in_fault_flow = AXIS2_FALSE; + msg_ctx->server_side = AXIS2_FALSE; + msg_ctx->message_id = NULL; + msg_ctx->new_thread_required = AXIS2_FALSE; + msg_ctx->paused = AXIS2_FALSE; + msg_ctx->keep_alive = AXIS2_FALSE; + msg_ctx->output_written = AXIS2_FALSE; + msg_ctx->svc_ctx_id = NULL; + msg_ctx->paused_phase_name = NULL; + msg_ctx->paused_handler_name = NULL; + msg_ctx->soap_action = NULL; + msg_ctx->rest_http_method = NULL; + msg_ctx->supported_rest_http_methods = NULL; + msg_ctx->doing_mtom = AXIS2_FALSE; + msg_ctx->doing_rest = AXIS2_FALSE; + msg_ctx->do_rest_through_post = AXIS2_FALSE; + msg_ctx->manage_session = AXIS2_FALSE; + msg_ctx->is_soap_11 = AXIS2_FALSE; + msg_ctx->svc_grp_ctx_id = NULL; + msg_ctx->transport_in_desc_enum = AXIS2_TRANSPORT_ENUM_MAX; + msg_ctx->transport_out_desc_enum = AXIS2_TRANSPORT_ENUM_MAX; + msg_ctx->svc_grp_id = NULL; + msg_ctx->svc_qname = NULL; + msg_ctx->op_qname = NULL; + msg_ctx->flow = AXIS2_IN_FLOW; + msg_ctx->execution_chain = NULL; + msg_ctx->current_handler_index = -1; + msg_ctx->paused_handler_index = -1; + msg_ctx->current_phase_index = 0; + msg_ctx->paused_phase_index = 0; + msg_ctx->charset_encoding = NULL; + msg_ctx->transport_out_stream = NULL; + msg_ctx->out_transport_info = NULL; + msg_ctx->transport_headers = NULL; + msg_ctx->accept_record_list = NULL; + msg_ctx->accept_charset_record_list = NULL; + msg_ctx->output_headers = NULL; + msg_ctx->accept_language_record_list = NULL; + msg_ctx->transfer_encoding = NULL; + msg_ctx->content_language = NULL; + msg_ctx->transport_url = NULL; + msg_ctx->response_soap_envelope = NULL; + msg_ctx->is_auth_failure = AXIS2_FALSE; + msg_ctx->required_auth_is_http = AXIS2_FALSE; + msg_ctx->auth_type = NULL; + msg_ctx->no_content = AXIS2_FALSE; + msg_ctx->status_code = 0; + msg_ctx->options = NULL; + msg_ctx->mime_parts = NULL; + + msg_ctx->base = axis2_ctx_create(env); + if(!(msg_ctx->base)) + { + axis2_msg_ctx_free(msg_ctx, env); + return NULL; + } + + if(transport_in_desc) + msg_ctx->transport_in_desc = transport_in_desc; + if(transport_out_desc) + msg_ctx->transport_out_desc = transport_out_desc; + if(conf_ctx) + msg_ctx->conf_ctx = conf_ctx; + + if(msg_ctx->transport_in_desc) + msg_ctx->transport_in_desc_enum = axis2_transport_in_desc_get_enum(transport_in_desc, env); + if(msg_ctx->transport_out_desc) + msg_ctx->transport_out_desc_enum = axis2_transport_out_desc_get_enum(transport_out_desc, + env); + + msg_ctx->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); + if(!(msg_ctx->msg_info_headers)) + { + axis2_msg_ctx_free(msg_ctx, env); + return NULL; + } + msg_ctx->msg_info_headers_deep_copy = AXIS2_TRUE; + msg_ctx->ref = 1; + + return msg_ctx; +} + +/******************************************************************************/ +struct axis2_ctx *AXIS2_CALL +axis2_msg_ctx_get_base( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + return msg_ctx->base; +} + +struct axis2_op_ctx *AXIS2_CALL +axis2_msg_ctx_get_parent( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->parent; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_parent( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx * parent) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(parent) + { + msg_ctx->parent = parent; + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_msg_ctx_free( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(--(msg_ctx->ref) > 0) + { + return; + } + + if(msg_ctx->keep_alive) + { + return; + } + + if(msg_ctx->base) + { + axis2_ctx_free(msg_ctx->base, env); + } + + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + } + + if(msg_ctx->message_id) + { + AXIS2_FREE(env->allocator, msg_ctx->message_id); + } + + if(msg_ctx->svc_ctx_id) + { + AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id); + } + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + if(msg_ctx->rest_http_method) + { + AXIS2_FREE(env->allocator, msg_ctx->rest_http_method); + } + + if(msg_ctx->svc_grp_ctx_id) + { + axutil_string_free(msg_ctx->svc_grp_ctx_id, env); + } + + if(msg_ctx->soap_envelope) + { + axiom_soap_envelope_free(msg_ctx->soap_envelope, env); + } + + if(msg_ctx->fault_soap_envelope) + { + axiom_soap_envelope_free(msg_ctx->fault_soap_envelope, env); + } + + if(msg_ctx->charset_encoding) + { + axutil_string_free(msg_ctx->charset_encoding, env); + } + + if(msg_ctx->transport_out_stream) + { + axutil_stream_free(msg_ctx->transport_out_stream, env); + } + + if(msg_ctx->out_transport_info) + { + AXIS2_OUT_TRANSPORT_INFO_FREE(msg_ctx->out_transport_info, env); + } + + if(msg_ctx->transport_headers) + { + axutil_hash_free(msg_ctx->transport_headers, env); + } + + if(msg_ctx->accept_charset_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_charset_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_charset_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_charset_record_list, env); + } + + if(msg_ctx->output_headers) + { + axis2_http_header_t *header = NULL; + while(axutil_array_list_size(msg_ctx->output_headers, env)) + { + header = (axis2_http_header_t *)axutil_array_list_remove(msg_ctx->output_headers, env, + 0); + if(header) + { + axis2_http_header_free(header, env); + } + } + axutil_array_list_free(msg_ctx->output_headers, env); + } + + if(msg_ctx->accept_language_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_language_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_language_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_language_record_list, env); + } + + if(msg_ctx->accept_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_record_list, env); + } + + if(msg_ctx->transfer_encoding) + { + AXIS2_FREE(env->allocator, msg_ctx->transfer_encoding); + } + + if(msg_ctx->content_language) + { + AXIS2_FREE(env->allocator, msg_ctx->content_language); + } + + if(msg_ctx->auth_type) + { + AXIS2_FREE(env->allocator, msg_ctx->auth_type); + } + + if(msg_ctx->supported_rest_http_methods) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(msg_ctx->supported_rest_http_methods, env); + for(i = 0; i < size; i++) + { + axis2_char_t *rest_http_method = NULL; + rest_http_method = axutil_array_list_get(msg_ctx->supported_rest_http_methods, env, i); + if(rest_http_method) + { + AXIS2_FREE(env->allocator, rest_http_method); + } + } + axutil_array_list_free(msg_ctx->supported_rest_http_methods, env); + } + + if(msg_ctx->options) + { + /* freeing only axis2_options_t allocated space, should not + * call axis2_options_free because it will free internal + * properties as well. */ + AXIS2_FREE(env->allocator, msg_ctx->options); + } + + AXIS2_FREE(env->allocator, msg_ctx); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_increment_ref( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + msg_ctx->ref++; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_init( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_conf * conf) +{ + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + msg_ctx->transport_in_desc = axis2_conf_get_transport_in(conf, env, + msg_ctx-> transport_in_desc_enum); + + msg_ctx->transport_out_desc = axis2_conf_get_transport_out(conf, env, + msg_ctx-> transport_out_desc_enum); + + if(msg_ctx->svc_grp_id) + { + msg_ctx->svc_grp = axis2_conf_get_svc_grp(conf, env, msg_ctx->svc_grp_id); + } + + if(msg_ctx->svc_qname) + { + msg_ctx->svc = axis2_conf_get_svc(conf, env, axutil_qname_get_localpart( + msg_ctx-> svc_qname, env)); + } + + if(msg_ctx->op_qname) + { + if(msg_ctx->svc) + msg_ctx->op = axis2_svc_get_op_with_qname(msg_ctx->svc, env, msg_ctx->op_qname); + } + + return AXIS2_SUCCESS; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_fault_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_fault_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_from( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_from(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_in_fault_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->in_fault_flow; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->soap_envelope; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_response_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->response_soap_envelope; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_fault_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->fault_soap_envelope; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_msg_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_message_id(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_msg_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * msg_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, msg_id); + } + + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_process_fault( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->process_fault; +} + +axis2_relates_to_t *AXIS2_CALL +axis2_msg_ctx_get_relates_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_relates_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_reply_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_reply_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_server_side( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->server_side; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_fault_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_from( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_from(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_in_fault_flow( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t in_fault_flow) +{ + msg_ctx->in_fault_flow = in_fault_flow; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(soap_envelope) + { + int soap_v = AXIOM_SOAP12; + soap_v = axiom_soap_envelope_get_soap_version(soap_envelope, env); + msg_ctx->is_soap_11 = (soap_v == AXIOM_SOAP12) ? AXIS2_FALSE : AXIS2_TRUE; + msg_ctx->soap_envelope = soap_envelope; + } + else + { + msg_ctx->soap_envelope = NULL; + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_response_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(soap_envelope) + { + int soap_v = AXIOM_SOAP12; + soap_v = axiom_soap_envelope_get_soap_version(soap_envelope, env); + msg_ctx->response_soap_envelope = soap_envelope; + } + else + { + msg_ctx->response_soap_envelope = NULL; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_fault_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->fault_soap_envelope = soap_envelope; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_message_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, message_id); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_process_fault( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t process_fault) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->process_fault = process_fault; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_relates_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_relates_to_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_relates_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_reply_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_reply_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_server_side( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t server_side) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->server_side = server_side; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_new_thread_required( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + return msg_ctx->new_thread_required; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_new_thread_required( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t new_thread_required) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->new_thread_required = new_thread_required; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_wsa_action( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * action_uri) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_action(msg_ctx->msg_info_headers, env, action_uri); + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_wsa_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_action(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_wsa_message_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, message_id); + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_wsa_message_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_message_id(msg_ctx->msg_info_headers, env); + } + + return NULL; + +} + +axis2_msg_info_headers_t *AXIS2_CALL +axis2_msg_ctx_get_msg_info_headers( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->msg_info_headers; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_paused( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->paused; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_paused( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t paused) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->paused = paused; + msg_ctx->paused_phase_index = msg_ctx->current_phase_index; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_keep_alive( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t keep_alive) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->keep_alive = keep_alive; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_is_keep_alive( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->keep_alive; +} + +struct axis2_transport_in_desc *AXIS2_CALL +axis2_msg_ctx_get_transport_in_desc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->transport_in_desc; +} + +struct axis2_transport_out_desc *AXIS2_CALL +axis2_msg_ctx_get_transport_out_desc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->transport_out_desc; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_in_desc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_in_desc * transport_in_desc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(transport_in_desc) + { + msg_ctx->transport_in_desc = transport_in_desc; + msg_ctx->transport_in_desc_enum = axis2_transport_in_desc_get_enum(transport_in_desc, env); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_out_desc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_out_desc * transport_out_desc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(transport_out_desc) + { + msg_ctx->transport_out_desc = transport_out_desc; + msg_ctx->transport_out_desc_enum = axis2_transport_out_desc_get_enum(transport_out_desc, + env); + } + + return AXIS2_SUCCESS; +} + +struct axis2_op_ctx *AXIS2_CALL +axis2_msg_ctx_get_op_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->op_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_op_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx * op_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(op_ctx) + { + msg_ctx->op_ctx = op_ctx; + + if(msg_ctx->svc_ctx) + { + if(!(axis2_op_ctx_get_parent(msg_ctx->op_ctx, env))) + { + axis2_op_ctx_set_parent(msg_ctx->op_ctx, env, msg_ctx->svc_ctx); + } + } + axis2_msg_ctx_set_parent(msg_ctx, env, op_ctx); + axis2_msg_ctx_set_op(msg_ctx, env, axis2_op_ctx_get_op(op_ctx, env)); + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_output_written( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->output_written; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_output_written( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t output_written) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->output_written = output_written; + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_rest_http_method( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->rest_http_method; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_rest_http_method( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * rest_http_method) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->rest_http_method) + { + AXIS2_FREE(env->allocator, msg_ctx->rest_http_method); + msg_ctx->rest_http_method = NULL; + } + + if(rest_http_method) + { + msg_ctx->rest_http_method = axutil_strdup(env, rest_http_method); + if(!(msg_ctx->rest_http_method)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_svc_ctx_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_ctx_id; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_ctx_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_ctx_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->svc_ctx_id) + { + AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id); + msg_ctx->svc_ctx_id = NULL; + } + + if(svc_ctx_id) + { + msg_ctx->svc_ctx_id = axutil_strdup(env, svc_ctx_id); + if(!(msg_ctx->svc_ctx_id)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +struct axis2_conf_ctx *AXIS2_CALL +axis2_msg_ctx_get_conf_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->conf_ctx; +} + +struct axis2_svc_ctx *AXIS2_CALL +axis2_msg_ctx_get_svc_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_conf_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_conf_ctx * conf_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(conf_ctx) + { + msg_ctx->conf_ctx = conf_ctx; + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx * svc_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc_ctx) + { + msg_ctx->svc_ctx = svc_ctx; + + if(msg_ctx->op_ctx) + { + if(!axis2_op_ctx_get_parent(msg_ctx->op_ctx, env)) + axis2_op_ctx_set_parent(msg_ctx->op_ctx, env, svc_ctx); + } + axis2_msg_ctx_set_svc(msg_ctx, env, axis2_svc_ctx_get_svc(svc_ctx, env)); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_msg_info_headers( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_msg_info_headers_t * msg_info_headers) +{ + AXIS2_PARAM_CHECK(env->error, msg_info_headers, AXIS2_FAILURE); + + if(msg_info_headers) + { + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + msg_ctx->msg_info_headers = NULL; + } + msg_ctx->msg_info_headers = msg_info_headers; + msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE; + } + + return AXIS2_SUCCESS; +} + +axutil_param_t *AXIS2_CALL +axis2_msg_ctx_get_parameter( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key) +{ + axutil_param_t *param = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->op) + { + param = axis2_op_get_param(msg_ctx->op, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->svc) + { + param = axis2_svc_get_param(msg_ctx->svc, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->svc_grp) + { + param = axis2_svc_grp_get_param(msg_ctx->svc_grp, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(msg_ctx->conf_ctx, env); + param = axis2_conf_get_param(conf, env, key); + } + + return param; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_msg_ctx_get_property_value( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * property_str) +{ + axutil_property_t *property; + void *property_value = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + property = axis2_msg_ctx_get_property(msg_ctx, env, property_str); + + if(!property) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "%s not set in message context", property_str); + return NULL; + } + + property_value = axutil_property_get_value(property, env); + if(!property_value) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "%s properties not set in message context", + property_str); + return NULL; + } + + return property_value; +} + +axutil_property_t *AXIS2_CALL +axis2_msg_ctx_get_property( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key) +{ + void *obj = NULL; + axis2_ctx_t *ctx = NULL; + + /* Don't use AXIS2_PARAM_CHECK to verify msg_ctx, as it clobbers + env->error->status_code destroying the information therein that + an error has already occurred. */ + if(!msg_ctx) + { + if(axutil_error_get_status_code(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + } + return obj; + } + + /* search in message context */ + obj = axis2_ctx_get_property(msg_ctx->base, env, key); + if(obj) + { + return obj; + } + + if(msg_ctx->op_ctx) + { + ctx = axis2_op_ctx_get_base(msg_ctx->op_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->svc_ctx) + { + ctx = axis2_svc_ctx_get_base(msg_ctx->svc_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->svc_grp_ctx) + { + ctx = axis2_svc_grp_ctx_get_base(msg_ctx->svc_grp_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->conf_ctx) + { + ctx = axis2_conf_ctx_get_base(msg_ctx->conf_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_property( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + return axis2_ctx_set_property(msg_ctx->base, env, key, value); +} + +const axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_paused_handler_name( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->paused_handler_name; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_paused_phase_name( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->paused_phase_name; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_paused_phase_name( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * paused_phase_name) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + /* a shallow copy is sufficient as phase lives beyond message */ + msg_ctx->paused_phase_name = (axis2_char_t *)paused_phase_name; + return AXIS2_SUCCESS; +} + +axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_soap_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->soap_action; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_soap_action( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axutil_string_t * soap_action) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + if(soap_action) + { + msg_ctx->soap_action = axutil_string_clone(soap_action, env); + if(!(msg_ctx->soap_action)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_doing_mtom( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + + if(!(msg_ctx->doing_mtom) && msg_ctx->conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(msg_ctx->conf_ctx, env); + msg_ctx->doing_mtom = axis2_conf_get_enable_mtom(conf, env); + } + + return msg_ctx->doing_mtom; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_doing_mtom( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_mtom) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->doing_mtom = doing_mtom; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_doing_rest( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + /* Don't use AXIS2_PARAM_CHECK to verify msg_ctx, as it clobbers + env->error->status_code destroying the information therein that + an error has already occurred. */ + if(!msg_ctx) + { + if(axutil_error_get_status_code(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + } + return AXIS2_FALSE; + } + return msg_ctx->doing_rest; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_doing_rest( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_rest) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->doing_rest = doing_rest; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_do_rest_through_post( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t do_rest_through_post) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->do_rest_through_post = do_rest_through_post; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_do_rest_through_post( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->do_rest_through_post; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_manage_session( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->manage_session; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_manage_session( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t manage_session) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->manage_session = manage_session; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_is_soap_11( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->is_soap_11; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_is_soap_11( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t is_soap11) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->is_soap_11 = is_soap11; + return AXIS2_SUCCESS; +} + +struct axis2_svc_grp_ctx *AXIS2_CALL +axis2_msg_ctx_get_svc_grp_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_grp_ctx * svc_grp_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc_grp_ctx) + { + msg_ctx->svc_grp_ctx = svc_grp_ctx; + } + + return AXIS2_SUCCESS; +} + +axis2_op_t *AXIS2_CALL +axis2_msg_ctx_get_op( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->op; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_op( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_op_t * op) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(op) + { + msg_ctx->op = op; + msg_ctx->op_qname = (axutil_qname_t *)axis2_op_get_qname(op, env); + } + + return AXIS2_SUCCESS; +} + +axis2_svc_t *AXIS2_CALL +axis2_msg_ctx_get_svc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc) + { + axis2_svc_grp_t *svc_grp = NULL; + msg_ctx->svc = svc; + msg_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + + svc_grp = axis2_svc_get_parent(svc, env); + if(svc_grp) + { + msg_ctx->svc_grp = svc_grp; + msg_ctx->svc_grp_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + } + + return AXIS2_SUCCESS; +} + +axis2_svc_grp_t *AXIS2_CALL +axis2_msg_ctx_get_svc_grp( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(svc_grp) + { + msg_ctx->svc_grp = svc_grp; + msg_ctx->svc_grp_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + + return AXIS2_SUCCESS; +} + +const axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_svc_grp_ctx_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp_ctx_id; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp_ctx_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axutil_string_t * svc_grp_ctx_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->svc_grp_ctx_id) + { + axutil_string_free(msg_ctx->svc_grp_ctx_id, env); + msg_ctx->svc_grp_ctx_id = NULL; + } + + if(svc_grp_ctx_id) + { + msg_ctx->svc_grp_ctx_id = axutil_string_clone(svc_grp_ctx_id, env); + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_is_paused( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->paused; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + AXIS2_MSG_CTX_FIND_SVC func) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->find_svc = func; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + AXIS2_MSG_CTX_FIND_OP func) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->find_op = func; + return AXIS2_SUCCESS; +} + +axis2_options_t *AXIS2_CALL +axis2_msg_ctx_get_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_hash_t *properties = NULL; + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(!msg_ctx->options) + { + msg_ctx->options = axis2_options_create(env); + + if(!msg_ctx->options) + { + return NULL; + } + } + + axis2_options_set_msg_info_headers(msg_ctx->options, env, msg_ctx->msg_info_headers); + properties = axis2_ctx_get_property_map(msg_ctx->base, env); + axis2_options_set_properties(msg_ctx->options, env, properties); + return msg_ctx->options; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_options_t * options) +{ + axutil_property_t *rest_val = NULL; + axis2_char_t *value; + axutil_string_t *soap_action = NULL; + ; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, options, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + } + msg_ctx->msg_info_headers = axis2_options_get_msg_info_headers(options, env); + msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE; + + msg_ctx->doing_mtom = axis2_options_get_enable_mtom(options, env); + + msg_ctx->manage_session = axis2_options_get_manage_session(options, env); + + axis2_ctx_set_property_map(msg_ctx->base, env, axis2_options_get_properties(options, env)); + rest_val = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_val) + { + value = (axis2_char_t *)axutil_property_get_value(rest_val, env); + if(value) + { + if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0) + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + } + } + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + soap_action = axis2_options_get_soap_action(options, env); + if(soap_action) + { + msg_ctx->soap_action = axutil_string_clone(soap_action, env); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_flow( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + int flow) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->flow = flow; + return AXIS2_SUCCESS; +} + +int AXIS2_CALL +axis2_msg_ctx_get_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->flow; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_execution_chain( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * execution_chain) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->execution_chain = execution_chain; + msg_ctx->current_handler_index = -1; + msg_ctx->paused_handler_index = -1; + msg_ctx->current_phase_index = 0; + + return AXIS2_SUCCESS; +} + +axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_execution_chain( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->execution_chain; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_supported_rest_http_methods( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * supported_rest_http_methods) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->supported_rest_http_methods = supported_rest_http_methods; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_supported_rest_http_methods( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->supported_rest_http_methods; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_current_handler_index( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int index) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->current_handler_index = index; + if(msg_ctx->execution_chain) + { + axis2_handler_t *handler = (axis2_handler_t *)axutil_array_list_get( + msg_ctx->execution_chain, env, index); + if(handler) + { + msg_ctx->paused_handler_name = (axutil_string_t *)axis2_handler_get_name(handler, env); + } + } + return AXIS2_SUCCESS; +} + +int AXIS2_CALL +axis2_msg_ctx_get_current_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->current_handler_index; +} + +int AXIS2_CALL +axis2_msg_ctx_get_paused_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->paused_handler_index; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_current_phase_index( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int index) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->current_phase_index = index; + return AXIS2_SUCCESS; + +} + +int AXIS2_CALL +axis2_msg_ctx_get_current_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->current_phase_index; +} + +int AXIS2_CALL +axis2_msg_ctx_get_paused_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->paused_phase_index; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_msg_ctx_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->find_svc(msg_ctx, env); +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_msg_ctx_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->find_op(msg_ctx, env, svc); +} + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_charset_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + return msg_ctx->charset_encoding; + else + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_charset_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_string_t * str) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->charset_encoding) + { + axutil_string_free(msg_ctx->charset_encoding, env); + msg_ctx->charset_encoding = NULL; + } + if(str) + { + msg_ctx->charset_encoding = axutil_string_clone(str, env); + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axis2_msg_ctx_get_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + { + return msg_ctx->transport_out_stream; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_stream_t * stream) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->transport_out_stream) + { + axutil_stream_free(msg_ctx->transport_out_stream, env); + } + + msg_ctx->transport_out_stream = stream; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_reset_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + msg_ctx->transport_out_stream = NULL; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_out_transport_info_t *AXIS2_CALL +axis2_msg_ctx_get_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + { + return msg_ctx->out_transport_info; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_out_transport_info_t * out_transport_info) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->out_transport_info) + { + AXIS2_OUT_TRANSPORT_INFO_FREE(msg_ctx->out_transport_info, env); + } + + msg_ctx->out_transport_info = out_transport_info; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_reset_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + msg_ctx->out_transport_info = NULL; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_msg_ctx_get_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->transport_headers; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_msg_ctx_extract_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_hash_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->transport_headers; + msg_ctx->transport_headers = NULL; + return temp; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_hash_t * transport_headers) +{ + if(msg_ctx) + { + if(msg_ctx->transport_headers) + { + axutil_hash_free(msg_ctx->transport_headers, env); + } + + msg_ctx->transport_headers = transport_headers; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->accept_record_list; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_extract_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_record_list; + msg_ctx->accept_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_record_list) +{ + if(msg_ctx) + { + if(msg_ctx->accept_record_list && msg_ctx->accept_record_list != accept_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_record_list, env); + } + msg_ctx->accept_record_list = accept_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->accept_charset_record_list; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_extract_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_charset_record_list; + msg_ctx->accept_charset_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_charset_record_list) +{ + if(msg_ctx) + { + if(msg_ctx->accept_charset_record_list && msg_ctx->accept_charset_record_list + != accept_charset_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_charset_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_charset_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_charset_record_list, env); + } + msg_ctx->accept_charset_record_list = accept_charset_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->output_headers; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_extract_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + axutil_array_list_t *temp = NULL; + temp = msg_ctx->output_headers; + msg_ctx->output_headers = NULL; + return temp; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * output_headers) +{ + if(msg_ctx) + { + if(msg_ctx->output_headers && msg_ctx->output_headers != output_headers) + { + axis2_http_header_t *header = NULL; + while(axutil_array_list_size(msg_ctx->output_headers, env)) + { + header = (axis2_http_header_t *)axutil_array_list_remove(msg_ctx->output_headers, + env, 0); + if(header) + { + axis2_http_header_free(header, env); + } + } + axutil_array_list_free(msg_ctx->output_headers, env); + } + msg_ctx->output_headers = output_headers; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->accept_language_record_list; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_extract_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_language_record_list; + msg_ctx->accept_language_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_language_record_list) +{ + if(msg_ctx) + { + if(msg_ctx->accept_language_record_list && msg_ctx->accept_language_record_list + != accept_language_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_language_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_language_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_language_record_list, env); + } + msg_ctx->accept_language_record_list = accept_language_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_transfer_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->transfer_encoding; + else + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transfer_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str) +{ + if(msg_ctx) + { + if(msg_ctx->transfer_encoding) + { + AXIS2_FREE(env->allocator, msg_ctx->transfer_encoding); + msg_ctx->transfer_encoding = NULL; + } + if(str) + { + msg_ctx->transfer_encoding = str; + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_content_language( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->content_language; + else + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_content_language( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str) +{ + if(msg_ctx) + { + if(msg_ctx->content_language) + { + AXIS2_FREE(env->allocator, msg_ctx->content_language); + msg_ctx->content_language = NULL; + } + if(str) + { + msg_ctx->content_language = str; + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_transport_url( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->transport_url; + else + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_url( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str) +{ + if(msg_ctx) + { + /* this is a shallow copy, no need to free */ + msg_ctx->transport_url = str; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_msg_ctx_get_status_code( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->status_code; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_status_code( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int status_code) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->status_code = status_code; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_auth_failed( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->is_auth_failure; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_auth_failed( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t status) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->is_auth_failure = status; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_no_content( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->no_content; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_no_content( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t no_content) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->no_content = no_content; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_required_auth_is_http( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->required_auth_is_http; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_required_auth_is_http( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t status) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->required_auth_is_http = status; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_auth_type( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * auth_type) +{ + if(msg_ctx->auth_type) + { + AXIS2_FREE(env->allocator, msg_ctx->auth_type); + } + msg_ctx->auth_type = NULL; + if(auth_type) + { + msg_ctx->auth_type = axutil_strdup(env, auth_type); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_auth_type( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + return msg_ctx->auth_type; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_mime_parts( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + return msg_ctx->mime_parts; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_msg_ctx_set_mime_parts( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t *mime_parts) +{ + if(msg_ctx->mime_parts) + { + axutil_array_list_free(mime_parts, env); + msg_ctx->mime_parts = NULL; + } + msg_ctx->mime_parts = mime_parts; +} diff --git a/src/core/context/op_ctx.c b/src/core/context/op_ctx.c new file mode 100644 index 0000000..30f0e3b --- /dev/null +++ b/src/core/context/op_ctx.c @@ -0,0 +1,420 @@ +/* + * 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_op_ctx.h> +#include <axis2_conf_ctx.h> +#include <axis2_op.h> +#include <axis2_const.h> +#include <axutil_hash.h> + +struct axis2_op_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of operation context is a service context instance */ + struct axis2_svc_ctx *parent; + + /** message context map */ + axis2_msg_ctx_t *msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_MAX]; + + /** + * the operation of which this is a running instance. The MEP of this + * operation must be one of the 8 predefined ones in WSDL 2.0. + */ + axis2_op_t *op; + + /** operation Message Exchange Pattern (MEP) */ + int op_mep; + + /** is complete? */ + axis2_bool_t is_complete; + + /** the global message_id -> op_ctx map which is stored in + * the axis2_conf_ctx. We are caching it here for faster access. + */ + axutil_hash_t *op_ctx_map; + + /** op qname */ + axutil_qname_t *op_qname; + + /** service qname */ + axutil_qname_t *svc_qname; + /* mutex to synchronize the read/write operations */ + axutil_thread_mutex_t *mutex; + axis2_bool_t response_written; + axis2_bool_t is_in_use; + + int ref; +}; + +AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL +axis2_op_ctx_create( + const axutil_env_t * env, + axis2_op_t * op, + struct axis2_svc_ctx *svc_ctx) +{ + axis2_op_ctx_t *op_ctx = NULL; + int i = 0; + + op_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_op_ctx_t)); + if(!op_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + op_ctx->base = NULL; + op_ctx->parent = NULL; + op_ctx->op = NULL; + op_ctx->op_mep = 0; + op_ctx->is_complete = AXIS2_FALSE; + op_ctx->is_in_use = AXIS2_FALSE; + op_ctx->op_ctx_map = NULL; + op_ctx->op_qname = NULL; + op_ctx->svc_qname = NULL; + op_ctx->response_written = AXIS2_FALSE; + op_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + + if(!op_ctx->mutex) + { + axis2_op_ctx_free(op_ctx, env); + return NULL; + } + + op_ctx->base = axis2_ctx_create(env); + if(!(op_ctx->base)) + { + axis2_op_ctx_free(op_ctx, env); + return NULL; + } + + if(op) + { + op_ctx->op = op; + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + op_ctx->msg_ctx_array[i] = NULL; + } + + if(op_ctx->op) + { + op_ctx->op_qname = (axutil_qname_t *)axis2_op_get_qname(op_ctx->op, env); + op_ctx->op_mep = axis2_op_get_axis_specific_mep_const(op_ctx->op, env); + } + + axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); + op_ctx->ref = 1; + + return op_ctx; +} + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_op_ctx_get_base( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->base; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_ctx_free( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env) +{ + int i = 0; + if(--(op_ctx->ref) > 0) + { + return; + } + if(op_ctx->is_in_use) + { + return; + } + + if(op_ctx->base) + { + axis2_ctx_free(op_ctx->base, env); + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_free(op_ctx->msg_ctx_array[i], env); + op_ctx->msg_ctx_array[i] = NULL; + } + } + + if(op_ctx->mutex) + { + axutil_thread_mutex_destroy(op_ctx->mutex); + } + + AXIS2_FREE(env->allocator, op_ctx); + + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_ctx_destroy_mutex( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env) +{ + + if(op_ctx->mutex) + { + axutil_thread_mutex_destroy(op_ctx->mutex); + op_ctx->mutex = NULL; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_init( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + struct axis2_conf *conf) +{ + int i = 0; + + if(op_ctx->op_qname && op_ctx->svc_qname) + { + axis2_svc_t *svc = NULL; + axis2_char_t *svc_name = NULL; + + svc_name = axutil_qname_get_localpart(op_ctx->svc_qname, env); + + if(svc_name) + { + svc = axis2_conf_get_svc(conf, env, svc_name); + + if(svc) + { + op_ctx->op = axis2_svc_get_op_with_qname(svc, env, op_ctx->op_qname); + } + } + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_init(op_ctx->msg_ctx_array[i], env, conf); + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_op_ctx_get_op( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->op; +} + +AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL +axis2_op_ctx_get_parent( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->parent; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_add_msg_ctx( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + + axutil_thread_mutex_lock(op_ctx->mutex); + + out_msg_ctx = op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_IN]; + + if(out_msg_ctx && in_msg_ctx) + { + axutil_thread_mutex_unlock(op_ctx->mutex); + return AXIS2_FAILURE; + } + + if(!out_msg_ctx) + { + op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx; + } + else + { + op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx; + } + + axutil_thread_mutex_unlock(op_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL +axis2_op_ctx_get_msg_ctx( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_wsdl_msg_labels_t message_id) +{ + axutil_thread_mutex_lock(op_ctx->mutex); + if(op_ctx->msg_ctx_array) + { + axis2_msg_ctx_t *rv = NULL; + rv = op_ctx->msg_ctx_array[message_id]; + axutil_thread_mutex_unlock(op_ctx->mutex); + return rv; + } + axutil_thread_mutex_unlock(op_ctx->mutex); + return NULL; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_op_ctx_get_is_complete( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->is_complete; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_set_complete( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env, + axis2_bool_t is_complete) +{ + op_ctx->is_complete = is_complete; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_op_ctx_is_in_use( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->is_in_use; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_set_in_use( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env, + axis2_bool_t is_in_use) +{ + op_ctx->is_in_use = is_in_use; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_cleanup( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env) +{ + int i = 0; + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_free(op_ctx->msg_ctx_array[i], env); + op_ctx->msg_ctx_array[i] = NULL; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_set_parent( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx * svc_ctx) +{ + if(svc_ctx) + { + op_ctx->parent = svc_ctx; + } + + if(op_ctx->parent) /* that is if there is a service context associated */ + { + axis2_conf_ctx_t *conf_ctx = NULL; + conf_ctx = axis2_svc_ctx_get_conf_ctx(op_ctx->parent, env); + if(conf_ctx) + { + op_ctx->op_ctx_map = axis2_conf_ctx_get_op_ctx_map(conf_ctx, env); + } + op_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(axis2_svc_ctx_get_svc( + op_ctx->parent, env), env); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_ctx_t **AXIS2_CALL +axis2_op_ctx_get_msg_ctx_map( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return (axis2_msg_ctx_t **)(op_ctx->msg_ctx_array); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_op_ctx_get_response_written( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + if(op_ctx) + return op_ctx->response_written; + else + return AXIS2_FALSE; + +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_set_response_written( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_bool_t written) +{ + if(op_ctx) + { + op_ctx->response_written = written; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_increment_ref( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + op_ctx->ref++; + return AXIS2_SUCCESS; +} + diff --git a/src/core/context/svc_ctx.c b/src/core/context/svc_ctx.c new file mode 100644 index 0000000..c9e19fe --- /dev/null +++ b/src/core/context/svc_ctx.c @@ -0,0 +1,200 @@ +/* + * 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_svc_ctx.h> +#include <axis2_conf_ctx.h> +#include <axis2_const.h> +#include <axutil_hash.h> + +struct axis2_svc_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of op context is a service context instance */ + struct axis2_svc_grp_ctx *parent; + + /** service associated with this service context */ + axis2_svc_t *svc; + + /** id of the service associated with this context */ + axis2_char_t *svc_id; + + /** service qname */ + axutil_qname_t *svc_qname; +}; + +AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL +axis2_svc_ctx_create( + const axutil_env_t * env, + axis2_svc_t * svc, + struct axis2_svc_grp_ctx *svc_grp_ctx) +{ + axis2_svc_ctx_t *svc_ctx = NULL; + + svc_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_ctx_t)); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_ctx->base = NULL; + svc_ctx->parent = NULL; + svc_ctx->svc = NULL; + svc_ctx->svc_id = NULL; + svc_ctx->svc_qname = NULL; + + svc_ctx->base = axis2_ctx_create(env); + if(!(svc_ctx->base)) + { + axis2_svc_ctx_free(svc_ctx, env); + return NULL; + } + + if(svc) + { + svc_ctx->svc = svc; + svc_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + if(svc_ctx->svc_qname) + { + svc_ctx->svc_id = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + } + } + + if(svc_grp_ctx) + { + svc_ctx->parent = svc_grp_ctx; + } + + return svc_ctx; +} + +axis2_ctx_t *AXIS2_CALL +axis2_svc_ctx_get_base( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->base; +} + +struct axis2_svc_grp_ctx *AXIS2_CALL +axis2_svc_ctx_get_parent( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->parent; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_set_parent( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + axis2_svc_grp_ctx_t * parent) +{ + svc_ctx->parent = parent; + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_svc_ctx_free( + struct axis2_svc_ctx *svc_ctx, + const axutil_env_t * env) +{ + if(svc_ctx->base) + { + axis2_ctx_free(svc_ctx->base, env); + } + + AXIS2_FREE(env->allocator, svc_ctx); + return; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_init( + struct axis2_svc_ctx * svc_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + if(svc_ctx->svc_qname) + { + axis2_char_t *svc_name = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + svc_ctx->svc = axis2_conf_get_svc(conf, env, svc_name); + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_svc_ctx_get_svc_id( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->svc_id; +} + +axis2_svc_t *AXIS2_CALL +axis2_svc_ctx_get_svc( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->svc; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_set_svc( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + + svc_ctx->svc = svc; + svc_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + if(svc_ctx->svc_qname) + { + svc_ctx->svc_id = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + } + return AXIS2_SUCCESS; +} + +struct axis2_conf_ctx *AXIS2_CALL +axis2_svc_ctx_get_conf_ctx( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return axis2_svc_grp_ctx_get_parent(svc_ctx->parent, env); +} + +axis2_op_ctx_t *AXIS2_CALL +axis2_svc_ctx_create_op_ctx( + struct axis2_svc_ctx * svc_ctx, + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_op_t *op = NULL; + + if(svc_ctx->svc) + { + op = axis2_svc_get_op_with_qname(svc_ctx->svc, env, qname); + return axis2_op_ctx_create(env, op, svc_ctx); + } + + return NULL; +} + diff --git a/src/core/context/svc_grp_ctx.c b/src/core/context/svc_grp_ctx.c new file mode 100644 index 0000000..449c01b --- /dev/null +++ b/src/core/context/svc_grp_ctx.c @@ -0,0 +1,256 @@ +/* + * 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_svc_grp_ctx.h> +#include <axis2_svc_grp.h> +#include <axis2_const.h> +#include <axutil_hash.h> + +struct axis2_svc_grp_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of service group context is a configuration context instance */ + struct axis2_conf_ctx *parent; + + /** service group context ID */ + axis2_char_t *id; + + /** map of service contexts belonging to this service context group */ + axutil_hash_t *svc_ctx_map; + + /** service group associated with this service group context */ + axis2_svc_grp_t *svc_grp; + + /** name of the service group associated with this context */ + axis2_char_t *svc_grp_name; +}; + +AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL +axis2_svc_grp_ctx_create( + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp, + struct axis2_conf_ctx *conf_ctx) +{ + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + + svc_grp_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_ctx_t)); + if(!svc_grp_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_grp_ctx->base = NULL; + svc_grp_ctx->parent = NULL; + svc_grp_ctx->id = NULL; + svc_grp_ctx->svc_ctx_map = NULL; + svc_grp_ctx->svc_grp = NULL; + svc_grp_ctx->svc_grp_name = NULL; + + svc_grp_ctx->base = axis2_ctx_create(env); + if(!(svc_grp_ctx->base)) + { + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + return NULL; + } + + if(svc_grp) + { + svc_grp_ctx->svc_grp = svc_grp; + svc_grp_ctx->svc_grp_name = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp_ctx->svc_grp, + env); + svc_grp_ctx->id = axutil_strdup(env, svc_grp_ctx->svc_grp_name); + } + + if(conf_ctx) + { + svc_grp_ctx->parent = conf_ctx; + } + + svc_grp_ctx->svc_ctx_map = axutil_hash_make(env); + if(!(svc_grp_ctx->svc_ctx_map)) + { + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + return NULL; + } + + axis2_svc_grp_ctx_fill_svc_ctx_map((svc_grp_ctx), env); + + return svc_grp_ctx; +} + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_svc_grp_ctx_get_base( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->base; +} + +AXIS2_EXTERN struct axis2_conf_ctx *AXIS2_CALL +axis2_svc_grp_ctx_get_parent( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->parent; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_grp_ctx_free( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env) +{ + if(svc_grp_ctx->id) + { + AXIS2_FREE(env->allocator, svc_grp_ctx->id); + } + + if(svc_grp_ctx->base) + { + axis2_ctx_free(svc_grp_ctx->base, env); + } + + if(svc_grp_ctx->svc_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(svc_grp_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, + hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + if(val) + { + axis2_svc_ctx_t *svc_ctx = NULL; + svc_ctx = (axis2_svc_ctx_t *)val; + axis2_svc_ctx_free(svc_ctx, env); + } + } + + axutil_hash_free(svc_grp_ctx->svc_ctx_map, env); + svc_grp_ctx->base = NULL; + } + + AXIS2_FREE(env->allocator, svc_grp_ctx); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_ctx_init( + struct axis2_svc_grp_ctx * svc_grp_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + if(svc_grp_ctx->svc_grp_name) + { + svc_grp_ctx->svc_grp = axis2_conf_get_svc_grp(conf, env, svc_grp_ctx->svc_grp_name); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_grp_ctx_get_id( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->id; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_ctx_set_id( + struct axis2_svc_grp_ctx * svc_grp_ctx, + const axutil_env_t * env, + const axis2_char_t * id) +{ + if(svc_grp_ctx->id) + { + AXIS2_FREE(env->allocator, svc_grp_ctx->id); + svc_grp_ctx->id = NULL; + } + + if(id) + { + svc_grp_ctx->id = axutil_strdup(env, id); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL +axis2_svc_grp_ctx_get_svc_ctx( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + return (axis2_svc_ctx_t *)axutil_hash_get(svc_grp_ctx->svc_ctx_map, svc_name, + AXIS2_HASH_KEY_STRING); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_ctx_fill_svc_ctx_map( + struct axis2_svc_grp_ctx * svc_grp_ctx, + const axutil_env_t * env) +{ + axutil_hash_index_t *hi = NULL; + void *next_svc = NULL; + + if(svc_grp_ctx->svc_grp) + { + axutil_hash_t *service_map = axis2_svc_grp_get_all_svcs(svc_grp_ctx->svc_grp, env); + if(service_map) + { + for(hi = axutil_hash_first(service_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &next_svc); + if(next_svc) + { + axis2_svc_t *svc = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_char_t *svc_name = NULL; + svc = (axis2_svc_t *)next_svc; + svc_ctx = axis2_svc_ctx_create(env, svc, svc_grp_ctx); + svc_name = axutil_qname_get_localpart(axis2_svc_get_qname(svc, env), env); + if(svc_name) + axutil_hash_set(svc_grp_ctx->svc_ctx_map, svc_name, AXIS2_HASH_KEY_STRING, + svc_ctx); + } + } + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_svc_grp_ctx_get_svc_grp( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->svc_grp; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_svc_grp_ctx_get_svc_ctx_map( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->svc_ctx_map; +} + |