axis2_status_t AXIS2_CALL
axis2_statistics_admin_global_request_count_handler_invoke(struct axis2_handler *handler,
const axutil_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
axis2_status_t status = AXIS2_SUCCESS;
axis2_svc_t *svc = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] Start:axis2_statistics_admin_global_request_count_handler_invoke");
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
long *time_now = NULL;
axutil_property_t *property = NULL;
time_now = AXIS2_MALLOC(env->allocator, sizeof(long));
*time_now = service_admin_util_get_current_time_in_millis(env);
property = axutil_property_create_with_args(env, 0, 0, 0, time_now);
axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_REQUEST_RECEIVED_TIME, property);
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] End:axis2_statistics_admin_global_request_count_handler_invoke");
return status;
}
/**
* Set a security processed result property to the message context
* @env the environment
* @msg_ctx the message context in which data are stored/extracted
* @return status of the operation
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rampart_set_security_processed_results_property(
const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axutil_hash_t *sec_processed_results = NULL;
axutil_property_t *sec_processed_results_prop = NULL;
sec_processed_results = axutil_hash_make(env);
if(!sec_processed_results)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Security processed result hash container creation failed.");
return AXIS2_FAILURE;
}
sec_processed_results_prop = axutil_property_create_with_args(
env, AXIS2_SCOPE_REQUEST , AXIS2_TRUE, (void *)axutil_hash_free, sec_processed_results);
if(!sec_processed_results_prop)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Security processed result property creation failed.");
return AXIS2_FAILURE;
}
axis2_msg_ctx_set_property(
msg_ctx, env, RAMPART_SECURITY_PROCESSED_RESULTS, sec_processed_results_prop);
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
sandesha2_msg_ctx_set_property(
sandesha2_msg_ctx_t *rm_msg_ctx,
const axutil_env_t *env,
axis2_char_t *key,
void *val)
{
AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE);
return axis2_msg_ctx_set_property(rm_msg_ctx->msg_ctx, env, key, val);
}
axis2_status_t AXIS2_CALL
sandesha2_out_handler_invoke(
struct axis2_handler *handler,
const axutil_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
axutil_property_t *temp_prop = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_char_t *str_done = NULL;
axis2_char_t *dummy_msg_str = NULL;
axis2_bool_t dummy_msg = AXIS2_FALSE;
axis2_svc_t *svc = NULL;
axutil_qname_t *module_qname = NULL;
sandesha2_msg_ctx_t *rm_msg_ctx = NULL;
sandesha2_msg_processor_t *msg_processor = NULL;
int msg_type = -1;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_out_handler_invoke");
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_SEQ_PROP_MAKE_CONNECTION_OUT_PATH);
if (temp_prop)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2] In make connection out path. So return here.");
return AXIS2_SUCCESS;
temp_prop = NULL;
}
if(sandesha2_util_is_rstr_msg(env, msg_ctx))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2] A RSTR message. Sandesha don't process.");
return AXIS2_SUCCESS;
}
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if(!conf_ctx)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2] Configuration Context is NULL");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(!svc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Axis2 Service is NULL");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SVC_NULL, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
module_qname = axutil_qname_create(env, SANDESHA2_MODULE, NULL, NULL);
if(!axis2_svc_is_module_engaged(svc, env, module_qname))
{
if(module_qname)
{
axutil_qname_free(module_qname, env);
}
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]RM is not engaged. So return here");
return AXIS2_SUCCESS;
}
if(module_qname)
{
axutil_qname_free(module_qname, env);
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE);
if(temp_prop)
{
str_done = (axis2_char_t *) axutil_property_get_value(temp_prop, env);
}
if(str_done && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, str_done))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2]Application Processing Done. So return here.");
return AXIS2_SUCCESS;
}
temp_prop = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, temp_prop);
conf = axis2_conf_ctx_get_conf(conf_ctx, env);
if(!sandesha2_permanent_storage_mgr_create_db(env, conf_ctx))
{
return AXIS2_FAILURE;
}
/* Getting rm message */
rm_msg_ctx = sandesha2_msg_init_init_msg(env, msg_ctx);
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_DUMMY_MESSAGE);
if(NULL != temp_prop)
{
dummy_msg_str = (axis2_char_t *) axutil_property_get_value(temp_prop, env);
}
if(dummy_msg_str && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, dummy_msg_str))
{
dummy_msg = AXIS2_TRUE;
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SVC_CLIENT_CLOSED);
if(temp_prop)
{
axis2_char_t *spec_version = NULL;
axis2_endpoint_ref_t *reply_to = axis2_msg_ctx_get_reply_to(msg_ctx, env);
if(reply_to)
{
axis2_char_t *address = axis2_endpoint_ref_get_address(reply_to, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to_address:%s", address);
}
spec_version = sandesha2_utils_get_rm_version(env, msg_ctx);
if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version))
{
axis2_char_t *action = NULL;
axutil_string_t *str_action = NULL;
action = sandesha2_spec_specific_consts_get_terminate_seq_action(env, spec_version);
str_action = axutil_string_create(env, action);
axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action);
axutil_string_free(str_action, env);
/*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/
msg_type = sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env,
SANDESHA2_MSG_TYPE_CLOSE_SEQ);
}
else if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version))
{
axutil_property_t *property = NULL;
axutil_string_t *str_action = NULL;
/*axis2_msg_info_headers_set_action(axis2_msg_ctx_get_msg_info_headers(msg_ctx, env),
* env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); */
str_action = axutil_string_create(env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE);
axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action);
axutil_string_free(str_action, env);
property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, "Sandesha2LastMessage", property);
/*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/
}
}
msg_type = sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, env);
if(msg_type == SANDESHA2_MSG_TYPE_UNKNOWN)
{
axis2_msg_ctx_t *req_msg_ctx = NULL;
axis2_op_ctx_t *op_ctx = NULL;
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
if(req_msg_ctx) /* For the server side */
{
sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL;
sandesha2_seq_t *seq_part = NULL;
req_rm_msg_ctx = sandesha2_msg_init_init_msg(env, req_msg_ctx);
seq_part = sandesha2_msg_ctx_get_sequence(req_rm_msg_ctx, env);
if(seq_part)
{
msg_processor = (sandesha2_msg_processor_t *)
sandesha2_app_msg_processor_create(env); /* rm intended msg */
}
if(req_rm_msg_ctx)
sandesha2_msg_ctx_free(req_rm_msg_ctx, env);
}
else if(!axis2_msg_ctx_get_server_side(msg_ctx, env))
{
msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env);
}
}
else
{
msg_processor = sandesha2_msg_processor_create_msg_processor(env, rm_msg_ctx);
}
if(msg_processor)
{
sandesha2_msg_processor_process_out_msg(msg_processor, env, rm_msg_ctx);
sandesha2_msg_processor_free(msg_processor, env);
}
if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
{
/* Message should not be sent in an exception situation */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Pausing message context");
axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE);
if(rm_msg_ctx)
{
sandesha2_msg_ctx_free(rm_msg_ctx, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Error in processing the message");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_PROCESS_MSG, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE);
if(temp_prop)
{
axutil_property_set_value(temp_prop, env, AXIS2_VALUE_FALSE);
}
if(rm_msg_ctx)
{
sandesha2_msg_ctx_free(rm_msg_ctx, env);
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_out_handler_invoke");
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_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;
}
/**
* Create a new create_terminate_seq_msg
* @param env
* @param ref_rm_msg
* @param seq_id
* @param internal_seq_id
* @param seq_prop_mgr
* @return
*/
sandesha2_msg_ctx_t *AXIS2_CALL
sandesha2_msg_creator_create_terminate_seq_msg(
const axutil_env_t *env,
sandesha2_msg_ctx_t *ref_rm_msg,
axis2_char_t *seq_id,
axis2_char_t *internal_seq_id,
sandesha2_seq_property_mgr_t *seq_prop_mgr)
{
axis2_msg_ctx_t *ref_msg_ctx = NULL;
axis2_msg_ctx_t *terminate_seq_msg_ctx = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_char_t *terminate_seq_msg_id = NULL;
axis2_char_t *temp_msg_id = NULL;
axis2_char_t *rm_version = NULL;
axis2_char_t *rm_ns_value = NULL;
axis2_bool_t is_seq_res_reqd = AXIS2_FALSE;
axiom_soap_envelope_t *temp_envelope = NULL;
sandesha2_msg_ctx_t *terminate_rm_msg = NULL;
sandesha2_terminate_seq_t *terminate_seq = NULL;
int soap_version = -1;
sandesha2_identifier_t *identifier = NULL;
sandesha2_last_msg_number_t *last_msg_number = NULL;
sandesha2_seq_property_bean_t *last_out_msg_no_bean = NULL;
ref_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env);
/*axis2_msg_ctx_set_keep_alive(ref_msg_ctx, env, AXIS2_TRUE);*/
if(!ref_msg_ctx)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX,
AXIS2_FAILURE);
return NULL;
}
conf_ctx = axis2_msg_ctx_get_conf_ctx(ref_msg_ctx, env);
if(!conf_ctx)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE);
return NULL;
}
terminate_seq_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, ref_rm_msg);
terminate_seq_msg_id = (axis2_char_t*)axis2_msg_ctx_get_msg_id(
terminate_seq_msg_ctx, env);
rm_version = sandesha2_utils_get_rm_version(env, ref_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);
sandesha2_msg_creator_init_creation(env, ref_msg_ctx, terminate_seq_msg_ctx);
is_seq_res_reqd = sandesha2_spec_specific_consts_is_term_seq_res_reqd(env, rm_version);
if(!is_seq_res_reqd)
{
axis2_msg_ctx_set_property(terminate_seq_msg_ctx, env, AXIS2_TRANSPORT_IN, NULL);
}
terminate_rm_msg = sandesha2_msg_init_init_msg(env, terminate_seq_msg_ctx);
if(!terminate_rm_msg)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX, AXIS2_FAILURE);
return NULL;
}
temp_msg_id = axutil_uuid_gen(env);
axis2_msg_ctx_set_message_id(terminate_seq_msg_ctx, env, temp_msg_id);
AXIS2_FREE(env->allocator, temp_msg_id);
temp_envelope = sandesha2_msg_ctx_get_soap_envelope(ref_rm_msg, env);
soap_version = sandesha2_utils_get_soap_version(env, temp_envelope);
terminate_seq = sandesha2_terminate_seq_create(env, rm_ns_value);
identifier = sandesha2_identifier_create(env, rm_ns_value);
sandesha2_identifier_set_identifier(identifier, env, seq_id);
sandesha2_terminate_seq_set_identifier(terminate_seq, env, identifier);
sandesha2_msg_ctx_set_terminate_seq(terminate_rm_msg, env, terminate_seq);
if(is_seq_res_reqd)
{
last_out_msg_no_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
internal_seq_id, SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NUMBER);
}
if(last_out_msg_no_bean)
{
axis2_char_t *msg_no_str = NULL;
long last_msg_num = -1;
msg_no_str = sandesha2_seq_property_bean_get_value(last_out_msg_no_bean, env);
if(msg_no_str)
{
last_msg_num = atol(msg_no_str);
}
last_msg_number = sandesha2_last_msg_number_create(env, rm_ns_value);
if(last_msg_number)
{
sandesha2_last_msg_number_set_last_msg_number(last_msg_number, env, last_msg_num);
sandesha2_terminate_seq_set_last_msg_number(terminate_seq, env, last_msg_number);
}
sandesha2_seq_property_bean_free(last_out_msg_no_bean, env);
}
sandesha2_msg_creator_finalize_creation(env, ref_msg_ctx, terminate_seq_msg_ctx);
axis2_msg_ctx_set_property(terminate_seq_msg_ctx, env, AXIS2_TRANSPORT_IN, NULL);
return terminate_rm_msg;
}
axis2_status_t
axis2_amqp_process_request(
const axutil_env_t* env,
axis2_amqp_request_processor_resource_pack_t* request_resource_pack)
{
axiom_xml_reader_t* xml_reader = NULL;
axiom_stax_builder_t* stax_builder = NULL;
axiom_soap_builder_t* soap_builder = NULL;
axis2_transport_out_desc_t* out_desc = NULL;
axis2_transport_in_desc_t* in_desc = NULL;
axis2_msg_ctx_t* msg_ctx = NULL;
axiom_soap_envelope_t* soap_envelope = NULL;
axis2_engine_t* engine = NULL;
const axis2_char_t* soap_ns_uri = NULL;
axis2_bool_t is_soap_11 = AXIS2_FALSE;
axis2_char_t *soap_body_str = NULL;
int soap_body_len = 0;
axis2_bool_t is_mtom = AXIS2_FALSE;
axis2_status_t status = AXIS2_FAILURE;
axutil_hash_t *binary_data_map = NULL;
axiom_soap_body_t *soap_body = NULL;
axutil_property_t* reply_to_property = NULL;
/* Create msg_ctx */
if(!request_resource_pack->conf_ctx)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Conf Context not Available");
return AXIS2_FAILURE;
}
out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(
request_resource_pack->conf_ctx, env), env, AXIS2_TRANSPORT_ENUM_AMQP);
if(!out_desc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport Out Descriptor not Found");
return AXIS2_FAILURE;
}
in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(request_resource_pack->conf_ctx,
env), env, AXIS2_TRANSPORT_ENUM_AMQP);
if(!in_desc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport In Descriptor not Found");
return AXIS2_FAILURE;
}
/* Create msg_ctx */
msg_ctx = axis2_msg_ctx_create(env, request_resource_pack->conf_ctx, in_desc, out_desc);
axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE);
/* Handle MTOM */
if(strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_MULTIPART_RELATED))
{
axis2_char_t* mime_boundary = axis2_amqp_util_get_value_from_content_type(env,
request_resource_pack->content_type, AXIS2_AMQP_HEADER_CONTENT_TYPE_MIME_BOUNDARY);
if(mime_boundary)
{
axiom_mime_parser_t *mime_parser = NULL;
int soap_body_len = 0;
axutil_param_t *buffer_size_param = NULL;
axutil_param_t *max_buffers_param = NULL;
axutil_param_t *attachment_dir_param = NULL;
axis2_char_t *value_size = NULL;
axis2_char_t *value_num = NULL;
axis2_char_t *value_dir = NULL;
int size = 0;
int num = 0;
mime_parser = axiom_mime_parser_create(env);
buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE);
if(buffer_size_param)
{
value_size = (axis2_char_t*)axutil_param_get_value(buffer_size_param, env);
if(value_size)
{
size = atoi(value_size);
axiom_mime_parser_set_buffer_size(mime_parser, env, size);
}
}
max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS);
if(max_buffers_param)
{
value_num = (axis2_char_t*)axutil_param_get_value(max_buffers_param, env);
if(value_num)
{
num = atoi(value_num);
axiom_mime_parser_set_max_buffers(mime_parser, env, num);
}
}
/* If this paramter is there mime_parser will cached the attachment
* using to the directory for large attachments. */
attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR);
if(attachment_dir_param)
{
value_dir = (axis2_char_t*)axutil_param_get_value(attachment_dir_param, env);
if(value_dir)
{
axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir);
}
}
if(mime_parser)
{
axis2_callback_info_t *callback_ctx = NULL;
axutil_stream_t *stream = NULL;
callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t));
stream = axutil_stream_create_basic(env);
if(stream)
{
axutil_stream_write(stream, env, request_resource_pack->request_content,
request_resource_pack->content_length);
callback_ctx->env = env;
callback_ctx->in_stream = stream;
callback_ctx->content_length = request_resource_pack->content_length;
callback_ctx->unread_len = request_resource_pack->content_length;
callback_ctx->chunked_stream = NULL;
}
/*binary_data_map =
axiom_mime_parser_parse(mime_parser, env,
axis2_amqp_util_on_data_request,
(void*)callback_ctx,
mime_boundary);*/
if(!binary_data_map)
{
return AXIS2_FAILURE;
}
soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env);
soap_body_len = axiom_mime_parser_get_soap_body_len(mime_parser, env);
axutil_stream_free(stream, env);
AXIS2_FREE(env->allocator, callback_ctx);
axiom_mime_parser_free(mime_parser, env);
}
AXIS2_FREE(env->allocator, mime_boundary);
}
is_mtom = AXIS2_TRUE;
}
else
{
soap_body_str = request_resource_pack->request_content;
soap_body_len = request_resource_pack->content_length;
}
soap_body_len = axutil_strlen(soap_body_str);
xml_reader = axiom_xml_reader_create_for_memory(env, soap_body_str, soap_body_len, NULL,
AXIS2_XML_PARSER_TYPE_BUFFER);
if(!xml_reader)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create XML Reader");
return AXIS2_FAILURE;
}
stax_builder = axiom_stax_builder_create(env, xml_reader);
if(!stax_builder)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create StAX Builder");
return AXIS2_FAILURE;
}
soap_ns_uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
if(request_resource_pack->content_type)
{
if(strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML))
{
is_soap_11 = AXIS2_TRUE;
soap_ns_uri = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI;
}
/*if (strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_APPL_SOAP))
{
is_soap_11 = AXIS2_FALSE;
soap_ns_uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
}
else if (strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML))
{
is_soap_11 = AXIS2_TRUE;
soap_ns_uri = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI;
}*/
}
soap_builder = axiom_soap_builder_create(env, stax_builder, soap_ns_uri);
if(!soap_builder)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create SOAP Builder");
return AXIS2_FAILURE;
}
if(binary_data_map)
{
axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map);
}
soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env);
axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope);
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if(!soap_body)
{
return AXIS2_FAILURE;
}
/* SOAPAction */
if(request_resource_pack->soap_action)
{
axis2_msg_ctx_set_soap_action(msg_ctx, env, axutil_string_create(env,
request_resource_pack->soap_action));
}
/* SOAP version */
axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap_11);
/* Set ReplyTo in the msg_ctx as a property. This is used by the server when
* 1. WS-A is not in use
* 2. ReplyTo is an anonymous EPR - Sandesha2/Dual-channel */
reply_to_property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, 0, 0,
(void*)request_resource_pack->reply_to);
axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO,
reply_to_property);
engine = axis2_engine_create(env, request_resource_pack->conf_ctx);
if(AXIS2_TRUE == axiom_soap_body_has_fault(soap_body, env))
{
status = axis2_engine_receive_fault(engine, env, msg_ctx);
}
else
{
status = axis2_engine_receive(engine, env, msg_ctx);
}
if(engine)
{
axis2_engine_free(engine, env);
}
if(soap_body_str && is_mtom)
{
AXIS2_FREE(env->allocator, soap_body_str);
}
return status;
}
/**
* This function is invoked in RM 1.1 where client explicitly send the
* terminate sequence message
*/
static axis2_status_t AXIS2_CALL
sandesha2_terminate_seq_msg_processor_process_out_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_seq_property_mgr_t *seq_prop_mgr = NULL;
sandesha2_create_seq_mgr_t *create_seq_mgr = NULL;
sandesha2_sender_mgr_t *sender_mgr = NULL;
axis2_char_t *to_address = NULL;
axis2_char_t *seq_key = NULL;
axis2_char_t *int_seq_id = NULL;
axis2_char_t *out_seq_id = NULL;
axutil_property_t *property = NULL;
axis2_char_t *terminated = NULL;
axis2_op_t *old_op = NULL;
axis2_op_t *out_in_op = NULL;
axutil_qname_t *qname = NULL;
sandesha2_terminate_seq_t *term_seq_part = NULL;
axis2_char_t *rm_version = NULL;
axis2_char_t *transport_to = NULL;
sandesha2_seq_property_bean_t *term_added = NULL;
axis2_char_t *temp_action = NULL;
axutil_string_t *soap_action = NULL;
axis2_char_t *dbname = NULL;
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[sandesha2]Entry:sandesha2_terminate_seq_msg_processor_process_out_msg.");
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;
}
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);
to_address = (axis2_char_t*)axis2_endpoint_ref_get_address(axis2_msg_ctx_get_to(msg_ctx, env),
env);
property = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_SEQ_KEY);
if(property)
{
seq_key = axutil_property_get_value(property, env);
}
int_seq_id = sandesha2_utils_get_client_internal_sequence_id(env, to_address, seq_key);
out_seq_id = sandesha2_utils_get_seq_property(env, int_seq_id,
SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_SEQUENCE_ID, seq_prop_mgr);
if(!out_seq_id)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]seq_id was not found. Cannot send the terminate message");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_SEQ_ID, AXIS2_FAILURE);
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;
}
terminated = sandesha2_utils_get_seq_property(env, int_seq_id,
SANDESHA2_SEQ_PROP_TERMINATE_ADDED, seq_prop_mgr);
old_op = axis2_msg_ctx_get_op(msg_ctx, env);
qname = axutil_qname_create(env, "temp", NULL, NULL);
out_in_op = axis2_op_create_with_qname(env, qname);
if(qname)
{
axutil_qname_free(qname, env);
}
axis2_op_set_msg_exchange_pattern(out_in_op, env, AXIS2_MEP_URI_OUT_IN);
axis2_op_set_in_flow(out_in_op, env, axis2_op_get_in_flow(old_op, env));
if(terminated && !axutil_strcmp(terminated, AXIS2_VALUE_TRUE))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate was added previously");
if(terminated)
{
AXIS2_FREE(env->allocator, terminated);
}
if(out_seq_id)
{
AXIS2_FREE(env->allocator, out_seq_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);
}
return AXIS2_SUCCESS;
}
if(terminated)
{
AXIS2_FREE(env->allocator, terminated);
}
term_seq_part = sandesha2_msg_ctx_get_terminate_seq(rm_msg_ctx, env);
sandesha2_identifier_set_identifier(sandesha2_terminate_seq_get_identifier(term_seq_part, env),
env, out_seq_id);
sandesha2_msg_ctx_set_flow(rm_msg_ctx, env, AXIS2_OUT_FLOW);
property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, property);
axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, to_address));
rm_version = sandesha2_utils_get_rm_version(env, msg_ctx);
if(!rm_version)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2] Cant find the rm_version of the given message");
if(out_seq_id)
{
AXIS2_FREE(env->allocator, out_seq_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);
}
return AXIS2_FAILURE;
}
axis2_msg_ctx_set_wsa_action(msg_ctx, env,
sandesha2_spec_specific_consts_get_terminate_seq_action(env, rm_version));
temp_action = sandesha2_spec_specific_consts_get_terminate_seq_soap_action(env, rm_version);
soap_action = axutil_string_create(env, temp_action);
axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action);
transport_to = sandesha2_utils_get_seq_property(env, int_seq_id,
SANDESHA2_SEQ_PROP_TRANSPORT_TO, seq_prop_mgr);
if(transport_to)
{
axis2_msg_ctx_set_transport_url(msg_ctx, env, transport_to);
AXIS2_FREE(env->allocator, transport_to);
}
if(!sandesha2_util_is_ack_already_piggybacked(env, rm_msg_ctx))
{
sandesha2_ack_mgr_piggyback_acks_if_present(env, out_seq_id, rm_msg_ctx, storage_mgr,
seq_prop_mgr, sender_mgr);
}
term_added = sandesha2_seq_property_bean_create(env);
sandesha2_seq_property_bean_set_name(term_added, env, SANDESHA2_SEQ_PROP_TERMINATE_ADDED);
sandesha2_seq_property_bean_set_seq_id(term_added, env, int_seq_id);
if(out_seq_id)
{
AXIS2_FREE(env->allocator, out_seq_id);
}
sandesha2_seq_property_bean_set_value(term_added, env, AXIS2_VALUE_TRUE);
sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, term_added);
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_terminate_seq_msg_processor_process_out_msg");
return AXIS2_SUCCESS;
}
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_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;
}
