int tr_general(uint8_t *src_data, uint16_t* offset, uint16_t* length, uint8_t* buffer, struct ipfix_lnf_map* item_info)
{
switch(*length)
{
case 1:
readui8(buffer) = readui8(src_data + *offset);
break;
case 2:
readui16(buffer) = ntohs(readui16(src_data + *offset));
break;
case 4:
readui32(buffer) = ntohl(readui32(src_data + *offset));
break;
case 8:
readui64(buffer) = be64toh(readui64(src_data + *offset));
break;
case VAR_IE_LENGTH:
*length = real_length(src_data, offset, *length);
default:
//Assume data type to be octetArray -> no endian conversion
memcpy(buffer, src_data + *offset, *length);
}
if(/*length check comes here*/0){
//invalid length
return 1;
}
return 0;
}
void store_record(struct metadata* mdata, struct lnfstore_conf *conf)
{
static uint8_t buffer[(uint16_t)-1];
static lnf_rec_t *recp = NULL;
static lnf_file_t *lfp = NULL;
stack_t *smap = conf->pst;
if( conf->profiles && !mdata->channels ){
//Record wont be stored, it does not belong to any channel and profiling is activated
return;
}
if(recp == NULL) {
lnf_rec_init(&recp);
} else {
lnf_rec_clear(recp);
}
uint16_t offset, length;
offset = 0;
struct ipfix_template *templ = mdata->record.templ;
uint8_t *data_record = (uint8_t*) mdata->record.record;
/* get all fields */
for (uint16_t count = 0, index = 0; count < templ->field_count; ++count, ++index) {
struct ipfix_lnf_map *item, key;
/* Get Enterprise number and ID */
key.ie = templ->fields[index].ie.id;
length = templ->fields[index].ie.length;
key.en = 0;
if (key.ie & 0x8000) {
key.ie &= 0x7fff;
key.en = templ->fields[++index].enterprise_number;
}
item = bsearch(&key, tr_table, MAX_TABLE , sizeof(struct ipfix_lnf_map), ipfix_lnf_map_compare);
int problem = 1;
if(item != NULL){
problem = item->func(data_record, &offset, &length, buffer, item);
lnf_rec_fset(recp, item->lnf_id, buffer);
}
if(problem){
length = real_length(data_record, &offset, length);
}
offset += length;
} //end of element processing
//!< Decide whether close close files and create new time window
time_t now = time(NULL);
if(difftime(now, conf->t_vars->window_start) > conf->time_window){
mktime_window(now, conf);
if( conf->profiles ){
prec_t* item = NULL;
//Close all old files
for(unsigned x = 0; x < smap->top; x += al4B(sizeof(prec_t))){
item = (prec_t*)smap->data + x;
if(item->lfp == NULL)
continue;
lnf_close(item->lfp);
item->lfp = NULL;
}
} else {
lnf_close(lfp);
lfp = NULL;
}
}
if( conf->profiles ){
//On stack allocation of bit array
int ba_size = smap->top/(8*sizeof(int))+1;
int ba[ba_size];
memset(&ba[0], 0, ba_size*sizeof(int));
int status = 0;
prec_t *item = NULL;
for( int i = 0; mdata->channels[i] != 0; i++ ){
void* rec_prof = channel_get_profile(mdata->channels[i]);
item = bsearch(&rec_prof, smap->data, smap->top/al4B(sizeof(prec_t)),
al4B(sizeof(prec_t)), prec_compare);
if( item == NULL ){
//Profile is not in configuration
prec_t entry;
entry.address = rec_prof;
entry.lfp = NULL;
const char* prpath = profile_get_path(rec_prof);
char* path = mkpath_string(conf, prpath);
mkdir_hierarchy(path);
status = lnf_open(&entry.lfp, path, LNF_WRITE | (conf->compress? LNF_COMP : 0), (char*)conf->ident);
stack_push(smap, &entry, sizeof(prec_t));
//Add resilience
qsort(smap->data, smap->top/al4B(sizeof(prec_t)),
al4B(sizeof(prec_t)), prec_compare);
free(path);
} else if( item->lfp == NULL ){
//Profile file is closed
const char* prpath = profile_get_path(rec_prof);
char* path = mkpath_string(conf, prpath);
mkdir_hierarchy(path);
status = lnf_open(&item->lfp, path, LNF_WRITE | (conf->compress? LNF_COMP : 0), (char*)conf->ident);
//Get prof name and open aprop file
free(path);
}
}
void* profile = NULL;
int i = 0;
for(profile = channel_get_profile(mdata->channels[i=0]);
mdata->channels[i] != 0;
profile = channel_get_profile(mdata->channels[i++]) ){
item = bsearch(&profile, smap->data, smap->top/al4B(sizeof(prec_t)),
al4B(sizeof(prec_t)), prec_compare);
int index = (((base_t*)item) - smap->data)/al4B(sizeof(prec_t));
if( !GETb(ba, index) ){ //And profile is not shadow
status = lnf_write(item->lfp, recp);
SETb(ba, index, 1);
}
}
} else {
if( lfp == NULL ){
int status;
char* path = mkpath_string(conf, NULL);
status = mkdir_hierarchy(path);
status |= lnf_open(&lfp, path, LNF_WRITE | (conf->compress ? LNF_COMP : 0), (char*)conf->ident);
if(status != LNF_OK) {
MSG_ERROR(msg_module, "Failed to open file! ...at path: %s \n", path);
}
free(path);
}
lnf_write(lfp, recp);
}
return;
}
void extract_ratfuns(node_type **root)
{
node_type *r = *root;
Coefficient t = {special};
switch (r->type) {
case op2_type:
extract_ratfuns(&(r->u.op2.operand1));
extract_ratfuns(&(r->u.op2.operand2));
if (r->u.op2.operand1->type != ratfun_type
|| r->u.op2.operand2->type != ratfun_type) {
/* nothing to do here */
return;
}
switch (r->u.op2.operator) {
case '^':
if (r->u.op2.operand2->u.coef.type != rational
|| real_length(r->u.op2.operand2->u.coef.u.rat.num) != 1) {
printf("Error! "
"Indices must be single precision integers!\n");
exit(1);
}
ratfun_power(&r->u.op2.operand1->u.ratfun,
r->u.op2.operand1->u.ratfun,
*(r->u.op2.operand2->u.coef.u.rat.num+1));
if (coef_neg(r->u.op2.operand2->u.coef)) {
invert_ratfun(&r->u.op2.operand1->u.ratfun);
}
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '+':
add_ratfuns(&r->u.op2.operand1->u.ratfun,
r->u.op2.operand1->u.ratfun,
r->u.op2.operand2->u.ratfun);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '-':
sub_ratfuns(&r->u.op2.operand1->u.ratfun,
r->u.op2.operand1->u.ratfun,
r->u.op2.operand2->u.ratfun);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '*':
mul_ratfuns(&r->u.op2.operand1->u.ratfun,
r->u.op2.operand1->u.ratfun,
r->u.op2.operand2->u.ratfun);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '/':
div_ratfuns(&r->u.op2.operand1->u.ratfun,
r->u.op2.operand1->u.ratfun,
r->u.op2.operand2->u.ratfun);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
}
break;
case op1_type:
extract_ratfuns(&r->u.op1.operand);
if (r->u.op1.operand->type != ratfun_type) {
/* nothing to do here */
return;
}
switch (r->u.op1.operator) {
case UMINUS:
negate_ratfun(&r->u.op1.operand->u.ratfun);
*root = r->u.op1.operand;
r->u.op1.operand = NULL;
free_tree(r);
break;
}
break;
case coef_type:
/* turn into ratfun */
t.type = rational;
t.u.rat = make_bigrat3(1);
*root = add_ratfun(r->u.coef, t);
r->u.coef.type = special;
free_tree(r);
case ratfun_type:
break;
}
}
void extract_polys(node_type **root)
{
node_type *r = *root;
Coefficient tq = {special}, tr = {special};
switch (r->type) {
case op2_type:
extract_polys(&(r->u.op2.operand1));
extract_polys(&(r->u.op2.operand2));
if (r->u.op2.operand1->type != coef_type
|| r->u.op2.operand2->type != coef_type) {
/* nothing to do here */
return;
}
switch (r->u.op2.operator) {
case '^':
if (r->u.op2.operand2->u.coef.type != rational
|| real_length(r->u.op2.operand2->u.coef.u.rat.num) != 1) {
printf("Error! "
"Indices must be single precision integers!\n");
exit(1);
}
if (coef_neg(r->u.op2.operand2->u.coef)) {
/* this is a rational function */
break;
}
coef_power(&r->u.op2.operand1->u.coef,
r->u.op2.operand1->u.coef,
*(r->u.op2.operand2->u.coef.u.rat.num+1));
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '+':
add_coefficients(&r->u.op2.operand1->u.coef,
r->u.op2.operand1->u.coef,
r->u.op2.operand2->u.coef);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '-':
sub_coefficients(&r->u.op2.operand1->u.coef,
r->u.op2.operand1->u.coef,
r->u.op2.operand2->u.coef);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '*':
mul_coefficients(&r->u.op2.operand1->u.coef,
r->u.op2.operand1->u.coef,
r->u.op2.operand2->u.coef);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
break;
case '/':
/* see if division will be exact */
polydiv_coefficients(&tq, &tr,
r->u.op2.operand1->u.coef,
r->u.op2.operand2->u.coef);
if (!coef_zero(tr)) {
/* division is not exact so this is a ratfun */
/* PRINTC(tq); */
/* PRINTC(tr); */
free_coefficient(&tq);
free_coefficient(&tr);
*root = add_ratfun(r->u.op2.operand1->u.coef,
r->u.op2.operand2->u.coef);
r->u.op2.operand1->u.coef.type = special;
r->u.op2.operand2->u.coef.type = special;
free_tree(r);
break;
}
/* division is exact */
copy_coefficient(&r->u.op2.operand1->u.coef, tq);
*root = r->u.op2.operand1;
r->u.op2.operand1 = NULL;
free_tree(r);
free_coefficient(&tq);
free_coefficient(&tr);
break;
}
break;
case op1_type:
extract_polys(&r->u.op1.operand);
if (r->u.op1.operand->type != coef_type) {
/* nothing to do here */
return;
}
switch (r->u.op1.operator) {
case UMINUS:
negate_coefficient(&r->u.op1.operand->u.coef);
*root = r->u.op1.operand;
r->u.op1.operand = NULL;
free_tree(r);
break;
}
break;
case coef_type:
case ratfun_type:
break;
}
}
