root/trunk/src/dataFlowSet.c @ 54

Revision 54, 35.0 KB (checked in by andreu, 15 years ago)

add the comparaison with fields 7 and 11 (ports)

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