axiom_node_t *
axis2_echo_echo(
const axutil_env_t * env,
axiom_node_t * node)
{
axiom_node_t *text_parent_node = NULL;
axiom_node_t *text_node = NULL;
axiom_node_t *ret_node = NULL;
AXIS2_ENV_CHECK(env, NULL);
/* Expected request format is :-
* <ns1:echoString xmlns:ns1="http://ws.apache.org/axis2/c/samples">
* <text>echo5</text>
* </ns1:echoString>
*/
if (!node) /* 'echoString' node */
{
set_custom_error(env, "Invalid payload; echoString node is NULL");
return NULL;
}
text_parent_node = axiom_node_get_first_element(node, env);
if (!text_parent_node)
{
set_custom_error(env, "Invalid payload; text node is NULL");
return NULL;
}
text_node = axiom_node_get_first_child(text_parent_node, env);
if (!text_node) /* actual text to echo */
{
set_custom_error(env, "Invalid payload; text to be echoed is NULL");
return NULL;
}
if (axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
{
axiom_text_t *text =
(axiom_text_t *) axiom_node_get_data_element(text_node, env);
if (text && axiom_text_get_value(text, env))
{
axis2_char_t *text_str =
(axis2_char_t *) axiom_text_get_value(text, env);
ret_node = build_om_programatically(env, text_str);
}
}
else
{
set_custom_error(env, "Invalid payload; invalid XML in request");
return NULL;
}
return ret_node;
}
axis2_status_t AXIS2_CALL
adb_data_type0_deserialize_obj(
adb_data_type0_t* _data_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;
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 data_type0");
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_data_type0_deserialize_from_string(_data_type0, env, text_value, parent);
}
}
return status;
}
/**
* @param el_node of type AXIOM_ELEMENT
* @param env
* @return text contents of el_node
*/
const axis2_char_t *sp_get_text_el(
axiom_node_t *el_node,
const axutil_env_t *env)
{
axiom_node_t *val_node = NULL;
const axis2_char_t *ret_val = NULL;
if (el_node &&
axiom_node_get_node_type(el_node, env) == AXIOM_ELEMENT)
{
val_node = axiom_node_get_first_child(el_node, env);
if (val_node &&
axiom_node_get_node_type(val_node, env) == AXIOM_TEXT)
{
axiom_text_t *val_text = NULL;
val_text = (axiom_text_t *)
axiom_node_get_data_element(val_node, env);
if (val_text)
{
ret_val = axiom_text_get_value(val_text, env);
}
}
}
return ret_val;
}
/**
* @param text_node of type AXIOM_TEXT
* @param env
* @return text contents of el_node
*/
const axis2_char_t *sp_get_text_text(
axiom_node_t *text_node,
const axutil_env_t *env)
{
const axis2_char_t *ret_val = NULL;
if (text_node &&
axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
{
axiom_text_t *val_text = (axiom_text_t *)
axiom_node_get_data_element(text_node, env);
if (val_text)
{
ret_val = axiom_text_get_value(val_text, env);
}
}
return ret_val;
}
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;
}
axiom_node_t *
axis2_sub_sub(
const axutil_env_t * env,
axiom_node_t * node)
{
axiom_node_t *param1_node = NULL;
axiom_node_t *param1_text_node = NULL;
axis2_char_t *param1_str = NULL;
long int param1 = 0;
axiom_node_t *param2_node = NULL;
axiom_node_t *param2_text_node = NULL;
axis2_char_t *param2_str = NULL;
long int param2 = 0;
if (!node)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INPUT_OM_NODE_NULL,
AXIS2_FAILURE);
printf("Math client request ERROR: input parameter NULL\n");
return NULL;
}
param1_node = axiom_node_get_first_child(node, env);
if (!param1_node)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
param1_text_node = axiom_node_get_first_child(param1_node, env);
if (!param1_text_node)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
if (axiom_node_get_node_type(param1_text_node, env) == AXIOM_TEXT)
{
axiom_text_t *text =
(axiom_text_t *) axiom_node_get_data_element(param1_text_node, env);
if (text && axiom_text_get_value(text, env))
{
param1_str = (axis2_char_t *) axiom_text_get_value(text, env);
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
param2_node = axiom_node_get_next_sibling(param1_node, env);
if (!param2_node)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
param2_text_node = axiom_node_get_first_child(param2_node, env);
if (!param2_text_node)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
if (axiom_node_get_node_type(param2_text_node, env) == AXIOM_TEXT)
{
axiom_text_t *text =
(axiom_text_t *) axiom_node_get_data_element(param2_text_node, env);
if (text && axiom_text_get_value(text, env))
{
param2_str = (axis2_char_t *) axiom_text_get_value(text, env);
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid XML in request\n");
return NULL;
}
if (param1_str && param2_str)
{
long int result = 0;
axis2_char_t result_str[255];
axiom_element_t *ele1 = NULL;
axiom_node_t *node1 = NULL,
*node2 = NULL;
axiom_namespace_t *ns1 = NULL;
axiom_text_t *text1 = NULL;
param1 = strtol(param1_str, NULL, 10);
param2 = strtol(param2_str, NULL, 10);
result = param1 - param2;
sprintf(result_str, "%ld", result);
ns1 = axiom_namespace_create(env,
"http://axis2/test/namespace1", "ns1");
ele1 = axiom_element_create(env, NULL, "result", ns1, &node1);
text1 = axiom_text_create(env, node1, result_str, &node2);
return node1;
}
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_OPERATION_PARAMETERS_IN_SOAP_REQUEST,
AXIS2_FAILURE);
printf("Math service ERROR: invalid parameters\n");
return NULL;
}
axiom_node_t*
axis2_mtom_mtom(
const axutil_env_t * env,
axiom_node_t * node,
axis2_msg_ctx_t *msg_ctx)
{
axiom_node_t *file_name_node = NULL;
axiom_node_t *file_text_node = NULL;
axiom_node_t *ret_node = NULL;
AXIS2_ENV_CHECK(env, NULL);
/* Expected request format is :-
* <ns1:mtomSample xmlns:ns1="http://ws.apache.org/axis2/c/samples">
<ns1:fileName>test.jpg</ns1:fileName>
<ns1:image>
<xop:Include xmlns:xop="http://www.w3.org/2004/08/xop/include" href="cid:[email protected]"></xop:Include>
</ns1:image>
</ns1:mtomSample>
*/
if (!node) /* 'mtomSample' node */
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INPUT_OM_NODE_NULL,
AXIS2_FAILURE);
printf("Echo client ERROR: input parameter NULL\n");
return NULL;
}
file_name_node = axiom_node_get_first_child(node, env);
if (!file_name_node) /* 'text' node */
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Echo client ERROR: invalid XML in request\n");
return NULL;
}
file_text_node = axiom_node_get_first_child(file_name_node, env);
if (!file_text_node) /* actual text to mtom */
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Echo client ERROR: invalid XML in request\n");
return NULL;
}
if (axiom_node_get_node_type(file_text_node, env) == AXIOM_TEXT)
{
axiom_text_t *text =
(axiom_text_t *) axiom_node_get_data_element(file_text_node, env);
if (text && axiom_text_get_value(text, env))
{
axiom_node_t *image_node = NULL;
axis2_char_t *text_str =
(axis2_char_t *) axiom_text_get_value(text, env);
printf("File Name %s \n", text_str);
image_node = axiom_node_get_next_sibling(file_name_node, env);
if (image_node)
{
/* axiom_node_t *inc_node = NULL;
inc_node = axiom_node_get_first_child(image_node, env);
if (inc_node)
{ */
axiom_node_t *binary_node = NULL;
binary_node = axiom_node_get_first_child(image_node, env);
if (binary_node)
{
axiom_data_handler_t *data_handler = NULL;
axiom_text_t *bin_text = (axiom_text_t *)
axiom_node_get_data_element(binary_node, env);
data_handler = axiom_text_get_data_handler(bin_text, env);
if (data_handler)
{
axiom_data_handler_t *data_handler_res = NULL;
axis2_byte_t *input_buff = NULL;
axis2_byte_t *buff = NULL;
int buff_len = 0;
axiom_data_handler_set_file_name(data_handler, env,
text_str);
axiom_data_handler_write_to(data_handler, env);
input_buff = axiom_data_handler_get_input_stream(data_handler, env);
buff_len = axiom_data_handler_get_input_stream_len(data_handler, env);
data_handler_res = axiom_data_handler_create(env, NULL, NULL);
buff = AXIS2_MALLOC(env->allocator, sizeof(axis2_byte_t)*buff_len);
memcpy(buff, input_buff, buff_len);
axiom_data_handler_set_binary_data(data_handler_res, env, buff, buff_len);
axis2_msg_ctx_set_doing_mtom (msg_ctx, env, AXIS2_TRUE);
ret_node = build_response2(env, data_handler_res);
}
else /* attachment has come by value, as non-optimized binary */
{
int plain_binary_len = 0;
int ret_len = 0;
axiom_text_t *bin_text = (axiom_text_t *)
axiom_node_get_data_element(binary_node, env);
axis2_byte_t *plain_binary = NULL;
axiom_data_handler_t *data_handler = NULL;
axis2_char_t *base64text =
(axis2_char_t *) axiom_text_get_value(bin_text,
env);
printf("base64text = %s\n", base64text);
plain_binary_len = axutil_base64_decode_len(base64text);
plain_binary = AXIS2_MALLOC(env->
allocator,
sizeof(unsigned char) *
plain_binary_len);
ret_len =
axutil_base64_decode_binary((unsigned char *)
plain_binary,
base64text);
data_handler =
axiom_data_handler_create(env, text_str, NULL);
axiom_data_handler_set_binary_data(data_handler, env,
plain_binary,
ret_len);
axiom_data_handler_write_to(data_handler, env);
ret_node = build_response1(env, base64text);
}
/* } */
}
}
}
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST,
AXIS2_FAILURE);
printf("Echo client ERROR: invalid XML in request\n");
return NULL;
}
return ret_node;
}
