| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <sandesha2_fault_mgr.h> |
| #include <sandesha2_seq_property_mgr.h> |
| #include <sandesha2_create_seq_mgr.h> |
| #include <sandesha2_next_msg_mgr.h> |
| #include <sandesha2_constants.h> |
| #include <axutil_hash.h> |
| #include <axis2_core_utils.h> |
| #include <axiom_soap_const.h> |
| #include <sandesha2_create_seq.h> |
| #include <sandesha2_seq_ack.h> |
| #include <sandesha2_seq.h> |
| #include <sandesha2_identifier.h> |
| #include <sandesha2_msg_number.h> |
| #include <sandesha2_utils.h> |
| #include <sandesha2_spec_specific_consts.h> |
| #include <sandesha2_msg_init.h> |
| #include <sandesha2_utils.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_create_seq_refused ( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *rm_create_seq_msg_ctx, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| sandesha2_create_seq_t *create_seq = NULL; |
| axis2_bool_t refuse_seq = AXIS2_FALSE; |
| |
| AXIS2_PARAM_CHECK(env->error, rm_create_seq_msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| |
| create_seq = sandesha2_msg_ctx_get_create_seq(rm_create_seq_msg_ctx, env); |
| |
| if(!create_seq) |
| { |
| AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); |
| return NULL; |
| } |
| if(refuse_seq) |
| { |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| sandesha2_fault_data_t *fault_data = NULL; |
| |
| fault_data = sandesha2_fault_data_create(env); |
| sandesha2_fault_data_set_type(fault_data, env, |
| SANDESHA2_SOAP_FAULT_TYPE_CREATE_SEQ_REFUSED); |
| |
| soap_envelope = sandesha2_msg_ctx_get_soap_envelope(rm_create_seq_msg_ctx, env); |
| if(SANDESHA2_SOAP_VERSION_1_1 == sandesha2_utils_get_soap_version(env, soap_envelope)) |
| { |
| sandesha2_fault_data_set_code(fault_data, env, AXIOM_SOAP11_FAULT_CODE_SENDER); |
| } |
| else |
| { |
| sandesha2_fault_data_set_code(fault_data, env, AXIOM_SOAP12_FAULT_CODE_SENDER); |
| } |
| |
| sandesha2_fault_data_set_sub_code(fault_data, env, |
| SANDESHA2_SOAP_FAULT_SUBCODE_CREATE_SEQ_REFUSED); |
| |
| sandesha2_fault_data_set_reason(fault_data, env, ""); |
| |
| return sandesha2_fault_mgr_get_fault(env, rm_create_seq_msg_ctx, fault_data, |
| sandesha2_msg_ctx_get_addr_ns_val(rm_create_seq_msg_ctx, env), seq_prop_mgr); |
| } |
| |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_last_msg_num_exceeded( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *app_rm_msg, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| sandesha2_seq_t *sequence = NULL; |
| long msg_num = -1; |
| axis2_char_t *seq_id = NULL; |
| sandesha2_seq_property_bean_t *last_msg_bean = NULL; |
| axis2_bool_t exceeded = AXIS2_FALSE; |
| axis2_char_t reason[256]; |
| |
| AXIS2_PARAM_CHECK(env->error, app_rm_msg, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| |
| sequence = sandesha2_msg_ctx_get_sequence(app_rm_msg, env); |
| msg_num = sandesha2_msg_number_get_msg_num(sandesha2_seq_get_msg_num( |
| sequence, env), env); |
| seq_id = sandesha2_identifier_get_identifier( |
| sandesha2_seq_get_identifier(sequence, env), env); |
| |
| last_msg_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, |
| env, seq_id, SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO); |
| if(NULL != last_msg_bean) |
| { |
| long last_msg_no = -1; |
| last_msg_no = atol(sandesha2_seq_property_bean_get_value(last_msg_bean, |
| env)); |
| if(msg_num > last_msg_no) |
| { |
| exceeded = AXIS2_TRUE; |
| sprintf(reason, "The message number of the message %ld exceeded the" |
| " last message number %ld which was mentioned as last" |
| " message in a previosly received application message", |
| msg_num, last_msg_no); |
| } |
| } |
| if(exceeded) |
| { |
| sandesha2_fault_data_t *fault_data = NULL; |
| fault_data = sandesha2_fault_data_create(env); |
| sandesha2_fault_data_set_type(fault_data, env, |
| SANDESHA2_SOAP_FAULT_TYPE_LAST_MESSAGE_NO_EXCEEDED); |
| if(SANDESHA2_SOAP_VERSION_1_1 == sandesha2_utils_get_soap_version(env, |
| sandesha2_msg_ctx_get_soap_envelope(app_rm_msg, env))) |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP11_FAULT_CODE_SENDER); |
| else |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP12_FAULT_CODE_SENDER); |
| sandesha2_fault_data_set_sub_code(fault_data, env, |
| SANDESHA2_SOAP_FAULT_SUBCODE_LAST_MESSAGE_NO_EXCEEDED); |
| sandesha2_fault_data_set_reason(fault_data, env, reason); |
| return sandesha2_fault_mgr_get_fault(env, app_rm_msg, fault_data, |
| sandesha2_msg_ctx_get_addr_ns_val(app_rm_msg, env), seq_prop_mgr); |
| } |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_msg_num_rollover( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *rm_msg_ctx, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_unknown_seq( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *rm_msg_ctx, |
| axis2_char_t *seq_id, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr, |
| sandesha2_create_seq_mgr_t *create_seq_mgr, |
| sandesha2_next_msg_mgr_t *next_msg_mgr) |
| { |
| int type = -1; |
| axis2_bool_t valid_seq = AXIS2_TRUE; |
| |
| AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] sandesha2_fault_mgr_check_for_unknown_seq"); |
| |
| AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| AXIS2_PARAM_CHECK(env->error, create_seq_mgr, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_id, NULL); |
| |
| type = sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, env); |
| if(SANDESHA2_MSG_TYPE_ACK == type || SANDESHA2_MSG_TYPE_CREATE_SEQ_RESPONSE == type || |
| SANDESHA2_MSG_TYPE_TERMINATE_SEQ_RESPONSE == type || |
| SANDESHA2_MSG_TYPE_CLOSE_SEQ_RESPONSE == type) |
| { |
| sandesha2_create_seq_bean_t *find_bean = NULL; |
| axutil_array_list_t *list = NULL; |
| |
| find_bean = sandesha2_create_seq_bean_create(env); |
| sandesha2_create_seq_bean_set_rms_sequence_id(find_bean, env, seq_id); |
| list = sandesha2_create_seq_mgr_find(create_seq_mgr, env, find_bean); |
| if(find_bean) |
| { |
| sandesha2_create_seq_bean_free(find_bean, env); |
| } |
| |
| if(list) |
| { |
| int i = 0, size = 0; |
| size = axutil_array_list_size(list, env); |
| if(0 == size) |
| { |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Not a valid sequence message"); |
| valid_seq = AXIS2_FALSE; |
| } |
| |
| for(i = 0; i < size; i++) |
| { |
| sandesha2_create_seq_bean_t *create_seq_bean = axutil_array_list_get(list, env, i); |
| if(create_seq_bean) |
| { |
| sandesha2_create_seq_bean_free(create_seq_bean, env); |
| } |
| } |
| |
| axutil_array_list_free(list, env); |
| } |
| else |
| { |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Not a valid sequence message"); |
| valid_seq = AXIS2_FALSE; |
| } |
| } |
| else |
| { |
| axutil_array_list_t *list = NULL; |
| axis2_bool_t contains = AXIS2_FALSE; |
| |
| list = sandesha2_next_msg_mgr_retrieve_all(next_msg_mgr, env); |
| if(list) |
| { |
| int size = axutil_array_list_size(list, env); |
| int i = 0; |
| for(i = 0; i < size; i++) |
| { |
| sandesha2_next_msg_bean_t *next_bean = NULL; |
| axis2_char_t *tmp_id = NULL; |
| |
| next_bean = axutil_array_list_get(list, env, i); |
| tmp_id = sandesha2_next_msg_bean_get_seq_id(next_bean, env); |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] tmp_sequence_id:%s", tmp_id); |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] sequence_id:%s", seq_id); |
| if(contains) |
| { |
| if(next_bean) |
| { |
| sandesha2_next_msg_bean_free(next_bean, env); |
| } |
| |
| continue; |
| } |
| if(!axutil_strcmp(seq_id, tmp_id)) |
| { |
| if(next_bean) |
| { |
| sandesha2_next_msg_bean_free(next_bean, env); |
| } |
| |
| contains = AXIS2_TRUE; |
| } |
| else |
| { |
| if(next_bean) |
| { |
| sandesha2_next_msg_bean_free(next_bean, env); |
| } |
| } |
| } |
| |
| axutil_array_list_free(list, env); |
| } |
| |
| if(contains) |
| { |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Not a valid sequence message"); |
| valid_seq = AXIS2_TRUE; |
| } |
| else |
| { |
| valid_seq = AXIS2_FALSE; |
| } |
| } |
| |
| if(!valid_seq) |
| { |
| sandesha2_fault_data_t *fault_data = NULL; |
| axis2_char_t *rm_ns_val = NULL; |
| axiom_element_t *detail_ele = NULL; |
| axiom_node_t *detail_node = NULL; |
| axutil_qname_t *qname = NULL; |
| |
| fault_data = sandesha2_fault_data_create(env); |
| rm_ns_val = sandesha2_msg_ctx_get_rm_ns_val(rm_msg_ctx, env); |
| if(SANDESHA2_SOAP_VERSION_1_1 == sandesha2_utils_get_soap_version(env, |
| sandesha2_msg_ctx_get_soap_envelope(rm_msg_ctx, env))) |
| { |
| sandesha2_fault_data_set_code(fault_data, env, AXIOM_SOAP11_FAULT_CODE_SENDER); |
| } |
| else |
| { |
| sandesha2_fault_data_set_code(fault_data, env, AXIOM_SOAP12_FAULT_CODE_SENDER); |
| } |
| |
| sandesha2_fault_data_set_sub_code(fault_data, env, SANDESHA2_SOAP_FAULT_SUBCODE_UNKNOWN_SEQ); |
| qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_IDENTIFIER, |
| rm_ns_val, SANDESHA2_WSRM_COMMON_NS_PREFIX_RM); |
| detail_ele = axiom_element_create_with_qname(env, NULL, qname, &detail_node); |
| if(qname) |
| { |
| axutil_qname_free(qname, env); |
| } |
| |
| sandesha2_fault_data_set_detail(fault_data, env, detail_node); |
| sandesha2_fault_data_set_reason(fault_data, env, |
| "A sequence with the given sequenceID has NOT been established"); |
| |
| return sandesha2_fault_mgr_get_fault(env, rm_msg_ctx, fault_data, |
| sandesha2_msg_ctx_get_addr_ns_val(rm_msg_ctx, env), seq_prop_mgr); |
| } |
| |
| AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] sandesha2_fault_mgr_check_for_unknown_seq"); |
| |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_invalid_ack( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *ack_rm_msg, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| axis2_bool_t invalid_ack = AXIS2_FALSE; |
| axis2_char_t reason[256]; |
| sandesha2_seq_ack_t *seq_ack = NULL; |
| axutil_array_list_t *ack_range_list = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, ack_rm_msg, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| |
| if(SANDESHA2_MSG_TYPE_ACK != sandesha2_msg_ctx_get_msg_type(ack_rm_msg, env)) |
| return NULL; |
| seq_ack = sandesha2_msg_ctx_get_seq_ack(ack_rm_msg, env); |
| ack_range_list = sandesha2_seq_ack_get_ack_range_list(seq_ack, env); |
| if(ack_range_list) |
| { |
| int i = 0; |
| for(i = 0; i < axutil_array_list_size(ack_range_list, env); i++) |
| { |
| sandesha2_ack_range_t *ack_range = NULL; |
| long upper = -1; |
| long lower = -1; |
| ack_range = axutil_array_list_get(ack_range_list, env, i); |
| lower = sandesha2_ack_range_get_lower_value(ack_range, env); |
| upper = sandesha2_ack_range_get_upper_value(ack_range, env); |
| if(lower > upper) |
| { |
| invalid_ack = AXIS2_TRUE; |
| sprintf(reason, "The SequenceAcknowledgement is invalid. " |
| "Lower value is larger than upper value"); |
| } |
| } |
| } |
| if(invalid_ack) |
| { |
| sandesha2_fault_data_t *fault_data = NULL; |
| axis2_char_t *rm_ns_val = NULL; |
| axiom_element_t *detail_ele = NULL; |
| axiom_node_t *detail_node = NULL; |
| axiom_element_t *dummy_ele = NULL; |
| axiom_node_t *dummy_node = NULL; |
| axutil_qname_t *qname = NULL; |
| |
| fault_data = sandesha2_fault_data_create(env); |
| rm_ns_val = sandesha2_msg_ctx_get_rm_ns_val(ack_rm_msg, env); |
| if(SANDESHA2_SOAP_VERSION_1_1 == sandesha2_utils_get_soap_version(env, |
| sandesha2_msg_ctx_get_soap_envelope(ack_rm_msg, env))) |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP11_FAULT_CODE_SENDER); |
| else |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP12_FAULT_CODE_SENDER); |
| sandesha2_fault_data_set_sub_code(fault_data, env, |
| SANDESHA2_SOAP_FAULT_SUBCODE_INVALID_ACKNOWLEDGEMENT); |
| dummy_ele = axiom_element_create(env, NULL, "dummy_ele", NULL, |
| &dummy_node); |
| sandesha2_seq_ack_to_om_node(seq_ack, env, dummy_node); |
| qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ_ACK, |
| NULL, NULL); |
| detail_ele = axiom_element_get_first_child_with_qname(dummy_ele, env, |
| qname, dummy_node, &detail_node); |
| if(qname) |
| axutil_qname_free(qname, env); |
| sandesha2_fault_data_set_detail(fault_data, env, detail_node); |
| sandesha2_fault_data_set_reason(fault_data, env, reason); |
| return sandesha2_fault_mgr_get_fault(env, ack_rm_msg, fault_data, |
| sandesha2_msg_ctx_get_addr_ns_val(ack_rm_msg, env), seq_prop_mgr); |
| } |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_check_for_seq_closed( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *rm_msg_ctx, |
| axis2_char_t *seq_id, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| sandesha2_seq_property_bean_t *closed_bean = NULL; |
| axis2_bool_t seq_closed = AXIS2_FALSE; |
| axis2_char_t reason[256]; |
| |
| AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_id, NULL); |
| |
| closed_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, |
| seq_id, SANDESHA2_SEQ_PROP_SEQ_CLOSED); |
| if(closed_bean && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, |
| sandesha2_seq_property_bean_get_value(closed_bean, env))) |
| { |
| seq_closed = AXIS2_TRUE; |
| sprintf(reason, "The sequence with the id %s was closed previously." |
| " Cannot accept this message", seq_id); |
| } |
| if(seq_closed) |
| { |
| sandesha2_fault_data_t *fault_data = NULL; |
| |
| fault_data = sandesha2_fault_data_create(env); |
| if(SANDESHA2_SOAP_VERSION_1_1 == sandesha2_utils_get_soap_version(env, |
| sandesha2_msg_ctx_get_soap_envelope(rm_msg_ctx, env))) |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP11_FAULT_CODE_SENDER); |
| else |
| sandesha2_fault_data_set_code(fault_data, env, |
| AXIOM_SOAP12_FAULT_CODE_SENDER); |
| |
| sandesha2_fault_data_set_reason(fault_data, env, reason); |
| return sandesha2_fault_mgr_get_fault(env, rm_msg_ctx, fault_data, |
| sandesha2_msg_ctx_get_addr_ns_val(rm_msg_ctx, env), seq_prop_mgr); |
| } |
| return NULL; |
| } |
| |
| sandesha2_msg_ctx_t* AXIS2_CALL |
| sandesha2_fault_mgr_get_fault( |
| const axutil_env_t *env, |
| sandesha2_msg_ctx_t *rm_msg_ctx, |
| sandesha2_fault_data_t *fault_data, |
| axis2_char_t *addr_ns_uri, |
| sandesha2_seq_property_mgr_t *seq_prop_mgr) |
| { |
| axis2_msg_ctx_t *fault_msg_ctx = NULL; |
| axis2_msg_ctx_t *ref_msg = NULL; |
| axis2_op_t *op = NULL; |
| axis2_op_ctx_t *op_ctx = NULL; |
| axis2_char_t *acks_to_str = NULL; |
| axutil_string_t *grp_ctx_id = NULL; |
| int soap_ver = -1; |
| sandesha2_msg_ctx_t *fault_rm_msg = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL); |
| AXIS2_PARAM_CHECK(env->error, addr_ns_uri, NULL); |
| AXIS2_PARAM_CHECK(env->error, fault_data, NULL); |
| |
| ref_msg = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); |
| fault_msg_ctx = sandesha2_utils_create_out_msg_ctx(env, ref_msg); |
| |
| /* Setting context hierachy - be caereful about freeing |
| */ |
| axis2_msg_ctx_set_svc_grp(fault_msg_ctx, env, axis2_msg_ctx_get_svc_grp( |
| ref_msg, env)); |
| axis2_msg_ctx_set_svc_grp(fault_msg_ctx, env, (axis2_svc_grp_t *)axis2_msg_ctx_get_svc(ref_msg, |
| env)); |
| axis2_msg_ctx_set_svc_grp_ctx(fault_msg_ctx, env, |
| axis2_msg_ctx_get_svc_grp_ctx(ref_msg, env)); |
| axis2_msg_ctx_set_svc_ctx(fault_msg_ctx, env, axis2_msg_ctx_get_svc_ctx( |
| ref_msg, env)); |
| grp_ctx_id = (axutil_string_t *) axis2_msg_ctx_get_svc_grp_ctx_id(ref_msg, |
| env); |
| axis2_msg_ctx_set_svc_grp_ctx_id(fault_msg_ctx, env, grp_ctx_id); |
| axis2_msg_ctx_set_svc_ctx_id(fault_msg_ctx, env, |
| axis2_msg_ctx_get_svc_ctx_id(ref_msg, env)); |
| op = axis2_op_create(env); |
| axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY); |
| op_ctx = axis2_op_ctx_create(env, op, NULL); |
| axis2_msg_ctx_set_op(fault_msg_ctx, env, op); |
| axis2_msg_ctx_set_op_ctx(fault_msg_ctx, env, op_ctx); |
| |
| if(SANDESHA2_MSG_TYPE_CREATE_SEQ == sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, |
| env)) |
| { |
| sandesha2_create_seq_t *create_seq = NULL; |
| axis2_endpoint_ref_t *epr = NULL; |
| |
| create_seq = sandesha2_msg_ctx_get_create_seq(rm_msg_ctx, env); |
| epr = sandesha2_address_get_epr(sandesha2_acks_to_get_address( |
| sandesha2_create_seq_get_acks_to(create_seq, env), |
| env), env); |
| acks_to_str = (axis2_char_t*)axis2_endpoint_ref_get_address(epr, env); |
| } |
| else |
| { |
| sandesha2_seq_property_bean_t *acks_to_bean = NULL; |
| axis2_char_t *seq_id = NULL; |
| |
| seq_id = sandesha2_fault_data_get_seq_id(fault_data, env); |
| acks_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, |
| env, seq_id, SANDESHA2_SEQ_PROP_ACKS_TO_EPR); |
| if(NULL != acks_to_bean) |
| acks_to_str = sandesha2_seq_property_bean_get_value(acks_to_bean, |
| env); |
| } |
| if(!sandesha2_utils_is_anon_uri(env, acks_to_str)) |
| axis2_msg_ctx_set_to(fault_msg_ctx, env, axis2_endpoint_ref_create(env, |
| acks_to_str)); |
| soap_ver = sandesha2_utils_get_soap_version(env, |
| sandesha2_msg_ctx_get_soap_envelope(rm_msg_ctx, env)); |
| /* this method is not implemented. Uncomment this when implemented */ |
| /* sandesha2_soap_env_creator_add_soap_env(env, fault_msg_ctx, soap_ver, |
| fault_data, sandesha2_msg_ctx_get_rm_ns_val(rm_msg_ctx, |
| env));*/ |
| |
| fault_rm_msg = sandesha2_msg_init_init_msg(env, fault_msg_ctx); |
| return fault_rm_msg; |
| } |
| |
