| /* |
| * 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 <axutil_types.h> |
| #include <apr_rmm.h> |
| #include <apr_shm.h> |
| #include <apr_dbd.h> |
| #include <mod_dbd.h> |
| #include <axis2_http_transport.h> |
| #include <axutil_types.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; |
| 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(!axutil_strcasecmp(str, "crit")) |
| { |
| level = AXIS2_LOG_LEVEL_CRITICAL; |
| } |
| else if(!axutil_strcasecmp(str, "error")) |
| { |
| level = AXIS2_LOG_LEVEL_ERROR; |
| } |
| else if(!axutil_strcasecmp(str, "warn")) |
| { |
| level = AXIS2_LOG_LEVEL_WARNING; |
| } |
| else if(!axutil_strcasecmp(str, "info")) |
| { |
| level = AXIS2_LOG_LEVEL_INFO; |
| } |
| else if(!axutil_strcasecmp(str, "debug")) |
| { |
| level = AXIS2_LOG_LEVEL_DEBUG; |
| } |
| else if(!axutil_strcasecmp(str, "user")) |
| { |
| level = AXIS2_LOG_LEVEL_USER; |
| } |
| else if(!axutil_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); |
| } |
| |
| /* If we are initialized we register a clean up as well */ |
| apr_pool_pre_cleanup_register(p, NULL, axis2_shutdown); |
| } |
| |
| 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); |
| if(authn_dbd_acquire_fn) |
| { |
| 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'. Check whether apache2 is installed with mod-dbd enabled", 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; |
| } |
| |
| |