root/trunk/src/dataFlowSet.c @ 51

Revision 51, 34.3 KB (checked in by andreu, 15 years ago)

comparaison on field 1 (flow size in bytes) in dataFlowSet.c (comparaison more or less 5 percent.

  • Property svn:eol-style set to native
Line 
1/*
2 * File: dataFlowSet.c
3 *
4 * Authors: ANDREU Francois-Xavier
5 *
6 * Copyright (C) 2005 2006 2007 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                 )
39{
40  TplFlowSetPtr tmp = NULL;
41  TplOptionPtr tmpOpt = NULL;
42  FieldPtr pftmp = NULL;
43  FieldPtr secondPftmp = NULL;
44  unsigned short data_length = 0;
45  unsigned short flow_size = 0;
46  unsigned short oldOffset = *myPtrs->offsetV9Ptr;
47  unsigned short secondOffset = 0;
48  unsigned short secondOldOffset = 0;
49  int moreIsNecessary = 1;
50  int field_size = 0;
51  int cpt = 0;
52  int secondCpt = 0;
53  int overflow = 0;
54  int noEnd = 1;
55  int i = 0;
56  int j = 0;
57  int pos = 0;
58  unsigned char buffer1; 
59  unsigned char buffer2[2];
60  unsigned char buffer4[4];
61  RulesPtr tmpRuleList = myPtrs->rulesListPtr;
62  RulesPtr tmpRL = myPtrs->rulesListPtr;
63  msgType myMsg;
64  char *msgTextIndex;
65  char *msgToSend;
66  unsigned short tplMsgType = 11;
67  struct PrefixV4 prefixKey, *res, *res2; /* for bsearch */
68  struct AggCache agCache;
69  int bool = 0; /* in IPV4 Agg mode enabled, we need to now if it's an IPv4 */
70                /* flow, we test on the field and then put bool at 1 */
71  int isMplsFlow = 0;
72  int paddingCounter = 0;
73  int crazyCounter = 0;
74
75#ifdef CRIHAN
76  struct IPFLowCache ipFirstCache;
77  struct MPLSFlowCache mplsFirstCache;
78  unsigned long firstTime = 0;
79  unsigned long lastTime = 0;
80
81  ipFirstCache.ipProt = 0;
82  ipFirstCache.bytes = 0;
83  ipFirstCache.pkts = 0;
84  ipFirstCache.inSnmp = 0;
85  ipFirstCache.outSnmp = 0;
86  ipFirstCache.v4AdS = 0;
87  ipFirstCache.v4AdD = 0;
88  ipFirstCache.tProt = 0;
89  ipFirstCache.sPort = 0;
90  ipFirstCache.dPort = 0;
91  ipFirstCache.maskD = 0;
92  ipFirstCache.maskS = 0;
93  ipFirstCache.routerAd = 0;
94  ipFirstCache.liveTime = 0;
95  mplsFirstCache.ipProt = 0;
96  mplsFirstCache.v4AdS = 0;
97  mplsFirstCache.v4AdD = 0;
98  mplsFirstCache.routerAd = 0;
99  mplsFirstCache.mplsLabel1 = 0;
100#endif /* CRIHAN */
101
102  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
103  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
104  (*myPtrs->currentFlowsetIdPtr) = *((unsigned short*)&buffer2);
105  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
106  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
107  data_length = *((unsigned short*)&buffer2);
108
109  if ( (tmp=existTplId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,
110                      (*myPtrs->currentFlowsetIdPtr)))!=NULL ) {
111#ifdef DEBUG
112    fprintf(stderr,"{d id: %hu, lg %hu", (*myPtrs->currentFlowsetIdPtr), data_length);
113    if ( (*myPtrs->currentFlowsetIdPtr) > TRESHOLD_TEMPLATE_ID ) {
114/*      fprintf(stderr,"Bad TID from router: %lu.%lu.%lu.%lu\n", */
115/*              (*myPtrs->currentFlowsetIdPtr), */
116/*              (myPtrs->pcktPtr->ipH->srcAdd>>24), */
117/*              (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */
118/*              (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */
119/*              (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); */
120/*      fprintf(stderr," Bytes : \n"); */
121/*      while ( ( myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr) ) > (myPtrs->ptr_buffer+1416) ){ */
122/*        buffer1= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++; */
123/*        tmp = *((unsigned char*)&buffer1); */
124/*        fprintf (stderr, " %s ", tmp); */
125/*      } */
126/*      exit(-1); */
127      return (data_length+shift);
128    }
129#endif
130    pftmp = tmp->lastField;
131    for (; pftmp; pftmp = pftmp->prev) {
132      flow_size += pftmp->fieldLength;
133    }
134    if ( data_length%flow_size >= 9 ) {
135      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
136      syslog(LOG_INFO, "data flowset length not match with length from template definition, wrong template definition suspected; all next informations of this data flowset are not considered! flowset ID: %hu, from router: %lu.%lu.%lu.%lu",
137             (*myPtrs->currentFlowsetIdPtr),
138             (myPtrs->pcktPtr->ipH->srcAdd>>24),
139             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
140             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
141             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
142      return (data_length+shift);
143    }
144    if ( data_length >= 1452 ) {
145      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",
146             (*myPtrs->currentFlowsetIdPtr),
147             (myPtrs->pcktPtr->ipH->srcAdd>>24),
148             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
149             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
150             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
151      return (-1);
152    }
153#ifdef IPV4AGG
154    agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
155#endif
156
157#ifdef CRIHAN
158    ipFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
159    mplsFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
160#endif /* CRIHAN */
161
162    pftmp = tmp->lastField;
163    secondPftmp = tmp->lastField;   
164    secondOffset = *myPtrs->offsetV9Ptr;
165    secondOldOffset = secondOffset;
166    while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length) && (overflow!=1) ) {
167      /*
168       * progression in a data flow Set
169       * notes:
170       *   48=header ip + header netf
171       *   shift = shift if there is a template declaration
172       */
173      cpt++;
174      j = 0;
175      pos = (pftmp->fieldType)*MAX_RULES_PER_FIELD+j;
176      field_size = (int) pftmp->fieldLength;
177     
178      /* special case: check yes on all flows from one router (phantom field nb 0) */
179      /* FIXME : this code is repeated, perhaps past before */
180      while ( ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j))) != NULL ) {
181        if  ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j)))->value->stor.lvalue)
182              == myPtrs->pcktPtr->ipH->srcAdd )
183          {
184            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+j)))->check = 1;
185          }     
186        j++;
187      }   
188      j = 0;
189     
190      /*
191       * Comparaison between the field value and the rules
192       * ... if one rule exist
193       * FIXME : warning, if no rules, no accounting ?
194       */
195      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL) {
196        oldOffset = *myPtrs->offsetV9Ptr;
197        while (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL){
198          /*
199           * while on one cache table line
200           */
201          *myPtrs->offsetV9Ptr = oldOffset;
202          switch ((int)
203                  (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)){
204          case 2:
205            /* operator: "=" */ 
206            switch (field_size) {
207            case 1:
208              buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
209              /* rule check */
210              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue
211                  == *((unsigned char*)&buffer1)) {
212                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
213              }
214              /* end rule check */
215#ifdef IPV4AGG
216              if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
217                agCache.maskS = *((unsigned char*)&buffer1);
218              }
219              if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
220                agCache.maskD = *((unsigned char*)&buffer1);
221              }
222              if (pftmp->fieldType==60){
223                agCache.ipProt = *((unsigned char*)&buffer1);
224              }
225              if (pftmp->fieldType==4){
226                agCache.tProt = *((unsigned char*)&buffer1);
227              }
228              if (pftmp->fieldType==61){
229                agCache.sens = *((unsigned char*)&buffer1);
230              }
231              if (pftmp->fieldType==5){
232                agCache.dscp = *((unsigned char*)&buffer1);
233              }
234#endif       
235#ifdef CRIHAN
236              if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
237                ipFirstCache.maskS = *((unsigned char*)&buffer1);
238              }
239              if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
240                ipFirstCache.maskD = *((unsigned char*)&buffer1);
241              }
242              if (pftmp->fieldType==60){
243                ipFirstCache.ipProt = *((unsigned char*)&buffer1);
244                mplsFirstCache.ipProt = *((unsigned char*)&buffer1);
245              }
246              if (pftmp->fieldType==4){
247                ipFirstCache.tProt = *((unsigned char*)&buffer1);
248              }
249#endif
250              break;
251            case 2:
252              buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
253              buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
254              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue
255                  == *((unsigned short*)&buffer2))
256                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
257#ifdef IPV4AGG
258              if (pftmp->fieldType==10){
259                agCache.idSnmp = *((unsigned short*)&buffer2);
260              }
261#endif
262#ifdef CRIHAN
263              if (pftmp->fieldType==10){
264                ipFirstCache.inSnmp = *((unsigned short*)&buffer2);
265              }
266              if (pftmp->fieldType==14){
267                ipFirstCache.outSnmp = *((unsigned short*)&buffer2);
268              }
269              if (pftmp->fieldType==7){
270                ipFirstCache.sPort = *((unsigned short*)&buffer2);
271              }
272              if (pftmp->fieldType==11){
273                ipFirstCache.dPort = *((unsigned short*)&buffer2);
274              }
275#endif
276              break;
277            case 3:
278              buffer4[3]= 0;
279              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
280              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
281              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
282              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue
283                  == *((unsigned long*)&buffer4))
284                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
285              /* aggregation */
286              /* end aggregation */
287              if (pftmp->fieldType==70){
288                isMplsFlow = 1;
289              }
290#ifdef CRIHAN
291              if (pftmp->fieldType==70){
292                mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4;
293              }
294#endif
295              break;
296            case 4:
297              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
298              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
299              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
300              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
301              /* FIXME : here , add a check on the field type */
302              if ((pftmp->fieldType==8)||(pftmp->fieldType==12)){
303                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)
304                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) )
305                  {
306                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
307                  }
308              }
309#ifdef IPV4AGG
310              if ((pftmp->fieldType==8)){
311                bool = 1; /* very important, test if we have an IPv4 flow for Agg */
312                agCache.v4AdS = *((unsigned long*)&buffer4);
313              }
314              if ((pftmp->fieldType==12)){
315                agCache.v4AdD = *((unsigned long*)&buffer4);
316              }
317              if (pftmp->fieldType==1){
318                agCache.bytes = *((unsigned long*)&buffer4);
319                if (
320                    ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) + ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)*10/100))
321                    <= (*((unsigned long*)&buffer4))
322                     &&
323                    ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) - ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)*10/100))
324                     >= (*((unsigned long*)&buffer4))
325                    )
326                  {
327                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
328                  }
329              }
330              if (pftmp->fieldType==2){
331                agCache.pkts = *((unsigned long*)&buffer4);
332              }
333#endif
334#ifdef CRIHAN
335              if (pftmp->fieldType==8){
336                ipFirstCache.v4AdS = *((unsigned long*)&buffer4);
337                mplsFirstCache.v4AdS = *((unsigned long*)&buffer4);
338              }
339              if (pftmp->fieldType==12){
340                ipFirstCache.v4AdD = *((unsigned long*)&buffer4);
341                mplsFirstCache.v4AdD = *((unsigned long*)&buffer4);
342              }
343              if (pftmp->fieldType==1){
344                ipFirstCache.bytes = *((unsigned long*)&buffer4);
345              }
346              if (pftmp->fieldType==2){
347                ipFirstCache.pkts = *((unsigned long*)&buffer4);
348              }
349              if (pftmp->fieldType==22){
350                firstTime = *((unsigned long*)&buffer4);
351              }
352              if (pftmp->fieldType==21){
353                lastTime = *((unsigned long*)&buffer4);
354              }
355#endif
356              break;
357            case 16:
358              for (i=0; i<4; i++) {
359                buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
360                buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
361                buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
362                buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
363                if (1==moreIsNecessary){
364                  switch(i){
365                  case 0:
366                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){
367                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
368                          ==
369                          (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
370                          )
371                        {
372                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
373                          moreIsNecessary = 0;
374                        } else {
375                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
376                          moreIsNecessary = 0;
377                        }
378                    } else {
379                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
380                          ==
381                          (*((unsigned long*)&buffer4))
382                          )
383                        {
384                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
385                        } else {
386                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
387                          moreIsNecessary = 0;
388                        }
389                    }
390                    break;
391                  case 1:
392                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){
393                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
394                          ==
395                          (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
396                          )
397                        {
398                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
399                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
400                          moreIsNecessary = 0;
401                        } else {
402                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
403                          moreIsNecessary = 0;
404                        }
405                    } else {
406                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
407                          ==
408                          (*((unsigned long*)&buffer4))
409                          )
410                        {
411                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
412                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
413                        } else {
414                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
415                          moreIsNecessary = 0;
416                        }
417                    }
418                    break;
419                  case 2:
420                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){
421                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
422                          ==
423                          (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
424                          )
425                        {
426                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
427                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
428                          moreIsNecessary = 0;
429                        } else {
430                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
431                          moreIsNecessary = 0;
432                        }
433                    } else {
434                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
435                          ==
436                          (*((unsigned long*)&buffer4))
437                          )
438                        {
439                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
440                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
441                        } else {
442                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
443                          moreIsNecessary = 0;
444                        }
445                    }
446                    break;
447                  case 3:
448                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){
449                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
450                          ==
451                          (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
452                          )
453                        {
454                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
455                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
456                        } else {
457                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
458                          moreIsNecessary = 0;
459                        }
460                    } else {
461                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
462                          ==
463                          (*((unsigned long*)&buffer4))
464                          )
465                        {
466                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
467                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
468                        } else {
469                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
470                          moreIsNecessary = 0;
471                        }
472                    }
473                    break;
474                  default:
475                    break;
476                  } /* end of switch(i) */
477                } /* end of if moreIsNecessary */
478              }
479              moreIsNecessary = 1;
480              /* aggregation for IPv6 flows */
481             
482              /* end aggregation */
483              break;
484            default:
485              syslog(LOG_INFO, "Field size not known: %d\n", field_size);
486              for (i=0; i<field_size; i++){
487                (*myPtrs->offsetV9Ptr)++;
488              }
489              break;
490            }
491            break;
492          default:
493            syslog(LOG_INFO, "Operator not known: %d\n",
494                   (int)(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator));
495            break;
496          }
497          j++;
498          pos = (pftmp->fieldType)*10+j;
499        } /* end while myPtrs->rulesAddressPtr */
500      } else {
501        /*
502         * no rule within this field type, but we must read the value
503         */
504        switch (field_size) {
505        case 1:
506          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
507#ifdef IPV4AGG
508          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
509            agCache.maskS = *((unsigned char*)&buffer1);
510          }
511          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
512            agCache.maskD = *((unsigned char*)&buffer1);
513          }
514          if (pftmp->fieldType==60){
515            agCache.ipProt = *((unsigned char*)&buffer1);
516          }
517          if (pftmp->fieldType==4){
518            agCache.tProt = *((unsigned char*)&buffer1);
519          }
520          if (pftmp->fieldType==61){
521            agCache.sens = *((unsigned char*)&buffer1);
522          }
523          if (pftmp->fieldType==5){
524            agCache.dscp = *((unsigned char*)&buffer1);
525          }       
526#endif
527#ifdef CRIHAN
528          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
529            ipFirstCache.maskS = *((unsigned char*)&buffer1);
530          }
531          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
532            ipFirstCache.maskD = *((unsigned char*)&buffer1);
533          }
534          if (pftmp->fieldType==60){
535            ipFirstCache.ipProt = *((unsigned char*)&buffer1);
536            mplsFirstCache.ipProt = *((unsigned char*)&buffer1);
537          }
538          if (pftmp->fieldType==4){
539            ipFirstCache.tProt = *((unsigned char*)&buffer1);
540          }
541#endif
542          break;
543        case 2:
544          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
545          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
546#ifdef IPV4AGG
547          if (pftmp->fieldType==10){
548            agCache.idSnmp = *((unsigned short*)&buffer2);
549          }       
550#endif
551#ifdef CRIHAN
552          if (pftmp->fieldType==10){
553            ipFirstCache.inSnmp = *((unsigned short*)&buffer2);
554          }
555          if (pftmp->fieldType==14){
556            ipFirstCache.outSnmp = *((unsigned short*)&buffer2);
557          }
558          if (pftmp->fieldType==7){
559            ipFirstCache.sPort = *((unsigned short*)&buffer2);
560          }
561          if (pftmp->fieldType==11){
562            ipFirstCache.dPort = *((unsigned short*)&buffer2);
563          }
564#endif
565          break;
566        case 3:
567          buffer4[3]= 0;
568          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
569          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
570          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
571          /* aggregation */
572          /* end aggregation */
573          if (pftmp->fieldType==70){
574            isMplsFlow = 1;
575          }
576#ifdef CRIHAN
577          if (pftmp->fieldType==70){
578            mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4;
579          }
580#endif
581          break;
582        case 4:
583          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
584          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
585          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
586          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
587#ifdef IPV4AGG
588          if ((pftmp->fieldType==8)){
589            bool = 1;
590            agCache.v4AdS = *((unsigned long*)&buffer4);
591          } else if ((pftmp->fieldType==12)){
592            agCache.v4AdD = *((unsigned long*)&buffer4);
593          } else if (pftmp->fieldType==1){
594            agCache.bytes = *((unsigned long*)&buffer4);
595          } else if (pftmp->fieldType==2){
596            agCache.pkts = *((unsigned long*)&buffer4);
597          }
598#endif
599#ifdef CRIHAN
600          if (pftmp->fieldType==8){
601            ipFirstCache.v4AdS = *((unsigned long*)&buffer4);
602            mplsFirstCache.v4AdS = *((unsigned long*)&buffer4);
603          }
604          if (pftmp->fieldType==12){
605            ipFirstCache.v4AdD = *((unsigned long*)&buffer4);
606            mplsFirstCache.v4AdD = *((unsigned long*)&buffer4);
607          }
608          if (pftmp->fieldType==1){
609            ipFirstCache.bytes = *((unsigned long*)&buffer4);
610          }
611          if (pftmp->fieldType==2){
612            ipFirstCache.pkts = *((unsigned long*)&buffer4);
613          }
614          if (pftmp->fieldType==22){
615            firstTime = *((unsigned long*)&buffer4);
616          }
617          if (pftmp->fieldType==21){
618            lastTime = *((unsigned long*)&buffer4);
619          }
620#endif
621          break;
622        case 16:
623          for (i=0; i<4; i++) {
624            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
625            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
626            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
627            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
628          }
629          /* aggregation IPv6 */         
630          /* end aggregation */
631          break;
632        default:
633          syslog(LOG_INFO,"UNKNOWN FIELDS LENGTH: %d ", field_size);
634          for (i=0; i<field_size; i++){
635            (*myPtrs->offsetV9Ptr)++;
636          }
637        }
638      } /* end if one cache table line existence */
639      if (cpt==tmp->fieldCount) {
640        /*
641         * end of one flow (not the flowset)
642         */
643#ifdef CRIHAN
644        if ( mplsFirstCache.mplsLabel1 == 0 ) {
645          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->ipProt = ipFirstCache.ipProt;
646          ipFirstCache.ipProt = 0;
647          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->bytes = ipFirstCache.bytes;
648          ipFirstCache.bytes = 0;
649          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->pkts = ipFirstCache.pkts;
650          ipFirstCache.pkts = 0;
651          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->inSnmp = ipFirstCache.inSnmp;
652          ipFirstCache.inSnmp = 0;
653          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->outSnmp = ipFirstCache.outSnmp;
654          ipFirstCache.outSnmp = 0;
655          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdS = ipFirstCache.v4AdS;
656          ipFirstCache.outSnmp = 0;
657          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdD = ipFirstCache.v4AdD;
658          ipFirstCache.v4AdD = 0;
659          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->tProt = ipFirstCache.tProt;
660          ipFirstCache.tProt = 0;
661          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->sPort = ipFirstCache.sPort;
662          ipFirstCache.sPort = 0;
663          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->dPort = ipFirstCache.dPort;
664          ipFirstCache.dPort = 0;
665          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskD = ipFirstCache.maskD;
666          ipFirstCache.maskD = 0;
667          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskS = ipFirstCache.maskS;
668          ipFirstCache.maskS = 0;
669          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->routerAd = ipFirstCache.routerAd;
670          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->liveTime = lastTime - firstTime;
671          firstTime = 0; lastTime = 0;
672          (*myPtrs->ipNbPtr)++;
673        } else {
674          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->ipProt = mplsFirstCache.ipProt;
675          mplsFirstCache.ipProt = 0;
676          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdS =  mplsFirstCache.v4AdS;
677          mplsFirstCache.v4AdS = 0;
678          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdD =  mplsFirstCache.v4AdD;
679          mplsFirstCache.v4AdD = 0;
680          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->routerAd =  mplsFirstCache.routerAd;
681          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->mplsLabel1 =  mplsFirstCache.mplsLabel1;
682          mplsFirstCache.mplsLabel1 = 0;
683          (*myPtrs->mplsNbPtr)++;
684        }
685#endif 
686        /* put aggregation cache information to IPv4 Prefixes table */
687        /* Aggregation mode must be enable in ./configure options   */
688        /* first we must know if the address belong to our prefix   */
689        myPtrs->nbFluxTT++;
690#ifdef IPV4AGG
691        if ( (bool == 1) && (isMplsFlow == 0) ){
692          prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS);
693          res = bsearch(&prefixKey, V4PTab, nbPV4,
694                        sizeof(struct PrefixV4), prefGlobalCmp);
695          if (res!=NULL){
696            if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
697              myPtrs->nbFluxSR4++;
698              /* OUT ("traffic from the prefix/subnet")  */
699              res->bytesNbOUT += agCache.bytes;
700              res->pktsNbOUT += agCache.pkts;
701              (res->flowNbOUT)++;
702              /* inter-pop matrix Accounting */
703              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);
704              res2 = bsearch(&prefixKey, V4PTab, nbPV4,
705                            sizeof(struct PrefixV4), prefGlobalCmp);
706              if (res2!=NULL){
707                myPtrs->nbFluxIR4++;
708                ((struct POP *)((myPtrs->matrixPOP)
709                                +((res->routerNb)*ROUTER_INDEX_MAX)
710                                +((res2->routerNb))))->pktsNb += agCache.pkts;
711                ((struct POP *)((myPtrs->matrixPOP)
712                                +((res->routerNb)*ROUTER_INDEX_MAX)
713                                +((res2->routerNb))))->bytesNb += agCache.bytes;
714                ((struct POP *)((myPtrs->matrixPOP)
715                                +((res->routerNb)*ROUTER_INDEX_MAX)
716                                +((res2->routerNb))))->flowNb++;
717              } else {
718                myPtrs->nbFluxSE++;
719                (
720                 ((struct POP *)(myPtrs->matrixPOP)
721                 +((res->routerNb)*ROUTER_INDEX_MAX)
722                 +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts;
723                (
724                 ((struct POP *)(myPtrs->matrixPOP)
725                 +((res->routerNb)*ROUTER_INDEX_MAX)
726                 +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes;
727                (
728                 ((struct POP *)(myPtrs->matrixPOP)
729                 +((res->routerNb)*ROUTER_INDEX_MAX)
730                 +((ROUTER_INDEX_MAX-1))))->flowNb++;
731              }
732              /* end interpop matrix accounting */
733            } else {
734              /* doublon or bad reference in prefix list */
735            }
736          } else {
737            prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);
738            res = bsearch(&prefixKey, V4PTab, nbPV4,
739                          sizeof(struct PrefixV4), prefGlobalCmp);
740            if (res!=NULL){
741              if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
742                /* IN ("traffic to the prefix")  */
743                res->bytesNbIN += agCache.bytes;
744                res->pktsNbIN += agCache.pkts;
745                (res->flowNbIN)++;
746              } else {
747                /* doublon or bad reference in prefix list */
748               
749/*              fprintf(stderr, "IN NC: %lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu R:%lu.%lu.%lu.%lu \n", */
750/*                      (agCache.v4AdS>>24), */
751/*                      (agCache.v4AdS<<8>>24),  */
752/*                      (agCache.v4AdS<<16>>24),  */
753/*                      (agCache.v4AdS<<24>>24),  */
754/*                      (agCache.maskS),  */
755/*                      (agCache.v4AdD>>24),  */
756/*                      (agCache.v4AdD<<8>>24),  */
757/*                      (agCache.v4AdD<<16>>24),  */
758/*                      (agCache.v4AdD<<24>>24),  */
759/*                      (agCache.maskD),  */
760/*                      (myPtrs->pcktPtr->ipH->srcAdd>>24),  */
761/*                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */
762/*                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */
763/*                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24) */
764/*                      ); */
765              }
766            } else {
767              /* HERE : we are in the cases of the address/mask don't      */
768              /*        belong to a prefix listed in the IPv4 prefix file  */
769              /* possibilities :                                           */
770              /*     -  prefix not referenced but allowed to be routed     */
771              /*     -  prefix not referenced but not allowed to be routed */
772              /*     -  spoofing                                           */
773              myPtrs->nbFluxUK++;
774#ifdef PRINTUNKNOWNSUBNET 
775              fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu (R:%lu.%lu.%lu.%lu) \n",
776                      (agCache.v4AdS>>24),
777                      (agCache.v4AdS<<8>>24),
778                      (agCache.v4AdS<<16>>24),
779                      (agCache.v4AdS<<24>>24),
780                      (agCache.maskS),
781                      (agCache.v4AdD>>24),
782                      (agCache.v4AdD<<8>>24),
783                      (agCache.v4AdD<<16>>24),
784                      (agCache.v4AdD<<24>>24),
785                      (agCache.maskD),
786                      (myPtrs->pcktPtr->ipH->srcAdd>>24),
787                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
788                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
789                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)
790                      );
791#endif
792            }
793          }
794        }
795        bool = 0;
796        isMplsFlow = 0;
797#endif
798        /*
799         * Redirection if needed
800         * switch the rules definition (check & fieldToRecord),
801         * we send the flow or a part of the flow to a remote host or a file.
802         * In a first time (until release 0.0.7, the information was sent via
803         * the process renetcolSender with an IPC message queue. But, the perf
804         * of IPC Msg was very bad with a default system compilation.
805         * So, now, we send information directly from here.
806         */
807        tmpRuleList = myPtrs->rulesListPtr;
808        tmpRL = myPtrs->rulesListPtr;
809        while (tmpRuleList){
810          RuleDefPtr tmpRuleDefList = tmpRuleList->def;
811          unsigned short check = 1;
812          int s=0;
813          secondOffset = secondOldOffset;
814          while (tmpRuleDefList){
815            check = check && tmpRuleDefList->check;
816            tmpRuleDefList->check = 0;
817            tmpRuleDefList = tmpRuleDefList->next;
818          }
819          if ( (tmpRuleList->def != NULL) && (check == 1)) {
820            /* msg building */
821            secondPftmp = tmp->lastField;
822            msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text,   
823                                                   &tplMsgType,
824                                                   sizeof(unsigned short)
825                                                   ),
826                                           &tmpRuleList->id,
827                                           sizeof(tmpRuleList->id)
828                                           ),
829                                   &myPtrs->currentRouterPtr->IpAddress,
830                                   sizeof(unsigned long)
831                                   );
832            msgTextIndex = mempcpy(mempcpy(mempcpy(msgTextIndex,
833                                                   &tmp->sourceId,
834                                                   sizeof(unsigned long)
835                                                   ),
836                                           &tmp->templateFlowSetId,
837                                           sizeof(tmp->templateFlowSetId)
838                                           ),
839                                   myPtrs->ptr_buffer+secondOffset,
840                                   flow_size
841                                   );
842            myMsg.type = 1;
843            /* OLD transfert type */
844/*          msgSend( myQueue, myMsg); */
845            /* NEW transfert type */
846            for ( ; tmpRL; tmpRL=tmpRL->next){
847              if (tmpRL->id == tmpRuleList->id){       
848                s = sendMessage(tmpRL->host->sockId, myMsg.text, sizeof(myMsg.text),
849                                tmpRL->host->hostAddressPtr);
850              }
851            }
852            /* FIXME : perhaps check "s" */
853            noEnd = 1;
854            secondCpt=0;
855          } /* end if check */
856          tmpRuleList = tmpRuleList->next;
857          tmpRL = myPtrs->rulesListPtr; /* ticket #11 */
858          secondPftmp = tmp->lastField;
859        } /* end while tmpRuleList */
860        /*
861         * end redirection
862         */
863        secondOffset = *myPtrs->offsetV9Ptr;
864        secondOldOffset = secondOffset;
865        pftmp = tmp->lastField;
866        cpt=0;
867        (*myPtrs->currentFlowsetNumberPtr)++; /* pointer on the flows number */
868        if (((*myPtrs->offsetV9Ptr)-48-shift+flow_size) > data_length){
869          overflow = 1; /* buffer index not correct */
870        }
871      } else {
872        /* not the flow end, progress in field list */
873        pftmp = pftmp->prev;
874      }
875    } /* end of the while on one flow record */
876   
877    while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) {
878      (*myPtrs->offsetV9Ptr)++; /* if padding */
879      paddingCounter++;
880      if ( paddingCounter > 8 ) {
881#ifdef DEBUG
882        fprintf(stderr," padding too high: %d ", paddingCounter);
883#endif
884        syslog(LOG_INFO,"padding too high: %d ", paddingCounter);
885        return (-1);
886      }
887    }
888    while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) {
889      (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */
890      crazyCounter++;
891    }
892#ifdef DEBUG
893    if (crazyCounter != 0){ fprintf(stderr," crazyCounter: %d ", crazyCounter); }
894#endif
895    if (crazyCounter!=0) { syslog(LOG_INFO,"crazyCounter: %d ", crazyCounter);}
896   
897#ifdef DEBUG
898    fprintf(stderr,"}");
899#endif
900
901    return (data_length+shift);
902    /* end new place */
903   
904  }else{
905    /*
906     *
907     *
908     *       Optional template
909     *
910     *
911     */
912    if ((tmpOpt=existTplOptId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,
913                              (*myPtrs->currentFlowsetIdPtr)))!=NULL) {       
914#ifdef DEBUG
915      fprintf(stderr,"<d id: %hu, lg %hu", (*myPtrs->currentFlowsetIdPtr), data_length);
916#endif     
917      for ( i=0; i<(tmpOpt->optionScopeLg/4); i++){
918        /* FIXME : today we skip the scope fields, it's bad :( */ 
919        if ((pftmp=tmpOpt->lastField)!=NULL) {
920          for (j=0; j<pftmp->fieldLength; j++) {
921            (*myPtrs->offsetV9Ptr)++;
922          }
923          pftmp = pftmp->prev;
924        }
925      }
926      while (pftmp != NULL) {
927        if (pftmp->fieldLength==1){
928          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
929        }
930        if (pftmp->fieldLength==2){
931          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
932          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
933        }
934        if (pftmp->fieldLength==4){
935          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
936          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
937          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
938          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
939          if (pftmp->fieldType==34){
940            if ((*((unsigned long*)&buffer4)==1)
941                || (*((unsigned long*)&buffer4)==10)
942                || (*((unsigned long*)&buffer4)==1000)) {
943              if (myPtrs->currentRouterPtr->sampled != *((unsigned long*)&buffer4) ) {
944#ifdef DEBUGAGG
945                fprintf(stderr,"\n SV (p) %lu != %lu (r)", *((unsigned long*)&buffer4),
946                        myPtrs->currentRouterPtr->sampled);
947#endif                     
948                myPtrs->currentRouterPtr->sampled = *((unsigned long*)&buffer4);
949                for (i=0; i<nbPV4; i++) {
950                  /* we update the PrefixV4 structure with the sampled information */
951                  if ( myPtrs->currentRouterPtr->IpAddress == myPtrs->routersID[V4PTab[i].routerNb]) {
952                    V4PTab[i].sampling = *((unsigned long*)&buffer4);
953                    myPtrs->secondV4Tab[i].sampling = *((unsigned long*)&buffer4);
954                  }
955                }
956              }
957            }
958          }
959        }       
960        pftmp = pftmp->prev;
961      }
962      if ( pftmp == NULL ) {
963        while ((*myPtrs->offsetV9Ptr)%4 != 0) {
964          (*myPtrs->offsetV9Ptr)++;
965#ifdef DEBUG
966          fprintf(stderr," p ");
967#endif
968        }
969      } else {
970        fprintf(stderr,"PB ");
971      }
972#ifdef DEBUG
973      fprintf(stderr,">");
974#endif
975      return (data_length+shift);
976    } else {
977      /*
978       * template unknown, we skip this all the data
979       */
980      (*myPtrs->offsetV9Ptr)+=(data_length-4);
981      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
982#ifdef DEBUG
983      fprintf(stderr, " U, r: %lu.%lu.%lu.%lu, sourceId: %lu, TID: %hu",
984              (myPtrs->pcktPtr->ipH->srcAdd>>24),
985              (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
986              (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
987              (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
988              myPtrs->currentHeaderV9Ptr->sourceId,
989              (*myPtrs->currentFlowsetIdPtr)
990              );
991#endif
992      return (data_length+shift);
993    }
994  }
995}
Note: See TracBrowser for help on using the browser.