root/trunk/src/dataFlowSet.c @ 55

Revision 55, 35.5 KB (checked in by andreu, 15 years ago)

addadd the comparaison with fields 10 and 14 (snmp index)

  • 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              /* FIXME : add this two following bloc in the case N = 4 */
264              if (pftmp->fieldType==10){
265                ipFirstCache.inSnmp = *((unsigned short*)&buffer2);
266                if ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
267                     == (*((unsigned short*)&buffer2))
268                     )
269                  {
270                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
271                  }
272              }
273              if (pftmp->fieldType==14){
274                ipFirstCache.outSnmp = *((unsigned short*)&buffer2);
275                if ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
276                     == (*((unsigned short*)&buffer2))
277                     )
278                  {
279                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
280                  }
281              }
282              if (pftmp->fieldType==7){
283                ipFirstCache.sPort = *((unsigned short*)&buffer2);
284                if ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
285                     == (*((unsigned short*)&buffer2))
286                     )
287                  {
288                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
289                  }
290              }
291              if (pftmp->fieldType==11){
292                ipFirstCache.dPort = *((unsigned short*)&buffer2);
293                if ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue)
294                     == (*((unsigned short*)&buffer2))
295                     )
296                  {
297                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
298                  }
299              }
300#endif
301              break;
302            case 3:
303              buffer4[3]= 0;
304              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
305              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
306              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
307              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue
308                  == *((unsigned long*)&buffer4))
309                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
310              /* aggregation */
311              /* end aggregation */
312              if (pftmp->fieldType==70){
313                isMplsFlow = 1;
314              }
315#ifdef CRIHAN
316              if (pftmp->fieldType==70){
317                mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4;
318              }
319#endif
320              break;
321            case 4:
322              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
323              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
324              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
325              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
326              /* FIXME : here , add a check on the field type */
327              if ((pftmp->fieldType==8)||(pftmp->fieldType==12)){
328                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)
329                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) )
330                  {
331                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
332                  }
333              }
334              if (pftmp->fieldType==1){
335                agCache.bytes = *((unsigned long*)&buffer4);
336                if (
337                    ((unsigned long)((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) + ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)*10/100))
338                     >= (*((unsigned long*)&buffer4)))
339                    &&
340                    ( (unsigned long)((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) - ( (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue)*10/100))
341                      <= (*((unsigned long*)&buffer4)) )
342                    )
343                  {
344                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
345                  }
346              }
347#ifdef IPV4AGG
348              if ((pftmp->fieldType==8)){
349                bool = 1; /* very important, test if we have an IPv4 flow for Agg */
350                agCache.v4AdS = *((unsigned long*)&buffer4);
351              }
352              if ((pftmp->fieldType==12)){
353                agCache.v4AdD = *((unsigned long*)&buffer4);
354              }
355              if (pftmp->fieldType==1){
356                agCache.bytes = *((unsigned long*)&buffer4);
357              }
358              if (pftmp->fieldType==2){
359                agCache.pkts = *((unsigned long*)&buffer4);
360              }
361#endif
362#ifdef CRIHAN
363              if (pftmp->fieldType==8){
364                ipFirstCache.v4AdS = *((unsigned long*)&buffer4);
365                mplsFirstCache.v4AdS = *((unsigned long*)&buffer4);
366              }
367              if (pftmp->fieldType==12){
368                ipFirstCache.v4AdD = *((unsigned long*)&buffer4);
369                mplsFirstCache.v4AdD = *((unsigned long*)&buffer4);
370              }
371              if (pftmp->fieldType==1){
372                ipFirstCache.bytes = *((unsigned long*)&buffer4);
373              }
374              if (pftmp->fieldType==2){
375                ipFirstCache.pkts = *((unsigned long*)&buffer4);
376              }
377              if (pftmp->fieldType==22){
378                firstTime = *((unsigned long*)&buffer4);
379              }
380              if (pftmp->fieldType==21){
381                lastTime = *((unsigned long*)&buffer4);
382              }
383#endif
384              break;
385            case 16:
386              for (i=0; i<4; i++) {
387                buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
388                buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
389                buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
390                buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
391                if (1==moreIsNecessary){
392                  switch(i){
393                  case 0:
394                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){
395                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
396                          ==
397                          (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
398                          )
399                        {
400                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
401                          moreIsNecessary = 0;
402                        } else {
403                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
404                          moreIsNecessary = 0;
405                        }
406                    } else {
407                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
408                          ==
409                          (*((unsigned long*)&buffer4))
410                          )
411                        {
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 1:
420                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){
421                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
422                          ==
423                          (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((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 2:
448                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){
449                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
450                          ==
451                          (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
452                          )
453                        {
454                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
455                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
456                          moreIsNecessary = 0;
457                        } else {
458                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
459                          moreIsNecessary = 0;
460                        }
461                    } else {
462                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
463                          ==
464                          (*((unsigned long*)&buffer4))
465                          )
466                        {
467                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
468                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
469                        } else {
470                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
471                          moreIsNecessary = 0;
472                        }
473                    }
474                    break;
475                  case 3:
476                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){
477                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
478                          ==
479                          (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
480                          )
481                        {
482                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
483                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
484                        } else {
485                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
486                          moreIsNecessary = 0;
487                        }
488                    } else {
489                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i])
490                          ==
491                          (*((unsigned long*)&buffer4))
492                          )
493                        {
494                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
495                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
496                        } else {
497                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
498                          moreIsNecessary = 0;
499                        }
500                    }
501                    break;
502                  default:
503                    break;
504                  } /* end of switch(i) */
505                } /* end of if moreIsNecessary */
506              }
507              moreIsNecessary = 1;
508              /* aggregation for IPv6 flows */
509             
510              /* end aggregation */
511              break;
512            default:
513              syslog(LOG_INFO, "Field size not known: %d\n", field_size);
514              for (i=0; i<field_size; i++){
515                (*myPtrs->offsetV9Ptr)++;
516              }
517              break;
518            }
519            break;
520          default:
521            syslog(LOG_INFO, "Operator not known: %d\n",
522                   (int)(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator));
523            break;
524          }
525          j++;
526          pos = (pftmp->fieldType)*10+j;
527        } /* end while myPtrs->rulesAddressPtr */
528      } else {
529        /*
530         * no rule within this field type, but we must read the value
531         */
532        switch (field_size) {
533        case 1:
534          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
535#ifdef IPV4AGG
536          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
537            agCache.maskS = *((unsigned char*)&buffer1);
538          }
539          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
540            agCache.maskD = *((unsigned char*)&buffer1);
541          }
542          if (pftmp->fieldType==60){
543            agCache.ipProt = *((unsigned char*)&buffer1);
544          }
545          if (pftmp->fieldType==4){
546            agCache.tProt = *((unsigned char*)&buffer1);
547          }
548          if (pftmp->fieldType==61){
549            agCache.sens = *((unsigned char*)&buffer1);
550          }
551          if (pftmp->fieldType==5){
552            agCache.dscp = *((unsigned char*)&buffer1);
553          }       
554#endif
555#ifdef CRIHAN
556          if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
557            ipFirstCache.maskS = *((unsigned char*)&buffer1);
558          }
559          if ((pftmp->fieldType==13)||(pftmp->fieldType==30)){
560            ipFirstCache.maskD = *((unsigned char*)&buffer1);
561          }
562          if (pftmp->fieldType==60){
563            ipFirstCache.ipProt = *((unsigned char*)&buffer1);
564            mplsFirstCache.ipProt = *((unsigned char*)&buffer1);
565          }
566          if (pftmp->fieldType==4){
567            ipFirstCache.tProt = *((unsigned char*)&buffer1);
568          }
569#endif
570          break;
571        case 2:
572          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
573          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
574#ifdef IPV4AGG
575          if (pftmp->fieldType==10){
576            agCache.idSnmp = *((unsigned short*)&buffer2);
577          }       
578#endif
579#ifdef CRIHAN
580          if (pftmp->fieldType==10){
581            ipFirstCache.inSnmp = *((unsigned short*)&buffer2);
582          }
583          if (pftmp->fieldType==14){
584            ipFirstCache.outSnmp = *((unsigned short*)&buffer2);
585          }
586          if (pftmp->fieldType==7){
587            ipFirstCache.sPort = *((unsigned short*)&buffer2);
588          }
589          if (pftmp->fieldType==11){
590            ipFirstCache.dPort = *((unsigned short*)&buffer2);
591          }
592#endif
593          break;
594        case 3:
595          buffer4[3]= 0;
596          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
597          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
598          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
599          /* aggregation */
600          /* end aggregation */
601          if (pftmp->fieldType==70){
602            isMplsFlow = 1;
603          }
604#ifdef CRIHAN
605          if (pftmp->fieldType==70){
606            mplsFirstCache.mplsLabel1 = (*((unsigned long*)&buffer4))>>4;
607          }
608#endif
609          break;
610        case 4:
611          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
612          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
613          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
614          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
615#ifdef IPV4AGG
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 CRIHAN
628          if (pftmp->fieldType==8){
629            ipFirstCache.v4AdS = *((unsigned long*)&buffer4);
630            mplsFirstCache.v4AdS = *((unsigned long*)&buffer4);
631          }
632          if (pftmp->fieldType==12){
633            ipFirstCache.v4AdD = *((unsigned long*)&buffer4);
634            mplsFirstCache.v4AdD = *((unsigned long*)&buffer4);
635          }
636          if (pftmp->fieldType==1){
637            ipFirstCache.bytes = *((unsigned long*)&buffer4);
638          }
639          if (pftmp->fieldType==2){
640            ipFirstCache.pkts = *((unsigned long*)&buffer4);
641          }
642          if (pftmp->fieldType==22){
643            firstTime = *((unsigned long*)&buffer4);
644          }
645          if (pftmp->fieldType==21){
646            lastTime = *((unsigned long*)&buffer4);
647          }
648#endif
649          break;
650        case 16:
651          for (i=0; i<4; i++) {
652            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
653            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
654            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
655            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
656          }
657          /* aggregation IPv6 */         
658          /* end aggregation */
659          break;
660        default:
661          syslog(LOG_INFO,"UNKNOWN FIELDS LENGTH: %d ", field_size);
662          for (i=0; i<field_size; i++){
663            (*myPtrs->offsetV9Ptr)++;
664          }
665        }
666      } /* end if one cache table line existence */
667      if (cpt==tmp->fieldCount) {
668        /*
669         * end of one flow (not the flowset)
670         */
671#ifdef CRIHAN
672        if ( mplsFirstCache.mplsLabel1 == 0 ) {
673          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->ipProt = ipFirstCache.ipProt;
674          ipFirstCache.ipProt = 0;
675          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->bytes = ipFirstCache.bytes;
676          ipFirstCache.bytes = 0;
677          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->pkts = ipFirstCache.pkts;
678          ipFirstCache.pkts = 0;
679          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->inSnmp = ipFirstCache.inSnmp;
680          ipFirstCache.inSnmp = 0;
681          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->outSnmp = ipFirstCache.outSnmp;
682          ipFirstCache.outSnmp = 0;
683          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdS = ipFirstCache.v4AdS;
684          ipFirstCache.outSnmp = 0;
685          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdD = ipFirstCache.v4AdD;
686          ipFirstCache.v4AdD = 0;
687          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->tProt = ipFirstCache.tProt;
688          ipFirstCache.tProt = 0;
689          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->sPort = ipFirstCache.sPort;
690          ipFirstCache.sPort = 0;
691          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->dPort = ipFirstCache.dPort;
692          ipFirstCache.dPort = 0;
693          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskD = ipFirstCache.maskD;
694          ipFirstCache.maskD = 0;
695          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskS = ipFirstCache.maskS;
696          ipFirstCache.maskS = 0;
697          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->routerAd = ipFirstCache.routerAd;
698          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->liveTime = lastTime - firstTime;
699          firstTime = 0; lastTime = 0;
700          (*myPtrs->ipNbPtr)++;
701        } else {
702          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->ipProt = mplsFirstCache.ipProt;
703          mplsFirstCache.ipProt = 0;
704          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdS =  mplsFirstCache.v4AdS;
705          mplsFirstCache.v4AdS = 0;
706          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdD =  mplsFirstCache.v4AdD;
707          mplsFirstCache.v4AdD = 0;
708          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->routerAd =  mplsFirstCache.routerAd;
709          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->mplsLabel1 =  mplsFirstCache.mplsLabel1;
710          mplsFirstCache.mplsLabel1 = 0;
711          (*myPtrs->mplsNbPtr)++;
712        }
713#endif 
714        /* put aggregation cache information to IPv4 Prefixes table */
715        /* Aggregation mode must be enable in ./configure options   */
716        /* first we must know if the address belong to our prefix   */
717        myPtrs->nbFluxTT++;
718#ifdef IPV4AGG
719        if ( (bool == 1) && (isMplsFlow == 0) ){
720          prefixKey.beginning = agCache.v4AdS>>(32-agCache.maskS)<<(32-agCache.maskS);
721          res = bsearch(&prefixKey, V4PTab, nbPV4,
722                        sizeof(struct PrefixV4), prefGlobalCmp);
723          if (res!=NULL){
724            if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
725              myPtrs->nbFluxSR4++;
726              /* OUT ("traffic from the prefix/subnet")  */
727              res->bytesNbOUT += agCache.bytes;
728              res->pktsNbOUT += agCache.pkts;
729              (res->flowNbOUT)++;
730              /* inter-pop matrix Accounting */
731              prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);
732              res2 = bsearch(&prefixKey, V4PTab, nbPV4,
733                            sizeof(struct PrefixV4), prefGlobalCmp);
734              if (res2!=NULL){
735                myPtrs->nbFluxIR4++;
736                ((struct POP *)((myPtrs->matrixPOP)
737                                +((res->routerNb)*ROUTER_INDEX_MAX)
738                                +((res2->routerNb))))->pktsNb += agCache.pkts;
739                ((struct POP *)((myPtrs->matrixPOP)
740                                +((res->routerNb)*ROUTER_INDEX_MAX)
741                                +((res2->routerNb))))->bytesNb += agCache.bytes;
742                ((struct POP *)((myPtrs->matrixPOP)
743                                +((res->routerNb)*ROUTER_INDEX_MAX)
744                                +((res2->routerNb))))->flowNb++;
745              } else {
746                myPtrs->nbFluxSE++;
747                (
748                 ((struct POP *)(myPtrs->matrixPOP)
749                 +((res->routerNb)*ROUTER_INDEX_MAX)
750                 +((ROUTER_INDEX_MAX-1))))->pktsNb += agCache.pkts;
751                (
752                 ((struct POP *)(myPtrs->matrixPOP)
753                 +((res->routerNb)*ROUTER_INDEX_MAX)
754                 +((ROUTER_INDEX_MAX-1))))->bytesNb += agCache.bytes;
755                (
756                 ((struct POP *)(myPtrs->matrixPOP)
757                 +((res->routerNb)*ROUTER_INDEX_MAX)
758                 +((ROUTER_INDEX_MAX-1))))->flowNb++;
759              }
760              /* end interpop matrix accounting */
761            } else {
762              /* doublon or bad reference in prefix list */
763            }
764          } else {
765            prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);
766            res = bsearch(&prefixKey, V4PTab, nbPV4,
767                          sizeof(struct PrefixV4), prefGlobalCmp);
768            if (res!=NULL){
769              if ( myPtrs->routersID[res->routerNb] == agCache.routerAd  ) {
770                /* IN ("traffic to the prefix")  */
771                res->bytesNbIN += agCache.bytes;
772                res->pktsNbIN += agCache.pkts;
773                (res->flowNbIN)++;
774              } else {
775                /* doublon or bad reference in prefix list */
776               
777/*              fprintf(stderr, "IN NC: %lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu R:%lu.%lu.%lu.%lu \n", */
778/*                      (agCache.v4AdS>>24), */
779/*                      (agCache.v4AdS<<8>>24),  */
780/*                      (agCache.v4AdS<<16>>24),  */
781/*                      (agCache.v4AdS<<24>>24),  */
782/*                      (agCache.maskS),  */
783/*                      (agCache.v4AdD>>24),  */
784/*                      (agCache.v4AdD<<8>>24),  */
785/*                      (agCache.v4AdD<<16>>24),  */
786/*                      (agCache.v4AdD<<24>>24),  */
787/*                      (agCache.maskD),  */
788/*                      (myPtrs->pcktPtr->ipH->srcAdd>>24),  */
789/*                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */
790/*                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */
791/*                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24) */
792/*                      ); */
793              }
794            } else {
795              /* HERE : we are in the cases of the address/mask don't      */
796              /*        belong to a prefix listed in the IPv4 prefix file  */
797              /* possibilities :                                           */
798              /*     -  prefix not referenced but allowed to be routed     */
799              /*     -  prefix not referenced but not allowed to be routed */
800              /*     -  spoofing                                           */
801              myPtrs->nbFluxUK++;
802#ifdef PRINTUNKNOWNSUBNET 
803              fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu (R:%lu.%lu.%lu.%lu) \n",
804                      (agCache.v4AdS>>24),
805                      (agCache.v4AdS<<8>>24),
806                      (agCache.v4AdS<<16>>24),
807                      (agCache.v4AdS<<24>>24),
808                      (agCache.maskS),
809                      (agCache.v4AdD>>24),
810                      (agCache.v4AdD<<8>>24),
811                      (agCache.v4AdD<<16>>24),
812                      (agCache.v4AdD<<24>>24),
813                      (agCache.maskD),
814                      (myPtrs->pcktPtr->ipH->srcAdd>>24),
815                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
816                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
817                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)
818                      );
819#endif
820            }
821          }
822        }
823        bool = 0;
824        isMplsFlow = 0;
825#endif
826        /*
827         * Redirection if needed
828         * switch the rules definition (check & fieldToRecord),
829         * we send the flow or a part of the flow to a remote host or a file.
830         * In a first time (until release 0.0.7, the information was sent via
831         * the process renetcolSender with an IPC message queue. But, the perf
832         * of IPC Msg was very bad with a default system compilation.
833         * So, now, we send information directly from here.
834         */
835        tmpRuleList = myPtrs->rulesListPtr;
836        tmpRL = myPtrs->rulesListPtr;
837        while (tmpRuleList){
838          RuleDefPtr tmpRuleDefList = tmpRuleList->def;
839          unsigned short check = 1;
840          int s=0;
841          secondOffset = secondOldOffset;
842          while (tmpRuleDefList){
843            check = check && tmpRuleDefList->check;
844            tmpRuleDefList->check = 0;
845            tmpRuleDefList = tmpRuleDefList->next;
846          }
847          if ( (tmpRuleList->def != NULL) && (check == 1)) {
848            /* msg building */
849            secondPftmp = tmp->lastField;
850            msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text,   
851                                                   &tplMsgType,
852                                                   sizeof(unsigned short)
853                                                   ),
854                                           &tmpRuleList->id,
855                                           sizeof(tmpRuleList->id)
856                                           ),
857                                   &myPtrs->currentRouterPtr->IpAddress,
858                                   sizeof(unsigned long)
859                                   );
860            msgTextIndex = mempcpy(mempcpy(mempcpy(msgTextIndex,
861                                                   &tmp->sourceId,
862                                                   sizeof(unsigned long)
863                                                   ),
864                                           &tmp->templateFlowSetId,
865                                           sizeof(tmp->templateFlowSetId)
866                                           ),
867                                   myPtrs->ptr_buffer+secondOffset,
868                                   flow_size
869                                   );
870            myMsg.type = 1;
871            /* OLD transfert type */
872/*          msgSend( myQueue, myMsg); */
873            /* NEW transfert type */
874            for ( ; tmpRL; tmpRL=tmpRL->next){
875              if (tmpRL->id == tmpRuleList->id){       
876                s = sendMessage(tmpRL->host->sockId, myMsg.text, sizeof(myMsg.text),
877                                tmpRL->host->hostAddressPtr);
878              }
879            }
880            /* FIXME : perhaps check "s" */
881            noEnd = 1;
882            secondCpt=0;
883          } /* end if check */
884          tmpRuleList = tmpRuleList->next;
885          tmpRL = myPtrs->rulesListPtr; /* ticket #11 */
886          secondPftmp = tmp->lastField;
887        } /* end while tmpRuleList */
888        /*
889         * end redirection
890         */
891        secondOffset = *myPtrs->offsetV9Ptr;
892        secondOldOffset = secondOffset;
893        pftmp = tmp->lastField;
894        cpt=0;
895        (*myPtrs->currentFlowsetNumberPtr)++; /* pointer on the flows number */
896        if (((*myPtrs->offsetV9Ptr)-48-shift+flow_size) > data_length){
897          overflow = 1; /* buffer index not correct */
898        }
899      } else {
900        /* not the flow end, progress in field list */
901        pftmp = pftmp->prev;
902      }
903    } /* end of the while on one flow record */
904   
905    while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) {
906      (*myPtrs->offsetV9Ptr)++; /* if padding */
907      paddingCounter++;
908      if ( paddingCounter > 8 ) {
909#ifdef DEBUG
910        fprintf(stderr," padding too high: %d ", paddingCounter);
911#endif
912        syslog(LOG_INFO,"padding too high: %d ", paddingCounter);
913        return (-1);
914      }
915    }
916    while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) {
917      (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */
918      crazyCounter++;
919    }
920#ifdef DEBUG
921    if (crazyCounter != 0){ fprintf(stderr," crazyCounter: %d ", crazyCounter); }
922#endif
923    if (crazyCounter!=0) { syslog(LOG_INFO,"crazyCounter: %d ", crazyCounter);}
924   
925#ifdef DEBUG
926    fprintf(stderr,"}");
927#endif
928
929    return (data_length+shift);
930    /* end new place */
931   
932  }else{
933    /*
934     *
935     *
936     *       Optional template
937     *
938     *
939     */
940    if ((tmpOpt=existTplOptId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId,
941                              (*myPtrs->currentFlowsetIdPtr)))!=NULL) {       
942#ifdef DEBUG
943      fprintf(stderr,"<d id: %hu, lg %hu", (*myPtrs->currentFlowsetIdPtr), data_length);
944#endif     
945      for ( i=0; i<(tmpOpt->optionScopeLg/4); i++){
946        /* FIXME : today we skip the scope fields, it's bad :( */ 
947        if ((pftmp=tmpOpt->lastField)!=NULL) {
948          for (j=0; j<pftmp->fieldLength; j++) {
949            (*myPtrs->offsetV9Ptr)++;
950          }
951          pftmp = pftmp->prev;
952        }
953      }
954      while (pftmp != NULL) {
955        if (pftmp->fieldLength==1){
956          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
957        }
958        if (pftmp->fieldLength==2){
959          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
960          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
961        }
962        if (pftmp->fieldLength==4){
963          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
964          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
965          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
966          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
967          if (pftmp->fieldType==34){
968            if ((*((unsigned long*)&buffer4)==1)
969                || (*((unsigned long*)&buffer4)==10)
970                || (*((unsigned long*)&buffer4)==1000)) {
971              if (myPtrs->currentRouterPtr->sampled != *((unsigned long*)&buffer4) ) {
972#ifdef DEBUGAGG
973                fprintf(stderr,"\n SV (p) %lu != %lu (r)", *((unsigned long*)&buffer4),
974                        myPtrs->currentRouterPtr->sampled);
975#endif                     
976                myPtrs->currentRouterPtr->sampled = *((unsigned long*)&buffer4);
977                for (i=0; i<nbPV4; i++) {
978                  /* we update the PrefixV4 structure with the sampled information */
979                  if ( myPtrs->currentRouterPtr->IpAddress == myPtrs->routersID[V4PTab[i].routerNb]) {
980                    V4PTab[i].sampling = *((unsigned long*)&buffer4);
981                    myPtrs->secondV4Tab[i].sampling = *((unsigned long*)&buffer4);
982                  }
983                }
984              }
985            }
986          }
987        }       
988        pftmp = pftmp->prev;
989      }
990      if ( pftmp == NULL ) {
991        while ((*myPtrs->offsetV9Ptr)%4 != 0) {
992          (*myPtrs->offsetV9Ptr)++;
993#ifdef DEBUG
994          fprintf(stderr," p ");
995#endif
996        }
997      } else {
998        fprintf(stderr,"PB ");
999      }
1000#ifdef DEBUG
1001      fprintf(stderr,">");
1002#endif
1003      return (data_length+shift);
1004    } else {
1005      /*
1006       * template unknown, we skip this all the data
1007       */
1008      (*myPtrs->offsetV9Ptr)+=(data_length-4);
1009      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
1010#ifdef DEBUG
1011      fprintf(stderr, " U, r: %lu.%lu.%lu.%lu, sourceId: %lu, TID: %hu",
1012              (myPtrs->pcktPtr->ipH->srcAdd>>24),
1013              (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
1014              (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
1015              (myPtrs->pcktPtr->ipH->srcAdd<<24>>24),
1016              myPtrs->currentHeaderV9Ptr->sourceId,
1017              (*myPtrs->currentFlowsetIdPtr)
1018              );
1019#endif
1020      return (data_length+shift);
1021    }
1022  }
1023}
Note: See TracBrowser for help on using the browser.