/**
* Creates <ds:Transform> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_transform_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* algorithm)
{
axiom_node_t *transform_node = NULL, *tr_para_node = NULL, *tr_can_node = NULL;
axiom_element_t *transform_ele = NULL, *tr_para_ele = NULL, *tr_can_ele = NULL;
axiom_attribute_t *algo_attr = NULL;
int ret;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS);
transform_ele = axiom_element_create(env, parent, OXS_NODE_TRANSFORM, ns_obj, &transform_node);
if (!transform_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating transform element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
/* If transform algorithm is NULL then use the default */
if(!algorithm)
{
algorithm = (axis2_char_t*)OXS_HREF_XML_EXC_C14N;
}
algo_attr = axiom_attribute_create(env, OXS_ATTR_ALGORITHM, algorithm, NULL);
ret = axiom_element_add_attribute(transform_ele, env, algo_attr, transform_node);
if (!axutil_strcmp(algorithm, OXS_HREF_TRANSFORM_STR_TRANSFORM))
{
ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
tr_para_ele = axiom_element_create(
env, NULL, OXS_NODE_TRANSFORMATIONPARAMETERS, ns_obj, &tr_para_node);
if (!tr_para_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating TransformationParameters element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS);
tr_can_ele = axiom_element_create(
env, tr_para_node, OXS_NODE_CANONICALIZATION_METHOD, ns_obj, &tr_can_node);
if (!tr_can_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating CanonicalizationMethod element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
algo_attr = axiom_attribute_create(env, OXS_ATTR_ALGORITHM, OXS_HREF_XML_EXC_C14N, NULL);
axiom_element_add_attribute(tr_can_ele, env, algo_attr, tr_can_node);
axiom_node_add_child(transform_node, env, tr_para_node);
}
return transform_node;
}
/**
* Creates <wsc:DerivedKeyToken> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_derived_key_token_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* id,
axis2_char_t* algo,
axis2_char_t* wsc_ns_uri)
{
axiom_node_t *derived_key_token_node = NULL;
axiom_element_t *derived_key_token_ele = NULL;
axiom_attribute_t *algo_att = NULL;
axiom_attribute_t *id_attr = NULL;
int ret;
axiom_namespace_t *ns_obj = NULL;
axiom_namespace_t *ns = NULL;
if(!wsc_ns_uri)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element. SecConv namespace uri is not valid.",
OXS_NODE_DERIVED_KEY_TOKEN);
return NULL;
}
ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC);
ns = axiom_namespace_create(env, RAMPART_WSU_XMLNS, OXS_WSU);
derived_key_token_ele = axiom_element_create(
env, parent, OXS_NODE_DERIVED_KEY_TOKEN, ns_obj, &derived_key_token_node);
if (!derived_key_token_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element", OXS_NODE_DERIVED_KEY_TOKEN);
axiom_namespace_free(ns_obj, env);
axiom_namespace_free(ns, env);
return NULL;
}
if(algo)
{
algo_att = axiom_attribute_create(env, OXS_ATTR_ALGORITHM, algo, NULL);
ret = axiom_element_add_attribute(
derived_key_token_ele, env, algo_att, derived_key_token_node);
}
if (!id)
{
id = oxs_util_generate_id(env,(axis2_char_t*)OXS_DERIVED_ID);
}
id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id,ns);
ret = axiom_element_add_attribute(derived_key_token_ele, env, id_attr, derived_key_token_node);
return derived_key_token_node;
}
/**
* Adds an attribute to a particular node
* @param env Environment. MUST NOT be NULL
* @param node the node where the attibute will be added
* @param attribute_ns the the ns_prefix of the attribute
* @param attribute_ns_uri the uri of the attribute
* @param attribute the localname of the attribute
* @param value the value of the attribute
* @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
oxs_axiom_add_attribute(
const axutil_env_t *env,
axiom_node_t* node,
axis2_char_t* attribute_ns,
axis2_char_t* attribute_ns_uri,
axis2_char_t* attribute,
axis2_char_t* value)
{
axiom_attribute_t *attr = NULL;
axiom_element_t *ele = NULL;
axis2_status_t status = AXIS2_FAILURE;
axiom_namespace_t *ns = NULL;
if(attribute_ns_uri)
{
ns = axiom_namespace_create(env, attribute_ns_uri, attribute_ns);
}
ele = axiom_node_get_data_element(node, env);
attr = axiom_attribute_create(env, attribute , value, ns);
if((!attr) && ns)
{
axiom_namespace_free(ns, env);
}
status = axiom_element_add_attribute(ele, env, attr, node);
return status;
}
AXIS2_EXTERN void AXIS2_CALL
axiom_text_free(
axiom_text_t * om_text,
const axutil_env_t * env)
{
AXIS2_ENV_CHECK_VOID(env);
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 axiom_node_t* AXIS2_CALL
oxs_token_build_security_token_reference_element(
const axutil_env_t *env,
axiom_node_t *parent)
{
axiom_node_t *security_token_reference_node = NULL;
axiom_element_t *security_token_reference_ele = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_WSSE_XMLNS, OXS_WSSE);
/* We especially pass parent=NULL in order to add WSSE namespace to the SECURITY_TOKEN_REFRENCE
* node. Otherwise if we encrypt the signature , the dercyption fails to build the node as the
* namespace is not within the doc */
security_token_reference_ele = axiom_element_create(
env, NULL, OXS_NODE_SECURITY_TOKEN_REFRENCE, ns_obj, &security_token_reference_node);
if(!security_token_reference_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating SecurityTokenReference element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
if(parent)
{
axiom_node_add_child(parent, env, security_token_reference_node);
}
return security_token_reference_node;
}
/**
* Creates <wsse:Embedded> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_embedded_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* id)
{
axiom_node_t *embedded_node = NULL;
axiom_element_t *embedded_ele = NULL;
axiom_attribute_t *id_attr = NULL;
int ret;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
embedded_ele = axiom_element_create(env, parent, OXS_NODE_EMBEDDED, ns_obj, &embedded_node);
if(!embedded_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating embedded element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
if(!id)
{
id = oxs_util_generate_id(env,(axis2_char_t*)OXS_EMBEDDED_ID);
}
id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, NULL);
ret = axiom_element_add_attribute(embedded_ele, env, id_attr, embedded_node);
return embedded_node;
}
/* build SOAP request message content using OM */
axiom_node_t *
build_om_payload_for_poclient_svc(
const axutil_env_t * env)
{
axiom_node_t *poclient_om_node = NULL;
axiom_element_t *poclient_om_ele = NULL;
axiom_node_t *text_om_node = NULL;
axiom_element_t *text_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *om_str = NULL;
ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/services/poclient", "ns1");
poclient_om_ele = axiom_element_create(env, NULL, "poclientString", ns1, &poclient_om_node);
text_om_ele = axiom_element_create(env, poclient_om_node, "text", NULL, &text_om_node);
axiom_element_set_text(text_om_ele, env, "Hello World!", text_om_node);
om_str = axiom_node_to_string(poclient_om_node, env);
axiom_namespace_free(ns1, env);
if (om_str)
{
printf("\nSending OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
om_str = NULL;
}
return poclient_om_node;
}
/**
* Creates <ds:X509IssuerName> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_issuer_name_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* value)
{
axiom_node_t *issuer_name_node = NULL;
axiom_element_t *issuer_name_ele = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS);
issuer_name_ele = axiom_element_create(
env, parent, OXS_NODE_X509_ISSUER_NAME, ns_obj, &issuer_name_node);
if (!issuer_name_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating X509IssuerName element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
if (value)
{
axiom_element_set_text(issuer_name_ele, env, value, issuer_name_node);
}
return issuer_name_node;
}
/**
* Creates <ds:CanonicalizationMethod> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_c14n_method_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* algorithm)
{
axiom_node_t *c14n_method_node = NULL;
axiom_element_t *c14n_method_ele = NULL;
axiom_attribute_t *algo_attr = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS);
c14n_method_ele = axiom_element_create(
env, parent, OXS_NODE_CANONICALIZATION_METHOD, ns_obj, &c14n_method_node);
if (!c14n_method_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element.", OXS_NODE_CANONICALIZATION_METHOD);
axiom_namespace_free(ns_obj, env);
return NULL;
}
/* If c14n algorithm is NULL then use the default */
if(!algorithm)
{
algorithm = (axis2_char_t*)OXS_HREF_XML_EXC_C14N;
}
algo_attr = axiom_attribute_create(env, OXS_ATTR_ALGORITHM, algorithm, NULL);
axiom_element_add_attribute(c14n_method_ele, env, algo_attr, c14n_method_node);
return c14n_method_node;
}
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 = "Include";
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);
axiom_namespace_free(om_text->ns, env);
om_text->ns = NULL;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
oxs_sign_part_set_sign_namespace(
oxs_sign_part_t *sign_part,
const axutil_env_t *env,
axiom_namespace_t *sig_ns)
{
if (sign_part->sig_ns)
{
axiom_namespace_free(sign_part->sig_ns, env);
sign_part->sig_ns = NULL;
}
sign_part->sig_ns = sig_ns;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN void AXIS2_CALL
axiom_soap_fault_text_free(
axiom_soap_fault_text_t * fault_text,
const axutil_env_t * env)
{
if(fault_text->lang_ns_used == AXIS2_FALSE && fault_text->lang_namespace)
{
axiom_namespace_free(fault_text->lang_namespace, env);
fault_text->lang_namespace = NULL;
}
AXIS2_FREE(env->allocator, fault_text);
fault_text = NULL;
return;
}
axiom_node_t *
axis2_addr_out_handler_process_string_info(
const axutil_env_t * env,
const axis2_char_t * value,
const axis2_char_t * type,
axiom_soap_header_t ** soap_header_p,
const axis2_char_t * addr_ns,
axis2_bool_t set_must_understand)
{
axiom_soap_header_t *soap_header = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_node = NULL;
axiom_element_t *header_block_ele = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, value, NULL);
AXIS2_PARAM_CHECK(env->error, type, NULL);
AXIS2_PARAM_CHECK(env->error, soap_header_p, NULL);
AXIS2_PARAM_CHECK(env->error, addr_ns, NULL);
soap_header = *(soap_header_p);
if(value && *value)
{
axiom_namespace_t *addr_ns_obj = NULL;
addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj);
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);
if(header_block_ele)
{
axiom_namespace_t *dec_ns = NULL;
axiom_element_set_text(header_block_ele, env, value, header_block_node);
dec_ns = axiom_element_find_declared_namespace(header_block_ele, env, addr_ns,
AXIS2_WSA_DEFAULT_PREFIX);
if(!dec_ns)
{
axiom_namespace_free(addr_ns_obj, env);
addr_ns_obj = NULL;
}
}
if(set_must_understand)
{
axiom_soap_header_block_set_must_understand_with_bool(header_block, env, AXIS2_TRUE);
}
}
return header_block_node;
}
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;
}
/**
* Creates <wsc:Length> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_length_element(
const axutil_env_t *env,
axiom_node_t *parent,
int length,
axis2_char_t *wsc_ns_uri)
{
axiom_node_t *length_node = NULL;
axiom_element_t *length_ele = NULL;
axis2_status_t ret;
axiom_namespace_t *ns_obj = NULL;
axis2_char_t *length_val = NULL;
if(!wsc_ns_uri)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element. SecConv namespace uri is not valid.",
OXS_NODE_LENGTH);
return NULL;
}
ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC);
length_ele = axiom_element_create(env, parent, OXS_NODE_LENGTH, ns_obj, &length_node);
if(!length_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element.", OXS_NODE_LENGTH);
axiom_namespace_free(ns_obj, env);
return NULL;
}
if(length > 0)
{
length_val = (axis2_char_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 32);
sprintf(length_val, "%d", length );
}
if(length_val)
{
ret = axiom_element_set_text(length_ele, env, length_val, length_node);
AXIS2_FREE(env->allocator, length_val);
}
return length_node;
}
/* Builds the response content */
axiom_node_t *
build_om_programatically(
const axutil_env_t * env,
axis2_char_t * text)
{
axiom_node_t *echo_om_node = NULL;
axiom_element_t *echo_om_ele = NULL;
axiom_node_t *text_om_node = NULL;
axiom_element_t *text_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples", "ns1");
echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node);
text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node);
axiom_element_set_text(text_om_ele, env, text, text_om_node);
axiom_namespace_free(ns1, env);
return echo_om_node;
}
/**
* Creates <ds:SignedInfo> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_signed_info_element(
const axutil_env_t *env,
axiom_node_t *parent)
{
axiom_node_t *signed_info_node = NULL;
axiom_element_t *signed_info_ele = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS);
signed_info_ele = axiom_element_create(
env, parent, OXS_NODE_SIGNEDINFO, ns_obj, &signed_info_node);
if (!signed_info_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating SignedInfo element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
return signed_info_node;
}
/**
* Creates <xenc:CipherData> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_cipher_data_element(
const axutil_env_t *env,
axiom_node_t *parent)
{
axiom_node_t *cipher_data_node = NULL;
axiom_element_t *cipher_data_ele = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_ENC_NS, OXS_XENC);
cipher_data_ele = axiom_element_create(
env, parent, OXS_NODE_CIPHER_DATA, ns_obj, &cipher_data_node);
if (!cipher_data_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating cipher data element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
return cipher_data_node;
}
/**
* Creates <xenc:EncryptedData> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_encrypted_data_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* type_attribute,
axis2_char_t* id)
{
axiom_node_t *encrypted_data_node = NULL;
axiom_element_t *encrypted_data_ele = NULL;
axiom_attribute_t *type_attr = NULL;
axiom_attribute_t *id_attr = NULL;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_ENC_NS, OXS_XENC);
encrypted_data_ele = axiom_element_create(
env, parent, OXS_NODE_ENCRYPTED_DATA, ns_obj, &encrypted_data_node);
if(!encrypted_data_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating encrypted data element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
if (type_attribute)
{
type_attr = axiom_attribute_create(env, OXS_ATTR_TYPE, type_attribute, NULL);
axiom_element_add_attribute(encrypted_data_ele, env, type_attr, encrypted_data_node);
}
if(!id)
{
id = oxs_util_generate_id(env, (axis2_char_t*)OXS_ENCDATA_ID);
}
id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, NULL );
axiom_element_add_attribute(encrypted_data_ele, env, id_attr, encrypted_data_node);
return encrypted_data_node;
}
axiom_node_t *
build_om_programatically(
const axutil_env_t * env)
{
axiom_node_t *version_om_node = NULL;
axiom_element_t *version_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axiom_output_t *om_output = NULL;
axis2_char_t *buffer = NULL;
ns1 =
axiom_namespace_create(env, "urn:aewebservices71",
"ns1");
version_om_ele =
axiom_element_create(env, NULL, "GetVersion", ns1, &version_om_node);
xml_writer =
axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_output = axiom_output_create(env, xml_writer);
axiom_node_serialize(version_om_node, env, om_output);
buffer = (axis2_char_t *) axiom_xml_writer_get_xml(xml_writer, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n",
buffer);
if (om_output)
{
axiom_output_free(om_output, env);
om_output = NULL;
}
axiom_namespace_free(ns1, env);
return version_om_node;
}
/**
* Creates <wsse:Reference> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_reference_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t *ref,
axis2_char_t *value_type)
{
axiom_node_t *reference_node = NULL;
axiom_element_t *reference_ele = NULL;
axiom_attribute_t *ref_attr = NULL;
axiom_attribute_t *value_type_attr = NULL;
int ret;
axiom_namespace_t *ns_obj = NULL;
ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
reference_ele = axiom_element_create(env, parent, OXS_NODE_REFERENCE, ns_obj, &reference_node);
if (!reference_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating Reference element.");
axiom_namespace_free(ns_obj, env);
return NULL;
}
if(!ref)
{
ref = "";
}
ref_attr = axiom_attribute_create(env, OXS_ATTR_URI , ref, NULL);
ret = axiom_element_add_attribute(reference_ele, env, ref_attr, reference_node);
if(value_type)
{
value_type_attr = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE , value_type, NULL);
ret = axiom_element_add_attribute(reference_ele, env, value_type_attr, reference_node);
}
return reference_node;
}
/**
* Creates <wsc:Nonce> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_nonce_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* nonce_val,
axis2_char_t *wsc_ns_uri)
{
axiom_node_t *nonce_node = NULL;
axiom_element_t *nonce_ele = NULL;
axis2_status_t ret;
axiom_namespace_t *ns_obj = NULL;
if(!wsc_ns_uri)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element. SecConv namespace uri is not valid.",
OXS_NODE_NONCE);
return NULL;
}
ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC);
nonce_ele = axiom_element_create(env, parent, OXS_NODE_NONCE, ns_obj, &nonce_node);
if (!nonce_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element.", OXS_NODE_NONCE);
axiom_namespace_free(ns_obj, env);
return NULL;
}
if (nonce_val)
{
ret = axiom_element_set_text(nonce_ele, env, nonce_val, nonce_node);
}
return nonce_node;
}
/**
* Creates <wsc:Label> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_label_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t *label_val,
axis2_char_t *wsc_ns_uri)
{
axiom_node_t *label_node = NULL;
axiom_element_t *label_ele = NULL;
axiom_namespace_t *ns_obj = NULL;
if(!wsc_ns_uri)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element. SecConv namespace uri is not valid.",
OXS_NODE_LABEL);
return NULL;
}
ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC);
label_ele = axiom_element_create(env, parent, OXS_NODE_LABEL, ns_obj, &label_node);
if(!label_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Error creating %s Token element.", OXS_NODE_LABEL);
axiom_namespace_free(ns_obj, env);
return NULL;
}
if(label_val)
{
axiom_element_set_text(label_ele, env, label_val, label_node);
}
return label_node;
}
axiom_node_t* AXIS2_CALL
adb_TransformTypeChoice_serialize_obj(
adb_TransformTypeChoice_t* _TransformTypeChoice,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t *text_value_1;
axis2_char_t *text_value_1_temp;
axis2_char_t *text_value_2;
axis2_char_t *text_value_2_temp;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _TransformTypeChoice, NULL);
current_node = parent;
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
if (!data_source)
return NULL;
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
if (!stream)
return NULL;
if(!parent_tag_closed)
{
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"TransformTypeChoice\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
else {
/* if the parent tag closed we would be able to declare the type directly on the parent element */
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
}
xsi_ns = axiom_namespace_create (env,
"http://www.w3.org/2000/09/xmldsig#",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "TransformTypeChoice", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(0 == axutil_strcmp(_TransformTypeChoice->current_choice, ":extraElement"))
{
p_prefix = NULL;
if (!_TransformTypeChoice->is_valid_extraElement)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property extraElement");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("extraElement")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("extraElement")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing extraElement element
*/
sprintf(start_input_str, "<%s%sextraElement>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sextraElement>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_1 = axiom_node_to_string(_TransformTypeChoice->property_extraElement, env);
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
}
if(0 == axutil_strcmp(_TransformTypeChoice->current_choice, "http://www.w3.org/2000/09/xmldsig#:XPath"))
{
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.w3.org/2000/09/xmldsig#",
p_prefix));
}
if (!_TransformTypeChoice->is_valid_XPath)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property XPath");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("XPath")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("XPath")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing XPath element
*/
sprintf(start_input_str, "<%s%sXPath>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sXPath>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
text_value_2 = _TransformTypeChoice->property_XPath;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
if (text_value_2_temp)
{
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
AXIS2_FREE(env->allocator, text_value_2_temp);
}
else
{
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
}
return parent;
}
axiom_node_t* AXIS2_CALL
prf_logOnResponseType_serialize_obj(
prf_logOnResponseType_t* _logOnResponseType,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[PRF_DEFAULT_DIGIT_LIMIT];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _logOnResponseType, NULL);
current_node = parent;
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
if (!data_source)
return NULL;
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
if (!stream)
return NULL;
if(!parent_tag_closed)
{
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"logOnResponseType\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
else {
/* if the parent tag closed we would be able to declare the type directly on the parent element */
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
}
xsi_ns = axiom_namespace_create (env,
"http://www.pratsam.org/ns/profile/",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "logOnResponseType", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * PRF_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.pratsam.org/ns/profile/",
p_prefix));
}
if (!_logOnResponseType->is_valid_logOnResult)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property logOnResult");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("logOnResult")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("logOnResult")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing logOnResult element
*/
sprintf(start_input_str, "<%s%slogOnResult>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%slogOnResult>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
strcpy(text_value_1, (_logOnResponseType->property_logOnResult)?"true":"false");
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
/**
* Creates <wsse:BinarySecurityToken> element
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_token_build_binary_security_token_element(
const axutil_env_t *env,
axiom_node_t *parent,
axis2_char_t* id,
axis2_char_t* encoding_type,
axis2_char_t* value_type,
axis2_char_t* data)
{
axiom_node_t *binary_sec_token_node = NULL;
axiom_node_t *first_child_of_parent = NULL;
axiom_element_t *binary_security_token_ele = NULL;
axiom_attribute_t *encoding_type_att = NULL;
axiom_attribute_t *value_type_att = NULL;
axiom_attribute_t *id_attr = NULL;
axiom_namespace_t *ns_obj = NULL;
axiom_namespace_t *ns = NULL;
ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
ns = axiom_namespace_create(env, RAMPART_WSU_XMLNS, OXS_WSU);
binary_security_token_ele = axiom_element_create(env, parent, OXS_NODE_BINARY_SECURITY_TOKEN,
ns_obj, &binary_sec_token_node);
if(!binary_security_token_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s element.",
OXS_NODE_BINARY_SECURITY_TOKEN);
axiom_namespace_free(ns_obj, env);
axiom_namespace_free(ns, env);
return NULL;
}
/* Binary security token must be added as the first child of the paretn */
binary_sec_token_node = axiom_node_detach_without_namespaces(binary_sec_token_node, env);
first_child_of_parent = axiom_node_get_first_element(parent, env);
if(first_child_of_parent)
{
/* If there is a child add bst before it */
axiom_node_insert_sibling_before(first_child_of_parent, env, binary_sec_token_node);
}
else
{
/* If there are no children just add the bst */
axiom_node_add_child(parent, env, binary_sec_token_node);
}
if(!id)
{
id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID);
}
id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, ns);
encoding_type_att = axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL);
value_type_att = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL);
axiom_element_add_attribute(binary_security_token_ele, env, id_attr,
binary_sec_token_node);
axiom_element_add_attribute(binary_security_token_ele, env, encoding_type_att,
binary_sec_token_node);
axiom_element_add_attribute(binary_security_token_ele, env, value_type_att,
binary_sec_token_node);
if(data)
{
axiom_element_set_text(binary_security_token_ele, env, data,
binary_sec_token_node);
}
return binary_sec_token_node;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
oxs_sign_part_free(oxs_sign_part_t *sign_part,
const axutil_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (sign_part->id)
{
AXIS2_FREE(env->allocator, sign_part->id);
sign_part->id = NULL;
}
if (sign_part->digest_mtd)
{
AXIS2_FREE(env->allocator, sign_part->digest_mtd);
sign_part->digest_mtd = NULL;
}
if (sign_part->digest_val)
{
AXIS2_FREE(env->allocator, sign_part->digest_val);
sign_part->digest_val = NULL;
}
if (sign_part->id_name)
{
AXIS2_FREE(env->allocator, sign_part->id_name);
sign_part->id_name = NULL;
}
if (sign_part->sig_ns)
{
axiom_namespace_free(sign_part->sig_ns, env);
sign_part->sig_ns = NULL;
}
sign_part->node = NULL;
if(sign_part->transforms){
int size = 0;
int j = 0;
size = axutil_array_list_size(sign_part->transforms, env);
for (j = 0; j < size; j++)
{
oxs_transform_t *tr = NULL;
tr = axutil_array_list_get(sign_part->transforms, env, j);
oxs_transform_free(tr, env);
tr = NULL;
}
axutil_array_list_free(sign_part->transforms, env);
sign_part->transforms = NULL;
}
AXIS2_FREE(env->allocator, sign_part);
sign_part = NULL;
return AXIS2_SUCCESS;
}
axiom_node_t* AXIS2_CALL
adb_supportedContentFormats_type0_serialize_obj(
adb_supportedContentFormats_type0_t* _supportedContentFormats_type0,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
int i = 0;
int count = 0;
void *element = NULL;
axis2_char_t *text_value_1;
axis2_char_t *text_value_1_temp;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _supportedContentFormats_type0, NULL);
current_node = parent;
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
if (!data_source)
return NULL;
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
if (!stream)
return NULL;
if(!parent_tag_closed)
{
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"supportedContentFormats_type0\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
else {
/* if the parent tag closed we would be able to declare the type directly on the parent element */
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
}
xsi_ns = axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "supportedContentFormats_type0", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
p_prefix));
}
if (!_supportedContentFormats_type0->is_valid_contentFormat)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("contentFormat")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("contentFormat")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* Parsing contentFormat array
*/
if (_supportedContentFormats_type0->property_contentFormat != NULL)
{
sprintf(start_input_str, "<%s%scontentFormat>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%scontentFormat>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
count = axutil_array_list_size(_supportedContentFormats_type0->property_contentFormat, env);
for(i = 0; i < count; i ++)
{
element = axutil_array_list_get(_supportedContentFormats_type0->property_contentFormat, env, i);
if(NULL == element)
{
continue;
}
/*
* parsing contentFormat element
*/
text_value_1 = (axis2_char_t*)element;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
if (text_value_1_temp)
{
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
AXIS2_FREE(env->allocator, text_value_1_temp);
}
else
{
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
static axis2_status_t AXIS2_CALL
axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axis2_msg_ctx_t * new_msg_ctx)
{
axis2_svc_skeleton_t *svc_obj = NULL;
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
const axis2_char_t *style = NULL;
axiom_node_t *om_node = NULL;
axiom_element_t *om_element = NULL;
axis2_char_t *local_name = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *body_content_node = NULL;
axiom_element_t *body_content_element = NULL;
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axiom_node_t *out_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
int soap_version = AXIOM_SOAP12;
axiom_namespace_t *env_ns = NULL;
axiom_node_t *fault_node = NULL;
axiom_soap_fault_detail_t *fault_detail;
axis2_bool_t is_fault = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
/* get the implementation class for the Web Service */
svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx);
if(!svc_obj)
{
const axis2_char_t *svc_name = NULL;
axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
else
{
svc_name = "unknown";
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Impl object for service '%s' not set in message receiver. %d :: %s", svc_name,
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
{
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
om_node = axiom_soap_body_get_base_node(body, env);
om_element = axiom_node_get_data_element(om_node, env);
om_node = axiom_node_get_first_element(om_node, env);
}
else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
op_node = axiom_soap_body_get_base_node(body, env);
op_element = axiom_node_get_data_element(op_node, env);
if(op_element)
{
local_name = axiom_element_get_localname(op_element, env);
if(local_name)
{
axutil_array_list_t *function_arr = NULL;
int i = 0;
int size = 0;
axis2_bool_t matches = AXIS2_FALSE;
function_arr = svc_obj->func_array;
if(function_arr)
{
size = axutil_array_list_size(function_arr, env);
}
for(i = 0; i < size; i++)
{
axis2_char_t *function_name = NULL;
function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i);
if(!axutil_strcmp(function_name, local_name))
{
matches = AXIS2_TRUE;
}
}
if(matches)
{
om_node = axiom_node_get_first_child(op_node, env);
om_element = axiom_node_get_data_element(om_node, env);
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
if(status == AXIS2_SUCCESS)
{
skel_invoked = AXIS2_TRUE;
result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
}
if(result_node)
{
if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *res_name = NULL;
res_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if(!ns)
{
status = AXIS2_FAILURE;
}
else
{
body_content_element = axiom_element_create(env, NULL, res_name, ns,
&body_content_node);
axiom_node_add_child(body_content_node, env, result_node);
}
}
else
{
body_content_node = result_node;
}
}
else
{
axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env);
if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep,
AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
}
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
else
{
/* If we have a in only message result node is NULL. We create fault only if
* an error is set
*/
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) ||
(!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)))
{
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
}
}
}
}
if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
{
/* service implementation has set the envelope,
useful when setting a SOAP fault.
No need to further process */
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, "soapenv");
if(!env_ns)
{
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
axiom_namespace_free(env_ns, env);
if(!default_envelope)
{
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if(!out_header)
{
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if(!out_body)
{
return AXIS2_FAILURE;
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if(!out_node)
{
return AXIS2_FAILURE;
}
if(status != AXIS2_SUCCESS || is_fault)
{
/* something went wrong. set a SOAP Fault */
const axis2_char_t *fault_value_str = "soapenv:Sender";
const axis2_char_t *fault_reason_str = NULL;
const axis2_char_t *err_msg = NULL;
if(!skel_invoked)
{
if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP11_FAULT_CODE_RECEIVER;
}
else
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
}
}
err_msg = AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg && axutil_strcmp(err_msg, ""))
{
if(!axutil_strcmp(err_msg, "No Error"))
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
else
{
fault_reason_str = err_msg;
}
}
else
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str,
fault_reason_str, soap_version);
if (fault_node)
{
axiom_node_t *fault_detail_node = NULL;
axis2_char_t *om_str = NULL;
fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault);
fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env);
om_str = axiom_node_to_string(fault_detail_node, env);
if (om_str)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node);
}
}
if (body_content_node)
{
axiom_node_add_child(out_node, env, body_content_node);
status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
}
else if (soap_fault)
{
axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
status = AXIS2_SUCCESS;
}
else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
return status;
}
axiom_node_t* AXIS2_CALL
adb_KeyPairType_serialize_obj(
adb_KeyPairType_t* _KeyPairType,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t text_value_2[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _KeyPairType, NULL);
current_node = parent;
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
if (!data_source)
return NULL;
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
if (!stream)
return NULL;
if(!parent_tag_closed)
{
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"KeyPairType\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
else {
/* if the parent tag closed we would be able to declare the type directly on the parent element */
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
}
xsi_ns = axiom_namespace_create (env,
"http://www.daisy.org/DRM/2005/KeyExchange",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "KeyPairType", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.w3.org/2000/09/xmldsig#",
p_prefix));
}
if (!_KeyPairType->is_valid_KeyInfo)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property KeyInfo");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("KeyInfo")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("KeyInfo")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing KeyInfo element
*/
sprintf(start_input_str, "<%s%sKeyInfo",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sKeyInfo>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_KeyInfoType_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_KeyInfoType_serialize(_KeyPairType->property_KeyInfo,
env, current_node, parent_element,
adb_KeyInfoType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_KeyInfoType_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/04/xmlenc#", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.w3.org/2001/04/xmlenc#", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.w3.org/2001/04/xmlenc#",
p_prefix));
}
if (!_KeyPairType->is_valid_EncryptedKey)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property EncryptedKey");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("EncryptedKey")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("EncryptedKey")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing EncryptedKey element
*/
sprintf(start_input_str, "<%s%sEncryptedKey",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sEncryptedKey>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_EncryptedKeyType_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_EncryptedKeyType_serialize(_KeyPairType->property_EncryptedKey,
env, current_node, parent_element,
adb_EncryptedKeyType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_EncryptedKeyType_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
