| |
| /* |
| * 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 <httpd.h> |
| #include <http_config.h> |
| #include <http_log.h> |
| #include <http_protocol.h> |
| #include <ap_config.h> |
| #include <apr_strings.h> |
| #include "axis2_apache2_worker.h" |
| #include <axutil_error_default.h> |
| #include <axutil_log_default.h> |
| #include <axutil_thread_pool.h> |
| #include <axiom_xml_reader.h> |
| #include <axutil_version.h> |
| #include <apr_rmm.h> |
| #include <apr_shm.h> |
| #include <axis2_http_transport.h> |
| |
| /* 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; |
| const 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); |
| |
| /***************************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->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; |
| |
| 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->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); |
| } |
| |
| 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->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); |
| } |
| 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); |
| } |
| /* 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; |
| } |
| |
