diff options
Diffstat (limited to 'src/core/transport/http/server/apache2/mod_axis2.c')
| -rw-r--r-- | src/core/transport/http/server/apache2/mod_axis2.c | 844 |
1 files changed, 844 insertions, 0 deletions
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 <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 <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(!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; +} + + |