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;
}
/*****************************************************************************
* 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;
}
APR_DECLARE(RMM_OFF_T(rmm_hash_t)) rmm_hash_make(apr_rmm_t *rmm)
{
rmm_hash_t *ht_physical;
RMM_OFF_T(rmm_hash_t) ht_offset;
ht_offset = apr_rmm_malloc(rmm, sizeof(rmm_hash_t));
if (ht_offset == RMM_OFF_NULL) {
return RMM_OFF_NULL;
}
ht_physical = APR_RMM_ADDR_GET(rmm_hash_t, rmm, ht_offset);
ht_physical->free = RMM_OFF_NULL;
ht_physical->count = 0;
ht_physical->max = INITIAL_MAX;
ht_physical->array = alloc_array(rmm, ht_physical->max);
if (ht_physical == RMM_OFF_NULL)
{
apr_rmm_free(rmm, ht_offset);
return RMM_OFF_NULL;
}
ht_physical->hash_func = apr_hashfunc_default;
return ht_offset;
}
static RMM_OFF_T(rmm_hash_entry_t_ptr) alloc_array(apr_rmm_t *rmm, unsigned int max)
{
return apr_rmm_malloc(rmm, sizeof(apr_rmm_off_t) * (max + 1));
}
static void test_rmm(abts_case *tc, void *data)
{
apr_status_t rv;
apr_pool_t *pool;
apr_shm_t *shm;
apr_rmm_t *rmm;
apr_size_t size, fragsize;
apr_rmm_off_t *off, off2;
int i;
void *entity;
rv = apr_pool_create(&pool, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* We're going to want 10 blocks of data from our target rmm. */
size = SHARED_SIZE + apr_rmm_overhead_get(FRAG_COUNT + 1);
rv = apr_shm_create(&shm, size, NULL, pool);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
if (rv != APR_SUCCESS)
return;
rv = apr_rmm_init(&rmm, NULL, apr_shm_baseaddr_get(shm), size, pool);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
if (rv != APR_SUCCESS)
return;
/* Creating each fragment of size fragsize */
fragsize = SHARED_SIZE / FRAG_COUNT;
off = apr_palloc(pool, FRAG_COUNT * sizeof(apr_rmm_off_t));
for (i = 0; i < FRAG_COUNT; i++) {
off[i] = apr_rmm_malloc(rmm, fragsize);
}
/* Checking for out of memory allocation */
off2 = apr_rmm_malloc(rmm, FRAG_SIZE * FRAG_COUNT);
ABTS_TRUE(tc, !off2);
/* Checking each fragment for address alignment */
for (i = 0; i < FRAG_COUNT; i++) {
char *c = apr_rmm_addr_get(rmm, off[i]);
apr_size_t sc = (apr_size_t)c;
ABTS_TRUE(tc, !!off[i]);
ABTS_TRUE(tc, !(sc & 7));
}
/* Setting each fragment to a unique value */
for (i = 0; i < FRAG_COUNT; i++) {
int j;
char **c = apr_rmm_addr_get(rmm, off[i]);
for (j = 0; j < FRAG_SIZE; j++, c++) {
*c = apr_itoa(pool, i + j);
}
}
/* Checking each fragment for its unique value */
for (i = 0; i < FRAG_COUNT; i++) {
int j;
char **c = apr_rmm_addr_get(rmm, off[i]);
for (j = 0; j < FRAG_SIZE; j++, c++) {
char *d = apr_itoa(pool, i + j);
ABTS_STR_EQUAL(tc, d, *c);
}
}
/* Freeing each fragment */
for (i = 0; i < FRAG_COUNT; i++) {
rv = apr_rmm_free(rmm, off[i]);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
/* Creating one large segment */
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE);
/* Setting large segment */
for (i = 0; i < FRAG_COUNT * FRAG_SIZE; i++) {
char **c = apr_rmm_addr_get(rmm, off[0]);
c[i] = apr_itoa(pool, i);
}
/* Freeing large segment */
rv = apr_rmm_free(rmm, off[0]);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Creating each fragment of size fragsize */
for (i = 0; i < FRAG_COUNT; i++) {
off[i] = apr_rmm_malloc(rmm, fragsize);
}
/* Freeing each fragment backwards */
for (i = FRAG_COUNT - 1; i >= 0; i--) {
rv = apr_rmm_free(rmm, off[i]);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
/* Creating one large segment (again) */
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE);
/* Freeing large segment */
rv = apr_rmm_free(rmm, off[0]);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Checking realloc */
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE - 100);
off[1] = apr_rmm_calloc(rmm, 100);
ABTS_TRUE(tc, !!off[0]);
ABTS_TRUE(tc, !!off[1]);
entity = apr_rmm_addr_get(rmm, off[1]);
rv = apr_rmm_free(rmm, off[0]);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
{
unsigned char *c = entity;
/* Fill in the region; the first half with zereos, which will
* likely catch the apr_rmm_realloc offset calculation bug by
* making it think the old region was zero length. */
for (i = 0; i < 100; i++) {
c[i] = (i < 50) ? 0 : i;
}
}
/* now we can realloc off[1] and get many more bytes */
off[0] = apr_rmm_realloc(rmm, entity, SHARED_SIZE - 100);
ABTS_TRUE(tc, !!off[0]);
{
unsigned char *c = apr_rmm_addr_get(rmm, off[0]);
/* fill in the region */
for (i = 0; i < 100; i++) {
ABTS_TRUE(tc, c[i] == (i < 50 ? 0 : i));
}
}
rv = apr_rmm_destroy(rmm);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_shm_destroy(shm);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
apr_pool_destroy(pool);
}
static apr_status_t test_rmm(apr_pool_t *parpool)
{
apr_status_t rv;
apr_pool_t *pool;
apr_shm_t *shm;
apr_rmm_t *rmm;
apr_size_t size, fragsize;
apr_rmm_off_t *off;
int i;
void *entity;
rv = apr_pool_create(&pool, parpool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Error creating child pool\n");
return rv;
}
/* We're going to want 10 blocks of data from our target rmm. */
size = SHARED_SIZE + apr_rmm_overhead_get(FRAG_COUNT + 1);
printf("Creating anonymous shared memory (%"
APR_SIZE_T_FMT " bytes).....", size);
rv = apr_shm_create(&shm, size, NULL, pool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Error allocating shared memory block\n");
return rv;
}
fprintf(stdout, "OK\n");
printf("Creating rmm segment.............................");
rv = apr_rmm_init(&rmm, NULL, apr_shm_baseaddr_get(shm), size,
pool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Error allocating rmm..............\n");
return rv;
}
fprintf(stdout, "OK\n");
fragsize = SHARED_SIZE / FRAG_COUNT;
printf("Creating each fragment of size %" APR_SIZE_T_FMT "................",
fragsize);
off = apr_palloc(pool, FRAG_COUNT * sizeof(apr_rmm_off_t));
for (i = 0; i < FRAG_COUNT; i++) {
off[i] = apr_rmm_malloc(rmm, fragsize);
}
fprintf(stdout, "OK\n");
printf("Checking for out of memory allocation............");
if (apr_rmm_malloc(rmm, FRAG_SIZE * FRAG_COUNT) == 0) {
fprintf(stdout, "OK\n");
}
else {
return APR_EGENERAL;
}
printf("Checking each fragment for address alignment.....");
for (i = 0; i < FRAG_COUNT; i++) {
char *c = apr_rmm_addr_get(rmm, off[i]);
apr_size_t sc = (apr_size_t)c;
if (off[i] == 0) {
printf("allocation failed for offset %d\n", i);
return APR_ENOMEM;
}
if (sc & 7) {
printf("Bad alignment for fragment %d; %p not %p!\n",
i, c, (void *)APR_ALIGN_DEFAULT((apr_size_t)c));
return APR_EGENERAL;
}
}
fprintf(stdout, "OK\n");
printf("Setting each fragment to a unique value..........");
for (i = 0; i < FRAG_COUNT; i++) {
int j;
char **c = apr_rmm_addr_get(rmm, off[i]);
for (j = 0; j < FRAG_SIZE; j++, c++) {
*c = apr_itoa(pool, i + j);
}
}
fprintf(stdout, "OK\n");
printf("Checking each fragment for its unique value......");
for (i = 0; i < FRAG_COUNT; i++) {
int j;
char **c = apr_rmm_addr_get(rmm, off[i]);
for (j = 0; j < FRAG_SIZE; j++, c++) {
char *d = apr_itoa(pool, i + j);
if (strcmp(*c, d) != 0) {
return APR_EGENERAL;
}
}
}
fprintf(stdout, "OK\n");
printf("Freeing each fragment............................");
for (i = 0; i < FRAG_COUNT; i++) {
rv = apr_rmm_free(rmm, off[i]);
if (rv != APR_SUCCESS) {
return rv;
}
}
fprintf(stdout, "OK\n");
printf("Creating one large segment.......................");
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE);
fprintf(stdout, "OK\n");
printf("Setting large segment............................");
for (i = 0; i < FRAG_COUNT * FRAG_SIZE; i++) {
char **c = apr_rmm_addr_get(rmm, off[0]);
c[i] = apr_itoa(pool, i);
}
fprintf(stdout, "OK\n");
printf("Freeing large segment............................");
apr_rmm_free(rmm, off[0]);
fprintf(stdout, "OK\n");
printf("Creating each fragment of size %" APR_SIZE_T_FMT " (again)........",
fragsize);
for (i = 0; i < FRAG_COUNT; i++) {
off[i] = apr_rmm_malloc(rmm, fragsize);
}
fprintf(stdout, "OK\n");
printf("Freeing each fragment backwards..................");
for (i = FRAG_COUNT - 1; i >= 0; i--) {
rv = apr_rmm_free(rmm, off[i]);
if (rv != APR_SUCCESS) {
return rv;
}
}
fprintf(stdout, "OK\n");
printf("Creating one large segment (again)...............");
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE);
fprintf(stdout, "OK\n");
printf("Freeing large segment............................");
apr_rmm_free(rmm, off[0]);
fprintf(stdout, "OK\n");
printf("Checking realloc.................................");
off[0] = apr_rmm_calloc(rmm, SHARED_SIZE - 100);
off[1] = apr_rmm_calloc(rmm, 100);
if (off[0] == 0 || off[1] == 0) {
printf("FAILED\n");
return APR_EINVAL;
}
entity = apr_rmm_addr_get(rmm, off[1]);
rv = apr_rmm_free(rmm, off[0]);
if (rv != APR_SUCCESS) {
printf("FAILED\n");
return rv;
}
{
unsigned char *c = entity;
/* Fill in the region; the first half with zereos, which will
* likely catch the apr_rmm_realloc offset calculation bug by
* making it think the old region was zero length. */
for (i = 0; i < 100; i++) {
c[i] = (i < 50) ? 0 : i;
}
}
/* now we can realloc off[1] and get many more bytes */
off[0] = apr_rmm_realloc(rmm, entity, SHARED_SIZE - 100);
if (off[0] == 0) {
printf("FAILED\n");
return APR_EINVAL;
}
{
unsigned char *c = apr_rmm_addr_get(rmm, off[0]);
/* fill in the region */
for (i = 0; i < 100; i++) {
if (c[i] != (i < 50 ? 0 : i)) {
printf("FAILED at offset %d: %hx\n", i, c[i]);
return APR_EGENERAL;
}
}
}
fprintf(stdout, "OK\n");
printf("Destroying rmm segment...........................");
rv = apr_rmm_destroy(rmm);
if (rv != APR_SUCCESS) {
printf("FAILED\n");
return rv;
}
printf("OK\n");
printf("Destroying shared memory segment.................");
rv = apr_shm_destroy(shm);
if (rv != APR_SUCCESS) {
printf("FAILED\n");
return rv;
}
printf("OK\n");
apr_pool_destroy(pool);
return APR_SUCCESS;
}