Moving axis svn, part of TLP move INFRA-2441

git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 2268 insertions, 0 deletions

diff --git a/src/core/phaseresolver/Makefile.am b/src/core/phaseresolver/Makefile.am
new file mode 100644
index 0000000..62724f2
--- /dev/null
+++ b/src/core/phaseresolver/Makefile.am
@@ -0,0 +1,9 @@
+noinst_LTLIBRARIES = libaxis2_phaseresolver.la
+
+libaxis2_phaseresolver_la_SOURCES =	phase_holder.c \
+                                	phase_resolver.c
+
+INCLUDES = -I$(top_builddir)/include \
+            -I$(top_builddir)/src/core/engine \
+            -I$(top_builddir)/axiom/include	\
+            -I$(top_builddir)/util/include
diff --git a/src/core/phaseresolver/phase_holder.c b/src/core/phaseresolver/phase_holder.c
new file mode 100644
index 0000000..f371dd4
--- /dev/null
+++ b/src/core/phaseresolver/phase_holder.c
@@ -0,0 +1,243 @@
+/*
+ * 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_phase_holder.h>
+
+struct axis2_phase_holder
+{
+    axutil_array_list_t *phase_list;
+};
+
+AXIS2_EXTERN axis2_phase_holder_t *AXIS2_CALL
+axis2_phase_holder_create(
+    const axutil_env_t * env)
+{
+    axis2_phase_holder_t *phase_holder = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    phase_holder = (axis2_phase_holder_t *)AXIS2_MALLOC(env-> allocator,
+        sizeof(axis2_phase_holder_t));
+
+    if(!phase_holder)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    phase_holder->phase_list = NULL;
+
+    return phase_holder;
+}
+
+AXIS2_EXTERN axis2_phase_holder_t *AXIS2_CALL
+axis2_phase_holder_create_with_phases(
+    const axutil_env_t * env,
+    axutil_array_list_t * phases)
+{
+    axis2_phase_holder_t *phase_holder = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    if(!phases)
+    {
+        return NULL;
+    }
+
+    phase_holder = (axis2_phase_holder_t *)axis2_phase_holder_create(env);
+    phase_holder->phase_list = phases;
+
+    return phase_holder;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_phase_holder_free(
+    axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, void);
+
+    if(phase_holder)
+    {
+        AXIS2_FREE(env->allocator, phase_holder);
+    }
+
+    return;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_phase_holder_is_phase_exist(
+    axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env,
+    const axis2_char_t * phase_name)
+{
+    int size = 0;
+    int i = 0;
+    axis2_phase_t *phase = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, phase_name, AXIS2_FALSE);
+
+    size = axutil_array_list_size(phase_holder->phase_list, env);
+
+    for(i = 0; i < size; i++)
+    {
+        const axis2_char_t *phase_name_l = NULL;
+
+        phase = (axis2_phase_t *)axutil_array_list_get(phase_holder-> phase_list, env, i);
+        phase_name_l = axis2_phase_get_name(phase, env);
+        if(0 == axutil_strcmp(phase_name_l, phase_name))
+        {
+            return AXIS2_TRUE;
+        }
+    }
+    return AXIS2_FALSE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_holder_add_handler(
+    axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env,
+    axis2_handler_desc_t * handler)
+{
+    const axis2_char_t *phase_name = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler start");
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
+
+    phase_name = axis2_phase_rule_get_name(axis2_handler_desc_get_rules(handler, env), env);
+    if(AXIS2_TRUE == axis2_phase_holder_is_phase_exist(phase_holder, env, phase_name))
+    {
+        axis2_phase_t *phase = NULL;
+
+        phase = axis2_phase_holder_get_phase(phase_holder, env, phase_name);
+        status = axis2_phase_add_handler_desc(phase, env, handler);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Add handler %s to phase %s",
+            axutil_string_get_buffer(axis2_handler_desc_get_name(handler, env), env), phase_name);
+    }
+    else
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
+        status = AXIS2_FAILURE;
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler end status = %s",
+        status ? "SUCCESS" : "FAILURE");
+    return status;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_holder_remove_handler(
+    axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env,
+    axis2_handler_desc_t * handler)
+{
+    const axis2_char_t *phase_name = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_remove_handler start");
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
+
+    phase_name = axis2_phase_rule_get_name(axis2_handler_desc_get_rules(handler, env), env);
+    if(AXIS2_TRUE == axis2_phase_holder_is_phase_exist(phase_holder, env, phase_name))
+    {
+        axis2_phase_t *phase = NULL;
+
+        phase = axis2_phase_holder_get_phase(phase_holder, env, phase_name);
+        status = axis2_phase_remove_handler_desc(phase, env, handler);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Remove handler %s from phase %s",
+            axutil_string_get_buffer(axis2_handler_desc_get_name(handler, env), env), phase_name);
+    }
+    else
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
+        status = AXIS2_FAILURE;
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_remove_handler end status = %s",
+        status ? "SUCCESS" : "FAILURE");
+    return status;
+}
+
+AXIS2_EXTERN axis2_phase_t *AXIS2_CALL
+axis2_phase_holder_get_phase(
+    const axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env,
+    const axis2_char_t * phase_name)
+{
+    int size = 0;
+    int i = 0;
+    axis2_phase_t *phase = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, phase_name, NULL);
+
+    size = axutil_array_list_size(phase_holder->phase_list, env);
+
+    for(i = 0; i < size; i++)
+    {
+        const axis2_char_t *phase_name_l = NULL;
+        phase = (axis2_phase_t *)axutil_array_list_get(phase_holder-> phase_list, env, i);
+        phase_name_l = axis2_phase_get_name(phase, env);
+        if(0 == axutil_strcmp(phase_name_l, phase_name))
+        {
+            return phase;
+        }
+    }
+
+    return NULL;
+}
+
+/* This function is deprecated */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_holder_build_transport_handler_chain(
+    axis2_phase_holder_t * phase_holder,
+    const axutil_env_t * env,
+    axis2_phase_t * phase,
+    axutil_array_list_t * handlers)
+{
+    axis2_handler_t *handler = NULL;
+    int size = 0;
+    int status = AXIS2_FAILURE;
+    int i = 0;
+    axis2_handler_desc_t *handler_desc = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, phase, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, handlers, AXIS2_FAILURE);
+
+    size = axutil_array_list_size(handlers, env);
+
+    for(i = 0; i < size; i++)
+    {
+        handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(handlers, env, i);
+        status = axis2_handler_init(handler, env, handler_desc);
+        if(AXIS2_FAILURE == status)
+        {
+            return status;
+        }
+
+        status = axis2_handler_desc_set_handler(handler_desc, env, handler);
+        if(AXIS2_FAILURE == status)
+        {
+            return status;
+        }
+
+        status = axis2_phase_add_handler(phase, env, handler);
+    }
+    return status;
+}
diff --git a/src/core/phaseresolver/phase_resolver.c b/src/core/phaseresolver/phase_resolver.c
new file mode 100644
index 0000000..c291456
--- /dev/null
+++ b/src/core/phaseresolver/phase_resolver.c
@@ -0,0 +1,2016 @@
+/*
+ * 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_phase_resolver.h>
+#include <axutil_property.h>
+#include <axis2_addr.h>
+/*
+ * It is important to understand the following relationships between the
+ * functions defined here and else where.
+ * axis2_phase_resolver_engage_module_globally->axis2_svc_add_module_ops->
+ * ->axis2_phase_resolver_build_execution_chains_for_module_op->axis2_phase_resolver_build_execution_chains_for_op
+ *  and
+ * axis2_phase_resolver_engage_module_to_svc->axis2_svc_add_module_ops->
+ * ->axis2_phase_resolver_build_execution_chains_for_module_op->axis2_phase_resolver_build_execution_chains_for_op
+ */
+struct axis2_phase_resolver
+{
+
+    /** axis2 configuration */
+    axis2_conf_t *axis2_config;
+
+    /** service */
+    axis2_svc_t *svc;
+};
+
+static axis2_status_t
+axis2_phase_resolver_build_execution_chains_for_op(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    int type,
+    axis2_op_t * op);
+
+static axis2_status_t
+axis2_phase_resolver_add_module_handlers_to_system_defined_phases(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc);
+
+static axis2_status_t
+axis2_phase_resolver_add_module_handlers_to_user_defined_phases(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    struct axis2_svc *svc,
+    struct axis2_module_desc *module_desc);
+
+/* Deprecated and no longer used */
+static axis2_status_t
+axis2_phase_resolver_build_in_transport_chains(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_transport_in_desc_t * transport);
+
+/* Deprecated and no longer used */
+static axis2_status_t
+axis2_phase_resolver_build_out_transport_chains(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_transport_out_desc_t * transport);
+
+static axis2_status_t
+axis2_phase_resolver_add_to_handler_list(
+    const axutil_env_t * env,
+    axutil_array_list_t *handler_list,
+    axis2_op_t *op,
+    axis2_module_desc_t * module_desc,
+    int type);
+
+AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
+axis2_phase_resolver_create(
+    const axutil_env_t * env)
+{
+    axis2_phase_resolver_t *phase_resolver = NULL;
+
+    phase_resolver = (axis2_phase_resolver_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_phase_resolver_t));
+
+    if(!phase_resolver)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory.");
+        return NULL;
+    }
+
+    phase_resolver->axis2_config = NULL;
+    phase_resolver->svc = NULL;
+
+    return phase_resolver;
+}
+
+AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
+axis2_phase_resolver_create_with_config(
+    const axutil_env_t * env,
+    axis2_conf_t * axis2_config)
+{
+    axis2_phase_resolver_t *phase_resolver = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, axis2_config, NULL);
+
+    phase_resolver = (axis2_phase_resolver_t *)axis2_phase_resolver_create(env);
+
+    phase_resolver->axis2_config = axis2_config;
+
+    return phase_resolver;
+}
+
+AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
+axis2_phase_resolver_create_with_config_and_svc(
+    const axutil_env_t * env,
+    axis2_conf_t * axis2_config,
+    axis2_svc_t * svc)
+{
+    axis2_phase_resolver_t *phase_resolver = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, axis2_config, NULL);
+
+    phase_resolver = (axis2_phase_resolver_t *)axis2_phase_resolver_create(env);
+
+    if(!phase_resolver)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No Memory.");
+        return NULL;
+    }
+    phase_resolver->axis2_config = axis2_config;
+
+    phase_resolver->svc = svc;
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name is : %s", axis2_svc_get_name(
+        phase_resolver->svc, env));
+
+    return phase_resolver;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_phase_resolver_free(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env)
+{
+    if(phase_resolver)
+    {
+        AXIS2_FREE(env->allocator, phase_resolver);
+    }
+
+    return;
+}
+
+/**
+ * This is in general called to engage a module to the axis2 engine. In other words modules handlers 
+ * are added into all global and operation specific phases appropriately. Where these handlers 
+ * should go is determined by the module handler specific descriptions in module.xml file. Also 
+ * module operations are added to service and built exeuction chains for those operations as well.
+ * First add all the handlers defined for system phases are added into system phases. Then module
+ * operations are added into each service. At the same time execution chains for these module
+ * operations are built as well. Then handlers defined for user phases are added into user defined
+ * pahses.
+ */
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_globally(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc)
+{
+    axis2_status_t status = AXIS2_FAILURE;
+    axutil_qname_t *qname_addressing = NULL;
+    axutil_hash_t *svcs = NULL;
+
+    const axutil_qname_t *mod_qname = NULL;
+    axis2_char_t *mod_name = NULL;
+    axutil_hash_t *all_ops = NULL;
+    axutil_hash_index_t *index_j = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_globally");
+
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+
+    mod_qname = axis2_module_desc_get_qname(module_desc, env);
+    mod_name = axutil_qname_get_localpart(mod_qname, env);
+
+    /* Add module handlers into global phases */
+    status = axis2_phase_resolver_add_module_handlers_to_system_defined_phases(phase_resolver, env,
+        module_desc);
+
+    if(AXIS2_SUCCESS != status)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to global chain failed",
+            mod_name);
+        return status;
+    }
+
+    /* Module is engaged to all the services */
+    svcs = axis2_conf_get_all_svcs(phase_resolver->axis2_config, env);
+    if(!svcs)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "There are no services in the axis2 configuration");
+        return AXIS2_FAILURE;
+    }
+
+    qname_addressing = axutil_qname_create(env, AXIS2_MODULE_ADDRESSING, NULL, NULL);
+
+    for(index_j = axutil_hash_first(svcs, env); index_j; index_j = axutil_hash_next(env, index_j))
+    {
+        axis2_svc_t *svc = NULL;
+        void *w = NULL;
+        axis2_svc_grp_t *parent = NULL;
+        const axis2_char_t *svc_name = NULL;
+        const axis2_char_t *svc_grp_name = NULL;
+
+        axutil_hash_this(index_j, NULL, NULL, &w);
+        svc = (axis2_svc_t *)w;
+        svc_name = axis2_svc_get_name(svc, env);
+
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "svc name is:%s", svc_name);
+
+        /* Module operations are added to service and built execution chains for operations. */
+        status = axis2_svc_add_module_ops(svc, env, module_desc, phase_resolver->axis2_config);
+        if(AXIS2_SUCCESS != status)
+        {
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Adding module operations for module %s to service %s failed", mod_name, svc_name);
+            axutil_qname_free(qname_addressing, env);
+            return status;
+        }
+
+        /* Call this function to add module handlers into service operation phases */
+        status = axis2_phase_resolver_add_module_handlers_to_user_defined_phases(phase_resolver,
+            env, svc, module_desc);
+
+        if(AXIS2_SUCCESS != status)
+        {
+            axutil_qname_free(qname_addressing, env);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to service %s failed",
+                mod_name, svc_name);
+
+            return status;
+        }
+
+        if(axutil_qname_equals(mod_qname, env, qname_addressing))
+        {
+            /* If addressing module then all operations which are not module 
+             * operations with a wsa mapping parameter is added to the 
+             * service's wsa-mapping list*/
+            all_ops = axis2_svc_get_all_ops(svc, env);
+            if(all_ops)
+            {
+                axutil_hash_index_t *hi = NULL;
+                void *val = NULL;
+
+                for(hi = axutil_hash_first(all_ops, env); hi; hi = axutil_hash_next(env, hi))
+                {
+                    axutil_hash_this(hi, NULL, NULL, &val);
+
+                    if(val)
+                    {
+                        if(!axis2_op_is_from_module((axis2_op_t *)val, env))
+                        {
+                            axis2_op_t *op_desc = NULL;
+                            axutil_array_list_t *params = NULL;
+                            int j = 0;
+                            int sizej = 0;
+
+                            op_desc = (axis2_op_t *)val;
+                            params = axis2_op_get_all_params(op_desc, env);
+                            /* Adding wsa-mapping into service */
+                            sizej = axutil_array_list_size(params, env);
+                            for(j = 0; j < sizej; j++)
+                            {
+                                axutil_param_t *param = NULL;
+                                axis2_char_t *param_name = NULL;
+
+                                param = axutil_array_list_get(params, env, j);
+                                param_name = axutil_param_get_name(param, env);
+                                if(!axutil_strcmp(param_name, AXIS2_WSA_MAPPING))
+                                {
+                                    axis2_char_t *key = NULL;
+                                    key = (axis2_char_t *)axutil_param_get_value(param, env);
+                                    axis2_svc_add_mapping(svc, env, key, op_desc);
+                                }
+                            }
+                        }
+                        val = NULL;
+                    }
+                }
+            }
+        }
+
+        parent = axis2_svc_get_parent(svc, env);
+        if(parent)
+        {
+            axutil_array_list_t *modules = NULL;
+            int j = 0;
+            int sizej = 0;
+            axis2_bool_t add_to_group = AXIS2_TRUE;
+            svc_grp_name = axis2_svc_grp_get_name(parent, env);
+
+            modules = axis2_svc_grp_get_all_module_qnames(parent, env);
+            sizej = axutil_array_list_size(modules, env);
+            for(j = 0; j < sizej; j++)
+            {
+                axutil_qname_t *module = NULL;
+
+                module = (axutil_qname_t *)axutil_array_list_get(modules, env, j);
+                if(axutil_qname_equals(mod_qname, env, module))
+                {
+                    add_to_group = AXIS2_FALSE;
+                    break;
+                }
+            }
+
+            if(add_to_group)
+            {
+                status = axis2_svc_grp_add_module_qname(parent, env, mod_qname);
+            }
+        }
+
+        if(AXIS2_SUCCESS != status)
+        {
+            axutil_qname_free(qname_addressing, env);
+
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding module %s to service group %s failed",
+                mod_name, svc_grp_name);
+
+            return status;
+        }
+    }
+
+    axutil_qname_free(qname_addressing, env);
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_globally");
+
+    return status;
+}
+
+/**
+ * This function is called to engage a module to a service specifically. In other words all module 
+ * handlers defined for user phases are added into user defined phases and all module handlers 
+ * defined for system defined phases are added into system defined phases. Note that user defined
+ * phases are in the flows taken from operation and system defined phases are in the flows taken
+ * from conf. Where each module handler should go is determined by module handler descriptions in 
+ * module.xml file.
+ * First we add the operations defined in the module into the service and built execution chains for 
+ * them. Then for all the operations of the service we check whether the module 
+ * already engaged to operation. If not engage it to service operation. Also if the module is newly 
+ * engaged to operation add the module qnname to the engaged module list of the operation.
+ */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_svc(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_svc_t * svc,
+    axis2_module_desc_t * module_desc)
+{
+    axutil_hash_t *ops = NULL;
+    axutil_hash_index_t *index_i = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    const axutil_qname_t *module_d_qname = NULL;
+    axis2_char_t *modname_d = NULL;
+    const axis2_char_t *svcname = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_to_svc");
+
+    module_d_qname = axis2_module_desc_get_qname(module_desc, env);
+    modname_d = axutil_qname_get_localpart(module_d_qname, env);
+    svcname = axis2_svc_get_name(svc, env);
+
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s will be engaged to %s", modname_d, svcname);
+
+    ops = axis2_svc_get_all_ops(svc, env);
+    if(!ops)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s has no operation", svcname);
+
+        return AXIS2_FAILURE;
+    }
+
+    /* Module operations are added to service and built execution chains */
+    status = axis2_svc_add_module_ops(svc, env, module_desc, phase_resolver->axis2_config);
+
+    if(AXIS2_SUCCESS != status)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Adding module operations from module %s into service %s failed", modname_d, svcname);
+
+        return status;
+    }
+
+    for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i))
+    {
+        axutil_array_list_t *modules = NULL;
+        axis2_op_t *op_desc = NULL;
+        int size = 0;
+        int j = 0;
+        void *v = NULL;
+        axis2_bool_t engaged = AXIS2_FALSE;
+        axis2_char_t *opname = NULL;
+
+        axutil_hash_this(index_i, NULL, NULL, &v);
+        op_desc = (axis2_op_t *)v;
+
+        opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
+
+        modules = axis2_op_get_all_modules(op_desc, env);
+        if(modules)
+        {
+            size = axutil_array_list_size(modules, env);
+        }
+
+        for(j = 0; j < size; j++)
+        {
+            axis2_module_desc_t *module_desc_l = NULL;
+            const axutil_qname_t *module_d_qname_l = NULL;
+
+            module_desc_l = axutil_array_list_get(modules, env, j);
+            module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+            if(axutil_qname_equals(module_d_qname, env, module_d_qname_l))
+            {
+                engaged = AXIS2_TRUE;
+                status = AXIS2_SUCCESS;
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                    "Module %s already engaged to operation %s of service %s", modname_d, opname,
+                    svcname);
+
+                break;
+            }
+        }
+
+        if(!engaged)
+        {
+            status = axis2_phase_resolver_engage_module_to_op(phase_resolver, env, op_desc,
+                module_desc);
+
+            if(AXIS2_SUCCESS != status)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "Engaging module %s to operation %s failed.", modname_d, opname);
+
+                return status;
+            }
+
+            status = axis2_op_add_to_engaged_module_list(op_desc, env, module_desc);
+        }
+
+    }
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_to_svc");
+
+    return status;
+}
+
+/**
+ * In this function all the handlers in each flow of the module description are added to the phases 
+ * of the operation(user define phases) and phases of the conf(system defined phases). First handlers 
+ * for system defined phases are added. Then handlers for operation specific phases are added.
+ */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_op(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_op_t * axis_op,
+    axis2_module_desc_t * module_desc)
+{
+    int type = 0;
+    axis2_phase_holder_t *phase_holder = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_to_op");
+    AXIS2_PARAM_CHECK(env->error, axis_op, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+
+    for(type = 1; type < 5; type++)
+    {
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flowname = NULL;
+        axutil_array_list_t *phases = NULL;
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                phases = axis2_op_get_in_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                phases = axis2_op_get_out_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                phases = axis2_op_get_fault_in_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                phases = axis2_op_get_fault_out_flow(axis_op, env);
+                break;
+            }
+        }
+
+        if(phases)
+        {
+            phase_holder = axis2_phase_holder_create_with_phases(env, phases);
+        }
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_in_flow(module_desc, env);
+                flowname = "in flow";
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_out_flow(module_desc, env);
+                flowname = "out flow";
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+                flowname = "fault in flow";
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+                flowname = "fault out flow";
+                break;
+            }
+        }
+
+        if(flow && phase_holder)
+        {
+            int j = 0;
+            int handler_count = 0;
+
+            handler_count = axis2_flow_get_handler_count(flow, env);
+            for(j = 0; j < handler_count; j++)
+            {
+                /* For all handlers in the flow from the module description */
+                axis2_handler_desc_t *metadata = NULL;
+                const axis2_char_t *phase_name = NULL;
+                axis2_phase_rule_t *phase_rule = NULL;
+                const axutil_string_t *handlersname = NULL;
+                const axis2_char_t *handlername = NULL;
+                axis2_status_t status = AXIS2_FAILURE;
+
+                metadata = axis2_flow_get_handler(flow, env, j);
+                handlersname = axis2_handler_desc_get_name(metadata, env);
+                handlername = axutil_string_get_buffer(handlersname, env);
+                phase_rule = axis2_handler_desc_get_rules(metadata, env);
+                phase_name = axis2_phase_rule_get_name(phase_rule, env);
+
+                /* For user/operation specific phases */
+                if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp(
+                    AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH,
+                    phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+                    if(AXIS2_SUCCESS != status)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "Handler %s inclusion failed for %s phase within flow %s. Phase might"
+                                "not available in axis2.xml", handlername, phase_name, phase_name,
+                            flowname);
+
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "");
+                        axis2_phase_holder_free(phase_holder, env);
+                        return status;
+                    }
+
+                }
+
+                /* For System defined phases */
+                if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    axutil_array_list_t *phase_list = NULL;
+                    axis2_phase_holder_t *phase_holder = NULL;
+
+                    phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch(
+                        phase_resolver->axis2_config, env);
+
+                    if(phase_holder)
+                    {
+                        axis2_phase_holder_free(phase_holder, env);
+                        phase_holder = NULL;
+                    }
+
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+
+                    status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+                    axis2_phase_holder_free(phase_holder, env);
+                    phase_holder = NULL;
+
+                    if(AXIS2_SUCCESS != status)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "Adding handler %s to phase %s within flow %s failed", handlername,
+                            phase_name, flowname);
+
+                        return status;
+                    }
+                }
+            }
+        }
+
+        if(phase_holder)
+        {
+            axis2_phase_holder_free(phase_holder, env);
+            phase_holder = NULL;
+        }
+    }
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_to_op");
+
+    return AXIS2_SUCCESS;
+}
+
+/**
+ * The caller function first set the service into the phase resolver. Then call this function to 
+ * build execution chains for that services operations. Within this function it just call
+ * axis2_phase_resolver_build_execution_chains_for_op() function to build exection chains for
+ * each operation.
+ */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_execution_chains_for_svc(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env)
+{
+    axutil_hash_index_t *index_i = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_op_t *op = NULL;
+    axutil_hash_t *ops = NULL;
+
+    if(!(phase_resolver->svc))
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No service set to phase resolver");
+        return AXIS2_FAILURE;
+    }
+
+    ops = axis2_svc_get_all_ops(phase_resolver->svc, env);
+
+    for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i))
+    {
+        void *v = NULL;
+        int j = 0;
+
+        axutil_hash_this(index_i, NULL, NULL, &v);
+        op = (axis2_op_t *)v;
+        for(j = 1; j < 5; j++)
+        {
+            status = axis2_phase_resolver_build_execution_chains_for_op(phase_resolver, env, j, op);
+        }
+    }
+
+    return status;
+}
+
+/**
+ * For operation passed as parameter, build execution chains. To do this get all engaged modules
+ * from the axis2 configuration and for each module get the all handlers to be add to the operation 
+ * specific phases. Then for each operation specific phases add those handlers. It should be noted 
+ * that by the time this function is called the module handlers are already added to system specific 
+ * phases. This function is called from axis2_phase_resolver_build_execution_chains_for_svc() 
+ * function and axis2_phase_resolver_build_execution_chains_for_module_op() function.
+ */
+static axis2_status_t
+axis2_phase_resolver_build_execution_chains_for_op(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    int type,
+    axis2_op_t *op)
+{
+    axutil_array_list_t *handler_list = NULL;
+    axutil_array_list_t *moduleqnames = NULL;
+    int i = 0;
+    int size = 0;
+    int status = AXIS2_FAILURE;
+    axis2_char_t *flowname = NULL;
+    axis2_phase_holder_t *phase_holder = NULL;
+    axutil_array_list_t *engaged_module_list_for_parent_svc = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Entry:axis2_phase_resolver_build_execution_chains_for_op");
+
+    handler_list = axutil_array_list_create(env, 0);
+    if(!handler_list)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+        return AXIS2_FAILURE;
+    }
+
+    /* Engage handlers from axis2.xml and from modules */
+    moduleqnames = axis2_conf_get_all_engaged_modules(phase_resolver->axis2_config, env);
+
+    size = axutil_array_list_size(moduleqnames, env);
+
+    for(i = 0; i < size; i++)
+    {
+        axis2_char_t *modulename = NULL;
+        axutil_qname_t *moduleqname = NULL;
+        axis2_module_desc_t *module_desc = NULL;
+
+        moduleqname = (axutil_qname_t *)axutil_array_list_get(moduleqnames, env, i);
+        modulename = axutil_qname_get_localpart(moduleqname, env);
+
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module name is:%s", modulename);
+
+        module_desc = axis2_conf_get_module(phase_resolver->axis2_config, env, moduleqname);
+        if(!module_desc)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_REF, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Module description not found in axis2 configuration for name %s", modulename);
+
+            if(handler_list)
+            {
+                axutil_array_list_free(handler_list, env);
+            }
+
+            return AXIS2_FAILURE;
+        }
+
+        status = axis2_phase_resolver_add_to_handler_list(env, handler_list, op, module_desc, type);
+        if(AXIS2_SUCCESS != status)
+        {
+            if(handler_list)
+            {
+                axutil_array_list_free(handler_list, env);
+            }
+            return AXIS2_FAILURE;
+        }
+
+        axis2_op_add_to_engaged_module_list(op, env, module_desc);
+    }
+
+    engaged_module_list_for_parent_svc
+        = axis2_svc_get_engaged_module_list(phase_resolver->svc, env);
+    size = axutil_array_list_size(engaged_module_list_for_parent_svc, env);
+
+    for(i = 0; i < size; i++)
+    {
+        axis2_char_t *modulename = NULL;
+        axutil_qname_t *moduleqname = NULL;
+        axis2_module_desc_t *module_desc = NULL;
+
+        module_desc = axutil_array_list_get(engaged_module_list_for_parent_svc, env, i);
+        if(!module_desc)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_REF, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Module description not found in engaged module list for service %s",
+                axis2_svc_get_name(phase_resolver->svc, env));
+
+            if(handler_list)
+            {
+                axutil_array_list_free(handler_list, env);
+            }
+
+            return AXIS2_FAILURE;
+        }
+
+        moduleqname = (axutil_qname_t *)axis2_module_desc_get_qname(module_desc, env);
+        modulename = axutil_qname_get_localpart(moduleqname, env);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module name is:%s", modulename);
+
+        status = axis2_phase_resolver_add_to_handler_list(env, handler_list, op, module_desc, type);
+        if(AXIS2_SUCCESS != status)
+        {
+            if(handler_list)
+            {
+                axutil_array_list_free(handler_list, env);
+            }
+            return AXIS2_FAILURE;
+        }
+
+        axis2_op_add_to_engaged_module_list(op, env, module_desc);
+    }
+
+    if(0 == axutil_array_list_size(handler_list, env))
+    {
+        /* No flows configured */
+        if(handler_list)
+        {
+            axutil_array_list_free(handler_list, env);
+        }
+
+        return AXIS2_SUCCESS;
+    }
+
+    switch(type)
+    {
+        case AXIS2_IN_FLOW:
+        {
+            axutil_array_list_t *phase_list = NULL;
+
+            phase_list = axis2_op_get_in_flow(op, env);
+            phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+            flowname = "in flow";
+            break;
+        }
+        case AXIS2_OUT_FLOW:
+        {
+            axutil_array_list_t *phase_list = NULL;
+
+            phase_list = axis2_op_get_out_flow(op, env);
+            phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+            flowname = "out flow";
+            break;
+        }
+        case AXIS2_FAULT_IN_FLOW:
+        {
+            axutil_array_list_t *phase_list = NULL;
+
+            phase_list = axis2_op_get_fault_in_flow(op, env);
+            phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+            flowname = "fault in flow";
+            break;
+        }
+        case AXIS2_FAULT_OUT_FLOW:
+        {
+            axutil_array_list_t *phase_list = NULL;
+
+            phase_list = axis2_op_get_fault_out_flow(op, env);
+            phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+            flowname = "fault out flow";
+            break;
+        }
+    }
+
+    size = axutil_array_list_size(handler_list, env);
+    for(i = 0; i < size; i++)
+    {
+        axis2_handler_desc_t *metadata = NULL;
+
+        metadata = (axis2_handler_desc_t *)axutil_array_list_get(handler_list, env, i);
+        if(phase_holder)
+        {
+            status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+            if(!status)
+            {
+                break;
+            }
+        }
+    }
+
+    /* Free the locally created handler_list*/
+    if(handler_list)
+    {
+        axutil_array_list_free(handler_list, env);
+    }
+
+    if(phase_holder)
+    {
+        axis2_phase_holder_free(phase_holder, env);
+    }
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Exit:axis2_phase_resolver_build_execution_chains_for_op");
+
+    return status;
+}
+
+/**
+ * For module operation build execution chains. This is called by axis2_svc_add_module_ops() function.
+ */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_execution_chains_for_module_op(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_op_t * op)
+{
+    int i = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Entry:axis2_phase_resolver_build_execution_chains_for_module_op");
+    AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
+
+    for(i = 1; i < 5; i++)
+    {
+        status = axis2_phase_resolver_build_execution_chains_for_op(phase_resolver, env, i, op);
+        if(!status)
+        {
+            break;
+        }
+    }
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Exit:axis2_phase_resolver_build_execution_chains_for_module_op");
+    return status;
+}
+
+/**
+ * Take the phases for each flow from the axis2 configuration, take all the handlers of each flow 
+ * from the module description and then each handler is added into the corresponding global phase. 
+ * This function is called from  function axis2_phase_resolver_engage_module_globally() to add 
+ * module handlers into global phases.
+ */
+static axis2_status_t
+axis2_phase_resolver_add_module_handlers_to_system_defined_phases(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc)
+{
+    int type = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_phase_holder_t *phase_holder = NULL;
+    const axutil_qname_t *modqname = NULL;
+    axis2_char_t *modname = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Entry:axis2_phase_resolver_add_module_handlers_to_system_defined_phases");
+
+    modqname = axis2_module_desc_get_qname(module_desc, env);
+    modname = axutil_qname_get_localpart(modqname, env);
+    for(type = 1; type < 5; type++)
+    {
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flow_name = NULL;
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                axutil_array_list_t *phase_list = NULL;
+
+                phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch(
+                    phase_resolver->axis2_config, env);
+                phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                if(!phase_holder)
+                    continue;
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                axutil_array_list_t *phase_list = NULL;
+
+                phase_list = axis2_conf_get_out_flow(phase_resolver->axis2_config, env);
+                phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                if(!phase_holder)
+                    continue;
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                axutil_array_list_t *phase_list = NULL;
+
+                phase_list = axis2_conf_get_in_fault_flow(phase_resolver-> axis2_config, env);
+                phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                if(!phase_holder)
+                    continue;
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                axutil_array_list_t *phase_list = NULL;
+
+                phase_list = axis2_conf_get_out_fault_flow(phase_resolver-> axis2_config, env);
+                phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                if(!phase_holder)
+                    continue;
+                break;
+            }
+        }
+
+        /* Modules referred by axis2.xml */
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_in_flow(module_desc, env);
+                flow_name = "in flow";
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_out_flow(module_desc, env);
+                flow_name = "out flow";
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+                flow_name = "fault in flow";
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+                flow_name = "fault out flow";
+                break;
+            }
+        }
+        if(flow)
+        {
+            int j = 0;
+            for(j = 0; j < axis2_flow_get_handler_count(flow, env); j++)
+            {
+                axis2_handler_desc_t *metadata = NULL;
+                const axis2_char_t *phase_name = NULL;
+                axis2_phase_rule_t *phase_rule = NULL;
+                const axutil_string_t *handlersname = NULL;
+                const axis2_char_t *handlername = NULL;
+
+                metadata = axis2_flow_get_handler(flow, env, j);
+                handlersname = axis2_handler_desc_get_name(metadata, env);
+                handlername = axutil_string_get_buffer(handlersname, env);
+                phase_rule = axis2_handler_desc_get_rules(metadata, env);
+                if(phase_rule)
+                {
+                    phase_name = axis2_phase_rule_get_name(phase_rule, env);
+                }
+                if(!phase_name)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Phase rules for handler %s has no name", handlername);
+                    return AXIS2_FAILURE;
+                }
+                if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    /* If a global phase add the module handler*/
+                    status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+                    if(!status)
+                    {
+                        axis2_phase_holder_free(phase_holder, env);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "Adding handler %s of module %s to phase %s of "
+                                "flow %s failed", handlername, modname, phase_name, flow_name);
+                        return status;
+                    }
+                }
+            }
+        }
+        if(phase_holder)
+        {
+            axis2_phase_holder_free(phase_holder, env);
+        }
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Exit:axis2_phase_resolver_add_module_handlers_to_system_defined_phases");
+    return AXIS2_SUCCESS;
+}
+
+/**
+ * For each operation of the service first check whether module is already engaged to operation. 
+ * If not take each operations flows and add the module handlers into them appropriately. This 
+ * function is called from function axis2_phase_resolver_engage_module_globally() to add handlers 
+ * from module into each services all operations.
+ */
+static axis2_status_t
+axis2_phase_resolver_add_module_handlers_to_user_defined_phases(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_svc_t * svc,
+    axis2_module_desc_t * module_desc)
+{
+    axutil_hash_t *ops = NULL;
+    axis2_bool_t engaged = AXIS2_FALSE;
+    axutil_hash_index_t *index_i = NULL;
+    int type = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_phase_holder_t *phase_holder = NULL;
+    const axis2_char_t *svc_name = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Entry:axis2_phase_resolver_add_module_handlers_to_user_defined_phases");
+
+    AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+    svc_name = axis2_svc_get_name(svc, env);
+    ops = axis2_svc_get_all_ops(svc, env);
+    if(!ops)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No operations for the service %s", svc_name);
+        return AXIS2_FAILURE;
+    }
+
+    for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i))
+    {
+        void *v = NULL;
+        axis2_op_t *op_desc = NULL;
+        int j = 0;
+        axutil_array_list_t *modules = NULL;
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flowname = NULL;
+        const axutil_qname_t *module_desc_qname = NULL;
+        axis2_char_t *module_desc_name = NULL;
+        int size = 0;
+        axis2_char_t *op_name = NULL;
+
+        axutil_hash_this(index_i, NULL, NULL, &v);
+        op_desc = (axis2_op_t *)v;
+        op_name = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation name is : %s", op_name);
+
+        /* Get all modules engaged to the operation */
+        modules = axis2_op_get_all_modules(op_desc, env);
+        module_desc_qname = axis2_module_desc_get_qname(module_desc, env);
+        module_desc_name = axutil_qname_get_localpart(module_desc_qname, env);
+        if(modules)
+        {
+            size = axutil_array_list_size(modules, env);
+        }
+
+        /* Checking whether module is already engaged to operation */
+        for(j = 0; j < size; j++)
+        {
+            axis2_module_desc_t *module_desc_l = NULL;
+            const axutil_qname_t *module_desc_qname_l = NULL;
+
+            module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(modules, env, j);
+
+            module_desc_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+            if(axutil_qname_equals(module_desc_qname_l, env, module_desc_qname))
+            {
+                engaged = AXIS2_TRUE;
+                break;
+            }
+        }
+
+        if(engaged)
+        {
+            continue;
+        }
+
+        for(type = 1; type < 5; type++)
+        {
+            switch(type)
+            {
+                case AXIS2_IN_FLOW:
+                {
+                    axutil_array_list_t *phase_list = NULL;
+
+                    phase_list = axis2_op_get_in_flow(op_desc, env);
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                    break;
+                }
+                case AXIS2_OUT_FLOW:
+                {
+                    axutil_array_list_t *phase_list = NULL;
+
+                    phase_list = axis2_op_get_out_flow(op_desc, env);
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                    break;
+                }
+                case AXIS2_FAULT_IN_FLOW:
+                {
+                    axutil_array_list_t *phase_list = NULL;
+
+                    phase_list = axis2_op_get_fault_in_flow(op_desc, env);
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                    break;
+                }
+                case AXIS2_FAULT_OUT_FLOW:
+                {
+                    axutil_array_list_t *phase_list = NULL;
+
+                    phase_list = axis2_op_get_fault_out_flow(op_desc, env);
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+                    break;
+                }
+            }
+
+            /* Process modules referred by axis2.xml */
+
+            switch(type)
+            {
+                case AXIS2_IN_FLOW:
+                {
+                    flow = axis2_module_desc_get_in_flow(module_desc, env);
+                    flowname = "in flow";
+                    break;
+                }
+                case AXIS2_OUT_FLOW:
+                {
+                    flow = axis2_module_desc_get_out_flow(module_desc, env);
+                    flowname = "out flow";
+                    break;
+                }
+                case AXIS2_FAULT_IN_FLOW:
+                {
+                    flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+                    flowname = "fault in flow";
+                    break;
+                }
+                case AXIS2_FAULT_OUT_FLOW:
+                {
+                    flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+                    flowname = "fault out flow";
+                    break;
+                }
+            }
+
+            if(flow)
+            {
+                int handler_count = 0;
+
+                handler_count = axis2_flow_get_handler_count(flow, env);
+                for(j = 0; j < handler_count; j++)
+                {
+                    axis2_handler_desc_t *metadata = NULL;
+                    const axis2_char_t *phase_name = NULL;
+                    axis2_phase_rule_t *phase_rule = NULL;
+                    const axutil_string_t *handlersname = NULL;
+                    const axis2_char_t *handlername = NULL;
+
+                    metadata = axis2_flow_get_handler(flow, env, j);
+                    handlersname = axis2_handler_desc_get_name(metadata, env);
+                    handlername = axutil_string_get_buffer(handlersname, env);
+                    phase_rule = axis2_handler_desc_get_rules(metadata, env);
+                    if(phase_rule)
+                    {
+                        phase_name = axis2_phase_rule_get_name(phase_rule, env);
+                    }
+                    if(!phase_name)
+                    {
+                        AXIS2_LOG_ERROR(
+                            env->log,
+                            AXIS2_LOG_SI,
+                            "Handler rules for the handler description %s within flow %s has no name",
+                            handlername, flowname);
+
+                        return AXIS2_FAILURE;
+                    }
+
+                    /* If phase is not a system defined phase, add module handler to it */
+                    if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp(
+                        AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(
+                        AXIS2_PHASE_POST_DISPATCH, phase_name)) && (axutil_strcmp(
+                        AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                    {
+                        if(phase_holder)
+                        {
+                            status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+                            if(!status)
+                            {
+                                axis2_phase_holder_free(phase_holder, env);
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding handler desc %s to"
+                                    "phase %s within flow %s failed", handlername, phase_name,
+                                    flowname);
+
+                                return status;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if(phase_holder)
+            {
+                axis2_phase_holder_free(phase_holder, env);
+            }
+        }
+        status = axis2_op_add_to_engaged_module_list(op_desc, env, module_desc);
+        if(AXIS2_SUCCESS != status)
+        {
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding module description %s to engaged "
+                "module list of operation %s failed", module_desc_name, op_name);
+
+            return status;
+        }
+    }
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
+        "Exit:axis2_phase_resolver_add_module_handlers_to_user_defined_phases");
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_disengage_module_from_svc(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_svc_t * svc,
+    axis2_module_desc_t * module_desc)
+{
+    axutil_hash_t *ops = NULL;
+    axutil_hash_index_t *index_i = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    const axutil_qname_t *module_d_qname = NULL;
+    const axis2_char_t *svc_name = axis2_svc_get_name(svc, env);
+    axis2_char_t *modname_d = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_disengage_module_from_svc");
+
+    ops = axis2_svc_get_all_ops(svc, env);
+    if(!ops)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s has no operation", svc_name);
+        return AXIS2_FAILURE;
+    }
+
+    module_d_qname = axis2_module_desc_get_qname(module_desc, env);
+    modname_d = axutil_qname_get_localpart(module_d_qname, env);
+    for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i))
+    {
+        axutil_array_list_t *modules = NULL;
+        axis2_op_t *op_desc = NULL;
+        int size = 0;
+        int j = 0;
+        void *v = NULL;
+        axis2_bool_t engaged = AXIS2_FALSE;
+        const axutil_qname_t *opqname = NULL;
+        axis2_char_t *opname = NULL;
+
+        axutil_hash_this(index_i, NULL, NULL, &v);
+        op_desc = (axis2_op_t *)v;
+        opqname = axis2_op_get_qname(op_desc, env);
+        opname = axutil_qname_get_localpart(opqname, env);
+        modules = axis2_op_get_all_modules(op_desc, env);
+        if(modules)
+        {
+            size = axutil_array_list_size(modules, env);
+        }
+        for(j = 0; j < size; j++)
+        {
+            axis2_module_desc_t *module_desc_l = NULL;
+            const axutil_qname_t *module_d_qname_l = NULL;
+
+            module_desc_l = axutil_array_list_get(modules, env, j);
+            module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+            if(axutil_qname_equals(module_d_qname, env, module_d_qname_l))
+            {
+                engaged = AXIS2_TRUE;
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s already engaged.", modname_d);
+                break;
+            }
+        }
+
+        if(engaged)
+        {
+            status = axis2_phase_resolver_disengage_module_from_op(phase_resolver, env, op_desc,
+                module_desc);
+            if(AXIS2_SUCCESS != status)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "Disengaging module %s from operation %s failed", modname_d, opname);
+                return status;
+            }
+
+            status = axis2_op_remove_from_engaged_module_list(op_desc, env, module_desc);
+        }
+
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_disengage_module_from_svc");
+    return status;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_disengage_module_from_op(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_op_t * axis_op,
+    axis2_module_desc_t * module_desc)
+{
+    int type = 0;
+    axis2_phase_holder_t *phase_holder = NULL;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_disengage_module_from_op");
+    AXIS2_PARAM_CHECK(env->error, axis_op, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+
+    for(type = 1; type < 5; type++)
+    {
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flowname = NULL;
+        axutil_array_list_t *phases = NULL;
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                phases = axis2_op_get_in_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                phases = axis2_op_get_out_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                phases = axis2_op_get_fault_in_flow(axis_op, env);
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                phases = axis2_op_get_fault_out_flow(axis_op, env);
+                break;
+            }
+        }
+
+        if(phases)
+        {
+            phase_holder = axis2_phase_holder_create_with_phases(env, phases);
+        }
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_in_flow(module_desc, env);
+                flowname = "in flow";
+                break;
+            }
+            case AXIS2_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_out_flow(module_desc, env);
+                flowname = "out flow";
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+                flowname = "fault in flow";
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+                flowname = "fault out flow";
+                break;
+            }
+        }
+
+        if(flow && phase_holder)
+        {
+            int j = 0;
+            int handler_count = 0;
+
+            handler_count = axis2_flow_get_handler_count(flow, env);
+            for(j = 0; j < handler_count; j++)
+            {
+                axis2_handler_desc_t *metadata = NULL;
+                const axis2_char_t *phase_name = NULL;
+                axis2_phase_rule_t *phase_rule = NULL;
+                const axutil_string_t *handlersname = NULL;
+                const axis2_char_t *handlername = NULL;
+                axis2_status_t status = AXIS2_FAILURE;
+
+                metadata = axis2_flow_get_handler(flow, env, j);
+                handlersname = axis2_handler_desc_get_name(metadata, env);
+                handlername = axutil_string_get_buffer(handlersname, env);
+                phase_rule = axis2_handler_desc_get_rules(metadata, env);
+                phase_name = axis2_phase_rule_get_name(phase_rule, env);
+                if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp(
+                    AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH,
+                    phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    status = axis2_phase_holder_remove_handler(phase_holder, env, metadata);
+                    if(AXIS2_SUCCESS != status)
+                    {
+                        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                            "Handler %s Removal failed for %s phase within flow %s", handlername,
+                            phase_name, flowname);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "");
+                        axis2_phase_holder_free(phase_holder, env);
+                        return status;
+                    }
+
+                }
+                if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp(
+                    AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    axutil_array_list_t *phase_list = NULL;
+                    axis2_phase_holder_t *phase_holder = NULL;
+
+                    phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch(
+                        phase_resolver->axis2_config, env);
+                    if(phase_holder)
+                    {
+                        axis2_phase_holder_free(phase_holder, env);
+                        phase_holder = NULL;
+                    }
+                    phase_holder = axis2_phase_holder_create_with_phases(env, phase_list);
+
+                    status = axis2_phase_holder_remove_handler(phase_holder, env, metadata);
+                    axis2_phase_holder_free(phase_holder, env);
+                    phase_holder = NULL;
+                    if(AXIS2_SUCCESS != status)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "Removing handler %s from phase %s within flow %s failed", handlername,
+                            phase_name, flowname);
+                        return status;
+                    }
+                }
+            }
+        }
+
+        if(phase_holder)
+        {
+            axis2_phase_holder_free(phase_holder, env);
+            phase_holder = NULL;
+        }
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_disengage_module_from_op");
+    return AXIS2_SUCCESS;
+}
+
+/* This function is deprecated and no longer used */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_transport_chains(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env)
+{
+    axis2_transport_in_desc_t **transports_in = NULL;
+    axis2_transport_out_desc_t **transports_out = NULL;
+    int index_i = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_transport_chains");
+
+    transports_in = axis2_conf_get_all_in_transports(phase_resolver->axis2_config, env);
+    if(!transports_in)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_IN_CONFIGURED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No transport in descriptions configured");
+        return AXIS2_SUCCESS;
+    }
+
+    transports_out = axis2_conf_get_all_out_transports(phase_resolver->axis2_config, env);
+    if(!transports_out)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_OUT_CONFIGURED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No transport out descriptions configured");
+        return AXIS2_SUCCESS;
+    }
+
+    for(index_i = 0; index_i < AXIS2_TRANSPORT_ENUM_MAX; index_i++)
+    {
+        if(transports_in[index_i])
+        {
+            status = axis2_phase_resolver_build_in_transport_chains(phase_resolver, env,
+                transports_in[index_i]);
+            if(AXIS2_SUCCESS != status)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building transport in chains failed");
+                return status;
+            }
+        }
+    }
+
+    for(index_i = 0; index_i < AXIS2_TRANSPORT_ENUM_MAX; index_i++)
+    {
+        if(transports_out[index_i])
+        {
+            status = axis2_phase_resolver_build_out_transport_chains(phase_resolver, env,
+                transports_out[index_i]);
+            if(AXIS2_SUCCESS != status)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building transport out chains failed");
+                return status;
+            }
+        }
+    }
+
+    /* If transport in or transport out maps are not null but still they don't
+     * have chains configured then we return success, because there are no
+     * chains to process.
+     */
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_transport_chains");
+    return AXIS2_SUCCESS;
+}
+
+/**
+ * This function is called from function 
+ * axis2_phase_resolver_build_transport_chains().
+ * This function is deprecated and no longer used.
+ */
+static axis2_status_t
+axis2_phase_resolver_build_in_transport_chains(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_transport_in_desc_t * transport)
+{
+    int type = 0;
+    int j = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axutil_array_list_t *handlers = NULL;
+    AXIS2_TRANSPORT_ENUMS transport_enum = axis2_transport_in_desc_get_enum(transport, env);
+    ;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_in_transport_chains");
+    AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE);
+
+    for(type = 1; type < 4; type++)
+    {
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flowname = NULL;
+        axis2_phase_t *phase = NULL;
+
+        switch(type)
+        {
+            case AXIS2_IN_FLOW:
+            {
+                flow = axis2_transport_in_desc_get_in_flow(transport, env);
+                phase = axis2_transport_in_desc_get_in_phase(transport, env);
+                flowname = "in flow";
+                break;
+            }
+            case AXIS2_FAULT_IN_FLOW:
+            {
+                flow = axis2_transport_in_desc_get_fault_in_flow(transport, env);
+                phase = axis2_transport_in_desc_get_fault_phase(transport, env);
+                flowname = "fault in flow";
+                break;
+            }
+        }
+        if(flow)
+        {
+            axis2_phase_holder_t *phase_holder = NULL;
+            int size = 0;
+
+            size = axis2_flow_get_handler_count(flow, env);
+            handlers = axutil_array_list_create(env, 0);
+            for(j = 0; j < size; j++)
+            {
+                axis2_handler_desc_t *metadata = NULL;
+                axis2_phase_rule_t *rule = NULL;
+                const axis2_char_t *handlername = NULL;
+                const axutil_string_t *handlersname = NULL;
+
+                metadata = axis2_flow_get_handler(flow, env, j);
+                handlersname = axis2_handler_desc_get_name(metadata, env);
+                handlername = axutil_string_get_buffer(handlersname, env);
+                rule = axis2_handler_desc_get_rules(metadata, env);
+                if(rule)
+                {
+                    status = axis2_phase_rule_set_name(rule, env, AXIS2_TRANSPORT_PHASE);
+                }
+                if(AXIS2_SUCCESS != status)
+                {
+                    if(handlers)
+                    {
+                        axis2_handler_desc_t *handler_d = NULL;
+                        int i = 0;
+                        int size = 0;
+
+                        size = axutil_array_list_size(handlers, env);
+                        for(i = 0; i < size; i++)
+                        {
+                            handler_d = axutil_array_list_get(handlers, env, i);
+                            axis2_handler_desc_free(handler_d, env);
+                        }
+                        axutil_array_list_free(handlers, env);
+                    }
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Setting name %s to phase rules for handler %s failed"
+                            "for in transport %d within flow %s", AXIS2_TRANSPORT_PHASE,
+                        handlername, transport_enum, flowname);
+                    return status;
+                }
+                status = axutil_array_list_add(handlers, env, metadata);
+                if(AXIS2_SUCCESS != status)
+                {
+                    if(handlers)
+                    {
+                        axis2_handler_desc_t *handler_d = NULL;
+                        int i = 0;
+                        int size = 0;
+
+                        size = axutil_array_list_size(handlers, env);
+                        for(i = 0; i < size; i++)
+                        {
+                            handler_d = axutil_array_list_get(handlers, env, i);
+                            axis2_handler_desc_free(handler_d, env);
+                        }
+                        axutil_array_list_free(handlers, env);
+                    }
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Adding handler %s from in transport %d to handler "
+                            "list failed within flow %s", handlername, transport_enum, flowname);
+                    return status;
+                }
+            }
+            phase_holder = axis2_phase_holder_create(env);
+            if(!phase_holder)
+            {
+                if(handlers)
+                {
+                    axis2_handler_desc_t *handler_d = NULL;
+                    int i = 0;
+                    int size = 0;
+
+                    size = axutil_array_list_size(handlers, env);
+                    for(i = 0; i < size; i++)
+                    {
+                        handler_d = axutil_array_list_get(handlers, env, i);
+                        axis2_handler_desc_free(handler_d, env);
+                    }
+                    axutil_array_list_free(handlers, env);
+                }
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+                return AXIS2_FAILURE;
+            }
+
+            status = axis2_phase_holder_build_transport_handler_chain(phase_holder, env, phase,
+                handlers);
+            if(phase_holder)
+            {
+                axis2_phase_holder_free(phase_holder, env);
+            }
+        }
+        else
+        {
+            /* Do nothing */
+        }
+    }
+    if(handlers)
+    {
+        axutil_array_list_free(handlers, env);
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_in_transport_chains");
+    return status;
+}
+
+/**
+ * This function is called from function
+ * axis2_phase_resolver_build_transport_chains().
+ * This is deprecated and no longer used.
+ */
+static axis2_status_t
+axis2_phase_resolver_build_out_transport_chains(
+    axis2_phase_resolver_t * phase_resolver,
+    const axutil_env_t * env,
+    axis2_transport_out_desc_t * transport)
+{
+    int type = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axutil_array_list_t *handlers = NULL;
+    AXIS2_TRANSPORT_ENUMS transport_enum = axis2_transport_out_desc_get_enum(transport, env);
+    ;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_out_transport_chains");
+    AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE);
+    for(type = 1; type < 5; type++)
+    {
+        axis2_flow_t *flow = NULL;
+        axis2_char_t *flowname = NULL;
+        axis2_phase_t *phase = NULL;
+
+        switch(type)
+        {
+            case AXIS2_OUT_FLOW:
+            {
+                flow = axis2_transport_out_desc_get_out_flow(transport, env);
+                phase = axis2_transport_out_desc_get_out_phase(transport, env);
+                flowname = "out flow";
+                break;
+            }
+            case AXIS2_FAULT_OUT_FLOW:
+            {
+                flow = axis2_transport_out_desc_get_fault_out_flow(transport, env);
+                phase = axis2_transport_out_desc_get_fault_phase(transport, env);
+                flowname = "fault out flow";
+                break;
+            }
+        }
+
+        if(flow)
+        {
+            axis2_phase_holder_t *phase_holder = NULL;
+            int hndlr_count = 0;
+            int j = 0;
+            hndlr_count = axis2_flow_get_handler_count(flow, env);
+            if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "");
+                return AXIS2_ERROR_GET_STATUS_CODE(env->error);
+            }
+            handlers = axutil_array_list_create(env, 0);
+
+            for(j = 0; j < hndlr_count; j++)
+            {
+                axis2_handler_desc_t *metadata = NULL;
+                axis2_phase_rule_t *rule = NULL;
+                const axis2_char_t *handlername = NULL;
+                const axutil_string_t *handlersname = NULL;
+
+                metadata = axis2_flow_get_handler(flow, env, j);
+                handlersname = axis2_handler_desc_get_name(metadata, env);
+                handlername = axutil_string_get_buffer(handlersname, env);
+
+                rule = axis2_handler_desc_get_rules(metadata, env);
+                if(rule)
+                {
+                    status = axis2_phase_rule_set_name(rule, env, AXIS2_TRANSPORT_PHASE);
+                }
+                if(AXIS2_SUCCESS != status)
+                {
+                    if(handlers)
+                    {
+                        axis2_handler_desc_t *handler_d = NULL;
+                        int i = 0;
+                        int size = 0;
+
+                        size = axutil_array_list_size(handlers, env);
+                        for(i = 0; i < size; i++)
+                        {
+                            handler_d = axutil_array_list_get(handlers, env, i);
+                            axis2_handler_desc_free(handler_d, env);
+                        }
+                        axutil_array_list_free(handlers, env);
+                    }
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Setting name %s to phase rules for handler %s failed"
+                            "for out transport %d within flow %s", AXIS2_TRANSPORT_PHASE,
+                        handlername, transport_enum, flowname);
+                    return status;
+                }
+
+                status = axutil_array_list_add(handlers, env, metadata);
+                if(AXIS2_FAILURE == status)
+                {
+                    if(handlers)
+                    {
+                        axis2_handler_desc_t *handler_d = NULL;
+                        int i = 0;
+                        int size = 0;
+
+                        size = axutil_array_list_size(handlers, env);
+                        for(i = 0; i < size; i++)
+                        {
+                            handler_d = axutil_array_list_get(handlers, env, i);
+                            axis2_handler_desc_free(handler_d, env);
+                        }
+                        axutil_array_list_free(handlers, env);
+                    }
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Adding handler %s from out transport %d to handler "
+                            "list failed within flow %s", handlername, transport_enum, flowname);
+                    return status;
+                }
+            }
+            phase_holder = axis2_phase_holder_create(env);
+            if(!phase_holder)
+            {
+                if(handlers)
+                {
+                    axis2_handler_desc_t *handler_d = NULL;
+                    int i = 0;
+                    int size = 0;
+
+                    size = axutil_array_list_size(handlers, env);
+                    for(i = 0; i < size; i++)
+                    {
+                        handler_d = axutil_array_list_get(handlers, env, i);
+                        axis2_handler_desc_free(handler_d, env);
+                    }
+                    axutil_array_list_free(handlers, env);
+                }
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+                return AXIS2_FAILURE;
+            }
+
+            status = axis2_phase_holder_build_transport_handler_chain(phase_holder, env, phase,
+                handlers);
+            if(phase_holder)
+            {
+                axis2_phase_holder_free(phase_holder, env);
+            }
+        }
+        else
+        {
+            /* Do nothing */
+        }
+    }
+    if(handlers)
+    {
+        axutil_array_list_free(handlers, env);
+    }
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_out_transport_chains");
+    return status;
+}
+
+/**
+ * This function is called from axis2_phase_resolver_build_execution_chains_for_op() function.
+ */
+static axis2_status_t
+axis2_phase_resolver_add_to_handler_list(
+    const axutil_env_t * env,
+    axutil_array_list_t *handler_list,
+    axis2_op_t *op,
+    axis2_module_desc_t * module_desc,
+    int type)
+{
+    axis2_flow_t *flow = NULL;
+    axis2_char_t *flowname = NULL;
+    const axutil_qname_t *opqname = NULL;
+    axis2_char_t *opname = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    opqname = axis2_op_get_qname(op, env);
+    opname = axutil_qname_get_localpart(opqname, env);
+
+    switch(type)
+    {
+        case AXIS2_IN_FLOW:
+        {
+            flow = axis2_module_desc_get_in_flow(module_desc, env);
+            flowname = "in flow";
+            break;
+        }
+        case AXIS2_OUT_FLOW:
+        {
+            flow = axis2_module_desc_get_out_flow(module_desc, env);
+            flowname = "out flow";
+            break;
+        }
+        case AXIS2_FAULT_IN_FLOW:
+        {
+            flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+            flowname = "fault in flow";
+            break;
+        }
+        case AXIS2_FAULT_OUT_FLOW:
+        {
+            flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+            flowname = "fault out flow";
+            break;
+        }
+    }
+
+    if(flow)
+    {
+        int j = 0;
+        int count = 0;
+
+        /* Ignore all the errors upto now */
+        AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_SUCCESS);
+
+        count = axis2_flow_get_handler_count(flow, env);
+        /*if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
+        {
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Getting hanlder count for the flow %s failed",
+                flowname);
+
+            return AXIS2_ERROR_GET_STATUS_CODE(env->error);
+        }*/
+
+        for(j = 0; j < count; j++)
+        {
+            axis2_handler_desc_t *metadata = NULL;
+            const axis2_char_t *phase_name = NULL;
+            axis2_phase_rule_t *phase_rule = NULL;
+            const axutil_string_t *handlername = NULL;
+            const axis2_char_t *handlername_buff = NULL;
+
+            metadata = axis2_flow_get_handler(flow, env, j);
+            handlername = axis2_handler_desc_get_name(metadata, env);
+            handlername_buff = axutil_string_get_buffer(handlername, env);
+            phase_rule = axis2_handler_desc_get_rules(metadata, env);
+            phase_name = axis2_phase_rule_get_name(phase_rule, env);
+            if(!phase_name)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "Phase rules name null for the handler description %s within flow %s",
+                    handlername_buff, flowname);
+
+                return AXIS2_FAILURE;
+            }
+
+            /* If user defined phases */
+            if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp(
+                AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH,
+                phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+            {
+                status = axutil_array_list_add(handler_list, env, metadata);
+                if(AXIS2_SUCCESS != status)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Adding handler description %s failed for phase %s within flow %s",
+                        handlername_buff, phase_name, flowname);
+
+                    return status;
+                }
+            }
+            else
+            {
+                AXIS2_LOG_DEBUG(
+                    env->log,
+                    AXIS2_LOG_SI,
+                    "Trying to add this handler %s to system pre defined phases , but those "
+                        "handlers are already added to global chain which run irrespective of the service",
+                    handlername_buff);
+            }
+        }
+    }
+
+    return AXIS2_SUCCESS;
+}
+