axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nand...@apache.org
Subject svn commit: r892174 [2/2] - /webservices/axis2/trunk/c/src/core/transport/http/server/apache2/apache2_worker.c
Date Fri, 18 Dec 2009 08:20:00 GMT

Modified: webservices/axis2/trunk/c/src/core/transport/http/server/apache2/apache2_worker.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/transport/http/server/apache2/apache2_worker.c?rev=892174&r1=892173&r2=892174&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/transport/http/server/apache2/apache2_worker.c (original)
+++ webservices/axis2/trunk/c/src/core/transport/http/server/apache2/apache2_worker.c Fri Dec 18 08:19:57 2009
@@ -1,1548 +1,1676 @@
-/*
- * 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_apache2_worker.h"
-#include <axis2_http_transport.h>
-#include <axis2_conf.h>
-#include <axutil_string.h>
-#include <axis2_msg_ctx.h>
-#include <axis2_http_out_transport_info.h>
-#include <axis2_http_transport_utils.h>
-#include <axis2_http_accept_record.h>
-#include <axis2_op_ctx.h>
-#include <axis2_engine.h>
-#include <axutil_uuid_gen.h>
-#include <axis2_conf_init.h>
-#include "axis2_apache2_out_transport_info.h"
-#include <axutil_url.h>
-#include <http_core.h>
-#include <http_protocol.h>
-#include <axiom_soap.h>
-#include <axutil_class_loader.h>
-#include <axutil_string_util.h>
-#include <axiom_mime_part.h>
-#include <axiom_mtom_sending_callback.h>
-
-#define READ_SIZE  2048
-
-static axis2_status_t
-apache2_worker_send_mtom_message(
-    request_rec *request,
-    const axutil_env_t * env,
-    axutil_array_list_t *mime_parts,
-    axis2_char_t *mtom_sending_callback_name);
-
-static axis2_status_t
-apache2_worker_send_attachment_using_file(
-    const axutil_env_t * env,
-    request_rec *request,
-    FILE *fp,
-    axis2_byte_t *buffer,
-    int buffer_size);
-
-static axis2_status_t
-apache2_worker_send_attachment_using_callback(
-    const axutil_env_t * env,
-    request_rec *request,
-    axiom_mtom_sending_callback_t *callback,
-    void *handler,
-    void *user_param);
-
-struct axis2_apache2_worker
-{
-    axis2_conf_ctx_t *conf_ctx;
-};
-
-AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL
-axis2_apache2_worker_create(
-    const axutil_env_t * env,
-    axis2_char_t * repo_path)
-{
-    axis2_apache2_worker_t *apache2_worker = NULL;
-    axutil_hash_t* svc_map = NULL;
-    axis2_conf_t* conf = NULL;
-    axutil_hash_index_t *hi = NULL;
-    void* svc = NULL;
-    AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created");
-    apache2_worker = (axis2_apache2_worker_t *)AXIS2_MALLOC(env->allocator,
-        sizeof(axis2_apache2_worker_t));
-
-    if(!apache2_worker)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-    apache2_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path);
-
-    if(!apache2_worker->conf_ctx)
-    {
-        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
-        return NULL;
-    }
-
-    /*
-     * we have to load all the services. This is because, before the fork (in linux)
-     * we should have a full code segment. Otherwise, we can't share function pointers of services
-     * between processed. In fork, the code segment will be duplicated across processes
-     */
-    conf = axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env);
-    if(!conf)
-    {
-        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
-        return NULL;
-    }
-
-    svc_map = axis2_conf_get_all_svcs(conf, env);
-    if(!svc_map)
-    {
-        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
-        return NULL;
-    }
-
-    for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi))
-    {
-        void *impl_class = NULL;
-        axis2_msg_recv_t *msg_recv = NULL;
-        axutil_hash_t *ops_hash = NULL;
-
-        axutil_hash_this(hi, NULL, NULL, &svc);
-        if(!svc)
-            continue;
-        impl_class = axis2_svc_get_impl_class(svc, env);
-        if(impl_class)
-            continue;
-        ops_hash = axis2_svc_get_all_ops(svc, env);
-        if(ops_hash)
-        {
-            axutil_hash_index_t *op_hi = NULL;
-            void *op = NULL;
-            op_hi = axutil_hash_first(ops_hash, env);
-            if(op_hi)
-            {
-                axutil_hash_this(op_hi, NULL, NULL, &op);
-                if(op)
-                {
-                    msg_recv = axis2_op_get_msg_recv(op, env);
-                    if(msg_recv)
-                        axis2_msg_recv_load_and_init_svc(msg_recv, env, svc);
-                }
-            }
-
-        }
-    }
-
-    AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created");
-
-    return apache2_worker;
-}
-
-AXIS2_EXTERN void AXIS2_CALL
-axis2_apache2_worker_free(
-    axis2_apache2_worker_t * apache2_worker,
-    const axutil_env_t * env)
-{
-    AXIS2_ENV_CHECK(env, void);
-
-    if(apache2_worker->conf_ctx)
-    {
-        axis2_conf_ctx_free(apache2_worker->conf_ctx, env);
-        apache2_worker->conf_ctx = NULL;
-    }
-
-    AXIS2_FREE(env->allocator, apache2_worker);
-
-    return;
-}
-
-AXIS2_EXTERN int AXIS2_CALL
-axis2_apache2_worker_process_request(
-    axis2_apache2_worker_t * apache2_worker,
-    const axutil_env_t * env,
-    request_rec * request)
-{
-    axis2_conf_ctx_t *conf_ctx = NULL;
-    axis2_msg_ctx_t *msg_ctx = NULL;
-    axutil_stream_t *request_body = NULL;
-    axutil_stream_t *out_stream = NULL;
-    axis2_transport_out_desc_t *out_desc = NULL;
-    axis2_transport_in_desc_t *in_desc = NULL;
-    axis2_char_t *http_version = NULL;
-    axutil_string_t *soap_action = NULL;
-    axis2_char_t *soap_action_header_txt = NULL;
-    axis2_bool_t processed = AXIS2_FALSE;
-    int content_length = -1;
-    axis2_char_t *url_external_form = NULL;
-    axis2_char_t *body_string = NULL;
-    unsigned int body_string_len = 0;
-    int send_status = DECLINED;
-    axis2_char_t *content_type = NULL;
-    axis2_http_out_transport_info_t *apache2_out_transport_info = NULL;
-    axis2_char_t *ctx_uuid = NULL;
-    axis2_op_ctx_t *op_ctx = NULL;
-    axis2_char_t *peer_ip = NULL;
-    axutil_property_t *peer_property = NULL;
-    axutil_url_t *request_url = NULL;
-    axis2_char_t *accept_header_value = NULL;
-    axis2_char_t *accept_charset_header_value = NULL;
-    axis2_char_t *accept_language_header_value = NULL;
-    axis2_char_t *content_language_header_value = NULL;
-    axis2_bool_t do_mtom = AXIS2_FALSE;
-    axutil_array_list_t *mime_parts = NULL;
-    axutil_param_t *callback_name_param = NULL;
-    axis2_char_t *mtom_sending_callback_name = NULL;
-    axis2_char_t *cookie = NULL;
-    axis2_char_t *header_value = NULL;
-    axis2_status_t status = AXIS2_FAILURE;
-
-    AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE);
-
-    conf_ctx = apache2_worker->conf_ctx;
-
-    if(!conf_ctx)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE);
-        return AXIS2_CRITICAL_FAILURE;
-    }
-    content_length = (int)request->remaining;
-    /* We are sure that the difference lies within the int range */
-    http_version = request->protocol;
-
-    request_url = axutil_url_create(env, "http", request->hostname, request->parsed_uri.port,
-        request->unparsed_uri);
-    if(request_url)
-    {
-        url_external_form = axutil_url_to_external_form(request_url, env);
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, url_external_form);
-        axutil_url_free(request_url, env);
-        request_url = NULL;
-    }
-    else
-    {
-        send_status = OK;
-        request->status = HTTP_BAD_REQUEST;
-        return send_status;
-    }
-
-    content_type = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_CONTENT_TYPE);
-    if(!content_type)
-    {
-        content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN;
-    }
-    request->content_type = content_type;
-
-    out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env),
-        env, AXIS2_TRANSPORT_ENUM_HTTP);
-    in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env),
-        env, AXIS2_TRANSPORT_ENUM_HTTP);
-
-    msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc);
-    axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE);
-
-    cookie = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_COOKIE);
-    if(cookie)
-    {
-        char *session_str = NULL;
-        axis2_char_t *session_id = NULL;
-
-        session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, cookie);
-        session_str = env->get_session_fn((void *) request, session_id);
-        axis2_http_transport_utils_set_session(env, msg_ctx, session_str);
-    }
-
-    if(request->read_chunked == AXIS2_TRUE && 0 == content_length)
-    {
-        content_length = -1;
-        request->chunked = 1;
-    }
-    if(!http_version)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE);
-        return AXIS2_CRITICAL_FAILURE;
-    }
-    out_stream = axutil_stream_create_basic(env);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version);
-
-    peer_ip = request->connection->remote_ip;
-
-    if(peer_ip)
-    {
-        peer_property = axutil_property_create(env);
-        axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip));
-        axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property);
-    }
-
-    axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream);
-
-    ctx_uuid = axutil_uuid_gen(env);
-    if(ctx_uuid)
-    {
-        axutil_string_t *uuid_str = axutil_string_create_assume_ownership(env, &ctx_uuid);
-        axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, uuid_str);
-        axutil_string_free(uuid_str, env);
-    }
-
-    apache2_out_transport_info = axis2_apache2_out_transport_info_create(env, request);
-    axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(apache2_out_transport_info->out_transport));
-
-    accept_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_ACCEPT);
-    if(accept_header_value)
-    {
-        axutil_array_list_t *accept_header_field_list = NULL;
-        axutil_array_list_t *accept_record_list = NULL;
-        accept_header_field_list = axutil_tokenize(env, accept_header_value, ',');
-        if(accept_header_field_list && axutil_array_list_size(accept_header_field_list, env) > 0)
-        {
-            axis2_char_t *token = NULL;
-            accept_record_list = axutil_array_list_create(env, axutil_array_list_size(
-                accept_header_field_list, env));
-            do
-            {
-                if(token)
-                {
-                    axis2_http_accept_record_t *rec = NULL;
-                    rec = axis2_http_accept_record_create(env, token);
-                    if(rec)
-                    {
-                        axutil_array_list_add(accept_record_list, env, rec);
-                    }
-                    AXIS2_FREE(env->allocator, token);
-                }
-                token = (axis2_char_t *)axutil_array_list_remove(accept_header_field_list, env, 0);
-            }
-            while(token);
-        }
-        if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0)
-        {
-            axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list);
-        }
-    }
-
-    accept_charset_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_ACCEPT_CHARSET);
-    if(accept_charset_header_value)
-    {
-        axutil_array_list_t *accept_charset_header_field_list = NULL;
-        axutil_array_list_t *accept_charset_record_list = NULL;
-        accept_charset_header_field_list = axutil_tokenize(env, accept_charset_header_value, ',');
-        if(accept_charset_header_field_list && axutil_array_list_size(
-            accept_charset_header_field_list, env) > 0)
-        {
-            axis2_char_t *token = NULL;
-            accept_charset_record_list = axutil_array_list_create(env, axutil_array_list_size(
-                accept_charset_header_field_list, env));
-            do
-            {
-                if(token)
-                {
-                    axis2_http_accept_record_t *rec = NULL;
-                    rec = axis2_http_accept_record_create(env, token);
-                    if(rec)
-                    {
-                        axutil_array_list_add(accept_charset_record_list, env, rec);
-                    }
-                    AXIS2_FREE(env->allocator, token);
-                }
-                token = (axis2_char_t *)axutil_array_list_remove(accept_charset_header_field_list,
-                    env, 0);
-            }
-            while(token);
-        }
-        if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env)
-        > 0)
-        {
-            axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env,
-                accept_charset_record_list);
-        }
-    }
-
-    accept_language_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE);
-    if(accept_language_header_value)
-    {
-        axutil_array_list_t *accept_language_header_field_list = NULL;
-        axutil_array_list_t *accept_language_record_list = NULL;
-        accept_language_header_field_list = axutil_tokenize(env, accept_language_header_value, ',');
-        if(accept_language_header_field_list && axutil_array_list_size(
-            accept_language_header_field_list, env) > 0)
-        {
-            axis2_char_t *token = NULL;
-            accept_language_record_list = axutil_array_list_create(env, axutil_array_list_size(
-                accept_language_header_field_list, env));
-            do
-            {
-                if(token)
-                {
-                    axis2_http_accept_record_t *rec = NULL;
-                    rec = axis2_http_accept_record_create(env, token);
-                    if(rec)
-                    {
-                        axutil_array_list_add(accept_language_record_list, env, rec);
-                    }
-                    AXIS2_FREE(env->allocator, token);
-                }
-                token = (axis2_char_t *)axutil_array_list_remove(accept_language_header_field_list,
-                    env, 0);
-            }
-            while(token);
-        }
-        if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env)
-        > 0)
-        {
-            axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env,
-                accept_language_record_list);
-        }
-    }
-
-    soap_action_header_txt = (axis2_char_t *)apr_table_get(request->headers_in,
-        AXIS2_HTTP_HEADER_SOAP_ACTION);
-
-    if(soap_action_header_txt)
-    {
-        soap_action = axutil_string_create(env, soap_action_header_txt);
-    }
-
-    request_body = axutil_stream_create_apache2(env, request);
-    if(!request_body)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in"
-            " creating input stream.");
-        return AXIS2_CRITICAL_FAILURE;
-    }
-    if(M_GET == request->method_number || M_DELETE == request->method_number)
-    {
-        if(M_DELETE == request->method_number)
-        {
-            processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx,
-                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
-                axis2_http_transport_utils_get_request_params(env,
-                    (axis2_char_t *)url_external_form));
-        }
-        else if(request->header_only)
-        {
-            processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx,
-                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
-                axis2_http_transport_utils_get_request_params(env,
-                    (axis2_char_t *)url_external_form));
-        }
-        else
-        {
-            processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx,
-                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
-                axis2_http_transport_utils_get_request_params(env,
-                    (axis2_char_t *)url_external_form));
-        }
-        if(AXIS2_FALSE == processed)
-        {
-            axis2_char_t *wsdl = NULL;
-            axis2_bool_t is_services_path = AXIS2_FALSE;
-            if(M_DELETE != request->method_number)
-            {
-                axis2_char_t *temp = NULL;
-                temp = strstr(url_external_form, AXIS2_REQUEST_URL_PREFIX);
-                if(temp)
-                {
-                    temp += strlen(AXIS2_REQUEST_URL_PREFIX);
-                    if(*temp == '/')
-                    {
-                        temp++;
-                    }
-                    if(!*temp || *temp == '?' || *temp == '#')
-                    {
-                        is_services_path = AXIS2_TRUE;
-                    }
-                }
-            }
-            wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL);
-            if(is_services_path)
-            {
-                body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-            }
-            else if(M_DELETE != request->method_number && wsdl)
-            {
-                body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx,
-                    (axis2_char_t *)url_external_form);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
-
-            }
-            else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND)
-            {
-                axutil_array_list_t *method_list = NULL;
-                int size = 0;
-                method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env);
-                size = axutil_array_list_size(method_list, env);
-                if(method_list && size)
-                {
-                    axis2_char_t *method_list_str = NULL;
-                    axis2_char_t *temp;
-                    int i = 0;
-                    method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29);
-                    temp = method_list_str;
-                    request->allowed_methods->method_mask = 0;
-                    for(i = 0; i < size; i++)
-                    {
-                        if(i)
-                        {
-                            sprintf(temp, ", ");
-                            temp += 2;
-                        }
-                        sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env,
-                            i));
-                        temp += strlen(temp);
-                        /* Conditions below is to assist down-stream modules */
-                        if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            /* Apache Can't differentiate between HEAD and GET */
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_DELETE,
-                            (axis2_char_t *)axutil_array_list_get(method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE;
-                        }
-                    }
-                    *temp = '\0';
-                    apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW,
-                        method_list_str);
-                    AXIS2_FREE(env->allocator, method_list_str);
-                    body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx);
-                    request->status = HTTP_METHOD_NOT_ALLOWED;
-                }
-                else
-                {
-                    body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx);
-                    request->status = HTTP_NOT_FOUND;
-                }
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_BAD_REQUEST;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_REQUEST_TIME_OUT;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_CONFLICT;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_gone(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_GONE;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_PRECONDITION_FAILED;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_REQUEST_ENTITY_TOO_LARGE;
-            }
-            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
-                == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL)
-            {
-                body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_SERVICE_UNAVAILABLE;
-            }
-            else
-            {
-                body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_INTERNAL_SERVER_ERROR;
-            }
-
-            if(body_string)
-            {
-                body_string_len = axutil_strlen(body_string);
-            }
-            send_status = OK;
-        }
-    }
-    else if(M_POST == request->method_number || M_PUT == request->method_number)
-    {
-        /*axis2_status_t status = AXIS2_FAILURE;*/
-        if(M_POST == request->method_number)
-        {
-            status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx,
-                request_body, out_stream, content_type, content_length, soap_action,
-                (axis2_char_t *)url_external_form);
-        }
-        else
-        {
-            status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx,
-                request_body, out_stream, content_type, content_length, soap_action,
-                (axis2_char_t *)url_external_form);
-        }
-        if(AXIS2_FAILURE == status && (M_PUT == request->method_number
-            || axis2_msg_ctx_get_doing_rest(msg_ctx, env)))
-        {
-            if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND)
-            {
-                axutil_array_list_t *method_list = NULL;
-                int size = 0;
-                method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env);
-                size = axutil_array_list_size(method_list, env);
-                if(method_list && size)
-                {
-                    axis2_char_t *method_list_str = NULL;
-                    axis2_char_t *temp;
-                    int i = 0;
-                    method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29);
-                    temp = method_list_str;
-                    request->allowed_methods->method_mask = 0;
-                    for(i = 0; i < size; i++)
-                    {
-                        if(i)
-                        {
-                            sprintf(temp, ", ");
-                            temp += 2;
-                        }
-                        sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env,
-                            i));
-                        temp += strlen(temp);
-                        /* Conditions below is to assist down-stream modules */
-                        if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get(
-                            method_list, env, i)))
-                        {
-                            /* Apache Can't differentiate between HEAD and GET */
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
-                        }
-                        else if(!strcasecmp(AXIS2_HTTP_DELETE,
-                            (axis2_char_t *)axutil_array_list_get(method_list, env, i)))
-                        {
-                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE;
-                        }
-                    }
-                    *temp = '\0';
-                    apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW,
-                        method_list_str);
-                    AXIS2_FREE(env->allocator, method_list_str);
-                    body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx);
-                    request->status = HTTP_METHOD_NOT_ALLOWED;
-                }
-                else
-                {
-                    body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx);
-                    request->status = HTTP_NOT_FOUND;
-                }
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-            }
-            else
-            {
-                body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx);
-                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-                request->status = HTTP_INTERNAL_SERVER_ERROR;
-            }
-
-            if(body_string)
-            {
-                body_string_len = axutil_strlen(body_string);
-            }
-            send_status = OK;
-        }
-        else if(status == AXIS2_FAILURE)
-        {
-            axis2_msg_ctx_t *fault_ctx = NULL;
-            axis2_char_t *fault_code = NULL;
-            axis2_engine_t *engine = axis2_engine_create(env, conf_ctx);
-            if(!engine)
-            {
-                /* Critical error, cannot proceed, Apache will send default 
-                 document for 500
-                 */
-                return AXIS2_CRITICAL_FAILURE;
-            }
-            if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
-            {
-                fault_code            = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
-                    AXIOM_SOAP11_FAULT_CODE_SENDER;
-            }
-            else
-            {
-                fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
-                    AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER;
-            }
-            fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx,
-                fault_code,
-                axutil_error_get_message
-                (env->error));
-            axis2_engine_send_fault(engine, env, fault_ctx);
-            if (out_stream)
-            {
-                body_string = axutil_stream_get_buffer(out_stream, env);
-                body_string_len = axutil_stream_get_len(out_stream, env);
-            }
-
-            /* In case of a SOAP Fault, we have to set the status to 500,
-         but still return OK because the module has handled the error
-             */
-            send_status = OK;
-            request->status = HTTP_INTERNAL_SERVER_ERROR;
-        }
-    }
-    else
-    {
-        body_string =
-            axis2_http_transport_utils_get_not_implemented(env, conf_ctx);
-        request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-
-        if (body_string)
-        {
-            body_string_len = axutil_strlen(body_string);
-        }
-        send_status = OK;
-        request->status = HTTP_NOT_IMPLEMENTED;
-    }
-
-    op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-
-    if (op_ctx)
-    {
-        axis2_msg_ctx_t *out_msg_ctx = NULL;
-        axis2_msg_ctx_t **msg_ctx_map = NULL;
-
-        msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
-        out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];
-        if (out_msg_ctx)
-        {
-            content_language_header_value = axis2_msg_ctx_get_content_language(out_msg_ctx, env);
-        }
-    }
-
-    if (send_status == DECLINED)
-    {
-        axis2_bool_t do_rest = AXIS2_FALSE;
-        if (M_POST != request->method_number ||
-            axis2_msg_ctx_get_doing_rest(msg_ctx, env))
-        {
-            do_rest = AXIS2_TRUE;
-        }
-        if ((accept_header_value || accept_charset_header_value ||
-            accept_language_header_value) && do_rest)
-        {
-            axis2_char_t *content_type_header_value = NULL;
-            axis2_char_t *temp = NULL;
-            axis2_char_t *language_header_value = NULL;
-
-            content_type_header_value = (axis2_char_t *) request->content_type;
-            language_header_value = content_language_header_value;
-            if (content_type_header_value)
-            {
-                temp = axutil_strdup(env, content_type_header_value);
-            }
-            if (temp)
-            {
-                axis2_char_t *content_type = NULL;
-                axis2_char_t *char_set = NULL;
-                axis2_char_t *temp2 = NULL;
-
-                temp2 = strchr(temp, ';');
-                if (temp2)
-                {
-                    *temp2 = '\0';
-                    temp2++;
-                    char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING);
-                }
-                if (char_set)
-                {
-                    char_set = axutil_strltrim(env, char_set, " \t=");
-                }
-                if (char_set)
-                {
-                    temp2 = strchr(char_set, ';');
-                }
-                if (temp2)
-                {
-                    *temp2 = '\0';
-                }
-                content_type = axutil_strtrim(env, temp, NULL);
-
-                if (temp)
-                {
-                    AXIS2_FREE(env->allocator, temp);
-                    temp = NULL;
-                }
-                if (content_type && accept_header_value &&
-                    !axutil_strcasestr(accept_header_value, content_type))
-                {
-                    temp2 = strchr(content_type, '/');
-                    if (temp2)
-                    {
-                        *temp2 = '\0';
-                        temp = AXIS2_MALLOC(env->allocator,
-                            sizeof(axis2_char_t) * ((int)strlen(content_type) + 3));
-                        if (!temp)
-                        {
-                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-                            return AXIS2_FALSE;
-                        }
-                        sprintf(temp, "%s/*", content_type);
-                        if (!axutil_strcasestr(accept_header_value, temp) &&
-                            !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL))
-                        {
-                            body_string =
-                                axis2_http_transport_utils_get_not_acceptable(env, conf_ctx);
-                            request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-
-                            if (body_string)
-                            {
-                                body_string_len = axutil_strlen(body_string);
-                            }
-                            send_status = OK;
-                            request->status = HTTP_NOT_ACCEPTABLE;
-                        }
-                        AXIS2_FREE(env->allocator, temp);
-                    }
-                }
-                if (content_type)
-                {
-                    AXIS2_FREE(env->allocator, content_type);
-                }
-                if (char_set && accept_charset_header_value &&
-                    !axutil_strcasestr(accept_charset_header_value, char_set))
-                {
-                    body_string =
-                        axis2_http_transport_utils_get_not_acceptable(env, conf_ctx);
-                    request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-
-                    if (body_string)
-                    {
-                        body_string_len = axutil_strlen(body_string);
-                    }
-                    send_status = OK;
-                    request->status = HTTP_NOT_ACCEPTABLE;
-                }
-                if (char_set)
-                {
-                    AXIS2_FREE(env->allocator, char_set);
-                }
-            }
-            if (language_header_value)
-            {
-                if (accept_language_header_value &&
-                    !axutil_strcasestr(accept_language_header_value, language_header_value))
-                {
-                    body_string =
-                        axis2_http_transport_utils_get_not_acceptable(env, conf_ctx);
-                    request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
-
-                    if (body_string)
-                    {
-                        body_string_len = axutil_strlen(body_string);
-                    }
-                    send_status = OK;
-                    request->status = HTTP_NOT_ACCEPTABLE;
-                }
-            }
-        }
-    }
-
-    header_value = axis2_http_transport_utils_get_session(env, msg_ctx);
-    if(header_value)
-    {
-        axis2_http_out_transport_info_t *out_info = NULL;
-        out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info(msg_ctx, env);
-        AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value);
-    }
-    if (send_status == DECLINED)
-    {
-        axis2_bool_t do_rest = AXIS2_FALSE;
-        if (M_POST != request->method_number ||
-            axis2_msg_ctx_get_doing_rest(msg_ctx, env))
-        {
-            do_rest = AXIS2_TRUE;
-        }
-        if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env))
-        {
-            if (do_rest)
-            {
-                axis2_msg_ctx_t *out_msg_ctx = NULL;
-                axis2_msg_ctx_t *in_msg_ctx = NULL;
-                axis2_msg_ctx_t **msg_ctx_map = NULL;
-
-                msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
-                out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];
-                in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN];
-                if (in_msg_ctx)
-                {
-                    /* TODO: Add necessary handling */
-                }
-                if (out_msg_ctx)
-                {
-                    int size = 0;
-                    axutil_array_list_t *output_header_list = NULL;
-                    output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env);
-                    if (output_header_list)
-                    {
-                        size = axutil_array_list_size(output_header_list, env);
-                    }
-                    while (size)
-                    {
-                        axis2_http_header_t *output_header = NULL;
-                        size--;
-                        output_header = (axis2_http_header_t *)
-                        axutil_array_list_get(output_header_list, env, size);
-                        apr_table_set(request->err_headers_out,
-                            axis2_http_header_get_name(output_header, env),
-                            axis2_http_header_get_value(output_header, env));
-                    }
-                    if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
-                    {
-                        int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env);
-                        switch (status_code)
-                        {
-                            case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
-                                request->status = HTTP_CONTINUE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL:
-                                request->status = HTTP_ACCEPTED;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
-                                request->status = HTTP_MULTIPLE_CHOICES;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
-                                request->status = HTTP_MOVED_PERMANENTLY;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
-                                request->status = HTTP_SEE_OTHER;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                                request->status = HTTP_NOT_MODIFIED;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
-                                request->status = HTTP_TEMPORARY_REDIRECT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
-                                request->status = HTTP_BAD_REQUEST;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
-                                request->status = HTTP_REQUEST_TIME_OUT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
-                                request->status = HTTP_CONFLICT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
-                                request->status = HTTP_GONE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
-                                request->status = HTTP_PRECONDITION_FAILED;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
-                                request->status = HTTP_REQUEST_ENTITY_TOO_LARGE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
-                                request->status = HTTP_SERVICE_UNAVAILABLE;
-                                break;
-                            default:
-                                request->status = HTTP_OK;
-                                break;
-                        }
-                        send_status = DONE;
-                    }
-                }
-            }
-            if (send_status == DECLINED)
-            {
-                send_status = OK;
-                if (out_stream)
-                {
-                    body_string = axutil_stream_get_buffer(out_stream, env);
-                    body_string_len = axutil_stream_get_len(out_stream, env);
-                }
-            }
-        }
-        else if (op_ctx)
-        {
-            if (do_rest)
-            {
-                axis2_msg_ctx_t *out_msg_ctx = NULL;
-                axis2_msg_ctx_t *in_msg_ctx = NULL;
-                axis2_msg_ctx_t **msg_ctx_map = NULL;
-
-                msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
-                out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];
-                in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN];
-                if (in_msg_ctx)
-                {
-                    /* TODO: Add necessary handling */
-                }
-                if (out_msg_ctx)
-                {
-                    int size = 0;
-                    axutil_array_list_t *output_header_list = NULL;
-                    output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env);
-                    if (output_header_list)
-                    {
-                        size = axutil_array_list_size(output_header_list, env);
-                    }
-                    while (size)
-                    {
-                        axis2_http_header_t *output_header = NULL;
-                        size--;
-                        output_header = (axis2_http_header_t *)
-                        axutil_array_list_get(output_header_list, env, size);
-                        apr_table_set(request->err_headers_out,
-                            axis2_http_header_get_name(output_header, env),
-                            axis2_http_header_get_value(output_header, env));
-                    }
-                    if (axis2_msg_ctx_get_no_content(out_msg_ctx, env))
-                    {
-                        if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
-                        {
-                            int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env);
-                            switch (status_code)
-                            {
-                                case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL:
-                                    request->status = HTTP_RESET_CONTENT;
-                                    break;
-                                case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                                    request->status = HTTP_NOT_MODIFIED;
-                                    break;
-                                default:
-                                    request->status = HTTP_NO_CONTENT;
-                                    break;
-                            }
-                        }
-                        else
-                        {
-                            request->status = HTTP_NO_CONTENT;
-                        }
-                        send_status = DONE;
-                    }
-                    else if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
-                    {
-                        int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env);
-                        switch (status_code)
-                        {
-                            case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
-                                request->status = HTTP_CONTINUE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_OK_CODE_VAL:
-                                request->status = HTTP_OK;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
-                                request->status = HTTP_MULTIPLE_CHOICES;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
-                                request->status = HTTP_MOVED_PERMANENTLY;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
-                                request->status = HTTP_SEE_OTHER;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                                request->status = HTTP_NOT_MODIFIED;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
-                                request->status = HTTP_TEMPORARY_REDIRECT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
-                                request->status = HTTP_BAD_REQUEST;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
-                                request->status = HTTP_REQUEST_TIME_OUT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
-                                request->status = HTTP_CONFLICT;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
-                                request->status = HTTP_GONE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
-                                request->status = HTTP_PRECONDITION_FAILED;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
-                                request->status = HTTP_REQUEST_ENTITY_TOO_LARGE;
-                                break;
-                            case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
-                                request->status = HTTP_SERVICE_UNAVAILABLE;
-                                break;
-                            default:
-                                request->status = HTTP_ACCEPTED;
-                                break;
-                        }
-                        send_status = DONE;
-                    }
-                }
-            }
-            if (send_status == DECLINED)
-            {
-                request->status = HTTP_ACCEPTED;
-                send_status = DONE;
-            }
-        }
-        else
-        {
-            send_status = DONE;
-            request->status = HTTP_ACCEPTED;
-        }
-    }
-
-    if (content_language_header_value)
-    {
-        apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_CONTENT_LANGUAGE,
-            content_language_header_value);
-    }
-
-    if (op_ctx)
-    {
-        axis2_msg_ctx_t *out_msg_ctx = NULL,
-            *in_msg_ctx = NULL;
-        axis2_msg_ctx_t **msg_ctx_map = NULL;
-        axis2_char_t *msg_id = NULL;
-        axis2_conf_ctx_t *conf_ctx = NULL;
-        msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env);
-
-        out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];
-        in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN];
-
-        /* In mtom case we send the attachment differently */
-
-        /* status = AXIS2_FAILURE means fault scenario. We are not
-         * doing MTOM for fault cases. */
-
-        if(status != AXIS2_FAILURE)
-        {
-            do_mtom = axis2_msg_ctx_get_doing_mtom(out_msg_ctx, env);
-            if(do_mtom)
-            {
-                mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env);
-                if(!mime_parts)
-                {
-                    return AXIS2_FAILURE;
-                }
-                callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env ,
-                    AXIS2_MTOM_SENDING_CALLBACK);
-                if(callback_name_param)
-                {
-                    mtom_sending_callback_name =
-                        (axis2_char_t *) axutil_param_get_value (callback_name_param, env);
-                }
-            }
-        }
-
-        if (out_msg_ctx)
-        {
-            axis2_msg_ctx_free(out_msg_ctx, env);
-            out_msg_ctx = NULL;
-            msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL;
-        }
-
-        if (in_msg_ctx)
-        {
-            msg_id =
-                axutil_strdup(env, axis2_msg_ctx_get_msg_id(in_msg_ctx, env));
-            conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env);
-            axis2_msg_ctx_reset_out_transport_info(in_msg_ctx, env);
-            axis2_msg_ctx_free(in_msg_ctx, env);
-            in_msg_ctx = NULL;
-            msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL;
-        }
-
-        if (!axis2_op_ctx_is_in_use(op_ctx, env))
-        {
-            axis2_op_ctx_destroy_mutex(op_ctx, env);
-            if (conf_ctx && msg_id)
-            {
-                axis2_conf_ctx_register_op_ctx(conf_ctx, env, msg_id, NULL);
-                AXIS2_FREE(env->allocator, msg_id);
-            }
-            axis2_op_ctx_free(op_ctx, env);
-        }
-
-    } /* Done freeing message contexts */
-
-    /* We send the message in parts when doing MTOM */
-
-    if(do_mtom)
-    {
-        axis2_status_t mtom_status = AXIS2_FAILURE;
-
-        if(!mtom_sending_callback_name)
-        {
-            /* If the callback name is not there, then we will check whether there
-             * is any mime_parts which has type callback. If we found then no point
-             * of continuing we should return a failure */
-
-            if(!mtom_sending_callback_name)
-            {
-                if(axis2_http_transport_utils_is_callback_required(
-                    env, mime_parts))
-                {
-                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified");
-                    return AXIS2_FAILURE;
-                }
-            }
-        }
-
-        mtom_status = apache2_worker_send_mtom_message(request, env, mime_parts,
-            mtom_sending_callback_name);
-        if(mtom_status == AXIS2_SUCCESS)
-        {
-            send_status = DONE;
-        }
-        else
-        {
-            send_status = DECLINED;
-        }
-
-        axis2_http_transport_utils_destroy_mime_parts(mime_parts, env);
-        mime_parts = NULL;
-    }
-
-    else if (body_string)
-    {
-        ap_rwrite(body_string, body_string_len, request);
-        body_string = NULL;
-    }
-
-    if (request_body)
-    {
-        axutil_stream_free(request_body, env);
-        request_body = NULL;
-    }
-
-    axutil_string_free(soap_action, env);
-
-    msg_ctx = NULL;
-    return send_status;
-}
-
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axis2_apache2_worker_get_bytes(
-    const axutil_env_t * env,
-    axutil_stream_t * stream)
-{
-
-    axutil_stream_t *tmp_stream = NULL;
-    int return_size = -1;
-    axis2_char_t *buffer = NULL;
-    axis2_bool_t loop_status = AXIS2_TRUE;
-
-    AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK(env->error, stream, NULL);
-
-    tmp_stream = axutil_stream_create_basic(env);
-    while(loop_status)
-    {
-        int read = 0;
-        int write = 0;
-
-        char buf[READ_SIZE];
-        read = axutil_stream_read(stream, env, buf, READ_SIZE);
-        if(read < 0)
-        {
-            break;
-        }
-        write = axutil_stream_write(tmp_stream, env, buf, read);
-        if(read < (READ_SIZE - 1))
-        {
-            break;
-        }
-    }
-    return_size = axutil_stream_get_len(tmp_stream, env);
-
-    if(return_size > 0)
-    {
-        buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 2));
-        return_size = axutil_stream_read(tmp_stream, env, buffer, return_size + 1);
-        buffer[return_size + 1] = '\0';
-    }
-    axutil_stream_free(tmp_stream, env);
-    return buffer;
-}
-
-static axis2_status_t
-apache2_worker_send_mtom_message(
-    request_rec *request,
-    const axutil_env_t * env,
-    axutil_array_list_t *mime_parts,
-    axis2_char_t *mtom_sending_callback_name)
-{
-    int i = 0;
-    axiom_mime_part_t *mime_part = NULL;
-    axis2_status_t status = AXIS2_SUCCESS;
-    /*int written = 0;*/
-    int len = 0;
-
-    if(mime_parts)
-    {
-        for(i = 0; i < axutil_array_list_size(mime_parts, env); i++)
-        {
-            mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i);
-            if((mime_part->type) == AXIOM_MIME_PART_BUFFER)
-            {
-                len = 0;
-                len = ap_rwrite(mime_part->part, (int)mime_part->part_size, request);
-                ap_rflush(request);
-                if(len == -1)
-                {
-                    status = AXIS2_FAILURE;
-                    break;
-                }
-            }
-            else if((mime_part->type) == AXIOM_MIME_PART_FILE)
-            {
-                FILE *f = NULL;
-                axis2_byte_t *output_buffer = NULL;
-                int output_buffer_size = 0;
-
-                f = fopen(mime_part->file_name, "rb");
-                if(!f)
-                {
-                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error opening file %s for reading",
-                        mime_part->file_name);
-                    return AXIS2_FAILURE;
-                }
-                if(mime_part->part_size > AXIS2_MTOM_OUTPUT_BUFFER_SIZE)
-                {
-                    output_buffer_size = AXIS2_MTOM_OUTPUT_BUFFER_SIZE;
-                }
-                else
-                {
-                    output_buffer_size = (int)mime_part->part_size;
-                }
-
-                output_buffer = AXIS2_MALLOC(env->allocator, (output_buffer_size + 1)
-                    * sizeof(axis2_char_t));
-
-                status = apache2_worker_send_attachment_using_file(env, request, f, output_buffer,
-                    output_buffer_size);
-                if(status == AXIS2_FAILURE)
-                {
-                    return status;
-                }
-            }
-            else if((mime_part->type) == AXIOM_MIME_PART_CALLBACK)
-            {
-                void *handler = NULL;
-                axiom_mtom_sending_callback_t *callback = NULL;
-
-                handler = axis2_http_transport_utils_initiate_callback(env,
-                    mtom_sending_callback_name, mime_part->user_param, &callback);
-
-                if(handler)
-                {
-                    status = apache2_worker_send_attachment_using_callback(env, request, callback,
-                        handler, mime_part->user_param);
-                }
-                else
-                {
-                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "MTOM Sending Callback loading failed");
-                    status = AXIS2_FAILURE;
-                }
-                if(callback)
-                {
-                    axutil_param_t *param = NULL;
-
-                    param = callback->param;
-
-                    AXIOM_MTOM_SENDING_CALLBACK_FREE(callback, env);
-                    callback = NULL;
-
-                    if(param)
-                    {
-                        axutil_param_free(param, env);
-                        param = NULL;
-                    }
-
-                }
-
-                if(status == AXIS2_FAILURE)
-                {
-                    return status;
-                }
-            }
-            else
-            {
-                return AXIS2_FAILURE;
-            }
-            if(status == AXIS2_FAILURE)
-            {
-                break;
-            }
-        }
-        return status;
-    }
-    else
-    {
-        return AXIS2_FAILURE;
-    }
-}
-
-static axis2_status_t
-apache2_worker_send_attachment_using_file(
-    const axutil_env_t * env,
-    request_rec *request,
-    FILE *fp,
-    axis2_byte_t *buffer,
-    int buffer_size)
-{
-
-    int count = 0;
-    int len = 0;
-    /*int written = 0;*/
-    axis2_status_t status = AXIS2_SUCCESS;
-
-    do
-    {
-        count = (int)fread(buffer, 1, buffer_size + 1, fp);
-        if(ferror(fp))
-        {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in reading file containg the attachment");
-            if(buffer)
-            {
-                AXIS2_FREE(env->allocator, buffer);
-                buffer = NULL;
-            }
-            fclose(fp);
-            return AXIS2_FAILURE;
-        }
-
-        if(count > 0)
-        {
-            len = 0;
-            len = ap_rwrite(buffer, count, request);
-            ap_rflush(request);
-            if(len == -1)
-            {
-                status = AXIS2_FAILURE;
-                break;
-            }
-        }
-        else
-        {
-            if(buffer)
-            {
-                AXIS2_FREE(env->allocator, buffer);
-                buffer = NULL;
-            }
-            fclose(fp);
-            return AXIS2_FAILURE;
-        }
-        memset(buffer, 0, buffer_size);
-        if(status == AXIS2_FAILURE)
-        {
-            if(buffer)
-            {
-                AXIS2_FREE(env->allocator, buffer);
-                buffer = NULL;
-            }
-            fclose(fp);
-            return AXIS2_FAILURE;
-        }
-    }
-    while(!feof(fp));
-
-    fclose(fp);
-    AXIS2_FREE(env->allocator, buffer);
-    buffer = NULL;
-    return AXIS2_SUCCESS;
-}
-
-static axis2_status_t
-apache2_worker_send_attachment_using_callback(
-    const axutil_env_t * env,
-    request_rec *request,
-    axiom_mtom_sending_callback_t *callback,
-    void *handler,
-    void *user_param)
-{
-    int count = 0;
-    int len = 0;
-    axis2_status_t status = AXIS2_SUCCESS;
-    axis2_char_t *buffer = NULL;
-
-    /* Keep on loading the data in a loop until 
-     * all the data is sent */
-
-    while((count = AXIOM_MTOM_SENDING_CALLBACK_LOAD_DATA(callback, env, handler, &buffer)) > 0)
-    {
-        len = 0;
-        len = ap_rwrite(buffer, count, request);
-        ap_rflush(request);
-        if(len == -1)
-        {
-            status = AXIS2_FAILURE;
-            break;
-        }
-    }
-
-    if(status == AXIS2_FAILURE)
-    {
-        AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler);
-        return status;
-    }
-
-    status = AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler);
-    return status;
-}
+/*
+ * 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_apache2_worker.h"
+#include <axis2_http_transport.h>
+#include <axis2_conf.h>
+#include <axutil_string.h>
+#include <axis2_msg_ctx.h>
+#include <axis2_http_out_transport_info.h>
+#include <axis2_http_transport_utils.h>
+#include <axis2_http_accept_record.h>
+#include <axis2_op_ctx.h>
+#include <axis2_engine.h>
+#include <axutil_uuid_gen.h>
+#include <axis2_conf_init.h>
+#include "axis2_apache2_out_transport_info.h"
+#include <axutil_url.h>
+#include <http_core.h>
+#include <http_protocol.h>
+#include <axiom_soap.h>
+#include <axutil_class_loader.h>
+#include <axutil_string_util.h>
+#include <axiom_mime_part.h>
+#include <axiom_mtom_sending_callback.h>
+
+#define READ_SIZE  2048
+
+static axis2_status_t
+apache2_worker_send_mtom_message(
+    request_rec *request,
+    const axutil_env_t * env,
+    axutil_array_list_t *mime_parts,
+    axis2_char_t *mtom_sending_callback_name);
+
+static axis2_status_t
+apache2_worker_send_attachment_using_file(
+    const axutil_env_t * env,
+    request_rec *request,
+    FILE *fp,
+    axis2_byte_t *buffer,
+    int buffer_size);
+
+static axis2_status_t
+apache2_worker_send_attachment_using_callback(
+    const axutil_env_t * env,
+    request_rec *request,
+    axiom_mtom_sending_callback_t *callback,
+    void *handler,
+    void *user_param);
+
+static axutil_hash_t* 
+axis2_apache_worker_get_headers(
+	const axutil_env_t *env,
+	request_rec *request);
+
+
+struct axis2_apache2_worker
+{
+    axis2_conf_ctx_t *conf_ctx;
+};
+
+AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL
+axis2_apache2_worker_create(
+    const axutil_env_t * env,
+    axis2_char_t * repo_path)
+{
+    axis2_apache2_worker_t *apache2_worker = NULL;
+    axutil_hash_t* svc_map = NULL;
+    axis2_conf_t* conf = NULL;
+    axutil_hash_index_t *hi = NULL;
+    void* svc = NULL;
+    AXIS2_ENV_CHECK(env, NULL);
+    AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created");
+    apache2_worker = (axis2_apache2_worker_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_apache2_worker_t));
+
+    if(!apache2_worker)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    apache2_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path);
+
+    if(!apache2_worker->conf_ctx)
+    {
+        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
+        return NULL;
+    }
+
+    /*
+     * we have to load all the services. This is because, before the fork (in linux)
+     * we should have a full code segment. Otherwise, we can't share function pointers of services
+     * between processed. In fork, the code segment will be duplicated across processes
+     */
+    conf = axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env);
+    if(!conf)
+    {
+        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
+        return NULL;
+    }
+
+    svc_map = axis2_conf_get_all_svcs(conf, env);
+    if(!svc_map)
+    {
+        axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env);
+        return NULL;
+    }
+
+    for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi))
+    {
+        void *impl_class = NULL;
+        axis2_msg_recv_t *msg_recv = NULL;
+        axutil_hash_t *ops_hash = NULL;
+
+        axutil_hash_this(hi, NULL, NULL, &svc);
+        if(!svc)
+            continue;
+        impl_class = axis2_svc_get_impl_class(svc, env);
+        if(impl_class)
+            continue;
+        ops_hash = axis2_svc_get_all_ops(svc, env);
+        if(ops_hash)
+        {
+            axutil_hash_index_t *op_hi = NULL;
+            void *op = NULL;
+            op_hi = axutil_hash_first(ops_hash, env);
+            if(op_hi)
+            {
+                axutil_hash_this(op_hi, NULL, NULL, &op);
+                if(op)
+                {
+                    msg_recv = axis2_op_get_msg_recv(op, env);
+                    if(msg_recv)
+                        axis2_msg_recv_load_and_init_svc(msg_recv, env, svc);
+                }
+            }
+
+        }
+    }
+
+    AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created");
+
+    return apache2_worker;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_apache2_worker_free(
+    axis2_apache2_worker_t * apache2_worker,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, void);
+
+    if(apache2_worker->conf_ctx)
+    {
+        axis2_conf_ctx_free(apache2_worker->conf_ctx, env);
+        apache2_worker->conf_ctx = NULL;
+    }
+
+    AXIS2_FREE(env->allocator, apache2_worker);
+
+    return;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+axis2_apache2_worker_process_request(
+    axis2_apache2_worker_t * apache2_worker,
+    const axutil_env_t * env,
+    request_rec * request)
+{
+    axis2_conf_ctx_t *conf_ctx = NULL;
+    axis2_msg_ctx_t *msg_ctx = NULL;
+    axutil_stream_t *request_body = NULL;
+    axutil_stream_t *out_stream = NULL;
+    axis2_transport_out_desc_t *out_desc = NULL;
+    axis2_transport_in_desc_t *in_desc = NULL;
+    axis2_char_t *http_version = NULL;
+    axutil_string_t *soap_action = NULL;
+    axis2_char_t *soap_action_header_txt = NULL;
+    axis2_bool_t processed = AXIS2_FALSE;
+    int content_length = -1;
+    axis2_char_t *url_external_form = NULL;
+    axis2_char_t *body_string = NULL;
+    unsigned int body_string_len = 0;
+    int send_status = DECLINED;
+    axis2_char_t *content_type = NULL;
+    axis2_http_out_transport_info_t *apache2_out_transport_info = NULL;
+    axis2_char_t *ctx_uuid = NULL;
+    axis2_op_ctx_t *op_ctx = NULL;
+    axis2_char_t *peer_ip = NULL;
+    axutil_property_t *peer_property = NULL;
+    axutil_url_t *request_url = NULL;
+    axis2_char_t *accept_header_value = NULL;
+    axis2_char_t *accept_charset_header_value = NULL;
+    axis2_char_t *accept_language_header_value = NULL;
+    axis2_char_t *content_language_header_value = NULL;
+    axis2_bool_t do_mtom = AXIS2_FALSE;
+    axutil_array_list_t *mime_parts = NULL;
+    axutil_param_t *callback_name_param = NULL;
+    axis2_char_t *mtom_sending_callback_name = NULL;
+    axis2_char_t *cookie = NULL;
+    axis2_char_t *header_value = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+	axutil_hash_t *headers = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE);
+
+    conf_ctx = apache2_worker->conf_ctx;
+
+    if(!conf_ctx)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE);
+        return AXIS2_CRITICAL_FAILURE;
+    }
+    content_length = (int)request->remaining;
+    /* We are sure that the difference lies within the int range */
+    http_version = request->protocol;
+
+    request_url = axutil_url_create(env, "http", request->hostname, request->parsed_uri.port,
+        request->unparsed_uri);
+    if(request_url)
+    {
+        url_external_form = axutil_url_to_external_form(request_url, env);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, url_external_form);
+        axutil_url_free(request_url, env);
+        request_url = NULL;
+    }
+    else
+    {
+        send_status = OK;
+        request->status = HTTP_BAD_REQUEST;
+        return send_status;
+    }
+
+    content_type = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_CONTENT_TYPE);
+    if(!content_type)
+    {
+        content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN;
+    }
+    request->content_type = content_type;
+
+    out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env),
+        env, AXIS2_TRANSPORT_ENUM_HTTP);
+    in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env),
+        env, AXIS2_TRANSPORT_ENUM_HTTP);
+
+    msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc);
+    axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE);
+
+    cookie = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_COOKIE);
+    if(cookie)
+    {
+        char *session_str = NULL;
+        axis2_char_t *session_id = NULL;
+
+        session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, cookie);
+        session_str = env->get_session_fn((void *) request, session_id);
+        axis2_http_transport_utils_set_session(env, msg_ctx, session_str);
+    }
+
+    if(request->read_chunked == AXIS2_TRUE && 0 == content_length)
+    {
+        content_length = -1;
+        request->chunked = 1;
+    }
+    if(!http_version)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE);
+        return AXIS2_CRITICAL_FAILURE;
+    }
+    out_stream = axutil_stream_create_basic(env);
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version);
+
+    peer_ip = request->connection->remote_ip;
+
+    if(peer_ip)
+    {
+        peer_property = axutil_property_create(env);
+        axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip));
+        axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property);
+    }
+
+    axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream);
+
+    ctx_uuid = axutil_uuid_gen(env);
+    if(ctx_uuid)
+    {
+        axutil_string_t *uuid_str = axutil_string_create_assume_ownership(env, &ctx_uuid);
+        axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, uuid_str);
+        axutil_string_free(uuid_str, env);
+    }
+
+    apache2_out_transport_info = axis2_apache2_out_transport_info_create(env, request);
+    axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(apache2_out_transport_info->out_transport));
+
+    accept_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_ACCEPT);
+    if(accept_header_value)
+    {
+        axutil_array_list_t *accept_header_field_list = NULL;
+        axutil_array_list_t *accept_record_list = NULL;
+        accept_header_field_list = axutil_tokenize(env, accept_header_value, ',');
+        if(accept_header_field_list && axutil_array_list_size(accept_header_field_list, env) > 0)
+        {
+            axis2_char_t *token = NULL;
+            accept_record_list = axutil_array_list_create(env, axutil_array_list_size(
+                accept_header_field_list, env));
+            do
+            {
+                if(token)
+                {
+                    axis2_http_accept_record_t *rec = NULL;
+                    rec = axis2_http_accept_record_create(env, token);
+                    if(rec)
+                    {
+                        axutil_array_list_add(accept_record_list, env, rec);
+                    }
+                    AXIS2_FREE(env->allocator, token);
+                }
+                token = (axis2_char_t *)axutil_array_list_remove(accept_header_field_list, env, 0);
+            }
+            while(token);
+        }
+        if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0)
+        {
+            axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list);
+        }
+    }
+
+    accept_charset_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_ACCEPT_CHARSET);
+    if(accept_charset_header_value)
+    {
+        axutil_array_list_t *accept_charset_header_field_list = NULL;
+        axutil_array_list_t *accept_charset_record_list = NULL;
+        accept_charset_header_field_list = axutil_tokenize(env, accept_charset_header_value, ',');
+        if(accept_charset_header_field_list && axutil_array_list_size(
+            accept_charset_header_field_list, env) > 0)
+        {
+            axis2_char_t *token = NULL;
+            accept_charset_record_list = axutil_array_list_create(env, axutil_array_list_size(
+                accept_charset_header_field_list, env));
+            do
+            {
+                if(token)
+                {
+                    axis2_http_accept_record_t *rec = NULL;
+                    rec = axis2_http_accept_record_create(env, token);
+                    if(rec)
+                    {
+                        axutil_array_list_add(accept_charset_record_list, env, rec);
+                    }
+                    AXIS2_FREE(env->allocator, token);
+                }
+                token = (axis2_char_t *)axutil_array_list_remove(accept_charset_header_field_list,
+                    env, 0);
+            }
+            while(token);
+        }
+        if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env)
+        > 0)
+        {
+            axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env,
+                accept_charset_record_list);
+        }
+    }
+
+    accept_language_header_value = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE);
+    if(accept_language_header_value)
+    {
+        axutil_array_list_t *accept_language_header_field_list = NULL;
+        axutil_array_list_t *accept_language_record_list = NULL;
+        accept_language_header_field_list = axutil_tokenize(env, accept_language_header_value, ',');
+        if(accept_language_header_field_list && axutil_array_list_size(
+            accept_language_header_field_list, env) > 0)
+        {
+            axis2_char_t *token = NULL;
+            accept_language_record_list = axutil_array_list_create(env, axutil_array_list_size(
+                accept_language_header_field_list, env));
+            do
+            {
+                if(token)
+                {
+                    axis2_http_accept_record_t *rec = NULL;
+                    rec = axis2_http_accept_record_create(env, token);
+                    if(rec)
+                    {
+                        axutil_array_list_add(accept_language_record_list, env, rec);
+                    }
+                    AXIS2_FREE(env->allocator, token);
+                }
+                token = (axis2_char_t *)axutil_array_list_remove(accept_language_header_field_list,
+                    env, 0);
+            }
+            while(token);
+        }
+        if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env)
+        > 0)
+        {
+            axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env,
+                accept_language_record_list);
+        }
+    }
+
+    soap_action_header_txt = (axis2_char_t *)apr_table_get(request->headers_in,
+        AXIS2_HTTP_HEADER_SOAP_ACTION);
+
+    if(soap_action_header_txt)
+    {
+        soap_action = axutil_string_create(env, soap_action_header_txt);
+    }
+
+	headers = axis2_apache_worker_get_headers(env, request);
+	axis2_msg_ctx_set_transport_headers(msg_ctx, env, headers);
+
+    request_body = axutil_stream_create_apache2(env, request);
+    if(!request_body)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in"
+            " creating input stream.");
+        return AXIS2_CRITICAL_FAILURE;
+    }
+    if(M_GET == request->method_number || M_DELETE == request->method_number)
+    {
+        if(M_DELETE == request->method_number)
+        {
+            processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx,
+                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
+                axis2_http_transport_utils_get_request_params(env,
+                    (axis2_char_t *)url_external_form));
+        }
+        else if(request->header_only)
+        {
+            processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx,
+                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
+                axis2_http_transport_utils_get_request_params(env,
+                    (axis2_char_t *)url_external_form));
+        }
+        else
+        {
+            processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx,
+                request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx,
+                axis2_http_transport_utils_get_request_params(env,
+                    (axis2_char_t *)url_external_form));
+        }
+        if(AXIS2_FALSE == processed)
+        {
+            axis2_char_t *wsdl = NULL;
+            axis2_bool_t is_services_path = AXIS2_FALSE;
+            if(M_DELETE != request->method_number)
+            {
+                axis2_char_t *temp = NULL;
+                temp = strstr(url_external_form, AXIS2_REQUEST_URL_PREFIX);
+                if(temp)
+                {
+                    temp += strlen(AXIS2_REQUEST_URL_PREFIX);
+                    if(*temp == '/')
+                    {
+                        temp++;
+                    }
+                    if(!*temp || *temp == '?' || *temp == '#')
+                    {
+                        is_services_path = AXIS2_TRUE;
+                    }
+                }
+            }
+            wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL);
+            if(is_services_path)
+            {
+                body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+            }
+            else if(M_DELETE != request->method_number && wsdl)
+            {
+                body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx,
+                    (axis2_char_t *)url_external_form);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
+
+            }
+            else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND)
+            {
+                axutil_array_list_t *method_list = NULL;
+                int size = 0;
+                method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env);
+                size = axutil_array_list_size(method_list, env);
+                if(method_list && size)
+                {
+                    axis2_char_t *method_list_str = NULL;
+                    axis2_char_t *temp;
+                    int i = 0;
+                    method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29);
+                    temp = method_list_str;
+                    request->allowed_methods->method_mask = 0;
+                    for(i = 0; i < size; i++)
+                    {
+                        if(i)
+                        {
+                            sprintf(temp, ", ");
+                            temp += 2;
+                        }
+                        sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env,
+                            i));
+                        temp += strlen(temp);
+                        /* Conditions below is to assist down-stream modules */
+                        if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get(
+                            method_list, env, i)))
+                        {
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT;
+                        }
+                        else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get(
+                            method_list, env, i)))
+                        {
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST;
+                        }
+                        else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get(
+                            method_list, env, i)))
+                        {
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
+                        }
+                        else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get(
+                            method_list, env, i)))
+                        {
+                            /* Apache Can't differentiate between HEAD and GET */
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET;
+                        }
+                        else if(!strcasecmp(AXIS2_HTTP_DELETE,
+                            (axis2_char_t *)axutil_array_list_get(method_list, env, i)))
+                        {
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE;
+                        }
+                    }
+                    *temp = '\0';
+                    apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW,
+                        method_list_str);
+                    AXIS2_FREE(env->allocator, method_list_str);
+                    body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx);
+                    request->status = HTTP_METHOD_NOT_ALLOWED;
+                }
+                else
+                {
+                    body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx);
+                    request->status = HTTP_NOT_FOUND;
+                }
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_BAD_REQUEST;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_REQUEST_TIME_OUT;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_CONFLICT;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_gone(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_GONE;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_PRECONDITION_FAILED;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_REQUEST_ENTITY_TOO_LARGE;
+            }
+            else if(axis2_msg_ctx_get_status_code(msg_ctx, env)
+                == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL)
+            {
+                body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_SERVICE_UNAVAILABLE;
+            }
+            else
+            {
+                body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx);
+                request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML;
+                request->status = HTTP_INTERNAL_SERVER_ERROR;
+            }
+
+            if(body_string)
+            {
+                body_string_len = axutil_strlen(body_string);
+            }
+            send_status = OK;
+        }
+    }
+    else if(M_POST == request->method_number || M_PUT == request->method_number)
+    {
+        /*axis2_status_t status = AXIS2_FAILURE;*/
+        if(M_POST == request->method_number)
+        {
+            status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx,
+                request_body, out_stream, content_type, content_length, soap_action,
+                (axis2_char_t *)url_external_form);
+        }
+        else
+        {
+            status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx,
+                request_body, out_stream, content_type, content_length, soap_action,
+                (axis2_char_t *)url_external_form);
+        }
+        if(AXIS2_FAILURE == status && (M_PUT == request->method_number
+            || axis2_msg_ctx_get_doing_rest(msg_ctx, env)))
+        {
+            if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND)
+            {
+                axutil_array_list_t *method_list = NULL;
+                int size = 0;
+                method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env);
+                size = axutil_array_list_size(method_list, env);
+                if(method_list && size)
+                {
+                    axis2_char_t *method_list_str = NULL;
+                    axis2_char_t *temp;
+                    int i = 0;
+                    method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29);
+                    temp = method_list_str;
+                    request->allowed_methods->method_mask = 0;
+                    for(i = 0; i < size; i++)
+                    {
+                        if(i)
+                        {
+                            sprintf(temp, ", ");
+                            temp += 2;
+                        }
+                        sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env,
+                            i));
+                        temp += strlen(temp);
+                        /* Conditions below is to assist down-stream modules */
+                        if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get(
+                            method_list, env, i)))
+                        {
+                            request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT;
+                        }

[... 1004 lines stripped ...]


Mime
View raw message