/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <axis2_http_transport_sender.h>
#include <axutil_string.h>
#include <axis2_endpoint_ref.h>
#include <axis2_addr.h>
#include <axiom_xml_writer.h>
#include <axiom_output.h>
#include <axis2_http_transport_utils.h>
#include <axutil_generic_obj.h>
#include <axis2_http_out_transport_info.h>
#include <axis2_http_transport.h>
#include <axis2_http_sender.h>
#include <axiom_soap_body.h>
#include <axutil_types.h>
#include <axiom_soap_fault_detail.h>
#include <axis2_msg_ctx.h>

#ifdef AXIS2_LIBCURL_ENABLED
#include "libcurl/axis2_libcurl.h"
#endif

#ifdef AXIS2_JSON_ENABLED
#include <axis2_json_writer.h>
#endif

/**
 * HTTP Transport Sender struct impl
 * Axis2 HTTP Transport Sender impl
 */

typedef struct axis2_http_transport_sender_impl
{
    axis2_transport_sender_t transport_sender;
    axis2_char_t *http_version;
    axis2_bool_t chunked;
    int connection_timeout;
    int so_timeout;
    axis2_bool_t keep_alive;
#ifdef AXIS2_LIBCURL_ENABLED
    axis2_libcurl_t *libcurl;
#endif
} axis2_http_transport_sender_impl_t;

#define AXIS2_WS_RM_ANONYMOUS_URL "http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id="
#define AXIS2_INTF_TO_IMPL(transport_sender) \
                         ((axis2_http_transport_sender_impl_t *)\
                     (transport_sender))

/***************************** Function headers *******************************/
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_invoke(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx);

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_clean_up(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx);

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_init(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_conf_ctx_t * conf_ctx,
    axis2_transport_out_desc_t * out_desc);

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_write_message(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx,
    axis2_endpoint_ref_t * epr,
    axiom_soap_envelope_t * out,
    axiom_output_t * om_output);

void AXIS2_CALL axis2_http_transport_sender_free(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env);

static const axis2_transport_sender_ops_t http_transport_sender_ops_var = {
    axis2_http_transport_sender_init, axis2_http_transport_sender_invoke,
    axis2_http_transport_sender_clean_up, axis2_http_transport_sender_free };

axis2_transport_sender_t *AXIS2_CALL
axis2_http_transport_sender_create(
    const axutil_env_t * env)
{
    axis2_http_transport_sender_impl_t *transport_sender_impl = NULL;

    transport_sender_impl = (axis2_http_transport_sender_impl_t *)AXIS2_MALLOC(env->allocator,
        sizeof(axis2_http_transport_sender_impl_t));

    if(!transport_sender_impl)
    {
        AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
    memset((void *)transport_sender_impl, 0, sizeof(axis2_http_transport_sender_impl_t));

    transport_sender_impl->http_version = axutil_strdup(env, AXIS2_HTTP_HEADER_PROTOCOL_11);
    transport_sender_impl->chunked = AXIS2_TRUE;
    transport_sender_impl->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
    transport_sender_impl->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT;
    transport_sender_impl->keep_alive = AXIS2_TRUE;
    transport_sender_impl->transport_sender.ops = &http_transport_sender_ops_var;

#ifdef AXIS2_LIBCURL_ENABLED
    transport_sender_impl->libcurl = axis2_libcurl_create(env);
    if (!transport_sender_impl->libcurl)
    {
        AXIS2_FREE(env->allocator, transport_sender_impl);
        AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }
#endif

    return &(transport_sender_impl->transport_sender);
}

void AXIS2_CALL
axis2_http_transport_sender_free(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env)
{

    axis2_http_transport_sender_impl_t *transport_sender_impl = NULL;
    if(!transport_sender)
    {
        return;
    }

    transport_sender_impl = AXIS2_INTF_TO_IMPL(transport_sender);

    if(transport_sender_impl->http_version)
    {
        AXIS2_FREE(env->allocator, transport_sender_impl->http_version);
        transport_sender_impl->http_version = NULL;
    }

#ifdef AXIS2_LIBCURL_ENABLED
    if (transport_sender_impl->libcurl)
    {
        axis2_libcurl_free(transport_sender_impl->libcurl, env);
    }
#endif

    AXIS2_FREE(env->allocator, transport_sender_impl);
    return;
}

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_invoke(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx)
{
    const axis2_char_t *char_set_enc = NULL;
    axutil_string_t *char_set_enc_str = NULL;
    axis2_endpoint_ref_t *epr = NULL;
    axis2_char_t *transport_url = NULL;
    axiom_xml_writer_t *xml_writer = NULL;
    axiom_output_t *om_output = NULL;
    axis2_char_t *buffer = NULL;
    axiom_soap_envelope_t *soap_data_out = NULL;
    axis2_bool_t do_mtom;
    axutil_property_t *property = NULL;
    axiom_node_t *data_out = NULL;
    int buffer_size = 0;
    axis2_status_t status = AXIS2_SUCCESS;
    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;
    axis2_bool_t fault = AXIS2_FALSE;

    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_sender_invoke");
    AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);

    char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env);
    if(char_set_enc_str)
    {
        char_set_enc = axutil_string_get_buffer(char_set_enc_str, env);
    }

    if(!char_set_enc)
    {
        axis2_op_ctx_t *op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
        if(op_ctx)
        {
            axis2_ctx_t *ctx = axis2_op_ctx_get_base(op_ctx, env);
            if(ctx)
            {
                property = axis2_ctx_get_property(ctx, env, AXIS2_CHARACTER_SET_ENCODING);
                if(property)
                {
                    char_set_enc = axutil_property_get_value(property, env);
                    property = NULL;
                }
            }
        }
    }

    /**
     * If we still can't find the char set enc we will
     * use default
     */
    if(!char_set_enc)
    {
        char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
    }

    do_mtom = axis2_http_transport_utils_do_write_mtom(env, msg_ctx);

    transport_url = axis2_msg_ctx_get_transport_url(msg_ctx, env);
    if(transport_url)
    {
        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "transport_url:%s", transport_url);
        epr = axis2_endpoint_ref_create(env, transport_url);
    }
    else
    {
        /* when transport url is not available in msg_ctx */
        axis2_endpoint_ref_t *ctx_epr = axis2_msg_ctx_get_to(msg_ctx, env);
        if(ctx_epr)
            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "ctx_epr:%s", axis2_endpoint_ref_get_address(
                ctx_epr, env));

        if(ctx_epr && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL_SUBMISSION,
            axis2_endpoint_ref_get_address(ctx_epr, env)) && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL,
            axis2_endpoint_ref_get_address(ctx_epr, env)) && !(axutil_strstr(
            axis2_endpoint_ref_get_address(ctx_epr, env), AXIS2_WS_RM_ANONYMOUS_URL)))
        {
            epr = ctx_epr;
        }
    }

    soap_data_out = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
    if(!soap_data_out)
    {
        AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_SOAP_ENVELOPE_IN_MSG_CTX, AXIS2_FAILURE);
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", AXIS2_ERROR_GET_MESSAGE(env->error));
        return AXIS2_SUCCESS;
    }

#ifdef AXIS2_JSON_ENABLED
    if (AXIS2_TRUE == axis2_msg_ctx_get_doing_json(msg_ctx, env))
    {
        axis2_json_writer_t* json_writer;
        axiom_node_t *body_node = NULL;
        axiom_soap_body_t* soap_body =
                axiom_soap_envelope_get_body(soap_data_out, env);
        axutil_stream_t* out_stream =
            axis2_msg_ctx_get_transport_out_stream(msg_ctx, env);

        if (!soap_body)
        {
            AXIS2_ERROR_SET(env->error,
                    AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
                    AXIS2_FAILURE);
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
                    AXIS2_ERROR_GET_MESSAGE(env->error));
            return AXIS2_FAILURE;
        }

        body_node = axiom_soap_body_get_base_node(soap_body, env);
        if (!body_node)
        {
            return AXIS2_FAILURE;
        }

        data_out = axiom_node_get_first_element(body_node, env);
        if (!data_out || axiom_node_get_node_type(data_out, env)
                != AXIOM_ELEMENT)
        {
            return AXIS2_FAILURE;
        }

        json_writer = axis2_json_writer_create(env);
        if (!json_writer)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                            "Failed to create JSON writer");
            return AXIS2_FAILURE;
        }

        axis2_json_writer_write(json_writer, data_out, env);

        buffer = (axis2_char_t*)axis2_json_writer_get_json_string(
                    json_writer, env, &buffer_size);
        if (!buffer)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                            "Failed to get resulting JSON string");
            return AXIS2_FAILURE;
        }

        if (AXIS2_TRUE == axis2_msg_ctx_get_server_side(msg_ctx, env))
        {
            axis2_op_ctx_t *op_ctx = NULL;
            axis2_http_out_transport_info_t* out_info =
                    (axis2_http_out_transport_info_t *)
                    axis2_msg_ctx_get_out_transport_info(msg_ctx, env);

            if (!out_info)
            {
                AXIS2_HANDLE_ERROR(env,
                                   AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL,
                                   AXIS2_FAILURE);
                return AXIS2_FAILURE;
            }

            AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(
                        out_info, env, char_set_enc);
            AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(
                        out_info, env, AXIS2_HTTP_HEADER_ACCEPT_JSON);
            op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
            axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE);
        }

        axutil_stream_write(out_stream, env, buffer, buffer_size);

        axis2_json_writer_free(json_writer, env);

        return AXIS2_SUCCESS;
    }
#endif

    xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
        AXIS2_XML_PARSER_TYPE_BUFFER);
    if(!xml_writer)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
            "Could not create xml_writer for \
AXIS2_XML_PARSER_TYPE_BUFFER");
        return AXIS2_FAILURE;
    }

    om_output = axiom_output_create(env, xml_writer);
    if(!om_output)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
            "Could not create om_output for xml writer of \
AXIS2_XML_PARSER_TYPE_BUFFER");
        axiom_xml_writer_free(xml_writer, env);
        xml_writer = NULL;
        return AXIS2_FAILURE;
    }

    /* setting SOAP version for OM_OUTPUT.  */
    axiom_output_set_soap11(om_output, env, axis2_msg_ctx_get_is_soap_11(msg_ctx, env));

    /* This is the case where normal client send the requet using a http_client*/

    if(epr)
    {
        if(axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, axis2_endpoint_ref_get_address(epr, env))
            == 0 || axutil_strcmp(AXIS2_WSA_NONE_URL, axis2_endpoint_ref_get_address(epr, env))
            == 0)
        {
            epr = NULL;
        }
        else
        {
            status = axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx, epr,
                soap_data_out, om_output);
        }
    }

    /* If no endpoint reference could be derived from the the message context. It could well be the
     * single channel two way scenario in the application server side send.
     */
    if(!epr)
    {
        axutil_stream_t *out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env);

        if(AXIS2_TRUE == axis2_msg_ctx_get_server_side(msg_ctx, env))
        {
            axis2_http_out_transport_info_t *out_info = NULL;
            axis2_bool_t is_soap11 = AXIS2_FALSE;
            axis2_op_ctx_t *op_ctx = NULL;
            /*axis2_char_t *header_value = NULL;*/

            out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info(
                msg_ctx, env);

            if(!out_info)
            {
                AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE);
                axiom_output_free(om_output, env);
                om_output = NULL;
                xml_writer = NULL;
                return AXIS2_FAILURE;
            }
            /*header_value = axis2_http_transport_utils_get_session(env, msg_ctx);
            if(header_value)
            {
                AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value);
            }*/

            is_soap11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env);

            AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_info, env, char_set_enc);
            if(AXIS2_TRUE == is_soap11)
            {
                /* SOAP1.1 */
                AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env,
                    AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML);
            }
            else
            {
                /* SOAP1.2 */
                AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env,
                    AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP);
            }

            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)
            {
                /* get access to HTTP transport for sending */
                trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP);
            }

            if(trans_desc)
            {

                /* accessing parameter in axis2.xml which set to have
                 * an ability to send xml versoin processing
                 * instruction <?xml version = "1.0"?> */
                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)
                {
                    /* Accessing attribute values */
                    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(AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env))
            {
                axiom_node_t *body_node = NULL;
                /* axis2_bool_t fault = AXIS2_FALSE;*/
                axiom_soap_fault_t *soap_fault;
                axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_data_out, env);
                axiom_soap_fault_detail_t *soap_fault_detial;

                if(!soap_body)
                {
                    AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
                        AXIS2_FAILURE);
                    axiom_output_free(om_output, env);
                    om_output = NULL;
                    xml_writer = NULL;
                    return AXIS2_FAILURE;
                }

                fault = axiom_soap_body_has_fault(soap_body, env);

                if(fault == AXIS2_TRUE)
                {
                    soap_fault = axiom_soap_body_get_fault(soap_body, env);

                    if(!soap_fault)
                    {

                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                            "Rest fault has occur, error described below");
                        axiom_output_free(om_output, env);
                        om_output = NULL;
                        xml_writer = NULL;
                        return AXIS2_FAILURE;
                    }

                    soap_fault_detial = axiom_soap_fault_get_detail(soap_fault, env);

                    if(!soap_fault_detial)
                    {
                        axiom_output_free(om_output, env);
                        om_output = NULL;
                        xml_writer = NULL;
                        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                            "Returning failure to obtain soap_fault_detail from soap_fault");
                        return AXIS2_FAILURE;
                    }

                    body_node = axiom_soap_fault_detail_get_base_node(soap_fault_detial, env);
                    if(!body_node)
                    {
                        axiom_output_free(om_output, env);
                        om_output = NULL;
                        xml_writer = NULL;
                        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                            "failure to get base node from soap_fault_detail.");
                        return AXIS2_FAILURE;
                    }

                }
                else
                {

                    body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(!body_node)
                    {
                        axiom_output_free(om_output, env);
                        om_output = NULL;
                        xml_writer = NULL;
                        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                            "failure to get base node from soap_body.");
                        return AXIS2_FAILURE;
                    }
                }

                data_out = axiom_node_get_first_element(body_node, env);

                if(!data_out || axiom_node_get_node_type(data_out, env) != AXIOM_ELEMENT)
                {
                    axiom_output_free(om_output, env);
                    om_output = NULL;
                    xml_writer = NULL;
                    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                        "unable to get first element from soap_body, base node.");
                    return AXIS2_FAILURE;
                }

                axiom_node_serialize(data_out, env, om_output);
                buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env);
                buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env);
                axutil_stream_write(out_stream, env, buffer, buffer_size);
                /* Finish Rest Processing */

            }
            else
            {
                axiom_soap_body_t *body = NULL;

                body = axiom_soap_envelope_get_body(soap_data_out, env);
                fault = axiom_soap_body_has_fault(body, env);

                /* SOAP Processing */
                axiom_output_set_do_optimize(om_output, env, do_mtom);
                axiom_soap_envelope_serialize(soap_data_out, env, om_output, AXIS2_FALSE);
                if(do_mtom && !fault)
                {
                    axis2_status_t mtom_status = AXIS2_FAILURE;
                    axis2_char_t *content_type = NULL;
                    axutil_array_list_t *mime_parts = NULL;

                    /*Create the attachment related data and put them to an
                     *array_list */
                    mtom_status = axiom_output_flush(om_output, env);
                    if(mtom_status == AXIS2_SUCCESS)
                    {
                        mime_parts = axiom_output_get_mime_parts(om_output, env);
                        if(!mime_parts)
                        {
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                                "Unable to create the mime_part list from om_output");
                            return AXIS2_FAILURE;
                        }
                        else
                        {
                            axis2_msg_ctx_set_mime_parts(msg_ctx, env, mime_parts);
                        }
                    }
                    /*om_out put has the details of content_type */
                    content_type = (axis2_char_t *)axiom_output_get_content_type(om_output, env);
                    AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, content_type);
                }
                else
                {
                    buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env);
                    buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env);

                    /* This is where it actually fill the buffer in out_stream. In application server
                     * side this is the out_stream passed to the in message context from http_worker
                     * function and then copied to the out message context. 
                     */
                    axutil_stream_write(out_stream, env, buffer, buffer_size);
                }
            }

            op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
            axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE);
        }
    }

    axiom_output_free(om_output, env);
    om_output = NULL;
    xml_writer = NULL;

    if(transport_url)
    {
        if(epr)
        {
            axis2_endpoint_ref_free(epr, env);
            epr = NULL;
        }
    }
    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_sender_invoke");
    return status;
}

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_clean_up(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx)
{
    AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE);
    /*
     * Clean up is not used. If the http sender needs
     * to be cleaned up it should be done here.
     */
    return AXIS2_SUCCESS;
}

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_init(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_conf_ctx_t * conf_ctx,
    axis2_transport_out_desc_t * out_desc)
{
    axutil_param_t *version_param = NULL;
    axis2_char_t *version = NULL;
    axis2_char_t *temp = NULL;
    axutil_param_t *temp_param = NULL;

    AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE);

    /* Getting HTTP version from axis2.xml */
    version_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container(
        out_desc, env), env, AXIS2_HTTP_PROTOCOL_VERSION);

    if(version_param)
    {
        version = axutil_param_get_value(version_param, env);
    }

    if(version)
    {
        /* handling HTTP 1.1 */
        if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_11))
        {
            axis2_char_t *encoding = NULL;
            axutil_param_t *encoding_param = NULL;
            if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version)
            {
                AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version);
            }

            AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version);
            AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_TRUE;
            encoding_param = axutil_param_container_get_param(
                axis2_transport_out_desc_param_container(out_desc, env), env,
                AXIS2_HTTP_HEADER_TRANSFER_ENCODING);

            if(encoding_param)
            {
                encoding = axutil_param_get_value(encoding_param, env);
            }

            if(encoding && 0
                == axutil_strcmp(encoding, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
            {
                AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_TRUE;
            }
            else
            {
                AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE;
            }

        }
        else if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_10))
        {
            axutil_param_t *keepalive_param = NULL;

            /* Handling HTTP 1.0 */
            if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version)
            {
                AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version);
            }
            AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version);
            AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE;
            keepalive_param = axutil_param_container_get_param(
                    axis2_transport_out_desc_param_container(out_desc, env), env, 
                    AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE);
            if(keepalive_param)
            {
                axis2_char_t *keepalive_value = NULL;
                keepalive_value = axutil_param_get_value(keepalive_param, env);
                if(!axutil_strcmp(keepalive_value, AXIS2_VALUE_FALSE))
                {
                    AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_FALSE;
                }
            }
        }
    }
    else
    {
        /* HTTP version is not available in axis2.xml */
        AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE);
        return AXIS2_FAILURE;
    }

    /* Getting HTTP_SO_TIMEOUT value from axis2.xml */
    temp_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container(
        out_desc, env), env, AXIS2_HTTP_SO_TIMEOUT);

    if(temp_param)
    {
        temp = axutil_param_get_value(temp_param, env);
    }

    if(temp)
    {
        AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp);
    }

    /* Getting HTTP_CONNECTION_TIMEOUT from axis2.xml */
    temp
        = (axis2_char_t *)axutil_param_container_get_param(
            axis2_transport_out_desc_param_container(out_desc, env), env,
            AXIS2_HTTP_CONNECTION_TIMEOUT);
    if(temp_param)
    {
        temp = axutil_param_get_value(temp_param, env);
    }

    /* set axis2.xml connection timeout value to http_sender */
    if(temp)
    {
        AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout = AXIS2_ATOI(temp);
    }

    return AXIS2_SUCCESS;
}

axis2_status_t AXIS2_CALL
axis2_http_transport_sender_write_message(
    axis2_transport_sender_t * transport_sender,
    const axutil_env_t * env,
    axis2_msg_ctx_t * msg_ctx,
    axis2_endpoint_ref_t * epr,
    axiom_soap_envelope_t * out,
    axiom_output_t * om_output)
{
    const axis2_char_t *soap_action = NULL;
    const axis2_char_t *url = NULL;
    axis2_http_sender_t *sender = NULL;
    axis2_status_t status = AXIS2_FAILURE;
    const axis2_char_t *soap_ns_uri = NULL;
    axiom_soap_envelope_t *response_envelope = NULL;
    axis2_op_t *op = NULL;

    AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, epr, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, out, AXIS2_FAILURE);

    /* epr is already passed NULL checking */
    url = axis2_endpoint_ref_get_address(epr, env);

    soap_action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env);

    if(!soap_action)
    {
        soap_action = "";
    }

    sender = axis2_http_sender_create(env);

    if(!sender)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "http sender creation failed");
        return AXIS2_FAILURE;
    }
    axis2_http_sender_set_keep_alive(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive);

    /* For the MTOM case we should on chunking. And for chunking to work the
     * protocol should be http 1.1*/

    if(axis2_msg_ctx_get_doing_mtom(msg_ctx, env))
    {
        AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_TRUE);
        AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, AXIS2_HTTP_HEADER_PROTOCOL_11);
    }
    else
    {
        AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->chunked);
        AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env,
            AXIS2_INTF_TO_IMPL(transport_sender)->http_version);
    }
    AXIS2_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output);

#ifdef AXIS2_LIBCURL_ENABLED
    AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "using axis2 libcurl http sender.");
    status =
    axis2_libcurl_http_send(AXIS2_INTF_TO_IMPL(transport_sender)->libcurl,
        sender, env, msg_ctx, out, url, soap_action);
#else
    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "using axis2 native http sender.");
    status = AXIS2_HTTP_SENDER_SEND(sender, env, msg_ctx, out, url, soap_action);
#endif


    /* if the send was not successful, do not process any response */
    if(status != AXIS2_SUCCESS)
    {
        AXIS2_HTTP_SENDER_FREE(sender, env);
        sender = NULL;
        return status;
    }

    op = axis2_msg_ctx_get_op(msg_ctx, env);
    if(op)
    {
        /* handle one way case */
        const axis2_char_t *mep = axis2_op_get_msg_exchange_pattern(op, env);
        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "OP name axutil_qname_get_localpart = %s", mep);
        if(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 || axutil_strcmp(mep,
            AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0 || axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) == 0)
        {
            AXIS2_HTTP_SENDER_FREE(sender, env);
            sender = NULL;
            return status;
        }
        else
        {
            /* AXIS2_MEP_URI_IN_OUT case , we have a response this
             * time */
            soap_ns_uri
                = axis2_msg_ctx_get_is_soap_11(msg_ctx, env) ? AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI
                    : AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
            response_envelope = axis2_http_transport_utils_create_soap_msg(env, msg_ctx,
                soap_ns_uri);
            if(response_envelope)
            {
                axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, response_envelope);
            }
        }
    }

    AXIS2_HTTP_SENDER_FREE(sender, env);
    sender = NULL;

    return status;
}

/**
 * Following block distinguish the exposed part of the dll.
 */

/* When building for static deployment, give the get and remove methods
 * unique names.  This avoids having the linker fail with duplicate symbol
 * errors.
 */

AXIS2_EXPORT int
#ifndef AXIS2_STATIC_DEPLOY
axis2_get_instance(
#else
    axis2_http_transport_sender_get_instance(
#endif
    struct axis2_transport_sender **inst,
    const axutil_env_t * env)
{
    *inst = axis2_http_transport_sender_create(env);
    if(!(*inst))
    {
        return AXIS2_FAILURE;
    }

    return AXIS2_SUCCESS;
}

AXIS2_EXPORT int
#ifndef AXIS2_STATIC_DEPLOY
axis2_remove_instance(
#else
    axis2_http_transport_sender_remove_instance(
#endif
    axis2_transport_sender_t * inst,
    const axutil_env_t * env)
{
    if(inst)
    {
        AXIS2_TRANSPORT_SENDER_FREE(inst, env);
    }
    return AXIS2_SUCCESS;
}