axis2_char_t * AXIS2_CALL
savan_client_get_sub_url_from_response(
axiom_element_t *response_elem,
axiom_node_t *response_node,
const axutil_env_t *env)
{
axutil_qname_t *qname = NULL;
axiom_element_t *submgr_elem = NULL;
axiom_element_t *address_elem = NULL;
axiom_node_t *submgr_node = NULL;
axiom_node_t *address_node = NULL;
axis2_char_t *address = NULL;
/* Format:
* <SubscribeResponse>
* <SubscriptionManager>
* <Address>
*/
/* Get Sub Mgr sub element */
qname = axutil_qname_create(env, ELEM_NAME_SUB_MGR, EVENTING_NAMESPACE, NULL);
submgr_elem = axiom_element_get_first_child_with_qname(response_elem, env, qname,
response_node, &submgr_node);
axutil_qname_free(qname, env);
/* Get Address sub element */
qname = axutil_qname_create(env, ELEM_NAME_ADDR,
AXIS2_WSA_NAMESPACE_SUBMISSION, NULL);
address_elem = axiom_element_get_first_child_with_qname(submgr_elem, env, qname,
submgr_node, &address_node);
axutil_qname_free(qname, env);
address = axiom_element_get_text(address_elem, env, address_node);
return address;
}
AjBool ajSoapAxis2Error(axiom_node_t *fault, const axutil_env_t *env)
{
axis2_char_t* faultcode = NULL;
axis2_char_t* faultmsg = NULL;
axis2_char_t* exception = NULL;
axiom_element_t* parent = NULL;
axiom_element_t* child = NULL;
axiom_node_t* node = NULL;
axutil_qname_t* qname = NULL;
parent = axiom_node_get_data_element(fault, env);
if (!parent)
return ajFalse;
/* fault->faultcode */
qname = axutil_qname_create(env, "faultcode", NULL, "");
child = axiom_element_get_first_child_with_qname(parent, env, qname,
fault, &node);
if (child)
faultcode = axiom_element_get_text(child, env, node);
axutil_qname_free(qname, env);
/* fault->faultstring */
qname = axutil_qname_create(env, "faultstring", NULL, "");
child = axiom_element_get_first_child_with_qname(parent, env, qname,
fault, &node);
if (child)
faultmsg = axiom_element_get_text(child, env, node);
axutil_qname_free(qname, env);
/* fault->detail */
qname = axutil_qname_create(env, "detail", NULL, "");
parent = axiom_element_get_first_child_with_qname(parent, env, qname,
fault, &node);
axutil_qname_free(qname, env);
if(!parent)
return ajFalse;
/* fault->detail->exceptionName */
qname = axutil_qname_create(env, "exceptionName", AXIS_NS , "");
child = axiom_element_get_first_child_with_qname(parent, env, qname,
node, &node);
if(child)
exception = axiom_element_get_text(child, env, node);
if(!strstr(exception, "DbfNoEntryFoundException"))
ajErr("webservices error: %s, %s %s", faultcode, faultmsg, exception);
axutil_qname_free(qname, env);
return ajTrue;
}
WSF_WSDL_EXTERN axis2_bool_t WSF_WSDL_CALL
wsdl_util_reverse_type_from_type_map(
const axutil_env_t* env,
axiom_node_t* type_map,
axis2_char_t* type1,
axis2_char_t** type2)
{
axiom_element_t* type_map_element = NULL, *reverse_element = NULL;
axiom_node_t* reverse_node = NULL;
axutil_qname_t *qname = NULL;
type_map_element = (axiom_element_t*)axiom_node_get_data_element(type_map, env);
if (type_map_element)
{
qname = axutil_qname_create(env, WSDL_TYPEMAP_REVERSE, NULL, NULL);
reverse_element = axiom_element_get_first_child_with_qname(type_map_element, env, qname,
type_map, &reverse_node);
axutil_qname_free(qname, env);
if (reverse_element)
{
axiom_node_t* type_node = NULL;
axiom_element_t* type_element = NULL;
qname = axutil_qname_create(env, type1, NULL, NULL);
type_element = axiom_element_get_first_child_with_qname(reverse_element, env, qname,
reverse_node, &type_node);
axutil_qname_free(qname, env);
if (type_element)
{
axis2_char_t* text = NULL;
text = axiom_element_get_text(type_element, env, type_node);
if (text)
{
*type2 = (axis2_char_t*)axutil_strdup(env, text);
return AXIS2_SUCCESS;
}
else
{
AXIS2_LOG_ERROR_MSG(env->log, "Badly formatted type map");
return AXIS2_FAILURE;
}
}
else
{
AXIS2_LOG_DEBUG_MSG(env->log, "Requested type is not found in the type map");
return AXIS2_FAILURE;
}
}
}
return AXIS2_FAILURE;
}
axiom_node_t *
axis2_listener_notify(const axutil_env_t *env, axiom_node_t *node)
{
axiom_node_t *pres_node = NULL;
axiom_node_t *status_node = NULL;
axiom_element_t *body_elem = NULL;
axiom_element_t *pres_elem = NULL;
axiom_element_t *status_elem = NULL;
axiom_attribute_t *attr_from = NULL;
axutil_qname_t *qname= NULL;
axis2_char_t *str = NULL;
axis2_char_t *from = NULL;
axis2_char_t *status = NULL;
AXIS2_ENV_CHECK(env, NULL);
str = axiom_node_to_string(node, env);
body_elem = axiom_node_get_data_element(node, env);
qname = axutil_qname_create(env, "presence", NULL, NULL);
pres_elem = axiom_element_get_first_child_with_qname(body_elem, env, qname,
node, &pres_node);
axutil_qname_free(qname, env);
if (pres_elem)
{
qname = axutil_qname_create(env, "from", NULL, NULL);
attr_from = axiom_element_get_attribute(pres_elem, env, qname);
axutil_qname_free(qname, env);
if (attr_from)
{
from = axiom_attribute_get_value(attr_from, env);
}
qname = axutil_qname_create(env, "status", NULL, NULL);
status_elem = axiom_element_get_first_child_with_qname(pres_elem, env, qname,
pres_node, &status_node);
axutil_qname_free(qname, env);
if (status_elem)
{
status = axiom_element_get_text(status_elem, env, status_node);
}
}
printf("\n************************************************************\n");
printf("Received presence notification:\n\n");
printf("From: %s\n", from);
printf("Status: %s\n", status);
printf("\nFull notification:\n%s\n\n", str);
return NULL;
}
/**
* Check the node and its children. Check if the localname is equal to the given name
* Note: You may pass the prefix=NULL as the prefix may be different depending on the impl
* @param env Environment. MUST NOT be NULL,
* @param parent the node to be searched
* @param local_name the local name of the node to be searched
* @ns_uri namespace uri of the node to be searched
* @prefix prefix of the node to be searched. If NULL, node with any prefix will be considered
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_axiom_get_first_child_node_by_name(
const axutil_env_t *env,
axiom_node_t* parent,
axis2_char_t* local_name,
axis2_char_t* ns_uri,
axis2_char_t* prefix)
{
axutil_qname_t *qname = NULL;
axiom_node_t *node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_element_t *ele = NULL;
qname = axutil_qname_create(env, local_name, ns_uri, prefix);
parent_ele = axiom_node_get_data_element(parent, env);
if (!parent_ele)
{
return NULL;
}
/*Get the child*/
ele = axiom_element_get_first_child_with_qname(parent_ele, env, qname, parent, &node);
axutil_qname_free(qname, env);
qname = NULL;
return node;
}
axis2_char_t * AXIS2_CALL
savan_client_get_sub_id_from_response(
axiom_element_t *response_elem,
axiom_node_t *response_node,
const axutil_env_t *env)
{
axutil_qname_t *qname = NULL;
axiom_element_t *submgr_elem = NULL;
axiom_element_t *refparam_elem = NULL;
axiom_element_t *id_elem = NULL;
axiom_node_t *submgr_node = NULL;
axiom_node_t *refparam_node = NULL;
axiom_node_t *id_node = NULL;
axis2_char_t *sub_id = NULL;
/* Format:
* <SubscribeResponse>
* <SubscriptionManager>
* <ReferenceParameters>
* <Identifier>
*/
/* Get Sub Mgr sub element */
qname = axutil_qname_create(env, ELEM_NAME_SUB_MGR, EVENTING_NAMESPACE, NULL);
submgr_elem = axiom_element_get_first_child_with_qname(response_elem, env, qname,
response_node, &submgr_node);
axutil_qname_free(qname, env);
/* Get Ref Param sub element */
qname = axutil_qname_create(env, ELEM_NAME_REF_PARAM,
AXIS2_WSA_NAMESPACE_SUBMISSION, NULL);
refparam_elem = axiom_element_get_first_child_with_qname(submgr_elem, env, qname,
submgr_node, &refparam_node);
axutil_qname_free(qname, env);
/* Get Identifier sub element */
qname = axutil_qname_create(env, ELEM_NAME_ID, EVENTING_NAMESPACE, NULL);
id_elem = axiom_element_get_first_child_with_qname(refparam_elem, env, qname,
refparam_node, &id_node);
axutil_qname_free(qname, env);
sub_id = axiom_element_get_text(id_elem, env, id_node);
return sub_id;
}
void* AXIS2_CALL
sandesha2_address_from_om_node(
sandesha2_address_t *address,
const axutil_env_t *env, axiom_node_t *om_node)
{
axiom_element_t *om_element = NULL;
axiom_element_t *addr_part = NULL;
axiom_node_t *addr_node = NULL;
axutil_qname_t *addr_qname = NULL;
axis2_char_t *str_address = NULL;
AXIS2_PARAM_CHECK(env->error, om_node, NULL);
om_element = axiom_node_get_data_element(om_node, env);
if(!om_element)
{
AXIS2_ERROR_SET(env->error, (axutil_error_codes_t)SANDESHA2_ERROR_NULL_OM_ELEMENT,
AXIS2_FAILURE);
return NULL;
}
addr_qname = axutil_qname_create(env, SANDESHA2_WSA_ADDRESS,
address->ns_val, NULL);
if(!addr_qname)
{
return NULL;
}
addr_part = axiom_element_get_first_child_with_qname(om_element, env,
addr_qname, om_node, &addr_node);
if(addr_qname)
axutil_qname_free(addr_qname, env);
if(!addr_part)
{
AXIS2_ERROR_SET(env->error, (axutil_error_codes_t)SANDESHA2_ERROR_NULL_OM_ELEMENT,
AXIS2_FAILURE);
return NULL;
}
str_address = axiom_element_get_text(addr_part, env, addr_node);
if(!str_address || 0 == axutil_strlen(str_address))
{
AXIS2_ERROR_SET(env->error, (axutil_error_codes_t)SANDESHA2_ERROR_EMPTY_OM_ELEMENT,
AXIS2_FAILURE);
return NULL;
}
if(address->epr)
{
axis2_endpoint_ref_free(address->epr, env);
address->epr = NULL;
}
address->epr = axis2_endpoint_ref_create(env, str_address);
if(!address->epr)
{
return NULL;
}
return address;
}
axis2_status_t
axis2_addr_in_extract_svc_grp_ctx_id(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_ctx_t * msg_ctx)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
node = axiom_soap_header_get_base_node(soap_header, env);
if (node && axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
axutil_qname_t *qname = NULL;
element = (axiom_element_t *) axiom_node_get_data_element(node, env);
qname = axutil_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI,
AXIS2_NAMESPACE_PREFIX);
if (qname)
{
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
child_element =
axiom_element_get_first_child_with_qname(element, env, qname,
node, &child_node);
if (child_element)
{
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_char_t *grp_id =
axiom_element_get_text(child_element, env,
child_node);
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if (conf_ctx && grp_id)
{
axutil_string_t *svc_grp_ctx_id_str =
axutil_string_create(env, grp_id);
axis2_svc_grp_ctx_t *svc_ctx_grp_ctx =
axis2_conf_ctx_get_svc_grp_ctx(conf_ctx, env, grp_id);
if (!svc_ctx_grp_ctx)
{
return AXIS2_FAILURE;
}
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);
return AXIS2_SUCCESS;
}
}
}
axutil_qname_free(qname, env);
}
return AXIS2_FAILURE;
}
axis2_status_t AXIS2_CALL
sandesha2_rm_elements_from_soap_envelope(
sandesha2_rm_elements_t *rm_elements,
const axutil_env_t *env,
axiom_soap_envelope_t *soap_envelope,
axis2_char_t *action)
{
axiom_soap_header_t *soap_header = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *header_node = NULL;
axiom_element_t *body_element = NULL;
axiom_node_t *body_node = NULL;
axiom_element_t *header_element = NULL;
axiom_node_t *seq_node = NULL;
axiom_element_t *seq_ack_element = NULL;
axiom_node_t *seq_ack_node = NULL;
axiom_node_t *create_seq_node = NULL;
axiom_node_t *create_seq_res_node = NULL;
axiom_node_t *terminate_seq_node = NULL;
axiom_node_t *terminate_seq_res_node = NULL;
axiom_node_t *close_seq_node = NULL;
axiom_node_t *close_seq_res_node = NULL;
axiom_node_t *ack_requested_node = NULL;
axiom_node_t *make_conn_node = NULL;
axiom_node_t *msg_pending_node = NULL;
axutil_qname_t *qname = NULL;
axis2_char_t *rm_ns_val = NULL;
axis2_char_t *addr_ns_val = NULL;
AXIS2_PARAM_CHECK(env->error, soap_envelope, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, action, AXIS2_FAILURE);
rm_ns_val = sandesha2_rm_elements_get_rm_ns_val(env, soap_envelope, action);
if(!rm_ns_val)
return AXIS2_SUCCESS;
addr_ns_val = sandesha2_rm_elements_get_addr_ns_val_from_env(env,
soap_envelope, action);
if(!addr_ns_val)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]Cannot find the addressing version");
return AXIS2_FAILURE;
}
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
header_node = axiom_soap_header_get_base_node(soap_header, env);
header_element = axiom_node_get_data_element(header_node, env);
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
body_node = axiom_soap_body_get_base_node(soap_body, env);
body_element = axiom_node_get_data_element(body_node, env);
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env,
qname, header_node, &seq_node);
if(qname)
axutil_qname_free(qname, env);
if(seq_node)
{
rm_elements->seq = sandesha2_seq_create(env, rm_ns_val);
sandesha2_seq_from_om_node(
rm_elements->seq, env, seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ_ACK, rm_ns_val,
NULL);
seq_ack_element = axiom_element_get_first_child_with_qname(header_element,
env, qname, header_node, &seq_ack_node);
if(qname)
axutil_qname_free(qname, env);
if(seq_ack_element)
{
rm_elements->seq_ack = sandesha2_seq_ack_create(env, rm_ns_val);
sandesha2_seq_ack_from_om_node(
rm_elements->seq_ack, env, seq_ack_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CREATE_SEQ, rm_ns_val,
NULL);
axiom_element_get_first_child_with_qname(body_element,
env, qname, body_node, &create_seq_node);
if(qname)
axutil_qname_free(qname, env);
if(create_seq_node)
{
rm_elements->create_seq = sandesha2_create_seq_create(env,
addr_ns_val, rm_ns_val);
sandesha2_create_seq_from_om_node(
rm_elements->create_seq, env, create_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CREATE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &create_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(create_seq_res_node)
{
rm_elements->create_seq_res = sandesha2_create_seq_res_create(env, rm_ns_val, addr_ns_val);
sandesha2_create_seq_res_from_om_node(rm_elements->create_seq_res, env, create_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_TERMINATE_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &terminate_seq_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(terminate_seq_node)
{
rm_elements->terminate_seq = sandesha2_terminate_seq_create(env, rm_ns_val);
sandesha2_terminate_seq_from_om_node(rm_elements->terminate_seq, env, terminate_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_TERMINATE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &terminate_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(terminate_seq_res_node)
{
rm_elements->terminate_seq_res = sandesha2_terminate_seq_res_create(env, rm_ns_val);
sandesha2_terminate_seq_res_from_om_node(rm_elements->terminate_seq_res, env,
terminate_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CLOSE_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &close_seq_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(close_seq_node)
{
rm_elements->close_seq = sandesha2_close_seq_create(env, rm_ns_val);
sandesha2_close_seq_from_om_node(rm_elements->close_seq, env, close_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CLOSE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &close_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(close_seq_res_node)
{
rm_elements->close_seq_res = sandesha2_close_seq_res_create(env, rm_ns_val);
sandesha2_close_seq_res_from_om_node(rm_elements->close_seq_res, env, close_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_MAKE_CONNECTION, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &make_conn_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(make_conn_node)
{
rm_elements->make_connection = sandesha2_make_connection_create(env, rm_ns_val);
sandesha2_make_connection_from_om_node(rm_elements->make_connection, env, make_conn_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_ACK_REQUESTED, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env, qname, header_node, &ack_requested_node);
if(qname)
axutil_qname_free(qname, env);
if(ack_requested_node)
{
rm_elements->ack_requested = sandesha2_ack_requested_create(env,
rm_ns_val);
sandesha2_ack_requested_from_om_node(
rm_elements->ack_requested, env, ack_requested_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_MESSAGE_PENDING,
rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env, qname, header_node, &msg_pending_node);
if(qname)
axutil_qname_free(qname, env);
if(msg_pending_node)
{
rm_elements->msg_pending = sandesha2_msg_pending_create(env,
rm_ns_val);
sandesha2_msg_pending_from_om_node(
rm_elements->msg_pending, env, msg_pending_node);
}
return AXIS2_SUCCESS;
}
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_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_populate_rstr(
trust_rstr_t *rstr,
const axutil_env_t *env,
axiom_node_t *rstr_node)
{
axiom_element_t *rstr_ele = NULL;
axutil_qname_t *attr_ctx_qname = NULL;
axis2_char_t *attr_ctx = NULL;
axiom_node_t *requested_security_token_node = NULL;
axiom_element_t *requested_security_token_ele = NULL;
axutil_qname_t *requested_security_token_qname = NULL;
axiom_node_t *proof_token_node = NULL;
axiom_element_t *proof_token_ele = NULL;
axutil_qname_t *proof_token_qname = NULL;
axiom_node_t *attached_reference_node = NULL;
axiom_element_t *attached_reference_ele = NULL;
axutil_qname_t *attached_reference_qname = NULL;
axiom_node_t *unattached_reference_node = NULL;
axiom_element_t *unattached_reference_ele = NULL;
axutil_qname_t *unattached_reference_qname = NULL;
axiom_node_t *token_type_node = NULL;
axiom_element_t *token_type_ele = NULL;
axutil_qname_t *token_type_qname = NULL;
axis2_char_t *token_type = NULL;
axutil_qname_t *applies_to_qname = NULL;
axiom_node_t *appliesto_node = NULL;
axiom_element_t *appliesto_ele = NULL;
axiom_node_t *first_node = NULL;
axiom_element_t *first_ele = NULL;
trust_entropy_t *entropy = NULL;
axiom_node_t *entropy_node = NULL;
axiom_element_t *entropy_ele = NULL;
axutil_qname_t *entropy_qname = NULL;
axiom_node_t *lifetime_node = NULL;
axiom_element_t *lifetime_ele = NULL;
axutil_qname_t *lifetime_qname = NULL;
axiom_node_t *key_size_node = NULL;
axiom_element_t *key_size_ele = NULL;
axutil_qname_t *key_size_qname = NULL;
axis2_char_t *key_size = NULL;
rstr_ele = (axiom_element_t*)axiom_node_get_data_element(rstr_node, env);
/*@Context RSTR*/
attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rstr->wst_ns_uri, TRUST_WST);
if (!attr_ctx_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Context Attribute Qname creation failed.");
return AXIS2_FAILURE;
}
attr_ctx = axiom_element_get_attribute_value(rstr_ele, env, attr_ctx_qname);
if (attr_ctx)
{
rstr->attr_context = attr_ctx;
}
axutil_qname_free(attr_ctx_qname, env);
/*TokenType*/
token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rstr->wst_ns_uri, TRUST_WST);
if (!token_type_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Qname creation failed.");
return AXIS2_FAILURE;
}
token_type_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, token_type_qname, rstr_node, &token_type_node);
if (token_type_ele)
{
token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
if(token_type)
{
rstr->token_type = token_type;
}
}
axutil_qname_free(token_type_qname, env);
/*RequestedSecurityToken*/
requested_security_token_qname = axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN, rstr->wst_ns_uri, TRUST_WST);
if(!requested_security_token_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedSecurityToken Qname creation failed.");
return AXIS2_FAILURE;
}
requested_security_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, requested_security_token_qname,
rstr_node, &requested_security_token_node);
if(requested_security_token_ele)
{
axiom_element_get_first_element(requested_security_token_ele, env, requested_security_token_node, &rstr->requested_sec_token);
}
axutil_qname_free(requested_security_token_qname, env);
/*RequestedProofToken*/
proof_token_qname = axutil_qname_create(env, TRUST_REQUESTED_PROOF_TOKEN, rstr->wst_ns_uri, TRUST_WST);
if(!proof_token_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken Qname creation failed.");
return AXIS2_FAILURE;
}
proof_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, proof_token_qname, rstr_node, &proof_token_node);
if(proof_token_ele)
{
axiom_element_get_first_element(proof_token_ele, env, proof_token_node, &rstr->requested_proof_token);
}
axutil_qname_free(proof_token_qname, env);
/*AppliesTo*/
applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
if (!applies_to_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed.");
return AXIS2_FAILURE;
}
appliesto_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, applies_to_qname, rstr_node, &appliesto_node);
if(appliesto_ele)
{
first_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &first_node);
if(first_ele)
{
rstr->applies_to = axiom_element_get_text(first_ele, env, first_node);
}
}
axutil_qname_free(applies_to_qname, env);
/*Entropy*/
entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rstr->wst_ns_uri, TRUST_WST);
if (!entropy_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Qname creation failed.");
return AXIS2_FAILURE;
}
entropy_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, entropy_qname, rstr_node, &entropy_node);
if(entropy_ele)
{
entropy = trust_entropy_create(env);
trust_entropy_set_ns_uri(entropy, env, rstr->wst_ns_uri);
if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node))
{
rstr->entropy = entropy;
}
}
axutil_qname_free(entropy_qname, env);
/*LifeTime*/
lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rstr->wst_ns_uri, TRUST_WST);
if(!lifetime_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime Qname creation failed.");
return AXIS2_FAILURE;
}
lifetime_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, lifetime_qname, rstr_node, &lifetime_node);
if(lifetime_ele)
{
rstr->life_time = trust_life_time_create(env);
if(AXIS2_SUCCESS == trust_life_time_deserialize(rstr->life_time, env, lifetime_node))
{
}
}
axutil_qname_free(lifetime_qname, env);
/* KeySize */
key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rstr->wst_ns_uri, TRUST_WST);
key_size_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, key_size_qname, rstr_node, &key_size_node);
if(key_size_ele)
{
key_size = axiom_element_get_text(key_size_ele, env, key_size_node);
if(key_size)
{
rstr->key_size = atoi(key_size);
}
}
axutil_qname_free(key_size_qname, env);
/*Attached reference*/
attached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_ATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
if(!attached_reference_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedAttachedReference Qname creation failed.");
return AXIS2_FAILURE;
}
attached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, attached_reference_qname, rstr_node, &attached_reference_node);
if(attached_reference_ele)
{
axiom_element_get_first_element(attached_reference_ele, env, attached_reference_node, &rstr->requested_attached_ref);
}
axutil_qname_free(attached_reference_qname, env);
/*Unattached reference*/
unattached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_UNATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
if(!unattached_reference_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedUnattachedReference Qname creation failed.");
return AXIS2_FAILURE;
}
unattached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, unattached_reference_qname, rstr_node, &unattached_reference_node);
if(unattached_reference_ele)
{
axiom_element_get_first_element(unattached_reference_ele, env, unattached_reference_node, &rstr->requested_unattached_ref);
}
axutil_qname_free(unattached_reference_qname, env);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_char_t * AXIS2_CALL
savan_client_get_status(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axutil_qname_t *qname = NULL;
axiom_namespace_t *ns = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *status_node = NULL;
axiom_node_t *expires_node = NULL;
axiom_element_t *status_elem = NULL;
axiom_element_t *expires_elem = NULL;
axis2_char_t *expires = NULL;
axis2_char_t *status_elem_localname = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_get_status");
/* Set wsa action as GetStatus. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_GET_STATUS);
/* Create the body of the GetStatus request */
ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
status_elem = axiom_element_create(env, NULL, ELEM_NAME_GETSTATUS, ns, &status_node);
savan_client_add_sub_id_to_soap_header(client, env, svc_client);
/* Send the GetStatus request and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, status_node);
/* Reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send get status "
"request. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
status_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env);
/* Check whether we have received a GetStatusResponse */
status_elem_localname = axiom_element_get_localname(status_elem, env);
if (axutil_strcmp(ELEM_NAME_GETSTATUS_RESPONSE, status_elem_localname))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve GetStatusResponse"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
/* Now read Expires sub element */
qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL);
expires_elem = axiom_element_get_first_child_with_qname(status_elem, env, qname, reply,
&expires_node);
axutil_qname_free(qname, env);
if(!expires_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
expires_elem = (axiom_element_t *) axiom_node_get_data_element(expires_node, env);
expires = axiom_element_get_text(expires_elem, env, expires_node);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_get_status");
return expires;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
savan_client_renew(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client,
axutil_hash_t *options)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axiom_namespace_t *ns = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *renew_node = NULL;
axiom_node_t *expires_node = NULL;
axiom_element_t *renew_elem = NULL;
axiom_element_t *expires_elem = NULL;
axis2_char_t *expires = NULL;
axis2_char_t *renew_elem_localname = NULL;
axutil_qname_t *qname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_renew");
/* Set wsa action as Renew. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_RENEW);
/* Create the body of the Renew request */
ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
renew_elem = axiom_element_create(env, NULL, ELEM_NAME_RENEW, ns, &renew_node);
/* Extract the values from the options map */
expires = axutil_hash_get(options, SAVAN_OP_KEY_EXPIRES, AXIS2_HASH_KEY_STRING);
if(expires)
{
/* Expires element */
expires_elem = axiom_element_create(env, renew_node, ELEM_NAME_EXPIRES, ns,
&expires_node);
axiom_element_set_text(expires_elem, env, expires, expires_node);
}
savan_client_add_sub_id_to_soap_header(client, env, svc_client);
/* send the Renew request and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, renew_node);
/* reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[savan] Failed to send renew request. Error: %d Reason: %s",
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
renew_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env);
/* Check whether we have received a RenewResponse */
renew_elem_localname = axiom_element_get_localname(renew_elem, env);
if (axutil_strcmp(ELEM_NAME_RENEW_RESPONSE, renew_elem_localname))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve RenewResponse"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
/* Get Expires element from RenewResponse element */
qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL);
expires_elem = axiom_element_get_first_child_with_qname(renew_elem, env, qname, reply,
&expires_node);
axutil_qname_free(qname, env);
if(!expires_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
expires = axiom_element_get_text(expires_elem, env, expires_node);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_renew");
return expires;
}
void test_endpoint_deserialize(char *content)
{
axutil_qname_t *qname = NULL;
axiom_node_t *subs_node = NULL;
axiom_element_t *subs_element = NULL;
axiom_node_t *endpoint_node = NULL;
axiom_element_t *endpoint_element = NULL;
axiom_node_t *address_node = NULL;
axiom_element_t *address_element = NULL;
axis2_char_t *address = NULL;
const axutil_env_t *env = NULL;
axis2_char_t *nsurl = "http://ws.apache.org/ns/synapse";
env = axutil_env_create_all("test.log", AXIS2_LOG_LEVEL_TRACE);
subs_node = axiom_node_create_from_buffer(env, content);
subs_element = axiom_node_get_data_element(subs_node, env);
if(!subs_element)
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OM_ELEMENT_EXPECTED, AXIS2_FAILURE);
return;
}
qname = axutil_qname_create(env, "endpoint", nsurl, NULL);
if(!qname)
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return;
}
endpoint_element = axiom_element_get_first_child_with_qname(subs_element, env, qname,
subs_node, &endpoint_node);
if(qname)
{
axutil_qname_free(qname, env);
}
qname = axutil_qname_create(env, "address", nsurl, NULL);
if(!qname)
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return;
}
address_element = axiom_element_get_first_child_with_qname(endpoint_element, env, qname,
endpoint_node, &address_node);
if(qname)
{
axutil_qname_free(qname, env);
}
address = axiom_element_get_attribute_value_by_name(address_element, env, "url");
if(!address)
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
return;
}
printf("\naddress:%s\n\n", address);
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rst_populate_rst(
trust_rst_t *rst,
const axutil_env_t *env,
axiom_node_t *rst_node)
{
axiom_element_t *rst_ele = NULL;
axutil_qname_t *attr_ctx_qname = NULL;
axis2_char_t *attr_ctx = NULL;
axiom_node_t *token_type_node = NULL;
axiom_element_t *token_type_ele = NULL;
axutil_qname_t *token_type_qname = NULL;
axis2_char_t *token_type = NULL;
axiom_element_t *req_type_ele = NULL;
axiom_node_t *req_type_node = NULL;
axutil_qname_t *req_type_qname = NULL;
axis2_char_t *req_type = NULL;
axutil_qname_t *applies_to_qname = NULL; /*AppliesTo*/
axiom_node_t *applies_to_node = NULL;
axiom_element_t *applies_to_ele = NULL;
axutil_qname_t *applies_to_epr_qname = NULL; /*EPR*/
axiom_node_t *applies_to_epr_node = NULL;
axiom_element_t *applies_to_epr_ele = NULL;
axutil_qname_t *applies_to_addr_qname = NULL; /*Addr*/
axiom_node_t *applies_to_addr_node = NULL;
axiom_element_t *applies_to_addr_ele = NULL;
trust_claims_t *claims = NULL;
axiom_node_t *claims_node = NULL;
axiom_element_t *claims_ele = NULL;
axutil_qname_t *claims_qname = NULL;
trust_entropy_t *entropy = NULL;
axiom_node_t *entropy_node = NULL;
axiom_element_t *entropy_ele = NULL;
axutil_qname_t *entropy_qname = NULL;
axiom_node_t *lifetime_node = NULL;
axiom_element_t *lifetime_ele = NULL;
axutil_qname_t *lifetime_qname = NULL;
axiom_node_t *key_type_node = NULL;
axiom_element_t *key_type_ele = NULL;
axutil_qname_t *key_type_qname = NULL;
axis2_char_t *key_type = NULL;
axiom_node_t *key_size_node = NULL;
axiom_element_t *key_size_ele = NULL;
axutil_qname_t *key_size_qname = NULL;
axis2_char_t *key_size = NULL;
axiom_node_t *authnetication_type_node = NULL;
axiom_element_t *authnetication_type_ele = NULL;
axutil_qname_t *authnetication_type_qname = NULL;
axis2_char_t *authnetication_type = NULL;
axiom_node_t *signature_algo_node = NULL;
axiom_element_t *signature_algo_ele = NULL;
axutil_qname_t *signature_algo_qname = NULL;
axis2_char_t *signature_algo = NULL;
axiom_node_t *encryption_algo_node = NULL;
axiom_element_t *encryption_algo_ele = NULL;
axutil_qname_t *encryption_algo_qname = NULL;
axis2_char_t *encryption_algo = NULL;
axiom_node_t *canonocalization_algo_node = NULL;
axiom_element_t *canonocalization_algo_ele = NULL;
axutil_qname_t *canonocalization_algo_qname = NULL;
axis2_char_t *canonocalization_algo = NULL;
axiom_node_t *computedkey_algo_node = NULL;
axiom_element_t *computedkey_algo_ele = NULL;
axutil_qname_t *computedkey_algo_qname = NULL;
axis2_char_t *computedkey_algo = NULL;
axiom_node_t *desired_encryption_node = NULL;
axiom_element_t *desired_encryption_ele = NULL;
axutil_qname_t *desired_encryption_qname = NULL;
axiom_node_t *desired_encryption_key_node = NULL; /*This can be either Key or STR*/
axiom_element_t *desired_encryption_key_ele = NULL;
axiom_node_t *proof_encryption_node = NULL;
axiom_element_t *proof_encryption_ele = NULL;
axutil_qname_t *proof_encryption_qname = NULL;
axiom_node_t *proof_encryption_key_node = NULL; /*This can be either Key or STR*/
axiom_element_t *proof_encryption_key_ele = NULL;
axiom_node_t *use_key_node = NULL;
axiom_element_t *use_key_ele = NULL;
axutil_qname_t *use_key_qname = NULL;
axiom_node_t *usekey_key_node = NULL; /*This can be either Key or STR*/
axiom_element_t *usekey_key_ele = NULL;
axiom_node_t *sign_with_node = NULL;
axiom_element_t *sign_with_ele = NULL;
axutil_qname_t *sign_with_qname = NULL;
axis2_char_t *sign_with = NULL;
axiom_node_t *encrypt_with_node = NULL;
axiom_element_t *encrypt_with_ele = NULL;
axutil_qname_t *encrypt_with_qname = NULL;
axis2_char_t *encrypt_with = NULL;
if(NULL == rst_node || NULL == rst)
{
return AXIS2_FAILURE;
}
rst_ele = (axiom_element_t*)axiom_node_get_data_element(rst_node, env);
if(NULL == rst_ele)
{
return AXIS2_FAILURE;
}
/*@Context*/
attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rst->wst_ns_uri, TRUST_WST);
if (!attr_ctx_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Context Attribute Qname creation failed.");
return AXIS2_FAILURE;
}
attr_ctx = axiom_element_get_attribute_value(rst_ele, env, attr_ctx_qname);
if (attr_ctx)
{
rst->attr_context = attr_ctx;
}
axutil_qname_free(attr_ctx_qname, env);
/*TokenType*/
token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rst->wst_ns_uri, TRUST_WST);
if (!token_type_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Qname creation failed.");
return AXIS2_FAILURE;
}
token_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, token_type_qname, rst_node, &token_type_node);
if (token_type_ele)
{
token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
if(token_type)
{
rst->token_type = token_type;
}
}
axutil_qname_free(token_type_qname, env);
/* RequestType */
req_type_qname = axutil_qname_create(env, TRUST_REQUEST_TYPE, rst->wst_ns_uri, TRUST_WST);
if (!req_type_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType Qname creation failed.");
return AXIS2_FAILURE;
}
req_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, req_type_qname, rst_node, &req_type_node);
if(req_type_ele)
{
req_type = axiom_element_get_text(req_type_ele, env, req_type_node);
if(req_type)
{
rst->request_type = req_type;
}
}
axutil_qname_free(req_type_qname, env);
/* AppliesTo */
applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
applies_to_epr_qname = axutil_qname_create(env, TRUST_EPR, TRUST_WSA_XMLNS, TRUST_WSA);
applies_to_addr_qname = axutil_qname_create(env, TRUST_EPR_ADDRESS, TRUST_WSA_XMLNS, TRUST_WSA);
if (!applies_to_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed.");
return AXIS2_FAILURE;
}
applies_to_ele = axiom_element_get_first_child_with_qname(rst_ele, env, applies_to_qname, rst_node, &applies_to_node);
if(applies_to_ele)
{
applies_to_epr_ele = axiom_element_get_first_child_with_qname(applies_to_ele, env, applies_to_epr_qname,
applies_to_node, &applies_to_epr_node);
if(applies_to_epr_ele)
{
applies_to_addr_ele = axiom_element_get_first_child_with_qname(applies_to_epr_ele, env, applies_to_addr_qname,
applies_to_epr_node, &applies_to_addr_node);
if(applies_to_addr_ele)
{
rst->applies_to_addr = axiom_element_get_text(applies_to_addr_ele, env, applies_to_addr_node);
}
}
}
axutil_qname_free(applies_to_qname, env);
axutil_qname_free(applies_to_epr_qname, env);
axutil_qname_free(applies_to_addr_qname, env);
/* Claims */
claims_qname = axutil_qname_create(env, TRUST_CLAIMS, rst->wst_ns_uri, TRUST_WST);
if (!claims_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims Qname creation failed.");
return AXIS2_FAILURE;
}
claims_ele = axiom_element_get_first_child_with_qname(rst_ele, env, claims_qname, rst_node, &claims_node);
if (claims_ele)
{
claims = trust_claims_create(env);
if(AXIS2_SUCCESS == trust_claims_deserialize(claims, env, claims_node))
{
rst->claims = claims;
}
}
axutil_qname_free(claims_qname, env);
/*Entropy */
entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rst->wst_ns_uri, TRUST_WST);
if (!entropy_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Qname creation failed.");
return AXIS2_FAILURE;
}
entropy_ele = axiom_element_get_first_child_with_qname(rst_ele, env, entropy_qname, rst_node, &entropy_node);
if(entropy_ele)
{
entropy = trust_entropy_create(env);
trust_entropy_set_ns_uri(entropy, env, rst->wst_ns_uri);
if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node))
{
rst->entropy = entropy;
}
}
axutil_qname_free(entropy_qname, env);
/*LifeTime*/
lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rst->wst_ns_uri, TRUST_WST);
if(!lifetime_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime Qname creation failed.");
return AXIS2_FAILURE;
}
lifetime_ele = axiom_element_get_first_child_with_qname(rst_ele, env, lifetime_qname, rst_node, &lifetime_node);
if(lifetime_ele)
{
if(AXIS2_SUCCESS == trust_life_time_deserialize(rst->life_time, env, lifetime_node))
{
rst->life_time = NULL;
}
}
axutil_qname_free(lifetime_qname, env);
/*Key and Encryption Requirements*/
/* KeyType */
key_type_qname = axutil_qname_create(env, TRUST_KEY_TYPE, rst->wst_ns_uri, TRUST_WST);
if(!key_type_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType Qname creation failed.");
return AXIS2_FAILURE;
}
key_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, key_type_qname, rst_node, &key_type_node);
if(key_type_ele)
{
key_type = axiom_element_get_text(key_type_ele, env, key_type_node);
if(key_type)
{
rst->key_type = key_type;
}
}
axutil_qname_free(key_type_qname, env);
/* KeySize */
key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rst->wst_ns_uri, TRUST_WST);
key_size_ele = axiom_element_get_first_child_with_qname(rst_ele, env, key_size_qname, rst_node, &key_size_node);
if(key_size_ele)
{
key_size = axiom_element_get_text(key_size_ele, env, key_size_node);
if(key_size)
{
rst->key_size = atoi(key_size);
}
}
axutil_qname_free(key_size_qname, env);
/*AuthenticationType*/
authnetication_type_qname = axutil_qname_create(env, TRUST_AUTHENTICATION_TYPE, rst->wst_ns_uri, TRUST_WST);
authnetication_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, authnetication_type_qname, rst_node, &authnetication_type_node);
if(authnetication_type_ele)
{
authnetication_type = axiom_element_get_text(authnetication_type_ele, env, authnetication_type_node);
if(authnetication_type)
{
rst->authentication_type = authnetication_type;
}
}
axutil_qname_free(authnetication_type_qname, env);
/*SignatureAlgorithm*/
signature_algo_qname = axutil_qname_create(env, TRUST_SIGNATURE_ALGO, rst->wst_ns_uri, TRUST_WST);
signature_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, signature_algo_qname, rst_node, &signature_algo_node);
if(signature_algo_ele)
{
signature_algo = axiom_element_get_text(signature_algo_ele, env, signature_algo_node);
if(signature_algo)
{
rst->signature_algo = signature_algo;
}
}
axutil_qname_free(signature_algo_qname, env);
/*EncryptionAlgorithm*/
encryption_algo_qname = axutil_qname_create(env, TRUST_ENCRYPTION_ALGO, rst->wst_ns_uri, TRUST_WST);
encryption_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, encryption_algo_qname, rst_node, &encryption_algo_node);
if(encryption_algo_ele)
{
encryption_algo = axiom_element_get_text(encryption_algo_ele, env, encryption_algo_node);
if(encryption_algo)
{
rst->encryption_algo = encryption_algo;
}
}
axutil_qname_free(encryption_algo_qname, env);
/*CanonicalizationAlgorithm*/
canonocalization_algo_qname = axutil_qname_create(env, TRUST_CANONICAL_ALGO, rst->wst_ns_uri, TRUST_WST);
canonocalization_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, canonocalization_algo_qname, rst_node, &canonocalization_algo_node);
if(canonocalization_algo_ele)
{
canonocalization_algo = axiom_element_get_text(canonocalization_algo_ele, env, canonocalization_algo_node);
if(canonocalization_algo)
{
rst->canonicalization_algo = canonocalization_algo;
}
}
axutil_qname_free(canonocalization_algo_qname, env);
/*ComputedKeyAlgorithm*/
computedkey_algo_qname = axutil_qname_create(env, TRUST_COMPUTED_KEY_ALGO, rst->wst_ns_uri, TRUST_WST);
computedkey_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, computedkey_algo_qname, rst_node, &computedkey_algo_node);
if(computedkey_algo_ele)
{
computedkey_algo = axiom_element_get_text(computedkey_algo_ele, env, computedkey_algo_node);
if(computedkey_algo)
{
rst->computed_key_algo = computedkey_algo;
}
}
axutil_qname_free(computedkey_algo_qname, env);
/*(Desired)Encryption */
desired_encryption_qname = axutil_qname_create(env, TRUST_DESIRED_ENCRYPTION, rst->wst_ns_uri, TRUST_WST);
if (!desired_encryption_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Encryption Qname creation failed.");
return AXIS2_FAILURE;
}
desired_encryption_ele = axiom_element_get_first_child_with_qname(rst_ele, env, desired_encryption_qname, rst_node, &desired_encryption_node);
if(desired_encryption_ele)
{
desired_encryption_key_ele = axiom_element_get_first_element(desired_encryption_ele, env, desired_encryption_node, &desired_encryption_key_node);
rst->desired_encryption = desired_encryption_key_node;
}
axutil_qname_free(desired_encryption_qname, env);
/*ProofEncryption*/
proof_encryption_qname = axutil_qname_create(env, TRUST_PROOF_ENCRYPTION, rst->wst_ns_uri, TRUST_WST);
if (!proof_encryption_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ProofEncryption Qname creation failed.");
return AXIS2_FAILURE;
}
proof_encryption_ele = axiom_element_get_first_child_with_qname(rst_ele, env, proof_encryption_qname, rst_node, &proof_encryption_node);
if(proof_encryption_ele)
{
proof_encryption_key_ele = axiom_element_get_first_element(proof_encryption_ele, env, proof_encryption_node, &proof_encryption_key_node);
rst->proof_encryption = proof_encryption_key_node;
}
axutil_qname_free(proof_encryption_qname, env);
/*UseKey*/
use_key_qname = axutil_qname_create(env, TRUST_USE_KEY, rst->wst_ns_uri, TRUST_WST);
if(!use_key_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] UseKey Qname creation failed.");
return AXIS2_FAILURE;
}
use_key_ele = axiom_element_get_first_child_with_qname(rst_ele, env, use_key_qname, rst_node, &use_key_node);
if(use_key_ele)
{
usekey_key_ele = axiom_element_get_first_element(use_key_ele, env, use_key_node, &usekey_key_node);
rst->usekey = usekey_key_node;
}
axutil_qname_free(use_key_qname, env);
/*SignWith*/
sign_with_qname = axutil_qname_create(env, TRUST_SIGN_WITH, rst->wst_ns_uri, TRUST_WST);
sign_with_ele = axiom_element_get_first_child_with_qname(rst_ele, env, sign_with_qname, rst_node, &sign_with_node);
if(sign_with_ele)
{
sign_with = axiom_element_get_text(sign_with_ele, env, sign_with_node);
if(sign_with)
{
rst->sign_with = sign_with;
}
}
axutil_qname_free(sign_with_qname, env);
/*EncryptWith*/
encrypt_with_qname = axutil_qname_create(env, TRUST_ENCRYPT_WITH, rst->wst_ns_uri, TRUST_WST);
if(!encrypt_with_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptWith Qname creation failed.");
return AXIS2_FAILURE;
}
encrypt_with_ele = axiom_element_get_first_child_with_qname(rst_ele, env, encrypt_with_qname, rst_node, &encrypt_with_node);
if(encrypt_with_ele)
{
encrypt_with = axiom_element_get_text(encrypt_with_ele, env, encrypt_with_node);
if(encrypt_with)
{
rst->encrypt_with = encrypt_with;
}
}
axutil_qname_free(encrypt_with_qname, env);
return AXIS2_SUCCESS;
}
WSF_WSDL_EXTERN axis2_bool_t WSF_WSDL_CALL
wsdl_util_forward_type_from_type_map(
const axutil_env_t* env,
axiom_node_t* type_map,
axis2_char_t* type1,
axis2_char_t* type2)
{
axiom_element_t* type_map_element = NULL, *forward_element = NULL;
axiom_node_t* forward_node = NULL;
axutil_qname_t *qname = NULL;
axis2_bool_t type_found = AXIS2_FALSE;
type_map_element = (axiom_element_t*)axiom_node_get_data_element(type_map, env);
if (type_map_element)
{
qname = axutil_qname_create(env, WSDL_TYPEMAP_FORWARD, NULL, NULL);
forward_element = axiom_element_get_first_child_with_qname(type_map_element, env, qname,
type_map, &forward_node);
axutil_qname_free(qname, env);
if (forward_element)
{
axiom_children_qname_iterator_t* parse_iter = NULL;
qname = axutil_qname_create(env, type1, NULL, NULL);
parse_iter = axiom_element_get_children_with_qname(forward_element, env, qname, forward_node);
while (axiom_children_qname_iterator_has_next(parse_iter, env) == AXIS2_TRUE)
{
axiom_node_t* type_node = NULL;
axiom_element_t* type_element = NULL;
axis2_char_t* text = NULL;
type_node = (axiom_node_t*)axiom_children_qname_iterator_next(parse_iter, env);
type_element = (axiom_element_t*)axiom_node_get_data_element(type_node, env);
text = axiom_element_get_text(type_element, env, type_node);
if (text)
{
if (!axutil_strcmp(text, type2))
{
type_found = AXIS2_TRUE;
break;
}
}
else
{
AXIS2_LOG_ERROR_MSG(env->log, "Badly formatted type map");
}
}
axutil_qname_free(qname, env);
if (!type_found)
{
AXIS2_LOG_DEBUG_MSG(env->log, "Requested type is not found in the type map");
}
}
}
return type_found;
}
