/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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; 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; }