/*
* shm init. it should be called in ap_hook_post_config phase
* code partially from mod_auth_digest.c
*/
static int
shm_init(apr_pool_t *p, server_rec *s)
{
apr_status_t ret;
void *data;
const char *userdata_key = "akismet_dummy_key";
/* initialize_module() will be called twice, and if it's a DSO
* then all static data from the first call will be lost. Only
* set up our static data on the second call. */
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
apr_pool_userdata_set((const void *)1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
return OK; /* This would be the first time through */
}
if ( ret = apr_shm_create(&api_cache_shm,
API_CACHE_SHM_SIZE,
api_cache_shm_file, p) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s,
"Failed to create shared segment file '%s'", api_cache_shm_file );
return HTTP_INTERNAL_SERVER_ERROR;
}
if (ret = apr_global_mutex_create(&global_lock,
global_lock_file, APR_LOCK_DEFAULT, p) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s,
"Failed to create global mutex file '%s'", global_lock_file);
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef AP_NEED_SET_MUTEX_PERMS
if( ret = unixd_set_global_mutex_perms(global_lock) != APR_SUCCESS ) {
ap_log_perror(APLOG_MARK, APLOG_CRIT, ret, p,
"%s:Failed to set mutex permission. "
"please check out parent process's privileges!");
return HTTP_INTERNAL_SERVER_ERROR;
}
#endif
key_verified_infos = apr_shm_baseaddr_get(api_cache_shm);
if (!key_verified_infos) {
ap_log_error(APLOG_MARK, APLOG_CRIT, -1, s,
"failed to allocate shared memory" );
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Clear all key_verified_info */
int i;
for (i = 0; i < NUM_BUCKETS; i++) {
key_verified_infos[i].status = -1;
memset(key_verified_infos[i].key, 0, 1024);
}
/* Register a cleanup function */
apr_pool_cleanup_register(p, NULL, cleanup_shm_resources, apr_pool_cleanup_null);
return OK;
}
/**
* Initialise the modsecurity engine. This function must be invoked
* after configuration processing is complete as Apache needs to know the
* username it is running as.
*/
int modsecurity_init(msc_engine *msce, apr_pool_t *mp) {
apr_status_t rc;
/* Serial audit log mutext */
rc = apr_global_mutex_create(&msce->auditlog_lock, NULL, APR_LOCK_DEFAULT, mp);
if (rc != APR_SUCCESS) {
//ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, "mod_security: Could not create modsec_auditlog_lock");
//return HTTP_INTERNAL_SERVER_ERROR;
return -1;
}
#if !defined(MSC_TEST)
#ifdef __SET_MUTEX_PERMS
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER > 2
rc = ap_unixd_set_global_mutex_perms(msce->auditlog_lock);
#else
rc = unixd_set_global_mutex_perms(msce->auditlog_lock);
#endif
if (rc != APR_SUCCESS) {
// ap_log_error(APLOG_MARK, APLOG_ERR, rc, s, "mod_security: Could not set permissions on modsec_auditlog_lock; check User and Group directives");
// return HTTP_INTERNAL_SERVER_ERROR;
return -1;
}
#endif /* SET_MUTEX_PERMS */
rc = apr_global_mutex_create(&msce->geo_lock, NULL, APR_LOCK_DEFAULT, mp);
if (rc != APR_SUCCESS) {
return -1;
}
#ifdef __SET_MUTEX_PERMS
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER > 2
rc = ap_unixd_set_global_mutex_perms(msce->geo_lock);
#else
rc = unixd_set_global_mutex_perms(msce->geo_lock);
#endif
if (rc != APR_SUCCESS) {
return -1;
}
#endif /* SET_MUTEX_PERMS */
#endif
return 1;
}
/*
* This callback is called when the parent initialized.
* Note that this can happen multiple times.
*/
static int but_post_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
void *data;
const char *userdata_key = "but_init_module";
apr_status_t status;
/*
* The following checks if this routine has been called before.
* This is necessary because the parent process gets initialized
* a couple of times as the server starts up, and we don't want
* to create any more mutexes and shared memory segments than
* we're actually going to use.
*/
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
apr_pool_userdata_set((const void *) 1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
return OK;
}
/* Create the shared memory segments. */
status = but_shm_initialize(pconf, plog, ptemp, s);
if (status != APR_SUCCESS) {
ERRLOG_SRV_CRIT("Failed to initialize session SHM.");
return HTTP_INTERNAL_SERVER_ERROR;
}
status = but_shm_initialize_cookiestore(pconf, plog, ptemp, s);
if (status != APR_SUCCESS) {
ERRLOG_SRV_CRIT("Failed to initialize cookiestore SHM.");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Create the module mutex. */
/*
* Create another unique filename to lock upon. Note that
* depending on OS and locking mechanism of choice, the file
* may or may not be actually created.
*/
status = apr_global_mutex_create(&but_mutex, tmpnam(NULL), APR_LOCK_DEFAULT, pconf);
if (status != APR_SUCCESS) {
ERRLOG_SRV_CRIT("Failed to create mutex.");
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef MOD_BUT_SET_MUTEX_PERMS
status = unixd_set_global_mutex_perms(but_mutex);
if (status != APR_SUCCESS) {
ERRLOG_SRV_CRIT("Failed to set mutex permissions.");
return HTTP_INTERNAL_SERVER_ERROR;
}
#endif /* MOD_BUT_SET_MUTEX_PERMS */
return OK;
}
static void lock_init(apr_lockmech_e mech, test_mode_e test_mode)
{
if (test_mode == TEST_PROC) {
assert(apr_proc_mutex_create(&proc_mutex,
NULL,
mech,
p) == APR_SUCCESS);
}
else {
assert(apr_global_mutex_create(&global_mutex,
NULL,
mech,
p) == APR_SUCCESS);
}
}
static int
psgi_post_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
dTHX;
const void *key;
char *file;
SV *app;
apr_hash_index_t *hi;
void *data;
const char *userdata_key = "psgi_post_config";
psgi_apps_t *psgi_apps = NULL;
apr_status_t rc;
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (data == NULL) {
apr_pool_userdata_set((const void *)1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
return OK;
}
ap_add_version_component(pconf, apr_psprintf(pconf, "mod_psgi/%s", MOD_PSGI_VERSION));
mutex_name = apr_psprintf(pconf, "/tmp/psgi_mutex.%ld", (long int) getpid());
rc = apr_global_mutex_create(&psgi_mutex,
(const char *) mutex_name, APR_LOCK_DEFAULT, pconf);
if (rc != APR_SUCCESS) {
return DECLINED;
}
rc = apr_global_mutex_lock(psgi_mutex);
if (rc != APR_SUCCESS) {
return DECLINED;
}
/* shared name to store apps */
shm_name = apr_pstrdup(pconf, "/tmp/psgi_shm");
rc = apr_shm_attach(&psgi_shm, (const char *) shm_name, pconf);
if (rc != APR_SUCCESS) {
rc = apr_shm_create(&psgi_shm, sizeof(psgi_apps_t),
(const char *) shm_name, pconf);
}
if (rc == APR_SUCCESS) {
psgi_apps = (psgi_apps_t *)apr_shm_baseaddr_get(psgi_shm);
psgi_apps->apps = apr_hash_make(pconf);
}
apr_global_mutex_unlock(psgi_mutex);
return OK;
}
static void create_shm(server_rec *s,apr_pool_t *p)
{
int threaded_mpm;
ap_mpm_query(AP_MPMQ_IS_THREADED, &threaded_mpm);
//if (threaded_mpm) {
tmpnam(lock_name);
apr_global_mutex_create(&lock, lock_name, APR_THREAD_MUTEX_DEFAULT, p);
//DEBUGLOG("threaded!");
// }
size_t size;
size = sizeof(client_list_t) + table_size * sizeof(client_t);
ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
"Create or Joining shmem. name: %s, size: %zd", shmname, size);
if(lock) apr_global_mutex_lock(lock);
apr_status_t rc = apr_shm_attach(&shm, shmname, p);
if (APR_SUCCESS != rc) {
DEBUGLOG("dosdetector: Creating shared memory");
apr_shm_remove(shmname, p);
rc = apr_shm_create(&shm, size, shmname, p);
if (APR_SUCCESS != rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0,0, "dosdetector: failed to create shared memory %s\n", shmname);
//ap_log_error(APLOG_MARK, APLOG_ERR, 0,0, "dosdetector: %s:%d: failed to create shared memory %s\n", __FILE__, __LINE__, shmname);
} else {
client_list = apr_shm_baseaddr_get(shm);
memset(client_list, 0, size);
}
} else {
DEBUGLOG("dosdetector: Joining shared memory");
client_list = apr_shm_baseaddr_get(shm);
}
apr_shm_remove(shmname, p); // Just to set destroy flag.
client_list->head = client_list->base;
client_t *c = client_list->base;
int i;
for (i = 1; i < table_size; i++) {
c->next = (c + 1);
c++;
}
c->next = NULL;
if (lock) apr_global_mutex_unlock(lock);
}
apr_status_t
server_init_master_stat(dav_rainx_server_conf *conf, apr_pool_t *pool, apr_pool_t *plog)
{
char buff[256];
apr_status_t rc;
DAV_XDEBUG_POOL(plog, 0, "%s()", __FUNCTION__);
/* Create and attach the segment */
rc = apr_shm_create(&(conf->shm.handle), sizeof(struct shm_stats_s), conf->shm.path, pool);
if (APR_SUCCESS != rc) {
DAV_ERROR_POOL(plog, 0, "%s : Cannot create a SHM segment at [%s] rc=%d : %s",
__FUNCTION__, conf->shm.path, rc, apr_strerror(rc, buff, sizeof(buff)));
conf->shm.handle = NULL;
return rc;
}
DAV_DEBUG_POOL(plog, 0, "%s : SHM segment created at [%s]", __FUNCTION__, conf->shm.path);
/* Create a processus lock*/
rc = apr_global_mutex_create(&(conf->lock.handle), conf->lock.path, APR_LOCK_DEFAULT, pool);
if (rc != APR_SUCCESS) {
DAV_ERROR_POOL(plog, 0, "%s : Cannot create a global_mutex at [%s] rc=%d : %s",
__FUNCTION__, conf->lock.path, rc, apr_strerror(rc, buff, sizeof(buff)));
(void) apr_shm_destroy(conf->shm.handle);
conf->shm.handle = NULL;
return rc;
}
DAV_DEBUG_POOL(plog, 0, "%s : globalmutex created at [%s]", __FUNCTION__, conf->lock.path);
/* Init the SHM */
void *ptr_counter = apr_shm_baseaddr_get(conf->shm.handle);
if (ptr_counter) {
bzero(ptr_counter, sizeof(struct shm_stats_s));
/* init rrd's */
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_sec));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_duration));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_put_sec));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_put_duration));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_get_sec));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_get_duration));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_del_sec));
rainx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_del_duration));
}
return APR_SUCCESS;
}
/* Set up startup-time initialization */
static int vlimit_init(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", MODULE_NAME " " MODULE_VERSION " started.", p);
if(apr_file_open(&vlimit_log_fp, VLIMIT_LOG_FILE, APR_WRITE|APR_APPEND|APR_CREATE,
APR_OS_DEFAULT, p) != APR_SUCCESS){
return OK;
}
apr_status_t status;
apr_size_t retsize;
apr_size_t shm_size;
int t;
SHM_DATA *shm_data = NULL;
shm_size = (apr_size_t) (sizeof(shm_data) + sizeof(shm_data->file_stat_shm) + sizeof(shm_data->ip_stat_shm)) * (conf_counter + 1);
//Create global mutex
status = apr_global_mutex_create(&vlimit_mutex, NULL, APR_LOCK_DEFAULT, p);
if(status != APR_SUCCESS){
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Error creating global mutex.", p);
return status;
}
#ifdef AP_NEED_SET_MUTEX_PERMS
status = unixd_set_global_mutex_perms(vlimit_mutex);
if(status != APR_SUCCESS){
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Error xrent could not set permissions on global mutex.", p);
return status;
}
#endif
if(apr_global_mutex_child_init(&vlimit_mutex, NULL, p))
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "global mutex attached.", p);
/* If there was a memory block already assigned.. destroy it */
if (shm) {
status = apr_shm_destroy(shm);
if (status != APR_SUCCESS) {
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Couldn't destroy old memory block", p);
return status;
} else {
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Old Shared memory block, destroyed.", p);
}
}
/* Create shared memory block */
status = apr_shm_create(&shm, shm_size, NULL, p);
if (status != APR_SUCCESS) {
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Error creating shm block", p);
return status;
}
/* Check size of shared memory block */
retsize = apr_shm_size_get(shm);
if (retsize != shm_size) {
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", "Error allocating shared memory block", p);
return status;
}
/* Init shm block */
shm_base = apr_shm_baseaddr_get(shm);
if (shm_base == NULL) {
VLIMIT_DEBUG_SYSLOG("vlimit_init", "Error creating status block.", p);
return status;
}
memset(shm_base, 0, retsize);
vlimit_debug_log_buf = apr_psprintf(p
, "Memory Allocated %d bytes (each conf takes %d bytes) MaxClient:%d"
, (int) retsize
, (int) (sizeof(shm_data) + sizeof(shm_data->file_stat_shm) + sizeof(shm_data->ip_stat_shm))
, MAX_CLIENTS
);
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", vlimit_debug_log_buf, p);
if (retsize < (sizeof(shm_data) * conf_counter)) {
VLIMIT_DEBUG_SYSLOG("vlimit_init ", "Not enough memory allocated!! Giving up" , p);
return HTTP_INTERNAL_SERVER_ERROR;
}
int i;
for (t = 0; t <= conf_counter; t++) {
shm_data = shm_base + t;
for (i = 0; i < MAX_CLIENTS; i++) {
shm_data->file_stat_shm[i].filename[0] = '\0';
shm_data->ip_stat_shm[i].address[0] = '\0';
shm_data->file_stat_shm[i].counter = 0;
shm_data->ip_stat_shm[i].counter = 0;
}
}
vlimit_debug_log_buf = apr_psprintf(p
, "%s Version %s - Initialized [%d Conf]"
, MODULE_NAME
, MODULE_VERSION
, conf_counter
);
VLIMIT_DEBUG_SYSLOG("vlimit_init: ", vlimit_debug_log_buf, p);
return OK;
}
bool InitAPRGlobalStorage (APRGlobalStorage *storage_p, apr_pool_t *pool_p, apr_hashfunc_t hash_fn, unsigned char *(*make_key_fn) (const void *data_p, uint32 raw_key_length, uint32 *key_len_p), void (*free_key_and_value_fn) (unsigned char *key_p, void *value_p), server_rec *server_p, const char *mutex_filename_s, const char *cache_id_s, const char *provider_name_s)
{
ap_socache_provider_t *provider_p = ap_lookup_provider (AP_SOCACHE_PROVIDER_GROUP, provider_name_s, AP_SOCACHE_PROVIDER_VERSION);
if (provider_p)
{
apr_status_t status = apr_global_mutex_create (& (storage_p -> ags_mutex_p), mutex_filename_s, APR_THREAD_MUTEX_UNNESTED, pool_p);
if (status == APR_SUCCESS)
{
char *current_dir_s = GetCurrentWorkingDirectory ();
if (current_dir_s)
{
storage_p -> ags_largest_entry_memory_id = AllocateSharedMemory (current_dir_s, sizeof (unsigned int), 0644);
FreeCopiedString (current_dir_s);
if (storage_p -> ags_largest_entry_memory_id != -1)
{
storage_p -> ags_entries_p = apr_hash_make_custom (pool_p, hash_fn);
if (storage_p -> ags_entries_p)
{
storage_p -> ags_pool_p = pool_p;
storage_p -> ags_server_p = server_p;
storage_p -> ags_make_key_fn = make_key_fn;
storage_p -> ags_free_key_and_value_fn = free_key_and_value_fn;
storage_p -> ags_cache_id_s = cache_id_s;
storage_p -> ags_mutex_lock_filename_s = mutex_filename_s;
storage_p -> ags_socache_instance_p = NULL;
storage_p -> ags_socache_provider_p = provider_p;
apr_pool_cleanup_register (pool_p, storage_p, (const void *) FreeAPRGlobalStorage, apr_pool_cleanup_null);
return true;
} /* if (storage_p -> ags_entries_p) */
else
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to allocate shared memory hash table");
}
FreeSharedMemory (storage_p -> ags_largest_entry_memory_id);
} /* if (storage_p -> ags_largest_entry_memory_id != -1) */
else
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to allocate shared memory for largest chunk size");
}
} /* if (mem_key_s) */
else
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to create memory key from \"%s\" and \".memory\"", cache_id_s);
}
apr_global_mutex_destroy (storage_p -> ags_mutex_p);
storage_p -> ags_mutex_p = NULL;
} /* if (status == APR_SUCCESS) */
else
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to create global mutex for shared memory at %s", mutex_filename_s);
}
} /* if (provider_p) */
else
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to find provider \"%s\"", provider_name_s ? provider_name_s : "NULL");
}
return false;
}
static int exipc_post_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
void *data; /* These two help ensure that we only init once. */
const char *userdata_key;
apr_status_t rs;
exipc_data *base;
const char *tempdir;
/*
* The following checks if this routine has been called before.
* This is necessary because the parent process gets initialized
* a couple of times as the server starts up, and we don't want
* to create any more mutexes and shared memory segments than
* we're actually going to use.
*
* The key needs to be unique for the entire web server, so put
* the module name in it.
*/
userdata_key = "example_ipc_init_module";
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
/*
* If no data was found for our key, this must be the first
* time the module is initialized. Put some data under that
* key and return.
*/
apr_pool_userdata_set((const void *) 1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
return OK;
} /* Kilroy was here */
/*
* Both the shared memory and mutex allocation routines take a
* file name. Depending on system-specific implementation of these
* routines, that file may or may not actually be created. We'd
* like to store those files in the operating system's designated
* temporary directory, which APR can point us to.
*/
rs = apr_temp_dir_get(&tempdir, pconf);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s,
"Failed to find temporary directory");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Create the shared memory segment */
/*
* Create a unique filename using our pid. This information is
* stashed in the global variable so the children inherit it.
*/
shmfilename = apr_psprintf(pconf, "%s/httpd_shm.%ld", tempdir,
(long int)getpid());
/* Now create that segment */
rs = apr_shm_create(&exipc_shm, sizeof(exipc_data),
(const char *) shmfilename, pconf);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s,
"Failed to create shared memory segment on file %s",
shmfilename);
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Created it, now let's zero it out */
base = (exipc_data *)apr_shm_baseaddr_get(exipc_shm);
base->counter = 0;
/* Create global mutex */
/*
* Create another unique filename to lock upon. Note that
* depending on OS and locking mechanism of choice, the file
* may or may not be actually created.
*/
mutexfilename = apr_psprintf(pconf, "%s/httpd_mutex.%ld", tempdir,
(long int) getpid());
rs = apr_global_mutex_create(&exipc_mutex, (const char *) mutexfilename,
APR_LOCK_DEFAULT, pconf);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s,
"Failed to create mutex on file %s",
mutexfilename);
return HTTP_INTERNAL_SERVER_ERROR;
}
/*
* After the mutex is created, its permissions need to be adjusted
* on unix platforms so that the child processe can acquire
* it. This call takes care of that. The preprocessor define was
* set up early in this source file since Apache doesn't provide
* it.
*/
#ifdef MOD_EXIPC_SET_MUTEX_PERMS
rs = unixd_set_global_mutex_perms(exipc_mutex);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s,
"Parent could not set permissions on Example IPC "
"mutex: check User and Group directives");
return HTTP_INTERNAL_SERVER_ERROR;
}
#endif /* MOD_EXIPC_SET_MUTEX_PERMS */
/*
* Destroy the shm segment when the configuration pool gets destroyed. This
* happens on server restarts. The parent will then (above) allocate a new
* shm segment that the new children will bind to.
*/
apr_pool_cleanup_register(pconf, NULL, shm_cleanup_wrapper,
apr_pool_cleanup_null);
return OK;
}
int upload_progress_init(apr_pool_t *p, apr_pool_t *plog,
apr_pool_t *ptemp,
server_rec *s) {
apr_status_t result;
server_rec *s_vhost;
ServerConfig *st_vhost;
ServerConfig *config = (ServerConfig*)ap_get_module_config(s->module_config, &upload_progress_module);
void *data;
const char *userdata_key = "upload_progress_init";
/* upload_progress_init will be called twice. Don't bother
* going through all of the initialization on the first call
* because it will just be thrown away.*/
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
apr_pool_userdata_set((const void *)1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
#if APR_HAS_SHARED_MEMORY
/* If the cache file already exists then delete it. Otherwise we are
* going to run into problems creating the shared memory. */
if (config->cache_file) {
char *lck_file = apr_pstrcat(ptemp, config->cache_file, ".lck",
NULL);
apr_file_remove(lck_file, ptemp);
}
#endif
return OK;
}
#if APR_HAS_SHARED_MEMORY
/* initializing cache if shared memory size is not zero and we already
* don't have shm address
*/
if (!config->cache_shm && config->cache_bytes > 0) {
#endif
result = upload_progress_cache_init(p, config);
if (result != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, result, s,
"Upload Progress cache: could not create shared memory segment");
return DONE;
}
#if APR_HAS_SHARED_MEMORY
if (config->cache_file) {
config->lock_file = apr_pstrcat(config->pool, config->cache_file, ".lck",
NULL);
}
#endif
result = apr_global_mutex_create(&config->cache_lock,
config->lock_file, APR_LOCK_DEFAULT,
config->pool);
if (result != APR_SUCCESS) {
return result;
}
#ifdef AP_NEED_SET_MUTEX_PERMS
result = unixd_set_global_mutex_perms(config->cache_lock);
if (result != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, result, s,
"Upload progress cache: failed to set mutex permissions");
return result;
}
#endif
/* merge config in all vhost */
s_vhost = s->next;
while (s_vhost) {
st_vhost = (ServerConfig *)
ap_get_module_config(s_vhost->module_config,
&upload_progress_module);
#if APR_HAS_SHARED_MEMORY
st_vhost->cache_shm = config->cache_shm;
st_vhost->cache_rmm = config->cache_rmm;
st_vhost->cache_file = config->cache_file;
st_vhost->cache_offset = config->cache_offset;
st_vhost->cache = config->cache;
ap_log_error(APLOG_MARK, APLOG_DEBUG, result, s,
"Upload Progress: merging Shared Cache conf: shm=0x%pp rmm=0x%pp "
"for VHOST: %s", config->cache_shm, config->cache_rmm,
s_vhost->server_hostname);
#endif
st_vhost->lock_file = config->lock_file;
s_vhost = s_vhost->next;
}
#if APR_HAS_SHARED_MEMORY
}
else {
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
"Upload Progress cache: cache size is zero, disabling "
"shared memory cache");
}
#endif
return(OK);
}
static int mod_mapcache_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s) {
apr_status_t rc;
mapcache_server_cfg* cfg = ap_get_module_config(s->module_config, &mapcache_module);
apr_lockmech_e lock_type = APR_LOCK_DEFAULT;
server_rec *sconf;
if(!cfg) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "configuration not found in server context");
return 1;
}
#if APR_HAS_PROC_PTHREAD_SERIALIZE
lock_type = APR_LOCK_PROC_PTHREAD;
#endif
rc = apr_global_mutex_create(&cfg->mutex,cfg->mutex_name,lock_type,p);
if(rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rc, s, "Could not create global parent mutex %s", cfg->mutex_name);
return rc;
}
#ifdef AP_NEED_SET_MUTEX_PERMS
rc = unixd_set_global_mutex_perms(cfg->mutex);
if(rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rc, s, "Could not set permissions on global parent mutex %s", cfg->mutex_name);
return rc;
}
#endif
apr_pool_cleanup_register(p,cfg->mutex,
(void*)apr_global_mutex_destroy, apr_pool_cleanup_null);
#ifndef DISABLE_VERSION_STRING
ap_add_version_component(p, MAPCACHE_USERAGENT);
#endif
for (sconf = s->next; sconf; sconf = sconf->next) {
mapcache_server_cfg* config = ap_get_module_config(sconf->module_config, &mapcache_module);
config->mutex = cfg->mutex;
}
#if APR_HAS_FORK
/* fork a child process to let it accomplish post-configuration tasks with the uid of the runtime user */
apr_proc_t proc;
apr_status_t rv;
rv = apr_proc_fork(&proc, ptemp);
if (rv == APR_INCHILD) {
#define ap_unixd_setup_child unixd_setup_child
ap_unixd_setup_child();
mapcache_context *ctx = (mapcache_context*)apache_server_context_create(s,p);
for (sconf = s; sconf; sconf = sconf->next) {
mapcache_server_cfg* config = ap_get_module_config(sconf->module_config, &mapcache_module);
if(config->aliases) {
apr_hash_index_t *entry = apr_hash_first(ptemp,config->aliases);
/* loop through the configured configurations */
while (entry) {
const char *alias;
apr_ssize_t aliaslen;
mapcache_cfg *c;
apr_hash_this(entry,(const void**)&alias,&aliaslen,(void**)&c);
mapcache_configuration_post_config(ctx, c);
if(GC_HAS_ERROR(ctx)) {
ap_log_error(APLOG_MARK, APLOG_CRIT, APR_EGENERAL, s, "post config for %s failed: %s", alias,
ctx->get_error_message(ctx));
exit(APR_EGENERAL);
}
entry = apr_hash_next(entry);
}
}
}
exit(0);
} else if (rv == APR_INPARENT) {
apr_exit_why_e exitwhy;
int exitcode;
apr_proc_wait(&proc,&exitcode,&exitwhy,APR_WAIT);
if(exitwhy != APR_PROC_EXIT) {
ap_log_error(APLOG_MARK, APLOG_CRIT, APR_EGENERAL, s, "mapcache post-config child terminated abnormally");
return APR_EGENERAL;
} else {
if(exitcode != 0) {
return APR_EGENERAL;
}
}
return OK;
} else {
ap_log_error(APLOG_MARK, APLOG_CRIT, APR_EGENERAL, s, "failed to fork mapcache post-config child");
return APR_EGENERAL;
}
#else /* APR_HAS_FORK */
mapcache_context *ctx = (mapcache_context*)apache_server_context_create(s,p);
for (sconf = s; sconf; sconf = sconf->next) {
mapcache_server_cfg* config = ap_get_module_config(sconf->module_config, &mapcache_module);
if(config->aliases) {
apr_hash_index_t *entry = apr_hash_first(ptemp,config->aliases);
/* loop through the configured configurations */
while (entry) {
const char *alias;
apr_ssize_t aliaslen;
mapcache_cfg *c;
apr_hash_this(entry,(const void**)&alias,&aliaslen,(void**)&c);
mapcache_configuration_post_config(ctx, c);
if(GC_HAS_ERROR(ctx)) {
ap_log_error(APLOG_MARK, APLOG_CRIT, APR_EGENERAL, s, "post config for %s failed: %s", alias,
ctx->get_error_message(ctx));
return APR_EGENERAL;
}
entry = apr_hash_next(entry);
}
}
}
return OK;
#endif
}
/*
* This routine is called in the parent, so we'll set up the shared
* memory segments and mutexs here.
*/
static int dosblock_post_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
void *data; /* These two help ensure that we only init once. */
const char *userdata_key;
apr_status_t rs;
const char *tempdir;
dosblockipc_data *base;
dosblock_cfg *cfg = (dosblock_cfg *)ap_get_module_config(s->module_config, &mod_dosblock_module);
/*
* The following checks if this routine has been called before.
* This is necessary because the parent process gets initialized
* a couple of times as the server starts up, and we don't want
* to create any more mutexes and shared memory segments than
* we're actually going to use.
*
* The key needs to be unique for the entire web server, so put
* the module name in it.
*/
userdata_key = "dosblock_ipc_init_module";
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
/*
* If no data was found for our key, this must be the first
* time the module is initialized. Put some data under that
* key and return.
*/
apr_pool_userdata_set((const void *) 1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
return OK;
}
/*
* The shared memory allocation routines take a file name.
* Depending on system-specific implementation of these
* routines, that file may or may not actually be created. We'd
* like to store those files in the operating system's designated
* temporary directory, which APR can point us to.
*/
rs = apr_temp_dir_get(&tempdir, pconf);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s,
"Failed to find temporary directory");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Create the shared memory segments. We also populate a dosrule to shared
* memory mapping table with all the shared memory segments
*/
const apr_array_header_t *tarr = apr_table_elts(cfg->dosrulemap);
const apr_table_entry_t *telts = (const apr_table_entry_t*)tarr->elts;
int i;
for (i = 0; i < tarr->nelts; ++i) {
/*
* Create a unique filename using our pid. This information is
* stashed in the global variable so the children inherit it.
*/
shmfilename = apr_psprintf(pconf, "%s/httpd_shm_%s.%ld", tempdir,
telts[i].key, (long int)getpid());
mutex_filename = apr_psprintf(pconf, "%s/httpd_mutex_%s.%ld", tempdir,
telts[i].key, (long int)getpid());
/* Now create that shm segment. We prefer anonymous shm */
rs = apr_shm_create(&dosblockipc_shm[i], sizeof(dosblockipc_data),
NULL, pconf);
if (APR_ENOTIMPL == rs) {
rs = apr_shm_create(&dosblockipc_shm[i], sizeof(dosblockipc_data),
(const char *) shmfilename, pconf);
}
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s,
"Failed to create shared memory segment on file %s",
shmfilename);
return HTTP_INTERNAL_SERVER_ERROR;
}
apr_hash_set(cfg->dosrule_shm_map, telts[i].key, APR_HASH_KEY_STRING, apr_psprintf(pconf, "%d",i));
if (cfg->verbosity)
ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, "Dos Rule configured is %s", telts[i].key);
base = (dosblockipc_data *)apr_shm_baseaddr_get(dosblockipc_shm[i]);
/* Now initialise the array of structs. Zero it out */
base->ds.t = 0;
base->ds.isblocked = 0;
base->ds.rate_when_blocked = 0;
base->next = 0;
int j;
for (j=0; j<ARSIZE; j++) {
base->dh[j].t = 0;
base->dh[j].counter = 0;
}
/* Create global mutex */
rs = apr_global_mutex_create(&dosblockipc_mutex[i], mutex_filename, APR_LOCK_DEFAULT, pconf);
if (APR_SUCCESS != rs) {
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef AP_NEED_SET_MUTEX_PERMS
rs = unixd_set_global_mutex_perms(dosblockipc_mutex[i]);
if (rs != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s,
"mod_dosblock: Parent could not set permissions "
"on shared memory; check User and Group directives");
return rs;
}
#endif
apr_table_set(cfg->dosrule_mutex_map, telts[i].key, mutex_filename);
}
/*
* Destroy the shm segment when the configuration pool gets destroyed. This
*happens on server restarts. The parent will then (above) allocate a new
* shm segment that the new children will bind to.
*/
/*
apr_pool_cleanup_register(pconf, NULL, shm_cleanup_wrapper(),
apr_pool_cleanup_null);
*/
return OK;
}
