axis2_status_t AXIS2_CALL sandesha2_out_handler_invoke( struct axis2_handler *handler, const axutil_env_t *env, struct axis2_msg_ctx *msg_ctx) { axutil_property_t *temp_prop = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axis2_char_t *str_done = NULL; axis2_char_t *dummy_msg_str = NULL; axis2_bool_t dummy_msg = AXIS2_FALSE; axis2_svc_t *svc = NULL; axutil_qname_t *module_qname = NULL; sandesha2_msg_ctx_t *rm_msg_ctx = NULL; sandesha2_msg_processor_t *msg_processor = NULL; int msg_type = -1; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_out_handler_invoke"); temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_SEQ_PROP_MAKE_CONNECTION_OUT_PATH); if (temp_prop) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] In make connection out path. So return here."); return AXIS2_SUCCESS; temp_prop = NULL; } if(sandesha2_util_is_rstr_msg(env, msg_ctx)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] A RSTR message. Sandesha don't process."); return AXIS2_SUCCESS; } conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(!conf_ctx) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Configuration Context is NULL"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(!svc) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Axis2 Service is NULL"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SVC_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } module_qname = axutil_qname_create(env, SANDESHA2_MODULE, NULL, NULL); if(!axis2_svc_is_module_engaged(svc, env, module_qname)) { if(module_qname) { axutil_qname_free(module_qname, env); } AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]RM is not engaged. So return here"); return AXIS2_SUCCESS; } if(module_qname) { axutil_qname_free(module_qname, env); } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE); if(temp_prop) { str_done = (axis2_char_t *) axutil_property_get_value(temp_prop, env); } if(str_done && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, str_done)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]Application Processing Done. So return here."); return AXIS2_SUCCESS; } temp_prop = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, temp_prop); conf = axis2_conf_ctx_get_conf(conf_ctx, env); if(!sandesha2_permanent_storage_mgr_create_db(env, conf_ctx)) { return AXIS2_FAILURE; } /* Getting rm message */ rm_msg_ctx = sandesha2_msg_init_init_msg(env, msg_ctx); temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_DUMMY_MESSAGE); if(NULL != temp_prop) { dummy_msg_str = (axis2_char_t *) axutil_property_get_value(temp_prop, env); } if(dummy_msg_str && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, dummy_msg_str)) { dummy_msg = AXIS2_TRUE; } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SVC_CLIENT_CLOSED); if(temp_prop) { axis2_char_t *spec_version = NULL; axis2_endpoint_ref_t *reply_to = axis2_msg_ctx_get_reply_to(msg_ctx, env); if(reply_to) { axis2_char_t *address = axis2_endpoint_ref_get_address(reply_to, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to_address:%s", address); } spec_version = sandesha2_utils_get_rm_version(env, msg_ctx); if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) { axis2_char_t *action = NULL; axutil_string_t *str_action = NULL; action = sandesha2_spec_specific_consts_get_terminate_seq_action(env, spec_version); str_action = axutil_string_create(env, action); axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action); axutil_string_free(str_action, env); /*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/ msg_type = sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env, SANDESHA2_MSG_TYPE_CLOSE_SEQ); } else if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version)) { axutil_property_t *property = NULL; axutil_string_t *str_action = NULL; /*axis2_msg_info_headers_set_action(axis2_msg_ctx_get_msg_info_headers(msg_ctx, env), * env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); */ str_action = axutil_string_create(env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action); axutil_string_free(str_action, env); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, "Sandesha2LastMessage", property); /*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/ } } msg_type = sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, env); if(msg_type == SANDESHA2_MSG_TYPE_UNKNOWN) { axis2_msg_ctx_t *req_msg_ctx = NULL; axis2_op_ctx_t *op_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); if(req_msg_ctx) /* For the server side */ { sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL; sandesha2_seq_t *seq_part = NULL; req_rm_msg_ctx = sandesha2_msg_init_init_msg(env, req_msg_ctx); seq_part = sandesha2_msg_ctx_get_sequence(req_rm_msg_ctx, env); if(seq_part) { msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env); /* rm intended msg */ } if(req_rm_msg_ctx) sandesha2_msg_ctx_free(req_rm_msg_ctx, env); } else if(!axis2_msg_ctx_get_server_side(msg_ctx, env)) { msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env); } } else { msg_processor = sandesha2_msg_processor_create_msg_processor(env, rm_msg_ctx); } if(msg_processor) { sandesha2_msg_processor_process_out_msg(msg_processor, env, rm_msg_ctx); sandesha2_msg_processor_free(msg_processor, env); } if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error)) { /* Message should not be sent in an exception situation */ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Pausing message context"); axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE); if(rm_msg_ctx) { sandesha2_msg_ctx_free(rm_msg_ctx, env); } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Error in processing the message"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_PROCESS_MSG, AXIS2_FAILURE); return AXIS2_FAILURE; } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE); if(temp_prop) { axutil_property_set_value(temp_prop, env, AXIS2_VALUE_FALSE); } if(rm_msg_ctx) { sandesha2_msg_ctx_free(rm_msg_ctx, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_out_handler_invoke"); return AXIS2_SUCCESS; }
axis2_status_t AXIS2_CALL axis2_addr_out_handler_invoke( struct axis2_handler * handler, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_char_t *addr_ver_from_msg_ctx = NULL; const axis2_char_t *addr_ns = NULL; axis2_msg_info_headers_t *msg_info_headers = NULL; axis2_ctx_t *ctx = NULL; axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_header_t *soap_header = NULL; axiom_node_t *soap_header_node = NULL; axiom_element_t *soap_header_ele = NULL; axis2_endpoint_ref_t *epr_to = NULL; axis2_endpoint_ref_t *epr_reply_to = NULL; axis2_endpoint_ref_t *epr_from = NULL; axis2_endpoint_ref_t *epr_fault_to = NULL; axutil_property_t *property = NULL; const axis2_char_t *wsa_action = NULL; axis2_bool_t set_must_understand = AXIS2_FALSE; axutil_property_t *must_understand_prop; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_LOG_INFO(env->log, "Starting addressing out handler"); soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_envelope) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP envelope. Stop processing addressing"); return AXIS2_SUCCESS; /* Can happen in case of ONE-WAY services/clients */ } msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env); if(msg_info_headers) { wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); } else { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No addressing in use"); return AXIS2_SUCCESS; /* No addressing in use */ } if(!wsa_action || !*wsa_action) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No action present. Stop processing addressing"); return AXIS2_SUCCESS; /* If no action present, assume no addressing in use */ } ctx = axis2_msg_ctx_get_base(msg_ctx, env); property = axis2_ctx_get_property(ctx, env, AXIS2_WSA_VERSION); if(property) { addr_ver_from_msg_ctx = axutil_property_get_value(property, env); property = NULL; } must_understand_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ADDR_ADD_MUST_UNDERSTAND_TO_ADDR_HEADERS); if(must_understand_prop) { axis2_char_t *value = axutil_property_get_value(must_understand_prop, env); if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0) set_must_understand = AXIS2_TRUE; } /* Setting version 1.0 as the default addressing namespace */ addr_ns = AXIS2_WSA_NAMESPACE; if(addr_ver_from_msg_ctx) { if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ver_from_msg_ctx)) { addr_ns = AXIS2_WSA_NAMESPACE_SUBMISSION; } } else if(axis2_msg_ctx_get_op_ctx(msg_ctx, env)) { axis2_op_ctx_t *op_ctx = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); } if(in_msg_ctx) { axis2_ctx_t *in_ctx = NULL; in_ctx = axis2_msg_ctx_get_base(in_msg_ctx, env); property = axis2_ctx_get_property(in_ctx, env, AXIS2_WSA_VERSION); if(property) { addr_ns = axutil_property_get_value(property, env); property = NULL; } if(!addr_ns || !*addr_ns) { addr_ns = AXIS2_WSA_NAMESPACE; } } } soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if(!soap_header) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP header. Stop processing addressing"); return AXIS2_SUCCESS; /* No SOAP header, so no point proceeding */ } else { /* By this time, we definitely have some addressing information to be sent. This is because, * we have tested at the start of this whether msg_info_headers are null or not. * So rather than declaring addressing namespace in each and every addressing header, lets * define that in the Header itself. */ const axis2_char_t *action = NULL; const axis2_char_t *address = NULL; const axis2_char_t *svc_group_context_id = NULL; const axis2_char_t *message_id = NULL; axis2_relates_to_t *relates_to = NULL; axiom_node_t *relates_to_header_node = NULL; axiom_element_t *relates_to_header_ele = NULL; axiom_namespace_t *addressing_namespace = NULL; soap_header_node = axiom_soap_header_get_base_node(soap_header, env); soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header_node, env); addressing_namespace = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); axiom_element_declare_namespace(soap_header_ele, env, soap_header_node, addressing_namespace); epr_to = axis2_msg_info_headers_get_to(msg_info_headers, env); if(epr_to) { axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env); if(body) { /* In case of a SOAP fault, we got to send the response to the adress specified by FaultTo */ if(axiom_soap_body_has_fault(body, env)) { axis2_endpoint_ref_t *epr_fault_to = axis2_msg_info_headers_get_fault_to( msg_info_headers, env); if(epr_fault_to) { const axis2_char_t *fault_to_address = axis2_endpoint_ref_get_address( epr_fault_to, env); if(fault_to_address) { if(axutil_strcmp(AXIS2_WSA_NONE_URL, fault_to_address) && axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, fault_to_address)) { axis2_endpoint_ref_set_address(epr_to, env, fault_to_address); } } } } } address = axis2_endpoint_ref_get_address(epr_to, env); if(address && *address) { axiom_node_t *to_header_block_node = NULL; axiom_soap_header_block_t *to_header_block = NULL; axutil_array_list_t *ref_param_list = NULL; int size = 0; to_header_block = axiom_soap_header_add_header_block(soap_header, env, AXIS2_WSA_TO, addressing_namespace); if(set_must_understand == AXIS2_TRUE) { axiom_soap_header_block_set_must_understand_with_bool(to_header_block, env, AXIS2_TRUE); } to_header_block_node = axiom_soap_header_block_get_base_node(to_header_block, env); if(to_header_block_node) { axiom_element_t *to_header_block_element = NULL; to_header_block_element = (axiom_element_t *)axiom_node_get_data_element( to_header_block_node, env); if(to_header_block_element) { axiom_element_set_text(to_header_block_element, env, address, to_header_block_node); } } ref_param_list = axis2_endpoint_ref_get_ref_param_list(epr_to, env); size = axutil_array_list_size(ref_param_list, env); if(ref_param_list && size > 0) { axiom_soap_header_block_t *reference_header_block = NULL; axiom_node_t *reference_node = NULL; int i = 0; for(i = 0; i < size; i++) { axiom_node_t *temp_node = NULL; temp_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i); if(temp_node) { axiom_element_t *temp_ele = NULL; temp_ele = axiom_node_get_data_element(temp_node, env); if(temp_ele) { reference_header_block = axiom_soap_header_add_header_block( soap_header, env, axiom_element_get_localname(temp_ele, env), axiom_element_get_namespace(temp_ele, env, temp_node)); if(set_must_understand) { axiom_soap_header_block_set_must_understand_with_bool(reference_header_block, env, AXIS2_TRUE); } reference_node = axiom_soap_header_block_get_base_node( reference_header_block, env); if(reference_node) { axiom_element_t *reference_ele = NULL; reference_ele = (axiom_element_t *)axiom_node_get_data_element( reference_node, env); if(reference_ele) { axiom_namespace_t *addr_ns_obj = NULL; axiom_attribute_t *reference_attr = NULL; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); reference_attr = axiom_attribute_create(env, /*"isReferenceParameter"*/ AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, "true", addr_ns_obj); axiom_element_add_attribute(reference_ele, env, reference_attr, reference_node); axiom_element_set_text(reference_ele, env, axiom_element_get_text(temp_ele, env, temp_node), reference_node); } } } } } } } }/* if(epr_to) */ axiom_namespace_free(addressing_namespace, env); action = axis2_msg_info_headers_get_action(msg_info_headers, env); if(action && *action) { axis2_addr_out_handler_process_string_info(env, action, AXIS2_WSA_ACTION, &soap_header, addr_ns, set_must_understand); } epr_reply_to = axis2_msg_info_headers_get_reply_to(msg_info_headers, env); if(!epr_reply_to) { const axis2_char_t *anonymous_uri = NULL; axis2_bool_t anonymous = axis2_msg_info_headers_get_reply_to_anonymous( msg_info_headers, env); axis2_bool_t none = axis2_msg_info_headers_get_reply_to_none(msg_info_headers, env); if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; } } else { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; } } if(anonymous_uri) { epr_reply_to = axis2_endpoint_ref_create(env, anonymous_uri); } if(epr_reply_to) { axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr_reply_to); } } /* add the service group id as a reference parameter */ svc_group_context_id = axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(msg_ctx, env), env); axis2_addr_out_handler_add_to_soap_header(env, epr_reply_to, AXIS2_WSA_REPLY_TO, soap_header, addr_ns); epr_from = axis2_msg_info_headers_get_from(msg_info_headers, env); if(epr_from) { axis2_addr_out_handler_add_to_soap_header(env, epr_from, AXIS2_WSA_FROM, soap_header, addr_ns); } epr_fault_to = axis2_msg_info_headers_get_fault_to(msg_info_headers, env); if(!epr_fault_to) { const axis2_char_t *anonymous_uri = NULL; axis2_bool_t anonymous = axis2_msg_info_headers_get_fault_to_anonymous( msg_info_headers, env); axis2_bool_t none = axis2_msg_info_headers_get_fault_to_none(msg_info_headers, env); if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { if(none) { anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; } else if(anonymous) { anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; } } else { if(none) anonymous_uri = AXIS2_WSA_NONE_URL; else if(anonymous) anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; } if(anonymous_uri) { epr_fault_to = axis2_endpoint_ref_create(env, anonymous_uri); } } if(epr_fault_to) { /* optional */ axis2_addr_out_handler_add_to_soap_header(env, epr_fault_to, AXIS2_WSA_FAULT_TO, soap_header, addr_ns); } message_id = axis2_msg_info_headers_get_message_id(msg_info_headers, env); if(message_id) { axis2_addr_out_handler_process_string_info(env, message_id, AXIS2_WSA_MESSAGE_ID, &soap_header, addr_ns, set_must_understand); } relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env); if(relates_to) { const axis2_char_t *value = NULL; value = axis2_relates_to_get_value(relates_to, env); relates_to_header_node = axis2_addr_out_handler_process_string_info(env, value, AXIS2_WSA_RELATES_TO, &soap_header, addr_ns, set_must_understand); } if(relates_to_header_node) { const axis2_char_t *relationship_type = NULL; relationship_type = axis2_relates_to_get_relationship_type(relates_to, env); if(relationship_type && *relationship_type) { axiom_attribute_t *om_attr = NULL; axiom_namespace_t *addr_ns_obj = NULL; axiom_namespace_t *dec_ns = NULL; relates_to_header_ele = (axiom_element_t *)axiom_node_get_data_element( relates_to_header_node, env); if(relates_to_header_ele) { dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(dec_ns) { addr_ns_obj = dec_ns; } else { addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); } if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) { om_attr = axiom_attribute_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION, addr_ns_obj); } else { om_attr = axiom_attribute_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE, addr_ns_obj); } axiom_element_add_attribute(relates_to_header_ele, env, om_attr, relates_to_header_node); dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(!dec_ns) { dec_ns = axiom_element_find_namespace(relates_to_header_ele, env, relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(dec_ns) { axiom_namespace_free(addr_ns_obj, env); addr_ns_obj = NULL; axiom_attribute_set_namespace(om_attr, env, dec_ns); } } } } } } return AXIS2_SUCCESS; }
axis2_status_t __euca_authenticate(const axutil_env_t *env,axis2_msg_ctx_t *out_msg_ctx, axis2_op_ctx_t *op_ctx) { //***** First get the message context before doing anything dumb w/ a NULL pointer *****/ axis2_msg_ctx_t *msg_ctx = NULL; //<--- incoming msg context, it is NULL, see? msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); //***** Print everything from the security results, just for testing now *****// rampart_context_t *rampart_context = NULL; axutil_property_t *property = NULL; property = axis2_msg_ctx_get_property(msg_ctx, env, RAMPART_CONTEXT); if(property) { rampart_context = (rampart_context_t *)axutil_property_get_value(property, env); // AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," ======== PRINTING PROCESSED WSSEC TOKENS ======== "); rampart_print_security_processed_results_set(env,msg_ctx); } //***** Extract Security Node from header from enveloper from msg_ctx *****// axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_header_t *soap_header = NULL; axiom_node_t *sec_node = NULL; soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_envelope) NO_U_FAIL("SOAP envelope cannot be found."); soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if (!soap_header) NO_U_FAIL("SOAP header cannot be found."); sec_node = rampart_get_security_header(env, msg_ctx, soap_header); // <---- here it is! if(!sec_node)NO_U_FAIL("No node wsse:Security -- required: ws-security"); //***** Find the wsse:Reference to the BinarySecurityToken *****// //** Path is: Security/ //** *sec_node must be non-NULL, kkthx **// axiom_node_t *sig_node = NULL; axiom_node_t *key_info_node = NULL; axiom_node_t *sec_token_ref_node = NULL; /** the ds:Signature node **/ sig_node = oxs_axiom_get_first_child_node_by_name(env,sec_node, OXS_NODE_SIGNATURE, OXS_DSIG_NS, OXS_DS ); if(!sig_node)NO_U_FAIL("No node ds:Signature -- required: signature"); /** the ds:KeyInfo **/ key_info_node = oxs_axiom_get_first_child_node_by_name(env, sig_node, OXS_NODE_KEY_INFO, OXS_DSIG_NS, NULL ); if(!key_info_node)NO_U_FAIL("No node ds:KeyInfo -- required: signature key"); /** the wsse:SecurityTokenReference **/ sec_token_ref_node = oxs_axiom_get_first_child_node_by_name(env, key_info_node,OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, NULL); if(!sec_token_ref_node)NO_U_FAIL("No node wsse:SecurityTokenReference -- required: signing token"); //** in theory this is the branching point for supporting all kinds of tokens -- we only do BST Direct Reference **/ //***** Find the wsse:Reference to the BinarySecurityToken *****// //** *sec_token_ref_node must be non-NULL **/ axis2_char_t *ref = NULL; axis2_char_t *ref_id = NULL; axiom_node_t *token_ref_node = NULL; axiom_node_t *bst_node = NULL; /** the wsse:Reference node **/ token_ref_node = oxs_axiom_get_first_child_node_by_name(env, sec_token_ref_node,OXS_NODE_REFERENCE, OXS_WSSE_XMLNS, NULL); /** pull out the name of the BST node **/ ref = oxs_token_get_reference(env, token_ref_node); ref_id = axutil_string_substring_starting_at(axutil_strdup(env, ref), 1); /** get the wsse:BinarySecurityToken used to sign the message **/ bst_node = oxs_axiom_get_node_by_id(env, sec_node, "Id", ref_id, OXS_WSU_XMLNS); if(!bst_node){oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Error retrieving elementwith ID=%s", ref_id);NO_U_FAIL("Cant find the required node");} //***** Find the wsse:Reference to the BinarySecurityToken *****// //** *bst_node must be non-NULL **/ axis2_char_t *data = NULL; oxs_x509_cert_t *_cert = NULL; oxs_x509_cert_t *recv_cert = NULL; axis2_char_t *file_name = NULL; axis2_char_t *recv_x509_buf = NULL; axis2_char_t *msg_x509_buf = NULL; /** pull out the data from the BST **/ data = oxs_axiom_get_node_content(env, bst_node); /** create an oxs_X509_cert **/ _cert = oxs_key_mgr_load_x509_cert_from_string(env, data); if(_cert) { //***** FINALLY -- we have the certificate used to sign the message. authenticate it HERE *****// msg_x509_buf = oxs_x509_cert_get_data(_cert,env); if(!msg_x509_buf)NO_U_FAIL("OMG WHAT NOW?!"); /* recv_x509_buf = (axis2_char_t *)rampart_context_get_receiver_certificate(rampart_context, env); if(recv_x509_buf) recv_cert = oxs_key_mgr_load_x509_cert_from_string(env, recv_x509_buf); else { file_name = rampart_context_get_receiver_certificate_file(rampart_context, env); if(!file_name) NO_U_FAIL("Policy for the service is incorrect -- ReceiverCertificate is not set!!"); if (check_file(file_name)) NO_U_FAIL("No cert file ($EUCALYPTUS/var/lib/eucalyptus/keys/cloud-cert.pem) found, failing"); recv_cert = oxs_key_mgr_load_x509_cert_from_pem_file(env, file_name); } */ file_name = rampart_context_get_receiver_certificate_file(rampart_context, env); if(!file_name) NO_U_FAIL("Policy for the service is incorrect -- ReceiverCertificate is not set!!"); if (check_file(file_name)) NO_U_FAIL("No cert file ($EUCALYPTUS/var/lib/eucalyptus/keys/cloud-cert.pem) found, failing"); recv_cert = oxs_key_mgr_load_x509_cert_from_pem_file(env, file_name); if (recv_cert) { recv_x509_buf = oxs_x509_cert_get_data(recv_cert,env); } else { NO_U_FAIL("could not populate receiver cert"); } if( axutil_strcmp(recv_x509_buf,msg_x509_buf)!=0){ AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," --------- Received x509 certificate value ---------" ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI, msg_x509_buf ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," --------- Local x509 certificate value! ---------" ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI, recv_x509_buf ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," ---------------------------------------------------" ); NO_U_FAIL("The certificate specified is invalid!"); } } else { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_DEFAULT, "Cannot load certificate from string =%s", data); NO_U_FAIL("Failed to build certificate from BinarySecurityToken"); } oxs_x509_cert_free(_cert, env); oxs_x509_cert_free(recv_cert, env); return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL sandesha2_seq_mgr_setup_new_outgoing_sequence( const axutil_env_t *env, axis2_msg_ctx_t *first_app_msg, axis2_char_t *internal_sequence_id, axis2_char_t *spec_version, sandesha2_seq_property_mgr_t *seq_prop_mgr) { axis2_conf_ctx_t *conf_ctx = NULL; axis2_char_t *addr_ns_val = NULL; axutil_property_t *property = NULL; sandesha2_seq_property_bean_t *addr_ns_bean = NULL; axis2_char_t *anon_uri = NULL; axis2_endpoint_ref_t *to_epr = NULL; axis2_char_t *acks_to_str = NULL; sandesha2_seq_property_bean_t *to_bean = NULL; sandesha2_seq_property_bean_t *reply_to_bean = NULL; sandesha2_seq_property_bean_t *acks_to_bean = NULL; sandesha2_seq_property_bean_t *msgs_bean = NULL; axis2_char_t *transport_to = NULL; axis2_endpoint_ref_t *reply_to_epr = NULL; axis2_bool_t is_svr_side = AXIS2_FALSE; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:sandesha2_seq_mgr_setup_new_outgoing_sequence"); AXIS2_PARAM_CHECK(env->error, first_app_msg, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, internal_sequence_id, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, spec_version, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FAILURE); conf_ctx = axis2_msg_ctx_get_conf_ctx(first_app_msg, env); property = axis2_msg_ctx_get_property(first_app_msg, env, AXIS2_WSA_VERSION); if(property) { addr_ns_val = axutil_property_get_value(property, env); } if(!addr_ns_val) { axis2_op_ctx_t *op_ctx = NULL; axis2_msg_ctx_t *req_msg_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(first_app_msg, env); req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); if(req_msg_ctx) { property = axis2_msg_ctx_get_property(req_msg_ctx, env, AXIS2_WSA_VERSION); if(property) { addr_ns_val = axutil_property_get_value(property, env); } } } if(!addr_ns_val) { addr_ns_val = AXIS2_WSA_NAMESPACE; } addr_ns_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, addr_ns_val); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, addr_ns_bean); if(addr_ns_bean) { sandesha2_seq_property_bean_free(addr_ns_bean, env); } anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_val); to_epr = axis2_msg_ctx_get_to(first_app_msg, env); property = axis2_msg_ctx_get_property(first_app_msg, env, SANDESHA2_CLIENT_ACKS_TO); if(property) { acks_to_str = axutil_property_get_value(property, env); } if (to_epr) { to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_TO_EPR, (axis2_char_t*)axis2_endpoint_ref_get_address(to_epr, env)); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, to_bean); sandesha2_seq_property_bean_free(to_bean, env); } is_svr_side = axis2_msg_ctx_get_server_side(first_app_msg, env); if(is_svr_side) { axis2_op_ctx_t *op_ctx = NULL; axis2_msg_ctx_t *req_msg_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(first_app_msg, env); req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); if(!req_msg_ctx) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cannot find the request message from the operation context"); return AXIS2_FAILURE; } reply_to_epr = axis2_msg_ctx_get_to(req_msg_ctx, env); if(reply_to_epr) { const axis2_char_t *temp_epr_addr = axis2_endpoint_ref_get_address(reply_to_epr, env); if(temp_epr_addr) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "temp_epr_address:%s", temp_epr_addr); acks_to_str = (axis2_char_t *) temp_epr_addr; reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR, (axis2_char_t*) temp_epr_addr); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean); sandesha2_seq_property_bean_free(reply_to_bean, env); } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cannot get request message from the operation context"); return AXIS2_FAILURE; } } else /* Not server side */ { reply_to_epr = axis2_msg_ctx_get_reply_to(first_app_msg, env); if(reply_to_epr) { const axis2_char_t *temp_epr_addr = axis2_endpoint_ref_get_address(reply_to_epr, env); if(temp_epr_addr) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "temp_epr_address:%s", temp_epr_addr); reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR, (axis2_char_t*) temp_epr_addr); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean); sandesha2_seq_property_bean_free(reply_to_bean, env); } } } if(!acks_to_str) { acks_to_str = anon_uri; } acks_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_ACKS_TO_EPR, acks_to_str); msgs_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_CLIENT_COMPLETED_MESSAGES, ""); if(msgs_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, msgs_bean); sandesha2_seq_property_bean_free(msgs_bean, env); } if(acks_to_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_bean); sandesha2_seq_property_bean_free(acks_to_bean, env); } transport_to = axis2_msg_ctx_get_transport_url(first_app_msg, env); if(transport_to) { sandesha2_seq_property_bean_t *transport_to_bean = NULL; transport_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, SANDESHA2_SEQ_PROP_TRANSPORT_TO, transport_to); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, transport_to_bean); } sandesha2_seq_mgr_update_last_activated_time(env, internal_sequence_id, seq_prop_mgr); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:sandesha2_seq_mgr_setup_new_outgoing_sequence"); return AXIS2_SUCCESS; }