root/trunk/src/dataFlowSet.c @ 144

Revision 144, 58.8 KB (checked in by andreu, 12 years ago)

DoS detection - detection in core (todo: email notification with renetcolSEC module)

  • Property svn:eol-style set to native
Line 
1/*
2 * File: dataFlowSet.c
3 *
4 * Authors: ANDREU Francois-Xavier
5 *
6 * Copyright (C) 2005 - 2010 GIP RENATER
7 */
8
9/*  This file is part of renetcol.
10 *
11 *  renetcol is free software; you can redistribute it and/or modify
12 *  it under the terms of the GNU General Public License as published by
13 *  the Free Software Foundation; either version 2 of the License, or
14 *  (at your option) any later version.
15 *
16 *  renetcol is distributed in the hope that it will be useful,
17 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *  GNU General Public License for more details.
20 *
21 *  You should have received a copy of the GNU General Public License
22 *  along with renetcol; if not, write to the Free Software
23 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24 */
25
26#include "dataFlowSet.h"
27
28/*
29 * Check Data FlowSet
30 *
31 */
32short 
33checkDataFlowSet(short shift,
34                 struct MyPtrs *myPtrs,
35                 int myQueue,
36                 struct PrefixV4 *V4PTab,
37                 size_t nbPV4,
38                 struct PrefixV4 *V4STab,
39                 size_t nbSV4
40                 )
41{
42  TplFlowSetPtr tmp = NULL;
43  TplOptionPtr tmpOpt = NULL;
44  FieldPtr pftmp = NULL;
45  FieldPtr secondPftmp = NULL;
46  unsigned short data_length = 0;
47  unsigned short flow_size = 0;
48  unsigned short oldOffset = *myPtrs->offsetV9Ptr;
49  unsigned short secondOffset = 0;
50  unsigned short secondOldOffset = 0;
51  int moreIsNecessary = 1;
52  int field_size = 0;
53  int cpt = 0;
54  int secondCpt = 0;
55  int overflow = 0;
56  int noEnd = 1;
57  int i = 0;
58  int j = 0;
59  int pos = 0;
60        int jdos = 0;
61        int posdos = 0;
62  unsigned char buffer1; 
63  unsigned char buffer2[2];
64  unsigned char buffer4[4];
65  RulesPtr tmpRuleList = myPtrs->rulesListPtr;
66  RulesPtr tmpRL = myPtrs->rulesListPtr;
67  msgType myMsg;
68  char *msgTextIndex;
69
70  unsigned short tplMsgType = 11;
71  struct PrefixV4 prefixKey, *res, *res2, *resSub; /* for bsearch */
72#if defined(IPV4AGGIDSNMP)
73  struct PrefixV4 *res3;
74#endif
75#ifdef ASACC
76  struct AS asKey, *asres; /* for bsearch */
77#endif
78  struct AggCache agCache;
79        struct DoSCache dosCache;
80  int bool = 0; /* in IPV4 Agg mode enabled, we need to now if it's an IPv4 */
81  int isIPv6 = 0;
82  /* flow, we test on the field and then put bool at 1 */
83  int isMplsFlow = 0;
84  int paddingCounter = 0;
85  int crazyCounter = 0;
86#ifdef DEBUG
87  int flowCpt = 0;
88#endif
89
90  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
91  (*myPtrs->offsetV9Ptr)++;
92  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
93  (*myPtrs->offsetV9Ptr)++;
94  (*myPtrs->currentFlowsetIdPtr) = *((unsigned short*)&buffer2);
95  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
96  (*myPtrs->offsetV9Ptr)++;
97  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
98  (*myPtrs->offsetV9Ptr)++;
99  data_length = *((unsigned short*)&buffer2);
100  if (data_length == 0) {
101#ifdef DEBUG   
102    fprintf (stderr, " dlg==0 <--| ");
103#endif
104/*     syslog(LOG_INFO, "data flowset length null; all next informations of this data flowset are not considered! flowset ID: %hu, from router: %lu.%lu.%lu.%lu", */
105/*         (*myPtrs->currentFlowsetIdPtr), */
106/*         (myPtrs->pcktPtr->ipH->srcAdd>>24), */
107/*         (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */
108/*         (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */
109/*         (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); */
110    return (-1);
111
112  }
113
114  if ( (tmp=existTplId(myPtrs->currentRouterPtr,
115                       myPtrs->currentHeaderV9Ptr->sourceId,
116                       (*myPtrs->currentFlowsetIdPtr)))!=NULL ) {
117    myPtrs->currentMIB->dataFlowSetNb += 1;
118#ifdef DEBUG
119    fprintf(stderr,
120            "{d id: %hu, lg %hu",
121            (*myPtrs->currentFlowsetIdPtr),
122            data_length);
123    if ( (*myPtrs->currentFlowsetIdPtr) > TRESHOLD_TEMPLATE_ID ) {
124        fprintf(stderr,"Bad TID from router: %lu.%lu.%lu.%lu\n",
125                (*myPtrs->currentFlowsetIdPtr),
126                (myPtrs->pcktPtr->ipH->srcAdd>>24),
127                (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
128                (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
129                (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
130        fprintf(stderr," Bytes : \n");
131        while ( ( myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr) ) > (myPtrs->ptr_buffer+1416) ){
132          buffer1= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
133          tmp = *((unsigned char*)&buffer1);
134          fprintf (stderr, " %s ", tmp);
135        }
136        exit(-1);
137      return (data_length+shift);
138    }
139#endif
140    pftmp = tmp->lastField;
141    for (; pftmp; pftmp = pftmp->prev) {
142      flow_size += pftmp->fieldLength;
143    }
144    if ( data_length%flow_size >= 9 ) {
145      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
146      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! sourceID: %lu flowset ID: %hu, from router: %lu.%lu.%lu.%lu",
147             myPtrs->currentHeaderV9Ptr->sourceId,
148             (*myPtrs->currentFlowsetIdPtr),
149             (myPtrs->pcktPtr->ipH->srcAdd>>24),
150             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
151             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
152             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
153#ifdef DEBUG   
154    fprintf (stderr, " dlg%flsz >=9 skip data ");
155#endif
156      return (data_length+shift);
157    }
158    if ( data_length >= 1452 ) {
159      syslog(LOG_INFO, "data flowset length too raised; all next informations of this data flowset are not considered! flowset ID: %hu, from router: %lu.%lu.%lu.%lu",
160             (*myPtrs->currentFlowsetIdPtr),
161             (myPtrs->pcktPtr->ipH->srcAdd>>24),
162             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
163             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
164             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
165#ifdef DEBUG   
166    fprintf (stderr, " dlg >= 1452 skip pckt ");
167#endif
168      return (-1);
169    }
170#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
171    agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
172#endif
173
174    pftmp = tmp->lastField;
175    secondPftmp = tmp->lastField;   
176    secondOffset = *myPtrs->offsetV9Ptr;
177    secondOldOffset = secondOffset;
178    while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length)
179            && (overflow!=1) ) {
180      /*
181       * progression in a data flow Set
182       * notes:
183       *   48= IP header size + NetFlow header size
184       *   shift = shift because we have a template declaration
185       *           inside data templates
186       */
187      cpt++;
188      j = 0;
189      pos = (pftmp->fieldType)*MAX_RULES_PER_FIELD+j;
190      field_size = (int) pftmp->fieldLength;
191
192      /* special case: check yes on all flows from one router */
193      /* (phantom field nb 0) */
194      /* FIXME : this code is repeated, perhaps past before */
195      while ( ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j))) != NULL ) {
196        if ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j)))->value->stor.lvalue)
197             == myPtrs->pcktPtr->ipH->srcAdd )
198          {
199            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j)))->check = 1;
200          }     
201        j++;
202      }   
203      j = 0;
204
205      /*
206       * Comparaison between the field value and the rules
207       * ... if one rule exist
208       * FIXME : warning, if no rules, no accounting ?
209       */
210      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL) {
211        oldOffset = *myPtrs->offsetV9Ptr;
212        while (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL){
213          /*
214           * while on one cache table line
215           */
216          *myPtrs->offsetV9Ptr = oldOffset;
217          switch ((int)
218                  (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)){
219          case 2:
220            /* operator: "=" */ 
221            switch (field_size) {
222            case 1:
223              buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
224              (*myPtrs->offsetV9Ptr)++;
225              /* rule check */
226              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue
227                  == *((unsigned char*)&buffer1)) {
228                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
229              }
230              /* end rule check */
231#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
232              if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
233                agCache.maskS = *((unsigned char*)&buffer1);
234              }
235              if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
236                agCache.maskD = *((unsigned char*)&buffer1);
237              }
238              if (pftmp->fieldType==60){
239                agCache.ipProt = *((unsigned char*)&buffer1);
240              }
241              if (pftmp->fieldType==4){
242                agCache.tProt = *((unsigned char*)&buffer1);
243              }
244              if (pftmp->fieldType==61){
245                agCache.sens = *((unsigned char*)&buffer1);
246              }
247              if (pftmp->fieldType==5){
248                agCache.dscp = *((unsigned char*)&buffer1);
249              }
250#endif       
251              break;
252            case 2:
253              buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
254              (*myPtrs->offsetV9Ptr)++;
255              buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
256              (*myPtrs->offsetV9Ptr)++;
257              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue
258                  == *((unsigned short*)&buffer2))
259                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
260              if (pftmp->fieldType==7){
261                agCache.sPort = *((unsigned short*)&buffer2);
262              }   
263              if (pftmp->fieldType==11){
264                agCache.dPort = *((unsigned short*)&buffer2);
265              }
266#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
267              if (pftmp->fieldType==10){
268                agCache.inputSnmp = *((unsigned short*)&buffer2);
269              }
270              if (pftmp->fieldType==14){
271                agCache.outputSnmp = *((unsigned short*)&buffer2);
272              }
273#endif
274#ifdef ASACC
275              if (pftmp->fieldType==16){
276                agCache.asS = *((unsigned short*)&buffer2);
277              }   
278              if (pftmp->fieldType==17){
279                agCache.asD = *((unsigned short*)&buffer2);
280              }
281#endif
282              break;
283            case 3:
284              buffer4[3]= 0;
285              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
286              (*myPtrs->offsetV9Ptr)++;
287              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
288              (*myPtrs->offsetV9Ptr)++;
289              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
290              (*myPtrs->offsetV9Ptr)++;
291              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue
292                  == *((unsigned long*)&buffer4))
293                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
294              /* aggregation */
295              /* end aggregation */
296              if (pftmp->fieldType==70){
297                isMplsFlow = 1;
298              }
299              break;
300            case 4:
301              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
302              (*myPtrs->offsetV9Ptr)++;
303              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
304              (*myPtrs->offsetV9Ptr)++;
305              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
306              (*myPtrs->offsetV9Ptr)++;
307              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
308              (*myPtrs->offsetV9Ptr)++;
309              /* FIXME : here , add a check on the field type */
310              if ((pftmp->fieldType==8)||(pftmp->fieldType==12)
311                  ||(pftmp->fieldType==15)||(pftmp->fieldType==18)){
312                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)
313                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) )
314                  {
315                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
316                  }
317              }
318              if ((pftmp->fieldType==10)||(pftmp->fieldType==14)){
319                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
320                    == ((unsigned short)*((unsigned long*)&buffer4)))
321                  {
322                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
323                  }
324              }
325              if ((pftmp->fieldType==16)||(pftmp->fieldType==17)){
326                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
327                    == ((unsigned short)*((unsigned long*)&buffer4)))
328                  {
329                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
330                  }
331              }
332              if (pftmp->fieldType==1){
333                agCache.bytes = *((unsigned long*)&buffer4);
334                if (
335                    ((unsigned long)((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) + ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)/5))
336                     >= (*((unsigned long*)&buffer4)))
337                    &&
338                    ( (unsigned long)((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) - ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)/5))
339                      <= (*((unsigned long*)&buffer4)) )
340                    )
341                  {
342                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
343                  }
344                                }
345#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
346              if (pftmp->fieldType==10){
347                agCache.inputSnmp = (unsigned short)*((unsigned long*)&buffer4);
348              }
349              if (pftmp->fieldType==14){
350                agCache.outputSnmp = (unsigned short)*((unsigned long*)&buffer4);
351              }
352              if ((pftmp->fieldType==8)){
353                bool = 1; /* very important, test if we have an IPv4 flow for Agg */
354                agCache.v4AdS = *((unsigned long*)&buffer4);
355              }
356              if ((pftmp->fieldType==12)){
357                agCache.v4AdD = *((unsigned long*)&buffer4);
358              }
359              if (pftmp->fieldType==1){
360                agCache.bytes = *((unsigned long*)&buffer4);
361              }
362              if (pftmp->fieldType==2){
363                agCache.pkts = *((unsigned long*)&buffer4);
364              }
365#endif
366#ifdef ASACC
367              if (pftmp->fieldType==16){
368                agCache.asS = (unsigned short)*((unsigned long*)&buffer4);
369              }   
370              if (pftmp->fieldType==17){
371                agCache.asD = (unsigned short)*((unsigned long*)&buffer4);
372              }
373#endif
374              if (pftmp->fieldType==1){
375                      dosCache.bytes = *((unsigned long*)&buffer4);
376                                        dosCache.sampling = *myPtrs->currentRouterPtr->sampled;
377              }
378              if (pftmp->fieldType==2){
379                      dosCache.pkts = *((unsigned long*)&buffer4);
380                                }
381              break;
382            case 16:
383              if ((pftmp->fieldType==27)||(pftmp->fieldType==28)){
384                isIPv6 = 1;
385                for (i=0; i<4; i++) {
386                  buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
387                  (*myPtrs->offsetV9Ptr)++;
388                  buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
389                  (*myPtrs->offsetV9Ptr)++;
390                  buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
391                  (*myPtrs->offsetV9Ptr)++;
392                  buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
393                  (*myPtrs->offsetV9Ptr)++;
394                  if (1==moreIsNecessary){
395                    switch(i){
396                    case 0:
397                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){
398                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
399                            ==
400                            (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
401                            )
402                          {
403                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
404                            moreIsNecessary = 0;
405                          } else {
406                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
407                          moreIsNecessary = 0;
408                        }
409                      } else {
410                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
411                            ==
412                            (*((unsigned long*)&buffer4))
413                            )
414                          {
415                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
416                          } else {
417                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
418                          moreIsNecessary = 0;
419                        }
420                      }
421                      break;
422                    case 1:
423                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){
424                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
425                            ==
426                            (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
427                            )
428                          {
429                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
430                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
431                            moreIsNecessary = 0;
432                          } else {
433                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
434                          moreIsNecessary = 0;
435                        }
436                      } else {
437                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
438                            ==
439                            (*((unsigned long*)&buffer4))
440                            )
441                          {
442                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
443                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
444                          } else {
445                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
446                          moreIsNecessary = 0;
447                        }
448                      }
449                      break;
450                    case 2:
451                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){
452                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
453                            ==
454                            (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
455                            )
456                          {
457                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
458                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
459                            moreIsNecessary = 0;
460                          } else {
461                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
462                        moreIsNecessary = 0;
463                        }
464                      } else {
465                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
466                            ==
467                            (*((unsigned long*)&buffer4))
468                            )
469                          {
470                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
471                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
472                          } else {
473                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
474                          moreIsNecessary = 0;
475                        }
476                      }
477                      break;
478                    case 3:
479                      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){
480                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
481                            ==
482                            (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
483                            )
484                          {
485                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
486                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
487                          } else {
488                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
489                          moreIsNecessary = 0;
490                        }
491                      } else {
492                        if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
493                            ==
494                            (*((unsigned long*)&buffer4))
495                            )
496                          {
497                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
498                              ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
499                          } else {
500                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
501                          moreIsNecessary = 0;
502                        }
503                      }
504                      break;
505                    default:
506                      break;
507                    } /* end of switch(i) */
508                  } /* end of if moreIsNecessary */
509#if defined IPV6AGGIDSNMP
510                  if ((pftmp->fieldType==27)){
511                    agCache.tabAdd6S[i] = *((unsigned long*)&buffer4);
512                  } else if ((pftmp->fieldType==28)){
513                    agCache.tabAdd6D[i] = *((unsigned long*)&buffer4);
514                  }
515#endif
516                }
517                moreIsNecessary = 1;
518                /* aggregation for IPv6 flows */
519               
520                /* end aggregation */
521              } /* end of : if ((pftmp->fieldType==27)||(pftmp->fieldType==28)){ */
522              break;
523            default:
524              syslog(LOG_INFO, "Field size not known: %d\n", field_size);
525              for (i=0; i<field_size; i++){
526                (*myPtrs->offsetV9Ptr)++;
527              }
528              break;
529            }
530            break;
531          default:
532            syslog(LOG_INFO, "Operator not known: %d\n",
533                   (int)(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator));
534            break;
535          }
536          j++;
537          pos = (pftmp->fieldType)*MAX_RULES_PER_FIELD+j;
538        } /* end while myPtrs->rulesAddressPtr */
539      } else {
540        /*
541         * no rule within this field type, but we must read the value
542         */
543        switch (field_size) {
544        case 1:
545          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
546          (*myPtrs->offsetV9Ptr)++;
547#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
548          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
549            agCache.maskS = *((unsigned char*)&buffer1);
550          }
551          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
552            agCache.maskD = *((unsigned char*)&buffer1);
553          }
554          if (pftmp->fieldType==60){
555            agCache.ipProt = *((unsigned char*)&buffer1);
556          }
557          if (pftmp->fieldType==4){
558            agCache.tProt = *((unsigned char*)&buffer1);
559          }
560          if (pftmp->fieldType==61){
561            agCache.sens = *((unsigned char*)&buffer1);
562          }
563          if (pftmp->fieldType==5){
564            agCache.dscp = *((unsigned char*)&buffer1);
565          }       
566#endif
567          break;
568        case 2:
569          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
570          (*myPtrs->offsetV9Ptr)++;
571          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
572          (*myPtrs->offsetV9Ptr)++;
573          if (pftmp->fieldType==7){
574            agCache.sPort = *((unsigned short*)&buffer2);
575          }       
576          if (pftmp->fieldType==11){
577            agCache.dPort = *((unsigned short*)&buffer2);
578          }
579#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
580          if (pftmp->fieldType==10){
581            agCache.inputSnmp = *((unsigned short*)&buffer2);
582          }       
583          if (pftmp->fieldType==14){
584            agCache.outputSnmp = *((unsigned short*)&buffer2);
585          }       
586#endif
587#ifdef ASACC
588          if (pftmp->fieldType==16){
589            agCache.asS = *((unsigned short*)&buffer2);
590          }       
591          if (pftmp->fieldType==17){
592            agCache.asD = *((unsigned short*)&buffer2);
593          }
594#endif
595          break;
596        case 3:
597          buffer4[3]= 0;
598          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
599          (*myPtrs->offsetV9Ptr)++;
600          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
601          (*myPtrs->offsetV9Ptr)++;
602          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
603          (*myPtrs->offsetV9Ptr)++;
604          /* aggregation */
605          /* end aggregation */
606          if (pftmp->fieldType==70){
607            isMplsFlow = 1;
608          }
609          break;
610        case 4:
611          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
612          (*myPtrs->offsetV9Ptr)++;
613          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
614          (*myPtrs->offsetV9Ptr)++;
615          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
616          (*myPtrs->offsetV9Ptr)++;
617          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
618          (*myPtrs->offsetV9Ptr)++;
619#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
620          if (pftmp->fieldType==10){
621            agCache.inputSnmp = (unsigned short)*((unsigned long*)&buffer4);
622          }
623          if (pftmp->fieldType==14){
624            agCache.outputSnmp = (unsigned short)*((unsigned long*)&buffer4);
625          }
626          if ((pftmp->fieldType==8)){
627            bool = 1;
628            agCache.v4AdS = *((unsigned long*)&buffer4);
629          } else if ((pftmp->fieldType==12)){
630            agCache.v4AdD = *((unsigned long*)&buffer4);
631          } else if (pftmp->fieldType==1){
632            agCache.bytes = *((unsigned long*)&buffer4);
633          } else if (pftmp->fieldType==2){
634            agCache.pkts = *((unsigned long*)&buffer4);
635          }
636#endif
637#ifdef ASACC
638          if (pftmp->fieldType==16){
639            agCache.asS = (unsigned short)*((unsigned long*)&buffer4);
640          }       
641          if (pftmp->fieldType==17){
642            agCache.asD = (unsigned short)*((unsigned long*)&buffer4);
643          }
644#endif
645                if (pftmp->fieldType==1){
646            dosCache.bytes = *((unsigned long*)&buffer4);
647                        dosCache.sampling = *myPtrs->currentRouterPtr->sampled;
648          }
649                if (pftmp->fieldType==2){
650            dosCache.pkts = *((unsigned long*)&buffer4);
651          }
652          break;
653        case 16:
654          if ((pftmp->fieldType==27)||(pftmp->fieldType==28)){
655            isIPv6 = 1;
656          }
657          for (i=0; i<4; i++) {
658            buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
659            (*myPtrs->offsetV9Ptr)++;
660            buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
661            (*myPtrs->offsetV9Ptr)++;
662            buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
663            (*myPtrs->offsetV9Ptr)++;
664            buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));
665            (*myPtrs->offsetV9Ptr)++;
666#if defined IPV6AGGIDSNMP
667            if ((pftmp->fieldType==27)){
668              agCache.tabAdd6S[i] = *((unsigned long*)&buffer4);
669            } else if ((pftmp->fieldType==28)){
670              agCache.tabAdd6D[i] = *((unsigned long*)&buffer4);
671            }
672#endif
673          }
674          break;
675        default:
676          syslog(LOG_INFO,"UNKNOWN FIELDS LENGTH: %d ", field_size);
677          for (i=0; i<field_size; i++){
678            (*myPtrs->offsetV9Ptr)++;
679          }
680        }
681      } /* end if one cache table line existence */
682      if (cpt==tmp->fieldCount) {
683        /*
684         * end of one flow (not the flowset)
685         */
686        myPtrs->currentMIB->realFlowNb += 1;
687#ifdef DEBUG
688        flowCpt++;
689        fprintf(stderr," F%d ", flowCpt);
690#endif 
691        /* put aggregation cache information to IPv4 Prefixes table */
692        /* Aggregation mode must be enable in ./configure options   */
693        /* first we must know if the address belong to our prefix   */
694        /*
695         * AS ACCOUNTING
696         */
697#if defined(ASACC) && defined(IPV4AGGIDSNMP)
698        if ( (bool == 1) && (isMplsFlow == 0) ){
699          asKey.as = agCache.asS;
700          asres = bsearch(&asKey, myPtrs->currentASTab, myPtrs->asNb, sizeof(struct AS), asGlobalCmp);
701          if (asres != NULL) {
702            if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) {
703#if defined(MULTISAMPLING)
704              if (myPtrs->currentRouterPtr->sampled != asres->sampling ){
705                /* OUT ("traffic from the AS")  */
706                asres->bytesNbOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/asres->sampling;
707                asres->pktsNbOUT += agCache.pkts*myPtrs->currentRouterPtr->sampled/asres->sampling;
708              }else{
709                asres->bytesNbOUT += agCache.bytes;
710                asres->pktsNbOUT += agCache.pkts;
711                (asres->flowNbOUT)++;
712              }
713#else
714              if (myPtrs->currentRouterPtr->sampled != 0 ){
715                /* OUT ("traffic from the AS")  */
716                asres->bytesNbOUT += agCache.bytes;
717                asres->pktsNbOUT += agCache.pkts;
718                (asres->flowNbOUT)++;
719              }
720              if (asres->sampling == 0
721                  && myPtrs->currentRouterPtr->sampled != 0){
722                asres->sampling = myPtrs->currentRouterPtr->sampled;
723              }
724#endif
725              asres = NULL;
726              asKey.as = agCache.asD;
727              asres = bsearch(&asKey, myPtrs->currentASTab, myPtrs->asNb, sizeof(struct AS), asGlobalCmp);
728              if (asres!=NULL){
729#if defined(MULTISAMPLING)
730                if (myPtrs->currentRouterPtr->sampled != asres->sampling ){
731                  /* IN ("traffic to the AS")  */
732                  asres->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/asres->sampling;
733                  asres->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/asres->sampling;
734                }else{
735                  asres->bytesNbIN += agCache.bytes;
736                  asres->pktsNbIN += agCache.pkts;
737                  (asres->flowNbIN)++;
738                }
739#else
740                if (myPtrs->currentRouterPtr->sampled != 0 ){
741                  /* IN ("traffic to the AS")  */
742                  asres->bytesNbIN += agCache.bytes;
743                  asres->pktsNbIN += agCache.pkts;
744                  (asres->flowNbIN)++;
745                }
746                if (asres->sampling == 0
747                    && myPtrs->currentRouterPtr->sampled != 0){
748                  asres->sampling = myPtrs->currentRouterPtr->sampled;
749                }
750#endif
751                asres = NULL;
752              }
753            }
754          } else {
755            asres = NULL;
756            asKey.as = agCache.asD;
757            asres = bsearch(&asKey, myPtrs->currentASTab, myPtrs->asNb, sizeof(struct AS), asGlobalCmp);
758            if (asres!=NULL){
759              if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) {
760#if defined(MULTISAMPLING)
761                if (myPtrs->currentRouterPtr->sampled != asres->sampling ){
762                  /* IN ("traffic to the AS")  */
763                  asres->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/asres->sampling;
764                  asres->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/asres->sampling;
765                }else{
766                  asres->bytesNbIN += agCache.bytes;
767                  asres->pktsNbIN += agCache.pkts;
768                  (asres->flowNbIN)++;
769                }
770#else
771                if (myPtrs->currentRouterPtr->sampled != 0 ){
772                  /* IN ("traffic to the AS")  */
773                  asres->bytesNbIN += agCache.bytes;
774                  asres->pktsNbIN += agCache.pkts;
775                  (asres->flowNbIN)++;
776                }
777                if (asres->sampling == 0
778                    && myPtrs->currentRouterPtr->sampled != 0){
779                  asres->sampling = myPtrs->currentRouterPtr->sampled;
780                }
781#endif
782              }
783            }
784          }
785        }
786#endif
787        if ( (bool == 1) && (isMplsFlow == 0) ){
788          /* Update the information db (aka RenetcolMIB) */
789          myPtrs->currentMIB->ipv4Bytes += agCache.bytes;
790          myPtrs->currentMIB->ipv4Pckts += agCache.pkts;
791          myPtrs->currentMIB->ipv4Flow += 1;
792          switch (agCache.tProt){
793          case 1:
794            myPtrs->currentMIB->ipv4IcmpFlowNb += 1;
795            myPtrs->currentMIB->ipv4IcmpBytesNb += agCache.bytes;
796            myPtrs->currentMIB->ipv4IcmpPktsNb += agCache.pkts;
797            break;
798          case 6:
799            myPtrs->currentMIB->ipv4TCPFlowNb += 1;
800            myPtrs->currentMIB->ipv4TCPBytesNb += agCache.bytes;
801            myPtrs->currentMIB->ipv4TCPPktsNb += agCache.pkts;
802            break;
803          case 17:
804            myPtrs->currentMIB->ipv4UDPFlowNb += 1;
805            myPtrs->currentMIB->ipv4UDPBytesNb += agCache.bytes;
806            myPtrs->currentMIB->ipv4UDPPktsNb += agCache.pkts;
807            break;
808          default:
809            myPtrs->currentMIB->ipv4OthersFlowNb += 1;
810            myPtrs->currentMIB->ipv4OthersBytesNb += agCache.bytes;
811            myPtrs->currentMIB->ipv4OthersPktsNb += agCache.pkts;
812            break;
813          }
814          if (agCache.pkts==1){
815            myPtrs->currentMIB->ipv4FlowSizePcktsE1 += 1;
816          } else if (agCache.pkts<10) {
817            myPtrs->currentMIB->ipv4FlowSizePcktsLT10 += 1;
818          } else if (agCache.pkts<100) {
819            myPtrs->currentMIB->ipv4FlowSizePcktsLT100 += 1;
820          } else if (agCache.pkts<1000) {
821            myPtrs->currentMIB->ipv4FlowSizePcktsLT1k += 1;
822          } else if (agCache.pkts<10000) {
823            myPtrs->currentMIB->ipv4FlowSizePcktsLT10k += 1;
824          } else if (agCache.pkts>=10000) {
825            myPtrs->currentMIB->ipv4FlowSizePcktsMT10k += 1;
826          }
827          if (agCache.bytes<50){
828            myPtrs->currentMIB->ipv4FlowSizeBytesLT50 += 1;
829          } else if (agCache.bytes<100) {
830            myPtrs->currentMIB->ipv4FlowSizeBytesLT100 += 1;
831          } else if (agCache.bytes<1000) {
832            myPtrs->currentMIB->ipv4FlowSizeBytesLT1k += 1;
833          } else if (agCache.bytes<10000) {
834            myPtrs->currentMIB->ipv4FlowSizeBytesLT10k += 1;
835          } else if (agCache.bytes<100000) {
836            myPtrs->currentMIB->ipv4FlowSizeBytesLT100k += 1;
837          } else if (agCache.bytes<1000000) {
838            myPtrs->currentMIB->ipv4FlowSizeBytesLT1M += 1;
839          } else if (agCache.bytes<10000000) {
840            myPtrs->currentMIB->ipv4FlowSizeBytesLT10M += 1;
841          } else if (agCache.bytes<100000000) {
842            myPtrs->currentMIB->ipv4FlowSizeBytesLT100M += 1;
843          } else if (agCache.bytes>=100000000) {
844            myPtrs->currentMIB->ipv4FlowSizeBytesMT100M += 1;
845          }
846          switch (agCache.dPort){
847          case 53:
848            myPtrs->currentMIB->ipv4DNSFlowNb += 1;
849            myPtrs->currentMIB->ipv4DNSBytesNb += agCache.bytes;
850            myPtrs->currentMIB->ipv4DNSPcktsNb += agCache.pkts;
851            break;
852          case 80:
853            myPtrs->currentMIB->ipv4WebFlowNb += 1;
854            myPtrs->currentMIB->ipv4WebBytesNb += agCache.bytes;
855            myPtrs->currentMIB->ipv4WebPcktsNb += agCache.pkts;
856            break;
857          default:
858            myPtrs->currentMIB->ipv4OthersApFlowNb += 1;
859            myPtrs->currentMIB->ipv4OthersApBytesNb += agCache.bytes;
860            myPtrs->currentMIB->ipv4OthersApPcktsNb += agCache.pkts;
861            break;
862          } 
863          /* end of mib update */
864        }
865        /*
866         * PREFIX &/or MATRIX ACCOUNTING
867         */
868#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP)
869        if ( (bool == 1) && (isMplsFlow == 0) ){
870          /*      prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS); */
871          prefixKey.beginning = agCache.v4AdS;
872          res = bsearch(&prefixKey, V4PTab, nbPV4,
873                        sizeof(struct PrefixV4), prefGlobalCmp);
874          if (res!=NULL){
875            /* WE HAVE FOUND SOURCE ADDRESS IN OUR LIST */
876            if (res->hasSubnet == 1) {
877              resSub = NULL;
878              resSub = bsearch(&prefixKey, V4STab, nbSV4,
879                               sizeof(struct PrefixV4), prefGlobalCmp);
880              if (resSub != NULL) {
881                res = resSub;
882                resSub = NULL;
883              }
884            }
885#ifdef DEBUG
886            fprintf(stderr,"S %lu.%lu.%lu.%lu/%hu %lu.%lu.%lu.%lu/%hu Rs %lu Ps %lu SNMPin(hu) %hu\n",
887                    (agCache.v4AdS>>24),
888                    (agCache.v4AdS<<8>>24),
889                    (agCache.v4AdS<<16>>24),
890                    (agCache.v4AdS<<24>>24),
891                    (agCache.maskS),
892                    (agCache.v4AdD>>24),
893                    (agCache.v4AdD<<8>>24),
894                    (agCache.v4AdD<<16>>24),
895                    (agCache.v4AdD<<24>>24),
896                    (agCache.maskD),
897                    myPtrs->currentRouterPtr->sampled,
898                    res->sampling,
899                    agCache.inputSnmp);
900#endif
901#if defined(IPV4AGGIDR)
902            if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
903#elif defined(IPV4AGGIDSNMP)
904              if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) {       
905#endif
906                /* OUT ("traffic from the prefix/subnet")  */
907#if defined(MULTISAMPLING)
908                if (myPtrs->currentRouterPtr->sampled != res->sampling ){
909                  res->bytesNbOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
910                  res->pktsNbOUT += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling;
911                  /* (res->flowNbOUT)++; FIXME : FIND SOMETHING*/
912                  if (agCache.dscp>>2 == FIRST_CoS) {
913                    res->firstCoSOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
914                  } else if (agCache.dscp>>2 == SECOND_CoS) {
915                    res->secondCoSOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
916                  } else if (agCache.dscp>>2 == THIRD_CoS) {
917                    res->thirdCoSOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
918                  } else {
919                    res->fourthCoSOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
920                  }
921                }else{
922                  res->bytesNbOUT += agCache.bytes;
923                  res->pktsNbOUT += agCache.pkts;
924                  (res->flowNbOUT)++;
925                  if (agCache.dscp>>2 == FIRST_CoS) {
926                    res->firstCoSOUT += agCache.bytes;
927                  } else if (agCache.dscp>>2 == SECOND_CoS) {
928                    res->secondCoSOUT += agCache.bytes;
929                  } else if (agCache.dscp>>2 == THIRD_CoS) {
930                    res->thirdCoSOUT += agCache.bytes;
931                  } else {
932                    res->fourthCoSOUT += agCache.bytes;
933                  }
934                }
935#else
936                if (myPtrs->currentRouterPtr->sampled != 0 ){
937                  res->bytesNbOUT += agCache.bytes;
938                  res->pktsNbOUT += agCache.pkts;
939                  (res->flowNbOUT)++;
940                  if (agCache.dscp>>2 == FIRST_CoS) {
941                    res->firstCoSOUT += agCache.bytes;
942                  } else if (agCache.dscp>>2 == SECOND_CoS) {
943                    res->secondCoSOUT += agCache.bytes;
944                  } else if (agCache.dscp>>2 == THIRD_CoS) {
945                    res->thirdCoSOUT += agCache.bytes;
946                  } else {
947                    res->fourthCoSOUT += agCache.bytes;
948                  }
949                }
950                if (res->sampling == 0
951                    && myPtrs->currentRouterPtr->sampled != 0){
952                  res->sampling = myPtrs->currentRouterPtr->sampled;
953                }
954#endif
955#if defined(IPV4AGGIDSNMP)
956                /*              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);*/
957                prefixKey.beginning = agCache.v4AdD;
958                res3 = bsearch(&prefixKey, V4PTab, nbPV4,
959                               sizeof(struct PrefixV4), prefGlobalCmp);
960                if (res3!=NULL){
961                  /* res is supernet or subnet ? */
962                  if (res3->hasSubnet == 1) {
963                    resSub = NULL;
964                    resSub = bsearch(&prefixKey, V4STab, nbSV4,
965                                     sizeof(struct PrefixV4), prefGlobalCmp);
966                    if (resSub != NULL) {
967                      res3 = resSub;
968                      resSub = NULL;
969                    }
970                  }
971#ifdef DEBUG
972            fprintf(stderr,"S&D %lu.%lu.%lu.%lu/%hu %lu.%lu.%lu.%lu/%hu Rs %lu Ps %lu SNMPin %hu\n",
973                    (agCache.v4AdS>>24),
974                    (agCache.v4AdS<<8>>24),
975                    (agCache.v4AdS<<16>>24),
976                    (agCache.v4AdS<<24>>24),
977                    (agCache.maskS),
978                    (agCache.v4AdD>>24),
979                    (agCache.v4AdD<<8>>24),
980                    (agCache.v4AdD<<16>>24),
981                    (agCache.v4AdD<<24>>24),
982                    (agCache.maskD),
983                    myPtrs->currentRouterPtr->sampled,
984                    res3->sampling,
985                    agCache.inputSnmp);
986#endif
987#if defined(MULTISAMPLING)
988                  if (myPtrs->currentRouterPtr->sampled != res3->sampling ){
989                    res3->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling;
990                    res3->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res3->sampling;
991                    /* (res3->flowNbIN)++;  FIXME : FIND SOMETHING */
992                    if (agCache.dscp>>2 == FIRST_CoS) {
993                      res3->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling;
994                    } else if (agCache.dscp>>2 == SECOND_CoS) {
995                      res3->secondCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling;
996                    } else if (agCache.dscp>>2 == THIRD_CoS) {
997                      res3->thirdCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling;
998                    } else {
999                      res3->fourthCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling;
1000                    }
1001                  }else{
1002                    res3->bytesNbIN += agCache.bytes;
1003                    res3->pktsNbIN += agCache.pkts;
1004                    (res3->flowNbIN)++;
1005                    if (agCache.dscp>>2 == FIRST_CoS) {
1006                      res3->firstCoSIN += agCache.bytes;
1007                    } else if (agCache.dscp>>2 == SECOND_CoS) {
1008                      res3->secondCoSIN += agCache.bytes;
1009                    } else if (agCache.dscp>>2 == THIRD_CoS) {
1010                      res3->thirdCoSIN += agCache.bytes;
1011                    } else {
1012                      res3->fourthCoSIN += agCache.bytes;
1013                    }
1014                  }
1015#else
1016
1017                  if (myPtrs->currentRouterPtr->sampled != 0 ){
1018                    /* IN ("traffic to the prefix/subnet")  */
1019                    res3->bytesNbIN += agCache.bytes;
1020                    res3->pktsNbIN += agCache.pkts;
1021                    (res3->flowNbIN)++;
1022                    if (agCache.dscp>>2 == FIRST_CoS) {
1023                      res3->firstCoSIN += agCache.bytes;
1024                    } else if (agCache.dscp>>2 == SECOND_CoS) {
1025                      res3->secondCoSIN += agCache.bytes;
1026                    } else if (agCache.dscp>>2 == THIRD_CoS) {
1027                      res3->thirdCoSIN += agCache.bytes;
1028                    } else {
1029                      res3->fourthCoSIN += agCache.bytes;
1030                    }
1031                  }
1032                  if (res3->sampling == 0
1033                      && myPtrs->currentRouterPtr->sampled != 0){
1034                    res3->sampling = myPtrs->currentRouterPtr->sampled;
1035                  }
1036#endif
1037                }
1038#endif
1039#if defined(MATRIX) && defined(IPV4AGGIDR)
1040                /* inter-pop matrix Accounting */
1041                /*              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);*/
1042                prefixKey.beginning = agCache.v4AdD;
1043                res2 = bsearch(&prefixKey, V4PTab, nbPV4,
1044                               sizeof(struct PrefixV4), prefGlobalCmp);
1045                if (res2!=NULL){
1046#if defined(MULTISAMPLING)
1047                  if (myPtrs->currentRouterPtr->sampled != res2->sampling ){
1048                    ((struct POP *)((myPtrs->matrixPOP)
1049                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1050                                    +((res2->routerNb))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/res2->sampling;
1051                    ((struct POP *)((myPtrs->matrixPOP)
1052                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1053                                    +((res2->routerNb))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/res2->sampling;
1054                    ((struct POP *)((myPtrs->matrixPOP)
1055                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1056                                    +((res2->routerNb))))->flowNb++;
1057                  } else {
1058                    ((struct POP *)((myPtrs->matrixPOP)
1059                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1060                                    +((res2->routerNb))))->pktsNb += agCache.pkts;
1061                    ((struct POP *)((myPtrs->matrixPOP)
1062                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1063                                    +((res2->routerNb))))->bytesNb += agCache.bytes;
1064                    ((struct POP *)((myPtrs->matrixPOP)
1065                                    +((res->routerNb)*ROUTER_INDEX_MAX)
1066                                    +((res2->routerNb))))->flowNb++;
1067                  }
1068#else
1069                  ((struct POP *)((myPtrs->matrixPOP)
1070                                  +((res->routerNb)*ROUTER_INDEX_MAX)
1071                                  +((res2->routerNb))))->pktsNb += agCache.pkts;
1072                  ((struct POP *)((myPtrs->matrixPOP)
1073                                  +((res->routerNb)*ROUTER_INDEX_MAX)
1074                                  +((res2->routerNb))))->bytesNb += agCache.bytes;
1075                  ((struct POP *)((myPtrs->matrixPOP)
1076                                  +((res->routerNb)*ROUTER_INDEX_MAX)
1077                                  +((res2->routerNb))))->flowNb++;
1078#endif
1079                } else {
1080                  /* here we'll make the choice that in multisampling mode,
1081                   * the virtual POP that represent the reste of world will be
1082                   * recorded in 1:10 packets mode */
1083#if defined(MULTISAMPLING)
1084                  (
1085                   ((struct POP *)(myPtrs->matrixPOP)
1086                    +((res->routerNb)*ROUTER_INDEX_MAX)
1087                    +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10;
1088                  (
1089                   ((struct POP *)(myPtrs->matrixPOP)
1090                    +((res->routerNb)*ROUTER_INDEX_MAX)
1091                    +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10;
1092                  (
1093                   ((struct POP *)(myPtrs->matrixPOP)
1094                    +((res->routerNb)*ROUTER_INDEX_MAX)
1095                    +((ROUTER_INDEX_MAX-1))))->flowNb++;
1096#else
1097                  (
1098                   ((struct POP *)(myPtrs->matrixPOP)
1099                    +((res->routerNb)*ROUTER_INDEX_MAX)
1100                    +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts;
1101                  (
1102                   ((struct POP *)(myPtrs->matrixPOP)
1103                    +((res->routerNb)*ROUTER_INDEX_MAX)
1104                    +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes;
1105                  (
1106                   ((struct POP *)(myPtrs->matrixPOP)
1107                    +((res->routerNb)*ROUTER_INDEX_MAX)
1108                    +((ROUTER_INDEX_MAX-1))))->flowNb++;
1109#endif         
1110                }
1111                /* end interpop matrix accounting */
1112#endif /* matrix */
1113              } else {
1114                /* doublon or bad reference in prefix list */
1115#if defined(IPV4AGGIDR)
1116              }
1117#elif defined(IPV4AGGIDSNMP)
1118            }
1119#endif
1120          } else { /* SOURCE ADDRESS DOESN'T IN OUR LIST */
1121            /*      prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD); */
1122            prefixKey.beginning = agCache.v4AdD;
1123            res = bsearch(&prefixKey, V4PTab, nbPV4,
1124                          sizeof(struct PrefixV4), prefGlobalCmp);
1125            if (res!=NULL){
1126              /* DESTINATION ADDRESS IS IN OUR LIST */
1127              if (res->hasSubnet == 1) {
1128                resSub = NULL;
1129                resSub = bsearch(&prefixKey, V4STab, nbSV4,
1130                                 sizeof(struct PrefixV4), prefGlobalCmp);
1131                if (resSub != NULL) {
1132                  res = resSub;
1133                  resSub = NULL;
1134                }
1135              }
1136#ifdef DEBUG
1137            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",
1138                    (agCache.v4AdS>>24),
1139                    (agCache.v4AdS<<8>>24),
1140                    (agCache.v4AdS<<16>>24),
1141                    (agCache.v4AdS<<24>>24),
1142                    (agCache.maskS),
1143                    (agCache.v4AdD>>24),
1144                    (agCache.v4AdD<<8>>24),
1145                    (agCache.v4AdD<<16>>24),
1146                    (agCache.v4AdD<<24>>24),
1147                    (agCache.maskD),
1148                    myPtrs->currentRouterPtr->sampled,
1149                    res->sampling,
1150                    (myPtrs->pcktPtr->ipH->srcAdd>>24),
1151                    (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1152                    (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1153                    (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
1154                    agCache.inputSnmp);
1155#endif
1156#if defined(IPV4AGGIDSNMP)
1157              if ( myPtrs->currentRouterPtr->snmpIndexList[agCache.inputSnmp] == 1  ) {
1158#if defined(MULTISAMPLING)
1159                if (myPtrs->currentRouterPtr->sampled != res->sampling ){
1160                  res->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1161                  res->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling;
1162                  if (agCache.dscp>>2 == FIRST_CoS) {
1163                    res->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1164                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1165                    res->secondCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1166                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1167                    res->thirdCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1168                  } else {
1169                    res->fourthCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1170                  }
1171                }else{
1172                  res->bytesNbIN += agCache.bytes;
1173                  res->pktsNbIN += agCache.pkts;
1174                  (res->flowNbIN)++;
1175                  if (agCache.dscp>>2 == FIRST_CoS) {
1176                    res->firstCoSIN += agCache.bytes;
1177                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1178                    res->secondCoSIN += agCache.bytes;
1179                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1180                    res->thirdCoSIN += agCache.bytes;
1181                  } else {
1182                    res->fourthCoSIN += agCache.bytes;
1183                  }
1184                }
1185#else
1186                if (myPtrs->currentRouterPtr->sampled != 0 ){
1187                  /* IN ("traffic to the prefix/subnet")  */
1188                  res->bytesNbIN += agCache.bytes;
1189                  res->pktsNbIN += agCache.pkts;
1190                  (res->flowNbIN)++;
1191                  if (agCache.dscp>>2 == FIRST_CoS) {
1192                    res->firstCoSIN += agCache.bytes;
1193                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1194                    res->secondCoSIN += agCache.bytes;
1195                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1196                    res->thirdCoSIN += agCache.bytes;
1197                  } else {
1198                    res->fourthCoSIN += agCache.bytes;
1199                  }
1200                }
1201#endif
1202              }
1203#endif
1204#if defined(IPV4AGGIDR)
1205              if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
1206#if defined(MULTISAMPLING)
1207                if (myPtrs->currentRouterPtr->sampled != res->sampling ){
1208                  res->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1209                  res->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling;
1210                  if (agCache.dscp>>2 == FIRST_CoS) {
1211                    res->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1212                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1213                    res->secondCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1214                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1215                    res->thirdCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1216                  } else {
1217                    res->fourthCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling;
1218                  }
1219                }else{
1220                  res->bytesNbIN += agCache.bytes;
1221                  res->pktsNbIN += agCache.pkts;
1222                  (res->flowNbIN)++;
1223                  if (agCache.dscp>>2 == FIRST_CoS) {
1224                    res->firstCoSIN += agCache.bytes;
1225                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1226                    res->secondCoSIN += agCache.bytes;
1227                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1228                    res->thirdCoSIN += agCache.bytes;
1229                  } else {
1230                    res->fourthCoSIN += agCache.bytes;
1231                  }
1232                }
1233#else
1234                if (myPtrs->currentRouterPtr->sampled != 0 ){
1235                  /* IN ("traffic to the prefix")  */
1236                  res->bytesNbIN += agCache.bytes;
1237                  res->pktsNbIN += agCache.pkts;
1238                  (res->flowNbIN)++;
1239                  if (agCache.dscp>>2 == FIRST_CoS) {
1240                    res->firstCoSIN += agCache.bytes;
1241                  } else if (agCache.dscp>>2 == SECOND_CoS) {
1242                    res->secondCoSIN += agCache.bytes;
1243                  } else if (agCache.dscp>>2 == THIRD_CoS) {
1244                    res->thirdCoSIN += agCache.bytes;
1245                  } else {
1246                    res->fourthCoSIN += agCache.bytes;
1247                  }
1248                }
1249#endif
1250              } else {
1251#if defined(MULTISAMPLING)
1252#if defined(MATRIX)
1253                  (
1254                   ((struct POP *)(myPtrs->matrixPOP)
1255                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1256                    +((res->routerNb))))->pktsNb += agCache.pkts*myPtrs->currentRouterPtr->sampled/10;
1257                  (
1258                   ((struct POP *)(myPtrs->matrixPOP)
1259                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1260                    +((res->routerNb))))->bytesNb += agCache.bytes*myPtrs->currentRouterPtr->sampled/10;
1261                  (
1262                   ((struct POP *)(myPtrs->matrixPOP)
1263                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1264                    +((res->routerNb))))->flowNb++;
1265#endif
1266#else
1267#if defined(MATRIX)
1268                  (
1269                   ((struct POP *)(myPtrs->matrixPOP)
1270                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1271                    +((res->routerNb))))->pktsNb += agCache.pkts;
1272                  (
1273                   ((struct POP *)(myPtrs->matrixPOP)
1274                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1275                    +((res->routerNb))))->bytesNb += agCache.bytes;
1276                  (
1277                   ((struct POP *)(myPtrs->matrixPOP)
1278                    +((ROUTER_INDEX_MAX-1)*ROUTER_INDEX_MAX)
1279                    +((res->routerNb))))->flowNb++;
1280#endif
1281#endif 
1282              }
1283              if (res->sampling == 0
1284                  && myPtrs->currentRouterPtr->sampled != 0 ){
1285                res->sampling = myPtrs->currentRouterPtr->sampled;
1286              }
1287#endif
1288            } else {
1289              /* UNKNOW SUBNET CASE                                        */
1290              /*                                                           */
1291              /* HERE : we are in the cases of the address/mask don't      */
1292              /*        belong to a prefix listed in the IPv4 prefix file  */
1293              /* possibilities :                                           */
1294              /*     -  prefix not referenced but allowed to be routed     */
1295              /*     -  prefix not referenced but not allowed to be routed */
1296              /*     -  spoofing                                           */
1297#ifdef PRINTUNKNOWNSUBNET 
1298              fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu (R:%lu.%lu.%lu.%lu) \n",
1299                      (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),
1310                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1311                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1312                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)
1313                      );
1314#endif /* PRINTUNKNOWNSUBNET */
1315            }
1316          } /* end of the Destination prefix is in our list */
1317        } /* end of the prefix is in our list */
1318        bool = 0;
1319#endif /* (IPV4AGGIDR) || (IPV4AGGIDSNMP) */
1320        if ( ( isIPv6 == 1 ) && (isMplsFlow == 0) ){
1321#ifdef IPV6LINKAGG
1322          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1323                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1324                              +(agCache.inputSnmp)))->routerIPAddress = myPtrs->currentRouterPtr->IpAddress;
1325          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1326                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1327                              +(agCache.outputSnmp)))->routerIPAddress = myPtrs->currentRouterPtr->IpAddress;
1328          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1329                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1330                              +(agCache.inputSnmp)))->indexSNMP = agCache.inputSnmp;
1331          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1332                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1333                              +(agCache.outputSnmp)))->indexSNMP = agCache.outputSnmp;
1334          /* FIXME, error or warning if (indexSNMP != agCache.outputSnmp) */
1335          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1336                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1337                              +(agCache.inputSnmp)))->hasStats = 1;
1338          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1339                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1340                              +(agCache.outputSnmp)))->hasStats = 1;
1341          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1342                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1343                              +(agCache.inputSnmp)))->bytesNbIN += agCache.bytes;
1344          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1345                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1346                              +(agCache.outputSnmp)))->bytesNbOUT += agCache.bytes;
1347          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1348                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1349                              +(agCache.inputSnmp)))->pktsNbIN += agCache.pkts;
1350          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1351                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1352                              +(agCache.outputSnmp)))->pktsNbOUT += agCache.pkts;
1353          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1354                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1355                              +(agCache.inputSnmp)))->flowNbIN++;
1356          ((struct IndexV6 *)((myPtrs->currentV6IndexTab)
1357                              +((myPtrs->currentRouterPtr->ID)*MAX_INDEX_BY_ROUTER)
1358                              +(agCache.outputSnmp)))->flowNbOUT++;
1359/*        fprintf(stderr,"IPV6LINKAGG;IN;%hu;OUT;%hu;router;%lu;bytes;%lu\n", */
1360/*                agCache.inputSnmp, */
1361/*                agCache.outputSnmp, */
1362/*                myPtrs->currentRouterPtr->IpAddress, */
1363/*                agCache.bytes */
1364/*               ); */
1365#endif /* IPV6LINKAGG */
1366          /* Update the information db (aka RenetcolMIB) */
1367          myPtrs->currentMIB->ipv6Bytes += agCache.bytes;
1368          myPtrs->currentMIB->ipv6Pckts += agCache.pkts;
1369          myPtrs->currentMIB->ipv6Flow += 1;
1370          switch (agCache.tProt){
1371          case 1:
1372            myPtrs->currentMIB->ipv6IcmpFlowNb += 1;
1373            myPtrs->currentMIB->ipv6IcmpBytesNb += agCache.bytes;
1374            myPtrs->currentMIB->ipv6IcmpPktsNb += agCache.pkts;
1375            break;
1376          case 6:
1377            myPtrs->currentMIB->ipv6TCPFlowNb += 1;
1378            myPtrs->currentMIB->ipv6TCPBytesNb += agCache.bytes;
1379            myPtrs->currentMIB->ipv6TCPPktsNb += agCache.pkts;
1380            break;
1381          case 17:
1382            myPtrs->currentMIB->ipv6UDPFlowNb += 1;
1383            myPtrs->currentMIB->ipv6UDPBytesNb += agCache.bytes;
1384            myPtrs->currentMIB->ipv6UDPPktsNb += agCache.pkts;
1385            break;
1386          default:
1387            myPtrs->currentMIB->ipv6OthersFlowNb += 1;
1388            myPtrs->currentMIB->ipv6OthersBytesNb += agCache.bytes;
1389            myPtrs->currentMIB->ipv6OthersPktsNb += agCache.pkts;
1390            break;
1391          }
1392          if (agCache.pkts==1){
1393            myPtrs->currentMIB->ipv6FlowSizePcktsE1 += 1;
1394          } else if (agCache.pkts<10) {
1395            myPtrs->currentMIB->ipv6FlowSizePcktsLT10 += 1;
1396          } else if (agCache.pkts<100) {
1397            myPtrs->currentMIB->ipv6FlowSizePcktsLT100 += 1;
1398          } else if (agCache.pkts<1000) {
1399            myPtrs->currentMIB->ipv6FlowSizePcktsLT1k += 1;
1400          } else if (agCache.pkts<10000) {
1401            myPtrs->currentMIB->ipv6FlowSizePcktsLT10k += 1;
1402          } else if (agCache.pkts>=10000) {
1403            myPtrs->currentMIB->ipv6FlowSizePcktsMT10k += 1;
1404          }
1405          if (agCache.bytes<50){
1406            myPtrs->currentMIB->ipv6FlowSizeBytesLT50 += 1;
1407          } else if (agCache.bytes<100) {
1408            myPtrs->currentMIB->ipv6FlowSizeBytesLT100 += 1;
1409          } else if (agCache.bytes<1000) {
1410            myPtrs->currentMIB->ipv6FlowSizeBytesLT1k += 1;
1411          } else if (agCache.bytes<10000) {
1412            myPtrs->currentMIB->ipv6FlowSizeBytesLT10k += 1;
1413          } else if (agCache.bytes<100000) {
1414            myPtrs->currentMIB->ipv6FlowSizeBytesLT100k += 1;
1415          } else if (agCache.bytes<1000000) {
1416            myPtrs->currentMIB->ipv6FlowSizeBytesLT1M += 1;
1417          } else if (agCache.bytes<10000000) {
1418            myPtrs->currentMIB->ipv6FlowSizeBytesLT10M += 1;
1419          } else if (agCache.bytes<100000000) {
1420            myPtrs->currentMIB->ipv6FlowSizeBytesLT100M += 1;
1421          } else if (agCache.bytes>=100000000) {
1422            myPtrs->currentMIB->ipv6FlowSizeBytesMT100M += 1;
1423          }
1424          switch (agCache.dPort){
1425          case 53:
1426            myPtrs->currentMIB->ipv6DNSFlowNb += 1;
1427            myPtrs->currentMIB->ipv6DNSBytesNb += agCache.bytes;
1428            myPtrs->currentMIB->ipv6DNSPcktsNb += agCache.pkts;
1429            break;
1430          case 80:
1431            myPtrs->currentMIB->ipv6WebFlowNb += 1;
1432            myPtrs->currentMIB->ipv6WebBytesNb += agCache.bytes;
1433            myPtrs->currentMIB->ipv6WebPcktsNb += agCache.pkts;
1434            break;
1435          default:
1436            myPtrs->currentMIB->ipv6OthersApFlowNb += 1;
1437            myPtrs->currentMIB->ipv6OthersApBytesNb += agCache.bytes;
1438            myPtrs->currentMIB->ipv6OthersApPcktsNb += agCache.pkts;
1439            break;
1440          } 
1441          /* end of mib update */
1442          isIPv6 = 0;
1443        }
1444        isMplsFlow = 0;
1445
1446        /* 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;
1451        while ( ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+jdos))) != NULL ) {
1452                                        ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+posdos)))->check = 1;
1453                                        jdos++;
1454                                }
1455        }
1456
1457        /*
1458         *
1459         * SOCKET OUTPUT TO A REMOTE CLIENT
1460         *
1461         * switch the rules definition (check & fieldToRecord),
1462         * we send the flow or a part of the flow to a remote host or a file.
1463         * In a first time (until release 0.0.7, the information was sent via
1464         * the process renetcolSender with an IPC message queue. But, the perf
1465         * of IPC Msg was very bad with a default system compilation.
1466         * So, now, we send information directly from here through sockets.
1467         */
1468        tmpRuleList = myPtrs->rulesListPtr;
1469        tmpRL = myPtrs->rulesListPtr;
1470        while (tmpRuleList){
1471          RuleDefPtr tmpRuleDefList = tmpRuleList->def;
1472          unsigned short check = 1;
1473          int s=0;
1474          secondOffset = secondOldOffset;
1475          while (tmpRuleDefList){
1476            check = check && tmpRuleDefList->check;
1477            tmpRuleDefList->check = 0;
1478            tmpRuleDefList = tmpRuleDefList->next;
1479          }
1480          if ( (tmpRuleList->def != NULL) && (check == 1)) {
1481            /* msg building */
1482            secondPftmp = tmp->lastField;
1483            msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text,   
1484                                                   &tplMsgType,
1485                                                   sizeof(unsigned short)
1486                                                   ),
1487                                           &tmpRuleList->id,
1488                                           sizeof(tmpRuleList->id)
1489                                           ),
1490                                   &myPtrs->currentRouterPtr->IpAddress,
1491                                   sizeof(unsigned long)
1492                                   );
1493            msgTextIndex = mempcpy(mempcpy(mempcpy(msgTextIndex,
1494                                                   &tmp->sourceId,
1495                                                   sizeof(unsigned long)
1496                                                   ),
1497                                           &tmp->templateFlowSetId,
1498                                           sizeof(tmp->templateFlowSetId)
1499                                           ),
1500                                   myPtrs->ptr_buffer+secondOffset,
1501                                   flow_size
1502                                   );
1503            myMsg.type = 1;
1504             
1505
1506            /* NEW transfert type */
1507            for ( ; tmpRL; tmpRL=tmpRL->next){
1508              if (tmpRL->id == tmpRuleList->id){       
1509                s = sendMessage(tmpRL->host->sockId, myMsg.text, sizeof(myMsg.text),
1510                                tmpRL->host->hostAddressPtr);
1511              }
1512            }
1513            /* FIXME : perhaps check "s" */
1514            noEnd = 1;
1515            secondCpt=0;
1516          } /* end if check */
1517          tmpRuleList = tmpRuleList->next;
1518          tmpRL = myPtrs->rulesListPtr; /* ticket #11 */
1519          secondPftmp = tmp->lastField;
1520        } /* end while tmpRuleList */
1521        /*
1522         * end redirection
1523         */
1524        secondOffset = *myPtrs->offsetV9Ptr;
1525        secondOldOffset = secondOffset;
1526        pftmp = tmp->lastField;
1527        cpt=0;
1528        (*myPtrs->currentFlowsetNumberPtr)++; /* pointer on the flows number */
1529        if (((*myPtrs->offsetV9Ptr)-48-shift+flow_size) > data_length){
1530          overflow = 1; /* buffer index not correct */
1531        }
1532      } else {
1533        /* not the flow end, progress in field list */
1534        pftmp = pftmp->prev;
1535      }   
1536    } /* end of the while on one flow record */
1537       
1538    while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) {
1539      (*myPtrs->offsetV9Ptr)++; /* if padding */
1540      paddingCounter++;
1541#ifdef DEBUG
1542        fprintf(stderr,", pC: %d ", paddingCounter);
1543#endif
1544      if ( paddingCounter > 8 ) {
1545        syslog(LOG_INFO,"padding too high: %d ", paddingCounter);
1546#ifdef DEBUG
1547        fprintf(stderr,", pC: %d <--| ", paddingCounter);
1548#endif
1549        return (-1);
1550      }
1551    }
1552    while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) {
1553      (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */
1554      crazyCounter++;
1555    }
1556#ifdef DEBUG
1557    if (crazyCounter != 0){ fprintf(stderr," crazyCounter: %d ", crazyCounter); }
1558#endif
1559    if (crazyCounter!=0) { syslog(LOG_INFO,"crazyCounter: %d ", crazyCounter);}
1560     
1561#ifdef DEBUG
1562    fprintf(stderr,"(%hu,%hu)}", data_length, data_length+shift);
1563#endif
1564     
1565    return (data_length+shift);
1566    /* end new place */
1567
1568  } else {
1569    /*
1570     *
1571     *
1572     *  OPTIONAL TEMPLATE
1573     *
1574     *
1575     */
1576    if ((tmpOpt=existTplOptId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,
1577                              (*myPtrs->currentFlowsetIdPtr)))!=NULL) {       
1578
1579      myPtrs->currentMIB->optDataFlowSetNb += 1;
1580#ifdef DEBUG
1581      fprintf(stderr,"<d id: %hu, lg %hu", (*myPtrs->currentFlowsetIdPtr), data_length);
1582#endif
1583      for ( i=0; i<(tmpOpt->optionScopeLg/4); i++){
1584        /* FIXME : today we skip the scope fields, it's bad :( */ 
1585        if ((pftmp=tmpOpt->lastField)!=NULL) {
1586          for (j=0; j<pftmp->fieldLength; j++) {
1587            (*myPtrs->offsetV9Ptr)++;
1588          }
1589          pftmp = pftmp->prev;
1590        }
1591      }
1592      while (pftmp != NULL) {
1593        if (pftmp->fieldLength==1){
1594          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1595        }
1596        if (pftmp->fieldLength==2){
1597          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1598          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1599        }
1600        if (pftmp->fieldLength==4){
1601          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1602          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1603          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1604          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
1605          if (pftmp->fieldType==34||pftmp->fieldType==50){
1606            if ((*((unsigned long*)&buffer4)==1)
1607                || (*((unsigned long*)&buffer4)==10)
1608                || (*((unsigned long*)&buffer4)==20)
1609                || (*((unsigned long*)&buffer4)==100)
1610                || (*((unsigned long*)&buffer4)==1000)) {
1611              if (myPtrs->currentRouterPtr->sampled != *((unsigned long*)&buffer4) ) {
1612#ifdef DEBUGAGG
1613                fprintf(stderr,"\n SV (p) %lu != %lu (r)", *((unsigned long*)&buffer4),
1614                        myPtrs->currentRouterPtr->sampled);
1615#endif
1616                syslog(LOG_INFO,"Sampling value change for router : %lu.%lu.%lu.%lu, old: %lu, new: %lu",
1617                       (myPtrs->pcktPtr->ipH->srcAdd>>24),
1618                       (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1619                       (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1620                       (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
1621                       myPtrs->currentRouterPtr->sampled,
1622                       *((unsigned long*)&buffer4)
1623                       );
1624                myPtrs->currentRouterPtr->sampled = *((unsigned long*)&buffer4);
1625              }
1626            }else{
1627              syslog(LOG_INFO,"Sampling value not standard for router : %lu.%lu.%lu.%lu, value : %lu",
1628                     (myPtrs->pcktPtr->ipH->srcAdd>>24),
1629                     (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1630                     (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1631                     (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
1632                     *((unsigned long*)&buffer4)
1633                     );
1634            }
1635          }
1636        }       
1637        pftmp = pftmp->prev;
1638      }
1639      if ( pftmp == NULL ) {
1640        while ((*myPtrs->offsetV9Ptr)%4 != 0) {
1641          (*myPtrs->offsetV9Ptr)++;
1642#ifdef DEBUG
1643          fprintf(stderr," p ");
1644#endif
1645        }
1646      } else {
1647        fprintf(stderr,"PB ");
1648      }
1649#ifdef DEBUG
1650      fprintf(stderr,">");
1651#endif
1652      myPtrs->currentMIB->realFlowNb += 1;
1653      return (data_length+shift);
1654    } else {
1655      /*
1656       * template unknown, we skip the data
1657       */
1658      (*myPtrs->offsetV9Ptr)+=(data_length-4);
1659      (*myPtrs->currentFlowsetNumberPtr)+= 1 ;
1660      /*      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;*/
1661#ifdef DEBUG
1662      fprintf(stderr, " U, r: %lu.%lu.%lu.%lu, sourceId: %lu, TID: %hu ",
1663              (myPtrs->pcktPtr->ipH->srcAdd>>24),
1664              (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1665              (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1666              (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
1667              myPtrs->currentHeaderV9Ptr->sourceId,
1668              (*myPtrs->currentFlowsetIdPtr)
1669              );
1670      fprintf(stderr,"(%hu,%hu) ", data_length, data_length+shift);
1671#endif
1672      return (data_length+shift);
1673    }
1674  }
1675}
Note: See TracBrowser for help on using the browser.