From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: 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 --- src/core/transport/http/server/CGI/Makefile.am | 31 + .../transport/http/server/CGI/axis2_cgi_main.c | 280 ++++ .../http/server/CGI/axis2_cgi_out_transport_info.c | 160 ++ .../http/server/CGI/axis2_cgi_out_transport_info.h | 62 + .../transport/http/server/CGI/axis2_cgi_stream.c | 164 ++ .../transport/http/server/CGI/axis2_cgi_stream.h | 44 + .../transport/http/server/CGI/axis2_cgi_types.h | 34 + src/core/transport/http/server/IIS/README | 61 + .../http/server/IIS/axis2_iis_constants.h | 51 + .../http/server/IIS/axis2_iis_out_transport_info.c | 153 ++ .../http/server/IIS/axis2_iis_out_transport_info.h | 61 + .../transport/http/server/IIS/axis2_iis_regedit.js | 84 + .../transport/http/server/IIS/axis2_iis_stream.c | 313 ++++ .../transport/http/server/IIS/axis2_iis_stream.h | 45 + .../transport/http/server/IIS/axis2_iis_worker.c | 607 +++++++ .../transport/http/server/IIS/axis2_iis_worker.h | 62 + .../transport/http/server/IIS/axis2_isapi_plugin.c | 476 ++++++ .../IIS/iis_iaspi_plugin_51/axis2_isapi_51.c | 153 ++ src/core/transport/http/server/IIS/mod_axis2.def | 7 + src/core/transport/http/server/Makefile.am | 2 + src/core/transport/http/server/apache2/Makefile.am | 40 + .../server/apache2/apache2_out_transport_info.c | 191 +++ .../transport/http/server/apache2/apache2_stream.c | 292 ++++ .../transport/http/server/apache2/apache2_stream.h | 46 + .../transport/http/server/apache2/apache2_worker.c | 1687 ++++++++++++++++++++ .../apache2/axis2_apache2_out_transport_info.h | 61 + .../http/server/apache2/axis2_apache2_worker.h | 78 + src/core/transport/http/server/apache2/mod_axis2.c | 844 ++++++++++ .../http/server/simple_axis2_server/Makefile.am | 30 + .../server/simple_axis2_server/http_server_main.c | 310 ++++ 30 files changed, 6429 insertions(+) create mode 100644 src/core/transport/http/server/CGI/Makefile.am create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_main.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_stream.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_stream.h create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_types.h create mode 100644 src/core/transport/http/server/IIS/README create mode 100644 src/core/transport/http/server/IIS/axis2_iis_constants.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_regedit.js create mode 100644 src/core/transport/http/server/IIS/axis2_iis_stream.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_stream.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_worker.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_worker.h create mode 100644 src/core/transport/http/server/IIS/axis2_isapi_plugin.c create mode 100644 src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c create mode 100644 src/core/transport/http/server/IIS/mod_axis2.def create mode 100644 src/core/transport/http/server/Makefile.am create mode 100644 src/core/transport/http/server/apache2/Makefile.am create mode 100644 src/core/transport/http/server/apache2/apache2_out_transport_info.c create mode 100644 src/core/transport/http/server/apache2/apache2_stream.c create mode 100644 src/core/transport/http/server/apache2/apache2_stream.h create mode 100644 src/core/transport/http/server/apache2/apache2_worker.c create mode 100644 src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h create mode 100644 src/core/transport/http/server/apache2/axis2_apache2_worker.h create mode 100644 src/core/transport/http/server/apache2/mod_axis2.c create mode 100644 src/core/transport/http/server/simple_axis2_server/Makefile.am create mode 100644 src/core/transport/http/server/simple_axis2_server/http_server_main.c (limited to 'src/core/transport/http/server') diff --git a/src/core/transport/http/server/CGI/Makefile.am b/src/core/transport/http/server/CGI/Makefile.am new file mode 100644 index 0000000..fafb8bf --- /dev/null +++ b/src/core/transport/http/server/CGI/Makefile.am @@ -0,0 +1,31 @@ +prgbindir=$(bindir) +prgbin_PROGRAMS = axis2.cgi +SUBDIRS = +AM_CFLAGS = -g -pthread +axis2_cgi_SOURCES = axis2_cgi_main.c \ + axis2_cgi_out_transport_info.c \ + axis2_cgi_stream.c + +axis2_cgi_LDADD = $(LDFLAGS) \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la \ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/src/core/transport/http/sender/libaxis2_http_sender.la \ + $(top_builddir)/src/core/transport/http/receiver/libaxis2_http_receiver.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description\ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deployment\ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/server/CGI/axis2_cgi_main.c b/src/core/transport/http/server/CGI/axis2_cgi_main.c new file mode 100644 index 0000000..6f9a59d --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_main.c @@ -0,0 +1,280 @@ +/* + * 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_cgi_out_transport_info.h" +#include "axis2_cgi_stream.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +axis2_char_t *axis2_cgi_default_url_prefix = "/cgi-bin/axis2.cgi/"; + +/***************************** Function headers *******************************/ + +void +axis2_cgi_system_exit( + axutil_env_t * env, + int status); + +void +axis2_cgi_set_request_vars( + axis2_cgi_request_t *cgi_request); + +axis2_status_t +axis2_cgi_write_response( + const void *buffer, + unsigned int length); + +/***************************** End of function headers ************************/ + +int +main( + int argc, + char *argv[]) +{ + axutil_allocator_t *allocator = NULL; + axutil_env_t *env = NULL; + const axis2_char_t *repo_path; + axis2_conf_ctx_t *conf_ctx; + axis2_cgi_request_t *cgi_request = NULL; + int content_length = 0; + axis2_char_t *request_url = NULL; + /* axutil_stream_t *request_body_stream = NULL; */ + axutil_stream_t *out_stream = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + axis2_transport_out_desc_t *out_desc = NULL; + /* axis2_msg_ctx_t *msg_ctx = NULL; */ + /* axis2_bool_t processed = AXIS2_FALSE; */ + axis2_http_transport_in_t request; + axis2_http_transport_out_t response; + /*axis2_http_header_t* http_header = NULL; */ + /*axutil_hash_t *headers = NULL; */ + /* axis2_char_t *axis2_cgi_url_prefix = NULL; */ + + if(!(repo_path = AXIS2_GETENV("AXIS2C_HOME"))) + { + fprintf(stderr, "Error: AXIS2C_HOME environment variable not set!"); + axis2_cgi_system_exit(env, -1); + } + + allocator = axutil_allocator_init(NULL); + env = axutil_env_create(allocator); + + if(axutil_file_handler_access(repo_path, AXIS2_R_OK) != AXIS2_SUCCESS) + { + fprintf(stderr, "Error reading repository: %s\nPlease check AXIS2C_HOME var", repo_path); + axis2_cgi_system_exit(env, -1); + } + + /* Set configuration */ + + conf_ctx = axis2_build_conf_ctx(env, repo_path); + if(!conf_ctx) + { + fprintf(stderr, "Error: Configuration not builded propertly\n"); + axis2_cgi_system_exit(env, -1); + } + + axis2_http_transport_utils_transport_out_init(&response, env); + axis2_http_transport_utils_transport_in_init(&request, env); + + /* Get input info */ + + cgi_request = AXIS2_MALLOC(allocator, sizeof(axis2_cgi_request_t)); + axis2_cgi_set_request_vars(cgi_request); + + request_url = (axis2_char_t *)AXIS2_MALLOC(allocator, (7 + /* "http:" */ + strlen(cgi_request->server_name) + ((strlen(cgi_request->server_port)) ? 1 : 0) + /* ":"*/ + strlen(cgi_request->server_port) + strlen(cgi_request->script_name) + strlen( + cgi_request->path_info) + ((strlen(cgi_request->path_info)) ? 1 : 0) + /* "?" */ + strlen(cgi_request->query_string)) * sizeof(axis2_char_t)); + + request_url[0] = '\0'; + + strcat(request_url, "http://"); + strcat(request_url, cgi_request->server_name); + if(strlen(cgi_request->server_port)) + strcat(request_url, ":"); + strcat(request_url, cgi_request->server_port); + strcat(request_url, cgi_request->script_name); + strcat(request_url, cgi_request->path_info); + if(strlen(cgi_request->query_string)) + strcat(request_url, "?"); + strcat(request_url, cgi_request->query_string); + + if(cgi_request->content_length) + content_length = axutil_atoi(cgi_request->content_length); + else + content_length = 0; + + /* Set streams */ + + out_stream = axutil_stream_create_basic(env); + + /* Set message contexts */ + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + + request.msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + + axis2_msg_ctx_set_server_side(request.msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_transport_out_stream(request.msg_ctx, env, out_stream); + axis2_msg_ctx_set_transport_headers(request.msg_ctx, env, NULL); + + /* Set request parameters */ + + request.soap_action = cgi_request->soap_action; + request.in_stream = axutil_stream_create_cgi(env, content_length); + request.remote_ip = cgi_request->remote_addr; + request.content_length = content_length; + request.content_type = cgi_request->content_type; + request.request_uri = request_url; + request.svr_port = cgi_request->server_port; + request.accept_header = AXIS2_GETENV("HTTP_ACCEPT"); + request.accept_language_header = AXIS2_GETENV("HTTP_ACCEPT_LANGUAGE"); + request.accept_charset_header = AXIS2_GETENV("HTTP_ACCEPT_CHARSET"); + request.request_url_prefix = (AXIS2_GETENV("AXIS2C_URL_PREFIX")) ? AXIS2_GETENV( + "AXIS2C_URL_PREFIX") : axis2_cgi_default_url_prefix; + + if(axutil_strcasecmp(cgi_request->request_method, "POST") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_POST; + } + else if(axutil_strcasecmp(cgi_request->request_method, "GET") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_GET; + } + else if(axutil_strcasecmp(cgi_request->request_method, "HEAD") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_HEAD; + } + else if(axutil_strcasecmp(cgi_request->request_method, "PUT") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_PUT; + } + else if(axutil_strcasecmp(cgi_request->request_method, "DELETE") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_DELETE; + } + + request.out_transport_info = axis2_cgi_out_transport_info_create(env, cgi_request); + + /*Process request */ + fprintf(stderr, "ok\n"); + axis2_http_transport_utils_process_request(env, conf_ctx, &request, &response); + fprintf(stderr, "ok\n"); + /*Send status */ + + fprintf(stdout, "Status: %d %s \r\n", response.http_status_code, response.http_status_code_name); + + if(response.content_type) + { + fprintf(stdout, "Content-type: %s \r\n", response.content_type); + } + else if(strlen(axis2_cgi_out_transport_get_content(request.out_transport_info)) + && axis2_cgi_out_transport_get_content(request.out_transport_info)) + { + fprintf(stdout, "Content-type: %s \r\n", axis2_cgi_out_transport_get_content( + request.out_transport_info)); + } + + fprintf(stdout, "\r\n"); /* End of headers for server */ + + /* Write data body */ + if(!axis2_cgi_write_response(response.response_data, response.response_data_length)) + { + fprintf(stderr, "Error writing output data\n"); + } + + axis2_http_transport_utils_transport_in_uninit(&request, env); + axis2_http_transport_utils_transport_out_uninit(&response, env); + + return 0; +} + +axis2_status_t +axis2_cgi_write_response( + const void *buffer, + unsigned int length) +{ + if(buffer && length) + { + unsigned int completed = 0; + unsigned int written = 0; + + while(completed < length) + { + written = fwrite(buffer, sizeof(char), length - completed, stdout); + if(written < 0) + return AXIS2_FALSE; + completed += written; + } + } + return AXIS2_TRUE; +} + +void +axis2_cgi_set_request_vars( + axis2_cgi_request_t *cgi_request) +{ + cgi_request->server_name = (AXIS2_GETENV("SERVER_NAME")) ? AXIS2_GETENV("SERVER_NAME") : ""; + cgi_request->script_name = (AXIS2_GETENV("SCRIPT_NAME")) ? AXIS2_GETENV("SCRIPT_NAME") : ""; + cgi_request->path_info = (AXIS2_GETENV("PATH_INFO")) ? AXIS2_GETENV("PATH_INFO") : ""; + cgi_request->server_port = (AXIS2_GETENV("SERVER_PORT")) ? AXIS2_GETENV("SERVER_PORT") : ""; + cgi_request->server_protocol = (AXIS2_GETENV("SERVER_PROTOCOL")) ? AXIS2_GETENV( + "SERVER_PROTOCOL") : ""; + cgi_request->content_length = (AXIS2_GETENV("CONTENT_LENGTH")) ? AXIS2_GETENV("CONTENT_LENGTH") + : ""; + cgi_request->content_type = (AXIS2_GETENV("CONTENT_TYPE")) ? AXIS2_GETENV("CONTENT_TYPE") : ""; + cgi_request->request_method = (AXIS2_GETENV("REQUEST_METHOD")) ? AXIS2_GETENV("REQUEST_METHOD") + : ""; + cgi_request->remote_addr = (AXIS2_GETENV("REMOTE_ADDR")) ? AXIS2_GETENV("REMOTE_ADDR") : ""; + cgi_request->soap_action = (AXIS2_GETENV("HTTP_SOAPACTION")) ? AXIS2_GETENV("HTTP_SOAPACTION") + : NULL; + cgi_request->query_string = (AXIS2_GETENV("QUERY_STRING")) ? AXIS2_GETENV("QUERY_STRING") : ""; +} + +void +axis2_cgi_system_exit( + axutil_env_t * env, + int status) +{ + axutil_allocator_t *allocator = NULL; + + if(env) + { + allocator = env->allocator; + axutil_env_free(env); + } + exit(status); +} diff --git a/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c new file mode 100644 index 0000000..59e6820 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c @@ -0,0 +1,160 @@ +/* + * 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_cgi_out_transport_info.h" +#include +#include + +/** + * @brief CIG Out transport info impl structure + * Axis2 cgi_out_transport_info_impl + */ + +typedef struct axis2_cgi_out_transport_info_s +{ + axis2_http_out_transport_info_t out_transport_info; + axis2_cgi_request_t *request; + axis2_char_t *encoding; +} axis2_cgi_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_cgi_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_cgi_out_transport_info_free( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, void); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + info_impl->request = NULL; /* doesn't belong here so no need to free it here */ + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + info_impl->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info_impl); + return; +} + +void AXIS2_CALL +axis2_cgi_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_cgi_out_transport_info_set_content_type( + axis2_http_out_transport_info_t *info, + const axutil_env_t *env, + const axis2_char_t *content_type) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + + axis2_char_t *temp1 = NULL; + axis2_char_t *temp2 = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + info_impl = AXIS2_INTF_TO_IMPL(info); + if(info_impl->encoding) + { + temp1 = axutil_stracat(env, content_type, ";charset="); + temp2 = axutil_stracat(env, temp1, info_impl->encoding); + info_impl->request->content_type = axutil_strdup(env, temp2); + AXIS2_FREE(env->allocator, temp1); + AXIS2_FREE(env->allocator, temp2); + } + else + { + info_impl->request->content_type = axutil_strdup(env, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_cgi_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + } + info_impl->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_cgi_out_transport_info_create( + const axutil_env_t * env, + axis2_cgi_request_t * request) +{ + axis2_cgi_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *out_transport_info = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_cgi_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_cgi_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->request = request; + info->encoding = NULL; + + out_transport_info = &(info->out_transport_info); + + axis2_http_out_transport_info_set_char_encoding_func(out_transport_info, env, + axis2_cgi_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_content_type_func(out_transport_info, env, + axis2_cgi_out_transport_info_set_content_type); + + return out_transport_info; +} + +axis2_char_t * +axis2_cgi_out_transport_get_content( + axis2_http_out_transport_info_t * info) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + info_impl = AXIS2_INTF_TO_IMPL(info); + return info_impl->request->content_type; +} + diff --git a/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h new file mode 100644 index 0000000..bc0f526 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h @@ -0,0 +1,62 @@ + +/* + * 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. + */ + +#ifndef AXIS2_CGI_OUT_TRANSPORT_INFO_H +#define AXIS2_CGI_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_cgi_out_transport_info.h + * @brief axis2 CGI Out Transport Info + */ + +#include "axis2_cgi_types.h" +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_cgi_out_transport_info_create( + const axutil_env_t * env, + axis2_cgi_request_t * request); + + /** + * Free http_out_transport_info passed as void pointer. This will be + * cast into appropriate type and then pass the cast object + * into the http_out_transport_info structure's free method + */ + void AXIS2_CALL + axis2_cgi_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + axis2_char_t *axis2_cgi_out_transport_get_content( + axis2_http_out_transport_info_t * out_transport_info); + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SGI_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/CGI/axis2_cgi_stream.c b/src/core/transport/http/server/CGI/axis2_cgi_stream.c new file mode 100644 index 0000000..68ad19f --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_stream.c @@ -0,0 +1,164 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "axis2_cgi_stream.h" + +/** + * @brief Stream struct impl + * Streaming mechanisms for cgi + */ + +typedef struct cgi_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + unsigned int cur_pos; + unsigned int content_length; +} cgi_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((cgi_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +cgi_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL cgi_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL cgi_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL cgi_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL cgi_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +axutil_stream_t *AXIS2_CALL +axutil_stream_create_cgi( + const axutil_env_t * env, + unsigned int content_length) +{ + cgi_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, content_length, NULL); + + stream_impl = (cgi_stream_impl_t *)AXIS2_MALLOC(env->allocator, sizeof(cgi_stream_impl_t)); + + if(!stream_impl) + { + return NULL; + } + stream_impl->cur_pos = 0; + stream_impl->content_length = content_length; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, cgi_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, cgi_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, cgi_stream_skip); + + return &(stream_impl->stream); +} +int AXIS2_CALL +cgi_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + /*void *temp_buff = NULL;*/ + /*unsigned int data_to_read = 0;*/ + unsigned int read_bytes = 0; + /*axis2_bool_t ret_ok = AXIS2_TRUE;*/ + + cgi_stream_impl_t *stream_impl = NULL; + /*char *temp = NULL;*/ + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (cgi_stream_impl_t *)stream; + + if(count < stream_impl->content_length) + { + read_bytes = fread(buffer, sizeof(char), count, stdin); + } + else + { + read_bytes = fread(buffer, sizeof(char), stream_impl->content_length, stdin); + } + + return read_bytes; +} + +int AXIS2_CALL +cgi_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + /* Cannot write on cgi stdin, explicitly an input stream */ + + return -1; +} + +int AXIS2_CALL +cgi_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + cgi_stream_impl_t *stream_impl = NULL; + int skipped = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + if(fseek(stdin, count, SEEK_CUR) == 0) + skipped = count; + return skipped; +} + +int AXIS2_CALL +cgi_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +cgi_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} diff --git a/src/core/transport/http/server/CGI/axis2_cgi_stream.h b/src/core/transport/http/server/CGI/axis2_cgi_stream.h new file mode 100644 index 0000000..9a6af34 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_stream.h @@ -0,0 +1,44 @@ + +/* + * 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. + */ + +#ifndef CGI_STREAM_H +#define CGI_STREAM_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** brief Constructor for creating CGI stream + * @return axutil_stream (CGI) + */ + axutil_stream_t *AXIS2_CALL + axutil_stream_create_cgi( + const axutil_env_t * env, + unsigned int content_length); + +#ifdef __cplusplus +} +#endif + +#endif /* CGI_STREAM_H */ diff --git a/src/core/transport/http/server/CGI/axis2_cgi_types.h b/src/core/transport/http/server/CGI/axis2_cgi_types.h new file mode 100644 index 0000000..af184a1 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_types.h @@ -0,0 +1,34 @@ + +/* + * 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 + +typedef struct axis2_cgi_request +{ + axis2_char_t *server_name; + axis2_char_t *server_port; + axis2_char_t *script_name; + axis2_char_t *path_info; + axis2_char_t *server_protocol; + axis2_char_t *content_length; + axis2_char_t *content_type; + axis2_char_t *request_method; + axis2_char_t *remote_addr; + axis2_char_t *soap_action; + axis2_char_t *query_string; +} axis2_cgi_request_t; diff --git a/src/core/transport/http/server/IIS/README b/src/core/transport/http/server/IIS/README new file mode 100644 index 0000000..1a47cc4 --- /dev/null +++ b/src/core/transport/http/server/IIS/README @@ -0,0 +1,61 @@ +How to Configure IIS Module for Axis2C +________________________________________ + +Use the Axis2/C VC project or makefile to build the component. + +In this document it is assumed that the mod_axis2_IIS.dll is in the directory +c:\axis2c\lib\mod_axis2_IIS.dll and axis2c_home is c:\axis2c + +Add the following key to the registry. + +HKEY_LOCAL_MACHINE\SOFTWARE\Apache Axis2c\IIS ISAPI Redirector + +Add a string value with the name axis2c_home and a value of c:\axis2c + +Add a string value with the name log_file and a value of c:\axis2c\logs\axis2.log + +Add a string value with the name log_level. The value can be one of trace, error, info, critical, debug, warning + +You can add a string value with the name services_url_prefix. This is optional and defaults to "/services". +As an example, if you have "/web_services" as the prefix, then all the services hosted would have the endpoint prefix of : +http://localhost/axis2/web_services. +Note: don't forget the / at the begining. + +If you wish, you can also change the location as well by adding a string value with the name axis2_location. +This is also optional and defaults to /axis2. If you have /myserser as the value you can access your web +services with a url like http://localhost/myserver/services. +Note: Don't forget the / at the beginning. + +Now you can do all the registry editing using the JScript file axis2_iis_regedit.js +provided with the distribution. When you build axis2/C with the IIS module the file +is copied to the root directory of the binary distribution. Just double click it and +everything will be set to the defaults. The axis2c_home is taken as the current directory, +so make sure you run the file in the Axis2/C repository location (or root of the binary distribution). +If you want to change the values you can manually edit the the .js file or give it as command line arguments +to the script when running the script. To run the jscript from the command line use the command +:\cscript axis2_iis_regedit.js optional arguments. +We recomend the manual editing as it is the easiest way to specify the values + +IIS 5.1 or Below + +Using the IIS management console, add a new virtual directory to your IIS/PWS Web site. +The name of the virtual directory must be axis2. Its physical path should be the directory +where you placed mod_axis2_IIS.dll (in our example it is c:\axis2c\lib). When creating this new +virtual directory, assign execute access to it. + +By Using the IIS management console, add mod_axis2_IIS.dll as a filter in your IIS/PWS web site and restart the IIS admin service. + + +IIS 6 & 7 + +Using the IIS management console, add the mod_axis2_IIS.dll as a Wildcard Script Map. + Executable should be the complete path to the mod_axis2_IIS.dll + You can put any name as the name of the Wildcard Script Map + +Please don't add the mod_axis2_IIS.dll as a filter to IIS as in the IIS 5.1 case. + +Note: If the Axis2/C failed to load, verify that Axis2/C and its dependent DLLs are in the System Path (not the user path). + + + + diff --git a/src/core/transport/http/server/IIS/axis2_iis_constants.h b/src/core/transport/http/server/IIS/axis2_iis_constants.h new file mode 100644 index 0000000..fb6929b --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_constants.h @@ -0,0 +1,51 @@ + +/* + * 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. + */ + +#ifndef AXIS2_IIS_CONSTANTS_H +#define AXIS2_IIS_CONSTANTS_H + +#define INTERNET_MAX_PATH_LENGTH 2048 +#define INTERNET_MAX_SCHEME_LENGTH 32 /* longest protocol name length */ +#define INTERNET_MAX_URL_LENGTH (INTERNET_MAX_SCHEME_LENGTH +sizeof("://") +INTERNET_MAX_PATH_LENGTH) + +#define URI_MATCHED 1 +#define URI_UN_MATCHED 2 + +#define EXTENSION_URL "/axis2/mod_axis2_IIS.dll\? " +#define EXTENSION_URL_AXIS2 "/axis2/" +#define EXTENSION_URL_MODIIS "mod_axis2_IIS.dll\? " + + +#define MAX_SERVERNAME 128 +#define MAX_PORT_LEN 8 + +#define MAX_HTTP_VERSION_LEN 16 +#define MAX_HTTP_CONTENT_TYPE_LEN 2048 +#define MAX_CONTENT_ENCODING_LEN 16 +#define MAX_HTTP_METHOD_LEN 8 +#define MAX_TCP_PORT_LEN 8 +#define MAX_CONTENT_LEN 16 + +#define OK 200 +#define HTTP_INTERNAL_SERVER_ERROR 500 +#define HTTP_ACCEPTED 202 + +#define AXIS2_STRICMP _stricmp + +#endif /*AXIS2_IIS_CONSTANTS_H*/ + diff --git a/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c new file mode 100644 index 0000000..fb7693b --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c @@ -0,0 +1,153 @@ +/* + * 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_iis_out_transport_info.h" +#include +#include +#include + +#include "axis2_iis_constants.h" + +/** + * @brief IIS Out transport info impl structure + * Axis2 iis_out_transport_info_impl + */ + +typedef struct axis2_iis_out_transport_info_s +{ + axis2_http_out_transport_info_t out_transport_info; + axis2_char_t *encoding; + axis2_char_t content_type[MAX_HTTP_CONTENT_TYPE_LEN]; +} axis2_iis_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_iis_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_iis_out_transport_info_free( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env) +{ + axis2_iis_out_transport_info_t *info = NULL; + AXIS2_ENV_CHECK(env, void); + + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + info->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info); + return; +} + +void AXIS2_CALL +axis2_iis_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_iis_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + + info_impl = AXIS2_INTF_TO_IMPL(info); + info_impl->content_type[0] = '\0'; + if(info_impl->encoding) + { + sprintf(info_impl->content_type, "%s%s%s", content_type, ";charser:", info_impl->encoding); + } + else + { + strcat(info_impl->content_type, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_iis_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + } + info_impl->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_iis_out_transport_info_create( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + axis2_iis_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *http_out_info = NULL; + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_iis_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_iis_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->encoding = NULL; + + http_out_info = &(info->out_transport_info); + + axis2_http_out_transport_info_set_content_type_func(http_out_info, env, + axis2_iis_out_transport_info_set_content_type); + axis2_http_out_transport_info_set_char_encoding_func(http_out_info, env, + axis2_iis_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_free_func(http_out_info, env, + axis2_iis_out_transport_info_free); + + return http_out_info; +} + +axis2_char_t * +axis2_iis_out_transport_get_content( + axis2_http_out_transport_info_t * info) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + info_impl = AXIS2_INTF_TO_IMPL(info); + return info_impl->content_type; +} diff --git a/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h new file mode 100644 index 0000000..893ffdf --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h @@ -0,0 +1,61 @@ + +/* + * 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. + */ + +#ifndef AXIS2_IIS_OUT_TRANSPORT_INFO_H +#define AXIS2_IIS_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_iis_out_transport_info.h + * @brief axis2 IIS Out Transport Info + */ + +#include +#include +#ifdef __cplusplus +extern "C" +{ +#endif + + axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_iis_out_transport_info_create( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + + /** + * Free http_out_transport_info passed as void pointer. This will be + * cast into appropriate type and then pass the cast object + * into the http_out_transport_info structure's free method + */ + void AXIS2_CALL + axis2_iis_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + axis2_char_t *axis2_iis_out_transport_get_content( + axis2_http_out_transport_info_t * out_transport_info); + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_IIS_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/IIS/axis2_iis_regedit.js b/src/core/transport/http/server/IIS/axis2_iis_regedit.js new file mode 100644 index 0000000..3889c1e --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_regedit.js @@ -0,0 +1,84 @@ +var WshShell = WScript.CreateObject("WScript.Shell"); + +/* You can change the following values to suite your requirements */ +/* Axis2/C repo location. axis2.xml, modules folder and services folder should be in this dir */ +var axis2c_home = WshShell.CurrentDirectory; +/* Log level. Possible values are trace, error, info, critical, user, debug and warning */ +var log_level = "debug"; +/* Full path to the log file */ +var log_file = axis2c_home + "/logs/axis2.log"; +/* Services URL prefix. This is the folder where services are hosted. Optional */ +var services_url_prefix; +/* Max log file size */ +var max_log_file_size; +/* Axis2 location */ +var axis2_location; + +/* Don't change anything below */ +var axis2c_home_str = "axis2c_home"; +var log_level_str = "log_level"; +var log_file_str = "log_file"; +var services_url_prefix_str = "services_url_prefix"; +var max_log_file_size_str = "max_log_file_size"; +var axis2_location_str = "axis2_location" + +var reg_location = "HKLM\\Software\\Apache Axis2C\\IIS ISAPI Redirector\\" +/* If specified get the values from the command prompt */ +var args = WScript.Arguments; +if (args.length > 0) { + axis2c_home = args.Item(0); + if (axis2c_home) { + log_file = axis2c_home + "/logs/axis2.log"; + } +} +if (args.length > 1) { + log_level = args.Item(1); +} +if (args.length > 2) { + log_file = args.Item(2); +} +if (args.length > 3) { + services_url_prefix = args.Item(3); +} +if (args.length > 4) { + max_log_file_size = args.Item(4); +} +if (args.length > 5) { + axis2_location = args.Item(5); +} +/* Write the axis2c_home entry. This is used by Axis2/C to find the repo location */ +WshShell.RegWrite (reg_location + axis2c_home_str, axis2c_home, "REG_SZ"); +/* Write the log_level registry entry */ +WshShell.RegWrite (reg_location + log_level_str, log_level, "REG_SZ"); +/* Write the log file name */ +WshShell.RegWrite (reg_location + log_file_str, log_file, "REG_SZ"); +/* Write the services url prefix. We write this only if specified */ +try { + var services_url_prefix_key = WshShell.RegRead (reg_location + services_url_prefix_str); + if (services_url_prefix_key) { + WshShell.RegDelete (reg_location + services_url_prefix_str); + } +} catch (e) {} +if (services_url_prefix) { + WshShell.RegWrite (reg_location + services_url_prefix_str, services_url_prefix, "REG_SZ"); +} +/* We write max_log_file_size only if specified */ +try { + var max_log_file_size_key = WshShell.RegRead (reg_location + max_log_file_size_str); + if (max_log_file_size_key) { + WshShell.RegDelete (reg_location + max_log_file_size_str); + } +} catch (e) {} +if (max_log_file_size) { + WshShell.RegWrite (reg_location + max_log_file_size_str, max_log_file_size, "REG_SZ"); +} + +try{ + var axis2_location_key = WshShell.RegRead (reg_location + axis2_location_str); + if (axis2_location_key) { + WshShell.RegDelete (reg_location + axis2_location_str); + } +} catch (e) {} +if (axis2_location) { + WshShell.RegWrite (reg_location + axis2_location_str, axis2_location, "REG_SZ"); +} \ No newline at end of file diff --git a/src/core/transport/http/server/IIS/axis2_iis_stream.c b/src/core/transport/http/server/IIS/axis2_iis_stream.c new file mode 100644 index 0000000..90fc8ba --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_stream.c @@ -0,0 +1,313 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "axis2_iis_stream.h" +#include + +/** + * @brief Stream struct impl + * Streaming mechanisms for iis web server + */ + +typedef struct iis_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + LPEXTENSION_CONTROL_BLOCK lpECB; + unsigned int cur_pos; + void *cur_position; +} iis_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((iis_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +iis_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL iis_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL iis_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL iis_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL iis_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +axutil_stream_t *AXIS2_CALL +axutil_stream_create_iis( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + iis_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, lpECB, NULL); + + stream_impl = (iis_stream_impl_t *)AXIS2_MALLOC(env->allocator, sizeof(iis_stream_impl_t)); + + if(!stream_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + stream_impl->cur_pos = 0; + stream_impl->cur_position = NULL; + stream_impl->lpECB = lpECB; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, iis_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, iis_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, iis_stream_skip); + + return &(stream_impl->stream); +} + +int AXIS2_CALL +iis_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + void *temp_buff = NULL; + unsigned int data_to_read = 0; + DWORD ret_val = TRUE; + DWORD read_bytes = (DWORD)count; + iis_stream_impl_t *stream_impl = NULL; + char *temp = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (iis_stream_impl_t *)stream; + + if(stream_impl->cur_pos == 0) + stream_impl->cur_position = stream_impl->lpECB->lpbData; + + /* If this is the case all the bytes are in the lpECB->lpbData buffer*/ + if(stream_impl->lpECB->cbAvailable == stream_impl->lpECB->cbTotalBytes) + { + /* Cannot read more than in the buffer.*/ + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + data_to_read = (unsigned)count; + else + data_to_read = stream_impl->lpECB->cbTotalBytes - stream_impl->cur_pos; + + memcpy(buffer, stream_impl->cur_position, data_to_read); + temp = (char *)(stream_impl->cur_position); + temp += data_to_read; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += data_to_read; + read_bytes = data_to_read; + } + else if(stream_impl->lpECB->cbAvailable == -1) + { + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, buffer, &read_bytes); + } + else if(stream_impl->lpECB->cbAvailable < stream_impl->lpECB->cbTotalBytes) + { + if(stream_impl->cur_pos > stream_impl->lpECB->cbAvailable) + { + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, buffer, + &read_bytes); + } + else if(stream_impl->cur_pos + count > stream_impl->lpECB->cbAvailable + && stream_impl->cur_pos < stream_impl->lpECB->cbAvailable) + { + int read_length = 0; + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + read_length = (unsigned)count; + else + read_length = stream_impl->lpECB->cbTotalBytes - stream_impl->cur_pos; + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + memcpy(buffer, stream_impl->cur_position, data_to_read); + + read_bytes = stream_impl->cur_pos + read_length - stream_impl->lpECB->cbAvailable; + temp_buff = malloc(read_bytes); + + if(temp_buff == NULL) + return data_to_read; + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + memcpy(((char *)buffer + data_to_read), temp_buff, read_bytes); + read_bytes += data_to_read; + temp = (char *)(stream_impl->cur_position); + temp += read_bytes; + stream_impl->cur_position = temp; + stream_impl->cur_pos += (unsigned)read_bytes; + } + else + { + memcpy(buffer, stream_impl->cur_position, count); + temp = (char *)(stream_impl->cur_position); + temp += count; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += (unsigned)count; + read_bytes = (int)count; + } + } + if(ret_val == TRUE) + return read_bytes; + else + return -1; +} + +int AXIS2_CALL +iis_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + DWORD ret_val = NO_ERROR; + unsigned long bytes_sent = 0; + iis_stream_impl_t *stream_impl = NULL; + axis2_char_t *buffer = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + buffer = (axis2_char_t *)buf; + bytes_sent = (unsigned)strlen(buffer); + + if(count <= 0) + { + return (int)count; + } + /* assume that buffer is not null terminated */ + ret_val = stream_impl->lpECB->WriteClient(stream_impl->lpECB->ConnID, buffer, &bytes_sent, + HSE_IO_SYNC); + if(ret_val == TRUE) + return (int)bytes_sent; + else + return -1; +} + +int AXIS2_CALL +iis_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + DWORD ret_val = TRUE; + iis_stream_impl_t *stream_impl = NULL; + void *temp_buff = NULL; + int data_to_read = 0; + DWORD read_bytes = (DWORD)count; + char *temp = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (iis_stream_impl_t *)stream; + + if(stream_impl->cur_pos == 0) + stream_impl->cur_position = stream_impl->lpECB->lpbData; + + if(stream_impl->lpECB->cbAvailable == stream_impl->lpECB->cbTotalBytes) + { + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + data_to_read = count; + else + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + + temp = (char *)(stream_impl->cur_position); + temp += data_to_read; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += data_to_read; + read_bytes = data_to_read; + } + else if(stream_impl->lpECB->cbAvailable == -1) + { + temp_buff = malloc(read_bytes); + ret_val + = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, &read_bytes); + free(temp_buff); + } + else if(stream_impl->lpECB->cbAvailable < stream_impl->lpECB->cbTotalBytes) + { + if(stream_impl->cur_pos > stream_impl->lpECB->cbAvailable) + { + temp_buff = malloc(read_bytes); + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + free(temp_buff); + } + else if(stream_impl->cur_pos + count > stream_impl->lpECB->cbAvailable + && stream_impl->cur_pos < stream_impl->lpECB->cbAvailable) + { + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + read_bytes = stream_impl->cur_pos + count - stream_impl->lpECB->cbAvailable; + temp_buff = malloc(read_bytes); + + if(temp_buff == NULL) + return data_to_read; + + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + read_bytes += data_to_read; + free(temp_buff); + } + else + { + temp = (char *)(stream_impl->cur_position); + temp += count; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += count; + read_bytes = count; + } + } + if(ret_val == FALSE) + { + return -1; + } + return read_bytes; +} + +int AXIS2_CALL +iis_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +iis_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} diff --git a/src/core/transport/http/server/IIS/axis2_iis_stream.h b/src/core/transport/http/server/IIS/axis2_iis_stream.h new file mode 100644 index 0000000..091edb0 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_stream.h @@ -0,0 +1,45 @@ + +/* + * 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. + */ + +#ifndef IIS_STREAM_H +#define IIS_STREAM_H + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** brief Constructor for creating IIS stream + * @return axutil_stream (IIS) + */ + axutil_stream_t *AXIS2_CALL + axutil_stream_create_iis( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + +#ifdef __cplusplus +} +#endif + +#endif /* IIS_STREAM_H */ diff --git a/src/core/transport/http/server/IIS/axis2_iis_worker.c b/src/core/transport/http/server/IIS/axis2_iis_worker.c new file mode 100644 index 0000000..51a6cc8 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_worker.c @@ -0,0 +1,607 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "axis2_iis_out_transport_info.h" +#include "axis2_iis_stream.h" +#include "axis2_iis_worker.h" + +/* Files from iis */ +#include +#include + +#include "axis2_iis_constants.h" + +#define READ_SIZE 2048 + +axis2_status_t AXIS2_CALL +axis2_worker_get_original_url( + char url[], + char ret_url[]); + +axis2_char_t * AXIS2_CALL +axis2_iis_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream); + +axis2_status_t AXIS2_CALL +start_response( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB, + int status, + const char *reason, + axutil_array_list_t *headers); + +axis2_status_t +write_response( + LPEXTENSION_CONTROL_BLOCK lpECB, + const void *b, + unsigned int l); + +axutil_hash_t * +axis2_iis_worker_read_http_headers( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + +AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + +static struct reasons +{ + axis2_char_t * status_code; + int status_len; +} reasons[] = { { "200 OK", 6 }, { "202 Accepted", 12 }, { "500 Internal Server Error", 25 } }; + +struct axis2_iis_worker +{ + axis2_conf_ctx_t * conf_ctx; +}; + +char * +status_reason( + int status); + +axis2_iis_worker_t * AXIS2_CALL +axis2_iis_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path) +{ + axis2_iis_worker_t * iis_worker = NULL; + + iis_worker = (axis2_iis_worker_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_iis_worker_t)); + if(!iis_worker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + iis_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path); + if(!iis_worker->conf_ctx) + { + axis2_iis_worker_free((axis2_iis_worker_t *)iis_worker, env); + return NULL; + } + return iis_worker; +} + +void AXIS2_CALL +axis2_iis_worker_free( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env) +{ + if(iis_worker->conf_ctx) + { + axis2_conf_ctx_free(iis_worker->conf_ctx, env); + iis_worker->conf_ctx = NULL; + } + AXIS2_FREE(env->allocator, iis_worker); + return; +} + +int AXIS2_CALL +axis2_iis_worker_process_request( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + axis2_conf_ctx_t * conf_ctx = NULL; + axutil_stream_t * out_stream = NULL; + axis2_transport_out_desc_t * out_desc = NULL; + axis2_transport_in_desc_t * in_desc = NULL; + axis2_char_t soap_action[INTERNET_MAX_URL_LENGTH]; + axis2_char_t original_url[INTERNET_MAX_URL_LENGTH]; + axis2_char_t req_url[INTERNET_MAX_URL_LENGTH]; + DWORD cbSize = 0; + CHAR server_name[MAX_SERVERNAME]; + axis2_char_t port[MAX_TCP_PORT_LEN]; + axis2_char_t redirect_url[INTERNET_MAX_PATH_LENGTH]; + axis2_char_t accept_language[INTERNET_MAX_PATH_LENGTH]; + axutil_hash_t *headers = NULL; + axis2_char_t peer_ip[50]; + axis2_char_t accept_header[INTERNET_MAX_URL_LENGTH]; + axis2_char_t accept_charset[INTERNET_MAX_URL_LENGTH]; + /*axutil_property_t *peer_property = NULL;*/ + + axis2_http_header_t *content_type_header = NULL; + axis2_http_header_t *content_length_header = NULL; + + /* New Code variables */ + axis2_http_transport_in_t request; + axis2_http_transport_out_t response; + + /* initialize tranport in structure */ + axis2_http_transport_utils_transport_in_init(&request, env); + + /* initialize tranport out structure */ + axis2_http_transport_utils_transport_out_init(&response, env); + + soap_action[0] = '\0'; + + /*Check the parameters*/ + if(!lpECB) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_INVALID_NULL_PARAM); + return AXIS2_FAILURE; + } + conf_ctx = iis_worker->conf_ctx; + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "SERVER_NAME", server_name, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server name from IIS."); + return AXIS2_FAILURE; + } + cbSize = MAX_TCP_PORT_LEN; + if(lpECB->GetServerVariable(lpECB->ConnID, "SERVER_PORT", port, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server port from IIS."); + return AXIS2_FAILURE; + } + request.svr_port = port; + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_URL", redirect_url, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server port from IIS."); + return AXIS2_FAILURE; + } + + /* We have a mapped URL only when the server version is 5 or less than that. */ + if(server_version <= 5) + { + axis2_worker_get_original_url(redirect_url, original_url); + /* create the url using the above variables */ + sprintf(req_url, "%s%s%s%s%s", "http://", server_name, ":", port, original_url); + } + else + { + sprintf(req_url, "%s%s%s%s%s", "http://", server_name, ":", port, redirect_url); + } + /* Set the request url */ + request.request_uri = req_url; + + out_stream = axutil_stream_create_basic(env); + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(iis_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(iis_worker->conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + + /* Create the in message context */ + request.msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(request.msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_transport_out_stream(request.msg_ctx, env, out_stream); + + /* Get the SOAPAction Header */ + cbSize = INTERNET_MAX_URL_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_SOAPAction", soap_action, &cbSize)) + { + request.soap_action = soap_action; + } + + /* Create the in stream */ + request.in_stream = axutil_stream_create_iis(env, lpECB); + if(!request.in_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in creating input stream."); + return AXIS2_FAILURE; + } + + /* Get the Remote Adrress */ + if(lpECB->GetServerVariable(lpECB->ConnID, "REMOTE_ADDR", peer_ip, &cbSize)) + { + request.remote_ip = peer_ip; + } + + /* Set the http headers into the message context */ + headers = axis2_iis_worker_read_http_headers(env, lpECB); + if(axis2_msg_ctx_set_transport_headers(request.msg_ctx, env, headers) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Error occured in setting transport headers."); + } + /* Set the content length */ + request.content_length = lpECB->cbTotalBytes; + /* Set the HTTP method */ + if(axutil_strcasecmp(lpECB->lpszMethod, "POST") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_POST; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "GET") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_GET; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "HEAD") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_HEAD; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "PUT") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_PUT; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "DELETE") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_DELETE; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Unsupported HTTP Method."); + return AXIS2_FAILURE; + } + /* Set the URL prefix. axis2_request_url_prefix is a global variable set at the init time */ + request.request_url_prefix = axis2_request_url_prefix; + /* Create the transport out info */ + request.out_transport_info = axis2_iis_out_transport_info_create(env, lpECB); + /* Set the content type */ + request.content_type = lpECB->lpszContentType; + + /* Get accept headaer */ + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept", accept_header, &cbSize)) + { + request.accept_header = accept_header; + } + + /* Get the accept langauge */ + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept-Language", accept_language, &cbSize)) + { + request.accept_language_header = accept_language; + } + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept-Charset", accept_charset, &cbSize)) + { + request.accept_charset_header = accept_charset; + } + + /* Now we have set everything. We can call process method to process the request */ + if(axis2_http_transport_utils_process_request(env, conf_ctx, &request, &response) + == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + + /* Write the response */ + if(response.response_data && response.response_data_length > 0) + { + axis2_char_t content_length_str[16] = { 0 }; + axis2_bool_t is_out_headers_created = AXIS2_FALSE; + if(!response.output_headers) + { + response.output_headers = axutil_array_list_create(env, 2); + is_out_headers_created = AXIS2_TRUE; + } + sprintf(content_length_str, "%d", response.response_data_length); + if(!response.content_type) + { + content_type_header = axis2_http_header_create(env, "Content-Type", + axis2_iis_out_transport_get_content(request.out_transport_info)); + } + else + { + content_type_header = axis2_http_header_create(env, "Content-Type", + response.content_type); + } + content_length_header = axis2_http_header_create(env, "Content-Length", content_length_str); + axutil_array_list_add(response.output_headers, env, content_length_header); + axutil_array_list_add(response.output_headers, env, content_type_header); + /* Write the headers */ + start_response(env, lpECB, response.http_status_code, response.http_status_code_name, + response.output_headers); + /* Write the response body */ + if(write_response(lpECB, response.response_data, response.response_data_length) + == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Writing data to IIS"); + return AXIS2_FAILURE; + } + if(is_out_headers_created) + { + if(content_length_header) + { + axis2_http_header_free(content_length_header, env); + } + if(content_type_header) + { + axis2_http_header_free(content_type_header, env); + } + axutil_array_list_free(response.output_headers, env); + } + } + else + { + /* If we don't have a body we should write the HTTP headers */ + start_response(env, lpECB, response.http_status_code, response.http_status_code_name, + response.output_headers); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Response is NULL"); + } + + /* Do some cleaning */ + axis2_http_transport_utils_transport_in_uninit(&request, env); + axis2_http_transport_utils_transport_out_uninit(&response, env); + return AXIS2_SUCCESS; +} + +axis2_status_t +write_response( + LPEXTENSION_CONTROL_BLOCK lpECB, + const void *b, + unsigned int l) +{ + if(lpECB && b) + { + if(l) + { + unsigned int written = 0; + char *buf = (char *)b; + /* If couldn't write the data at onece try again until all the data is written.*/ + while(written < l) + { + DWORD try_to_write = l - written; + if(!lpECB-> WriteClient(lpECB->ConnID, buf + written, &try_to_write, 0)) + { + return AXIS2_FAILURE; + } + written += try_to_write; + } + } + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +start_response( + const axutil_env_t *env, + LPEXTENSION_CONTROL_BLOCK lpECB, + int status, + const char *reason, + axutil_array_list_t *headers) +{ + static char crlf[3] = { (char)13, (char)10, '\0' }; + unsigned int num_of_headers = 0; + + if(status < 100 || status > 1000) + { + return AXIS2_FAILURE; + } + if(lpECB) + { + size_t len_of_status; + char *status_str; + char *headers_str; + + /* + * Create the status line + */ + if(reason) + { + status_str = (char *)_alloca((6 + strlen(reason)) * sizeof(char)); + sprintf(status_str, "%d %s", status, reason); + len_of_status = strlen(status_str); + } + else + { + switch(status) + { + case 200: + status_str = reasons[0].status_code; + len_of_status = reasons[0].status_len; + break; + case 202: + status_str = reasons[1].status_code; + len_of_status = reasons[1].status_len; + break; + case 500: + status_str = reasons[2].status_code; + len_of_status = reasons[2].status_len; + break; + default: + status_str = reasons[0].status_code; + len_of_status = reasons[0].status_len; + break; + } + } + /* + * Create response headers string + */ + if(headers && (num_of_headers = axutil_array_list_size(headers, env)) > 0) + { + size_t i, len_of_headers; + axis2_http_header_t *header = NULL; + for(i = 0, len_of_headers = 0; i < num_of_headers; i++) + { + header = axutil_array_list_get(headers, env, (int)i); + len_of_headers += strlen(axis2_http_header_get_name(header, env)); + len_of_headers += strlen(axis2_http_header_get_value(header, env)); + len_of_headers += 4; /* extra for colon, space and crlf */ + } + len_of_headers += 3; /* crlf and terminating null char */ + headers_str = (char *)_alloca(len_of_headers * sizeof(char)); + headers_str[0] = '\0'; + for(i = 0; i < num_of_headers; i++) + { + header = axutil_array_list_get(headers, env, (int)i); + strcat(headers_str, axis2_http_header_get_name(header, env)); + strcat(headers_str, ": "); + strcat(headers_str, axis2_http_header_get_value(header, env)); + strcat(headers_str, "\r\n"); + } + strcat(headers_str, "\r\n"); + } + else + { + headers_str = crlf; + } + if(!lpECB-> ServerSupportFunction(lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER, status_str, + (LPDWORD) & len_of_status, (LPDWORD)headers_str)) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_worker_get_original_url( + char url[], + char ret_url[]) +{ + extern axis2_char_t *axis2_location; + strcpy(ret_url, axis2_location); + strcat(ret_url, &url[25]); + return URI_MATCHED; +} + +axis2_char_t * AXIS2_CALL +axis2_iis_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream) +{ + axutil_stream_t * tmp_stream = NULL; + int return_size = -1; + axis2_char_t * buffer = NULL; + axis2_bool_t loop_state = AXIS2_TRUE; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, stream, NULL); + + tmp_stream = axutil_stream_create_basic(env); + while(loop_state) + { + int read = 0; + int write = 0; + char buf[READ_SIZE]; + + read = axutil_stream_read(stream, env, buf, READ_SIZE); + if(read < 0) + { + break; + } + write = axutil_stream_write(tmp_stream, env, buf, read); + if(read < (READ_SIZE - 1)) + { + break; + } + } + return_size = axutil_stream_get_len(tmp_stream, env); + if(return_size > 0) + { + buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 2)); + return_size = axutil_stream_read(tmp_stream, env, buffer, return_size + 1); + buffer[return_size + 1] = '\0'; + } + axutil_stream_free(tmp_stream, env); + return buffer; +} + +/** Read all HTTP headers. + */ +axutil_hash_t * +axis2_iis_worker_read_http_headers( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + const char szHTTP_[] = "HTTP_"; + char szBuffer[4096]; + DWORD dwBufferSize = sizeof szBuffer; + axutil_hash_t *headers = NULL; + axis2_http_header_t* http_header = NULL; + + BOOL bGet = lpECB->GetServerVariable(lpECB->ConnID, "ALL_HTTP", szBuffer, &dwBufferSize); + if(bGet) + { + /* Find lines, split key/data pair and write them as output */ + LPTSTR pOpts = NULL; + LPTSTR pEnd = NULL; + LPTSTR pChar = NULL; + char szTmpBuf[512]; + char szTmpName[256]; + + headers = axutil_hash_make(env); + szTmpBuf[0] = 0; + for(pChar = szBuffer; '\0' != *pChar;) + { + if(*pChar == '\r' || *pChar == '\n') + { + pChar++; + continue; + } + pOpts = strchr(pChar, ':');/* findseparator */ + if(pOpts && *pOpts) + { + pEnd = pOpts; + while(*pEnd && *pEnd != '\r' && *pEnd != '\n') + { + pEnd++; + } + *pOpts = '\0'; /* split the strings */ + *pEnd = '\0'; + if(0 == strncmp(pChar, szHTTP_, strlen(szHTTP_))) + { + pChar += strlen(szHTTP_); + } + strcpy(szTmpName, pChar); + axutil_string_replace(szTmpName, '_', '-'); + http_header = axis2_http_header_create(env, szTmpName, pOpts + 1); + axutil_hash_set(headers, axutil_strdup(env, szTmpName), AXIS2_HASH_KEY_STRING, + http_header); + pChar = pEnd + 1; + } + } + } + else + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "axis2_iis_worker_read_http_headers: no http headers"); + } + return headers; +} + diff --git a/src/core/transport/http/server/IIS/axis2_iis_worker.h b/src/core/transport/http/server/IIS/axis2_iis_worker.h new file mode 100644 index 0000000..f9b6292 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_worker.h @@ -0,0 +1,62 @@ + +/* + * 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. + */ + +#ifndef AXIS2_APACHE2_WORKER_H +#define AXIS2_APACHE2_WORKER_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ + +#endif /* + */ + +typedef struct axis2_iis_worker axis2_iis_worker_t; + +int server_version; + +int AXIS2_CALL + axis2_iis_worker_process_request( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env, + void *r); + + +void AXIS2_CALL + axis2_iis_worker_free( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env); + + +axis2_iis_worker_t * AXIS2_CALL + axis2_iis_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path); + + +#ifdef __cplusplus +} +#endif /* + */ + +#endif /* AXIS2_IIS_WORKER_H */ diff --git a/src/core/transport/http/server/IIS/axis2_isapi_plugin.c b/src/core/transport/http/server/IIS/axis2_isapi_plugin.c new file mode 100644 index 0000000..eccfd1c --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_isapi_plugin.c @@ -0,0 +1,476 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "axis2_iis_constants.h" +#include "axis2_iis_worker.h" + +/* Axis headers */ +#include +#include +#include +#include +#include + +#ifndef _WIN32_WINNT +#define _WIN32_WINNT 0x0500 +#endif + +#define AXIS2_IIS_LOG_FILE_TAG "log_file" +#define AXIS2_IIS_LOG_LEVEL_TAG "log_level" +#define AXIS2_IIS_REPO_PATH_TAG "axis2c_home" +#define AXIS2_IIS_EXTENSION_URI_TAG "extension_uri" +#define AXIS2_IIS_REDIRECT_WORD_TAG "redirect_uri" +#define AXIS2_IIS_AXIS2_LOCATION "axis2_location" +#define AXIS2_IIS_SERVICE_URL_PREFIX "services_url_prefix" + +#define AXIS2_IIS_LOG_TRACE_VERB "trace" +#define AXIS2_IIS_LOG_ERROR_VERB "error" +#define AXIS2_IIS_LOG_INFO_VERB "info" +#define AXIS2_IIS_LOG_USER_VERB "user" +#define AXIS2_IIS_LOG_CRITICAL_VERB "critical" +#define AXIS2_IIS_LOG_WARN_VERB "warning" +#define AXIS2_IIS_LOG_DEBUG_VERB "debug" + +#define MAX_FILE_PATH 256 +#define REGISTRY_LOCATION "Software\\Apache Axis2c\\IIS ISAPI Redirector" + +static int is_inited = FALSE; +static axis2_iis_worker_t *axis2_worker = NULL; +static const axutil_env_t *axutil_env = NULL; + +/* Configuration parameters */ +axis2_char_t *axis2_location = "/axis2"; +static axis2_char_t *axis2_service_url_prefix= "/services"; +static axis2_char_t repo_path[MAX_FILE_PATH]; +static axis2_char_t log_file[MAX_FILE_PATH]; +static axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_CRITICAL; + +/* Path variables */ +static char szOriginalPath[_MAX_PATH + 1]; +static char szPath[_MAX_PATH + 1]; + +axis2_char_t general_error[] = "\r\n" + " An IIS server error occurred. \r\n" + "

An IIS server error occurred

\r\n" + "
\r\n" + "An error occurred in IIS while processing this request."; + +axis2_char_t initializing_error[] = "\r\n" + " An IIS server error occurred. \r\n" + "

An IIS server error occurred

\r\n" + "
\r\n" + "An error occurred while initilizing Axis2/C."; + + +/* + * This is a utility functipn for reading configuration data from the registery. + */ +static axis2_status_t AXIS2_CALL +read_registery_init_data(); + +/* + * Utility function for reading + */ +static axis2_status_t AXIS2_CALL get_registry_config_parameter( + HKEY hkey, + const char *tag, + char *b, + DWORD sz); + +/* + * Parse the given string and return the corresponding log_level + */ +axutil_log_levels_t AXIS2_CALL axis2_iis_parse_log_level(char level[]); + +/* + * Initialize axis. This function is called in the begining of the module loading. + * It initializes the axis by reading values from the configuration and creating the + * required structures for the axis2c +*/ +axis2_status_t AXIS2_CALL init_axis2(); + +/* + * This is the function to be called after the processing + * is over for non Axis2 requets + */ +VOID +WINAPI +ExecUrlCompletion ( + EXTENSION_CONTROL_BLOCK * pecb, + PVOID pContext, + DWORD cbIO, + DWORD dwError + ); + +/* + * If somethign went wrong in the IIS server when + * we are proccessing we send this + */ +BOOL +send_error( + EXTENSION_CONTROL_BLOCK * pecb, + CHAR error[]); + +axis2_status_t AXIS2_CALL init_axis2(); + +BOOL +WINAPI +GetExtensionVersion(HSE_VERSION_INFO * pVer) +{ + pVer->dwExtensionVersion = MAKELONG( HSE_VERSION_MINOR, + HSE_VERSION_MAJOR); + strncpy( pVer->lpszExtensionDesc, + "WildCardMap Sample ISAPI Extension", HSE_MAX_EXT_DLL_NAME_LEN ); + + pVer->lpszExtensionDesc[HSE_MAX_EXT_DLL_NAME_LEN-1] = '\0'; + server_version = 5; + return TRUE; +} + +DWORD +WINAPI +HttpExtensionProc(EXTENSION_CONTROL_BLOCK * pecb) + +{ + HSE_EXEC_URL_INFO ExecUrlInfo; + DWORD cbData = INTERNET_MAX_URL_LENGTH; + char url[INTERNET_MAX_URL_LENGTH]; + axis2_bool_t is_for_us = AXIS2_TRUE; + + /* Get the URL */ + if ( pecb->GetServerVariable( pecb->ConnID, + "URL", + url, + &cbData ) == FALSE ) + { + return HSE_STATUS_ERROR; + } + + if (!is_inited) + { + DWORD dwBufferSize = 0; + axis2_char_t server_software[256]; + axis2_char_t *version = NULL; + + ZeroMemory(szOriginalPath, sizeof szOriginalPath); + dwBufferSize = sizeof szOriginalPath; + +#if _WIN32_WINNT >= 0x0502 + GetDllDirectory( dwBufferSize, szOriginalPath ); +#else + GetCurrentDirectory( dwBufferSize, szOriginalPath ); +#endif + ZeroMemory(szPath, sizeof szPath); + dwBufferSize = sizeof szPath; + /* Get the current physical paht */ + if (pecb->GetServerVariable(pecb->ConnID, "APPL_PHYSICAL_PATH", szPath, &dwBufferSize) == FALSE) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } + /* Retrieve the server version */ + dwBufferSize = 32; + if (pecb->GetServerVariable(pecb->ConnID, "SERVER_SOFTWARE", server_software, &dwBufferSize) == FALSE) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } + version = axutil_strchr(server_software, '/'); + if (version) + { + server_version = atoi(version + 1); + } +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szPath ); +#else + SetCurrentDirectory( szPath ); +#endif + /* If we haven't initialized axis2/c before initialization failed */ + if (AXIS2_FAILURE == init_axis2()) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szOriginalPath ); +#else + SetCurrentDirectory( szOriginalPath ); +#endif + } + + /* Check weather we have a request for Axis2/C */ + if (server_version >= 6 && strlen(url) >= strlen(axis2_location)) + { + int i = 0; + is_for_us = AXIS2_TRUE; + while (axis2_location[i] != '\0') + { + if (axis2_location[i] != (url)[i]) { + is_for_us = AXIS2_FALSE; + break; + } + i++; + } + if (url[i] != '/' && url[i] != '\0') + { + is_for_us = AXIS2_FALSE; + } + } + + if (is_for_us) + { + /* Windows cannot find the correct dlls unless the path is set*/ +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szPath ); +#else + SetCurrentDirectory( szPath ); +#endif + pecb->dwHttpStatusCode = HTTP_INTERNAL_SERVER_ERROR; + /* We are sure that worker is not NULL since it is NULL init_axis2 would have failed */ + axis2_iis_worker_process_request(axis2_worker, axutil_env, pecb); + + /* Windows cannot find the correct dlls unless the dir is set + but we want to reset to previous dir after the load */ +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szOriginalPath ); +#else + SetCurrentDirectory( szOriginalPath ); +#endif + return HSE_STATUS_SUCCESS; + } + else if (server_version >= 6) + { + /* For IIS 5.1 or earlier this code is never executed. Since the URL is + redirected to Axis2/C by the Filter */ + + /* If not for Axis2/C let the request go to who ever wants it */ + ExecUrlInfo.pszUrl = NULL; /* Use original request URL */ + ExecUrlInfo.pszMethod = NULL; /* Use original request method */ + ExecUrlInfo.pszChildHeaders = NULL; /* Use original request headers */ + ExecUrlInfo.pUserInfo = NULL; /* Use original request user info */ + ExecUrlInfo.pEntity = NULL; /* Use original request entity */ + + /* Provent recursion */ + ExecUrlInfo.dwExecUrlFlags = HSE_EXEC_URL_IGNORE_CURRENT_INTERCEPTOR; + + /* Associate the completion routine and the current URL with this request. */ + if ( pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_IO_COMPLETION, + ExecUrlCompletion, + NULL, + NULL) == FALSE ) + { + return HSE_STATUS_ERROR; + } + + /* Ok, now that everything is set up, let's call the child request */ + if ( pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_EXEC_URL, + &ExecUrlInfo, + NULL, + NULL ) == FALSE ) + { + return HSE_STATUS_ERROR; + } + /* Return pending and let the completion clean up */ + return HSE_STATUS_PENDING; + } + return HSE_STATUS_ERROR; +} + +VOID +WINAPI +ExecUrlCompletion ( + EXTENSION_CONTROL_BLOCK * pecb, + PVOID pContext, + DWORD cbIO, + DWORD dwError + ) +{ + /* We are done so notify */ + pecb->ServerSupportFunction( + pecb->ConnID, + HSE_REQ_DONE_WITH_SESSION, + NULL, + NULL, + NULL); +} + + +BOOL +send_error( + EXTENSION_CONTROL_BLOCK * pecb, + axis2_char_t error[]) +{ + DWORD cbData; + pecb->dwHttpStatusCode = 500; + /* Send headers and response */ + pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_SEND_RESPONSE_HEADER, + "500 Server Error", + NULL, + (LPDWORD)"Content-Type: text/html\r\n\r\n" ); + + cbData = axutil_strlen( error ); + return pecb->WriteClient( pecb->ConnID, + error, + &cbData, + HSE_IO_SYNC ); +} + +axis2_status_t AXIS2_CALL read_registery_init_data() +{ + long rc = 0; + axis2_status_t ok = TRUE; + char tmpbuf[INTERNET_MAX_URL_LENGTH]; + HKEY hkey; + AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + + rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGISTRY_LOCATION, (DWORD) 0, KEY_READ, &hkey); + if (ERROR_SUCCESS != rc) + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_REPO_PATH_TAG, tmpbuf, sizeof(repo_path))) + { + strcpy(repo_path, tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_LOG_FILE_TAG, tmpbuf, sizeof(log_file))) + { + strcpy(log_file, tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_LOG_LEVEL_TAG, tmpbuf, sizeof(tmpbuf))) + { + log_level = axis2_iis_parse_log_level(tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_SERVICE_URL_PREFIX, tmpbuf, sizeof(tmpbuf))) + { + axis2_request_url_prefix = _strdup(tmpbuf); + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_AXIS2_LOCATION, tmpbuf, sizeof(tmpbuf))) + { + axis2_location = _strdup(tmpbuf); + } + RegCloseKey(hkey); + return ok; +} + +axutil_log_levels_t AXIS2_CALL +axis2_iis_parse_log_level(char level[]) +{ + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_TRACE_VERB)) + { + return AXIS2_LOG_LEVEL_TRACE; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_DEBUG_VERB)) + { + return AXIS2_LOG_LEVEL_DEBUG; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_INFO_VERB)) + { + return AXIS2_LOG_LEVEL_INFO; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_USER_VERB)) + { + return AXIS2_LOG_LEVEL_USER; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_WARN_VERB)) + { + return AXIS2_LOG_LEVEL_WARNING; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_ERROR_VERB)) + { + return AXIS2_LOG_LEVEL_ERROR; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_CRITICAL_VERB)) + { + return AXIS2_LOG_LEVEL_CRITICAL; + } + return AXIS2_LOG_LEVEL_DEBUG; +} + +axis2_status_t AXIS2_CALL +get_registry_config_parameter(HKEY hkey, const char *tag, char *b, DWORD sz) +{ + DWORD type = 0; + LONG lrc; + + lrc = RegQueryValueEx(hkey, tag, (LPDWORD) 0, &type, (LPBYTE) b, &sz); + if ((ERROR_SUCCESS != lrc) || (type != REG_SZ)) + { + return FALSE; + } + b[sz] = '\0'; + return TRUE; +} + +/** + * This method initializes the axis2 engine. All the required variables are set to + * their initial values in this method. +*/ +axis2_status_t AXIS2_CALL init_axis2() +{ + /* + * These are the varibles required to initialize axis. + */ + axis2_status_t status = FALSE; + /* We need to init xml readers before we go into threaded env */ + if (!is_inited) + { + axiom_xml_reader_init(); + status = read_registery_init_data(); + if (status == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + axutil_error_init(); + /* Initialize the environement */ + axutil_env = axutil_env_create_all(log_file, log_level); + if (!axutil_env) + { + return AXIS2_FAILURE; + } + axis2_worker = axis2_iis_worker_create(axutil_env, repo_path); + if (!axis2_worker) + { + return AXIS2_FAILURE; + } + is_inited = AXIS2_TRUE; + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} diff --git a/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c b/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c new file mode 100644 index 0000000..49cd6d9 --- /dev/null +++ b/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c @@ -0,0 +1,153 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "..\\axis2_iis_constants.h" + +#define REGISTRY_LOC "Software\\Apache Axis2c\\IIS ISAPI Redirector" +#define AXIS2_IIS_AXIS2_LOC "axis2_location" +static char *axis2_loc = "/axis2"; + +static axis2_char_t redirect_word[INTERNET_MAX_URL_LENGTH] = "/axis2/mod_axis2_IIS.dll\?"; +/* + * Search a given uri to find weather it matches a uri for the axis2 + * The uri format for axis2 is of the form + * scheme://server:port/axis2/other_parts + * This function search a give uri for the /axis2/. If a match + * is found it will replace the /axis2 part of the url with /axis2/mod_iis.dll? + */ +axis2_bool_t AXIS2_CALL +get_extension_url( + char url[], + char ret_url[]); + +/* + * This function is called by the IIS server at the server + * initialization. So this is the ideal plcae for initializing + * axis2c. + */ +BOOL WINAPI +GetFilterVersion( + PHTTP_FILTER_VERSION pVer) +{ + DWORD type = 0, size = 0; + LONG lrc = 0; + char tmpbuf[INTERNET_MAX_URL_LENGTH]; + HKEY hkey; + ULONG http_filter_revision = HTTP_FILTER_REVISION; + pVer->dwFilterVersion = pVer->dwServerFilterVersion; + if(pVer->dwFilterVersion > http_filter_revision) + { + pVer->dwFilterVersion = http_filter_revision; + } + + /* + Receive notifictions when + 1. Server preprocessed the headers. + 2. Log + 3. All the request coming in secure and none secure ports. + */ + pVer->dwFlags = (SF_NOTIFY_ORDER_HIGH | SF_NOTIFY_PREPROC_HEADERS | SF_NOTIFY_SECURE_PORT + | SF_NOTIFY_NONSECURE_PORT | SF_NOTIFY_AUTH_COMPLETE); + + /* Give a short discription about the module.*/ + strcpy(pVer->lpszFilterDesc, "axis2c filter"); + /* Get the axis2 location from the registry configuration */ + lrc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGISTRY_LOC, (DWORD)0, KEY_READ, &hkey); + if(ERROR_SUCCESS != lrc) + { + return FALSE; + } + size = INTERNET_MAX_URL_LENGTH; + lrc = RegQueryValueEx(hkey, AXIS2_IIS_AXIS2_LOC, (LPDWORD)0, &type, (LPBYTE)tmpbuf, &size); + if((ERROR_SUCCESS == lrc) && (type == REG_SZ)) + { + tmpbuf[size] = '\0'; + axis2_loc = _strdup(tmpbuf); + } + RegCloseKey(hkey); + return TRUE; +} + +/* + When a notification happens this function is called by the IIS. + */ +DWORD WINAPI +HttpFilterProc( + PHTTP_FILTER_CONTEXT pfc, + DWORD notificationType, + LPVOID pvNotification) +{ + DWORD bufferLength = INTERNET_MAX_URL_LENGTH; + char url[INTERNET_MAX_URL_LENGTH]; + char modified_url[INTERNET_MAX_URL_LENGTH]; + + if(notificationType == SF_NOTIFY_PREPROC_HEADERS) + { + pfc->GetServerVariable(pfc, "HTTP_URL", url, &bufferLength); + if(get_extension_url(url, modified_url)) + { + ((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->SetHeader(pfc, "url", modified_url); + return SF_STATUS_REQ_HANDLED_NOTIFICATION; + } + } + return SF_STATUS_REQ_NEXT_NOTIFICATION; +} + +axis2_bool_t AXIS2_CALL +get_extension_url( + char url[], + char ret_url[]) +{ + axis2_bool_t is_for_us = AXIS2_FALSE; + int i = 0; + /* Should contain "/axis2/"*/ + ret_url[0] = '\0'; + if(strlen(url) >= strlen(axis2_loc)) + { + is_for_us = AXIS2_TRUE; + while(axis2_loc[i] != '\0') + { + if(axis2_loc[i] != (url)[i]) + { + is_for_us = AXIS2_FALSE; + break; + } + i++; + } + if(url[i] != '/' && url[i] != '\0') + { + is_for_us = AXIS2_FALSE; + } + } + if(is_for_us) + { + strcpy(ret_url, redirect_word); + strcat(ret_url, &url[i]); + } + return is_for_us; +} diff --git a/src/core/transport/http/server/IIS/mod_axis2.def b/src/core/transport/http/server/IIS/mod_axis2.def new file mode 100644 index 0000000..22205e7 --- /dev/null +++ b/src/core/transport/http/server/IIS/mod_axis2.def @@ -0,0 +1,7 @@ +LIBRARY "mod_axis2_IIS" + +EXPORTS + GetExtensionVersion + HttpExtensionProc + GetFilterVersion + HttpFilterProc \ No newline at end of file diff --git a/src/core/transport/http/server/Makefile.am b/src/core/transport/http/server/Makefile.am new file mode 100644 index 0000000..07cf1e9 --- /dev/null +++ b/src/core/transport/http/server/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS=@APACHE2BUILD@ simple_axis2_server ${CGI_DIR} +EXTRA_DIST=IIS CGI diff --git a/src/core/transport/http/server/apache2/Makefile.am b/src/core/transport/http/server/apache2/Makefile.am new file mode 100644 index 0000000..d5f6bd8 --- /dev/null +++ b/src/core/transport/http/server/apache2/Makefile.am @@ -0,0 +1,40 @@ +lib_LTLIBRARIES = libmod_axis2.la +libmod_axis2_la_SOURCES = mod_axis2.c\ + apache2_stream.c\ + apache2_out_transport_info.c\ + apache2_worker.c + +AM_CFLAGS = -DLINUX=2 -D_REENTRANT -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -D_SVID_SOURCE -D_GNU_SOURCE + +libmod_axis2_la_LIBADD = $(LDFLAGS) \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la\ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la\ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la\ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la\ + -lpthread + +libmod_axis2_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/http \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/axiom/include\ + -I$(top_builddir)/util/include\ + @APACHE2INC@ \ + @APRINC@ + +EXTRA_DIST=axis2_apache2_worker.h apache2_stream.h axis2_apache2_out_transport_info.h + + + + + + + + diff --git a/src/core/transport/http/server/apache2/apache2_out_transport_info.c b/src/core/transport/http/server/apache2/apache2_out_transport_info.c new file mode 100644 index 0000000..9deaa56 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_out_transport_info.c @@ -0,0 +1,191 @@ +/* + * 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_apache2_out_transport_info.h" +#include +#include +#include +#include + +typedef struct axis2_apache2_out_transport_info +{ + axis2_http_out_transport_info_t out_transport_info; + request_rec *request; + axis2_char_t *encoding; +} axis2_apache2_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_apache2_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_apache2_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_free( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env) +{ + axis2_apache2_out_transport_info_t *info = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + info->request = NULL; /* request doesn't belong to info */ + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + info->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_apache2_out_transport_info_t *info = NULL; + + axis2_char_t *tmp1 = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + if(info->encoding) + { + + tmp1 = axutil_stracat(env, content_type, ";charset="); + tmp2 = axutil_stracat(env, tmp1, info->encoding); + info->request->content_type = apr_pstrdup(info->request->pool, tmp2); + AXIS2_FREE(env->allocator, tmp1); + AXIS2_FREE(env->allocator, tmp2); + } + else + { + info->request->content_type = apr_pstrdup(info->request->pool, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + } + info->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_cookie_header( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * cookie_header) +{ + axis2_apache2_out_transport_info_t *info = NULL; + + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, cookie_header, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + apr_table_set(info->request->headers_out, AXIS2_HTTP_HEADER_SET_COOKIE, cookie_header); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_session( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value) +{ + axis2_apache2_out_transport_info_t *info = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, session_id, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, session_value, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + status = env->set_session_fn(info->request, session_id, session_value); + + return status; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_apache2_out_transport_info_create( + const axutil_env_t * env, + request_rec * request) +{ + axis2_apache2_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *out_transport_info = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_apache2_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_apache2_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->request = request; + info->encoding = NULL; + + out_transport_info = &(info->out_transport_info); + out_transport_info->encoding = NULL; + out_transport_info->response = NULL; + + axis2_http_out_transport_info_set_char_encoding_func(out_transport_info, env, + axis2_apache_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_content_type_func(out_transport_info, env, + axis2_apache_out_transport_info_set_content_type); + axis2_http_out_transport_info_set_cookie_header_func(out_transport_info, env, + axis2_apache_out_transport_info_set_cookie_header); + axis2_http_out_transport_info_set_session_func(out_transport_info, env, + axis2_apache_out_transport_info_set_session); + + return out_transport_info; +} + + diff --git a/src/core/transport/http/server/apache2/apache2_stream.c b/src/core/transport/http/server/apache2/apache2_stream.c new file mode 100644 index 0000000..5e189a7 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_stream.c @@ -0,0 +1,292 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "apache2_stream.h" +#include + +typedef struct apache2_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + request_rec *request; +} apache2_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((apache2_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +apache2_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL apache2_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL apache2_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +static int AXIS2_CALL +apache2_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL apache2_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +static apr_size_t +apache2_ap_get_client_block( + request_rec *r, + char* buffer, + apr_size_t bufsiz); + +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axutil_stream_create_apache2( + const axutil_env_t * env, + request_rec * request) +{ + apache2_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, request, NULL); + + stream_impl = (apache2_stream_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(apache2_stream_impl_t)); + + if(!stream_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset(&(stream_impl->stream), 0, sizeof(axutil_stream_t)); + + stream_impl->request = request; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, apache2_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, apache2_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, apache2_stream_skip); + + return &(stream_impl->stream); +} + +int AXIS2_CALL +apache2_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + apache2_stream_impl_t *stream_impl = NULL; + size_t read = 0; + size_t len = 0; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + while(count - len > 0) + { + read = apache2_ap_get_client_block(stream_impl->request, (char *) buffer + len, + count - len); + if(read > 0) + { + len += read; + } + else + { + break; + } + } + + return (int)len; + /* We are sure that the difference lies within the int range */ +} + +int AXIS2_CALL +apache2_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + apache2_stream_impl_t *stream_impl = NULL; + axis2_char_t *buffer = NULL; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + buffer = (axis2_char_t *)buf; + if(count <= 0) + { + return (int)count; + /* We are sure that the difference lies within the int range */ + } + /* assume that buffer is not null terminated */ + return ap_rwrite(buffer, (int)count, stream_impl->request); + /* We are sure that the difference lies within the int range */ +} + +static int AXIS2_CALL +apache2_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + apache2_stream_impl_t *stream_impl = NULL; + axis2_char_t *tmp_buffer = NULL; + apr_size_t len = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + tmp_buffer = AXIS2_MALLOC(env->allocator, count * sizeof(axis2_char_t)); + if(tmp_buffer == NULL) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return -1; + } + len = apache2_ap_get_client_block(stream_impl->request, tmp_buffer, count); + AXIS2_FREE(env->allocator, tmp_buffer); + return (int)len; + +} + +int AXIS2_CALL +apache2_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +apache2_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} + +/* + * This is a re-write of get_client_block found in http_filters.c in httpd + * which does not work when dealing with compressed payloads (or any other input + * filters that could potentially return 0 bytes of filtered data and not be at + * the end of the stream). + * get_client_block is called in a loop to get the request message body. + * This is quite simple if the client includes a content-length + * (the normal case), but gets messy if the body is chunked. Note that + * r->remaining is used to maintain state across calls and that + * r->read_length is the total number of bytes given to the caller + * across all invocations. It is messy because we have to be careful not + * to read past the data provided by the client, since these reads block. + * Returns 0 on End-of-body, -1 on error or premature chunk end. + * + */ +static apr_size_t +apache2_ap_get_client_block( + request_rec *r, + char *buffer, + apr_size_t bufsiz) +{ + apr_status_t rv; + apr_bucket_brigade *bb; + int loop = 1; + apr_size_t origBufSize = bufsiz; + + if (r->remaining < 0 || (!r->read_chunked && r->remaining == 0)) { + return 0; + } + + bb = apr_brigade_create(r->pool, r->connection->bucket_alloc); + if (bb == NULL) { + r->connection->keepalive = AP_CONN_CLOSE; + return -1; + } + + /* we need to loop until the input filters (if any) give us data */ + while (loop) { + rv = ap_get_brigade(r->input_filters, bb, AP_MODE_READBYTES, + APR_BLOCK_READ, bufsiz); + + /* We lose the failure code here. This is why ap_get_client_block should + * not be used. + */ + if (rv != APR_SUCCESS) { + /* if we actually fail here, we want to just return and + * stop trying to read data from the client. + */ + r->connection->keepalive = AP_CONN_CLOSE; + apr_brigade_destroy(bb); + return -1; + } + + /* If this fails, it means that a filter is written incorrectly and that + * it needs to learn how to properly handle APR_BLOCK_READ requests by + * returning data when requested. + */ + AP_DEBUG_ASSERT(!APR_BRIGADE_EMPTY(bb)); + + /* Check to see if EOS in the brigade. + * + * If so, we have to leave a nugget for the *next* ap_get_client_block + * call to return 0. + */ + if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(bb))) { + if (r->read_chunked) { + r->remaining = -1; + } else { + r->remaining = 0; + } + } + + rv = apr_brigade_flatten(bb, buffer, &bufsiz); + if (rv != APR_SUCCESS) { + apr_brigade_destroy(bb); + return -1; + } + + /* XXX yank me? */ + r->read_length += bufsiz; + + /* it is possible that the entire bucket brigade is exhausted, but no data + * has been produced by the input filter (mod_deflate, for example).... + * in this scenario, we really need to keep looping + */ + if (bufsiz != 0 || r->remaining <= 0) { + loop = 0; + apr_brigade_destroy(bb); + } else { + if (bufsiz == 0) { + bufsiz = origBufSize; + } + } + + } + + return (long)bufsiz; +} diff --git a/src/core/transport/http/server/apache2/apache2_stream.h b/src/core/transport/http/server/apache2/apache2_stream.h new file mode 100644 index 0000000..abbea45 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_stream.h @@ -0,0 +1,46 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain count 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. + */ + +#ifndef APACHE2_STREAM_H +#define APACHE2_STREAM_H + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** \brief Constructor for creating apche2 stream + * @return axutil_stream (apache2) + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + axutil_stream_create_apache2( + const axutil_env_t * env, + request_rec * req); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* APACHE2_STREAM_H */ diff --git a/src/core/transport/http/server/apache2/apache2_worker.c b/src/core/transport/http/server/apache2/apache2_worker.c new file mode 100644 index 0000000..12b05b2 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_worker.c @@ -0,0 +1,1687 @@ +/* + * 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_apache2_worker.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "axis2_apache2_out_transport_info.h" +#include +#include +#include +#include +#include +#include +#include +#include + +#define READ_SIZE 2048 + +static axis2_status_t +apache2_worker_send_mtom_message( + request_rec *request, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *mtom_sending_callback_name); + +static axis2_status_t +apache2_worker_send_attachment_using_file( + const axutil_env_t * env, + request_rec *request, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size); + +static axis2_status_t +apache2_worker_send_attachment_using_callback( + const axutil_env_t * env, + request_rec *request, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param); + +static axutil_hash_t* +axis2_apache_worker_get_headers( + const axutil_env_t *env, + request_rec *request); + + +struct axis2_apache2_worker +{ + axis2_conf_ctx_t *conf_ctx; +}; + +AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL +axis2_apache2_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path) +{ + axis2_apache2_worker_t *apache2_worker = NULL; + axutil_hash_t* svc_map = NULL; + axis2_conf_t* conf = NULL; + axutil_hash_index_t *hi = NULL; + void* svc = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created"); + apache2_worker = (axis2_apache2_worker_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_apache2_worker_t)); + + if(!apache2_worker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + apache2_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path); + + if(!apache2_worker->conf_ctx) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + /* + * we have to load all the services. This is because, before the fork (in linux) + * we should have a full code segment. Otherwise, we can't share function pointers of services + * between processed. In fork, the code segment will be duplicated across processes + */ + conf = axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env); + if(!conf) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + svc_map = axis2_conf_get_all_svcs(conf, env); + if(!svc_map) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *impl_class = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_hash_t *ops_hash = NULL; + + axutil_hash_this(hi, NULL, NULL, &svc); + if(!svc) + continue; + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + continue; + ops_hash = axis2_svc_get_all_ops(svc, env); + if(ops_hash) + { + axutil_hash_index_t *op_hi = NULL; + void *op = NULL; + op_hi = axutil_hash_first(ops_hash, env); + if(op_hi) + { + axutil_hash_this(op_hi, NULL, NULL, &op); + if(op) + { + msg_recv = axis2_op_get_msg_recv(op, env); + if(msg_recv) + { + axis2_msg_recv_set_conf_ctx(msg_recv, env, apache2_worker->conf_ctx); + axis2_msg_recv_load_and_init_svc(msg_recv, env, svc); + } + } + } + + } + } + + AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created"); + + return apache2_worker; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_apache2_worker_free( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(apache2_worker->conf_ctx) + { + axis2_conf_ctx_free(apache2_worker->conf_ctx, env); + apache2_worker->conf_ctx = NULL; + } + + AXIS2_FREE(env->allocator, apache2_worker); + + return; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_apache2_worker_process_request( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env, + request_rec * request) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + axutil_stream_t *request_body = NULL; + axutil_stream_t *out_stream = NULL; + axis2_transport_out_desc_t *out_desc = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + axis2_char_t *http_version = NULL; + axutil_string_t *soap_action = NULL; + axis2_char_t *soap_action_header_txt = NULL; + axis2_bool_t processed = AXIS2_FALSE; + int content_length = -1; + axis2_char_t *url_external_form = NULL; + axis2_char_t *body_string = NULL; + unsigned int body_string_len = 0; + int send_status = DECLINED; + axis2_char_t *content_type = NULL; + axis2_http_out_transport_info_t *apache2_out_transport_info = 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; + axutil_url_t *request_url = NULL; + axis2_char_t *accept_header_value = NULL; + axis2_char_t *accept_charset_header_value = NULL; + axis2_char_t *accept_language_header_value = NULL; + axis2_char_t *content_language_header_value = NULL; + axis2_bool_t do_mtom = AXIS2_FALSE; + axutil_array_list_t *mime_parts = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *mtom_sending_callback_name = NULL; + axis2_char_t *cookie = NULL; + axis2_char_t *header_value = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *headers = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE); + + conf_ctx = apache2_worker->conf_ctx; + + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + content_length = (int)request->remaining; + /* We are sure that the difference lies within the int range */ + http_version = request->protocol; + + request_url = axutil_url_create(env, "http", request->hostname, request->parsed_uri.port, + request->unparsed_uri); + if(request_url) + { + url_external_form = axutil_url_to_external_form(request_url, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, url_external_form); + axutil_url_free(request_url, env); + request_url = NULL; + } + else + { + send_status = OK; + request->status = HTTP_BAD_REQUEST; + return send_status; + } + + content_type = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(!content_type) + { + content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; + } + request->content_type = content_type; + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + { + axis2_transport_receiver_t *receiver = NULL; + receiver = axis2_transport_in_desc_get_recv(in_desc, env); + if(receiver) + axis2_transport_receiver_set_server_ip(receiver, env, request->connection->local_ip); + } + + msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + cookie = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_COOKIE); + if(cookie) + { + char *session_str = NULL; + axis2_char_t *session_id = NULL; + + session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, cookie); + if(session_id) + session_str = env->get_session_fn((void *) request, session_id); + if(session_str) + axis2_http_transport_utils_set_session(env, msg_ctx, session_str); + } + + if(request->read_chunked == AXIS2_TRUE && 0 == content_length) + { + content_length = -1; + request->chunked = 1; + } + if(!http_version) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + out_stream = axutil_stream_create_basic(env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version); + + peer_ip = request->connection->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); + } + + apache2_out_transport_info = axis2_apache2_out_transport_info_create(env, request); + axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(apache2_out_transport_info->out_transport)); + + accept_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT); + if(accept_header_value) + { + axutil_array_list_t *accept_header_field_list = NULL; + axutil_array_list_t *accept_record_list = NULL; + accept_header_field_list = axutil_tokenize(env, accept_header_value, ','); + if(accept_header_field_list && axutil_array_list_size(accept_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_header_field_list, env, 0); + } + while(token); + } + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list); + } + } + + accept_charset_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT_CHARSET); + if(accept_charset_header_value) + { + axutil_array_list_t *accept_charset_header_field_list = NULL; + axutil_array_list_t *accept_charset_record_list = NULL; + accept_charset_header_field_list = axutil_tokenize(env, accept_charset_header_value, ','); + if(accept_charset_header_field_list && axutil_array_list_size( + accept_charset_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_charset_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_charset_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_charset_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_charset_header_field_list, + env, 0); + } + while(token); + } + if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env, + accept_charset_record_list); + } + } + + accept_language_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE); + if(accept_language_header_value) + { + axutil_array_list_t *accept_language_header_field_list = NULL; + axutil_array_list_t *accept_language_record_list = NULL; + accept_language_header_field_list = axutil_tokenize(env, accept_language_header_value, ','); + if(accept_language_header_field_list && axutil_array_list_size( + accept_language_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_language_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_language_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_language_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_language_header_field_list, + env, 0); + } + while(token); + } + if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env, + accept_language_record_list); + } + } + + soap_action_header_txt = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_SOAP_ACTION); + + if(soap_action_header_txt) + { + soap_action = axutil_string_create(env, soap_action_header_txt); + } + + headers = axis2_apache_worker_get_headers(env, request); + axis2_msg_ctx_set_transport_headers(msg_ctx, env, headers); + + request_body = axutil_stream_create_apache2(env, request); + if(!request_body) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in" + " creating input stream."); + return AXIS2_CRITICAL_FAILURE; + } + if(M_GET == request->method_number || M_DELETE == request->method_number) + { + if(M_DELETE == request->method_number) + { + processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + else if(request->header_only) + { + processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + else + { + processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + if(AXIS2_FALSE == processed) + { + axis2_char_t *wsdl = NULL; + axis2_bool_t is_services_path = AXIS2_FALSE; + if(M_DELETE != request->method_number) + { + axis2_char_t *temp = NULL; + temp = strstr(url_external_form, AXIS2_REQUEST_URL_PREFIX); + if(temp) + { + temp += strlen(AXIS2_REQUEST_URL_PREFIX); + if(*temp == '/') + { + temp++; + } + if(!*temp || *temp == '?' || *temp == '#') + { + is_services_path = AXIS2_TRUE; + } + } + } + wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL); + if(is_services_path) + { + body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else if(M_DELETE != request->method_number && wsdl) + { + body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx, + (axis2_char_t *)url_external_form); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + + } + 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) + { + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + temp = method_list_str; + request->allowed_methods->method_mask = 0; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, ", "); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + /* Conditions below is to assist down-stream modules */ + if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT; + } + else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST; + } + else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + /* Apache Can't differentiate between HEAD and GET */ + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_DELETE, + (axis2_char_t *)axutil_array_list_get(method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE; + } + } + *temp = '\0'; + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + AXIS2_FREE(env->allocator, method_list_str); + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + request->status = HTTP_METHOD_NOT_ALLOWED; + } + else + { + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + request->status = HTTP_NOT_FOUND; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_BAD_REQUEST; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_REQUEST_TIME_OUT; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_CONFLICT; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_GONE; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_PRECONDITION_FAILED; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_SERVICE_UNAVAILABLE; + } + else + { + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + + if(body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + } + } + else if(M_POST == request->method_number || M_PUT == request->method_number) + { + /*axis2_status_t status = AXIS2_FAILURE;*/ + if(M_POST == request->method_number) + { + status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action, + (axis2_char_t *)url_external_form); + } + else + { + status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action, + (axis2_char_t *)url_external_form); + } + if(AXIS2_FAILURE == status && (M_PUT == request->method_number + || 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) + { + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + temp = method_list_str; + request->allowed_methods->method_mask = 0; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, ", "); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + /* Conditions below is to assist down-stream modules */ + if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT; + } + else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST; + } + else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + /* Apache Can't differentiate between HEAD and GET */ + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_DELETE, + (axis2_char_t *)axutil_array_list_get(method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE; + } + } + *temp = '\0'; + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + AXIS2_FREE(env->allocator, method_list_str); + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + request->status = HTTP_METHOD_NOT_ALLOWED; + } + else + { + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + request->status = HTTP_NOT_FOUND; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else + { + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + + if(body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + } + else if(status == 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, Apache will send default + 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, msg_ctx, + fault_code, + axutil_error_get_message + (env->error)); + axis2_engine_send_fault(engine, env, fault_ctx); + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + + /* In case of a SOAP Fault, we have to set the status to 500, + but still return OK because the module has handled the error + */ + send_status = OK; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + } + else + { + body_string = + axis2_http_transport_utils_get_not_implemented(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_IMPLEMENTED; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if (op_ctx) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + if (out_msg_ctx) + { + content_language_header_value = axis2_msg_ctx_get_content_language(out_msg_ctx, env); + } + } + + if (send_status == DECLINED) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (M_POST != request->method_number || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if ((accept_header_value || accept_charset_header_value || + accept_language_header_value) && do_rest) + { + axis2_char_t *content_type_header_value = NULL; + axis2_char_t *temp = NULL; + axis2_char_t *language_header_value = NULL; + + content_type_header_value = (axis2_char_t *) request->content_type; + language_header_value = content_language_header_value; + 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 && accept_header_value && + !axutil_strcasestr(accept_header_value, 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(accept_header_value, temp) && + !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + AXIS2_FREE(env->allocator, temp); + } + } + if (content_type) + { + AXIS2_FREE(env->allocator, content_type); + } + if (char_set && accept_charset_header_value && + !axutil_strcasestr(accept_charset_header_value, char_set)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + if (char_set) + { + AXIS2_FREE(env->allocator, char_set); + } + } + if (language_header_value) + { + if (accept_language_header_value && + !axutil_strcasestr(accept_language_header_value, language_header_value)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + } + } + } + + header_value = axis2_http_transport_utils_get_session(env, msg_ctx); + if(header_value) + { + axis2_http_out_transport_info_t *out_info = NULL; + out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info(msg_ctx, env); + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value); + } + if (send_status == DECLINED) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (M_POST != request->method_number || + 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) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add necessary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, 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_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL: + request->status = HTTP_ACCEPTED; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + default: + request->status = HTTP_OK; + break; + } + send_status = DONE; + } + } + } + if (send_status == DECLINED) + { + send_status = OK; + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + } + } + else if (op_ctx) + { + if (do_rest) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add necessary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, env)); + } + 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: + request->status = HTTP_RESET_CONTENT; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + default: + request->status = HTTP_NO_CONTENT; + break; + } + } + else + { + request->status = HTTP_NO_CONTENT; + } + send_status = DONE; + } + 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); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_OK_CODE_VAL: + request->status = HTTP_OK; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + default: + request->status = HTTP_ACCEPTED; + break; + } + send_status = DONE; + } + } + } + if (send_status == DECLINED) + { + if (msg_ctx) + { + int size = 0; + int status_code; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, env)); + } + + status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_OK_CODE_VAL: + request->status = HTTP_OK; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + case AXIS2_HTTP_RESPONSE_FORBIDDEN_CODE_VAL: + request->status = HTTP_FORBIDDEN; + break; + case AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL: + request->status = HTTP_UNAUTHORIZED; + break; + default: + request->status = HTTP_ACCEPTED; + break; + } + + out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env); + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + send_status = DONE; + } + else + { + request->status = HTTP_ACCEPTED; + send_status = DONE; + } + } + } + else + { + send_status = DONE; + request->status = HTTP_ACCEPTED; + } + } + + if (content_language_header_value) + { + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_CONTENT_LANGUAGE, + content_language_header_value); + } + + if (op_ctx) + { + axis2_msg_ctx_t *out_msg_ctx = NULL, + *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + axis2_char_t *msg_id = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + + /* In mtom case we send the attachment differently */ + + /* status = AXIS2_FAILURE means fault scenario. We are not + * doing MTOM for fault cases. */ + + if(status != AXIS2_FAILURE) + { + do_mtom = axis2_msg_ctx_get_doing_mtom(out_msg_ctx, env); + if(do_mtom) + { + mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env); + if(!mime_parts) + { + return AXIS2_FAILURE; + } + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env , + AXIS2_MTOM_SENDING_CALLBACK); + if(callback_name_param) + { + mtom_sending_callback_name = + (axis2_char_t *) axutil_param_get_value (callback_name_param, env); + } + } + } + + if (out_msg_ctx) + { + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + } + + if (in_msg_ctx) + { + msg_id = + axutil_strdup(env, axis2_msg_ctx_get_msg_id(in_msg_ctx, env)); + conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env); + axis2_msg_ctx_reset_out_transport_info(in_msg_ctx, env); + axis2_msg_ctx_free(in_msg_ctx, env); + in_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL; + } + + if (!axis2_op_ctx_is_in_use(op_ctx, env)) + { + axis2_op_ctx_destroy_mutex(op_ctx, env); + if (conf_ctx && msg_id) + { + axis2_conf_ctx_register_op_ctx(conf_ctx, env, msg_id, NULL); + AXIS2_FREE(env->allocator, msg_id); + } + axis2_op_ctx_free(op_ctx, env); + } + + } /* Done freeing message contexts */ + + /* We send the message in parts when doing MTOM */ + + if(do_mtom) + { + axis2_status_t mtom_status = AXIS2_FAILURE; + + if(!mtom_sending_callback_name) + { + /* If the callback name is not there, then we will check whether there + * is any mime_parts which has type callback. If we found then no point + * of continuing we should return a failure */ + + if(!mtom_sending_callback_name) + { + if(axis2_http_transport_utils_is_callback_required( + env, mime_parts)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); + return AXIS2_FAILURE; + } + } + } + + mtom_status = apache2_worker_send_mtom_message(request, env, mime_parts, + mtom_sending_callback_name); + if(mtom_status == AXIS2_SUCCESS) + { + send_status = DONE; + } + else + { + send_status = DECLINED; + } + + axis2_http_transport_utils_destroy_mime_parts(mime_parts, env); + mime_parts = NULL; + } + + else if (body_string) + { + ap_rwrite(body_string, body_string_len, request); + body_string = NULL; + } + + if (request_body) + { + axutil_stream_free(request_body, env); + request_body = NULL; + } + + axutil_string_free(soap_action, env); + + msg_ctx = NULL; + return send_status; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_apache2_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream) +{ + + axutil_stream_t *tmp_stream = NULL; + int return_size = -1; + axis2_char_t *buffer = NULL; + axis2_bool_t loop_status = AXIS2_TRUE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, stream, NULL); + + tmp_stream = axutil_stream_create_basic(env); + while(loop_status) + { + int read = 0; + int write = 0; + + char buf[READ_SIZE]; + read = axutil_stream_read(stream, env, buf, READ_SIZE); + if(read < 0) + { + break; + } + write = axutil_stream_write(tmp_stream, env, buf, read); + if(read < (READ_SIZE - 1)) + { + break; + } + } + return_size = axutil_stream_get_len(tmp_stream, env); + + if(return_size > 0) + { + buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 2)); + return_size = axutil_stream_read(tmp_stream, env, buffer, return_size + 1); + buffer[return_size + 1] = '\0'; + } + axutil_stream_free(tmp_stream, env); + return buffer; +} + +static axis2_status_t +apache2_worker_send_mtom_message( + request_rec *request, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *mtom_sending_callback_name) +{ + int i = 0; + axiom_mime_part_t *mime_part = NULL; + axis2_status_t status = AXIS2_SUCCESS; + /*int written = 0;*/ + int len = 0; + + if(mime_parts) + { + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + if((mime_part->type) == AXIOM_MIME_PART_BUFFER) + { + len = 0; + len = ap_rwrite(mime_part->part, (int)mime_part->part_size, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + 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(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 + 1) + * sizeof(axis2_char_t)); + + status = apache2_worker_send_attachment_using_file(env, request, f, output_buffer, + output_buffer_size); + if(status == AXIS2_FAILURE) + { + return status; + } + } + 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, + mtom_sending_callback_name, mime_part->user_param, &callback); + + if(handler) + { + status = apache2_worker_send_attachment_using_callback(env, request, 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); + callback = NULL; + + if(param) + { + axutil_param_free(param, env); + param = NULL; + } + + } + + if(status == AXIS2_FAILURE) + { + return status; + } + } + else + { + return AXIS2_FAILURE; + } + if(status == AXIS2_FAILURE) + { + break; + } + } + return status; + } + else + { + return AXIS2_FAILURE; + } +} + +static axis2_status_t +apache2_worker_send_attachment_using_file( + const axutil_env_t * env, + request_rec *request, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size) +{ + + int count = 0; + int len = 0; + /*int written = 0;*/ + axis2_status_t status = AXIS2_SUCCESS; + + do + { + count = (int)fread(buffer, 1, buffer_size + 1, fp); + if(ferror(fp)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in reading file containg the attachment"); + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + + if(count > 0) + { + len = 0; + len = ap_rwrite(buffer, count, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + else + { + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + memset(buffer, 0, buffer_size); + if(status == AXIS2_FAILURE) + { + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + } + while(!feof(fp)); + + fclose(fp); + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + return AXIS2_SUCCESS; +} + +static axis2_status_t +apache2_worker_send_attachment_using_callback( + const axutil_env_t * env, + request_rec *request, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param) +{ + int count = 0; + int len = 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) + { + len = 0; + len = ap_rwrite(buffer, count, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + + if(status == AXIS2_FAILURE) + { + AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler); + return status; + } + + status = AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler); + return status; +} + + +static axutil_hash_t* +axis2_apache_worker_get_headers( + const axutil_env_t *env, + request_rec *request) +{ + int i = 0; + axutil_hash_t *header_map = NULL; + const apr_array_header_t *tarr; + const apr_table_entry_t *telts; + axis2_http_header_t * tmp_http_header = NULL; + + + header_map = axutil_hash_make(env); + tarr = apr_table_elts(request->headers_in); + telts = (const apr_table_entry_t*)tarr->elts; + + for (i = 0; i < tarr->nelts; i++) + { + axis2_char_t* tmp_key = (axis2_char_t*) telts[i].key; + axis2_char_t* tmp_value = (axis2_char_t*) telts[i].val; + tmp_http_header = axis2_http_header_create(env, tmp_key, tmp_value); + axutil_hash_set(header_map, tmp_key, AXIS2_HASH_KEY_STRING, tmp_http_header); + } + + return header_map; + + +} diff --git a/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h b/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h new file mode 100644 index 0000000..9ab9250 --- /dev/null +++ b/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h @@ -0,0 +1,61 @@ + +/* + * 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. + */ + +#ifndef AXIS2_APACHE2_OUT_TRANSPORT_INFO_H +#define AXIS2_APACHE2_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_apache2_out_transport_info.h + * @brief axis2 Apache2 Out Transport Info + */ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_apache2_out_transport_info_create( + const axutil_env_t * env, + request_rec * r); + + /** + * Free http_out_transport_info passed as void pointer. This will be + * cast into appropriate type and then pass the cast object + * into the http_out_transport_info structure's free method + */ + AXIS2_EXTERN void AXIS2_CALL + + axis2_apache2_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_APACHE2_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/apache2/axis2_apache2_worker.h b/src/core/transport/http/server/apache2/axis2_apache2_worker.h new file mode 100644 index 0000000..eea4033 --- /dev/null +++ b/src/core/transport/http/server/apache2/axis2_apache2_worker.h @@ -0,0 +1,78 @@ + +/* + * 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. + */ + +#ifndef AXIS2_APACHE2_WORKER_H +#define AXIS2_APACHE2_WORKER_H + +/** + * @brief Apache2 Worker ops struct + * Encapsulator struct for ops of axis2_apache2_worker + */ + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_apache2_worker.h + * @brief axis2 Apache2 Worker + */ + +#include +#include +#include +#include +#include "apache2_stream.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_apache2_worker axis2_apache2_worker_t; + + AXIS2_EXTERN int AXIS2_CALL + axis2_apache2_worker_process_request( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env, + request_rec * r); + + AXIS2_EXTERN void AXIS2_CALL + axis2_apache2_worker_free( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL + + axis2_apache2_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path); + +#define AXIS2_APACHE2_WORKER_PROCESS_REQUEST(apache2_worker, env, request) \ + axis2_apache2_worker_process_request(\ + apache2_worker, env, request) +#define AXIS2_APACHE2_WORKER_FREE(apache2_worker, env) \ + axis2_apache2_worker_free(apache2_worker, env) + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_APACHE2_WORKER_H */ diff --git a/src/core/transport/http/server/apache2/mod_axis2.c b/src/core/transport/http/server/apache2/mod_axis2.c new file mode 100644 index 0000000..a9431eb --- /dev/null +++ b/src/core/transport/http/server/apache2/mod_axis2.c @@ -0,0 +1,844 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include "axis2_apache2_worker.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Configuration structure populated by apache2.conf */ +typedef struct axis2_config_rec +{ + char *axutil_log_file; + char *axis2_repo_path; + axutil_log_levels_t log_level; + int max_log_file_size; + int axis2_global_pool_size; +} axis2_config_rec_t; + +axis2_apache2_worker_t *axis2_worker = NULL; +axutil_env_t *axutil_env = NULL; +apr_rmm_t* rmm = NULL; +apr_global_mutex_t *global_mutex = NULL; + +/******************************Function Headers********************************/ +static void * +axis2_create_svr( + apr_pool_t * p, + server_rec * s); + +static const char * +axis2_set_repo_path( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_log_file( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_max_log_file_size( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_global_pool_size( + cmd_parms * cmd, + void * dummy, + const char *arg); + +static const char * +axis2_set_log_level( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_svc_url_prefix( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static int +axis2_handler( + request_rec * req); + +/* Shutdown Axis2 */ +apr_status_t +axis2_shutdown( + void *tmp); + +void *AXIS2_CALL axis2_module_malloc( + axutil_allocator_t * allocator, + size_t size); + +void *AXIS2_CALL axis2_module_realloc( + axutil_allocator_t * allocator, + void *ptr, + size_t size); + +void AXIS2_CALL axis2_module_free( + axutil_allocator_t * allocator, + void *ptr); + +static void +axis2_module_init( + apr_pool_t * p, + server_rec * svr_rec); + +static void +axis2_register_hooks( + apr_pool_t * p); + +char * +axis2_get_session( + void *req, + const char *id); + +axis2_status_t +axis2_set_session( + void *req, + const char *id, + const char *session); + +/***************************End of Function Headers****************************/ + +static const command_rec axis2_cmds[] = { AP_INIT_TAKE1("Axis2RepoPath", axis2_set_repo_path, NULL, + RSRC_CONF, "Axis2/C repository path"), AP_INIT_TAKE1("Axis2LogFile", axis2_set_log_file, NULL, + RSRC_CONF, "Axis2/C log file name"), AP_INIT_TAKE1("Axis2LogLevel", axis2_set_log_level, NULL, + RSRC_CONF, "Axis2/C log level"), AP_INIT_TAKE1("Axis2MaxLogFileSize", + axis2_set_max_log_file_size, NULL, RSRC_CONF, "Axis2/C maximum log file size"), + AP_INIT_TAKE1("Axis2GlobalPoolSize", axis2_set_global_pool_size, NULL, RSRC_CONF, + "Axis2/C global pool size"), AP_INIT_TAKE1("Axis2ServiceURLPrefix", + axis2_set_svc_url_prefix, NULL, RSRC_CONF, "Axis2/C service URL prifix"), + { NULL } }; + +/* Dispatch list for API hooks */ +module AP_MODULE_DECLARE_DATA axis2_module = { STANDARD20_MODULE_STUFF, NULL, /* create per-dir config structures */ + NULL, /* merge per-dir config structures */ + axis2_create_svr, /* create per-server config structures */ + NULL, /* merge per-server config structures */ + axis2_cmds, /* table of config file commands */ + axis2_register_hooks /* register hooks */ + }; + +static void * +axis2_create_svr( + apr_pool_t * p, + server_rec * s) +{ + axis2_config_rec_t *conf = apr_palloc(p, sizeof(*conf)); + conf->axutil_log_file = NULL; + conf->axis2_repo_path = NULL; + conf->log_level = AXIS2_LOG_LEVEL_DEBUG; + conf->axis2_global_pool_size = 0; + conf->max_log_file_size = 1; + return conf; +} + +static const char * +axis2_set_repo_path( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axis2_repo_path = apr_pstrdup(cmd->pool, arg); + return NULL; +} + +static const char * +axis2_set_log_file( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axutil_log_file = apr_pstrdup(cmd->pool, arg); + return NULL; +} + +static const char * +axis2_set_max_log_file_size( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->max_log_file_size = 1024 * 1024 * atoi(arg); + return NULL; +} + +static const char * +axis2_set_global_pool_size( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axis2_global_pool_size = 1024 * 1024 * atoi(arg); + return NULL; +} + +static const char * +axis2_set_log_level( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + char *str; + axutil_log_levels_t level = AXIS2_LOG_LEVEL_DEBUG; + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + + str = ap_getword_conf(cmd->pool, &arg); + if(str) + { + if(!strcasecmp(str, "crit")) + { + level = AXIS2_LOG_LEVEL_CRITICAL; + } + else if(!strcasecmp(str, "error")) + { + level = AXIS2_LOG_LEVEL_ERROR; + } + else if(!strcasecmp(str, "warn")) + { + level = AXIS2_LOG_LEVEL_WARNING; + } + else if(!strcasecmp(str, "info")) + { + level = AXIS2_LOG_LEVEL_INFO; + } + else if(!strcasecmp(str, "debug")) + { + level = AXIS2_LOG_LEVEL_DEBUG; + } + else if(!strcasecmp(str, "user")) + { + level = AXIS2_LOG_LEVEL_USER; + } + else if(!strcasecmp(str, "trace")) + { + level = AXIS2_LOG_LEVEL_TRACE; + } + } + conf->log_level = level; + return NULL; +} + +static const char * +axis2_set_svc_url_prefix( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + + axis2_request_url_prefix = AXIS2_REQUEST_URL_PREFIX; + if(!err) + { + axis2_char_t *prefix = apr_pstrdup(cmd->pool, arg); + if(prefix) + axis2_request_url_prefix = prefix; + } + + return NULL; +} + +/* The sample content handler */ +static int +axis2_handler( + request_rec * req) +{ + int rv = 0; + axutil_env_t *thread_env = NULL; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + + apr_allocator_t *local_allocator = NULL; + apr_pool_t *local_pool = NULL; + + if(strcmp(req->handler, "axis2_module")) + { + return DECLINED; + } + + /* Set up the read policy from the client. */ + if((rv = ap_setup_client_block(req, REQUEST_CHUNKED_DECHUNK)) != OK) + { + return rv; + } + ap_should_client_block(req); + + apr_allocator_create(&local_allocator); + apr_pool_create_ex(&local_pool, NULL, NULL, local_allocator); + + /*thread_env = axutil_init_thread_env(axutil_env);*/ + + /*axutil_env->allocator->current_pool = (void *) req->pool; + rv = AXIS2_APACHE2_WORKER_PROCESS_REQUEST(axis2_worker, axutil_env, req);*/ + + /* create new allocator for this request */ + /*allocator = (axutil_allocator_t *) apr_palloc(req->pool, + sizeof(axutil_allocator_t));*/ + + allocator = (axutil_allocator_t *)apr_palloc(local_pool, sizeof(axutil_allocator_t)); + + if(!allocator) + { + return HTTP_INTERNAL_SERVER_ERROR; + } + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void *)local_pool; + allocator->current_pool = (void *)local_pool; + allocator->global_pool = axutil_env->allocator->global_pool; + + error = axutil_error_create(allocator); + thread_env = axutil_env_create_with_error_log_thread_pool(allocator, error, axutil_env->log, + axutil_env-> thread_pool); + thread_env->allocator = allocator; + thread_env->set_session_fn = axis2_set_session; + thread_env->get_session_fn = axis2_get_session; + + rv = AXIS2_APACHE2_WORKER_PROCESS_REQUEST(axis2_worker, thread_env, req); + if(AXIS2_CRITICAL_FAILURE == rv) + { + return HTTP_INTERNAL_SERVER_ERROR; + } + + apr_pool_destroy(local_pool); + apr_allocator_destroy(local_allocator); + + return rv; +} + +void *AXIS2_CALL +axis2_module_malloc( + axutil_allocator_t * allocator, + size_t size) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + + void* ptr = NULL; + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_malloc(rmm, size); + if (offset) + ptr = apr_rmm_addr_get(rmm, offset); + apr_global_mutex_unlock(global_mutex); + return ptr; + } +#endif + return apr_palloc((apr_pool_t *)(allocator->current_pool), size); +} + +void *AXIS2_CALL +axis2_module_realloc( + axutil_allocator_t * allocator, + void *ptr, + size_t size) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + void* ptr = NULL; + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_realloc(rmm, ptr, size); + if (offset) + ptr = apr_rmm_addr_get(rmm, offset); + apr_global_mutex_unlock(global_mutex); + return ptr; + } +#endif + /* can't be easily implemented */ + return NULL; +} + +void AXIS2_CALL +axis2_module_free( + axutil_allocator_t * allocator, + void *ptr) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_offset_get(rmm, ptr); + apr_rmm_free(rmm, offset); + apr_global_mutex_unlock(global_mutex); + } +#endif +} + +static int +axis2_post_config( + apr_pool_t *pconf, + apr_pool_t *plog, + apr_pool_t *ptemp, + server_rec *svr_rec) +{ + apr_status_t status = APR_SUCCESS; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + axutil_log_t *axutil_logger = NULL; + axutil_thread_pool_t *thread_pool = NULL; + void *data = NULL; + const char *userdata_key = "axis2_init"; + axis2_config_rec_t *conf = (axis2_config_rec_t *)ap_get_module_config(svr_rec->module_config, + &axis2_module); + + /* axis2_post_config() will be called twice. Don't bother + * going through all of the initialization on the first call + * because it will just be thrown away.*/ + + ap_add_version_component(pconf, AXIS2_HTTP_HEADER_SERVER_AXIS2C); + + apr_pool_userdata_get(&data, userdata_key, svr_rec->process->pool); + if(!data) + { + apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, + svr_rec->process->pool); + return OK; + } + +#if APR_HAS_SHARED_MEMORY + if (conf->axis2_global_pool_size > 0) + { + apr_shm_t *shm; + apr_rmm_off_t offset; + + status = apr_shm_create(&shm, conf->axis2_global_pool_size, NULL, pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating shared memory pool"); + exit(APEXIT_INIT); + } + + status = apr_rmm_init(&rmm, NULL, apr_shm_baseaddr_get(shm), conf->axis2_global_pool_size, + pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating relocatable memory pool"); + exit(APEXIT_INIT); + } + + status = apr_global_mutex_create(&global_mutex, NULL, + APR_LOCK_DEFAULT, pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating global mutex"); + exit(APEXIT_INIT); + } + + /*status = unixd_set_global_mutex_perms(global_mutex); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Permision cannot be set to global mutex"); + exit(APEXIT_INIT); + } + */ + + offset = apr_rmm_malloc(rmm, sizeof(axutil_allocator_t)); + if (!offset) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error in creating allocator in global pool"); + exit(APEXIT_INIT); + } + allocator = apr_rmm_addr_get(rmm, offset); + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void *) rmm; + allocator->current_pool = (void *) rmm; + allocator->global_pool = (void *) rmm; + + /* We need to init xml readers before we go into threaded env + */ + axiom_xml_reader_init(); + axutil_error_init(); + + error = axutil_error_create(allocator); + if (!error) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 error structure"); + exit(APEXIT_CHILDFATAL); + } + + axutil_logger = axutil_log_create(allocator, NULL, conf->axutil_log_file); + if (!axutil_logger) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 log structure"); + exit(APEXIT_CHILDFATAL); + } + thread_pool = axutil_thread_pool_init(allocator); + if (!thread_pool) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 thread pool"); + exit(APEXIT_CHILDFATAL); + } + axutil_env = axutil_env_create_with_error_log_thread_pool(allocator, error, + axutil_logger, + thread_pool); + if (!axutil_env) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 environment"); + exit(APEXIT_CHILDFATAL); + } + if (axutil_logger) + { + axutil_logger->level = conf->log_level; + axutil_logger->size = conf->max_log_file_size; + AXIS2_LOG_INFO(axutil_env->log, "Apache Axis2/C version in use : %s", + axis2_version_string()); + AXIS2_LOG_INFO(axutil_env->log, + "Starting log with log level %d and max log file size %d", + conf->log_level, conf->max_log_file_size); + } + axutil_env->set_session_fn = axis2_set_session; + axutil_env->get_session_fn = axis2_get_session; + + axis2_worker = axis2_apache2_worker_create(axutil_env, + conf->axis2_repo_path); + if (!axis2_worker) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 apache2 worker"); + exit(APEXIT_CHILDFATAL); + } + } + +#endif + + return OK; +} + +static void +axis2_module_init( + apr_pool_t * p, + server_rec * svr_rec) +{ + apr_pool_t *pool; + apr_status_t status; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + axutil_log_t *axutil_logger = NULL; + axutil_thread_pool_t *thread_pool = NULL; + axis2_config_rec_t *conf = (axis2_config_rec_t*)ap_get_module_config(svr_rec->module_config, + &axis2_module); + + if(conf->axis2_global_pool_size > 0) + { + /* + If we are using shared memory, no need to init the child, as the + worker has been created in post config. + */ + return; + } + + /* We need to init xml readers before we go into threaded env + */ + axiom_xml_reader_init(); + + /* create an allocator that uses APR memory pools and lasts the + * lifetime of the httpd server child process + */ + status = apr_pool_create(&pool, p); + if(status) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error allocating mod_axis2 memory pool"); + exit(APEXIT_CHILDFATAL); + } + allocator = (axutil_allocator_t*)apr_palloc(pool, sizeof(axutil_allocator_t)); + if(!allocator) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_ENOMEM, svr_rec, + "[Axis2] Error allocating mod_axis2 allocator"); + exit(APEXIT_CHILDFATAL); + } + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void*)pool; + allocator->current_pool = (void*)pool; + allocator->global_pool = (void*)pool; + + if(!allocator) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 allocator"); + exit(APEXIT_CHILDFATAL); + } + + axutil_error_init(); + + error = axutil_error_create(allocator); + if(!error) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 error structure"); + exit(APEXIT_CHILDFATAL); + } + axutil_logger = axutil_log_create(allocator, NULL, conf->axutil_log_file); + if(!axutil_logger) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 log structure"); + exit(APEXIT_CHILDFATAL); + } + thread_pool = axutil_thread_pool_init(allocator); + if(!thread_pool) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 thread pool"); + exit(APEXIT_CHILDFATAL); + } + axutil_env = axutil_env_create_with_error_log_thread_pool(allocator, error, axutil_logger, + thread_pool); + if(!axutil_env) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 environment"); + exit(APEXIT_CHILDFATAL); + } + if(axutil_logger) + { + + axutil_logger->level = conf->log_level; + AXIS2_LOG_INFO(axutil_env->log, "Apache Axis2/C version in use : %s", + axis2_version_string()); + AXIS2_LOG_INFO(axutil_env->log, "Starting log with log level %d", conf->log_level); + } + axutil_env->set_session_fn = axis2_set_session; + axutil_env->get_session_fn = axis2_get_session; + axis2_worker = axis2_apache2_worker_create(axutil_env, conf->axis2_repo_path); + if(!axis2_worker) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 apache2 worker"); + exit(APEXIT_CHILDFATAL); + } + + /*ap_dbd_prepare(svr_rec, "SELECT value FROM session WHERE id = %s", "retrieve_session"); + ap_dbd_prepare(svr_rec, "INSERT INTO session VALUES(?,?)", "insert_session");*/ + + + /* If we are initialized we register a clean up as well */ + /* apr_pool_cleanup_register(p, NULL, axis2_shutdown, apr_pool_cleanup_null);*/ +} + +static void +axis2_register_hooks( + apr_pool_t * p) +{ + ap_hook_post_config(axis2_post_config, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_handler(axis2_handler, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_child_init(axis2_module_init, NULL, NULL, APR_HOOK_MIDDLE); +} + +apr_status_t +axis2_shutdown( + void *tmp) +{ + if(axis2_worker) + { + axis2_apache2_worker_free(axis2_worker, axutil_env); + } + return APR_SUCCESS; +} + +char * +axis2_get_session( + void *req, + const char *id) +{ + request_rec *request = NULL; + apr_status_t rv; + const char *dbd_session = NULL; + apr_dbd_prepared_t *statement; + apr_dbd_results_t *res = NULL; + apr_dbd_row_t *row = NULL; + ap_dbd_t *dbd = NULL; + ap_dbd_t *(*authn_dbd_acquire_fn)(request_rec*) = NULL; + request = (request_rec *) req; + + authn_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire); + dbd = authn_dbd_acquire_fn(request); + if (!dbd) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Failed to acquire database connection to look up " + "id '%s'", id); + return NULL; + } + + statement = apr_hash_get(dbd->prepared, "retrieve_session", APR_HASH_KEY_STRING); + if (!statement) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "A prepared statement could not be found for " + "the key '%s'", "retrieve_session"); + return NULL; + } + if (apr_dbd_pvselect(dbd->driver, request->pool, dbd->handle, &res, statement, + 0, id, NULL) != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Query execution error looking up '%s' " + "in database", id); + return NULL; + } + for (rv = apr_dbd_get_row(dbd->driver, request->pool, res, &row, -1); rv != -1; + rv = apr_dbd_get_row(dbd->driver, request->pool, res, &row, -1)) + { + if (rv != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, request, + "Error retrieving results while looking up '%s' " + "in database", id); + return NULL; + } + if (!dbd_session) + { + dbd_session = apr_dbd_get_entry(dbd->driver, row, 0); + } + /* we can't break out here or row won't get cleaned up */ + } + + if (!dbd_session) + { + return NULL; + } + + return (char *) dbd_session; +} + +axis2_status_t +axis2_set_session( + void *req, + const char *id, + const char *session) +{ + request_rec *request = NULL; + apr_dbd_prepared_t *statement; + int affected_rows = -1; + ap_dbd_t *dbd = NULL; + ap_dbd_t *(*authn_dbd_acquire_fn)(request_rec*) = NULL; + request = (request_rec *) req; + + authn_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire); + dbd = authn_dbd_acquire_fn(request); + if (!dbd) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Failed to acquire database connection to insert session for " + "id '%s'", id); + return AXIS2_FAILURE; + } + + statement = apr_hash_get(dbd->prepared, "insert_session", APR_HASH_KEY_STRING); + if (!statement) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "A prepared statement could not be found for " + "the key '%s'", "insert_session"); + return AXIS2_FAILURE; + } + if (apr_dbd_pvquery(dbd->driver, request->pool, dbd->handle, &affected_rows, statement, id, + session, NULL) != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Query execution error inserting session for '%s' " + "in database", id); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + + diff --git a/src/core/transport/http/server/simple_axis2_server/Makefile.am b/src/core/transport/http/server/simple_axis2_server/Makefile.am new file mode 100644 index 0000000..604851d --- /dev/null +++ b/src/core/transport/http/server/simple_axis2_server/Makefile.am @@ -0,0 +1,30 @@ +prgbindir=$(bindir) +prgbin_PROGRAMS = axis2_http_server +SUBDIRS = +AM_CFLAGS = -g -pthread +axis2_http_server_SOURCES = http_server_main.c + +axis2_http_server_LDADD = $(LDFLAGS) \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la \ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/src/core/transport/http/sender/libaxis2_http_sender.la \ + $(top_builddir)/src/core/transport/http/receiver/libaxis2_http_receiver.la \ + $(top_builddir)/neethi/src/libneethi.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description\ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deployment\ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/server/simple_axis2_server/http_server_main.c b/src/core/transport/http/server/simple_axis2_server/http_server_main.c new file mode 100644 index 0000000..cfbcda4 --- /dev/null +++ b/src/core/transport/http/server/simple_axis2_server/http_server_main.c @@ -0,0 +1,310 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axutil_env_t *system_env = NULL; +axis2_transport_receiver_t *server = NULL; +AXIS2_IMPORT extern int axis2_http_socket_read_timeout; +AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + +#define DEFAULT_REPO_PATH "../" + +/***************************** Function headers *******************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file); + +void +system_exit( + axutil_env_t * env, + int status); + +void +usage( + axis2_char_t * prog_name); + +void +sig_handler( + int signal); + +/***************************** End of function headers ************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file) +{ + axutil_error_t *error = axutil_error_create(allocator); + axutil_log_t *log = axutil_log_create(allocator, NULL, log_file); + /* if (!log) */ + + /* log = axutil_log_create_default (allocator); */ + axutil_thread_pool_t *thread_pool = axutil_thread_pool_init(allocator); + /* We need to init the parser in main thread before spawning child + * threads + */ + axiom_xml_reader_init(); + return axutil_env_create_with_error_log_thread_pool(allocator, error, log, thread_pool); +} + +void +system_exit( + axutil_env_t * env, + int status) +{ + axutil_allocator_t *allocator = NULL; + if(server) + { + axis2_transport_receiver_free(server, system_env); + } + if(env) + { + allocator = env->allocator; + axutil_env_free(env); + } + /*axutil_allocator_free(allocator); */ + axiom_xml_reader_cleanup(); + exit(status); +} + +int +main( + int argc, + char *argv[]) +{ + axutil_allocator_t *allocator = NULL; + axutil_env_t *env = NULL; + extern char *optarg; + extern int optopt; + int c; + unsigned int len; + int log_file_size = AXUTIL_LOG_FILE_SIZE; + unsigned int file_flag = 0; + axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_DEBUG; + const axis2_char_t *log_file = "axis2.log"; + const axis2_char_t *repo_path = DEFAULT_REPO_PATH; + int port = 9090; + axis2_status_t status; + + /* Set the service URL prefix to be used. This could default to services if not + set with AXIS2_REQUEST_URL_PREFIX macro at compile time */ + axis2_request_url_prefix = AXIS2_REQUEST_URL_PREFIX; + + while((c = AXIS2_GETOPT(argc, argv, ":p:r:ht:l:s:f:")) != -1) + { + + switch(c) + { + case 'p': + port = AXIS2_ATOI(optarg); + break; + case 'r': + repo_path = optarg; + break; + case 't': + axis2_http_socket_read_timeout = AXIS2_ATOI(optarg) * 1000; + break; + case 'l': + log_level = AXIS2_ATOI(optarg); + if(log_level < AXIS2_LOG_LEVEL_CRITICAL) + log_level = AXIS2_LOG_LEVEL_CRITICAL; + if(log_level > AXIS2_LOG_LEVEL_TRACE) + log_level = AXIS2_LOG_LEVEL_TRACE; + break; + case 's': + log_file_size = 1024 * 1024 * AXIS2_ATOI(optarg); + break; + case 'f': + log_file = optarg; + break; + case 'h': + usage(argv[0]); + return 0; + case ':': + fprintf(stderr, "\nOption -%c requires an operand\n", optopt); + usage(argv[0]); + return -1; + case '?': + if(isprint(optopt)) + fprintf(stderr, "\nUnknown option `-%c'.\n", optopt); + usage(argv[0]); + return -1; + } + } + + allocator = axutil_allocator_init(NULL); + + if(!allocator) + { + system_exit(NULL, -1); + } + + env = init_syetem_env(allocator, log_file); + env->log->level = log_level; + env->log->size = log_file_size; + + axutil_error_init(); + system_env = env; + + signal(SIGINT, sig_handler); +#ifndef WIN32 + signal(SIGPIPE, sig_handler); +#endif + + AXIS2_LOG_INFO(env->log, "Starting Axis2 HTTP server...."); + AXIS2_LOG_INFO(env->log, "Apache Axis2/C version in use : %s", axis2_version_string()); + AXIS2_LOG_INFO(env->log, "Server port : %d", port); + AXIS2_LOG_INFO(env->log, "Repo location : %s", repo_path); + AXIS2_LOG_INFO(env->log, "Read Timeout : %d ms", axis2_http_socket_read_timeout); + + status = axutil_file_handler_access(repo_path, AXIS2_R_OK); + if(status == AXIS2_SUCCESS) + { + len = (unsigned int)strlen(repo_path); + /* We are sure that the difference lies within the unsigned int range */ + if((len >= 9) && !strcmp((repo_path + (len - 9)), "axis2.xml")) + { + file_flag = 1; + } + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "provided repo path %s does " + "not exist or no permissions to read, set " + "repo_path to DEFAULT_REPO_PATH", repo_path); + repo_path = DEFAULT_REPO_PATH; + } + + if(!file_flag) + server = axis2_http_server_create(env, repo_path, port); + else + server = axis2_http_server_create_with_file(env, repo_path, port); + + if(!server) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server creation failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + + } + printf("Started Simple Axis2 HTTP Server ...\n"); + if(axis2_transport_receiver_start(server, env) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server start failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + } + return 0; +} + +void +usage( + axis2_char_t * prog_name) +{ + fprintf(stdout, "\n Usage : %s", prog_name); + fprintf(stdout, " [-p PORT]"); + fprintf(stdout, " [-t TIMEOUT]"); + fprintf(stdout, " [-r REPO_PATH]"); + fprintf(stdout, " [-l LOG_LEVEL]"); + fprintf(stdout, " [-f LOG_FILE]\n"); + fprintf(stdout, " [-s LOG_FILE_SIZE]\n"); + fprintf(stdout, " Options :\n"); + fprintf(stdout, "\t-p PORT \t port number to use, default port is 9090\n"); + fprintf(stdout, "\t-r REPO_PATH \t repository path, default is ../\n"); + fprintf(stdout, "\t-t TIMEOUT\t socket read timeout, default is 30 seconds\n"); + fprintf(stdout, "\t-l LOG_LEVEL\t log level, available log levels:" + "\n\t\t\t 0 - critical 1 - errors 2 - warnings" + "\n\t\t\t 3 - information 4 - debug 5- user 6- trace" + "\n\t\t\t Default log level is 4(debug).\n"); +#ifndef WIN32 + fprintf(stdout, "\t-f LOG_FILE\t log file, default is $AXIS2C_HOME/logs/axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#else + fprintf(stdout, + "\t-f LOG_FILE\t log file, default is %%AXIS2C_HOME%%\\logs\\axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#endif + fprintf(stdout, + "\t-s LOG_FILE_SIZE\t Maximum log file size in mega bytes, default maximum size is 1MB.\n"); + fprintf(stdout, " Help :\n\t-h \t display this help screen.\n\n"); +} + +/** + * Signal handler + */ +void +sig_handler( + int signal) +{ + + if(!system_env) + { + AXIS2_LOG_ERROR( + system_env->log, + AXIS2_LOG_SI, + "Received signal %d, unable to proceed system_env is NULL ,\ + system exit with -1", + signal); + _exit(-1); + } + + switch(signal) + { + case SIGINT: + { + /* Use of SIGINT in Windows is valid, since we have a console application + * Thus, eventhough this may a single threaded application, it does work. + */ + AXIS2_LOG_INFO(system_env->log, "Received signal SIGINT. Server " + "shutting down"); + if(server) + { + axis2_http_server_stop(server, system_env); + } + + AXIS2_LOG_INFO(system_env->log, "Shutdown complete ..."); + system_exit(system_env, 0); + } +#ifndef WIN32 + case SIGPIPE: + { + AXIS2_LOG_INFO(system_env->log, "Received signal SIGPIPE. Client " + "request serve aborted"); + return; + } +#endif + case SIGSEGV: + { + fprintf(stderr, "Received deadly signal SIGSEGV. Terminating\n"); + _exit(-1); + } + } +} -- cgit v1.1-32-gdbae