| /* |
| * 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 <axis2_handler_desc.h> |
| #include <axutil_array_list.h> |
| #include <axis2_svc.h> |
| #include <axis2_msg_ctx.h> |
| #include <axutil_property.h> |
| #include <axis2_const.h> |
| #include <axis2_conf_ctx.h> |
| #include <sandesha2_seq.h> |
| #include <sandesha2_msg_ctx.h> |
| #include <sandesha2_msg_processor.h> |
| #include <sandesha2_msg_init.h> |
| #include <sandesha2_constants.h> |
| #include <sandesha2_utils.h> |
| #include <axis2_relates_to.h> |
| #include <axiom_soap_fault.h> |
| #include <axiom_soap_body.h> |
| #include <axiom_soap_header.h> |
| #include <stdlib.h> |
| #include <sandesha2_seq.h> |
| #include <sandesha2_msg_number.h> |
| #include <sandesha2_identifier.h> |
| #include <sandesha2_app_msg_processor.h> |
| |
| static axis2_status_t AXIS2_CALL |
| sandesha2_global_in_handler_invoke( |
| struct axis2_handler *handler, |
| const axutil_env_t *env, |
| struct axis2_msg_ctx *msg_ctx); |
| |
| AXIS2_EXTERN axis2_handler_t* AXIS2_CALL |
| sandesha2_global_in_handler_create( |
| const axutil_env_t *env, |
| axutil_qname_t *qname) |
| { |
| axis2_handler_t *handler = NULL; |
| |
| handler = axis2_handler_create(env); |
| if (!handler) |
| { |
| return NULL; |
| } |
| /* handler init is handled by conf loading, so no need to do it here */ |
| |
| /* set the base struct's invoke op */ |
| axis2_handler_set_invoke(handler, env, sandesha2_global_in_handler_invoke); |
| |
| return handler; |
| } |
| |
| |
| static axis2_status_t AXIS2_CALL |
| sandesha2_global_in_handler_invoke( |
| struct axis2_handler *handler, |
| const axutil_env_t *env, |
| struct axis2_msg_ctx *msg_ctx) |
| { |
| |
| axis2_conf_ctx_t *conf_ctx = NULL; |
| /*axis2_ctx_t *ctx = NULL;*/ |
| /*axis2_char_t *reinjected_msg = AXIS2_FALSE;*/ |
| /*axutil_property_t *property = NULL;*/ |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| axiom_soap_fault_t *fault_part = NULL; |
| const axutil_string_t *str_soap_action = NULL; |
| const axis2_char_t *wsa_action = NULL; |
| const axis2_char_t *soap_action = NULL; |
| axis2_bool_t is_rm_global_msg = AXIS2_FALSE; |
| |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); |
| AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_global_in_handler"); |
| |
| /* This handler needs to identify messages which follow the WSRM 1.0 |
| * convention for sending 'LastMessage' when the sender doesn't have a |
| * reliable message to piggyback the last message marker onto. |
| * Normally they will identify this scenario with an action marker, but if |
| * there is no action at all then we have to check the soap body. |
| * Either way, all that this handler need do is set the action back onto |
| * the message, so that the dispatchers can allow it to continue. The real |
| * processing will be done in the app_msg_processor. |
| */ |
| str_soap_action = axis2_msg_ctx_get_soap_action(msg_ctx, env); |
| soap_action = axutil_string_get_buffer(str_soap_action, env); |
| wsa_action = axis2_msg_ctx_get_wsa_action(msg_ctx, env); |
| if(wsa_action && !axutil_strcmp(wsa_action, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE)) |
| { |
| axutil_property_t *property = NULL; |
| property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); |
| axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_ISOLATED_LAST_MSG, property); |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Isolated last message"); |
| return AXIS2_SUCCESS; |
| } |
| if(!soap_action && !wsa_action) |
| { |
| axiom_soap_envelope_t *envelope = NULL; |
| envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); |
| if(envelope) |
| { |
| axis2_bool_t last_msg_header = AXIS2_FALSE; |
| axiom_soap_header_t *header = NULL; |
| |
| header = axiom_soap_envelope_get_header(envelope, env); |
| if(header) |
| { |
| sandesha2_seq_t *sequence = NULL; |
| axiom_node_t *seq_node = NULL; |
| axiom_node_t *header_node = NULL; |
| |
| sequence = sandesha2_seq_create(env, SANDESHA2_SPEC_2005_02_NS_URI); |
| header_node = axiom_soap_header_get_base_node(header, env); |
| if(header_node) |
| { |
| axutil_qname_t *seq_qname = NULL; |
| axiom_element_t *header_element = NULL; |
| |
| seq_qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ, |
| SANDESHA2_SPEC_2005_02_NS_URI, NULL); |
| if(seq_qname) |
| { |
| axiom_element_t *seq_element = NULL; |
| |
| header_element = axiom_node_get_data_element(header_node, env); |
| seq_element = axiom_element_get_first_child_with_qname(header_element, env, |
| seq_qname, header_node, &seq_node); |
| |
| axutil_qname_free(seq_qname, env); |
| } |
| } |
| |
| if(sequence && seq_node) |
| { |
| sandesha2_seq_from_om_node(sequence, env, seq_node); |
| } |
| |
| if(sandesha2_seq_get_last_msg(sequence, env)) |
| { |
| last_msg_header = AXIS2_TRUE; |
| } |
| } |
| |
| if(last_msg_header) |
| { |
| axiom_soap_body_t *body = NULL; |
| axiom_node_t *body_node = NULL; |
| |
| body = axiom_soap_envelope_get_body(envelope, env); |
| body_node = axiom_soap_body_get_base_node(body, env); |
| if(body && !axiom_node_get_first_element(body_node, env)) |
| { |
| axutil_property_t *property = NULL; |
| axutil_string_t *temp_soap_action = NULL; |
| |
| /* There is an empty body so we know this is the kind of message that we are |
| * looking for. |
| */ |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, |
| "[sandesha2] Setting SOAP Action for a WSRM 1.0 last message"); |
| |
| temp_soap_action = axutil_string_create(env, |
| SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); |
| if(temp_soap_action) |
| { |
| axis2_msg_ctx_set_soap_action(msg_ctx, env, temp_soap_action); |
| axutil_string_free(temp_soap_action, env); |
| } |
| |
| axis2_msg_ctx_set_wsa_action(msg_ctx, env, |
| SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); |
| |
| property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); |
| axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_ISOLATED_LAST_MSG, property); |
| } |
| } |
| } |
| |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, |
| "[sandesha2]soap::action and wsa::action are NULL. So return here"); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| is_rm_global_msg = sandesha2_utils_is_rm_global_msg(env, msg_ctx); |
| if(!is_rm_global_msg) |
| { |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Not a global RM Message"); |
| 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; |
| } |
| |
| /*ctx = axis2_msg_ctx_get_base(msg_ctx, env); |
| if(!axis2_msg_ctx_get_server_side(msg_ctx, env)) |
| { |
| axis2_ctx_t *conf_ctx_base = axis2_conf_ctx_get_base(conf_ctx, env); |
| axutil_property_t *property = axutil_property_create_with_args(env, 0, |
| 0, 0, NULL); |
| axis2_ctx_set_property(conf_ctx_base, env, SANDESHA2_IS_SVR_SIDE, |
| property); |
| }*/ |
| |
| soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); |
| if(!soap_envelope) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]SOAP envelope is NULL"); |
| return AXIS2_FAILURE; |
| } |
| |
| /*property = axis2_ctx_get_property(ctx, env, SANDESHA2_REINJECTED_MESSAGE); |
| if(property) |
| reinjected_msg = (axis2_char_t *) axutil_property_get_value(property, env); |
| if(reinjected_msg && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, reinjected_msg)) |
| { |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Detected"\ |
| " reinjected_msg. So return here."); |
| return AXIS2_SUCCESS; // Reinjected Messages are not processed by |
| sandesha2 inflow handlers |
| }*/ |
| |
| fault_part = axiom_soap_body_get_fault(axiom_soap_envelope_get_body(soap_envelope, env), env); |
| if(fault_part) |
| { |
| axis2_relates_to_t *relates_to = NULL; |
| relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); |
| if(relates_to) |
| { |
| const axis2_char_t *relates_to_val = NULL; |
| axis2_op_ctx_t *op_ctx = NULL; |
| |
| relates_to_val = axis2_relates_to_get_value(relates_to, env); |
| op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, relates_to_val); |
| if(op_ctx) |
| { |
| axis2_msg_ctx_t *req_msg_ctx = NULL; |
| req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_OUT); |
| if(req_msg_ctx) |
| { |
| if(sandesha2_utils_is_retrievable_on_faults(env, req_msg_ctx)) |
| { |
| /* TODO we need to notify the listeners */ |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] soap fault generated"); |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Pausing message context"); |
| axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE); |
| return AXIS2_SUCCESS; |
| } |
| } |
| } |
| } |
| } |
| |
| /*Process if global processing possible. - Currently none*/ |
| AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, |
| "[sandesha2]Exit:sandesha2_global_in_handler"); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| |