blob: 35e54e9d9a6d4d4650744204d702f09c522c7f70 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <axiom_text.h>
#include <axiom_output.h>
#include <axutil_string.h>
#include "axiom_node_internal.h"
#include <axiom_xml_writer.h>
#include <axiom_output.h>
#include <axiom_attribute.h>
#include <axiom_namespace.h>
#include <axutil_base64.h>
static axis2_bool_t AXIS2_CALL
axiom_text_get_is_binary(axiom_text_t *om_text,
const axutil_env_t *env);
static axis2_status_t AXIS2_CALL
axiom_text_serialize_start_part(axiom_text_t *om_text,
const axutil_env_t *env,
axiom_output_t *om_output);
struct axiom_text
{
/** Text value */
axutil_string_t *value;
/** The following fields are for MTOM */
axis2_char_t *mime_type;
axis2_bool_t optimize;
const axis2_char_t *localname;
axis2_bool_t is_binary;
axis2_char_t *content_id;
axiom_attribute_t *om_attribute;
axiom_namespace_t *ns;
axiom_data_handler_t *data_handler;
};
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
axiom_text_create(const axutil_env_t *env,
axiom_node_t * parent,
const axis2_char_t * value,
axiom_node_t **node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, node, NULL);
*node = axiom_node_create(env);
if (!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text = (axiom_text_t *) AXIS2_MALLOC(env->allocator,
sizeof(axiom_text_t));
if (!om_text)
{
AXIS2_FREE(env->allocator, *node);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text->mime_type = NULL;
om_text->optimize = AXIS2_FALSE;
om_text->localname = "Include";
om_text->is_binary = AXIS2_FALSE;
om_text->content_id = NULL;
om_text->om_attribute = NULL;
om_text->value = NULL;
om_text->ns = NULL;
om_text->data_handler = NULL;
om_text->mime_type = NULL;
om_text->ns = NULL;
if (value)
{
om_text->value = axutil_string_create(env, value);
}
axiom_node_set_data_element((*node), env, om_text);
axiom_node_set_node_type((*node), env, AXIOM_TEXT);
axiom_node_set_complete((*node), env, AXIS2_FALSE);
if (parent && axiom_node_get_node_type(parent, env) == AXIOM_ELEMENT)
{
axiom_node_add_child(parent, env, (*node));
}
return om_text;
}
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
axiom_text_create_with_data_handler(const axutil_env_t *env,
axiom_node_t * parent,
axiom_data_handler_t* data_handler,
axiom_node_t **node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, data_handler, NULL);
om_text = (axiom_text_t*)axiom_text_create(env, parent, NULL, node);
if (!om_text)
{
return NULL;
}
om_text->optimize = AXIS2_TRUE;
om_text->is_binary = AXIS2_TRUE;
om_text->data_handler = data_handler;
om_text->mime_type = axiom_data_handler_get_content_type(data_handler, env);
return om_text;
}
AXIS2_EXTERN void AXIS2_CALL
axiom_text_free(axiom_text_t * om_text,
const axutil_env_t *env)
{
AXIS2_ENV_CHECK(env, void);
if (om_text->value)
{
axutil_string_free(om_text->value, env);
}
if (om_text->ns)
{
axiom_namespace_free(om_text->ns, env);
}
if (om_text->content_id)
{
AXIS2_FREE(env->allocator, om_text->content_id);
}
if (om_text->om_attribute)
{
axiom_attribute_free(om_text->om_attribute, env);
}
if (om_text->data_handler)
{
axiom_data_handler_free(om_text->data_handler, env);
}
AXIS2_FREE(env->allocator, om_text);
return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_serialize(axiom_text_t *om_text,
const axutil_env_t *env,
axiom_output_t *om_output)
{
int status = AXIS2_SUCCESS;
axis2_char_t *attribute_value = NULL;
const axis2_char_t *text = NULL;
axiom_xml_writer_t *om_output_xml_writer = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
if (!axiom_text_get_is_binary(om_text, env))
{
if (om_text->value)
{
status = axiom_output_write(om_output, env,
AXIOM_TEXT, 1, axutil_string_get_buffer(om_text->value, env));
}
}
else
{
om_output_xml_writer = axiom_output_get_xml_writer(om_output, env);
if (om_text->optimize)
{
if (!(axiom_text_get_content_id(om_text, env)))
{
axis2_char_t *content_id = axiom_output_get_next_content_id(om_output, env);
if (content_id)
{
om_text->content_id = axutil_strdup(env, content_id);
}
}
attribute_value = axutil_stracat(env, "cid:", om_text->content_id);
/*send binary as MTOM optimised*/
if (om_text->om_attribute)
{
axiom_attribute_free(om_text->om_attribute, env);
om_text->om_attribute = NULL;
}
om_text->om_attribute = axiom_attribute_create(env, "href", attribute_value, NULL);
AXIS2_FREE(env->allocator, attribute_value);
attribute_value = NULL;
axiom_text_serialize_start_part(om_text, env, om_output);
axiom_output_write_optimized(om_output, env, om_text);
axiom_output_write(om_output, env, AXIOM_ELEMENT, 0);
}
else
{
text = axiom_text_get_text(om_text, env);
axiom_xml_writer_write_characters(om_output_xml_writer, env, (axis2_char_t*)text);
}
}
return status;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axiom_text_get_value(axiom_text_t *om_text,
const axutil_env_t *env)
{
if (om_text->value)
{
return axutil_string_get_buffer(om_text->value, env);
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_value(axiom_text_t *om_text,
const axutil_env_t *env,
const axis2_char_t *value)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
if (om_text->value)
{
axutil_string_free(om_text->value, env);
om_text->value = NULL;
}
om_text->value = axutil_string_create(env, value);
if (!om_text->value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
/*Following has been implemented for the MTOM support*/
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_text_get_mime_type(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->mime_type;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_mime_type(axiom_text_t *om_text,
const axutil_env_t *env,
const axis2_char_t *mime_type)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
if (om_text->mime_type)
{
AXIS2_FREE(env->allocator, om_text->mime_type);
}
om_text->mime_type = (axis2_char_t*)axutil_strdup(env, mime_type);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axiom_text_get_optimize(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->optimize;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_optimize(axiom_text_t *om_text,
const axutil_env_t *env,
axis2_bool_t optimize)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
om_text->optimize = optimize;
return AXIS2_SUCCESS;
}
static axis2_bool_t AXIS2_CALL
axiom_text_get_is_binary(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->is_binary;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_is_binary(axiom_text_t *om_text,
const axutil_env_t *env,
const axis2_bool_t is_binary)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
om_text->is_binary = is_binary;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axiom_text_get_localname(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->localname;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_text_get_content_id(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->content_id;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_content_id(axiom_text_t *om_text,
const axutil_env_t *env,
const axis2_char_t *content_id)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
if (om_text->content_id)
{
AXIS2_FREE(env->allocator, om_text->content_id);
}
om_text->content_id = (axis2_char_t*)axutil_strdup(env, content_id);
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
axiom_text_serialize_start_part(axiom_text_t *om_text,
const axutil_env_t *env,
axiom_output_t *om_output)
{
axis2_char_t *namespace_uri = NULL;
axis2_char_t *prefix = NULL;
const axis2_char_t *local_name = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
local_name = axiom_text_get_localname(om_text, env);
om_text->ns = axiom_namespace_create(env,
"http://www.w3.org/2004/08/xop/include", "xop");
if (om_text->ns)
{
namespace_uri = axiom_namespace_get_uri(om_text->ns, env);
if (namespace_uri)
{
prefix = axiom_namespace_get_prefix(om_text->ns, env);
if (prefix)
{
axiom_output_write(om_output, env, AXIOM_ELEMENT, 3,
local_name, namespace_uri, prefix);
}
else
{
axiom_output_write(om_output, env, AXIOM_ELEMENT, 2,
local_name, namespace_uri);
}
}
else
{
axiom_output_write(om_output, env, AXIOM_ELEMENT, 1,
local_name);
}
}
else
{
axiom_output_write(om_output, env, AXIOM_TEXT, 1,
local_name);
}
if (om_text->om_attribute)
{
axiom_attribute_serialize(om_text->om_attribute, env, om_output);
}
if (om_text->ns)
{
axiom_namespace_serialize(om_text->ns, env, om_output);
}
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);
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_EXTERN axis2_status_t AXIS2_CALL
axiom_text_serialize_namespace(axiom_text_t *om_text,
const axutil_env_t *env,
const axiom_namespace_t *om_namespace,
axiom_output_t *om_output)
{
axiom_xml_writer_t *xml_writer = NULL;
axis2_char_t *namespace_uri = NULL;
axis2_char_t *namespace_prefix = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_namespace = axiom_namespace_create(env, "" , "");
if (om_namespace)
{
namespace_uri = axiom_namespace_get_uri(om_text->ns, env);
namespace_prefix = axiom_namespace_get_prefix(om_text->ns, env);
axiom_xml_writer_write_namespace(xml_writer, env, namespace_prefix, namespace_uri);
axiom_xml_writer_set_prefix(xml_writer, env, namespace_prefix, namespace_uri);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axiom_text_get_text(axiom_text_t *om_text,
const axutil_env_t *env)
{
if (om_text->value)
{
return axutil_string_get_buffer(om_text->value, env);
}
else
{
axis2_char_t *data_handler_stream = NULL;
int data_handler_stream_size = 0;
if (om_text->data_handler)
{
int encoded_len = 0;
axis2_char_t *encoded_str = NULL;
axiom_data_handler_read_from(om_text->data_handler, env,
&data_handler_stream, &data_handler_stream_size);
if (data_handler_stream)
{
encoded_len = axutil_base64_encode_len(data_handler_stream_size);
encoded_str = AXIS2_MALLOC(env->allocator, encoded_len + 2);
if (encoded_str)
{
encoded_len = axutil_base64_encode(encoded_str,
data_handler_stream, data_handler_stream_size);
encoded_str[encoded_len] = '\0';
return encoded_str;
}
}
}
}
return NULL;
}
AXIS2_EXTERN axiom_data_handler_t *AXIS2_CALL
axiom_text_get_data_handler(axiom_text_t *om_text,
const axutil_env_t *env)
{
return om_text->data_handler;
}
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
axiom_text_create_str(const axutil_env_t *env,
axiom_node_t *parent,
axutil_string_t *value,
axiom_node_t ** node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, node, NULL);
*node = axiom_node_create(env);
if (!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text = (axiom_text_t *) AXIS2_MALLOC(env->allocator,
sizeof(axiom_text_t));
if (!om_text)
{
AXIS2_FREE(env->allocator, *node);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
om_text->mime_type = NULL;
om_text->optimize = AXIS2_FALSE;
om_text->localname = "Include";
om_text->is_binary = AXIS2_FALSE;
om_text->content_id = NULL;
om_text->om_attribute = NULL;
om_text->value = NULL;
om_text->ns = NULL;
om_text->data_handler = NULL;
om_text->mime_type = NULL;
om_text->ns = NULL;
if (value)
{
om_text->value = axutil_string_clone(value, env);
}
axiom_node_set_data_element((*node), env, om_text);
axiom_node_set_node_type((*node), env, AXIOM_TEXT);
axiom_node_set_complete((*node), env, AXIS2_FALSE);
if (parent && axiom_node_get_node_type(parent, env) == AXIOM_ELEMENT)
{
axiom_node_add_child(parent, env, (*node));
}
return om_text;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_set_value_str(struct axiom_text *om_text,
const axutil_env_t *env,
axutil_string_t *value)
{
if (om_text->value)
{
axutil_string_free(om_text->value, env);
om_text->value = NULL;
}
if (value)
{
om_text->value = axutil_string_clone(value, env);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_string_t *AXIS2_CALL
axiom_text_get_value_str(struct axiom_text *om_text,
const axutil_env_t *env)
{
return om_text->value;
}