/**
* Verify that an addressing element is located in <Envelope>/<Header>
*/
int verify_addr_hdr_elem_loc(axiom_node_t *signed_node, const axutil_env_t *env, axis2_char_t *ref) {
axiom_node_t *parent = axiom_node_get_parent(signed_node,env);
if(axutil_strcmp(OXS_NODE_HEADER, axiom_util_get_localname(parent, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of addressing elem is %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed addressing elem with ID = %s", ref);
return 1;
}
parent = axiom_node_get_parent(parent,env);
if(axutil_strcmp(OXS_NODE_ENVELOPE, axiom_util_get_localname(parent, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] second parent of addressing elem is %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed addressing elem with ID = %s", ref);
return 1;
}
parent = axiom_node_get_parent(parent,env);
if(parent) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of Envelope = %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed Body with ID = %s", ref);
return 1;
}
return 0;
}
/**
* First find the root of the scope node. Traverse thru the root node and its
* children. Check if the element has the given qname and has a attribute
* equal to the given values.
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param e_name element name
* @param e_ns element namespace. If NULL doesn't consider the namespaces
* @param attr_name the attribute name of the node
* @param attr_val the attribute value of the node
* @param attr_ns the attribute namespace. If NULL doesn't consider namespaces.
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t * AXIS2_CALL
oxs_axiom_get_first_node_by_name_and_attr_val_from_xml_doc(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *e_name,
axis2_char_t *e_ns,
axis2_char_t *attr_name,
axis2_char_t *attr_val,
axis2_char_t *attr_ns)
{
axiom_node_t *p = NULL;
axiom_node_t *root = NULL;
/* find the root node */
p = node;
do
{
root = p;
p = axiom_node_get_parent(root, env);
} while (p);
/* from the root node, find the node with name and attribute value */
return oxs_axiom_get_first_node_by_name_and_attr_val(
env, root, e_name, e_ns, attr_name, attr_val, attr_ns);
}
static axiom_node_t *
axiom_stax_builder_create_om_element(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env,
axis2_bool_t is_empty)
{
axiom_node_t *element_node = NULL;
axiom_element_t *om_ele = NULL;
axis2_char_t *temp_localname = NULL;
axiom_node_t *parent = NULL;
temp_localname = axiom_xml_reader_get_name(om_builder->parser, env);
if(!temp_localname)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find name of the element");
return NULL;
}
om_builder->element_level++;
if(om_builder->lastnode)
{
if(axiom_node_is_complete(om_builder->lastnode, env))
{
/*previous node building is finished. This node should be a sibling of previous node */
parent = axiom_node_get_parent(om_builder->lastnode, env);
}
else
{
/*previous node building is not finished. This should be child of previous node */
parent = om_builder->lastnode;
}
}
om_ele = axiom_element_create(env, parent, temp_localname, NULL, &element_node);
axiom_xml_reader_xml_free(om_builder->parser, env, temp_localname);
if((!om_ele) || (!element_node))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create axiom element");
return NULL;
}
axiom_node_set_builder(element_node, env, om_builder);
axiom_element_set_is_empty(om_ele, env, is_empty);
if(!om_builder->lastnode)
{
/* since last node is null, this should be the root node */
om_builder->root_node = element_node;
axiom_document_set_root_element(om_builder->document, env, element_node);
}
/* order of processing name spaces first (before processing attributes) is important */
axiom_stax_builder_process_namespaces(om_builder, env, element_node, 0);
axiom_stax_builder_process_attributes(om_builder, env, element_node);
om_builder->lastnode = element_node;
return element_node;
}
static axiom_node_t *
axiom_stax_builder_create_om_text(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axis2_char_t *temp_value = NULL;
axutil_string_t *temp_value_str = NULL;
axiom_node_t *node = NULL;
axiom_node_t *parent = om_builder->lastnode;
if(!parent)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BUILDER_STATE_LAST_NODE_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text without a node");
return NULL;
}
temp_value = axiom_xml_reader_get_value(om_builder->parser, env);
if(!temp_value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_VALUE_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid OM Text value");
return NULL;
}
#ifdef AXIS2_LIBXML2_ENABLED
temp_value_str = axutil_string_create(env, temp_value);
axiom_xml_reader_xml_free(om_builder->parser, env, temp_value);
#else
temp_value_str = axutil_string_create_assume_ownership(env, &temp_value);
#endif
if(!temp_value_str)
{
/* axutil_string_create will have set an error number */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text value");
return NULL;
}
if(axiom_node_is_complete(parent, env))
{
parent = axiom_node_get_parent(om_builder->lastnode, env);
}
axiom_text_create_str(env, parent, temp_value_str, &node);
axutil_string_free(temp_value_str, env);
if(!node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create axiom_text");
return NULL;
}
axiom_node_set_builder(node, env, om_builder);
axiom_node_set_complete(node, env, AXIS2_TRUE);
om_builder->lastnode = node;
return node;
}
/** this method encapsulate searching logic */
static void
axiom_navigator_update_next_node(
axiom_navigator_t * om_navigator,
const axutil_env_t * env)
{
if (!om_navigator)
{
return;
}
if (!om_navigator->next)
{
return;
}
if ((AXIOM_ELEMENT == axiom_node_get_node_type(om_navigator->next, env)) &&
!(om_navigator->visited))
{
if (axiom_node_get_first_child(om_navigator->next, env))
{
om_navigator->next =
axiom_node_get_first_child(om_navigator->next, env);
}
else if (AXIS2_TRUE == axiom_node_is_complete(om_navigator->next, env))
{
om_navigator->backtracked = AXIS2_TRUE;
}
else
{
om_navigator->next = NULL;
}
}
else
{
axiom_node_t *parent = NULL;
axiom_node_t *next_sibling = NULL;
next_sibling = axiom_node_get_next_sibling(om_navigator->next, env);
parent = axiom_node_get_parent(om_navigator->next, env);
if (next_sibling)
{
om_navigator->next = next_sibling;
}
else if ((parent) && axiom_node_is_complete(parent, env))
{
om_navigator->next = parent;
om_navigator->backtracked = AXIS2_TRUE;
}
else
{
om_navigator->next = NULL;
}
}
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
oxs_xml_enc_decrypt_node(
const axutil_env_t *env,
oxs_ctx_t * enc_ctx,
axiom_node_t *enc_type_node,
axiom_node_t **decrypted_node)
{
axiom_node_t *deserialized_node = NULL;
axiom_node_t *parent_of_enc_node = NULL;
oxs_buffer_t *result_buf = NULL;
axis2_char_t *decrypted_data = NULL;/*Can be either am XML-Element or XML-Content*/
axis2_status_t status = AXIS2_FAILURE;
/*Create an empty buffer for results*/
result_buf = oxs_buffer_create(env);
/*Decrypt*/
status = oxs_xml_enc_decrypt_data(env, enc_ctx, enc_type_node, result_buf);
if(AXIS2_FAILURE == status)
{
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Data encryption failed");
return AXIS2_FAILURE;
}
decrypted_data = axutil_strmemdup(oxs_buffer_get_data(result_buf, env), oxs_buffer_get_size(
result_buf, env), env);
/*De-serialize the decrypted content to build the node*/
deserialized_node = (axiom_node_t*)oxs_axiom_deserialize_node(env, decrypted_data);
if(!deserialized_node)
{
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
"Cannot deserialize a node from the content.\n%s", decrypted_data);
return AXIS2_FAILURE;
}
/*Assign deserialized_node to the reference passed*/
*decrypted_node = deserialized_node;
/*Replace the encrypted node with the de-serialized node*/
parent_of_enc_node = axiom_node_get_parent(enc_type_node, env);
axiom_node_insert_sibling_after(enc_type_node, env, deserialized_node);
axiom_node_free_tree(enc_type_node, env);
enc_type_node = NULL;
/*Free result buf*/
oxs_buffer_free(result_buf, env);
result_buf = NULL;
AXIS2_FREE(env->allocator, decrypted_data);
decrypted_data = NULL;
return AXIS2_SUCCESS;
}
static axiom_node_t *
axiom_stax_builder_create_om_processing_instruction(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axiom_node_t *pi_node = NULL;
axis2_char_t *target = NULL;
axis2_char_t *value = NULL;
target = axiom_xml_reader_get_pi_target(om_builder->parser, env);
value = axiom_xml_reader_get_pi_data(om_builder->parser, env);
if(!target)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL, AXIS2_FAILURE);
return NULL;
}
if(!om_builder->lastnode)
{
/* do nothing */
axiom_xml_reader_xml_free(om_builder->parser, env, target);
axiom_xml_reader_xml_free(om_builder->parser, env, value);
return NULL;
}
else if(axiom_node_is_complete(om_builder->lastnode, env)
|| (axiom_node_get_node_type(om_builder->lastnode, env) == AXIOM_TEXT))
{
axiom_processing_instruction_create(env, axiom_node_get_parent(om_builder-> lastnode, env),
target, value, &pi_node);
axiom_node_set_next_sibling(om_builder->lastnode, env, pi_node);
axiom_node_set_previous_sibling(pi_node, env, om_builder->lastnode);
}
else
{
axiom_processing_instruction_create(env, om_builder->lastnode, target, value, &pi_node);
axiom_node_set_first_child(om_builder->lastnode, env, pi_node);
axiom_node_set_parent(pi_node, env, om_builder->lastnode);
}
axiom_node_set_builder(pi_node, env, om_builder);
om_builder->element_level++;
if(target)
{
axiom_xml_reader_xml_free(om_builder->parser, env, target);
}
if(value)
{
axiom_xml_reader_xml_free(om_builder->parser, env, value);
}
om_builder->lastnode = pi_node;
return pi_node;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_stax_builder_discard_current_element(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axiom_node_t *element = NULL;
axiom_node_t *prev_node = NULL;
axiom_node_t *parent = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
element = om_builder->lastnode;
if(axiom_node_is_complete(element, env) || !(om_builder->cache))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BUILDER_STATE_CANNOT_DISCARD, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
om_builder->cache = AXIS2_FALSE;
do
{
while(axiom_xml_reader_next(om_builder->parser, env) != AXIOM_XML_READER_END_ELEMENT)
;
}
while(!(axiom_node_is_complete(element, env)));
/*All children of this element is pulled now */
prev_node = axiom_node_get_previous_sibling(element, env);
if(prev_node)
{
axiom_node_free_tree(axiom_node_get_next_sibling(prev_node, env), env);
axiom_node_set_next_sibling(prev_node, env, NULL);
}
else
{
parent = axiom_node_get_parent(element, env);
axiom_node_free_tree(axiom_node_get_first_child(parent, env), env);
axiom_node_set_first_child(parent, env, NULL);
om_builder->lastnode = parent;
}
om_builder->cache = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
static axiom_node_t *
axiom_stax_builder_create_om_comment(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axiom_node_t *comment_node = NULL;
axis2_char_t *comment_value = NULL;
axiom_node_t *parent = NULL;
comment_value = axiom_xml_reader_get_value(om_builder->parser, env);
if(!comment_value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in reading comment");
return NULL;
}
if(axiom_node_is_complete(om_builder->lastnode, env))
{
/* Last node is completed means, this node should be a sibling of last node */
parent = axiom_node_get_parent(om_builder->lastnode, env);
}
else
{
/* this node should be a child of last node */
parent = om_builder->lastnode;
}
axiom_comment_create(env, parent, comment_value, &comment_node);
axiom_xml_reader_xml_free(om_builder->parser,env,comment_value);
if(!comment_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create axiom element");
return NULL;
}
axiom_node_set_builder(comment_node, env, om_builder);
om_builder->element_level++;
om_builder->lastnode = comment_node;
return comment_node;
}
static axis2_status_t
axiom_stax_builder_end_element(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
/* if last node is not set, that means end_element is called before start_element,
* which is an error */
if(!om_builder->lastnode)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Invalid XML. End element is received before start element.");
return AXIS2_FAILURE;
}
om_builder->element_level--;
if(axiom_node_is_complete(om_builder->lastnode, env))
{
/* Last node completed means, this end element should be parent of the last node. */
axiom_node_t *parent = axiom_node_get_parent(om_builder->lastnode, env);
if(parent)
{
axiom_node_set_complete(parent, env, AXIS2_TRUE);
om_builder->lastnode = parent;
}
}
else
{
axiom_node_set_complete((om_builder->lastnode), env, AXIS2_TRUE);
}
/* if we finish building the root node, then we can set the complete status of om_builder */
if(axiom_node_is_complete(om_builder->root_node, env))
{
om_builder->done = AXIS2_TRUE;
}
return AXIS2_SUCCESS;
}
/*
* This method invokes the target service method
*/
static axiom_node_t* AXIS2_CALL
Axis2Service_invoke(axis2_svc_skeleton_t* /*pServiceSkeleton*/,
const axutil_env_t* pEnv,
axiom_node_t* pAxiomNode,
axis2_msg_ctx_t* pMsgCtx)
{
if (pAxiomNode == NULL)
{
staff::LogError() << "AxiOM node is NULL\n";
return NULL;
}
if (axiom_node_get_node_type(pAxiomNode, pEnv) != AXIOM_ELEMENT)
{
staff::LogError() << "Can't get AxiOM node type";
return NULL;
}
axiom_element_t* pAxiomElement = (axiom_element_t*)axiom_node_get_data_element(pAxiomNode, pEnv);
if (pAxiomElement == NULL)
{
staff::LogError() << "Can't get AxiOM node element\n";
return NULL;
}
const axis2_char_t* szServiceName = reinterpret_cast<const axis2_char_t*>
(axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "ServiceName"));
#ifndef WITHOUT_SECURITY
const axis2_char_t* szSessionId = reinterpret_cast<const axis2_char_t*>
(axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "SessionId"));
const axis2_char_t* szInstanceId = reinterpret_cast<const axis2_char_t*>
(axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "InstanceId"));
#endif
if (szServiceName == NULL)
{
staff::LogError() << "Cannot process message: Failed to get service name.";
return NULL;
}
#ifndef WITHOUT_SECURITY
if (szSessionId == NULL)
{
staff::LogError() << "Cannot process message: Failed to get session id.";
return NULL;
}
if (szInstanceId == NULL)
{
staff::LogError() << "Cannot process message: Failed to get instance id.";
return NULL;
}
#endif
#ifdef _DEBUG
staff::LogDebug1() << "Service name: [" << szServiceName << "]";
#ifndef WITHOUT_SECURITY
staff::LogDebug1() << "Session id: [" << szSessionId << "]";
staff::LogDebug1() << "Instance id: [" << szInstanceId << "]";
#endif
{
axiom_node_t* panBody = axiom_node_get_parent(pAxiomNode, pEnv);
axiom_node_t* panEnv = axiom_node_get_parent(panBody, pEnv);
staff::LogDebug2() << "request SOAP Envelope: \n" << staff::ColorTextBlue
<< staff::DataObject(panEnv).ToString() << "\n" << staff::ColorDefault;
}
#endif
staff::Operation tOperation;
staff::MessageContext tMessageContext(pEnv, pMsgCtx);
std::string sServiceName(szServiceName);
#ifndef WITHOUT_SECURITY
std::string sSessionId(szSessionId);
std::string sInstanceId(szInstanceId);
#else
static std::string sSessionId;
static std::string sInstanceId;
#endif
try
{
tOperation.SetRequest(pAxiomNode);
tOperation.SetMessageContext(tMessageContext);
if (axis2_msg_ctx_get_doing_rest(pMsgCtx, pEnv))
{
const axis2_char_t* szOperation = reinterpret_cast<const axis2_char_t*>
(axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "Operation"));
if (szOperation != NULL)
{
tOperation.SetName(szOperation);
}
}
if (sServiceName == "StaffService")
{
staff::ServiceDispatcher::Inst().InvokeSelf(tOperation);
}
else
{
staff::ServiceWrapper* pServiceWrapper =
staff::SharedContext::Inst().GetService(sServiceName);
STAFF_ASSERT(pServiceWrapper, "Service [" + sServiceName + "] is not found: ");
pServiceWrapper->Invoke(tOperation, sSessionId, sInstanceId);
}
}
catch (const staff::SoapUserFaultException& rEx)
{
try
{
staff::DataObject tdoFault;
tdoFault.FromString(rEx.GetFault());
tOperation.SetUserFault(tdoFault);
}
catch (...)
{
tOperation.SetFault("server", "Invalid format of user soap fault",
"Failed to invoke service " + sServiceName
+ "." + tOperation.GetName()
#ifndef WITHOUT_SECURITY
+ "#" + sInstanceId + "(" + sSessionId + ")"
#endif
);
}
}
catch (const staff::SoapFaultException& rEx)
{
tOperation.SetFault(rEx.GetCode(), rEx.GetString(), rEx.GetDetail());
}
catch (const std::exception& rEx)
{
tOperation.SetFault("server", rEx.what(), "Failed to invoke service " + sServiceName
+ "." + tOperation.GetName()
#ifndef WITHOUT_SECURITY
+ "#" + sInstanceId + "(" + sSessionId + ")"
#endif
);
}
catch (...)
{
tOperation.SetFault("server", "Unknown exception", "Failed to invoke service " + sServiceName
+ "." + tOperation.GetName()
#ifndef WITHOUT_SECURITY
+ "#" + sInstanceId + "(" + sSessionId + ")"
#endif
);
}
if (tOperation.IsFault())
{
staff::ScopedLock tLock(m_tFaultDetailsMutex);
m_mFaultDetails[staff::Thread::GetCurrentId()] = tOperation.GetFaultDetail();
staff::LogWarning() << "Fault: \n" << tOperation.GetFaultDescr() << "\n";
AXIS2_ERROR_SET_MESSAGE(pEnv->error, static_cast<axis2_char_t*>(axutil_strdup(pEnv, tOperation.GetFaultString().c_str())));
AXIS2_ERROR_SET_ERROR_NUMBER(pEnv->error, static_cast<axutil_error_codes_t>(AXUTIL_ERROR_MAX + 1));
AXIS2_ERROR_SET_STATUS_CODE(pEnv->error, AXIS2_FAILURE);
if (!m_bHttp200OnFault)
return NULL;
}
if(!IsNeedReply(pMsgCtx, pEnv))
{
return NULL;
}
tOperation.PrepareResult();
staff::DataObject& rResponse = tOperation.GetResponse();
rResponse.SetOwner(false);
#ifdef _DEBUG
staff::LogDebug2() << "Sending Response: \n" << staff::ColorTextBlue << rResponse.ToString() << "\n" << staff::ColorDefault;
#endif
return rResponse;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap11_builder_helper_handle_event(
axiom_soap11_builder_helper_t * builder_helper,
const axutil_env_t * env,
axiom_node_t * om_element_node,
int element_level)
{
axiom_element_t *om_ele = NULL;
axis2_char_t *ele_localname = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
AXIS2_PARAM_CHECK(env->error, om_element_node, AXIS2_FAILURE);
om_ele = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env);
ele_localname = axiom_element_get_localname(om_ele, env);
if(!ele_localname)
{
return AXIS2_FAILURE;
}
soap_envelope = axiom_soap_builder_get_soap_envelope(builder_helper->soap_builder, env);
if(!soap_envelope)
{
return AXIS2_FAILURE;
}
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if(!soap_body)
{
return AXIS2_FAILURE;
}
soap_fault = axiom_soap_body_get_fault(soap_body, env);
if(!soap_fault)
{
return AXIS2_FAILURE;
}
if(element_level == 4)
{
axiom_soap_fault_code_t *fault_code = NULL;
axiom_soap_fault_value_t *fault_value = NULL;
axiom_node_t *fault_value_node = NULL;
axiom_element_t *fault_value_ele = NULL;
if(axutil_strcmp(ele_localname, AXIOM_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME) == 0)
{
axis2_status_t status = AXIS2_SUCCESS;
if(builder_helper->fault_string_present)
{
axiom_soap_builder_set_bool_processing_mandatory_fault_elements(
builder_helper->soap_builder, env, AXIS2_FALSE);
}
fault_code = axiom_soap_fault_code_create(env);
if(!fault_code)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_code_set_base_node(fault_code, env, om_element_node);
axiom_soap_fault_set_code(soap_fault, env, fault_code);
axiom_soap_fault_code_set_builder(fault_code, env, builder_helper->soap_builder);
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
fault_value = axiom_soap_fault_value_create_with_code(env, fault_code);
if(!fault_value)
{
return AXIS2_FAILURE;
}
fault_value_node = axiom_soap_fault_value_get_base_node(fault_value, env);
if(!fault_value_node)
{
return AXIS2_FAILURE;
}
fault_value_ele = (axiom_element_t *)axiom_node_get_data_element(fault_value_node, env);
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_value_node);
status = axiom_soap11_builder_helper_process_text(builder_helper, env);
if(status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node);
axiom_node_set_complete(om_element_node, env, AXIS2_TRUE);
axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level
- 1));
builder_helper->fault_code_present = AXIS2_TRUE;
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_reason_t *fault_reason = NULL;
axiom_soap_fault_text_t *fault_text = NULL;
axiom_node_t *fault_text_node = NULL;
int status = AXIS2_SUCCESS;
if(builder_helper->fault_code_present)
{
axiom_soap_builder_set_bool_processing_mandatory_fault_elements(
builder_helper->soap_builder, env, AXIS2_FALSE);
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
fault_reason = axiom_soap_fault_reason_create(env);
if(!fault_reason)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_reason_set_base_node(fault_reason, env, om_element_node);
axiom_soap_fault_set_reason(soap_fault, env, fault_reason);
fault_text = axiom_soap_fault_text_create_with_parent(env, fault_reason);
if(!fault_text)
{
return AXIS2_FAILURE;
}
fault_text_node = axiom_soap_fault_text_get_base_node(fault_text, env);
if(!fault_text_node)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_text_node);
status = axiom_soap11_builder_helper_process_text(builder_helper, env);
if(status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node);
axiom_node_set_complete(om_element_node, env, AXIS2_TRUE);
axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level
- 1));
builder_helper->fault_string_present = AXIS2_TRUE;
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_role_t *fault_role = NULL;
fault_role = axiom_soap_fault_role_create(env);
if(!fault_role)
{
return AXIS2_FAILURE;
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
axiom_soap_fault_role_set_base_node(fault_role, env, om_element_node);
axiom_soap_fault_set_role(soap_fault, env, fault_role);
/*
Role element may not have a namespace associated, hence commented, else it segfaults here - Samisa
status = axiom_soap_builder_process_namespace_data(
builder_helper->soap_builder, env, om_element_node, AXIS2_TRUE);
if(status == AXIS2_FAILURE)
return AXIS2_FAILURE; */
}
else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME, ele_localname) == 0)
{
axiom_soap_fault_detail_t *fault_detail = NULL;
fault_detail = axiom_soap_fault_detail_create(env);
if(!fault_detail)
{
return AXIS2_FAILURE;
}
axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
axiom_soap_fault_detail_set_base_node(fault_detail, env, om_element_node);
axiom_soap_fault_set_detail(soap_fault, env, fault_detail);
}
else
{
return AXIS2_SUCCESS;
}
}
else if(element_level == 5)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *parent_localname = NULL;
parent_node = axiom_node_get_parent(om_element_node, env);
if(!parent_node)
{
return AXIS2_FAILURE;
}
parent_element = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env);
parent_localname = axiom_element_get_localname(parent_element, env);
if(!parent_localname)
{
return AXIS2_FAILURE;
}
if(axutil_strcmp(parent_localname, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME) == 0)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP11_FAULT_ACTOR_SHOULD_NOT_HAVE_CHILD_ELEMENTS, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "SOAP 1.1 Actor should not have child elements");
return AXIS2_FAILURE;
}
}
return AXIS2_SUCCESS;
}
/**
* Verifies XPath location of signed elements.
*/
int verify_node(axiom_node_t *signed_node, const axutil_env_t *env, axis2_msg_ctx_t *msg_ctx, axis2_char_t *ref, short *signed_elems) {
if(!axutil_strcmp(OXS_NODE_BODY, axiom_util_get_localname(signed_node, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Body", ref);
signed_elems[0] = 1;
axiom_node_t *parent = axiom_node_get_parent(signed_node,env);
if(axutil_strcmp(OXS_NODE_ENVELOPE, axiom_util_get_localname(parent, env))) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected parent element for Body with ID = %s", ref);
return 1;
}
parent = axiom_node_get_parent(parent,env);
if(parent) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of Envelope = %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed Body with ID = %s", ref);
return 1;
}
} else if(!axutil_strcmp(RAMPART_SECURITY_TIMESTAMP, axiom_util_get_localname(signed_node, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Timestamp", ref);
signed_elems[1] = 1;
/* Regardless of the location of the Timestamp, verify the one that is signed */
if(AXIS2_FAILURE == rampart_timestamp_token_validate(env, msg_ctx, signed_node, 20)) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for Timestamp with ID = %s", ref);
return 1;
}
} else if(!axutil_strcmp(AXIS2_WSA_ACTION, axiom_util_get_localname(signed_node, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Action", ref);
signed_elems[2] = 1;
if(verify_addr_hdr_elem_loc(signed_node, env, ref)) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for Action with ID = %s", ref);
return 1;
}
} else if(!axutil_strcmp(AXIS2_WSA_TO, axiom_util_get_localname(signed_node, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is To", ref);
signed_elems[3] = 1;
if(verify_addr_hdr_elem_loc(signed_node, env, ref)) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for To with ID = %s", ref);
return 1;
}
} else if(!axutil_strcmp(AXIS2_WSA_MESSAGE_ID, axiom_util_get_localname(signed_node, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is MessageId", ref);
signed_elems[4] = 1;
if(verify_addr_hdr_elem_loc(signed_node, env, ref)) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for MessageId with ID = %s", ref);
return 1;
}
} else {
AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is UNKNOWN", ref);
}
return 0;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap12_builder_helper_handle_event(
axiom_soap12_builder_helper_t * builder_helper,
const axutil_env_t * env,
axiom_node_t * om_ele_node,
int element_level)
{
axis2_char_t *ele_localname = NULL;
axiom_element_t *om_ele = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_ele_node, AXIS2_FAILURE);
om_ele = (axiom_element_t *) axiom_node_get_data_element(om_ele_node, env);
if (!om_ele)
{
return AXIS2_FAILURE;
}
ele_localname = axiom_element_get_localname(om_ele, env);
if (!ele_localname)
{
return AXIS2_FAILURE;
}
soap_envelope =
axiom_soap_builder_get_soap_envelope(builder_helper->soap_builder, env);
if (!soap_envelope)
{
return AXIS2_FAILURE;
}
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if (!soap_body)
{
return AXIS2_FAILURE;
}
soap_fault = axiom_soap_body_get_fault(soap_body, env);
if (!soap_fault)
{
return AXIS2_FAILURE;
}
if (element_level == 4)
{
if (axutil_strcmp
(AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME, ele_localname) == 0)
{
if (builder_helper->code_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_CODE_ELEMENTS_ENCOUNTERED,
AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Multiple fault code elements encountered in SOAP fault");
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_code_t *soap_fault_code = NULL;
soap_fault_code = axiom_soap_fault_code_create(env);
if (!soap_fault_code)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_code_set_base_node(soap_fault_code, env,
om_ele_node);
axiom_soap_fault_code_set_builder(soap_fault_code, env,
builder_helper->soap_builder);
axiom_soap_fault_set_code(soap_fault, env, soap_fault_code);
builder_helper->code_present = AXIS2_TRUE;
builder_helper->code_processing = AXIS2_TRUE;
}
}
else if (axutil_strcmp
(AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME,
ele_localname) == 0)
{
if (!(builder_helper->code_processing) &&
!(builder_helper->sub_code_processing))
{
if (builder_helper->code_present)
{
if (builder_helper->reason_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_REASON_ELEMENTS_ENCOUNTERED,
AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Multiple fault reason elements encountered in SOAP fault");
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_reason_t *fault_reason = NULL;
fault_reason = axiom_soap_fault_reason_create(env);
if (!fault_reason)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_reason_set_base_node(fault_reason, env,
om_ele_node);
axiom_soap_fault_set_reason(soap_fault, env,
fault_reason);
axiom_soap_fault_reason_set_builder(fault_reason, env,
builder_helper->
soap_builder);
builder_helper->reason_present = AXIS2_TRUE;
builder_helper->reason_processing = AXIS2_TRUE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
if (builder_helper->code_processing)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_CODE_DOES_NOT_HAVE_A_VALUE,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_CODE_DOES_NOT_HAVE_A_VALUE,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
}
else if (axutil_strcmp
(ele_localname, AXIOM_SOAP12_SOAP_FAULT_NODE_LOCAL_NAME) == 0)
{
if (!(builder_helper->reason_processing))
{
if (builder_helper->reason_present &&
!(builder_helper->role_present) &&
!(builder_helper->detail_present))
{
if (builder_helper->node_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_NODE_ELEMENTS_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_node_t *soap_fault_node = NULL;
soap_fault_node = axiom_soap_fault_node_create(env);
if (!soap_fault_node)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_node_set_base_node(soap_fault_node,
env, om_ele_node);
axiom_soap_fault_set_node(soap_fault, env,
soap_fault_node);
builder_helper->node_present = AXIS2_TRUE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED,
AXIS2_FALSE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_REASON_ELEMENT_SHOULD_HAVE_A_TEXT,
AXIS2_FALSE);
return AXIS2_FAILURE;
}
}
else if (axutil_strcmp
(ele_localname, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME) == 0)
{
if (!(builder_helper->reason_processing))
{
if (builder_helper->reason_present &&
!(builder_helper->detail_present))
{
if (builder_helper->role_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_ROLE_ELEMENTS_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_role_t *soap_fault_role = NULL;
soap_fault_role = axiom_soap_fault_role_create(env);
if (!soap_fault_role)
return AXIS2_FAILURE;
axiom_soap_fault_role_set_base_node(soap_fault_role,
env, om_ele_node);
axiom_soap_fault_set_role(soap_fault, env,
soap_fault_role);
builder_helper->role_present = AXIS2_TRUE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_ROLE_ELEMENT_SHOULD_HAVE_A_TEXT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (axutil_strcmp
(ele_localname,
AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME) == 0)
{
if (!(builder_helper->reason_processing))
{
if (builder_helper->reason_present)
{
if (builder_helper->detail_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_DETAIL_ELEMENTS_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_detail_t *soap_fault_detail = NULL;
soap_fault_detail = axiom_soap_fault_detail_create(env);
if (!soap_fault_detail)
return AXIS2_FAILURE;
axiom_soap_fault_detail_set_base_node(soap_fault_detail,
env, om_ele_node);
axiom_soap_fault_set_detail(soap_fault, env,
soap_fault_detail);
builder_helper->detail_present = AXIS2_TRUE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_REASON_ELEMENT_SHOULD_HAVE_A_TEXT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_UNSUPPORTED_ELEMENT_IN_SOAP_FAULT_ELEMENT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (element_level == 5)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axis2_char_t *parent_localname = NULL;
parent_node = axiom_node_get_parent(om_ele_node, env);
if (!parent_node)
{
return AXIS2_FAILURE;
}
parent_ele =
(axiom_element_t *) axiom_node_get_data_element(parent_node, env);
if (!parent_ele)
{
return AXIS2_FAILURE;
}
parent_localname = axiom_element_get_localname(parent_ele, env);
if (!parent_localname)
{
return AXIS2_FAILURE;
}
if (axutil_strcmp(parent_localname,
AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME) == 0)
{
if (axutil_strcmp
(ele_localname, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME) == 0)
{
if (!(builder_helper->value_present))
{
axiom_soap_fault_value_t *soap_fault_value = NULL;
axiom_soap_fault_code_t *parent_fcode = NULL;
soap_fault_value = axiom_soap_fault_value_create(env);
if (!soap_fault_value)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_value_set_base_node(soap_fault_value, env,
om_ele_node);
parent_fcode = axiom_soap_fault_get_code(soap_fault, env);
if (!parent_fcode)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_code_set_value(parent_fcode, env,
soap_fault_value);
builder_helper->value_present = AXIS2_TRUE;
builder_helper->code_processing = AXIS2_FALSE;
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_VALUE_ENCOUNTERED_IN_CODE_ELEMENT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (axutil_strcmp(ele_localname,
AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME)
== 0)
{
if (!(builder_helper->sub_code_present))
{
if (builder_helper->value_present)
{
axiom_soap_fault_sub_code_t *fault_subcode = NULL;
axiom_soap_fault_code_t *fault_code = NULL;
fault_subcode = axiom_soap_fault_sub_code_create(env);
if (!fault_subcode)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_sub_code_set_base_node(fault_subcode,
env,
om_ele_node);
fault_code = axiom_soap_fault_get_code(soap_fault, env);
if (!fault_code)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_code_set_sub_code(fault_code, env,
fault_subcode);
axiom_soap_fault_sub_code_set_builder(fault_subcode,
env,
builder_helper->
soap_builder);
builder_helper->sub_code_present = AXIS2_TRUE;
builder_helper->sub_code_processing = AXIS2_TRUE;
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_VALUE_SHOULD_BE_PRESENT_BEFORE_SUB_CODE,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_THIS_LOCALNAME_NOT_SUPPORTED_INSIDE_THE_CODE_ELEMENT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (axutil_strcmp
(parent_localname,
AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME) == 0)
{
if (axutil_strcmp
(ele_localname, AXIOM_SOAP12_SOAP_FAULT_TEXT_LOCAL_NAME) == 0)
{
axiom_soap_fault_text_t *soap_fault_text = NULL;
axiom_soap_fault_reason_t *fault_reason = NULL;
soap_fault_text = axiom_soap_fault_text_create(env);
if (!soap_fault_text)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_text_set_base_node(soap_fault_text, env,
om_ele_node);
fault_reason = axiom_soap_fault_get_reason(soap_fault, env);
if (!fault_reason)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_reason_add_soap_fault_text(fault_reason, env,
soap_fault_text);
builder_helper->reason_processing = AXIS2_FALSE;
axiom_soap_builder_set_bool_processing_mandatory_fault_elements
(builder_helper->soap_builder, env, AXIS2_FALSE);
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_THIS_LOCALNAME_IS_NOT_SUPPORTED_INSIDE_THE_REASON_ELEMENT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (axutil_strcmp
(parent_localname,
AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME) == 0)
{
axiom_soap_builder_set_processing_detail_elements(builder_helper->
soap_builder, env,
AXIS2_TRUE);
if (!(builder_helper->detail_element_names))
{
builder_helper->detail_element_names =
axutil_array_list_create(env, 20);
}
axutil_array_list_add(builder_helper->detail_element_names, env,
ele_localname);
}
else
{
return AXIS2_FAILURE;
}
}
else if (element_level > 5)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axis2_char_t *parent_localname = NULL;
parent_node = axiom_node_get_parent(om_ele_node, env);
if (!parent_node)
{
return AXIS2_FAILURE;
}
parent_ele =
(axiom_element_t *) axiom_node_get_data_element(parent_node, env);
if (!parent_ele)
{
return AXIS2_FAILURE;
}
parent_localname = axiom_element_get_localname(parent_ele, env);
if (!parent_localname)
{
return AXIS2_FAILURE;
}
if (axutil_strcmp
(parent_localname,
AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME) == 0)
{
if (axutil_strcmp
(ele_localname, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME) == 0)
{
if (builder_helper->subcode_value_present)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
axiom_soap_fault_sub_code_t *sub_code = NULL;
axiom_soap_fault_code_t *code = NULL;
axiom_soap_fault_value_t *value = NULL;
code = axiom_soap_fault_get_code(soap_fault, env);
if (!code)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"fault code null when it should not be null");
return AXIS2_FAILURE;
}
sub_code = axiom_soap_fault_code_get_sub_code(code, env);
if (!sub_code)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"fault subcode null when it should not be null");
return AXIS2_FAILURE;
}
value = axiom_soap_fault_value_create(env);
if (!value)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_value_set_base_node(value, env,
om_ele_node);
axiom_soap_fault_sub_code_set_value(sub_code, env, value);
builder_helper->subcode_value_present = AXIS2_TRUE;
builder_helper->sub_sub_code_present = AXIS2_FALSE;
builder_helper->sub_code_processing = AXIS2_FALSE;
}
}
else if (axutil_strcmp
(ele_localname,
AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME) == 0)
{
if (builder_helper->subcode_value_present)
{
if (!(builder_helper->sub_sub_code_present))
{
axiom_soap_fault_code_t *fault_code = NULL;
axiom_soap_fault_sub_code_t *parent_subcode = NULL;
axiom_soap_fault_sub_code_t *subcode = NULL;
subcode = axiom_soap_fault_sub_code_create(env);
if (!subcode)
{
return AXIS2_FAILURE;
}
axiom_soap_fault_sub_code_set_base_node(subcode, env,
om_ele_node);
fault_code = axiom_soap_fault_get_code(soap_fault, env);
if (!fault_code)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"fault code null when it should not be null");
return AXIS2_FAILURE;
}
parent_subcode =
axiom_soap_fault_code_get_sub_code(fault_code, env);
if (!parent_subcode)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"fault subcode null when it should not be null");
return AXIS2_FAILURE;
}
axiom_soap_fault_sub_code_set_sub_code(parent_subcode,
env, subcode);
builder_helper->subcode_value_present = AXIS2_FALSE;
builder_helper->sub_sub_code_present = AXIS2_TRUE;
builder_helper->sub_code_processing = AXIS2_TRUE;
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SOAP_FAULT_VALUE_SHOULD_BE_PRESENT_BEFORE_SUB_CODE,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_THIS_LOCALNAME_IS_NOT_SUPPORTED_INSIDE_THE_SUB_CODE_ELEMENT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
else if (axiom_soap_builder_is_processing_detail_elements
(builder_helper->soap_builder, env))
{
int detail_element_level = 0;
axis2_bool_t local_name_exists = AXIS2_FALSE;
int i = 0;
if (!(builder_helper->detail_element_names))
{
return AXIS2_FAILURE;
}
for (i = 0;
i <
axutil_array_list_size(builder_helper->detail_element_names,
env); i++)
{
if (axutil_strcmp
(parent_localname,
axutil_array_list_get(builder_helper->detail_element_names,
env, i)) == 0)
{
local_name_exists = AXIS2_TRUE;
detail_element_level = i + 1;
}
}
if (local_name_exists)
{
axutil_array_list_add(builder_helper->detail_element_names, env,
ele_localname);
}
else
{
return AXIS2_FAILURE;
}
}
}
return AXIS2_SUCCESS;
}
axis2_status_t
wsclient_set_attachment (const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *base_dir,
int is_mtom_enabled)
{
axiom_node_t *child_node = NULL;
axiom_element_t *element;
if (!node || !env)
return AXIS2_FAILURE;
if (axiom_node_get_node_type (node, env) == AXIOM_ELEMENT)
{
axis2_char_t *local_name;
axiom_namespace_t *ns;
axis2_char_t *ns_uri;
element = (axiom_element_t *) axiom_node_get_data_element (node, env);
local_name = axiom_element_get_localname (element, env);
if (local_name)
{
if (!strcmp (local_name, "Include"))
{
ns = axiom_element_get_namespace(element, env, node);
if (ns && (ns_uri = axiom_namespace_get_uri (ns, env))
&& (!strcmp (ns_uri, "http://www.w3.org/2004/08/xop/include")))
{
axis2_char_t *file_path;
axiom_data_handler_t *data_handler;
axiom_text_t *data_text;
axiom_node_t *data_node;
axiom_node_t *parent;
axutil_uri_t *file_uri = NULL;
axutil_uri_t *base_uri = NULL;
axutil_uri_t *real_uri = NULL;
axis2_char_t *real_path = NULL;
parent = axiom_node_get_parent (node, env);
axiom_node_detach (node, env);
file_path = axiom_element_get_attribute_value_by_name (element, env, "href");
file_uri = axutil_uri_parse_string (env, file_path);
if (base_dir)
base_uri = axutil_uri_parse_string (env, base_dir);
else
return AXIS2_FAILURE;
if (base_uri)
real_uri = axutil_uri_parse_relative (env, base_uri, file_path);
else
return AXIS2_FAILURE;
if (real_uri)
real_path = axutil_uri_to_string (real_uri, env, 1);
else
return AXIS2_FAILURE;
if (real_path)
data_handler = axiom_data_handler_create (env, real_path, "image/jpeg");
else
return AXIS2_FAILURE;
if (data_handler)
data_text = axiom_text_create_with_data_handler (env, parent, data_handler, &data_node);
else
return AXIS2_FAILURE;
if (data_text)
{
if (!is_mtom_enabled)
axiom_text_set_optimize (data_text, env, AXIS2_FALSE);
}
}
}
}
child_node = axiom_node_get_first_element (node, env);
while (child_node)
{
wsclient_set_attachment (env, child_node, base_dir, is_mtom_enabled);
child_node = axiom_node_get_next_sibling (child_node, env);
}
}
else
return AXIS2_FAILURE;
return AXIS2_SUCCESS;
}
