/**
* Performs per-child (new process) initialisation.
*/
void modsecurity_child_init(msc_engine *msce)
{
/* Need to call this once per process before any other XML calls. */
xmlInitParser();
if (msce->auditlog_lock != NULL) {
apr_status_t rc = apr_global_mutex_child_init(&msce->auditlog_lock, NULL, msce->mp);
if (rc != APR_SUCCESS) {
/* 原本就无内容 */
}
}
if (msce->geo_lock != NULL) {
apr_status_t rc = apr_global_mutex_child_init(&msce->geo_lock, NULL, msce->mp);
if (rc != APR_SUCCESS) {
/* 原本就无内容 */
}
}
#ifdef DEBUG_DBLOG
if (ap_logdb_mutex != NULL) {
apr_status_t rc = apr_global_mutex_child_init(&ap_logdb_mutex, NULL, msce->mp);
if (rc != APR_SUCCESS) {
/* 原本就无内容 */
}
}
#endif
}
apr_status_t
server_init_child_stat(dav_rawx_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__);
/* Attaches the mutex */
DAV_DEBUG_POOL(plog, 0, "%s : Attaching the SHM global_mutex at [%s]", __FUNCTION__, conf->shm.path);
rc = apr_global_mutex_child_init(&(conf->lock.handle), conf->shm.path, pool);
if (APR_SUCCESS != rc) {
DAV_ERROR_POOL(plog, 0, "%s : Failed to attach the SHM global_mutex at [%s] rc=%d : %s",
__FUNCTION__, conf->shm.path, rc, apr_strerror(rc, buff, sizeof(buff)));
return rc;
}
DAV_DEBUG_POOL(plog, 0, "%s : globalmutex attached at [%s]", __FUNCTION__, conf->shm.path);
/* Atatches the SHM */
if (!conf->shm.handle) {
DAV_DEBUG_POOL(plog, 0, "%s : Attaching the SHM segment at [%s]", __FUNCTION__, conf->shm.path);
rc = apr_shm_attach(&(conf->shm.handle), conf->shm.path, pool);
if (APR_SUCCESS != rc) {
DAV_ERROR_POOL(plog, 0, "%s : Failed to attach the 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 attached at [%s]", __FUNCTION__, conf->shm.path);
return APR_SUCCESS;
}
static void mod_mapcache_child_init(apr_pool_t *pool, server_rec *s) {
while(s) {
mapcache_server_cfg* cfg = ap_get_module_config(s->module_config, &mapcache_module);
apr_global_mutex_child_init(&(cfg->mutex),cfg->mutex_name, pool);
s = s->next;
}
}
/*
* This routine gets called when a child inits. We use it to attach
* to the shared memory segments, and reinitialize the corresponding mutex.
*/
static void dosblock_child_init(apr_pool_t *p, server_rec *s)
{
apr_status_t rs ;
const apr_table_entry_t *dosrule_mutex_map_elts = NULL;
const apr_array_header_t *dosrule_mutex_map_arr = NULL;
/*
* Re-open the mutexes for the child. Note we're reusing
* the mutex pointer global here.
*/
dosblock_cfg *cfg = (dosblock_cfg *)ap_get_module_config(s->module_config, &mod_dosblock_module);
dosrule_mutex_map_arr = apr_table_elts(cfg->dosrule_mutex_map);
if (dosrule_mutex_map_arr) {
dosrule_mutex_map_elts = (const apr_table_entry_t *)dosrule_mutex_map_arr->elts;
int i = 0;
for (i=0; i<dosrule_mutex_map_arr->nelts; ++i)
{
rs = apr_global_mutex_child_init(&dosblockipc_mutex[i], dosrule_mutex_map_elts[i].val, p);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s,
"Failed to reopen mutex %s in child",
dosblockipc_mutex[i]);
/* There's really nothing else we can do here, since This
* routine doesn't return a status. If this ever goes wrong,
* it will turn Apache into a fork bomb. Let's hope it never
* will.
*/
exit(1); /* Ugly, but what else? */
}
}
}
}
/**
* Performs per-child (new process) initialisation.
*/
void modsecurity_child_init(msc_engine *msce) {
/* Need to call this once per process before any other XML calls. */
xmlInitParser();
if (msce->auditlog_lock != NULL) {
apr_status_t rc = apr_global_mutex_child_init(&msce->auditlog_lock, NULL, msce->mp);
if (rc != APR_SUCCESS) {
// ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, "Failed to child-init auditlog mutex");
}
}
if (msce->geo_lock != NULL) {
apr_status_t rc = apr_global_mutex_child_init(&msce->geo_lock, NULL, msce->mp);
if (rc != APR_SUCCESS) {
// ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, "Failed to child-init geo mutex");
}
}
}
/*
* This callback is called when a child process initializes.
* We use it to set up the mutex.
*/
static void
but_child_init(apr_pool_t *p, server_rec *s)
{
apr_status_t status;
/* Re-open the mutex in the child process. */
status = apr_global_mutex_child_init(&but_mutex, (const char*) mutex_filename, p);
if (status != APR_SUCCESS) {
ERRLOG_SRV_CRIT("Failed to reopen mutex on file %s", mutex_filename);
exit(1);
}
}
apr_status_t
procmgr_child_init(server_rec * main_server, apr_pool_t * configpool)
{
apr_status_t rv;
if ((rv = apr_global_mutex_child_init(&g_pipelock,
g_pipelock_name,
main_server->process->pconf)) !=
APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: apr_global_mutex_child_init error for pipe mutex");
exit(1);
}
return APR_SUCCESS;
}
/*
* initialize the shared memory segment in a child process
*/
int oidc_cache_shm_child_init(apr_pool_t *p, server_rec *s) {
oidc_cfg *cfg = ap_get_module_config(s->module_config, &auth_openidc_module);
oidc_cache_cfg_shm_t *context = (oidc_cache_cfg_shm_t *)cfg->cache_cfg;
/* initialize the lock for the child process */
apr_status_t rv = apr_global_mutex_child_init(&context->mutex,
(const char *) context->mutex_filename, p);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
"oic_cache_shm_child_init: apr_global_mutex_child_init failed to reopen mutex on file %s",
context->mutex_filename);
}
return rv;
}
static void initialize_child(apr_pool_t *p, server_rec *s)
{
//DEBUGLOG("initialize_child is called");
apr_status_t status;
if (!shm) {
DEBUGLOG("dosdetector: shm is null in initialize_child");
return;
}
status = apr_global_mutex_child_init(&lock, lock_name, p);
if (status != APR_SUCCESS) {
log_and_cleanup("dosdetector: failed to create lock (lock)", status, s);
return;
}
}
static void upload_progress_child_init(apr_pool_t *p, server_rec *s)
{
apr_status_t sts;
ServerConfig *st = (ServerConfig *)ap_get_module_config(s->module_config,
&upload_progress_module);
if (!st->cache_lock) return;
sts = apr_global_mutex_child_init(&st->cache_lock,
st->lock_file, p);
if (sts != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, sts, s,
"Failed to initialise global mutex %s in child process %"
APR_PID_T_FMT ".",
st->lock_file, getpid());
}
}
int zcache_mutex_reinit(MCConfigRecord *mc,apr_pool_t *p)
{
apr_status_t rv;
if (mc->nMutexMode == ZCACHE_MUTEXMODE_NONE)
return TRUE;
if ((rv = apr_global_mutex_child_init(&mc->pMutex,
mc->szMutexFile, p)) != APR_SUCCESS) {
/* if (mc->szMutexFile)
ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
"Cannot reinit STORAGEMutex with file `%s'",
mc->szMutexFile);
else
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, s,
"Cannot reinit STORAGEMutex");*/
return FALSE;
}
return TRUE;
}
int ssl_mutex_reinit(server_rec *s, apr_pool_t *p)
{
SSLModConfigRec *mc = myModConfig(s);
apr_status_t rv;
if (mc->nMutexMode == SSL_MUTEXMODE_NONE)
return TRUE;
if ((rv = apr_global_mutex_child_init(&mc->pMutex,
mc->szMutexFile, p)) != APR_SUCCESS) {
if (mc->szMutexFile)
ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
"Cannot reinit SSLMutex with file `%s'",
mc->szMutexFile);
else
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, s,
"Cannot reinit SSLMutex");
return FALSE;
}
return TRUE;
}
bool InitAPRGlobalStorageForChild (APRGlobalStorage *storage_p, apr_pool_t *pool_p)
{
bool success_flag = false;
/* Now that we are in a child process, we have to reconnect
* to the global mutex and the shared segment. We also
* have to find out the base address of the segment, in case
* it moved to a new address. */
apr_status_t res = apr_global_mutex_child_init (& (storage_p -> ags_mutex_p), storage_p -> ags_mutex_lock_filename_s, pool_p);
if (res != APR_SUCCESS)
{
PrintErrors (STM_LEVEL_SEVERE, __FILE__, __LINE__, "Failed to attach grassroots child to global mutex file '%s', res %d", storage_p -> ags_mutex_lock_filename_s, res);
}
else
{
success_flag = true;
}
return success_flag;
}
static void initialize_child(apr_pool_t *p, server_rec *s)
{
//DEBUGLOG("initialize_child is called");
apr_status_t status;
if (!shm) {
DEBUGLOG("shm is null in initialize_child");
return;
}
if(!lock) {
DEBUGLOG("global mutex is null in initialize_child");
return;
}
const char *lock_filename = apr_global_mutex_lockfile(lock);
status = apr_global_mutex_child_init(&lock, lock_filename, p);
if (status != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, status, s, "apr_global_mutex_child_init failed");
return;
}
}
static void exipc_child_init(apr_pool_t *p, server_rec *s)
{
apr_status_t rs;
/*
* Re-open the mutex for the child. Note we're reusing
* the mutex pointer global here.
*/
rs = apr_global_mutex_child_init(&exipc_mutex,
(const char *) mutexfilename,
p);
if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s,
"Failed to reopen mutex on file %s",
shmfilename);
/* There's really nothing else we can do here, since This
* routine doesn't return a status. If this ever goes wrong,
* it will turn Apache into a fork bomb. Let's hope it never
* will.
*/
exit(1); /* Ugly, but what else? */
}
}
static void
akismet_child_init(apr_pool_t *p, server_rec *s)
{
apr_status_t ret;
if (!api_cache_shm) {
return;
}
ret = apr_global_mutex_child_init(&global_lock, global_lock_file, p);
if (ret != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s,
"failed to create lock (global_lock)");
cleanup_shm_resources(NULL);
return;
}
if(!api_cache_shm) {
ret = apr_shm_attach( &api_cache_shm, api_cache_shm_file, p);
if (ret != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, ret, s,
"Failed to attach to shared memory file '%s'", api_cache_shm_file);
return;
}
}
key_verified_infos = apr_shm_baseaddr_get(api_cache_shm);
}
/* 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;
}
static void psgi_child_init(apr_pool_t *p, server_rec *s)
{
apr_global_mutex_child_init(&psgi_mutex, (const char *) mutex_name, p);
apr_pool_cleanup_register(p, NULL, psgi_child_exit, psgi_child_exit);
}
