axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From shan...@apache.org
Subject svn commit: r810531 [2/3] - in /webservices/axis2/trunk/c/src/core/transport/http: common/ receiver/ server/apache2/ util/
Date Wed, 02 Sep 2009 14:45:11 GMT
Modified: webservices/axis2/trunk/c/src/core/transport/http/common/http_worker.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/transport/http/common/http_worker.c?rev=810531&r1=810530&r2=810531&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/transport/http/common/http_worker.c (original)
+++ webservices/axis2/trunk/c/src/core/transport/http/common/http_worker.c Wed Sep  2 14:45:10 2009
@@ -52,23 +52,16 @@
     axis2_http_simple_response_t * simple_response,
     axis2_ssize_t content_length);
 
-static axis2_status_t
-axis2_http_worker_set_transport_out_config(
-    axis2_http_worker_t * http_worker,
-    const axutil_env_t * env,
-    axis2_conf_ctx_t * conf_ctx,
-    axis2_http_simple_response_t * simple_response);
-
 static axutil_hash_t *
 axis2_http_worker_get_headers(
     axis2_http_worker_t * http_worker,
     const axutil_env_t * env,
     axis2_http_simple_request_t * request);
 
-static axis2_char_t *
-axis2_http_worker_get_server_time(
-    axis2_http_worker_t * http_worker,
-    const axutil_env_t * env);
+static axis2_http_simple_response_t *
+axis2_http_worker_create_simple_response(
+    axis2_http_worker_t *http_worker,
+    const axutil_env_t *env);
 
 AXIS2_EXTERN axis2_http_worker_t *AXIS2_CALL
 axis2_http_worker_create(
@@ -102,7 +95,7 @@
 
 /* Each in-coming request is passed into this function for process. Basically http method to deliver
  * is deduced here and call appropriate http processing function. 
- * eg. transport_utils_process_http_post_request() function. Once this fuction call done it will go
+ * eg. transport_utils_process_http_post_request() function. Once this function call done it will go
  * through engine inflow phases and finally hit the message receiver for the operation.
  */
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
@@ -181,15 +174,10 @@
     }
 
     content_length = axis2_http_simple_request_get_content_length(simple_request, env);
-
     request_line = axis2_http_simple_request_get_request_line(simple_request, env);
-    if(request_line)
-    {
-        http_method = axis2_http_request_line_get_method(request_line, env);
-    }
+    http_method = axis2_http_request_line_get_method(request_line, env);
 
     http_version = axis2_http_request_line_get_http_version(request_line, env);
-
     if(!http_version)
     {
         AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE);
@@ -197,54 +185,26 @@
     }
     AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version);
 
-    response = axis2_http_simple_response_create_default(env);
     encoding_header = axis2_http_simple_request_get_first_header(simple_request, env,
         AXIS2_HTTP_HEADER_TRANSFER_ENCODING);
-
-    if(response)
+    if(encoding_header)
     {
-        axis2_http_header_t *server = NULL;
-        axis2_http_header_t *server_date = NULL;
-        axis2_char_t *date_str = NULL;
-        char *date_str_tmp = NULL;
-
-        date_str_tmp = axis2_http_worker_get_server_time(http_worker, env);
-        date_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (strlen(date_str_tmp) + 5));
-
-        if(!date_str)
-        {
-            AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-            return AXIS2_FALSE;
-
-        }
-
-        sprintf(date_str, "%s GMT", date_str_tmp);
-
-        server_date = axis2_http_header_create(env, AXIS2_HTTP_HEADER_DATE, date_str);
-        if(date_str)
-        {
-            AXIS2_FREE(env->allocator, date_str);
-            date_str = NULL;
-        }
-        axis2_http_simple_response_set_header(response, env, server_date);
-
-        server = axis2_http_header_create(env,
-            AXIS2_HTTP_HEADER_SERVER,
-            AXIS2_HTTP_HEADER_SERVER_AXIS2C
-            AXIS2_HTTP_SERVER);
-        axis2_http_simple_response_set_header(response, env, server);
+        encoding_header_value = axis2_http_header_get_value(encoding_header, env);
     }
 
-    if(encoding_header)
+    response = axis2_http_worker_create_simple_response(http_worker, env);
+    if(!response)
     {
-        encoding_header_value = axis2_http_header_get_value(encoding_header, env);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot create http simple response");
+        return AXIS2_FALSE;
     }
 
-    if(content_length < 0 && (encoding_header_value && 0 != axutil_strcmp(encoding_header_value,
-        AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)))
+    /* if length is not given and it is not chunked, then return error to client */
+    if((content_length < 0) && encoding_header_value
+        && (0 != axutil_strcmp(encoding_header_value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)))
     {
-        if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_POST) || 0 == axutil_strcasecmp(
-            http_method, AXIS2_HTTP_PUT))
+        if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_POST)
+            || 0 == axutil_strcasecmp(http_method, AXIS2_HTTP_PUT))
         {
             axis2_http_simple_response_set_status_line(response, env, http_version,
                 AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_VAL,
@@ -252,27 +212,20 @@
 
             status = axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
             axis2_http_simple_response_free(response, env);
-            response = NULL;
             return status;
         }
-
     }
 
     request_body = axis2_http_simple_request_get_body(simple_request, env);
 
-    out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(http_worker->conf_ctx, env),
-        env, AXIS2_TRANSPORT_ENUM_HTTP);
-    in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(http_worker->conf_ctx, env), env,
+    out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env), env,
+        AXIS2_TRANSPORT_ENUM_HTTP);
+    in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(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);
 
-    if(0 == axutil_strcasecmp(http_version, AXIS2_HTTP_HEADER_PROTOCOL_11))
-    {
-        axis2_http_worker_set_transport_out_config(http_worker, env, conf_ctx, response);
-    }
-
     /* Server and Peer IP's */
     svr_ip = axis2_simple_http_svr_conn_get_svr_ip(svr_conn, env);
     peer_ip = axis2_simple_http_svr_conn_get_peer_ip(svr_conn, env);
@@ -377,7 +330,7 @@
         }
 
         if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env)
-            > 0)
+        > 0)
         {
             axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env,
                 accept_charset_record_list);
@@ -421,7 +374,7 @@
             while(token);
         }
         if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env)
-            > 0)
+        > 0)
         {
             axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env,
                 accept_language_record_list);
@@ -691,7 +644,7 @@
                     AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME);
 
                 body_string
-                    = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
+                = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
                 cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE,
                     AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
                 axis2_http_simple_response_set_header(response, env, cont_type);
@@ -901,7 +854,7 @@
                     AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME);
 
                 body_string
-                    = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
+                = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx);
                 cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE,
                     AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
                 axis2_http_simple_response_set_header(response, env, cont_type);
@@ -981,826 +934,826 @@
 
             if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
             {
-fault_code            = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR
-            AXIOM_SOAP11_FAULT_CODE_SENDER;
-        }
-        else
-        {
-            fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR
-            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));
-        req_line =
-        axis2_http_simple_request_get_request_line(simple_request, env);
-        if (req_line)
-        {
-            if (!http_error_value)
+                fault_code            = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR
+                    AXIOM_SOAP11_FAULT_CODE_SENDER;
+            }
+            else
             {
-                sprintf(status_line_str, "%s %s\r\n",
-                    http_version,
-                    AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR);
+                fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR
+                    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));
+            req_line =
+                axis2_http_simple_request_get_request_line(simple_request, env);
+            if (req_line)
+            {
+                if (!http_error_value)
+                {
+                    sprintf(status_line_str, "%s %s\r\n",
+                        http_version,
+                        AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR);
+                }
+                else
+                {
+                    sprintf(status_line_str, "%s %s",
+                        http_version,
+                        http_error_value);
+                }
             }
             else
             {
-                sprintf(status_line_str, "%s %s",
-                    http_version,
-                    http_error_value);
+                sprintf(status_line_str, "%s %s\r\n",
+                    AXIS2_HTTP_HEADER_PROTOCOL_11,
+                    AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR);
             }
-        }
-        else
-        {
-            sprintf(status_line_str, "%s %s\r\n",
-                AXIS2_HTTP_HEADER_PROTOCOL_11,
-                AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR);
-        }
 
-        tmp_stat_line = axis2_http_status_line_create(env, status_line_str);
+            tmp_stat_line = axis2_http_status_line_create(env, status_line_str);
 
-        if (!http_error_value)
-        {
-            axis2_engine_send_fault(engine, env, fault_ctx);
-        }
+            if (!http_error_value)
+            {
+                axis2_engine_send_fault(engine, env, fault_ctx);
+            }
 
-        status_code = axis2_http_status_line_get_status_code(tmp_stat_line, env);
-        reason_phrase = axis2_http_status_line_get_reason_phrase(tmp_stat_line, env);
+            status_code = axis2_http_status_line_get_status_code(tmp_stat_line, env);
+            reason_phrase = axis2_http_status_line_get_reason_phrase(tmp_stat_line, env);
 
-        axis2_http_simple_response_set_status_line(response, env,
-            http_version,
-            status_code,
-            reason_phrase);
+            axis2_http_simple_response_set_status_line(response, env,
+                http_version,
+                status_code,
+                reason_phrase);
 
-        axis2_http_simple_response_set_body_stream(response, env,
-            out_stream);
+            axis2_http_simple_response_set_body_stream(response, env,
+                out_stream);
 
-        stream_len = axutil_stream_get_len (out_stream, env);
-        axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-            simple_request, response,
-            stream_len);
+            stream_len = axutil_stream_get_len (out_stream, env);
+            axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                simple_request, response,
+                stream_len);
 
-        status = axis2_simple_http_svr_conn_write_response(svr_conn, env,
-            response);
-        request_handled = AXIS2_TRUE;
-        if(tmp_stat_line)
-        {
-            axis2_http_status_line_free(tmp_stat_line, env);
-            tmp_stat_line = NULL;
+            status = axis2_simple_http_svr_conn_write_response(svr_conn, env,
+                response);
+            request_handled = AXIS2_TRUE;
+            if(tmp_stat_line)
+            {
+                axis2_http_status_line_free(tmp_stat_line, env);
+                tmp_stat_line = NULL;
+            }
         }
     }
-}
-else
-{
-    /* Other case than, PUT, DELETE, HEAD, GET and POST */
-    /* 501, Request method is not implemented */
-    axis2_http_header_t *cont_len = NULL;
-    axis2_http_header_t *cont_type = NULL;
-    axis2_char_t *body_string = NULL;
-    axis2_http_simple_response_set_status_line(
-        response, env,
-        http_version,
-        AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL,
-        AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME);
-
-    body_string =
-    axis2_http_transport_utils_get_not_implemented(env,
-        conf_ctx);
-    cont_type = axis2_http_header_create(env,
-        AXIS2_HTTP_HEADER_CONTENT_TYPE,
-        AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
-    axis2_http_simple_response_set_header(response, env, cont_type);
-
-    if (body_string)
-    {
-        axis2_char_t str_len[10];
-        axis2_http_simple_response_set_body_string(response, env,
-            body_string);
-        sprintf(str_len, "%d", axutil_strlen(body_string));
-        cont_len = axis2_http_header_create(env,
-            AXIS2_HTTP_HEADER_CONTENT_LENGTH,
-            str_len);
-        axis2_http_simple_response_set_header(response, env, cont_len);
-    }
-
-    axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-        simple_request, response, 0);
-    axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
-    axis2_http_simple_response_free(response, env);
-    request_handled = AXIS2_TRUE;
-    status = AXIS2_TRUE;
-}
-
-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;*/
-    axis2_char_t *language_str = 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)
+    else
     {
-        language_str = axis2_msg_ctx_get_content_language(out_msg_ctx, env);
-    }
+        /* Other case than, PUT, DELETE, HEAD, GET and POST */
+        /* 501, Request method is not implemented */
+        axis2_http_header_t *cont_len = NULL;
+        axis2_http_header_t *cont_type = NULL;
+        axis2_char_t *body_string = NULL;
+        axis2_http_simple_response_set_status_line(
+            response, env,
+            http_version,
+            AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL,
+            AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME);
 
-    if (language_str && *language_str && !request_handled)
-    {
-        axis2_http_header_t *language = NULL;
-        language = axis2_http_header_create(env,
-            AXIS2_HTTP_HEADER_CONTENT_LANGUAGE,
-            language_str);
-        axis2_http_simple_response_set_header(response, env, language);
-    }
-}
+        body_string =
+            axis2_http_transport_utils_get_not_implemented(env,
+                conf_ctx);
+        cont_type = axis2_http_header_create(env,
+            AXIS2_HTTP_HEADER_CONTENT_TYPE,
+            AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
+        axis2_http_simple_response_set_header(response, env, cont_type);
+
+        if (body_string)
+        {
+            axis2_char_t str_len[10];
+            axis2_http_simple_response_set_body_string(response, env,
+                body_string);
+            sprintf(str_len, "%d", axutil_strlen(body_string));
+            cont_len = axis2_http_header_create(env,
+                AXIS2_HTTP_HEADER_CONTENT_LENGTH,
+                str_len);
+            axis2_http_simple_response_set_header(response, env, cont_len);
+        }
 
-if (!request_handled)
-{
-    axis2_bool_t do_rest = AXIS2_FALSE;
-    axis2_bool_t response_written = AXIS2_FALSE;
-    if (is_get || is_head || is_put || is_delete ||
-        axis2_msg_ctx_get_doing_rest(msg_ctx, env))
-    {
-        do_rest = AXIS2_TRUE;
+        axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+            simple_request, response, 0);
+        axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
+        axis2_http_simple_response_free(response, env);
+        request_handled = AXIS2_TRUE;
+        status = AXIS2_TRUE;
     }
 
-    if ((accept_header_value || accept_charset_header_value ||
-            accept_language_header_value) && do_rest)
+    op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
+    if (op_ctx)
     {
-        axis2_char_t *content_type_header_value = NULL;
-        axis2_http_header_t *content_type_header = NULL;
-        axis2_char_t *temp = NULL;
-        axis2_char_t *language_header_value = NULL;
-        axis2_http_header_t *language_header = NULL;
-        content_type_header = axis2_http_simple_response_get_first_header(
-            response,
-            env,
-            AXIS2_HTTP_HEADER_CONTENT_TYPE);
-
-        language_header = axis2_http_simple_response_get_first_header(
-            response,
-            env,
-            AXIS2_HTTP_HEADER_CONTENT_LANGUAGE);
+        /*axis2_msg_ctx_t *out_msg_ctx = NULL;
+     axis2_msg_ctx_t **msg_ctx_map = NULL;*/
+        axis2_char_t *language_str = NULL;
 
-        if (content_type_header)
+        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_type_header_value = axis2_http_header_get_value(content_type_header,
-                env);
+            language_str = axis2_msg_ctx_get_content_language(out_msg_ctx, env);
         }
 
-        if (content_type_header_value)
+        if (language_str && *language_str && !request_handled)
         {
-            temp = axutil_strdup(env, content_type_header_value);
+            axis2_http_header_t *language = NULL;
+            language = axis2_http_header_create(env,
+                AXIS2_HTTP_HEADER_CONTENT_LANGUAGE,
+                language_str);
+            axis2_http_simple_response_set_header(response, env, language);
         }
+    }
 
-        if (language_header)
+    if (!request_handled)
+    {
+        axis2_bool_t do_rest = AXIS2_FALSE;
+        axis2_bool_t response_written = AXIS2_FALSE;
+        if (is_get || is_head || is_put || is_delete ||
+            axis2_msg_ctx_get_doing_rest(msg_ctx, env))
         {
-            language_header_value = axis2_http_header_get_value(language_header,
-                env);
+            do_rest = AXIS2_TRUE;
         }
 
-        if (temp)
+        if ((accept_header_value || accept_charset_header_value ||
+            accept_language_header_value) && do_rest)
         {
-            axis2_char_t *content_type = NULL;
-            axis2_char_t *char_set = NULL;
-            axis2_char_t *temp2 = NULL;
+            axis2_char_t *content_type_header_value = NULL;
+            axis2_http_header_t *content_type_header = NULL;
+            axis2_char_t *temp = NULL;
+            axis2_char_t *language_header_value = NULL;
+            axis2_http_header_t *language_header = NULL;
+            content_type_header = axis2_http_simple_response_get_first_header(
+                response,
+                env,
+                AXIS2_HTTP_HEADER_CONTENT_TYPE);
 
-            temp2 = strchr(temp, AXIS2_SEMI_COLON);
-            if (temp2)
+            language_header = axis2_http_simple_response_get_first_header(
+                response,
+                env,
+                AXIS2_HTTP_HEADER_CONTENT_LANGUAGE);
+
+            if (content_type_header)
             {
-                *temp2 = AXIS2_ESC_NULL;
-                temp2++;
-                char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING);
+                content_type_header_value = axis2_http_header_get_value(content_type_header,
+                    env);
             }
 
-            if (char_set)
+            if (content_type_header_value)
             {
-                char_set = axutil_strltrim(env, char_set, AXIS2_SPACE_TAB_EQ);
+                temp = axutil_strdup(env, content_type_header_value);
             }
 
-            content_type = axutil_strtrim(env, temp, NULL);
-
-            if (temp)
+            if (language_header)
             {
-                AXIS2_FREE(env->allocator, temp);
-                temp = NULL;
+                language_header_value = axis2_http_header_get_value(language_header,
+                    env);
             }
 
-            if (content_type && accept_header_value &&
-                !axutil_strcasestr(accept_header_value, content_type))
+            if (temp)
             {
-                temp2 = strchr(content_type, AXIS2_F_SLASH);
+                axis2_char_t *content_type = NULL;
+                axis2_char_t *char_set = NULL;
+                axis2_char_t *temp2 = NULL;
+
+                temp2 = strchr(temp, AXIS2_SEMI_COLON);
                 if (temp2)
                 {
                     *temp2 = AXIS2_ESC_NULL;
-                    temp = AXIS2_MALLOC(env->allocator,
-                        sizeof(axis2_char_t) *
-                        ((int)strlen(content_type) + 3));
-                    if (!temp)
-                    {
-                        AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-                        return AXIS2_FALSE;
-                    }
+                    temp2++;
+                    char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING);
+                }
 
-                    sprintf(temp, "%s/*", content_type);
-                    if (!axutil_strcasestr(accept_header_value, temp) &&
-                        !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL))
-                    {
-                        /* 406, Not Acceptable */
-                        axis2_http_header_t *cont_len = NULL;
-                        axis2_http_header_t *cont_type = NULL;
-                        axis2_char_t *body_string = NULL;
-                        axis2_http_simple_response_set_status_line(
-                            response, env, http_version,
-                            AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
-                            AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
+                if (char_set)
+                {
+                    char_set = axutil_strltrim(env, char_set, AXIS2_SPACE_TAB_EQ);
+                }
 
-                        body_string =
-                        axis2_http_transport_utils_get_not_acceptable(env,
-                            conf_ctx);
-                        cont_type =
-                        axis2_http_header_create(env,
-                            AXIS2_HTTP_HEADER_CONTENT_TYPE,
-                            AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
+                content_type = axutil_strtrim(env, temp, NULL);
 
-                        axis2_http_simple_response_set_header(response, env, cont_type);
-                        if (body_string)
-                        {
-                            axis2_char_t str_len[10];
-                            axis2_http_simple_response_set_body_string(response, env,
-                                body_string);
-                            sprintf(str_len, "%d", axutil_strlen(body_string));
-                            cont_len =
-                            axis2_http_header_create(env,
-                                AXIS2_HTTP_HEADER_CONTENT_LENGTH,
-                                str_len);
+                if (temp)
+                {
+                    AXIS2_FREE(env->allocator, temp);
+                    temp = NULL;
+                }
 
-                            axis2_http_simple_response_set_header(response,
-                                env,
-                                cont_len);
+                if (content_type && accept_header_value &&
+                    !axutil_strcasestr(accept_header_value, content_type))
+                {
+                    temp2 = strchr(content_type, AXIS2_F_SLASH);
+                    if (temp2)
+                    {
+                        *temp2 = AXIS2_ESC_NULL;
+                        temp = AXIS2_MALLOC(env->allocator,
+                            sizeof(axis2_char_t) *
+                            ((int)strlen(content_type) + 3));
+                        if (!temp)
+                        {
+                            AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                            return AXIS2_FALSE;
                         }
 
-                        axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-                            simple_request, response, 0);
-                        axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
-                        axis2_http_simple_response_free(response, env);
-                        request_handled = AXIS2_TRUE;
-                        status = AXIS2_TRUE;
-                        response_written = AXIS2_TRUE;
+                        sprintf(temp, "%s/*", content_type);
+                        if (!axutil_strcasestr(accept_header_value, temp) &&
+                            !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL))
+                        {
+                            /* 406, Not Acceptable */
+                            axis2_http_header_t *cont_len = NULL;
+                            axis2_http_header_t *cont_type = NULL;
+                            axis2_char_t *body_string = NULL;
+                            axis2_http_simple_response_set_status_line(
+                                response, env, http_version,
+                                AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
+                                AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
+
+                            body_string =
+                                axis2_http_transport_utils_get_not_acceptable(env,
+                                    conf_ctx);
+                            cont_type =
+                                axis2_http_header_create(env,
+                                    AXIS2_HTTP_HEADER_CONTENT_TYPE,
+                                    AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
+
+                            axis2_http_simple_response_set_header(response, env, cont_type);
+                            if (body_string)
+                            {
+                                axis2_char_t str_len[10];
+                                axis2_http_simple_response_set_body_string(response, env,
+                                    body_string);
+                                sprintf(str_len, "%d", axutil_strlen(body_string));
+                                cont_len =
+                                    axis2_http_header_create(env,
+                                        AXIS2_HTTP_HEADER_CONTENT_LENGTH,
+                                        str_len);
+
+                                axis2_http_simple_response_set_header(response,
+                                    env,
+                                    cont_len);
+                            }
+
+                            axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                                simple_request, response, 0);
+                            axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
+                            axis2_http_simple_response_free(response, env);
+                            request_handled = AXIS2_TRUE;
+                            status = AXIS2_TRUE;
+                            response_written = AXIS2_TRUE;
+                        }
+                        AXIS2_FREE(env->allocator, temp);
                     }
-                    AXIS2_FREE(env->allocator, temp);
                 }
-            }
 
-            if (content_type)
-            {
-                AXIS2_FREE(env->allocator, content_type);
-            }
+                if (content_type)
+                {
+                    AXIS2_FREE(env->allocator, content_type);
+                }
 
-            if (char_set)
-            {
-                temp2 = strchr(char_set, AXIS2_EQ);
-            }
+                if (char_set)
+                {
+                    temp2 = strchr(char_set, AXIS2_EQ);
+                }
 
-            if (temp2)
-            {
-                ++temp2;
-            }
+                if (temp2)
+                {
+                    ++temp2;
+                }
 
-            if (char_set && accept_charset_header_value &&
-                !axutil_strcasestr(accept_charset_header_value, char_set) &&
-                !axutil_strcasestr(accept_charset_header_value, temp2))
-            {
-                /* 406, Not Acceptable */
-                axis2_http_header_t *cont_len = NULL;
-                axis2_http_header_t *cont_type = NULL;
-                axis2_char_t *body_string = NULL;
-                axis2_http_simple_response_set_status_line(
-                    response, env, http_version,
-                    AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
-                    AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
-                body_string =
-                axis2_http_transport_utils_get_not_acceptable(env,
-                    conf_ctx);
-                cont_type =
-                axis2_http_header_create(env,
-                    AXIS2_HTTP_HEADER_CONTENT_TYPE,
-                    AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
+                if (char_set && accept_charset_header_value &&
+                    !axutil_strcasestr(accept_charset_header_value, char_set) &&
+                    !axutil_strcasestr(accept_charset_header_value, temp2))
+                {
+                    /* 406, Not Acceptable */
+                    axis2_http_header_t *cont_len = NULL;
+                    axis2_http_header_t *cont_type = NULL;
+                    axis2_char_t *body_string = NULL;
+                    axis2_http_simple_response_set_status_line(
+                        response, env, http_version,
+                        AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
+                        AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
+                    body_string =
+                        axis2_http_transport_utils_get_not_acceptable(env,
+                            conf_ctx);
+                    cont_type =
+                        axis2_http_header_create(env,
+                            AXIS2_HTTP_HEADER_CONTENT_TYPE,
+                            AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
 
-                axis2_http_simple_response_set_header(response, env, cont_type);
-                if (body_string)
+                    axis2_http_simple_response_set_header(response, env, cont_type);
+                    if (body_string)
+                    {
+                        axis2_char_t str_len[10];
+                        axis2_http_simple_response_set_body_string(response, env,
+                            body_string);
+                        sprintf(str_len, "%d", axutil_strlen(body_string));
+                        cont_len = axis2_http_header_create(env,
+                            AXIS2_HTTP_HEADER_CONTENT_LENGTH,
+                            str_len);
+                        axis2_http_simple_response_set_header(response, env, cont_len);
+                    }
+                    axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                        simple_request, response, 0);
+                    axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
+                    request_handled = AXIS2_TRUE;
+                    status = AXIS2_TRUE;
+                    response_written = AXIS2_TRUE;
+                }
+                if (char_set)
                 {
-                    axis2_char_t str_len[10];
-                    axis2_http_simple_response_set_body_string(response, env,
-                        body_string);
-                    sprintf(str_len, "%d", axutil_strlen(body_string));
-                    cont_len = axis2_http_header_create(env,
-                        AXIS2_HTTP_HEADER_CONTENT_LENGTH,
-                        str_len);
-                    axis2_http_simple_response_set_header(response, env, cont_len);
+                    AXIS2_FREE(env->allocator, char_set);
                 }
-                axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-                    simple_request, response, 0);
-                axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
-                request_handled = AXIS2_TRUE;
-                status = AXIS2_TRUE;
-                response_written = AXIS2_TRUE;
             }
-            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))
+            if (language_header_value)
             {
-                /* 406, Not acceptable */
-                axis2_http_header_t *cont_len = NULL;
-                axis2_http_header_t *cont_type = NULL;
-                axis2_char_t *body_string = NULL;
-                axis2_http_simple_response_set_status_line(
-                    response, env, http_version,
-                    AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
-                    AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
+                if (accept_language_header_value &&
+                    !axutil_strcasestr(accept_language_header_value,
+                        language_header_value))
+                {
+                    /* 406, Not acceptable */
+                    axis2_http_header_t *cont_len = NULL;
+                    axis2_http_header_t *cont_type = NULL;
+                    axis2_char_t *body_string = NULL;
+                    axis2_http_simple_response_set_status_line(
+                        response, env, http_version,
+                        AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL,
+                        AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME);
 
-                body_string =
-                axis2_http_transport_utils_get_not_acceptable(env,
-                    conf_ctx);
-                cont_type =
-                axis2_http_header_create(env,
-                    AXIS2_HTTP_HEADER_CONTENT_TYPE,
-                    AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
+                    body_string =
+                        axis2_http_transport_utils_get_not_acceptable(env,
+                            conf_ctx);
+                    cont_type =
+                        axis2_http_header_create(env,
+                            AXIS2_HTTP_HEADER_CONTENT_TYPE,
+                            AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML);
 
-                axis2_http_simple_response_set_header(response, env, cont_type);
-                axis2_http_simple_response_remove_headers(
-                    response,
-                    env,
-                    AXIS2_HTTP_HEADER_CONTENT_LANGUAGE);
+                    axis2_http_simple_response_set_header(response, env, cont_type);
+                    axis2_http_simple_response_remove_headers(
+                        response,
+                        env,
+                        AXIS2_HTTP_HEADER_CONTENT_LANGUAGE);
 
-                if (body_string)
-                {
-                    axis2_char_t str_len[10];
-                    axis2_http_simple_response_set_body_string(response, env,
-                        body_string);
-                    sprintf(str_len, "%d", axutil_strlen(body_string));
-                    cont_len = axis2_http_header_create(env,
-                        AXIS2_HTTP_HEADER_CONTENT_LENGTH,
-                        str_len);
-                    axis2_http_simple_response_set_header(response, env, cont_len);
-                }
+                    if (body_string)
+                    {
+                        axis2_char_t str_len[10];
+                        axis2_http_simple_response_set_body_string(response, env,
+                            body_string);
+                        sprintf(str_len, "%d", axutil_strlen(body_string));
+                        cont_len = axis2_http_header_create(env,
+                            AXIS2_HTTP_HEADER_CONTENT_LENGTH,
+                            str_len);
+                        axis2_http_simple_response_set_header(response, env, cont_len);
+                    }
 
-                axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-                    simple_request, response, 0);
-                axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
-                request_handled = AXIS2_TRUE;
-                status = AXIS2_TRUE;
-                response_written = AXIS2_TRUE;
+                    axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                        simple_request, response, 0);
+                    axis2_simple_http_svr_conn_write_response(svr_conn, env, response);
+                    request_handled = AXIS2_TRUE;
+                    status = AXIS2_TRUE;
+                    response_written = AXIS2_TRUE;
+                }
             }
         }
-    }
 
-    if (!response_written)
-    {
-        /* If in there is a soap message is to to be sent in the back channel then we go inside this
-         * block. Somewhere in the receiveing end axis2_op_ctx_set_response_written() function has
-         * been called by this time to indicate to append the message into the http back channel.
-         */
-        if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env))
+        if (!response_written)
         {
-            if (do_rest)
+            /* If in there is a soap message is to to be sent in the back channel then we go inside this
+             * block. Somewhere in the receiveing end axis2_op_ctx_set_response_written() function has
+             * been called by this time to indicate to append the message into the http back channel.
+             */
+            if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env))
             {
-                /*axis2_msg_ctx_t *out_msg_ctx = NULL;
+                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);
+                    /*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 neccessary 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)
+                    in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN];
+                    if (in_msg_ctx)
                     {
-                        axis2_http_header_t *simple_header = NULL;
-                        size--;
-                        simple_header = (axis2_http_header_t *)
-                        axutil_array_list_get(output_header_list,
-                            env, size);
-                        axis2_http_simple_response_set_header(response,
-                            env,
-                            simple_header);
+                        /* TODO: Add neccessary handling */
                     }
-
-                    if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
+                    if (out_msg_ctx)
                     {
-                        int status_code = 0;
-                        axis2_char_t *status_code_str = NULL;
-                        status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env);
-
-                        switch (status_code)
+                        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)
                         {
-                            case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_ACK_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_GONE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME;
-                            break;
-                            default:
-                            status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL;
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_OK_CODE_NAME;
-                            break;
+                            size = axutil_array_list_size(output_header_list,
+                                env);
                         }
+                        while (size)
+                        {
+                            axis2_http_header_t *simple_header = NULL;
+                            size--;
+                            simple_header = (axis2_http_header_t *)
+                            axutil_array_list_get(output_header_list,
+                                env, size);
+                            axis2_http_simple_response_set_header(response,
+                                env,
+                                simple_header);
+                        }
+
+                        if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
+                        {
+                            int status_code = 0;
+                            axis2_char_t *status_code_str = NULL;
+                            status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env);
 
-                        axis2_http_simple_response_set_status_line(response, env,
-                            http_version,
-                            status_code,
-                            status_code_str);
-                        request_handled = AXIS2_TRUE;
+                            switch (status_code)
+                            {
+                                case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_ACK_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_GONE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME;
+                                    break;
+                                default:
+                                    status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL;
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_OK_CODE_NAME;
+                                    break;
+                            }
+
+                            axis2_http_simple_response_set_status_line(response, env,
+                                http_version,
+                                status_code,
+                                status_code_str);
+                            request_handled = AXIS2_TRUE;
+                        }
                     }
                 }
-            }
-
-            if (!request_handled)
-            {
-                axis2_http_simple_response_set_status_line(
-                    response, env, http_version,
-                    AXIS2_HTTP_RESPONSE_OK_CODE_VAL,
-                    AXIS2_HTTP_RESPONSE_OK_CODE_NAME);
 
-                if (!is_head)
+                if (!request_handled)
                 {
-                    /* This is where we append the message into the http back channel.*/
-                    axis2_http_simple_response_set_body_stream(response, env, out_stream);
+                    axis2_http_simple_response_set_status_line(
+                        response, env, http_version,
+                        AXIS2_HTTP_RESPONSE_OK_CODE_VAL,
+                        AXIS2_HTTP_RESPONSE_OK_CODE_NAME);
+
+                    if (!is_head)
+                    {
+                        /* This is where we append the message into the http back channel.*/
+                        axis2_http_simple_response_set_body_stream(response, env, out_stream);
+                    }
                 }
             }
-        }
-        else if (op_ctx)
-        {
-            /* If response is not written */
-            if (do_rest)
+            else if (op_ctx)
             {
-                /*axis2_msg_ctx_t *out_msg_ctx = NULL;
+                /* If response is not written */
+                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 neccessary 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)
+                    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)
                     {
-                        size = axutil_array_list_size(output_header_list,
-                            env);
+                        /* TODO: Add neccessary handling */
                     }
-
-                    while (size)
+                    if (out_msg_ctx)
                     {
-                        axis2_http_header_t *simeple_header = NULL;
-                        size--;
-                        simeple_header = (axis2_http_header_t *)
-                        axutil_array_list_get(output_header_list,
-                            env, size);
-                        axis2_http_simple_response_set_header(response, env,
-                            simeple_header);
-                    }
+                        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);
+                        }
 
-                    if (axis2_msg_ctx_get_no_content(out_msg_ctx, env))
-                    {
-                        if (axis2_msg_ctx_get_status_code(out_msg_ctx, env))
+                        while (size)
+                        {
+                            axis2_http_header_t *simeple_header = NULL;
+                            size--;
+                            simeple_header = (axis2_http_header_t *)
+                            axutil_array_list_get(output_header_list,
+                                env, size);
+                            axis2_http_simple_response_set_header(response, env,
+                                simeple_header);
+                        }
+
+                        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);
+                                axis2_char_t *status_code_str = NULL;
+                                switch (status_code)
+                                {
+                                    case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL:
+                                        status_code_str =
+                                            AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_NAME;
+                                        break;
+                                    case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
+                                        status_code_str =
+                                            AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
+                                        break;
+                                    default:
+                                        status_code =
+                                            AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL;
+                                        status_code_str =
+                                            AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME;
+                                        break;
+                                }
+                                axis2_http_simple_response_set_status_line(
+                                    response, env, http_version,
+                                    status_code,
+                                    status_code_str);
+                            }
+                            else
+                            {
+                                /* status code not available in msg_ctx */
+                                axis2_http_simple_response_set_status_line(
+                                    response, env, http_version,
+                                    AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL,
+                                    AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME);
+                            }
+
+                            request_handled = AXIS2_TRUE;
+                        }
+                        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);
                             axis2_char_t *status_code_str = NULL;
                             switch (status_code)
                             {
-                                case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL:
-                                status_code_str =
-                                AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_NAME;
-                                break;
+                                case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_OK_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_OK_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME;
+                                    break;
                                 case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                                status_code_str =
-                                AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
-                                break;
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_GONE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME;
+                                    break;
+                                case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME;
+                                    break;
                                 default:
-                                status_code =
-                                AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL;
-                                status_code_str =
-                                AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME;
-                                break;
+                                    status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL;
+                                    status_code_str =
+                                        AXIS2_HTTP_RESPONSE_ACK_CODE_NAME;
+                                    break;
                             }
                             axis2_http_simple_response_set_status_line(
                                 response, env, http_version,
                                 status_code,
                                 status_code_str);
-                        }
-                        else
-                        {
-                            /* status code not available in msg_ctx */
-                            axis2_http_simple_response_set_status_line(
-                                response, env, http_version,
-                                AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL,
-                                AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME);
-                        }
 
-                        request_handled = AXIS2_TRUE;
-                    }
-                    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);
-                        axis2_char_t *status_code_str = NULL;
-                        switch (status_code)
-                        {
-                            case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_OK_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_OK_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_GONE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME;
-                            break;
-                            case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL:
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME;
-                            break;
-                            default:
-                            status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL;
-                            status_code_str =
-                            AXIS2_HTTP_RESPONSE_ACK_CODE_NAME;
-                            break;
+                            request_handled = AXIS2_TRUE;
                         }
-                        axis2_http_simple_response_set_status_line(
-                            response, env, http_version,
-                            status_code,
-                            status_code_str);
-
-                        request_handled = AXIS2_TRUE;
                     }
                 }
+                if (!request_handled)
+                {
+                    axis2_http_simple_response_set_status_line(
+                        response, env, http_version,
+                        AXIS2_HTTP_RESPONSE_ACK_CODE_VAL,
+                        AXIS2_HTTP_RESPONSE_ACK_CODE_NAME);
+                }
             }
-            if (!request_handled)
+            else
             {
                 axis2_http_simple_response_set_status_line(
                     response, env, http_version,
                     AXIS2_HTTP_RESPONSE_ACK_CODE_VAL,
                     AXIS2_HTTP_RESPONSE_ACK_CODE_NAME);
             }
-        }
-        else
-        {
-            axis2_http_simple_response_set_status_line(
-                response, env, http_version,
-                AXIS2_HTTP_RESPONSE_ACK_CODE_VAL,
-                AXIS2_HTTP_RESPONSE_ACK_CODE_NAME);
-        }
 
-        if (!response_written)
-        {
-            int stream_len = 0;
-            stream_len = axutil_stream_get_len(out_stream, env);
+            if (!response_written)
+            {
+                int stream_len = 0;
+                stream_len = axutil_stream_get_len(out_stream, env);
 
-            /*axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                /*axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
              simple_request, response,
              stream_len);*/
 
-            /* This is where it actually write to the wire in the http back channel
-             * append case. */
-            if(out_msg_ctx)
-            {
-                axutil_array_list_t *mime_parts = NULL;
-                mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env);
-                /* If mime_parts is there then that means we send MTOM. So
-                 * in order to send MTOM we are enabling HTTP1.1 and cunk transfer
-                 * encoding */
-
-                if(mime_parts)
-                {
-                    axis2_http_header_t *transfer_enc_header = NULL;
-                    axutil_param_t *callback_name_param = NULL;
-                    axis2_char_t *mtom_sending_callback_name = NULL;
-
-                    /* Getting the sender callback name paramter if it is
-                     * specified in the configuration file */
-
-                    callback_name_param = axis2_msg_ctx_get_parameter(out_msg_ctx, env ,
-                        AXIS2_MTOM_SENDING_CALLBACK);
-                    if(callback_name_param)
+                /* This is where it actually write to the wire in the http back channel
+                 * append case. */
+                if(out_msg_ctx)
+                {
+                    axutil_array_list_t *mime_parts = NULL;
+                    mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env);
+                    /* If mime_parts is there then that means we send MTOM. So
+                     * in order to send MTOM we are enabling HTTP1.1 and cunk transfer
+                     * encoding */
+
+                    if(mime_parts)
                     {
-                        mtom_sending_callback_name =
-                        (axis2_char_t *) axutil_param_get_value (callback_name_param, env);
-                        if(mtom_sending_callback_name)
+                        axis2_http_header_t *transfer_enc_header = NULL;
+                        axutil_param_t *callback_name_param = NULL;
+                        axis2_char_t *mtom_sending_callback_name = NULL;
+
+                        /* Getting the sender callback name paramter if it is
+                         * specified in the configuration file */
+
+                        callback_name_param = axis2_msg_ctx_get_parameter(out_msg_ctx, env ,
+                            AXIS2_MTOM_SENDING_CALLBACK);
+                        if(callback_name_param)
                         {
-                            axis2_http_simple_response_set_mtom_sending_callback_name(
-                                response, env, mtom_sending_callback_name);
+                            mtom_sending_callback_name =
+                                (axis2_char_t *) axutil_param_get_value (callback_name_param, env);
+                            if(mtom_sending_callback_name)
+                            {
+                                axis2_http_simple_response_set_mtom_sending_callback_name(
+                                    response, env, mtom_sending_callback_name);
+                            }
                         }
-                    }
 
-                    axis2_http_simple_response_set_mime_parts(response, env, mime_parts);
+                        axis2_http_simple_response_set_mime_parts(response, env, mime_parts);
 
-                    axis2_http_simple_response_set_http_version(response, env,
-                        AXIS2_HTTP_HEADER_PROTOCOL_11);
+                        axis2_http_simple_response_set_http_version(response, env,
+                            AXIS2_HTTP_HEADER_PROTOCOL_11);
 
-                    transfer_enc_header = axis2_http_header_create(env,
-                        AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
-                        AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
+                        transfer_enc_header = axis2_http_header_create(env,
+                            AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
+                            AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
 
-                    axis2_http_simple_response_set_header(response, env,
-                        transfer_enc_header);
+                        axis2_http_simple_response_set_header(response, env,
+                            transfer_enc_header);
 
-                    /* In the chunking case content-lenght is zero */
-                    axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-                        simple_request, response,
-                        0);
-                }
-                else
-                {
-                    axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
-                        simple_request, response,
-                        stream_len);
+                        /* In the chunking case content-lenght is zero */
+                        axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                            simple_request, response,
+                            0);
+                    }
+                    else
+                    {
+                        axis2_http_worker_set_response_headers(http_worker, env, svr_conn,
+                            simple_request, response,
+                            stream_len);
+                    }
                 }
+                status = axis2_simple_http_svr_conn_write_response(svr_conn,
+                    env,
+                    response);
             }
-            status = axis2_simple_http_svr_conn_write_response(svr_conn,
-                env,
-                response);
         }
     }
-}
 
-if (url_external_form)
-{
-    AXIS2_FREE(env->allocator, url_external_form);
-    url_external_form = NULL;
-}
-if (op_ctx)
-{
-    axis2_msg_ctx_t *out_msg_ctx = NULL;
-    axis2_msg_ctx_t *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];
-
-    if (out_msg_ctx)
+    if (url_external_form)
     {
-        axis2_msg_ctx_free(out_msg_ctx, env);
-        out_msg_ctx = NULL;
-        msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL;
+        AXIS2_FREE(env->allocator, url_external_form);
+        url_external_form = NULL;
     }
-
-    if (in_msg_ctx)
+    if (op_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_t *out_msg_ctx = NULL;
+        axis2_msg_ctx_t *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);
 
-        axis2_msg_ctx_free(in_msg_ctx, env);
-        in_msg_ctx = NULL;
-        msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL;
-    }
+        out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];
+        in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN];
 
-    if (!axis2_op_ctx_is_in_use(op_ctx, env))
-    {
-        axis2_op_ctx_destroy_mutex(op_ctx, env);
-        if (conf_ctx && msg_id)
+        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)
         {
-            axis2_conf_ctx_register_op_ctx(conf_ctx, env, msg_id, NULL);
+            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_FREE(env->allocator, msg_id);
+            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);
         }
-        axis2_op_ctx_free(op_ctx, env);
-    }
 
-} /* Done freeing message contexts */
+    } /* Done freeing message contexts */
 
-msg_ctx = NULL;
-axutil_url_free(request_url, env);
-axutil_string_free(soap_action_str, env);
-request_url = NULL;
-return status;
+    msg_ctx = NULL;
+    axutil_url_free(request_url, env);
+    axutil_string_free(soap_action_str, env);
+    request_url = NULL;
+    return status;
 }
 
 static axis2_status_t
@@ -1891,27 +1844,6 @@
     return AXIS2_SUCCESS;
 }
 
-/*
- * This is only called for HTTP/1.1 to enable 1.1 specific parameters.
- *
- */
-static axis2_status_t
-axis2_http_worker_set_transport_out_config(
-    axis2_http_worker_t * http_worker,
-    const axutil_env_t * env,
-    axis2_conf_ctx_t * conf_ctx,
-    axis2_http_simple_response_t * simple_response)
-{
-    axis2_conf_t *config = NULL;
-
-    AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, simple_response, AXIS2_FAILURE);
-
-    config = axis2_conf_ctx_get_conf(conf_ctx, env);
-
-    return AXIS2_SUCCESS;
-}
-
 static axutil_hash_t *
 axis2_http_worker_get_headers(
     axis2_http_worker_t * http_worker,
@@ -1971,7 +1903,7 @@
     worker->svr_port = port;
     return AXIS2_SUCCESS;
 }
-
+#if 0
 static axis2_char_t *
 axis2_http_worker_get_server_time(
     axis2_http_worker_t * http_worker,
@@ -1994,4 +1926,60 @@
      */
     return time_str;
 }
+#endif
+
+static axis2_http_simple_response_t *
+axis2_http_worker_create_simple_response(
+    axis2_http_worker_t *http_worker,
+    const axutil_env_t *env)
+{
+    axis2_http_simple_response_t *response = NULL;
+    response = axis2_http_simple_response_create_default(env);
+    if(response)
+    {
+        axis2_http_header_t *server = NULL;
+        axis2_http_header_t *server_date = NULL;
+        axis2_char_t *date_str = NULL;
+        char *date_str_tmp = NULL;
+        time_t tp;
+        int date_str_len = 0;
+
+        /* create "Date: xxxx GMT" HTTP header */
+        tp = time(&tp);
+        date_str_tmp = ctime(&tp);
+        if(!date_str_tmp)
+        {
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot get server time");
+            return NULL;
+        }
+
+        date_str_len = strlen(date_str_tmp);
+        if(AXIS2_NEW_LINE == date_str_tmp[date_str_len - 1])
+        {
+            date_str_len -= 1;
+            date_str_tmp[date_str_len] = AXIS2_ESC_NULL;
+        }
+        /* We use the ANSI C Date Format, which is Legal according to RFC2616,
+         * Section 3.3.1. We are not a HTTP/1.1 only server, and thus, it suffices.
+         */
+
+        date_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (date_str_len + 5));
+        if(!date_str)
+        {
+            AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+
+        }
+        sprintf(date_str, "%s GMT", date_str_tmp);
+        server_date = axis2_http_header_create(env, AXIS2_HTTP_HEADER_DATE, date_str);
+        AXIS2_FREE(env->allocator, date_str);
+        axis2_http_simple_response_set_header(response, env, server_date);
+
+        /* create "Server: Axis2C/x.x.x (Simple Axis2 HTTP Server)" HTTP Header */
+        server = axis2_http_header_create(env, AXIS2_HTTP_HEADER_SERVER,
+            AXIS2_HTTP_HEADER_SERVER_AXIS2C AXIS2_HTTP_SERVER);
+        axis2_http_simple_response_set_header(response, env, server);
+    }
+    return response;
+}
 



Mime
View raw message