axis2_bool_t axis2_json_element_is_nil(axiom_element_t* om_element, const axutil_env_t* env)
{
axiom_attribute_t* attr = NULL;
axutil_hash_index_t* index;
axutil_hash_t* attr_hash = axiom_element_get_all_attributes(om_element, env);
if (!attr_hash)
return AXIS2_FALSE;
for (index = axutil_hash_first(attr_hash, env);
index; index = axutil_hash_next(env, index))
{
axutil_hash_this(index, NULL, NULL, (void**)&attr);
if (attr && !strcmp(axiom_attribute_get_localname(attr, env), "nil"))
{
/* found some "nil" attribute, check it namespace */
axutil_qname_t* qname =
axiom_attribute_get_qname(attr, env);
if (qname && !strcmp(axutil_qname_get_uri(qname, env), AXIS2_JSON_XSI_URI))
{
axis2_char_t* attr_value =
axiom_attribute_get_value(attr, env);
return (!strcmp(attr_value, "true") || !strcmp(attr_value, "1")) ?
AXIS2_TRUE : AXIS2_FALSE;
}
}
}
return AXIS2_FALSE;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_soap_fault_text_get_lang(
axiom_soap_fault_text_t * fault_text,
const axutil_env_t * env)
{
axiom_element_t *om_ele = NULL;
axutil_qname_t *tmp_qname = NULL;
if(!fault_text->om_ele_node)
{
return NULL;
}
om_ele = (axiom_element_t *)axiom_node_get_data_element(fault_text->om_ele_node, env);
if(!om_ele)
{
return NULL;
}
if(!(fault_text->lang_attribute))
{
/* this logic need to be rechecked */
tmp_qname = axutil_qname_create(env, AXIOM_SOAP12_SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME,
AXIOM_SOAP12_SOAP_FAULT_TEXT_LANG_ATTR_NS_URI,
AXIOM_SOAP12_SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX);
fault_text->lang_attribute = axiom_element_get_attribute(om_ele, env, tmp_qname);
axutil_qname_free(tmp_qname, env);
}
if(fault_text->lang_attribute)
{
return axiom_attribute_get_value(fault_text->lang_attribute, env);
}
else
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_fault_text_set_lang(
axiom_soap_fault_text_t * fault_text,
const axutil_env_t * env,
const axis2_char_t * lang)
{
int status = AXIS2_SUCCESS;
axiom_element_t *om_ele = NULL;
AXIS2_PARAM_CHECK(env->error, lang, AXIS2_FAILURE);
if(fault_text->lang_attribute)
{
axis2_char_t *attr_lang = NULL;
attr_lang = axiom_attribute_get_value(fault_text->lang_attribute, env);
if(attr_lang)
{
if(axutil_strcmp(attr_lang, lang) == 0)
{
/** this attribute already exists */
return AXIS2_SUCCESS;
}
}
axiom_attribute_set_value(fault_text->lang_attribute, env, lang);
return AXIS2_SUCCESS;
}
fault_text->lang_attribute = axiom_attribute_create(env,
AXIOM_SOAP12_SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME, lang, fault_text-> lang_namespace);
if(!fault_text->lang_attribute)
{
return AXIS2_FAILURE;
}
if(!fault_text->om_ele_node)
{
return AXIS2_FAILURE;
}
om_ele = (axiom_element_t *)axiom_node_get_data_element(fault_text->om_ele_node, env);
if(!om_ele)
{
return AXIS2_FAILURE;
}
status = axiom_element_add_attribute(om_ele, env, fault_text->lang_attribute,
fault_text->om_ele_node);
if(status == AXIS2_SUCCESS)
{
fault_text->lang_ns_used = AXIS2_TRUE;
}
else
{
axiom_attribute_free(fault_text->lang_attribute, env);
fault_text->lang_attribute = NULL;
}
return status;
}
axis2_status_t
axis2_addr_in_extract_ref_params(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_info_headers_t * msg_info_headers)
{
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axutil_qname_t *wsa_qname = NULL;
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_info_headers, AXIS2_FAILURE);
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if(!header_block_ht)
{
return AXIS2_FAILURE;
}
wsa_qname = axutil_qname_create(env, AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE,
AXIS2_WSA_NAMESPACE, NULL);
for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index
= axutil_hash_next(env, hash_index))
{
void *hb = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_node = NULL;
axiom_element_t *header_block_ele = NULL;
axutil_hash_this(hash_index, NULL, NULL, &hb);
header_block = (axiom_soap_header_block_t *)hb;
header_block_node = axiom_soap_header_block_get_base_node(header_block, env);
if(header_block_node && (axiom_node_get_node_type(header_block_node, env) == AXIOM_ELEMENT))
{
axiom_attribute_t *om_attr = NULL;
axis2_char_t *attr_value = NULL;
header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node,
env);
om_attr = axiom_element_get_attribute(header_block_ele, env, wsa_qname);
if(om_attr)
{
attr_value = axiom_attribute_get_value(om_attr, env);
if(!axutil_strcmp(attr_value, AXIS2_WSA_TYPE_ATTRIBUTE_VALUE))
{
axis2_msg_info_headers_add_ref_param(msg_info_headers, env, header_block_node);
}
}
}
}
axutil_qname_free(wsa_qname, env);
return AXIS2_SUCCESS;
}
/**
* Auxiliary function to determine an ADB object type from its Axiom node.
* @param env pointer to environment struct
* @param node double pointer to the parent node to deserialize
* @return type name on success, else NULL
*/
axis2_char_t *AXIS2_CALL
axis2_extension_mapper_type_from_node(
const axutil_env_t *env,
axiom_node_t** node)
{
axiom_node_t *parent = *node;
axutil_qname_t *element_qname = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi;
void *val;
axiom_attribute_t *type_attr;
axutil_hash_t *ht;
axis2_char_t *temp;
axis2_char_t *type;
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
ht = axiom_element_get_all_attributes(element, env);
if (ht == NULL)
return NULL;
for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
axis2_char_t *localpart;
axutil_hash_this(hi, NULL, NULL, &val);
type_attr = (axiom_attribute_t *)val;
localpart = axutil_qname_get_localpart(axiom_attribute_get_qname(type_attr, env), env);
if (axutil_strcmp(localpart, "type") == 0) break;
}
type = axiom_attribute_get_value(type_attr, env);
if (type != NULL && (temp = axutil_strchr(type, ':')) != NULL)
{
if (axutil_strchr(temp, ':') != NULL)
type = temp + 1; /* Pointer arithmetic */
}
return type;
}
axiom_node_t *
axis2_listener_notify(const axutil_env_t *env, axiom_node_t *node)
{
axiom_node_t *pres_node = NULL;
axiom_node_t *status_node = NULL;
axiom_element_t *body_elem = NULL;
axiom_element_t *pres_elem = NULL;
axiom_element_t *status_elem = NULL;
axiom_attribute_t *attr_from = NULL;
axutil_qname_t *qname= NULL;
axis2_char_t *str = NULL;
axis2_char_t *from = NULL;
axis2_char_t *status = NULL;
AXIS2_ENV_CHECK(env, NULL);
str = axiom_node_to_string(node, env);
body_elem = axiom_node_get_data_element(node, env);
qname = axutil_qname_create(env, "presence", NULL, NULL);
pres_elem = axiom_element_get_first_child_with_qname(body_elem, env, qname,
node, &pres_node);
axutil_qname_free(qname, env);
if (pres_elem)
{
qname = axutil_qname_create(env, "from", NULL, NULL);
attr_from = axiom_element_get_attribute(pres_elem, env, qname);
axutil_qname_free(qname, env);
if (attr_from)
{
from = axiom_attribute_get_value(attr_from, env);
}
qname = axutil_qname_create(env, "status", NULL, NULL);
status_elem = axiom_element_get_first_child_with_qname(pres_elem, env, qname,
pres_node, &status_node);
axutil_qname_free(qname, env);
if (status_elem)
{
status = axiom_element_get_text(status_elem, env, status_node);
}
}
printf("\n************************************************************\n");
printf("Received presence notification:\n\n");
printf("From: %s\n", from);
printf("Status: %s\n", status);
printf("\nFull notification:\n%s\n\n", str);
return NULL;
}
void
get_all_policy(
axis2_char_t * element_name,
const axutil_env_t * env,
axutil_array_list_t * policy_node_list,
axis2_char_t * wsdl_name)
{
axutil_hash_t *attr_hash = NULL;
axutil_hash_index_t *hi = NULL;
axiom_element_t *element = NULL;
axiom_attribute_t *attribute = NULL;
axis2_char_t *attribute_val = NULL;
axiom_node_t *parent_policy_node = NULL,
*parent_node = NULL;
parent_node = return_policy_element(element_name, env, wsdl_name);
if (!parent_node)
return;
parent_policy_node =
return_policy_element(get_policy_ref(parent_node, env), env, wsdl_name);
axutil_array_list_add(policy_node_list, env, parent_policy_node);
if (axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT)
{
element =
(axiom_element_t *) axiom_node_get_data_element(parent_node, env);
attr_hash = axiom_element_get_all_attributes(element, env);
if (attr_hash)
{
hi = axutil_hash_next(env, axutil_hash_first(attr_hash, env));
do
{
if (hi)
{
axutil_hash_this(hi, NULL, NULL, &attribute);
attribute_val = axiom_attribute_get_value(attribute, env);
attribute_val = axutil_rindex(attribute_val, ':');
attribute_val =
axutil_string_substring_starting_at(attribute_val, 1);
get_all_policy(attribute_val, env, policy_node_list,
wsdl_name);
hi = axutil_hash_next(env, hi);
}
}
while (hi);
}
}
return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_grp_builder_process_module_refs(
axis2_svc_grp_builder_t * svc_grp_builder,
const axutil_env_t * env,
axiom_children_qname_iterator_t * module_refs,
axis2_svc_grp_t * svc_grp)
{
AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE);
while(axiom_children_qname_iterator_has_next(module_refs, env))
{
axiom_node_t *module_ref_node = NULL;
axiom_element_t *module_ref_element = NULL;
axiom_attribute_t *module_ref_att = NULL;
axutil_qname_t *qref = NULL;
module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env);
module_ref_element = axiom_node_get_data_element(module_ref_node, env);
qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL);
module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref);
if(module_ref_att)
{
axis2_char_t *ref_name = NULL;
axutil_qname_t *qrefname = NULL;
axis2_module_desc_t *module = NULL;
ref_name = axiom_attribute_get_value(module_ref_att, env);
qrefname = axutil_qname_create(env, ref_name, NULL, NULL);
module = axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine(
svc_grp_builder->desc_builder, env), env, qrefname);
if(!module)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Module %s not found in deployment engine.", ref_name);
return AXIS2_FAILURE;
}
else
{
axis2_svc_grp_add_module_ref(svc_grp, env, qrefname);
}
axutil_qname_free(qrefname, env);
}
axutil_qname_free(qref, env);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_serialize_attribute(
axiom_text_t * om_text,
const axutil_env_t * env,
axiom_output_t * om_output,
axiom_attribute_t * om_attribute)
{
axiom_xml_writer_t *xml_writer = NULL;
axiom_namespace_t *om_namespace = NULL;
axis2_char_t *namespace_uri = NULL;
axis2_char_t *prefix = NULL;
axis2_char_t *attribute_local_name = NULL;
axis2_char_t *attribute_value = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
(void)om_output;
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_namespace = axiom_namespace_create(env, "", "");
namespace_uri = axiom_namespace_get_uri(om_text->ns, env);
attribute_local_name = axiom_attribute_get_localname(om_attribute, env);
if(om_namespace)
{
prefix = axiom_namespace_get_prefix(om_text->ns, env);
attribute_value = axiom_attribute_get_value(om_attribute, env);
if(prefix)
{
axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value);
}
else
{
axiom_xml_writer_write_attribute_with_namespace(xml_writer, env, attribute_local_name,
attribute_value, namespace_uri);
}
}
else
{
axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value);
}
axiom_namespace_free(om_namespace, env);
return AXIS2_SUCCESS;
}
axis2_char_t *
get_policy_ref(
axiom_node_t * node,
const axutil_env_t * env)
{
axiom_element_t *policy_element = NULL;
axiom_children_iterator_t *children_iter = NULL;
axiom_node_t *child_node = NULL;
axutil_qname_t *qname = NULL;
axis2_char_t *value = NULL;
axis2_char_t *val = NULL;
axiom_attribute_t *attr = NULL;
policy_element = (axiom_element_t *) axiom_node_get_data_element(node, env);
children_iter = axiom_element_get_children(policy_element, env, node);
while (axiom_children_iterator_has_next(children_iter, env))
{
child_node = axiom_children_iterator_next(children_iter, env);
if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
policy_element =
(axiom_element_t *) axiom_node_get_data_element(child_node,
env);
if (axutil_strcmp
(axiom_element_get_localname(policy_element, env),
"PolicyReference") == 0)
{
qname = axutil_qname_create(env, "URI", NULL, NULL);
attr = axiom_element_get_attribute(policy_element, env, qname);
if (attr)
{
value = axiom_attribute_get_value(attr, env);
val = axutil_string_substring_starting_at(value, 1);
return val;
}
}
}
}
return NULL;
}
axiom_node_t *
return_policy_element(
axis2_char_t * name,
const axutil_env_t * env,
axis2_char_t * wsdl_name)
{
axiom_element_t *ele1 = NULL,
*ele2 = NULL;
axiom_document_t *document = NULL;
axiom_node_t *node1 = NULL,
*node2 = NULL,
*policy_node = NULL;
axiom_namespace_t *ns = NULL;
axiom_xml_reader_t *reader = NULL;
axiom_stax_builder_t *builder = NULL;
char *buffer = NULL;
axiom_attribute_t *attr = NULL;
axis2_char_t *value = NULL;
axis2_char_t *val = NULL;
axutil_hash_t *attr_hash = NULL;
axis2_char_t *xml_output = NULL;
axutil_hash_index_t *hi;
/*
f = fopen(wsdl_name, "r");
if (!f)
return NULL;
reader = axiom_xml_reader_create_for_io(env, read_input, NULL , NULL, NULL);
*/
reader = axiom_xml_reader_create_for_file(env, wsdl_name, NULL);
if (!reader)
{
printf("ERROR CREATING PULLPARSER");
return NULL;
}
builder = axiom_stax_builder_create(env, reader);
if (!builder)
{
printf("ERROR CREATING PULL PARSER");
return NULL;
}
document = axiom_stax_builder_get_document(builder, env);
if (!document)
return NULL;
node1 = axiom_document_get_root_element(document, env);
if (!node1)
{
printf(" root element null ");
axiom_stax_builder_free(builder, env);
return NULL;
}
do
{
node2 = axiom_document_build_next(document, env);
if (!node2)
break;
if (axiom_node_get_node_type(node2, env) == AXIOM_ELEMENT)
{
ele2 = (axiom_element_t *) axiom_node_get_data_element(node2, env);
attr_hash = axiom_element_get_all_attributes(ele2, env);
if (attr_hash)
{
hi = axutil_hash_first(attr_hash, env);
axutil_hash_this(hi, NULL, NULL, &attr);
if (axutil_strcmp(axiom_attribute_get_value(attr, env), name) ==
0)
{
policy_node = node2;
}
}
}
}
while (node2);
return policy_node;
}
axis2_status_t
axis2_addr_in_extract_addr_params(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_info_headers_t ** msg_info_headers_p,
axutil_array_list_t * addr_headers,
const axis2_char_t * addr_ns_str,
axis2_msg_ctx_t * msg_ctx)
{
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p);
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t to_found = AXIS2_FALSE;
axis2_bool_t reply_to_found = AXIS2_FALSE;
axis2_bool_t fault_to_found = AXIS2_FALSE;
axis2_bool_t action_found = AXIS2_FALSE;
axis2_bool_t msg_id_found = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_info_headers_p, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_headers, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE);
if (!msg_info_headers)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No messgae info header. Creating new");
msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
if (!msg_info_headers)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MSG_INFO_HEADERS, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"No message information headers available");
return AXIS2_FAILURE;
}
}
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if (!header_block_ht)
{
return AXIS2_FAILURE;
}
/* Iterate thru header blocks */
for (hash_index = axutil_hash_first(header_block_ht, env); hash_index;
hash_index = axutil_hash_next(env, hash_index))
{
void *hb = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_node = NULL;
axiom_element_t *header_block_ele = NULL;
axis2_char_t *ele_localname = NULL;
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *role = NULL;
axutil_hash_this(hash_index, NULL, NULL, &hb);
header_block = (axiom_soap_header_block_t *) hb;
header_block_node =
axiom_soap_header_block_get_base_node(header_block, env);
header_block_ele =
(axiom_element_t *) axiom_node_get_data_element(header_block_node,
env);
ele_localname = axiom_element_get_localname(header_block_ele, env);
role = axiom_soap_header_block_get_role(header_block, env);
if (role && !axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NONE))
{
/* Role is none, no need of processing */
continue;
}
if (!axutil_strcmp(ele_localname, AXIS2_WSA_TO))
{
/* Here the addressing epr overidde what ever already there in the message context */
epr =
axis2_endpoint_ref_create(env,
axiom_element_get_text
(header_block_ele, env,
header_block_node));
if (AXIS2_TRUE == to_found)
{
/* Duplicate To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
axis2_msg_info_headers_set_to(msg_info_headers, env, epr);
axis2_addr_in_extract_to_epr_ref_params(env, epr, soap_header,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FROM))
{
epr = axis2_msg_info_headers_get_from(msg_info_headers, env);
if (!epr)
{
/* The address is not known now. Pass the empty
string and fill this once the element
under this is processed. */
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_from(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_REPLY_TO))
{
epr = axis2_msg_info_headers_get_reply_to(msg_info_headers, env);
if (reply_to_found == AXIS2_TRUE)
{
/* Duplicate Reply To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_REPLY_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
reply_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FAULT_TO))
{
epr = axis2_msg_info_headers_get_fault_to(msg_info_headers, env);
if (fault_to_found == AXIS2_TRUE)
{
/* Duplicate Fault To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_FAULT_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
axis2_msg_info_headers_set_fault_to(msg_info_headers, env,
NULL);
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_fault_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
fault_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_MESSAGE_ID))
{
axis2_char_t *text = NULL;
if (msg_id_found == AXIS2_TRUE)
{
/* Duplicate Message ID */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_MESSAGE_ID,
addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_in_message_id(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
msg_id_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_ACTION))
{
axis2_char_t *text = NULL;
if (action_found == AXIS2_TRUE)
{
/* Duplicate Action */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_action(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
action_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_RELATES_TO))
{
axis2_char_t *address = NULL;
axutil_qname_t *rqn = NULL;
axiom_attribute_t *relationship_type = NULL;
const axis2_char_t *relationship_type_default_value = NULL;
const axis2_char_t *relationship_type_value = NULL;
axis2_relates_to_t *relates_to = NULL;
if (!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns_str))
{
relationship_type_default_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_default_value =
AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
rqn =
axutil_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
NULL, NULL);
relationship_type =
axiom_element_get_attribute(header_block_ele, env, rqn);
if (!relationship_type)
{
relationship_type_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_value =
axiom_attribute_get_value(relationship_type, env);
}
address =
axiom_element_get_text(header_block_ele, env,
header_block_node);
relates_to =
axis2_relates_to_create(env, address, relationship_type_value);
axis2_msg_info_headers_set_relates_to(msg_info_headers, env,
relates_to);
axiom_soap_header_block_set_processed(header_block, env);
axutil_qname_free(rqn, env);
}
}
/* If an action is not found, it's a false*/
if (action_found == AXIS2_FALSE)
{
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_SnakeException_deserialize(
adb_SnakeException_t* _SnakeException,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _SnakeException, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for SnakeException : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building message element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
element_qname = axutil_qname_create(env, "message", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_SnakeException_set_message(_SnakeException, env,
text_value);
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element message");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
status = adb_SnakeException_set_message(_SnakeException, env,
"");
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for message ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_service_type0_deserialize_obj(
adb_service_type0_t* _service_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _service_type0, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for service_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
/*
* building label element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
element_qname = axutil_qname_create(env, "label", "http://www.daisy.org/ns/daisy-online/", NULL);
if (adb_label_type0_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_label_type0");
status = adb_label_type0_deserialize((adb_label_type0_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element label");
}
else
{
status = adb_service_type0_set_label(_service_type0, env,
(adb_label_type0_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for label ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "id"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "id", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "id");
}
if(attrib_text != NULL)
{
adb_service_type0_set_id(_service_type0,
env, attrib_text);
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute id missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_lang_type0_deserialize_from_string(
adb_lang_type0_t* _lang_type0,
const axutil_env_t *env,
const axis2_char_t *node_value,
axiom_node_t *parent)
{
axis2_status_t status = AXIS2_SUCCESS;
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "type", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
axiom_element_t *current_element = NULL;
current_element = (axiom_element_t*)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "lang|http://www.w3.org/XML/1998/namespace"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "type");
}
if(attrib_text)
{
/* skipping the namespace prefix */
axis2_char_t *temp_attrib = NULL;
temp_attrib = strchr(attrib_text, ':');
if(temp_attrib)
{
/* take the string after the ':' character */
attrib_text = temp_attrib + 1;
}
}
if(!attrib_text) {
/* nothing is here, reset things */
status = adb_lang_type0_reset_members(_lang_type0, env);
}
else
{
status = adb_lang_type0_set_language(_lang_type0,
env, attrib_text);
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_grp_builder_populate_svc_grp(
axis2_svc_grp_builder_t * svc_grp_builder,
const axutil_env_t * env,
axis2_svc_grp_t * svc_grp)
{
axiom_children_qname_iterator_t *itr = NULL;
axiom_children_qname_iterator_t *module_ref_itr = NULL;
axiom_children_qname_iterator_t *svc_itr = NULL;
axutil_qname_t *qparamst = NULL;
axutil_qname_t *qmodulest = NULL;
axutil_qname_t *qsvc_element = NULL;
axiom_element_t *svc_grp_element = NULL;
axis2_status_t status = AXIS2_FAILURE;
axis2_conf_t *parent = NULL;
/* Processing service level paramters */
svc_grp_element = axiom_node_get_data_element(svc_grp_builder->svc_grp, env);
qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
itr = axiom_element_get_children_with_qname(svc_grp_element, env, qparamst,
svc_grp_builder->svc_grp);
if(qparamst)
{
axutil_qname_free(qparamst, env);
qparamst = NULL;
}
parent = axis2_svc_grp_get_parent(svc_grp, env);
status = axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env, itr,
axis2_svc_grp_get_param_container(svc_grp, env),
axis2_conf_get_param_container(parent, env));
/* Processing service modules required to be engaged globally */
qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL);
module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qmodulest,
svc_grp_builder-> svc_grp);
if(qmodulest)
{
axutil_qname_free(qmodulest, env);
qmodulest = NULL;
}
axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env, module_ref_itr, svc_grp);
qsvc_element = axutil_qname_create(env, AXIS2_SVC_ELEMENT, NULL, NULL);
svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qsvc_element,
svc_grp_builder->svc_grp);
if(qsvc_element)
{
axutil_qname_free(qsvc_element, env);
qsvc_element = NULL;
}
while(axiom_children_qname_iterator_has_next(svc_itr, env))
{
axiom_node_t *svc_node = NULL;
axiom_element_t *svc_element = NULL;
axiom_attribute_t *svc_name_att = NULL;
axis2_char_t *svc_name = NULL;
axutil_qname_t *qattname = NULL;
svc_node = (axiom_node_t *)axiom_children_qname_iterator_next(svc_itr, env);
svc_element = axiom_node_get_data_element(svc_node, env);
qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
svc_name_att = axiom_element_get_attribute(svc_element, env, qattname);
if(qattname)
{
axutil_qname_free(qattname, env);
qattname = NULL;
}
svc_name = axiom_attribute_get_value(svc_name_att, env);
if(!svc_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service name attribute has no value");
return AXIS2_FAILURE;
}
else
{
axis2_svc_t *axis_svc = NULL;
axis2_arch_file_data_t *file_data = NULL;
axutil_array_list_t *deployable_svcs = NULL;
axis2_svc_builder_t *svc_builder = NULL;
file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine(
svc_grp_builder->desc_builder, env), env);
axis_svc = axis2_arch_file_data_get_svc(file_data, env, svc_name);
if(!axis_svc)
{
axutil_qname_t *qsvc_name = NULL;
qsvc_name = axutil_qname_create(env, svc_name, NULL, NULL);
axis_svc = axis2_svc_create_with_qname(env, qsvc_name);
axutil_qname_free(qsvc_name, env);
axis2_arch_file_data_add_svc(file_data, env, axis_svc);
}
/* Adding service to the deployable services list */
deployable_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env);
axutil_array_list_add(deployable_svcs, env, axis_svc);
axis2_svc_set_parent(axis_svc, env, svc_grp);
svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env,
axis2_desc_builder_get_dep_engine(svc_grp_builder-> desc_builder, env), axis_svc);
status = axis2_svc_builder_populate_svc(svc_builder, env, svc_node);
axis2_svc_builder_free(svc_builder, env);
}
}
return status;
}
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 int AXIS2_CALL saml_authentication_query_build(saml_authentication_query_t* authentication_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
if(attr_hash)
{
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_AUTHENTICATION_METHOD))
{
authentication_query->auth_method = attr_val;
break;
}
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(authentication_query->subject)
return saml_subject_build(authentication_query->subject, child_node, env);
else
return AXIS2_FAILURE;
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
AXIS2_EXTERN int AXIS2_CALL saml_attr_query_build(saml_attr_query_t* attribute_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
saml_attr_desig_t *attr_desig = NULL;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
/*One resource attribute relate to the attibute query*/
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env),SAML_RESOURCE))
{
attribute_query->resource = attr_val;
break;
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(attribute_query->subject)
saml_subject_build(attribute_query->subject, child_node, env);
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_ATTRIBUTE_DESIGNATOR)))
{
/*attr_desig = saml_attr_desig_create(env);
*/
attr_desig = (saml_attr_desig_t*)AXIS2_MALLOC(env->allocator,
sizeof(saml_attr_desig_t));
if( AXIS2_SUCCESS == saml_attr_desig_build(attr_desig, child_node, env))
{
axutil_array_list_add(attribute_query->attr_desigs,env, attr_desig);
}
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
/**
* 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;
}
/**
* Traverse thru the node and its descendents. Check if the node has a particular attribute with
* name as in @attr and namespace as in @ns. Returns the attribute value.
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param attribute_name the attribute name of the node
* @param ns namespace of the attribute
* @return the attribute value if found, else NULL
*/
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
oxs_axiom_get_attribute_value_of_node_by_name(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *attribute_name,
axis2_char_t *ns_uri)
{
axis2_char_t *found_val = NULL;
axiom_element_t *ele = NULL;
axutil_hash_t *attr_list = NULL;
axutil_hash_index_t *hi = NULL;
ele = axiom_node_get_data_element(node, env);
/* Get attribute list of the element */
attr_list = axiom_element_extract_attributes(ele, env, node);
if(!attr_list)
{
return NULL;
}
/* namespace uri can be NULL. In that case, use empty string */
if(!ns_uri)
{
ns_uri = "";
}
/* Traverse thru all the attributes. If both localname and the nsuri matches return the val */
for (hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi))
{
void *attr = NULL;
axiom_attribute_t *om_attr = NULL;
axutil_hash_this(hi, NULL, NULL, &attr);
if (attr)
{
axis2_char_t *this_attr_name = NULL;
axis2_char_t *this_attr_ns_uri = NULL;
axiom_namespace_t *attr_ns = NULL;
om_attr = (axiom_attribute_t*)attr;
this_attr_name = axiom_attribute_get_localname(om_attr, env);
attr_ns = axiom_attribute_get_namespace(om_attr, env);
if(attr_ns)
{
this_attr_ns_uri = axiom_namespace_get_uri(attr_ns, env);
}
else
{
this_attr_ns_uri = "";
}
if((!axutil_strcmp(attribute_name, this_attr_name)) &&
(!axutil_strcmp(ns_uri, this_attr_ns_uri)))
{
/* Got it !!! */
found_val = axiom_attribute_get_value(om_attr, env);
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
for(hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi))
{
void *val = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
axiom_attribute_free((axiom_attribute_t *)val, env);
val = NULL;
}
}
axutil_hash_free(attr_list, env);
attr_list = NULL;
return found_val;
}
axis2_status_t AXIS2_CALL
adb_supportedContentFormats_type0_deserialize_obj(
adb_supportedContentFormats_type0_t* _supportedContentFormats_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _supportedContentFormats_type0, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for supportedContentFormats_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building contentFormat array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building contentFormat element
*/
element_qname = axutil_qname_create(env, "contentFormat", "http://www.daisy.org/ns/daisy-online/", NULL);
for (i = 0, sequence_broken = 0, current_node = first_node; !sequence_broken && current_node != NULL;)
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node =axiom_node_get_next_sibling(current_node, env);
is_early_node_valid = AXIS2_FALSE;
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element contentFormat");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for contentFormat ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i < 0)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "contentFormat (@minOccurs = '0') only have %d elements", i);
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_supportedContentFormats_type0_set_contentFormat(_supportedContentFormats_type0, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_build(saml_autho_decision_query_t* autho_decision_query,
axiom_node_t *node,
const axutil_env_t *env)
{
axutil_hash_t *attr_hash = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi = NULL;
axiom_child_element_iterator_t *iterator = NULL;
axiom_node_t *child_node;
saml_action_t *action;
if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
if ((element = axiom_node_get_data_element(node, env)) == NULL)
{
return AXIS2_FAILURE;
}
/* initialize the attributes */
attr_hash = axiom_element_get_all_attributes(element, env);
for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
{
void *v = NULL;
axutil_hash_this(hi, NULL, NULL, &v);
if (v)
{
axis2_char_t *attr_val = NULL;
axiom_attribute_t *attr = (axiom_attribute_t*)v;
attr_val = axiom_attribute_get_value(attr, env);
if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RESOURCE))
{
if(autho_decision_query->resource)
{
autho_decision_query->resource = attr_val;
break;
}
else
return AXIS2_FAILURE;
}
}
}
iterator = axiom_element_get_child_elements(element, env, node);
if(iterator)
{
while(axiom_child_element_iterator_has_next(iterator, env))
{
child_node = axiom_child_element_iterator_next(iterator, env);
element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_SUBJECT)))
{
if(autho_decision_query->subject)
saml_subject_build(autho_decision_query->subject, child_node, env);
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_ACTION)))
{
if(autho_decision_query->saml_actions)
{
action = saml_action_create(env);
saml_action_build(action, child_node, env);
axutil_array_list_add(autho_decision_query->saml_actions, env, action);
}
}
else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
SAML_EVIDENCE)))
{
if(autho_decision_query->evidence)
saml_evidence_build(autho_decision_query->evidence, child_node, env);
}
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
axis2_status_t AXIS2_CALL
adb_UAKType_deserialize_obj(
adb_UAKType_t* _UAKType,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
status = AXIS2_FAILURE;
if(parent)
{
axis2_char_t *attrib_text = NULL;
attrib_text = axiom_element_get_attribute_value_by_name(axiom_node_get_data_element(parent, env), env, "nil");
if (attrib_text != NULL && !axutil_strcasecmp(attrib_text, "true"))
{
/* but the wsdl says that, this is non nillable */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element UAKType");
status = AXIS2_FAILURE;
}
else
{
axiom_node_t *text_node = NULL;
axiom_text_t *text_element = NULL;
text_node = axiom_node_get_first_child(parent, env);
if (text_node &&
axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
text_element = (axiom_text_t*)axiom_node_get_data_element(text_node, env);
text_value = "";
if(text_element && axiom_text_get_value(text_element, env))
{
text_value = (axis2_char_t*)axiom_text_get_value(text_element, env);
}
status = adb_UAKType_deserialize_from_string(_UAKType, env, text_value, parent);
}
}
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "issuerID"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "issuerID", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "issuerID");
}
if(attrib_text != NULL)
{
adb_UAKType_set_issuerID(_UAKType,
env, attrib_text);
}
else if(!dont_care_minoccurs)
{
/*
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
*/
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute issuerID missing");
return AXIS2_FAILURE;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "collectionID"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "collectionID", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "collectionID");
}
if(attrib_text != NULL)
{
adb_UAKType_set_collectionID(_UAKType,
env, attrib_text);
}
else if(!dont_care_minoccurs)
{
/*
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
*/
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute collectionID missing");
return AXIS2_FAILURE;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_deserialize_obj(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for CanonicalizationMethodType : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
/*
* building extraElement array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building extraElement element
*/
/* 'any' arrays are not handling correctly when there are other elements mixed with the 'any' element. */
for (i = 0, sequence_broken = 0, current_node = first_node; !sequence_broken && current_node != NULL;)
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node =axiom_node_get_next_sibling(current_node, env);
is_early_node_valid = AXIS2_FALSE;
continue;
}
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("extraElement", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for extraElement ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_CanonicalizationMethodType_set_extraElement(_CanonicalizationMethodType, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "Algorithm"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "Algorithm", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "Algorithm");
}
if(attrib_text != NULL)
{
adb_CanonicalizationMethodType_set_Algorithm(_CanonicalizationMethodType,
env, axutil_uri_parse_string(env, attrib_text));
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute Algorithm missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
axis2_libcurl_send(
axis2_libcurl_t *data,
axiom_output_t * om_output,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axiom_soap_envelope_t * out,
const axis2_char_t * str_url,
const axis2_char_t * soap_action)
{
struct curl_slist *headers = NULL;
axiom_soap_body_t *soap_body;
axis2_bool_t is_soap = AXIS2_TRUE;
axis2_bool_t send_via_get = AXIS2_FALSE;
axis2_bool_t send_via_head = AXIS2_FALSE;
axis2_bool_t send_via_put = AXIS2_FALSE;
axis2_bool_t send_via_delete = AXIS2_FALSE;
axis2_bool_t doing_mtom = AXIS2_FALSE;
axiom_node_t *body_node = NULL;
axiom_node_t *data_out = NULL;
axutil_property_t *method = NULL;
axis2_char_t *method_value = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axis2_char_t *buffer = NULL;
unsigned int buffer_size = 0;
int content_length = -1;
axis2_char_t *content_type = NULL;
/*axis2_char_t *content_len = AXIS2_HTTP_HEADER_CONTENT_LENGTH_; */
const axis2_char_t *char_set_enc = NULL;
axis2_char_t *content = AXIS2_HTTP_HEADER_CONTENT_TYPE_;
axis2_char_t *soap_action_header = AXIS2_HTTP_HEADER_SOAP_ACTION_;
axutil_stream_t *in_stream;
axutil_property_t *trans_in_property;
axutil_string_t *char_set_enc_str;
axis2_byte_t *output_stream = NULL;
int output_stream_size = 0;
CURL *handler;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_transport_out_desc_t *trans_desc = NULL;
axutil_param_t *write_xml_declaration_param = NULL;
axutil_hash_t *transport_attrs = NULL;
axis2_bool_t write_xml_declaration = AXIS2_FALSE;
axutil_property_t *property;
int *response_length = NULL;
axis2_http_status_line_t *status_line = NULL;
axis2_char_t *status_line_str = NULL;
axis2_char_t *tmp_strcat = NULL;
int status_code = 0;
AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, data->handler, AXIS2_FAILURE);
handler = data->handler;
curl_easy_reset(handler);
curl_easy_setopt(handler, CURLOPT_ERRORBUFFER, data->errorbuffer);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_USER_AGENT_AXIS2C);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_ACCEPT_);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_EXPECT_);
if(AXIS2_FAILURE == axis2_libcurl_set_options(handler, env, msg_ctx))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[axis2libcurl]Setting options in Libcurl failed");
return AXIS2_FAILURE;
}
if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env))
{
is_soap = AXIS2_FALSE;
}
else
{
is_soap = AXIS2_TRUE;
}
if (!is_soap)
{
soap_body = axiom_soap_envelope_get_body(out, env);
if (!soap_body)
{
AXIS2_HANDLE_ERROR(env,
AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
body_node = axiom_soap_body_get_base_node(soap_body, env);
if (!body_node)
{
AXIS2_HANDLE_ERROR(env,
AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
data_out = axiom_node_get_first_element(body_node, env);
method = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env,
AXIS2_HTTP_METHOD);
if (method)
{
method_value =
(axis2_char_t *) axutil_property_get_value(method, env);
}
/* The default is POST */
if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET))
{
send_via_get = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_HEAD))
{
send_via_head = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_PUT))
{
send_via_put = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_DELETE))
{
send_via_delete = AXIS2_TRUE;
}
}
conf_ctx = axis2_msg_ctx_get_conf_ctx (msg_ctx, env);
if (conf_ctx)
{
conf = axis2_conf_ctx_get_conf (conf_ctx, env);
}
if (conf)
{
trans_desc = axis2_conf_get_transport_out (conf,
env, AXIS2_TRANSPORT_ENUM_HTTP);
}
if (trans_desc)
{
write_xml_declaration_param =
axutil_param_container_get_param
(axis2_transport_out_desc_param_container (trans_desc, env), env,
AXIS2_XML_DECLARATION);
}
if (write_xml_declaration_param)
{
transport_attrs =
axutil_param_get_attributes (write_xml_declaration_param, env);
if (transport_attrs)
{
axutil_generic_obj_t *obj = NULL;
axiom_attribute_t *write_xml_declaration_attr = NULL;
axis2_char_t *write_xml_declaration_attr_value = NULL;
obj = axutil_hash_get (transport_attrs, AXIS2_ADD_XML_DECLARATION,
AXIS2_HASH_KEY_STRING);
if (obj)
{
write_xml_declaration_attr = (axiom_attribute_t *)
axutil_generic_obj_get_value (obj,
env);
}
if (write_xml_declaration_attr)
{
write_xml_declaration_attr_value =
axiom_attribute_get_value (write_xml_declaration_attr, env);
}
if (write_xml_declaration_attr_value &&
0 == axutil_strcasecmp (write_xml_declaration_attr_value,
AXIS2_VALUE_TRUE))
{
write_xml_declaration = AXIS2_TRUE;
}
}
}
if (write_xml_declaration)
{
axiom_output_write_xml_version_encoding (om_output, env);
}
if (!send_via_get && !send_via_head && !send_via_delete)
{
xml_writer = axiom_output_get_xml_writer(om_output, env);
char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env);
if (!char_set_enc_str)
{
char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
}
else
{
char_set_enc = axutil_string_get_buffer(char_set_enc_str, env);
}
if (!send_via_put && is_soap)
{
doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env);
axiom_output_set_do_optimize(om_output, env, doing_mtom);
axiom_soap_envelope_serialize(out, env, om_output, AXIS2_FALSE);
if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
if (AXIS2_ESC_DOUBLE_QUOTE != *soap_action)
{
axis2_char_t *tmp_soap_action = NULL;
tmp_soap_action =
AXIS2_MALLOC(env->allocator,
(axutil_strlen(soap_action) +
5) * sizeof(axis2_char_t));
sprintf(tmp_soap_action, "\"%s\"", soap_action);
tmp_strcat = axutil_stracat(env, soap_action_header,tmp_soap_action);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_soap_action);
}
else
{
tmp_strcat = axutil_stracat(env, soap_action_header, soap_action);
headers = curl_slist_append(headers, tmp_strcat );
AXIS2_FREE(env->allocator, tmp_strcat);
}
}
if (doing_mtom)
{
/*axiom_output_flush(om_output, env, &output_stream,
&output_stream_size);*/
axiom_output_flush(om_output, env);
content_type =
(axis2_char_t *) axiom_output_get_content_type(om_output,
env);
if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
if (axutil_strcmp(soap_action, ""))
{
/* handle SOAP action for SOAP 1.2 case */
axis2_char_t *temp_content_type = NULL;
temp_content_type = axutil_stracat (env,
content_type,
AXIS2_CONTENT_TYPE_ACTION);
content_type = temp_content_type;
temp_content_type = axutil_stracat (env,
content_type,
soap_action);
AXIS2_FREE (env->allocator, content_type);
content_type = temp_content_type;
temp_content_type =
axutil_stracat (env, content_type,
AXIS2_ESC_DOUBLE_QUOTE_STR);
AXIS2_FREE (env->allocator, content_type);
content_type = temp_content_type;
}
}
}
else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
axis2_char_t *temp_content_type = NULL;
content_type =
(axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
content_type = axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_CHARSET);
temp_content_type =
axutil_stracat(env, content_type, char_set_enc);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
else
{
axis2_char_t *temp_content_type = NULL;
content_type =
(axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP;
content_type = axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_CHARSET);
temp_content_type =
axutil_stracat(env, content_type, char_set_enc);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
if (axutil_strcmp(soap_action, ""))
{
temp_content_type =
axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_ACTION);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
temp_content_type =
axutil_stracat(env, content_type, soap_action);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
temp_content_type = axutil_stracat(env, content_type,
AXIS2_SEMI_COLON_STR);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
}
else if (is_soap)
{
AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Attempt to send SOAP"
"message using HTTP PUT failed");
return AXIS2_FAILURE;
}
else
{
axutil_property_t *content_type_property = NULL;
axutil_hash_t *content_type_hash = NULL;
axis2_char_t *content_type_value = NULL;
axiom_node_serialize(data_out, env, om_output);
content_type_property =
(axutil_property_t *)
axis2_msg_ctx_get_property(msg_ctx, env,
AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE);
if (content_type_property)
{
content_type_hash =
(axutil_hash_t *)
axutil_property_get_value(content_type_property, env);
if (content_type_hash)
{
content_type_value =
(char *) axutil_hash_get(content_type_hash,
AXIS2_HTTP_HEADER_CONTENT_TYPE,
AXIS2_HASH_KEY_STRING);
}
}
if (content_type_value)
{
content_type = content_type_value;
}
else
{
content_type = axutil_strdup(env,AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML);
}
}
buffer = axiom_xml_writer_get_xml(xml_writer, env);
if (!doing_mtom)
{
buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env);
}
else
buffer_size = output_stream_size;
{
/*
* Curl calculates the content-length automatically.
* This commented section is not only unnecessary,
* it interferes with authentication.
*
* NTLM, for example, will send an empty request
* first (no body) to get the auth challenge
* before resending with actual content.
*/
/*char tmp_buf[10];
sprintf(tmp_buf, "%d", buffer_size);
tmp_strcat = axutil_stracat(env, content_len, tmp_buf);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
tmp_strcat = NULL;*/
tmp_strcat = axutil_stracat(env, content, content_type);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
tmp_strcat = NULL;
}
if (!doing_mtom)
{
curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, buffer_size);
curl_easy_setopt(handler, CURLOPT_POSTFIELDS, buffer);
}
else
{
curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE,
output_stream_size);
curl_easy_setopt(handler, CURLOPT_POSTFIELDS, output_stream);
}
if (send_via_put)
{
curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_PUT);
}
curl_easy_setopt(handler, CURLOPT_URL, str_url);
}
else
{
axis2_char_t *request_param;
axis2_char_t *url_encode;
request_param =
(axis2_char_t *) axis2_http_sender_get_param_string(NULL, env,
msg_ctx);
url_encode = axutil_strcat(env, str_url, AXIS2_Q_MARK_STR,
request_param, NULL);
if (send_via_get)
{
curl_easy_setopt(handler, CURLOPT_HTTPGET, 1);
}
else if (send_via_head)
{
curl_easy_setopt(handler, CURLOPT_NOBODY, 1);
}
else if (send_via_delete)
{
curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_DELETE);
}
curl_easy_setopt(handler, CURLOPT_URL, url_encode);
}
{
axis2_bool_t manage_session;
manage_session = axis2_msg_ctx_get_manage_session(msg_ctx, env);
if (manage_session == AXIS2_TRUE)
{
if (data->cookies == AXIS2_FALSE)
{
/* Ensure cookies enabled to manage session */
/* Pass empty cookie string to enable cookies */
curl_easy_setopt(handler, CURLOPT_COOKIEFILE, " ");
data->cookies = AXIS2_TRUE;
}
}
else if (data->cookies == AXIS2_TRUE)
{
/* Pass special string ALL to reset cookies if any have been enabled. */
/* If cookies have ever been enabled, we reset every time as long as
manage_session is false, as there is no clear curl option to
turn off the cookie engine once enabled. */
curl_easy_setopt(handler, CURLOPT_COOKIELIST, AXIS2_ALL);
}
}
curl_easy_setopt(handler, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(handler, CURLOPT_WRITEFUNCTION,
axis2_libcurl_write_memory_callback);
curl_easy_setopt(handler, CURLOPT_WRITEDATA, data);
curl_easy_setopt (handler, CURLOPT_HEADERFUNCTION, axis2_libcurl_header_callback);
curl_easy_setopt (handler, CURLOPT_WRITEHEADER, data);
/* Free response data from previous request */
if( data->size )
{
if (data->memory)
{
AXIS2_FREE(data->env->allocator, data->memory);
}
data->size = 0;
}
if (curl_easy_perform(handler))
{
AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "%s", &data->errorbuffer);
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
in_stream = axutil_stream_create_libcurl(env, data->memory, data->size);
trans_in_property = axutil_property_create(env);
axutil_property_set_scope(trans_in_property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_free_func(trans_in_property, env,
libcurl_stream_free);
axutil_property_set_value(trans_in_property, env, in_stream);
axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN,
trans_in_property);
if (axutil_array_list_size(data->alist, env) > 0)
{
status_line_str = axutil_array_list_get(data->alist, env, 0);
if (status_line_str)
{
status_line = axis2_http_status_line_create(env, status_line_str);
}
}
if (status_line)
{
status_code = axis2_http_status_line_get_status_code(status_line, env);
}
axis2_msg_ctx_set_status_code (msg_ctx, env, status_code);
AXIS2_FREE(data->env->allocator, content_type);
content_type = axis2_libcurl_get_content_type(data, env);
if (content_type)
{
if (strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)
&& strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_XOP_XML))
{
axis2_ctx_t *axis_ctx =
axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env),
env);
property = axutil_property_create (env);
axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value (property,
env, axutil_strdup (env, content_type));
axis2_ctx_set_property (axis_ctx,
env, MTOM_RECIVED_CONTENT_TYPE, property);
}
}
content_length = axis2_libcurl_get_content_length(data, env);
if (content_length >= 0)
{
response_length = AXIS2_MALLOC (env->allocator, sizeof (int));
memcpy (response_length, &content_length, sizeof (int));
property = axutil_property_create (env);
axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value (property, env, response_length);
axis2_msg_ctx_set_property (msg_ctx, env,
AXIS2_HTTP_HEADER_CONTENT_LENGTH, property);
}
curl_slist_free_all (headers);
/* release the read http headers. */
/* (commenting out the call below is a clever way to force a premature EOF
condition in subsequent messages, as they will be read using the content-length
of the first message.) */
axis2_libcurl_free_headers(data, env);
AXIS2_FREE(data->env->allocator, content_type);
axis2_http_status_line_free( status_line, env);
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
adb_TransformTypeChoice_deserialize_obj(
adb_TransformTypeChoice_t* _TransformTypeChoice,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _TransformTypeChoice, AXIS2_FAILURE);
first_node = parent;
/*
* building extraElement element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
if (
(current_node ))
{
if( current_node )
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
status = adb_TransformTypeChoice_set_extraElement(_TransformTypeChoice, env,
current_property_node);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for extraElement ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building XPath element
*/
/*
* because elements are ordered this works fine
*/
if(current_node != NULL && is_early_node_valid)
{
current_node = axiom_node_get_next_sibling(current_node, env);
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
}
is_early_node_valid = AXIS2_FALSE;
element_qname = axutil_qname_create(env, "XPath", "http://www.w3.org/2000/09/xmldsig#", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_TransformTypeChoice_set_XPath(_TransformTypeChoice, env,
text_value);
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element XPath");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
status = adb_TransformTypeChoice_set_XPath(_TransformTypeChoice, env,
"");
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for XPath ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
*dp_parent = current_node;
*dp_is_early_node_valid = is_early_node_valid;
return status;
}
/**
* axis2_libcurl_set_proxy_options maps proxy AXIS2/C options to
* libcURL options.
*
* CURLOPT_PROXY - char * proxy hostname
* CURLOPT_PROXYPORT - long proxy listen port
* CURLOPT_PROXYUSERPWD - char * user:password to authenticate to proxy
*
* TODO:
* CURLOPT_PROXYTYPE - long enum type of proxy (HTTP, SOCKS)
* CURLOPT_PROXYAUTH - long bitmask which authentication methods to use for proxy
*/
static axis2_status_t
axis2_libcurl_set_proxy_options(
CURL *handler,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx)
{
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_transport_out_desc_t *trans_desc = NULL;
axutil_param_t *proxy_param = NULL;
axutil_hash_t *transport_attrs = NULL;
axutil_property_t *property = NULL;
axis2_char_t *uname = NULL;
axis2_char_t *passwd = NULL;
axis2_char_t *proxy_host = NULL;
axis2_char_t *proxy_port = NULL;
property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_UNAME);
if (property)
{
uname = (axis2_char_t *) axutil_property_get_value(property, env);
}
property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_PASSWD);
if (property)
{
passwd = (axis2_char_t *) axutil_property_get_value(property, env);
}
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if (conf_ctx)
{
conf = axis2_conf_ctx_get_conf(conf_ctx, env);
if (conf)
{
trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP);
}
}
if (trans_desc)
{
proxy_param = axutil_param_container_get_param(
axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_HTTP_PROXY_API);
if (!proxy_param)
{
proxy_param = axutil_param_container_get_param(
axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_HTTP_PROXY);
}
if (proxy_param)
{
transport_attrs = axutil_param_get_attributes(proxy_param, env);
}
}
if (transport_attrs)
{
axutil_generic_obj_t *obj = NULL;
axiom_attribute_t *attr = NULL;
if (!uname || !passwd)
{
obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_USERNAME, AXIS2_HASH_KEY_STRING);
if (obj)
{
attr = (axiom_attribute_t *) axutil_generic_obj_get_value(obj, env);
}
if (attr)
{
uname = axiom_attribute_get_value(attr, env);
}
attr = NULL;
obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PASSWORD, AXIS2_HASH_KEY_STRING);
if (obj)
{
attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env);
}
if (attr)
{
passwd = axiom_attribute_get_value(attr, env);
}
}
obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_HOST, AXIS2_HASH_KEY_STRING);
if (obj)
{
attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env);
}
if (attr)
{
proxy_host = axiom_attribute_get_value(attr, env);
}
if (proxy_host)
{
curl_easy_setopt(handler, CURLOPT_PROXY, proxy_host);
}
attr = NULL;
obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PORT, AXIS2_HASH_KEY_STRING);
if (obj)
{
attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env);
}
if (attr)
{
proxy_port = axiom_attribute_get_value(attr, env);
}
if (proxy_port)
{
curl_easy_setopt(handler, CURLOPT_PROXYPORT, AXIS2_ATOI(proxy_port));
}
}
if (uname && passwd)
{
axis2_char_t buffer[256];
strncpy(buffer, uname, 256);
strncat(buffer, ":", 256);
strncat(buffer, passwd, 256);
curl_easy_setopt(handler, CURLOPT_PROXYUSERPWD, buffer);
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
adb_audio_type0_deserialize_obj(
adb_audio_type0_t* _audio_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _audio_type0, AXIS2_FAILURE);
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for audio_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "uri"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "uri", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "uri");
}
if(attrib_text != NULL)
{
adb_audio_type0_set_uri(_audio_type0,
env, axutil_uri_parse_string(env, attrib_text));
}
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute uri missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "rangeBegin"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "rangeBegin", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "rangeBegin");
}
if(attrib_text != NULL)
{
adb_audio_type0_set_rangeBegin(_audio_type0,
env, axutil_strtol(attrib_text, (char**)NULL, 0));
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "rangeEnd"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "rangeEnd", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "rangeEnd");
}
if(attrib_text != NULL)
{
adb_audio_type0_set_rangeEnd(_audio_type0,
env, axutil_strtol(attrib_text, (char**)NULL, 0));
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(!strcmp((axis2_char_t*)key, "size"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "size", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "size");
}
if(attrib_text != NULL)
{
adb_audio_type0_set_size(_audio_type0,
env, axutil_strtol(attrib_text, (char**)NULL, 0));
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
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;
}
