summaryrefslogtreecommitdiffstats
path: root/src/core/transport/http/util
diff options
context:
space:
mode:
authorGravatar gmcdonald2010-02-13 01:32:03 +0000
committerGravatar gmcdonald2010-02-13 01:32:03 +0000
commit0425aadc78680e53000fd0108b540d6eca048516 (patch)
tree8ec7ab8e015d454c5ec586dfc91e05a2dce1cfc0 /src/core/transport/http/util
downloadaxis2c-0425aadc78680e53000fd0108b540d6eca048516.tar.gz
axis2c-0425aadc78680e53000fd0108b540d6eca048516.tar.bz2
Moving axis svn, part of TLP move INFRA-2441
git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'src/core/transport/http/util')
-rw-r--r--src/core/transport/http/util/Makefile.am14
-rw-r--r--src/core/transport/http/util/http_transport_utils.c3885
2 files changed, 3899 insertions, 0 deletions
diff --git a/src/core/transport/http/util/Makefile.am b/src/core/transport/http/util/Makefile.am
new file mode 100644
index 0000000..eff6c0e
--- /dev/null
+++ b/src/core/transport/http/util/Makefile.am
@@ -0,0 +1,14 @@
+NSUBDIRS =
+noinst_LTLIBRARIES = libaxis2_http_util.la
+
+libaxis2_http_util_la_SOURCES = http_transport_utils.c
+
+libaxis2_http_util_la_LIBADD=$(top_builddir)/util/src/libaxutil.la \
+ $(top_builddir)/axiom/src/parser/${WRAPPER_DIR}/libaxis2_parser.la\
+ $(top_builddir)/axiom/src/om/libaxis2_axiom.la
+
+
+INCLUDES = -I$(top_builddir)/include \
+ -I$(top_builddir)/src/core/engine \
+ -I$(top_builddir)/util/include \
+ -I$(top_builddir)/axiom/include
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);
+}
+
+
© 2009-2020 sukimashita.com - Generated by cgit - Icons from Tango - Uses Google Analytics