You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/09/28 12:22:36 UTC
svn commit: r580284 [9/12] - in /webservices/axis2/trunk/c/axiom:
src/attachments/ src/om/ src/parser/ src/parser/guththila/
src/parser/libxml2/ src/soap/ src/util/ test/om/ test/soap/
Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_body.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_body.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_body.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_body.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -40,15 +41,15 @@
int soap_version;
};
-AXIS2_EXTERN axiom_soap_body_t* AXIS2_CALL
-axiom_soap_body_create(const axutil_env_t *env)
+AXIS2_EXTERN axiom_soap_body_t *AXIS2_CALL
+axiom_soap_body_create(
+ const axutil_env_t * env)
{
axiom_soap_body_t *soap_body = NULL;
AXIS2_ENV_CHECK(env, NULL);
- soap_body = (axiom_soap_body_t*)AXIS2_MALLOC(
- env->allocator,
- sizeof(axiom_soap_body_t));
+ soap_body = (axiom_soap_body_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axiom_soap_body_t));
if (!soap_body)
{
@@ -63,16 +64,15 @@
return soap_body;
}
-
-
-AXIS2_EXTERN axiom_soap_body_t* AXIS2_CALL
-axiom_soap_body_create_with_parent(const axutil_env_t *env,
- axiom_soap_envelope_t *envelope)
+AXIS2_EXTERN axiom_soap_body_t *AXIS2_CALL
+axiom_soap_body_create_with_parent(
+ const axutil_env_t * env,
+ axiom_soap_envelope_t * envelope)
{
axiom_soap_body_t *soap_body = NULL;
axiom_element_t *ele = NULL;
axiom_node_t *parent_node = NULL;
- axiom_element_t *parent_ele = NULL;
+ axiom_element_t *parent_ele = NULL;
axiom_namespace_t *om_ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -91,8 +91,8 @@
axiom_soap_body_free(soap_body, env);
return NULL;
}
- parent_ele = (axiom_element_t *)axiom_node_get_data_element(
- parent_node, env);
+ parent_ele =
+ (axiom_element_t *) axiom_node_get_data_element(parent_node, env);
if (!parent_ele)
{
@@ -103,8 +103,8 @@
om_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
ele = axiom_element_create(env, parent_node,
- AXIOM_SOAP_BODY_LOCAL_NAME, om_ns,
- &(soap_body->om_ele_node));
+ AXIOM_SOAP_BODY_LOCAL_NAME, om_ns,
+ &(soap_body->om_ele_node));
if (!ele)
{
axiom_soap_body_free(soap_body, env);
@@ -117,8 +117,9 @@
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_soap_body_free(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+axiom_soap_body_free(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -132,8 +133,10 @@
return;
}
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL axiom_soap_body_has_fault(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axiom_soap_body_has_fault(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -147,7 +150,8 @@
{
if (soap_body->soap_builder)
{
- while (!(soap_body->soap_fault) && !(axiom_node_is_complete(soap_body->om_ele_node, env)))
+ while (!(soap_body->soap_fault) &&
+ !(axiom_node_is_complete(soap_body->om_ele_node, env)))
{
status = axiom_soap_builder_next(soap_body->soap_builder, env);
if (status == AXIS2_FAILURE)
@@ -171,9 +175,10 @@
* @return the <code>SOAPFault</code> object in this <code>SOAPBody</code>
* object
*/
-AXIS2_EXTERN axiom_soap_fault_t* AXIS2_CALL
-axiom_soap_body_get_fault(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_soap_fault_t *AXIS2_CALL
+axiom_soap_body_get_fault(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
if (soap_body->soap_fault)
@@ -182,7 +187,8 @@
}
else if (soap_body->soap_builder)
{
- while (!(soap_body->soap_fault) && !(axiom_node_is_complete(soap_body->om_ele_node, env)))
+ while (!(soap_body->soap_fault) &&
+ !(axiom_node_is_complete(soap_body->om_ele_node, env)))
{
int status = AXIS2_SUCCESS;
status = axiom_soap_builder_next(soap_body->soap_builder, env);
@@ -198,51 +204,55 @@
return NULL;
}
-AXIS2_EXTERN axiom_node_t* AXIS2_CALL
-axiom_soap_body_get_base_node(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+axiom_soap_body_get_base_node(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
return soap_body->om_ele_node;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_set_base_node(axiom_soap_body_t *soap_body,
- const axutil_env_t *env,
- axiom_node_t *node)
+axiom_soap_body_set_base_node(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env,
+ axiom_node_t * node)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
soap_body->om_ele_node = node;
return AXIS2_SUCCESS;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_set_builder(axiom_soap_body_t *soap_body,
- const axutil_env_t *env,
- axiom_soap_builder_t *builder)
+axiom_soap_body_set_builder(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env,
+ axiom_soap_builder_t * builder)
{
AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE);
soap_body->soap_builder = builder;
return AXIS2_SUCCESS;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_build(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+axiom_soap_body_build(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (soap_body->om_ele_node && soap_body->soap_builder)
{
- while (axiom_node_is_complete(soap_body->om_ele_node, env) != AXIS2_TRUE)
+ while (axiom_node_is_complete(soap_body->om_ele_node, env) !=
+ AXIS2_TRUE)
{
status = axiom_soap_builder_next(soap_body->soap_builder, env);
if (status == AXIS2_FAILURE)
@@ -257,15 +267,17 @@
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_set_fault(axiom_soap_body_t *soap_body,
- const axutil_env_t *env,
- axiom_soap_fault_t *soap_fault)
+axiom_soap_body_set_fault(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env,
+ axiom_soap_fault_t * soap_fault)
{
AXIS2_PARAM_CHECK(env->error, soap_fault, AXIS2_FAILURE);
if (soap_body->soap_fault)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_ONLY_ONE_SOAP_FAULT_ALLOWED_IN_BODY, AXIS2_FAILURE);
+ AXIS2_ERROR_ONLY_ONE_SOAP_FAULT_ALLOWED_IN_BODY,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
@@ -277,9 +289,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_add_child(axiom_soap_body_t *soap_body,
- const axutil_env_t *env,
- axiom_node_t *child)
+axiom_soap_body_add_child(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env,
+ axiom_node_t * child)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, child, AXIS2_FAILURE);
@@ -292,12 +305,13 @@
}
AXIS2_EXTERN int AXIS2_CALL
-axiom_soap_body_get_soap_version(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+axiom_soap_body_get_soap_version(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
axiom_element_t *body_ele = NULL;
axiom_namespace_t *om_ns = NULL;
- axis2_char_t *uri = NULL;
+ axis2_char_t *uri = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!soap_body->om_ele_node)
return AXIS2_FAILURE;
@@ -312,15 +326,17 @@
{
if (axutil_strcmp(uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0)
return AXIOM_SOAP11;
- else if (axutil_strcmp(uri, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) == 0)
+ else if (axutil_strcmp(uri, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) ==
+ 0)
return AXIOM_SOAP12;
}
return AXIS2_FAILURE;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_body_convert_fault_to_soap11(axiom_soap_body_t *soap_body,
- const axutil_env_t *env)
+axiom_soap_body_convert_fault_to_soap11(
+ axiom_soap_body_t * soap_body,
+ const axutil_env_t * env)
{
if (soap_body)
{
@@ -344,34 +360,51 @@
axiom_soap_fault_value_t *fault_value = NULL;
axis2_char_t *text = NULL;
- fault_code_om_node = axiom_soap_fault_code_get_base_node(fault_code, env);
+ fault_code_om_node =
+ axiom_soap_fault_code_get_base_node(fault_code, env);
if (fault_code_om_node)
{
fault_code_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_code_om_node, env);
+ axiom_node_get_data_element(fault_code_om_node,
+ env);
if (fault_code_om_ele)
{
axiom_element_set_localname(fault_code_om_ele,
- env, AXIOM_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME);
+ env,
+ AXIOM_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME);
- fault_value = axiom_soap_fault_code_get_value(fault_code, env);
+ fault_value =
+ axiom_soap_fault_code_get_value(fault_code,
+ env);
if (fault_value)
{
- fault_value_om_node = axiom_soap_fault_value_get_base_node(fault_value, env);
+ fault_value_om_node =
+ axiom_soap_fault_value_get_base_node
+ (fault_value, env);
if (fault_value_om_node)
{
- fault_value_om_node = axiom_node_detach(fault_value_om_node, env);
- fault_value_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_value_om_node, env);
+ fault_value_om_node =
+ axiom_node_detach(fault_value_om_node,
+ env);
+ fault_value_om_ele =
+ (axiom_element_t *)
+ axiom_node_get_data_element
+ (fault_value_om_node, env);
if (fault_value_om_ele)
{
- text = axiom_element_get_text(fault_value_om_ele, env, fault_value_om_node);
+ text =
+ axiom_element_get_text
+ (fault_value_om_ele, env,
+ fault_value_om_node);
if (text)
{
- axiom_element_set_text(fault_code_om_ele, env, text, fault_code_om_node);
+ axiom_element_set_text
+ (fault_code_om_ele, env, text,
+ fault_code_om_node);
}
- axiom_node_free_tree(fault_value_om_node, env);
+ axiom_node_free_tree
+ (fault_value_om_node, env);
}
}
@@ -387,40 +420,56 @@
axiom_node_t *fault_text_om_node = NULL;
axiom_element_t *fault_text_om_ele = NULL;
axiom_soap_fault_text_t *fault_text = NULL;
- axis2_char_t *text = NULL;
+ axis2_char_t *text = NULL;
- fault_reason_om_node = axiom_soap_fault_reason_get_base_node(fault_reason, env);
+ fault_reason_om_node =
+ axiom_soap_fault_reason_get_base_node(fault_reason,
+ env);
if (fault_reason_om_node)
{
- fault_reason_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_reason_om_node, env);
+ fault_reason_om_ele = (axiom_element_t *)
+ axiom_node_get_data_element(fault_reason_om_node,
+ env);
if (fault_reason_om_ele)
{
axiom_element_set_localname(fault_reason_om_ele,
- env, AXIOM_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME);
+ env,
+ AXIOM_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME);
fault_text =
- axiom_soap_fault_reason_get_first_soap_fault_text(fault_reason, env);
+ axiom_soap_fault_reason_get_first_soap_fault_text
+ (fault_reason, env);
if (fault_text)
{
- fault_text_om_node = axiom_soap_fault_text_get_base_node(fault_text, env);
+ fault_text_om_node =
+ axiom_soap_fault_text_get_base_node
+ (fault_text, env);
if (fault_text_om_node)
{
- fault_text_om_node = axiom_node_detach(fault_text_om_node, env);
- fault_text_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_text_om_node, env);
+ fault_text_om_node =
+ axiom_node_detach(fault_text_om_node,
+ env);
+ fault_text_om_ele =
+ (axiom_element_t *)
+ axiom_node_get_data_element
+ (fault_text_om_node, env);
if (fault_text_om_ele)
{
- text = axiom_element_get_text(fault_text_om_ele, env, fault_text_om_node);
+ text =
+ axiom_element_get_text
+ (fault_text_om_ele, env,
+ fault_text_om_node);
if (text)
{
- axiom_element_set_text(fault_reason_om_ele,
- env, text, fault_reason_om_node);
+ axiom_element_set_text
+ (fault_reason_om_ele, env, text,
+ fault_reason_om_node);
}
}
- axiom_node_free_tree(fault_text_om_node, env);
+ axiom_node_free_tree(fault_text_om_node,
+ env);
}
}
}
@@ -433,15 +482,17 @@
axiom_node_t *fault_role_om_node = NULL;
axiom_element_t *fault_role_om_ele = NULL;
- fault_role_om_node = axiom_soap_fault_role_get_base_node(fault_role, env);
+ fault_role_om_node =
+ axiom_soap_fault_role_get_base_node(fault_role, env);
if (fault_role_om_node)
{
fault_role_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_role_om_node, env);
+ axiom_node_get_data_element(fault_role_om_node,
+ env);
if (fault_role_om_ele)
{
axiom_element_set_localname(fault_role_om_ele, env,
- AXIOM_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME);
+ AXIOM_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME);
}
}
}
@@ -451,15 +502,19 @@
{
axiom_node_t *fault_detail_om_node = NULL;
axiom_element_t *fault_detail_om_ele = NULL;
- fault_detail_om_node = axiom_soap_fault_detail_get_base_node(fault_detail, env);
+ fault_detail_om_node =
+ axiom_soap_fault_detail_get_base_node(fault_detail,
+ env);
if (fault_detail_om_node)
{
fault_detail_om_ele = (axiom_element_t *)
- axiom_node_get_data_element(fault_detail_om_node, env);
+ axiom_node_get_data_element(fault_detail_om_node,
+ env);
if (fault_detail_om_ele)
{
axiom_element_set_localname(fault_detail_om_ele,
- env, AXIOM_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME);
+ env,
+ AXIOM_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME);
}
}
}
Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -26,34 +27,33 @@
#include <axiom_stax_builder_internal.h>
#include "_axiom_soap_fault.h"
-axis2_status_t
-axiom_soap_builder_create_om_element(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *current_node,
- int current_event);
-
-static axis2_status_t
-axiom_soap_builder_construct_node(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *parent,
- axiom_node_t *om_element_node,
- axis2_bool_t is_soap_envelope);
-
-static axis2_status_t
-axiom_soap_builder_identify_soap_version(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- const axis2_char_t* soap_version_uri_from_transport);
-
-static axis2_status_t
-axiom_soap_builder_parse_headers(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env);
-
-static axis2_status_t
-axiom_soap_builder_construct_node_for_empty_element
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *parent,
- axiom_node_t *om_element_node);
+axis2_status_t axiom_soap_builder_create_om_element(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * current_node,
+ int current_event);
+
+static axis2_status_t axiom_soap_builder_construct_node(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * parent,
+ axiom_node_t * om_element_node,
+ axis2_bool_t is_soap_envelope);
+
+static axis2_status_t axiom_soap_builder_identify_soap_version(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ const axis2_char_t * soap_version_uri_from_transport);
+
+static axis2_status_t axiom_soap_builder_parse_headers(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env);
+
+static axis2_status_t axiom_soap_builder_construct_node_for_empty_element(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * parent,
+ axiom_node_t * om_element_node);
struct axiom_soap_builder
{
@@ -71,9 +71,9 @@
axis2_bool_t processing_detail_elements;
- axis2_char_t* sender_fault_code;
+ axis2_char_t *sender_fault_code;
- axis2_char_t* receiver_fault_code;
+ axis2_char_t *receiver_fault_code;
axis2_bool_t processing_mandatory_fault_elements;
@@ -85,7 +85,7 @@
int last_node_status;
- axis2_bool_t done;
+ axis2_bool_t done;
axutil_hash_t *mime_body_parts;
@@ -95,22 +95,24 @@
{
AXIS2_BUILDER_LAST_NODE_NULL = 0,
AXIS2_BUILDER_LAST_NODE_NOT_NULL
-}axis2_builder_last_node_states;
+} axis2_builder_last_node_states;
#define AXIS2_MAX_EVENT 100
-AXIS2_EXTERN axiom_soap_builder_t * AXIS2_CALL
-axiom_soap_builder_create(const axutil_env_t *env,
- axiom_stax_builder_t *stax_builder,
- const axis2_char_t *soap_version)
+AXIS2_EXTERN axiom_soap_builder_t *AXIS2_CALL
+axiom_soap_builder_create(
+ const axutil_env_t * env,
+ axiom_stax_builder_t * stax_builder,
+ const axis2_char_t * soap_version)
{
axiom_soap_builder_t *soap_builder = NULL;
axis2_status_t status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, stax_builder, NULL);
- soap_builder = (axiom_soap_builder_t*)AXIS2_MALLOC(env->allocator,
- sizeof(axiom_soap_builder_t));
+ soap_builder = (axiom_soap_builder_t *) AXIS2_MALLOC(env->allocator,
+ sizeof
+ (axiom_soap_builder_t));
if (soap_builder == NULL)
{
@@ -135,7 +137,9 @@
soap_builder->mime_body_parts = NULL;
soap_builder->om_builder = stax_builder;
- status = axiom_soap_builder_identify_soap_version(soap_builder, env, soap_version);
+ status =
+ axiom_soap_builder_identify_soap_version(soap_builder, env,
+ soap_version);
if (status == AXIS2_FAILURE)
{
axiom_soap_builder_free(soap_builder, env);
@@ -151,8 +155,9 @@
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_soap_builder_free(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+axiom_soap_builder_free(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
if (!soap_builder)
@@ -160,37 +165,43 @@
if (soap_builder->builder_helper)
{
- if (soap_builder->soap_version == AXIOM_SOAP11 && soap_builder->builder_helper)
+ if (soap_builder->soap_version == AXIOM_SOAP11 &&
+ soap_builder->builder_helper)
{
- axiom_soap11_builder_helper_free((axiom_soap11_builder_helper_t *)(soap_builder->builder_helper), env);
+ axiom_soap11_builder_helper_free((axiom_soap11_builder_helper_t
+ *) (soap_builder->builder_helper),
+ env);
soap_builder->builder_helper = NULL;
}
- else if (soap_builder->soap_version == AXIOM_SOAP12 && soap_builder->builder_helper)
+ else if (soap_builder->soap_version == AXIOM_SOAP12 &&
+ soap_builder->builder_helper)
{
- axiom_soap12_builder_helper_free((axiom_soap12_builder_helper_t *)(soap_builder->builder_helper), env);
+ axiom_soap12_builder_helper_free((axiom_soap12_builder_helper_t
+ *) (soap_builder->builder_helper),
+ env);
soap_builder->builder_helper = NULL;
}
}
-
- if ( soap_builder->om_builder)
+
+ if (soap_builder->om_builder)
{
axiom_stax_builder_free(soap_builder->om_builder, env);
soap_builder->om_builder = NULL;
}
-
+
if (soap_builder->mime_body_parts)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
const void *key = NULL;
for (hi = axutil_hash_first(soap_builder->mime_body_parts, env);
- hi; hi = axutil_hash_next(env, hi))
+ hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if (key)
{
- AXIS2_FREE(env->allocator, (char*)key);
+ AXIS2_FREE(env->allocator, (char *) key);
}
val = NULL;
@@ -210,13 +221,12 @@
return;
}
-
-AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL
-axiom_soap_builder_get_soap_envelope
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+ axiom_soap_builder_get_soap_envelope(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
- int status = AXIS2_SUCCESS ;
+ int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, NULL);
if (!soap_builder)
@@ -226,7 +236,7 @@
return NULL;
while (!(soap_builder->soap_envelope) &&
- !axiom_stax_builder_is_complete(soap_builder->om_builder, env))
+ !axiom_stax_builder_is_complete(soap_builder->om_builder, env))
{
status = axiom_soap_builder_next(soap_builder, env);
if (status == AXIS2_FAILURE)
@@ -236,10 +246,9 @@
return soap_builder->soap_envelope;
}
-AXIS2_EXTERN axiom_document_t* AXIS2_CALL
-axiom_soap_builder_get_document
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_document_t *AXIS2_CALL axiom_soap_builder_get_document(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
if (!soap_builder)
@@ -253,12 +262,13 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_builder_next(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+axiom_soap_builder_next(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
axiom_node_t *lastnode = NULL;
int current_event = AXIS2_MAX_EVENT;
- axiom_node_t *current_node = NULL;
+ axiom_node_t *current_node = NULL;
int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!soap_builder)
@@ -280,18 +290,23 @@
{
soap_builder->last_node_status = AXIS2_BUILDER_LAST_NODE_NOT_NULL;
}
- current_event = axiom_stax_builder_next_with_token(soap_builder->om_builder, env);
+ current_event =
+ axiom_stax_builder_next_with_token(soap_builder->om_builder, env);
if (current_event == -1)
{
soap_builder->done = AXIS2_TRUE;
return AXIS2_FAILURE;
}
if (current_event == AXIOM_XML_READER_EMPTY_ELEMENT ||
- current_event == AXIOM_XML_READER_START_ELEMENT)
+ current_event == AXIOM_XML_READER_START_ELEMENT)
{
- current_node = axiom_stax_builder_get_lastnode(soap_builder->om_builder, env);
+ current_node =
+ axiom_stax_builder_get_lastnode(soap_builder->om_builder, env);
if (current_node)
- status = axiom_soap_builder_create_om_element(soap_builder, env, current_node, current_event);
+ status =
+ axiom_soap_builder_create_om_element(soap_builder, env,
+ current_node,
+ current_event);
else
return AXIS2_FAILURE;
}
@@ -299,28 +314,24 @@
return status;
}
-AXIS2_EXTERN axiom_node_t* AXIS2_CALL
-axiom_soap_builder_get_document_element
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL axiom_soap_builder_get_document_element(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
if (soap_builder->soap_envelope)
{
- return axiom_soap_envelope_get_base_node(soap_builder->soap_envelope, env);
+ return axiom_soap_envelope_get_base_node(soap_builder->soap_envelope,
+ env);
}
else
return NULL;
}
-
-
axis2_status_t
-axiom_soap_builder_create_om_element
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *current_node,
- int current_event)
+ axiom_soap_builder_create_om_element
+ (axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env, axiom_node_t * current_node, int current_event)
{
int ret_val = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -330,7 +341,9 @@
if (soap_builder->last_node_status == AXIS2_BUILDER_LAST_NODE_NULL)
{
- ret_val = axiom_soap_builder_construct_node(soap_builder, env, NULL, current_node, AXIS2_TRUE);
+ ret_val =
+ axiom_soap_builder_construct_node(soap_builder, env, NULL,
+ current_node, AXIS2_TRUE);
}
else
{
@@ -338,17 +351,23 @@
axiom_node_t *parent_node = NULL;
parent_node = axiom_node_get_parent(current_node, env);
if (!soap_builder->om_builder)
- return AXIS2_FAILURE;
+ return AXIS2_FAILURE;
- element_level = axiom_stax_builder_get_element_level(
- soap_builder->om_builder, env);
- if (parent_node && element_level == 1 && current_event == AXIOM_XML_READER_EMPTY_ELEMENT)
- {
- ret_val = axiom_soap_builder_construct_node_for_empty_element(soap_builder, env, parent_node , current_node);
+ element_level =
+ axiom_stax_builder_get_element_level(soap_builder->om_builder, env);
+ if (parent_node && element_level == 1 &&
+ current_event == AXIOM_XML_READER_EMPTY_ELEMENT)
+ {
+ ret_val =
+ axiom_soap_builder_construct_node_for_empty_element
+ (soap_builder, env, parent_node, current_node);
}
else if (parent_node)
{
- ret_val = axiom_soap_builder_construct_node(soap_builder, env, parent_node , current_node, AXIS2_FALSE);
+ ret_val =
+ axiom_soap_builder_construct_node(soap_builder, env,
+ parent_node, current_node,
+ AXIS2_FALSE);
}
else
return AXIS2_FAILURE;
@@ -357,13 +376,14 @@
}
static axis2_status_t
-axiom_soap_builder_construct_node(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *parent,
- axiom_node_t *om_element_node,
- axis2_bool_t is_soap_envelope)
+axiom_soap_builder_construct_node(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * parent,
+ axiom_node_t * om_element_node,
+ axis2_bool_t is_soap_envelope)
{
- axiom_element_t *parent_ele = NULL;
+ axiom_element_t *parent_ele = NULL;
axis2_char_t *parent_localname = NULL;
axiom_element_t *om_element = NULL;
@@ -379,10 +399,11 @@
if (!soap_builder->om_builder)
return AXIS2_FAILURE;
+
/** get element level of this om element */
- element_level = axiom_stax_builder_get_element_level(
- soap_builder->om_builder, env);
- if (axiom_stax_builder_get_current_event(soap_builder->om_builder, env) ==
+ element_level =
+ axiom_stax_builder_get_element_level(soap_builder->om_builder, env);
+ if (axiom_stax_builder_get_current_event(soap_builder->om_builder, env) ==
AXIOM_XML_READER_EMPTY_ELEMENT)
{
/* if it is an empty element, increase the element level to ensurer processing
@@ -392,7 +413,7 @@
}
/* get om element struct from node */
om_element = (axiom_element_t *)
- axiom_node_get_data_element(om_element_node, env);
+ axiom_node_get_data_element(om_element_node, env);
if (!om_element)
return AXIS2_FAILURE;
/* get element localname */
@@ -404,8 +425,8 @@
if (axutil_strcmp(ele_localname, AXIS2_XOP_INCLUDE) == 0)
{
axiom_namespace_t *ns = NULL;
-
- while(!axiom_node_is_complete(om_element_node, env))
+
+ while (!axiom_node_is_complete(om_element_node, env))
axiom_stax_builder_next_with_token(soap_builder->om_builder, env);
ns = axiom_element_get_namespace(om_element, env, om_element_node);
@@ -421,7 +442,8 @@
if (qname)
{
axis2_char_t *id = NULL;
- id = axiom_element_get_attribute_value(om_element, env, qname);
+ id = axiom_element_get_attribute_value(om_element, env,
+ qname);
if (id)
{
axis2_char_t *pos = NULL;
@@ -432,25 +454,32 @@
id += 4;
if (soap_builder->mime_body_parts)
{
- data_handler = (axiom_data_handler_t *)axutil_hash_get(
- soap_builder->mime_body_parts,
- (void*)id, AXIS2_HASH_KEY_STRING);
+ data_handler =
+ (axiom_data_handler_t *)
+ axutil_hash_get(soap_builder->
+ mime_body_parts,
+ (void *) id,
+ AXIS2_HASH_KEY_STRING);
if (data_handler)
{
axiom_text_t *data_text = NULL;
axiom_node_t *data_om_node = NULL;
- /*remove the <xop:Include> element*/
+ /*remove the <xop:Include> element */
axiom_node_detach(om_element_node, env);
-
- data_text = axiom_text_create_with_data_handler(
- env, parent,
- data_handler, &data_om_node);
-
- axiom_text_set_content_id(data_text, env, id);
- axiom_stax_builder_set_lastnode(
- soap_builder->om_builder, env, parent);
- axiom_node_free_tree(om_element_node, env);
+
+ data_text =
+ axiom_text_create_with_data_handler
+ (env, parent, data_handler,
+ &data_om_node);
+
+ axiom_text_set_content_id(data_text,
+ env, id);
+ axiom_stax_builder_set_lastnode
+ (soap_builder->om_builder, env,
+ parent);
+ axiom_node_free_tree(om_element_node,
+ env);
}
}
@@ -466,18 +495,23 @@
if (parent)
{
+
/** a parent node exist , so not soap envelope element */
- parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent, env);
+ parent_ele =
+ (axiom_element_t *) axiom_node_get_data_element(parent, env);
if (parent_ele)
parent_localname = axiom_element_get_localname(parent_ele, env);
}
if (!parent && is_soap_envelope)
{
+
/** this is the soap envelope element */
- if (axutil_strcasecmp(ele_localname, AXIOM_SOAP_ENVELOPE_LOCAL_NAME) != 0)
+ if (axutil_strcasecmp(ele_localname, AXIOM_SOAP_ENVELOPE_LOCAL_NAME) !=
+ 0)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_MESSAGE_FIRST_ELEMENT_MUST_CONTAIN_LOCAL_NAME, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_MESSAGE_FIRST_ELEMENT_MUST_CONTAIN_LOCAL_NAME,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -485,12 +519,17 @@
soap_builder->soap_envelope = axiom_soap_envelope_create_null(env);
if (!soap_builder->soap_envelope)
return AXIS2_FAILURE;
+
/** wrap this om node in it */
status = axiom_soap_envelope_set_base_node(soap_builder->soap_envelope,
- env, om_element_node);
+ env, om_element_node);
- axiom_soap_envelope_set_builder(soap_builder->soap_envelope, env, soap_builder);
- status = axiom_soap_builder_process_namespace_data(soap_builder, env, om_element_node, AXIS2_TRUE);
+ axiom_soap_envelope_set_builder(soap_builder->soap_envelope, env,
+ soap_builder);
+ status =
+ axiom_soap_builder_process_namespace_data(soap_builder, env,
+ om_element_node,
+ AXIS2_TRUE);
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
}
@@ -498,19 +537,22 @@
{
if (axutil_strcmp(ele_localname, AXIOM_SOAP_HEADER_LOCAL_NAME) == 0)
{
+
/** this is the soap header element */
axiom_soap_header_t *soap_header = NULL;
if (soap_builder->header_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
if (soap_builder->body_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER, AXIS2_FAILURE);
- return AXIS2_FAILURE;
+ AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
}
soap_builder->header_present = AXIS2_TRUE;
@@ -521,14 +563,18 @@
axiom_soap_header_set_base_node(soap_header, env, om_element_node);
- axiom_soap_envelope_set_header(soap_builder->soap_envelope, env, soap_header);
+ axiom_soap_envelope_set_header(soap_builder->soap_envelope, env,
+ soap_header);
axiom_soap_header_set_builder(soap_header, env, soap_builder);
- axiom_soap_header_set_soap_version(soap_header, env, soap_builder->soap_version);
+ axiom_soap_header_set_soap_version(soap_header, env,
+ soap_builder->soap_version);
- status = axiom_soap_builder_process_namespace_data(soap_builder, env,
- om_element_node, AXIS2_TRUE);
+ status =
+ axiom_soap_builder_process_namespace_data(soap_builder, env,
+ om_element_node,
+ AXIS2_TRUE);
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
@@ -540,7 +586,8 @@
if (soap_builder->body_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -554,30 +601,38 @@
axiom_soap_body_set_builder(soap_body, env, soap_builder);
- axiom_soap_envelope_set_body(soap_builder->soap_envelope, env, soap_body);
+ axiom_soap_envelope_set_body(soap_builder->soap_envelope, env,
+ soap_body);
- status = axiom_soap_builder_process_namespace_data(soap_builder, env,
- om_element_node, AXIS2_TRUE);
+ status =
+ axiom_soap_builder_process_namespace_data(soap_builder, env,
+ om_element_node,
+ AXIS2_TRUE);
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
}
- else if ( parent_localname &&
- axutil_strcasecmp(parent_localname, AXIOM_SOAP_HEADER_LOCAL_NAME) &&
- axutil_strcasecmp(parent_localname, AXIOM_SOAP_BODY_LOCAL_NAME))
+ else if (parent_localname &&
+ axutil_strcasecmp(parent_localname,
+ AXIOM_SOAP_HEADER_LOCAL_NAME) &&
+ axutil_strcasecmp(parent_localname,
+ AXIOM_SOAP_BODY_LOCAL_NAME))
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
- else if ((element_level == 3) && parent_localname &&
- axutil_strcasecmp(parent_localname, AXIOM_SOAP_HEADER_LOCAL_NAME) == 0)
+ else if ((element_level == 3) && parent_localname &&
+ axutil_strcasecmp(parent_localname,
+ AXIOM_SOAP_HEADER_LOCAL_NAME) == 0)
{
axiom_soap_header_block_t *header_block = NULL;
axiom_soap_header_t *soap_header = NULL;
- soap_header = axiom_soap_envelope_get_header(soap_builder->soap_envelope, env);
+ soap_header =
+ axiom_soap_envelope_get_header(soap_builder->soap_envelope, env);
if (!soap_header)
return AXIS2_FAILURE;
@@ -585,27 +640,32 @@
if (!header_block)
return AXIS2_FAILURE;
- axiom_soap_header_block_set_base_node(header_block, env, om_element_node);
+ axiom_soap_header_block_set_base_node(header_block, env,
+ om_element_node);
axiom_soap_header_set_header_block(soap_header, env, header_block);
- axiom_soap_header_block_set_soap_version(header_block, env, soap_builder->soap_version);
-
+ axiom_soap_header_block_set_soap_version(header_block, env,
+ soap_builder->soap_version);
}
else if ((element_level == 3) && parent_localname &&
- axutil_strcasecmp(parent_localname, AXIOM_SOAP_BODY_LOCAL_NAME) == 0 &&
- axutil_strcasecmp(ele_localname, AXIOM_SOAP_BODY_FAULT_LOCAL_NAME) == 0)
+ axutil_strcasecmp(parent_localname,
+ AXIOM_SOAP_BODY_LOCAL_NAME) == 0 &&
+ axutil_strcasecmp(ele_localname,
+ AXIOM_SOAP_BODY_FAULT_LOCAL_NAME) == 0)
{
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axiom_namespace_t *env_ns = NULL;
- env_ns = axiom_soap_envelope_get_namespace(soap_builder->soap_envelope, env);
+ env_ns =
+ axiom_soap_envelope_get_namespace(soap_builder->soap_envelope, env);
if (!env_ns)
return AXIS2_FAILURE;
- soap_body = axiom_soap_envelope_get_body(soap_builder->soap_envelope, env);
+ soap_body =
+ axiom_soap_envelope_get_body(soap_builder->soap_envelope, env);
if (!soap_body)
return AXIS2_FAILURE;
@@ -617,7 +677,7 @@
axiom_soap_fault_set_base_node(soap_fault, env, om_element_node);
axiom_soap_body_set_fault(soap_body, env, soap_fault);
-
+
axiom_soap_fault_set_builder(soap_fault, env, soap_builder);
soap_builder->processing_fault = AXIS2_TRUE;
@@ -625,16 +685,19 @@
soap_builder->processing_mandatory_fault_elements = AXIS2_TRUE;
if (axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI,
- axiom_namespace_get_uri(env_ns , env)) == 0)
+ axiom_namespace_get_uri(env_ns, env)) == 0)
{
- soap_builder->builder_helper = axiom_soap12_builder_helper_create(env, soap_builder);
+ soap_builder->builder_helper =
+ axiom_soap12_builder_helper_create(env, soap_builder);
if (!(soap_builder->builder_helper))
return AXIS2_FAILURE;
}
else if (axutil_strcmp(AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI,
- axiom_namespace_get_uri(env_ns , env)) == 0)
+ axiom_namespace_get_uri(env_ns, env)) == 0)
{
- soap_builder->builder_helper = axiom_soap11_builder_helper_create(env, soap_builder, soap_builder->om_builder);
+ soap_builder->builder_helper =
+ axiom_soap11_builder_helper_create(env, soap_builder,
+ soap_builder->om_builder);
if (!(soap_builder->builder_helper))
return AXIS2_FAILURE;
}
@@ -644,28 +707,23 @@
{
if (soap_builder->soap_version == AXIOM_SOAP11)
{
- status = axiom_soap11_builder_helper_handle_event(
- ((axiom_soap11_builder_helper_t*)(soap_builder->builder_helper)),
- env, om_element_node , element_level);
+ status = axiom_soap11_builder_helper_handle_event(((axiom_soap11_builder_helper_t *) (soap_builder->builder_helper)), env, om_element_node, element_level);
}
else if (soap_builder->soap_version == AXIOM_SOAP12)
{
- status = axiom_soap12_builder_helper_handle_event(
- ((axiom_soap12_builder_helper_t *)(soap_builder->builder_helper)),
- env, om_element_node , element_level);
+ status = axiom_soap12_builder_helper_handle_event(((axiom_soap12_builder_helper_t *) (soap_builder->builder_helper)), env, om_element_node, element_level);
}
}
return status;
}
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_builder_process_namespace_data
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *om_node,
- int is_soap_element)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_builder_process_namespace_data(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * om_node,
+ int is_soap_element)
{
axiom_element_t *om_ele = NULL;
axiom_namespace_t *om_ns = NULL;
@@ -689,11 +747,16 @@
{
ns_uri = axiom_namespace_get_uri(om_ns, env);
if (ns_uri &&
- (axutil_strcmp(ns_uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) != 0) &&
- (axutil_strcmp(ns_uri, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) != 0))
+ (axutil_strcmp
+ (ns_uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) != 0) &&
+ (axutil_strcmp
+ (ns_uri, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) != 0))
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI, AXIS2_FAILURE);
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI");
+ AXIS2_ERROR_SET(env->error,
+ AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI,
+ AXIS2_FAILURE);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI");
return AXIS2_FAILURE;
}
@@ -704,36 +767,42 @@
}
static axis2_status_t
-axiom_soap_builder_identify_soap_version(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- const axis2_char_t* soap_version_uri_from_transport)
+axiom_soap_builder_identify_soap_version(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ const axis2_char_t * soap_version_uri_from_transport)
{
axiom_namespace_t *om_ns = NULL;
axiom_node_t *envelope_node = NULL;
axiom_element_t *om_ele = NULL;
axis2_char_t *ns_uri = NULL;
- AXIS2_PARAM_CHECK(env->error, soap_version_uri_from_transport, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_version_uri_from_transport,
+ AXIS2_FAILURE);
if (!soap_builder)
return AXIS2_FAILURE;
- soap_builder->soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env);
+ soap_builder->soap_envelope =
+ axiom_soap_builder_get_soap_envelope(soap_builder, env);
if (soap_builder->soap_envelope == NULL)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_MESSAGE_DOES_NOT_CONTAIN_AN_ENVELOPE, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_MESSAGE_DOES_NOT_CONTAIN_AN_ENVELOPE,
+ AXIS2_FAILURE);
AXIS2_LOG_CRITICAL(env->log, AXIS2_LOG_SI,
- "SOAP message does not have a SOAP envelope element ");
+ "SOAP message does not have a SOAP envelope element ");
return AXIS2_FAILURE;
}
- envelope_node = axiom_soap_envelope_get_base_node(soap_builder->soap_envelope, env);
+ envelope_node =
+ axiom_soap_envelope_get_base_node(soap_builder->soap_envelope, env);
if (!envelope_node)
return AXIS2_FAILURE;
- om_ele = (axiom_element_t *) axiom_node_get_data_element(envelope_node, env);
+ om_ele =
+ (axiom_element_t *) axiom_node_get_data_element(envelope_node, env);
if (!om_ele)
return AXIS2_FAILURE;
@@ -745,34 +814,44 @@
if (ns_uri)
{
- if (soap_version_uri_from_transport && axutil_strcmp(soap_version_uri_from_transport, ns_uri) != 0)
+ if (soap_version_uri_from_transport &&
+ axutil_strcmp(soap_version_uri_from_transport, ns_uri) != 0)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP, AXIS2_FAILURE);
+ AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP,
+ AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log , AXIS2_LOG_SI,
- "AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "AXIS2_ERROR_TRANSPORT_LEVEL_INFORMATION_DOES_NOT_MATCH_WITH_SOAP");
return AXIS2_FAILURE;
}
- if (axutil_strcmp(AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri) == 0)
+ if (axutil_strcmp(AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri) ==
+ 0)
{
soap_builder->soap_version = AXIOM_SOAP11;
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Identified soap version is soap11");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "Identified soap version is soap11");
- axiom_soap_envelope_set_soap_version_internal(soap_builder->soap_envelope,
- env, soap_builder->soap_version);
+ axiom_soap_envelope_set_soap_version_internal(soap_builder->
+ soap_envelope, env,
+ soap_builder->
+ soap_version);
return AXIS2_SUCCESS;
}
- else if (axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri) == 0)
+ else if (axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, ns_uri)
+ == 0)
{
soap_builder->soap_version = AXIOM_SOAP12;
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "identified soap version is soap12");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "identified soap version is soap12");
- axiom_soap_envelope_set_soap_version_internal(soap_builder->soap_envelope,
- env, soap_builder->soap_version);
+ axiom_soap_envelope_set_soap_version_internal(soap_builder->
+ soap_envelope, env,
+ soap_builder->
+ soap_version);
return AXIS2_SUCCESS;
}
@@ -781,21 +860,24 @@
}
static axis2_status_t
-axiom_soap_builder_parse_headers(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+axiom_soap_builder_parse_headers(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
axiom_node_t *om_node = NULL;
axiom_soap_header_t *soap_header = NULL;
int status = AXIS2_SUCCESS;
if (!soap_builder)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
if (!soap_builder->soap_envelope)
return AXIS2_FAILURE;
- soap_header = axiom_soap_envelope_get_header(soap_builder->soap_envelope, env);
+ soap_header =
+ axiom_soap_envelope_get_header(soap_builder->soap_envelope, env);
if (soap_header)
{
@@ -808,21 +890,21 @@
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
}
- /*HACK: to fix AXIS2C-129 - Samisa*/
+ /*HACK: to fix AXIS2C-129 - Samisa */
/*
- axiom_stax_builder_set_element_level(
- soap_builder->om_builder, env, 1);
- */
+ axiom_stax_builder_set_element_level(
+ soap_builder->om_builder, env, 1);
+ */
}
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_builder_set_bool_processing_mandatory_fault_elements
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axis2_bool_t value)
+ axiom_soap_builder_set_bool_processing_mandatory_fault_elements(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axis2_bool_t value)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
soap_builder->processing_mandatory_fault_elements = value;
@@ -830,10 +912,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_builder_set_processing_detail_elements
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axis2_bool_t value)
+ axiom_soap_builder_set_processing_detail_elements(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axis2_bool_t value)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
soap_builder->processing_detail_elements = value;
@@ -841,41 +923,40 @@
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_soap_builder_is_processing_detail_elements
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+ axiom_soap_builder_is_processing_detail_elements(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- return soap_builder->processing_detail_elements ;
+ return soap_builder->processing_detail_elements;
}
AXIS2_EXTERN int AXIS2_CALL
-axiom_soap_builder_get_soap_version(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env)
+axiom_soap_builder_get_soap_version(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- return soap_builder->soap_version ;
+ return soap_builder->soap_version;
}
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_builder_set_mime_body_parts
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axutil_hash_t *map)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_builder_set_mime_body_parts(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axutil_hash_t * map)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
soap_builder->mime_body_parts = map;
return AXIS2_SUCCESS;
}
-static axis2_status_t
-axiom_soap_builder_construct_node_for_empty_element
-(axiom_soap_builder_t *soap_builder,
- const axutil_env_t *env,
- axiom_node_t *parent,
- axiom_node_t *om_element_node)
+static axis2_status_t axiom_soap_builder_construct_node_for_empty_element(
+ axiom_soap_builder_t * soap_builder,
+ const axutil_env_t * env,
+ axiom_node_t * parent,
+ axiom_node_t * om_element_node)
{
- axiom_element_t *parent_ele = NULL;
+ axiom_element_t *parent_ele = NULL;
axis2_char_t *parent_localname = NULL;
axiom_element_t *om_element = NULL;
@@ -892,11 +973,11 @@
if (!soap_builder->om_builder)
return AXIS2_FAILURE;
- element_level = axiom_stax_builder_get_element_level(
- soap_builder->om_builder, env);
+ element_level =
+ axiom_stax_builder_get_element_level(soap_builder->om_builder, env);
om_element = (axiom_element_t *)
- axiom_node_get_data_element(om_element_node, env);
+ axiom_node_get_data_element(om_element_node, env);
if (!om_element)
return AXIS2_FAILURE;
@@ -907,8 +988,7 @@
if (!parent)
return AXIS2_FAILURE;
-
- parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent, env);
+ parent_ele = (axiom_element_t *) axiom_node_get_data_element(parent, env);
if (!parent_ele)
return AXIS2_FAILURE;
@@ -920,19 +1000,22 @@
{
if (axutil_strcmp(ele_localname, AXIOM_SOAP_HEADER_LOCAL_NAME) == 0)
{
+
/** this is the soap header element */
axiom_soap_header_t *soap_header = NULL;
if (soap_builder->header_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_HEADERS_ENCOUNTERED,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
if (soap_builder->body_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER, AXIS2_FAILURE);
- return AXIS2_FAILURE;
+ AXIS2_ERROR_SOAP_BUILDER_HEADER_BODY_WRONG_ORDER,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
}
soap_builder->header_present = AXIS2_TRUE;
@@ -943,14 +1026,18 @@
axiom_soap_header_set_base_node(soap_header, env, om_element_node);
- axiom_soap_envelope_set_header(soap_builder->soap_envelope, env, soap_header);
+ axiom_soap_envelope_set_header(soap_builder->soap_envelope, env,
+ soap_header);
axiom_soap_header_set_builder(soap_header, env, soap_builder);
- axiom_soap_header_set_soap_version(soap_header, env, soap_builder->soap_version);
+ axiom_soap_header_set_soap_version(soap_header, env,
+ soap_builder->soap_version);
- status = axiom_soap_builder_process_namespace_data(soap_builder, env,
- om_element_node, AXIS2_TRUE);
+ status =
+ axiom_soap_builder_process_namespace_data(soap_builder, env,
+ om_element_node,
+ AXIS2_TRUE);
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
@@ -962,7 +1049,8 @@
if (soap_builder->body_present)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_MULTIPLE_BODY_ELEMENTS_ENCOUNTERED,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -976,10 +1064,13 @@
axiom_soap_body_set_builder(soap_body, env, soap_builder);
- axiom_soap_envelope_set_body(soap_builder->soap_envelope, env, soap_body);
+ axiom_soap_envelope_set_body(soap_builder->soap_envelope, env,
+ soap_body);
- status = axiom_soap_builder_process_namespace_data(soap_builder, env,
- om_element_node, AXIS2_TRUE);
+ status =
+ axiom_soap_builder_process_namespace_data(soap_builder, env,
+ om_element_node,
+ AXIS2_TRUE);
if (status == AXIS2_FAILURE)
return AXIS2_FAILURE;
@@ -987,7 +1078,8 @@
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY, AXIS2_FAILURE);
+ AXIS2_ERROR_SOAP_BUILDER_ENVELOPE_CAN_HAVE_ONLY_HEADER_AND_BODY,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -43,19 +44,20 @@
/* pointer to soap builder */
axiom_soap_builder_t *soap_builder;
};
-static axis2_status_t
-check_and_set_soap_version(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_namespace_t *ns);
-
-AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL
-axiom_soap_envelope_create_null(const axutil_env_t *env)
+static axis2_status_t check_and_set_soap_version(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_namespace_t * ns);
+
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+axiom_soap_envelope_create_null(
+ const axutil_env_t * env)
{
axiom_soap_envelope_t *soap_envelope = NULL;
AXIS2_ENV_CHECK(env, NULL);
- soap_envelope = (axiom_soap_envelope_t*)AXIS2_MALLOC(
- env->allocator,
- sizeof(axiom_soap_envelope_t));
+ soap_envelope = (axiom_soap_envelope_t *) AXIS2_MALLOC(env->allocator,
+ sizeof
+ (axiom_soap_envelope_t));
if (!soap_envelope)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -70,10 +72,10 @@
return soap_envelope;
}
-
-AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL
-axiom_soap_envelope_create(const axutil_env_t *env,
- axiom_namespace_t *ns)
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+axiom_soap_envelope_create(
+ const axutil_env_t * env,
+ axiom_namespace_t * ns)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_element_t *ele = NULL;
@@ -85,7 +87,7 @@
if (!soap_envelope)
return NULL;
- status = check_and_set_soap_version(soap_envelope, env, ns);
+ status = check_and_set_soap_version(soap_envelope, env, ns);
if (status == AXIS2_FAILURE)
{
AXIS2_FREE(env->allocator, soap_envelope);
@@ -93,8 +95,8 @@
}
ele = axiom_element_create(env, NULL,
- AXIOM_SOAP_ENVELOPE_LOCAL_NAME, ns,
- &(soap_envelope->om_ele_node));
+ AXIOM_SOAP_ENVELOPE_LOCAL_NAME, ns,
+ &(soap_envelope->om_ele_node));
if (!ele)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -104,14 +106,15 @@
return soap_envelope;
}
-AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL
-axiom_soap_envelope_create_with_soap_version_prefix(const axutil_env_t *env,
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+axiom_soap_envelope_create_with_soap_version_prefix(
+ const axutil_env_t * env,
int soap_version,
- const axis2_char_t *prefix)
+ const axis2_char_t * prefix)
{
- axiom_namespace_t *ns = NULL;
+ axiom_namespace_t *ns = NULL;
const axis2_char_t *ns_prefix = NULL;
- const axis2_char_t *ns_uri = NULL;
+ const axis2_char_t *ns_uri = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (soap_version == AXIOM_SOAP11)
{
@@ -123,7 +126,8 @@
}
else
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOAP_VERSION,
+ AXIS2_FAILURE);
return NULL;
}
if (!prefix || axutil_strcmp(prefix, "") == 0)
@@ -142,8 +146,9 @@
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_soap_envelope_free(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+axiom_soap_envelope_free(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -172,24 +177,27 @@
return;
}
-AXIS2_EXTERN axiom_node_t* AXIS2_CALL
-axiom_soap_envelope_get_base_node(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+axiom_soap_envelope_get_base_node(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
return soap_envelope->om_ele_node;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_set_base_node(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_node_t *node)
+axiom_soap_envelope_set_base_node(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_node_t * node)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
soap_envelope->om_ele_node = node;
@@ -197,16 +205,18 @@
}
AXIS2_EXTERN int AXIS2_CALL
-axiom_soap_envelope_get_soap_version(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+axiom_soap_envelope_get_soap_version(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
return soap_envelope->soap_version;
}
/** this is an internal function */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_set_soap_version_internal(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
+axiom_soap_envelope_set_soap_version_internal(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
int soap_version)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -215,9 +225,10 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axiom_soap_header_t* AXIS2_CALL
-axiom_soap_envelope_get_header(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_soap_header_t *AXIS2_CALL
+axiom_soap_envelope_get_header(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
int status = AXIS2_SUCCESS;
@@ -227,8 +238,8 @@
}
else if (soap_envelope->soap_builder)
{
- while (!(soap_envelope->header) && !(soap_envelope->body)
- && !axiom_node_is_complete(soap_envelope->om_ele_node, env))
+ while (!(soap_envelope->header) && !(soap_envelope->body)
+ && !axiom_node_is_complete(soap_envelope->om_ele_node, env))
{
status = axiom_soap_builder_next(soap_envelope->soap_builder, env);
if (status == AXIS2_FAILURE)
@@ -239,11 +250,12 @@
return soap_envelope->header;
}
-AXIS2_EXTERN axiom_soap_header_block_t* AXIS2_CALL
-axiom_soap_envelope_add_header(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axis2_char_t *namespace_uri,
- axis2_char_t *name)
+AXIS2_EXTERN axiom_soap_header_block_t *AXIS2_CALL
+axiom_soap_envelope_add_header(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axis2_char_t * namespace_uri,
+ axis2_char_t * name)
{
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -256,12 +268,14 @@
ns = axiom_namespace_create(env, namespace_uri, NULL);
}
- return axiom_soap_header_block_create_with_parent(env, name, ns, soap_envelope->header);
+ return axiom_soap_header_block_create_with_parent(env, name, ns,
+ soap_envelope->header);
}
-AXIS2_EXTERN axiom_soap_body_t* AXIS2_CALL
-axiom_soap_envelope_get_body(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_soap_body_t *AXIS2_CALL
+axiom_soap_envelope_get_body(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
int status = AXIS2_SUCCESS;
@@ -271,7 +285,8 @@
}
else if (soap_envelope->soap_builder)
{
- while (!(soap_envelope->body) && !axiom_node_is_complete(soap_envelope->om_ele_node, env))
+ while (!(soap_envelope->body) &&
+ !axiom_node_is_complete(soap_envelope->om_ele_node, env))
{
status = axiom_soap_builder_next(soap_envelope->soap_builder, env);
if (status == AXIS2_FAILURE)
@@ -284,9 +299,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_serialize(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_output_t *om_output,
+axiom_soap_envelope_serialize(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_output_t * om_output,
axis2_bool_t cache)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -298,25 +314,26 @@
This is done because the builder construct a soap12 fault all
the time. So when serializing if the soap version is soap11
we should convert it back to soap11 fault
- */
+ */
if (soap_envelope->soap_version == AXIOM_SOAP11)
{
axiom_soap_body_t *soap_body = NULL;
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
- axiom_soap_body_convert_fault_to_soap11(soap_body, env);
+ axiom_soap_body_convert_fault_to_soap11(soap_body, env);
}
/* write the xml version and encoding
These should be set to om output before calling the serialize function
Otherwise default values will be written
- */
+ */
axiom_output_get_content_type(om_output, env);
return axiom_node_serialize(soap_envelope->om_ele_node, env, om_output);
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_set_body(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_soap_body_t *body)
+axiom_soap_envelope_set_body(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_soap_body_t * body)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -327,14 +344,17 @@
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "trying to set a soap bedy to soap_envelope when a soap body alrady exists");
+ "trying to set a soap bedy to soap_envelope when a soap body alrady exists");
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_envelope_set_header(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env, axiom_soap_header_t *header)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_envelope_set_header(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_soap_header_t * header)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -345,27 +365,33 @@
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- " trying to set a soap header to soap_envelope when a soap header alrady exists");
+ " trying to set a soap header to soap_envelope when a soap header alrady exists");
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL
-axiom_soap_envelope_get_namespace(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
+axiom_soap_envelope_get_namespace(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
if (soap_envelope->om_ele_node)
{
axiom_element_t *ele = NULL;
- if (axiom_node_get_node_type(soap_envelope->om_ele_node, env) == AXIOM_ELEMENT)
+ if (axiom_node_get_node_type(soap_envelope->om_ele_node, env) ==
+ AXIOM_ELEMENT)
{
- ele = (axiom_element_t*)axiom_node_get_data_element(soap_envelope->om_ele_node, env);
+ ele =
+ (axiom_element_t *) axiom_node_get_data_element(soap_envelope->
+ om_ele_node,
+ env);
if (ele)
{
- return axiom_element_get_namespace(ele, env, soap_envelope->om_ele_node);
+ return axiom_element_get_namespace(ele, env,
+ soap_envelope->om_ele_node);
}
}
}
@@ -373,9 +399,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_set_builder(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_soap_builder_t *soap_builder)
+axiom_soap_envelope_set_builder(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_soap_builder_t * soap_builder)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, soap_builder, AXIS2_FAILURE);
@@ -383,8 +410,9 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axiom_soap_envelope_t * AXIS2_CALL
-axiom_soap_envelope_create_default_soap_envelope(const axutil_env_t *env,
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+axiom_soap_envelope_create_default_soap_envelope(
+ const axutil_env_t * env,
int soap_version)
{
axiom_soap_envelope_t *soap_envelope = NULL;
@@ -395,14 +423,14 @@
if (soap_version == AXIOM_SOAP11)
{
om_ns = axiom_namespace_create(env,
- AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI,
- AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
+ AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI,
+ AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
if (!om_ns)
return NULL;
soap_envelope = axiom_soap_envelope_create(env, om_ns);
soap_header = axiom_soap_header_create_with_parent(env, soap_envelope);
- soap_body = axiom_soap_body_create_with_parent(env, soap_envelope);
+ soap_body = axiom_soap_body_create_with_parent(env, soap_envelope);
soap_envelope->body = soap_body;
soap_envelope->header = soap_header;
return soap_envelope;
@@ -410,31 +438,32 @@
else if (soap_version == AXIOM_SOAP12)
{
om_ns = axiom_namespace_create(env,
- AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI,
- AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
+ AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI,
+ AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
if (!om_ns)
return NULL;
soap_envelope = axiom_soap_envelope_create(env, om_ns);
soap_header = axiom_soap_header_create_with_parent(env, soap_envelope);
- soap_body = axiom_soap_body_create_with_parent(env, soap_envelope);
+ soap_body = axiom_soap_body_create_with_parent(env, soap_envelope);
soap_envelope->body = soap_body;
soap_envelope->header = soap_header;
return soap_envelope;
}
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE);
return NULL;
}
-AXIS2_EXTERN axiom_soap_envelope_t * AXIS2_CALL
-axiom_soap_envelope_create_default_soap_fault_envelope(const axutil_env_t *env,
- const axis2_char_t *code_value,
- const axis2_char_t *reason_text,
+AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+axiom_soap_envelope_create_default_soap_fault_envelope(
+ const axutil_env_t * env,
+ const axis2_char_t * code_value,
+ const axis2_char_t * reason_text,
const int soap_version,
- axutil_array_list_t *sub_codes,
- axiom_node_t *detail_node)
+ axutil_array_list_t * sub_codes,
+ axiom_node_t * detail_node)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
@@ -444,11 +473,12 @@
if (AXIOM_SOAP11 != soap_version && AXIOM_SOAP12 != soap_version)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_SOAP_VERSION, AXIS2_FAILURE);
return NULL;
}
- soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, soap_version);
+ soap_envelope =
+ axiom_soap_envelope_create_default_soap_envelope(env, soap_version);
if (!soap_envelope)
{
return NULL;
@@ -461,7 +491,8 @@
return NULL;
}
fault = axiom_soap_fault_create_default_fault(env, soap_body,
- code_value, reason_text, soap_version);
+ code_value, reason_text,
+ soap_version);
if (!fault)
{
axiom_soap_envelope_free(soap_envelope, env);
@@ -477,10 +508,13 @@
{
for (i = 0; i < axutil_array_list_size(sub_codes, env); i++)
{
- axis2_char_t *sub_code = (axis2_char_t*) axutil_array_list_get(sub_codes, env, i);
+ axis2_char_t *sub_code =
+ (axis2_char_t *) axutil_array_list_get(sub_codes, env, i);
if (sub_code)
{
- axiom_soap_fault_sub_code_create_with_parent_value(env, fault_code, sub_code);
+ axiom_soap_fault_sub_code_create_with_parent_value(env,
+ fault_code,
+ sub_code);
}
}
}
@@ -501,9 +535,10 @@
}
static axis2_status_t
-check_and_set_soap_version(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
- axiom_namespace_t *ns)
+check_and_set_soap_version(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
+ axiom_namespace_t * ns)
{
axis2_char_t *uri = NULL;
if (!soap_envelope)
@@ -528,19 +563,20 @@
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_SOAP_NAMESPACE_URI, AXIS2_FAILURE);
}
return AXIS2_FAILURE;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_soap_envelope_set_soap_version(axiom_soap_envelope_t *soap_envelope,
- const axutil_env_t *env,
+axiom_soap_envelope_set_soap_version(
+ axiom_soap_envelope_t * soap_envelope,
+ const axutil_env_t * env,
int soap_version)
{
- axiom_element_t *env_ele = NULL;
+ axiom_element_t *env_ele = NULL;
axiom_namespace_t *env_ns = NULL;
- const axis2_char_t *ns_uri = NULL;
+ const axis2_char_t *ns_uri = NULL;
int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -553,28 +589,28 @@
ns_uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
}
else
- {
+ {
return AXIS2_FAILURE;
}
- env_ele = (axiom_element_t*)
- axiom_node_get_data_element(soap_envelope->om_ele_node,
- env);
+ env_ele = (axiom_element_t *)
+ axiom_node_get_data_element(soap_envelope->om_ele_node, env);
if (!env_ele)
{
return AXIS2_FAILURE;
}
- env_ns = axiom_element_get_namespace(env_ele, env, soap_envelope->om_ele_node);
+ env_ns =
+ axiom_element_get_namespace(env_ele, env, soap_envelope->om_ele_node);
if (!env_ns)
return AXIS2_FAILURE;
status = axiom_namespace_set_uri(env_ns, env, ns_uri);
if (status == AXIS2_SUCCESS)
{
- axiom_soap_envelope_set_soap_version_internal(soap_envelope, env, soap_version);
+ axiom_soap_envelope_set_soap_version_internal(soap_envelope, env,
+ soap_version);
return AXIS2_SUCCESS;
}
return AXIS2_FAILURE;
}
-
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org