/************************ Basic Stream Operations *****************************/
AXIS2_EXTERN axutil_stream_t *AXIS2_CALL
axutil_stream_create_basic(
const axutil_env_t *env)
{
axutil_stream_t *stream = NULL;
AXIS2_ENV_CHECK(env, NULL);
stream = axutil_stream_create_internal(env);
if(!stream)
{
/*
* We leave the error returned by the
* axutil_stream_create_internal intact
*/
return NULL;
}
stream->stream_type = AXIS2_STREAM_BASIC;
stream->read = axutil_stream_read_basic;
stream->write = axutil_stream_write_basic;
stream->skip = axutil_stream_skip_basic;
stream->buffer = (axis2_char_t *)AXIS2_MALLOC(env->allocator, AXIS2_STREAM_DEFAULT_BUF_SIZE
* sizeof(axis2_char_t));
stream->buffer_head = stream->buffer;
stream->len = 0;
stream->max_len = AXIS2_STREAM_DEFAULT_BUF_SIZE;
if(!stream->buffer)
{
axutil_stream_free(stream, env);
return NULL;
}
return stream;
}
void AXIS2_CALL
axutil_stream_free_void_arg(
void *stream,
const axutil_env_t *env)
{
axutil_stream_t *stream_l = NULL;
stream_l = (axutil_stream_t *)stream;
axutil_stream_free(stream_l, env);
return;
}
/** Close down a stream and perform any cleanup.
* @param env
* @param sstream
*/
void
sp_stream_cleanup(
const axutil_env_t *env,
axutil_stream_t *sstream)
{
if (AXIS2_SUCCESS != axutil_stream_close (sstream, env) )
{
p_log_error(env, "Error closing socket stream");
}
axutil_stream_free (sstream, env);
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_simple_http_svr_conn_close(
axis2_simple_http_svr_conn_t * svr_conn,
const axutil_env_t * env)
{
axutil_stream_free(svr_conn->stream, env);
if(-1 != svr_conn->socket)
{
axutil_network_handler_close_socket(env, svr_conn->socket);
svr_conn->socket = -1;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL
axis2_amqp_util_get_soap_envelope(
axis2_amqp_response_t* response,
const axutil_env_t* env,
axis2_msg_ctx_t* msg_ctx)
{
axiom_xml_reader_t* xml_reader = NULL;
axiom_stax_builder_t* stax_builder = NULL;
axiom_soap_builder_t* soap_builder = NULL;
axiom_soap_envelope_t* soap_envelope = NULL;
const axis2_char_t* soap_ns_uri = NULL;
axis2_char_t *soap_body_str = NULL;
int soap_body_len = 0;
axis2_bool_t is_mtom = AXIS2_FALSE;
axutil_hash_t *binary_data_map = NULL;
axis2_bool_t is_soap_11 = AXIS2_FALSE;
if(!response || !response->data || !response->content_type)
{
return NULL;
}
is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env);
/* Handle MTOM */
if(strstr(response->content_type, AXIS2_AMQP_HEADER_ACCEPT_MULTIPART_RELATED))
{
axis2_char_t* mime_boundary = axis2_amqp_util_get_value_from_content_type(env,
response->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);
}
}
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_callback_info_t*)AXIS2_MALLOC(env->allocator,
sizeof(axis2_callback_info_t));
stream = axutil_stream_create_basic(env);
if(stream)
{
axutil_stream_write(stream, env, response->data, response->length);
callback_ctx->env = env;
callback_ctx->in_stream = stream;
callback_ctx->content_length = response->length;
callback_ctx->unread_len = response->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_len = axiom_mime_parser_get_soap_body_len(mime_parser, env);
soap_body_str = axiom_mime_parser_get_soap_body_str(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 = response->data;
soap_body_len = axutil_strlen(response->data);
}
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 NULL;
}
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 NULL;
}
soap_ns_uri = is_soap_11 ? AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI
: AXIOM_SOAP12_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 NULL;
}
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);
return soap_envelope;
}
/** executes as new entry arises */
void *AXIS2_CALL
tcpmon_entry_new_entry_funct(
axutil_thread_t * thd,
void *data)
{
tcpmon_entry_request_data_t *req_data = (tcpmon_entry_request_data_t *) data;
const axutil_env_t *env = NULL;
int client_socket = -1;
int host_socket = -1;
tcpmon_session_t *session;
TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct;
TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry;
axutil_stream_t *client_stream = NULL;
axutil_stream_t *host_stream = NULL;
int buffer_size = 0;
axis2_char_t *headers = NULL;
axis2_char_t *content = NULL;
axis2_char_t *buffer = NULL;
time_t now;
struct tm *localTime = NULL;
int arrived_secs = 0;
int sent_secs = 0;
int time_diff_i = 0;
int target_port = 0;
axis2_char_t *target_host = NULL;
int test_bit = 0;
int format_bit = 0;
tcpmon_entry_t *entry = NULL;
tcpmon_entry_impl_t *entry_impl = NULL;
env = req_data->env;
client_socket = req_data->socket;
session = req_data->session;
on_trans_fault_funct = tcpmon_session_get_on_trans_fault(session, env);
on_new_entry = tcpmon_session_get_on_new_entry(session, env);
entry = tcpmon_entry_create(env);
entry_impl = AXIS2_INTF_TO_IMPL(entry);
target_port = TCPMON_SESSION_GET_TARGET_PORT(session, env);
target_host = TCPMON_SESSION_GET_TARGET_HOST(session, env);
if (target_port == -1 || target_host == NULL)
{
axutil_network_handler_close_socket(env, client_socket);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Missing target port and host"
"input missing");
if (on_trans_fault_funct)
{
(on_trans_fault_funct) (env, "Missing target port and host");
}
if (thd)
{
AXIS2_FREE(env->allocator, thd);
}
if (data)
{
AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
}
return NULL;
}
client_stream = axutil_stream_create_socket(env, client_socket);
if (!client_stream)
{
axutil_network_handler_close_socket(env, client_socket);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Error in creating client stream" "handling response");
/** call the callback */
if (on_trans_fault_funct)
{
(on_trans_fault_funct) (env, "error in creating the client stream");
}
if (thd)
{
AXIS2_FREE(env->allocator, thd);
}
if (data)
{
AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
}
return NULL;
}
buffer = tcpmon_util_read_current_stream(env, client_stream, &buffer_size,
&headers, &content);
headers =(char *) tcpmon_util_str_replace(env, headers,"localhost", target_host);
test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env);
if (test_bit)
{
tcpmon_util_write_to_file("reqest", buffer);
}
format_bit = TCPMON_SESSION_GET_FORMAT_BIT(session, env);
TCPMON_ENTRY_SET_FORMAT_BIT(entry, env, format_bit);
now = time(NULL);
localTime = localtime(&now);
sprintf(entry_impl->sent_time, "%d:%d:%d", localTime->tm_hour,
localTime->tm_min, localTime->tm_sec);
sent_secs =
localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 +
localTime->tm_sec;
/*free ( localTime); */
entry_impl->sent_headers = headers;
entry_impl->sent_data = content;
entry_impl->sent_data_length = buffer_size;
if (on_new_entry)
{
(on_new_entry) (env, entry, 0);
}
host_socket =
(int)axutil_network_handler_open_socket(env, target_host, target_port);
if (-1 == host_socket)
{
axutil_stream_write(client_stream, env, NULL, 0);
axutil_stream_free(client_stream, env);
axutil_network_handler_close_socket(env, client_socket);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host_socket"
"creating socket");
/** call the callback */
if (on_trans_fault_funct)
{
(on_trans_fault_funct) (env, "error in creating the host socket");
}
if (thd)
{
AXIS2_FREE(env->allocator, thd);
}
if (data)
{
AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
}
return NULL;
}
host_stream = axutil_stream_create_socket(env, host_socket);
if (!host_stream)
{
axutil_stream_write(client_stream, env, NULL, 0);
axutil_stream_free(client_stream, env);
axutil_network_handler_close_socket(env, client_socket);
axutil_network_handler_close_socket(env, host_socket);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host stream"
"handling response");
/** call the callback */
if (on_trans_fault_funct)
{
(on_trans_fault_funct) (env, "error in creating the host stream");
}
if (thd)
{
AXIS2_FREE(env->allocator, thd);
}
if (data)
{
AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
}
return NULL;
}
axutil_stream_write(host_stream, env, buffer, buffer_size);
AXIS2_FREE(env->allocator, buffer);
buffer = tcpmon_util_read_current_stream(env, host_stream, &buffer_size,
&headers, &content);
test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env);
if (test_bit)
{
tcpmon_util_write_to_file("response", buffer);
}
now = time(NULL);
localTime = localtime(&now);
sprintf(entry_impl->arrived_time, "%d:%d:%d", localTime->tm_hour,
localTime->tm_min, localTime->tm_sec);
arrived_secs =
localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 +
localTime->tm_sec;
/*free ( localTime); */
time_diff_i = arrived_secs - sent_secs;
if (time_diff_i < 0)
{
time_diff_i += 24 * 60 * 60;
}
sprintf(entry_impl->time_diff, "%d sec(s)", time_diff_i);
entry_impl->arrived_headers = headers;
entry_impl->arrived_data = content;
entry_impl->arrived_data_length = buffer_size;
if (buffer == NULL || buffer_size == 0)
{
entry_impl->is_success = 0;
}
else
{
entry_impl->is_success = 1;
}
if (on_new_entry)
{
(on_new_entry) (env, entry, 1);
}
axutil_stream_write(client_stream, env, buffer, buffer_size);
AXIS2_FREE(env->allocator, buffer);
axutil_stream_free(client_stream, env);
axutil_stream_free(host_stream, env);
axutil_network_handler_close_socket(env, client_socket);
axutil_network_handler_close_socket(env, host_socket);
if (entry_impl)
{
tcpmon_entry_free(&(entry_impl->entry), env);
}
if (thd)
{
AXIS2_FREE(env->allocator, thd);
}
if (data)
{
AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
}
return NULL;
}
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;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_http_client_free(
axis2_http_client_t * http_client,
const axutil_env_t * env)
{
if(http_client->proxy_host)
{
AXIS2_FREE(env->allocator, http_client->proxy_host);
}
if(http_client->proxy_host_port)
{
AXIS2_FREE(env->allocator, http_client->proxy_host_port);
}
if(http_client->url)
{
axutil_url_free(http_client->url, env);
}
if(http_client->response)
{
axis2_http_simple_response_free(http_client->response, env);
}
if(-1 != http_client->sockfd)
{
#ifdef AXIS2_SSL_ENABLED
if(http_client->data_stream)
{
if(http_client->data_stream->stream_type == AXIS2_STREAM_SOCKET)
{
axutil_network_handler_close_socket(env, http_client->sockfd);
/** ssl streams of type AXIS2_STREAM_BASIC will be handled by SSL_shutdown(); */
}
}
#else
axutil_network_handler_close_socket(env, http_client->sockfd);
#endif
http_client->sockfd = -1;
}
if(http_client->data_stream && http_client->owns_stream)
{
axutil_stream_free(http_client->data_stream,env);
}
if(http_client->req_body)
{
AXIS2_FREE(env->allocator, http_client->req_body);
}
/* There is no other appropriate place to free the mime_part list when a
* particular client send requests. */
if(http_client->mime_parts)
{
int i = 0;
for(i = 0; i < axutil_array_list_size(http_client->mime_parts, env); i++)
{
axiom_mime_part_t *mime_part = NULL;
mime_part = (axiom_mime_part_t *)axutil_array_list_get(http_client->mime_parts, env, i);
if(mime_part)
{
axiom_mime_part_free(mime_part, env);
}
}
axutil_array_list_free(http_client->mime_parts, env);
}
AXIS2_FREE(env->allocator, http_client);
return;
}
