AXIS2_EXTERN axiom_soap_fault_value_t *AXIS2_CALL
axiom_soap_fault_value_create_with_subcode(
const axutil_env_t * env,
axiom_soap_fault_sub_code_t * parent)
{
axiom_soap_fault_value_t *fault_value = NULL;
axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;
axiom_namespace_t *parent_ns = NULL;
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
int soap_version = -1;
AXIS2_PARAM_CHECK(env->error, parent, NULL);
fault_value = axiom_soap_fault_value_create(env);
if(!fault_value)
{
return NULL;
}
parent_node = axiom_soap_fault_sub_code_get_base_node(parent, env);
if(!parent_node)
{
axiom_soap_fault_value_free(fault_value, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_fault_value_free(fault_value, env);
return NULL;
}
soap_version = axiom_soap_fault_sub_code_get_soap_version(parent, env);
if(soap_version == AXIOM_SOAP12)
{
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
}
this_ele = axiom_element_create(env, parent_node, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME,
parent_ns, &this_node);
if(!this_ele)
{
axiom_soap_fault_value_free(fault_value, env);
return NULL;
}
fault_value->om_ele_node = this_node;
axiom_soap_fault_sub_code_set_value(parent, env, fault_value);
return fault_value;
}
/** Get namespace.
* @param env
* @param node
* @return ptr to the namespace of 'node'.
*/
axiom_namespace_t * rp_get_namespace(
const axutil_env_t *env,
axiom_node_t *node)
{
axiom_element_t * root_el =
(axiom_element_t *) axiom_node_get_data_element (node, env);
return axiom_element_get_namespace (root_el, env, node);
}
AXIS2_EXTERN axiom_soap_fault_text_t *AXIS2_CALL
axiom_soap_fault_text_create_with_parent(
const axutil_env_t * env,
axiom_soap_fault_reason_t * parent)
{
axiom_soap_fault_text_t *fault_text = NULL;
axiom_element_t *this_ele = NULL;
int soap_version = -1;
axiom_node_t *this_node = NULL;
axiom_namespace_t *parent_ns = NULL;
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
AXIS2_PARAM_CHECK(env->error, parent, NULL);
fault_text = axiom_soap_fault_text_create(env);
if(!fault_text)
{
return NULL;
}
parent_node = axiom_soap_fault_reason_get_base_node(parent, env);
if(!parent_node)
{
axiom_soap_fault_text_free(fault_text, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_fault_text_free(fault_text, env);
return NULL;
}
soap_version = axiom_soap_fault_reason_get_soap_version(parent, env);
if(AXIOM_SOAP12 == soap_version)
{
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
}
this_ele = axiom_element_create(env, parent_node, AXIOM_SOAP12_SOAP_FAULT_TEXT_LOCAL_NAME,
parent_ns, &this_node);
if(!this_ele)
{
axiom_soap_fault_text_free(fault_text, env);
return NULL;
}
fault_text->om_ele_node = this_node;
axiom_soap_fault_reason_add_soap_fault_text(parent, env, fault_text);
return fault_text;
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_soap_header_get_base_node(
axiom_soap_header_t * soap_header,
const axutil_env_t * env)
{
if(!soap_header->om_ele_node)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_namespace_t *parent_ns = NULL;
axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *body_node = NULL;
parent_node = axiom_soap_envelope_get_base_node(soap_header->soap_envelope, env);
if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
this_ele = axiom_element_create(env, NULL, AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns,
&this_node);
if(!this_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
soap_body = axiom_soap_envelope_get_body(soap_header->soap_envelope, env);
if(soap_body)
{
body_node = axiom_soap_body_get_base_node(soap_body, env);
axiom_node_insert_sibling_before(body_node, env, this_node);
}
else
{
axiom_node_add_child(parent_node, env, this_node);
}
soap_header->om_ele_node = this_node;
}
return soap_header->om_ele_node;
}
axis2_char_t* AXIS2_CALL
sandesha2_rm_elements_get_addr_ns_val_from_env(
const axutil_env_t *env,
axiom_soap_envelope_t *soap_envelope,
axis2_char_t *action)
{
axiom_soap_header_t *soap_header = NULL;
AXIS2_PARAM_CHECK(env->error, soap_envelope, NULL);
AXIS2_PARAM_CHECK(env->error, action, NULL);
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if(soap_header)
{
axutil_array_list_t *headers = NULL;
axiom_node_t *soap_header_node = NULL;
axiom_element_t *soap_header_element = NULL;
axiom_namespace_t *addr_ns = NULL;
headers = axiom_soap_header_get_header_blocks_with_namespace_uri(
soap_header, env, AXIS2_WSA_NAMESPACE);
if(headers && 0 < axutil_array_list_size(headers, env))
{
axutil_array_list_free(headers, env);
return AXIS2_WSA_NAMESPACE;
}
headers = axiom_soap_header_get_header_blocks_with_namespace_uri(
soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION);
if(headers && 0 < axutil_array_list_size(headers, env))
{
axutil_array_list_free(headers, env);
return AXIS2_WSA_NAMESPACE_SUBMISSION;
}
if(headers)
axutil_array_list_free(headers, env);
soap_header_node = axiom_soap_header_get_base_node(soap_header, env);
soap_header_element = axiom_node_get_data_element(soap_header_node,
env);
addr_ns = axiom_element_get_namespace(soap_header_element, env,
soap_header_node);
if(addr_ns)
{
axis2_char_t *str_addr_ns = axiom_namespace_get_uri(addr_ns, env);
return str_addr_ns;
}
}
return NULL;
}
AXIS2_EXTERN axiom_soap_fault_reason_t *AXIS2_CALL
axiom_soap_fault_reason_create_with_parent(
const axutil_env_t * env,
axiom_soap_fault_t * fault)
{
axiom_soap_fault_reason_t *fault_reason = NULL;
axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_namespace_t *parent_ns = NULL;
AXIS2_PARAM_CHECK(env->error, fault, NULL);
fault_reason = axiom_soap_fault_reason_create(env);
if (!fault_reason)
{
return NULL;
}
parent_node = axiom_soap_fault_get_base_node(fault, env);
if (!parent_node)
{
return NULL;
}
parent_ele =
(axiom_element_t *) axiom_node_get_data_element(parent_node, env);
if (!parent_ele)
{
return NULL;
}
fault_reason->soap_version = axiom_soap_fault_get_soap_version(fault, env);
if (fault_reason->soap_version == AXIOM_SOAP12)
{
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
}
this_ele = axiom_element_create(env,
parent_node,
AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME,
parent_ns, &this_node);
if (!this_ele)
{
return NULL;
}
fault_reason->om_ele_node = this_node;
axiom_soap_fault_set_reason(fault, env, fault_reason);
return fault_reason;
}
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_namespace_t *om_ns = NULL;
AXIS2_PARAM_CHECK(env->error, envelope, NULL);
soap_body = axiom_soap_body_create(env);
if(!soap_body)
{
return NULL;
}
/*get parent node from SOAP envelope */
parent_node = axiom_soap_envelope_get_base_node(envelope, env);
if(!parent_node)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
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));
if(!ele)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
axiom_soap_envelope_set_body(envelope, env, soap_body);
return soap_body;
}
AXIS2_EXTERN int AXIS2_CALL
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;
if(!soap_body->om_ele_node)
{
return AXIS2_FAILURE;
}
body_ele = axiom_node_get_data_element(soap_body->om_ele_node, env);
if(!body_ele)
{
return AXIS2_FAILURE;
}
om_ns = axiom_element_get_namespace(body_ele, env, soap_body->om_ele_node);
if(!om_ns)
{
return AXIS2_FAILURE;
}
uri = axiom_namespace_get_uri(om_ns, env);
if(uri)
{
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)
{
return AXIOM_SOAP12;
}
}
return AXIS2_FAILURE;
}
void wsf_util_pack_attachments (
axutil_env_t *env,
axiom_node_t *node,
VALUE attach_ht,
int enable_mtom,
char *default_cnt_type)
{
axiom_element_t *node_element = NULL;
axiom_element_t *child_element = NULL;
axiom_child_element_iterator_t *child_element_ite = NULL;
axiom_node_t *child_node = NULL;
int attachment_done = 0;
axis2_char_t *element_localname = NULL;
axiom_namespace_t *element_namespace = NULL;
axis2_char_t *namespace_uri = NULL;
if (!node)
return;
if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
node_element = axiom_node_get_data_element(node, env);
if (node_element)
{
child_element_ite = axiom_element_get_child_elements(node_element, env, node);
if (child_element_ite)
{
child_node = axiom_child_element_iterator_next(child_element_ite, env);
attachment_done = 0;
while (child_node && !attachment_done)
{
child_element = axiom_node_get_data_element(child_node, env);
element_localname = axiom_element_get_localname(child_element, env);
if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0))
{
element_namespace = axiom_element_get_namespace(child_element, env, child_node);
if (element_namespace)
{
namespace_uri = axiom_namespace_get_uri(element_namespace, env);
if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0))
{
axis2_char_t *cnt_type = NULL;
axis2_char_t *content_type = NULL;
axis2_char_t *href = NULL;
axis2_char_t* pos = NULL;
cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE);
content_type = !cnt_type ? default_cnt_type : cnt_type;
href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF);
if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:")))
{
axis2_char_t* cid = NULL;
VALUE content_tmp;
void* content = NULL;
unsigned int content_length = 0;
cid = href + 4;
content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid));
content_length = RSTRING(content_tmp)->len;
content = malloc(sizeof (char) * content_length);
memcpy (content, (const void*)STR2CSTR(content_tmp), content_length);
if (content)
{
void *data_buffer = NULL;
axiom_data_handler_t *data_handler = NULL;
axiom_node_t *text_node = NULL;
axiom_text_t *text = NULL;
data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length);
if (data_buffer)
{
memcpy (data_buffer, content, content_length);
data_handler = axiom_data_handler_create (env, NULL, content_type);
if (data_handler)
{
axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length);
text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node);
if (enable_mtom == AXIS2_FALSE)
axiom_text_set_optimize (text, env, AXIS2_FALSE);
axiom_node_detach (child_node, env);
}
}
attachment_done = 1;
}
}
}
}
}
child_node = axiom_child_element_iterator_next(child_element_ite, env);
}
}
}
}
// Process child nodes
child_node = axiom_node_get_first_child(node, env);
while (child_node)
{
wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type);
child_node = axiom_node_get_next_sibling(child_node, env);
}
}
/**
* Traverse thru the node and its children. Check if the element has the
* given qname and has a id attribute equal to the given value.
* @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(
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)
{
axis2_char_t *attribute_value = NULL;
axis2_char_t *localname = NULL;
axiom_namespace_t *nmsp = NULL;
axiom_element_t *element = NULL;
axis2_bool_t element_match = AXIS2_FALSE;
axiom_node_t *temp_node = NULL;
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return NULL;
}
element = axiom_node_get_data_element(node, env);
localname = axiom_element_get_localname(element, env);
if(localname && !axutil_strcmp(localname, e_name))
{
element_match = AXIS2_TRUE;
if(e_ns)
{
nmsp = axiom_element_get_namespace(element, env, node);
if(nmsp)
{
axis2_char_t *namespacea = NULL;
namespacea = axiom_namespace_get_uri(nmsp, env);
if(axutil_strcmp(e_ns, namespacea))
{
element_match = AXIS2_FALSE;
}
}
}
/* element is ok. So, we have to check the attribute value */
if(element_match)
{
if(attr_ns)
{
axiom_attribute_t *attr = NULL;
axutil_qname_t *qname = axutil_qname_create(env, attr_name, attr_ns, NULL);
attr = axiom_element_get_attribute(element, env, qname);
if(attr)
{
attribute_value = axiom_attribute_get_value(attr, env);
}
axutil_qname_free(qname, env);
}
else
{
attribute_value = axiom_element_get_attribute_value_by_name(
element, env, attr_name);
}
}
if (attribute_value && !axutil_strcmp(attribute_value, attr_val))
{
return node;
}
}
/* Doesn't match? Get the children and search */
temp_node = axiom_node_get_first_element(node, env);
while (temp_node)
{
axiom_node_t *res_node = NULL;
res_node = oxs_axiom_get_first_node_by_name_and_attr_val(
env, temp_node, e_name, e_ns, attr_name, attr_val, attr_ns);
if (res_node)
{
return res_node;
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
return NULL;
}
static void
ngx_squ_xml_parse_children(squ_State *l, axutil_env_t *env,
axiom_node_t *parent, axiom_element_t *parent_elem)
{
int n;
char *uri, *prefix, *name, *text, *value;
axiom_node_t *node;
axutil_hash_t *attrs;
axiom_element_t *elem;
ngx_squ_thread_t *thr;
axiom_attribute_t *attr;
axiom_namespace_t *ns;
axutil_hash_index_t *hi;
axiom_child_element_iterator_t *it;
thr = ngx_squ_thread(l);
ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse children");
it = axiom_element_get_child_elements(parent_elem, env, parent);
if (it == NULL) {
return;
}
n = 1;
do {
node = axiom_child_element_iterator_next(it, env);
elem = axiom_node_get_data_element(node, env);
name = axiom_element_get_localname(elem, env);
squ_createtable(l, 2, 4);
squ_pushstring(l, name);
squ_setfield(l, -2, "name");
ns = axiom_element_get_namespace(elem, env, node);
if (ns != NULL) {
uri = axiom_namespace_get_uri(ns, env);
if (uri != NULL) {
squ_pushstring(l, uri);
squ_setfield(l, -2, "uri");
}
prefix = axiom_namespace_get_prefix(ns, env);
if (prefix != NULL) {
squ_pushstring(l, prefix);
squ_setfield(l, -2, "prefix");
}
}
attrs = axiom_element_get_all_attributes(elem, env);
if (attrs != NULL) {
squ_newtable(l);
hi = axutil_hash_first(attrs, env);
do {
if (hi == NULL) {
break;
}
axutil_hash_this(hi, NULL, NULL, (void **) &attr);
name = axiom_attribute_get_localname(attr, env);
value = axiom_attribute_get_value(attr, env);
squ_pushstring(l, value);
squ_setfield(l, -2, name);
hi = axutil_hash_next(env, hi);
} while (1);
squ_setfield(l, -2, "attributes");
}
text = axiom_element_get_text(elem, env, node);
if (text != NULL) {
squ_pushstring(l, text);
squ_setfield(l, -2, "text");
} else {
squ_newtable(l);
ngx_squ_xml_parse_children(l, env, node, elem);
squ_setfield(l, -2, "children");
}
squ_setfield(l, -2, name);
squ_getfield(l, -1, name);
squ_rawseti(l, -2, n++);
} while (axiom_child_element_iterator_has_next(it, env) == AXIS2_TRUE);
}
AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
axiom_soap_header_get_header_blocks_with_namespace_uri(
axiom_soap_header_t * soap_header,
const axutil_env_t * env,
const axis2_char_t * ns_uri)
{
axutil_array_list_t *header_block_list = NULL;
axutil_hash_index_t *hash_index = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_om_node = NULL;
axiom_element_t *header_block_om_ele = NULL;
axiom_namespace_t *ns = NULL;
axis2_char_t *hb_namespace_uri = NULL;
int found = 0;
void *hb = NULL;
AXIS2_PARAM_CHECK(env->error, ns_uri, NULL);
if(!(soap_header->header_blocks))
{
return NULL;
}
header_block_list = axutil_array_list_create(env, 10);
if(!header_block_list)
{
return NULL;
}
for(hash_index = axutil_hash_first(soap_header->header_blocks, env); hash_index; hash_index
= axutil_hash_next(env, hash_index))
{
axutil_hash_this(hash_index, NULL, NULL, &hb);
if(hb)
{
header_block = (axiom_soap_header_block_t *)hb;
header_block_om_node = axiom_soap_header_block_get_base_node(header_block, env);
if(header_block_om_node)
{
header_block_om_ele = (axiom_element_t *)axiom_node_get_data_element(
header_block_om_node, env);
if(header_block_om_ele)
{
ns
= axiom_element_get_namespace(header_block_om_ele, env,
header_block_om_node);
if(ns)
{
hb_namespace_uri = axiom_namespace_get_uri(ns, env);
if(axutil_strcmp(hb_namespace_uri, ns_uri) == 0)
{
axutil_array_list_add(header_block_list, env, header_block);
found++;
}
}
}
}
hb = NULL;
header_block = NULL;
header_block_om_ele = NULL;
header_block_om_node = NULL;
ns = NULL;
hb_namespace_uri = NULL;
}
}
if(found > 0)
{
return header_block_list;
}
else
{
axutil_array_list_free(header_block_list, env);
}
return NULL;
}
axis2_status_t AXIS2_CALL
axis2_addr_out_handler_invoke(
struct axis2_handler * handler,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx)
{
axis2_char_t *addr_ver_from_msg_ctx = NULL;
const axis2_char_t *addr_ns = NULL;
axis2_msg_info_headers_t *msg_info_headers = NULL;
axis2_ctx_t *ctx = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_header_t *soap_header = NULL;
axiom_node_t *soap_header_node = NULL;
axiom_element_t *soap_header_ele = NULL;
axis2_endpoint_ref_t *epr_to = NULL;
axis2_endpoint_ref_t *epr_reply_to = NULL;
axis2_endpoint_ref_t *epr_from = NULL;
axis2_endpoint_ref_t *epr_fault_to = NULL;
axutil_property_t *property = NULL;
const axis2_char_t *wsa_action = NULL;
axis2_bool_t set_must_understand = AXIS2_FALSE;
axutil_property_t *must_understand_prop;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log, "Starting addressing out handler");
soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
if(!soap_envelope)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP envelope. Stop processing addressing");
return AXIS2_SUCCESS; /* Can happen in case of ONE-WAY services/clients */
}
msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env);
if(msg_info_headers)
{
wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env);
}
else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No addressing in use");
return AXIS2_SUCCESS; /* No addressing in use */
}
if(!wsa_action || !*wsa_action)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No action present. Stop processing addressing");
return AXIS2_SUCCESS; /* If no action present, assume no addressing in use */
}
ctx = axis2_msg_ctx_get_base(msg_ctx, env);
property = axis2_ctx_get_property(ctx, env, AXIS2_WSA_VERSION);
if(property)
{
addr_ver_from_msg_ctx = axutil_property_get_value(property, env);
property = NULL;
}
must_understand_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ADDR_ADD_MUST_UNDERSTAND_TO_ADDR_HEADERS);
if(must_understand_prop)
{
axis2_char_t *value = axutil_property_get_value(must_understand_prop, env);
if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0)
set_must_understand = AXIS2_TRUE;
}
/* Setting version 1.0 as the default addressing namespace */
addr_ns = AXIS2_WSA_NAMESPACE;
if(addr_ver_from_msg_ctx)
{
if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ver_from_msg_ctx))
{
addr_ns = AXIS2_WSA_NAMESPACE_SUBMISSION;
}
}
else if(axis2_msg_ctx_get_op_ctx(msg_ctx, env))
{
axis2_op_ctx_t *op_ctx = NULL;
axis2_msg_ctx_t *in_msg_ctx = NULL;
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
if(op_ctx)
{
in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
}
if(in_msg_ctx)
{
axis2_ctx_t *in_ctx = NULL;
in_ctx = axis2_msg_ctx_get_base(in_msg_ctx, env);
property = axis2_ctx_get_property(in_ctx, env, AXIS2_WSA_VERSION);
if(property)
{
addr_ns = axutil_property_get_value(property, env);
property = NULL;
}
if(!addr_ns || !*addr_ns)
{
addr_ns = AXIS2_WSA_NAMESPACE;
}
}
}
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if(!soap_header)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP header. Stop processing addressing");
return AXIS2_SUCCESS; /* No SOAP header, so no point proceeding */
}
else
{
/* By this time, we definitely have some addressing information to be sent. This is because,
* we have tested at the start of this whether msg_info_headers are null or not.
* So rather than declaring addressing namespace in each and every addressing header, lets
* define that in the Header itself.
*/
const axis2_char_t *action = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *svc_group_context_id = NULL;
const axis2_char_t *message_id = NULL;
axis2_relates_to_t *relates_to = NULL;
axiom_node_t *relates_to_header_node = NULL;
axiom_element_t *relates_to_header_ele = NULL;
axiom_namespace_t *addressing_namespace = NULL;
soap_header_node = axiom_soap_header_get_base_node(soap_header, env);
soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header_node, env);
addressing_namespace = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
axiom_element_declare_namespace(soap_header_ele, env, soap_header_node,
addressing_namespace);
epr_to = axis2_msg_info_headers_get_to(msg_info_headers, env);
if(epr_to)
{
axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env);
if(body)
{
/* In case of a SOAP fault, we got to send the response to
the adress specified by FaultTo */
if(axiom_soap_body_has_fault(body, env))
{
axis2_endpoint_ref_t *epr_fault_to = axis2_msg_info_headers_get_fault_to(
msg_info_headers, env);
if(epr_fault_to)
{
const axis2_char_t *fault_to_address = axis2_endpoint_ref_get_address(
epr_fault_to, env);
if(fault_to_address)
{
if(axutil_strcmp(AXIS2_WSA_NONE_URL, fault_to_address)
&& axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, fault_to_address))
{
axis2_endpoint_ref_set_address(epr_to, env, fault_to_address);
}
}
}
}
}
address = axis2_endpoint_ref_get_address(epr_to, env);
if(address && *address)
{
axiom_node_t *to_header_block_node = NULL;
axiom_soap_header_block_t *to_header_block = NULL;
axutil_array_list_t *ref_param_list = NULL;
int size = 0;
to_header_block = axiom_soap_header_add_header_block(soap_header, env,
AXIS2_WSA_TO, addressing_namespace);
if(set_must_understand == AXIS2_TRUE)
{
axiom_soap_header_block_set_must_understand_with_bool(to_header_block, env, AXIS2_TRUE);
}
to_header_block_node = axiom_soap_header_block_get_base_node(to_header_block, env);
if(to_header_block_node)
{
axiom_element_t *to_header_block_element = NULL;
to_header_block_element = (axiom_element_t *)axiom_node_get_data_element(
to_header_block_node, env);
if(to_header_block_element)
{
axiom_element_set_text(to_header_block_element, env, address,
to_header_block_node);
}
}
ref_param_list = axis2_endpoint_ref_get_ref_param_list(epr_to, env);
size = axutil_array_list_size(ref_param_list, env);
if(ref_param_list && size > 0)
{
axiom_soap_header_block_t *reference_header_block = NULL;
axiom_node_t *reference_node = NULL;
int i = 0;
for(i = 0; i < size; i++)
{
axiom_node_t *temp_node = NULL;
temp_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i);
if(temp_node)
{
axiom_element_t *temp_ele = NULL;
temp_ele = axiom_node_get_data_element(temp_node, env);
if(temp_ele)
{
reference_header_block = axiom_soap_header_add_header_block(
soap_header, env, axiom_element_get_localname(temp_ele, env),
axiom_element_get_namespace(temp_ele, env, temp_node));
if(set_must_understand)
{
axiom_soap_header_block_set_must_understand_with_bool(reference_header_block, env, AXIS2_TRUE);
}
reference_node = axiom_soap_header_block_get_base_node(
reference_header_block, env);
if(reference_node)
{
axiom_element_t *reference_ele = NULL;
reference_ele = (axiom_element_t *)axiom_node_get_data_element(
reference_node, env);
if(reference_ele)
{
axiom_namespace_t *addr_ns_obj = NULL;
axiom_attribute_t *reference_attr = NULL;
addr_ns_obj = axiom_namespace_create(env, addr_ns,
AXIS2_WSA_DEFAULT_PREFIX);
reference_attr = axiom_attribute_create(env,
/*"isReferenceParameter"*/
AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, "true",
addr_ns_obj);
axiom_element_add_attribute(reference_ele, env,
reference_attr, reference_node);
axiom_element_set_text(reference_ele, env,
axiom_element_get_text(temp_ele, env, temp_node),
reference_node);
}
}
}
}
}
}
}
}/* if(epr_to) */
axiom_namespace_free(addressing_namespace, env);
action = axis2_msg_info_headers_get_action(msg_info_headers, env);
if(action && *action)
{
axis2_addr_out_handler_process_string_info(env, action, AXIS2_WSA_ACTION, &soap_header,
addr_ns, set_must_understand);
}
epr_reply_to = axis2_msg_info_headers_get_reply_to(msg_info_headers, env);
if(!epr_reply_to)
{
const axis2_char_t *anonymous_uri = NULL;
axis2_bool_t anonymous = axis2_msg_info_headers_get_reply_to_anonymous(
msg_info_headers, env);
axis2_bool_t none = axis2_msg_info_headers_get_reply_to_none(msg_info_headers, env);
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
}
else
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL;
}
}
if(anonymous_uri)
{
epr_reply_to = axis2_endpoint_ref_create(env, anonymous_uri);
}
if(epr_reply_to)
{
axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr_reply_to);
}
}
/* add the service group id as a reference parameter */
svc_group_context_id = axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(msg_ctx,
env), env);
axis2_addr_out_handler_add_to_soap_header(env, epr_reply_to, AXIS2_WSA_REPLY_TO,
soap_header, addr_ns);
epr_from = axis2_msg_info_headers_get_from(msg_info_headers, env);
if(epr_from)
{
axis2_addr_out_handler_add_to_soap_header(env, epr_from, AXIS2_WSA_FROM, soap_header,
addr_ns);
}
epr_fault_to = axis2_msg_info_headers_get_fault_to(msg_info_headers, env);
if(!epr_fault_to)
{
const axis2_char_t *anonymous_uri = NULL;
axis2_bool_t anonymous = axis2_msg_info_headers_get_fault_to_anonymous(
msg_info_headers, env);
axis2_bool_t none = axis2_msg_info_headers_get_fault_to_none(msg_info_headers, env);
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
}
else
{
if(none)
anonymous_uri = AXIS2_WSA_NONE_URL;
else if(anonymous)
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL;
}
if(anonymous_uri)
{
epr_fault_to = axis2_endpoint_ref_create(env, anonymous_uri);
}
}
if(epr_fault_to)
{
/* optional */
axis2_addr_out_handler_add_to_soap_header(env, epr_fault_to, AXIS2_WSA_FAULT_TO,
soap_header, addr_ns);
}
message_id = axis2_msg_info_headers_get_message_id(msg_info_headers, env);
if(message_id)
{
axis2_addr_out_handler_process_string_info(env, message_id, AXIS2_WSA_MESSAGE_ID,
&soap_header, addr_ns, set_must_understand);
}
relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env);
if(relates_to)
{
const axis2_char_t *value = NULL;
value = axis2_relates_to_get_value(relates_to, env);
relates_to_header_node = axis2_addr_out_handler_process_string_info(env, value,
AXIS2_WSA_RELATES_TO, &soap_header, addr_ns, set_must_understand);
}
if(relates_to_header_node)
{
const axis2_char_t *relationship_type = NULL;
relationship_type = axis2_relates_to_get_relationship_type(relates_to, env);
if(relationship_type && *relationship_type)
{
axiom_attribute_t *om_attr = NULL;
axiom_namespace_t *addr_ns_obj = NULL;
axiom_namespace_t *dec_ns = NULL;
relates_to_header_ele = (axiom_element_t *)axiom_node_get_data_element(
relates_to_header_node, env);
if(relates_to_header_ele)
{
dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env,
addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(dec_ns)
{
addr_ns_obj = dec_ns;
}
else
{
addr_ns_obj
= axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
}
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
om_attr = axiom_attribute_create(env,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION,
addr_ns_obj);
}
else
{
om_attr = axiom_attribute_create(env,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE, addr_ns_obj);
}
axiom_element_add_attribute(relates_to_header_ele, env, om_attr,
relates_to_header_node);
dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env,
addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(!dec_ns)
{
dec_ns = axiom_element_find_namespace(relates_to_header_ele, env,
relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(dec_ns)
{
axiom_namespace_free(addr_ns_obj, env);
addr_ns_obj = NULL;
axiom_attribute_set_namespace(om_attr, env, dec_ns);
}
}
}
}
}
}
return AXIS2_SUCCESS;
}
axis2_status_t
wsclient_get_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")))
{
axiom_node_t *text_node;
axiom_text_t *text;
axiom_data_handler_t *data_handler;
axis2_char_t *write_file = NULL;
axis2_char_t *pwd;
axis2_char_t *relative;
axutil_qname_t *attribute_qname;
axiom_attribute_t *href = NULL;
axis2_char_t *cid_value;
#if defined(WIN32)
char path[256];
GetCurrentDirectory(256, path);
pwd = path;
#else
pwd = AXIS2_GETENV ("PWD");
#endif
relative = wsclient_get_relative_path (env, pwd, base_dir);
attribute_qname = axutil_qname_create (env, "href", NULL, NULL);
if (attribute_qname)
href = axiom_element_get_attribute (element, env, attribute_qname);
else
return AXIS2_FAILURE;
if (href)
{
cid_value = axiom_attribute_get_value (href, env);
cid_value = cid_value + 4;
}
else
return AXIS2_FAILURE;
axiom_attribute_set_value (href, env, relative);
text_node = axiom_node_get_first_child (node, env);
if (text_node && (axiom_node_get_node_type (text_node, env) == AXIOM_TEXT))
{
text = (axiom_text_t *) axiom_node_get_data_element (text_node, env);
data_handler = axiom_text_get_data_handler(text, env);
if (data_handler && text)
{
if (base_dir)
{
int len = 0;
len = strlen (base_dir);
if (base_dir [len - 1] != '/')
strcat (base_dir, "/");
if (cid_value)
write_file = strcat (base_dir, cid_value);
else
return AXIS2_FAILURE;
}
if (write_file)
axiom_data_handler_set_file_name(data_handler,
env,
write_file);
axiom_data_handler_write_to(data_handler, env);
}
}
}
}
}
child_node = axiom_node_get_first_element (node, env);
while (child_node)
{
wsclient_get_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;
}
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;
}
