/* build SOAP request message content using OM */
axiom_node_t *
build_om_programatically_mtom(
const axutil_env_t * env)
{
axiom_node_t *mtom_om_node = NULL;
axiom_element_t *mtom_om_ele = NULL;
axiom_node_t *image_om_node = NULL;
axiom_element_t *image_om_ele = NULL;
axiom_node_t *file_om_node = NULL;
axiom_element_t *file_om_ele = NULL;
axiom_node_t *data_om_node = NULL;
axiom_text_t *data_text = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *om_str = NULL;
const axis2_char_t *image_name = "E:/src/C/Axis2C/build/deploy/samples/bin/resources/axis2.jpg";
const axis2_char_t *to_save_name = "test.jpg";
axis2_bool_t optimized = AXIS2_TRUE;
axiom_data_handler_t *data_handler = NULL;
ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples/mtom", "ns1");
mtom_om_ele = axiom_element_create(env, NULL, "mtomSample", ns1, &mtom_om_node);
file_om_ele = axiom_element_create(env, mtom_om_node, "fileName", ns1, &file_om_node);
axiom_element_set_text(file_om_ele, env, to_save_name, file_om_node);
image_om_ele = axiom_element_create(env, mtom_om_node, "image", ns1, &image_om_node);
/* This is when we directly give file name */
data_handler = axiom_data_handler_create(env, image_name, "image/jpeg");
/* Uncomment following to set a callback instead of a file */
/*data_handler = axiom_data_handler_create(env, NULL, "image/jpeg");
axiom_data_handler_set_data_handler_type(data_handler, env, AXIOM_DATA_HANDLER_TYPE_CALLBACK);
axiom_data_handler_set_user_param(data_handler, env, (void *)image_name);*/
data_text
= axiom_text_create_with_data_handler(env, image_om_node, data_handler, &data_om_node);
axiom_text_set_optimize(data_text, env, optimized);
/*axiom_text_set_is_swa(data_text, env, AXIS2_TRUE);*/
om_str = axiom_node_to_string(mtom_om_node, env);
if(om_str)
{
printf("%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
return mtom_om_node;
}
//-----------------------------------------------------------------------------
axiom_node_t *
sp_make_MTOM_node20(
const axutil_env_t *env,
axutil_stream_t *st,
char *header_blob,
axis2_char_t *el_name,
axis2_char_t *content_type,
axis2_char_t *ns_prefix,
axis2_char_t *ns_uri)
{
axiom_node_t *resp_om_node = NULL;
int data_len = 0;
char *bin_data = sp_load_binary_file(env, header_blob, st, &data_len);
if (NULL == bin_data)
{
SP_ERROR(env, SP_USER_ERR_DATA_LOAD);
}
else
{
axiom_element_t *resp_om_ele = NULL;
axiom_data_handler_t *data_handler = NULL;
axiom_node_t *data_om_node = NULL;
axiom_text_t *data_text = NULL;
axiom_namespace_t *ns = axiom_namespace_create(env, ns_uri, ns_prefix);
resp_om_ele =
axiom_element_create (env, NULL, el_name, ns, &resp_om_node);
data_handler =
axiom_data_handler_create(env, NULL, content_type);
axiom_data_handler_set_binary_data
(data_handler, env, bin_data, data_len);
data_text =
axiom_text_create_with_data_handler
(env, resp_om_node, data_handler, &data_om_node);
axiom_text_set_optimize(data_text, env, AXIS2_TRUE);
}
// Note: The buffer 'bin_data' gets freed when
// axiom_data_handler_free is called, and it in turn gets called
// from axiom_text_free.
// That should get called when the resp_om_node gets freed.
// Hopefully the service framework does this at some point.
return resp_om_node;
}
/* build SOAP request message content using OM */
axiom_node_t *
build_om_programatically(
const axutil_env_t * env,
const axis2_char_t * attachment_name)
{
axiom_node_t *mtom_om_node = NULL;
axiom_element_t *mtom_om_ele = NULL;
axiom_node_t *attachment_om_node = NULL;
axiom_element_t *attachment_om_ele = NULL;
axiom_node_t *data_om_node = NULL;
axiom_text_t *data_text = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *om_str = NULL;
axiom_data_handler_t *data_handler = NULL;
ns1 =
axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples/mtom",
"ns1");
mtom_om_ele =
axiom_element_create(env, NULL, "mtomSample", ns1, &mtom_om_node);
attachment_om_ele =
axiom_element_create(env, mtom_om_node, "attachment", ns1, &attachment_om_node);
/* The attachment is loaded using the callback. The callback should be
* specified in the axis2.xml */
data_handler = axiom_data_handler_create(env, NULL, "image/jpeg");
axiom_data_handler_set_data_handler_type(data_handler, env, AXIOM_DATA_HANDLER_TYPE_CALLBACK);
axiom_data_handler_set_user_param(data_handler, env, (void *)attachment_name);
data_text =
axiom_text_create_with_data_handler(env, attachment_om_node, data_handler,
&data_om_node);
axiom_text_set_optimize(data_text, env, AXIS2_TRUE);
om_str = axiom_node_to_string(mtom_om_node, env);
if (om_str)
{
printf("%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
return mtom_om_node;
}
void wsf_util_pack_attachments (
axutil_env_t *env,
axiom_node_t *node,
VALUE attach_ht,
int enable_mtom,
char *default_cnt_type)
{
axiom_element_t *node_element = NULL;
axiom_element_t *child_element = NULL;
axiom_child_element_iterator_t *child_element_ite = NULL;
axiom_node_t *child_node = NULL;
int attachment_done = 0;
axis2_char_t *element_localname = NULL;
axiom_namespace_t *element_namespace = NULL;
axis2_char_t *namespace_uri = NULL;
if (!node)
return;
if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
node_element = axiom_node_get_data_element(node, env);
if (node_element)
{
child_element_ite = axiom_element_get_child_elements(node_element, env, node);
if (child_element_ite)
{
child_node = axiom_child_element_iterator_next(child_element_ite, env);
attachment_done = 0;
while (child_node && !attachment_done)
{
child_element = axiom_node_get_data_element(child_node, env);
element_localname = axiom_element_get_localname(child_element, env);
if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0))
{
element_namespace = axiom_element_get_namespace(child_element, env, child_node);
if (element_namespace)
{
namespace_uri = axiom_namespace_get_uri(element_namespace, env);
if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0))
{
axis2_char_t *cnt_type = NULL;
axis2_char_t *content_type = NULL;
axis2_char_t *href = NULL;
axis2_char_t* pos = NULL;
cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE);
content_type = !cnt_type ? default_cnt_type : cnt_type;
href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF);
if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:")))
{
axis2_char_t* cid = NULL;
VALUE content_tmp;
void* content = NULL;
unsigned int content_length = 0;
cid = href + 4;
content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid));
content_length = RSTRING(content_tmp)->len;
content = malloc(sizeof (char) * content_length);
memcpy (content, (const void*)STR2CSTR(content_tmp), content_length);
if (content)
{
void *data_buffer = NULL;
axiom_data_handler_t *data_handler = NULL;
axiom_node_t *text_node = NULL;
axiom_text_t *text = NULL;
data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length);
if (data_buffer)
{
memcpy (data_buffer, content, content_length);
data_handler = axiom_data_handler_create (env, NULL, content_type);
if (data_handler)
{
axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length);
text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node);
if (enable_mtom == AXIS2_FALSE)
axiom_text_set_optimize (text, env, AXIS2_FALSE);
axiom_node_detach (child_node, env);
}
}
attachment_done = 1;
}
}
}
}
}
child_node = axiom_child_element_iterator_next(child_element_ite, env);
}
}
}
}
// Process child nodes
child_node = axiom_node_get_first_child(node, env);
while (child_node)
{
wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type);
child_node = axiom_node_get_next_sibling(child_node, env);
}
}
axis2_status_t
wsclient_set_attachment (const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *base_dir,
int is_mtom_enabled)
{
axiom_node_t *child_node = NULL;
axiom_element_t *element;
if (!node || !env)
return AXIS2_FAILURE;
if (axiom_node_get_node_type (node, env) == AXIOM_ELEMENT)
{
axis2_char_t *local_name;
axiom_namespace_t *ns;
axis2_char_t *ns_uri;
element = (axiom_element_t *) axiom_node_get_data_element (node, env);
local_name = axiom_element_get_localname (element, env);
if (local_name)
{
if (!strcmp (local_name, "Include"))
{
ns = axiom_element_get_namespace(element, env, node);
if (ns && (ns_uri = axiom_namespace_get_uri (ns, env))
&& (!strcmp (ns_uri, "http://www.w3.org/2004/08/xop/include")))
{
axis2_char_t *file_path;
axiom_data_handler_t *data_handler;
axiom_text_t *data_text;
axiom_node_t *data_node;
axiom_node_t *parent;
axutil_uri_t *file_uri = NULL;
axutil_uri_t *base_uri = NULL;
axutil_uri_t *real_uri = NULL;
axis2_char_t *real_path = NULL;
parent = axiom_node_get_parent (node, env);
axiom_node_detach (node, env);
file_path = axiom_element_get_attribute_value_by_name (element, env, "href");
file_uri = axutil_uri_parse_string (env, file_path);
if (base_dir)
base_uri = axutil_uri_parse_string (env, base_dir);
else
return AXIS2_FAILURE;
if (base_uri)
real_uri = axutil_uri_parse_relative (env, base_uri, file_path);
else
return AXIS2_FAILURE;
if (real_uri)
real_path = axutil_uri_to_string (real_uri, env, 1);
else
return AXIS2_FAILURE;
if (real_path)
data_handler = axiom_data_handler_create (env, real_path, "image/jpeg");
else
return AXIS2_FAILURE;
if (data_handler)
data_text = axiom_text_create_with_data_handler (env, parent, data_handler, &data_node);
else
return AXIS2_FAILURE;
if (data_text)
{
if (!is_mtom_enabled)
axiom_text_set_optimize (data_text, env, AXIS2_FALSE);
}
}
}
}
child_node = axiom_node_get_first_element (node, env);
while (child_node)
{
wsclient_set_attachment (env, child_node, base_dir, is_mtom_enabled);
child_node = axiom_node_get_next_sibling (child_node, env);
}
}
else
return AXIS2_FAILURE;
return AXIS2_SUCCESS;
}
