summaryrefslogtreecommitdiffstats
path: root/src/core/description
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/description')
-rw-r--r--src/core/description/Makefile.am24
-rw-r--r--src/core/description/desc.c261
-rw-r--r--src/core/description/flow.c130
-rw-r--r--src/core/description/flow_container.c173
-rw-r--r--src/core/description/handler_desc.c333
-rw-r--r--src/core/description/module_desc.c470
-rw-r--r--src/core/description/msg.c407
-rw-r--r--src/core/description/op.c1383
-rw-r--r--src/core/description/phase_rule.c254
-rw-r--r--src/core/description/policy_include.c612
-rw-r--r--src/core/description/svc.c1543
-rw-r--r--src/core/description/svc_grp.c600
-rw-r--r--src/core/description/transport_in_desc.c305
-rw-r--r--src/core/description/transport_out_desc.c299
14 files changed, 6794 insertions, 0 deletions
diff --git a/src/core/description/Makefile.am b/src/core/description/Makefile.am
new file mode 100644
index 0000000..5c3618c
--- /dev/null
+++ b/src/core/description/Makefile.am
@@ -0,0 +1,24 @@
+noinst_LTLIBRARIES = libaxis2_description.la
+
+libaxis2_description_la_SOURCES =desc.c \
+ op.c \
+ policy_include.c \
+ svc.c \
+ module_desc.c \
+ svc_grp.c \
+ phase_rule.c \
+ handler_desc.c \
+ flow.c \
+ flow_container.c \
+ transport_in_desc.c \
+ transport_out_desc.c \
+ msg.c
+
+libaxis2_description_la_LDFLAGS = -version-info $(VERSION_NO)
+
+INCLUDES = -I$(top_builddir)/include \
+ -I$(top_builddir)/src/core/engine \
+ -I$(top_builddir)/util/include \
+ -I$(top_builddir)/axiom/include \
+ -I$(top_builddir)/neethi/include
+
diff --git a/src/core/description/desc.c b/src/core/description/desc.c
new file mode 100644
index 0000000..bd5a80a
--- /dev/null
+++ b/src/core/description/desc.c
@@ -0,0 +1,261 @@
+/*
+ * 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_desc.h>
+#include <axutil_property.h>
+#include <axis2_policy_include.h>
+#include <axis2_msg.h>
+
+struct axis2_desc
+{
+
+ /** parameter container */
+ axutil_param_container_t *param_container;
+
+ /** children of this description */
+ axutil_hash_t *children;
+
+ axis2_desc_t *parent;
+
+ axis2_policy_include_t *policy_include;
+};
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_desc_create(
+ const axutil_env_t * env)
+{
+ axis2_desc_t *desc = NULL;
+
+ desc = (axis2_desc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_desc_t));
+
+ if(!desc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ desc->param_container = NULL;
+ desc->children = NULL;
+ desc->parent = NULL;
+ desc->policy_include = NULL;
+
+ desc->param_container = (axutil_param_container_t *)axutil_param_container_create(env);
+ if(!(desc->param_container))
+ {
+ axis2_desc_free(desc, env);
+ return NULL;
+ }
+
+ desc->children = axutil_hash_make(env);
+ if(!(desc->children))
+ {
+ axis2_desc_free(desc, env);
+ return NULL;
+ }
+
+ desc->policy_include = axis2_policy_include_create_with_desc(env, desc);
+
+ return desc;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_desc_free(
+ axis2_desc_t * desc,
+ const axutil_env_t * env)
+{
+ if(desc->children)
+ {
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+
+ for(hi = axutil_hash_first(desc->children, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ axutil_hash_this(hi, NULL, NULL, &val);
+
+ if(val)
+ {
+ axis2_msg_free((axis2_msg_t *)val, env);
+ }
+ }
+
+ axutil_hash_free(desc->children, env);
+ }
+
+ if(desc->param_container)
+ {
+ axutil_param_container_free(desc->param_container, env);
+ }
+
+ if(desc->policy_include)
+ {
+ axis2_policy_include_free(desc->policy_include, env);
+ }
+
+ if(desc)
+ {
+ AXIS2_FREE(env->allocator, desc);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_desc_add_param(
+ axis2_desc_t * desc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE);
+
+ return axutil_param_container_add_param(desc->param_container, env, param);
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_desc_get_param(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ AXIS2_PARAM_CHECK(env->error, param_name, NULL);
+ return axutil_param_container_get_param(desc->param_container, env, param_name);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_desc_get_all_params(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env)
+{
+ AXIS2_PARAM_CHECK(env->error, desc->param_container, AXIS2_FALSE);
+
+ return axutil_param_container_get_params(desc->param_container, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_desc_is_param_locked(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axutil_param_t *param_l = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
+
+ param_l = axis2_desc_get_param(desc, env, param_name);
+
+ return (param_l && axutil_param_is_locked(param_l, env));
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_desc_add_child(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env,
+ const axis2_char_t * key,
+ const axis2_msg_t *child)
+{
+ if(desc->children)
+ {
+ axis2_msg_t* msg = (axis2_msg_t *)axutil_hash_get(desc->children, key,
+ AXIS2_HASH_KEY_STRING);
+ if(msg != NULL)
+ {
+ axis2_msg_free(msg, env);
+ msg = NULL;
+ }
+ axutil_hash_set(desc->children, key, AXIS2_HASH_KEY_STRING, (void *)child);
+ return AXIS2_SUCCESS;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_desc_get_all_children(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env)
+{
+ return desc->children;
+}
+
+AXIS2_EXTERN void *AXIS2_CALL
+axis2_desc_get_child(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env,
+ const axis2_char_t * key)
+{
+ return axutil_hash_get(desc->children, key, AXIS2_HASH_KEY_STRING);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_desc_remove_child(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env,
+ const axis2_char_t * key)
+{
+ if(desc->children)
+ {
+ axutil_hash_set(desc->children, key, AXIS2_HASH_KEY_STRING, NULL);
+ return AXIS2_SUCCESS;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_desc_get_parent(
+ const axis2_desc_t * desc,
+ const axutil_env_t * env)
+{
+ return desc->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_desc_set_parent(
+ axis2_desc_t * desc,
+ const axutil_env_t * env,
+ axis2_desc_t * parent)
+{
+ desc->parent = parent;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_desc_set_policy_include(
+ axis2_desc_t * desc,
+ const axutil_env_t * env,
+ axis2_policy_include_t * policy_include)
+{
+ if(desc->policy_include)
+ {
+ axis2_policy_include_free(desc->policy_include, env);
+ desc->policy_include = NULL;
+ }
+
+ desc->policy_include = policy_include;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL
+axis2_desc_get_policy_include(
+ axis2_desc_t * desc,
+ const axutil_env_t * env)
+{
+ if(!desc->policy_include)
+ {
+ /*desc->policy_include = axis2_policy_include_create(env); */
+ desc->policy_include = axis2_policy_include_create_with_desc(env, desc);
+ }
+ return desc->policy_include;
+}
+
diff --git a/src/core/description/flow.c b/src/core/description/flow.c
new file mode 100644
index 0000000..554d666
--- /dev/null
+++ b/src/core/description/flow.c
@@ -0,0 +1,130 @@
+/*
+ * 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_flow.h>
+
+struct axis2_flow
+{
+ axutil_array_list_t *list;
+};
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_flow_create(
+ const axutil_env_t * env)
+{
+ axis2_flow_t *flow = NULL;
+
+ flow = (axis2_flow_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_flow_t));
+
+ if(!flow)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ flow->list = NULL;
+
+ flow->list = axutil_array_list_create(env, 20);
+ if(!(flow->list))
+ {
+ axis2_flow_free(flow, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return flow;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_flow_free(
+ axis2_flow_t * flow,
+ const axutil_env_t * env)
+{
+ if(flow->list)
+ {
+ int i = 0;
+ int size = 0;
+
+ size = axutil_array_list_size(flow->list, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_handler_desc_t *handler_desc = NULL;
+
+ handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(flow->list, env, i);
+ axis2_handler_desc_free(handler_desc, env);
+ }
+ axutil_array_list_free(flow->list, env);
+ }
+
+ if(flow)
+ {
+ AXIS2_FREE(env->allocator, flow);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_flow_free_void_arg(
+ void *flow,
+ const axutil_env_t * env)
+{
+ axis2_flow_t *flow_l = NULL;
+
+ flow_l = (axis2_flow_t *)flow;
+ axis2_flow_free(flow_l, env);
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_flow_add_handler(
+ axis2_flow_t * flow,
+ const axutil_env_t * env,
+ axis2_handler_desc_t * handler)
+{
+ AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
+
+ if(!flow->list)
+ {
+ flow->list = axutil_array_list_create(env, 0);
+ if(!flow->list)
+ {
+ axis2_flow_free(flow, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+ return axutil_array_list_add(flow->list, env, handler);
+}
+
+AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL
+axis2_flow_get_handler(
+ const axis2_flow_t * flow,
+ const axutil_env_t * env,
+ const int index)
+{
+ return axutil_array_list_get(flow->list, env, index);
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+axis2_flow_get_handler_count(
+ const axis2_flow_t * flow,
+ const axutil_env_t * env)
+{
+ return axutil_array_list_size(flow->list, env);
+}
+
diff --git a/src/core/description/flow_container.c b/src/core/description/flow_container.c
new file mode 100644
index 0000000..e39be01
--- /dev/null
+++ b/src/core/description/flow_container.c
@@ -0,0 +1,173 @@
+/*
+ * 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_flow.h>
+#include <axis2_flow_container.h>
+
+struct axis2_flow_container
+{
+ axis2_flow_t *in;
+ axis2_flow_t *out;
+ axis2_flow_t *in_fault;
+ axis2_flow_t *out_fault;
+};
+
+AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
+axis2_flow_container_create(
+ const axutil_env_t * env)
+{
+ axis2_flow_container_t *flow_container = NULL;
+
+ flow_container = (axis2_flow_container_t *)AXIS2_MALLOC(env-> allocator,
+ sizeof(axis2_flow_container_t));
+
+ if(!flow_container)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ flow_container->in = NULL;
+ flow_container->out = NULL;
+ flow_container->in_fault = NULL;
+ flow_container->out_fault = NULL;
+
+ return flow_container;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_flow_container_free(
+ axis2_flow_container_t * flow_container,
+ const axutil_env_t * env)
+{
+ if(flow_container->in)
+ {
+ axis2_flow_free(flow_container->in, env);
+ }
+
+ if(flow_container->out)
+ {
+ axis2_flow_free(flow_container->out, env);
+ }
+
+ if(flow_container->in_fault)
+ {
+ axis2_flow_free(flow_container->in_fault, env);
+ }
+
+ if(flow_container->out_fault)
+ {
+ axis2_flow_free(flow_container->out_fault, env);
+ }
+
+ if(flow_container)
+ {
+ AXIS2_FREE(env->allocator, flow_container);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_flow_container_get_in_flow(
+ const axis2_flow_container_t * flow_container,
+ const axutil_env_t * env)
+{
+ return flow_container->in;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_flow_container_set_in_flow(
+ axis2_flow_container_t * flow_container,
+ const axutil_env_t * env,
+ axis2_flow_t * in_flow)
+{
+ if(flow_container->in)
+ {
+ axis2_flow_free(flow_container->in, env);
+ }
+ flow_container->in = in_flow;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_flow_container_get_out_flow(
+ const axis2_flow_container_t * flow_container,
+ const axutil_env_t * env)
+{
+ return flow_container->out;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_flow_container_set_out_flow(
+ axis2_flow_container_t * flow_container,
+ const axutil_env_t * env,
+ axis2_flow_t * out_flow)
+{
+ if(flow_container->out)
+ {
+ axis2_flow_free(flow_container->out, env);
+ }
+ flow_container->out = out_flow;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_flow_container_get_fault_in_flow(
+ const axis2_flow_container_t * flow_container,
+ const axutil_env_t * env)
+{
+ return flow_container->in_fault;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_flow_container_set_fault_in_flow(
+ axis2_flow_container_t * flow_container,
+ const axutil_env_t * env,
+ axis2_flow_t * falut_in_flow)
+{
+ if(flow_container->in_fault)
+ {
+ axis2_flow_free(flow_container->in_fault, env);
+ }
+ flow_container->in_fault = falut_in_flow;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_flow_container_get_fault_out_flow(
+ const axis2_flow_container_t * flow_container,
+ const axutil_env_t * env)
+{
+ return flow_container->out_fault;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_flow_container_set_fault_out_flow(
+ axis2_flow_container_t * flow_container,
+ const axutil_env_t * env,
+ axis2_flow_t * fault_out_flow)
+{
+ AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
+ if(flow_container->out_fault)
+ {
+ axis2_flow_free(flow_container->out_fault, env);
+ }
+ flow_container->out_fault = fault_out_flow;
+ return AXIS2_SUCCESS;
+}
+
diff --git a/src/core/description/handler_desc.c b/src/core/description/handler_desc.c
new file mode 100644
index 0000000..c3281f5
--- /dev/null
+++ b/src/core/description/handler_desc.c
@@ -0,0 +1,333 @@
+/*
+ * 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_handler_desc.h>
+#include <axutil_param_container.h>
+#include <axutil_string.h>
+#include <axis2_handler.h>
+
+struct axis2_handler_desc
+{
+
+ /** name */
+ axutil_string_t *name;
+
+ /** phase rules */
+ axis2_phase_rule_t *rules;
+
+ /** handler represented by meta information*/
+ axis2_handler_t *handler;
+
+ /** class name */
+ axis2_char_t *class_name;
+
+ /** parent param container */
+ axutil_param_container_t *parent;
+
+ /** parameter container */
+ axutil_param_container_t *param_container;
+};
+
+AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL
+axis2_handler_desc_create(
+ const axutil_env_t * env,
+ axutil_string_t * name)
+{
+ axis2_handler_desc_t *handler_desc = NULL;
+
+ handler_desc = AXIS2_MALLOC(env->allocator, sizeof(axis2_handler_desc_t));
+ if(!handler_desc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return NULL;
+ }
+
+ handler_desc->param_container = NULL;
+ handler_desc->name = NULL;
+ handler_desc->rules = NULL;
+ handler_desc->handler = NULL;
+ handler_desc->class_name = NULL;
+ handler_desc->parent = NULL;
+
+ handler_desc->param_container = axutil_param_container_create(env);
+ if(!handler_desc->param_container)
+ {
+
+ /** error code is already set by last param container create */
+ axis2_handler_desc_free(handler_desc, env);
+ return NULL;
+ }
+
+ handler_desc->rules = axis2_phase_rule_create(env, NULL);
+ if(!handler_desc->rules)
+ {
+
+ /** error code is already set by last param container create */
+ axis2_handler_desc_free(handler_desc, env);
+ return NULL;
+ }
+
+ if(name)
+ {
+ handler_desc->name = axutil_string_clone(name, env);
+ }
+
+ return handler_desc;
+}
+
+AXIS2_EXTERN const axutil_string_t *AXIS2_CALL
+axis2_handler_desc_get_name(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->name;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_set_name(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ axutil_string_t * name)
+{
+ if(handler_desc->name)
+ {
+ axutil_string_free(handler_desc->name, env);
+ handler_desc->name = NULL;
+ }
+
+ if(name)
+ {
+ handler_desc->name = axutil_string_clone(name, env);
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
+axis2_handler_desc_get_rules(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->rules;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_set_rules(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ axis2_phase_rule_t * phase_rule)
+{
+ const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env);
+ const axis2_char_t *name = axutil_string_get_buffer(str_name, env);
+ if(handler_desc->rules)
+ {
+ axis2_phase_rule_free(handler_desc->rules, env);
+ }
+
+ if(phase_rule)
+ {
+ handler_desc->rules = axis2_phase_rule_clone(phase_rule, env);
+ if(!(handler_desc->rules))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Phase rule cloning failed for handler description %s", name);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_handler_desc_get_param(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ return axutil_param_container_get_param(handler_desc->param_container, env, name);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_add_param(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env);
+ const axis2_char_t *name = axutil_string_get_buffer(str_name, env);
+ axis2_char_t *param_name = axutil_param_get_name(param, env);
+ if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for handler %s",
+ param_name, name);
+ return AXIS2_FAILURE;
+ }
+
+ return axutil_param_container_add_param(handler_desc->param_container, env, param);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_handler_desc_get_all_params(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return axutil_param_container_get_params(handler_desc->param_container, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_handler_desc_is_param_locked(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ /* See if it is locked in parent */
+ if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name))
+ {
+ return AXIS2_TRUE;
+ }
+
+ return axutil_param_container_is_param_locked(handler_desc->param_container, env, param_name);
+}
+
+AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
+axis2_handler_desc_get_handler(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->handler;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_set_handler(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ axis2_handler_t * handler)
+{
+ /* Handler description is the place where the handler really lives.
+ Hence this is a deep copy and should be freed by the free function. */
+
+ if(handler_desc->handler && (handler_desc->handler != handler))
+ {
+ axis2_handler_free(handler_desc->handler, env);
+ }
+
+ if(handler)
+ handler_desc->handler = handler; /* Shallow copy, but free method
+ should free this */
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_handler_desc_get_class_name(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->class_name;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_set_class_name(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * class_name)
+{
+ if(handler_desc->class_name)
+ {
+ AXIS2_FREE(env->allocator, handler_desc->class_name);
+ }
+
+ if(class_name)
+ {
+ handler_desc->class_name = axutil_strdup(env, class_name);
+ if(!handler_desc->class_name)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_handler_desc_get_parent(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_handler_desc_set_parent(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env,
+ axutil_param_container_t * parent)
+{
+ handler_desc->parent = parent; /* Shallow copy, because
+ the parent lives somewhere else */
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_handler_desc_free(
+ axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ if(handler_desc->param_container)
+ {
+ axutil_param_container_free(handler_desc->param_container, env);
+ }
+
+ if(handler_desc->name)
+ {
+ axutil_string_free(handler_desc->name, env);
+ }
+
+ if(handler_desc->rules)
+ {
+ axis2_phase_rule_free(handler_desc->rules, env);
+ }
+
+ if(handler_desc->handler)
+ {
+ axis2_handler_free(handler_desc->handler, env);
+ }
+
+ if(handler_desc->class_name)
+ {
+ AXIS2_FREE(env->allocator, handler_desc->class_name);
+ }
+ if(handler_desc)
+ {
+ AXIS2_FREE(env->allocator, handler_desc);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_handler_desc_get_param_container(
+ const axis2_handler_desc_t * handler_desc,
+ const axutil_env_t * env)
+{
+ return handler_desc->param_container;
+}
+
diff --git a/src/core/description/module_desc.c b/src/core/description/module_desc.c
new file mode 100644
index 0000000..a5b27c7
--- /dev/null
+++ b/src/core/description/module_desc.c
@@ -0,0 +1,470 @@
+/*
+ * 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_module_desc.h>
+#include <axis2_module.h>
+
+struct axis2_module_desc
+{
+ axis2_module_t *module;
+ axutil_qname_t *qname;
+ axis2_conf_t *parent;
+
+ /**
+ * To store module operations , which are supposed to be added to a service
+ * the module is engaged to a service
+ */
+ axutil_hash_t *ops;
+
+ /**
+ * flow container that encapsulates the flows associated with the
+ * module
+ */
+ axis2_flow_container_t *flow_container;
+
+ /**
+ * parameter container that stores all the parameters associated with
+ * the module
+ */
+ axutil_param_container_t *params;
+};
+
+AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL
+axis2_module_desc_create(
+ const axutil_env_t * env)
+{
+ axis2_module_desc_t *module_desc = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ module_desc = (axis2_module_desc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_module_desc_t));
+
+ if(!module_desc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ module_desc->qname = NULL;
+ module_desc->module = NULL;
+ module_desc->parent = NULL;
+ module_desc->params = NULL;
+ module_desc->flow_container = NULL;
+ module_desc->ops = NULL;
+
+ module_desc->params = axutil_param_container_create(env);
+ if(!module_desc->params)
+ {
+ axis2_module_desc_free(module_desc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ module_desc->flow_container = axis2_flow_container_create(env);
+ if(!module_desc->flow_container)
+ {
+ axis2_module_desc_free(module_desc, env);
+AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE)
+ return NULL;
+}
+
+module_desc->ops = axutil_hash_make(env);
+if (!module_desc->ops)
+{
+ axis2_module_desc_free(module_desc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+}
+
+return module_desc;
+}
+
+AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL
+axis2_module_desc_create_with_qname(
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ axis2_module_desc_t *module_desc = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, qname, NULL);
+
+ module_desc = axis2_module_desc_create(env);
+ if(!module_desc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ module_desc->qname = (axutil_qname_t *)qname;
+
+ return module_desc;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_module_desc_free(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(module_desc->module)
+ {
+ axis2_module_shutdown(module_desc->module, env);
+ }
+
+ if(module_desc->params)
+ {
+ axutil_param_container_free(module_desc->params, env);
+ }
+
+ if(module_desc->flow_container)
+ {
+ axis2_flow_container_free(module_desc->flow_container, env);
+ }
+
+ module_desc->parent = NULL;
+
+ if(module_desc->qname)
+ {
+ axutil_qname_free(module_desc->qname, env);
+ }
+
+ if(module_desc->ops)
+ {
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+ for(hi = axutil_hash_first(module_desc->ops, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ struct axis2_op *op = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ op = (struct axis2_op *)val;
+ if(op)
+ axis2_op_free(op, env);
+ val = NULL;
+ op = NULL;
+
+ }
+ axutil_hash_free(module_desc->ops, env);
+ }
+
+ if(module_desc)
+ {
+ AXIS2_FREE(env->allocator, module_desc);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_module_desc_free_void_arg(
+ void *module_desc,
+ const axutil_env_t * env)
+{
+ axis2_module_desc_t *module_desc_l = NULL;
+
+ AXIS2_ENV_CHECK(env, void);
+ module_desc_l = (axis2_module_desc_t *)module_desc;
+ axis2_module_desc_free(module_desc_l, env);
+ return;
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_in_flow(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return axis2_flow_container_get_in_flow(module_desc->flow_container, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_in_flow(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_flow_t * in_flow)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE);
+
+ return axis2_flow_container_set_in_flow(module_desc->flow_container, env, in_flow);
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_out_flow(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return axis2_flow_container_get_out_flow(module_desc->flow_container, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_out_flow(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_flow_t * out_flow)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, out_flow, AXIS2_FAILURE);
+
+ return axis2_flow_container_set_out_flow(module_desc->flow_container, env, out_flow);
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_fault_in_flow(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return axis2_flow_container_get_fault_in_flow(module_desc->flow_container, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_fault_in_flow(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_flow_t * falut_in_flow)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, falut_in_flow, AXIS2_FAILURE);
+
+ return axis2_flow_container_set_fault_in_flow(module_desc->flow_container, env, falut_in_flow);
+}
+
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_fault_out_flow(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return axis2_flow_container_get_fault_out_flow(module_desc->flow_container, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_fault_out_flow(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_flow_t * fault_out_flow)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
+
+ return axis2_flow_container_set_fault_out_flow(module_desc->flow_container, env, fault_out_flow);
+}
+
+AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL
+axis2_module_desc_get_qname(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->qname;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_qname(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
+
+ if(module_desc->qname)
+ {
+ axutil_qname_free(module_desc->qname, env);
+ }
+
+ module_desc->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_add_op(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_op_t * op)
+{
+ const axutil_qname_t *op_qname = NULL;
+ axis2_char_t *op_name = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
+
+ if(!(module_desc->ops))
+ {
+ module_desc->ops = axutil_hash_make(env);
+ if(!module_desc->ops)
+ return AXIS2_FAILURE;
+ }
+
+ op_qname = axis2_op_get_qname(op, env);
+
+ if(!op_qname)
+ {
+ return AXIS2_FAILURE;
+ }
+ op_name = axutil_qname_to_string((axutil_qname_t *)op_qname, env);
+ axutil_hash_set(module_desc->ops, op_name, AXIS2_HASH_KEY_STRING, op);
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_module_desc_get_all_ops(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->ops;
+}
+
+AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
+axis2_module_desc_get_parent(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_parent(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_conf_t * parent)
+{
+ AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
+
+ module_desc->parent = parent;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_add_param(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ axis2_char_t *param_name_l = NULL;
+ axis2_status_t ret_status = AXIS2_FAILURE;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ param_name_l = axutil_param_get_name(param, env);
+ if(!param_name_l)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if(AXIS2_TRUE == axis2_module_desc_is_param_locked(module_desc, env, param_name_l))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ else
+ {
+ ret_status = axutil_param_container_add_param(module_desc->params, env, param);
+ }
+ return ret_status;
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_module_desc_get_param(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ AXIS2_PARAM_CHECK(env->error, name, NULL);
+
+ return axutil_param_container_get_param(module_desc->params, env, name);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_module_desc_get_all_params(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return axutil_param_container_get_params(module_desc->params, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_module_desc_is_param_locked(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axis2_bool_t locked = AXIS2_FALSE;
+ axis2_bool_t ret_state = AXIS2_FALSE;
+ axutil_param_t *param_l = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
+
+ /* checking the locked value of parent */
+ if(!module_desc->parent)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MODULE_DESC, AXIS2_FAILURE);
+ return AXIS2_FALSE;
+ }
+ locked = axis2_conf_is_param_locked(module_desc->parent, env, param_name);
+
+ if(AXIS2_TRUE == locked)
+ {
+ ret_state = AXIS2_TRUE;
+ }
+ else
+ {
+ param_l = axis2_module_desc_get_param(module_desc, env, param_name);
+ if(param_l && AXIS2_TRUE == axutil_param_is_locked(param_l, env))
+ ret_state = AXIS2_TRUE;
+ else
+ ret_state = AXIS2_FALSE;
+
+ }
+ return ret_state;
+}
+
+AXIS2_EXTERN axis2_module_t *AXIS2_CALL
+axis2_module_desc_get_module(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->module;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_module_desc_set_module(
+ axis2_module_desc_t * module_desc,
+ const axutil_env_t * env,
+ axis2_module_t * module)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, module, AXIS2_FAILURE);
+ module_desc->module = module;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_module_desc_get_param_container(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->params;
+}
+
+AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
+axis2_module_desc_get_flow_container(
+ const axis2_module_desc_t * module_desc,
+ const axutil_env_t * env)
+{
+ return module_desc->flow_container;
+}
diff --git a/src/core/description/msg.c b/src/core/description/msg.c
new file mode 100644
index 0000000..241253a
--- /dev/null
+++ b/src/core/description/msg.c
@@ -0,0 +1,407 @@
+/*
+ * 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.h>
+#include <axutil_property.h>
+
+struct axis2_msg
+{
+
+ /** parent operation */
+ axis2_op_t *parent;
+
+ /** list of phases that represent the flow */
+ axutil_array_list_t *flow;
+
+ /** name of the message */
+ axis2_char_t *name;
+
+ /** XML schema element qname */
+ axutil_qname_t *element_qname;
+
+ /** direction of message */
+ axis2_char_t *direction;
+
+ /** parameter container to hold message parameters */
+ struct axutil_param_container *param_container;
+
+ /** base description struct */
+ axis2_desc_t *base;
+
+ /** reference count of this object*/
+ int ref;
+
+};
+
+AXIS2_EXTERN axis2_msg_t *AXIS2_CALL
+axis2_msg_create(
+ const axutil_env_t * env)
+{
+ axis2_msg_t *msg = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg = (axis2_msg_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_t));
+
+ if(!msg)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg->param_container = NULL;
+ msg->parent = NULL;
+ msg->flow = NULL;
+ msg->name = NULL;
+ msg->element_qname = NULL;
+ msg->direction = NULL;
+ msg->base = NULL;
+ msg->ref = 1;
+
+ msg->param_container = (axutil_param_container_t *)axutil_param_container_create(env);
+ if(!msg->param_container)
+ {
+ axis2_msg_free(msg, env);
+ return NULL;
+ }
+
+ msg->flow = axutil_array_list_create(env, 0);
+ if(!msg->flow)
+ {
+ axis2_msg_free(msg, env);
+ return NULL;
+ }
+
+ msg->base = axis2_desc_create(env);
+ if(!msg->base)
+ {
+ axis2_msg_free(msg, env);
+ return NULL;
+ }
+
+ return msg;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_msg_free(
+ axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(--(msg->ref) > 0)
+ {
+ return;
+ }
+
+ if(msg->flow)
+ {
+ int i = 0, size = 0;
+ size = axutil_array_list_size(msg->flow, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_phase_t *phase = NULL;
+ phase = axutil_array_list_get(msg->flow, env, i);
+ if(phase)
+ axis2_phase_free(phase, env);
+ }
+ axutil_array_list_free(msg->flow, env);
+ }
+
+ if(msg->name)
+ {
+ AXIS2_FREE(env->allocator, msg->name);
+ }
+
+ if(msg->element_qname)
+ {
+ axutil_qname_free(msg->element_qname, env);
+ }
+
+ if(msg->direction)
+ {
+ AXIS2_FREE(env->allocator, msg->direction);
+ }
+
+ if(msg->param_container)
+ {
+ axutil_param_container_free(msg->param_container, env);
+ }
+
+ if(msg->base)
+ {
+ axis2_desc_free(msg->base, env);
+ }
+
+ msg->parent = NULL;
+
+ if(msg)
+ {
+ AXIS2_FREE(env->allocator, msg);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_add_param(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ axis2_char_t *param_name = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE);
+
+ param_name = axutil_param_get_name(param, env);
+ if(AXIS2_TRUE == axis2_msg_is_param_locked(msg, env, param_name))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ return axutil_param_container_add_param(msg->param_container, env, param);
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_msg_get_param(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ AXIS2_PARAM_CHECK(env->error, param_name, NULL);
+
+ return axutil_param_container_get_param(msg->param_container, env, param_name);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_msg_get_all_params(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ AXIS2_PARAM_CHECK(env->error, msg->param_container, AXIS2_FALSE);
+
+ return axutil_param_container_get_params(msg->param_container, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_set_parent(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ axis2_op_t * op)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg->parent = op;
+ if(op)
+ {
+ axis2_desc_set_parent(msg->base, env, axis2_op_get_base(op, env));
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_msg_get_parent(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->parent;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_msg_get_flow(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->flow;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_msg_is_param_locked(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axis2_op_t *parent_l = NULL;
+ axutil_param_t *param_l = NULL;
+ axis2_bool_t locked = AXIS2_FALSE;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
+
+ /* checking the locked status in parent */
+ parent_l = axis2_msg_get_parent(msg, env);
+ if(parent_l)
+ {
+ locked = axis2_op_is_param_locked(parent_l, env, param_name);
+ }
+ if(AXIS2_TRUE == locked)
+ {
+ return AXIS2_TRUE;
+ }
+ else
+ {
+ param_l = axis2_msg_get_param(msg, env, param_name);
+ }
+ return (param_l && axutil_param_is_locked(param_l, env));
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_set_flow(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ axutil_array_list_t * flow)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ if(msg->flow)
+ {
+ axutil_array_list_free(msg->flow, env);
+ msg->flow = NULL;
+ }
+ if(flow)
+ {
+ msg->flow = flow;
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_msg_get_direction(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->direction;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_set_direction(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ const axis2_char_t * direction)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(msg->direction)
+ {
+ AXIS2_FREE(env->allocator, msg->direction);
+ msg->direction = NULL;
+ }
+
+ if(direction)
+ {
+ msg->direction = axutil_strdup(env, direction);
+ if(!(msg->direction))
+ {
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL
+axis2_msg_get_element_qname(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->element_qname;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_set_element_qname(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ const axutil_qname_t * element_qname)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(msg->element_qname)
+ {
+ axutil_qname_free(msg->element_qname, env);
+ msg->element_qname = NULL;
+ }
+
+ if(element_qname)
+ {
+ msg->element_qname = axutil_qname_clone((axutil_qname_t *)element_qname, env);
+ if(!(msg->element_qname))
+ {
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_msg_get_name(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->name;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_set_name(
+ axis2_msg_t * msg,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(msg->name)
+ {
+ AXIS2_FREE(env->allocator, msg->name);
+ msg->name = NULL;
+ }
+
+ if(name)
+ {
+ msg->name = axutil_strdup(env, name);
+ if(!(msg->name))
+ {
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_msg_get_base(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->base;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_msg_get_param_container(
+ const axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ return msg->param_container;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_increment_ref(
+ axis2_msg_t * msg,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg->ref++;
+ return AXIS2_SUCCESS;
+}
diff --git a/src/core/description/op.c b/src/core/description/op.c
new file mode 100644
index 0000000..0cf926c
--- /dev/null
+++ b/src/core/description/op.c
@@ -0,0 +1,1383 @@
+/*
+ * 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.h>
+#include <axutil_property.h>
+#include <axis2_msg.h>
+#include <axis2_desc.h>
+#include <axis2_conf_ctx.h>
+#include <axis2_module.h>
+
+struct axis2_op
+{
+ axis2_svc_t *parent;
+ axis2_desc_t *base;
+ axis2_msg_recv_t *msg_recv;
+
+ int mep;
+ /* To store deploy time modules */
+ axutil_array_list_t *module_qnames;
+ axutil_array_list_t *engaged_module_list;
+ axutil_array_list_t *wsamapping_list;
+ axis2_bool_t from_module;
+ axutil_qname_t *qname;
+ axis2_char_t *msg_exchange_pattern;
+ axis2_char_t *style;
+
+ /* For REST support */
+ axis2_char_t *rest_http_method;
+ axis2_char_t *rest_http_location;
+
+ /** Parameter container to hold operation related parameters */
+ struct axutil_param_container *param_container;
+};
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_op_create(
+ const axutil_env_t * env)
+{
+ axis2_op_t *op = NULL;
+ axis2_msg_t *msg = NULL;
+
+ op = (axis2_op_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_op_t));
+
+ if(!op)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "");
+ return NULL;
+ }
+
+ op->parent = NULL;
+ op->base = NULL;
+ op->msg_recv = NULL;
+ op->mep = AXIS2_MEP_CONSTANT_INVALID;
+ op->param_container = NULL;
+ op->module_qnames = axutil_array_list_create(env, 0);
+ op->engaged_module_list = NULL;
+ op->from_module = AXIS2_FALSE;
+ op->wsamapping_list = NULL;
+ op->qname = NULL;
+ op->msg_exchange_pattern = NULL;
+ op->style = NULL;
+ op->rest_http_method = NULL;
+ op->rest_http_location = NULL;
+ op->style = axutil_strdup(env, AXIS2_STYLE_DOC);
+
+ op->param_container = (axutil_param_container_t *)axutil_param_container_create(env);
+ if(!op->param_container)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Param container creation failed");
+ return NULL;
+ }
+
+ op->base = axis2_desc_create(env);
+ if(!op->base)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation base creation failed");
+ return NULL;
+ }
+
+ /* Create and set up children messages */
+ msg = axis2_msg_create(env);
+ if(!msg)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed");
+ return NULL;
+ }
+ axis2_msg_set_direction(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_IN);
+ axis2_msg_set_parent(msg, env, op);
+ axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg);
+
+ msg = axis2_msg_create(env);
+ if(!msg)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed");
+ return NULL;
+ }
+ axis2_msg_set_direction(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_OUT);
+ axis2_msg_set_parent(msg, env, op);
+ axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg);
+
+ msg = axis2_msg_create(env);
+ if(!msg)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed");
+ return NULL;
+ }
+ axis2_msg_set_parent(msg, env, op);
+ axis2_msg_set_flow(msg, env, NULL);
+ axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg);
+
+ msg = axis2_msg_create(env);
+ if(!msg)
+ {
+ axis2_op_free(op, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed");
+ return NULL;
+ }
+ axis2_msg_set_parent(msg, env, op);
+ axis2_msg_set_flow(msg, env, NULL);
+ axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg);
+
+ axis2_op_set_msg_exchange_pattern(op, env, (axis2_char_t *)AXIS2_MEP_URI_IN_OUT);
+
+ return op;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_op_create_from_module(
+ const axutil_env_t * env)
+{
+ axis2_op_t *op = NULL;
+
+ op = (axis2_op_t *)axis2_op_create(env);
+ op->from_module = AXIS2_TRUE;
+ return op;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_op_create_with_qname(
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ axis2_op_t *op = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_PARAM_CHECK(env->error, qname, NULL);
+
+ op = (axis2_op_t *)axis2_op_create(env);
+
+ if(!op)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation creation failed for %s",
+ axutil_qname_get_localpart(qname, env));
+ return NULL;
+ }
+
+ status = axis2_op_set_qname(op, env, qname);
+ if(AXIS2_SUCCESS != status)
+ {
+ axis2_op_free(op, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name failed for operation %s",
+ axutil_qname_get_localpart(qname, env));
+ return NULL;
+ }
+
+ return op;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_op_free(
+ axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(op->base)
+ {
+ axis2_desc_free(op->base, env);
+ }
+ if(op->param_container)
+ {
+ axutil_param_container_free(op->param_container, env);
+ }
+
+ op->parent = NULL;
+
+ if(op->msg_recv)
+ {
+ axis2_msg_recv_free(op->msg_recv, env);
+ }
+ if(op->module_qnames)
+ {
+ int i = 0;
+ for(i = 0; i < axutil_array_list_size(op->module_qnames, env); i++)
+ {
+ axutil_qname_t *module_ref = NULL;
+ module_ref = axutil_array_list_get(op->module_qnames, env, i);
+
+ if(module_ref)
+ {
+ axutil_qname_free(module_ref, env);
+ }
+ }
+ axutil_array_list_free(op->module_qnames, env);
+ }
+ if(op->engaged_module_list)
+ {
+ axutil_array_list_free(op->engaged_module_list, env);
+ }
+ if(op->wsamapping_list)
+ {
+ int i = 0;
+ int size = 0;
+ size = axutil_array_list_size(op->wsamapping_list, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_char_t *temp_str = axutil_array_list_get(op->wsamapping_list, env, i);
+ if(temp_str)
+ AXIS2_FREE(env->allocator, temp_str);
+ }
+ axutil_array_list_free(op->wsamapping_list, env);
+ }
+
+ if(op->qname)
+ {
+ axutil_qname_free(op->qname, env);
+ }
+
+ if(op->msg_exchange_pattern)
+ {
+ AXIS2_FREE(env->allocator, op->msg_exchange_pattern);
+ }
+
+ if(op->style)
+ {
+ AXIS2_FREE(env->allocator, op->style);
+ }
+
+ if(op->rest_http_method)
+ {
+ AXIS2_FREE(env->allocator, op->rest_http_method);
+ }
+
+ if(op->rest_http_location)
+ {
+ AXIS2_FREE(env->allocator, op->rest_http_location);
+ }
+
+ if(op)
+ {
+ AXIS2_FREE(env->allocator, op);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_op_free_void_arg(
+ void *op,
+ const axutil_env_t * env)
+{
+ axis2_op_t *op_l = NULL;
+
+ op_l = (axis2_op_t *)op;
+ axis2_op_free(op_l, env);
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_param(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ axis2_char_t *param_name = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE);
+
+ param_name = axutil_param_get_name(param, env);
+ if(AXIS2_TRUE == axis2_op_is_param_locked(op, env, param_name))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked, cannot override",
+ param_name);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ else
+ {
+ status = axutil_param_container_add_param(op->param_container, env, param);
+ }
+
+ return status;
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_op_get_param(
+ const axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axutil_param_t *param = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, param_name, NULL);
+
+ param = axutil_param_container_get_param(op->param_container, env, param_name);
+ if(!param && op->parent)
+ {
+ param = axis2_svc_get_param(op->parent, env, param_name);
+ }
+ return param;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_remove_param
+ (axis2_op_t *op,
+ const axutil_env_t *env,
+ const axis2_char_t *param_name)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ status = axutil_param_container_delete_param(op->param_container, env, param_name);
+ return status;
+
+
+}
+
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_all_params(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return axutil_param_container_get_params(op->param_container, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_op_is_param_locked(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axis2_svc_t *parent = NULL;
+ axutil_param_t *param = NULL;
+ axis2_bool_t locked = AXIS2_FALSE;
+
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
+
+ /* Checking the locked value of parent */
+ parent = axis2_op_get_parent(op, env);
+ if(parent)
+ {
+ locked = axis2_svc_is_param_locked(parent, env, param_name);
+ }
+ if(locked)
+ {
+ return AXIS2_TRUE;
+ }
+ param = axis2_op_get_param(op, env, param_name);
+ return (param && AXIS2_TRUE == axutil_param_is_locked(param, env));
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_rest_http_method(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * rest_http_method)
+{
+ AXIS2_PARAM_CHECK(env->error, rest_http_method, AXIS2_FAILURE);
+
+ if(op->rest_http_method)
+ {
+ AXIS2_FREE(env->allocator, op->rest_http_method);
+ }
+ op->rest_http_method = NULL;
+ if(rest_http_method)
+ {
+ op->rest_http_method = axutil_strdup(env, rest_http_method);
+ return AXIS2_SUCCESS;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axis2_op_get_rest_http_method(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(!op)
+ {
+ return NULL;
+ }
+ if(op->rest_http_method)
+ {
+ return op->rest_http_method;
+ }
+ else
+ {
+ axutil_param_t *param = NULL;
+
+ param = axis2_op_get_param(op, env, AXIS2_DEFAULT_REST_HTTP_METHOD);
+
+ if(!param)
+ {
+ return "POST"; /* Added hard-coded string to avoid inclusion of HTTP
+ * Transport header
+ */
+ }
+ return (axis2_char_t *)axutil_param_get_value(param, env);
+ }
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_rest_http_location(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * rest_http_location)
+{
+ axis2_char_t *opname = NULL;
+ AXIS2_PARAM_CHECK(env->error, rest_http_location, AXIS2_FAILURE);
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ if(op->rest_http_location)
+ {
+ AXIS2_FREE(env->allocator, op->rest_http_location);
+ }
+ op->rest_http_location = NULL;
+ if(rest_http_location)
+ {
+ op->rest_http_location = axutil_strdup(env, rest_http_location);
+ return AXIS2_SUCCESS;
+ }
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting rest http location failed for operation %s",
+ opname);
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axis2_op_get_rest_http_location(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(!op)
+ {
+ return NULL;
+ }
+ return op->rest_http_location;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_parent(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_svc_t * svc)
+{
+ AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE);
+
+ if(op->parent)
+ {
+ op->parent = NULL;
+ }
+ op->parent = svc;
+ if(svc)
+ {
+ axis2_desc_set_parent(op->base, env, axis2_svc_get_base(svc, env));
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
+axis2_op_get_parent(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_msg_recv(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ struct axis2_msg_recv * msg_recv)
+{
+ AXIS2_PARAM_CHECK(env->error, msg_recv, AXIS2_FAILURE);
+
+ if(op->msg_recv == msg_recv)
+ {
+ return AXIS2_SUCCESS;
+ }
+ if(op->msg_recv)
+ {
+ axis2_msg_recv_free(op->msg_recv, env);
+ op->msg_recv = NULL;
+ }
+
+ op->msg_recv = msg_recv;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL
+axis2_op_get_msg_recv(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->msg_recv;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_qname(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ if(op->qname)
+ {
+ axutil_qname_free(op->qname, env);
+ op->qname = NULL;
+ }
+
+ if(qname)
+ {
+ op->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL
+axis2_op_get_qname(
+ void *op,
+ const axutil_env_t * env)
+{
+ return ((axis2_op_t *)op)->qname;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_msg_exchange_pattern(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * pattern)
+{
+ AXIS2_PARAM_CHECK(env->error, pattern, AXIS2_FAILURE);
+
+ if(op->msg_exchange_pattern)
+ {
+ AXIS2_FREE(env->allocator, op->msg_exchange_pattern);
+ op->msg_exchange_pattern = NULL;
+ }
+
+ op->msg_exchange_pattern = axutil_strdup(env, pattern);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_op_get_msg_exchange_pattern(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->msg_exchange_pattern;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_op_get_style(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->style;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_style(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * style)
+{
+ AXIS2_PARAM_CHECK(env->error, style, AXIS2_FAILURE);
+
+ if(op->style)
+ {
+ AXIS2_FREE(env->allocator, op->style);
+ op->style = NULL;
+ }
+
+ op->style = axutil_strdup(env, style);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_engage_module(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_module_desc_t * moduleref,
+ axis2_conf_t * conf)
+{
+ int index = 0;
+ int size = 0;
+ axutil_array_list_t *collection_module = NULL;
+ axis2_module_desc_t *module_desc = NULL;
+ axis2_phase_resolver_t *pr = NULL;
+ axis2_bool_t need_to_add = AXIS2_FALSE;
+ axis2_char_t *opname = NULL;
+ axis2_char_t *modname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ collection_module = op->engaged_module_list;
+ if(collection_module)
+ {
+ size = axutil_array_list_size(collection_module, env);
+ }
+ for(index = 0; index < size; index++)
+ {
+ const axutil_qname_t *qname1 = NULL;
+ const axutil_qname_t *qname2 = NULL;
+
+ module_desc = (axis2_module_desc_t *)axutil_array_list_get(collection_module, env, index);
+ if(!module_desc)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Retrieving a module failed from operation %s engaged module"
+ " list", opname);
+ return AXIS2_FAILURE;
+ }
+ qname1 = axis2_module_desc_get_qname(module_desc, env);
+ qname2 = axis2_module_desc_get_qname(moduleref, env);
+ modname = axutil_qname_get_localpart(qname2, env);
+ if(axutil_qname_equals(qname1, env, qname2))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module %s already engaged to operation %s",
+ modname, opname);
+
+ need_to_add = AXIS2_FALSE;
+ return AXIS2_FAILURE;
+ }
+
+ }
+ pr = axis2_phase_resolver_create_with_config(env, conf);
+ if(pr)
+ {
+ axis2_module_t *module = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ status = axis2_phase_resolver_engage_module_to_op(pr, env, op, moduleref);
+ if(AXIS2_SUCCESS != status)
+ {
+ /* Ignore the status */
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_SUCCESS);
+ AXIS2_LOG_INFO(env->log, AXIS2_LOG_SI,
+ "Engaging module %s to operaion %s failed. But ignore this.", modname, opname);
+ }
+ module = axis2_module_desc_get_module(moduleref, env);
+
+ if(need_to_add)
+ {
+ axutil_array_list_add(collection_module, env, moduleref);
+ }
+ }
+ else
+ {
+ return AXIS2_FAILURE;
+ }
+ axis2_phase_resolver_free(pr, env);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_to_engaged_module_list(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc)
+{
+ axis2_module_desc_t *module_desc_l = NULL;
+ int size = 0;
+ int index = 0;
+ const axutil_qname_t *module_qname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+
+ if(!op->engaged_module_list)
+ {
+ op->engaged_module_list = axutil_array_list_create(env, 0);
+ }
+ size = axutil_array_list_size(op->engaged_module_list, env);
+
+ module_qname = axis2_module_desc_get_qname(module_desc, env);
+ for(index = 0; index < size; index++)
+ {
+ const axutil_qname_t *module_qname_l = NULL;
+
+ module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(op-> engaged_module_list, env,
+ index);
+ module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+
+ if(axutil_qname_equals(module_qname, env, module_qname_l))
+ {
+ return AXIS2_SUCCESS;
+ }
+
+ }
+
+ return axutil_array_list_add(op->engaged_module_list, env, module_desc);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_remove_from_engaged_module_list(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc)
+{
+ axis2_module_desc_t *module_desc_l = NULL;
+ int size = 0;
+ int index = 0;
+ const axutil_qname_t *module_qname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op->engaged_module_list, AXIS2_FAILURE);
+
+ size = axutil_array_list_size(op->engaged_module_list, env);
+
+ module_qname = axis2_module_desc_get_qname(module_desc, env);
+ for(index = 0; index < size; index++)
+ {
+ const axutil_qname_t *module_qname_l = NULL;
+
+ module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(op-> engaged_module_list, env,
+ index);
+ module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+
+ if(axutil_qname_equals(module_qname, env, module_qname_l))
+ {
+ axutil_array_list_remove(op->engaged_module_list, env, index);
+ return AXIS2_SUCCESS;
+ }
+
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_all_modules(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->engaged_module_list;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+axis2_op_get_axis_specific_mep_const(
+ axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ int temp = 0;
+ axis2_char_t *opname = NULL;
+
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ if(op->mep != AXIS2_MEP_CONSTANT_INVALID)
+ {
+ return op->mep;
+ }
+
+ temp = AXIS2_MEP_CONSTANT_INVALID;
+
+ if((axutil_strcmp(AXIS2_MEP_URI_IN_OUT, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_IN_OUT_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_IN_OUT;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_IN_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0)
+ || (axutil_strcmp(AXIS2_MEP_URI_IN_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_IN_ONLY;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_IN_OPTIONAL_OUT, axis2_op_get_msg_exchange_pattern(op, env))== 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_IN_OPTIONAL_OUT_WSDL2, axis2_op_get_msg_exchange_pattern(op, env))== 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_IN_OPTIONAL_OUT;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_OUT_IN, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_OUT_IN_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_OUT_IN;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_OUT_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_OUT_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_OUT_ONLY;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_OUT_OPTIONAL_IN, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_OUT_OPTIONAL_IN_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_OUT_OPTIONAL_IN;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_ROBUST_IN_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_ROBUST_IN_ONLY;
+ }
+ else if((axutil_strcmp(AXIS2_MEP_URI_ROBUST_OUT_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) ||
+ (axutil_strcmp(AXIS2_MEP_URI_ROBUST_OUT_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0))
+ {
+ temp = AXIS2_MEP_CONSTANT_ROBUST_OUT_ONLY;
+ }
+ if(temp == AXIS2_MEP_CONSTANT_INVALID)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Could not map the MEP URI %s to an Axis2/C MEP constant value "
+ "in retrieving MEP for operation %s", axis2_op_get_msg_exchange_pattern(op, env),
+ opname);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_COULD_NOT_MAP_MEP_URI_TO_MEP_CONSTANT,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ op->mep = temp;
+ return op->mep;
+
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_fault_in_flow(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN_FAULT);
+ if(msg)
+ {
+ return axis2_msg_get_flow(msg, env);
+ }
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_fault_out_flow(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT_FAULT);
+ if(msg)
+ {
+ return axis2_msg_get_flow(msg, env);
+ }
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_out_flow(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT);
+ if(msg)
+ {
+ return axis2_msg_get_flow(msg, env);
+ }
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_in_flow(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN);
+ if(msg)
+ {
+ return axis2_msg_get_flow(msg, env);
+ }
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_fault_in_flow(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_array_list_t * list)
+{
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE);
+
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN_FAULT);
+ if(msg)
+ {
+ return axis2_msg_set_flow(msg, env, list);
+ }
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_fault_out_flow(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_array_list_t * list)
+{
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE);
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT_FAULT);
+ if(msg)
+ {
+ return axis2_msg_set_flow(msg, env, list);
+ }
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_out_flow(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_array_list_t * list)
+{
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE);
+
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT);
+ if(msg)
+ {
+ return axis2_msg_set_flow(msg, env, list);
+ }
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_in_flow(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_array_list_t * list)
+{
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE);
+
+ if(op->base)
+ {
+ axis2_msg_t *msg = NULL;
+ msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN);
+ if(msg)
+ {
+ return axis2_msg_set_flow(msg, env, list);
+ }
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_module_qname(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axutil_qname_t * module_qname)
+{
+ axutil_qname_t *module_qname_l = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
+ module_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env);
+
+ return axutil_array_list_add(op->module_qnames, env, module_qname_l);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_all_module_qnames(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->module_qnames;
+}
+
+AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL
+axis2_op_find_op_ctx(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * msg_ctx,
+ struct axis2_svc_ctx * svc_ctx)
+{
+ axis2_op_ctx_t *op_ctx = NULL;
+ axis2_relates_to_t *relates_to = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_char_t *opname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL);
+ AXIS2_PARAM_CHECK(env->error, svc_ctx, NULL);
+
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env);
+ if(!relates_to)
+ {
+ op_ctx = axis2_op_ctx_create(env, op, svc_ctx);
+ if(!op_ctx)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Creating operation context failed for operation %s", opname);
+ return NULL;
+ }
+ }
+ else
+ {
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ const axis2_char_t *value = NULL;
+
+ conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
+ value = axis2_relates_to_get_value(relates_to, env);
+ op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, value);
+ if(!op_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Cannot correlate message to %s for operation %s", value, opname);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_CORRELATE_MSG, AXIS2_FAILURE);
+ return NULL;
+ }
+ }
+
+ status = axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx);
+ if(AXIS2_FAILURE == status)
+ {
+ axis2_op_ctx_free(op_ctx, env);
+ return NULL;
+ }
+ else
+ {
+ return op_ctx;
+ }
+}
+
+AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL
+axis2_op_find_existing_op_ctx(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_msg_ctx_t * msg_ctx)
+{
+ axis2_op_ctx_t *op_ctx = NULL;
+ axis2_relates_to_t *relates_to = NULL;
+ axis2_char_t *opname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL);
+
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
+ if(op_ctx)
+ {
+ return op_ctx;
+ }
+
+ relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env);
+ if(!relates_to)
+ {
+ return NULL;
+ }
+ else
+ {
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ const axis2_char_t *value = NULL;
+ conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
+ value = axis2_relates_to_get_value(relates_to, env);
+ op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, value);
+
+ if(!op_ctx)
+ {
+ AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI,
+ "Cannot correlate message to %s for operation %s", value, opname);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_CORRELATE_MSG, AXIS2_FAILURE);
+ return NULL;
+ }
+ }
+
+ return op_ctx;
+
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_register_op_ctx(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_op_ctx_t * op_ctx)
+{
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ const axis2_char_t *msg_id = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_char_t *opname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE);
+
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+ conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
+ if(!conf_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Configuration context not found for message context while "
+ "registering operation context for operation %s", opname);
+ return AXIS2_FAILURE;
+ }
+
+ status = axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx);
+
+ if(AXIS2_SUCCESS != status)
+ {
+ axutil_hash_t *op_ctx_map = NULL;
+
+ msg_id = axis2_msg_ctx_get_msg_id(msg_ctx, env);
+ if(msg_id)
+ {
+ op_ctx_map = (axutil_hash_t *)axis2_conf_ctx_get_op_ctx_map(conf_ctx, env);
+ axutil_hash_set(op_ctx_map, msg_id, AXIS2_HASH_KEY_STRING, NULL);
+ }
+ else
+ {
+ AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI,
+ "Message id not found for message context while registering operation context "
+ "for operation %s. The reason could be that there is no addressing enabled for "
+ "communication", opname);
+ }
+ }
+ if(axis2_op_ctx_get_is_complete(op_ctx, env))
+ {
+ axis2_op_ctx_cleanup(op_ctx, env);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_msg_ctx_in_only(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_op_ctx_t * op_ctx)
+{
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE);
+
+ if(!axis2_op_ctx_get_is_complete(op_ctx, env))
+ {
+ axis2_msg_ctx_t **msg_ctxs = NULL;
+ msg_ctxs = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
+ msg_ctxs[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx;
+ axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE);
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Invalid message; adding operation context for the "
+ "operation :%s is already completed", axutil_qname_get_localpart(
+ axis2_op_get_qname(op, env), env));
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_msg_ctx_out_only(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_op_ctx_t * op_ctx)
+{
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE);
+
+ if(!axis2_op_ctx_get_is_complete(op_ctx, env))
+ {
+ axis2_msg_ctx_t **msg_ctxs = NULL;
+ msg_ctxs = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
+ msg_ctxs[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx;
+ axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE);
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Invalid message; adding operation context for the "
+ "operation :%s is already completed", axutil_qname_get_localpart(
+ axis2_op_get_qname(op, env), env));
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_msg_ctx_in_out(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_op_ctx_t * op_ctx)
+{
+ axis2_msg_ctx_t **mep = NULL;
+ axis2_msg_ctx_t *in_msg_ctx = NULL;
+ axis2_msg_ctx_t *out_msg_ctx = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE);
+
+ mep = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
+ in_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_IN];
+ out_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_OUT];
+
+ if(in_msg_ctx && out_msg_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Invalid message; adding operation context for the "
+ "operation :%s is invalid", axutil_qname_get_localpart(axis2_op_get_qname(op, env),
+ env));
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if(!in_msg_ctx)
+ {
+ mep[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx;
+ }
+ else
+ {
+ mep[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx;
+ axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_msg_ctx_out_in(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_op_ctx_t * op_ctx)
+{
+ axis2_msg_ctx_t **mep = NULL;
+ axis2_msg_ctx_t *in_msg_ctx = NULL;
+ axis2_msg_ctx_t *out_msg_ctx = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE);
+
+ mep = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
+ in_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_IN];
+ out_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_OUT];
+ if(in_msg_ctx && out_msg_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Invalid message; adding operation context for the "
+ "operation :%s is invalid", axutil_qname_get_localpart(axis2_op_get_qname(op, env),
+ env));
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if(!out_msg_ctx)
+ {
+ mep[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx;
+ }
+ else
+ {
+ mep[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx;
+ axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_msg_t *AXIS2_CALL
+axis2_op_get_msg(
+ const axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * label)
+{
+ AXIS2_PARAM_CHECK(env->error, label, NULL);
+
+ return (axis2_msg_t *)axis2_desc_get_child(op->base, env, label);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_add_msg(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ const axis2_char_t * label,
+ const axis2_msg_t * msg)
+{
+ AXIS2_PARAM_CHECK(env->error, label, AXIS2_FAILURE);
+
+ return axis2_desc_add_child(op->base, env, label, msg);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_op_is_from_module(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->from_module;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_op_set_wsamapping_list(
+ axis2_op_t * op,
+ const axutil_env_t * env,
+ axutil_array_list_t * mapping_list)
+{
+ AXIS2_PARAM_CHECK(env->error, mapping_list, AXIS2_FAILURE);
+
+ if(op->wsamapping_list)
+ {
+ int i = 0;
+ int size = 0;
+ size = axutil_array_list_size(op->wsamapping_list, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_char_t *temp_str = axutil_array_list_get(op->wsamapping_list, env, i);
+ if(temp_str)
+ AXIS2_FREE(env->allocator, temp_str);
+ }
+ axutil_array_list_free(op->wsamapping_list, env);
+ op->wsamapping_list = NULL;
+ }
+ op->wsamapping_list = mapping_list;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_op_get_wsamapping_list(
+ axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->wsamapping_list;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_op_get_param_container(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->param_container;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_op_get_base(
+ const axis2_op_t * op,
+ const axutil_env_t * env)
+{
+ return op->base;
+}
+
diff --git a/src/core/description/phase_rule.c b/src/core/description/phase_rule.c
new file mode 100644
index 0000000..bb4cfea
--- /dev/null
+++ b/src/core/description/phase_rule.c
@@ -0,0 +1,254 @@
+/*
+ * 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_const.h>
+#include <axis2_phase_rule.h>
+#include <axutil_string.h>
+
+struct axis2_phase_rule
+{
+
+ /** name of phase or handler before */
+ axis2_char_t *before;
+
+ /** name of phase or handler after */
+ axis2_char_t *after;
+
+ /** phase name */
+ axis2_char_t *name;
+
+ /** Is this first in phase? */
+ axis2_bool_t first;
+
+ /** Is this last in phase? */
+ axis2_bool_t last;
+
+};
+
+AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
+axis2_phase_rule_create(
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ axis2_phase_rule_t *phase_rule = NULL;
+
+ phase_rule = AXIS2_MALLOC(env->allocator, sizeof(axis2_phase_rule_t));
+ if(!phase_rule)
+ {
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ phase_rule->before = NULL;
+ phase_rule->after = NULL;
+ phase_rule->name = NULL;
+ phase_rule->first = AXIS2_FALSE;
+ phase_rule->last = AXIS2_FALSE;
+
+ if(name)
+ {
+ phase_rule->name = axutil_strdup(env, name);
+ }
+
+ return phase_rule;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_phase_rule_get_before(
+ const axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ return phase_rule->before;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_before(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env,
+ const axis2_char_t * before)
+{
+ if(phase_rule->before)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->before);
+ }
+
+ if(before)
+ {
+ phase_rule->before = axutil_strdup(env, before);
+ if(!phase_rule->before)
+ {
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_phase_rule_get_after(
+ const axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ return phase_rule->after;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_after(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env,
+ const axis2_char_t * after)
+{
+ if(phase_rule->after)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->after);
+ }
+
+ if(after)
+ {
+ phase_rule->after = axutil_strdup(env, after);
+ if(!phase_rule->after)
+ {
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_phase_rule_get_name(
+ const axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ return phase_rule->name;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_name(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ if(phase_rule->name)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->name);
+ }
+
+ if(name)
+ {
+ phase_rule->name = axutil_strdup(env, name);
+ if(!phase_rule->name)
+ {
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_first(
+ const axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ return phase_rule->first;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_first(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env,
+ axis2_bool_t first)
+{
+ phase_rule->first = first;
+ return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_last(
+ const axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ return phase_rule->last;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_last(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env,
+ axis2_bool_t last)
+{
+ phase_rule->last = last;
+ return AXIS2_SUCCESS;
+}
+
+void AXIS2_CALL
+axis2_phase_rule_free(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ if(phase_rule->before)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->before);
+ }
+
+ if(phase_rule->after)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->after);
+ }
+
+ if(phase_rule->name)
+ {
+ AXIS2_FREE(env->allocator, phase_rule->name);
+ }
+
+ AXIS2_FREE(env->allocator, phase_rule);
+
+ return;
+}
+
+axis2_phase_rule_t *AXIS2_CALL
+axis2_phase_rule_clone(
+ axis2_phase_rule_t * phase_rule,
+ const axutil_env_t * env)
+{
+ axis2_phase_rule_t *phase_rule_new = NULL;
+
+ phase_rule_new = axis2_phase_rule_create(env, NULL);
+ if(!phase_rule_new)
+ return NULL;
+
+ axis2_phase_rule_set_before(phase_rule_new, env, axis2_phase_rule_get_before(phase_rule, env));
+
+ axis2_phase_rule_set_after(phase_rule_new, env, axis2_phase_rule_get_after(phase_rule, env));
+
+ axis2_phase_rule_set_name(phase_rule_new, env, axis2_phase_rule_get_name(phase_rule, env));
+
+ axis2_phase_rule_set_first(phase_rule_new, env, axis2_phase_rule_is_first(phase_rule, env));
+
+ axis2_phase_rule_set_last(phase_rule_new, env, axis2_phase_rule_is_last(phase_rule, env));
+
+ return phase_rule_new;
+}
+
diff --git a/src/core/description/policy_include.c b/src/core/description/policy_include.c
new file mode 100644
index 0000000..5ce93f8
--- /dev/null
+++ b/src/core/description/policy_include.c
@@ -0,0 +1,612 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_policy_include.h>
+#include <neethi_policy.h>
+#include <neethi_engine.h>
+
+struct axis2_policy_include
+{
+ neethi_policy_t *policy;
+
+ neethi_policy_t *effective_policy;
+
+ neethi_registry_t *registry;
+
+ axis2_desc_t *desc;
+
+ axutil_hash_t *wrapper_elements;
+};
+
+typedef struct axis2_policy_wrapper
+{
+ int type;
+ void *value;
+} axis2_policy_wrapper_t;
+
+AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL
+axis2_policy_include_create(
+ const axutil_env_t * env)
+{
+ axis2_policy_include_t *policy_include = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ policy_include = (axis2_policy_include_t *)AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_policy_include_t));
+
+ if(!policy_include)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ policy_include->policy = NULL;
+ policy_include->effective_policy = NULL;
+ policy_include->registry = NULL;
+ policy_include->desc = NULL;
+ policy_include->wrapper_elements = NULL;
+
+ policy_include->registry = neethi_registry_create(env);
+ if(!policy_include->registry)
+ {
+ axis2_policy_include_free(policy_include, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ policy_include->wrapper_elements = axutil_hash_make(env);
+ if(!policy_include->wrapper_elements)
+ {
+ axis2_policy_include_free(policy_include, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return policy_include;
+}
+
+AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL
+axis2_policy_include_create_with_desc(
+ const axutil_env_t * env,
+ axis2_desc_t * desc)
+{
+ axis2_policy_include_t *policy_include = NULL;
+ axis2_desc_t *parent_desc = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ policy_include = (axis2_policy_include_t *)axis2_policy_include_create(env);
+
+ parent_desc = axis2_desc_get_parent(desc, env);
+
+ if(policy_include->registry)
+ {
+ neethi_registry_free(policy_include->registry, env);
+ policy_include->registry = NULL;
+ }
+
+ if(parent_desc)
+ {
+ axis2_policy_include_t *preant_policy_include = axis2_desc_get_policy_include(parent_desc,
+ env);
+ if(preant_policy_include)
+ {
+ policy_include->registry = neethi_registry_create_with_parent(env,
+ axis2_policy_include_get_registry(preant_policy_include, env));
+ }
+ else
+ {
+ policy_include->registry = neethi_registry_create(env);
+ }
+ }
+ else
+ {
+ policy_include->registry = neethi_registry_create(env);
+ }
+
+ policy_include->desc = desc;
+
+ return policy_include;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_policy_include_free(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(policy_include->registry)
+ {
+ neethi_registry_free(policy_include->registry, env);
+ }
+
+ if(policy_include->wrapper_elements)
+ {
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+ for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi
+ = axutil_hash_next(env, hi))
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ wrapper = (axis2_policy_wrapper_t *)val;
+ if(wrapper)
+ AXIS2_FREE(env->allocator, wrapper);
+ val = NULL;
+ wrapper = NULL;
+ }
+ axutil_hash_free(policy_include->wrapper_elements, env);
+ }
+
+ if(policy_include)
+ {
+ AXIS2_FREE(env->allocator, policy_include);
+ }
+
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_set_registry(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ neethi_registry_t * registry)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(policy_include->registry)
+ {
+ neethi_registry_free(policy_include->registry, env);
+ }
+
+ policy_include->registry = registry;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN neethi_registry_t *AXIS2_CALL
+axis2_policy_include_get_registry(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ return policy_include->registry;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_set_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ neethi_policy_t * policy)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(policy_include->wrapper_elements)
+ {
+ axutil_hash_free(policy_include->wrapper_elements, env);
+ policy_include->wrapper_elements = NULL;
+ }
+
+ policy_include->wrapper_elements = axutil_hash_make(env);
+
+ if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env))
+ {
+ neethi_policy_set_id(policy, env, axutil_uuid_gen(env));
+ }
+
+ if(policy_include->wrapper_elements)
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_policy_wrapper_t));
+ if(wrapper)
+ {
+ axis2_char_t *policy_name = NULL;
+ wrapper->type = AXIS2_ANON_POLICY;
+ wrapper->value = policy;
+
+ policy_name = neethi_policy_get_name(policy, env);
+
+ if(policy_name)
+ {
+ axutil_hash_set(policy_include->wrapper_elements, policy_name,
+ AXIS2_HASH_KEY_STRING, wrapper);
+ }
+ else
+ {
+ axutil_hash_set(policy_include->wrapper_elements,
+ neethi_policy_get_id(policy, env), AXIS2_HASH_KEY_STRING, wrapper);
+ }
+ }
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_update_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ neethi_policy_t * policy)
+{
+ axis2_char_t *key;
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ key = neethi_policy_get_name(policy, env);
+ if(!key)
+ key = neethi_policy_get_id(policy, env);
+
+ if(!key)
+ {
+ return AXIS2_FAILURE;
+ }
+
+ wrapper = axutil_hash_get(policy_include->wrapper_elements, key, AXIS2_HASH_KEY_STRING);
+ if(wrapper)
+ {
+ wrapper->value = policy;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_set_effective_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ neethi_policy_t * effective_policy)
+{
+ policy_include->effective_policy = effective_policy;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_set_desc(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ axis2_desc_t * desc)
+{
+ policy_include->desc = desc;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_policy_include_get_desc(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ return policy_include->desc;
+}
+
+AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL
+axis2_policy_include_get_parent(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ if(policy_include->desc)
+ {
+ axis2_desc_t *parent = NULL;
+ parent = axis2_desc_get_parent(policy_include->desc, env);
+ if(parent)
+ {
+ return axis2_desc_get_policy_include(parent, env);
+ }
+ }
+
+ return NULL;
+}
+
+static axis2_status_t
+axis2_policy_include_calculate_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ neethi_policy_t *result = NULL;
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+
+ for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next(
+ env, hi))
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ axutil_hash_this(hi, NULL, NULL, &val);
+ wrapper = (axis2_policy_wrapper_t *)val;
+
+ if(wrapper)
+ {
+ neethi_policy_t *policy = NULL;
+ if(wrapper->type == AXIS2_POLICY_REF)
+ {
+ neethi_reference_t *reference = (neethi_reference_t *)wrapper->value;
+ if(reference)
+ {
+ /* TOOD add neethi_reference_normalize
+ policy = (neethi_policy_t*) neethi_reference_normalize(
+ reference, env, policy_include->registry, AXIS2_FALSE);
+ */
+ }
+ }
+ else
+ {
+ policy = (neethi_policy_t *)wrapper->value;
+ }
+
+ result = (result == NULL) ? (neethi_policy_t *)policy
+ : (neethi_policy_t *)neethi_engine_merge(env, result, policy);
+ }
+ }
+
+ policy_include->policy = result;
+ return AXIS2_SUCCESS;
+}
+
+static neethi_policy_t *
+axis2_policy_include_calculate_effective_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ neethi_policy_t *result;
+ axis2_policy_include_t *parent = NULL;
+
+ parent = axis2_policy_include_get_parent(policy_include, env);
+
+ if(parent)
+ {
+ neethi_policy_t *parent_policy = axis2_policy_include_get_effective_policy(parent, env);
+
+ if(!parent_policy)
+ {
+ result = axis2_policy_include_get_policy(policy_include, env);
+
+ }
+ else
+ {
+ if(axis2_policy_include_get_policy(policy_include, env))
+ {
+ neethi_policy_t *temp_policy = NULL;
+ parent_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE,
+ parent_policy);
+ temp_policy = axis2_policy_include_get_policy(policy_include, env);
+ temp_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE,
+ temp_policy);
+ /* result = (neethi_policy_t*) neethi_engine_merge(env, parent_policy,
+ axis2_policy_include_get_policy(policy_include, env)); */
+ result = (neethi_policy_t *)neethi_engine_merge(env, parent_policy, temp_policy);
+
+ }
+ else
+ {
+ result = parent_policy;
+ }
+ }
+ }
+ else
+ {
+ result = axis2_policy_include_get_policy(policy_include, env);
+ }
+
+ return result;
+ /*policy_include->effective_policy = result;
+ return AXIS2_SUCCESS; */
+}
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+axis2_policy_include_get_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ axis2_policy_include_calculate_policy(policy_include, env);
+ return policy_include->policy;
+}
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+axis2_policy_include_get_effective_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ /*if (policy_include->effective_policy)
+ return policy_include->effective_policy;
+ */
+ return axis2_policy_include_calculate_effective_policy(policy_include, env);
+ /*return policy_include->effective_policy; */
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_policy_include_get_policy_elements(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ axutil_array_list_t *policy_elements_list = NULL;
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+
+ policy_elements_list = axutil_array_list_create(env, 10);
+
+ for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next(
+ env, hi))
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ axutil_hash_this(hi, NULL, NULL, &val);
+ wrapper = (axis2_policy_wrapper_t *)val;
+
+ if(wrapper)
+ {
+ axutil_array_list_add(policy_elements_list, env, wrapper->value);
+ }
+ }
+ return policy_elements_list;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_policy_include_get_policy_elements_with_type(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ int type)
+{
+ axutil_array_list_t *policy_elements_list = NULL;
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+
+ policy_elements_list = axutil_array_list_create(env, 10);
+
+ for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next(
+ env, hi))
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ axutil_hash_this(hi, NULL, NULL, &val);
+ wrapper = (axis2_policy_wrapper_t *)val;
+
+ if(wrapper && wrapper->type == type)
+ {
+ axutil_array_list_add(policy_elements_list, env, wrapper->value);
+ }
+ }
+ return policy_elements_list;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_register_policy(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ axis2_char_t * key,
+ neethi_policy_t * policy)
+{
+ if(policy_include->registry)
+ {
+ return neethi_registry_register(policy_include->registry, env, key, policy);
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+axis2_policy_include_get_policy_with_key(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ axis2_char_t * key)
+{
+ if(policy_include->registry)
+ {
+ return neethi_registry_lookup(policy_include->registry, env, key);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_add_policy_element(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ int type,
+ neethi_policy_t * policy)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env))
+ {
+ axis2_char_t *uuid = axutil_uuid_gen(env);
+ neethi_policy_set_id(policy, env, uuid);
+ if(uuid)
+ {
+ AXIS2_FREE(env->allocator, uuid);
+ uuid = NULL;
+ }
+ }
+
+ if(policy_include->wrapper_elements)
+ {
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_policy_wrapper_t));
+ if(wrapper)
+ {
+ axis2_char_t *policy_name = NULL;
+ wrapper->type = type;
+ wrapper->value = policy;
+
+ policy_name = neethi_policy_get_name(policy, env);
+ if(!policy_name)
+ policy_name = neethi_policy_get_id(policy, env);
+
+ if(policy_name)
+ {
+ axutil_hash_set(policy_include->wrapper_elements, policy_name,
+ AXIS2_HASH_KEY_STRING, wrapper);
+ if(policy_include->registry)
+ {
+ neethi_registry_register(policy_include->registry, env, policy_name, policy);
+ }
+ return AXIS2_SUCCESS;
+ }
+ }
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_add_policy_reference_element(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ int type,
+ neethi_reference_t * reference)
+{
+ axis2_policy_wrapper_t *wrapper = NULL;
+
+ wrapper
+ = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_policy_wrapper_t));
+ if(wrapper)
+ {
+ wrapper->type = type;
+ wrapper->value = reference;
+ axutil_hash_set(policy_include->wrapper_elements, neethi_reference_get_uri(reference, env),
+ AXIS2_HASH_KEY_STRING, wrapper);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_remove_policy_element(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env,
+ axis2_char_t * policy_uri)
+{
+ if(policy_include->wrapper_elements)
+ {
+ axutil_hash_set(policy_include->wrapper_elements, policy_uri, AXIS2_HASH_KEY_STRING, NULL);
+ }
+ if(policy_include->registry)
+ {
+ neethi_registry_register(policy_include->registry, env, policy_uri, NULL);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_policy_include_remove_all_policy_element(
+ axis2_policy_include_t * policy_include,
+ const axutil_env_t * env)
+{
+ if(policy_include->wrapper_elements)
+ {
+ axutil_hash_free(policy_include->wrapper_elements, env);
+ }
+ return AXIS2_SUCCESS;
+}
diff --git a/src/core/description/svc.c b/src/core/description/svc.c
new file mode 100644
index 0000000..72f4597
--- /dev/null
+++ b/src/core/description/svc.c
@@ -0,0 +1,1543 @@
+/*
+ * 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.h>
+#include <axis2_addr.h>
+#include <axutil_property.h>
+#include <axis2_module.h>
+#include "../deployment/axis2_desc_builder.h"
+#include <axis2_svc_skeleton.h>
+#include <axutil_thread.h>
+#include <axis2_core_utils.h>
+
+struct axis2_svc
+{
+ axis2_svc_grp_t *parent;
+ axis2_char_t *axis_svc_name;
+
+ /** To keep last update time of the service */
+ long last_update;
+ axis2_char_t *filename;
+
+ /** To store module descriptions at deploy time parsing */
+ axutil_array_list_t *module_list;
+
+ /** Service description */
+ axis2_char_t *svc_desc;
+
+ /** wsdl file path */
+ axis2_char_t *wsdl_path;
+
+ /** service folder path */
+ axis2_char_t *folder_path;
+
+ /**
+ * WSDL related stuff
+ */
+ axutil_hash_t *ns_map;
+ /* Count of the entries in the namespace map */
+ int ns_count;
+ /* To keep the XML scheama either from WSDL or
+ * C2WSDL(in the future)
+ */
+ axutil_array_list_t *schema_list;
+
+ /**
+ * A table that keeps a mapping of unique XSD names (Strings)
+ * against the schema objects. This is populated in the first
+ * instance the schemas are asked for and then used to serve
+ * the subsequent requests
+ */
+ axutil_hash_t *schema_mapping_table;
+
+ /**
+ * This is where operations are kept
+ */
+ axutil_hash_t *op_alias_map;
+
+ /**
+ * This is where action mappings are kept
+ */
+ axutil_hash_t *op_action_map;
+
+ /**
+ * This is where REST mappings are kept
+ */
+ axutil_hash_t *op_rest_map;
+
+ /**
+ * Keeps track whether the schema locations are adjusted
+ */
+ axis2_bool_t schema_loc_adjusted;
+
+ /**
+ * A custom schema name prefix. if set this will be used to
+ * modify the schema names
+ */
+ axis2_char_t *custom_schema_name_prefix;
+
+ /**
+ * A custom schema name suffix. will be attached to the
+ * schema file name when the files are uniquely named.
+ * A good place to add a file extension if needed
+ */
+ axis2_char_t *custom_schema_name_suffix;
+ /* To store the target namespace for the schema */
+ axis2_char_t *schema_target_ns;
+ axis2_char_t *schema_target_ns_prefix;
+ /* To keep the service target name space */
+ axis2_char_t *target_ns;
+ axis2_char_t *target_ns_prefix;
+ /* Used for schema name calculations */
+ int sc_calc_count;
+
+ void *impl_class;
+ axutil_qname_t *qname;
+ axis2_char_t *style;
+ axutil_array_list_t *engaged_module_list;
+
+ /** Parameter container to hold service related parameters */
+ struct axutil_param_container *param_container;
+
+ /** Flow container that encapsulates the flow related data */
+ struct axis2_flow_container *flow_container;
+
+ /** Base description struct */
+ axis2_desc_t *base;
+
+ /* Mutex to avoid loading the same service dll twice */
+ axutil_thread_mutex_t *mutex;
+};
+
+AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
+axis2_svc_create(
+ const axutil_env_t * env)
+{
+ axis2_svc_t *svc = NULL;
+
+ svc = (axis2_svc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_t));
+ if(!svc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return NULL;
+ }
+
+ svc->parent = NULL;
+ svc->axis_svc_name = NULL;
+ svc->filename = NULL;
+ svc->svc_desc = NULL;
+ svc->wsdl_path = NULL;
+ svc->folder_path = NULL;
+ svc->last_update = 0;
+ svc->param_container = NULL;
+ svc->flow_container = NULL;
+ svc->op_alias_map = NULL;
+ svc->op_action_map = NULL;
+ svc->op_rest_map = NULL;
+ svc->module_list = NULL;
+ svc->ns_map = NULL;
+ svc->ns_count = 0;
+ svc->schema_list = NULL;
+ svc->schema_mapping_table = NULL;
+ svc->schema_loc_adjusted = AXIS2_FALSE;
+ svc->custom_schema_name_prefix = NULL;
+ svc->custom_schema_name_suffix = NULL;
+ svc->schema_target_ns = NULL;
+ svc->schema_target_ns_prefix = NULL;
+ svc->target_ns = NULL;
+ svc->target_ns_prefix = NULL;
+ svc->sc_calc_count = 0;
+ svc->impl_class = NULL;
+ svc->qname = NULL;
+ svc->style = NULL;
+ svc->base = NULL;
+
+ svc->param_container = axutil_param_container_create(env);
+ if(!svc->param_container)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service param container creation failed");
+ return NULL;
+ }
+
+ svc->flow_container = axis2_flow_container_create(env);
+ if(!svc->flow_container)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service flow container creation failed");
+ return NULL;
+ }
+
+ svc->op_alias_map = axutil_hash_make(env);
+ if(!svc->op_alias_map)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation alias map creation failed");
+ return NULL;
+ }
+
+ svc->op_action_map = axutil_hash_make(env);
+ if(!svc->op_action_map)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation action map creation failed");
+ return NULL;
+ }
+
+ svc->op_rest_map = axutil_hash_make(env);
+ if(!svc->op_rest_map)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation rest map creation failed");
+ return NULL;
+ }
+
+ /** Create module list of default size */
+ svc->module_list = axutil_array_list_create(env, 0);
+ if(!svc->module_list)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service module list creation failed");
+ return NULL;
+ }
+
+ svc->schema_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+ if(!svc->schema_list)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service schema list creation failed");
+ return NULL;
+ }
+
+ svc->engaged_module_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+ if(!svc->engaged_module_list)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service engaged modules list creation failed");
+ return NULL;
+ }
+
+ svc->schema_loc_adjusted = AXIS2_FALSE;
+ if(svc->schema_target_ns_prefix)
+ {
+ AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix);
+ svc->schema_target_ns_prefix = NULL;
+ }
+ svc->schema_target_ns_prefix = axutil_strdup(env, "ns");
+
+ if(svc->target_ns)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns);
+ svc->target_ns = NULL;
+ }
+ svc->target_ns = axutil_strdup(env, "http://ws.apache.org/axis2");
+
+ if(svc->target_ns_prefix)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns_prefix);
+ svc->target_ns_prefix = NULL;
+ }
+ svc->target_ns_prefix = axutil_strdup(env, "tns");
+ svc->sc_calc_count = 0;
+
+ svc->base = axis2_desc_create(env);
+ if(!svc->base)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service base creation failed");
+ return NULL;
+ }
+ svc->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT);
+ if(!svc->mutex)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service mutex creation failed");
+ return NULL;
+ }
+ return svc;
+}
+
+AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
+axis2_svc_create_with_qname(
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ axis2_svc_t *svc = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_PARAM_CHECK(env->error, qname, NULL);
+
+ svc = axis2_svc_create(env);
+ if(!svc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service creation failed for name %s",
+ axutil_qname_get_localpart(qname, env));
+ return NULL;
+ }
+
+ status = axis2_svc_set_qname(svc, env, qname);
+ if(AXIS2_FAILURE == status)
+ {
+ axis2_svc_free(svc, env);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name %s to service failed",
+ axutil_qname_get_localpart(qname, env));
+ return NULL;
+ }
+
+ return svc;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_svc_free(
+ axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ if(svc->impl_class)
+ {
+ AXIS2_SVC_SKELETON_FREE((axis2_svc_skeleton_t *)svc->impl_class, env);
+ }
+ if(svc->param_container)
+ {
+ axutil_param_container_free(svc->param_container, env);
+ }
+
+ if(svc->flow_container)
+ {
+ axis2_flow_container_free(svc->flow_container, env);
+ }
+
+ if(svc->filename)
+ {
+ AXIS2_FREE(env->allocator, svc->filename);
+ svc->filename = NULL;
+ }
+
+ if(svc->svc_desc)
+ {
+ AXIS2_FREE(env->allocator, svc->svc_desc);
+ svc->svc_desc = NULL;
+ }
+
+ svc->parent = NULL;
+
+ if(svc->module_list)
+ {
+ int i = 0;
+ int size = 0;
+
+ size = axutil_array_list_size(svc->module_list, env);
+ for(i = 0; i < size; i++)
+ {
+ axutil_qname_t *qname = NULL;
+ qname = axutil_array_list_get(svc->module_list, env, i);
+ if(qname)
+ {
+ axutil_qname_free(qname, env);
+ }
+ }
+ axutil_array_list_free(svc->module_list, env);
+ }
+
+ if(svc->schema_list)
+ {
+ axutil_array_list_free(svc->schema_list, env);
+ }
+
+ if(svc->engaged_module_list)
+ {
+ axutil_array_list_free(svc->engaged_module_list, env);
+ }
+
+ if(svc->axis_svc_name)
+ {
+ AXIS2_FREE(env->allocator, svc->axis_svc_name);
+ svc->axis_svc_name = NULL;
+ }
+
+ if(svc->op_alias_map)
+ {
+ axutil_hash_index_t *hi = NULL;
+ void *val = NULL;
+
+ for(hi = axutil_hash_first(svc->op_alias_map, 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_FALSE)
+ {
+ axis2_op_free((axis2_op_t *)val, env);
+ }
+ val = NULL;
+ }
+ }
+
+ axutil_hash_free(svc->op_alias_map, env);
+ }
+
+ if(svc->op_action_map)
+ {
+ axutil_hash_index_t *hi = NULL;
+ const void *key = NULL;
+
+ for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ axutil_hash_this(hi, &key, NULL, NULL);
+
+ if(key)
+ {
+ AXIS2_FREE(env->allocator, (axis2_char_t *)key);
+ key = NULL;
+ }
+ }
+ axutil_hash_free(svc->op_action_map, env);
+ }
+
+ if(svc->op_rest_map)
+ {
+ axis2_core_utils_free_rest_map(env, svc->op_rest_map);
+ }
+
+ if(svc->schema_target_ns_prefix)
+ {
+ AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix);
+ svc->schema_target_ns_prefix = NULL;
+ }
+
+ if(svc->target_ns)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns);
+ svc->target_ns = NULL;
+ }
+
+ if(svc->wsdl_path)
+ {
+ AXIS2_FREE(env->allocator, svc->wsdl_path);
+ svc->wsdl_path = NULL;
+ }
+
+ if(svc->folder_path)
+ {
+ AXIS2_FREE(env->allocator, svc->folder_path);
+ svc->folder_path = NULL;
+ }
+
+ if(svc->target_ns_prefix)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns_prefix);
+ svc->target_ns_prefix = NULL;
+ }
+
+ if(svc->qname)
+ {
+ axutil_qname_free(svc->qname, env);
+ }
+
+ if(svc->style)
+ {
+ AXIS2_FREE(env->allocator, svc->style);
+ }
+
+ if(svc->base)
+ {
+ axis2_desc_free(svc->base, env);
+ }
+ if(svc->mutex)
+ {
+ axutil_thread_mutex_destroy(svc->mutex);
+ }
+ if(svc)
+ {
+ AXIS2_FREE(env->allocator, svc);
+ svc = NULL;
+ }
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_op(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axis2_op_t * op)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_msg_recv_t *msg_recv = NULL;
+ const axutil_qname_t *qname = NULL;
+ axis2_char_t *key = NULL;
+ const axis2_char_t *svcname = NULL;
+ axutil_array_list_t *mappings_list = NULL;
+ int size = 0;
+ int j = 0;
+
+ AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
+ svcname = axis2_svc_get_name(svc, env);
+ qname = axis2_op_get_qname(op, env);
+ if(qname)
+ key = axutil_qname_get_localpart(qname, env);
+ mappings_list = axis2_op_get_wsamapping_list(op, env);
+ /* Adding action mappings into service */
+ if(mappings_list)
+ size = axutil_array_list_size(mappings_list, env);
+ for(j = 0; j < size; j++)
+ {
+ axis2_char_t *mapping = NULL;
+
+ mapping = (axis2_char_t *)axutil_array_list_get(mappings_list, env, j);
+ status = axis2_svc_add_mapping(svc, env, mapping, op);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Adding operation %s to service %s mapping list failed", svcname, key);
+ return status;
+ }
+ }
+
+ status = axis2_op_set_parent(op, env, svc);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service %s as operation %s parent failed",
+ svcname, key);
+ return status;
+ }
+ msg_recv = axis2_op_get_msg_recv(op, env);
+ if(msg_recv == NULL)
+ {
+ msg_recv = axis2_desc_builder_load_default_msg_recv(env);
+ axis2_op_set_msg_recv(op, env, msg_recv);
+ }
+ if(key)
+ {
+ /* If service defines the operation, then we should not override with module level
+ * operation. Module operations are global. If any setting to be modified, those operations
+ * can be defined in service */
+ if(!axutil_hash_get(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING))
+ {
+ axutil_hash_set(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING, op);
+ }
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_svc_get_op_with_qname(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axutil_qname_t * op_qname)
+{
+ axis2_op_t *op = NULL;
+ axis2_char_t *nc_name = NULL;
+
+ axis2_char_t *nc_tmp = NULL;
+ /* This is just for the sake of comparison,
+ * and must not be used to change the passed value
+ */
+ axis2_bool_t is_matched = AXIS2_FALSE;
+
+ AXIS2_PARAM_CHECK(env->error, op_qname, NULL);
+
+ nc_name = axutil_qname_get_localpart(op_qname, env);
+ nc_tmp = nc_name;
+
+ op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING);
+ if(op)
+ {
+ return op;
+ }
+ op = axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING);
+ if(op)
+ {
+ return op;
+ }
+
+ if(*nc_tmp && svc->op_action_map)
+ {
+ axutil_hash_index_t *hi = NULL;
+ const void *key = NULL;
+
+ for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ axutil_hash_this(hi, &key, NULL, NULL);
+
+ nc_tmp = nc_name;
+
+ if(key)
+ {
+ axis2_char_t *search = NULL;
+ axis2_bool_t match_start = AXIS2_TRUE;
+ axis2_char_t *search_tmp = NULL;
+
+ search = (axis2_char_t *)key;
+
+ if(!axutil_strchr(search, '*'))
+ {
+ if(axutil_strstr(nc_tmp, search))
+ {
+ axis2_char_t *comp_tmp = NULL;
+
+ comp_tmp = axutil_strstr(nc_tmp, search);
+ if(strlen(comp_tmp) == strlen(search))
+ {
+ nc_tmp = (axis2_char_t *)key;
+ is_matched = AXIS2_TRUE;
+ break;
+ }
+ }
+ continue;
+ }
+
+ if(search[0] == '*')
+ {
+ search++;
+ if(!*search)
+ {
+ nc_tmp = (axis2_char_t *)key;
+ is_matched = AXIS2_TRUE;
+ break;
+ }
+ else if(axutil_strchr(search, '*'))
+ {
+ continue;
+ }
+ match_start = AXIS2_FALSE;
+ }
+ while(search && *search)
+ {
+ int length = 0;
+ axis2_char_t *loc_tmp = NULL;
+
+ if(search_tmp)
+ {
+ AXIS2_FREE(env->allocator, search_tmp);
+ search_tmp = NULL;
+ }
+ loc_tmp = axutil_strchr(search, '*');
+ if(loc_tmp && *loc_tmp)
+ {
+ if(!loc_tmp[1])
+ {
+ is_matched = AXIS2_TRUE;
+ break;
+ }
+ length = (int)(loc_tmp - search);
+ /* We are sure that the difference lies within the int range */
+ search_tmp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * (length + 1)));
+ strncpy(search_tmp, search, length);
+ search_tmp[length] = '\0';
+ }
+ else if(axutil_strstr(nc_tmp, search))
+ {
+ axis2_char_t *comp_tmp = NULL;
+
+ comp_tmp = axutil_strstr(nc_tmp, search);
+ if(strlen(comp_tmp) == strlen(search))
+ {
+ nc_tmp = (axis2_char_t *)key;
+ is_matched = AXIS2_TRUE;
+ break;
+ }
+ break;
+ }
+ else
+ {
+ break;
+ }
+ if(search_tmp && axutil_strstr(nc_tmp, search_tmp))
+ {
+ if(match_start && !(axutil_strncmp(nc_tmp, search, length) == 0))
+ {
+ break;
+ }
+ else if(!match_start)
+ {
+ match_start = AXIS2_TRUE;
+ }
+ }
+ else
+ {
+ break;
+ }
+ search += axutil_strlen(search_tmp) + 1;
+ nc_tmp = axutil_strstr(nc_tmp, search_tmp) + axutil_strlen(search_tmp);
+ }
+ if(search_tmp)
+ {
+ AXIS2_FREE(env->allocator, search_tmp);
+ search_tmp = NULL;
+ }
+ if(is_matched || !*search)
+ {
+ nc_tmp = (axis2_char_t *)key;
+ is_matched = AXIS2_TRUE;
+ break;
+ }
+ }
+ }
+ }
+ if(!is_matched)
+ {
+ nc_tmp = nc_name;
+ }
+
+ op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING);
+ if(op)
+ {
+ return op;
+ }
+ return (axis2_op_t *)axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_get_rest_op_list_with_method_and_location(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * method,
+ const axis2_char_t * location)
+{
+ axutil_array_list_t *op_list = NULL;
+ axis2_char_t *key = NULL;
+ axis2_char_t *loc_str = NULL;
+ axis2_char_t *loc_str_tmp = NULL;
+ axis2_char_t *rindex = NULL;
+ int plen;
+
+ AXIS2_PARAM_CHECK(env->error, method, NULL);
+ AXIS2_PARAM_CHECK(env->error, location, NULL);
+
+ loc_str_tmp = (axis2_char_t *)location; /* Casted to facilitate loop */
+ if(loc_str_tmp[1] == '/')
+ {
+ loc_str_tmp++;
+ } /* ignore any '/' at the beginning */
+ if(strchr(loc_str_tmp, '?'))
+ {
+ axis2_char_t *temp = NULL;
+
+ temp = strchr(loc_str_tmp, '?');
+ temp[0] = '\0';
+ } /* ignore block after '?' */
+ do
+ {
+ axis2_char_t *temp = NULL;
+ temp = strchr(loc_str_tmp, '{');
+ if(temp)
+ {
+ loc_str_tmp = temp;
+ }
+ else
+ {
+ loc_str_tmp += strlen(loc_str_tmp);
+ break;
+ }
+ }
+ while(loc_str_tmp[1] && loc_str_tmp[1] == '{');
+
+ loc_str = (axis2_char_t *)axutil_strmemdup(location, (loc_str_tmp - location), env);
+
+ rindex = axutil_rindex(loc_str, '/');
+ if(rindex && *rindex)
+ {
+ loc_str_tmp = axutil_string_substring_ending_at(loc_str, (int)(rindex - loc_str));
+ /* We are sure that the difference lies within the int range */
+ }
+ else
+ {
+ loc_str_tmp = loc_str;
+ }
+
+ plen = axutil_strlen(method) + axutil_strlen(loc_str_tmp) + 2;
+ key = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * plen));
+ sprintf(key, "%s:%s", method, loc_str_tmp);
+ AXIS2_FREE(env->allocator, loc_str);
+ op_list = (axutil_array_list_t *)axutil_hash_get(svc->op_rest_map, key, AXIS2_HASH_KEY_STRING);
+ AXIS2_FREE(env->allocator, key);
+ return op_list;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_svc_get_op_with_name(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * nc_name)
+{
+ AXIS2_PARAM_CHECK(env->error, nc_name, NULL);
+
+ return (axis2_op_t *)axutil_hash_get(svc->op_alias_map, nc_name, AXIS2_HASH_KEY_STRING);
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_svc_get_all_ops(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->op_alias_map;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_parent(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axis2_svc_grp_t * svc_grp)
+{
+ AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE);
+
+ svc->parent = svc_grp;
+ if(svc_grp)
+ {
+ axis2_desc_set_parent(svc->base, env, axis2_svc_grp_get_base(svc_grp, env));
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
+axis2_svc_get_parent(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_qname(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
+ if(svc->qname)
+ {
+ axutil_qname_free(svc->qname, env);
+ }
+
+ if(qname)
+ {
+ svc->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL
+axis2_svc_get_qname(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->qname;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_param(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ axis2_char_t *paramname = NULL;
+ const axis2_char_t *svcname = axis2_svc_get_name(svc, env);
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+ paramname = axutil_param_get_name(param, env);
+
+ if(axis2_svc_is_param_locked(svc, env, axutil_param_get_name(param, env)))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for service %s", paramname,
+ svcname);
+ return AXIS2_FAILURE;
+ }
+ return axutil_param_container_add_param(svc->param_container, env, param);
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_svc_get_param(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ axutil_param_t *param = NULL;
+ AXIS2_PARAM_CHECK(env->error, name, NULL);
+
+ param = axutil_param_container_get_param(svc->param_container, env, name);
+ if(!param && svc->parent)
+ {
+ param = axis2_svc_grp_get_param(svc->parent, env, name);
+ }
+ return param;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_remove_param(
+ const axis2_svc_t *svc,
+ const axutil_env_t *env,
+ const axis2_char_t *param_name)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ status = axutil_param_container_delete_param(svc->param_container, env, param_name);
+ return status;
+}
+
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_get_all_params(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return axutil_param_container_get_params(svc->param_container, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_svc_is_param_locked(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axis2_bool_t locked = AXIS2_FALSE;
+ axutil_param_t *param = NULL;
+ axis2_svc_grp_t *parent = NULL;
+ axis2_bool_t ret = AXIS2_FALSE;
+
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
+
+ /* Checking the locked value of parent */
+
+ parent = axis2_svc_get_parent(svc, env);
+ if(parent)
+ locked = axis2_svc_grp_is_param_locked(parent, env, param_name);
+ if(parent && locked)
+ {
+ return AXIS2_TRUE;
+ }
+ param = axis2_svc_get_param(svc, env, param_name);
+ if(param)
+ {
+ ret = axutil_param_is_locked(param, env);
+ }
+ return ret;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_engage_module(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc,
+ axis2_conf_t * conf)
+{
+ axis2_phase_resolver_t *phase_resolver = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ const axis2_char_t *svcname = NULL;
+
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_engage_module");
+
+ AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
+
+ svcname = axis2_svc_get_name(svc, env);
+ phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
+ if(!phase_resolver)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
+ svcname);
+
+ return AXIS2_FAILURE;
+ }
+
+ status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, svc, module_desc);
+ if(status)
+ {
+ const axutil_qname_t *qname = NULL;
+ status = axutil_array_list_add(svc->engaged_module_list, env, module_desc);
+ qname = axis2_module_desc_get_qname(module_desc, env);
+ axis2_svc_add_module_qname(svc, env, qname);
+ }
+
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_engage_module");
+
+ return status;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_svc_is_module_engaged(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axutil_qname_t * module_qname)
+{
+ int i = 0, size = 0;
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_is_module_engaged");
+ size = axutil_array_list_size(svc->engaged_module_list, env);
+ for(i = 0; i < size; i++)
+ {
+ const axutil_qname_t *module_qname_l = NULL;
+ axis2_module_desc_t *module_desc_l = NULL;
+
+ module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(svc->engaged_module_list, env,
+ i);
+ module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
+
+ if(axutil_qname_equals(module_qname, env, module_qname_l))
+ {
+ return AXIS2_TRUE;
+ }
+ }
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_is_module_engaged");
+ return AXIS2_FALSE;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_get_engaged_module_list(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->engaged_module_list;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_disengage_module(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc,
+ axis2_conf_t * conf)
+{
+ axis2_phase_resolver_t *phase_resolver = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ const axis2_char_t *svcname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
+ svcname = axis2_svc_get_name(svc, env);
+
+ phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
+ if(!phase_resolver)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
+ svcname);
+ return AXIS2_FAILURE;
+ }
+ status = axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc, module_desc);
+
+ axis2_phase_resolver_free(phase_resolver, env);
+
+ return status;
+}
+
+/**
+ * Here we extract all operations defined in module.xml and built execution
+ * chains for them by calling axis2_phase_resolver_build_execution_chains_for_module_op()
+ * function. Within that function handlers of the modules defined for that
+ * operation are added to module operation chains appropriately.
+ */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_module_ops(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc,
+ axis2_conf_t * conf)
+{
+ axutil_hash_t *map = NULL;
+ axutil_hash_index_t *index = NULL;
+ axis2_phase_resolver_t *phase_resolver = NULL;
+ axis2_op_t *op_desc = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ const axis2_char_t *svcname = NULL;
+ axis2_char_t *modname = NULL;
+ axis2_char_t *opname = NULL;
+
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_add_module_ops");
+ AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
+ svcname = axis2_svc_get_name(svc, env);
+ modname = axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc, env), env);
+ map = axis2_module_desc_get_all_ops(module_desc, env);
+ phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc);
+ if(!phase_resolver)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
+ svcname);
+ return AXIS2_FAILURE;
+ }
+ for(index = axutil_hash_first(map, env); index; index = axutil_hash_next(env, index))
+ {
+ void *v = NULL;
+ axutil_hash_this(index, NULL, NULL, &v);
+ op_desc = (axis2_op_t *)v;
+ opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
+ status = axis2_phase_resolver_build_execution_chains_for_module_op(phase_resolver, env,
+ op_desc);
+
+ if(AXIS2_SUCCESS != status)
+ {
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Builidng module operation %s failed for module %s", opname, modname);
+ return status;
+ }
+
+ status = axis2_svc_add_op(svc, env, op_desc);
+ if(AXIS2_SUCCESS != status)
+ {
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding operation %s to service %s failed",
+ opname, svcname);
+ return status;
+ }
+
+ }
+
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_add_module_ops");
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_name(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ if(svc->qname)
+ {
+ return axutil_qname_get_localpart(svc->qname, env);
+ }
+
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_name(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * axis_svc_name)
+{
+ AXIS2_PARAM_CHECK(env->error, axis_svc_name, AXIS2_FAILURE);
+
+ if(svc->axis_svc_name)
+ {
+ AXIS2_FREE(env->allocator, svc->axis_svc_name);
+ svc->axis_svc_name = NULL;
+ }
+ svc->axis_svc_name = axutil_strdup(env, axis_svc_name);
+ if(!svc->axis_svc_name)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_last_update(
+ axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN long AXIS2_CALL
+axis2_svc_get_last_update(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->last_update;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_file_name(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->filename;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_file_name(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * filename)
+{
+ AXIS2_PARAM_CHECK(env->error, filename, AXIS2_FAILURE);
+
+ if(svc->filename)
+ {
+ AXIS2_FREE(env->allocator, svc->filename);
+ svc->filename = NULL;
+ }
+ svc->filename = (axis2_char_t *)axutil_strdup(env, filename);
+ if(!svc->filename)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_svc_desc(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->svc_desc;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_svc_desc(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * svc_desc)
+{
+ AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE);
+
+ if(svc->svc_desc)
+ {
+ AXIS2_FREE(env->allocator, svc->svc_desc);
+ svc->svc_desc = NULL;
+ }
+ svc->svc_desc = (axis2_char_t *)axutil_strdup(env, svc_desc);
+ if(!svc->svc_desc)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_mapping(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * mapping_key,
+ axis2_op_t * op_desc)
+{
+ AXIS2_PARAM_CHECK(env->error, mapping_key, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);
+
+ axutil_hash_set(svc->op_action_map, axutil_strdup(env, mapping_key), AXIS2_HASH_KEY_STRING,
+ op_desc);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_rest_mapping(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * method,
+ const axis2_char_t * location,
+ axis2_op_t * op_desc)
+{
+
+ axis2_char_t *mapping_url = NULL;
+ int key_len = 0;
+ axis2_char_t* question_char = NULL;
+ axis2_char_t* local_location_str = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
+
+ local_location_str = (axis2_char_t *)location; /* Casted to facilitate loop */
+
+ /* skip the beginning '/' */
+ if(*local_location_str == '/')
+ {
+ local_location_str++;
+ }
+ question_char = axutil_strchr(local_location_str, '?');
+ if(question_char)
+ {
+ *question_char = '\0';
+ }
+
+ key_len = axutil_strlen(method) + axutil_strlen(local_location_str) + 2;
+
+ mapping_url = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * key_len));
+ if(!mapping_url)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the rest mapping url");
+ return AXIS2_FAILURE;
+ }
+
+ sprintf(mapping_url, "%s:%s", method, local_location_str);
+
+ status = axis2_core_utils_prepare_rest_mapping(env, mapping_url, svc->op_rest_map, op_desc);
+
+ if(mapping_url)
+ {
+ AXIS2_FREE(env->allocator, mapping_url);
+ }
+
+ /* restore the question character */
+ if(question_char)
+ {
+ *question_char = '?';
+ }
+
+ return status;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_add_module_qname(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axutil_qname_t * module_qname)
+{
+ axutil_qname_t *qmodule_qname_l = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
+
+ qmodule_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env);
+ return axutil_array_list_add(svc->module_list, env, qmodule_qname_l);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_get_all_module_qnames(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->module_list;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_target_ns(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->target_ns;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_target_ns(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * ns)
+{
+ AXIS2_PARAM_CHECK(env->error, ns, AXIS2_FAILURE);
+
+ if(svc->target_ns)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns);
+ svc->target_ns = NULL;
+ }
+ svc->target_ns = axutil_strdup(env, ns);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_target_ns_prefix(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->target_ns_prefix;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_target_ns_prefix(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * prefix)
+{
+ AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE);
+
+ if(svc->target_ns_prefix)
+ {
+ AXIS2_FREE(env->allocator, svc->target_ns_prefix);
+ svc->target_ns_prefix = NULL;
+ }
+ svc->target_ns_prefix = axutil_strdup(env, prefix);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_svc_get_ns_map(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->ns_map;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_ns_map(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axutil_hash_t * ns_map)
+{
+ axutil_hash_index_t *hi = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ns_map, AXIS2_FAILURE);
+
+ if(svc->ns_map)
+ {
+ for(hi = axutil_hash_first(svc->ns_map, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ void *value = NULL;
+ void *key = NULL;
+ axutil_hash_this(hi, (const void **)&key, NULL, (void **)&value);
+ if(key)
+ {
+ AXIS2_FREE(env->allocator, key);
+ key = NULL;
+ }
+ if(value)
+ {
+ AXIS2_FREE(env->allocator, value);
+ value = NULL;
+ }
+ }
+ axutil_hash_free(svc->ns_map, env);
+ }
+ svc->ns_map = ns_map;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_svc_swap_mapping_table(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ axutil_hash_t * orig_table)
+{
+ axutil_hash_t *new_table = NULL;
+ axutil_hash_index_t *hi = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, orig_table, NULL);
+
+ new_table = axutil_hash_make(env);
+
+ for(hi = axutil_hash_first(orig_table, env); env; hi = axutil_hash_next(env, hi))
+ {
+ void *value = NULL;
+ void *key = NULL;
+
+ axutil_hash_this(hi, (const void **)&key, NULL, (void **)&value);
+ axutil_hash_set(new_table, value, AXIS2_HASH_KEY_STRING, key);
+ }
+ return new_table;
+}
+
+AXIS2_EXTERN void *AXIS2_CALL
+axis2_svc_get_impl_class(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->impl_class;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_impl_class(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ void *impl_class)
+{
+ svc->impl_class = impl_class;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_svc_get_param_container(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->param_container;
+}
+
+AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
+axis2_svc_get_flow_container(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->flow_container;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_svc_wsdl_path(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->wsdl_path;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_svc_wsdl_path(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * wsdl_path)
+{
+ AXIS2_PARAM_CHECK(env->error, wsdl_path, AXIS2_FAILURE);
+ svc->wsdl_path = (axis2_char_t *)axutil_strdup(env, wsdl_path);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_get_svc_folder_path(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->folder_path;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_set_svc_folder_path(
+ axis2_svc_t * svc,
+ const axutil_env_t * env,
+ const axis2_char_t * folder_path)
+{
+ AXIS2_PARAM_CHECK(env->error, folder_path, AXIS2_FAILURE);
+ svc->folder_path = (axis2_char_t *)axutil_strdup(env, folder_path);
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_svc_get_base(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->base;
+}
+
+AXIS2_EXTERN axutil_thread_mutex_t * AXIS2_CALL
+axis2_svc_get_mutex(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->mutex;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_svc_get_rest_map(
+ const axis2_svc_t * svc,
+ const axutil_env_t * env)
+{
+ return svc->op_rest_map;
+}
+
diff --git a/src/core/description/svc_grp.c b/src/core/description/svc_grp.c
new file mode 100644
index 0000000..157b77a
--- /dev/null
+++ b/src/core/description/svc_grp.c
@@ -0,0 +1,600 @@
+/*
+ * 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.h>
+#include <axis2_conf_ctx.h>
+
+struct axis2_svc_grp
+{
+
+ /** service group name */
+ axis2_char_t *svc_grp_name;
+
+ /** map of services */
+ axutil_hash_t *svcs;
+
+ /** to store service group modules QNames */
+ axutil_array_list_t *module_qname_list;
+
+ /** to store module ref at deploy time parsing */
+ axis2_conf_t *parent;
+
+ /** list of module references */
+ axutil_array_list_t *module_list;
+
+ /** parameter container to hold service related parameters */
+ axutil_param_container_t *param_container;
+
+ /** base description struct */
+ axis2_desc_t *base;
+};
+
+AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
+axis2_svc_grp_create(
+ const axutil_env_t * env)
+{
+ axis2_svc_grp_t *svc_grp = NULL;
+ svc_grp = (axis2_svc_grp_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_t));
+
+ if(!svc_grp)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
+ return NULL;
+ }
+
+ svc_grp->param_container = NULL;
+ svc_grp->module_qname_list = NULL;
+ svc_grp->svcs = NULL;
+ svc_grp->parent = NULL;
+ svc_grp->svc_grp_name = NULL;
+ svc_grp->module_list = NULL;
+ svc_grp->base = NULL;
+
+ svc_grp->param_container = axutil_param_container_create(env);
+ if(!svc_grp->param_container)
+ {
+ axis2_svc_grp_free(svc_grp, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating parameter container failed");
+ return NULL;
+ }
+
+ svc_grp->module_qname_list = axutil_array_list_create(env, 20);
+ if(!svc_grp->module_qname_list)
+ {
+ axis2_svc_grp_free(svc_grp, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating module qnames list failed");
+ return NULL;
+ }
+
+ svc_grp->module_list = axutil_array_list_create(env, 0);
+ if(!svc_grp->module_list)
+ {
+ axis2_svc_grp_free(svc_grp, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating modules list failed");
+ return NULL;
+ }
+
+ svc_grp->svcs = axutil_hash_make(env);
+ if(!svc_grp->svcs)
+ {
+ axis2_svc_grp_free(svc_grp, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating services map failed");
+ return NULL;
+ }
+
+ svc_grp->base = axis2_desc_create(env);
+ if(!svc_grp->base)
+ {
+ axis2_svc_grp_free(svc_grp, env);
+ return NULL;
+ }
+
+ return svc_grp;
+}
+
+AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
+axis2_svc_grp_create_with_conf(
+ const axutil_env_t * env,
+ axis2_conf_t * conf)
+{
+ axis2_svc_grp_t *svc_grp = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, conf, NULL);
+
+ svc_grp = (axis2_svc_grp_t *)axis2_svc_grp_create(env);
+ if(svc_grp)
+ svc_grp->parent = conf;
+ if(conf)
+ {
+ axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(conf, env));
+ }
+
+ return svc_grp;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_svc_grp_free(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ if(svc_grp->param_container)
+ {
+ axutil_param_container_free(svc_grp->param_container, env);
+ }
+
+ if(svc_grp->svc_grp_name)
+ {
+ AXIS2_FREE(env->allocator, svc_grp->svc_grp_name);
+ }
+
+ if(svc_grp->svcs)
+ {
+ /* services are freed by arch_file_data */
+ axutil_hash_free(svc_grp->svcs, env);
+ }
+
+ if(svc_grp->module_qname_list)
+ {
+ axutil_array_list_free(svc_grp->module_qname_list, env);
+ }
+
+ if(svc_grp->module_list)
+ {
+ axutil_array_list_free(svc_grp->module_list, env);
+ }
+
+ if(svc_grp->base)
+ {
+ axis2_desc_free(svc_grp->base, env);
+ }
+
+ if(svc_grp)
+ {
+ AXIS2_FREE(env->allocator, svc_grp);
+ }
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_set_name(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ if(svc_grp->svc_grp_name)
+ AXIS2_FREE(env->allocator, svc_grp->svc_grp_name);
+ svc_grp->svc_grp_name = axutil_strdup(env, name);
+ if(!svc_grp->svc_grp_name)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No Memory");
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_svc_grp_get_name(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->svc_grp_name;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_add_svc(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ axis2_svc_t * svc)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ const axutil_qname_t *svc_qname = NULL;
+ axis2_char_t *svc_name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE);
+
+ if(!svc_grp->svcs)
+ {
+ svc_grp->svcs = axutil_hash_make(env);
+ if(!svc_grp->svcs)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating services list failed");
+ return AXIS2_FAILURE;
+ }
+ }
+
+ svc_qname = axis2_svc_get_qname(svc, env);
+ svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env);
+ axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, svc);
+
+ status = axis2_svc_set_last_update(svc, env);
+
+ if(AXIS2_SUCCESS != status)
+ {
+ /* remove the previously added service */
+ axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting last update failed for service %s",
+ svc_name);
+
+ return status;
+ }
+
+ status = axis2_svc_set_parent(svc, env, svc_grp);
+ if(AXIS2_SUCCESS != status)
+ {
+ /* remove the previously added service */
+ axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting parent failed for service %s", svc_name);
+
+ return status;
+ }
+
+ return status;
+}
+
+AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
+axis2_svc_grp_get_svc(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ axis2_char_t *name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, qname, NULL);
+
+ name = axutil_qname_to_string((axutil_qname_t *)qname, env);
+ return (axis2_svc_t *)axutil_hash_get(svc_grp->svcs, name, AXIS2_HASH_KEY_STRING);
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_svc_grp_get_all_svcs(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->svcs;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_remove_svc(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axutil_qname_t * svc_qname)
+{
+ axis2_svc_t *svc = NULL;
+ axis2_char_t *svc_name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, svc_name, AXIS2_FAILURE);
+
+ svc = axis2_svc_grp_get_svc(svc_grp, env, svc_qname);
+
+ svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env);
+ axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_add_param(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ const axis2_char_t *svc_grp_name = axis2_svc_grp_get_name(svc_grp, env);
+ axis2_char_t *param_name = axutil_param_get_name(param, env);
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+ if(axis2_svc_grp_is_param_locked(svc_grp, env, param_name))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for service group %s",
+ param_name, svc_grp_name);
+ return AXIS2_FAILURE;
+ }
+ return axutil_param_container_add_param(svc_grp->param_container, env, param);
+}
+
+AXIS2_EXTERN axutil_param_t *AXIS2_CALL
+axis2_svc_grp_get_param(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axis2_char_t * name)
+{
+ axutil_param_t *param = NULL;
+ AXIS2_PARAM_CHECK(env->error, name, NULL);
+
+ param = axutil_param_container_get_param(svc_grp->param_container, env, name);
+ if(!param && svc_grp->parent)
+ {
+ param = axis2_conf_get_param(svc_grp->parent, env, name);
+ }
+ return param;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_remove_param(
+ const axis2_svc_grp_t *svc_grp,
+ const axutil_env_t *env,
+ const axis2_char_t *param_name)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ status = axutil_param_container_delete_param(svc_grp->param_container, env, param_name);
+ return status;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_grp_get_all_params(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return axutil_param_container_get_params(svc_grp->param_container, env);
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_svc_grp_is_param_locked(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ axis2_bool_t locked = AXIS2_FALSE;
+ axis2_conf_t *parent = NULL;
+ axutil_param_t *param = NULL;
+ axis2_bool_t ret = AXIS2_FALSE;
+
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
+
+ parent = axis2_svc_grp_get_parent(svc_grp, env);
+ /* Checking the locked value of parent */
+ if(parent)
+ {
+ locked = axis2_conf_is_param_locked(parent, env, param_name);
+ }
+ if(locked)
+ {
+ ret = AXIS2_TRUE;
+ }
+ param = axis2_svc_grp_get_param(svc_grp, env, param_name);
+ if(param && axutil_param_is_locked(param, env))
+ {
+ ret = AXIS2_TRUE;
+ }
+ else
+ {
+ ret = AXIS2_FALSE;
+ }
+ return ret;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_add_module_qname(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axutil_qname_t * module_qname)
+{
+ return axutil_array_list_add(svc_grp->module_qname_list, env, module_qname);
+}
+
+AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
+axis2_svc_grp_get_parent(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->parent;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_set_parent(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ axis2_conf_t * parent)
+{
+ AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
+
+ if(svc_grp->parent)
+ axis2_conf_free(svc_grp->parent, env);
+ svc_grp->parent = parent;
+ if(parent)
+ {
+ axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(parent, env));
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_engage_module(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axutil_qname_t * module_name)
+{
+ int i = 0;
+ axis2_status_t status = AXIS2_FAILURE;
+ axutil_qname_t *modu = NULL;
+ axis2_char_t *modu_local = NULL;
+ axis2_char_t *module_name_local = NULL;
+ axutil_hash_t *svc_map = NULL;
+ axis2_phase_resolver_t *phase_resolver = NULL;
+ axis2_module_desc_t *module = NULL;
+ const axis2_char_t *svc_grp_name = axis2_svc_grp_get_name(svc_grp, env);
+
+ int size = 0;
+
+ AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE);
+
+ size = axutil_array_list_size(svc_grp->module_qname_list, env);
+ for(i = 0; size; i++)
+ {
+ modu = axutil_array_list_get(svc_grp->module_qname_list, env, i);
+ modu_local = axutil_qname_get_localpart(modu, env);
+ module_name_local = axutil_qname_get_localpart(module_name, env);
+ if(!axutil_strcmp(modu_local, module_name_local))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC_GRP,
+ AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Module %s is already engaged to service group %s", module_name_local, svc_grp_name);
+
+ return AXIS2_FAILURE;
+ }
+ }
+
+ svc_map = axis2_svc_grp_get_all_svcs(svc_grp, env);
+ if(!svc_map)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service map not found for service group %s",
+ svc_grp_name);
+
+ return AXIS2_FAILURE;
+ }
+
+ phase_resolver = axis2_phase_resolver_create_with_config(env, svc_grp->parent);
+
+ if(!phase_resolver)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Creating phase resolver failed for service group %s", svc_grp_name);
+
+ return AXIS2_FAILURE;
+ }
+
+ module = axis2_conf_get_module(svc_grp->parent, env, module_name);
+ if(module)
+ {
+ axis2_svc_t *axis_svc = NULL;
+ axutil_hash_index_t *index = NULL;
+
+ index = axutil_hash_first(svc_map, env);
+ while(index)
+ {
+ const axis2_char_t *svc_name = NULL;
+ void *v = NULL;
+ /* engage in per each service */
+ axutil_hash_this(index, NULL, NULL, &v);
+ axis_svc = (axis2_svc_t *)v;
+ svc_name = axis2_svc_get_name(axis_svc, env);
+ status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, axis_svc,
+ module);
+
+ if(!status)
+ {
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to service %s failed",
+ module_name_local, svc_name);
+
+ return status;
+ }
+
+ index = axutil_hash_next(env, index);
+ }
+ }
+
+ if(phase_resolver)
+ {
+ axis2_phase_resolver_free(phase_resolver, env);
+ }
+
+ return axis2_svc_grp_add_module_qname(svc_grp, env, module_name);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_grp_get_all_module_qnames(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->module_qname_list;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_svc_grp_add_module_ref(
+ axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ const axutil_qname_t * moduleref)
+{
+ const axis2_char_t *svc_grp_name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
+ svc_grp_name = axis2_svc_grp_get_name(svc_grp, env);
+
+ if(!svc_grp->module_list)
+ {
+ svc_grp->module_list = axutil_array_list_create(env, 0);
+ if(!svc_grp->module_list)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Creating module list failed for service group %s", svc_grp_name);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return axutil_array_list_add(svc_grp->module_list, env, moduleref);
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_svc_grp_get_all_module_refs(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->module_list;
+}
+
+AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL
+axis2_svc_grp_get_svc_grp_ctx(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env,
+ axis2_conf_ctx_t * parent)
+{
+ axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
+ const axis2_char_t *svc_grp_name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, parent, NULL);
+ svc_grp_name = axis2_svc_grp_get_name(svc_grp, env);
+
+ svc_grp_ctx = axis2_svc_grp_ctx_create(env, (axis2_svc_grp_t *)svc_grp, parent);
+ if(!svc_grp_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Creating service group context failed for service group %s", svc_grp_name);
+ return NULL;
+ }
+
+ return svc_grp_ctx;
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_svc_grp_get_param_container(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->param_container;
+}
+
+AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
+axis2_svc_grp_get_base(
+ const axis2_svc_grp_t * svc_grp,
+ const axutil_env_t * env)
+{
+ return svc_grp->base;
+}
+
diff --git a/src/core/description/transport_in_desc.c b/src/core/description/transport_in_desc.c
new file mode 100644
index 0000000..85885b6
--- /dev/null
+++ b/src/core/description/transport_in_desc.c
@@ -0,0 +1,305 @@
+/*
+ * 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_transport_in_desc.h>
+#include <axis2_transport_receiver.h>
+
+struct axis2_transport_in_desc
+{
+ axis2_flow_t *in_flow;
+ axis2_flow_t *fault_in_flow;
+ AXIS2_TRANSPORT_ENUMS trans_enum;
+
+ /**
+ * transport receiver will have a shallow copy, but will be freed by
+ * free function.
+ */
+ axis2_transport_receiver_t *recv;
+ axis2_phase_t *in_phase;
+ axis2_phase_t *fault_phase;
+
+ /** parameter container to hold transport in related parameters */
+ axutil_param_container_t *param_container;
+};
+
+AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL
+axis2_transport_in_desc_create(
+ const axutil_env_t * env,
+ const AXIS2_TRANSPORT_ENUMS trans_enum)
+{
+ axis2_transport_in_desc_t *transport_in = NULL;
+
+ transport_in = (axis2_transport_in_desc_t *)AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_transport_in_desc_t));
+
+ if(!transport_in)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ transport_in->trans_enum = trans_enum;
+ transport_in->in_phase = NULL;
+ transport_in->fault_phase = NULL;
+ transport_in->in_flow = NULL;
+ transport_in->fault_in_flow = NULL;
+ transport_in->recv = NULL;
+ transport_in->param_container = NULL;
+
+ transport_in->param_container = axutil_param_container_create(env);
+ if(!transport_in->param_container)
+ {
+ axis2_transport_in_desc_free(transport_in, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return transport_in;
+}
+
+void AXIS2_CALL
+axis2_transport_in_desc_free(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ if(transport_in->recv)
+ {
+ axis2_transport_receiver_free(transport_in->recv, env);
+ }
+
+ if(transport_in->param_container)
+ {
+ axutil_param_container_free(transport_in->param_container, env);
+ }
+
+ if(transport_in->in_flow)
+ {
+ axis2_flow_free(transport_in->in_flow, env);
+ }
+
+ if(transport_in->fault_in_flow)
+ {
+ axis2_flow_free(transport_in->fault_in_flow, env);
+ }
+
+ if(transport_in->in_phase)
+ {
+ axis2_phase_free(transport_in->in_phase, env);
+ }
+
+ if(transport_in->fault_phase)
+ {
+ axis2_phase_free(transport_in->fault_phase, env);
+ }
+
+ AXIS2_FREE(env->allocator, transport_in);
+
+ return;
+}
+
+void AXIS2_CALL
+axis2_transport_in_desc_free_void_arg(
+ void *transport_in,
+ const axutil_env_t * env)
+{
+ axis2_transport_in_desc_t *transport_in_l = NULL;
+
+ transport_in_l = (axis2_transport_in_desc_t *)transport_in;
+ axis2_transport_in_desc_free(transport_in_l, env);
+ return;
+}
+
+AXIS2_TRANSPORT_ENUMS AXIS2_CALL
+axis2_transport_in_desc_get_enum(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->trans_enum;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_enum(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ const AXIS2_TRANSPORT_ENUMS trans_enum)
+{
+ transport_in->trans_enum = trans_enum;
+ return AXIS2_SUCCESS;
+}
+
+axis2_flow_t *AXIS2_CALL
+axis2_transport_in_desc_get_in_flow(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->in_flow;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_in_flow(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ axis2_flow_t * in_flow)
+{
+ AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE);
+
+ if(transport_in->in_flow)
+ {
+ axis2_flow_free(transport_in->in_flow, env);
+ }
+ transport_in->in_flow = in_flow;
+ return AXIS2_SUCCESS;
+}
+
+axis2_flow_t *AXIS2_CALL
+axis2_transport_in_desc_get_fault_in_flow(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->fault_in_flow;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_fault_in_flow(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ axis2_flow_t * fault_in_flow)
+{
+ AXIS2_PARAM_CHECK(env->error, fault_in_flow, AXIS2_FAILURE);
+
+ if(transport_in->fault_in_flow)
+ {
+ axis2_flow_free(transport_in->fault_in_flow, env);
+ }
+ transport_in->fault_in_flow = fault_in_flow;
+ return AXIS2_SUCCESS;
+}
+
+axis2_transport_receiver_t *AXIS2_CALL
+axis2_transport_in_desc_get_recv(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->recv;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_recv(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ axis2_transport_receiver_t * recv)
+{
+ AXIS2_PARAM_CHECK(env->error, recv, AXIS2_FAILURE);
+
+ if(transport_in->recv)
+ {
+ axis2_transport_receiver_free(transport_in->recv, env);
+ }
+
+ transport_in->recv = recv;
+ return AXIS2_SUCCESS;
+}
+
+axis2_phase_t *AXIS2_CALL
+axis2_transport_in_desc_get_in_phase(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->in_phase;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_in_phase(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ axis2_phase_t * in_phase)
+{
+ AXIS2_PARAM_CHECK(env->error, in_phase, AXIS2_FAILURE);
+
+ if(transport_in->in_phase)
+ {
+ axis2_phase_free(transport_in->in_phase, env);
+ }
+ transport_in->in_phase = in_phase;
+ return AXIS2_SUCCESS;
+}
+
+axis2_phase_t *AXIS2_CALL
+axis2_transport_in_desc_get_fault_phase(
+ const axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env)
+{
+ return transport_in->fault_phase;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_set_fault_phase(
+ axis2_transport_in_desc_t * transport_in,
+ const axutil_env_t * env,
+ axis2_phase_t * fault_phase)
+{
+ AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE);
+
+ if(transport_in->fault_phase)
+ {
+ axis2_phase_free(transport_in->fault_phase, env);
+ }
+ transport_in->fault_phase = fault_phase;
+ return AXIS2_SUCCESS;
+
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_in_desc_add_param(
+ axis2_transport_in_desc_t * transport_in_desc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+
+ return axutil_param_container_add_param(transport_in_desc-> param_container, env, param);
+}
+
+axutil_param_t *AXIS2_CALL
+axis2_transport_in_desc_get_param(
+ const axis2_transport_in_desc_t * transport_in_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ return axutil_param_container_get_param(transport_in_desc->param_container, env, param_name);
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_transport_in_desc_is_param_locked(
+ axis2_transport_in_desc_t * transport_in_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
+
+ return axutil_param_container_is_param_locked(transport_in_desc-> param_container, env,
+ param_name);
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_transport_in_desc_param_container(
+ const axis2_transport_in_desc_t * transport_in_desc,
+ const axutil_env_t * env)
+{
+ return transport_in_desc->param_container;
+}
+
diff --git a/src/core/description/transport_out_desc.c b/src/core/description/transport_out_desc.c
new file mode 100644
index 0000000..ec69f56
--- /dev/null
+++ b/src/core/description/transport_out_desc.c
@@ -0,0 +1,299 @@
+/*
+ * 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_transport_out_desc.h>
+
+struct axis2_transport_out_desc
+{
+ axis2_flow_t *out_flow;
+ axis2_flow_t *fault_out_flow;
+ AXIS2_TRANSPORT_ENUMS trans_enum;
+ axis2_transport_sender_t *sender;
+ axis2_phase_t *out_phase;
+ axis2_phase_t *fault_phase;
+
+ /** parameter container that holds parameter */
+ axutil_param_container_t *param_container;
+};
+
+AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL
+axis2_transport_out_desc_create(
+ const axutil_env_t * env,
+ const AXIS2_TRANSPORT_ENUMS trans_enum)
+{
+ axis2_transport_out_desc_t *transport_out = NULL;
+
+ transport_out = (axis2_transport_out_desc_t *)AXIS2_MALLOC(env-> allocator,
+ sizeof(axis2_transport_out_desc_t));
+
+ if(!transport_out)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ transport_out->trans_enum = trans_enum;
+ transport_out->out_phase = NULL;
+ transport_out->fault_phase = NULL;
+ transport_out->out_flow = NULL;
+ transport_out->fault_out_flow = NULL;
+ transport_out->sender = NULL;
+ transport_out->param_container = NULL;
+
+ transport_out->param_container = axutil_param_container_create(env);
+ if(!transport_out->param_container)
+ {
+ axis2_transport_out_desc_free(transport_out, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return transport_out;
+}
+
+void AXIS2_CALL
+axis2_transport_out_desc_free(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ if(transport_out->sender)
+ {
+ AXIS2_TRANSPORT_SENDER_FREE(transport_out->sender, env);
+ }
+
+ if(transport_out->param_container)
+ {
+ axutil_param_container_free(transport_out->param_container, env);
+ }
+
+ if(transport_out->out_flow)
+ {
+ axis2_flow_free(transport_out->out_flow, env);
+ }
+
+ if(transport_out->fault_out_flow)
+ {
+ axis2_flow_free(transport_out->fault_out_flow, env);
+ }
+
+ if(transport_out->out_phase)
+ {
+ axis2_phase_free(transport_out->out_phase, env);
+ }
+
+ if(transport_out->fault_phase)
+ {
+ axis2_phase_free(transport_out->fault_phase, env);
+ }
+
+ AXIS2_FREE(env->allocator, transport_out);
+
+ return;
+}
+
+void AXIS2_CALL
+axis2_transport_out_desc_free_void_arg(
+ void *transport_out,
+ const axutil_env_t * env)
+{
+ axis2_transport_out_desc_t *transport_out_l = NULL;
+
+ transport_out_l = (axis2_transport_out_desc_t *)transport_out;
+ axis2_transport_out_desc_free(transport_out_l, env);
+ return;
+}
+
+AXIS2_TRANSPORT_ENUMS AXIS2_CALL
+axis2_transport_out_desc_get_enum(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->trans_enum;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_enum(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ const AXIS2_TRANSPORT_ENUMS trans_enum)
+{
+ transport_out->trans_enum = trans_enum;
+ return AXIS2_SUCCESS;
+}
+
+axis2_flow_t *AXIS2_CALL
+axis2_transport_out_desc_get_out_flow(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->out_flow;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_out_flow(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ axis2_flow_t * out_flow)
+{
+ AXIS2_PARAM_CHECK(env->error, out_flow, AXIS2_FAILURE);
+
+ if(transport_out->out_flow)
+ {
+ axis2_flow_free(transport_out->out_flow, env);
+ }
+ transport_out->out_flow = out_flow;
+ return AXIS2_SUCCESS;
+}
+
+axis2_flow_t *AXIS2_CALL
+axis2_transport_out_desc_get_fault_out_flow(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->fault_out_flow;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_fault_out_flow(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ axis2_flow_t * fault_out_flow)
+{
+ AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
+
+ if(transport_out->fault_out_flow)
+ {
+ axis2_flow_free(transport_out->fault_out_flow, env);
+ }
+ transport_out->fault_out_flow = fault_out_flow;
+ return AXIS2_SUCCESS;
+}
+
+axis2_transport_sender_t *AXIS2_CALL
+axis2_transport_out_desc_get_sender(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->sender;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_sender(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ axis2_transport_sender_t * sender)
+{
+ AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE);
+
+ if(transport_out->sender)
+ {
+ AXIS2_TRANSPORT_SENDER_FREE(transport_out->sender, env);
+ }
+
+ transport_out->sender = sender;
+ return AXIS2_SUCCESS;
+}
+
+axis2_phase_t *AXIS2_CALL
+axis2_transport_out_desc_get_out_phase(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->out_phase;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_out_phase(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ axis2_phase_t * out_phase)
+{
+ AXIS2_PARAM_CHECK(env->error, out_phase, AXIS2_FAILURE);
+
+ if(transport_out->out_phase)
+ {
+ axis2_phase_free(transport_out->out_phase, env);
+ }
+ transport_out->out_phase = out_phase;
+ return AXIS2_SUCCESS;
+}
+
+axis2_phase_t *AXIS2_CALL
+axis2_transport_out_desc_get_fault_phase(
+ const axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env)
+{
+ return transport_out->fault_phase;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_set_fault_phase(
+ axis2_transport_out_desc_t * transport_out,
+ const axutil_env_t * env,
+ axis2_phase_t * fault_phase)
+{
+ AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE);
+
+ if(transport_out->fault_phase)
+ {
+ axis2_phase_free(transport_out->fault_phase, env);
+ }
+ transport_out->fault_phase = fault_phase;
+ return AXIS2_SUCCESS;
+
+}
+
+axis2_status_t AXIS2_CALL
+axis2_transport_out_desc_add_param(
+ axis2_transport_out_desc_t * transport_out_desc,
+ const axutil_env_t * env,
+ axutil_param_t * param)
+{
+ AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+
+ return axutil_param_container_add_param(transport_out_desc-> param_container, env, param);
+}
+
+axutil_param_t *AXIS2_CALL
+axis2_transport_out_desc_get_param(
+ const axis2_transport_out_desc_t * transport_out_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ return axutil_param_container_get_param(transport_out_desc->param_container, env, param_name);
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_transport_out_desc_is_param_locked(
+ axis2_transport_out_desc_t * transport_out_desc,
+ const axutil_env_t * env,
+ const axis2_char_t * param_name)
+{
+ AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
+
+ return axutil_param_container_is_param_locked(transport_out_desc-> param_container, env,
+ param_name);
+}
+
+AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
+axis2_transport_out_desc_param_container(
+ const axis2_transport_out_desc_t * transport_out_desc,
+ const axutil_env_t * env)
+{
+ return transport_out_desc->param_container;
+}
+
© 2009-2020 sukimashita.com - Generated by cgit - Icons from Tango - Uses Google Analytics