summaryrefslogtreecommitdiffstats
path: root/src/core/addr
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/addr')
-rw-r--r--src/core/addr/Makefile.am13
-rw-r--r--src/core/addr/any_content_type.c120
-rw-r--r--src/core/addr/endpoint_ref.c375
-rw-r--r--src/core/addr/msg_info_headers.c448
-rw-r--r--src/core/addr/relates_to.c164
-rw-r--r--src/core/addr/svc_name.c151
6 files changed, 1271 insertions, 0 deletions
diff --git a/src/core/addr/Makefile.am b/src/core/addr/Makefile.am
new file mode 100644
index 0000000..1f7512f
--- /dev/null
+++ b/src/core/addr/Makefile.am
@@ -0,0 +1,13 @@
+noinst_LTLIBRARIES = libaxis2_addr.la
+
+libaxis2_addr_la_SOURCES = relates_to.c \
+ svc_name.c \
+ any_content_type.c \
+ endpoint_ref.c \
+ msg_info_headers.c
+
+
+INCLUDES = -I$(top_builddir)/include \
+ -I$(top_builddir)/src/core/engine \
+ -I$(top_builddir)/util/include \
+ -I$(top_builddir)/axiom/include
diff --git a/src/core/addr/any_content_type.c b/src/core/addr/any_content_type.c
new file mode 100644
index 0000000..1a9e6a1
--- /dev/null
+++ b/src/core/addr/any_content_type.c
@@ -0,0 +1,120 @@
+/*
+ * 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_any_content_type.h>
+#include <axutil_string.h>
+
+struct axis2_any_content_type
+{
+
+ /** map of values in the any content type */
+ axutil_hash_t *value_map;
+};
+
+AXIS2_EXTERN axis2_any_content_type_t *AXIS2_CALL
+axis2_any_content_type_create(
+ const axutil_env_t * env)
+{
+ axis2_any_content_type_t *any_content_type = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ any_content_type = AXIS2_MALLOC(env->allocator, sizeof(axis2_any_content_type_t));
+ if(!any_content_type)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ any_content_type->value_map = NULL;
+
+ any_content_type->value_map = axutil_hash_make(env);
+
+ if(!(any_content_type->value_map))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_any_content_type_free(any_content_type, env);
+ return NULL;
+ }
+
+ return any_content_type;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_any_content_type_add_value(
+ axis2_any_content_type_t * any_content_type,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname,
+ const axis2_char_t * value)
+{
+ axis2_char_t *temp = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(any_content_type->value_map)
+ {
+ axis2_char_t *name = NULL;
+
+ name = axutil_qname_to_string((axutil_qname_t *)qname, env);
+ axutil_hash_set(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING, value);
+
+ temp = axutil_hash_get(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING);
+ if(temp)
+ return AXIS2_SUCCESS;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_any_content_type_get_value(
+ const axis2_any_content_type_t * any_content_type,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ if(any_content_type->value_map)
+ {
+ axis2_char_t *name = NULL;
+
+ name = axutil_qname_to_string((axutil_qname_t *)qname, env);
+ return axutil_hash_get(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+axis2_any_content_type_get_value_map(
+ const axis2_any_content_type_t * any_content_type,
+ const axutil_env_t * env)
+{
+ return any_content_type->value_map;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_any_content_type_free(
+ axis2_any_content_type_t * any_content_type,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(any_content_type->value_map)
+ {
+ axutil_hash_free(any_content_type->value_map, env);
+ }
+
+ AXIS2_FREE(env->allocator, any_content_type);
+
+ return;
+}
diff --git a/src/core/addr/endpoint_ref.c b/src/core/addr/endpoint_ref.c
new file mode 100644
index 0000000..dd351f0
--- /dev/null
+++ b/src/core/addr/endpoint_ref.c
@@ -0,0 +1,375 @@
+/*
+ * 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_endpoint_ref.h>
+#include <axutil_string.h>
+#include <axutil_array_list.h>
+
+struct axis2_endpoint_ref
+{
+
+ /** endpoint address */
+ axis2_char_t *address;
+
+ /** interface qname */
+ axutil_qname_t *interface_qname;
+
+ /** reference parameters */
+ axutil_array_list_t *ref_param_list;
+
+ /** meta data */
+ axutil_array_list_t *metadata_list;
+
+ /** reference parameter attribute list */
+ axutil_array_list_t *ref_attribute_list;
+
+ /** meta data attribute list */
+ axutil_array_list_t *meta_attribute_list;
+
+ /** extensible element list */
+ axutil_array_list_t *extension_list;
+
+ /** service name */
+ axis2_svc_name_t *svc_name;
+};
+
+axis2_endpoint_ref_t *AXIS2_CALL
+axis2_endpoint_ref_create(
+ const axutil_env_t * env,
+ const axis2_char_t * address)
+{
+ axis2_endpoint_ref_t *endpoint_ref = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ endpoint_ref = AXIS2_MALLOC(env->allocator, sizeof(axis2_endpoint_ref_t));
+ if(!endpoint_ref)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ endpoint_ref->address = NULL;
+ endpoint_ref->interface_qname = NULL;
+ endpoint_ref->ref_param_list = NULL;
+ endpoint_ref->metadata_list = NULL;
+ endpoint_ref->ref_attribute_list = NULL;
+ endpoint_ref->meta_attribute_list = NULL;
+ endpoint_ref->extension_list = NULL;
+ endpoint_ref->svc_name = NULL;
+
+ if(address)
+ {
+ endpoint_ref->address = axutil_strdup(env, address);
+ if(!(endpoint_ref->address))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_endpoint_ref_free(endpoint_ref, env);
+ return NULL;
+ }
+ }
+
+ return endpoint_ref;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_endpoint_ref_get_address(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->address;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_set_address(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ const axis2_char_t * address)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ if(endpoint_ref->address)
+ {
+ AXIS2_FREE(env->allocator, endpoint_ref->address);
+ }
+
+ endpoint_ref->address = axutil_strdup(env, address);
+ return AXIS2_SUCCESS;
+}
+
+const axutil_qname_t *AXIS2_CALL
+axis2_endpoint_ref_get_interface_qname(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->interface_qname;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_set_interface_qname(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ const axutil_qname_t * interface_qname)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ endpoint_ref->interface_qname = axutil_qname_clone((axutil_qname_t *)interface_qname, env);
+ return AXIS2_SUCCESS;
+}
+
+axis2_svc_name_t *AXIS2_CALL
+axis2_endpoint_ref_get_svc_name(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->svc_name;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_set_svc_name(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axis2_svc_name_t * svc_name)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ endpoint_ref->svc_name = svc_name;
+ return AXIS2_SUCCESS;
+}
+
+void AXIS2_CALL
+axis2_endpoint_ref_free_void_arg(
+ void *endpoint_ref,
+ const axutil_env_t * env)
+{
+ axis2_endpoint_ref_t *endpoint_ref_l = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ endpoint_ref_l = (axis2_endpoint_ref_t *)endpoint_ref;
+ axis2_endpoint_ref_free(endpoint_ref_l, env);
+ return;
+}
+
+void AXIS2_CALL
+axis2_endpoint_ref_free(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(endpoint_ref->address)
+ {
+ AXIS2_FREE(env->allocator, endpoint_ref->address);
+ }
+
+ if(endpoint_ref->ref_param_list)
+ {
+ axutil_array_list_free(endpoint_ref->ref_param_list, env);
+ }
+
+ if(endpoint_ref->metadata_list)
+ {
+ axutil_array_list_free(endpoint_ref->metadata_list, env);
+ }
+
+ if(endpoint_ref->ref_attribute_list)
+ {
+ axutil_array_list_free(endpoint_ref->ref_attribute_list, env);
+ }
+
+ if(endpoint_ref->meta_attribute_list)
+ {
+ axutil_array_list_free(endpoint_ref->meta_attribute_list, env);
+ }
+
+ if(endpoint_ref->extension_list)
+ {
+ axutil_array_list_free(endpoint_ref->extension_list, env);
+ }
+
+ AXIS2_FREE(env->allocator, endpoint_ref);
+
+ return;
+}
+
+axutil_array_list_t *AXIS2_CALL
+axis2_endpoint_ref_get_ref_param_list(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->ref_param_list;
+}
+
+axutil_array_list_t *AXIS2_CALL
+axis2_endpoint_ref_get_metadata_list(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->metadata_list;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_add_ref_param(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axiom_node_t * ref_param_node)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!(endpoint_ref->ref_param_list))
+ {
+ endpoint_ref->ref_param_list = axutil_array_list_create(env, 0);
+ if(!(endpoint_ref->ref_param_list))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ if(endpoint_ref->ref_param_list && ref_param_node)
+ {
+ return axutil_array_list_add(endpoint_ref->ref_param_list, env, ref_param_node);
+ }
+
+ return AXIS2_FAILURE;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_add_metadata(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axiom_node_t * meta_data_node)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!(endpoint_ref->metadata_list))
+ {
+ endpoint_ref->metadata_list = axutil_array_list_create(env, 0);
+ if(!(endpoint_ref->metadata_list))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ if(endpoint_ref->metadata_list && meta_data_node)
+ {
+ return axutil_array_list_add(endpoint_ref->metadata_list, env, meta_data_node);
+ }
+
+ return AXIS2_FAILURE;
+}
+
+axutil_array_list_t *AXIS2_CALL
+axis2_endpoint_ref_get_ref_attribute_list(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->ref_attribute_list;
+}
+
+axutil_array_list_t *AXIS2_CALL
+axis2_endpoint_ref_get_metadata_attribute_list(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->meta_attribute_list;
+}
+
+axutil_array_list_t *AXIS2_CALL
+axis2_endpoint_ref_get_extension_list(
+ const axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env)
+{
+ return endpoint_ref->extension_list;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_add_ref_attribute(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axiom_attribute_t * attr)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!(endpoint_ref->ref_attribute_list))
+ {
+ endpoint_ref->ref_attribute_list = axutil_array_list_create(env, 0);
+ if(!(endpoint_ref->ref_attribute_list))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ if(endpoint_ref->ref_attribute_list && attr)
+ {
+ return axutil_array_list_add(endpoint_ref->ref_attribute_list, env, attr);
+ }
+
+ return AXIS2_FAILURE;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_add_metadata_attribute(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axiom_attribute_t * attr)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!(endpoint_ref->meta_attribute_list))
+ {
+ endpoint_ref->meta_attribute_list = axutil_array_list_create(env, 0);
+ if(!(endpoint_ref->meta_attribute_list))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ if(endpoint_ref->meta_attribute_list && attr)
+ {
+ return axutil_array_list_add(endpoint_ref->meta_attribute_list, env, attr);
+ }
+
+ return AXIS2_FAILURE;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_endpoint_ref_add_extension(
+ axis2_endpoint_ref_t * endpoint_ref,
+ const axutil_env_t * env,
+ axiom_node_t * extension_node)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(!(endpoint_ref->extension_list))
+ {
+ endpoint_ref->extension_list = axutil_array_list_create(env, 0);
+ if(!(endpoint_ref->extension_list))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ if(endpoint_ref->extension_list && extension_node)
+ {
+ return axutil_array_list_add(endpoint_ref->extension_list, env, extension_node);
+ }
+
+ return AXIS2_FAILURE;
+}
diff --git a/src/core/addr/msg_info_headers.c b/src/core/addr/msg_info_headers.c
new file mode 100644
index 0000000..8d61c5b
--- /dev/null
+++ b/src/core/addr/msg_info_headers.c
@@ -0,0 +1,448 @@
+/*
+ * 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_info_headers.h>
+#include <axutil_string.h>
+
+struct axis2_msg_info_headers
+{
+
+ /** The address of the intended receiver of the message. This is mandatory */
+ axis2_endpoint_ref_t *to;
+
+ /** Reference of the endpoint where the message originated from */
+ axis2_endpoint_ref_t *from;
+
+ /** Pair of values that indicate how this message relate to another message */
+ axis2_relates_to_t *relates_to;
+
+ /** Identifies the intended receiver for replies to the message,
+ if this is set, none and anonymous settings are ignored */
+ axis2_endpoint_ref_t *reply_to;
+
+ /** reply to should be none */
+ axis2_bool_t reply_to_none;
+
+ /** reply to should be anonymous, this is overridden by none*/
+ axis2_bool_t reply_to_anonymous;
+
+ /** identifies the intended receiver for faults related to the message
+ if this is set, none and anonymous settings are ignored */
+ axis2_endpoint_ref_t *fault_to;
+
+ /** fault to should be none */
+ axis2_bool_t fault_to_none;
+
+ /** fault to should be anonymous, this is overridden by none*/
+ axis2_bool_t fault_to_anonymous;
+
+ /** action */
+ axis2_char_t *action;
+
+ /** message Id */
+ axis2_char_t *message_id;
+
+ /** reference parameters */
+ axutil_array_list_t *ref_params;
+};
+
+AXIS2_EXTERN axis2_msg_info_headers_t *AXIS2_CALL
+axis2_msg_info_headers_create(
+ const axutil_env_t * env,
+ axis2_endpoint_ref_t * to,
+ const axis2_char_t * action)
+{
+ axis2_msg_info_headers_t *msg_info_headers = NULL;
+
+ msg_info_headers = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_info_headers_t));
+
+ if(!msg_info_headers)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_info_headers->to = NULL;
+ msg_info_headers->from = NULL;
+ msg_info_headers->relates_to = NULL;
+ msg_info_headers->reply_to_none = AXIS2_FALSE;
+ msg_info_headers->reply_to_anonymous = AXIS2_FALSE;
+ msg_info_headers->reply_to = NULL;
+ msg_info_headers->fault_to_none = AXIS2_FALSE;
+ msg_info_headers->fault_to_anonymous = AXIS2_FALSE;
+ msg_info_headers->fault_to = NULL;
+ msg_info_headers->action = NULL;
+ msg_info_headers->message_id = NULL;
+ msg_info_headers->ref_params = NULL;
+
+ if(to)
+ {
+ msg_info_headers->to = to;
+ }
+
+ if(action)
+ {
+ msg_info_headers->action = axutil_strdup(env, action);
+ if(!(msg_info_headers->action))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_msg_info_headers_free(msg_info_headers, env);
+ return NULL;
+ }
+ }
+
+ return msg_info_headers;
+}
+
+/**
+ * Method getTo
+ *
+ * @return
+ */
+AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL
+axis2_msg_info_headers_get_to(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->to;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_to(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axis2_endpoint_ref_t * to)
+{
+ if(msg_info_headers->to && to) /* if the incoming to is NULL,
+ we consider that to be a reset,
+ so don't free */
+ {
+ axis2_endpoint_ref_free(msg_info_headers->to, env);
+ msg_info_headers->to = NULL;
+ }
+ msg_info_headers->to = to;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL
+axis2_msg_info_headers_get_from(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->from;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_from(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axis2_endpoint_ref_t * from)
+{
+ msg_info_headers->from = from;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL
+axis2_msg_info_headers_get_reply_to(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->reply_to;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_reply_to(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axis2_endpoint_ref_t * reply_to)
+{
+ msg_info_headers->reply_to = reply_to;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL
+axis2_msg_info_headers_get_fault_to(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->fault_to;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_fault_to(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axis2_endpoint_ref_t * fault_to)
+{
+ msg_info_headers->fault_to = fault_to;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_msg_info_headers_get_action(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->action;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_action(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_char_t * action)
+{
+ if(msg_info_headers->action)
+ {
+ AXIS2_FREE(env->allocator, msg_info_headers->action);
+ msg_info_headers->action = NULL;
+ }
+ if(action)
+ {
+ msg_info_headers->action = axutil_strdup(env, action);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+axis2_msg_info_headers_get_message_id(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->message_id;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_message_id(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_char_t * message_id)
+{
+ if(msg_info_headers->message_id)
+ {
+ AXIS2_FREE(env->allocator, msg_info_headers->message_id);
+ msg_info_headers->message_id = NULL;
+ }
+
+ if(message_id)
+ {
+ msg_info_headers->message_id = axutil_stracat(env, AXIS2_MESSAGE_ID_PREFIX, message_id);
+ if(!(msg_info_headers->message_id))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_in_message_id(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_char_t * message_id)
+{
+ if(msg_info_headers->message_id)
+ {
+ AXIS2_FREE(env->allocator, msg_info_headers->message_id);
+ msg_info_headers->message_id = NULL;
+ }
+
+ if(message_id)
+ {
+ msg_info_headers->message_id = axutil_strdup(env, message_id);
+
+ if(!(msg_info_headers->message_id))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL
+axis2_msg_info_headers_get_relates_to(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->relates_to;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_relates_to(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axis2_relates_to_t * relates_to)
+{
+ if(msg_info_headers->relates_to)
+ {
+ axis2_relates_to_free(msg_info_headers->relates_to, env);
+ }
+ msg_info_headers->relates_to = relates_to;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+axis2_msg_info_headers_get_all_ref_params(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->ref_params;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_add_ref_param(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ axiom_node_t * ref_param)
+{
+ if(!(msg_info_headers->ref_params))
+ {
+ msg_info_headers->ref_params = axutil_array_list_create(env, 10);
+ if(!(msg_info_headers->ref_params))
+ return AXIS2_FAILURE;
+ }
+
+ if(ref_param)
+ {
+ return axutil_array_list_add(msg_info_headers->ref_params, env, ref_param);
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_msg_info_headers_free(
+ struct axis2_msg_info_headers *msg_info_headers,
+ const axutil_env_t * env)
+{
+ if(msg_info_headers->to)
+ {
+ axis2_endpoint_ref_free(msg_info_headers->to, env);
+ }
+ if(msg_info_headers->from)
+ {
+ axis2_endpoint_ref_free(msg_info_headers->from, env);
+ }
+ if(msg_info_headers->reply_to)
+ {
+ axis2_endpoint_ref_free(msg_info_headers->reply_to, env);
+ }
+ if(msg_info_headers->relates_to)
+ {
+ axis2_relates_to_free(msg_info_headers->relates_to, env);
+ }
+
+ if(msg_info_headers->fault_to)
+ {
+ axis2_endpoint_ref_free(msg_info_headers->fault_to, env);
+ }
+
+ if(msg_info_headers->ref_params)
+ {
+ axutil_array_list_free(msg_info_headers->ref_params, env);
+ }
+ if(msg_info_headers->action)
+ {
+ AXIS2_FREE(env->allocator, msg_info_headers->action);
+ }
+ if(msg_info_headers->message_id)
+ {
+ AXIS2_FREE(env->allocator, msg_info_headers->message_id);
+ }
+
+ AXIS2_FREE(env->allocator, msg_info_headers);
+
+ return;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_reply_to_none(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_bool_t none)
+{
+ msg_info_headers->reply_to_none = none;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_msg_info_headers_get_reply_to_none(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->reply_to_none;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_reply_to_anonymous(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_bool_t anonymous)
+{
+ msg_info_headers->reply_to_anonymous = anonymous;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_msg_info_headers_get_reply_to_anonymous(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->reply_to_anonymous;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_fault_to_none(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_bool_t none)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg_info_headers->fault_to_none = none;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_msg_info_headers_get_fault_to_none(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->fault_to_none;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_msg_info_headers_set_fault_to_anonymous(
+ struct axis2_msg_info_headers * msg_info_headers,
+ const axutil_env_t * env,
+ const axis2_bool_t anonymous)
+{
+ msg_info_headers->fault_to_anonymous = anonymous;
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_msg_info_headers_get_fault_to_anonymous(
+ const axis2_msg_info_headers_t * msg_info_headers,
+ const axutil_env_t * env)
+{
+ return msg_info_headers->fault_to_anonymous;
+}
+
diff --git a/src/core/addr/relates_to.c b/src/core/addr/relates_to.c
new file mode 100644
index 0000000..e28df54
--- /dev/null
+++ b/src/core/addr/relates_to.c
@@ -0,0 +1,164 @@
+/*
+ * 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_relates_to.h>
+#include <axutil_string.h>
+
+struct axis2_relates_to
+{
+
+ /** value string */
+ axis2_char_t *value;
+
+ /** relationship type string */
+ axis2_char_t *relationship_type;
+};
+
+axis2_relates_to_t *AXIS2_CALL
+axis2_relates_to_create(
+ const axutil_env_t * env,
+ const axis2_char_t * value,
+ const axis2_char_t * relationship_type)
+{
+ axis2_relates_to_t *relates_to = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ relates_to = AXIS2_MALLOC(env->allocator, sizeof(axis2_relates_to_t));
+ if(!relates_to)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ relates_to->value = NULL;
+ relates_to->relationship_type = NULL;
+
+ if(value)
+ {
+ relates_to->value = axutil_strdup(env, value);
+ if(!(relates_to->value))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_relates_to_free(relates_to, env);
+ return NULL;
+ }
+ }
+
+ if(relationship_type)
+ {
+ relates_to->relationship_type = axutil_strdup(env, relationship_type);
+ if(!(relates_to->relationship_type))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_relates_to_free(relates_to, env);
+ return NULL;
+ }
+ }
+
+ return relates_to;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_relates_to_get_value(
+ const axis2_relates_to_t * relates_to,
+ const axutil_env_t * env)
+{
+ return relates_to->value;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_relates_to_set_value(
+ struct axis2_relates_to * relates_to,
+ const axutil_env_t * env,
+ const axis2_char_t * value)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(relates_to->value)
+ {
+ AXIS2_FREE(env->allocator, relates_to->value);
+ }
+
+ if(value)
+ {
+ relates_to->value = (axis2_char_t *)axutil_strdup(env, value);
+ if(!(relates_to->value))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_relates_to_get_relationship_type(
+ const axis2_relates_to_t * relates_to,
+ const axutil_env_t * env)
+{
+ return relates_to->relationship_type;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_relates_to_set_relationship_type(
+ struct axis2_relates_to * relates_to,
+ const axutil_env_t * env,
+ const axis2_char_t * relationship_type)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(relates_to->relationship_type)
+ {
+ AXIS2_FREE(env->allocator, relates_to->relationship_type);
+ }
+
+ if(relationship_type)
+ {
+ relates_to->relationship_type = (axis2_char_t *)axutil_strdup(env, relationship_type);
+ if(!(relates_to->relationship_type))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+void AXIS2_CALL
+axis2_relates_to_free(
+ struct axis2_relates_to *relates_to,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, void);
+
+ if(relates_to->value)
+ {
+ AXIS2_FREE(env->allocator, relates_to->value);
+ }
+
+ if(relates_to->relationship_type)
+ {
+ AXIS2_FREE(env->allocator, relates_to->relationship_type);
+ }
+
+ AXIS2_FREE(env->allocator, relates_to);
+
+ return;
+}
diff --git a/src/core/addr/svc_name.c b/src/core/addr/svc_name.c
new file mode 100644
index 0000000..0aa34ab
--- /dev/null
+++ b/src/core/addr/svc_name.c
@@ -0,0 +1,151 @@
+/*
+ * 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_name.h>
+#include <axutil_string.h>
+
+struct axis2_svc_name
+{
+
+ /** service QName */
+ axutil_qname_t *qname;
+
+ /** service endpoint name */
+ axis2_char_t *endpoint_name;
+};
+
+axis2_svc_name_t *AXIS2_CALL
+axis2_svc_name_create(
+ const axutil_env_t * env,
+ const axutil_qname_t * qname,
+ const axis2_char_t * endpoint_name)
+{
+ axis2_svc_name_t *svc_name = NULL;
+
+ svc_name = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_name_t));
+ if(!svc_name)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ svc_name->qname = NULL;
+ svc_name->endpoint_name = NULL;
+
+ if(qname)
+ {
+ svc_name->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+ if(!(svc_name->qname))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_svc_name_free(svc_name, env);
+ return NULL;
+ }
+ }
+
+ if(endpoint_name)
+ {
+ svc_name->endpoint_name = axutil_strdup(env, endpoint_name);
+ if(!(svc_name->endpoint_name))
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_svc_name_free(svc_name, env);
+ return NULL;
+ }
+ }
+
+ return svc_name;
+}
+
+const axutil_qname_t *AXIS2_CALL
+axis2_svc_name_get_qname(
+ const axis2_svc_name_t * svc_name,
+ const axutil_env_t * env)
+{
+ return svc_name->qname;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_svc_name_set_qname(
+ struct axis2_svc_name * svc_name,
+ const axutil_env_t * env,
+ const axutil_qname_t * qname)
+{
+ if(svc_name->qname)
+ {
+ axutil_qname_free(svc_name->qname, env);
+ }
+
+ if(qname)
+ {
+ svc_name->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+ if(!(svc_name->qname))
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+const axis2_char_t *AXIS2_CALL
+axis2_svc_name_get_endpoint_name(
+ const axis2_svc_name_t * svc_name,
+ const axutil_env_t * env)
+{
+ return svc_name->endpoint_name;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_svc_name_set_endpoint_name(
+ struct axis2_svc_name * svc_name,
+ const axutil_env_t * env,
+ const axis2_char_t * endpoint_name)
+{
+ if(svc_name->endpoint_name)
+ {
+ AXIS2_FREE(env->allocator, svc_name->endpoint_name);
+ }
+
+ if(endpoint_name)
+ {
+ svc_name->endpoint_name = axutil_strdup(env, endpoint_name);
+ if(!(svc_name->endpoint_name))
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+void AXIS2_CALL
+axis2_svc_name_free(
+ struct axis2_svc_name *svc_name,
+ const axutil_env_t * env)
+{
+ if(svc_name->qname)
+ {
+ axutil_qname_free(svc_name->qname, env);
+ }
+
+ if(svc_name->endpoint_name)
+ {
+ AXIS2_FREE(env->allocator, svc_name->endpoint_name);
+ }
+
+ AXIS2_FREE(env->allocator, svc_name);
+
+ return;
+}
+