AXIS2_EXTERN axis2_status_t AXIS2_CALL
neethi_operator_serialize(
neethi_operator_t *neethi_operator,
const axutil_env_t *env,
axiom_node_t *parent)
{
neethi_policy_t *policy = NULL;
neethi_all_t *all = NULL;
neethi_exactlyone_t *exactlyone = NULL;
neethi_reference_t *reference = NULL;
neethi_assertion_t *assertion = NULL;
if(neethi_operator->value)
{
switch(neethi_operator->type)
{
case OPERATOR_TYPE_POLICY:
policy = (neethi_policy_t *)neethi_operator_get_value(neethi_operator, env);
if(!neethi_policy_serialize(policy, parent, env))
{
return AXIS2_FAILURE;
}
else
{
return AXIS2_SUCCESS;
}
break;
case OPERATOR_TYPE_ALL:
all = (neethi_all_t *)neethi_operator_get_value(neethi_operator, env);
return neethi_all_serialize(all, parent, env);
break;
case OPERATOR_TYPE_EXACTLYONE:
exactlyone = (neethi_exactlyone_t *)neethi_operator_get_value(neethi_operator, env);
return neethi_exactlyone_serialize(exactlyone, parent, env);
break;
case OPERATOR_TYPE_REFERENCE:
reference = (neethi_reference_t *)neethi_operator_get_value(neethi_operator, env);
return neethi_reference_serialize(reference, parent, env);
break;
case OPERATOR_TYPE_ASSERTION:
assertion = (neethi_assertion_t *)neethi_operator_get_value(neethi_operator, env);
return neethi_assertion_serialize(assertion, parent, env);
break;
case OPERATOR_TYPE_UNKNOWN:
break;
}
return AXIS2_SUCCESS;
}
else
return AXIS2_FAILURE;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
neethi_is_mtom_required(
const axutil_env_t *env,
neethi_policy_t *policy)
{
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
neethi_all_t *all = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_policy_t *normalized_policy = NULL;
neethi_operator_t *operator = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
int i = 0;
normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
if(normalized_policy)
{
alternatives = neethi_policy_get_alternatives(normalized_policy, env);
}
component =
(neethi_operator_t *) axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *) neethi_operator_get_value(component, env);
arraylist = neethi_all_get_policy_components(all, env);
for (i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator =(neethi_operator_t *) axutil_array_list_get(arraylist, env,
i);
assertion =
(neethi_assertion_t *) neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
/*if (value)
{*/
if (type == ASSERTION_TYPE_OPTIMIZED_MIME_SERIALIZATION)
{
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return AXIS2_TRUE;
}
/*}*/
}
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return AXIS2_FALSE;
}
axis2_status_t AXIS2_CALL
x509_token_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_x509_token_t *x509_token)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
type = neethi_assertion_get_type(assertion, env);
if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
{
rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC10);
}
else if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13)
{
rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC13);
}
else if(type == ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE)
{
rp_x509_token_set_require_key_identifier_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_ISSUER_SERIAL_REFERENCE)
{
rp_x509_token_set_require_issuer_serial_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_EMBEDDED_TOKEN_REFERENCE)
{
rp_x509_token_set_require_embedded_token_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_THUMBPRINT_REFERENCE)
{
rp_x509_token_set_require_thumb_print_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_WSS_X509_V1_TOKEN_10)
{
rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V1_TOKEN_10);
}
else if(type == ASSERTION_TYPE_WSS_X509_V3_TOKEN_10)
{
rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V3_TOKEN_10);
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_wss10_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_wss10_t *wss10 = NULL;
neethi_policy_t *policy = NULL;
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
neethi_all_t *all = NULL;
neethi_assertion_t *assertion = NULL;
neethi_policy_t *normalized_policy = NULL;
(void)element;
wss10 = rp_wss10_create(env);
child_node = axiom_node_get_first_element(node, env);
if(!child_node)
{
return NULL;
}
if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
if(child_element)
{
policy = neethi_engine_get_policy(env, child_node, child_element);
if(!policy)
{
return NULL;
}
normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
neethi_policy_free(policy, env);
policy = NULL;
alternatives = neethi_policy_get_alternatives(normalized_policy, env);
component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *)neethi_operator_get_value(component, env);
wss10_process_alternatives(env, all, wss10);
assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_wss10_free,
wss10, ASSERTION_TYPE_WSS10);
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return assertion;
}
else
return NULL;
}
else
return NULL;
}
axis2_status_t AXIS2_CALL
transport_token_process_alternatives(
const axutil_env_t * env,
neethi_all_t * all,
rp_property_t * transport_token)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
if(value)
{
if(type == ASSERTION_TYPE_HTTPS_TOKEN)
{
rp_https_token_t *https_token = NULL;
https_token = (rp_https_token_t *)neethi_assertion_get_value(assertion, env);
if(https_token)
{
rp_property_set_value(transport_token, env, https_token,
RP_PROPERTY_HTTPS_TOKEN);
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
username_token_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_username_token_t *username_token)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for (i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator =(neethi_operator_t *) axutil_array_list_get(arraylist, env,
i);
assertion =
(neethi_assertion_t *) neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
if (value)
{
if (type == ASSERTION_TYPE_WSS_USERNAME_TOKEN_10)
{
rp_username_token_set_useUTprofile10(username_token, env,
AXIS2_TRUE);
}
else if (type == ASSERTION_TYPE_WSS_USERNAME_TOKEN_11)
{
rp_username_token_set_useUTprofile11(username_token, env,
AXIS2_TRUE);
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
wss10_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_wss10_t *wss10)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_KEY_IDENTIFIER)
{
rp_wss10_set_must_support_ref_key_identifier(wss10, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_ISSUER_SERIAL)
{
rp_wss10_set_must_support_ref_issuer_serial(wss10, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EXTERNAL_URI)
{
rp_wss10_set_must_support_ref_external_uri(wss10, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EMBEDDED_TOKEN)
{
rp_wss10_set_must_support_ref_embedded_token(wss10, env, AXIS2_TRUE);
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rp_issued_token_builder_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_issued_token_t *issued_token)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
type = neethi_assertion_get_type(assertion, env);
if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
{
rp_issued_token_set_derivedkeys(issued_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_EXTERNAL_REFERENCE)
{
rp_issued_token_set_require_exernal_reference(issued_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_INTERNAL_REFERENCE)
{
rp_issued_token_set_require_internal_reference(issued_token, env, AXIS2_TRUE);
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL
rp_secpolicy_builder_build(
const axutil_env_t *env,
neethi_policy_t *policy)
{
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
neethi_all_t *all = NULL;
rp_secpolicy_t *secpolicy = NULL;
secpolicy = rp_secpolicy_create(env);
alternatives = neethi_policy_get_alternatives(policy, env);
component =
(neethi_operator_t *) axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *) neethi_operator_get_value(component, env);
if (secpolicy_process_alternatives(env, all, secpolicy) == AXIS2_FAILURE)
{
return NULL;
}
return secpolicy;
}
AXIS2_EXTERN neethi_assertion_t * AXIS2_CALL
rp_issued_token_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_issued_token_t *issued_token = NULL;
neethi_policy_t *policy = NULL;
neethi_policy_t *normalized_policy = NULL;
neethi_all_t *all = NULL;
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
axis2_char_t *inclusion_value = NULL;
axutil_qname_t *qname = NULL;
axiom_node_t *issuer_node = NULL;
axiom_element_t *issuer_ele = NULL;
axiom_element_t *issuer_first_child_ele = NULL;
axiom_node_t *issuer_first_child_node = NULL;
axiom_node_t *req_sec_tok_template_node = NULL;
axiom_element_t *req_sec_tok_template_ele = NULL;
axiom_node_t *policy_node = NULL;
axiom_element_t *policy_ele = NULL;
neethi_assertion_t *assertion = NULL;
issued_token = rp_issued_token_create(env);
qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
inclusion_value = axiom_element_get_attribute_value(element, env, qname);
axutil_qname_free(qname, env);
qname = NULL;
if(!inclusion_value)
{
/* we can try whether WS-SP1.2 specific inclusion value */
qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
inclusion_value = axiom_element_get_attribute_value(element, env, qname);
axutil_qname_free(qname, env);
qname = NULL;
}
if(inclusion_value)
{
rp_issued_token_set_inclusion(issued_token, env, inclusion_value);
}
qname = axutil_qname_create(env, RP_ISSUER, RP_SP_NS_11, RP_SP_PREFIX);
issuer_ele = axiom_element_get_first_child_with_qname(element, env, qname, node, &issuer_node);
if(issuer_ele)
{
issuer_first_child_ele = axiom_element_get_first_element(issuer_ele, env, issuer_node,
&issuer_first_child_node);
if(issuer_first_child_ele)
{
rp_issued_token_set_issuer_epr(issued_token, env, issuer_first_child_node);
}
}
axutil_qname_free(qname, env);
qname = NULL;
qname = axutil_qname_create(env, RP_REQUEST_SEC_TOKEN_TEMPLATE, RP_SP_NS_11, RP_SP_PREFIX);
req_sec_tok_template_ele = axiom_element_get_first_child_with_qname(element, env, qname, node,
&req_sec_tok_template_node);
if(req_sec_tok_template_ele)
{
rp_issued_token_set_requested_sec_token_template(issued_token, env,
req_sec_tok_template_node);
}
else
{
return NULL;
}
axutil_qname_free(qname, env);
qname = NULL;
qname = axutil_qname_create(env, RP_POLICY, RP_POLICY_NS, RP_POLICY_PREFIX);
policy_ele = axiom_element_get_first_child_with_qname(element, env, qname, node, &policy_node);
if(policy_ele)
{
policy = neethi_engine_get_policy(env, policy_node, policy_ele);
if(!policy)
{
return NULL;
}
normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
neethi_policy_free(policy, env);
policy = NULL;
alternatives = neethi_policy_get_alternatives(normalized_policy, env);
component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *)neethi_operator_get_value(component, env);
if(AXIS2_FAILURE == rp_issued_token_builder_process_alternatives(env, all, issued_token))
return NULL;
assertion = neethi_assertion_create_with_args(env,
(AXIS2_FREE_VOID_ARG)rp_issued_token_free, issued_token, ASSERTION_TYPE_ISSUED_TOKEN);
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return assertion;
}
assertion = neethi_assertion_create(env);
neethi_assertion_set_value(assertion, env, issued_token, ASSERTION_TYPE_ISSUED_TOKEN);
return assertion;
}
axis2_status_t AXIS2_CALL
secpolicy_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_secpolicy_t *secpolicy)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for (i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator =(neethi_operator_t *) axutil_array_list_get(arraylist, env,
i);
assertion =
(neethi_assertion_t *) neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
if (value)
{
if (type == ASSERTION_TYPE_TRANSPORT_BINDING)
{
rp_property_t *binding = NULL;
rp_transport_binding_t *transport_binding = NULL;
transport_binding =
(rp_transport_binding_t *)
neethi_assertion_get_value(assertion, env);
if (!transport_binding)
{
return AXIS2_FAILURE;
}
binding = rp_property_create(env);
rp_property_set_value(binding, env, transport_binding,
RP_PROPERTY_TRANSPORT_BINDING);
rp_secpolicy_set_binding(secpolicy, env, binding);
}
else if (type == ASSERTION_TYPE_ASSYMMETRIC_BINDING)
{
rp_property_t *binding = NULL;
rp_asymmetric_binding_t *asymmetric_binding = NULL;
asymmetric_binding =
(rp_asymmetric_binding_t *)
neethi_assertion_get_value(assertion, env);
if (!asymmetric_binding)
{
return AXIS2_FAILURE;
}
binding = rp_property_create(env);
rp_property_set_value(binding, env, asymmetric_binding,
RP_PROPERTY_ASYMMETRIC_BINDING);
rp_secpolicy_set_binding(secpolicy, env, binding);
}
else if (type == ASSERTION_TYPE_SYMMETRIC_BINDING)
{
rp_property_t *binding = NULL;
rp_symmetric_binding_t *symmetric_binding = NULL;
symmetric_binding =
(rp_symmetric_binding_t *)
neethi_assertion_get_value(assertion, env);
if (!symmetric_binding)
{
return AXIS2_FAILURE;
}
binding = rp_property_create(env);
rp_property_set_value(binding, env, symmetric_binding,
RP_PROPERTY_SYMMETRIC_BINDING);
rp_secpolicy_set_binding(secpolicy, env, binding);
}
else if (type == ASSERTION_TYPE_SUPPORTING_TOKENS)
{
rp_supporting_tokens_t *supporting_tokens = NULL;
supporting_tokens =
(rp_supporting_tokens_t *)
neethi_assertion_get_value(assertion, env);
if (supporting_tokens)
{
rp_property_type_t type;
type =
rp_supporting_tokens_get_type(supporting_tokens, env);
if (type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
{
rp_secpolicy_set_signed_supporting_tokens(secpolicy,
env,
supporting_tokens);
}
else if (type ==
RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
{
rp_secpolicy_set_signed_endorsing_supporting_tokens(secpolicy,
env,
supporting_tokens);
}
else if (type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
{
rp_secpolicy_set_supporting_tokens(secpolicy,
env,
supporting_tokens);
}
else if (type ==
RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
{
rp_secpolicy_set_endorsing_supporting_tokens(secpolicy,
env,
supporting_tokens);
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
else if (type == ASSERTION_TYPE_WSS10)
{
rp_wss10_t *wss10 = NULL;
rp_property_t *wss = NULL;
wss10 =
(rp_wss10_t *) neethi_assertion_get_value(assertion, env);
if (!wss10)
{
return AXIS2_FAILURE;
}
wss = rp_property_create(env);
rp_property_set_value(wss, env, wss10, RP_PROPERTY_WSS10);
rp_secpolicy_set_wss(secpolicy, env, wss);
}
else if (type == ASSERTION_TYPE_WSS11)
{
rp_wss11_t *wss11 = NULL;
rp_property_t *wss = NULL;
wss11 =
(rp_wss11_t *) neethi_assertion_get_value(assertion, env);
if (!wss11)
{
return AXIS2_FAILURE;
}
wss = rp_property_create(env);
rp_property_set_value(wss, env, wss11, RP_PROPERTY_WSS11);
rp_secpolicy_set_wss(secpolicy, env, wss);
}
else if (type == ASSERTION_TYPE_TRUST10)
{
rp_trust10_t *trust10 = NULL;
trust10 =
(rp_trust10_t *) neethi_assertion_get_value(assertion, env);
if (!trust10)
{
return AXIS2_FAILURE;
}
rp_secpolicy_set_trust10(secpolicy, env, trust10);
}
else if (type == ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS)
{
rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
signed_encrypted_parts =
(rp_signed_encrypted_parts_t *)
neethi_assertion_get_value(assertion, env);
if (signed_encrypted_parts)
{
if (rp_signed_encrypted_parts_get_signedparts
(signed_encrypted_parts, env))
{
rp_secpolicy_set_signed_parts(secpolicy, env,
signed_encrypted_parts);
}
else
{
rp_secpolicy_set_encrypted_parts(secpolicy, env,
signed_encrypted_parts);
}
}
else
return AXIS2_FAILURE;
}
else if (type == ASSERTION_TYPE_RAMPART_CONFIG)
{
rp_rampart_config_t *rampart_config = NULL;
rampart_config =
(rp_rampart_config_t *)
neethi_assertion_get_value(assertion, env);
if (!rampart_config)
{
return AXIS2_FAILURE;
}
rp_secpolicy_set_rampart_config(secpolicy, env, rampart_config);
}
else
{
continue;
}
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
rp_username_token_builder_build(
const axutil_env_t *env,
axiom_node_t *node,
axiom_element_t *element)
{
rp_username_token_t *username_token = NULL;
neethi_policy_t *policy = NULL;
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
axutil_array_list_t *alternatives = NULL;
neethi_operator_t *component = NULL;
neethi_all_t *all = NULL;
axis2_char_t *inclusion_value = NULL;
axutil_qname_t *qname = NULL;
neethi_assertion_t *assertion = NULL;
neethi_policy_t *normalized_policy = NULL;
username_token = rp_username_token_create(env);
qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
inclusion_value = axiom_element_get_attribute_value(element, env, qname);
axutil_qname_free(qname, env);
qname = NULL;
if(!inclusion_value)
{
/* we can try whether WS-SP1.2 specific inclusion value */
qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
inclusion_value = axiom_element_get_attribute_value(element, env, qname);
axutil_qname_free(qname, env);
qname = NULL;
}
rp_username_token_set_inclusion(username_token, env, inclusion_value);
child_node = axiom_node_get_first_element(node, env);
if (!child_node)
{
assertion = neethi_assertion_create(env);
neethi_assertion_set_value(assertion, env, username_token, ASSERTION_TYPE_USERNAME_TOKEN);
return assertion;
}
if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
child_element =
(axiom_element_t *) axiom_node_get_data_element(child_node, env);
if (child_element)
{
policy = neethi_engine_get_policy(env, child_node, child_element);
if (!policy)
{
return NULL;
}
normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
neethi_policy_free(policy, env);
policy = NULL;
alternatives = neethi_policy_get_alternatives(normalized_policy, env);
component = (neethi_operator_t *) axutil_array_list_get(alternatives, env, 0);
all = (neethi_all_t *) neethi_operator_get_value(component, env);
username_token_process_alternatives(env, all, username_token);
assertion = neethi_assertion_create_with_args(
env,(AXIS2_FREE_VOID_ARG)rp_username_token_free,
username_token, ASSERTION_TYPE_USERNAME_TOKEN);
neethi_policy_free(normalized_policy, env);
normalized_policy = NULL;
return assertion;
}
else
return NULL;
}
else
return NULL;
}
axis2_status_t AXIS2_CALL
symmetric_binding_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_symmetric_binding_t * symmetric_binding)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
void *value = NULL;
rp_binding_commons_t *commons = NULL;
rp_symmetric_asymmetric_binding_commons_t *as_commons = NULL;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
commons = rp_binding_commons_create(env);
as_commons = rp_symmetric_asymmetric_binding_commons_create(env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
value = neethi_assertion_get_value(assertion, env);
type = neethi_assertion_get_type(assertion, env);
if(type == ASSERTION_TYPE_PROTECTION_TOKEN)
{
rp_property_t *protection_token = NULL;
protection_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
if(protection_token)
{
rp_symmetric_binding_set_protection_token(symmetric_binding, env, protection_token);
}
else
return AXIS2_FAILURE;
}
else if(type == ASSERTION_TYPE_ENCRYPTION_TOKEN)
{
rp_property_t *encryption_token = NULL;
encryption_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
if(encryption_token)
{
rp_symmetric_binding_set_encryption_token(symmetric_binding, env, encryption_token);
}
else
return AXIS2_FAILURE;
}
else if(type == ASSERTION_TYPE_SIGNATURE_TOKEN)
{
rp_property_t *signature_token = NULL;
signature_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
if(signature_token)
{
rp_symmetric_binding_set_signature_token(symmetric_binding, env, signature_token);
}
else
return AXIS2_FAILURE;
}
else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
{
rp_algorithmsuite_t *algorithmsuite = NULL;
algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion, env);
if(algorithmsuite)
{
rp_binding_commons_set_algorithmsuite(commons, env, algorithmsuite);
}
else
return AXIS2_FAILURE;
}
else if(type == ASSERTION_TYPE_INCLUDE_TIMESTAMP)
{
rp_binding_commons_set_include_timestamp(commons, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_LAYOUT)
{
rp_layout_t *layout = NULL;
layout = (rp_layout_t *)neethi_assertion_get_value(assertion, env);
if(layout)
{
rp_binding_commons_set_layout(commons, env, layout);
}
else
return AXIS2_FAILURE;
}
else if(type == ASSERTION_TYPE_ENCRYPT_BEFORE_SIGNING)
{
rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
RP_ENCRYPT_BEFORE_SIGNING);
}
else if(type == ASSERTION_TYPE_SIGN_BEFORE_ENCRYPTING)
{
rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
RP_SIGN_BEFORE_ENCRYPTING);
}
else if(type == ASSERTION_TYPE_ENCRYPT_SIGNATURE)
{
rp_symmetric_asymmetric_binding_commons_set_signature_protection(as_commons, env,
AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_PROTECT_TOKENS)
{
rp_symmetric_asymmetric_binding_commons_set_token_protection(as_commons, env,
AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY)
{
rp_symmetric_asymmetric_binding_commons_set_entire_headers_and_body_signatures(
as_commons, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
{
rp_supporting_tokens_t *supporting_tokens = NULL;
supporting_tokens
= (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion, env);
if(supporting_tokens)
{
rp_property_type_t type;
type = rp_supporting_tokens_get_type(supporting_tokens, env);
if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
{
rp_binding_commons_set_signed_supporting_tokens(commons, env, supporting_tokens);
}
else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
{
rp_binding_commons_set_signed_endorsing_supporting_tokens(commons, env,
supporting_tokens);
}
else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
{
rp_binding_commons_set_supporting_tokens(commons, env, supporting_tokens);
}
else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
{
rp_binding_commons_set_endorsing_supporting_tokens(commons, env,
supporting_tokens);
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
else
return AXIS2_FAILURE;
}
rp_symmetric_asymmetric_binding_commons_set_binding_commons(as_commons, env, commons);
rp_symmetric_binding_set_symmetric_asymmetric_binding_commons(symmetric_binding, env,
as_commons);
return AXIS2_SUCCESS;
}