Changeset 23 for trunk/src/dataFlowSet.c

Show
Ignore:
Timestamp:
02/05/07 17:50:16 (16 years ago)
Author:
andreu
Message:

optimization : new param : myPtrs in checkdataflowset function

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/src/dataFlowSet.c

    r22 r23  
    2929 * Check Data FlowSet  
    3030 * 
    31  * @param shift Shift 
    32  * @param cr Current router pointer 
    33  * @param v9Ptr Pointer in the datagram ?? 
    34  * @param offv9 index in the datagram 
    35  * @param buf Pointer to the buffer 
    36  * @param cFNPtr Pointer on the current flowset number 
    37  * @param cFId Pointer on the current flowset ID 
    38  * @param pcktPtr Pointer on the datagram buffer 
    39  * @param rulesCache Pointer on the rules table (cache for the next param) 
    40  * @param rlPtr Pointer on the rules list 
    41  * @param myQueue FIXME : to erase/delete/suppress 
    42  * @param V4PTab Pointer on the IPv4 Prefix Table 
    43  * @param nbPV4 Previous table size 
    44  * @param ipCache Cache for all IP flow (for CRIHAN compilation option) 
    45  * @param mplsCache Cache for all MPLS flow (for CRIHAN compilation option) 
    46  * @param ipCounter Param to defined IP Cache size 
    47  * @param mplsCounter Param to defined MPLS Cache size  
    48  * @return shift (index in the datagram) FIXME  
    49  *  
    50  * FIXME to tune : just a param like a table ? 
    5131 */ 
    5232unsigned short  
    53 checkDataFlowSet(unsigned short shift, RouterPtr cr, NetFlowV9HeaderPtr v9Ptr, 
    54                  unsigned short *offV9, unsigned char *buf, short *cFNPtr, 
    55                  short *cFId, DatagramPtr pcktPtr, RuleDefPtr *rulesCache, 
    56                  RulesPtr rlPtr, int myQueue, struct PrefixV4 *V4PTab,  
    57                  size_t nbPV4,  
    58                  struct IPFLowCache *ipCache, struct MPLSFlowCache *mplsCache, 
    59                  unsigned long *ipCounter, unsigned long *mplsCounter) 
     33checkDataFlowSet(unsigned short shift,  
     34                 struct MyPtrs *myPtrs, 
     35                 int myQueue,  
     36                 struct PrefixV4 *V4PTab,  
     37                 size_t nbPV4 
     38                 ) 
    6039{ 
    6140  TplFlowSetPtr tmp; 
     
    6443  unsigned short data_length = 0; 
    6544  unsigned short flow_size = 0; 
    66   unsigned short oldOffset = *offV9; 
     45  unsigned short oldOffset = *myPtrs->offsetV9Ptr; 
    6746  unsigned short secondOffset = 0; 
    6847  unsigned short secondOldOffset = 0; 
     
    7958  unsigned char buffer2[2]; 
    8059  unsigned char buffer4[4]; 
    81   RulesPtr tmpRuleList = rlPtr; 
     60  RulesPtr tmpRuleList = myPtrs->rulesListPtr; 
    8261  msgType myMsg; 
    8362  char *msgTextIndex; 
     
    11493#endif /* CRIHAN */ 
    11594 
    116   buffer2[1] = *(buf+(*offV9));(*offV9)++; 
    117   buffer2[0] = *(buf+(*offV9));(*offV9)++; 
    118   (*cFId) = *((unsigned short*)&buffer2); 
    119   buffer2[1] = *(buf+(*offV9));(*offV9)++; 
    120   buffer2[0] = *(buf+(*offV9));(*offV9)++; 
     95  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++; 
     96  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++; 
     97  (*myPtrs->currentFlowsetIdPtr) = *((unsigned short*)&buffer2); 
     98  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++; 
     99  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++; 
    121100  data_length = *((unsigned short*)&buffer2); 
    122   if ((tmp=existTplId(cr, v9Ptr->sourceId,  
    123                       (*cFId)))!=NULL) { 
     101  if ((tmp=existTplId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,  
     102                      (*myPtrs->currentFlowsetIdPtr)))!=NULL) { 
    124103    pftmp = tmp->lastField; 
    125104    for (; pftmp; pftmp = pftmp->prev) { 
     
    127106    } 
    128107    if ( data_length%flow_size >= 9 ) { 
    129       (*cFNPtr) = v9Ptr->count; 
     108      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count; 
    130109      syslog(LOG_INFO, "data flowset length not match with length from template definition, wrong template definition suspected; all next informations of this data flowset are not considered! flowset ID: %hu, from router: %lu.%lu.%lu.%lu", 
    131              (*cFId), 
    132              (pcktPtr->ipH->srcAdd>>24), 
    133              (pcktPtr->ipH->srcAdd<<8>>24), 
    134              (pcktPtr->ipH->srcAdd<<16>>24), 
    135              (pcktPtr->ipH->srcAdd<<24>>24)); 
     110             (*myPtrs->currentFlowsetIdPtr), 
     111             (myPtrs->pcktPtr->ipH->srcAdd>>24), 
     112             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
     113             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     114             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); 
    136115      return (data_length+shift); 
    137116    } 
    138117#ifdef IPV4AGG 
    139     agCache.routerAd = pcktPtr->ipH->srcAdd;  
     118    agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;  
    140119#endif 
    141120 
    142121#ifdef CRIHAN 
    143     ipFirstCache.routerAd = pcktPtr->ipH->srcAdd; 
    144     mplsFirstCache.routerAd = pcktPtr->ipH->srcAdd; 
     122    ipFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd; 
     123    mplsFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd; 
    145124#endif /* CRIHAN */ 
    146125 
    147126    pftmp = tmp->lastField; 
    148127    secondPftmp = tmp->lastField;     
    149     secondOffset = *offV9; 
     128    secondOffset = *myPtrs->offsetV9Ptr; 
    150129    secondOldOffset = secondOffset; 
    151     while ( (((*offV9)-48-shift) <= data_length) && (overflow!=1) ) {  
     130    while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length) && (overflow!=1) ) {  
    152131      /*  
    153132       * progression in a flow Set  
     
    164143       * ... if one rule exist 
    165144       */ 
    166       if (((RuleDefPtr)(*(rulesCache+pos))) != NULL) { 
    167         oldOffset = *offV9; 
    168         while (((RuleDefPtr)(*(rulesCache+pos))) != NULL){ 
     145      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL) { 
     146        oldOffset = *myPtrs->offsetV9Ptr; 
     147        while (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL){ 
    169148          /*  
    170149           * while on one cache table line 
    171150           */ 
    172           *offV9 = oldOffset; 
     151          *myPtrs->offsetV9Ptr = oldOffset; 
    173152          switch ((int) 
    174                   (((RuleDefPtr)(*(rulesCache+pos)))->operator)){ 
     153                  (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)){ 
    175154          case 2: 
    176155            switch (field_size) { 
    177156            case 1: 
    178               buffer1 = *(buf+(*offV9)); (*offV9)++; 
     157              buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    179158              /* rule check */ 
    180               if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.cvalue  
     159              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue  
    181160                  == *((unsigned char*)&buffer1)) { 
    182                 ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     161                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    183162              } 
    184163              /* end rule check */ 
     
    220199              break; 
    221200            case 2: 
    222               buffer2[1]= *(buf+(*offV9)); (*offV9)++; 
    223               buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
    224               if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.svalue  
     201              buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     202              buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     203              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue  
    225204                  == *((unsigned short*)&buffer2)) 
    226                 ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     205                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    227206#ifdef IPV4AGG 
    228207              if (pftmp->fieldType==10){ 
     
    247226            case 3: 
    248227              buffer4[3]= 0; 
    249               buffer4[2]= *(buf+(*offV9)); (*offV9)++; 
    250               buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    251               buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
    252               if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.lvalue  
     228              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     229              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     230              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     231              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue  
    253232                  == *((unsigned long*)&buffer4)) 
    254                 ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     233                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    255234              /* aggregation */ 
    256235              /* end aggregation */ 
     
    262241              break; 
    263242            case 4: 
    264               buffer4[3]= *(buf+(*offV9)); (*offV9)++; 
    265               buffer4[2]= *(buf+(*offV9)); (*offV9)++; 
    266               buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    267               buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
     243              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     244              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     245              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     246              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    268247              /* FIXME : here , add a check on the field type */ 
    269248              if ((pftmp->fieldType==8)||(pftmp->fieldType==12)){ 
    270                 if ((((RuleDefPtr)(*(rulesCache+pos)))->value->stor.lvalue)  
    271                     == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) ) 
     249                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)  
     250                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) ) 
    272251                  { 
    273                     ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     252                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    274253                  } 
    275254              }        
     
    313292            case 16: 
    314293              for (i=0; i<4; i++) { 
    315                 buffer4[3]= *(buf+(*offV9)); (*offV9)++; 
    316                 buffer4[2]= *(buf+(*offV9)); (*offV9)++; 
    317                 buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    318                 buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
     294                buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     295                buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     296                buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     297                buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    319298                if (1==moreIsNecessary){ 
    320299                  switch(i){ 
    321300                  case 0: 
    322                     if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 32){ 
    323                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     301                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){ 
     302                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    324303                          ==  
    325                           (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) 
     304                          (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    326305                          ) 
    327306                        { 
    328                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     307                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    329308                          moreIsNecessary = 0; 
    330309                        } else { 
    331                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     310                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    332311                          moreIsNecessary = 0; 
    333312                        } 
    334313                    } else { 
    335                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     314                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    336315                          ==  
    337316                          (*((unsigned long*)&buffer4)) 
    338317                          ) 
    339318                        { 
    340                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
     319                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    341320                        } else { 
    342                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     321                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    343322                          moreIsNecessary = 0; 
    344323                        } 
     
    346325                    break; 
    347326                  case 1: 
    348                     if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 64){ 
    349                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     327                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){ 
     328                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    350329                          ==  
    351                           (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(64-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) 
     330                          (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    352331                          ) 
    353332                        { 
    354                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 
    355                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     333                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
     334                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    356335                          moreIsNecessary = 0; 
    357336                        } else { 
    358                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     337                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    359338                          moreIsNecessary = 0; 
    360339                        } 
    361340                    } else { 
    362                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     341                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    363342                          ==  
    364343                          (*((unsigned long*)&buffer4)) 
    365344                          ) 
    366345                        { 
    367                           ((RuleDefPtr)(*(rulesCache+pos)))->check =  
    368                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     346                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     347                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    369348                        } else { 
    370                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     349                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    371350                          moreIsNecessary = 0; 
    372351                        } 
     
    374353                    break; 
    375354                  case 2: 
    376                     if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 96){ 
    377                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     355                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){ 
     356                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    378357                          ==  
    379                           (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(96-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) 
     358                          (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    380359                          ) 
    381360                        { 
    382                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 
    383                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     361                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
     362                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    384363                          moreIsNecessary = 0; 
    385364                        } else { 
    386                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     365                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    387366                          moreIsNecessary = 0; 
    388367                        } 
    389368                    } else { 
    390                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     369                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    391370                          ==  
    392371                          (*((unsigned long*)&buffer4)) 
    393372                          ) 
    394373                        { 
    395                           ((RuleDefPtr)(*(rulesCache+pos)))->check =  
    396                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     374                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     375                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    397376                        } else { 
    398                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     377                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    399378                          moreIsNecessary = 0; 
    400379                        } 
     
    402381                    break; 
    403382                  case 3: 
    404                     if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 128){ 
    405                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     383                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){ 
     384                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    406385                          ==  
    407                           (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(128-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) 
     386                          (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    408387                          ) 
    409388                        { 
    410                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 
    411                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     389                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
     390                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    412391                        } else { 
    413                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     392                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    414393                          moreIsNecessary = 0; 
    415394                        } 
    416395                    } else { 
    417                       if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i])  
     396                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    418397                          ==  
    419398                          (*((unsigned long*)&buffer4)) 
    420399                          ) 
    421400                        { 
    422                           ((RuleDefPtr)(*(rulesCache+pos)))->check =  
    423                             ((RuleDefPtr)(*(rulesCache+pos)))->check && 1; 
     401                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     402                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    424403                        } else { 
    425                           ((RuleDefPtr)(*(rulesCache+pos)))->check = 0; 
     404                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0; 
    426405                          moreIsNecessary = 0; 
    427406                        } 
     
    441420              syslog(LOG_INFO, "Field size not known: %d\n", field_size);  
    442421              for (i=0; i<field_size; i++){ 
    443                 (*offV9)++; 
     422                (*myPtrs->offsetV9Ptr)++; 
    444423              } 
    445424              break; 
     
    448427          default: 
    449428            syslog(LOG_INFO, "Operator not known: %d\n", 
    450                    (int)(((RuleDefPtr)(*(rulesCache+pos)))->operator)); 
     429                   (int)(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)); 
    451430            break; 
    452431          } 
    453432          j++; 
    454433          pos = (pftmp->fieldType)*10+j; 
    455         } /* end while rulesCache */ 
     434        } /* end while myPtrs->rulesAddressPtr */ 
    456435      } else { 
    457436        /*  
     
    460439        switch (field_size) { 
    461440        case 1: 
    462           buffer1 = *(buf+(*offV9)); (*offV9)++; 
     441          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    463442#ifdef IPV4AGG 
    464443          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ 
     
    498477          break; 
    499478        case 2: 
    500           buffer2[1]= *(buf+(*offV9)); (*offV9)++; 
    501           buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
     479          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     480          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    502481#ifdef IPV4AGG 
    503482          if (pftmp->fieldType==10){ 
     
    522501        case 3: 
    523502          buffer4[3]= 0; 
    524           buffer4[2]= *(buf+(*offV9)); (*offV9)++; 
    525           buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    526           buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
     503          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     504          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     505          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    527506          /* aggregation */ 
    528507          /* end aggregation */ 
     
    534513          break; 
    535514        case 4: 
    536           buffer4[3]= *(buf+(*offV9)); (*offV9)++; 
    537           buffer4[2]= *(buf+(*offV9)); (*offV9)++; 
    538           buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    539           buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
     515          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     516          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     517          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     518          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    540519#ifdef IPV4AGG 
    541520          if ((pftmp->fieldType==8)){ 
     
    575554        case 16: 
    576555          for (i=0; i<4; i++) { 
    577             buffer2[1]= *(buf+(*offV9)); (*offV9)++; 
    578             buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
    579             buffer2[1]= *(buf+(*offV9)); (*offV9)++; 
    580             buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
     556            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     557            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     558            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     559            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    581560          } 
    582561          /* aggregation IPv6 */           
     
    586565          syslog(LOG_INFO,"UNKNOWN FIELDS LENGTH: %d ", field_size); 
    587566          for (i=0; i<field_size; i++){ 
    588             (*offV9)++; 
     567            (*myPtrs->offsetV9Ptr)++; 
    589568          } 
    590569        } 
     
    596575#ifdef CRIHAN 
    597576        if ( mplsFirstCache.mplsLabel1 == 0 ) { 
    598           (ipCache+(*ipCounter))->ipProt = ipFirstCache.ipProt; 
     577          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->ipProt = ipFirstCache.ipProt; 
    599578          ipFirstCache.ipProt = 0; 
    600           (ipCache+(*ipCounter))->bytes = ipFirstCache.bytes; 
     579          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->bytes = ipFirstCache.bytes; 
    601580          ipFirstCache.bytes = 0; 
    602           (ipCache+(*ipCounter))->pkts = ipFirstCache.pkts; 
     581          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->pkts = ipFirstCache.pkts; 
    603582          ipFirstCache.pkts = 0; 
    604           (ipCache+(*ipCounter))->inSnmp = ipFirstCache.inSnmp; 
     583          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->inSnmp = ipFirstCache.inSnmp; 
    605584          ipFirstCache.inSnmp = 0; 
    606           (ipCache+(*ipCounter))->outSnmp = ipFirstCache.outSnmp; 
     585          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->outSnmp = ipFirstCache.outSnmp; 
    607586          ipFirstCache.outSnmp = 0; 
    608           (ipCache+(*ipCounter))->v4AdS = ipFirstCache.v4AdS; 
     587          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdS = ipFirstCache.v4AdS; 
    609588          ipFirstCache.outSnmp = 0; 
    610           (ipCache+(*ipCounter))->v4AdD = ipFirstCache.v4AdD; 
     589          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdD = ipFirstCache.v4AdD; 
    611590          ipFirstCache.v4AdD = 0; 
    612           (ipCache+(*ipCounter))->tProt = ipFirstCache.tProt; 
     591          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->tProt = ipFirstCache.tProt; 
    613592          ipFirstCache.tProt = 0; 
    614           (ipCache+(*ipCounter))->sPort = ipFirstCache.sPort; 
     593          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->sPort = ipFirstCache.sPort; 
    615594          ipFirstCache.sPort = 0; 
    616           (ipCache+(*ipCounter))->dPort = ipFirstCache.dPort; 
     595          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->dPort = ipFirstCache.dPort; 
    617596          ipFirstCache.dPort = 0; 
    618           (ipCache+(*ipCounter))->maskD = ipFirstCache.maskD; 
     597          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskD = ipFirstCache.maskD; 
    619598          ipFirstCache.maskD = 0; 
    620           (ipCache+(*ipCounter))->maskS = ipFirstCache.maskS; 
     599          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskS = ipFirstCache.maskS; 
    621600          ipFirstCache.maskS = 0; 
    622           (ipCache+(*ipCounter))->routerAd = ipFirstCache.routerAd; 
    623           (ipCache+(*ipCounter))->liveTime = lastTime - firstTime; 
     601          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->routerAd = ipFirstCache.routerAd; 
     602          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->liveTime = lastTime - firstTime; 
    624603          firstTime = 0; lastTime = 0; 
    625           (*ipCounter)++; 
     604          (*myPtrs->ipNbPtr)++; 
    626605        } else { 
    627           (mplsCache+(*mplsCounter))->ipProt = mplsFirstCache.ipProt; 
     606          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->ipProt = mplsFirstCache.ipProt; 
    628607          mplsFirstCache.ipProt = 0; 
    629           (mplsCache+(*mplsCounter))->v4AdS =  mplsFirstCache.v4AdS; 
     608          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdS =  mplsFirstCache.v4AdS; 
    630609          mplsFirstCache.v4AdS = 0; 
    631           (mplsCache+(*mplsCounter))->v4AdD =  mplsFirstCache.v4AdD;  
     610          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdD =  mplsFirstCache.v4AdD;  
    632611          mplsFirstCache.v4AdD = 0; 
    633           (mplsCache+(*mplsCounter))->routerAd =  mplsFirstCache.routerAd; 
    634           (mplsCache+(*mplsCounter))->mplsLabel1 =  mplsFirstCache.mplsLabel1; 
     612          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->routerAd =  mplsFirstCache.routerAd; 
     613          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->mplsLabel1 =  mplsFirstCache.mplsLabel1; 
    635614          mplsFirstCache.mplsLabel1 = 0; 
    636           (*mplsCounter)++; 
     615          (*myPtrs->mplsNbPtr)++; 
    637616        } 
    638617#endif  
    639618        /* put aggregation cache information to IPv4 Prefixes table */ 
     619        /* Aggregation mode must be enable in ./configure options   */ 
     620        /* first we must know if the address belong to our prefix   */ 
    640621#ifdef IPV4AGG 
    641622        if (bool == 1){ 
     
    643624          res = bsearch(&prefixKey, V4PTab, nbPV4,  
    644625                        sizeof(struct PrefixV4), prefCmp); 
    645           if (res!=NULL){ 
    646             res->bytesNb += agCache.bytes; 
    647             res->pktsNb += agCache.pkts; 
    648             res->flowNb += 1; 
    649             switch (agCache.ipProt) { 
     626          if (res!=NULL){ /* OUT ("traffic from the prefix")  */ 
     627            res->bytesNbOUT += agCache.bytes; 
     628            res->pktsNbOUT += agCache.pkts; 
     629            (res->flowNbOUT)++; 
     630            switch (agCache.tProt) { 
    650631            case 1: 
    651               res->icmpBytesNb += agCache.bytes; 
    652               res->icmpPktsNb += agCache.pkts; 
    653               res->icmpFlowNb += 1; 
     632              res->icmpBytesNbOUT += agCache.bytes; 
     633              res->icmpPktsNbOUT += agCache.pkts; 
     634              (res->icmpFlowNbOUT)++; 
    654635              break; 
    655636            case 6: 
    656               res->tcpBytesNb += agCache.bytes; 
    657               res->tcpPktsNb += agCache.pkts; 
    658               res->tcpFlowNb += 1;             
     637              res->tcpBytesNbOUT += agCache.bytes; 
     638              res->tcpPktsNbOUT += agCache.pkts; 
     639              (res->tcpFlowNbOUT)++;           
    659640              break; 
    660641            case 17: 
    661               res->udpBytesNb += agCache.bytes; 
    662               res->udpPktsNb += agCache.pkts; 
    663               res->udpFlowNb += 1; 
     642              res->udpBytesNbOUT += agCache.bytes; 
     643              res->udpPktsNbOUT += agCache.pkts; 
     644              (res->udpFlowNbOUT)++; 
    664645              break; 
    665646            default: 
    666               res->othersBytesNb += agCache.bytes; 
    667               res->othersPktsNb += agCache.pkts; 
    668               res->othersFlowNb += 1;          
     647              res->othersBytesNbOUT += agCache.bytes; 
     648              res->othersPktsNbOUT += agCache.pkts; 
     649              (res->othersFlowNbOUT)++; 
    669650            } 
    670           } 
    671 /*        if (res==NULL){ */ 
    672 /*          fprintf(stderr, "IPv4_spoofing? ");  */ 
    673 /*        } */ 
     651          } else { 
     652            prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD); 
     653            res = bsearch(&prefixKey, V4PTab, nbPV4,  
     654                          sizeof(struct PrefixV4), prefCmp); 
     655            if (res!=NULL){ /* IN ("traffic to the prefix")  */ 
     656              res->bytesNbIN += agCache.bytes; 
     657              res->pktsNbIN += agCache.pkts; 
     658              (res->flowNbIN)++; 
     659              switch (agCache.tProt) { 
     660              case 1: 
     661                res->icmpBytesNbIN += agCache.bytes; 
     662                res->icmpPktsNbIN += agCache.pkts; 
     663                (res->icmpFlowNbIN)++; 
     664                break; 
     665              case 6: 
     666                res->tcpBytesNbIN += agCache.bytes; 
     667                res->tcpPktsNbIN += agCache.pkts; 
     668                (res->tcpFlowNbIN)++; 
     669                break; 
     670              case 17: 
     671                res->udpBytesNbIN += agCache.bytes; 
     672                res->udpPktsNbIN += agCache.pkts; 
     673                (res->udpFlowNbIN)++; 
     674                break; 
     675              default: 
     676                res->othersBytesNbIN += agCache.bytes; 
     677                res->othersPktsNbIN += agCache.pkts; 
     678                (res->othersFlowNbIN)++; 
     679              } 
     680            } else { 
     681              /* HERE : we are in the cases of the address/mask don't      */ 
     682              /*        belong to a prefix listed in the IPv4 prefix file  */ 
     683              /* possibilities :                                           */ 
     684              /*     -  prefix not referenced but allowed to be routed     */ 
     685              /*     -  prefix not referenced but not allowed to be routed */ 
     686              /*     -  spoofing                                           */ 
     687/*            fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu R:%lu.%lu.%lu.%lu \n", */ 
     688/*                    (agCache.v4AdS>>24), */ 
     689/*                    (agCache.v4AdS<<8>>24),  */ 
     690/*                    (agCache.v4AdS<<16>>24),  */ 
     691/*                    (agCache.v4AdS<<24>>24),  */ 
     692/*                    (agCache.maskS),  */ 
     693/*                    (agCache.v4AdD>>24),  */ 
     694/*                    (agCache.v4AdD<<8>>24),  */ 
     695/*                    (agCache.v4AdD<<16>>24),  */ 
     696/*                    (agCache.v4AdD<<24>>24),  */ 
     697/*                    (agCache.maskD),  */ 
     698/*                    (myPtrs->pcktPtr->ipH->srcAdd>>24),  */ 
     699/*                    (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */ 
     700/*                    (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */ 
     701/*                    (myPtrs->pcktPtr->ipH->srcAdd<<24>>24) */ 
     702/*                    ); */ 
     703            } 
     704          } 
    674705        } 
    675706        bool = 0; 
     
    680711         * we send the flow or a part of the flow to a remote host or a file 
    681712         */ 
    682         tmpRuleList = rlPtr; 
     713        tmpRuleList = myPtrs->rulesListPtr; 
    683714        while (tmpRuleList){ 
    684715          unsigned short check = 1; 
     
    693724            /* msg building */ 
    694725            secondPftmp = tmp->lastField; 
    695 /*          memcpy(myMsg.text, (char*)(buf+secondOffset),flow_size); */ 
     726/*          memcpy(myMsg.text, (char*)(myPtrs->ptr_buffer+secondOffset),flow_size); */ 
    696727            msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text,  
    697728                                                   &tplMsgType,  
     
    701732                                           sizeof(tmpRuleList->id) 
    702733                                           ), 
    703                                    &cr->IpAddress,  
     734                                   &myPtrs->currentRouterPtr->IpAddress,  
    704735                                   sizeof(unsigned long)  
    705736                                   ); 
     
    711742                                           sizeof(tmp->templateFlowSetId)  
    712743                                           ),  
    713                                    buf+secondOffset,  
     744                                   myPtrs->ptr_buffer+secondOffset,  
    714745                                   flow_size 
    715746                                   );  
     
    725756         * end redirection  
    726757         */ 
    727         secondOffset = *offV9; 
     758        secondOffset = *myPtrs->offsetV9Ptr; 
    728759        secondOldOffset = secondOffset; 
    729760        pftmp = tmp->lastField; 
    730761        cpt=0; 
    731         (*cFNPtr)++; /* pointer on the flows number */ 
    732         if (((*offV9)-48-shift+flow_size) > data_length){ 
     762        (*myPtrs->currentFlowsetNumberPtr)++; /* pointer on the flows number */ 
     763        if (((*myPtrs->offsetV9Ptr)-48-shift+flow_size) > data_length){ 
    733764          overflow = 1; /* buffer index not correct */ 
    734765        } 
     
    742773     * template unknown, we skip this all the data  
    743774     */ 
    744     (*offV9)+=(data_length-4); 
    745     (*cFNPtr) = v9Ptr->count; 
     775    (*myPtrs->offsetV9Ptr)+=(data_length-4); 
     776    (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count; 
    746777  } 
    747   while ( ((*offV9)-48-shift) < data_length ) { 
    748     (*offV9)++; /* if padding */ 
     778  while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) { 
     779    (*myPtrs->offsetV9Ptr)++; /* if padding */ 
    749780  } 
    750   while ( (*offV9)-48-shift > data_length ) {  
    751     (*offV9)--; /* crazy loop (when bug appears in template def) */ 
     781  while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) {  
     782    (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */ 
    752783  } 
    753784  return (data_length+shift);