/*
*
* Create a new hash table
*
* nrows : number of rows in hash table, primes are best.
* > 0 => we calc the nearest prime .ge. nrows internally
* < 0 => we use the magnitude as nrows.
* keysize : > 0 => bytes in each key, keys are binary bytes,
* all keys are the same size.
* ==0 => keys are strings and are null terminated,
* allowing random key lengths.
* userkeys : > 0 => indicates user owns the key data
* and we should not allocate or free space for it,
* nor should we attempt to free the user key. We just
* save the pointer to the key.
* ==0 => we should copy the keys and manage them internally
* userfree : routine to free users data, null if we should not
* free user data in sfghash_delete(). The routine
* should be of the form 'void userfree(void * userdata)',
* 'free' works for simple allocations.
*/
SFGHASH * sfghash_new( int nrows, int keysize, int userkeys, void (*userfree)(void*p) )
{
int i;
SFGHASH * h;
if( nrows > 0 ) /* make sure we have a prime number */
{
nrows = calcNextPrime( nrows );
}
else /* use the magnitude or nrows as is */
{
nrows = -nrows;
}
h = (SFGHASH*)s_malloc( sizeof(SFGHASH) );
if( !h ) return 0;
memset( h, 0, sizeof(SFGHASH) );
h->sfhashfcn = sfhashfcn_new( nrows );
if( !h->sfhashfcn ) return 0;
h->table = (SFGHASH_NODE**) s_malloc( sizeof(SFGHASH_NODE*) * nrows );
if( !h->table ) return 0;
for( i=0; i<nrows; i++ )
{
h->table[i] = 0;
}
h->userkey = userkeys;
h->keysize = keysize;
h->nrows = nrows;
h->count = 0;
h->userfree = userfree;
h->crow = 0; // findfirst/next current row
h->cnode = 0; // findfirst/next current node ptr
return h;
}
/*
Notes:
if nrows < 0 don't cal the nearest prime.
datasize must be the same for all entries, unless datasize is zero.
maxmem of 0 indicates no memory limits.
*/
SFXHASH * sfxhash_new( int nrows, int keysize, int datasize, int maxmem,
int anr_flag,
int (*anrfree)(void * key, void * data),
int (*usrfree)(void * key, void * data),
int recycle_flag )
{
int i;
SFXHASH * h;
if( nrows > 0 ) /* make sure we have a prime number */
{
nrows = calcNextPrime( nrows );
}
else /* use the magnitude or nrows as is */
{
nrows = -nrows;
}
/* Allocate the table structure from general memory */
//h = (SFXHASH*) calloc( 1, sizeof(SFXHASH) );
h = (SFXHASH*)SnortAlloc(sizeof(SFXHASH));
if( !h )
{
return 0;
}
/* this has a default hashing function */
h->sfhashfcn = sfhashfcn_new( nrows );
if( !h->sfhashfcn )
{
free(h);
return 0;
}
sfmemcap_init( &h->mc, maxmem );
/* Allocate the array of node ptrs */
h->table = (SFXHASH_NODE**) s_malloc( h, sizeof(SFXHASH_NODE*) * nrows );
if( !h->table )
{
free(h->sfhashfcn);
free(h);
return 0;
}
for( i=0; i<nrows; i++ )
{
h->table[i] = 0;
}
h->anrfree = anrfree;
h->usrfree = usrfree;
h->keysize = keysize;
h->datasize = datasize;
h->nrows = nrows;
h->crow = 0;
h->cnode = 0;
h->count = 0;
h->ghead = 0;
h->gtail = 0;
h->anr_count= 0;
h->anr_tries= 0;
h->anr_flag = anr_flag;
h->splay = 1;
h->recycle_nodes = recycle_flag;
h->find_success = 0;
h->find_fail = 0;
/* save off how much we've already allocated from our memcap */
h->overhead_bytes = h->mc.memused;
h->overhead_blocks = h->mc.nblocks;
return h;
}
/*
* Exposed function to return number of rows
*/
int sfxhash_calcrows(int num)
{
return calcNextPrime(num);
}
