static shared_page* shmdata_attachToSharedPage(pool* p, apr_shm_t** shm_t, int segmentsize, char* path){
int overheadsize,usersize, x;
shared_page* page;
apr_status_t rv;
overheadsize=sizeof(shared_page);
usersize=segmentsize*2;
rv = apr_shm_attach(shm_t,path,p);
if(rv!=APR_SUCCESS){
APACHE_LOG_DEBUG("UNABLE TO ATTACH TO SHARED PAGE BAD");
}
if(rv==APR_SUCCESS){
APACHE_LOG_DEBUG1("SHARED PAGES CREATED: Path=%s",path);
page=apr_shm_baseaddr_get(*shm_t);
page->itemmax=MAX_PAGE_ITEMS;
page->segmentsize=segmentsize;
page->timestamp=SHM_TIMESTAMP_INIT;
page->flipcount=0;
page->frontsegment=1;
page->backsegment=0;
page->data=(char*)(page+1);
page->cursor=page->data;
for(x=0;x<SEGMENTS_PER_PAGE;x++){
page->segments[x].itemcount=0;
}
return page;
}
APACHE_LOG_DEBUG("SHARED PAGE BAD");
return NULL;
}
int main(void)
{
apr_status_t rv;
apr_pool_t *pool;
apr_shm_t *shm;
int recvd;
apr_initialize();
if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
exit(-1);
}
rv = apr_shm_attach(&shm, SHARED_FILENAME, pool);
if (rv != APR_SUCCESS) {
exit(-2);
}
boxes = apr_shm_baseaddr_get(shm);
/* consume messages on all of the boxes */
recvd = msgwait(30, 0, N_BOXES); /* wait for 30 seconds for messages */
rv = apr_shm_detach(shm);
if (rv != APR_SUCCESS) {
exit(-3);
}
return recvd;
}
/*
* initialized the shared memory block in the parent process
*/
int oidc_cache_shm_post_config(server_rec *s) {
oidc_cfg *cfg = (oidc_cfg *) ap_get_module_config(s->module_config,
&auth_openidc_module);
if (cfg->cache_cfg != NULL)
return APR_SUCCESS;
oidc_cache_cfg_shm_t *context = oidc_cache_shm_cfg_create(s->process->pool);
cfg->cache_cfg = context;
/* create the shared memory segment */
apr_status_t rv = apr_shm_create(&context->shm,
cfg->cache_shm_entry_size_max * cfg->cache_shm_size_max,
NULL, s->process->pool);
if (rv != APR_SUCCESS) {
oidc_serror(s, "apr_shm_create failed to create shared memory segment");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* initialize the whole segment to '/0' */
int i;
oidc_cache_shm_entry_t *t = apr_shm_baseaddr_get(context->shm);
for (i = 0; i < cfg->cache_shm_size_max; i++, OIDC_CACHE_SHM_ADD_OFFSET(t, cfg->cache_shm_entry_size_max)) {
t->section_key[0] = '\0';
t->access = 0;
}
if (oidc_cache_mutex_post_config(s, context->mutex, "shm") == FALSE)
return HTTP_INTERNAL_SERVER_ERROR;
oidc_sdebug(s, "initialized shared memory with a cache size (# entries) of: %d, and a max (single) entry size of: %d", cfg->cache_shm_size_max, cfg->cache_shm_entry_size_max);
return OK;
}
apr_status_t
mod_but_shm_initialize(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
apr_status_t rv;
apr_pool_t *mypool;
apr_status_t sts;
apr_size_t size;
int i;
rv = apr_pool_create(&mypool, p);
if (rv != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM) Unable to create client pool for SHM");
return rv;
}
size = (apr_size_t)MOD_BUT_SESSION_COUNT * sizeof(mod_but_cookie) + apr_rmm_overhead_get(MOD_BUT_SESSION_COUNT + 1);
ERRLOG_SRV_INFO("(SHM) Size of the shared memory allocation: %d kBytes", size/1024);
sts = apr_shm_create(&cs_shm, size, tmpnam(NULL), p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM) Failed to create shared memory");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM) Successfully created shared memory");
}
sts = apr_rmm_init(&cs_rmm, NULL, apr_shm_baseaddr_get(cs_shm), size, p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM) Failed to initialize the RMM segment");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM) Initialized RMM successfully");
}
ERRLOG_SRV_INFO("(SHM) STARTING to malloc offsets in RMM");
off = apr_palloc(p, MOD_BUT_SESSION_COUNT * sizeof(apr_rmm_off_t));
for (i = 0; i < MOD_BUT_SESSION_COUNT; i++) {
//ap_log_error(PC_LOG_INFO, s, "mod_but_shm.c: Malloc cs_rmm %d", i);
off[i] = apr_rmm_malloc(cs_rmm, sizeof(mod_but_cookie));
}
/*
* Init of RMM with default values
*/
ERRLOG_SRV_INFO("(SHM) STARTING to give every session the default values");
for (i = 0; i < MOD_BUT_SESSION_COUNT; i++) {
mod_but_cookie *c = apr_rmm_addr_get(cs_rmm, off[i]);
apr_cpystrn(c->session_name, "empty", sizeof(c->session_name));
apr_cpystrn(c->session_value, "empty", sizeof(c->session_value));
apr_cpystrn(c->service_list, "empty", sizeof(c->service_list));
c->link_to_cookiestore = -1;
c->logon_state = 0;
c->logon_flag = 0; // used for redirect to ORIG_URL after successful authentication
c->auth_strength = 0;
}
ERRLOG_SRV_INFO("(SHM) END to give every session the default values");
ERRLOG_SRV_INFO("(SHM) Execution of mod_but_shm_initialize was successfully");
apr_pool_cleanup_register(mypool, NULL, shm_cleanup, apr_pool_cleanup_null);
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);
}
/*****************************************************************************
* Cookie Store Functionality
*/
apr_status_t
mod_but_shm_initialize_cookiestore(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
apr_status_t rv;
apr_pool_t *mypool;
apr_status_t sts;
apr_size_t size;
int i;
rv = apr_pool_create(&mypool, p);
if (rv != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Unable to create client pool for SHM cookiestore");
return rv;
}
size = (apr_size_t)MOD_BUT_COOKIESTORE_COUNT * sizeof(mod_but_cookie_cookiestore) + apr_rmm_overhead_get(MOD_BUT_COOKIESTORE_COUNT + 1);
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Size of the shared cookiestore memory allocation: %d kBytes", size/1024);
sts = apr_shm_create(&cs_shm_cookiestore, size, tmpnam(NULL), p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Failed to create shared cookiestore memory");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Successfully created shared cookiestore memory");
}
sts = apr_rmm_init(&cs_rmm_cookiestore, NULL, apr_shm_baseaddr_get(cs_shm_cookiestore), size, p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Failed to initialize the RMM segment");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Initialized RMM successfully");
}
ERRLOG_SRV_INFO("(SHM COOKIESTORE) STARTING to malloc offsets in RMM");
off_cookiestore = apr_palloc(p, MOD_BUT_COOKIESTORE_COUNT * sizeof(apr_rmm_off_t));
for (i = 0; i < MOD_BUT_COOKIESTORE_COUNT; i++) {
//ERRLOG_SRV_INFO("Malloc cs_rmm_cookiestore %d", i);
off_cookiestore[i] = apr_rmm_malloc(cs_rmm_cookiestore, sizeof(mod_but_cookie_cookiestore));
}
/*
* Init of RMM with default values
*/
ERRLOG_SRV_INFO("(SHM COOKIESTORE) STARTING to give every session the default values");
for (i = 0; i < MOD_BUT_COOKIESTORE_COUNT; i++) {
mod_but_cookie_cookiestore *c = apr_rmm_addr_get(cs_rmm_cookiestore, off_cookiestore[i]);
apr_cpystrn(c->cookie_name, "empty", sizeof(c->cookie_name));
apr_cpystrn(c->cookie_value, "empty", sizeof(c->cookie_value));
c->cookie_next = -1;
c->cookie_before = -1;
c->cookie_slot_used = -1;
c->location_id = -1;
}
ERRLOG_SRV_INFO("(SHM COOKIESTORE) END to give every session the default values");
ERRLOG_SRV_INFO("(SHM COOKIESTORE) Execution of mod_but_shm_initialize_cookiestore was successfully");
apr_pool_cleanup_register(mypool, NULL, shm_cleanup_cookiestore, apr_pool_cleanup_null);
return OK;
}
/*
* initialized the shared memory block in the parent process
*/
int oidc_cache_shm_post_config(server_rec *s) {
oidc_cfg *cfg = (oidc_cfg *) ap_get_module_config(s->module_config,
&auth_openidc_module);
if (cfg->cache_cfg != NULL) return APR_SUCCESS;
oidc_cache_cfg_shm_t *context = oidc_cache_shm_cfg_create(s->process->pool);
cfg->cache_cfg = context;
/* create the shared memory segment */
apr_status_t rv = apr_shm_create(&context->shm,
sizeof(oidc_cache_shm_entry_t) * cfg->cache_shm_size_max,
NULL, s->process->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
"oidc_cache_shm_post_config: apr_shm_create failed to create shared memory segment");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* initialize the whole segment to '/0' */
int i;
oidc_cache_shm_entry_t *table = apr_shm_baseaddr_get(context->shm);
for (i = 0; i < cfg->cache_shm_size_max; i++) {
table[i].key[0] = '\0';
table[i].access = 0;
}
const char *dir;
apr_temp_dir_get(&dir, s->process->pool);
/* construct the mutex filename */
context->mutex_filename = apr_psprintf(s->process->pool,
"%s/httpd_mutex.%ld.%pp", dir, (long int) getpid(), s);
/* create the mutex lock */
rv = apr_global_mutex_create(&context->mutex,
(const char *) context->mutex_filename, APR_LOCK_DEFAULT,
s->process->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
"oidc_cache_shm_post_config: apr_global_mutex_create failed to create mutex on file %s",
context->mutex_filename);
return HTTP_INTERNAL_SERVER_ERROR;
}
/* need this on Linux */
#ifdef AP_NEED_SET_MUTEX_PERMS
#if MODULE_MAGIC_NUMBER_MAJOR >= 20081201
rv = ap_unixd_set_global_mutex_perms(context->mutex);
#else
rv = unixd_set_global_mutex_perms(context->mutex);
#endif
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, s,
"oidc_cache_shm_post_config: unixd_set_global_mutex_perms failed; could not set permissions ");
return HTTP_INTERNAL_SERVER_ERROR;
}
#endif
return OK;
}
/*
* 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;
}
static void init_shm(lua_State *L, lua_apr_shm *object)
{
object->base = apr_shm_baseaddr_get(object->handle);
object->size = apr_shm_size_get(object->handle);
object->last_op = &object->input.buffer;
init_unmanaged_buffers(L,
&object->input, &object->output,
object->base, object->size);
}
/* Create or reinit an existing scoreboard. The MPM can control whether
* the scoreboard is shared across multiple processes or not
*/
int ap_create_scoreboard(apr_pool_t *p, ap_scoreboard_e sb_type)
{
int i;
#if APR_HAS_SHARED_MEMORY
apr_status_t rv;
#endif
if (ap_scoreboard_image) {
ap_scoreboard_image->global->restart_time = apr_time_now();
memset(ap_scoreboard_image->parent, 0,
sizeof(process_score) * server_limit);
for (i = 0; i < server_limit; i++) {
memset(ap_scoreboard_image->servers[i], 0,
sizeof(worker_score) * thread_limit);
}
/* Clean up the lb workers data */
if (lb_limit) {
memset(ap_scoreboard_image->balancers, 0,
sizeof(lb_score) * lb_limit);
}
return OK;
}
ap_calc_scoreboard_size();
#if APR_HAS_SHARED_MEMORY
if (sb_type == SB_SHARED) {
void *sb_shared;
rv = open_scoreboard(p);
if (rv || !(sb_shared = apr_shm_baseaddr_get(ap_scoreboard_shm))) {
return HTTP_INTERNAL_SERVER_ERROR;
}
memset(sb_shared, 0, scoreboard_size);
ap_init_scoreboard(sb_shared);
}
else
#endif
{
/* A simple malloc will suffice */
void *sb_mem = calloc(1, scoreboard_size);
if (sb_mem == NULL) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, NULL,
"(%d)%s: cannot allocate scoreboard",
errno, strerror(errno));
return HTTP_INTERNAL_SERVER_ERROR;
}
ap_init_scoreboard(sb_mem);
}
ap_scoreboard_image->global->sb_type = scoreboard_type = sb_type;
ap_scoreboard_image->global->running_generation = 0;
ap_scoreboard_image->global->restart_time = apr_time_now();
apr_pool_cleanup_register(p, NULL, ap_cleanup_scoreboard, apr_pool_cleanup_null);
return OK;
}
bool LLPluginSharedMemory::map(void)
{
mMappedAddress = apr_shm_baseaddr_get(mImpl->mAprSharedMemory);
if(mMappedAddress == NULL)
{
return false;
}
return true;
}
/* Initialize the session table.
*
* Parameters:
* am_mod_cfg_rec *mod_cfg The module configuration.
*
* Returns:
* Nothing.
*/
void am_cache_init(am_mod_cfg_rec *mod_cfg)
{
void *table;
apr_size_t i;
/* Initialize the session table. */
table = apr_shm_baseaddr_get(mod_cfg->cache);
for (i = 0; i < mod_cfg->init_cache_size; i++) {
am_cache_entry_t *e = am_cache_entry_ptr(mod_cfg, table, i);
e->key[0] = '\0';
e->access = 0;
}
}
/*
* get a value from the shared memory cache
*/
static apr_byte_t oidc_cache_shm_get(request_rec *r, const char *section,
const char *key, const char **value) {
oidc_debug(r, "enter, section=\"%s\", key=\"%s\"", section, key);
oidc_cfg *cfg = ap_get_module_config(r->server->module_config,
&auth_openidc_module);
oidc_cache_cfg_shm_t *context = (oidc_cache_cfg_shm_t *) cfg->cache_cfg;
int i;
const char *section_key = oidc_cache_shm_get_key(r->pool, section, key);
*value = NULL;
/* grab the global lock */
if (oidc_cache_mutex_lock(r, context->mutex) == FALSE)
return FALSE;
/* get the pointer to the start of the shared memory block */
oidc_cache_shm_entry_t *t = apr_shm_baseaddr_get(context->shm);
/* loop over the block, looking for the key */
for (i = 0; i < cfg->cache_shm_size_max; i++, OIDC_CACHE_SHM_ADD_OFFSET(t, cfg->cache_shm_entry_size_max)) {
const char *tablekey = t->section_key;
if ( (tablekey != NULL) && (apr_strnatcmp(tablekey, section_key) == 0) ) {
/* found a match, check if it has expired */
if (t->expires > apr_time_now()) {
/* update access timestamp */
t->access = apr_time_now();
*value = t->value;
} else {
/* clear the expired entry */
t->section_key[0] = '\0';
t->access = 0;
}
/* we safely can break now since we would not have found an expired match twice */
break;
}
}
/* release the global lock */
oidc_cache_mutex_unlock(r, context->mutex);
return (*value == NULL) ? FALSE : TRUE;
}
shared_page* shmdata_getNewSharedPage(pool* p, apr_shm_t** shm_t, int segmentsize, char* path){
int overheadsize,usersize, x;
shared_page* page;
apr_status_t rv;
overheadsize=sizeof(shared_page);
usersize=segmentsize*2;
rv=apr_shm_create(shm_t,overheadsize+usersize,path,p);
#ifdef WIN32
if(rv==APR_EEXIST) { // try to attach it; seems windows specific behaviour
rv = apr_shm_attach(shm_t,path,p);
}
#endif
if(rv!=APR_SUCCESS){
//if failure then try to remove shm segment and try again
if(apr_shm_attach(shm_t,path,p)==APR_SUCCESS){
apr_shm_destroy(*shm_t);
rv=apr_shm_create(shm_t,overheadsize+usersize,path,p);
//if again failure..possible bad shm file...remove and retry
if(rv!=APR_SUCCESS){
rv=apr_file_remove(path,p);
if(rv==APR_SUCCESS){
rv=apr_shm_create(shm_t,overheadsize+usersize,path,p);
}
}
}else{ //if cannot attach blow file away and try again
rv=apr_file_remove(path,p);
if(rv==APR_SUCCESS){
rv=apr_shm_create(shm_t,overheadsize+usersize,path,p);
}
}
}
if(rv==APR_SUCCESS){
APACHE_LOG_DEBUG1("SHARED PAGES CREATED: Path=%s",path);
page=apr_shm_baseaddr_get(*shm_t);
page->itemmax=MAX_PAGE_ITEMS;
page->segmentsize=segmentsize;
page->timestamp=SHM_TIMESTAMP_INIT;
page->flipcount=0;
page->frontsegment=1;
page->backsegment=0;
page->data=(char*)(page+1);
page->cursor=page->data;
for(x=0;x<SEGMENTS_PER_PAGE;x++){
page->segments[x].itemcount=0;
}
return page;
}
APACHE_LOG_DEBUG("SHARED PAGE BAD");
return NULL;
}
apr_status_t upload_progress_cache_init(apr_pool_t *pool, ServerConfig *config)
{
#if APR_HAS_SHARED_MEMORY
apr_status_t result;
apr_size_t size;
upload_progress_cache_t *cache;
apr_rmm_off_t block;
if (config->cache_file) {
/* Remove any existing shm segment with this name. */
apr_shm_remove(config->cache_file, config->pool);
}
size = APR_ALIGN_DEFAULT(config->cache_bytes);
result = apr_shm_create(&config->cache_shm, size, config->cache_file, config->pool);
if (result != APR_SUCCESS) {
return result;
}
/* Determine the usable size of the shm segment. */
size = apr_shm_size_get(config->cache_shm);
/* This will create a rmm "handler" to get into the shared memory area */
result = apr_rmm_init(&config->cache_rmm, NULL,
apr_shm_baseaddr_get(config->cache_shm), size,
config->pool);
if (result != APR_SUCCESS) {
return result;
}
apr_pool_cleanup_register(config->pool, config , upload_progress_cache_module_kill, apr_pool_cleanup_null);
/* init cache object */
CACHE_LOCK();
block = apr_rmm_calloc(config->cache_rmm, sizeof(upload_progress_cache_t));
cache = block ? (upload_progress_cache_t *)apr_rmm_addr_get(config->cache_rmm, block) : NULL;
if(cache == NULL) {
CACHE_UNLOCK();
return 0;
}
cache->head = NULL;
config->cache_offset = block;
config->cache = cache;
CACHE_UNLOCK();
#endif
return APR_SUCCESS;
}
static void test_shm_allocate(abts_case *tc, void *data)
{
apr_status_t rv;
apr_shm_t *shm = NULL;
rv = apr_shm_create(&shm, SHARED_SIZE, NULL, p);
APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv);
ABTS_PTR_NOTNULL(tc, shm);
boxes = apr_shm_baseaddr_get(shm);
ABTS_PTR_NOTNULL(tc, boxes);
rv = apr_shm_destroy(shm);
APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv);
}
/*
* get a value from the shared memory cache
*/
static apr_byte_t oidc_cache_shm_get(request_rec *r, const char *key,
const char **value) {
ap_log_rerror(APLOG_MARK, OIDC_DEBUG, 0, r,
"oidc_cache_shm_get: entering \"%s\"", key);
oidc_cfg *cfg = ap_get_module_config(r->server->module_config,
&auth_openidc_module);
oidc_cache_cfg_shm_t *context = (oidc_cache_cfg_shm_t *)cfg->cache_cfg;
apr_status_t rv;
int i;
*value = NULL;
/* grab the global lock */
if ((rv = apr_global_mutex_lock(context->mutex)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"oidc_cache_shm_get: apr_global_mutex_lock() failed [%d]", rv);
return FALSE;
}
/* get the pointer to the start of the shared memory block */
oidc_cache_shm_entry_t *table = apr_shm_baseaddr_get(context->shm);
/* loop over the block, looking for the key */
for (i = 0; i < cfg->cache_shm_size_max; i++) {
const char *tablekey = table[i].key;
if (tablekey == NULL)
continue;
if (strcmp(tablekey, key) == 0) {
/* found a match, check if it has expired */
if (table[i].expires > apr_time_now()) {
/* update access timestamp */
table[i].access = apr_time_now();
*value = table[i].value;
}
}
}
/* release the global lock */
apr_global_mutex_unlock(context->mutex);
return (*value == NULL) ? FALSE : TRUE;
}
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 test_anon(abts_case *tc, void *data)
{
apr_proc_t proc;
apr_status_t rv;
apr_shm_t *shm;
apr_size_t retsize;
int cnt, i;
int recvd;
rv = apr_shm_create(&shm, SHARED_SIZE, NULL, p);
APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv);
ABTS_PTR_NOTNULL(tc, shm);
retsize = apr_shm_size_get(shm);
ABTS_INT_EQUAL(tc, SHARED_SIZE, retsize);
boxes = apr_shm_baseaddr_get(shm);
ABTS_PTR_NOTNULL(tc, boxes);
rv = apr_proc_fork(&proc, p);
if (rv == APR_INCHILD) { /* child */
int num = msgwait(5, 0, N_BOXES);
/* exit with the number of messages received so that the parent
* can check that all messages were received.
*/
exit(num);
}
else if (rv == APR_INPARENT) { /* parent */
i = N_BOXES;
cnt = 0;
while (cnt++ < N_MESSAGES) {
if ((i-=3) < 0) {
i += N_BOXES; /* start over at the top */
}
msgput(i, MSG);
apr_sleep(apr_time_make(0, 10000));
}
}
else {
ABTS_FAIL(tc, "apr_proc_fork failed");
}
/* wait for the child */
rv = apr_proc_wait(&proc, &recvd, NULL, APR_WAIT);
ABTS_INT_EQUAL(tc, N_MESSAGES, recvd);
rv = apr_shm_destroy(shm);
APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv);
}
int reattach_dir_sync(music_globals_t* music_globals){
int i = 0;
int status = 0;
for(i = 0; i < music_globals->music_dirs->nelts; i++){
dir_t* dir = &(((dir_t*)music_globals->music_dirs->elts)[i]);
if(dir->shm_file){
status = apr_shm_attach(&(dir->shm), dir->shm_file, music_globals->pool);
if(status != APR_SUCCESS){
return status;
}
dir->stats = apr_shm_baseaddr_get(dir->shm);
}
}
return status;
}
DownloadFlowController *DownloadFlowController::get_instance(apr_shm_t *shm)
{
DownloadFlowController *flow_controller;
#ifdef DEBUG
if (apr_shm_size_get(shm) != get_memory_size()) {
THROW(MESSAGE_SHM_SIZE_INVALID);
}
#endif
flow_controller =
reinterpret_cast<DownloadFlowController *>(apr_shm_baseaddr_get(shm));
new(flow_controller) DownloadFlowController;
return flow_controller;
}
/* Create or reinit an existing scoreboard. The MPM can control whether
* the scoreboard is shared across multiple processes or not
*/
int ap_create_scoreboard(apr_pool_t *p, ap_scoreboard_e sb_type)
{
int i;
#if APR_HAS_SHARED_MEMORY
apr_status_t rv;
#endif
pfn_ap_logio_get_last_bytes = APR_RETRIEVE_OPTIONAL_FN(ap_logio_get_last_bytes);
if (ap_scoreboard_image) {
ap_scoreboard_image->global->restart_time = apr_time_now();
memset(ap_scoreboard_image->parent, 0,
sizeof(process_score) * server_limit);
for (i = 0; i < server_limit; i++) {
memset(ap_scoreboard_image->servers[i], 0,
sizeof(worker_score) * thread_limit);
}
return OK;
}
ap_calc_scoreboard_size();
#if APR_HAS_SHARED_MEMORY
if (sb_type == SB_SHARED) {
void *sb_shared;
rv = open_scoreboard(p);
if (rv || !(sb_shared = apr_shm_baseaddr_get(ap_scoreboard_shm))) {
return HTTP_INTERNAL_SERVER_ERROR;
}
memset(sb_shared, 0, scoreboard_size);
ap_init_scoreboard(sb_shared);
}
else
#endif
{
/* A simple malloc will suffice */
void *sb_mem = ap_calloc(1, scoreboard_size);
ap_init_scoreboard(sb_mem);
}
scoreboard_type = sb_type;
ap_scoreboard_image->global->running_generation = 0;
ap_scoreboard_image->global->restart_time = apr_time_now();
apr_pool_cleanup_register(p, NULL, ap_cleanup_scoreboard, apr_pool_cleanup_null);
return OK;
}
apr_status_t util_ldap_cache_init(apr_pool_t *pool, util_ldap_state_t *st)
{
#if APR_HAS_SHARED_MEMORY
apr_status_t result;
apr_size_t size;
if (st->cache_bytes > 0) {
if (st->cache_file) {
/* Remove any existing shm segment with this name. */
apr_shm_remove(st->cache_file, st->pool);
}
size = APR_ALIGN_DEFAULT(st->cache_bytes);
result = apr_shm_create(&st->cache_shm, size, st->cache_file, st->pool);
if (result != APR_SUCCESS) {
return result;
}
/* Determine the usable size of the shm segment. */
size = apr_shm_size_get(st->cache_shm);
/* This will create a rmm "handler" to get into the shared memory area */
result = apr_rmm_init(&st->cache_rmm, NULL,
apr_shm_baseaddr_get(st->cache_shm), size,
st->pool);
if (result != APR_SUCCESS) {
return result;
}
}
#endif
apr_pool_cleanup_register(st->pool, st , util_ldap_cache_module_kill, apr_pool_cleanup_null);
st->util_ldap_cache =
util_ald_create_cache(st,
st->search_cache_size,
st->search_cache_ttl,
util_ldap_url_node_hash,
util_ldap_url_node_compare,
util_ldap_url_node_copy,
util_ldap_url_node_free,
util_ldap_url_node_display);
return APR_SUCCESS;
}
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;
}
static apr_status_t
_create_shm_if_needed(char *shm_path, server_rec *server, apr_pool_t *plog)
{
apr_pool_t *ppool = server->process->pool;
apr_shm_t *shm = NULL;
apr_status_t rc;
// Test if an SHM segment already exists
apr_pool_userdata_get((void**)&shm, SHM_HANDLE_KEY, ppool);
if (shm == NULL) {
DAV_DEBUG_POOL(plog, 0, "%s: Creating SHM segment at [%s]",
__FUNCTION__, shm_path);
// Create a new SHM segment
rc = apr_shm_create(&shm, sizeof(struct shm_stats_s), shm_path, ppool);
if (rc != APR_SUCCESS) {
char buff[256];
DAV_ERROR_POOL(plog, 0, "Failed to create the SHM segment at [%s]: %s",
shm_path, apr_strerror(rc, buff, sizeof(buff)));
return rc;
}
/* Init the SHM */
void *ptr_counter = apr_shm_baseaddr_get(shm);
if (ptr_counter) {
memset(ptr_counter, 0, sizeof(struct shm_stats_s));
/* init rrd's */
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_sec));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_duration));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_put_sec));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_put_duration));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_get_sec));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_get_duration));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_req_del_sec));
rawx_stats_rrd_init(&(((struct shm_stats_s *) ptr_counter)->body.rrd_del_duration));
}
// Save the SHM handle in the process' pool, without cleanup callback
apr_pool_userdata_set(shm, SHM_HANDLE_KEY, NULL, ppool);
// Register the cleanup callback to be executed BEFORE pool cleanup
apr_pool_pre_cleanup_register(ppool, shm, _destroy_shm_cb);
} else {
DAV_DEBUG_POOL(plog, 0, "%s: Found an already created SHM segment",
__FUNCTION__);
}
return APR_SUCCESS;
}
apr_status_t util_ldap_cache_init(apr_pool_t *pool, util_ldap_state_t *st)
{
#if APR_HAS_SHARED_MEMORY
apr_status_t result;
apr_size_t size;
size = APR_ALIGN_DEFAULT(st->cache_bytes);
result = apr_shm_create(&st->cache_shm, size, st->cache_file, st->pool);
if (result == APR_EEXIST) {
/*
* The cache could have already been created (i.e. we may be a child process). See
* if we can attach to the existing shared memory
*/
result = apr_shm_attach(&st->cache_shm, st->cache_file, st->pool);
}
if (result != APR_SUCCESS) {
return result;
}
/* Determine the usable size of the shm segment. */
size = apr_shm_size_get(st->cache_shm);
/* This will create a rmm "handler" to get into the shared memory area */
result = apr_rmm_init(&st->cache_rmm, NULL,
apr_shm_baseaddr_get(st->cache_shm), size,
st->pool);
if (result != APR_SUCCESS) {
return result;
}
#endif
apr_pool_cleanup_register(st->pool, st , util_ldap_cache_module_kill, apr_pool_cleanup_null);
st->util_ldap_cache =
util_ald_create_cache(st,
util_ldap_url_node_hash,
util_ldap_url_node_compare,
util_ldap_url_node_copy,
util_ldap_url_node_free,
util_ldap_url_node_display);
return APR_SUCCESS;
}
static apr_status_t create_shm(server_rec *s,apr_pool_t *p)
{
size_t size;
apr_status_t rc;
size = sizeof(client_list_t) + table_size * sizeof(client_t);
if(shmname != NULL) {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, s, "creating named shared memory '%s'", shmname);
rc = apr_shm_remove(shmname, p);
if (APR_SUCCESS == rc) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"removed the existing shared memory segment named '%s'", shmname);
}
} else {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, s, "creating anonymous shared memory");
}
rc = apr_shm_create(&shm, size, shmname, p);
if (APR_SUCCESS != rc) {
return rc;
}
client_list = apr_shm_baseaddr_get(shm);
memset(client_list, 0, size);
if(shmname != NULL) {
/* prevent other processes from accessing the segment */
apr_shm_remove(shmname, p);
}
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;
return APR_SUCCESS;
}
static const char *
__gen_stats(const dav_resource *resource, apr_pool_t *pool)
{
DAV_XDEBUG_POOL(pool, 0, "%s()", __FUNCTION__);
dav_rainx_server_conf *c = resource_get_server_config(resource);
apr_global_mutex_lock(c->lock.handle);
struct shm_stats_s *stats = apr_shm_baseaddr_get(c->shm.handle);
apr_global_mutex_unlock(c->lock.handle);
return apr_pstrcat(pool,
STR_KV(time_all, "counter req.time"),
STR_KV(time_put, "counter req.time.put"),
STR_KV(time_get, "counter req.time.get"),
STR_KV(time_del, "counter req.time.del"),
STR_KV(time_stat, "counter req.time.stat"),
STR_KV(time_info, "counter req.time.info"),
STR_KV(time_raw, "counter req.time.raw"),
STR_KV(time_other, "counter req.time.other"),
STR_KV(req_all, "counter req.hits"),
STR_KV(req_chunk_put, "counter req.hits.put"),
STR_KV(req_chunk_get, "counter req.hits.get"),
STR_KV(req_chunk_del, "counter req.hits.del"),
STR_KV(req_stat, "counter req.hits.stat"),
STR_KV(req_info, "counter req.hits.info"),
STR_KV(req_raw, "counter req.hits.raw"),
STR_KV(req_other, "counter req.hits.other"),
STR_KV(rep_2XX, "counter rep.hits.2xx"),
STR_KV(rep_4XX, "counter rep.hits.4xx"),
STR_KV(rep_5XX, "counter rep.hits.5xx"),
STR_KV(rep_other, "counter rep.hits.other"),
STR_KV(rep_403, "counter rep.hits.403"),
STR_KV(rep_404, "counter rep.hits.404"),
STR_KV(rep_bread, "counter rep.bread"),
STR_KV(rep_bwritten, "counter rep.bwritten"),
NULL);
}
static void proc_mutex(CuTest *tc)
{
#if APR_HAS_FORK
apr_status_t rv;
const char *shmname = "tpm.shm";
apr_shm_t *shm;
/* Use anonymous shm if available. */
rv = apr_shm_create(&shm, sizeof(int), NULL, p);
if (rv == APR_ENOTIMPL) {
apr_file_remove(shmname, p);
rv = apr_shm_create(&shm, sizeof(int), shmname, p);
}
apr_assert_success(tc, "create shm segment", rv);
x = apr_shm_baseaddr_get(shm);
test_exclusive(tc, NULL);
#else
CuNotImpl(tc, "APR lacks fork() support");
#endif
}
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);
}
