diff options
Diffstat (limited to 'src/core/transport/http/util/http_transport_utils.c')
| -rw-r--r-- | src/core/transport/http/util/http_transport_utils.c | 3885 |
1 files changed, 3885 insertions, 0 deletions
diff --git a/src/core/transport/http/util/http_transport_utils.c b/src/core/transport/http/util/http_transport_utils.c new file mode 100644 index 0000000..97d1510 --- /dev/null +++ b/src/core/transport/http/util/http_transport_utils.c @@ -0,0 +1,3885 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <axis2_http_transport_utils.h> +#include <string.h> +#include <ctype.h> +#include <axis2_conf.h> +#include <axis2_op.h> +#include <axutil_qname.h> +#include <axis2_http_transport.h> +#include <axiom_soap_builder.h> +#include <axis2_engine.h> +#include <axiom_soap_body.h> +#include <axutil_utils.h> +#include <axiom_namespace.h> +#include <axiom_node.h> +#include <axutil_hash.h> +#include <axiom_soap_const.h> +#include <axis2_http_header.h> +#include <axutil_property.h> +#include <axutil_utils.h> +#include <axiom_mime_parser.h> +#include <axis2_http_accept_record.h> +#include <axis2_disp.h> +#include <axis2_msg.h> +#include <axutil_string_util.h> +#include <stdlib.h> +#include <axutil_uuid_gen.h> +#include <platforms/axutil_platform_auto_sense.h> +#include <axiom_mime_part.h> +#include <axutil_class_loader.h> + +#define AXIOM_MIME_BOUNDARY_BYTE 45 + +/** Size of the buffer to be used when reading a file */ +#ifndef AXIS2_FILE_READ_SIZE +#define AXIS2_FILE_READ_SIZE 2048 +#endif + +/** Content length value to be used in case of chunked content */ +#ifndef AXIS2_CHUNKED_CONTENT_LENGTH +#define AXIS2_CHUNKED_CONTENT_LENGTH 100000000 +#endif + +const axis2_char_t *AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING = + AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING; + +/***************************** Function headers *******************************/ + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_process_http_post_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_process_http_put_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_get_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_head_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_delete_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + +AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL +axis2_http_transport_utils_select_builder_for_mime( + const axutil_env_t * env, + axis2_char_t * request_uri, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axis2_char_t * content_type); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_is_optimized( + const axutil_env_t * env, + axiom_element_t * om_element); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_do_write_mtom( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_strdecode( + const axutil_env_t * env, + axis2_char_t * dest, + axis2_char_t * src); + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_transport_utils_hexit( + axis2_char_t c); + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_services_html( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_services_static_wsdl( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_char_t * request_url); + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_http_transport_utils_get_charset_enc( + const axutil_env_t * env, + const axis2_char_t * content_type); + +int AXIS2_CALL +axis2_http_transport_utils_on_data_request( + char *buffer, + int size, + void *ctx); + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_create_soap_msg( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + const axis2_char_t * soap_ns_uri); + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_dispatch_and_verify( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_handle_media_type_url_encoded( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_hash_t * param_map, + axis2_char_t * method); + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_session_map_free_void_arg( + void *sm_void, + const axutil_env_t *env); + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_file( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size); + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_callback( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param); + +static axis2_char_t * +axis2_http_transport_utils_copy_key( + const axutil_env_t *env, + axis2_char_t *); + +static axis2_char_t * +axis2_http_transport_utils_copy_value( + const axutil_env_t *env, + axis2_char_t *pair); + +static void +axis2_http_transport_utils_parse_session_str( + const axutil_env_t *env, + axis2_char_t *str, + axutil_hash_t *ht); +/***************************** End of function headers ************************/ + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_out_init( + axis2_http_transport_out_t *response, + const axutil_env_t *env) +{ + response->http_status_code_name = NULL; + response->http_status_code = 0; + response->msg_ctx = NULL; + response->response_data = NULL; + response->content_type = NULL; + response->response_data_length = 0; + response->content_language = NULL; + response->output_headers = NULL; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_out_uninit( + axis2_http_transport_out_t *response, + const axutil_env_t *env) +{ + if(response->msg_ctx) + { + axis2_msg_ctx_free(response->msg_ctx, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_in_init( + axis2_http_transport_in_t *request, + const axutil_env_t *env) +{ + request->content_type = NULL; + request->content_length = 0; + request->msg_ctx = NULL; + request->soap_action = NULL; + request->request_uri = NULL; + request->in_stream = NULL; + request->remote_ip = NULL; + request->svr_port = NULL; + request->transfer_encoding = NULL; + request->accept_header = NULL; + request->accept_language_header = NULL; + request->accept_charset_header = NULL; + request->request_method = 0; + request->out_transport_info = NULL; + request->request_url_prefix = NULL; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_in_uninit( + axis2_http_transport_in_t *request, + const axutil_env_t *env) +{ + if(request->msg_ctx) + { + axis2_msg_ctx_reset_out_transport_info(request->msg_ctx, env); + axis2_msg_ctx_free(request->msg_ctx, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_process_http_post_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_stax_builder_t *om_builder = NULL; + axis2_bool_t is_soap11 = AXIS2_FALSE; + axiom_xml_reader_t *xml_reader = NULL; + axutil_string_t *char_set_str = NULL; + + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_callback_info_t *callback_ctx = NULL; + axis2_callback_info_t *mime_cb_ctx = NULL; + axutil_hash_t *headers = NULL; + axis2_engine_t *engine = NULL; + axiom_soap_body_t *soap_body = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *binary_data_map = NULL; + axis2_char_t *soap_body_str = NULL; + axutil_stream_t *stream = NULL; + axis2_bool_t do_rest = AXIS2_FALSE; + axis2_bool_t run_as_get = AXIS2_FALSE; + axis2_char_t *soap_action = NULL; + unsigned int soap_action_len = 0; + axutil_property_t *http_error_property = NULL; + axiom_mime_parser_t *mime_parser = NULL; + axis2_bool_t is_svc_callback = AXIS2_FALSE; + axutil_property_t *is_client_property = NULL; + axis2_bool_t is_application_client_side = AXIS2_FALSE; + axis2_char_t *mime_boundary = NULL; + axis2_bool_t check_for_fault = AXIS2_FALSE; + axis2_bool_t has_fault = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = content_length; + callback_ctx->unread_len = content_length; + callback_ctx->chunked_stream = NULL; + + soap_action = (axis2_char_t *)axutil_string_get_buffer(soap_action_header, env); + soap_action_len = axutil_string_get_length(soap_action_header, env); + + if(soap_action && (soap_action_len > 0)) + { + /* remove leading and trailing " s */ + if(AXIS2_DOUBLE_QUOTE == soap_action[0]) + { + memmove(soap_action, soap_action + sizeof(char), soap_action_len - 1 + sizeof(char)); + } + if(AXIS2_DOUBLE_QUOTE == soap_action[soap_action_len - 2]) + { + soap_action[soap_action_len - 2] = AXIS2_ESC_NULL; + } + } + else + { + /** soap action is null, check whether soap action is in content_type header */ + soap_action = axis2_http_transport_utils_get_value_from_content_type(env, content_type, + AXIS2_ACTION); + } + + headers = axis2_msg_ctx_get_transport_headers(msg_ctx, env); + if(headers) + { + axis2_http_header_t *encoding_header = NULL; + encoding_header = (axis2_http_header_t *)axutil_hash_get(headers, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, AXIS2_HASH_KEY_STRING); + + if(encoding_header) + { + axis2_char_t *encoding_value = NULL; + encoding_value = axis2_http_header_get_value(encoding_header, env); + if(encoding_value && 0 == axutil_strcasecmp(encoding_value, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + + if(!callback_ctx->chunked_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occurred in" + " creating in chunked stream."); + return AXIS2_FAILURE; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "HTTP" + " stream chunked"); + } + } + } + else + { + /* Encoding header is not available */ + /* check content encoding from msg ctx property */ + axis2_char_t *value = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(value && axutil_strstr(value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + /* In case Transfer encoding is set to message context, some streams strip chunking meta + data, so chunked streams should not be created */ + + callback_ctx->content_length = -1; + callback_ctx->unread_len = -1; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[chunked ] setting length to -1"); + } + } + + /* when the message contains does not contain pure XML we can't send it + * directly to the parser, First we need to separate the SOAP part from + * the attachment */ + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + /* get mime boundary */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, + content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + /*axiom_mime_parser_t *mime_parser = NULL;*/ + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axutil_param_t *enable_service_callback_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + axis2_char_t *value_enable_service_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + /* This is the size of the buffer we keep inside mime_parser + * when parsing. */ + + enable_service_callback_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_ENABLE_MTOM_SERVICE_CALLBACK); + if(enable_service_callback_param) + { + value_enable_service_callback = (axis2_char_t *)axutil_param_get_value( + enable_service_callback_param, env); + if(value_enable_service_callback) + { + if(!axutil_strcmp(value_enable_service_callback, AXIS2_VALUE_TRUE)) + { + is_svc_callback = AXIS2_TRUE; + } + } + } + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + /* We create an array of buffers in order to conatin SOAP data inside + * mime_parser. This is the number of sucj buffers */ + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + /* If this paramter is there mime_parser will cached the attachment + * using to the directory for large attachments. */ + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + axiom_mime_parser_set_mime_boundary(mime_parser, env, mime_boundary); + + if(axiom_mime_parser_parse_for_soap(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, mime_boundary) + == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + + if(!is_svc_callback) + { + binary_data_map = axiom_mime_parser_parse_for_attachments(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, + mime_boundary, NULL); + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + } + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + + if(!is_svc_callback) + { + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + } + else + { + mime_cb_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + if(mime_cb_ctx) + { + mime_cb_ctx->in_stream = callback_ctx->in_stream; + mime_cb_ctx->env = callback_ctx->env; + mime_cb_ctx->content_length = callback_ctx->content_length; + mime_cb_ctx->unread_len = callback_ctx->unread_len; + mime_cb_ctx->chunked_stream = callback_ctx->chunked_stream; + } + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + /*axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL;*/ + + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + + if(soap_action_header) + { + axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action_header); + + } + else if(soap_action) + { + axutil_string_t *soap_action_str = NULL; + soap_action_str = axutil_string_create(env, soap_action); + axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action_str); + axutil_string_free(soap_action_str, env); + } + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + char_set_str = axis2_http_transport_utils_get_charset_enc(env, content_type); + xml_reader = axiom_xml_reader_create_for_io(env, axis2_http_transport_utils_on_data_request, + NULL, (void *)callback_ctx, axutil_string_get_buffer(char_set_str, env)); + + if(!xml_reader) + { + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_charset_encoding(msg_ctx, env, char_set_str); + + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return AXIS2_FAILURE; + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + is_soap11 = AXIS2_FALSE; + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_stax_builder_free(om_builder, env); + om_builder = NULL; + xml_reader = NULL; + axiom_soap_builder_free(soap_builder, env); + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + is_soap11 = AXIS2_TRUE; + if(soap_action_header) + { + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_soap_builder_free(soap_builder, env); + om_builder = NULL; + xml_reader = NULL; + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else + { + /* REST support */ + do_rest = AXIS2_TRUE; + } + } + + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_X_WWW_FORM_URLENCODED)) + { + /* REST support */ + do_rest = AXIS2_TRUE; + run_as_get = AXIS2_TRUE; + } + else + { + http_error_property = axutil_property_create(env); + axutil_property_set_value(http_error_property, env, AXIS2_HTTP_UNSUPPORTED_MEDIA_TYPE); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_TRANSPORT_ERROR, http_error_property); + } + + if(soap_builder) + { + if(mime_parser) + { + axiom_soap_builder_set_mime_parser(soap_builder, env, mime_parser); + if(mime_cb_ctx) + { + axiom_soap_builder_set_callback_ctx(soap_builder, env, mime_cb_ctx); + axiom_soap_builder_set_callback_function(soap_builder, env, + axis2_http_transport_utils_on_data_request); + } + else if(is_svc_callback) + { + return AXIS2_FAILURE; + } + } + } + + if(do_rest) + { + /* REST support */ + axutil_param_t *rest_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_param && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, axutil_param_get_value(rest_param, + env))) + { + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + if(!run_as_get) + { + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + } + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_POST); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + } + else + { + return AXIS2_FAILURE; + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FAILURE; + } + } + + if(run_as_get) + { + axis2_char_t *buffer = NULL; + axis2_char_t *new_url = NULL; + buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (content_length + 1)); + if(!buffer) + { + return AXIS2_FAILURE; + } + axis2_http_transport_utils_on_data_request(buffer, content_length, (void *)callback_ctx); + + new_url = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * ((int)(strlen(request_uri) + + strlen(buffer)) + 2)); + if(!new_url) + { + return AXIS2_FAILURE; + } + sprintf(new_url, "%s?%s", request_uri, buffer); + AXIS2_FREE(env->allocator, buffer); + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + axis2_http_transport_utils_get_request_params(env, new_url), AXIS2_HTTP_POST); + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + + if(!soap_envelope) + return AXIS2_FAILURE; + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + return AXIS2_FAILURE; + + if(!is_svc_callback) + { + is_client_property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE); + if(is_client_property) + { + axis2_char_t *prop_value = NULL; + prop_value = axutil_property_get_value(is_client_property, env); + if(prop_value && !axutil_strcmp(prop_value , AXIS2_VALUE_TRUE)) + { + is_application_client_side = AXIS2_TRUE; + } + } + if(mime_boundary || is_application_client_side) + { + check_for_fault = AXIS2_TRUE; + } + if(check_for_fault) + { + has_fault = axiom_soap_body_has_fault(soap_body, env); + } + if(has_fault) + { + status = axis2_engine_receive_fault(engine, env, msg_ctx); + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + + if(!axis2_msg_ctx_get_soap_envelope(msg_ctx, env) && AXIS2_FALSE == is_soap11) + { + axiom_soap_envelope_t *def_envelope = axiom_soap_envelope_create_default_soap_envelope(env, + AXIOM_SOAP12); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, def_envelope); + } + + if(engine) + { + axis2_engine_free(engine, env); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + + if(stream) + { + axutil_stream_free(stream, env); + } + + if(char_set_str) + { + axutil_string_free(char_set_str, env); + } + if(!soap_builder && om_builder) + { + axiom_stax_builder_free_self(om_builder, env); + om_builder = NULL; + } + if(!axutil_string_get_buffer(soap_action_header, env) && soap_action) + { + AXIS2_FREE(env->allocator, soap_action); + soap_action = NULL; + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_process_http_put_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_stax_builder_t *om_builder = NULL; + axis2_bool_t is_soap11 = AXIS2_FALSE; + axiom_xml_reader_t *xml_reader = NULL; + axutil_string_t *char_set_str = NULL; + + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_callback_info_t *callback_ctx; + axutil_hash_t *headers = NULL; + axis2_engine_t *engine = NULL; + axiom_soap_body_t *soap_body = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *binary_data_map = NULL; + axis2_char_t *soap_body_str = NULL; + axutil_stream_t *stream = NULL; + axis2_bool_t do_rest = AXIS2_FALSE; + axis2_bool_t run_as_get = AXIS2_FALSE; + axutil_property_t *http_error_property = NULL; + axutil_property_t *is_client_property = NULL; + axis2_bool_t is_application_client_side = AXIS2_FALSE; + axis2_char_t *mime_boundary = NULL; + axis2_bool_t check_for_fault = AXIS2_FALSE; + axis2_bool_t has_fault = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = content_length; + callback_ctx->unread_len = content_length; + callback_ctx->chunked_stream = NULL; + + headers = axis2_msg_ctx_get_transport_headers(msg_ctx, env); + if(headers) + { + axis2_http_header_t *encoding_header = NULL; + encoding_header = (axis2_http_header_t *)axutil_hash_get(headers, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, AXIS2_HASH_KEY_STRING); + + if(encoding_header) + { + axis2_char_t *encoding_value = NULL; + encoding_value = axis2_http_header_get_value(encoding_header, env); + if(encoding_value && 0 == axutil_strcasecmp(encoding_value, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + if(!callback_ctx->chunked_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in" + " creating in chunked stream."); + return AXIS2_FAILURE; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "HTTP" + " stream chunked"); + } + } + } + else + { + /* check content encoding from msg ctx property */ + axis2_char_t *value = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(value && axutil_strstr(value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + /* this is an UGLY hack to get some of the transports working + e.g. PHP transport where it strips the chunking info in case of chunking + and also gives out a content lenght of 0. + We need to fix the transport design to fix sutuations like this. + */ + callback_ctx->content_length = AXIS2_CHUNKED_CONTENT_LENGTH; + callback_ctx->unread_len = callback_ctx->content_length; + } + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + /* get mime boundry */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, + content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + /*binary_data_map = + axiom_mime_parser_parse(mime_parser, env, + axis2_http_transport_utils_on_data_request, + (void *) callback_ctx, + mime_boundary);*/ + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL; + } + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + char_set_str = axis2_http_transport_utils_get_charset_enc(env, content_type); + xml_reader = axiom_xml_reader_create_for_io(env, axis2_http_transport_utils_on_data_request, + NULL, (void *)callback_ctx, axutil_string_get_buffer(char_set_str, env)); + + if(!xml_reader) + { + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_charset_encoding(msg_ctx, env, char_set_str); + + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return AXIS2_FAILURE; + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + is_soap11 = AXIS2_FALSE; + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_stax_builder_free(om_builder, env); + om_builder = NULL; + xml_reader = NULL; + axiom_soap_builder_free(soap_builder, env); + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + do_rest = AXIS2_TRUE; + if(soap_action_header) + { + return AXIS2_FAILURE; + } + else + { + /* REST support */ + do_rest = AXIS2_TRUE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_X_WWW_FORM_URLENCODED)) + { + /* REST support */ + do_rest = AXIS2_TRUE; + run_as_get = AXIS2_TRUE; + } + else + { + http_error_property = axutil_property_create(env); + axutil_property_set_value(http_error_property, env, AXIS2_HTTP_UNSUPPORTED_MEDIA_TYPE); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_TRANSPORT_ERROR, http_error_property); + } + + if(do_rest) + { + /* REST support */ + axutil_param_t *rest_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_param && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, axutil_param_get_value(rest_param, + env))) + { + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + if(!run_as_get) + { + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + } + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_PUT); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + } + else + { + return AXIS2_FAILURE; + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FAILURE; + } + } + + if(run_as_get) + { + axis2_char_t *buffer = NULL; + axis2_char_t *new_url = NULL; + buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (content_length + 1)); + if(!buffer) + { + return AXIS2_FAILURE; + } + axis2_http_transport_utils_on_data_request(buffer, content_length, (void *)callback_ctx); + + new_url = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * ((int)(strlen(request_uri) + + strlen(buffer)) + 2)); + if(!new_url) + { + return AXIS2_FAILURE; + } + sprintf(new_url, "%s?%s", request_uri, buffer); + AXIS2_FREE(env->allocator, buffer); + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + axis2_http_transport_utils_get_request_params(env, new_url), AXIS2_HTTP_POST); + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + + if(!soap_envelope) + return AXIS2_FAILURE; + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + return AXIS2_FAILURE; + + is_client_property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE); + if(is_client_property) + { + axis2_char_t *prop_value = NULL; + prop_value = axutil_property_get_value(is_client_property, env); + if(prop_value && !axutil_strcmp(prop_value , AXIS2_VALUE_TRUE)) + { + is_application_client_side = AXIS2_TRUE; + } + } + if(mime_boundary || is_application_client_side) + { + check_for_fault = AXIS2_TRUE; + } + if(check_for_fault) + { + has_fault = axiom_soap_body_has_fault(soap_body, env); + } + if(has_fault) + { + status = axis2_engine_receive_fault(engine, env, msg_ctx); + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + if(mime_boundary) + { + AXIS2_FREE(env->allocator, mime_boundary); + } + if(!axis2_msg_ctx_get_soap_envelope(msg_ctx, env) && AXIS2_FALSE == is_soap11) + { + axiom_soap_envelope_t *def_envelope = axiom_soap_envelope_create_default_soap_envelope(env, + AXIOM_SOAP12); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, def_envelope); + } + + if(engine) + { + axis2_engine_free(engine, env); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + + if(stream) + { + axutil_stream_free(stream, env); + } + + if(char_set_str) + { + axutil_string_free(char_set_str, env); + } + if(!soap_builder && om_builder) + { + axiom_stax_builder_free_self(om_builder, env); + om_builder = NULL; + } + return status; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_head_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_HEAD); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_HEAD); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_get_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(content_type && strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(content_type && strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_GET); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_GET); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_process_http_delete_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_DELETE); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_DELETE); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_do_write_mtom( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + return (axis2_msg_ctx_get_doing_mtom(msg_ctx, env)); +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_http_transport_utils_get_request_params( + const axutil_env_t * env, + axis2_char_t * request_uri) +{ + + axis2_char_t *query_str = NULL; + axis2_char_t *tmp = strchr(request_uri, AXIS2_Q_MARK); + axis2_char_t *tmp2 = NULL; + axis2_char_t *tmp_name = NULL; + axis2_char_t *tmp_value = NULL; + axutil_hash_t *ret = NULL; + + AXIS2_PARAM_CHECK(env->error, request_uri, NULL); + + if(!tmp || AXIS2_ESC_NULL == *(tmp + 1)) + { + return NULL; + } + query_str = axutil_strdup(env, tmp + 1); + + for(tmp2 = tmp = query_str; *tmp != AXIS2_ESC_NULL; ++tmp) + { + if(AXIS2_EQ == *tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp_name = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_name, tmp_name); + tmp2 = tmp + 1; + } + if(AXIS2_AND == *tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp_value = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); + tmp2 = tmp + 1; + } + if(tmp_name && NULL != tmp_value) + { + if(!ret) + { + ret = axutil_hash_make(env); + } + axutil_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); + tmp_name = NULL; + tmp_value = NULL; + } + } + if(tmp_name && AXIS2_ESC_NULL != *tmp2) + { + if(!ret) + { + ret = axutil_hash_make(env); + } + tmp_value = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); + axutil_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); + } + + return ret; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_strdecode( + const axutil_env_t * env, + axis2_char_t * dest, + axis2_char_t * src) +{ + AXIS2_PARAM_CHECK(env->error, dest, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, src, AXIS2_FAILURE); + + for(; *src != AXIS2_ESC_NULL; ++dest, ++src) + { + if(src[0] == AXIS2_PERCENT && isxdigit((int)src[1]) && isxdigit((int)src[2])) + { + *dest = (axis2_char_t)(axis2_http_transport_utils_hexit(src[1]) * 16 + + axis2_http_transport_utils_hexit(src[2])); + /* We are sure that the conversion is valid */ + src += 2; + } + else + { + *dest = *src; + } + } + *dest = AXIS2_ESC_NULL; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_transport_utils_hexit( + axis2_char_t c) +{ + if(c >= '0' && c <= '9') + { + return c - '0'; + } + if(c >= 'a' && c <= 'f') + { + return c - 'a' + 10; + } + if(c >= 'A' && c <= 'F') + { + return c - 'A' + 10; + } + return 0; /* shouldn't happen, we're guarded by isxdigit() */ +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_not_found( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_NOT_FOUND; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_not_implemented( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_NOT_IMPLEMENTED; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_internal_server_error( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_INTERNAL_SERVER_ERROR; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_method_not_allowed( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_METHOD_NOT_ALLOWED; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_not_acceptable( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_NOT_ACCEPTABLE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_bad_request( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_BAD_REQUEST; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_request_timeout( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_REQUEST_TIMEOUT; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_conflict( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_CONFLICT; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_gone( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_GONE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_precondition_failed( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_PRECONDITION_FAILED; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_request_entity_too_large( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_TOO_LARGE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_service_unavailable( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_SERVICE_UNAVILABLE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_services_html( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axutil_hash_t *services_map = NULL; + axutil_hash_t *errorneous_svc_map = NULL; + axis2_char_t *ret = NULL; + axis2_char_t *tmp2 = (axis2_char_t *)"<h2>Deployed Services</h2>"; + axutil_hash_index_t *hi = NULL; + axis2_bool_t svcs_exists = AXIS2_FALSE; + axis2_conf_t *conf = NULL; + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + services_map = axis2_conf_get_all_svcs(conf, env); + errorneous_svc_map = axis2_conf_get_all_faulty_svcs(conf, env); + if(services_map && 0 != axutil_hash_count(services_map)) + { + void *service = NULL; + axis2_char_t *sname = NULL; + axutil_hash_t *ops = NULL; + svcs_exists = AXIS2_TRUE; + + for(hi = axutil_hash_first(services_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &service); + sname = axutil_qname_get_localpart(axis2_svc_get_qname(((axis2_svc_t *)service), env), + env); + ret = axutil_stracat(env, tmp2, "<h3><u>"); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, sname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "</u></h3>"); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "<p>"); + tmp2 = ret; + + /** + *setting services description */ + ret = axutil_stracat(env, tmp2, axis2_svc_get_svc_desc((axis2_svc_t *)service, env)); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "</p>"); + tmp2 = ret; + ops = axis2_svc_get_all_ops(((axis2_svc_t *)service), env); + if(ops && 0 != axutil_hash_count(ops)) + { + axutil_hash_index_t *hi2 = NULL; + void *op = NULL; + axis2_char_t *oname = NULL; + + ret = axutil_stracat(env, tmp2, "<i>Available Operations</i> <ul>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + for(hi2 = axutil_hash_first(ops, env); hi2; hi2 = axutil_hash_next(env, hi2)) + { + axutil_hash_this(hi2, NULL, NULL, &op); + oname = axutil_qname_get_localpart(axis2_op_get_qname(((axis2_op_t *)op), env), + env); + ret = axutil_stracat(env, tmp2, "<li>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + + ret = axutil_stracat(env, tmp2, oname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "</li>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + ret = axutil_stracat(env, tmp2, "</ul>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + else + { + ret = axutil_stracat(env, tmp2, "No operations Available"); + tmp2 = ret; + } + } + } + + if(errorneous_svc_map && 0 != axutil_hash_count(errorneous_svc_map)) + { + void *fsname = NULL; + svcs_exists = AXIS2_TRUE; + ret = axutil_stracat(env, tmp2, + "<hr><h2><font color=\"red\">Faulty \ + Services</font></h2>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + + for(hi = axutil_hash_first(errorneous_svc_map, env); hi; axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, (const void **)&fsname, NULL, NULL); + ret = axutil_stracat(env, tmp2, "<h3><font color=\"red\">"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, (axis2_char_t *)fsname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "</font></h3>"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + } + if(AXIS2_FALSE == svcs_exists) + { + ret = axutil_strdup(env, "<h2>There are no services deployed</h2>"); + } + ret = axutil_stracat(env, "<html><head><title>Axis2C :: Services</title></head>" + "<body><font face=\"courier\">", tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "</font></body></html>\r\n"); + + return ret; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_services_static_wsdl( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_char_t * request_url) +{ + axis2_char_t *wsdl_string = NULL; + axis2_char_t *wsdl_path = NULL; + axis2_char_t **url_tok = NULL; + unsigned int len = 0; + axis2_char_t *svc_name = NULL; + axis2_conf_t *conf = NULL; + axutil_hash_t *services_map = NULL; + axutil_hash_index_t *hi = NULL; + + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, request_url, NULL); + + url_tok = axutil_parse_request_url_for_svc_and_op(env, request_url); + if(url_tok[0]) + { + len = (int)strlen(url_tok[0]); + /* We are sure that the difference lies within the int range */ + url_tok[0][len - 5] = 0; + svc_name = url_tok[0]; + } + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + services_map = axis2_conf_get_all_svcs(conf, env); + + if(services_map && 0 != axutil_hash_count(services_map)) + { + void *service = NULL; + axis2_char_t *sname = NULL; + + for(hi = axutil_hash_first(services_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &service); + sname = axutil_qname_get_localpart(axis2_svc_get_qname(((axis2_svc_t *)service), env), + env); + if(!axutil_strcmp(svc_name, sname)) + { + wsdl_path = (axis2_char_t *)axutil_strdup(env, axis2_svc_get_svc_wsdl_path( + (axis2_svc_t *)service, env)); + if(!wsdl_path) + { + wsdl_path = axutil_strcat(env, axis2_svc_get_svc_folder_path( + (axis2_svc_t *)service, env), AXIS2_PATH_SEP_STR, svc_name, ".wsdl", NULL); + } + break; + } + + } + } + + if(wsdl_path) + { + FILE *wsdl_file = NULL; + axis2_char_t *content = NULL; + int c; + int size = AXIS2_FILE_READ_SIZE; + axis2_char_t *tmp; + int i = 0; + + content = (axis2_char_t *)AXIS2_MALLOC(env->allocator, size); + wsdl_file = fopen(wsdl_path, "r"); + if(wsdl_file) + { + c = fgetc(wsdl_file); + while(c != EOF) + { + if(i >= size) + { + size = size * 3; + tmp = (axis2_char_t *)AXIS2_MALLOC(env->allocator, size); + memcpy(tmp, content, i); + AXIS2_FREE(env->allocator, content); + content = tmp; + } + content[i++] = (axis2_char_t)c; + c = fgetc(wsdl_file); + } + content[i] = AXIS2_ESC_NULL; + wsdl_string = (axis2_char_t *)content; + fclose(wsdl_file); + } + + AXIS2_FREE(env->allocator, wsdl_path); + } + else + { + wsdl_string = axutil_strdup(env, "Unable to retrieve wsdl for this service"); + } + + return wsdl_string; +} + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_http_transport_utils_get_charset_enc( + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_char_t *tmp = NULL; + axis2_char_t *tmp_content_type = NULL; + axis2_char_t *tmp2 = NULL; + axutil_string_t *str = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, NULL); + + tmp_content_type = (axis2_char_t *)content_type; + if(!tmp_content_type) + { + return axutil_string_create_const(env, + (axis2_char_t **)&AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING); + } + + tmp = strstr(tmp_content_type, AXIS2_HTTP_CHAR_SET_ENCODING); + + if(tmp) + { + tmp = strchr(tmp, AXIS2_EQ); + if(tmp) + { + tmp2 = strchr(tmp, AXIS2_SEMI_COLON); + if(!tmp2) + { + tmp2 = tmp + strlen(tmp); + } + } + + if(tmp2) + { + if('\'' == *(tmp2 - sizeof(axis2_char_t)) || '\"' == *(tmp2 - sizeof(axis2_char_t))) + { + tmp2 -= sizeof(axis2_char_t); + } + *tmp2 = AXIS2_ESC_NULL; + } + } + + if(tmp) + { + /* Following formats are acceptable + * charset="UTF-8" + * charser='UTF-8' + * charset=UTF-8 + * But for our requirements charset we get should be UTF-8 + */ + if(AXIS2_ESC_SINGLE_QUOTE == *(tmp + sizeof(axis2_char_t)) || AXIS2_ESC_DOUBLE_QUOTE + == *(tmp + sizeof(axis2_char_t))) + { + tmp += 2 * sizeof(axis2_char_t); + } + else + { + tmp += sizeof(axis2_char_t); + } + } + + if(tmp) + { + str = axutil_string_create(env, tmp); + } + else + { + str = axutil_string_create_const(env, + (axis2_char_t **)&AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING); + } + return str; +} + +int AXIS2_CALL +axis2_http_transport_utils_on_data_request( + char *buffer, + int size, + void *ctx) +{ + const axutil_env_t *env = NULL; + int len = -1; + axis2_callback_info_t *cb_ctx = (axis2_callback_info_t *)ctx; + + if(!buffer || !ctx) + { + return 0; + } + env = ((axis2_callback_info_t *)ctx)->env; + if(cb_ctx->unread_len <= 0 && -1 != cb_ctx->content_length) + { + return 0; + } + if(cb_ctx->chunked_stream) + { + --size; + /* reserve space to insert trailing null */ + len = axutil_http_chunked_stream_read(cb_ctx->chunked_stream, env, buffer, size); + if(len >= 0) + { + buffer[len] = AXIS2_ESC_NULL; + } + } + else + { + axutil_stream_t *in_stream = NULL; + in_stream = (axutil_stream_t *)((axis2_callback_info_t *)ctx)->in_stream; + --size; /* reserve space to insert trailing null */ + len = axutil_stream_read(in_stream, env, buffer, size); + if(len > 0) + { + buffer[len] = AXIS2_ESC_NULL; + ((axis2_callback_info_t *)ctx)->unread_len -= len; + } + else if(len == 0) + { + ((axis2_callback_info_t *)ctx)->unread_len = 0; + } + } + return len; +} + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_create_soap_msg( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + const axis2_char_t * soap_ns_uri) +{ + axis2_op_ctx_t *op_ctx = NULL; + const axis2_char_t *char_set_enc = NULL; + axis2_char_t *content_type = NULL; + axutil_stream_t *in_stream = NULL; + axis2_callback_info_t *callback_ctx = NULL; + axis2_char_t *trans_enc = NULL; + int *content_length = NULL; + axutil_property_t *property = NULL; + axutil_hash_t *binary_data_map = NULL; + axiom_soap_envelope_t *soap_envelope = NULL; + axutil_stream_t *stream = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, soap_ns_uri, NULL); + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_TRANSPORT_IN); + if(property) + { + in_stream = axutil_property_get_value(property, env); + property = NULL; + } + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + if(!callback_ctx) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = -1; + callback_ctx->unread_len = -1; + callback_ctx->chunked_stream = NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_HEADER_CONTENT_LENGTH); + if(property) + { + content_length = axutil_property_get_value(property, env); + property = NULL; + } + + if(content_length) + { + callback_ctx->content_length = *content_length; + callback_ctx->unread_len = *content_length; + } + + if(!in_stream) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_IN_STREAM_IN_MSG_CTX, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, callback_ctx); + return NULL; + } + + trans_enc = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(trans_enc && 0 == axutil_strcmp(trans_enc, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + if(!callback_ctx->chunked_stream) + { + return NULL; + } + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_ctx_t *ctx = axis2_op_ctx_get_base(op_ctx, env); + if(ctx) + { + property = axis2_ctx_get_property(ctx, env, AXIS2_CHARACTER_SET_ENCODING); + if(property) + { + char_set_enc = axutil_property_get_value(property, env); + property = NULL; + } + property = axis2_ctx_get_property(ctx, env, MTOM_RECIVED_CONTENT_TYPE); + if(property) + { + content_type = axutil_property_get_value(property, env); + property = NULL; + } + + } + } + + if(!char_set_enc) + { + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + if(content_type) + { + axis2_char_t *mime_boundary = NULL; + axis2_msg_ctx_set_doing_mtom(msg_ctx, env, AXIS2_TRUE); + /* get mime boundry */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, content_type, + AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axis2_char_t *soap_body_str = NULL; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + /* Following are the parameters in the axis2.xml regarding MTOM */ + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + if(axiom_mime_parser_parse_for_soap(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, mime_boundary) + == AXIS2_FAILURE) + { + return NULL; + } + + binary_data_map = axiom_mime_parser_parse_for_attachments(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, + mime_boundary, NULL); + if(!binary_data_map) + { + return NULL; + } + + if(!binary_data_map) + { + return NULL; + } + + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + } + + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + + axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL; + if(mime_boundary) + { + AXIS2_FREE(env->allocator, mime_boundary); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + } + } + + if(AXIS2_TRUE != axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + axiom_xml_reader_t *xml_reader = NULL; + axiom_stax_builder_t *om_builder = NULL; + axiom_soap_builder_t *soap_builder = NULL; + + xml_reader = axiom_xml_reader_create_for_io(env, + axis2_http_transport_utils_on_data_request, NULL, (void *)callback_ctx, char_set_enc); + if(!xml_reader) + { + return NULL; + } + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return NULL; + } + soap_builder = axiom_soap_builder_create(env, om_builder, soap_ns_uri); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + return NULL; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + if(soap_envelope) + { + /* hack to get around MTOM problem */ + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(soap_body) + { + axiom_soap_body_has_fault(soap_body, env); + } + } + if(stream) + { + axutil_stream_free(stream, env); + callback_ctx->in_stream = NULL; + } + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + + } + else + { + /* REST processing */ + axiom_xml_reader_t *xml_reader = NULL; + axiom_stax_builder_t *om_builder = NULL; + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + + xml_reader = axiom_xml_reader_create_for_io(env, + axis2_http_transport_utils_on_data_request, NULL, (void *)callback_ctx, char_set_enc); + if(!xml_reader) + { + return NULL; + } + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return NULL; + } + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + axiom_stax_builder_free_self(om_builder, env); + } + + return soap_envelope; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key) +{ + axis2_char_t *tmp = NULL; + axis2_char_t *tmp_content_type = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, NULL); + AXIS2_PARAM_CHECK(env->error, key, NULL); + + tmp_content_type = axutil_strdup(env, content_type); + if(!tmp_content_type) + { + return NULL; + } + tmp = strstr(tmp_content_type, key); + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp = strchr(tmp, AXIS2_EQ); + tmp2 = strchr(tmp, AXIS2_SEMI_COLON); + + if(tmp2) + { + *tmp2 = AXIS2_ESC_NULL; + } + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp2 = axutil_strdup(env, tmp + 1); + + AXIS2_FREE(env->allocator, tmp_content_type); + if(*tmp2 == AXIS2_DOUBLE_QUOTE) + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 1); + tmp2[strlen(tmp2) - 1] = AXIS2_ESC_NULL; + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + + } + /* handle XOP */ + if(*tmp2 == AXIS2_B_SLASH && *(tmp2 + 1) == '\"') + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 2); + tmp2[strlen(tmp2) - 3] = AXIS2_ESC_NULL; + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + } + return tmp2; +} + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_handle_media_type_url_encoded( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_hash_t * param_map, + axis2_char_t * method) +{ + axiom_soap_envelope_t *soap_env = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_element_t *body_child = NULL; + axiom_node_t *body_child_node = NULL; + axiom_node_t *body_element_node = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, method, NULL); + + soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(!soap_env) + { + soap_env = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + } + soap_body = axiom_soap_envelope_get_body(soap_env, env); + if(!soap_body) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); + return NULL; + } + + body_element_node = axiom_soap_body_get_base_node(soap_body, env); + + if(body_element_node) + { + body_child_node = axiom_node_get_first_child(body_element_node, env); + } + + if(!body_child_node) + { + if(!axis2_msg_ctx_get_op(msg_ctx, env)) + { + return NULL; + } + body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname( + axis2_msg_ctx_get_op(msg_ctx, env), env), &body_child_node); + axiom_soap_body_add_child(soap_body, env, body_child_node); + } + if(param_map) + { + axutil_hash_index_t *hi = NULL; + for(hi = axutil_hash_first(param_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *name = NULL; + void *value = NULL; + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + + axutil_hash_this(hi, (const void **)&name, NULL, (void **)&value); + element = axiom_element_create(env, NULL, (axis2_char_t *)name, NULL, &node); + axiom_element_set_text(element, env, (axis2_char_t *)value, node); + axiom_node_add_child(body_child_node, env, node); + } + } + return soap_env; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_dispatch_and_verify( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_disp_t *rest_disp = NULL; + axis2_handler_t *handler = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + rest_disp = axis2_rest_disp_create(env); + handler = axis2_disp_get_base(rest_disp, env); + axis2_handler_invoke(handler, env, msg_ctx); + + if(!axis2_msg_ctx_get_svc(msg_ctx, env) || !axis2_msg_ctx_get_op(msg_ctx, env)) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SVC_OR_OP_NOT_FOUND, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_http_transport_utils_process_accept_headers( + const axutil_env_t *env, + axis2_char_t *accept_value) +{ + axutil_array_list_t *accept_field_list = NULL; + axutil_array_list_t *accept_record_list = NULL; + accept_field_list = axutil_tokenize(env, accept_value, ','); + if(accept_field_list && axutil_array_list_size(accept_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_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_field_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_field_list, env, 0); + } + while(token); + } + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + return accept_record_list; + } + return NULL; +} + +int +axis2_http_transport_utils_check_status_code( + int status_code) +{ + int status = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + switch(status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_GONE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL; + break; + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_process_request( + const axutil_env_t *env, + axis2_conf_ctx_t *conf_ctx, + axis2_http_transport_in_t *request, + axis2_http_transport_out_t *response) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_msg_ctx_t *msg_ctx = NULL; + axutil_stream_t *out_stream = NULL; + axutil_string_t *soap_action = NULL; + axis2_bool_t processed = AXIS2_FALSE; + axis2_char_t *body_string = NULL; + axis2_char_t *ctx_uuid = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_char_t *peer_ip = NULL; + axutil_property_t *peer_property = NULL; + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request->request_uri, AXIS2_FALSE); + + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + + if(!request->content_type) + { + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; + } + + /** creating the out stream */ + out_stream = axutil_stream_create_basic(env); + + if(request->transfer_encoding) + axis2_msg_ctx_set_transfer_encoding(request->msg_ctx, env, request->transfer_encoding); + + axis2_msg_ctx_set_server_side(request->msg_ctx, env, AXIS2_TRUE); + msg_ctx = request->msg_ctx; + peer_ip = request->remote_ip; + + if(peer_ip) + { + peer_property = axutil_property_create(env); + axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip)); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property); + } + + axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); + + ctx_uuid = axutil_uuid_gen(env); + if(ctx_uuid) + { + axutil_string_t *uuid_str = axutil_string_create_assume_ownership(env, &ctx_uuid); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, uuid_str); + axutil_string_free(uuid_str, env); + } + + axis2_msg_ctx_set_out_transport_info(msg_ctx, env, + &(request->out_transport_info->out_transport)); + + if(request->accept_header) + { + axutil_array_list_t *accept_record_list = NULL; + accept_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_header); + 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); + } + } + if(request->accept_charset_header) + { + axutil_array_list_t *accept_charset_record_list = NULL; + accept_charset_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_charset_header); + if(accept_charset_record_list) + { + axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env, + accept_charset_record_list); + } + } + if(request->accept_language_header) + { + axutil_array_list_t *accept_language_record_list = NULL; + accept_language_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_language_header); + if(accept_language_record_list) + { + axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env, + accept_language_record_list); + } + } + + if(request->soap_action) + { + soap_action = axutil_string_create(env, request->soap_action); + } + + if(request->request_method == AXIS2_HTTP_METHOD_GET || request->request_method + == AXIS2_HTTP_METHOD_DELETE || request->request_method == AXIS2_HTTP_METHOD_HEAD) + { + + if(request->request_method == AXIS2_HTTP_METHOD_DELETE) + { + processed = axis2_http_transport_utils_process_http_delete_request(env, + request->msg_ctx, request->in_stream, out_stream, request->content_type, + soap_action, request->request_uri, conf_ctx, + axis2_http_transport_utils_get_request_params(env, request->request_uri)); + } + else if(request->request_method == AXIS2_HTTP_METHOD_HEAD) + { + processed = axis2_http_transport_utils_process_http_head_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, soap_action, + request->request_uri, conf_ctx, axis2_http_transport_utils_get_request_params(env, + request->request_uri)); + } + else if(request->request_method == AXIS2_HTTP_METHOD_GET) + { + processed = axis2_http_transport_utils_process_http_get_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, soap_action, + request->request_uri, conf_ctx, axis2_http_transport_utils_get_request_params(env, + request->request_uri)); + } + if(AXIS2_FALSE == processed) + { + axis2_bool_t is_services_path = AXIS2_FALSE; + int msg_ctx_status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + if(request->request_method != AXIS2_HTTP_METHOD_DELETE && request->request_url_prefix) + { + axis2_char_t *temp = NULL; + temp = strstr(request->request_uri, request->request_url_prefix); + if(temp) + { + temp += strlen(request->request_url_prefix); + if(*temp == '/') + { + temp++; + } + if(!*temp || *temp == '?' || *temp == '#') + { + is_services_path = AXIS2_TRUE; + } + } + } + if(is_services_path) + { + body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + else if(AXIS2_HTTP_METHOD_DELETE != request->request_method) + { + axis2_char_t *wsdl = NULL; + wsdl = strstr(request->request_uri, AXIS2_REQUEST_WSDL); + if(wsdl) + { + body_string = axis2_http_transport_utils_get_services_static_wsdl(env, + conf_ctx, request->request_uri); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + } + else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + + if(method_list && size) + { + /** 405 */ + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + + response->http_status_code = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME; + } + else + { + /** 404 */ + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME; + } + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + /* 400, Bad Request */ + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + /* 408, Request Timeout */ + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + /* 409, Conflict Types */ + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + /* 410, Gone. Resource no longer available */ + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_GONE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_GONE_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + /*410, Precondition for the url failed */ + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + /* 413, Request entity too large */ + body_string + = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + /* 513, Service Unavailable */ + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME; + } + else + { + /* 500, Internal Server Error */ + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + } + + if(body_string) + { + response->response_data = body_string; + response->response_data_length = axutil_strlen(body_string); + } + status = AXIS2_SUCCESS; + } + } + else if(AXIS2_HTTP_METHOD_POST == request->request_method || AXIS2_HTTP_METHOD_PUT + == request->request_method) + { + if(AXIS2_HTTP_METHOD_POST == request->request_method) + { + processed = axis2_http_transport_utils_process_http_post_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, request->content_length, + soap_action, request->request_uri); + } + else + { + processed = axis2_http_transport_utils_process_http_put_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, request->content_length, + soap_action, request->request_uri); + } + if(AXIS2_FAILURE == processed && (AXIS2_HTTP_METHOD_PUT == request->request_method + || axis2_msg_ctx_get_doing_rest(msg_ctx, env))) + { + + if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + /** 405 */ + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME; + } + else + { + /** 404 */ + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else + { + /* 500, Internal Server Error */ + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + + } + + if(body_string) + { + response->response_data = body_string; + response->response_data_length = axutil_strlen(body_string); + } + status = AXIS2_SUCCESS; + } + else if(processed == AXIS2_FAILURE) + { + axis2_msg_ctx_t *fault_ctx = NULL; + axis2_char_t *fault_code = NULL; + axis2_engine_t *engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + /* Critical error, cannot proceed, send defaults document for 500 */ + return AXIS2_CRITICAL_FAILURE; + } + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_SENDER; + } + else + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; + } + fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, request->msg_ctx, + fault_code, axutil_error_get_message(env->error)); + + axis2_engine_send_fault(engine, env, fault_ctx); + if (out_stream) + { + response->response_data = axutil_stream_get_buffer(out_stream, env); + response->response_data_length = axutil_stream_get_len (out_stream, env); + } + /* In case of a SOAP Fault, we have to set the status to 500, but still return */ + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + } + } + else + { + response->response_data = axis2_http_transport_utils_get_not_implemented(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME; + status = AXIS2_SUCCESS; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if (op_ctx) + { + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + response->msg_ctx = out_msg_ctx; + } + + if (status == AXIS2_FAILURE) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (AXIS2_HTTP_METHOD_POST != request->request_method || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if ((request->accept_header || request->accept_charset_header || + request->accept_language_header) && do_rest) + { + axis2_char_t *content_type_header_value = NULL; + axis2_char_t *temp = NULL; + axis2_char_t *language_header_value = NULL; + + content_type_header_value = (axis2_char_t *) request->content_type; + language_header_value = axis2_msg_ctx_get_content_language(out_msg_ctx,env); + if (content_type_header_value) + { + temp = axutil_strdup(env, content_type_header_value); + } + if (temp) + { + axis2_char_t *content_type = NULL; + axis2_char_t *char_set = NULL; + axis2_char_t *temp2 = NULL; + + temp2 = strchr(temp, ';'); + if (temp2) + { + *temp2 = '\0'; + temp2++; + char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING); + } + if (char_set) + { + char_set = axutil_strltrim(env, char_set, " \t="); + } + if (char_set) + { + temp2 = strchr(char_set, ';'); + } + if (temp2) + { + *temp2 = '\0'; + } + content_type = axutil_strtrim(env, temp, NULL); + + if (temp) + { + AXIS2_FREE(env->allocator, temp); + temp = NULL; + } + if (content_type && request->accept_header && + !axutil_strcasestr(request->accept_header, content_type)) + { + temp2 = strchr(content_type, '/'); + if (temp2) + { + *temp2 = '\0'; + temp = AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * ((int)strlen(content_type) + 3)); + if (!temp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FALSE; + } + sprintf(temp, "%s/*", content_type); + if (!axutil_strcasestr(request->accept_header, temp) && + !strstr(request->accept_header, AXIS2_HTTP_HEADER_ACCEPT_ALL)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME; + status = AXIS2_TRUE; + } + AXIS2_FREE(env->allocator, temp); + } + } + if (content_type) + { + AXIS2_FREE(env->allocator, content_type); + } + if (char_set && request->accept_charset_header && + !axutil_strcasestr(request->accept_charset_header , char_set)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (response->response_data) + { + response->response_data_length= axutil_strlen(response->response_data); + } + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME; + } + if (char_set) + { + AXIS2_FREE(env->allocator, char_set); + } + } + if (language_header_value) + { + if (request->accept_language_header && + !axutil_strcasestr(request->accept_language_header , language_header_value)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME; + } + } + } + } + if (status == AXIS2_FAILURE) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (AXIS2_HTTP_METHOD_POST != request->request_method || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env)) + { + if (do_rest) + { + 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); + response->output_headers = output_header_list; + } + + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + response->http_status_code = + axis2_http_transport_utils_check_status_code(status_code); + status = AXIS2_SUCCESS; + } + } + } + if (status == AXIS2_FAILURE) + { + status = AXIS2_SUCCESS; + if (out_stream) + { + response->response_data = axutil_stream_get_buffer(out_stream, env); + response->response_data_length = axutil_stream_get_len(out_stream, env); + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + } + } + else if (op_ctx) + { + if (do_rest) + { + 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); + response->output_headers = output_header_list; + } + if (axis2_msg_ctx_get_no_content(out_msg_ctx, env)) + { + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL: + response->http_status_code = AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL; + break; + default: + response->http_status_code = AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL; + break; + } + } + else + { + response->http_status_code = AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL; + } + status = AXIS2_SUCCESS; + } + 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); + response->http_status_code = + axis2_http_transport_utils_check_status_code(status_code); + status = AXIS2_SUCCESS; + } + } + } + if (status == AXIS2_FAILURE) + { + response->http_status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + status = AXIS2_SUCCESS; + } + } + else + { + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + } + } + axutil_string_free(soap_action, env); + msg_ctx = NULL; + + return status; +} + +/* This method takes an array_list as the input. It has items some + may be buffers and some may be files. This will send these part + one by one to the wire using the chunked stream.*/ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_send_mtom_message( + axutil_http_chunked_stream_t * chunked_stream, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *sending_callback_name) +{ + int i = 0; + axis2_status_t status = AXIS2_SUCCESS; + + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + + /* If it is a buffer just write it to the wire. This includes mime_bounadaries, + * mime_headers and SOAP */ + if(mime_part->type == AXIOM_MIME_PART_BUFFER) + { + size_t written = 0; + while(written < mime_part->part_size) + { + int len = 0; + len = axutil_http_chunked_stream_write(chunked_stream, env, + mime_part->part + written, mime_part->part_size - written); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + else + { + written += len; + } + } + } + + /* If it is a file we load a very little portion to memory and send it as chunked , + * we keep on doing this until we find the end of the file */ + else if(mime_part->type == AXIOM_MIME_PART_FILE) + { + FILE *f = NULL; + axis2_byte_t *output_buffer = NULL; + int output_buffer_size = 0; + + f = fopen(mime_part->file_name, "rb"); + if(!f) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error opening file %s for reading", + mime_part->file_name); + return AXIS2_FAILURE; + } + + /* If the part_size is less than the defined buffer size then + * from the first write to the wire we can send the file */ + if(mime_part->part_size > AXIS2_MTOM_OUTPUT_BUFFER_SIZE) + { + output_buffer_size = AXIS2_MTOM_OUTPUT_BUFFER_SIZE; + } + else + { + output_buffer_size = (int)mime_part->part_size; + } + + output_buffer = AXIS2_MALLOC(env->allocator, output_buffer_size * sizeof(axis2_char_t)); + + /*This is the method responsible for writing to the wire */ + status = axis2_http_transport_utils_send_attachment_using_file(env, chunked_stream, + f, output_buffer, output_buffer_size); + AXIS2_FREE(env->allocator, output_buffer); + fclose(f); + } + + /* if the callback is given, send data using callback */ + else if((mime_part->type) == AXIOM_MIME_PART_CALLBACK) + { + void *handler = NULL; + axiom_mtom_sending_callback_t *callback = NULL; + + handler = axis2_http_transport_utils_initiate_callback(env, sending_callback_name, + mime_part->user_param, &callback); + if(handler) + { + status = axis2_http_transport_utils_send_attachment_using_callback(env, + chunked_stream, callback, handler, mime_part->user_param); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "MTOM Sending Callback loading failed"); + status = AXIS2_FAILURE; + } + + if(callback) + { + axutil_param_t *param = NULL; + param = callback->param; + AXIOM_MTOM_SENDING_CALLBACK_FREE(callback, env); + if(param) + { + axutil_param_free(param, env); + } + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unknown mime_part."); + status = AXIS2_FAILURE; + } + + if(status != AXIS2_SUCCESS) + { + break; + } + } + + if(status == AXIS2_SUCCESS) + { + /* send the end of chunk */ + status = axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); + } + + return status; +} + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_file( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size) +{ + /*We do not load the whole file to memory. Just load a buffer_size portion + *and send it. Keep on doing this until the end of file */ + do + { + int written = 0; + int count = (int)fread(buffer, 1, buffer_size, fp); + if(ferror(fp) || (count < 0)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in reading file containing the attachment"); + return AXIS2_FAILURE; + } + + /* count == 0 is a valid case. If the file size is multiple of buffer_size, then last read + * will have count == 0 + */ + + /*Writing the part we loaded to memory to the wire*/ + while(written < count) + { + int len = axutil_http_chunked_stream_write(chunked_stream, env, + buffer + written, count - written); + if(len == -1) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "error in writing file to stream"); + return AXIS2_FAILURE; + } + + written += len; + } + } + while(!feof(fp)); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_destroy_mime_parts( + axutil_array_list_t *mime_parts, + const axutil_env_t *env) +{ + if (mime_parts) + { + int i = 0; + for (i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *) + axutil_array_list_get(mime_parts, env, i); + if (mime_part) + { + axiom_mime_part_free(mime_part, env); + } + } + axutil_array_list_free(mime_parts, env); + } +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_http_transport_utils_initiate_callback( + const axutil_env_t *env, + axis2_char_t *callback_name, + void *user_param, + axiom_mtom_sending_callback_t **callback) +{ + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + void *ptr = NULL; + + if(!callback_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "invalid callback name given"); + return NULL; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Trying to load module = %s", callback_name); + + dll_desc = axutil_dll_desc_create(env); + axutil_dll_desc_set_name(dll_desc, env, callback_name); + impl_info_param = axutil_param_create(env, NULL, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + ptr = axutil_class_loader_create_dll(env, impl_info_param); + if (!ptr) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to load the module %s.", callback_name); + return NULL; + } + + *callback = (axiom_mtom_sending_callback_t *)ptr; + (*callback)->param = impl_info_param; + + return AXIOM_MTOM_SENDING_CALLBACK_INIT_HANDLER(*callback, env, user_param); +} + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_callback( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param) +{ + int count = 0; + axis2_status_t status = AXIS2_SUCCESS; + axis2_char_t *buffer = NULL; + + /* Keep on loading the data in a loop until all the data is sent */ + while((count = AXIOM_MTOM_SENDING_CALLBACK_LOAD_DATA(callback, env, handler, &buffer)) > 0) + { + int written = 0; + while(written < count) + { + int len = 0; + len = axutil_http_chunked_stream_write(chunked_stream, env, + buffer + written, count - written); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + + written += len; + } + } + + status = AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler) && status; + return status; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_transport_utils_is_callback_required( + const axutil_env_t *env, + axutil_array_list_t *mime_parts) +{ + int size = 0; + int i = 0; + axis2_bool_t is_required = AXIS2_FALSE; + + size = axutil_array_list_size(mime_parts, env); + for(i = 0; i < size; i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + if(mime_part) + { + if(mime_part->type == AXIOM_MIME_PART_CALLBACK) + { + is_required = AXIS2_TRUE; + break; + } + } + } + + return is_required; +} + +static void +axis2_http_transport_utils_parse_session_str(const axutil_env_t *env, axis2_char_t *str, + axutil_hash_t *ht) +{ + while (*str) + { + axis2_char_t *next = axutil_strstr(str, ";"); + if (next) + { + axis2_char_t *key = NULL; + axis2_char_t *val = NULL; + + + /* Get key and value pairs */ + key = axis2_http_transport_utils_copy_key(env, str); + val = axis2_http_transport_utils_copy_value(env, str); + axutil_hash_set(ht, key, AXIS2_HASH_KEY_STRING, val); + + /* find next token */ + str = next + 1; + } + + } +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_session( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx) +{ + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + axutil_hash_t *ht = NULL; + axis2_char_t *session_id = NULL; + axis2_char_t *time_str = NULL; + axis2_char_t *header_value = NULL; + axutil_date_time_t *expire_time = NULL; + axis2_char_t session_value[256]; + axis2_http_out_transport_info_t *out_info = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_get_session"); + ht = axis2_msg_ctx_get_property_value(msg_ctx, env, AXIS2_TRANSPORT_SESSION_TABLE); + if(!ht) + { + axis2_op_ctx_t *op_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); + if(in_msg_ctx) + { + ht = axis2_msg_ctx_get_property_value(in_msg_ctx, env, + AXIS2_TRANSPORT_SESSION_TABLE); + } + } + if(!ht) + { + return NULL; + } + } + session_id = axutil_hash_get(ht, "id", AXIS2_HASH_KEY_STRING); + if(!session_id) + { + /* Generate session and set it in session table */ + session_id = axutil_uuid_gen(env); + axutil_hash_set(ht, axutil_strdup(env, "id"), AXIS2_HASH_KEY_STRING, axutil_strdup(env, + session_id)); + + /* Generate expire time and set it in session table */ + expire_time = axutil_date_time_create_with_offset(env, AXIS2_TRANSPORT_SESSION_EXPIRE_DURATION); + time_str = axutil_strdup(env, axutil_date_time_serialize_date_time(expire_time, env)); + axutil_date_time_free(expire_time, env); + axutil_hash_set(ht, axutil_strdup(env, "expires"), AXIS2_HASH_KEY_STRING, time_str); + + sprintf(session_value, "%s", ""); + + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + int len = -1; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + value = (axis2_char_t *) val; + if(name) + { + len = axutil_strlen(session_value); + sprintf(session_value + len, "%s=", name); + AXIS2_FREE(env->allocator, name); + } + if(value) + { + len = axutil_strlen(session_value); + sprintf(session_value + len, "%s;", value); + AXIS2_FREE(env->allocator, value); + } + } + + out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info( + msg_ctx, env); + if(!out_info) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, header_value); + return NULL; + } + status = AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_SESSION(out_info, env, session_id, session_value); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Inserting session value failed for session id %s", session_id); + return NULL; + } + } + else + { + time_str = axutil_hash_get(ht, "expires", AXIS2_HASH_KEY_STRING); + } + header_value = AXIS2_MALLOC(env->allocator, 256 * sizeof(axis2_char_t)); + sprintf(header_value, "ID=%s; expires=%s;", session_id, time_str); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_get_session"); + return header_value; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_set_session( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_char_t *session_str) +{ + axutil_date_time_t *expire_time = NULL; + axutil_date_time_t *current_time = NULL; + axutil_date_time_comp_result_t result; + axis2_char_t *time_str = NULL; + axutil_hash_t *ht = NULL; + axutil_property_t *property = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_tranpsport_utils_set_session"); + + /* Check whether session has expired. If so set error and return */ + ht = axutil_hash_make(env); + axis2_http_transport_utils_parse_session_str(env, session_str, ht); + time_str = (axis2_char_t *) axutil_hash_get(ht, "time", AXIS2_HASH_KEY_STRING); + expire_time = axutil_date_time_create(env); + axutil_date_time_deserialize_date_time(expire_time, env, time_str); + current_time = axutil_date_time_create(env); + result = axutil_date_time_compare(current_time, env, expire_time); + axutil_date_time_free(current_time, env); + axutil_date_time_free(expire_time, env); + if(result == AXIS2_DATE_TIME_COMP_RES_EXPIRED) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Session time out"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SESSION_TIMEOUT, AXIS2_FAILURE); + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + if(name) + { + AXIS2_FREE(env->allocator, name); + } + value = (axis2_char_t *) val; + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + axutil_hash_free(ht, env); + } + + property = axutil_property_create_with_args(env, 0, AXIS2_TRUE, 0, ht); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_SESSION_TABLE, property); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_tranpsport_utils_set_session"); +} + +/** + * After receiving Set-Cookie header store it + */ +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_store_cookie( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_char_t *cookie) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axutil_property_t *property = NULL; + axutil_hash_t *session_map = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + const axis2_char_t *address = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_store_cookie"); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP); + if(property) + { + session_map = axutil_property_get_value(property, env); + } + if(!session_map) + { + if(!cookie) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "No session map found and no cookie set. So return"); + return; + } + session_map = axutil_hash_make(env); + if(session_map) + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 1, + axis2_http_transport_utils_session_map_free_void_arg, session_map); + axis2_conf_ctx_set_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP, property); + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return; + } + } + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = NULL; + server = axutil_url_get_server(url, env); + if(server) + { + if(cookie) + { + axutil_hash_set(session_map, axutil_strdup(env, server), AXIS2_HASH_KEY_STRING, + axutil_strdup(env, cookie)); + } + else /* We remove any cookie set for this endpoint */ + { + cookie = axutil_hash_get(session_map, server, AXIS2_HASH_KEY_STRING); + if(cookie) + { + AXIS2_FREE(env->allocator, cookie); + } + axutil_hash_set(session_map, axutil_strdup(env, server), AXIS2_HASH_KEY_STRING, NULL); + } + } + axutil_url_free(url, env); + } + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_store_cookie"); +} + +/* Read from cookie store before sending */ +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_read_from_cookie_store( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx) +{ + axutil_property_t *property = NULL; + axutil_hash_t *session_map = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + const axis2_char_t *address = NULL; + axis2_char_t *cookie = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_read_from_cookie_store"); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP); + if(property) + { + session_map = axutil_property_get_value(property, env); + } + if(!session_map) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No session map stored"); + return NULL; + } + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = NULL; + server = axutil_url_get_server(url, env); + if(server) + { + cookie = axutil_hash_get(session_map, server, AXIS2_HASH_KEY_STRING); + } + axutil_url_free(url, env); + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "cookie:%s", cookie); + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_read_from_cookie_store"); + return cookie; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_session_id_from_cookie( + const axutil_env_t *env, + axis2_char_t *cookie) +{ + axis2_char_t *next = NULL; + axis2_char_t *session_id = NULL; + + next = axutil_strstr(cookie, ";"); + if (next) + { + session_id = axis2_http_transport_utils_copy_value(env, cookie); + } + + return session_id; +} + +static axis2_char_t * +axis2_http_transport_utils_copy_key( + const axutil_env_t *env, + axis2_char_t *pair) +{ + axis2_char_t *p = axutil_strchr(pair, '='); + axis2_char_t *ret = NULL; + + if (p) + { + axis2_char_t c; + size_t len = p - pair; + c = pair[len]; + pair[len] = '\0'; + ret = axutil_strdup(env, pair); + pair[len] = c; + } + + return ret; +} + +static axis2_char_t * +axis2_http_transport_utils_copy_value( + const axutil_env_t *env, + axis2_char_t *pair) +{ + axis2_char_t *ret = NULL; + size_t len; + axis2_char_t c; + + pair = axutil_strchr(pair, '='); + if (pair) + { + pair++; + len = axutil_strchr(pair, ';') - pair; + c = pair[len]; + pair[len] = '\0'; + ret = axutil_strdup(env, pair); + pair[len] = c; + } + + return ret; +} + + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_session_map_free_void_arg( + void *sm_void, + const axutil_env_t *env) +{ + void *val = NULL; + const void *key = NULL; + axutil_hash_index_t *hi = NULL; + axutil_hash_t *ht = (axutil_hash_t *)sm_void; + + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + if(name) + { + AXIS2_FREE(env->allocator, name); + } + value = (axis2_char_t *) val; + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + axutil_hash_free(ht, env); +} + + |