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