AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_engine_receive_fault( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_op_ctx_t *op_ctx = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_receive_fault"); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(!op_ctx) { /* If we do not have an op context that means this may be an incoming dual channel response. So try to dispatch the service */ axis2_conf_ctx_t *conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(conf_ctx) { axis2_conf_t *conf = axis2_conf_ctx_get_conf(conf_ctx, env); if(conf) { axutil_array_list_t *phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); if(phases) { if(axis2_msg_ctx_is_paused(msg_ctx, env)) { axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); } else { axis2_engine_invoke_phases(engine, env, phases, msg_ctx); } } } } } op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); /* Find and execute the fault in flow handlers */ if(op_ctx) { axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); axutil_array_list_t *phases = axis2_op_get_fault_in_flow(op, env); if(axis2_msg_ctx_is_paused(msg_ctx, env)) { axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); } else { axis2_engine_invoke_phases(engine, env, phases, msg_ctx); } } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_receive_fault"); return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_engine_resume_receive( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_status_t status = AXIS2_FAILURE; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axutil_array_list_t *phases = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_receive"); /* Find and invoke the phases */ conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); conf = axis2_conf_ctx_get_conf(conf_ctx, env); phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); /* Invoking the message receiver */ if(axis2_msg_ctx_get_server_side(msg_ctx, env) && !axis2_msg_ctx_is_paused(msg_ctx, env)) { /* Invoke the message receivers */ axis2_op_ctx_t *op_ctx = NULL; status = axis2_engine_check_must_understand_headers(env, msg_ctx); if(status != AXIS2_SUCCESS) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Checking for must understand headers failed"); return status; } op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); if(op) { axis2_msg_recv_t *receiver = NULL; receiver = axis2_op_get_msg_recv(op, env); if(!receiver) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Message receiver not set in operation description"); return AXIS2_FAILURE; } status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived( receiver, env)); } } } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_resume_receive"); return status; }
AxisEnvironmentWrapper::AxisEnvironmentWrapper(const axutil_env_t * env, axis2_msg_ctx * msg_ctx):_env(env){ axis2_op_ctx* op_ctx = axis2_msg_ctx_get_op_ctx (msg_ctx, env); // _baseCtx = axis2_msg_ctx_get_base(msg_ctx, env); if (!op_ctx) { throw std::runtime_error("Couldn't get operation context from message context"); } _ctx = axis2_op_ctx_get_base(op_ctx, env); if (!_ctx) { throw std::runtime_error("Couldn't get operation context from message context"); } }
AXIS2_EXPORT axis2_status_t AXIS2_CALL axis2_msg_recv_delete_svc_obj( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_svc_t *svc = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_svc_ctx_t *svc_ctx = NULL; axutil_param_t *impl_info_param = NULL; axutil_param_t *scope_param = NULL; axis2_char_t *param_value = NULL; axutil_dll_desc_t *dll_desc = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); svc = axis2_svc_ctx_get_svc(svc_ctx, env); if(!svc) { return AXIS2_FAILURE; } scope_param = axis2_svc_get_param(svc, env, AXIS2_SCOPE); if(scope_param) { param_value = axutil_param_get_value(scope_param, env); } if(param_value && (0 == axutil_strcmp(AXIS2_APPLICATION_SCOPE, param_value))) { return AXIS2_SUCCESS; } impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS); if(!impl_info_param) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); return AXIS2_FAILURE; } dll_desc = axutil_param_get_value(impl_info_param, env); return axutil_class_loader_delete_dll(env, dll_desc); (void)msg_recv; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_engine_resume_send( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_op_ctx_t *op_ctx = NULL; axutil_array_list_t *phases = NULL; axis2_status_t status = AXIS2_FAILURE; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_send"); /* Invoke the phases */ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); if(op) { phases = axis2_op_get_out_flow(op, env); } } axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); /* Invoking transport sender */ if(!axis2_msg_ctx_is_paused(msg_ctx, env)) { /* Write the message to the wire */ axis2_transport_out_desc_t *transport_out = NULL; axis2_transport_sender_t *sender = NULL; transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, env); if(transport_out) { sender = axis2_transport_out_desc_get_sender(transport_out, env); if(sender) { status = AXIS2_TRANSPORT_SENDER_INVOKE(sender, env, msg_ctx); } } } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_resume_send"); return status; }
/** * Private function implementations */ static axis2_char_t * wsf_xml_msg_recv_get_method_name( axis2_msg_ctx_t * msg_ctx, const axutil_env_t * env) { axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op = NULL; const axutil_qname_t *qname = NULL; axis2_char_t *name = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if (!op_ctx) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] Operation Context is not found"); return NULL; } op = axis2_op_ctx_get_op(op_ctx, env); if (!op) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] Operation is not found"); return NULL; } qname = axis2_op_get_qname(op, env); if (!qname) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] Operation QName is not found"); return NULL; } name = axutil_qname_get_localpart(qname, env); return name; }
axis2_status_t AXIS2_CALL wsf_xml_msg_recv_invoke_business_logic_sync( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * in_msg_ctx, axis2_msg_ctx_t * out_msg_ctx) { axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op_desc = NULL; axiom_namespace_t *env_ns = NULL; int soap_version = AXIOM_SOAP12; axis2_status_t status = AXIS2_SUCCESS; axis2_bool_t skel_invoked = AXIS2_FALSE; const axis2_char_t *style = NULL; axis2_char_t *local_name = NULL; axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; axis2_char_t *operation_name = NULL; char *classname = NULL; axutil_property_t *svc_info_prop = NULL; axutil_property_t *req_info_prop = NULL; wsf_svc_info_t *svc_info = NULL; wsf_request_info_t *req_info = NULL; /** store in_msg_ctx envelope */ axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; axiom_node_t *in_body_node = NULL; /* store out_msg_ctx envelope */ axiom_soap_envelope_t *default_envelope = NULL; axiom_soap_body_t *out_body = NULL; axiom_soap_header_t *out_header = NULL; axiom_soap_fault_t *out_soap_fault = NULL; axiom_node_t *result_node = NULL; axiom_node_t *out_body_content_node = NULL; axiom_element_t *out_body_content_element = NULL; axiom_node_t *out_node = NULL; zval **output_headers_zval = NULL; TSRMLS_FETCH(); AXIS2_PARAM_CHECK(env->error, in_msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, out_msg_ctx, AXIS2_FAILURE); op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env); op_desc = axis2_op_ctx_get_op(op_ctx, env); style = axis2_op_get_style(op_desc, env); envelope = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); in_body_node = axiom_soap_body_get_base_node(body, env); if (0 == axutil_strcmp(AXIS2_STYLE_DOC, style)) { local_name = wsf_xml_msg_recv_get_method_name(in_msg_ctx, env); if (!local_name) { return AXIS2_FAILURE; } } else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style)) { axiom_node_t *op_node = NULL; axiom_element_t *op_element = NULL; op_node = axiom_node_get_first_child(in_body_node, env); if (!op_node) { return AXIS2_FAILURE; } op_element = axiom_node_get_data_element(op_node, env); if (!op_element) { return AXIS2_FAILURE; } local_name = axiom_element_get_localname(op_element, env); if (!local_name) { return AXIS2_FAILURE; } } /** set soap version and soap namespace to local variables */ if (in_msg_ctx && axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env)) { soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */ soap_version = AXIOM_SOAP11; } svc_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_SVC_INFO); if (svc_info_prop) { svc_info = (wsf_svc_info_t *) axutil_property_get_value(svc_info_prop, env); if (svc_info) { operation_name = axutil_hash_get(svc_info->ops_to_functions, local_name, AXIS2_HASH_KEY_STRING); if (!operation_name) { return AXIS2_FAILURE; } } else { return AXIS2_FAILURE; } if (svc_info->ops_to_classes) { classname = axutil_hash_get(svc_info->ops_to_classes, local_name, AXIS2_HASH_KEY_STRING); } } req_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_REQ_INFO); if (req_info_prop) { req_info = (wsf_request_info_t *) axutil_property_get_value(req_info_prop, env); if (axis2_msg_ctx_get_doing_rest(in_msg_ctx, env)) { axis2_op_t *op = NULL; axiom_node_t *body_child_node = NULL; axiom_element_t *body_child = NULL; int i = 0; body_child_node = axiom_node_get_first_child(in_body_node, env); if (!body_child_node) { op = axis2_msg_ctx_get_op(in_msg_ctx, env); if (op) { body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname(op, env), &body_child_node); axiom_soap_body_add_child(body, env, body_child_node); } } if (req_info->param_keys && req_info->param_values) { int i = 0; for (i = 0; i < axutil_array_list_size(req_info->param_keys, env); i++) { axiom_node_t *node = NULL; axiom_element_t *element = NULL; axis2_char_t *param_key = NULL; axis2_char_t *param_value = NULL; param_key = axutil_array_list_get(req_info->param_keys, env, i); param_value = axutil_array_list_get(req_info->param_values, env, i); element = axiom_element_create(env, NULL, param_key, NULL, &node); axiom_element_set_text(element, env, param_value, node); axiom_node_add_child(body_child_node, env, node); AXIS2_FREE(env->allocator, param_key); AXIS2_FREE(env->allocator, param_value); } axutil_array_list_free(req_info->param_keys, env); axutil_array_list_free(req_info->param_values, env); } } } if (svc_info->ht_op_params) { zval **tmp; char *function_type = NULL; if (zend_hash_find(svc_info->ht_op_params, operation_name, strlen(operation_name) + 1, (void **) & tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) { function_type = Z_STRVAL_PP(tmp); if (strcmp(function_type, WSF_MIXED) == 0) { result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info, in_msg_ctx, out_msg_ctx, operation_name, classname, &output_headers_zval TSRMLS_CC); } else if (strcmp(function_type, WSF_WSMESSAGE) == 0) { result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name, in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC); } } } else { /* this is where the default value for opParam is set, If the wsdl option is set go for the MIXED mode by default */ if (svc_info->wsdl == NULL || svc_info->omit_wsdl) { result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name, in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC); } else { result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info, in_msg_ctx, out_msg_ctx, operation_name, classname, &output_headers_zval TSRMLS_CC); } } if (!result_node) { status = AXIS2_ERROR_GET_STATUS_CODE(env->error); } else { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "Response node is not null"); } if (result_node) { if (0 == axutil_strcmp(style, AXIS2_STYLE_RPC)) { axiom_namespace_t *ns = NULL; axis2_char_t *response_name = NULL; response_name = axutil_stracat(env, local_name, "Response"); ns = axiom_namespace_create(env, "http://soapenc/", "res"); if (!ns) { return AXIS2_FAILURE; } out_body_content_element = axiom_element_create(env, NULL, response_name, ns, &out_body_content_node); axiom_node_add_child(out_body_content_node, env, result_node); } else { out_body_content_node = result_node; } } if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env)) { /* service implementation has set the envelope, useful when setting a SOAP fault. No need to further process */ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "soap fault is set"); return AXIS2_SUCCESS; } /* create the soap envelope here */ env_ns = axiom_namespace_create(env, soap_ns, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX); if (!env_ns) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] error seting the namespces for the " AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX); return AXIS2_FAILURE; } default_envelope = axiom_soap_envelope_create(env, env_ns); if (!default_envelope) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap envelope"); return AXIS2_FAILURE; } out_body = axiom_soap_body_create_with_parent(env, default_envelope); if (!out_body) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in creating the response soap body"); return AXIS2_FAILURE; } out_header = axiom_soap_header_create_with_parent(env, default_envelope); if (!out_header) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap headers"); return AXIS2_FAILURE; } if (output_headers_zval) { axiom_node_t *header_base_node = NULL; HashPosition pos; zval **param; char *header_str; axiom_node_t *header_node; for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(output_headers_zval), &pos); zend_hash_get_current_data_ex(Z_ARRVAL_PP(output_headers_zval), (void **) & param, &pos) == SUCCESS; zend_hash_move_forward_ex(Z_ARRVAL_PP(output_headers_zval), &pos)) { if (Z_TYPE_PP(param) == IS_STRING) { header_base_node = axiom_soap_header_get_base_node(out_header, env); if (header_base_node) { header_str = Z_STRVAL_PP(param); header_node = wsf_util_deserialize_buffer(env, header_str); axiom_node_add_child(header_base_node, env, header_node); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap headers node"); return AXIS2_FAILURE; } } } } out_node = axiom_soap_body_get_base_node(out_body, env); if (!out_node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap body node"); return AXIS2_FAILURE; } if (status != AXIS2_SUCCESS) { /* something went wrong, set a SOAP Fault */ axis2_char_t *fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; axis2_char_t *fault_reason_str = NULL; axis2_char_t *err_msg = NULL; if (!skel_invoked) fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; ; err_msg = (char *) AXIS2_ERROR_GET_MESSAGE(env->error); if (err_msg) { fault_reason_str = err_msg; } else { fault_reason_str = "Error occurred while processing SOAP message"; } out_soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str, fault_reason_str, soap_version); } if (out_body_content_node) { axiom_node_add_child(out_node, env, out_body_content_node); status = axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope); } else if (out_soap_fault) { axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope); status = AXIS2_FAILURE; /* if there is a failure we have to return a failure code */ } else { /* we should free the memory as the envelope is not used, one way case */ axiom_soap_envelope_free(default_envelope, env); default_envelope = NULL; } return AXIS2_SUCCESS; }
/** * Create a new create_seq_msg * @param env * @param application_rm_msg * @param internal_seq_id * @param acks_to * @param seq_prop_mgr * @return sandesha2_msg_ctx_t */ sandesha2_msg_ctx_t *AXIS2_CALL sandesha2_msg_creator_create_create_seq_msg( const axutil_env_t *env, sandesha2_msg_ctx_t *application_rm_msg, axis2_char_t *internal_seq_id, axis2_char_t *acks_to, sandesha2_seq_property_mgr_t *seq_prop_mgr) { axis2_msg_ctx_t *application_msg_ctx = NULL; axis2_msg_ctx_t *create_seq_msg_ctx = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_op_t *app_msg_op_desc = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_char_t *create_seq_msg_id = NULL; axis2_char_t *rm_version = NULL; axis2_char_t *rm_ns_value = NULL; axis2_char_t *addressing_ns_value = NULL; axis2_char_t *anonymous_uri = NULL; axis2_char_t *temp_value = NULL; axis2_char_t *temp_action = NULL; axutil_string_t *temp_soap_action = NULL; axis2_endpoint_ref_t *to_epr = NULL; axis2_endpoint_ref_t *temp_to = NULL; axis2_endpoint_ref_t *acks_to_epr = NULL; axis2_endpoint_ref_t *temp_reply_to = NULL; sandesha2_create_seq_t *create_seq_part = NULL; sandesha2_seq_property_bean_t *reply_to_bean = NULL; sandesha2_seq_property_bean_t *to_bean = NULL; sandesha2_msg_ctx_t *create_seq_rm_msg = NULL; sandesha2_address_t *temp_address = NULL; sandesha2_acks_to_t *temp_acks_to = NULL; axutil_property_t *property = NULL; const axis2_char_t *reply_to_address = NULL; application_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(application_rm_msg, env); if(!application_msg_ctx) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_APPLICATION_MSG_NULL, AXIS2_FAILURE); return NULL; } conf_ctx = axis2_msg_ctx_get_conf_ctx(application_msg_ctx, env); if(!conf_ctx) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE); return NULL; } /* Creating by copying common contents. */ create_seq_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, application_rm_msg); sandesha2_msg_creator_init_creation(env, application_msg_ctx, create_seq_msg_ctx); create_seq_msg_id = axutil_uuid_gen(env); axis2_msg_ctx_set_message_id(create_seq_msg_ctx, env, create_seq_msg_id); AXIS2_FREE(env->allocator, create_seq_msg_id); app_msg_op_desc = axis2_msg_ctx_get_op(application_msg_ctx, env); property = axis2_msg_ctx_get_property(application_msg_ctx, env, AXIS2_TARGET_EPR); if(property) { temp_to = axutil_property_get_value(property, env); to_epr = axis2_endpoint_ref_create(env, axis2_endpoint_ref_get_address(temp_to, env)); } if (!to_epr) { temp_to = sandesha2_msg_ctx_get_to(application_rm_msg, env); if (temp_to) { to_epr = axis2_endpoint_ref_create(env, axis2_endpoint_ref_get_address(temp_to, env)); } } if (to_epr) { axis2_msg_ctx_set_to(create_seq_msg_ctx, env, to_epr); to_epr = NULL; } temp_reply_to = sandesha2_msg_ctx_get_reply_to(application_rm_msg, env); if(temp_reply_to) { axis2_endpoint_ref_t *reply_to_epr = NULL; reply_to_address = axis2_endpoint_ref_get_address(temp_reply_to, env); reply_to_epr = axis2_endpoint_ref_create(env, reply_to_address); if(reply_to_epr) { axis2_msg_ctx_set_reply_to(create_seq_msg_ctx, env, reply_to_epr); } } create_seq_rm_msg = sandesha2_msg_ctx_create(env, create_seq_msg_ctx); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "create_seq_internal_seq_id:%s", internal_seq_id); rm_version = sandesha2_utils_get_rm_version(env, application_msg_ctx); if(!rm_version) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_RM_VERSION_OF_GIVEN_MSG, AXIS2_FAILURE); return NULL; } rm_ns_value = sandesha2_spec_specific_consts_get_rm_ns_val(env, rm_version); addressing_ns_value = sandesha2_utils_get_seq_property(env, internal_seq_id, SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, seq_prop_mgr); create_seq_part = sandesha2_create_seq_create(env, addressing_ns_value, rm_ns_value); if(!create_seq_part) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] creating create sequence message failed"); return NULL; } /* Adding sequence offer if present */ op_ctx = axis2_msg_ctx_get_op_ctx(application_msg_ctx, env); if(op_ctx) { axis2_op_t *operation = NULL; int mep = -1; axis2_char_t *offered_seq_id = NULL; /*axutil_property_t *property = NULL; axis2_ctx_t *ctx = NULL; ctx = axis2_msg_ctx_get_base(application_msg_ctx, env); property = axis2_ctx_get_property(ctx, env, SANDESHA2_CLIENT_OFFERED_SEQ_ID); if(property) { offered_seq_id = axutil_property_get_value(property, env); }*/ operation = axis2_op_ctx_get_op(op_ctx, env); mep = axis2_op_get_axis_specific_mep_const(operation, env); if(mep == AXIS2_MEP_CONSTANT_OUT_IN) { offered_seq_id = axutil_uuid_gen(env); } /*if(offered_seq_id && 0 != axutil_strcmp("", offered_seq_id))*/ if(offered_seq_id) { sandesha2_seq_offer_t *offer_part = NULL; sandesha2_identifier_t *identifier = NULL; sandesha2_endpoint_t *endpoint = NULL; offer_part = sandesha2_seq_offer_create(env, rm_ns_value, addressing_ns_value); identifier = sandesha2_identifier_create(env, rm_ns_value); sandesha2_identifier_set_identifier(identifier, env, offered_seq_id); sandesha2_seq_offer_set_identifier(offer_part, env, identifier); if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, rm_version)) { axis2_endpoint_ref_t *reply_to_epr = NULL; sandesha2_address_t *address = NULL; reply_to_epr = axis2_endpoint_ref_create(env, reply_to_address); address = sandesha2_address_create(env, addressing_ns_value, reply_to_epr); endpoint = sandesha2_endpoint_create(env, address, rm_ns_value, addressing_ns_value); sandesha2_seq_offer_set_endpoint(offer_part, env, endpoint); } sandesha2_create_seq_set_seq_offer(create_seq_part, env, offer_part); } } reply_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR); to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_seq_id, SANDESHA2_SEQ_PROP_TO_EPR); if (to_bean) { temp_value = sandesha2_seq_property_bean_get_value(to_bean, env); if (temp_value) { to_epr = axis2_endpoint_ref_create(env, temp_value); } sandesha2_seq_property_bean_free(to_bean, env); } anonymous_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addressing_ns_value); if(reply_to_bean) { axis2_endpoint_ref_t *reply_to_epr = NULL; temp_value = sandesha2_seq_property_bean_get_value(reply_to_bean, env); if(temp_value) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to:%s", temp_value); reply_to_epr = axis2_endpoint_ref_create(env, temp_value); acks_to = axutil_strdup(env, temp_value); } if(reply_to_epr) { sandesha2_msg_ctx_set_reply_to(create_seq_rm_msg, env, reply_to_epr); } sandesha2_seq_property_bean_free(reply_to_bean, env); } if(!acks_to || !axutil_strcmp("", acks_to)) { acks_to = axutil_strdup(env, anonymous_uri); } acks_to_epr = axis2_endpoint_ref_create(env, acks_to); temp_to = sandesha2_msg_ctx_get_to(create_seq_rm_msg, env); if(!temp_to && to_epr) { sandesha2_msg_ctx_set_to(create_seq_rm_msg, env, to_epr); } else { axis2_endpoint_ref_free(to_epr, env); } temp_address = sandesha2_address_create(env, addressing_ns_value, acks_to_epr); temp_acks_to = sandesha2_acks_to_create(env, temp_address, rm_ns_value, addressing_ns_value); if(addressing_ns_value) { AXIS2_FREE(env->allocator, addressing_ns_value); } sandesha2_create_seq_set_acks_to(create_seq_part, env, temp_acks_to); sandesha2_msg_ctx_set_create_seq(create_seq_rm_msg, env, create_seq_part); sandesha2_msg_ctx_add_soap_envelope(create_seq_rm_msg, env); temp_action = sandesha2_spec_specific_consts_get_create_seq_action(env, rm_version); sandesha2_msg_ctx_set_wsa_action(create_seq_rm_msg, env, temp_action); temp_soap_action = axutil_string_create(env, temp_action); if(temp_soap_action) { sandesha2_msg_ctx_set_soap_action(create_seq_rm_msg, env, temp_soap_action); axutil_string_free(temp_soap_action, env); } /*sandesha2_msg_creator_finalize_creation(env, application_msg_ctx, create_seq_msg_ctx);*/ return create_seq_rm_msg; }
static axis2_status_t AXIS2_CALL axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, axis2_msg_ctx_t * new_msg_ctx) { axis2_svc_skeleton_t *svc_obj = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op_desc = NULL; const axis2_char_t *style = NULL; axiom_node_t *om_node = NULL; axiom_element_t *om_element = NULL; axis2_char_t *local_name = NULL; axiom_node_t *result_node = NULL; axiom_node_t *body_content_node = NULL; axiom_element_t *body_content_element = NULL; axiom_soap_envelope_t *default_envelope = NULL; axiom_soap_body_t *out_body = NULL; axiom_soap_header_t *out_header = NULL; axiom_soap_fault_t *soap_fault = NULL; axiom_node_t *out_node = NULL; axis2_status_t status = AXIS2_SUCCESS; axis2_bool_t skel_invoked = AXIS2_FALSE; const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; int soap_version = AXIOM_SOAP12; axiom_namespace_t *env_ns = NULL; axiom_node_t *fault_node = NULL; axiom_soap_fault_detail_t *fault_detail; axis2_bool_t is_fault = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); /* get the implementation class for the Web Service */ svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx); if(!svc_obj) { const axis2_char_t *svc_name = NULL; axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(svc) { svc_name = axis2_svc_get_name(svc, env); } else { svc_name = "unknown"; } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Impl object for service '%s' not set in message receiver. %d :: %s", svc_name, env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); status = AXIS2_FAILURE; } else { op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); op_desc = axis2_op_ctx_get_op(op_ctx, env); style = axis2_op_get_style(op_desc, env); if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style)) { axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); om_node = axiom_soap_body_get_base_node(body, env); om_element = axiom_node_get_data_element(om_node, env); om_node = axiom_node_get_first_element(om_node, env); } else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style)) { axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; axiom_node_t *op_node = NULL; axiom_element_t *op_element = NULL; envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); op_node = axiom_soap_body_get_base_node(body, env); op_element = axiom_node_get_data_element(op_node, env); if(op_element) { local_name = axiom_element_get_localname(op_element, env); if(local_name) { axutil_array_list_t *function_arr = NULL; int i = 0; int size = 0; axis2_bool_t matches = AXIS2_FALSE; function_arr = svc_obj->func_array; if(function_arr) { size = axutil_array_list_size(function_arr, env); } for(i = 0; i < size; i++) { axis2_char_t *function_name = NULL; function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i); if(!axutil_strcmp(function_name, local_name)) { matches = AXIS2_TRUE; } } if(matches) { om_node = axiom_node_get_first_child(op_node, env); om_element = axiom_node_get_data_element(om_node, env); } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE); status = AXIS2_FAILURE; } if(status == AXIS2_SUCCESS) { skel_invoked = AXIS2_TRUE; result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx); } if(result_node) { if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC)) { axiom_namespace_t *ns = NULL; axis2_char_t *res_name = NULL; res_name = axutil_stracat(env, local_name, "Response"); ns = axiom_namespace_create(env, "http://soapenc/", "res"); if(!ns) { status = AXIS2_FAILURE; } else { body_content_element = axiom_element_create(env, NULL, res_name, ns, &body_content_node); axiom_node_add_child(body_content_node, env, result_node); } } else { body_content_node = result_node; } } else { axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env); if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)) { status = AXIS2_ERROR_GET_STATUS_CODE(env->error); if(status == AXIS2_SUCCESS) { axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); } else { axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( new_msg_ctx, env)); } /* The new_msg_ctx is passed to the service. The status code must * be taken from here and set to the old message context which is * used by the worker when the request processing fails. */ if(svc_obj->ops->on_fault) { fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); } is_fault = AXIS2_TRUE; } else { /* If we have a in only message result node is NULL. We create fault only if * an error is set */ status = AXIS2_ERROR_GET_STATUS_CODE(env->error); if(status == AXIS2_SUCCESS) { axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); } else { axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( new_msg_ctx, env)); if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) || (!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))) { /* The new_msg_ctx is passed to the service. The status code must * be taken from here and set to the old message context which is * used by the worker when the request processing fails. */ if(svc_obj->ops->on_fault) { fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); } is_fault = AXIS2_TRUE; } } } } } if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */ soap_version = AXIOM_SOAP11; } if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env)) { /* service implementation has set the envelope, useful when setting a SOAP fault. No need to further process */ return AXIS2_SUCCESS; } /* create the soap envelope here */ env_ns = axiom_namespace_create(env, soap_ns, "soapenv"); if(!env_ns) { return AXIS2_FAILURE; } default_envelope = axiom_soap_envelope_create(env, env_ns); axiom_namespace_free(env_ns, env); if(!default_envelope) { return AXIS2_FAILURE; } out_header = axiom_soap_header_create_with_parent(env, default_envelope); if(!out_header) { return AXIS2_FAILURE; } out_body = axiom_soap_body_create_with_parent(env, default_envelope); if(!out_body) { return AXIS2_FAILURE; } out_node = axiom_soap_body_get_base_node(out_body, env); if(!out_node) { return AXIS2_FAILURE; } if(status != AXIS2_SUCCESS || is_fault) { /* something went wrong. set a SOAP Fault */ const axis2_char_t *fault_value_str = "soapenv:Sender"; const axis2_char_t *fault_reason_str = NULL; const axis2_char_t *err_msg = NULL; if(!skel_invoked) { if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP11_FAULT_CODE_RECEIVER; } else { fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; } } err_msg = AXIS2_ERROR_GET_MESSAGE(env->error); if (err_msg && axutil_strcmp(err_msg, "")) { if(!axutil_strcmp(err_msg, "No Error")) { fault_reason_str = "An error has occurred, but could not determine exact details"; } else { fault_reason_str = err_msg; } } else { fault_reason_str = "An error has occurred, but could not determine exact details"; } soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str, fault_reason_str, soap_version); if (fault_node) { axiom_node_t *fault_detail_node = NULL; axis2_char_t *om_str = NULL; fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault); fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env); om_str = axiom_node_to_string(fault_detail_node, env); if (om_str) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str); AXIS2_FREE(env->allocator, om_str); } axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node); } } if (body_content_node) { axiom_node_add_child(out_node, env, body_content_node); status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); } else if (soap_fault) { axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); status = AXIS2_SUCCESS; } else { /* we should free the memory as the envelope is not used, one way case */ axiom_soap_envelope_free(default_envelope, env); default_envelope = NULL; } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); return status; }
static axis2_status_t AXIS2_CALL sandesha2_terminate_seq_msg_processor_add_terminate_seq_res( 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) { axis2_msg_ctx_t *msg_ctx = NULL; axis2_msg_ctx_t *out_msg_ctx = NULL; sandesha2_msg_ctx_t *out_rm_msg = NULL; sandesha2_msg_ctx_t *ack_rm_msg = NULL; sandesha2_seq_ack_t *seq_ack = NULL; axutil_property_t *property = NULL; axis2_engine_t *engine = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_endpoint_ref_t *to_epr = NULL; /*axis2_transport_out_desc_t *orig_trans_out = NULL; axis2_transport_out_desc_t *trans_out = NULL; sandesha2_sender_bean_t *term_res_bean = NULL; axis2_char_t *key = NULL; sandesha2_sender_mgr_t *retrans_mgr = NULL;*/ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_terminate_seq_msg_processor_add_terminate_seq_res"); msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); out_msg_ctx = sandesha2_utils_create_out_msg_ctx(env, msg_ctx); out_rm_msg = sandesha2_msg_creator_create_terminate_seq_res_msg(env, rm_msg_ctx, out_msg_ctx, seq_prop_mgr); if(!out_rm_msg) { return AXIS2_FAILURE; } ack_rm_msg = sandesha2_ack_mgr_generate_ack_msg(env, rm_msg_ctx, seq_id, seq_prop_mgr); if(ack_rm_msg) { seq_ack = sandesha2_msg_ctx_get_seq_ack(ack_rm_msg, env); sandesha2_msg_ctx_set_seq_ack(out_rm_msg, env, seq_ack); } sandesha2_msg_ctx_add_soap_envelope(out_rm_msg, env); sandesha2_msg_ctx_set_flow(out_rm_msg, env, AXIS2_OUT_FLOW); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(out_msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, property); /* test code */ /* to_epr = axis2_msg_ctx_get_to(out_msg_ctx, env); if(to_epr && !sandesha2_utils_is_anon_uri(env, axis2_endpoint_ref_get_address(to_epr, env))) { axis2_msg_ctx_t *tsr_msg_ctx = axis2_core_utils_create_out_msg_ctx(env, msg_ctx); orig_trans_out = axis2_msg_ctx_get_transport_out_desc(tsr_msg_ctx, env); property = axutil_property_create_with_args(env, 0, 0, 0, orig_trans_out); axis2_msg_ctx_set_property(tsr_msg_ctx, env, SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property); trans_out = sandesha2_utils_get_transport_out(env); axis2_msg_ctx_set_transport_out_desc(tsr_msg_ctx, env, trans_out); key = axutil_uuid_gen(env); term_res_bean = sandesha2_sender_bean_create(env); sandesha2_sender_bean_set_msg_ctx_ref_key(term_res_bean, env, key); property = axutil_property_create_with_args(env, 0, 0, 0, key); axis2_msg_ctx_set_property(tsr_msg_ctx, env, SANDESHA2_MESSAGE_STORE_KEY, property); sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, key, tsr_msg_ctx); */ /* TODO: refine the terminate delay */ /* sandesha2_sender_bean_set_time_to_send(term_res_bean, env, sandesha2_utils_get_current_time_in_millis(env) + SANDESHA2_TERMINATE_DELAY); sandesha2_sender_bean_set_msg_id(term_res_bean, env, (axis2_char_t *) axis2_msg_ctx_get_msg_id(tsr_msg_ctx, env)); sandesha2_sender_bean_set_send(term_res_bean, env, AXIS2_TRUE); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_QUALIFIED_FOR_SENDING, property); sandesha2_sender_bean_set_resend(term_res_bean, env, AXIS2_FALSE); retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(storage_mgr, env); sandesha2_sender_mgr_insert(retrans_mgr, env, term_res_bean); }*/ /* end test code */ engine = axis2_engine_create(env, axis2_msg_ctx_get_conf_ctx(msg_ctx, env)); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]axis2_engine_send"); axis2_engine_send(engine, env, out_msg_ctx); op_ctx = axis2_msg_ctx_get_op_ctx(out_msg_ctx, env); if(to_epr) { if(sandesha2_utils_is_anon_uri(env, axis2_endpoint_ref_get_address(to_epr, env))) { axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); } else { axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_FALSE); } } else { axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); } if(engine) { axis2_engine_free(engine, env); } if(out_rm_msg) { sandesha2_msg_ctx_free(out_rm_msg, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_terminate_seq_msg_processor_add_terminate_seq_res"); return AXIS2_SUCCESS; }
static axis2_status_t AXIS2_CALL sandesha2_create_seq_res_msg_processor_process_in_msg ( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { axis2_msg_ctx_t *msg_ctx = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_storage_mgr_t *storage_mgr = NULL; sandesha2_create_seq_res_t *csr_part = NULL; axis2_char_t *outgoing_sequence_id = NULL; axis2_relates_to_t *relates_to = NULL; axis2_char_t *create_seq_msg_id = NULL; sandesha2_sender_mgr_t *sender_mgr = NULL; sandesha2_create_seq_mgr_t *create_seq_mgr = NULL; sandesha2_create_seq_bean_t *create_seq_bean = NULL; axis2_char_t *outgoing_internal_sequence_id = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_seq_property_bean_t *outgoing_sequence_bean = NULL; sandesha2_seq_property_bean_t *outgoing_internal_sequence_bean = NULL; sandesha2_accept_t *accept = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_bool_t polling_mode = AXIS2_FALSE; axis2_char_t *dbname = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_create_seq_res_msg_processor_process_in_msg"); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname); if(!storage_mgr) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager."); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER, AXIS2_FAILURE); return AXIS2_FAILURE; } csr_part = sandesha2_msg_ctx_get_create_seq_res(rm_msg_ctx, env); if(!csr_part) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Create Sequence Response part is null"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } outgoing_sequence_id = sandesha2_identifier_get_identifier( sandesha2_create_seq_res_get_identifier(csr_part, env), env); if(!outgoing_sequence_id) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Out going sequence id is null"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_SEQ_ID, AXIS2_FAILURE); if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); if(!relates_to) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Invalid create sequence message. relates_to part is not available"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_RELATES_TO, AXIS2_FAILURE); if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } create_seq_msg_id = (axis2_char_t *) axis2_relates_to_get_value(relates_to, env); seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); create_seq_mgr = sandesha2_permanent_create_seq_mgr_create(env, dbname); sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname); create_seq_bean = sandesha2_create_seq_mgr_retrieve(create_seq_mgr, env, create_seq_msg_id); if(!create_seq_bean) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Create Sequence entry not found"); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } outgoing_internal_sequence_id = axutil_strdup(env, sandesha2_create_seq_bean_get_internal_sequence_id( create_seq_bean, env)); if(!outgoing_internal_sequence_id) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Internal sequence id is not set"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_SEQ_ID, AXIS2_FAILURE); sandesha2_create_seq_bean_free(create_seq_bean, env); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } sandesha2_create_seq_bean_set_outgoing_sequence_id(create_seq_bean, env, outgoing_sequence_id); sandesha2_create_seq_mgr_update(create_seq_mgr, env, create_seq_bean); sandesha2_create_seq_bean_free(create_seq_bean, env); outgoing_sequence_bean = sandesha2_seq_property_bean_create_with_data(env, outgoing_internal_sequence_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_SEQUENCE_ID, outgoing_sequence_id); if(outgoing_sequence_bean) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Inserting outgoing_sequence_bean with outgoing_sequence_id :%s and "\ "outgoing internal_sequence_id :%s", outgoing_sequence_id, outgoing_internal_sequence_id); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, outgoing_sequence_bean); sandesha2_seq_property_bean_free(outgoing_sequence_bean, env); } outgoing_internal_sequence_bean = sandesha2_seq_property_bean_create_with_data(env, outgoing_sequence_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_INTERNAL_SEQUENCE_ID, outgoing_internal_sequence_id); if(outgoing_internal_sequence_bean) { sandesha2_sender_bean_t *find_sender_bean = NULL; sandesha2_sender_bean_t *sender_bean = NULL; find_sender_bean = sandesha2_sender_bean_create(env); sandesha2_sender_bean_set_msg_type(find_sender_bean, env, SANDESHA2_MSG_TYPE_CREATE_SEQ); sandesha2_sender_bean_set_internal_seq_id(find_sender_bean, env, outgoing_internal_sequence_id); sandesha2_sender_bean_set_send(find_sender_bean, env, AXIS2_TRUE); sender_bean = sandesha2_sender_mgr_find_unique(sender_mgr, env, find_sender_bean); if(sender_bean) { axis2_char_t *msg_id = NULL; msg_id = sandesha2_sender_bean_get_msg_id(sender_bean, env); sandesha2_sender_mgr_remove(sender_mgr, env, msg_id); sandesha2_sender_bean_free(sender_bean, env); } sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, outgoing_internal_sequence_bean); sandesha2_seq_property_bean_free(outgoing_internal_sequence_bean, env); } accept = sandesha2_create_seq_res_get_accept(csr_part, env); if(accept) { /*sandesha2_seq_property_bean_t *special_int_seq_bean = NULL;*/ sandesha2_seq_property_bean_t *offerd_seq_bean = NULL; axis2_char_t *incoming_sequence_id = NULL; axis2_endpoint_ref_t *acks_to_epr = NULL; axis2_endpoint_ref_t *to_epr = NULL; sandesha2_seq_property_bean_t *acks_to_bean = NULL; sandesha2_next_msg_bean_t *next_bean = NULL; sandesha2_next_msg_mgr_t *next_msg_mgr = NULL; sandesha2_seq_property_bean_t *rcvd_msg_bean = NULL; sandesha2_seq_property_bean_t *msgs_bean = NULL; sandesha2_seq_property_bean_t *addr_ver_bean = NULL; axis2_char_t *rm_spec_ver = NULL; axis2_char_t *addr_ns_val = NULL; axis2_char_t *new_msg_store_key = NULL; sandesha2_seq_property_bean_t *to_seq_bean = NULL; sandesha2_msg_ctx_t *create_seq_rm_msg = NULL; axis2_msg_ctx_t *create_seq_msg = NULL; axis2_char_t *acks_to = NULL; /* axis2_char_t *reply_to_addr = NULL; */ next_msg_mgr = sandesha2_permanent_next_msg_mgr_create(env, dbname); offerd_seq_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, outgoing_internal_sequence_id, SANDESHA2_SEQ_PROP_OFFERED_SEQ); if(!offerd_seq_bean) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] No offered sequence entry. But an accept was received"); if(outgoing_internal_sequence_id) { AXIS2_FREE(env->allocator, outgoing_internal_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } incoming_sequence_id = axutil_strdup(env, sandesha2_seq_property_bean_get_value( offerd_seq_bean, env)); sandesha2_seq_property_bean_free(offerd_seq_bean, env); /*special_int_seq_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_SPECIAL_INTERNAL_SEQUENCE_ID, outgoing_internal_sequence_id); if(special_int_seq_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, special_int_seq_bean); sandesha2_seq_property_bean_free(special_int_seq_bean, env); }*/ acks_to_epr = sandesha2_address_get_epr(sandesha2_acks_to_get_address( sandesha2_accept_get_acks_to(accept, env), env), env); acks_to_bean = sandesha2_seq_property_bean_create(env); if(acks_to_bean) { sandesha2_seq_property_bean_set_name(acks_to_bean, env, SANDESHA2_SEQ_PROP_ACKS_TO_EPR); sandesha2_seq_property_bean_set_seq_id(acks_to_bean, env, incoming_sequence_id); if (acks_to_epr) { sandesha2_seq_property_bean_set_value(acks_to_bean, env, (axis2_char_t*)axis2_endpoint_ref_get_address(acks_to_epr, env)); } sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_bean); sandesha2_seq_property_bean_free(acks_to_bean, env); } rm_spec_ver = sandesha2_msg_ctx_get_rm_spec_ver(rm_msg_ctx, env); if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, rm_spec_ver)) { /*reply_to_addr = sandesha2_utils_get_seq_property(env, internal_sequence_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR, seq_prop_mgr); if(reply_to_addr) { polling_mode = sandesha2_utils_is_anon_uri(env, reply_to_addr); }*/ } acks_to = (axis2_char_t *) axis2_endpoint_ref_get_address(acks_to_epr, env); create_seq_rm_msg = sandesha2_msg_creator_create_create_seq_msg(env, rm_msg_ctx, outgoing_internal_sequence_id, acks_to, seq_prop_mgr); if(!create_seq_rm_msg) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]create_seq_rm_msg is NULL"); /*if(reply_to_addr) { AXIS2_FREE(env->allocator, reply_to_addr); }*/ if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(outgoing_internal_sequence_id) { AXIS2_FREE(env->allocator, outgoing_internal_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } sandesha2_msg_ctx_set_flow(create_seq_rm_msg, env, SANDESHA2_MSG_CTX_OUT_FLOW); create_seq_msg = sandesha2_msg_ctx_get_msg_ctx(create_seq_rm_msg, env); to_seq_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, outgoing_internal_sequence_id, SANDESHA2_SEQ_PROP_TO_EPR); if(to_seq_bean) { axis2_char_t *to_addr = sandesha2_seq_property_bean_get_value(to_seq_bean, env); to_epr = axis2_endpoint_ref_create(env, to_addr); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]to:%s", to_addr); sandesha2_seq_property_bean_free(to_seq_bean, env); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] to_seq_bean is NULL"); /*if(reply_to_addr) { AXIS2_FREE(env->allocator, reply_to_addr); }*/ if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(outgoing_internal_sequence_id) { AXIS2_FREE(env->allocator, outgoing_internal_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } if(create_seq_msg) { axis2_msg_ctx_free(create_seq_msg, env); } if(create_seq_rm_msg) { sandesha2_msg_ctx_free(create_seq_rm_msg, env); } return AXIS2_FAILURE; } axis2_msg_ctx_set_to(create_seq_msg, env, to_epr); axis2_msg_ctx_set_relates_to(create_seq_msg, env, NULL); new_msg_store_key = axutil_uuid_gen(env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]Storing msg_ctx with msg_id:%s", axis2_msg_ctx_get_msg_id(create_seq_msg, env)); sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, new_msg_store_key, create_seq_msg, AXIS2_TRUE); next_bean = sandesha2_next_msg_bean_create(env); sandesha2_next_msg_bean_set_seq_id(next_bean, env, incoming_sequence_id); sandesha2_next_msg_bean_set_internal_seq_id(next_bean, env, outgoing_internal_sequence_id); sandesha2_next_msg_bean_set_next_msg_no_to_process(next_bean, env, 1); sandesha2_next_msg_bean_set_ref_msg_key(next_bean, env, new_msg_store_key); sandesha2_next_msg_bean_set_polling_mode(next_bean, env, polling_mode); if(new_msg_store_key) { AXIS2_FREE(env->allocator, new_msg_store_key); } /* If polling_mode is true, starting the polling manager */ if(polling_mode) { /*sandesha2_polling_mgr_start(env, conf_ctx, storage_mgr, sender_mgr, create_seq_rm_msg, outgoing_internal_sequence_id, incoming_sequence_id, reply_to_addr);*/ } sandesha2_next_msg_mgr_insert(next_msg_mgr, env, next_bean); sandesha2_next_msg_bean_free(next_bean, env); rcvd_msg_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES, ""); if(rcvd_msg_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, rcvd_msg_bean); sandesha2_seq_property_bean_free(rcvd_msg_bean, env); } msgs_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_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); } addr_ns_val = sandesha2_msg_ctx_get_addr_ns_val(rm_msg_ctx, env); addr_ver_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, addr_ns_val); if(addr_ver_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, addr_ver_bean); sandesha2_seq_property_bean_free(addr_ver_bean, env); } if(create_seq_msg) { axis2_core_utils_reset_out_msg_ctx(env, create_seq_msg); axis2_msg_ctx_free(create_seq_msg, env); } /*if(reply_to_addr) { AXIS2_FREE(env->allocator, reply_to_addr); }*/ if(create_seq_rm_msg) { sandesha2_msg_ctx_free(create_seq_rm_msg, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } } /* End of if accept block */ sandesha2_seq_mgr_update_last_activated_time(env, outgoing_internal_sequence_id, seq_prop_mgr); op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); /* Pausing the flow here so that it won't go to a message receiver which is not set for this flow */ sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE); if(outgoing_internal_sequence_id) { AXIS2_FREE(env->allocator, outgoing_internal_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_create_seq_res_msg_processor_process_in_msg"); return AXIS2_SUCCESS; }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_StatisticsAdmin_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; axiom_soap_envelope_t *req_soap_env = NULL; axiom_soap_header_t *req_soap_header = NULL; axiom_soap_envelope_t *res_soap_env = NULL; axiom_soap_header_t *res_soap_header = NULL; axiom_node_t *ret_node = NULL; axiom_node_t *input_header = NULL; axiom_node_t *output_header = NULL; axiom_node_t *header_base_node = NULL; axis2_svc_skel_StatisticsAdmin_t *svc_skeleton_wrapper = NULL; adb_getMaxServiceResponseTimeResponse_t* ret_val1; adb_getMaxServiceResponseTime_t* input_val1; adb_getServiceRequestCountResponse_t* ret_val2; adb_getServiceRequestCount_t* input_val2; adb_getSystemResponseCountResponse_t* ret_val3; adb_getOperationResponseCountResponse_t* ret_val4; adb_getOperationResponseCount_t* input_val4; adb_getAvgOperationResponseTimeResponse_t* ret_val5; adb_getAvgOperationResponseTime_t* input_val5; adb_getOperationStatisticsResponse_t* ret_val6; adb_getOperationStatistics_t* input_val6; adb_getMinSystemResponseTimeResponse_t* ret_val7; adb_getSystemFaultCountResponse_t* ret_val8; adb_getMaxSystemResponseTimeResponse_t* ret_val9; adb_getServiceFaultCountResponse_t* ret_val10; adb_getServiceFaultCount_t* input_val10; adb_getMinServiceResponseTimeResponse_t* ret_val11; adb_getMinServiceResponseTime_t* input_val11; adb_getMaxOperationResponseTimeResponse_t* ret_val12; adb_getMaxOperationResponseTime_t* input_val12; adb_getServiceStatisticsResponse_t* ret_val13; adb_getServiceStatistics_t* input_val13; adb_getOperationFaultCountResponse_t* ret_val14; adb_getOperationFaultCount_t* input_val14; adb_getAvgServiceResponseTimeResponse_t* ret_val15; adb_getAvgServiceResponseTime_t* input_val15; adb_getServiceResponseCountResponse_t* ret_val16; adb_getServiceResponseCount_t* input_val16; adb_getSystemRequestCountResponse_t* ret_val17; adb_getMinOperationResponseTimeResponse_t* ret_val18; adb_getMinOperationResponseTime_t* input_val18; adb_getAvgSystemResponseTimeResponse_t* ret_val19; adb_getSystemStatisticsResponse_t* ret_val20; adb_getOperationRequestCountResponse_t* ret_val21; adb_getOperationRequestCount_t* input_val21; svc_skeleton_wrapper = (axis2_svc_skel_StatisticsAdmin_t*)svc_skeleton; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "getMaxServiceResponseTime") == 0 ) { input_val1 = adb_getMaxServiceResponseTime_create( env); if( AXIS2_FAILURE == adb_getMaxServiceResponseTime_deserialize(input_val1, env, &content_node, NULL, AXIS2_FALSE)) { adb_getMaxServiceResponseTime_free(input_val1, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getMaxServiceResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val1 = axis2_skel_StatisticsAdmin_getMaxServiceResponseTime(env, msg_ctx,input_val1); if ( NULL == ret_val1 ) { adb_getMaxServiceResponseTime_free(input_val1, env); return NULL; } ret_node = adb_getMaxServiceResponseTimeResponse_serialize(ret_val1, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMaxServiceResponseTimeResponse_free(ret_val1, env); adb_getMaxServiceResponseTime_free(input_val1, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getServiceRequestCount") == 0 ) { input_val2 = adb_getServiceRequestCount_create( env); if( AXIS2_FAILURE == adb_getServiceRequestCount_deserialize(input_val2, env, &content_node, NULL, AXIS2_FALSE)) { adb_getServiceRequestCount_free(input_val2, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getServiceRequestCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val2 = axis2_skel_StatisticsAdmin_getServiceRequestCount(env, msg_ctx,input_val2); if ( NULL == ret_val2 ) { adb_getServiceRequestCount_free(input_val2, env); return NULL; } ret_node = adb_getServiceRequestCountResponse_serialize(ret_val2, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getServiceRequestCountResponse_free(ret_val2, env); adb_getServiceRequestCount_free(input_val2, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getSystemResponseCount") == 0 ) { ret_val3 = axis2_skel_StatisticsAdmin_getSystemResponseCount(env, msg_ctx); if ( NULL == ret_val3 ) { return NULL; } ret_node = adb_getSystemResponseCountResponse_serialize(ret_val3, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSystemResponseCountResponse_free(ret_val3, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getOperationResponseCount") == 0 ) { input_val4 = adb_getOperationResponseCount_create( env); if( AXIS2_FAILURE == adb_getOperationResponseCount_deserialize(input_val4, env, &content_node, NULL, AXIS2_FALSE)) { adb_getOperationResponseCount_free(input_val4, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getOperationResponseCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val4 = axis2_skel_StatisticsAdmin_getOperationResponseCount(env, msg_ctx,input_val4); if ( NULL == ret_val4 ) { adb_getOperationResponseCount_free(input_val4, env); return NULL; } ret_node = adb_getOperationResponseCountResponse_serialize(ret_val4, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getOperationResponseCountResponse_free(ret_val4, env); adb_getOperationResponseCount_free(input_val4, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getAvgOperationResponseTime") == 0 ) { input_val5 = adb_getAvgOperationResponseTime_create( env); if( AXIS2_FAILURE == adb_getAvgOperationResponseTime_deserialize(input_val5, env, &content_node, NULL, AXIS2_FALSE)) { adb_getAvgOperationResponseTime_free(input_val5, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getAvgOperationResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val5 = axis2_skel_StatisticsAdmin_getAvgOperationResponseTime(env, msg_ctx,input_val5); if ( NULL == ret_val5 ) { adb_getAvgOperationResponseTime_free(input_val5, env); return NULL; } ret_node = adb_getAvgOperationResponseTimeResponse_serialize(ret_val5, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getAvgOperationResponseTimeResponse_free(ret_val5, env); adb_getAvgOperationResponseTime_free(input_val5, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getOperationStatistics") == 0 ) { input_val6 = adb_getOperationStatistics_create( env); if( AXIS2_FAILURE == adb_getOperationStatistics_deserialize(input_val6, env, &content_node, NULL, AXIS2_FALSE)) { adb_getOperationStatistics_free(input_val6, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getOperationStatistics_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val6 = axis2_skel_StatisticsAdmin_getOperationStatistics(env, msg_ctx,input_val6); if ( NULL == ret_val6 ) { adb_getOperationStatistics_free(input_val6, env); return NULL; } ret_node = adb_getOperationStatisticsResponse_serialize(ret_val6, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getOperationStatisticsResponse_free(ret_val6, env); adb_getOperationStatistics_free(input_val6, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getMinSystemResponseTime") == 0 ) { ret_val7 = axis2_skel_StatisticsAdmin_getMinSystemResponseTime(env, msg_ctx); if ( NULL == ret_val7 ) { return NULL; } ret_node = adb_getMinSystemResponseTimeResponse_serialize(ret_val7, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMinSystemResponseTimeResponse_free(ret_val7, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getSystemFaultCount") == 0 ) { ret_val8 = axis2_skel_StatisticsAdmin_getSystemFaultCount(env, msg_ctx); if ( NULL == ret_val8 ) { return NULL; } ret_node = adb_getSystemFaultCountResponse_serialize(ret_val8, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSystemFaultCountResponse_free(ret_val8, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getMaxSystemResponseTime") == 0 ) { ret_val9 = axis2_skel_StatisticsAdmin_getMaxSystemResponseTime(env, msg_ctx); if ( NULL == ret_val9 ) { return NULL; } ret_node = adb_getMaxSystemResponseTimeResponse_serialize(ret_val9, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMaxSystemResponseTimeResponse_free(ret_val9, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getServiceFaultCount") == 0 ) { input_val10 = adb_getServiceFaultCount_create( env); if( AXIS2_FAILURE == adb_getServiceFaultCount_deserialize(input_val10, env, &content_node, NULL, AXIS2_FALSE)) { adb_getServiceFaultCount_free(input_val10, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getServiceFaultCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val10 = axis2_skel_StatisticsAdmin_getServiceFaultCount(env, msg_ctx,input_val10); if ( NULL == ret_val10 ) { adb_getServiceFaultCount_free(input_val10, env); return NULL; } ret_node = adb_getServiceFaultCountResponse_serialize(ret_val10, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getServiceFaultCountResponse_free(ret_val10, env); adb_getServiceFaultCount_free(input_val10, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getMinServiceResponseTime") == 0 ) { input_val11 = adb_getMinServiceResponseTime_create( env); if( AXIS2_FAILURE == adb_getMinServiceResponseTime_deserialize(input_val11, env, &content_node, NULL, AXIS2_FALSE)) { adb_getMinServiceResponseTime_free(input_val11, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getMinServiceResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val11 = axis2_skel_StatisticsAdmin_getMinServiceResponseTime(env, msg_ctx,input_val11); if ( NULL == ret_val11 ) { adb_getMinServiceResponseTime_free(input_val11, env); return NULL; } ret_node = adb_getMinServiceResponseTimeResponse_serialize(ret_val11, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMinServiceResponseTimeResponse_free(ret_val11, env); adb_getMinServiceResponseTime_free(input_val11, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getMaxOperationResponseTime") == 0 ) { input_val12 = adb_getMaxOperationResponseTime_create( env); if( AXIS2_FAILURE == adb_getMaxOperationResponseTime_deserialize(input_val12, env, &content_node, NULL, AXIS2_FALSE)) { adb_getMaxOperationResponseTime_free(input_val12, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getMaxOperationResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val12 = axis2_skel_StatisticsAdmin_getMaxOperationResponseTime(env, msg_ctx,input_val12); if ( NULL == ret_val12 ) { adb_getMaxOperationResponseTime_free(input_val12, env); return NULL; } ret_node = adb_getMaxOperationResponseTimeResponse_serialize(ret_val12, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMaxOperationResponseTimeResponse_free(ret_val12, env); adb_getMaxOperationResponseTime_free(input_val12, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getServiceStatistics") == 0 ) { input_val13 = adb_getServiceStatistics_create( env); if( AXIS2_FAILURE == adb_getServiceStatistics_deserialize(input_val13, env, &content_node, NULL, AXIS2_FALSE)) { adb_getServiceStatistics_free(input_val13, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getServiceStatistics_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val13 = axis2_skel_StatisticsAdmin_getServiceStatistics(env, msg_ctx,input_val13); if ( NULL == ret_val13 ) { adb_getServiceStatistics_free(input_val13, env); return NULL; } ret_node = adb_getServiceStatisticsResponse_serialize(ret_val13, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getServiceStatisticsResponse_free(ret_val13, env); adb_getServiceStatistics_free(input_val13, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getOperationFaultCount") == 0 ) { input_val14 = adb_getOperationFaultCount_create( env); if( AXIS2_FAILURE == adb_getOperationFaultCount_deserialize(input_val14, env, &content_node, NULL, AXIS2_FALSE)) { adb_getOperationFaultCount_free(input_val14, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getOperationFaultCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val14 = axis2_skel_StatisticsAdmin_getOperationFaultCount(env, msg_ctx,input_val14); if ( NULL == ret_val14 ) { adb_getOperationFaultCount_free(input_val14, env); return NULL; } ret_node = adb_getOperationFaultCountResponse_serialize(ret_val14, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getOperationFaultCountResponse_free(ret_val14, env); adb_getOperationFaultCount_free(input_val14, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getAvgServiceResponseTime") == 0 ) { input_val15 = adb_getAvgServiceResponseTime_create( env); if( AXIS2_FAILURE == adb_getAvgServiceResponseTime_deserialize(input_val15, env, &content_node, NULL, AXIS2_FALSE)) { adb_getAvgServiceResponseTime_free(input_val15, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getAvgServiceResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val15 = axis2_skel_StatisticsAdmin_getAvgServiceResponseTime(env, msg_ctx,input_val15); if ( NULL == ret_val15 ) { adb_getAvgServiceResponseTime_free(input_val15, env); return NULL; } ret_node = adb_getAvgServiceResponseTimeResponse_serialize(ret_val15, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getAvgServiceResponseTimeResponse_free(ret_val15, env); adb_getAvgServiceResponseTime_free(input_val15, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getServiceResponseCount") == 0 ) { input_val16 = adb_getServiceResponseCount_create( env); if( AXIS2_FAILURE == adb_getServiceResponseCount_deserialize(input_val16, env, &content_node, NULL, AXIS2_FALSE)) { adb_getServiceResponseCount_free(input_val16, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getServiceResponseCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val16 = axis2_skel_StatisticsAdmin_getServiceResponseCount(env, msg_ctx,input_val16); if ( NULL == ret_val16 ) { adb_getServiceResponseCount_free(input_val16, env); return NULL; } ret_node = adb_getServiceResponseCountResponse_serialize(ret_val16, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getServiceResponseCountResponse_free(ret_val16, env); adb_getServiceResponseCount_free(input_val16, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getSystemRequestCount") == 0 ) { ret_val17 = axis2_skel_StatisticsAdmin_getSystemRequestCount(env, msg_ctx); if ( NULL == ret_val17 ) { return NULL; } ret_node = adb_getSystemRequestCountResponse_serialize(ret_val17, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSystemRequestCountResponse_free(ret_val17, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getMinOperationResponseTime") == 0 ) { input_val18 = adb_getMinOperationResponseTime_create( env); if( AXIS2_FAILURE == adb_getMinOperationResponseTime_deserialize(input_val18, env, &content_node, NULL, AXIS2_FALSE)) { adb_getMinOperationResponseTime_free(input_val18, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getMinOperationResponseTime_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val18 = axis2_skel_StatisticsAdmin_getMinOperationResponseTime(env, msg_ctx,input_val18); if ( NULL == ret_val18 ) { adb_getMinOperationResponseTime_free(input_val18, env); return NULL; } ret_node = adb_getMinOperationResponseTimeResponse_serialize(ret_val18, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getMinOperationResponseTimeResponse_free(ret_val18, env); adb_getMinOperationResponseTime_free(input_val18, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getAvgSystemResponseTime") == 0 ) { ret_val19 = axis2_skel_StatisticsAdmin_getAvgSystemResponseTime(env, msg_ctx); if ( NULL == ret_val19 ) { return NULL; } ret_node = adb_getAvgSystemResponseTimeResponse_serialize(ret_val19, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getAvgSystemResponseTimeResponse_free(ret_val19, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getSystemStatistics") == 0 ) { ret_val20 = axis2_skel_StatisticsAdmin_getSystemStatistics(env, msg_ctx); if ( NULL == ret_val20 ) { return NULL; } ret_node = adb_getSystemStatisticsResponse_serialize(ret_val20, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSystemStatisticsResponse_free(ret_val20, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getOperationRequestCount") == 0 ) { input_val21 = adb_getOperationRequestCount_create( env); if( AXIS2_FAILURE == adb_getOperationRequestCount_deserialize(input_val21, env, &content_node, NULL, AXIS2_FALSE)) { adb_getOperationRequestCount_free(input_val21, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getOperationRequestCount_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val21 = axis2_skel_StatisticsAdmin_getOperationRequestCount(env, msg_ctx,input_val21); if ( NULL == ret_val21 ) { adb_getOperationRequestCount_free(input_val21, env); return NULL; } ret_node = adb_getOperationRequestCountResponse_serialize(ret_val21, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getOperationRequestCountResponse_free(ret_val21, env); adb_getOperationRequestCount_free(input_val21, env); return ret_node; /* since this has no output params it just returns NULL */ } } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_svc_skel_StatisticsAdmin service ERROR: invalid OM parameters in request\n"); return NULL; }
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; }
AXIS2_EXTERN axis2_msg_ctx_t * AXIS2_CALL axis2_engine_create_fault_msg_ctx( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * processing_context, const axis2_char_t * code_value, const axis2_char_t * reason_text) { axis2_msg_ctx_t *fault_ctx = NULL; axis2_endpoint_ref_t *fault_to = NULL; axis2_endpoint_ref_t *reply_to = NULL; axutil_stream_t *stream = NULL; axiom_soap_envelope_t *envelope = NULL; const axis2_char_t *wsa_action = NULL; const axis2_char_t *msg_id = NULL; axis2_relates_to_t *relates_to = NULL; axis2_char_t *msg_uuid = NULL; axis2_msg_info_headers_t *msg_info_headers = NULL; axis2_bool_t doing_rest = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, processing_context, NULL); if(axis2_msg_ctx_get_process_fault(processing_context, env)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault message contex failed"); return NULL; } fault_ctx = axis2_msg_ctx_create(env, engine->conf_ctx, axis2_msg_ctx_get_transport_in_desc( processing_context, env), axis2_msg_ctx_get_transport_out_desc(processing_context, env)); axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); fault_to = axis2_msg_ctx_get_fault_to(processing_context, env); if(fault_to) { const axis2_char_t *address = axis2_endpoint_ref_get_address(fault_to, env); if(!address) { fault_to = NULL; } else if(axutil_strcmp(AXIS2_WSA_NONE_URL, address) == 0 || axutil_strcmp( AXIS2_WSA_NONE_URL_SUBMISSION, address) == 0) { reply_to = axis2_msg_ctx_get_reply_to(processing_context, env); if(reply_to) { axis2_msg_ctx_set_fault_to(fault_ctx, env, reply_to); } else { axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); } } else { axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); } } stream = axis2_msg_ctx_get_transport_out_stream(processing_context, env); if(stream) { axis2_msg_ctx_set_transport_out_stream(fault_ctx, env, stream); axis2_msg_ctx_reset_transport_out_stream(processing_context, env); } if(!fault_to && !stream) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap fault target destination not found"); return NULL; } /* Set WSA action */ msg_info_headers = axis2_msg_ctx_get_msg_info_headers(processing_context, env); if(msg_info_headers) { wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); if(wsa_action) { /* We have to use the action set by user, cannot use the default always. wsa_action = "http://www.w3.org/2005/08/addressing/fault"; */ axis2_msg_ctx_set_wsa_action(fault_ctx, env, wsa_action); } } /* Set relates to */ msg_id = axis2_msg_ctx_get_msg_id(processing_context, env); /* we can create with default Relates to namespace. Actual namespace based on addressing version will be created in addressing out handler */ relates_to = axis2_relates_to_create(env, msg_id, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE); axis2_msg_ctx_set_relates_to(fault_ctx, env, relates_to); /* Set msg id */ msg_uuid = axutil_uuid_gen(env); axis2_msg_ctx_set_message_id(fault_ctx, env, msg_uuid); if(msg_uuid) { AXIS2_FREE(env->allocator, msg_uuid); msg_uuid = NULL; } /** Copy the property map from the current message context to the newly created fault message context. */ { axis2_ctx_t *ctx = axis2_msg_ctx_get_base(processing_context, env); axis2_ctx_t *fault_base_ctx = axis2_msg_ctx_get_base(fault_ctx, env); if(ctx && fault_ctx) { axis2_ctx_set_property_map(fault_base_ctx, env, axis2_ctx_get_property_map(ctx, env)); } } axis2_msg_ctx_set_op_ctx(fault_ctx, env, axis2_msg_ctx_get_op_ctx(processing_context, env)); axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); axis2_msg_ctx_set_server_side(fault_ctx, env, AXIS2_TRUE); envelope = axis2_msg_ctx_get_fault_soap_envelope(processing_context, env); if(!envelope) { if(axis2_msg_ctx_get_is_soap_11(processing_context, env)) { envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, reason_text, AXIOM_SOAP11, NULL, NULL); } else { envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, reason_text, AXIOM_SOAP12, NULL, NULL); } if(!envelope) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Creating default soap envelope failed"); return NULL; } } else { axis2_msg_ctx_set_fault_soap_envelope(processing_context, env, NULL); } doing_rest = axis2_msg_ctx_get_doing_rest(processing_context, env); axis2_msg_ctx_set_doing_rest(fault_ctx, env, doing_rest); axis2_msg_ctx_set_soap_envelope(fault_ctx, env, envelope); axis2_msg_ctx_set_out_transport_info(fault_ctx, env, axis2_msg_ctx_get_out_transport_info( processing_context, env)); axis2_msg_ctx_reset_out_transport_info(processing_context, env); return fault_ctx; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_engine_send( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_status_t status = AXIS2_SUCCESS; axis2_op_ctx_t *op_ctx = NULL; axutil_array_list_t *phases = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send start"); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); /* Find and invoke the phases */ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); if(op) { phases = axis2_op_get_out_flow(op, env); } } if(axis2_msg_ctx_is_paused(msg_ctx, env)) { /* Message has paused, so rerun it from the position it stopped. The handler which paused the message will be the first one to resume invocation */ status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); if(status != AXIS2_SUCCESS) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Resuming invocation of phases failed"); return status; } conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(conf_ctx) { conf = axis2_conf_ctx_get_conf(conf_ctx, env); if(conf) { axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env); if(global_out_phase) { axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx); } } } } else { status = axis2_engine_invoke_phases(engine, env, phases, msg_ctx); if(status != AXIS2_SUCCESS) { return status; } conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(conf_ctx) { conf = axis2_conf_ctx_get_conf(conf_ctx, env); if(conf) { axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env); if(global_out_phase) { axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx); } } } } if(!(axis2_msg_ctx_is_paused(msg_ctx, env))) { /* Write the message to wire */ axis2_transport_sender_t *transport_sender = NULL; axis2_transport_out_desc_t *transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, env); if(transport_out) { transport_sender = axis2_transport_out_desc_get_sender(transport_out, env); if(!transport_sender) return AXIS2_FAILURE; status = AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx); if(status != AXIS2_SUCCESS) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport sender invoke failed"); return status; } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out is not set in message context"); return AXIS2_FAILURE; } } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send end successfully"); 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_EXTERN axis2_status_t AXIS2_CALL axis2_engine_receive( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op = NULL; axutil_array_list_t *pre_calculated_phases = NULL; axutil_array_list_t *op_specific_phases = NULL; axis2_status_t status = AXIS2_FAILURE; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_receive"); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); conf = axis2_conf_ctx_get_conf(conf_ctx, env); pre_calculated_phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); if(axis2_msg_ctx_is_paused(msg_ctx, env)) { /* The message has paused, so re-run them from the position they stopped. */ axis2_engine_resume_invocation_phases(engine, env, pre_calculated_phases, msg_ctx); if(axis2_msg_ctx_is_paused(msg_ctx, env)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); return AXIS2_SUCCESS; } /* Resume op specific phases */ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { op = axis2_op_ctx_get_op(op_ctx, env); op_specific_phases = axis2_op_get_in_flow(op, env); axis2_engine_resume_invocation_phases(engine, env, op_specific_phases, msg_ctx); if(axis2_msg_ctx_is_paused(msg_ctx, env)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); return AXIS2_SUCCESS; } } } else { status = axis2_engine_invoke_phases(engine, env, pre_calculated_phases, msg_ctx); if(status != AXIS2_SUCCESS) { if(axis2_msg_ctx_get_server_side(msg_ctx, env)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking pre-calculated phases failed"); return status; } } if(axis2_msg_ctx_is_paused(msg_ctx, env)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); return AXIS2_SUCCESS; } op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(op_ctx) { op = axis2_op_ctx_get_op(op_ctx, env); op_specific_phases = axis2_op_get_in_flow(op, env); status = axis2_engine_invoke_phases(engine, env, op_specific_phases, msg_ctx); if(status != AXIS2_SUCCESS) { axis2_char_t *op_name = NULL; op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking operation specific phases failed for operation %s", op_name); return status; } if(axis2_msg_ctx_is_paused(msg_ctx, env)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); return AXIS2_SUCCESS; } } } if((axis2_msg_ctx_get_server_side(msg_ctx, env)) && !(axis2_msg_ctx_is_paused(msg_ctx, env))) { axis2_msg_recv_t *receiver = NULL; status = axis2_engine_check_must_understand_headers(env, msg_ctx); if(status != AXIS2_SUCCESS) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Check for must understand headers failed"); return status; } /* Invoke the message receivers */ if(!op) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation not found"); return AXIS2_FAILURE; } receiver = axis2_op_get_msg_recv(op, env); if(!receiver) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Message receiver not set in operation description"); return AXIS2_FAILURE; } status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived( receiver, env)); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_receive"); return status; }
AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL axis2_conf_ctx_fill_ctxs( axis2_conf_ctx_t * conf_ctx, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_char_t *svc_grp_ctx_id = NULL; axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; axis2_svc_ctx_t *svc_ctx = NULL; axis2_svc_t *svc = NULL; axis2_svc_grp_t *svc_grp = NULL; const axutil_qname_t *qname = NULL; axis2_char_t *svc_id = NULL; axis2_op_ctx_t *op_ctx = NULL; AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(!svc) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_NOT_YET_FOUND, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service not yet found in message context. Cannot proceed"); return NULL; } qname = axis2_svc_get_qname(svc, env); if(!qname) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); return NULL; } svc_id = axutil_qname_get_localpart(qname, env); if(!svc_id) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); return NULL; } svc_grp = axis2_svc_get_parent(svc, env); if(svc_grp) { svc_grp_ctx_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); } if(!svc_grp_ctx_id) { svc_grp_ctx_id = (axis2_char_t *)axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id( msg_ctx, env), env); } /* By this time service group context id must have a value, either from transport or from * addressing */ if(svc_grp_ctx_id) { svc_grp_ctx = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, svc_grp_ctx_id, AXIS2_HASH_KEY_STRING); if(svc_grp_ctx) { svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); if(!svc_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service group context has no servie context set for service %s", svc_id); return NULL; } } } if(!svc_grp_ctx_id) { svc_grp_ctx_id = axutil_uuid_gen(env); if(svc_grp_ctx_id) { axutil_string_t *svc_grp_ctx_id_str = axutil_string_create_assume_ownership(env, &svc_grp_ctx_id); 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); } } if(!svc_grp_ctx) { axis2_svc_grp_t *svc_group; svc_group = axis2_svc_get_parent(svc, env); svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_group, env, conf_ctx); svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); if(!svc_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service group context has no servie context set for service %s", svc_id); return NULL; } axis2_svc_grp_ctx_set_id(svc_grp_ctx, env, svc_grp_ctx_id); axis2_conf_ctx_register_svc_grp_ctx(conf_ctx, env, svc_grp_ctx_id, svc_grp_ctx); } /* When you come here operation context MUST have already been assigned to the message context */ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(!op_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MSG_CTX, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation context not set for message context"); return NULL; } axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx); return svc_grp_ctx; }
axis2_status_t AXIS2_CALL axis2_libcurl_send( axis2_libcurl_t *data, axiom_output_t * om_output, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, axiom_soap_envelope_t * out, const axis2_char_t * str_url, const axis2_char_t * soap_action) { struct curl_slist *headers = NULL; axiom_soap_body_t *soap_body; axis2_bool_t is_soap = AXIS2_TRUE; axis2_bool_t send_via_get = AXIS2_FALSE; axis2_bool_t send_via_head = AXIS2_FALSE; axis2_bool_t send_via_put = AXIS2_FALSE; axis2_bool_t send_via_delete = AXIS2_FALSE; axis2_bool_t doing_mtom = AXIS2_FALSE; axiom_node_t *body_node = NULL; axiom_node_t *data_out = NULL; axutil_property_t *method = NULL; axis2_char_t *method_value = NULL; axiom_xml_writer_t *xml_writer = NULL; axis2_char_t *buffer = NULL; unsigned int buffer_size = 0; int content_length = -1; axis2_char_t *content_type = NULL; /*axis2_char_t *content_len = AXIS2_HTTP_HEADER_CONTENT_LENGTH_; */ const axis2_char_t *char_set_enc = NULL; axis2_char_t *content = AXIS2_HTTP_HEADER_CONTENT_TYPE_; axis2_char_t *soap_action_header = AXIS2_HTTP_HEADER_SOAP_ACTION_; axutil_stream_t *in_stream; axutil_property_t *trans_in_property; axutil_string_t *char_set_enc_str; axis2_byte_t *output_stream = NULL; int output_stream_size = 0; CURL *handler; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axis2_transport_out_desc_t *trans_desc = NULL; axutil_param_t *write_xml_declaration_param = NULL; axutil_hash_t *transport_attrs = NULL; axis2_bool_t write_xml_declaration = AXIS2_FALSE; axutil_property_t *property; int *response_length = NULL; axis2_http_status_line_t *status_line = NULL; axis2_char_t *status_line_str = NULL; axis2_char_t *tmp_strcat = NULL; int status_code = 0; AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, data->handler, AXIS2_FAILURE); handler = data->handler; curl_easy_reset(handler); curl_easy_setopt(handler, CURLOPT_ERRORBUFFER, data->errorbuffer); headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_USER_AGENT_AXIS2C); headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_ACCEPT_); headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_EXPECT_); if(AXIS2_FAILURE == axis2_libcurl_set_options(handler, env, msg_ctx)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[axis2libcurl]Setting options in Libcurl failed"); return AXIS2_FAILURE; } if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env)) { is_soap = AXIS2_FALSE; } else { is_soap = AXIS2_TRUE; } if (!is_soap) { soap_body = axiom_soap_envelope_get_body(out, env); if (!soap_body) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } body_node = axiom_soap_body_get_base_node(soap_body, env); if (!body_node) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } data_out = axiom_node_get_first_element(body_node, env); method = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_METHOD); if (method) { method_value = (axis2_char_t *) axutil_property_get_value(method, env); } /* The default is POST */ if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET)) { send_via_get = AXIS2_TRUE; } else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_HEAD)) { send_via_head = AXIS2_TRUE; } else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_PUT)) { send_via_put = AXIS2_TRUE; } else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_DELETE)) { send_via_delete = AXIS2_TRUE; } } conf_ctx = axis2_msg_ctx_get_conf_ctx (msg_ctx, env); if (conf_ctx) { conf = axis2_conf_ctx_get_conf (conf_ctx, env); } if (conf) { trans_desc = axis2_conf_get_transport_out (conf, env, AXIS2_TRANSPORT_ENUM_HTTP); } if (trans_desc) { write_xml_declaration_param = axutil_param_container_get_param (axis2_transport_out_desc_param_container (trans_desc, env), env, AXIS2_XML_DECLARATION); } if (write_xml_declaration_param) { transport_attrs = axutil_param_get_attributes (write_xml_declaration_param, env); if (transport_attrs) { axutil_generic_obj_t *obj = NULL; axiom_attribute_t *write_xml_declaration_attr = NULL; axis2_char_t *write_xml_declaration_attr_value = NULL; obj = axutil_hash_get (transport_attrs, AXIS2_ADD_XML_DECLARATION, AXIS2_HASH_KEY_STRING); if (obj) { write_xml_declaration_attr = (axiom_attribute_t *) axutil_generic_obj_get_value (obj, env); } if (write_xml_declaration_attr) { write_xml_declaration_attr_value = axiom_attribute_get_value (write_xml_declaration_attr, env); } if (write_xml_declaration_attr_value && 0 == axutil_strcasecmp (write_xml_declaration_attr_value, AXIS2_VALUE_TRUE)) { write_xml_declaration = AXIS2_TRUE; } } } if (write_xml_declaration) { axiom_output_write_xml_version_encoding (om_output, env); } if (!send_via_get && !send_via_head && !send_via_delete) { xml_writer = axiom_output_get_xml_writer(om_output, env); char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env); if (!char_set_enc_str) { char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; } else { char_set_enc = axutil_string_get_buffer(char_set_enc_str, env); } if (!send_via_put && is_soap) { doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env); axiom_output_set_do_optimize(om_output, env, doing_mtom); axiom_soap_envelope_serialize(out, env, om_output, AXIS2_FALSE); if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { if (AXIS2_ESC_DOUBLE_QUOTE != *soap_action) { axis2_char_t *tmp_soap_action = NULL; tmp_soap_action = AXIS2_MALLOC(env->allocator, (axutil_strlen(soap_action) + 5) * sizeof(axis2_char_t)); sprintf(tmp_soap_action, "\"%s\"", soap_action); tmp_strcat = axutil_stracat(env, soap_action_header,tmp_soap_action); headers = curl_slist_append(headers, tmp_strcat); AXIS2_FREE(env->allocator, tmp_strcat); AXIS2_FREE(env->allocator, tmp_soap_action); } else { tmp_strcat = axutil_stracat(env, soap_action_header, soap_action); headers = curl_slist_append(headers, tmp_strcat ); AXIS2_FREE(env->allocator, tmp_strcat); } } if (doing_mtom) { /*axiom_output_flush(om_output, env, &output_stream, &output_stream_size);*/ axiom_output_flush(om_output, env); content_type = (axis2_char_t *) axiom_output_get_content_type(om_output, env); if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { if (axutil_strcmp(soap_action, "")) { /* handle SOAP action for SOAP 1.2 case */ axis2_char_t *temp_content_type = NULL; temp_content_type = axutil_stracat (env, content_type, AXIS2_CONTENT_TYPE_ACTION); content_type = temp_content_type; temp_content_type = axutil_stracat (env, content_type, soap_action); AXIS2_FREE (env->allocator, content_type); content_type = temp_content_type; temp_content_type = axutil_stracat (env, content_type, AXIS2_ESC_DOUBLE_QUOTE_STR); AXIS2_FREE (env->allocator, content_type); content_type = temp_content_type; } } } else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { axis2_char_t *temp_content_type = NULL; content_type = (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; content_type = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_CHARSET); temp_content_type = axutil_stracat(env, content_type, char_set_enc); AXIS2_FREE(env->allocator, content_type); content_type = temp_content_type; } else { axis2_char_t *temp_content_type = NULL; content_type = (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP; content_type = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_CHARSET); temp_content_type = axutil_stracat(env, content_type, char_set_enc); AXIS2_FREE(env->allocator, content_type); content_type = temp_content_type; if (axutil_strcmp(soap_action, "")) { temp_content_type = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_ACTION); AXIS2_FREE(env->allocator, content_type); content_type = temp_content_type; temp_content_type = axutil_stracat(env, content_type, soap_action); AXIS2_FREE(env->allocator, content_type); content_type = temp_content_type; } temp_content_type = axutil_stracat(env, content_type, AXIS2_SEMI_COLON_STR); AXIS2_FREE(env->allocator, content_type); content_type = temp_content_type; } } else if (is_soap) { AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Attempt to send SOAP" "message using HTTP PUT failed"); return AXIS2_FAILURE; } else { axutil_property_t *content_type_property = NULL; axutil_hash_t *content_type_hash = NULL; axis2_char_t *content_type_value = NULL; axiom_node_serialize(data_out, env, om_output); content_type_property = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE); if (content_type_property) { content_type_hash = (axutil_hash_t *) axutil_property_get_value(content_type_property, env); if (content_type_hash) { content_type_value = (char *) axutil_hash_get(content_type_hash, AXIS2_HTTP_HEADER_CONTENT_TYPE, AXIS2_HASH_KEY_STRING); } } if (content_type_value) { content_type = content_type_value; } else { content_type = axutil_strdup(env,AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML); } } buffer = axiom_xml_writer_get_xml(xml_writer, env); if (!doing_mtom) { buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); } else buffer_size = output_stream_size; { /* * Curl calculates the content-length automatically. * This commented section is not only unnecessary, * it interferes with authentication. * * NTLM, for example, will send an empty request * first (no body) to get the auth challenge * before resending with actual content. */ /*char tmp_buf[10]; sprintf(tmp_buf, "%d", buffer_size); tmp_strcat = axutil_stracat(env, content_len, tmp_buf); headers = curl_slist_append(headers, tmp_strcat); AXIS2_FREE(env->allocator, tmp_strcat); tmp_strcat = NULL;*/ tmp_strcat = axutil_stracat(env, content, content_type); headers = curl_slist_append(headers, tmp_strcat); AXIS2_FREE(env->allocator, tmp_strcat); tmp_strcat = NULL; } if (!doing_mtom) { curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, buffer_size); curl_easy_setopt(handler, CURLOPT_POSTFIELDS, buffer); } else { curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, output_stream_size); curl_easy_setopt(handler, CURLOPT_POSTFIELDS, output_stream); } if (send_via_put) { curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_PUT); } curl_easy_setopt(handler, CURLOPT_URL, str_url); } else { axis2_char_t *request_param; axis2_char_t *url_encode; request_param = (axis2_char_t *) axis2_http_sender_get_param_string(NULL, env, msg_ctx); url_encode = axutil_strcat(env, str_url, AXIS2_Q_MARK_STR, request_param, NULL); if (send_via_get) { curl_easy_setopt(handler, CURLOPT_HTTPGET, 1); } else if (send_via_head) { curl_easy_setopt(handler, CURLOPT_NOBODY, 1); } else if (send_via_delete) { curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_DELETE); } curl_easy_setopt(handler, CURLOPT_URL, url_encode); } { axis2_bool_t manage_session; manage_session = axis2_msg_ctx_get_manage_session(msg_ctx, env); if (manage_session == AXIS2_TRUE) { if (data->cookies == AXIS2_FALSE) { /* Ensure cookies enabled to manage session */ /* Pass empty cookie string to enable cookies */ curl_easy_setopt(handler, CURLOPT_COOKIEFILE, " "); data->cookies = AXIS2_TRUE; } } else if (data->cookies == AXIS2_TRUE) { /* Pass special string ALL to reset cookies if any have been enabled. */ /* If cookies have ever been enabled, we reset every time as long as manage_session is false, as there is no clear curl option to turn off the cookie engine once enabled. */ curl_easy_setopt(handler, CURLOPT_COOKIELIST, AXIS2_ALL); } } curl_easy_setopt(handler, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(handler, CURLOPT_WRITEFUNCTION, axis2_libcurl_write_memory_callback); curl_easy_setopt(handler, CURLOPT_WRITEDATA, data); curl_easy_setopt (handler, CURLOPT_HEADERFUNCTION, axis2_libcurl_header_callback); curl_easy_setopt (handler, CURLOPT_WRITEHEADER, data); /* Free response data from previous request */ if( data->size ) { if (data->memory) { AXIS2_FREE(data->env->allocator, data->memory); } data->size = 0; } if (curl_easy_perform(handler)) { AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "%s", &data->errorbuffer); AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); return AXIS2_FAILURE; } in_stream = axutil_stream_create_libcurl(env, data->memory, data->size); trans_in_property = axutil_property_create(env); axutil_property_set_scope(trans_in_property, env, AXIS2_SCOPE_REQUEST); axutil_property_set_free_func(trans_in_property, env, libcurl_stream_free); axutil_property_set_value(trans_in_property, env, in_stream); axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, trans_in_property); if (axutil_array_list_size(data->alist, env) > 0) { status_line_str = axutil_array_list_get(data->alist, env, 0); if (status_line_str) { status_line = axis2_http_status_line_create(env, status_line_str); } } if (status_line) { status_code = axis2_http_status_line_get_status_code(status_line, env); } axis2_msg_ctx_set_status_code (msg_ctx, env, status_code); AXIS2_FREE(data->env->allocator, content_type); content_type = axis2_libcurl_get_content_type(data, env); if (content_type) { if (strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED) && strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_XOP_XML)) { axis2_ctx_t *axis_ctx = axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env), env); property = axutil_property_create (env); axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST); axutil_property_set_value (property, env, axutil_strdup (env, content_type)); axis2_ctx_set_property (axis_ctx, env, MTOM_RECIVED_CONTENT_TYPE, property); } } content_length = axis2_libcurl_get_content_length(data, env); if (content_length >= 0) { response_length = AXIS2_MALLOC (env->allocator, sizeof (int)); memcpy (response_length, &content_length, sizeof (int)); property = axutil_property_create (env); axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST); axutil_property_set_value (property, env, response_length); axis2_msg_ctx_set_property (msg_ctx, env, AXIS2_HTTP_HEADER_CONTENT_LENGTH, property); } curl_slist_free_all (headers); /* release the read http headers. */ /* (commenting out the call below is a clever way to force a premature EOF condition in subsequent messages, as they will be read using the content-length of the first message.) */ axis2_libcurl_free_headers(data, env); AXIS2_FREE(data->env->allocator, content_type); axis2_http_status_line_free( status_line, env); return AXIS2_SUCCESS; }
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_EXPORT axis2_svc_skeleton_t *AXIS2_CALL axis2_msg_recv_make_new_svc_obj( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, struct axis2_msg_ctx * msg_ctx) { struct axis2_svc *svc = NULL; struct axis2_op_ctx *op_ctx = NULL; struct axis2_svc_ctx *svc_ctx = NULL; axutil_param_t *impl_info_param = NULL; void *impl_class = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); svc = axis2_svc_ctx_get_svc(svc_ctx, env); if(!svc) { return NULL; } impl_class = axis2_svc_get_impl_class(svc, env); if(impl_class) { return impl_class; } else { /* When we load the DLL we have to make sure that only one thread will load it */ axutil_thread_mutex_lock(axis2_svc_get_mutex(svc, env)); /* If more than one thread tries to acquires the lock, first thread loads the DLL. Others should not load the DLL */ impl_class = axis2_svc_get_impl_class(svc, env); if(impl_class) { axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); return impl_class; } impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS); if(!impl_info_param) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); return NULL; } axutil_allocator_switch_to_global_pool(env->allocator); axutil_class_loader_init(env); impl_class = axutil_class_loader_create_dll(env, impl_info_param); if(impl_class) { AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *)impl_class, env); } axis2_svc_set_impl_class(svc, env, impl_class); axutil_allocator_switch_to_local_pool(env->allocator); axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); return impl_class; (void)msg_recv; } }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_IIp2Location_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; axiom_soap_envelope_t *req_soap_env = NULL; axiom_soap_header_t *req_soap_header = NULL; axiom_soap_envelope_t *res_soap_env = NULL; axiom_soap_header_t *res_soap_header = NULL; axiom_node_t *ret_node = NULL; axiom_node_t *input_header = NULL; axiom_node_t *output_header = NULL; axiom_node_t *header_base_node = NULL; axis2_svc_skel_IIp2Location_t *svc_skeleton_wrapper = NULL; adb_getResponse_t* ret_val1; adb_get_t* input_val1; axis2_status_t ret_val2; adb_add_t* input_val2; svc_skeleton_wrapper = (axis2_svc_skel_IIp2Location_t*)svc_skeleton; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "get") == 0 ) { input_val1 = adb_get_create( env); if( AXIS2_FAILURE == adb_get_deserialize(input_val1, env, &content_node, NULL, AXIS2_FALSE)) { adb_get_free(input_val1, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_get_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val1 = axis2_skel_IIp2Location_get(env, msg_ctx,input_val1); if ( NULL == ret_val1 ) { adb_get_free(input_val1, env); return NULL; } ret_node = adb_getResponse_serialize(ret_val1, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getResponse_free(ret_val1, env); adb_get_free(input_val1, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "add") == 0 ) { input_val2 = adb_add_create( env); if( AXIS2_FAILURE == adb_add_deserialize(input_val2, env, &content_node, NULL, AXIS2_FALSE)) { adb_add_free(input_val2, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_add_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val2 = axis2_skel_IIp2Location_add(env, msg_ctx,input_val2); if( AXIS2_FAILURE == ret_val2 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from add "); } adb_add_free(input_val2, env); /* since this has no output params it just returns NULL */ return NULL; } } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_svc_skel_IIp2Location service ERROR: invalid OM parameters in request\n"); return NULL; }
static axis2_status_t AXIS2_CALL axis2_msg_recv_receive_impl( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, void *callback_recv_param) { axis2_msg_ctx_t *out_msg_ctx = NULL; axis2_engine_t *engine = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_svc_ctx_t *svc_ctx = NULL; axis2_status_t status = AXIS2_FAILURE; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Entry:axis2_msg_recv_receive_impl"); out_msg_ctx = axis2_core_utils_create_out_msg_ctx(env, msg_ctx); if(!out_msg_ctx) { return AXIS2_FAILURE; } op_ctx = axis2_msg_ctx_get_op_ctx(out_msg_ctx, env); if(!op_ctx) { axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); axis2_msg_ctx_free(out_msg_ctx, env); return AXIS2_FAILURE; } status = axis2_op_ctx_add_msg_ctx(op_ctx, env, out_msg_ctx); if(!status) { axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); axis2_msg_ctx_free(out_msg_ctx, env); return status; } status = axis2_op_ctx_add_msg_ctx(op_ctx, env, msg_ctx); if(!status) { return status; } status = axis2_msg_recv_invoke_business_logic(msg_recv, env, msg_ctx, out_msg_ctx); if(AXIS2_SUCCESS != status) { axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); axis2_msg_ctx_free(out_msg_ctx, env); return status; } svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); conf_ctx = axis2_svc_ctx_get_conf_ctx(svc_ctx, env); engine = axis2_engine_create(env, conf_ctx); if(!engine) { axis2_msg_ctx_free(out_msg_ctx, env); return AXIS2_FAILURE; } if(axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env)) { axiom_soap_envelope_t *soap_envelope = axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env); if(soap_envelope) { axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env); if(body) { /* in case of a SOAP fault, we got to return failure so that transport gets to know that it should send 500 */ if(axiom_soap_body_has_fault(body, env)) { status = AXIS2_FAILURE; axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, soap_envelope); axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, NULL); } else { /* if it is two way and not a fault then send through engine. if it is one way we do not need to do an engine send */ status = axis2_engine_send(engine, env, out_msg_ctx); } } } } axis2_engine_free(engine, env); /* Reset the out message context to avoid double freeing at http worker. For example if this is * not done here both in and out message context will try to free the transport out stream * which will result in memory corruption. */ if(!axis2_msg_ctx_is_paused(out_msg_ctx, env) && !axis2_msg_ctx_is_keep_alive(out_msg_ctx, env)) { axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Exit:axis2_msg_recv_receive_impl"); return status; (void)callback_recv_param; }
static axis2_status_t AXIS2_CALL sandesha2_terminate_seq_msg_processor_process_in_msg ( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { axis2_msg_ctx_t *terminate_msg_ctx = NULL; sandesha2_terminate_seq_t *term_seq = NULL; axis2_char_t *rmd_sequence_id = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_storage_mgr_t *storage_mgr = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_create_seq_mgr_t *create_seq_mgr = NULL; sandesha2_sender_mgr_t *sender_mgr = NULL; sandesha2_next_msg_mgr_t *next_msg_mgr = NULL; sandesha2_msg_ctx_t *fault_ctx = NULL; axis2_char_t *spec_version = NULL; axis2_char_t *dbname = NULL; sandesha2_seq_ack_t *seq_ack = NULL; axis2_op_ctx_t *op_ctx = NULL; /*sandesha2_seq_property_bean_t *term_rcvd_bean = NULL;*/ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_terminate_seq_msg_processor_process_in_msg"); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); terminate_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); if(axis2_msg_ctx_get_server_side(terminate_msg_ctx, env)) { axis2_msg_ctx_t **msg_ctx_map = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(terminate_msg_ctx, env); msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = terminate_msg_ctx; } term_seq = sandesha2_msg_ctx_get_terminate_seq(rm_msg_ctx, env); if(!term_seq) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate Sequence part is not available"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); return AXIS2_FAILURE; } rmd_sequence_id = sandesha2_identifier_get_identifier(sandesha2_terminate_seq_get_identifier( term_seq, env), env); if(!rmd_sequence_id || 0 == axutil_strlen(rmd_sequence_id)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Invalid sequence id"); return AXIS2_FAILURE; } conf_ctx = axis2_msg_ctx_get_conf_ctx(terminate_msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname); if(!storage_mgr) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager."); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER, AXIS2_FAILURE); return AXIS2_FAILURE; } seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); create_seq_mgr = sandesha2_permanent_create_seq_mgr_create(env, dbname); sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname); next_msg_mgr = sandesha2_permanent_next_msg_mgr_create(env, dbname); fault_ctx = sandesha2_fault_mgr_check_for_unknown_seq(env, rm_msg_ctx, rmd_sequence_id, seq_prop_mgr, create_seq_mgr, next_msg_mgr); if(fault_ctx) { axis2_engine_t *engine = NULL; engine = axis2_engine_create(env, conf_ctx); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Send fault occurred"); axis2_engine_send_fault(engine, env, sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)); sandesha2_msg_ctx_free(fault_ctx, env); if(engine) { axis2_engine_free(engine, env); } axis2_msg_ctx_set_paused(terminate_msg_ctx, env, AXIS2_TRUE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_SUCCESS; } /*term_rcvd_bean = sandesha2_seq_property_bean_create(env); sandesha2_seq_property_bean_set_seq_id(term_rcvd_bean, env, rmd_sequence_id); sandesha2_seq_property_bean_set_name(term_rcvd_bean, env, SANDESHA2_SEQ_PROP_TERMINATE_RECEIVED); sandesha2_seq_property_bean_set_value(term_rcvd_bean, env, AXIS2_VALUE_TRUE); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, term_rcvd_bean);*/ spec_version = sandesha2_msg_ctx_get_rm_spec_ver(rm_msg_ctx, env); if(sandesha2_spec_specific_consts_is_term_seq_res_reqd(env, spec_version)) { sandesha2_terminate_seq_msg_processor_add_terminate_seq_res(env, rm_msg_ctx, rmd_sequence_id, seq_prop_mgr); } seq_ack = sandesha2_msg_ctx_get_seq_ack(rm_msg_ctx, env); /* If we have received a sequence acknowldegment with the incoming terminate message then we may * decide to send the terminate sequence message. */ if(seq_ack) { axis2_char_t *internal_sequence_id = NULL; axis2_char_t *rms_sequence_id = NULL; axis2_char_t *last_out_msg_no_str = NULL; long highest_out_msg_no = 0; sandesha2_seq_property_bean_t *terminated_bean = NULL; /* If there is a sequence acknowledgement element present in the sequence we will check * whether the sequence is completed. If so send a terminate sequence message. */ rms_sequence_id = sandesha2_identifier_get_identifier(sandesha2_seq_ack_get_identifier( seq_ack, env), env); internal_sequence_id = sandesha2_utils_get_seq_property(env, rms_sequence_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_INTERNAL_SEQUENCE_ID, seq_prop_mgr); terminated_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_sequence_id, SANDESHA2_SEQ_PROP_TERMINATE_ADDED); if(terminated_bean) { axis2_char_t *value = sandesha2_seq_property_bean_get_value(terminated_bean, env); if(value && !axutil_strcmp(AXIS2_VALUE_TRUE, value)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate sequence message was added previously"); } sandesha2_seq_property_bean_free(terminated_bean, env); } else { /* Retrieve the message number of the RM 1.0 last message */ last_out_msg_no_str = sandesha2_utils_get_seq_property(env, internal_sequence_id, SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO, seq_prop_mgr); if(last_out_msg_no_str) { highest_out_msg_no = atol(last_out_msg_no_str); if(last_out_msg_no_str) { AXIS2_FREE(env->allocator, last_out_msg_no_str); } } else { highest_out_msg_no = sandesha2_app_msg_processor_get_prev_msg_no(env, internal_sequence_id, seq_prop_mgr); } if(highest_out_msg_no > 0) { axis2_bool_t completed = AXIS2_FALSE; axutil_array_list_t *ack_range_list = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] highest_out_msg_no:%ld", highest_out_msg_no); ack_range_list = sandesha2_seq_ack_get_ack_range_list(seq_ack, env); completed = sandesha2_ack_mgr_verify_seq_completion(env, ack_range_list, highest_out_msg_no); if(completed) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Sequence %s is completed. So adding terminate msg", rms_sequence_id); sandesha2_terminate_mgr_send_terminate_seq_msg(env, rm_msg_ctx, rms_sequence_id, internal_sequence_id, storage_mgr, seq_prop_mgr, create_seq_mgr, sender_mgr); } } if(internal_sequence_id) { AXIS2_FREE(env->allocator, internal_sequence_id); } } } else { sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums(env, conf_ctx, storage_mgr, rmd_sequence_id, rm_msg_ctx, seq_prop_mgr, create_seq_mgr, sender_mgr); } /*sandesha2_terminate_mgr_clean_recv_side_after_terminate_msg(env, conf_ctx, rmd_sequence_id, storage_mgr, seq_prop_mgr, next_msg_mgr);*/ /*transmit_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, SANDESHA2_SEQ_PROP_SEQ_TERMINATED, AXIS2_VALUE_TRUE); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, transmit_bean); sandesha2_seq_mgr_update_last_activated_time(env, rmd_sequence_id, storage_mgr); */ /* We have no intention to pass this message beyond Sandesha2/C handler. So pause the message * context */ sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_terminate_seq_msg_processor_process_in_msg"); return AXIS2_SUCCESS; }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_TraderExchange_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axiom_node_t *ret_node = NULL; axis2_status_t ret_val1 = AXIS2_SUCCESS; axis2_updateRequest_t* input_val1_1; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "update") == 0 ) { input_val1_1 = axis2_updateRequest_create( env); axis2_updateRequest_deserialize(input_val1_1, env, content_node ); ret_val1 = axis2_skel_TraderExchange_update(env, input_val1_1 ); if ( AXIS2_FAILURE == ret_val1) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from update " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderExchange_on_fault( svc_skeleton, env, NULL); } /*ret_node = axis2__serialize(ret_val1, env, NULL, AXIS2_FALSE); axis2__free(ret_val1, env); axis2_updateRequest_free(input_val1_1, env); */ return ret_node; } } printf("axis2_svc_skel_TraderExchange service ERROR: invalid OM parameters in request\n"); return content_node; }
static axis2_status_t AXIS2_CALL sandesha2_create_seq_msg_processor_process_in_msg ( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { axis2_msg_ctx_t *create_seq_msg_ctx = NULL; sandesha2_create_seq_t *create_seq_part = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_msg_ctx_t *fault_rm_msg_ctx = NULL; axis2_msg_ctx_t *out_msg_ctx = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_next_msg_mgr_t *next_msg_mgr = NULL; axutil_property_t *property = NULL; axis2_char_t *incoming_sequence_id = NULL; sandesha2_msg_ctx_t *rm_create_seq_res_msg_ctx = NULL; sandesha2_create_seq_res_t *create_seq_res_part = NULL; sandesha2_seq_offer_t *seq_offer = NULL; axis2_endpoint_ref_t *acks_to_epr = NULL; sandesha2_acks_to_t *acks_to = NULL; sandesha2_seq_property_bean_t *acks_to_bean = NULL; sandesha2_seq_property_bean_t *acks_to_ref_param_bean = NULL; axutil_array_list_t *ref_param_list = NULL; axis2_char_t *ref_param_list_str = NULL; sandesha2_seq_property_bean_t *to_bean = NULL; axis2_engine_t *engine = NULL; axis2_char_t *addr_ns_uri = NULL; axis2_char_t *anon_uri = NULL; axis2_char_t *to_addr = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_char_t *dbname = NULL; sandesha2_create_seq_mgr_t *create_seq_mgr = NULL; axis2_msg_ctx_t **msg_ctx_map = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Start:sandesha2_create_seq_msg_processor_process_in_msg"); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); create_seq_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); op_ctx = axis2_msg_ctx_get_op_ctx(create_seq_msg_ctx, env); msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = create_seq_msg_ctx; create_seq_part = sandesha2_msg_ctx_get_create_seq(rm_msg_ctx, env); if(!create_seq_part) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] create_seq_part is NULL"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); return AXIS2_FAILURE; } conf_ctx = axis2_msg_ctx_get_conf_ctx(create_seq_msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); create_seq_mgr = sandesha2_permanent_create_seq_mgr_create(env, dbname); next_msg_mgr = sandesha2_permanent_next_msg_mgr_create(env, dbname); /*fault_rm_msg_ctx = sandesha2_fault_mgr_check_for_create_seq_refused(env, rm_msg_ctx, seq_prop_mgr);*/ fault_rm_msg_ctx = sandesha2_fault_mgr_check_for_create_seq_refused(env, rm_msg_ctx, seq_prop_mgr); if(fault_rm_msg_ctx) { axis2_engine_t *engine = NULL; AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] A fault occurred"); engine = axis2_engine_create(env, conf_ctx); axis2_engine_send_fault(engine, env, sandesha2_msg_ctx_get_msg_ctx(fault_rm_msg_ctx, env)); if(fault_rm_msg_ctx) { sandesha2_msg_ctx_free(fault_rm_msg_ctx, env); } if(engine) { axis2_engine_free(engine, env); engine = NULL; } axis2_msg_ctx_set_paused(create_seq_msg_ctx, env, AXIS2_TRUE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } return AXIS2_SUCCESS; } out_msg_ctx = sandesha2_utils_create_out_msg_ctx(env, create_seq_msg_ctx); incoming_sequence_id = sandesha2_seq_mgr_setup_new_incoming_sequence(env, rm_msg_ctx, seq_prop_mgr, next_msg_mgr); rm_create_seq_res_msg_ctx = sandesha2_msg_creator_create_create_seq_res_msg(env, rm_msg_ctx, out_msg_ctx, incoming_sequence_id, seq_prop_mgr); axis2_msg_ctx_set_flow(out_msg_ctx, env, AXIS2_OUT_FLOW); if(!rm_create_seq_res_msg_ctx) { if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } return AXIS2_FAILURE; } property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); /* For making sure that this won't be processed again */ sandesha2_msg_ctx_set_property(rm_create_seq_res_msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, property); create_seq_res_part = sandesha2_msg_ctx_get_create_seq_res(rm_create_seq_res_msg_ctx, env); seq_offer = sandesha2_create_seq_get_seq_offer(create_seq_part, env); /* Offer processing */ if(seq_offer) { sandesha2_accept_t *accept = NULL; axis2_char_t *outgoing_sequence_id = NULL; axis2_bool_t offer_accepted = AXIS2_FALSE; if(create_seq_res_part) { accept = sandesha2_create_seq_res_get_accept(create_seq_res_part, env); } if(!accept) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Accept part has not genereated for a message with offer"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); if(rm_create_seq_res_msg_ctx) { sandesha2_msg_ctx_free(rm_create_seq_res_msg_ctx, env); } if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } return AXIS2_FAILURE; } outgoing_sequence_id = sandesha2_identifier_get_identifier(sandesha2_seq_offer_get_identifier( seq_offer, env), env); /* Check whether offered sequence id is valid or create sequence bean already created */ offer_accepted = sandesha2_create_seq_msg_processor_offer_accepted(env, outgoing_sequence_id, rm_msg_ctx, create_seq_mgr); if(offer_accepted) { /*sandesha2_create_seq_bean_t *create_seq_bean = NULL;*/ axis2_char_t *outgoing_internal_sequence_id = NULL; sandesha2_seq_property_bean_t *outgoing_sequence_bean = NULL; sandesha2_seq_property_bean_t *outgoing_internal_sequence_bean = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Offer Accepted"); /* * If previously a create sequence message has arrived with an offer then there is * a create sequence bean already created in the database. Free it. Also free * outgoing_internal_sequence_bean, and outgoing_sequence_bean. */ sandesha2_create_seq_msg_processor_create_seq_msg_already_received(env, outgoing_sequence_id, rm_msg_ctx, create_seq_mgr, seq_prop_mgr); /* Note that outgoing_internal_sequence_id is derived from incoming_sequence_id. This * is server side. So it should be noted that in server side * incoming_internal_sequence_id and outgoing_internal_sequence_id are same */ outgoing_internal_sequence_id = sandesha2_utils_get_internal_sequence_id(env, incoming_sequence_id); /*create_seq_bean = sandesha2_create_seq_bean_create(env); sandesha2_create_seq_bean_set_outgoing_sequence_id(create_seq_bean, env, outgoing_sequence_id); sandesha2_create_seq_bean_set_internal_sequence_id(create_seq_bean, env, outgoing_internal_sequence_id); sandesha2_create_seq_bean_set_create_seq_msg_id(create_seq_bean, env, axutil_uuid_gen(env)); sandesha2_create_seq_mgr_insert(create_seq_mgr, env, create_seq_bean);*/ outgoing_sequence_bean = sandesha2_seq_property_bean_create(env); if(outgoing_sequence_bean) { sandesha2_seq_property_bean_set_name(outgoing_sequence_bean, env, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_SEQUENCE_ID); sandesha2_seq_property_bean_set_seq_id(outgoing_sequence_bean, env, outgoing_internal_sequence_id); sandesha2_seq_property_bean_set_value(outgoing_sequence_bean, env, outgoing_sequence_id); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] incoming_sequence_id:%s", incoming_sequence_id); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, outgoing_sequence_bean); sandesha2_seq_property_bean_free(outgoing_sequence_bean, env); } outgoing_internal_sequence_bean = sandesha2_seq_property_bean_create(env); if(outgoing_internal_sequence_bean) { sandesha2_seq_property_bean_set_name(outgoing_internal_sequence_bean, env, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_INTERNAL_SEQUENCE_ID); sandesha2_seq_property_bean_set_seq_id(outgoing_internal_sequence_bean, env, outgoing_sequence_id); sandesha2_seq_property_bean_set_value(outgoing_internal_sequence_bean, env, outgoing_internal_sequence_id); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, outgoing_internal_sequence_bean); sandesha2_seq_property_bean_free(outgoing_internal_sequence_bean, env); } if(outgoing_internal_sequence_id) { AXIS2_FREE(env->allocator, outgoing_internal_sequence_id); } } else { sandesha2_msg_ctx_add_soap_envelope(rm_create_seq_res_msg_ctx, env); } } acks_to = sandesha2_create_seq_get_acks_to(create_seq_part, env); acks_to_epr = sandesha2_address_get_epr(sandesha2_acks_to_get_address(acks_to, env), env); if(!acks_to_epr || !axis2_endpoint_ref_get_address(acks_to_epr, env)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Acks to is null"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_EPR, AXIS2_FAILURE); if(rm_create_seq_res_msg_ctx) { sandesha2_msg_ctx_free(rm_create_seq_res_msg_ctx, env); } if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } return AXIS2_FAILURE; } acks_to_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_ACKS_TO_EPR, (axis2_char_t*)axis2_endpoint_ref_get_address( acks_to_epr, 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); } ref_param_list = sandesha2_acks_to_get_ref_param_list(acks_to, env); if(ref_param_list) { ref_param_list_str = sandesha2_util_get_string_from_node_list(env, ref_param_list); acks_to_ref_param_bean = sandesha2_seq_property_bean_create_with_data(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_ACKS_TO_REF_PARAM, ref_param_list_str); if(ref_param_list_str) { AXIS2_FREE(env->allocator, ref_param_list_str); } if(acks_to_ref_param_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_ref_param_bean); sandesha2_seq_property_bean_free(acks_to_ref_param_bean, env); } } axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); sandesha2_seq_mgr_update_last_activated_time(env, incoming_sequence_id, seq_prop_mgr); engine = axis2_engine_create(env, conf_ctx); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]axis2_engine_send"); axis2_engine_send(engine, env, out_msg_ctx); if(engine) { axis2_engine_free(engine, env); } if(out_msg_ctx) { axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); /*axis2_msg_ctx_reset_transport_out_stream(out_msg_ctx, env);*/ axis2_msg_ctx_free(out_msg_ctx, env); } if(rm_create_seq_res_msg_ctx) { sandesha2_msg_ctx_free(rm_create_seq_res_msg_ctx, env); } to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, incoming_sequence_id, SANDESHA2_SEQ_PROP_TO_EPR); if(!to_bean) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] wsa:To is not set"); if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } return AXIS2_FAILURE; } to_addr = sandesha2_seq_property_bean_get_value(to_bean, env); addr_ns_uri = sandesha2_utils_get_seq_property(env, incoming_sequence_id, SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, seq_prop_mgr); anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_uri); if(addr_ns_uri) { AXIS2_FREE(env->allocator, addr_ns_uri); } if(sandesha2_utils_is_anon_uri(env, to_addr)) { axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); } else { axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_FALSE); } sandesha2_seq_property_bean_free(to_bean, env); /* Pausing the flow here so that it won't go to a message receiver which is not set for this flow */ sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE); if(incoming_sequence_id) { AXIS2_FREE(env->allocator, incoming_sequence_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit: sandesha2_create_seq_msg_processor_process_in_msg"); return AXIS2_SUCCESS; }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_LoggingAdmin_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; axiom_soap_envelope_t *req_soap_env = NULL; axiom_soap_header_t *req_soap_header = NULL; axiom_soap_envelope_t *res_soap_env = NULL; axiom_soap_header_t *res_soap_header = NULL; axiom_node_t *ret_node = NULL; axiom_node_t *input_header = NULL; axiom_node_t *output_header = NULL; axiom_node_t *header_base_node = NULL; axis2_svc_skel_LoggingAdmin_t *svc_skeleton_wrapper = NULL; adb_getAllLoggerDataResponse_t* ret_val1; adb_getAllLoggerData_t* input_val1; axis2_status_t ret_val2; axis2_status_t ret_val3; adb_updateSystemLog_t* input_val3; adb_getSystemLogResponse_t* ret_val4; adb_getAppenderDataResponse_t* ret_val5; adb_getAppenderData_t* input_val5; axis2_status_t ret_val6; adb_updateAllAppenderData_t* input_val6; adb_getLoggerDataResponse_t* ret_val7; adb_getLoggerData_t* input_val7; axis2_status_t ret_val8; adb_updateLoggerData_t* input_val8; svc_skeleton_wrapper = (axis2_svc_skel_LoggingAdmin_t*)svc_skeleton; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "getAllLoggerData") == 0 ) { input_val1 = adb_getAllLoggerData_create( env); if( AXIS2_FAILURE == adb_getAllLoggerData_deserialize(input_val1, env, &content_node, NULL, AXIS2_FALSE)) { adb_getAllLoggerData_free(input_val1, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getAllLoggerData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val1 = axis2_skel_LoggingAdmin_getAllLoggerData(env, msg_ctx,input_val1); if ( NULL == ret_val1 ) { adb_getAllLoggerData_free(input_val1, env); return NULL; } ret_node = adb_getAllLoggerDataResponse_serialize(ret_val1, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getAllLoggerDataResponse_free(ret_val1, env); adb_getAllLoggerData_free(input_val1, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "restoreDefaults") == 0 ) { ret_val2 = axis2_skel_LoggingAdmin_restoreDefaults(env, msg_ctx, (axis2_skel_LoggingAdmin_restoreDefaults_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val2 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from restoreDefaults "); } /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "updateSystemLog") == 0 ) { input_val3 = adb_updateSystemLog_create( env); if( AXIS2_FAILURE == adb_updateSystemLog_deserialize(input_val3, env, &content_node, NULL, AXIS2_FALSE)) { adb_updateSystemLog_free(input_val3, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_updateSystemLog_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val3 = axis2_skel_LoggingAdmin_updateSystemLog(env, msg_ctx,input_val3, (axis2_skel_LoggingAdmin_updateSystemLog_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val3 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from updateSystemLog "); } adb_updateSystemLog_free(input_val3, env); /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "getSystemLog") == 0 ) { ret_val4 = axis2_skel_LoggingAdmin_getSystemLog(env, msg_ctx, (axis2_skel_LoggingAdmin_getSystemLog_fault*)&(svc_skeleton_wrapper->fault)); if ( NULL == ret_val4 ) { return NULL; } ret_node = adb_getSystemLogResponse_serialize(ret_val4, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSystemLogResponse_free(ret_val4, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getAppenderData") == 0 ) { input_val5 = adb_getAppenderData_create( env); if( AXIS2_FAILURE == adb_getAppenderData_deserialize(input_val5, env, &content_node, NULL, AXIS2_FALSE)) { adb_getAppenderData_free(input_val5, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getAppenderData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val5 = axis2_skel_LoggingAdmin_getAppenderData(env, msg_ctx,input_val5); if ( NULL == ret_val5 ) { adb_getAppenderData_free(input_val5, env); return NULL; } ret_node = adb_getAppenderDataResponse_serialize(ret_val5, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getAppenderDataResponse_free(ret_val5, env); adb_getAppenderData_free(input_val5, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "updateAllAppenderData") == 0 ) { input_val6 = adb_updateAllAppenderData_create( env); if( AXIS2_FAILURE == adb_updateAllAppenderData_deserialize(input_val6, env, &content_node, NULL, AXIS2_FALSE)) { adb_updateAllAppenderData_free(input_val6, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_updateAllAppenderData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val6 = axis2_skel_LoggingAdmin_updateAllAppenderData(env, msg_ctx,input_val6, (axis2_skel_LoggingAdmin_updateAllAppenderData_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val6 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from updateAllAppenderData "); } adb_updateAllAppenderData_free(input_val6, env); /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "getLoggerData") == 0 ) { input_val7 = adb_getLoggerData_create( env); if( AXIS2_FAILURE == adb_getLoggerData_deserialize(input_val7, env, &content_node, NULL, AXIS2_FALSE)) { adb_getLoggerData_free(input_val7, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getLoggerData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val7 = axis2_skel_LoggingAdmin_getLoggerData(env, msg_ctx,input_val7); if ( NULL == ret_val7 ) { adb_getLoggerData_free(input_val7, env); return NULL; } ret_node = adb_getLoggerDataResponse_serialize(ret_val7, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getLoggerDataResponse_free(ret_val7, env); adb_getLoggerData_free(input_val7, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "updateLoggerData") == 0 ) { input_val8 = adb_updateLoggerData_create( env); if( AXIS2_FAILURE == adb_updateLoggerData_deserialize(input_val8, env, &content_node, NULL, AXIS2_FALSE)) { adb_updateLoggerData_free(input_val8, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_updateLoggerData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val8 = axis2_skel_LoggingAdmin_updateLoggerData(env, msg_ctx,input_val8, (axis2_skel_LoggingAdmin_updateLoggerData_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val8 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from updateLoggerData "); } adb_updateLoggerData_free(input_val8, env); /* since this has no output params it just returns NULL */ return NULL; } } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_svc_skel_LoggingAdmin service ERROR: invalid OM parameters in request\n"); return NULL; }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_TraderClient_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axiom_node_t *ret_node = NULL; axis2_buyResponse_t* ret_val1 = NULL; axis2_buyRequest_t* input_val1_1; axis2_getPortfolioResponse_t* ret_val2 = NULL; axis2_getPortfolioRequest_t* input_val2_1; axis2_depositResponse_t* ret_val3 = NULL; axis2_depositRequest_t* input_val3_1; axis2_getSymbolsResponse_t* ret_val4 = NULL; axis2_getSymbolsRequest_t* input_val4_1; axis2_getQuoteResponse_t* ret_val5 = NULL; axis2_getQuoteRequest_t* input_val5_1; axis2_createAccountResponse_t* ret_val6 = NULL; axis2_createAccountRequest_t* input_val6_1; axis2_sellResponse_t* ret_val7 = NULL; axis2_sellRequest_t* input_val7_1; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "buy") == 0 ) { input_val1_1 = axis2_buyRequest_create( env); axis2_buyRequest_deserialize(input_val1_1, env, content_node ); ret_val1 = axis2_skel_TraderClient_buy(env, input_val1_1 ); if ( NULL == ret_val1 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from buy " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_buyResponse_serialize(ret_val1, env, NULL, AXIS2_FALSE); axis2_buyResponse_free(ret_val1, env); axis2_buyRequest_free(input_val1_1, env); return ret_node; } if ( axutil_strcmp(op_name, "getPortfolio") == 0 ) { input_val2_1 = axis2_getPortfolioRequest_create( env); axis2_getPortfolioRequest_deserialize(input_val2_1, env, content_node ); ret_val2 = axis2_skel_TraderClient_getPortfolio(env, input_val2_1 ); if ( NULL == ret_val2 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getPortfolio " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_getPortfolioResponse_serialize(ret_val2, env, NULL, AXIS2_FALSE); axis2_getPortfolioResponse_free(ret_val2, env); axis2_getPortfolioRequest_free(input_val2_1, env); return ret_node; } if ( axutil_strcmp(op_name, "deposit") == 0 ) { input_val3_1 = axis2_depositRequest_create( env); axis2_depositRequest_deserialize(input_val3_1, env, content_node ); ret_val3 = axis2_skel_TraderClient_deposit(env, input_val3_1 ); if ( NULL == ret_val3 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from deposit " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_depositResponse_serialize(ret_val3, env, NULL, AXIS2_FALSE); axis2_depositResponse_free(ret_val3, env); axis2_depositRequest_free(input_val3_1, env); return ret_node; } if ( axutil_strcmp(op_name, "getSymbols") == 0 ) { input_val4_1 = axis2_getSymbolsRequest_create( env); axis2_getSymbolsRequest_deserialize(input_val4_1, env, content_node ); ret_val4 = axis2_skel_TraderClient_getSymbols(env, input_val4_1 ); if ( NULL == ret_val4 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getSymbols " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_getSymbolsResponse_serialize(ret_val4, env, NULL, AXIS2_FALSE); axis2_getSymbolsResponse_free(ret_val4, env); axis2_getSymbolsRequest_free(input_val4_1, env); return ret_node; } if ( axutil_strcmp(op_name, "getQuote") == 0 ) { input_val5_1 = axis2_getQuoteRequest_create( env); axis2_getQuoteRequest_deserialize(input_val5_1, env, content_node ); ret_val5 = axis2_skel_TraderClient_getQuote(env, input_val5_1 ); if ( NULL == ret_val5 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getQuote " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_getQuoteResponse_serialize(ret_val5, env, NULL, AXIS2_FALSE); axis2_getQuoteResponse_free(ret_val5, env); axis2_getQuoteRequest_free(input_val5_1, env); return ret_node; } if ( axutil_strcmp(op_name, "createAccount") == 0 ) { input_val6_1 = axis2_createAccountRequest_create( env); axis2_createAccountRequest_deserialize(input_val6_1, env, content_node ); ret_val6 = axis2_skel_TraderClient_createAccount(env, input_val6_1 ); if ( NULL == ret_val6 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from createAccount " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_createAccountResponse_serialize(ret_val6, env, NULL, AXIS2_FALSE); axis2_createAccountResponse_free(ret_val6, env); axis2_createAccountRequest_free(input_val6_1, env); return ret_node; } if ( axutil_strcmp(op_name, "sell") == 0 ) { input_val7_1 = axis2_sellRequest_create( env); axis2_sellRequest_deserialize(input_val7_1, env, content_node ); ret_val7 = axis2_skel_TraderClient_sell(env, input_val7_1 ); if ( NULL == ret_val7 ) { AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from sell " " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL); } ret_node = axis2_sellResponse_serialize(ret_val7, env, NULL, AXIS2_FALSE); axis2_sellResponse_free(ret_val7, env); axis2_sellRequest_free(input_val7_1, env); return ret_node; } } printf("axis2_svc_skel_TraderClient service ERROR: invalid OM parameters in request\n"); return content_node; }
/* * This method invokes the right service method */ axiom_node_t* AXIS2_CALL axis2_svc_skel_SecurityAdminService_invoke(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *content_node, axis2_msg_ctx_t *msg_ctx) { /* depending on the function name invoke the * corresponding method */ axis2_op_ctx_t *operation_ctx = NULL; axis2_op_t *operation = NULL; axutil_qname_t *op_qname = NULL; axis2_char_t *op_name = NULL; axis2_msg_ctx_t *in_msg_ctx = NULL; axiom_soap_envelope_t *req_soap_env = NULL; axiom_soap_header_t *req_soap_header = NULL; axiom_soap_envelope_t *res_soap_env = NULL; axiom_soap_header_t *res_soap_header = NULL; axiom_node_t *ret_node = NULL; axiom_node_t *input_header = NULL; axiom_node_t *output_header = NULL; axiom_node_t *header_base_node = NULL; axis2_svc_skel_SecurityAdminService_t *svc_skeleton_wrapper = NULL; adb_getScenariosResponse_t* ret_val1; adb_getScenarios_t* input_val1; axis2_status_t ret_val2; adb_applySecurity_t* input_val2; axis2_status_t ret_val3; adb_activateUsernameTokenAuthentication_t* input_val3; axis2_status_t ret_val4; adb_disableSecurityOnService_t* input_val4; adb_getSecurityConfigDataResponse_t* ret_val5; adb_getSecurityConfigData_t* input_val5; adb_getSecurityScenarioResponse_t* ret_val6; adb_getSecurityScenario_t* input_val6; svc_skeleton_wrapper = (axis2_svc_skel_SecurityAdminService_t*)svc_skeleton; operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); operation = axis2_op_ctx_get_op(operation_ctx, env); op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env); op_name = axutil_qname_get_localpart(op_qname, env); if (op_name) { if ( axutil_strcmp(op_name, "getScenarios") == 0 ) { input_val1 = adb_getScenarios_create( env); if( AXIS2_FAILURE == adb_getScenarios_deserialize(input_val1, env, &content_node, NULL, AXIS2_FALSE)) { adb_getScenarios_free(input_val1, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getScenarios_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val1 = axis2_skel_SecurityAdminService_getScenarios(env, msg_ctx,input_val1, (axis2_skel_SecurityAdminService_getScenarios_fault*)&(svc_skeleton_wrapper->fault)); if ( NULL == ret_val1 ) { adb_getScenarios_free(input_val1, env); return NULL; } ret_node = adb_getScenariosResponse_serialize(ret_val1, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getScenariosResponse_free(ret_val1, env); adb_getScenarios_free(input_val1, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "applySecurity") == 0 ) { input_val2 = adb_applySecurity_create( env); if( AXIS2_FAILURE == adb_applySecurity_deserialize(input_val2, env, &content_node, NULL, AXIS2_FALSE)) { adb_applySecurity_free(input_val2, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_applySecurity_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val2 = axis2_skel_SecurityAdminService_applySecurity(env, msg_ctx,input_val2, (axis2_skel_SecurityAdminService_applySecurity_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val2 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from applySecurity "); } adb_applySecurity_free(input_val2, env); /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "activateUsernameTokenAuthentication") == 0 ) { input_val3 = adb_activateUsernameTokenAuthentication_create( env); if( AXIS2_FAILURE == adb_activateUsernameTokenAuthentication_deserialize(input_val3, env, &content_node, NULL, AXIS2_FALSE)) { adb_activateUsernameTokenAuthentication_free(input_val3, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_activateUsernameTokenAuthentication_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val3 = axis2_skel_SecurityAdminService_activateUsernameTokenAuthentication(env, msg_ctx,input_val3, (axis2_skel_SecurityAdminService_activateUsernameTokenAuthentication_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val3 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from activateUsernameTokenAuthentication "); } adb_activateUsernameTokenAuthentication_free(input_val3, env); /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "disableSecurityOnService") == 0 ) { input_val4 = adb_disableSecurityOnService_create( env); if( AXIS2_FAILURE == adb_disableSecurityOnService_deserialize(input_val4, env, &content_node, NULL, AXIS2_FALSE)) { adb_disableSecurityOnService_free(input_val4, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_disableSecurityOnService_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val4 = axis2_skel_SecurityAdminService_disableSecurityOnService(env, msg_ctx,input_val4, (axis2_skel_SecurityAdminService_disableSecurityOnService_fault*)&(svc_skeleton_wrapper->fault)); if( AXIS2_FAILURE == ret_val4 ) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from disableSecurityOnService "); } adb_disableSecurityOnService_free(input_val4, env); /* since this has no output params it just returns NULL */ return NULL; } if ( axutil_strcmp(op_name, "getSecurityConfigData") == 0 ) { input_val5 = adb_getSecurityConfigData_create( env); if( AXIS2_FAILURE == adb_getSecurityConfigData_deserialize(input_val5, env, &content_node, NULL, AXIS2_FALSE)) { adb_getSecurityConfigData_free(input_val5, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getSecurityConfigData_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val5 = axis2_skel_SecurityAdminService_getSecurityConfigData(env, msg_ctx,input_val5, (axis2_skel_SecurityAdminService_getSecurityConfigData_fault*)&(svc_skeleton_wrapper->fault)); if ( NULL == ret_val5 ) { adb_getSecurityConfigData_free(input_val5, env); return NULL; } ret_node = adb_getSecurityConfigDataResponse_serialize(ret_val5, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSecurityConfigDataResponse_free(ret_val5, env); adb_getSecurityConfigData_free(input_val5, env); return ret_node; /* since this has no output params it just returns NULL */ } if ( axutil_strcmp(op_name, "getSecurityScenario") == 0 ) { input_val6 = adb_getSecurityScenario_create( env); if( AXIS2_FAILURE == adb_getSecurityScenario_deserialize(input_val6, env, &content_node, NULL, AXIS2_FALSE)) { adb_getSecurityScenario_free(input_val6, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getSecurityScenario_deserialize: " "This should be due to an invalid XML"); return NULL; } ret_val6 = axis2_skel_SecurityAdminService_getSecurityScenario(env, msg_ctx,input_val6, (axis2_skel_SecurityAdminService_getSecurityScenario_fault*)&(svc_skeleton_wrapper->fault)); if ( NULL == ret_val6 ) { adb_getSecurityScenario_free(input_val6, env); return NULL; } ret_node = adb_getSecurityScenarioResponse_serialize(ret_val6, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_getSecurityScenarioResponse_free(ret_val6, env); adb_getSecurityScenario_free(input_val6, env); return ret_node; /* since this has no output params it just returns NULL */ } } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_svc_skel_SecurityAdminService service ERROR: invalid OM parameters in request\n"); return NULL; }
static axis2_status_t AXIS2_CALL sandesha2_ack_req_msg_processor_process_in_msg ( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { sandesha2_ack_requested_t *ack_requested = NULL; axis2_msg_ctx_t *msg_ctx = NULL; axis2_char_t *seq_id = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_storage_mgr_t *storage_mgr = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_seq_property_bean_t *acks_to_bean = NULL; axis2_endpoint_ref_t *acks_to = NULL; axis2_char_t *acks_to_str = NULL; axis2_op_t *ack_op = NULL; axis2_op_t *rm_msg_op = NULL; axis2_msg_ctx_t *ack_msg_ctx = NULL; axutil_property_t *property = NULL; sandesha2_msg_ctx_t *ack_rm_msg = NULL; axiom_soap_envelope_t *envelope = NULL; axis2_char_t *wsa_version = NULL; axis2_char_t *dbname = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_ack_req_msg_processor_process_in_msg"); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); ack_requested = sandesha2_msg_ctx_get_ack_requested(rm_msg_ctx, env); if(!ack_requested) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Ack requested part is missing"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); return AXIS2_FAILURE; } sandesha2_ack_requested_set_must_understand(ack_requested, env, AXIS2_FALSE); sandesha2_msg_ctx_add_soap_envelope(rm_msg_ctx, env); msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); seq_id = sandesha2_identifier_get_identifier( sandesha2_ack_requested_get_identifier(ack_requested, env), env); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname); if(!storage_mgr) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager."); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER, AXIS2_FAILURE); return AXIS2_FAILURE; } seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); acks_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, seq_id, SANDESHA2_SEQ_PROP_ACKS_TO_EPR); acks_to_str = sandesha2_seq_property_bean_get_value(acks_to_bean, env); if(!acks_to_str) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]acks_to_str"\ " seqeunce property is not set correctly"); if(seq_prop_mgr) sandesha2_seq_property_mgr_free(seq_prop_mgr, env); if(storage_mgr) sandesha2_storage_mgr_free(storage_mgr, env); return AXIS2_FAILURE; } acks_to = axis2_endpoint_ref_create(env, acks_to_str); ack_op = axis2_op_create(env); axis2_op_set_msg_exchange_pattern(ack_op, env, AXIS2_MEP_URI_IN_ONLY); rm_msg_op = axis2_msg_ctx_get_op(msg_ctx, env); if(rm_msg_op) { axutil_array_list_t *out_flow = NULL; axutil_array_list_t *new_out_flow = NULL; axutil_array_list_t *out_fault_flow = NULL; axutil_array_list_t *new_out_fault_flow = NULL; out_flow = axis2_op_get_out_flow(rm_msg_op, env); new_out_flow = axis2_phases_info_copy_flow(env, out_flow); out_fault_flow = axis2_op_get_out_flow(rm_msg_op, env); new_out_fault_flow = axis2_phases_info_copy_flow(env, out_fault_flow); if(new_out_flow) axis2_op_set_out_flow(ack_op, env, new_out_flow); if(new_out_fault_flow) axis2_op_set_fault_out_flow(ack_op, env, new_out_fault_flow); } ack_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, rm_msg_ctx); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(ack_msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, property); ack_rm_msg = sandesha2_msg_init_init_msg(env, ack_msg_ctx); sandesha2_msg_ctx_set_rm_ns_val(ack_rm_msg, env, sandesha2_msg_ctx_get_rm_ns_val(rm_msg_ctx, env)); axis2_msg_ctx_set_message_id(ack_msg_ctx, env, axutil_uuid_gen(env)); envelope = axiom_soap_envelope_create_default_soap_envelope(env, sandesha2_utils_get_soap_version(env, axis2_msg_ctx_get_soap_envelope(msg_ctx, env))); axis2_msg_ctx_set_soap_envelope(ack_msg_ctx, env, envelope); axis2_msg_ctx_set_to(ack_msg_ctx, env, acks_to); axis2_msg_ctx_set_reply_to(ack_msg_ctx, env, axis2_msg_ctx_get_to(msg_ctx, env)); sandesha2_msg_creator_add_ack_msg(env, ack_rm_msg, seq_id, seq_prop_mgr); axis2_msg_ctx_set_server_side(ack_msg_ctx, env, AXIS2_TRUE); property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_WSA_VERSION); if(property) wsa_version = axutil_property_get_value(property, env); property = axutil_property_create_with_args(env, 0, 0, 0, wsa_version); if(property) { axis2_msg_ctx_set_property(ack_msg_ctx, env, AXIS2_WSA_VERSION, property); property = NULL; } if(sandesha2_utils_is_anon_uri(env, acks_to_str)) { axis2_engine_t *engine = NULL; axis2_op_ctx_t *op_ctx = NULL; if(!axis2_msg_ctx_get_op(msg_ctx, env)) { axis2_op_t *operation = NULL; axis2_op_ctx_t *op_ctx = NULL; operation = axis2_op_create(env); axis2_op_set_msg_exchange_pattern(operation, env, AXIS2_MEP_URI_IN_OUT); op_ctx = axis2_op_ctx_create(env, operation, NULL); axis2_msg_ctx_set_op(msg_ctx, env, operation); axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx); } op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_ACK_WRITTEN, property); engine = axis2_engine_create(env, conf_ctx); if(AXIS2_FAILURE == axis2_engine_send(engine, env, ack_msg_ctx)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]ack sending failed"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_ACK, AXIS2_FAILURE); if(engine) { axis2_engine_free(engine, env); engine = NULL; } if(seq_prop_mgr) sandesha2_seq_property_mgr_free(seq_prop_mgr, env); if(storage_mgr) sandesha2_storage_mgr_free(storage_mgr, env); return AXIS2_FAILURE; } if(engine) { axis2_engine_free(engine, env); engine = NULL; } } else { sandesha2_sender_mgr_t *sender_mgr = NULL; axis2_char_t *key = NULL; sandesha2_sender_bean_t *ack_bean = NULL; sandesha2_sender_bean_t *find_bean = NULL; sandesha2_property_bean_t *prop_bean = NULL; long ack_interval = 0; long time_to_send = 0; axutil_array_list_t *found_list = NULL; axis2_msg_ctx_t *msg_ctx = NULL; axis2_engine_t *engine = NULL; axis2_transport_out_desc_t *transport_out = NULL; axis2_svc_t *svc = NULL; sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname); key = axutil_uuid_gen(env); ack_bean = sandesha2_sender_bean_create(env); sandesha2_sender_bean_set_msg_ctx_ref_key(ack_bean, env, key); sandesha2_sender_bean_set_msg_id(ack_bean, env, (axis2_char_t*)axis2_msg_ctx_get_msg_id(ack_msg_ctx, env)); sandesha2_sender_bean_set_resend(ack_bean, env, AXIS2_FALSE); sandesha2_sender_bean_set_seq_id(ack_bean, env, seq_id); sandesha2_sender_bean_set_send(ack_bean, env, AXIS2_TRUE); sandesha2_sender_bean_set_msg_type(ack_bean, env, SANDESHA2_MSG_TYPE_ACK); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_FALSE); axis2_msg_ctx_set_property(ack_msg_ctx, env, SANDESHA2_QUALIFIED_FOR_SENDING, property); /* Avoid retrieving property bean from operation until it is availbale */ /*prop_bean = sandesha2_utils_get_property_bean_from_op(env, axis2_msg_ctx_get_op(msg_ctx, env));*/ svc = axis2_msg_ctx_get_svc(ack_msg_ctx, env); if(!svc) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2][ack_req_msg_processor.c] service is NULL"); return AXIS2_FAILURE; } prop_bean = sandesha2_utils_get_property_bean(env, svc); if(!prop_bean) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2][ack_req_msg_processor.c] Property bean is NULL"); return AXIS2_FAILURE; } /*prop_bean = sandesha2_utils_get_property_bean(env, axis2_conf_ctx_get_conf(conf_ctx, env));*/ prop_bean = sandesha2_utils_get_property_bean(env, svc); ack_interval = sandesha2_property_bean_get_ack_interval(prop_bean, env); time_to_send = sandesha2_utils_get_current_time_in_millis(env) + ack_interval; find_bean = sandesha2_sender_bean_create(env); sandesha2_sender_bean_set_resend(find_bean, env, AXIS2_FALSE); sandesha2_sender_bean_set_send(find_bean, env, AXIS2_TRUE); sandesha2_sender_bean_set_msg_type(find_bean, env, SANDESHA2_MSG_TYPE_ACK); found_list = sandesha2_sender_mgr_find_by_sender_bean(sender_mgr, env, find_bean); if(find_bean) sandesha2_sender_bean_free(find_bean, env); if(found_list) { int i = 0; for(i = 0; i < axutil_array_list_size(found_list, env); i++) { axis2_char_t *msg_stored_key = NULL; sandesha2_sender_bean_t *old_ack_bean = NULL; old_ack_bean = axutil_array_list_get(found_list, env, i); time_to_send = sandesha2_sender_bean_get_time_to_send( old_ack_bean, env); /*char *msg_id = sandesha2_sender_bean_get_msg_id(old_ack_bean, env);*/ sandesha2_sender_mgr_remove(sender_mgr, env, sandesha2_sender_bean_get_msg_id(old_ack_bean, env)); /* Removing the message from the storage */ msg_stored_key = sandesha2_sender_bean_get_msg_ctx_ref_key( old_ack_bean, env); sandesha2_storage_mgr_remove_msg_ctx(storage_mgr, env, msg_stored_key, conf_ctx, -1); } } sandesha2_sender_bean_set_time_to_send(ack_bean, env, time_to_send); /*axis2_msg_ctx_set_keep_alive(ack_msg_ctx, env, AXIS2_TRUE);*/ sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, key, ack_msg_ctx, AXIS2_FALSE); sandesha2_sender_mgr_insert(sender_mgr, env, ack_bean); transport_out = axis2_msg_ctx_get_transport_out_desc(ack_msg_ctx, env); property = axutil_property_create_with_args(env, 0, 0, axis2_transport_out_desc_free_void_arg, transport_out); axis2_msg_ctx_set_property(ack_msg_ctx, env, SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(ack_msg_ctx, env, SANDESHA2_SET_SEND_TO_TRUE, property); property = axutil_property_create_with_args(env, 0, 0, 0, key); axis2_msg_ctx_set_property(ack_msg_ctx, env, SANDESHA2_MESSAGE_STORE_KEY, property); axis2_msg_ctx_set_transport_out_desc(ack_msg_ctx, env, sandesha2_utils_get_transport_out(env)); engine = axis2_engine_create(env, conf_ctx); if(AXIS2_FAILURE == axis2_engine_send(engine, env, ack_msg_ctx)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]ack sending failed"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_ACK, AXIS2_FAILURE); if(engine) axis2_engine_free(engine, env); if(seq_prop_mgr) sandesha2_seq_property_mgr_free(seq_prop_mgr, env); if(sender_mgr) sandesha2_sender_mgr_free(sender_mgr, env); if(storage_mgr) sandesha2_storage_mgr_free(storage_mgr, env); return AXIS2_FAILURE; } if(engine) axis2_engine_free(engine, env); sandesha2_utils_start_sender_for_seq(env, conf_ctx, seq_id, AXIS2_FALSE); axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE); if(sender_mgr) sandesha2_sender_mgr_free(sender_mgr, env); } if(seq_prop_mgr) sandesha2_seq_property_mgr_free(seq_prop_mgr, env); if(storage_mgr) sandesha2_storage_mgr_free(storage_mgr, env); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_ack_req_msg_processor_process_in_msg"); return AXIS2_SUCCESS; }