Changeset 22 for trunk/src/dataFlowSet.c

Show
Ignore:
Timestamp:
01/17/07 18:37:59 (16 years ago)
Author:
andreu
Message:

aggregation et timer

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/src/dataFlowSet.c

    r20 r22  
    2727 
    2828/* 
    29  * checkDataFlowSet 
     29 * 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 ? 
    3151 */ 
    3252unsigned short  
     
    6585  struct PrefixV4 prefixKey, *res; /* for bsearch */ 
    6686  struct AggCache agCache; 
    67 #ifdef CRIHAN 
    68   struct IPFLowCache ipFirstCache; /* CRI */ 
    69   struct MPLSFlowCache mplsFirstCache; /* CRI */ 
    70   unsigned long firstTime = 0; /* CRI */ 
    71   unsigned long lastTime = 0; /* CRI */ 
    72 #endif /* CRIHAN */ 
    73   int bool = 0; 
     87  int bool = 0; /* in IPV4 Agg mode enabled, we need to now if it's an IPv4 */ 
     88                /* flow, we test on the field and then put bool at 1 */ 
     89#ifdef CRIHAN 
     90  struct IPFLowCache ipFirstCache; 
     91  struct MPLSFlowCache mplsFirstCache; 
     92  unsigned long firstTime = 0;  
     93  unsigned long lastTime = 0;  
    7494 
    75 #ifdef CRIHAN 
    7695  ipFirstCache.ipProt = 0; 
    7796  ipFirstCache.bytes = 0; 
     
    117136      return (data_length+shift); 
    118137    } 
    119     /* aggreg */ 
    120 /*     agCache.routerAd = pcktPtr->ipH->srcAdd; */ 
    121     /* end aggreg */ 
     138#ifdef IPV4AGG 
     139    agCache.routerAd = pcktPtr->ipH->srcAdd;  
     140#endif 
    122141 
    123142#ifdef CRIHAN 
     
    164183              } 
    165184              /* end rule check */ 
    166               /* aggregation */ 
    167 /*            if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ */ 
    168 /*              agCache.maskS = *((unsigned char*)&buffer1); */ 
    169 /*            } */ 
    170 /*            if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){ */ 
    171 /*              agCache.maskD = *((unsigned char*)&buffer1); */ 
    172 /*            } */ 
    173 /*            if (pftmp->fieldType==60){ */ 
    174 /*              agCache.ipProt = *((unsigned char*)&buffer1); */ 
    175 /*            } */ 
    176 /*            if (pftmp->fieldType==4){ */ 
    177 /*              agCache.tProt = *((unsigned char*)&buffer1); */ 
    178 /*            } */ 
    179 /*            if (pftmp->fieldType==61){ */ 
    180 /*              agCache.sens = *((unsigned char*)&buffer1); */ 
    181 /*            } */ 
    182 /*            if (pftmp->fieldType==5){ */ 
    183 /*              agCache.dscp = *((unsigned char*)&buffer1); */ 
    184 /*            } */ 
    185               /* end aggregation */ 
     185#ifdef IPV4AGG 
     186              if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ 
     187                agCache.maskS = *((unsigned char*)&buffer1); 
     188              } 
     189              if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){ 
     190                agCache.maskD = *((unsigned char*)&buffer1); 
     191              } 
     192              if (pftmp->fieldType==60){ 
     193                agCache.ipProt = *((unsigned char*)&buffer1); 
     194              } 
     195              if (pftmp->fieldType==4){ 
     196                agCache.tProt = *((unsigned char*)&buffer1); 
     197              } 
     198              if (pftmp->fieldType==61){ 
     199                agCache.sens = *((unsigned char*)&buffer1); 
     200              } 
     201              if (pftmp->fieldType==5){ 
     202                agCache.dscp = *((unsigned char*)&buffer1); 
     203              } 
     204#endif         
    186205#ifdef CRIHAN 
    187206              if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ 
     
    198217                ipFirstCache.tProt = *((unsigned char*)&buffer1);  
    199218              } 
    200 #endif /* CRIHAN */ 
     219#endif 
    201220              break; 
    202221            case 2: 
     
    206225                  == *((unsigned short*)&buffer2)) 
    207226                ((RuleDefPtr)(*(rulesCache+pos)))->check = 1; 
    208               /* aggregation */ 
    209 /*            if (pftmp->fieldType==10){ */ 
    210 /*              agCache.idSnmp = *((unsigned short*)&buffer2); */ 
    211 /*            } */ 
    212               /* end aggregation */ 
     227#ifdef IPV4AGG 
     228              if (pftmp->fieldType==10){ 
     229                agCache.idSnmp = *((unsigned short*)&buffer2); 
     230              } 
     231#endif 
    213232#ifdef CRIHAN 
    214233              if (pftmp->fieldType==10){ 
     
    224243                ipFirstCache.dPort = *((unsigned short*)&buffer2); 
    225244              } 
    226 #endif /* CRIHAN */  
     245#endif 
    227246              break; 
    228247            case 3: 
     
    240259                mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4; 
    241260              } 
    242 #endif /* CRIHAN */ 
     261#endif 
    243262              break; 
    244263            case 4: 
     
    255274                  } 
    256275              }        
    257               /* aggregation */ 
    258 /*            if ((pftmp->fieldType==8)){ */ 
    259 /*              agCache.v4AdS = *((unsigned long*)&buffer4); */ 
    260 /*            } */ 
    261 /*            if ((pftmp->fieldType==12)){ */ 
    262 /*              agCache.v4AdD = *((unsigned long*)&buffer4); */ 
    263 /*            } */ 
    264 /*            if (pftmp->fieldType==1){ */ 
    265 /*              agCache.bytes = *((unsigned long*)&buffer4); */ 
    266 /*            } */ 
    267 /*            if (pftmp->fieldType==2){ */ 
    268 /*              agCache.pkts = *((unsigned long*)&buffer4); */ 
    269 /*            } */ 
    270               /* end aggregation */ 
     276#ifdef IPV4AGG 
     277              if ((pftmp->fieldType==8)){ 
     278                agCache.v4AdS = *((unsigned long*)&buffer4); 
     279              } 
     280              if ((pftmp->fieldType==12)){ 
     281                agCache.v4AdD = *((unsigned long*)&buffer4); 
     282              } 
     283              if (pftmp->fieldType==1){ 
     284                agCache.bytes = *((unsigned long*)&buffer4); 
     285              } 
     286              if (pftmp->fieldType==2){ 
     287                agCache.pkts = *((unsigned long*)&buffer4); 
     288              } 
     289#endif 
    271290#ifdef CRIHAN 
    272291              if (pftmp->fieldType==8){ 
     
    290309                lastTime = *((unsigned long*)&buffer4); 
    291310              } 
    292 #endif /* CRIHAN */ 
     311#endif 
    293312              break; 
    294313            case 16: 
     
    415434              } 
    416435              moreIsNecessary = 1; 
    417               /* aggregation */ 
     436              /* aggregation for IPv6 flows */ 
    418437               
    419438              /* end aggregation */ 
     
    437456      } else { 
    438457        /*  
    439          * no rule within this field type, but we must reading the value  
     458         * no rule within this field type, but we must read the value  
    440459         */ 
    441460        switch (field_size) { 
    442461        case 1: 
    443462          buffer1 = *(buf+(*offV9)); (*offV9)++; 
    444           /* aggregation */ 
    445 /*        if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ */ 
    446 /*          agCache.maskS = *((unsigned char*)&buffer1); */ 
    447 /*        } */ 
    448 /*        if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){ */ 
    449 /*          agCache.maskD = *((unsigned char*)&buffer1); */ 
    450 /*        } */ 
    451 /*        if (pftmp->fieldType==60){ */ 
    452 /*          agCache.ipProt = *((unsigned char*)&buffer1); */ 
    453 /*        } */ 
    454 /*        if (pftmp->fieldType==4){ */ 
    455 /*          agCache.tProt = *((unsigned char*)&buffer1); */ 
    456 /*        } */ 
    457 /*        if (pftmp->fieldType==61){ */ 
    458 /*          agCache.sens = *((unsigned char*)&buffer1); */ 
    459 /*        } */ 
    460 /*        if (pftmp->fieldType==5){ */ 
    461 /*          agCache.dscp = *((unsigned char*)&buffer1); */ 
    462 /*        }        */ 
    463           /* end aggregation */ 
     463#ifdef IPV4AGG 
     464          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ 
     465            agCache.maskS = *((unsigned char*)&buffer1); 
     466          } 
     467          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){ 
     468            agCache.maskD = *((unsigned char*)&buffer1); 
     469          } 
     470          if (pftmp->fieldType==60){ 
     471            agCache.ipProt = *((unsigned char*)&buffer1); 
     472          } 
     473          if (pftmp->fieldType==4){ 
     474            agCache.tProt = *((unsigned char*)&buffer1); 
     475          } 
     476          if (pftmp->fieldType==61){ 
     477            agCache.sens = *((unsigned char*)&buffer1); 
     478          } 
     479          if (pftmp->fieldType==5){ 
     480            agCache.dscp = *((unsigned char*)&buffer1); 
     481          }        
     482#endif 
    464483#ifdef CRIHAN 
    465484          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){ 
     
    476495            ipFirstCache.tProt = *((unsigned char*)&buffer1);  
    477496          } 
    478 #endif /* CRIHAN */ 
     497#endif 
    479498          break; 
    480499        case 2: 
    481500          buffer2[1]= *(buf+(*offV9)); (*offV9)++; 
    482501          buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
    483           /* aggregation */ 
     502#ifdef IPV4AGG 
    484503          if (pftmp->fieldType==10){ 
    485504            agCache.idSnmp = *((unsigned short*)&buffer2); 
    486505          }        
    487           /* end aggregation */ 
     506#endif 
    488507#ifdef CRIHAN 
    489508          if (pftmp->fieldType==10){ 
     
    499518            ipFirstCache.dPort = *((unsigned short*)&buffer2); 
    500519          } 
    501 #endif /* CRIHAN */ 
     520#endif 
    502521          break; 
    503522        case 3: 
     
    512531            mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4; 
    513532          } 
    514 #endif /* CRIHAN */ 
     533#endif 
    515534          break; 
    516535        case 4: 
     
    519538          buffer4[1]= *(buf+(*offV9)); (*offV9)++; 
    520539          buffer4[0]= *(buf+(*offV9)); (*offV9)++; 
    521           /* aggregation */ 
    522 /*        if ((pftmp->fieldType==8)){ */ 
    523 /*          bool = 1; */ 
    524 /*          agCache.v4AdS = *((unsigned long*)&buffer4); */ 
    525 /*        } else if ((pftmp->fieldType==12)){ */ 
    526 /*          agCache.v4AdD = *((unsigned long*)&buffer4); */ 
    527 /*        } else if (pftmp->fieldType==1){ */ 
    528 /*          agCache.bytes = *((unsigned long*)&buffer4); */ 
    529 /*        } else if (pftmp->fieldType==2){ */ 
    530 /*          agCache.pkts = *((unsigned long*)&buffer4); */ 
    531 /*        } */ 
    532           /* end aggregation */ 
     540#ifdef IPV4AGG 
     541          if ((pftmp->fieldType==8)){ 
     542            bool = 1; 
     543            agCache.v4AdS = *((unsigned long*)&buffer4); 
     544          } else if ((pftmp->fieldType==12)){ 
     545            agCache.v4AdD = *((unsigned long*)&buffer4); 
     546          } else if (pftmp->fieldType==1){ 
     547            agCache.bytes = *((unsigned long*)&buffer4); 
     548          } else if (pftmp->fieldType==2){ 
     549            agCache.pkts = *((unsigned long*)&buffer4); 
     550          } 
     551#endif 
    533552#ifdef CRIHAN 
    534553          if (pftmp->fieldType==8){ 
     
    552571            lastTime = *((unsigned long*)&buffer4); 
    553572          } 
    554 #endif /* CRIHAN */ 
     573#endif 
    555574          break; 
    556575        case 16: 
     
    561580            buffer2[0]= *(buf+(*offV9)); (*offV9)++; 
    562581          } 
    563           /* aggregation */        
     582          /* aggregation IPv6 */           
    564583          /* end aggregation */ 
    565584          break; 
     
    617636          (*mplsCounter)++; 
    618637        } 
    619 #endif /* CRIHAN */ 
    620         /* put aggregation cache information to tables */ 
    621 /*      if (bool == 1){ */ 
    622 /*        prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS); */ 
    623 /*        res = bsearch(&prefixKey, V4PTab, nbPV4,  */ 
    624 /*                      sizeof(struct PrefixV4), prefCmp); */ 
    625 /*      } */ 
    626         bool = 0;     
    627         /* end put */ 
     638#endif  
     639        /* put aggregation cache information to IPv4 Prefixes table */ 
     640#ifdef IPV4AGG 
     641        if (bool == 1){ 
     642          prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS); 
     643          res = bsearch(&prefixKey, V4PTab, nbPV4,  
     644                        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) { 
     650            case 1: 
     651              res->icmpBytesNb += agCache.bytes; 
     652              res->icmpPktsNb += agCache.pkts; 
     653              res->icmpFlowNb += 1; 
     654              break; 
     655            case 6: 
     656              res->tcpBytesNb += agCache.bytes; 
     657              res->tcpPktsNb += agCache.pkts; 
     658              res->tcpFlowNb += 1;             
     659              break; 
     660            case 17: 
     661              res->udpBytesNb += agCache.bytes; 
     662              res->udpPktsNb += agCache.pkts; 
     663              res->udpFlowNb += 1; 
     664              break; 
     665            default: 
     666              res->othersBytesNb += agCache.bytes; 
     667              res->othersPktsNb += agCache.pkts; 
     668              res->othersFlowNb += 1;          
     669            } 
     670          } 
     671/*        if (res==NULL){ */ 
     672/*          fprintf(stderr, "IPv4_spoofing? ");  */ 
     673/*        } */ 
     674        } 
     675        bool = 0; 
     676#endif 
    628677        /*  
    629678         * Redirection if needed