| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <axis2_http_worker.h> |
| #include <axutil_string.h> |
| #include <axis2_http_transport.h> |
| #include <axis2_conf.h> |
| #include <axutil_string.h> |
| #include <axis2_msg_ctx.h> |
| #include <axis2_http_request_line.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 <axutil_url.h> |
| #include <axutil_property.h> |
| #include <axiom_soap.h> |
| #include <string.h> |
| #include <axutil_string_util.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <platforms/axutil_platform_auto_sense.h> |
| |
| struct axis2_http_worker |
| { |
| axis2_conf_ctx_t *conf_ctx; |
| int svr_port; |
| axis2_bool_t is_application_client_side; |
| }; |
| |
| static axis2_status_t |
| axis2_http_worker_set_response_headers( |
| axis2_http_worker_t * http_worker, |
| const axutil_env_t * env, |
| axis2_simple_http_svr_conn_t * svr_conn, |
| axis2_http_simple_request_t * simple_request, |
| axis2_http_simple_response_t * simple_response, |
| axis2_ssize_t content_length); |
| |
| 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_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( |
| const axutil_env_t * env, |
| axis2_conf_ctx_t * conf_ctx) |
| { |
| axis2_http_worker_t *http_worker = NULL; |
| |
| http_worker = (axis2_http_worker_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_worker_t)); |
| |
| if(!http_worker) |
| { |
| AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| http_worker->conf_ctx = conf_ctx; |
| http_worker->svr_port = 9090; /* default - must set later */ |
| http_worker->is_application_client_side = AXIS2_FALSE; /* default is creating for application |
| server side */ |
| |
| return http_worker; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL |
| axis2_http_worker_free( |
| axis2_http_worker_t * http_worker, |
| const axutil_env_t * env) |
| { |
| http_worker->conf_ctx = NULL; |
| AXIS2_FREE(env->allocator, http_worker); |
| return; |
| } |
| |
| /* 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 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 |
| axis2_http_worker_process_request( |
| axis2_http_worker_t * http_worker, |
| const axutil_env_t * env, |
| axis2_simple_http_svr_conn_t * svr_conn, |
| axis2_http_simple_request_t * simple_request) |
| { |
| axis2_conf_ctx_t *conf_ctx = NULL; |
| axis2_msg_ctx_t *msg_ctx = NULL; |
| axutil_stream_t *request_body = NULL; |
| |
| /* Creating out_stream as basic stream */ |
| axutil_stream_t *out_stream = axutil_stream_create_basic(env); |
| axis2_http_simple_response_t *response = NULL; |
| |
| /* Transport in and out descriptions */ |
| axis2_transport_out_desc_t *out_desc = NULL; |
| axis2_transport_in_desc_t *in_desc = NULL; |
| |
| axis2_char_t *http_version = NULL; |
| axis2_char_t *soap_action = NULL; |
| axutil_string_t *soap_action_str = NULL; |
| axis2_bool_t processed = AXIS2_FALSE; |
| axis2_status_t status = AXIS2_FAILURE; |
| int content_length = -1; |
| axis2_http_header_t *encoding_header = NULL; |
| axis2_char_t *encoding_header_value = NULL; |
| axis2_op_ctx_t *op_ctx = NULL; |
| axis2_char_t *svr_ip = NULL; |
| axis2_char_t *peer_ip = NULL; |
| axutil_url_t *request_url = NULL; |
| axis2_http_out_transport_info_t *http_out_transport_info = NULL; |
| axutil_hash_t *headers = NULL; |
| axis2_char_t *url_external_form = NULL; |
| axis2_char_t *svc_grp_uuid = NULL; |
| axis2_char_t *path = NULL; |
| axutil_property_t *peer_property = NULL; |
| |
| /* REST processing variables */ |
| axis2_bool_t is_get = AXIS2_FALSE; |
| axis2_bool_t is_head = AXIS2_FALSE; |
| axis2_bool_t is_put = AXIS2_FALSE; |
| axis2_bool_t is_delete = AXIS2_FALSE; |
| axis2_bool_t request_handled = AXIS2_FALSE; |
| |
| /* HTTP and Proxy authentication */ |
| axis2_char_t *cookie_header_value = NULL; |
| /*axis2_char_t *set_cookie_header_value = NULL; |
| axis2_http_header_t *set_cookie_header = NULL; |
| axis2_http_header_t *connection_header = NULL;*/ |
| axis2_http_header_t *cookie_header = NULL; |
| axis2_char_t *accept_header_value = NULL; |
| axis2_http_header_t *accept_header = NULL; |
| axis2_char_t *accept_charset_header_value = NULL; |
| axis2_http_header_t *accept_charset_header = NULL; |
| axis2_char_t *accept_language_header_value = NULL; |
| axis2_http_header_t *accept_language_header = NULL; |
| |
| axis2_char_t *http_method = NULL; |
| axis2_http_request_line_t *request_line = NULL; |
| |
| axutil_hash_t *request_params = NULL; |
| axis2_char_t *request_uri = NULL; |
| axis2_char_t *url_ext_form = NULL; |
| const axis2_char_t *content_type = NULL; |
| |
| 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_PARAM_CHECK(env->error, svr_conn, AXIS2_FALSE); |
| AXIS2_PARAM_CHECK(env->error, simple_request, AXIS2_FALSE); |
| |
| conf_ctx = http_worker->conf_ctx; |
| if(!conf_ctx) |
| { |
| AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); |
| return AXIS2_FALSE; |
| } |
| |
| content_length = axis2_http_simple_request_get_content_length(simple_request, env); |
| request_line = axis2_http_simple_request_get_request_line(simple_request, 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); |
| return AXIS2_FALSE; |
| } |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version); |
| |
| encoding_header = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING); |
| if(encoding_header) |
| { |
| encoding_header_value = axis2_http_header_get_value(encoding_header, env); |
| } |
| |
| response = axis2_http_worker_create_simple_response(http_worker, env); |
| if(!response) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot create http simple response"); |
| return AXIS2_FALSE; |
| } |
| |
| /* 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)) |
| { |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_NAME); |
| |
| status = axis2_simple_http_svr_conn_write_response(svr_conn, env, response); |
| axis2_http_simple_response_free(response, env); |
| 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(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); |
| |
| cookie_header = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_COOKIE); |
| if(cookie_header) |
| { |
| char *session_str = NULL; |
| axis2_char_t *session_id = NULL; |
| |
| cookie_header_value = axis2_http_header_get_value(cookie_header, env); |
| if(cookie_header_value) |
| { |
| session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, |
| cookie_header_value); |
| } |
| if(session_id && env->get_session_fn) |
| { |
| session_str = env->get_session_fn((void *) conf_ctx, session_id); |
| } |
| if(session_str) |
| { |
| axis2_http_transport_utils_set_session(env, msg_ctx, session_str); |
| } |
| } |
| |
| /*connection_header = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_CONNECTION); |
| if(connection_header) |
| { |
| axutil_property_t *connection_header_property = NULL; |
| axis2_char_t *connection_header_value = NULL; |
| connection_header_value = axis2_http_header_get_value(connection_header, env); |
| connection_header_property = axutil_property_create_with_args(env, |
| AXIS2_SCOPE_REQUEST, 0, 0, connection_header_value); |
| axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_HEADER_CONNECTION, |
| connection_header_property); |
| }*/ |
| |
| /* 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); |
| |
| 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); |
| } |
| |
| path = axis2_http_request_line_get_uri(request_line, env); |
| |
| request_url = axutil_url_create(env, AXIS2_HTTP_PROTOCOL, svr_ip, http_worker->svr_port, path); |
| if(request_url) |
| { |
| url_external_form = axutil_url_to_external_form(request_url, env); |
| } |
| |
| if(!url_external_form) |
| { |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); |
| status = axis2_simple_http_svr_conn_write_response(svr_conn, env, response); |
| axis2_http_simple_response_free(response, env); |
| response = NULL; |
| return status; |
| } |
| |
| accept_header = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_ACCEPT); |
| if(accept_header) |
| { |
| accept_header_value = axis2_http_header_get_value(accept_header, env); |
| } |
| 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, AXIS2_COMMA); |
| 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 = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_ACCEPT_CHARSET); |
| if(accept_charset_header) |
| { |
| accept_charset_header_value = axis2_http_header_get_value(accept_charset_header, env); |
| } |
| 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, |
| AXIS2_COMMA); |
| 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 = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE); |
| if(accept_language_header) |
| { |
| accept_language_header_value = axis2_http_header_get_value(accept_language_header, env); |
| } |
| |
| 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, |
| AXIS2_COMMA); |
| 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); |
| } |
| } |
| |
| /* Here out_stream is set into the in message context. out_stream is copied from in message context |
| * into the out message context later in core_utils_create_out_msg_ctx() function. The buffer in |
| * out_stream is finally filled with the soap envelope in http_transport_sender_invoke() function. |
| * To avoid double freeing of out_stream we reset the out message context at the end of engine |
| * receive function. |
| */ |
| axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); |
| |
| headers = axis2_http_worker_get_headers(http_worker, env, simple_request); |
| axis2_msg_ctx_set_transport_headers(msg_ctx, env, headers); |
| |
| svc_grp_uuid = axutil_uuid_gen(env); |
| if(svc_grp_uuid) |
| { |
| axutil_string_t *svc_grp_uuid_str = axutil_string_create_assume_ownership(env, |
| &svc_grp_uuid); |
| axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_uuid_str); |
| axutil_string_free(svc_grp_uuid_str, env); |
| } |
| |
| http_out_transport_info = axis2_http_out_transport_info_create(env, response); |
| axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(http_out_transport_info->out_transport)); |
| |
| if(axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_SOAP_ACTION)) |
| { |
| soap_action = axis2_http_header_get_value(axis2_http_simple_request_get_first_header( |
| simple_request, env, AXIS2_HTTP_HEADER_SOAP_ACTION), env); |
| soap_action_str = axutil_string_create(env, soap_action); |
| } |
| |
| if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_GET)) |
| { |
| is_get = AXIS2_TRUE; |
| } |
| else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_HEAD)) |
| { |
| is_head = AXIS2_TRUE; |
| } |
| else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_DELETE)) |
| { |
| is_delete = AXIS2_TRUE; |
| } |
| else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_PUT)) |
| { |
| is_put = AXIS2_TRUE; |
| } |
| |
| request_uri = axis2_http_request_line_get_uri(request_line, env); |
| request_params = axis2_http_transport_utils_get_request_params(env, request_uri); |
| url_ext_form = axutil_url_to_external_form(request_url, env); |
| |
| content_type = axis2_http_simple_request_get_content_type(simple_request, env); |
| |
| if(is_get || is_head || is_delete) |
| { |
| |
| if(is_get) |
| { |
| /* HTTP GET */ |
| processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx, |
| request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, |
| request_params); |
| } |
| else if(is_delete) |
| { |
| /* HTTP DELETE */ |
| processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx, |
| request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, |
| request_params); |
| } |
| else if(is_head) |
| { |
| /* HTTP HEAD */ |
| processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx, |
| request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, |
| request_params); |
| } |
| |
| if(AXIS2_FALSE == processed) |
| { |
| axis2_http_header_t *cont_len = NULL; |
| axis2_http_header_t *cont_type = NULL; |
| axis2_char_t *body_string = NULL; |
| axis2_char_t *wsdl = NULL; |
| axis2_bool_t is_services_path = AXIS2_FALSE; |
| |
| if(!is_delete) |
| { |
| axis2_char_t *temp = NULL; |
| /* check whether request url have "/services" */ |
| temp = strstr(axutil_url_get_path(request_url, env), AXIS2_REQUEST_URL_PREFIX); |
| if(temp) |
| { |
| temp += strlen(AXIS2_REQUEST_URL_PREFIX); |
| if(*temp == AXIS2_F_SLASH) |
| { |
| temp++; |
| } |
| if(!*temp || *temp == AXIS2_Q_MARK || *temp == AXIS2_H_MARK) |
| { |
| is_services_path = AXIS2_TRUE; |
| } |
| } |
| |
| } |
| |
| /* processing request for WSDL via "?wsdl" */ |
| wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL); |
| if(is_services_path) |
| { |
| /* request for service */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_OK_CODE_VAL, AXIS2_HTTP_RESPONSE_OK_CODE_NAME); |
| body_string = axis2_http_transport_utils_get_services_html(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); |
| } |
| else if(!is_delete && wsdl) |
| { |
| /* Request is not for delete and ask for wsdl */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_OK_CODE_VAL, AXIS2_HTTP_RESPONSE_OK_CODE_NAME); |
| body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx, |
| url_external_form); |
| cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, |
| AXIS2_HTTP_HEADER_ACCEPT_APPLICATION_XML); |
| axis2_http_simple_response_set_header(response, env, cont_type); |
| } |
| else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) |
| { |
| |
| /* Processing SVC or Operation Not found case */ |
| 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_http_header_t *allow_header = NULL; |
| 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); |
| |
| if(!method_list_str) |
| { |
| AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FALSE); |
| } |
| |
| temp = method_list_str; |
| for(i = 0; i < size; i++) |
| { |
| if(i) |
| { |
| sprintf(temp, AXIS2_COMMA_SPACE_STR); |
| temp += 2; |
| } |
| sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, |
| i)); |
| temp += strlen(temp); |
| } |
| *temp = AXIS2_ESC_NULL; |
| |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); |
| allow_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_ALLOW, |
| method_list_str); |
| axis2_http_simple_response_set_header(response, env, allow_header); |
| AXIS2_FREE(env->allocator, method_list_str); |
| } |
| else |
| { |
| /* 404 Not Found */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_not_found(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) |
| { |
| /* 400 Bad Request */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_bad_request(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) |
| { |
| |
| /* 408 , Request Time Out */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_request_timeout(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) |
| { |
| /* 409, Conflict */ |
| |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL, AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_conflict(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) |
| { |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_GONE_CODE_VAL, AXIS2_HTTP_RESPONSE_GONE_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_gone(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) |
| { |
| /* 412 Precondition failed */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_precondition_failed(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) |
| { |
| /* 413 entity too large */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME); |
| |
| body_string |
| = 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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) |
| { |
| /* 503, Service Unavailable*/ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_service_unavailable(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); |
| } |
| else |
| { |
| /* 500 Internal Server Error */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_internal_server_error(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]; |
| if(!is_head) |
| { |
| 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; |
| } |
| } |
| else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_POST) || is_put) |
| { |
| if(is_put) |
| { |
| axutil_property_t *property = NULL; |
| if(http_worker->is_application_client_side) |
| { |
| property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, 0, |
| AXIS2_VALUE_TRUE); |
| } |
| else |
| { |
| property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_FALSE, |
| 0, AXIS2_VALUE_FALSE); |
| } |
| axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE, |
| property); |
| status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx, |
| request_body, out_stream, content_type, content_length, soap_action_str, |
| url_ext_form); |
| |
| } |
| else |
| { |
| axutil_property_t *property = NULL; |
| if(http_worker->is_application_client_side) |
| { |
| property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, 0, |
| AXIS2_VALUE_TRUE); |
| } |
| else |
| { |
| property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_FALSE, |
| 0, AXIS2_VALUE_FALSE); |
| } |
| axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE, |
| property); |
| status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx, |
| request_body, out_stream, content_type, content_length, soap_action_str, |
| url_ext_form); |
| |
| } |
| |
| if(AXIS2_FAILURE == status && (is_put || axis2_msg_ctx_get_doing_rest(msg_ctx, env))) |
| { |
| /* Failure Occur while processing REST */ |
| |
| axis2_http_header_t *cont_len = NULL; |
| axis2_http_header_t *cont_type = NULL; |
| axis2_char_t *body_string = NULL; |
| 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_http_header_t *allow_header = NULL; |
| 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); |
| if(!method_list_str) |
| { |
| AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FALSE); |
| } |
| |
| temp = method_list_str; |
| for(i = 0; i < size; i++) |
| { |
| if(i) |
| { |
| sprintf(temp, AXIS2_COMMA_SPACE_STR); |
| temp += 2; |
| } |
| sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, |
| i)); |
| temp += strlen(temp); |
| } |
| *temp = AXIS2_ESC_NULL; |
| |
| /* 405 Method Not Allowed */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); |
| allow_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_ALLOW, |
| method_list_str); |
| axis2_http_simple_response_set_header(response, env, allow_header); |
| AXIS2_FREE(env->allocator, method_list_str); |
| } |
| else |
| { |
| /* 404 Not Found */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_not_found(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) |
| { |
| /* 400, Bad Request */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_bad_request(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) |
| { |
| /* 408, Request Timeout */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_request_timeout(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) |
| { |
| /* 409, Conflict Types */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL, AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_conflict(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) |
| { |
| /* 410, Gone. Resource no longer available */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_GONE_CODE_VAL, AXIS2_HTTP_RESPONSE_GONE_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_gone(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) |
| { |
| /*410, Precondition for the url failed */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_precondition_failed(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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) |
| { |
| /* 413, Request entity too large */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME); |
| |
| body_string |
| = 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); |
| } |
| else if(axis2_msg_ctx_get_status_code(msg_ctx, env) |
| == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) |
| { |
| /* 513, Service Unavailable */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_service_unavailable(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); |
| } |
| else |
| { |
| /* 500, Internal Server Error */ |
| axis2_http_simple_response_set_status_line(response, env, http_version, |
| AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL, |
| AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME); |
| |
| body_string = axis2_http_transport_utils_get_internal_server_error(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]; |
| if(!is_head) |
| { |
| 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; |
| } |
| else if(status == AXIS2_FAILURE) |
| { |
| axis2_msg_ctx_t *fault_ctx = NULL; |
| axis2_engine_t *engine = axis2_engine_create(env, conf_ctx); |
| axis2_http_request_line_t *req_line = NULL; |
| axis2_http_status_line_t *tmp_stat_line = NULL; |
| axis2_char_t status_line_str[100]; |
| axutil_property_t *http_error_property = NULL; |
| axis2_char_t *http_error_value = NULL; |
| axis2_char_t *fault_code = NULL; |
| int status_code = 0; |
| axis2_char_t *reason_phrase = NULL; |
| int stream_len = 0; |
| |
| if(!engine) |
| { |
| return AXIS2_FALSE; |
| } |
| |
| http_error_property = axis2_msg_ctx_get_property(msg_ctx, env, |
| AXIS2_HTTP_TRANSPORT_ERROR); |
| |
| if(http_error_property) |
| http_error_value = (axis2_char_t *)axutil_property_get_value(http_error_property, |
| env); |
| |
| 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) |
| { |
| 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\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); |
| |
| 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); |
| |
| 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); |
| |
| 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; |
| } |
| |
| axis2_engine_free(engine, env); |
| if(fault_ctx) |
| { |
| axis2_msg_ctx_free(fault_ctx, env); |
| } |
| } |
| } |
| 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); |
| request_handled = AXIS2_TRUE; |
| status = AXIS2_TRUE; |
| } |
| |
| if(url_ext_form) |
| { |
| AXIS2_FREE(env->allocator, url_ext_form); |
| } |
| |
| 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) |
| { |
| language_str = axis2_msg_ctx_get_content_language(out_msg_ctx, env); |
| } |
| |
| 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); |
| } |
| } |
| |
| 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; |
| } |
| |
| if ((accept_header_value || accept_charset_header_value || |
| accept_language_header_value) && do_rest) |
| { |
| 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); |
| |
| if (content_type_header) |
| { |
| content_type_header_value = axis2_http_header_get_value(content_type_header, |
| env); |
| } |
| |
| if (content_type_header_value) |
| { |
| temp = axutil_strdup(env, content_type_header_value); |
| } |
| |
| if (language_header) |
| { |
| language_header_value = axis2_http_header_get_value(language_header, |
| env); |
| } |
| |
| if (temp) |
| { |
| 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; |
| temp2++; |
| char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING); |
| } |
| |
| if (char_set) |
| { |
| char_set = axutil_strltrim(env, char_set, AXIS2_SPACE_TAB_EQ); |
| } |
| |
| 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, 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; |
| } |
| |
| 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); |
| request_handled = AXIS2_TRUE; |
| status = AXIS2_TRUE; |
| response_written = AXIS2_TRUE; |
| } |
| AXIS2_FREE(env->allocator, temp); |
| } |
| } |
| |
| if (content_type) |
| { |
| AXIS2_FREE(env->allocator, content_type); |
| } |
| |
| if (char_set) |
| { |
| temp2 = strchr(char_set, AXIS2_EQ); |
| } |
| |
| 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); |
| |
| 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_FREE(env->allocator, char_set); |
| } |
| } |
| |
| if (language_header_value) |
| { |
| 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); |
| |
| 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); |
| } |
| |
| 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 (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) |
| { |
| 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); |
| |
| 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) |
| { |
| /* 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) |
| { |
| /*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 neccssary 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 *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_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; |
| } |
| 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); |
| } |
| } |
| 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); |
| |
| /*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) |
| { |
| 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_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); |
| |
| axis2_http_simple_response_set_header(response, env, |
| transfer_enc_header); |
| |
| /* In the chunking case content-length 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); |
| } |
| } |
| } |
| |
| 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) |
| { |
| 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_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 */ |
| else |
| { |
| /* cases like HEAD, WSDL */ |
| axis2_msg_ctx_free(msg_ctx, env); |
| } |
| |
| 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 |
| axis2_http_worker_set_response_headers( |
| axis2_http_worker_t * http_worker, |
| const axutil_env_t * env, |
| axis2_simple_http_svr_conn_t * svr_conn, |
| axis2_http_simple_request_t * simple_request, |
| axis2_http_simple_response_t * simple_response, |
| axis2_ssize_t content_length) |
| { |
| axis2_http_header_t *conn_header = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, svr_conn, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, simple_request, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, simple_response, AXIS2_FAILURE); |
| |
| if(AXIS2_FALSE == axis2_http_simple_response_contains_header(simple_response, env, |
| AXIS2_HTTP_HEADER_CONNECTION)) |
| { |
| conn_header = axis2_http_simple_request_get_first_header(simple_request, env, |
| AXIS2_HTTP_HEADER_CONNECTION); |
| if(conn_header) |
| { |
| axis2_char_t *value = NULL; |
| value = axis2_http_header_get_value(conn_header, env); |
| |
| if(0 == axutil_strcasecmp(value, AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE)) |
| { |
| /* Comment these until keep alive support is completed for simple Axis2/C server */ |
| /*axis2_http_header_t *header = axis2_http_header_create(env, |
| AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); |
| |
| axis2_http_simple_response_set_header(simple_response, env, header); |
| axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_TRUE);*/ |
| } |
| |
| if(0 == axutil_strcasecmp(value, AXIS2_HTTP_HEADER_CONNECTION_CLOSE)) |
| { |
| axis2_http_header_t *header = axis2_http_header_create(env, |
| AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_CLOSE); |
| |
| axis2_http_simple_response_set_header(simple_response, env, header); |
| axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE); |
| } |
| } |
| else |
| { /* Connection Header not available */ |
| axis2_char_t *http_version = NULL; |
| http_version = axis2_http_simple_response_get_http_version(simple_response, env); |
| if(http_version && !axutil_strcasecmp(http_version, AXIS2_HTTP_HEADER_PROTOCOL_11)) |
| { |
| /* Comment these until keep alive support is completed for simple Axis2/C server */ |
| /*axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_TRUE);*/ |
| /* Instead add following to always send close connection header to indicate that |
| * we don't support http keep alive yet in simple Axis2/C server |
| */ |
| axis2_http_header_t *header = axis2_http_header_create(env, |
| AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_CLOSE); |
| |
| axis2_http_simple_response_set_header(simple_response, env, header); |
| /*axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE);*/ |
| } |
| else |
| { |
| axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE); |
| } |
| } |
| |
| if(!axis2_http_simple_response_contains_header(simple_response, env, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING)) |
| { |
| if(AXIS2_FALSE == axis2_http_simple_request_contains_header(simple_request, env, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING)) |
| { |
| if(0 != content_length) |
| { |
| axis2_char_t content_len_str[10]; |
| axis2_http_header_t *content_len_hdr = NULL; |
| |
| //Adds more 2 to http content length to involve CR and LF chars |
| content_length += 2; |
| |
| sprintf(content_len_str, "%d", content_length); |
| content_len_hdr = axis2_http_header_create(env, |
| AXIS2_HTTP_HEADER_CONTENT_LENGTH, content_len_str); |
| axis2_http_simple_response_set_header(simple_response, env, content_len_hdr); |
| } |
| } |
| else |
| { |
| /* Having Transfer encoding Header */ |
| axis2_http_header_t *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(simple_response, env, transfer_enc_header); |
| } |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| 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) |
| { |
| axutil_array_list_t *header_list = NULL; |
| int hdr_count = 0; |
| int i = 0; |
| axutil_hash_t *header_map = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, request, NULL); |
| |
| header_list = axis2_http_simple_request_get_headers(request, env); |
| if(!header_list) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "http simple request" |
| "doesn't contain a header list"); |
| return NULL; |
| } |
| hdr_count = axutil_array_list_size(header_list, env); |
| if(0 == hdr_count) |
| { |
| AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "http simple request , " |
| "header list contains zero headers"); |
| return NULL; |
| } |
| |
| for(i = 0; i < hdr_count; i++) |
| { |
| axis2_http_header_t *tmp_hdr = NULL; |
| tmp_hdr = axutil_array_list_get(header_list, env, i); |
| if(!tmp_hdr) |
| { |
| continue; |
| } |
| if(!header_map) |
| { |
| header_map = axutil_hash_make(env); |
| if(!header_map) |
| { |
| return NULL; |
| } |
| } |
| axutil_hash_set(header_map, axis2_http_header_get_name(tmp_hdr, env), |
| AXIS2_HASH_KEY_STRING, tmp_hdr); |
| } |
| return header_map; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_worker_set_svr_port( |
| axis2_http_worker_t * worker, |
| const axutil_env_t * env, |
| int port) |
| { |
| 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, |
| const axutil_env_t * env) |
| { |
| time_t tp; |
| char *time_str; |
| tp = time(&tp); |
| time_str = ctime(&tp); |
| if(!time_str) |
| { |
| return NULL; |
| } |
| if(AXIS2_NEW_LINE == time_str[strlen(time_str) - 1]) |
| { |
| time_str[strlen(time_str) - 1] = 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. |
| */ |
| 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; |
| size_t 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; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL |
| axis2_http_worker_set_is_application_client_side( |
| axis2_http_worker_t *http_worker, |
| const axutil_env_t *env, |
| axis2_bool_t application_client_side) |
| { |
| http_worker->is_application_client_side = application_client_side; |
| } |
| |
| |
