Show
Ignore:
Timestamp:
12/27/10 15:06:15 (12 years ago)
Author:
andreu
Message:

DoS detection update

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/src/dataFlowSet.c

    r144 r145  
    11/* 
    22 * File: dataFlowSet.c 
    3  *  
    4  * Authors: ANDREU Francois-Xavier  
    53 * 
    6  * Copyright (C) 2005 - 2010 GIP RENATER  
     4 * Authors: ANDREU Francois-Xavier 
     5 * 
     6 * Copyright (C) 2005 - 2010 GIP RENATER 
    77 */ 
    88 
    9 /*  This file is part of renetcol.  
     9/*  This file is part of renetcol. 
    1010 * 
    1111 *  renetcol is free software; you can redistribute it and/or modify 
     
    2727 
    2828/* 
    29  * Check Data FlowSet  
     29 * Check Data FlowSet 
    3030 * 
    3131 */ 
    32 short  
    33 checkDataFlowSet(short shift,  
     32short 
     33checkDataFlowSet(short shift, 
    3434                 struct MyPtrs *myPtrs, 
    35                  int myQueue,  
    36                  struct PrefixV4 *V4PTab,  
     35                 int myQueue, 
     36                 struct PrefixV4 *V4PTab, 
    3737                 size_t nbPV4, 
    3838                 struct PrefixV4 *V4STab, 
     
    5858  int j = 0; 
    5959  int pos = 0; 
    60         int jdos = 0; 
    61         int posdos = 0; 
    62   unsigned char buffer1;   
     60  int jdos = 0; 
     61  int posdos = 0; 
     62  unsigned char buffer1; 
    6363  unsigned char buffer2[2]; 
    6464  unsigned char buffer4[4]; 
     
    9999  data_length = *((unsigned short*)&buffer2); 
    100100  if (data_length == 0) { 
    101 #ifdef DEBUG     
     101#ifdef DEBUG 
    102102    fprintf (stderr, " dlg==0 <--| "); 
    103103#endif 
     
    112112  } 
    113113 
    114   if ( (tmp=existTplId(myPtrs->currentRouterPtr,  
    115                        myPtrs->currentHeaderV9Ptr->sourceId,  
     114  if ( (tmp=existTplId(myPtrs->currentRouterPtr, 
     115                       myPtrs->currentHeaderV9Ptr->sourceId, 
    116116                       (*myPtrs->currentFlowsetIdPtr)))!=NULL ) { 
    117117    myPtrs->currentMIB->dataFlowSetNb += 1; 
    118118#ifdef DEBUG 
    119119    fprintf(stderr, 
    120             "{d id: %hu, lg %hu",  
    121             (*myPtrs->currentFlowsetIdPtr),  
     120            "{d id: %hu, lg %hu", 
     121            (*myPtrs->currentFlowsetIdPtr), 
    122122            data_length); 
    123123    if ( (*myPtrs->currentFlowsetIdPtr) > TRESHOLD_TEMPLATE_ID ) { 
     
    151151             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
    152152             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); 
    153 #ifdef DEBUG     
     153#ifdef DEBUG 
    154154    fprintf (stderr, " dlg%flsz >=9 skip data "); 
    155155#endif 
     
    163163             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
    164164             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); 
    165 #ifdef DEBUG     
     165#ifdef DEBUG 
    166166    fprintf (stderr, " dlg >= 1452 skip pckt "); 
    167167#endif 
     
    169169    } 
    170170#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP) 
    171     agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;  
     171    agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd; 
    172172#endif 
    173173 
    174174    pftmp = tmp->lastField; 
    175     secondPftmp = tmp->lastField;     
     175    secondPftmp = tmp->lastField; 
    176176    secondOffset = *myPtrs->offsetV9Ptr; 
    177177    secondOldOffset = secondOffset; 
    178     while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length)  
    179             && (overflow!=1) ) {  
    180       /*  
    181        * progression in a data flow Set  
     178    while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length) 
     179            && (overflow!=1) ) { 
     180      /* 
     181       * progression in a data flow Set 
    182182       * notes: 
    183183       *   48= IP header size + NetFlow header size 
     
    198198          { 
    199199            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j)))->check = 1; 
    200           }      
     200          } 
    201201        j++; 
    202       }     
     202      } 
    203203      j = 0; 
    204204 
     
    211211        oldOffset = *myPtrs->offsetV9Ptr; 
    212212        while (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL){ 
    213           /*  
     213          /* 
    214214           * while on one cache table line 
    215215           */ 
     
    218218                  (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)){ 
    219219          case 2: 
    220             /* operator: "=" */  
     220            /* operator: "=" */ 
    221221            switch (field_size) { 
    222222            case 1: 
    223               buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     223              buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    224224              (*myPtrs->offsetV9Ptr)++; 
    225225              /* rule check */ 
    226               if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue  
     226              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue 
    227227                  == *((unsigned char*)&buffer1)) { 
    228228                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
     
    248248                agCache.dscp = *((unsigned char*)&buffer1); 
    249249              } 
    250 #endif         
     250#endif 
    251251              break; 
    252252            case 2: 
    253               buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     253              buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    254254              (*myPtrs->offsetV9Ptr)++; 
    255               buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     255              buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    256256              (*myPtrs->offsetV9Ptr)++; 
    257               if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue  
     257              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue 
    258258                  == *((unsigned short*)&buffer2)) 
    259259                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    260260              if (pftmp->fieldType==7){ 
    261261                agCache.sPort = *((unsigned short*)&buffer2); 
    262               }    
     262              } 
    263263              if (pftmp->fieldType==11){ 
    264264                agCache.dPort = *((unsigned short*)&buffer2); 
     
    275275              if (pftmp->fieldType==16){ 
    276276                agCache.asS = *((unsigned short*)&buffer2); 
    277               }    
     277              } 
    278278              if (pftmp->fieldType==17){ 
    279279                agCache.asD = *((unsigned short*)&buffer2); 
     
    283283            case 3: 
    284284              buffer4[3]= 0; 
    285               buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     285              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    286286              (*myPtrs->offsetV9Ptr)++; 
    287               buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     287              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    288288              (*myPtrs->offsetV9Ptr)++; 
    289               buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     289              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    290290              (*myPtrs->offsetV9Ptr)++; 
    291               if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue  
     291              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue 
    292292                  == *((unsigned long*)&buffer4)) 
    293293                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
     
    299299              break; 
    300300            case 4: 
    301               buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     301              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    302302              (*myPtrs->offsetV9Ptr)++; 
    303               buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     303              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    304304              (*myPtrs->offsetV9Ptr)++; 
    305               buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     305              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    306306              (*myPtrs->offsetV9Ptr)++; 
    307               buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     307              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    308308              (*myPtrs->offsetV9Ptr)++; 
    309309              /* FIXME : here , add a check on the field type */ 
    310310              if ((pftmp->fieldType==8)||(pftmp->fieldType==12) 
    311311                  ||(pftmp->fieldType==15)||(pftmp->fieldType==18)){ 
    312                 if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)  
     312                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) 
    313313                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) ) 
    314314                  { 
     
    317317              } 
    318318              if ((pftmp->fieldType==10)||(pftmp->fieldType==14)){ 
    319                 if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)  
     319                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue) 
    320320                    == ((unsigned short)*((unsigned long*)&buffer4))) 
    321321                  { 
     
    324324              } 
    325325              if ((pftmp->fieldType==16)||(pftmp->fieldType==17)){ 
    326                 if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)  
     326                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue) 
    327327                    == ((unsigned short)*((unsigned long*)&buffer4))) 
    328328                  { 
     
    349349              if (pftmp->fieldType==14){ 
    350350                agCache.outputSnmp = (unsigned short)*((unsigned long*)&buffer4); 
    351               }  
     351              } 
    352352              if ((pftmp->fieldType==8)){ 
    353353                bool = 1; /* very important, test if we have an IPv4 flow for Agg */ 
     
    367367              if (pftmp->fieldType==16){ 
    368368                agCache.asS = (unsigned short)*((unsigned long*)&buffer4); 
    369               }    
     369              } 
    370370              if (pftmp->fieldType==17){ 
    371371                agCache.asD = (unsigned short)*((unsigned long*)&buffer4); 
     
    374374              if (pftmp->fieldType==1){ 
    375375                      dosCache.bytes = *((unsigned long*)&buffer4); 
    376                                         dosCache.sampling = *myPtrs->currentRouterPtr->sampled; 
     376                      dosCache.sampling = myPtrs->currentRouterPtr->sampled; 
    377377              } 
    378378              if (pftmp->fieldType==2){ 
    379                       dosCache.pkts = *((unsigned long*)&buffer4); 
    380                                 } 
     379                      dosCache.packets = *((unsigned long*)&buffer4); 
     380          } 
     381          if (pftmp->fieldType==21){ 
     382                      dosCache.endTime = *((unsigned long*)&buffer4); 
     383          } 
     384          if (pftmp->fieldType==22){ 
     385                      dosCache.startTime = *((unsigned long*)&buffer4); 
     386          } 
    381387              break; 
    382388            case 16: 
     
    384390                isIPv6 = 1; 
    385391                for (i=0; i<4; i++) { 
    386                   buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     392                  buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    387393                  (*myPtrs->offsetV9Ptr)++; 
    388                   buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     394                  buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    389395                  (*myPtrs->offsetV9Ptr)++; 
    390                   buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     396                  buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    391397                  (*myPtrs->offsetV9Ptr)++; 
    392                   buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     398                  buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    393399                  (*myPtrs->offsetV9Ptr)++; 
    394400                  if (1==moreIsNecessary){ 
     
    396402                    case 0: 
    397403                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){ 
    398                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    399                             ==  
     404                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     405                            == 
    400406                            (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    401407                            ) 
     
    408414                        } 
    409415                      } else { 
    410                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    411                             ==  
     416                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     417                            == 
    412418                            (*((unsigned long*)&buffer4)) 
    413419                            ) 
     
    422428                    case 1: 
    423429                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){ 
    424                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    425                             ==  
     430                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     431                            == 
    426432                            (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    427433                            ) 
     
    435441                        } 
    436442                      } else { 
    437                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    438                             ==  
     443                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     444                            == 
    439445                            (*((unsigned long*)&buffer4)) 
    440446                            ) 
    441447                          { 
    442                             ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     448                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
    443449                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    444450                          } else { 
     
    450456                    case 2: 
    451457                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){ 
    452                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    453                             ==  
     458                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     459                            == 
    454460                            (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    455461                            ) 
     
    463469                        } 
    464470                      } else { 
    465                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    466                             ==  
     471                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     472                            == 
    467473                            (*((unsigned long*)&buffer4)) 
    468474                            ) 
    469475                          { 
    470                             ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     476                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
    471477                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    472478                          } else { 
     
    478484                    case 3: 
    479485                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){ 
    480                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    481                             ==  
     486                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     487                            == 
    482488                            (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) 
    483489                            ) 
     
    490496                        } 
    491497                      } else { 
    492                         if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])  
    493                             ==  
     498                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
     499                            == 
    494500                            (*((unsigned long*)&buffer4)) 
    495501                            ) 
    496502                          { 
    497                             ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =  
     503                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
    498504                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1; 
    499505                          } else { 
     
    517523                moreIsNecessary = 1; 
    518524                /* aggregation for IPv6 flows */ 
    519                  
     525 
    520526                /* end aggregation */ 
    521527              } /* end of : if ((pftmp->fieldType==27)||(pftmp->fieldType==28)){ */ 
    522528              break; 
    523529            default: 
    524               syslog(LOG_INFO, "Field size not known: %d\n", field_size);  
     530              syslog(LOG_INFO, "Field size not known: %d\n", field_size); 
    525531              for (i=0; i<field_size; i++){ 
    526532                (*myPtrs->offsetV9Ptr)++; 
     
    538544        } /* end while myPtrs->rulesAddressPtr */ 
    539545      } else { 
    540         /*  
    541          * no rule within this field type, but we must read the value  
     546        /* 
     547         * no rule within this field type, but we must read the value 
    542548         */ 
    543549        switch (field_size) { 
    544550        case 1: 
    545           buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     551          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    546552          (*myPtrs->offsetV9Ptr)++; 
    547553#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP) 
     
    563569          if (pftmp->fieldType==5){ 
    564570            agCache.dscp = *((unsigned char*)&buffer1); 
    565           }        
     571          } 
    566572#endif 
    567573          break; 
    568574        case 2: 
    569           buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     575          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    570576          (*myPtrs->offsetV9Ptr)++; 
    571           buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     577          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    572578          (*myPtrs->offsetV9Ptr)++; 
    573579          if (pftmp->fieldType==7){ 
    574580            agCache.sPort = *((unsigned short*)&buffer2); 
    575           }        
     581          } 
    576582          if (pftmp->fieldType==11){ 
    577583            agCache.dPort = *((unsigned short*)&buffer2); 
     
    580586          if (pftmp->fieldType==10){ 
    581587            agCache.inputSnmp = *((unsigned short*)&buffer2); 
    582           }        
     588          } 
    583589          if (pftmp->fieldType==14){ 
    584590            agCache.outputSnmp = *((unsigned short*)&buffer2); 
    585           }        
     591          } 
    586592#endif 
    587593#ifdef ASACC 
    588594          if (pftmp->fieldType==16){ 
    589595            agCache.asS = *((unsigned short*)&buffer2); 
    590           }        
     596          } 
    591597          if (pftmp->fieldType==17){ 
    592598            agCache.asD = *((unsigned short*)&buffer2); 
     
    596602        case 3: 
    597603          buffer4[3]= 0; 
    598           buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     604          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    599605          (*myPtrs->offsetV9Ptr)++; 
    600           buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     606          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    601607          (*myPtrs->offsetV9Ptr)++; 
    602           buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     608          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    603609          (*myPtrs->offsetV9Ptr)++; 
    604610          /* aggregation */ 
     
    609615          break; 
    610616        case 4: 
    611           buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     617          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    612618          (*myPtrs->offsetV9Ptr)++; 
    613           buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     619          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    614620          (*myPtrs->offsetV9Ptr)++; 
    615           buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     621          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    616622          (*myPtrs->offsetV9Ptr)++; 
    617           buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     623          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    618624          (*myPtrs->offsetV9Ptr)++; 
    619625#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP) 
     
    623629          if (pftmp->fieldType==14){ 
    624630            agCache.outputSnmp = (unsigned short)*((unsigned long*)&buffer4); 
    625           }  
     631          } 
    626632          if ((pftmp->fieldType==8)){ 
    627633            bool = 1; 
     
    638644          if (pftmp->fieldType==16){ 
    639645            agCache.asS = (unsigned short)*((unsigned long*)&buffer4); 
    640           }        
     646          } 
    641647          if (pftmp->fieldType==17){ 
    642648            agCache.asD = (unsigned short)*((unsigned long*)&buffer4); 
     
    645651                if (pftmp->fieldType==1){ 
    646652            dosCache.bytes = *((unsigned long*)&buffer4); 
    647                         dosCache.sampling = *myPtrs->currentRouterPtr->sampled; 
    648           }  
     653                        dosCache.sampling = myPtrs->currentRouterPtr->sampled; 
     654          } 
    649655                if (pftmp->fieldType==2){ 
    650             dosCache.pkts = *((unsigned long*)&buffer4); 
    651           } 
     656            dosCache.packets = *((unsigned long*)&buffer4); 
     657          } 
     658      if (pftmp->fieldType==21){ 
     659                dosCache.endTime = *((unsigned long*)&buffer4); 
     660      } 
     661      if (pftmp->fieldType==22){ 
     662                dosCache.startTime = *((unsigned long*)&buffer4); 
     663      } 
    652664          break; 
    653665        case 16: 
     
    656668          } 
    657669          for (i=0; i<4; i++) { 
    658             buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     670            buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    659671            (*myPtrs->offsetV9Ptr)++; 
    660             buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     672            buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    661673            (*myPtrs->offsetV9Ptr)++; 
    662             buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     674            buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    663675            (*myPtrs->offsetV9Ptr)++; 
    664             buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));  
     676            buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); 
    665677            (*myPtrs->offsetV9Ptr)++; 
    666678#if defined IPV6AGGIDSNMP 
     
    681693      } /* end if one cache table line existence */ 
    682694      if (cpt==tmp->fieldCount) { 
    683         /*  
    684          * end of one flow (not the flowset)  
     695        /* 
     696         * end of one flow (not the flowset) 
    685697         */ 
    686698        myPtrs->currentMIB->realFlowNb += 1; 
     
    688700        flowCpt++; 
    689701        fprintf(stderr," F%d ", flowCpt); 
    690 #endif  
     702#endif 
    691703        /* put aggregation cache information to IPv4 Prefixes table */ 
    692704        /* Aggregation mode must be enable in ./configure options   */ 
     
    718730                (asres->flowNbOUT)++; 
    719731              } 
    720               if (asres->sampling == 0  
     732              if (asres->sampling == 0 
    721733                  && myPtrs->currentRouterPtr->sampled != 0){ 
    722734                asres->sampling = myPtrs->currentRouterPtr->sampled; 
     
    744756                  (asres->flowNbIN)++; 
    745757                } 
    746                 if (asres->sampling == 0  
     758                if (asres->sampling == 0 
    747759                    && myPtrs->currentRouterPtr->sampled != 0){ 
    748760                  asres->sampling = myPtrs->currentRouterPtr->sampled; 
     
    775787                  (asres->flowNbIN)++; 
    776788                } 
    777                 if (asres->sampling == 0  
     789                if (asres->sampling == 0 
    778790                    && myPtrs->currentRouterPtr->sampled != 0){ 
    779791                  asres->sampling = myPtrs->currentRouterPtr->sampled; 
     
    860872            myPtrs->currentMIB->ipv4OthersApPcktsNb += agCache.pkts; 
    861873            break; 
    862           }   
     874          } 
    863875          /* end of mib update */ 
    864876        } 
     
    870882          /*      prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS); */ 
    871883          prefixKey.beginning = agCache.v4AdS; 
    872           res = bsearch(&prefixKey, V4PTab, nbPV4,  
     884          res = bsearch(&prefixKey, V4PTab, nbPV4, 
    873885                        sizeof(struct PrefixV4), prefGlobalCmp); 
    874886          if (res!=NULL){ 
     
    876888            if (res->hasSubnet == 1) { 
    877889              resSub = NULL; 
    878               resSub = bsearch(&prefixKey, V4STab, nbSV4,  
     890              resSub = bsearch(&prefixKey, V4STab, nbSV4, 
    879891                               sizeof(struct PrefixV4), prefGlobalCmp); 
    880892              if (resSub != NULL) { 
    881893                res = resSub; 
    882894                resSub = NULL; 
    883               }  
     895              } 
    884896            } 
    885897#ifdef DEBUG 
    886898            fprintf(stderr,"S %lu.%lu.%lu.%lu/%hu %lu.%lu.%lu.%lu/%hu Rs %lu Ps %lu SNMPin(hu) %hu\n", 
    887899                    (agCache.v4AdS>>24), 
    888                     (agCache.v4AdS<<8>>24),  
    889                     (agCache.v4AdS<<16>>24),  
    890                     (agCache.v4AdS<<24>>24),  
     900                    (agCache.v4AdS<<8>>24), 
     901                    (agCache.v4AdS<<16>>24), 
     902                    (agCache.v4AdS<<24>>24), 
    891903                    (agCache.maskS), 
    892                     (agCache.v4AdD>>24),  
    893                     (agCache.v4AdD<<8>>24),  
    894                     (agCache.v4AdD<<16>>24),  
    895                     (agCache.v4AdD<<24>>24),  
     904                    (agCache.v4AdD>>24), 
     905                    (agCache.v4AdD<<8>>24), 
     906                    (agCache.v4AdD<<16>>24), 
     907                    (agCache.v4AdD<<24>>24), 
    896908                    (agCache.maskD), 
    897909                    myPtrs->currentRouterPtr->sampled, 
     
    900912#endif 
    901913#if defined(IPV4AGGIDR) 
    902             if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {  
     914            if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) { 
    903915#elif defined(IPV4AGGIDSNMP) 
    904               if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) {        
     916              if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) { 
    905917#endif 
    906918                /* OUT ("traffic from the prefix/subnet")  */ 
     
    948960                  } 
    949961                } 
    950                 if (res->sampling == 0  
     962                if (res->sampling == 0 
    951963                    && myPtrs->currentRouterPtr->sampled != 0){ 
    952964                  res->sampling = myPtrs->currentRouterPtr->sampled; 
     
    956968                /*              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);*/ 
    957969                prefixKey.beginning = agCache.v4AdD; 
    958                 res3 = bsearch(&prefixKey, V4PTab, nbPV4,  
     970                res3 = bsearch(&prefixKey, V4PTab, nbPV4, 
    959971                               sizeof(struct PrefixV4), prefGlobalCmp); 
    960972                if (res3!=NULL){ 
     
    962974                  if (res3->hasSubnet == 1) { 
    963975                    resSub = NULL; 
    964                     resSub = bsearch(&prefixKey, V4STab, nbSV4,  
     976                    resSub = bsearch(&prefixKey, V4STab, nbSV4, 
    965977                                     sizeof(struct PrefixV4), prefGlobalCmp); 
    966978                    if (resSub != NULL) { 
     
    972984            fprintf(stderr,"S&D %lu.%lu.%lu.%lu/%hu %lu.%lu.%lu.%lu/%hu Rs %lu Ps %lu SNMPin %hu\n", 
    973985                    (agCache.v4AdS>>24), 
    974                     (agCache.v4AdS<<8>>24),  
    975                     (agCache.v4AdS<<16>>24),  
    976                     (agCache.v4AdS<<24>>24),  
     986                    (agCache.v4AdS<<8>>24), 
     987                    (agCache.v4AdS<<16>>24), 
     988                    (agCache.v4AdS<<24>>24), 
    977989                    (agCache.maskS), 
    978                     (agCache.v4AdD>>24),  
    979                     (agCache.v4AdD<<8>>24),  
    980                     (agCache.v4AdD<<16>>24),  
    981                     (agCache.v4AdD<<24>>24),  
     990                    (agCache.v4AdD>>24), 
     991                    (agCache.v4AdD<<8>>24), 
     992                    (agCache.v4AdD<<16>>24), 
     993                    (agCache.v4AdD<<24>>24), 
    982994                    (agCache.maskD), 
    983995                    myPtrs->currentRouterPtr->sampled, 
     
    10301042                    } 
    10311043                  } 
    1032                   if (res3->sampling == 0  
     1044                  if (res3->sampling == 0 
    10331045                      && myPtrs->currentRouterPtr->sampled != 0){ 
    10341046                    res3->sampling = myPtrs->currentRouterPtr->sampled; 
     
    10411053                /*              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);*/ 
    10421054                prefixKey.beginning = agCache.v4AdD; 
    1043                 res2 = bsearch(&prefixKey, V4PTab, nbPV4,  
     1055                res2 = bsearch(&prefixKey, V4PTab, nbPV4, 
    10441056                               sizeof(struct PrefixV4), prefGlobalCmp); 
    10451057                if (res2!=NULL){ 
     
    10611073                    ((struct POP *)((myPtrs->matrixPOP) 
    10621074                                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    1063                                     +((res2->routerNb))))->bytesNb += agCache.bytes;  
     1075                                    +((res2->routerNb))))->bytesNb += agCache.bytes; 
    10641076                    ((struct POP *)((myPtrs->matrixPOP) 
    10651077                                    +((res->routerNb)*ROUTER_INDEX_MAX) 
     
    10721084                  ((struct POP *)((myPtrs->matrixPOP) 
    10731085                                  +((res->routerNb)*ROUTER_INDEX_MAX) 
    1074                                   +((res2->routerNb))))->bytesNb += agCache.bytes;  
     1086                                  +((res2->routerNb))))->bytesNb += agCache.bytes; 
    10751087                  ((struct POP *)((myPtrs->matrixPOP) 
    10761088                                  +((res->routerNb)*ROUTER_INDEX_MAX) 
    1077                                   +((res2->routerNb))))->flowNb++;  
    1078 #endif 
    1079                 } else {  
     1089                                  +((res2->routerNb))))->flowNb++; 
     1090#endif 
     1091                } else { 
    10801092                  /* here we'll make the choice that in multisampling mode, 
    10811093                   * the virtual POP that represent the reste of world will be 
     
    10851097                   ((struct POP *)(myPtrs->matrixPOP) 
    10861098                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    1087                     +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10;  
     1099                    +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10; 
    10881100                  ( 
    10891101                   ((struct POP *)(myPtrs->matrixPOP) 
    10901102                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    1091                     +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10;  
     1103                    +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10; 
    10921104                  ( 
    10931105                   ((struct POP *)(myPtrs->matrixPOP) 
     
    10981110                   ((struct POP *)(myPtrs->matrixPOP) 
    10991111                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    1100                     +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts;  
     1112                    +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts; 
    11011113                  ( 
    11021114                   ((struct POP *)(myPtrs->matrixPOP) 
    11031115                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    1104                     +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes;  
     1116                    +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes; 
    11051117                  ( 
    11061118                   ((struct POP *)(myPtrs->matrixPOP) 
    11071119                    +((res->routerNb)*ROUTER_INDEX_MAX) 
    11081120                    +((ROUTER_INDEX_MAX-1))))->flowNb++; 
    1109 #endif           
     1121#endif 
    11101122                } 
    11111123                /* end interpop matrix accounting */ 
     
    11211133            /*      prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD); */ 
    11221134            prefixKey.beginning = agCache.v4AdD; 
    1123             res = bsearch(&prefixKey, V4PTab, nbPV4,  
     1135            res = bsearch(&prefixKey, V4PTab, nbPV4, 
    11241136                          sizeof(struct PrefixV4), prefGlobalCmp); 
    11251137            if (res!=NULL){ 
     
    11271139              if (res->hasSubnet == 1) { 
    11281140                resSub = NULL; 
    1129                 resSub = bsearch(&prefixKey, V4STab, nbSV4,  
     1141                resSub = bsearch(&prefixKey, V4STab, nbSV4, 
    11301142                                 sizeof(struct PrefixV4), prefGlobalCmp); 
    11311143                if (resSub != NULL) { 
     
    11371149            fprintf(stderr,"D %lu.%lu.%lu.%lu/%hu %lu.%lu.%lu.%lu/%hu Rs %lu Ps %lu R@ %lu.%lu.%lu.%lu SNMPin %hu\n", 
    11381150                    (agCache.v4AdS>>24), 
    1139                     (agCache.v4AdS<<8>>24),  
    1140                     (agCache.v4AdS<<16>>24),  
    1141                     (agCache.v4AdS<<24>>24),  
     1151                    (agCache.v4AdS<<8>>24), 
     1152                    (agCache.v4AdS<<16>>24), 
     1153                    (agCache.v4AdS<<24>>24), 
    11421154                    (agCache.maskS), 
    1143                     (agCache.v4AdD>>24),  
    1144                     (agCache.v4AdD<<8>>24),  
    1145                     (agCache.v4AdD<<16>>24),  
    1146                     (agCache.v4AdD<<24>>24),  
     1155                    (agCache.v4AdD>>24), 
     1156                    (agCache.v4AdD<<8>>24), 
     1157                    (agCache.v4AdD<<16>>24), 
     1158                    (agCache.v4AdD<<24>>24), 
    11471159                    (agCache.maskD), 
    11481160                    myPtrs->currentRouterPtr->sampled, 
    11491161                    res->sampling, 
    1150                     (myPtrs->pcktPtr->ipH->srcAdd>>24),  
     1162                    (myPtrs->pcktPtr->ipH->srcAdd>>24), 
    11511163                    (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
    11521164                    (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     
    12021214              } 
    12031215#endif 
    1204 #if defined(IPV4AGGIDR)  
     1216#if defined(IPV4AGGIDR) 
    12051217              if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) { 
    12061218#if defined(MULTISAMPLING) 
     
    12541266                   ((struct POP *)(myPtrs->matrixPOP) 
    12551267                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX) 
    1256                     +((res->routerNb))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10;  
     1268                    +((res->routerNb))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10; 
    12571269                  ( 
    12581270                   ((struct POP *)(myPtrs->matrixPOP) 
    12591271                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX) 
    1260                     +((res->routerNb))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10;  
     1272                    +((res->routerNb))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10; 
    12611273                  ( 
    12621274                   ((struct POP *)(myPtrs->matrixPOP) 
     
    12691281                   ((struct POP *)(myPtrs->matrixPOP) 
    12701282                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX) 
    1271                     +((res->routerNb))))->pktsNb += agCache.pkts;  
     1283                    +((res->routerNb))))->pktsNb += agCache.pkts; 
    12721284                  ( 
    12731285                   ((struct POP *)(myPtrs->matrixPOP) 
    12741286                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX) 
    1275                     +((res->routerNb))))->bytesNb += agCache.bytes;  
     1287                    +((res->routerNb))))->bytesNb += agCache.bytes; 
    12761288                  ( 
    12771289                   ((struct POP *)(myPtrs->matrixPOP) 
     
    12791291                    +((res->routerNb))))->flowNb++; 
    12801292#endif 
    1281 #endif   
    1282               } 
    1283               if (res->sampling == 0  
     1293#endif 
     1294              } 
     1295              if (res->sampling == 0 
    12841296                  && myPtrs->currentRouterPtr->sampled != 0 ){ 
    12851297                res->sampling = myPtrs->currentRouterPtr->sampled; 
    12861298              } 
    12871299#endif 
    1288             } else { 
     1300            } else { /* UNKNOW SUBNET CASE */ 
    12891301              /* UNKNOW SUBNET CASE                                        */ 
    12901302              /*                                                           */ 
     
    12951307              /*     -  prefix not referenced but not allowed to be routed */ 
    12961308              /*     -  spoofing                                           */ 
    1297 #ifdef PRINTUNKNOWNSUBNET  
     1309#ifdef PRINTUNKNOWNSUBNET 
    12981310              fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu (R:%lu.%lu.%lu.%lu) \n", 
    12991311                      (agCache.v4AdS>>24), 
    1300                       (agCache.v4AdS<<8>>24),  
    1301                       (agCache.v4AdS<<16>>24),  
    1302                       (agCache.v4AdS<<24>>24),  
    1303                       (agCache.maskS),  
    1304                       (agCache.v4AdD>>24),  
    1305                       (agCache.v4AdD<<8>>24),  
    1306                       (agCache.v4AdD<<16>>24),  
    1307                       (agCache.v4AdD<<24>>24),  
    1308                       (agCache.maskD),  
    1309                       (myPtrs->pcktPtr->ipH->srcAdd>>24),  
     1312                      (agCache.v4AdS<<8>>24), 
     1313                      (agCache.v4AdS<<16>>24), 
     1314                      (agCache.v4AdS<<24>>24), 
     1315                      (agCache.maskS), 
     1316                      (agCache.v4AdD>>24), 
     1317                      (agCache.v4AdD<<8>>24), 
     1318                      (agCache.v4AdD<<16>>24), 
     1319                      (agCache.v4AdD<<24>>24), 
     1320                      (agCache.maskD), 
     1321                      (myPtrs->pcktPtr->ipH->srcAdd>>24), 
    13101322                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
    13111323                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     
    13311343          ((struct IndexV6 *)((myPtrs->currentV6IndexTab) 
    13321344                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER) 
    1333                               +(agCache.outputSnmp)))->indexSNMP = agCache.outputSnmp;  
     1345                              +(agCache.outputSnmp)))->indexSNMP = agCache.outputSnmp; 
    13341346          /* FIXME, error or warning if (indexSNMP != agCache.outputSnmp) */ 
    13351347          ((struct IndexV6 *)((myPtrs->currentV6IndexTab) 
     
    14381450            myPtrs->currentMIB->ipv6OthersApPcktsNb += agCache.pkts; 
    14391451            break; 
    1440           }   
     1452          } 
    14411453          /* end of mib update */ 
    14421454          isIPv6 = 0; 
     
    14451457 
    14461458        /* DoS DETECTION */ 
    1447         if ( ( dosCache.packets*dosCache.sampling > MAX_PKTS_DOS )   
    1448                   && ((dosCache.packets)/(dosCache.bytes) < RATIO_DOS ) ) { 
    1449                                 jdos = 0; 
    1450         posdos = 69*MAX_RULES_PER_FIELD+jdos; 
     1459    if ( dosCache.endTime-dosCache.startTime > 1000 ) { 
     1460      if ( ( (dosCache.packets*dosCache.sampling)/((dosCache.endTime-dosCache.startTime)/1000) > MAX_PKTS_DOS ) 
     1461          && ((dosCache.bytes)/(dosCache.packets) < RATIO_DOS ) ) { 
     1462        jdos = 0; 
     1463        posdos = 69*MAX_RULES_PER_FIELD+jdos; 
    14511464        while ( ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+jdos))) != NULL ) { 
    1452                                         ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+posdos)))->check = 1; 
    1453                                         jdos++; 
    1454                                 } 
    1455         } 
    1456  
    1457         /*  
     1465          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+posdos)))->check = 1; 
     1466          jdos++; 
     1467        } 
     1468      } 
     1469    } else { /* flow duration <= 1000ms , we divide by 1 (sec) */ 
     1470      if ( ( (dosCache.packets*dosCache.sampling) > MAX_PKTS_DOS ) 
     1471          & ((dosCache.bytes)/(dosCache.packets) < RATIO_DOS ) ) { 
     1472        jdos = 0; 
     1473        posdos = 69*MAX_RULES_PER_FIELD+jdos; 
     1474        while ( ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+jdos))) != NULL ) { 
     1475          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+posdos)))->check = 1; 
     1476          jdos++; 
     1477        } 
     1478      } 
     1479    } 
     1480 
     1481        /* 
    14581482         * 
    14591483         * SOCKET OUTPUT TO A REMOTE CLIENT 
    14601484         * 
    1461          * switch the rules definition (check & fieldToRecord),  
     1485         * switch the rules definition (check & fieldToRecord), 
    14621486         * we send the flow or a part of the flow to a remote host or a file. 
    14631487         * In a first time (until release 0.0.7, the information was sent via 
     
    14811505            /* msg building */ 
    14821506            secondPftmp = tmp->lastField; 
    1483             msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text,    
    1484                                                    &tplMsgType,  
    1485                                                    sizeof(unsigned short)  
     1507            msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text, 
     1508                                                   &tplMsgType, 
     1509                                                   sizeof(unsigned short) 
    14861510                                                   ), 
    14871511                                           &tmpRuleList->id, 
    14881512                                           sizeof(tmpRuleList->id) 
    14891513                                           ), 
    1490                                    &myPtrs->currentRouterPtr->IpAddress,  
    1491                                    sizeof(unsigned long)  
     1514                                   &myPtrs->currentRouterPtr->IpAddress, 
     1515                                   sizeof(unsigned long) 
    14921516                                   ); 
    1493             msgTextIndex = mempcpy(mempcpy(mempcpy(msgTextIndex,  
    1494                                                    &tmp->sourceId,  
    1495                                                    sizeof(unsigned long)  
     1517            msgTextIndex = mempcpy(mempcpy(mempcpy(msgTextIndex, 
     1518                                                   &tmp->sourceId, 
     1519                                                   sizeof(unsigned long) 
    14961520                                                   ), 
    14971521                                           &tmp->templateFlowSetId, 
     
    15001524                                   myPtrs->ptr_buffer+secondOffset, 
    15011525                                   flow_size 
    1502                                    );  
     1526                                   ); 
    15031527            myMsg.type = 1; 
    1504                
     1528 
    15051529 
    15061530            /* NEW transfert type */ 
    15071531            for ( ; tmpRL; tmpRL=tmpRL->next){ 
    1508               if (tmpRL->id == tmpRuleList->id){         
     1532              if (tmpRL->id == tmpRuleList->id){ 
    15091533                s = sendMessage(tmpRL->host->sockId, myMsg.text, sizeof(myMsg.text), 
    15101534                                tmpRL->host->hostAddressPtr); 
     
    15191543          secondPftmp = tmp->lastField; 
    15201544        } /* end while tmpRuleList */ 
    1521         /*  
    1522          * end redirection  
     1545        /* 
     1546         * end redirection 
    15231547         */ 
    15241548        secondOffset = *myPtrs->offsetV9Ptr; 
     
    15331557        /* not the flow end, progress in field list */ 
    15341558        pftmp = pftmp->prev; 
    1535       }     
     1559      } 
    15361560    } /* end of the while on one flow record */ 
    1537         
     1561 
    15381562    while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) { 
    15391563      (*myPtrs->offsetV9Ptr)++; /* if padding */ 
     
    15501574      } 
    15511575    } 
    1552     while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) {  
     1576    while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) { 
    15531577      (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */ 
    15541578      crazyCounter++; 
     
    15581582#endif 
    15591583    if (crazyCounter!=0) { syslog(LOG_INFO,"crazyCounter: %d ", crazyCounter);} 
    1560        
     1584 
    15611585#ifdef DEBUG 
    15621586    fprintf(stderr,"(%hu,%hu)}", data_length, data_length+shift); 
    15631587#endif 
    1564        
     1588 
    15651589    return (data_length+shift); 
    15661590    /* end new place */ 
     
    15741598     * 
    15751599     */ 
    1576     if ((tmpOpt=existTplOptId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,  
    1577                               (*myPtrs->currentFlowsetIdPtr)))!=NULL) {         
     1600    if ((tmpOpt=existTplOptId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId, 
     1601                              (*myPtrs->currentFlowsetIdPtr)))!=NULL) { 
    15781602 
    15791603      myPtrs->currentMIB->optDataFlowSetNb += 1; 
     
    15821606#endif 
    15831607      for ( i=0; i<(tmpOpt->optionScopeLg/4); i++){ 
    1584         /* FIXME : today we skip the scope fields, it's bad :( */  
     1608        /* FIXME : today we skip the scope fields, it's bad :( */ 
    15851609        if ((pftmp=tmpOpt->lastField)!=NULL) { 
    15861610          for (j=0; j<pftmp->fieldLength; j++) { 
    1587             (*myPtrs->offsetV9Ptr)++;  
     1611            (*myPtrs->offsetV9Ptr)++; 
    15881612          } 
    15891613          pftmp = pftmp->prev; 
     
    15911615      } 
    15921616      while (pftmp != NULL) { 
    1593         if (pftmp->fieldLength==1){  
     1617        if (pftmp->fieldLength==1){ 
    15941618          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    15951619        } 
    1596         if (pftmp->fieldLength==2){  
     1620        if (pftmp->fieldLength==2){ 
    15971621          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    15981622          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    15991623        } 
    1600         if (pftmp->fieldLength==4){  
     1624        if (pftmp->fieldLength==4){ 
    16011625          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    16021626          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
     
    16041628          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++; 
    16051629          if (pftmp->fieldType==34||pftmp->fieldType==50){ 
    1606             if ((*((unsigned long*)&buffer4)==1)  
     1630            if ((*((unsigned long*)&buffer4)==1) 
    16071631                || (*((unsigned long*)&buffer4)==10) 
    16081632                || (*((unsigned long*)&buffer4)==20) 
     
    16341658            } 
    16351659          } 
    1636         }        
     1660        } 
    16371661        pftmp = pftmp->prev; 
    16381662      } 
     
    16531677      return (data_length+shift); 
    16541678    } else { 
    1655       /*  
    1656        * template unknown, we skip the data  
     1679      /* 
     1680       * template unknown, we skip the data 
    16571681       */ 
    16581682      (*myPtrs->offsetV9Ptr)+=(data_length-4); 
     
    16651689              (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
    16661690              (myPtrs->pcktPtr->ipH->srcAdd<<24>>24), 
    1667               myPtrs->currentHeaderV9Ptr->sourceId,  
     1691              myPtrs->currentHeaderV9Ptr->sourceId, 
    16681692              (*myPtrs->currentFlowsetIdPtr) 
    16691693              );