root/trunk/src/dataFlowSet.c @ 122

Revision 122, 56.9 KB (checked in by andreu, 12 years ago)

Update of web site and change in aggregation calculation mode in dataFlowSet.c

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