/* Free lookup table */
void sfrt_flat_free(TABLE_PTR table_ptr)
{
table_flat_t *table;
uint8_t *base;
if(!table_ptr)
{
/* What are you calling me for? */
return;
}
base = (uint8_t *)segment_basePtr();
table = (table_flat_t *)(&base[table_ptr]);
if(!table->data)
{
/* This really really should not have happened */
}
else
{
segment_free(table->data);
}
if(!table->rt)
{
/* This should not have happened either */
}
else
{
sfrt_dir_flat_free( table->rt );
}
#ifdef SUP_IP6
if(!table->rt6)
{
/* This should not have happened either */
}
else
{
sfrt_dir_flat_free( table->rt6 );
}
#endif
segment_free(table_ptr);
}
void post_free(post_t *post)
{
int i;
if(post == NULL)
return;
for (i = 0; i < post->num_groups; i++)
free(post->groups[i]);
for (i = 0; i < post->num_segments; i++)
segment_free(post->segments[i]);
free(post->subject);
free(post);
}
/* Create new lookup table
* @param table_flat_type Type of table. Uses the types enumeration in route.h
* @param ip_type IPv4 or IPv6. Uses the types enumeration in route.h
* @param data_size Max number of unique data entries
*
* Returns the new table. */
table_flat_t *sfrt_flat_new(char table_flat_type, char ip_type, long data_size, uint32_t mem_cap)
{
table_flat_t *table;
MEM_OFFSET table_ptr;
uint8_t *base;
table_ptr = segment_malloc(sizeof(table_flat_t));
if(!table_ptr)
{
// return NULL;
}
base = (uint8_t *)segment_basePtr();
table = (table_flat_t *)(&base[table_ptr]);
#ifndef SUP_IP6
/* IPv6 is not supported */
if(ip_type == IPv6)
{
segment_free(table_ptr);
return NULL;
}
#endif
/* If this limit is exceeded, there will be no way to distinguish
* between pointers and indeces into the data table. Only
* applies to DIR-n-m. */
#if SIZEOF_LONG_INT == 8
if(data_size >= 0x800000000000000)
#else
if(data_size >= 0x8000000)
#endif
{
segment_free(table_ptr);
return NULL;
}
/* mem_cap is specified in megabytes, but internally uses bytes. Convert */
mem_cap *= 1024*1024;
/* Maximum allowable number of stored entries */
table->max_size = data_size;
table->data = (INFO)segment_calloc(sizeof(INFO) * table->max_size, 1);
if(!table->data)
{
segment_free(table_ptr);
return NULL;
}
table->allocated = sizeof(table_flat_t) + sizeof(INFO) * table->max_size;
table->ip_type = ip_type;
table->table_flat_type = table_flat_type;
/* This will point to the actual table lookup algorithm */
table->rt = 0;
#ifdef SUP_IP6
table->rt6 = 0;
#endif
/* index 0 will be used for failed lookups, so set this to 1 */
table->num_ent = 1;
/* Allocate the user-specified DIR-n-m table */
switch(table_flat_type)
{
case DIR_24_8:
table->rt = sfrt_dir_flat_new( mem_cap, 2, 24, 8);
break;
case DIR_16x2:
table->rt = sfrt_dir_flat_new( mem_cap, 2, 16,16);
break;
case DIR_16_8x2:
table->rt = sfrt_dir_flat_new( mem_cap, 3, 16,8,8);
break;
case DIR_16_4x4:
table->rt = sfrt_dir_flat_new( mem_cap, 5, 16,4,4,4,4);
break;
case DIR_8x4:
table->rt = sfrt_dir_flat_new( mem_cap, 4, 8,8,8,8);
break;
/* There is no reason to use 4x8 except for benchmarking and
* comparison purposes. */
case DIR_4x8:
table->rt = sfrt_dir_flat_new( mem_cap, 8, 4,4,4,4,4,4,4,4);
break;
/* There is no reason to use 2x16 except for benchmarking and
* comparison purposes. */
case DIR_2x16:
table->rt = sfrt_dir_flat_new( mem_cap, 16,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2);
break;
#ifdef SUP_IP6
case DIR_16_4x4_16x5_4x4:
table->rt = sfrt_dir_flat_new(mem_cap, 5, 16,4,4,4,4);
table->rt6 = sfrt_dir_flat_new(mem_cap, 14, 16,4,4,4,4,16,16,16,16,16,4,4,4,4);
break;
case DIR_16x7_4x4:
table->rt = sfrt_dir_flat_new(mem_cap, 5, 16,4,4,4,4);
table->rt6 = sfrt_dir_flat_new(mem_cap, 11, 16,16,16,16,16,16,16,4,4,4,4);
break;
case DIR_16x8:
table->rt = sfrt_dir_flat_new(mem_cap, 2, 16,16);
table->rt6 = sfrt_dir_flat_new(mem_cap, 8, 16,16,16,16,16,16,16,16);
break;
case DIR_8x16:
table->rt = sfrt_dir_flat_new( mem_cap, 4, 16,8,4,4);
table->rt6 = sfrt_dir_flat_new(mem_cap, 16,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8);
break;
#endif
};
if(!table->rt)
{
segment_free(table->data);
segment_free(table_ptr);
return NULL;
}
#ifdef SUP_IP6
if (!table->rt6)
{
sfrt_dir_flat_free( table->rt );
segment_free(table->data);
segment_free(table_ptr);
}
#endif
return table;
}
