Changeset 23

Timestamp:

02/05/07 17:50:16 (16 years ago)

Author:

andreu

Message:

optimization : new param : myPtrs in checkdataflowset function

Location:

trunk/src

Files:

• dataFlowSet.c (modified) (29 diffs)
• dataFlowSet.h (modified) (1 diff)
• fields_mgmt.c (modified) (1 diff)
• fields_mgmt.h (modified) (2 diffs)
• get_conf.c (modified) (1 diff)
• get_conf.h (modified) (1 diff)
• renetcol.c (modified) (24 diffs)
• renetcol.h (modified) (2 diffs)
• renetcolDB.c (added)
• renetcolDB.h (added)
• renetcolSender.c (modified) (3 diffs)
• template.c (modified) (3 diffs)

trunk/src/dataFlowSet.c

@@ -29 +29 @@
  * Check Data FlowSet 
  *
- * @param shift Shift
- * @param cr Current router pointer
- * @param v9Ptr Pointer in the datagram ??
- * @param offv9 index in the datagram
- * @param buf Pointer to the buffer
- * @param cFNPtr Pointer on the current flowset number
- * @param cFId Pointer on the current flowset ID
- * @param pcktPtr Pointer on the datagram buffer
- * @param rulesCache Pointer on the rules table (cache for the next param)
- * @param rlPtr Pointer on the rules list
- * @param myQueue FIXME : to erase/delete/suppress
- * @param V4PTab Pointer on the IPv4 Prefix Table
- * @param nbPV4 Previous table size
- * @param ipCache Cache for all IP flow (for CRIHAN compilation option)
- * @param mplsCache Cache for all MPLS flow (for CRIHAN compilation option)
- * @param ipCounter Param to defined IP Cache size
- * @param mplsCounter Param to defined MPLS Cache size 
- * @return shift (index in the datagram) FIXME 
- * 
- * FIXME to tune : just a param like a table ?
  */
 unsigned short 
-checkDataFlowSet(unsigned short shift, RouterPtr cr, NetFlowV9HeaderPtr v9Ptr,
-                 unsigned short *offV9, unsigned char *buf, short *cFNPtr,
-                 short *cFId, DatagramPtr pcktPtr, RuleDefPtr *rulesCache,
-                 RulesPtr rlPtr, int myQueue, struct PrefixV4 *V4PTab, 
-                 size_t nbPV4, 
-                 struct IPFLowCache *ipCache, struct MPLSFlowCache *mplsCache,
-                 unsigned long *ipCounter, unsigned long *mplsCounter)
+checkDataFlowSet(unsigned short shift, 
+                 struct MyPtrs *myPtrs,
+                 int myQueue, 
+                 struct PrefixV4 *V4PTab, 
+                 size_t nbPV4
+                 )
 {
   TplFlowSetPtr tmp;
@@ -64 +43 @@
   unsigned short data_length = 0;
   unsigned short flow_size = 0;
-  unsigned short oldOffset = *offV9;
+  unsigned short oldOffset = *myPtrs->offsetV9Ptr;
   unsigned short secondOffset = 0;
   unsigned short secondOldOffset = 0;
@@ -79 +58 @@
   unsigned char buffer2[2];
   unsigned char buffer4[4];
-  RulesPtr tmpRuleList = rlPtr;
+  RulesPtr tmpRuleList = myPtrs->rulesListPtr;
   msgType myMsg;
   char *msgTextIndex;
@@ -114 +93 @@
 #endif /* CRIHAN */
 
-  buffer2[1] = *(buf+(*offV9));(*offV9)++;
-  buffer2[0] = *(buf+(*offV9));(*offV9)++;
-  (*cFId) = *((unsigned short*)&buffer2);
-  buffer2[1] = *(buf+(*offV9));(*offV9)++;
-  buffer2[0] = *(buf+(*offV9));(*offV9)++;
+  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
+  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
+  (*myPtrs->currentFlowsetIdPtr) = *((unsigned short*)&buffer2);
+  buffer2[1] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
+  buffer2[0] = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr));(*myPtrs->offsetV9Ptr)++;
   data_length = *((unsigned short*)&buffer2);
-  if ((tmp=existTplId(cr, v9Ptr->sourceId, 
-                      (*cFId)))!=NULL) {
+  if ((tmp=existTplId(myPtrs->currentRouterPtr, myPtrs->currentHeaderV9Ptr->sourceId, 
+                      (*myPtrs->currentFlowsetIdPtr)))!=NULL) {
     pftmp = tmp->lastField;
     for (; pftmp; pftmp = pftmp->prev) {
@@ -127 +106 @@
     }
     if ( data_length%flow_size >= 9 ) {
-      (*cFNPtr) = v9Ptr->count;
+      (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
       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",
-             (*cFId),
-             (pcktPtr->ipH->srcAdd>>24),
-             (pcktPtr->ipH->srcAdd<<8>>24),
-             (pcktPtr->ipH->srcAdd<<16>>24),
-             (pcktPtr->ipH->srcAdd<<24>>24));
+             (*myPtrs->currentFlowsetIdPtr),
+             (myPtrs->pcktPtr->ipH->srcAdd>>24),
+             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24),
+             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24),
+             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24));
       return (data_length+shift);
     }
 #ifdef IPV4AGG
-    agCache.routerAd = pcktPtr->ipH->srcAdd; 
+    agCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd; 
 #endif
 
 #ifdef CRIHAN
-    ipFirstCache.routerAd = pcktPtr->ipH->srcAdd;
-    mplsFirstCache.routerAd = pcktPtr->ipH->srcAdd;
+    ipFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
+    mplsFirstCache.routerAd = myPtrs->pcktPtr->ipH->srcAdd;
 #endif /* CRIHAN */
 
     pftmp = tmp->lastField;
     secondPftmp = tmp->lastField;    
-    secondOffset = *offV9;
+    secondOffset = *myPtrs->offsetV9Ptr;
     secondOldOffset = secondOffset;
-    while ( (((*offV9)-48-shift) <= data_length) && (overflow!=1) ) { 
+    while ( (((*myPtrs->offsetV9Ptr)-48-shift) <= data_length) && (overflow!=1) ) { 
       /* 
        * progression in a flow Set 
@@ -164 +143 @@
        * ... if one rule exist
        */
-      if (((RuleDefPtr)(*(rulesCache+pos))) != NULL) {
-        oldOffset = *offV9;
-        while (((RuleDefPtr)(*(rulesCache+pos))) != NULL){
+      if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL) {
+        oldOffset = *myPtrs->offsetV9Ptr;
+        while (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos))) != NULL){
           /* 
            * while on one cache table line
            */
-          *offV9 = oldOffset;
+          *myPtrs->offsetV9Ptr = oldOffset;
           switch ((int)
-                  (((RuleDefPtr)(*(rulesCache+pos)))->operator)){
+                  (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator)){
           case 2:
             switch (field_size) {
             case 1:
-              buffer1 = *(buf+(*offV9)); (*offV9)++;
+              buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
               /* rule check */
-              if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.cvalue 
+              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.cvalue 
                   == *((unsigned char*)&buffer1)) {
-                ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
               }
               /* end rule check */
@@ -220 +199 @@
               break;
             case 2:
-              buffer2[1]= *(buf+(*offV9)); (*offV9)++;
-              buffer2[0]= *(buf+(*offV9)); (*offV9)++;
-              if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.svalue 
+              buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.svalue 
                   == *((unsigned short*)&buffer2))
-                ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
 #ifdef IPV4AGG
               if (pftmp->fieldType==10){
@@ -247 +226 @@
             case 3:
               buffer4[3]= 0;
-              buffer4[2]= *(buf+(*offV9)); (*offV9)++;
-              buffer4[1]= *(buf+(*offV9)); (*offV9)++;
-              buffer4[0]= *(buf+(*offV9)); (*offV9)++;
-              if (((RuleDefPtr)(*(rulesCache+pos)))->value->stor.lvalue 
+              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue 
                   == *((unsigned long*)&buffer4))
-                ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
               /* aggregation */
               /* end aggregation */
@@ -262 +241 @@
               break;
             case 4:
-              buffer4[3]= *(buf+(*offV9)); (*offV9)++;
-              buffer4[2]= *(buf+(*offV9)); (*offV9)++;
-              buffer4[1]= *(buf+(*offV9)); (*offV9)++;
-              buffer4[0]= *(buf+(*offV9)); (*offV9)++;
+              buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+              buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
               /* FIXME : here , add a check on the field type */
               if ((pftmp->fieldType==8)||(pftmp->fieldType==12)){
-                if ((((RuleDefPtr)(*(rulesCache+pos)))->value->stor.lvalue) 
-                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask) )
+                if ((((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.lvalue) 
+                    == (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask) )
                   {
-                    ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
                   }
               }       
@@ -313 +292 @@
             case 16:
               for (i=0; i<4; i++) {
-                buffer4[3]= *(buf+(*offV9)); (*offV9)++;
-                buffer4[2]= *(buf+(*offV9)); (*offV9)++;
-                buffer4[1]= *(buf+(*offV9)); (*offV9)++;
-                buffer4[0]= *(buf+(*offV9)); (*offV9)++;
+                buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+                buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+                buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+                buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
                 if (1==moreIsNecessary){
                   switch(i){
                   case 0:
-                    if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 32){
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 32){
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
-                          (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(32-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)
+                          (*((unsigned long*)&buffer4))>>(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(32-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
                           moreIsNecessary = 0;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
                     } else {
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
                           (*((unsigned long*)&buffer4))
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
@@ -346 +325 @@
                     break;
                   case 1:
-                    if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 64){
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 64){
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
-                          (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(64-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)
+                          (*((unsigned long*)&buffer4))>>(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(64-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check =
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                           moreIsNecessary = 0;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
                     } else {
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
                           (*((unsigned long*)&buffer4))
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
@@ -374 +353 @@
                     break;
                   case 2:
-                    if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 96){
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 96){
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
-                          (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(96-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)
+                          (*((unsigned long*)&buffer4))>>(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(96-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check =
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                           moreIsNecessary = 0;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
                     } else {
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
                           (*((unsigned long*)&buffer4))
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
@@ -402 +381 @@
                     break;
                   case 3:
-                    if (((RuleDefPtr)(*(rulesCache+pos)))->value->mask <= 128){
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                    if (((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask <= 128){
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
-                          (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)<<(128-((RuleDefPtr)(*(rulesCache+pos)))->value->mask)
+                          (*((unsigned long*)&buffer4))>>(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)<<(128-((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->mask)
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check =
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check =
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
                     } else {
-                      if (ntohl(((RuleDefPtr)(*(rulesCache+pos)))->value->stor.tabAdd6[i]) 
+                      if (ntohl(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->value->stor.tabAdd6[i]) 
                           == 
                           (*((unsigned long*)&buffer4))
                           )
                         {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 
-                            ((RuleDefPtr)(*(rulesCache+pos)))->check && 1;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 
+                            ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check && 1;
                         } else {
-                          ((RuleDefPtr)(*(rulesCache+pos)))->check = 0;
+                          ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 0;
                           moreIsNecessary = 0;
                         }
@@ -441 +420 @@
               syslog(LOG_INFO, "Field size not known: %d\n", field_size); 
               for (i=0; i<field_size; i++){
-                (*offV9)++;
+                (*myPtrs->offsetV9Ptr)++;
               }
               break;
@@ -448 +427 @@
           default:
             syslog(LOG_INFO, "Operator not known: %d\n",
-                   (int)(((RuleDefPtr)(*(rulesCache+pos)))->operator));
+                   (int)(((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->operator));
             break;
           }
           j++;
           pos = (pftmp->fieldType)*10+j;
-        } /* end while rulesCache */
+        } /* end while myPtrs->rulesAddressPtr */
       } else {
         /* 
@@ -460 +439 @@
         switch (field_size) {
         case 1:
-          buffer1 = *(buf+(*offV9)); (*offV9)++;
+          buffer1 = *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
 #ifdef IPV4AGG
           if ((pftmp->fieldType==9)||(pftmp->fieldType==29)){
@@ -498 +477 @@
           break;
         case 2:
-          buffer2[1]= *(buf+(*offV9)); (*offV9)++;
-          buffer2[0]= *(buf+(*offV9)); (*offV9)++;
+          buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
 #ifdef IPV4AGG
           if (pftmp->fieldType==10){
@@ -522 +501 @@
         case 3:
           buffer4[3]= 0;
-          buffer4[2]= *(buf+(*offV9)); (*offV9)++;
-          buffer4[1]= *(buf+(*offV9)); (*offV9)++;
-          buffer4[0]= *(buf+(*offV9)); (*offV9)++;
+          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
           /* aggregation */
           /* end aggregation */
@@ -534 +513 @@
           break;
         case 4:
-          buffer4[3]= *(buf+(*offV9)); (*offV9)++;
-          buffer4[2]= *(buf+(*offV9)); (*offV9)++;
-          buffer4[1]= *(buf+(*offV9)); (*offV9)++;
-          buffer4[0]= *(buf+(*offV9)); (*offV9)++;
+          buffer4[3]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer4[2]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer4[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+          buffer4[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
 #ifdef IPV4AGG
           if ((pftmp->fieldType==8)){
@@ -575 +554 @@
         case 16:
           for (i=0; i<4; i++) {
-            buffer2[1]= *(buf+(*offV9)); (*offV9)++;
-            buffer2[0]= *(buf+(*offV9)); (*offV9)++;
-            buffer2[1]= *(buf+(*offV9)); (*offV9)++;
-            buffer2[0]= *(buf+(*offV9)); (*offV9)++;
+            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+            buffer2[1]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
+            buffer2[0]= *(myPtrs->ptr_buffer+(*myPtrs->offsetV9Ptr)); (*myPtrs->offsetV9Ptr)++;
           }
           /* aggregation IPv6 */          
@@ -586 +565 @@
           syslog(LOG_INFO,"UNKNOWN FIELDS LENGTH: %d ", field_size);
           for (i=0; i<field_size; i++){
-            (*offV9)++;
+            (*myPtrs->offsetV9Ptr)++;
           }
         }
@@ -596 +575 @@
 #ifdef CRIHAN
         if ( mplsFirstCache.mplsLabel1 == 0 ) {
-          (ipCache+(*ipCounter))->ipProt = ipFirstCache.ipProt;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->ipProt = ipFirstCache.ipProt;
           ipFirstCache.ipProt = 0;
-          (ipCache+(*ipCounter))->bytes = ipFirstCache.bytes;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->bytes = ipFirstCache.bytes;
           ipFirstCache.bytes = 0;
-          (ipCache+(*ipCounter))->pkts = ipFirstCache.pkts;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->pkts = ipFirstCache.pkts;
           ipFirstCache.pkts = 0;
-          (ipCache+(*ipCounter))->inSnmp = ipFirstCache.inSnmp;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->inSnmp = ipFirstCache.inSnmp;
           ipFirstCache.inSnmp = 0;
-          (ipCache+(*ipCounter))->outSnmp = ipFirstCache.outSnmp;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->outSnmp = ipFirstCache.outSnmp;
           ipFirstCache.outSnmp = 0;
-          (ipCache+(*ipCounter))->v4AdS = ipFirstCache.v4AdS;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdS = ipFirstCache.v4AdS;
           ipFirstCache.outSnmp = 0;
-          (ipCache+(*ipCounter))->v4AdD = ipFirstCache.v4AdD;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->v4AdD = ipFirstCache.v4AdD;
           ipFirstCache.v4AdD = 0;
-          (ipCache+(*ipCounter))->tProt = ipFirstCache.tProt;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->tProt = ipFirstCache.tProt;
           ipFirstCache.tProt = 0;
-          (ipCache+(*ipCounter))->sPort = ipFirstCache.sPort;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->sPort = ipFirstCache.sPort;
           ipFirstCache.sPort = 0;
-          (ipCache+(*ipCounter))->dPort = ipFirstCache.dPort;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->dPort = ipFirstCache.dPort;
           ipFirstCache.dPort = 0;
-          (ipCache+(*ipCounter))->maskD = ipFirstCache.maskD;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskD = ipFirstCache.maskD;
           ipFirstCache.maskD = 0;
-          (ipCache+(*ipCounter))->maskS = ipFirstCache.maskS;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->maskS = ipFirstCache.maskS;
           ipFirstCache.maskS = 0;
-          (ipCache+(*ipCounter))->routerAd = ipFirstCache.routerAd;
-          (ipCache+(*ipCounter))->liveTime = lastTime - firstTime;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->routerAd = ipFirstCache.routerAd;
+          (myPtrs->tabIPPtr+(*myPtrs->ipNbPtr))->liveTime = lastTime - firstTime;
           firstTime = 0; lastTime = 0;
-          (*ipCounter)++;
+          (*myPtrs->ipNbPtr)++;
         } else {
-          (mplsCache+(*mplsCounter))->ipProt = mplsFirstCache.ipProt;
+          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->ipProt = mplsFirstCache.ipProt;
           mplsFirstCache.ipProt = 0;
-          (mplsCache+(*mplsCounter))->v4AdS =  mplsFirstCache.v4AdS;
+          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdS =  mplsFirstCache.v4AdS;
           mplsFirstCache.v4AdS = 0;
-          (mplsCache+(*mplsCounter))->v4AdD =  mplsFirstCache.v4AdD; 
+          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->v4AdD =  mplsFirstCache.v4AdD; 
           mplsFirstCache.v4AdD = 0;
-          (mplsCache+(*mplsCounter))->routerAd =  mplsFirstCache.routerAd;
-          (mplsCache+(*mplsCounter))->mplsLabel1 =  mplsFirstCache.mplsLabel1;
+          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->routerAd =  mplsFirstCache.routerAd;
+          (myPtrs->tabMPLSPtr+(*myPtrs->mplsNbPtr))->mplsLabel1 =  mplsFirstCache.mplsLabel1;
           mplsFirstCache.mplsLabel1 = 0;
-          (*mplsCounter)++;
+          (*myPtrs->mplsNbPtr)++;
         }
 #endif 
         /* put aggregation cache information to IPv4 Prefixes table */
+        /* Aggregation mode must be enable in ./configure options   */
+        /* first we must know if the address belong to our prefix   */
 #ifdef IPV4AGG
         if (bool == 1){
@@ -643 +624 @@
           res = bsearch(&prefixKey, V4PTab, nbPV4, 
                         sizeof(struct PrefixV4), prefCmp);
-          if (res!=NULL){
-            res->bytesNb += agCache.bytes;
-            res->pktsNb += agCache.pkts;
-            res->flowNb += 1;
-            switch (agCache.ipProt) {
+          if (res!=NULL){ /* OUT ("traffic from the prefix")  */
+            res->bytesNbOUT += agCache.bytes;
+            res->pktsNbOUT += agCache.pkts;
+            (res->flowNbOUT)++;
+            switch (agCache.tProt) {
             case 1:
-              res->icmpBytesNb += agCache.bytes;
-              res->icmpPktsNb += agCache.pkts;
-              res->icmpFlowNb += 1;
+              res->icmpBytesNbOUT += agCache.bytes;
+              res->icmpPktsNbOUT += agCache.pkts;
+              (res->icmpFlowNbOUT)++;
               break;
             case 6:
-              res->tcpBytesNb += agCache.bytes;
-              res->tcpPktsNb += agCache.pkts;
-              res->tcpFlowNb += 1;            
+              res->tcpBytesNbOUT += agCache.bytes;
+              res->tcpPktsNbOUT += agCache.pkts;
+              (res->tcpFlowNbOUT)++;          
               break;
             case 17:
-              res->udpBytesNb += agCache.bytes;
-              res->udpPktsNb += agCache.pkts;
-              res->udpFlowNb += 1;
+              res->udpBytesNbOUT += agCache.bytes;
+              res->udpPktsNbOUT += agCache.pkts;
+              (res->udpFlowNbOUT)++;
               break;
             default:
-              res->othersBytesNb += agCache.bytes;
-              res->othersPktsNb += agCache.pkts;
-              res->othersFlowNb += 1;         
+              res->othersBytesNbOUT += agCache.bytes;
+              res->othersPktsNbOUT += agCache.pkts;
+              (res->othersFlowNbOUT)++;
             }
-          }
-/*        if (res==NULL){ */
-/*          fprintf(stderr, "IPv4_spoofing? ");  */
-/*        } */
+          } else {
+            prefixKey.beginning = agCache.v4AdD>>(32-agCache.maskD)<<(32-agCache.maskD);
+            res = bsearch(&prefixKey, V4PTab, nbPV4, 
+                          sizeof(struct PrefixV4), prefCmp);
+            if (res!=NULL){ /* IN ("traffic to the prefix")  */
+              res->bytesNbIN += agCache.bytes;
+              res->pktsNbIN += agCache.pkts;
+              (res->flowNbIN)++;
+              switch (agCache.tProt) {
+              case 1:
+                res->icmpBytesNbIN += agCache.bytes;
+                res->icmpPktsNbIN += agCache.pkts;
+                (res->icmpFlowNbIN)++;
+                break;
+              case 6:
+                res->tcpBytesNbIN += agCache.bytes;
+                res->tcpPktsNbIN += agCache.pkts;
+                (res->tcpFlowNbIN)++;
+                break;
+              case 17:
+                res->udpBytesNbIN += agCache.bytes;
+                res->udpPktsNbIN += agCache.pkts;
+                (res->udpFlowNbIN)++;
+                break;
+              default:
+                res->othersBytesNbIN += agCache.bytes;
+                res->othersPktsNbIN += agCache.pkts;
+                (res->othersFlowNbIN)++;
+              }
+            } else {
+              /* HERE : we are in the cases of the address/mask don't      */
+              /*        belong to a prefix listed in the IPv4 prefix file  */
+              /* possibilities :                                           */
+              /*     -  prefix not referenced but allowed to be routed     */
+              /*     -  prefix not referenced but not allowed to be routed */
+              /*     -  spoofing                                           */
+/*            fprintf(stderr, "%lu.%lu.%lu.%lu/%hu -> %lu.%lu.%lu.%lu/%hu R:%lu.%lu.%lu.%lu \n", */
+/*                    (agCache.v4AdS>>24), */
+/*                    (agCache.v4AdS<<8>>24),  */
+/*                    (agCache.v4AdS<<16>>24),  */
+/*                    (agCache.v4AdS<<24>>24),  */
+/*                    (agCache.maskS),  */
+/*                    (agCache.v4AdD>>24),  */
+/*                    (agCache.v4AdD<<8>>24),  */
+/*                    (agCache.v4AdD<<16>>24),  */
+/*                    (agCache.v4AdD<<24>>24),  */
+/*                    (agCache.maskD),  */
+/*                    (myPtrs->pcktPtr->ipH->srcAdd>>24),  */
+/*                    (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), */
+/*                    (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), */
+/*                    (myPtrs->pcktPtr->ipH->srcAdd<<24>>24) */
+/*                    ); */
+            }
+          }
         }
         bool = 0;
@@ -680 +711 @@
          * we send the flow or a part of the flow to a remote host or a file
          */
-        tmpRuleList = rlPtr;
+        tmpRuleList = myPtrs->rulesListPtr;
         while (tmpRuleList){
           unsigned short check = 1;
@@ -693 +724 @@
             /* msg building */
             secondPftmp = tmp->lastField;
-/*          memcpy(myMsg.text, (char*)(buf+secondOffset),flow_size); */
+/*          memcpy(myMsg.text, (char*)(myPtrs->ptr_buffer+secondOffset),flow_size); */
             msgTextIndex = mempcpy(mempcpy(mempcpy(myMsg.text, 
                                                    &tplMsgType, 
@@ -701 +732 @@
                                            sizeof(tmpRuleList->id)
                                            ),
-                                   &cr->IpAddress, 
+                                   &myPtrs->currentRouterPtr->IpAddress, 
                                    sizeof(unsigned long) 
                                    );
@@ -711 +742 @@
                                            sizeof(tmp->templateFlowSetId) 
                                            ), 
-                                   buf+secondOffset, 
+                                   myPtrs->ptr_buffer+secondOffset, 
                                    flow_size
                                    ); 
@@ -725 +756 @@
          * end redirection 
          */
-        secondOffset = *offV9;
+        secondOffset = *myPtrs->offsetV9Ptr;
         secondOldOffset = secondOffset;
         pftmp = tmp->lastField;
         cpt=0;
-        (*cFNPtr)++; /* pointer on the flows number */
-        if (((*offV9)-48-shift+flow_size) > data_length){
+        (*myPtrs->currentFlowsetNumberPtr)++; /* pointer on the flows number */
+        if (((*myPtrs->offsetV9Ptr)-48-shift+flow_size) > data_length){
           overflow = 1; /* buffer index not correct */
         }
@@ -742 +773 @@
      * template unknown, we skip this all the data 
      */
-    (*offV9)+=(data_length-4);
-    (*cFNPtr) = v9Ptr->count;
+    (*myPtrs->offsetV9Ptr)+=(data_length-4);
+    (*myPtrs->currentFlowsetNumberPtr) = myPtrs->currentHeaderV9Ptr->count;
   }
-  while ( ((*offV9)-48-shift) < data_length ) {
-    (*offV9)++; /* if padding */
+  while ( ((*myPtrs->offsetV9Ptr)-48-shift) < data_length ) {
+    (*myPtrs->offsetV9Ptr)++; /* if padding */
   }
-  while ( (*offV9)-48-shift > data_length ) { 
-    (*offV9)--; /* crazy loop (when bug appears in template def) */
+  while ( (*myPtrs->offsetV9Ptr)-48-shift > data_length ) { 
+    (*myPtrs->offsetV9Ptr)--; /* crazy loop (when bug appears in template def) */
   }
   return (data_length+shift);

trunk/src/dataFlowSet.h

@@ -86 +86 @@
 };
 
+struct MyPtrs {
+  RouterPtr currentRouterPtr;
+  NetFlowV9HeaderPtr currentHeaderV9Ptr;
+  unsigned short *offsetV9Ptr;
+  unsigned char *ptr_buffer;
+  short *currentFlowsetNumberPtr;
+  short *currentFlowsetIdPtr;
+  DatagramPtr pcktPtr;
+  RuleDefPtr *rulesAddressPtr;
+  RulesPtr rulesListPtr;                             /* Rules list */
+  struct IPFLowCache *tabIPPtr;
+  struct MPLSFlowCache *tabMPLSPtr;
+  unsigned long *ipNbPtr;
+  unsigned long *mplsNbPtr;
+};
+
 unsigned short 
-checkDataFlowSet(unsigned short, RouterPtr, NetFlowV9HeaderPtr,
-                 unsigned short *, unsigned char *, short *,
-                 short *, DatagramPtr, RuleDefPtr *, RulesPtr, int,
-                 struct PrefixV4 *, size_t, 
-                 struct IPFLowCache *, struct MPLSFlowCache *,
-                 unsigned long *, unsigned long *);
+checkDataFlowSet(unsigned short, 
+                 struct MyPtrs *,
+                 int,
+                 struct PrefixV4 *, size_t
+                 );
 
 #endif /* DATAFLOWSET_H */

trunk/src/fields_mgmt.c

@@ -31 +31 @@
  * print_fields_set
  */
-void printFieldSet(FieldPtr pf)
+void printFieldSet(FILE *file, FieldPtr pf)
 {
   FieldPtr tmp = pf;
   for (; tmp; tmp=tmp->next) {
-    fprintf(stderr, "(%hu,%hu) ", tmp->fieldType, tmp->fieldLength);
+    fprintf(file, "(%hu,%hu) ", tmp->fieldType, tmp->fieldLength);
   }
-  fprintf(stderr,"\n");
+  fprintf(file,"\n");
 }
 

trunk/src/fields_mgmt.h

@@ -26 +26 @@
 #define FIELDS_MGMT_H
 
+#include <stdio.h>
+
 typedef struct Field * FieldPtr;
 typedef struct Field {
@@ -36 +38 @@
 FieldPtr addField (FieldPtr, unsigned short, unsigned short);
 int delField(unsigned short, unsigned short);
-void printFieldSet(FieldPtr);
+void printFieldSet(FILE *, FieldPtr);
 void invPrintFieldSet(FieldPtr);
 void freeField(FieldPtr);

trunk/src/get_conf.c

@@ -172 +172 @@
       pV4TabPtr[i].mask = n4;
       pV4TabPtr[i].routerNb = n5;
-      pV4TabPtr[i].flowNb = 0;
-      pV4TabPtr[i].bytesNb = 0;
-      pV4TabPtr[i].pktsNb = 0;
-      pV4TabPtr[i].udpPktsNb = 0;
-      pV4TabPtr[i].tcpPktsNb = 0;
-      pV4TabPtr[i].icmpPktsNb = 0;
-      pV4TabPtr[i].othersPktsNb = 0;
-      pV4TabPtr[i].udpBytesNb = 0;
-      pV4TabPtr[i].tcpBytesNb = 0;
-      pV4TabPtr[i].icmpBytesNb = 0;
-      pV4TabPtr[i].othersBytesNb = 0;
+      pV4TabPtr[i].flowNbIN = 0;
+      pV4TabPtr[i].bytesNbIN = 0;
+      pV4TabPtr[i].pktsNbIN = 0;
+      pV4TabPtr[i].udpPktsNbIN = 0;
+      pV4TabPtr[i].tcpPktsNbIN = 0;
+      pV4TabPtr[i].icmpPktsNbIN = 0;
+      pV4TabPtr[i].othersPktsNbIN = 0;
+      pV4TabPtr[i].udpBytesNbIN = 0;
+      pV4TabPtr[i].tcpBytesNbIN = 0;
+      pV4TabPtr[i].icmpBytesNbIN = 0;
+      pV4TabPtr[i].othersBytesNbIN = 0;
+      pV4TabPtr[i].udpFlowNbIN = 0;
+      pV4TabPtr[i].tcpFlowNbIN = 0;
+      pV4TabPtr[i].icmpFlowNbIN = 0;
+      pV4TabPtr[i].othersFlowNbIN = 0;
+      pV4TabPtr[i].flowNbOUT = 0;
+      pV4TabPtr[i].bytesNbOUT = 0;
+      pV4TabPtr[i].pktsNbOUT = 0;
+      pV4TabPtr[i].udpPktsNbOUT = 0;
+      pV4TabPtr[i].tcpPktsNbOUT = 0;
+      pV4TabPtr[i].icmpPktsNbOUT = 0;
+      pV4TabPtr[i].othersPktsNbOUT = 0;
+      pV4TabPtr[i].udpBytesNbOUT = 0;
+      pV4TabPtr[i].tcpBytesNbOUT = 0;
+      pV4TabPtr[i].icmpBytesNbOUT = 0;
+      pV4TabPtr[i].othersBytesNbOUT = 0;
+      pV4TabPtr[i].udpFlowNbOUT = 0;
+      pV4TabPtr[i].tcpFlowNbOUT = 0;
+      pV4TabPtr[i].icmpFlowNbOUT = 0;
+      pV4TabPtr[i].othersFlowNbOUT = 0;
     }
   if( fclose(prefixFile) == 0) {

trunk/src/get_conf.h

@@ -33 +33 @@
   unsigned short mask;     /* prefix mask  */
   unsigned short routerNb; /* router ID */
-  unsigned long long flowNb; /* flow number accounting */
-  unsigned long long bytesNb; /* bytes number accounting */
-  unsigned long long pktsNb; /* packets number accounting */
-  unsigned long long udpPktsNb;
-  unsigned long long tcpPktsNb;
-  unsigned long long icmpPktsNb;
-  unsigned long long othersPktsNb;
-  unsigned long long udpBytesNb;
-  unsigned long long tcpBytesNb;
-  unsigned long long icmpBytesNb;
-  unsigned long long othersBytesNb;
-  unsigned long long udpFlowNb;
-  unsigned long long tcpFlowNb;
-  unsigned long long icmpFlowNb;
-  unsigned long long othersFlowNb;
+  unsigned long long flowNbIN; 
+  unsigned long long bytesNbIN; 
+  unsigned long long pktsNbIN; 
+  unsigned long long udpPktsNbIN;   /* WARNING !!! */
+  unsigned long long tcpPktsNbIN;   /* Here, IN means "to the prefix" */
+  unsigned long long icmpPktsNbIN;  /* or "prefix in destination address */
+  unsigned long long othersPktsNbIN;
+  unsigned long long udpBytesNbIN;
+  unsigned long long tcpBytesNbIN;
+  unsigned long long icmpBytesNbIN;
+  unsigned long long othersBytesNbIN;
+  unsigned long long udpFlowNbIN;
+  unsigned long long tcpFlowNbIN;
+  unsigned long long icmpFlowNbIN;
+  unsigned long long othersFlowNbIN;
+  unsigned long long flowNbOUT;  /* WARNING !!! */
+  unsigned long long bytesNbOUT;  /* Here, OUT means "from the prefix" */
+  unsigned long long pktsNbOUT;  /* or "prefix in source address */
+  unsigned long long udpPktsNbOUT;
+  unsigned long long tcpPktsNbOUT;
+  unsigned long long icmpPktsNbOUT;
+  unsigned long long othersPktsNbOUT;
+  unsigned long long udpBytesNbOUT;
+  unsigned long long tcpBytesNbOUT;
+  unsigned long long icmpBytesNbOUT;
+  unsigned long long othersBytesNbOUT;
+  unsigned long long udpFlowNbOUT;
+  unsigned long long tcpFlowNbOUT;
+  unsigned long long icmpFlowNbOUT;
+  unsigned long long othersFlowNbOUT;
 };
 

trunk/src/renetcol.c

@@ -26 +26 @@
 #include "renetcol.h"
 
-/* #ifdef CRIHAN */
-struct IPFLowCache tabIP[MAX_IP_FLOW], *tabIPPtr = tabIP;
-struct MPLSFlowCache tabMPLS[MAX_MPLS_FLOW], *tabMPLSPtr = tabMPLS;
-unsigned long ipNb = 0; /* counter of IP flows number */
-unsigned long mplsNb = 0; /* counter of MPLS flow number */
-unsigned long *ipNbPtr = &ipNb;
-unsigned long *mplsNbPtr = &mplsNb;
-unsigned short currentIPOutputFile = 0; /* index on the current IP file */
-unsigned short currentMPLSOutputFile = 0; /* index on the current MPLS file */
+struct MyPtrs myPtrs; /* defined in dataflowset.h */
+
+struct IPFLowCache tabIP[MAX_IP_FLOW];
+struct MPLSFlowCache tabMPLS[MAX_MPLS_FLOW];
+unsigned long ipNb = 0;                     /* counter of IP flows number */
+unsigned long mplsNb = 0;                   /* counter of MPLS flow number */
+
+unsigned short currentIPOutputFile = 0;    /* index on the current IP file */
+unsigned short currentMPLSOutputFile = 0;  /* index on the current MPLS file */
 char outputName[256];
-char cof_str[20]; /* current ouput file name */
-FILE *fIP; /* pointer on the IP output file */
-FILE *fMPLS; /* pointer on the MPLS output file */
-/* #endif */
-
-char *rulesFileName; /* file name of the rules (like acl) */
-char *configFileName;  /* file name where routers list is */
-char *prefixV4FileName;  /* IPv4 prefix list */
+char cof_str[20];                          /* current ouput file name */
+FILE *fIP;                                 /* pointer on the IP output file */
+FILE *fMPLS;                              /* pointer on the MPLS output file */
+
+char *rulesFileName;                    /* file name of the rules (like acl) */
+char *configFileName;                   /* file name where routers list is */
+char *prefixV4FileName;                 /* IPv4 prefix list */
 
 struct sigaction myAction; /* handler for renetcolSender communication */
@@ -50 +49 @@
 /* struct sigaction myAction;  for timer not used in this version */
 
-unsigned short currentIntervalle = 0; /* based on 5 min intervalles */ 
-
-unsigned short offsetV9 = 0; /* index in a neflow v9 packet */
-unsigned short *offsetV9Ptr = &offsetV9;
+unsigned short currentIntervalle = 0;        /* based on 5 min intervalles */ 
+
+unsigned short offsetV9 = 0;                 /* index in a neflow v9 packet */
 
 unsigned char buffer1;
@@ -61 +59 @@
 
 short currentFlowsetNumber;
-short *currentFlowsetNumberPtr = &currentFlowsetNumber;
 short currentFlowsetId;
-short *currentFlowsetIdPtr = &currentFlowsetId;
 TplFlowSetPtr curTplFlSetPtr; /* current template flowset pointer */
 TplOptionPtr curTplOptionPtr;
-RouterPtr routersListPtr;
-RouterPtr currentRouterPtr;
-DatagramPtr pcktPtr;
+RouterPtr routersListPtr; 
+
 unsigned long sortedRouterList[ROUTER_INDEX_MAX];
 unsigned long indexedRouterList[ROUTER_INDEX_MAX];
-int routerNb = 0; /* routers number */
-unsigned short v4PrefixNb = 0; /* IPv4 prefix number */
-struct PrefixV4 prefixV4Tab[MAX_IPV4_PREFIX]; /* IPv4 prefix structure */
-RulesPtr rulesListPtr; /* Rules list */
-NetFlowV9HeaderPtr currentHeaderV9Ptr;
+int routerNb = 0;                                  /* routers number */
+unsigned short v4PrefixNb = 0;                     /* IPv4 prefix number */
+struct PrefixV4 prefixV4Tab[2][MAX_IPV4_PREFIX];      /* IPv4 prefix structure */
+unsigned short indexForShmTable = 0;
+
 key_t myKey = 0; /* FIXME to delete in futur */
 int myQueue = 0; /* FIXME to delete in futur */
@@ -81 +76 @@
 /* Next structure used as cache in rules reading */
 RuleDefPtr rulesAddress[FIELD_TYPE_NUMBER+1][MAX_RULES_PER_FIELD]; 
-RuleDefPtr *rulesAddressPtr;
 
 int reInitConf = 0;
-
-static unsigned long datagramNumber;
 
 static time_t lastRock;
 static struct tm *tmPtr;
 
-static unsigned long myHost; /* FIXME to erase */
 extern int errno;
 static int inputSock;
@@ -100 +91 @@
 /* static unsigned short flowNumber; */
 static unsigned short receptPort = RECEPTION_PORT;
-static unsigned char *ptr_buffer;
+/* static unsigned char *ptr_buffer; */
 static char *receptAddress = RECEPTION_ADDRESS;
 static struct sockaddr_in name;
@@ -139 +130 @@
 
   initCache();
-  fprintf(stderr, "reading the routers list\n");
+  fprintf(stderr, "renetcol: reading the routers list...\n");
   routerNb = getRegisteredRouters(configFileName, &sortedRouterList[0], 
                                   &indexedRouterList[0]);
-  fprintf(stderr, "reading the IPv4 prefix\n");
+  fprintf(stderr, "renetcol: OK\n");
+  fprintf(stderr, "renetcol: reading the IPv4 prefix...\n");
   if ( (v4PrefixNb = getPrefixV4(prefixV4FileName, &prefixV4Tab[0])) < 1){
-    fprintf(stderr, "Error during prefix v4 reading\n");
+    fprintf(stderr, "renetcol:  Error \n");
     exit(1);
-  }
-  rulesListPtr = NULL;
-  fprintf(stderr, "reading the rules\n");
-  rulesListPtr = getLightRules(rulesListPtr, rulesFileName);
-  tmp = rulesListPtr;
+  } else {
+    fprintf(stderr, "renetcol:  OK \n");
+  }
+  myPtrs.rulesListPtr = NULL;
+  fprintf(stderr, "renetcol: reading the rules...\n");
+  myPtrs.rulesListPtr = getLightRules(myPtrs.rulesListPtr, rulesFileName);
+  fprintf(stderr, "renetcol : OK \n");
+  tmp = myPtrs.rulesListPtr;
   for ( ; tmp->next; tmp=tmp->next) {
     if (tmp->type != 2) {
-      rulesListPtr = delRule(tmp, rulesListPtr);
+      myPtrs.rulesListPtr = delRule(tmp, myPtrs.rulesListPtr);
     }
   }
@@ -159 +154 @@
 /*   exit(1); */
 
-  fprintf(stderr, "I become a deamon, next messages via syslogd.\n");
+  fprintf(stderr, "renetcol: I become a deamon, next messages via syslogd. By.\n");
   if (fork () != 0)
     exit (0);
@@ -174 +169 @@
 
   /* Pointer on rules Table */
-  setCache(rulesListPtr);
-  rulesAddressPtr = (RuleDefPtr *)rulesAddress;
+  setCache(myPtrs.rulesListPtr);
+  myPtrs.rulesAddressPtr = (RuleDefPtr *)rulesAddress;
 
   /* init IPC messages queue */
@@ -183 +178 @@
 
   /* INIT THE CURRENTS VARIABLES*/
-  currentRouterPtr = routersListPtr;
-  currentHeaderV9Ptr = (NetFlowV9HeaderPtr)
+  myPtrs.currentRouterPtr = routersListPtr;
+  myPtrs.currentHeaderV9Ptr = (NetFlowV9HeaderPtr)
     malloc(sizeof(struct NetFlowV9Header));
-  pcktPtr = (DatagramPtr) malloc(sizeof(struct Datagram));
-  if (pcktPtr==NULL) {
+  myPtrs.offsetV9Ptr = &offsetV9;
+  myPtrs.currentFlowsetIdPtr = &currentFlowsetId;
+  myPtrs.pcktPtr = (DatagramPtr) malloc(sizeof(struct Datagram));
+  myPtrs.currentFlowsetNumberPtr = &currentFlowsetNumber;
+  myPtrs.ipNbPtr =  &ipNb;
+  myPtrs.mplsNbPtr =  &mplsNb;
+  
+  if (myPtrs.pcktPtr==NULL) {
     fprintf(stderr, "ERROR in struct Datagram allocation\n");
     exit(1);
   } else {
-    pcktPtr->ipH = (IpHeaderPtr) malloc(sizeof(struct IpHeader));
-    pcktPtr->udp_header = (UdpHeaderPtr) malloc(sizeof(struct UdpHeader));
-  }
-
-  if (! (ptr_buffer = malloc(sockBufSize)))  
+    myPtrs.pcktPtr->ipH = (IpHeaderPtr) malloc(sizeof(struct IpHeader));
+    myPtrs.pcktPtr->udp_header = (UdpHeaderPtr) malloc(sizeof(struct UdpHeader));
+  }
+
+  if (! (myPtrs.ptr_buffer = malloc(sockBufSize)))  
     {
       printf("ERROR during socket buffer allocation\n");
@@ -204 +205 @@
   initStream();
 
-  datagramNumber =0; /* FIXME : ???? */
-
   socketLoop(); /* all work on datagram is made here */
+
   closelog();
+
   fprintf(stderr, "END\n");
+
   return (0);
 }
 
 /*
- *
- */
-void sendMyPid(int queueID)
+ * send his PID to another program via IPC message queue
+ *
+ * @param queueID the IPC queue ident
+ *
+ */
+void 
+sendMyPid(int queueID)
 {
   msgType myMsg;
@@ -235 +241 @@
 
 /*
+ * Send the "read rules list" message to another program
+ *
+ * @param queueID the IPC queue ident
  *
  */
@@ -252 +261 @@
 
 /*
- *
- */
-void sigusr1Mgmt(int num)
+ * 
+ */
+void 
+sigusr1Mgmt(int num)
 {
   sigusr1Up = 1;
@@ -260 +270 @@
 
 /*
- *
+ * init the rule structure
  */
 void 
@@ -267 +277 @@
   RulesPtr tmp = NULL;
   initCache();
-  tmp = rulesListPtr;
+  tmp = myPtrs.rulesListPtr;
   for ( ; tmp; tmp=tmp->next) {
-    rulesListPtr = delRule(tmp, rulesListPtr);
-  }
-  rulesListPtr = NULL;
-  rulesListPtr = getLightRules(rulesListPtr, rulesFileName);
-  tmp = rulesListPtr;
+    myPtrs.rulesListPtr = delRule(tmp, myPtrs.rulesListPtr);
+  }
+  myPtrs.rulesListPtr = NULL;
+  myPtrs.rulesListPtr = getLightRules(myPtrs.rulesListPtr, rulesFileName);
+  tmp = myPtrs.rulesListPtr;
   for ( ; tmp; tmp=tmp->next) {
     if (tmp->type != 2) {
-      rulesListPtr = delRule(tmp, rulesListPtr);
+      myPtrs.rulesListPtr = delRule(tmp, myPtrs.rulesListPtr);
     }
   }
   tmp = NULL;
   initCache();
-  setCache(rulesListPtr);
+  setCache(myPtrs.rulesListPtr);
   sendReadRulesSignal(myQueue);
 }
 
 /*
- *
+ * init cache table
  */
 void
@@ -339 +349 @@
   buffer4[2] = (unsigned char)n1;
   buffer4[3] = (unsigned char)n0;
-  myHost = *((unsigned long*)&buffer4[0]);
 }
 
@@ -353 +362 @@
   time_t now = time((time_t *)NULL);
   int iIP, iMPLS, i;
+  int loopNb = 0;
   time_t lastIPOutput, lastMPLSOutput;
   time_t receptionTime;
@@ -371 +381 @@
     } 
     socketReading();
-    getIpHeader(pcktPtr, ptr_buffer);
-    regRouter = checkIpHeader(pcktPtr, &sortedRouterList[0], routerNb);
-    getUdpHeader(pcktPtr, ptr_buffer);
-    checkUdpHeader(pcktPtr, regRouter, receptPort);
+    getIpHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer);
+    regRouter = checkIpHeader(myPtrs.pcktPtr, &sortedRouterList[0], routerNb);
+    getUdpHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer);
+    if ( checkUdpHeader(myPtrs.pcktPtr, regRouter, receptPort) == 1 ){
+      continue;
+    }
     
     switch( version = 
-            getNetFlowHeader(pcktPtr, ptr_buffer, 
-                             currentHeaderV9Ptr, offsetV9Ptr)){
+            getNetFlowHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer, 
+                             myPtrs.currentHeaderV9Ptr, myPtrs.offsetV9Ptr)){
     case 9:
-      if ((currentRouterPtr=notExistRouter(routersListPtr, 
-                                           pcktPtr->ipH->srcAdd))==NULL) {
+      if ((myPtrs.currentRouterPtr=notExistRouter(routersListPtr, 
+                                                  myPtrs.pcktPtr->ipH->srcAdd))==NULL) {
         routersListPtr = addRouter(routersListPtr, 
-                                   pcktPtr->ipH->srcAdd, 
+                                   myPtrs.pcktPtr->ipH->srcAdd, 
                                    (unsigned long) 0);
-        currentRouterPtr = routersListPtr;
+        myPtrs.currentRouterPtr = routersListPtr;
       }
       currentFlowsetNumber = 0;
       shift = 0;
-      while ((currentFlowsetNumber < currentHeaderV9Ptr->count)) {
+      while ((currentFlowsetNumber < myPtrs.currentHeaderV9Ptr->count)) {
         curTplFlSetPtr = NULL;
         currentFlowsetId=getFlowsetId(currentFlowsetNumber, 
-                                      offsetV9Ptr, ptr_buffer);
+                                      myPtrs.offsetV9Ptr, myPtrs.ptr_buffer);
         if ( currentFlowsetId == 0 ) {
-          shift = checkTemplateFlowSet(currentRouterPtr, offsetV9Ptr, 
-                                       ptr_buffer, currentHeaderV9Ptr,
+          shift = checkTemplateFlowSet(myPtrs.currentRouterPtr, myPtrs.offsetV9Ptr, 
+                                       myPtrs.ptr_buffer, myPtrs.currentHeaderV9Ptr,
                                        curTplFlSetPtr,
-                                       currentFlowsetNumberPtr,
+                                       myPtrs.currentFlowsetNumberPtr,
                                        myQueue);
-          /* FIXME : TplFlSet Def in a file before next release */
-          /* showAllTplFlSet(); */
         } else if (currentFlowsetId == 1) {
-          shift = checkTemplateOption(currentRouterPtr, offsetV9Ptr, 
-                                      ptr_buffer, currentHeaderV9Ptr,
+          shift = checkTemplateOption(myPtrs.currentRouterPtr, myPtrs.offsetV9Ptr, 
+                                      myPtrs.ptr_buffer, myPtrs.currentHeaderV9Ptr,
                                       curTplOptionPtr,
-                                      currentFlowsetNumberPtr);
+                                      myPtrs.currentFlowsetNumberPtr);
         } else {
-          shift = checkDataFlowSet(shift, currentRouterPtr,
-                                   currentHeaderV9Ptr, offsetV9Ptr,
-                                   ptr_buffer, currentFlowsetNumberPtr,
-                                   currentFlowsetIdPtr, pcktPtr,
-                                   rulesAddressPtr, rulesListPtr,
-                                   myQueue, prefixV4Tab,
-                                   (size_t) v4PrefixNb,
-                                   tabIPPtr, 
-                                   tabMPLSPtr, 
-                                   ipNbPtr, mplsNbPtr);
+          shift = checkDataFlowSet(shift,
+                                   &myPtrs,
+                                   myQueue, 
+                                   prefixV4Tab,
+                                   (size_t) v4PrefixNb
+                                   );
         }
-      }
+      } /* end while flowset exist */
       break;
     default:
-      /* FIXME : Uncomment before next release */
-/*        syslog(LOG_INFO,  */
-/*           "NetFlow exp. version unknown: %hu, from router: %lu.%lu.%lu.%lu", */
-/*           (unsigned short) version, */
-/*           (pcktPtr->ipH->srcAdd>>24), */
-/*           (pcktPtr->ipH->srcAdd<<8>>24), */
-/*           (pcktPtr->ipH->srcAdd<<16>>24), */
-/*           (pcktPtr->ipH->srcAdd<<24>>24));  */
+      syslog(LOG_INFO, 
+             "NetFlow exp. version unknown: %hu, from router: %lu.%lu.%lu.%lu",
+             (unsigned short) version,
+             (myPtrs.pcktPtr->ipH->srcAdd>>24),
+             (myPtrs.pcktPtr->ipH->srcAdd<<8>>24),
+             (myPtrs.pcktPtr->ipH->srcAdd<<16>>24),
+             (myPtrs.pcktPtr->ipH->srcAdd<<24>>24)); 
       break;
     }
-/*     for (i=0; i<v4PrefixNb; i++){ */
-/*       fprintf(stderr, "%lu %llu flows\n", */
-/*            prefixV4Tab[i].beginning, */
-/*            prefixV4Tab[i].flowNb); */
-/*     } */
+    if (loopNb  > 100 ){
+      /* FIXME perhaps call this function via the compilation options */
+      writeAllTplFlSet();
+      for (i=0; i<v4PrefixNb; i++){
+        fprintf(stderr, "%lu \n %llu flows,\t %llu bytes,\t %llu pkts\n Pkts (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n Bytes (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n Flows (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n \n %llu flows,\t %llu bytes,\t %llu pkts\n Pkts (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n Bytes (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n Flows (udp tcp icmp others): %llu \t %llu \t %llu \t %llu\n \n",
+                prefixV4Tab[i].beginning,
+                prefixV4Tab[i].flowNbIN,
+                prefixV4Tab[i].bytesNbIN,
+                prefixV4Tab[i].pktsNbIN,
+                prefixV4Tab[i].udpPktsNbIN,
+                prefixV4Tab[i].tcpPktsNbIN,
+                prefixV4Tab[i].icmpPktsNbIN,
+                prefixV4Tab[i].othersPktsNbIN,
+                prefixV4Tab[i].udpBytesNbIN,
+                prefixV4Tab[i].tcpBytesNbIN,
+                prefixV4Tab[i].icmpBytesNbIN,
+                prefixV4Tab[i].othersBytesNbIN,
+                prefixV4Tab[i].udpFlowNbIN,
+                prefixV4Tab[i].tcpFlowNbIN,
+                prefixV4Tab[i].icmpFlowNbIN,
+                prefixV4Tab[i].othersFlowNbIN,
+                prefixV4Tab[i].flowNbOUT,
+                prefixV4Tab[i].bytesNbOUT,
+                prefixV4Tab[i].pktsNbOUT,
+                prefixV4Tab[i].udpPktsNbOUT,
+                prefixV4Tab[i].tcpPktsNbOUT,
+                prefixV4Tab[i].icmpPktsNbOUT,
+                prefixV4Tab[i].othersPktsNbOUT,
+                prefixV4Tab[i].udpBytesNbOUT,
+                prefixV4Tab[i].tcpBytesNbOUT,
+                prefixV4Tab[i].icmpBytesNbOUT,
+                prefixV4Tab[i].othersBytesNbOUT,
+                prefixV4Tab[i].udpFlowNbOUT,
+                prefixV4Tab[i].tcpFlowNbOUT,
+                prefixV4Tab[i].icmpFlowNbOUT,
+                prefixV4Tab[i].othersFlowNbOUT
+                );
+      }
+      loopNb = 0;
+    }
+    loopNb++;
 
 #ifdef CRIHAN
@@ -558 +599 @@
     }
   /* Here socket DGRAM creation, only to not have a unreachable service */
+  /* message in return */
   inputSock2 = socket(AF_INET, SOCK_DGRAM, 0); 
   if (inputSock2 < 0)
@@ -597 +639 @@
 
   sockNameFromlg = sizeof(fromName);
-  rcv = recvfrom(inputSock, ptr_buffer, sockBufSize, 0,
+  rcv = recvfrom(inputSock, myPtrs.ptr_buffer, sockBufSize, 0,
                  (struct sockaddr *)(&fromName),
                  (socklen_t *)&sockNameFromlg);   
@@ -613 +655 @@
  
 /* 
- * check up flow datagramme 
+ * check up flow datagramme  
  */
 short 
 checkFlow(short flowNumber)
 {
-  return(0);
+  return(0); /* FIXME : why this function ??? */
 }
 
@@ -624 +666 @@
  * showAllTplFlSet
  *
+ * to use only in debug mode
  */
 void 
@@ -643 +686 @@
               tmpFS->templateFlowSetId,
               tmpFS->sourceId);
-      printFieldSet(tmpFS->fieldSet);
+      printFieldSet(stderr, tmpFS->fieldSet);
       fprintf(stderr,"\n");
     }
@@ -651 +694 @@
                 tmpOP->templateOptionId,
                 tmpOP->sourceId);
-        printFieldSet(tmpOP->fieldSet);
+        printFieldSet(stderr, tmpOP->fieldSet);
         fprintf(stderr,"\n");
       }
@@ -658 +701 @@
   }
 }
+
+
+/* 
+ * writeAllTplFlSet
+ *
+ */
+void 
+writeAllTplFlSet()
+{
+
+  RouterPtr tmp = routersListPtr;
+  TplFlowSetPtr tmpFS;
+  TplOptionPtr tmpOP;
+  FILE *TPLFILE;
+  if (!(TPLFILE = fopen("/tmp/TemplateDef.txt", "w"))) {
+    syslog (LOG_ERR, "error during %s opening", "/tmp/TemplateDef.txt");
+  }
+  fprintf(TPLFILE,"\n*********************************************\n* All template definitions: (field, size) : *\n*********************************************\n");
+  for (; tmp; tmp=tmp->next) {
+    fprintf(TPLFILE,"----------------------\nrouter %lu.%lu.%lu.%lu : \n----------------------\n",
+            (tmp->IpAddress>>24),
+            (tmp->IpAddress<<8>>24),
+            (tmp->IpAddress<<16>>24),
+            (tmp->IpAddress<<24>>24));
+    tmpFS =  tmp->tplList;
+    for (; tmpFS; tmpFS=tmpFS->next) {
+      fprintf(TPLFILE,"TId %hu (sourceId: %lu):\n", 
+              tmpFS->templateFlowSetId,
+              tmpFS->sourceId);
+      printFieldSet(TPLFILE, tmpFS->fieldSet);
+      fprintf(TPLFILE,"\n");
+    }
+    if ((tmpOP = tmp->tplOptList) != NULL){
+      for (; tmpOP; tmpOP=tmpOP->next) {
+        fprintf(TPLFILE,"OpTId %hu (sourceId: %lu) >\n", 
+                tmpOP->templateOptionId,
+                tmpOP->sourceId);
+        printFieldSet(TPLFILE, tmpOP->fieldSet);
+        fprintf(TPLFILE,"\n");
+      }
+      fprintf(TPLFILE,"\n");
+    }
+  }
+  fclose(TPLFILE);
+}

trunk/src/renetcol.h

@@ -82 +82 @@
 #define MPLS_TIME_THRESHOLD 60 /* in sec */
 #endif /* CRIHAN */
+
 #define MAX_IP_FLOW 10000
 #define MAX_MPLS_FLOW 200
+
+/* struct SHMForAgg { */
+/*   struct PrefixV4 prefixV4Tab[MAX_IPV4_PREFIX]; */
+/* } */
+
 
 void setCache(RulesPtr);
@@ -100 +106 @@
 short checkFlow(short);
 void showAllTplFlSet();
+void writeAllTplFlSet();
 

trunk/src/renetcolSender.c

@@ -299 +299 @@
   }
   if (sscanf (argv[2], "%ld", &type) != 1){
-    fprintf(stderr, "Invalid type\n");
+    fprintf(stderr, "renetcolSender: Error, Invalid message type in command\n");
     exit(1);
   }  
@@ -309 +309 @@
   strcpy (rulesFileName, argv[3]);
   rulesListPtr = NULL;
+  fprintf(stderr, "renetcolSender: reading the rules...\n");
   rulesListPtr = getRules(rulesListPtr, rulesFileName);
+  fprintf(stderr, "renetcolSender: OK\n");
   /* we delete rules which are not type socket */
   tmp = rulesListPtr;
@@ -329 +331 @@
 
 /*   chdir ("/"); */
-  fprintf(stderr, "I become a deamon, next messages via syslogd.\n");
+  fprintf(stderr, "renetcolSender: I become a deamon, next messages via syslogd. By.\n");
   if (fork () != 0)
     exit (0);

trunk/src/template.c

@@ -126 +126 @@
           syslog (LOG_INFO, 
                   "fields nb too large, bug collector or wrong template def"); 
-          exit(1);
+          cTFSPtr = deleteTplFlSet(cTFSPtr);
         }
       }
@@ -181 +181 @@
           syslog (LOG_INFO, 
                   "fields nb too large, bug collector or wrong template def"); 
-          exit(1);
+          cTFSPtr = deleteTplFlSet(cTFSPtr);
         }
       }
@@ -194 +194 @@
 /*          ( cr->IpAddress)<<24>>24); */
 /*     fprintf(stderr,"%lu %d\n", cTFSPtr->sourceId, sizeof(cTFSPtr->sourceId)); */
+    /* FIXME HERE don't send an wrong def if error detected */
     msgTextIndex = mempcpy(mempcpy(mempcpy(mempcpy(mempcpy(myMsg.text, 
                                                            &tplMsgType,