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; }