root/trunk/src/dataFlowSet.c @ 29

Revision 29, 31.7 KB (checked in by andreu, 15 years ago)

sampling information in rrd filename - optional template first step

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