static axiom_node_t *
axiom_stax_builder_create_om_text(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env)
{
axis2_char_t *temp_value = NULL;
axutil_string_t *temp_value_str = NULL;
axiom_node_t *node = NULL;
axiom_node_t *parent = om_builder->lastnode;
if(!parent)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BUILDER_STATE_LAST_NODE_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text without a node");
return NULL;
}
temp_value = axiom_xml_reader_get_value(om_builder->parser, env);
if(!temp_value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_VALUE_NULL, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid OM Text value");
return NULL;
}
#ifdef AXIS2_LIBXML2_ENABLED
temp_value_str = axutil_string_create(env, temp_value);
axiom_xml_reader_xml_free(om_builder->parser, env, temp_value);
#else
temp_value_str = axutil_string_create_assume_ownership(env, &temp_value);
#endif
if(!temp_value_str)
{
/* axutil_string_create will have set an error number */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text value");
return NULL;
}
if(axiom_node_is_complete(parent, env))
{
parent = axiom_node_get_parent(om_builder->lastnode, env);
}
axiom_text_create_str(env, parent, temp_value_str, &node);
axutil_string_free(temp_value_str, env);
if(!node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create axiom_text");
return NULL;
}
axiom_node_set_builder(node, env, om_builder);
axiom_node_set_complete(node, env, AXIS2_TRUE);
om_builder->lastnode = node;
return node;
}
AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL
axis2_conf_ctx_fill_ctxs(
axis2_conf_ctx_t * conf_ctx,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx)
{
axis2_char_t *svc_grp_ctx_id = NULL;
axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
axis2_svc_ctx_t *svc_ctx = NULL;
axis2_svc_t *svc = NULL;
axis2_svc_grp_t *svc_grp = NULL;
const axutil_qname_t *qname = NULL;
axis2_char_t *svc_id = NULL;
axis2_op_ctx_t *op_ctx = NULL;
AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL);
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(!svc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_NOT_YET_FOUND, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Service not yet found in message context. Cannot proceed");
return NULL;
}
qname = axis2_svc_get_qname(svc, env);
if(!qname)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name.");
return NULL;
}
svc_id = axutil_qname_get_localpart(qname, env);
if(!svc_id)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name.");
return NULL;
}
svc_grp = axis2_svc_get_parent(svc, env);
if(svc_grp)
{
svc_grp_ctx_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env);
}
if(!svc_grp_ctx_id)
{
svc_grp_ctx_id = (axis2_char_t *)axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(
msg_ctx, env), env);
}
/* By this time service group context id must have a value, either from transport or from
* addressing
*/
if(svc_grp_ctx_id)
{
svc_grp_ctx = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map,
svc_grp_ctx_id, AXIS2_HASH_KEY_STRING);
if(svc_grp_ctx)
{
svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id);
if(!svc_ctx)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Service group context has no servie context set for service %s", svc_id);
return NULL;
}
}
}
if(!svc_grp_ctx_id)
{
svc_grp_ctx_id = axutil_uuid_gen(env);
if(svc_grp_ctx_id)
{
axutil_string_t *svc_grp_ctx_id_str = axutil_string_create_assume_ownership(env,
&svc_grp_ctx_id);
axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str);
axutil_string_free(svc_grp_ctx_id_str, env);
}
}
if(!svc_grp_ctx)
{
axis2_svc_grp_t *svc_group;
svc_group = axis2_svc_get_parent(svc, env);
svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_group, env, conf_ctx);
svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id);
if(!svc_ctx)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Service group context has no servie context set for service %s", svc_id);
return NULL;
}
axis2_svc_grp_ctx_set_id(svc_grp_ctx, env, svc_grp_ctx_id);
axis2_conf_ctx_register_svc_grp_ctx(conf_ctx, env, svc_grp_ctx_id, svc_grp_ctx);
}
/* When you come here operation context MUST have already been assigned
to the message context */
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
if(!op_ctx)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MSG_CTX, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation context not set for message context");
return NULL;
}
axis2_op_ctx_set_parent(op_ctx, env, svc_ctx);
axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx);
axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx);
return svc_grp_ctx;
}
static axis2_status_t
axiom_stax_builder_process_namespaces(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env,
axiom_node_t * node,
int is_soap_element)
{
axis2_status_t status = AXIS2_SUCCESS;
int namespace_count = 0;
axiom_namespace_t *om_ns = NULL;
axiom_element_t *om_ele = NULL;
/* temp values */
axis2_char_t *tmp_prefix = NULL;
axis2_char_t *tmp_ns_prefix = NULL;
axis2_char_t *tmp_ns_uri = NULL;
axutil_string_t *tmp_ns_prefix_str = NULL;
axutil_string_t *tmp_ns_uri_str = NULL;
int i = 0;
om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
namespace_count = axiom_xml_reader_get_namespace_count(om_builder->parser, env);
for(i = 1; i <= namespace_count; ++i)
{
tmp_ns_prefix = axiom_xml_reader_get_namespace_prefix_by_number(om_builder->parser, env, i);
tmp_ns_uri = axiom_xml_reader_get_namespace_uri_by_number(om_builder->parser, env, i);
#ifdef AXIS2_LIBXML2_ENABLED
tmp_ns_prefix_str = axutil_string_create(env, tmp_ns_prefix);
tmp_ns_uri_str = axutil_string_create(env, tmp_ns_uri);
#else
tmp_ns_prefix_str = axutil_string_create_assume_ownership(env, &tmp_ns_prefix);
tmp_ns_uri_str = axutil_string_create_assume_ownership(env, &tmp_ns_uri);
#endif
if(!tmp_ns_prefix || axutil_strcmp(tmp_ns_prefix, "xmlns") == 0)
{
/* default namespace case. !temp_ns_prefix is for guththila */
if(tmp_ns_prefix_str)
{
axutil_string_free(tmp_ns_prefix_str, env);
}
tmp_ns_prefix_str = axutil_string_create(env, "");
om_ns = axiom_namespace_create_str(env, tmp_ns_uri_str, tmp_ns_prefix_str);
if(!om_ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create namespace");
return AXIS2_FAILURE;
}
status = axiom_element_declare_namespace(om_ele, env, node, om_ns);
if(!status)
{
axiom_namespace_free(om_ns, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error when declaring namespace");
return AXIS2_FAILURE;
}
}
else
{
axis2_char_t *prefix = NULL;
om_ns = axiom_namespace_create_str(env, tmp_ns_uri_str, tmp_ns_prefix_str);
if(!om_ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create namespace");
return AXIS2_FAILURE;
}
status = axiom_element_declare_namespace(om_ele, env, node, om_ns);
prefix = axiom_namespace_get_prefix(om_ns, env);
axutil_hash_set(om_builder->declared_namespaces, prefix, AXIS2_HASH_KEY_STRING, om_ns);
}
axutil_string_free(tmp_ns_uri_str, env);
axutil_string_free(tmp_ns_prefix_str, env);
#ifdef AXIS2_LIBXML2_ENABLED
axiom_xml_reader_xml_free(om_builder->parser, env, tmp_ns_uri);
axiom_xml_reader_xml_free(om_builder->parser, env, tmp_ns_prefix);
#endif
}
/* set own namespace */
tmp_prefix = axiom_xml_reader_get_prefix(om_builder->parser, env);
if(tmp_prefix)
{
om_ns = axutil_hash_get(om_builder->declared_namespaces, tmp_prefix, AXIS2_HASH_KEY_STRING);
if(om_ns)
{
axiom_element_set_namespace(om_ele, env, om_ns, node);
}
else
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_DOCUMENT_STATE_UNDEFINED_NAMESPACE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error when setting namespace");
return AXIS2_FAILURE;
}
axiom_xml_reader_xml_free(om_builder->parser, env, tmp_prefix);
}
return status;
}
static axis2_status_t
axiom_stax_builder_process_attributes(
axiom_stax_builder_t * om_builder,
const axutil_env_t * env,
axiom_node_t * element_node)
{
int i = 0;
int attribute_count;
axiom_element_t *om_ele = NULL;
om_ele = (axiom_element_t *)axiom_node_get_data_element(element_node, env);
attribute_count = axiom_xml_reader_get_attribute_count(om_builder->parser, env);
for(i = 1; i <= attribute_count; ++i)
{
axiom_namespace_t *ns = NULL;
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
axis2_char_t *attr_name = NULL;
axis2_char_t *attr_value = NULL;
uri = axiom_xml_reader_get_attribute_namespace_by_number(om_builder-> parser, env, i);
prefix = axiom_xml_reader_get_attribute_prefix_by_number(om_builder->parser, env, i);
if(uri && (axutil_strcmp(uri, "") != 0))
{
ns = axiom_element_find_namespace(om_ele, env, element_node, uri, prefix);
if(!ns)
{
/* if namespace is not defined yet, create it */
ns = axiom_namespace_create(env, uri, prefix);
}
}
if(uri)
{
axiom_xml_reader_xml_free(om_builder->parser, env, uri);
}
if(prefix)
{
axiom_xml_reader_xml_free(om_builder->parser, env, prefix);
}
attr_name = axiom_xml_reader_get_attribute_name_by_number(om_builder->parser, env, i);
attr_value = axiom_xml_reader_get_attribute_value_by_number(om_builder->parser, env, i);
if(attr_name)
{
axutil_string_t *attr_name_str = NULL;
axutil_string_t *attr_value_str = NULL;
axiom_attribute_t *attribute = NULL;
#ifdef AXIS2_LIBXML2_ENABLED
attr_name_str = axutil_string_create(env, attr_name);
attr_value_str = axutil_string_create(env, attr_value);
axiom_xml_reader_xml_free(om_builder->parser, env, attr_name);
axiom_xml_reader_xml_free(om_builder->parser, env, attr_value);
#else
attr_name_str = axutil_string_create_assume_ownership(env, &attr_name);
attr_value_str = axutil_string_create_assume_ownership(env, &attr_value);
#endif
attribute = axiom_attribute_create_str(env, attr_name_str, attr_value_str, ns);
axutil_string_free(attr_name_str, env);
axutil_string_free(attr_value_str, env);
if(!attribute)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create attribute");
return AXIS2_FAILURE;
}
if(axiom_element_add_attribute(om_ele, env, attribute, element_node) != AXIS2_SUCCESS)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot add attribute to element");
return AXIS2_FAILURE;
}
}
}
return AXIS2_SUCCESS;
}
