root/trunk/src/dataFlowSet.c @ 57

Revision 57, 28.5 KB (checked in by andreu, 15 years ago)

delete all CRIHAN code and some outputs; add param in check.sh

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