/* Perform a lookup on value contained in "ip" */
GENERIC sfrt_flat_lookup(void *adr, table_flat_t *table)
{
tuple_flat_t tuple;
INFO *data;
sfip_t *ip;
TABLE_PTR rt = 0;
uint8_t *base;
if(!adr)
{
return NULL;
}
if(!table)
{
return NULL;
}
ip = adr;
if (ip->family == AF_INET)
{
rt = table->rt;
}
else if (ip->family == AF_INET6)
{
rt = table->rt6;
}
if (!rt)
{
return NULL;
}
tuple = sfrt_dir_flat_lookup(ip, rt);
if(tuple.index >= table->num_ent)
{
return NULL;
}
base = (uint8_t *)segment_basePtr();
data = (INFO *)(&base[table->data]);
if (data[tuple.index])
return (GENERIC) &base[data[tuple.index]];
else
return NULL;
}
/* Perform a lookup on value contained in "ip" */
GENERIC sfrt_flat_lookup(sfaddr_t *ip, table_flat_t *table)
{
tuple_flat_t tuple;
uint32_t* adr;
int numAdrDwords;
INFO *data;
TABLE_PTR rt;
uint8_t *base;
if(!ip)
{
return NULL;
}
if(!table)
{
return NULL;
}
if (sfaddr_family(ip) == AF_INET)
{
adr = sfaddr_get_ip4_ptr(ip);
numAdrDwords = 1;
rt = table->rt;
}
else
{
adr = sfaddr_get_ip6_ptr(ip);
numAdrDwords = 4;
rt = table->rt6;
}
tuple = sfrt_dir_flat_lookup(adr, numAdrDwords, rt);
if(tuple.index >= table->num_ent)
{
return NULL;
}
base = (uint8_t *)segment_basePtr();
data = (INFO *)(&base[table->data]);
if (data[tuple.index])
return (GENERIC) &base[data[tuple.index]];
else
return NULL;
}
/* Insert "ip", of length "len", into "table", and have it point to "ptr" */
int sfrt_flat_insert(void *adr, unsigned char len, INFO ptr,
int behavior, table_flat_t* table)
{
int index;
int res;
INFO *data;
#ifdef SUP_IP6
sfip_t *ip;
#else
uint32_t ip;
#endif
tuple_flat_t tuple;
TABLE_PTR rt = 0;
uint8_t *base;
if(!adr )
{
return RT_INSERT_FAILURE;
}
if (len == 0)
return RT_INSERT_FAILURE;
if(!table || !table->data)
{
return RT_INSERT_FAILURE;
}
if( (table->ip_type == IPv4 && len > 32) ||
(table->ip_type == IPv6 && len > 128) )
{
return RT_INSERT_FAILURE;
}
#ifdef SUP_IP6
ip = adr;
#else
ip = *(uint32_t*)adr;
#endif
#ifdef SUP_IP6
if (ip->family == AF_INET)
{
rt = table->rt;
}
else if (ip->family == AF_INET6)
{
rt = table->rt6;
}
#else
rt = table->rt;
#endif
if (!rt)
{
return RT_INSERT_FAILURE;
}
tuple = sfrt_dir_flat_lookup(ip, table->rt);
if(tuple.length != len)
{
if( table->num_ent >= table->max_size)
{
return RT_POLICY_TABLE_EXCEEDED;
}
index = table->num_ent;
table->num_ent++;
}
else
{
index = tuple.index;
}
/* Insert value into policy table */
base = (uint8_t *)segment_basePtr();
data = (INFO *)(&base[table->data]);
data[index] = ptr;
/* The actual value that is looked-up is an index
* into the data table. */
res = sfrt_dir_flat_insert(ip, len, index, behavior, rt);
/* Check if we ran out of memory. If so, need to decrement
* table->num_ent */
if(res == MEM_ALLOC_FAILURE)
{
/* From the control flow above, it's possible table->num_ent was not
* incremented. It should be safe to decrement here, because the only
* time it will be incremented above is when we are potentially
* mallocing one or more new entries (It's not incremented when we
* overwrite an existing entry). */
table->num_ent--;
}
return res;
}
/* Perform a lookup on value contained in "ip" */
GENERIC sfrt_flat_lookup(void *adr, table_flat_t *table)
{
tuple_flat_t tuple;
INFO *data;
#ifdef SUP_IP6
sfip_t *ip;
#else
uint32_t ip;
#endif
TABLE_PTR rt = 0;
uint8_t *base;
if(!adr)
{
return NULL;
}
if(!table)
{
return NULL;
}
#ifdef SUP_IP6
ip = adr;
if (ip->family == AF_INET)
{
rt = table->rt;
}
else if (ip->family == AF_INET6)
{
rt = table->rt6;
}
#else
/* IPv6 not yet supported */
if(table->ip_type == IPv6)
{
return NULL;
}
ip = *(uint32_t*)adr;
rt = table->rt;
#endif
if (!rt)
{
return NULL;
}
tuple = sfrt_dir_flat_lookup(ip, rt);
if(tuple.index >= table->num_ent)
{
return NULL;
}
base = (uint8_t *)segment_basePtr();
data = (INFO *)(&base[table->data]);
if (data[tuple.index])
return (GENERIC) &base[data[tuple.index]];
else
return NULL;
}
/* Insert "ip", of length "len", into "table", and have it point to "ptr" */
int sfrt_flat_insert(sfcidr_t *ip, unsigned char len, INFO ptr,
int behavior, table_flat_t* table, updateEntryInfoFunc updateEntry)
{
int index;
int res = RT_SUCCESS;
INFO *data;
tuple_flat_t tuple;
uint32_t* adr;
int numAdrDwords;
TABLE_PTR rt;
uint8_t *base;
int64_t bytesAllocated;
if(!ip)
{
return RT_INSERT_FAILURE;
}
if (len == 0)
return RT_INSERT_FAILURE;
if(!table || !table->data)
{
return RT_INSERT_FAILURE;
}
if(len > 128)
{
return RT_INSERT_FAILURE;
}
if (sfaddr_family(&ip->addr) == AF_INET)
{
if (len < 96)
{
return RT_INSERT_FAILURE;
}
len -= 96;
adr = sfip_get_ip4_ptr(ip);
numAdrDwords = 1;
rt = table->rt;
}
else
{
adr = sfip_get_ip6_ptr(ip);
numAdrDwords = 4;
rt = table->rt6;
}
tuple = sfrt_dir_flat_lookup(adr, numAdrDwords, rt);
base = (uint8_t *)segment_basePtr();
data = (INFO *)(&base[table->data]);
if(tuple.length != len)
{
if( table->num_ent >= table->max_size)
{
return RT_POLICY_TABLE_EXCEEDED;
}
index = table->num_ent;
table->num_ent++;
/* Insert value into policy table */
data[index] = 0;
}
else
{
index = tuple.index;
}
bytesAllocated = updateEntry(&data[index], ptr, SAVE_TO_CURRENT, base);
if (bytesAllocated < 0)
{
if(tuple.length != len)
table->num_ent--;
return MEM_ALLOC_FAILURE;
}
table->allocated += (uint32_t)bytesAllocated;
/* The actual value that is looked-up is an index
* into the data table. */
res = sfrt_dir_flat_insert(adr, numAdrDwords, len, index, behavior, rt, updateEntry, data);
/* Check if we ran out of memory. If so, need to decrement
* table->num_ent */
if(res == MEM_ALLOC_FAILURE)
{
/* From the control flow above, it's possible table->num_ent was not
* incremented. It should be safe to decrement here, because the only
* time it will be incremented above is when we are potentially
* mallocing one or more new entries (It's not incremented when we
* overwrite an existing entry). */
table->num_ent--;
}
return res;
}