Show
Ignore:
Timestamp:
07/23/14 15:16:06 (8 years ago)
Author:
andreu
Message:

RECORDFLOW option

Location:
branches/renetcolSMP/src
Files:
16 modified

Legend:

Unmodified
Added
Removed
  • branches/renetcolSMP/src/V9Header_mgmt.c

    r154 r166  
    136136    buffer4[0] = *(buf+(*offV9)); (*offV9)++; 
    137137    v9Ptr->sourceId = *((unsigned long*)(&buffer4)); 
     138    v9Ptr->boot_time = (uint64_t)1000*(uint64_t)(v9Ptr->unix_seconds)-(uint64_t)(v9Ptr->system_uptime); 
    138139    correct = exportVersion; 
    139140    break; 
  • branches/renetcolSMP/src/V9Header_mgmt.h

    r154 r166  
    2727 
    2828#include "headers_mgmt.h" 
     29#include <stdint.h> 
    2930 
    3031typedef struct NetFlowV9Header * NetFlowV9HeaderPtr; 
     
    3435  unsigned short count;  /* nb flowset records (both template and data)*/ 
    3536  unsigned long system_uptime; 
    36   unsigned long unix_seconds;            
     37  unsigned long unix_seconds;    
    3738  unsigned long package_sequence; 
    3839  unsigned long sourceId; 
     40  uint64_t boot_time; /* in millisecond */ 
    3941} NetFlowV9HeaderType; 
    4042 
  • branches/renetcolSMP/src/dataFlowSet.c

    r161 r166  
    3030 * 
    3131 */ 
     32#ifdef RECORDFLOW 
    3233short 
    3334checkDataFlowSet(short shift, 
    34                  struct MyPtrs *myPtrs, 
    35                  int myQueue, 
    36                  struct PrefixV4 *V4PTab, 
    37                  size_t nbPV4, 
    38                  struct PrefixV4 *V4STab, 
    39                  size_t nbSV4 
    40                  ) 
     35                 struct MyPtrs *myPtrs, 
     36                 int myQueue, 
     37                 struct PrefixV4 *V4PTab, 
     38                 size_t nbPV4, 
     39                 struct PrefixV4 *V4STab, 
     40                 size_t nbSV4, 
     41                 FILE *curRFF) 
     42#else 
     43short 
     44checkDataFlowSet(short shift, 
     45                 struct MyPtrs *myPtrs, 
     46                 int myQueue, 
     47                 struct PrefixV4 *V4PTab, 
     48                 size_t nbPV4, 
     49                 struct PrefixV4 *V4STab, 
     50                 size_t nbSV4 
     51                 ) 
     52#endif 
    4153{ 
    4254  TplFlowSetPtr tmp = NULL; 
     
    347359                    ((RuleDefPtr)(*(myPtrs->rulesAddressPtr+pos)))->check = 1; 
    348360                  } 
    349                                 } 
     361              } 
     362              if (pftmp->fieldType==21){ 
     363                 agCache.lastTime = *((unsigned long*)&buffer4); 
     364              } 
     365              if (pftmp->fieldType==22){ 
     366                 agCache.firstTime = *((unsigned long*)&buffer4); 
     367              } 
    350368#if defined(IPV4AGGIDR) || defined(IPV4AGGIDSNMP) 
    351369              if (pftmp->fieldType==10){ 
     
    667685                dosCache.startTime = *((unsigned long*)&buffer4); 
    668686      } 
     687              if (pftmp->fieldType==21){ 
     688                 agCache.lastTime = *((unsigned long*)&buffer4); 
     689              } 
     690              if (pftmp->fieldType==22){ 
     691                 agCache.firstTime = *((unsigned long*)&buffer4); 
     692              } 
    669693          break; 
    670694        case 16: 
     
    927951#endif 
    928952                /* OUT ("traffic from the prefix/subnet")  */ 
     953              if (agCache.firstTime>agCache.lastTime) { 
     954                 agCache.firstTimeCor = myPtrs->currentHeaderV9Ptr->boot_time - 0x100000000LL + (uint64_t)agCache.firstTime; 
     955                 agCache.lastTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.lastTime; 
     956              }else{ 
     957                 agCache.firstTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.firstTime; 
     958                 agCache.lastTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.lastTime; 
     959              } 
     960#if defined(RECORDFLOW) 
     961        if (fprintf(curRFF,"%llu;%llu;%lu.%lu.%lu.%lu;%hu;%lu.%lu.%lu.%lu;%hu;%lu.%lu.%lu.%lu;%hu;%hu;%lu;%lu;%hu;%hu;%hu;%hu;%hu;%hu\n", 
     962                      agCache.firstTimeCor, 
     963                      agCache.lastTimeCor - agCache.firstTimeCor, 
     964                      (agCache.v4AdS>>24), 
     965                      (agCache.v4AdS<<8>>24), 
     966                      (agCache.v4AdS<<16>>24), 
     967                      (agCache.v4AdS<<24>>24), 
     968                      (agCache.maskS), 
     969                      (agCache.v4AdD>>24), 
     970                      (agCache.v4AdD<<8>>24), 
     971                      (agCache.v4AdD<<16>>24), 
     972                      (agCache.v4AdD<<24>>24), 
     973                      (agCache.maskD), 
     974                      (myPtrs->pcktPtr->ipH->srcAdd>>24), 
     975                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
     976                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     977                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24), 
     978                      agCache.inputSnmp, 
     979                      agCache.outputSnmp, 
     980                      agCache.bytes, 
     981                      agCache.pkts, 
     982                      agCache.sPort, 
     983                      agCache.dPort, 
     984                      agCache.asS, 
     985                      agCache.asD, 
     986                      agCache.ipProt, 
     987                      agCache.tProt 
     988        ) == NULL ) { 
     989           printf(stderr, "%s", strerror(errno)); 
     990         } 
     991#endif 
     992 
    929993#if defined(MULTISAMPLING) 
    930994                if (myPtrs->currentRouterPtr->sampled != res->sampling ){ 
    931995                  res->bytesNbOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
    932996                  res->pktsNbOUT += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling; 
    933                   /* (res->flowNbOUT)++; FIXME : FIND SOMETHING*/ 
     997                  (res->flowNbOUT)++; /* FIXME : FIND SOMETHING*/ 
    934998                  if (agCache.dscp>>2 == FIRST_CoS) { 
    935999                    res->firstCoSOUT += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
     
    10111075                    res3->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling; 
    10121076                    res3->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res3->sampling; 
    1013                     /* (res3->flowNbIN)++; FIXME : FIND SOMETHING */ 
     1077                    (res3->flowNbIN)++;  /* FIXME : FIND SOMETHING */ 
    10141078                    if (agCache.dscp>>2 == FIRST_CoS) { 
    10151079                      res3->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res3->sampling; 
     
    11821246                  res->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
    11831247                  res->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling; 
     1248                  (res->flowNbIN)++; 
    11841249                  if (agCache.dscp>>2 == FIRST_CoS) { 
    11851250                    res->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
     
    12231288#endif 
    12241289              } 
     1290              if (agCache.firstTime>agCache.lastTime) { 
     1291                 agCache.firstTimeCor = myPtrs->currentHeaderV9Ptr->boot_time - 0x100000000LL + (uint64_t)agCache.firstTime; 
     1292                 agCache.lastTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.lastTime; 
     1293              }else{ 
     1294                 agCache.firstTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.firstTime; 
     1295                 agCache.lastTimeCor = myPtrs->currentHeaderV9Ptr->boot_time + (uint64_t)agCache.lastTime; 
     1296              } 
     1297#if defined(RECORDFLOW) 
     1298        if (fprintf(curRFF,"%llu;%llu;%lu.%lu.%lu.%lu;%hu;%lu.%lu.%lu.%lu;%hu;%lu.%lu.%lu.%lu;%hu;%hu;%lu;%lu;%hu;%hu;%hu;%hu;%hu;%hu\n", 
     1299                      agCache.firstTimeCor, 
     1300                      agCache.lastTimeCor - agCache.firstTimeCor, 
     1301                      (agCache.v4AdS>>24), 
     1302                      (agCache.v4AdS<<8>>24), 
     1303                      (agCache.v4AdS<<16>>24), 
     1304                      (agCache.v4AdS<<24>>24), 
     1305                      (agCache.maskS), 
     1306                      (agCache.v4AdD>>24), 
     1307                      (agCache.v4AdD<<8>>24), 
     1308                      (agCache.v4AdD<<16>>24), 
     1309                      (agCache.v4AdD<<24>>24), 
     1310                      (agCache.maskD), 
     1311                      (myPtrs->pcktPtr->ipH->srcAdd>>24), 
     1312                      (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
     1313                      (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     1314                      (myPtrs->pcktPtr->ipH->srcAdd<<24>>24), 
     1315                      agCache.inputSnmp, 
     1316                      agCache.outputSnmp, 
     1317                      agCache.bytes, 
     1318                      agCache.pkts, 
     1319                      agCache.sPort, 
     1320                      agCache.dPort, 
     1321                      agCache.asS, 
     1322                      agCache.asD, 
     1323                      agCache.ipProt, 
     1324                      agCache.tProt 
     1325        ) == NULL ) { 
     1326           printf(stderr, "%s", strerror(errno)); 
     1327         } 
     1328#endif 
    12251329#endif 
    12261330#if defined(IPV4AGGIDR) 
     
    12301334                  res->bytesNbIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
    12311335                  res->pktsNbIN += agCache.pkts*myPtrs->currentRouterPtr->sampled/res->sampling; 
     1336                  (res->flowNbIN)++; 
    12321337                  if (agCache.dscp>>2 == FIRST_CoS) { 
    12331338                    res->firstCoSIN += agCache.bytes*myPtrs->currentRouterPtr->sampled/res->sampling; 
  • branches/renetcolSMP/src/dataFlowSet.h

    r154 r166  
    8585  unsigned long v4AdS; 
    8686  unsigned long v4AdD; 
     87  unsigned long firstTime; 
     88  uint64_t firstTimeCor; 
     89  uint64_t lastTimeCor; 
     90  unsigned long lastTime; 
    8791  uint32_t tabAdd6S[4]; 
    8892  uint32_t tabAdd6D[4]; 
     
    102106  unsigned long endTime; 
    103107}; 
    104  
     108#ifdef RECORDFLOW 
     109short 
     110checkDataFlowSet(short, 
     111                 struct MyPtrs *, 
     112                 int, 
     113                 struct PrefixV4 *, size_t, 
     114                 struct PrefixV4 *, size_t, 
     115                 FILE *currentRECORDFLOWFILE 
     116                 ); 
     117#else 
    105118short 
    106119checkDataFlowSet(short, 
     
    110123                 struct PrefixV4 *, size_t 
    111124                 ); 
     125#endif 
    112126 
    113127#endif /* DATAFLOWSET_H */ 
  • branches/renetcolSMP/src/headers_mgmt.c

    r154 r166  
    145145      if (regRouter == 2) 
    146146        { 
    147           syslog(LOG_INFO,"Router Address not registered : %lu.%lu.%lu.%lu)", 
     147        /*  syslog(LOG_INFO,"Router Address not registered : %lu.%lu.%lu.%lu)", 
    148148                 (pckt->ipH->srcAdd>>24), 
    149149                 (pckt->ipH->srcAdd<<8>>24), 
    150150                 (pckt->ipH->srcAdd<<16>>24), 
    151                  (pckt->ipH->srcAdd<<24>>24)); 
     151                 (pckt->ipH->srcAdd<<24>>24)); */ 
    152152          return (1); 
    153153        } 
  • branches/renetcolSMP/src/msg_mgmt.c

    r154 r166  
    6969              IPC_NOWAIT) <0) { 
    7070    if (errno == EAGAIN) { 
    71       syslog(LOG_INFO,"The IPC queue is full, I don't wait"); 
     71      /* syslog(LOG_INFO,"The IPC queue is full, I don't wait"); FIXME */ 
    7272    } else { 
    7373      syslog(LOG_ERR,"msgsnd : %s", strerror(errno));  
  • branches/renetcolSMP/src/renetcolParam.h

    r164 r166  
    3333 * your collector address - syntax: 10.0.0.90, can be empty 
    3434*/ 
    35 #define SMP1_RECEPTION_ADDRESS "192.68.2.2" 
    36 #define SMP2_RECEPTION_ADDRESS "192.68.3.2" 
    37 #define SMP3_RECEPTION_ADDRESS "192.68.4.2" 
    38 #define SMP4_RECEPTION_ADDRESS "192.68.5.2" 
     35#define SMP1_RECEPTION_ADDRESS "10.0.0.1" 
     36#define SMP2_RECEPTION_ADDRESS "10.0.0.2" 
     37#define SMP3_RECEPTION_ADDRESS "10.0.0.3" 
     38#define SMP4_RECEPTION_ADDRESS "10.0.0.4" 
    3939 
    4040/* 
     
    5050 * (not necessary the number of routers) 
    5151 */ 
    52 #define SMP1_ROUTER_INDEX_MAX 1 
    53 #define SMP2_ROUTER_INDEX_MAX 2 
    54 #define SMP3_ROUTER_INDEX_MAX 2 
    55 #define SMP4_ROUTER_INDEX_MAX 2 
     52#define SMP1_ROUTER_INDEX_MAX 13 
     53#define SMP2_ROUTER_INDEX_MAX 16 
     54#define SMP3_ROUTER_INDEX_MAX 20 
     55#define SMP4_ROUTER_INDEX_MAX 15 
    5656 
    5757/* 
    5858 * FILE with your routers IP address 
    5959*/ 
    60 #define SMP1_ROUTERS_LIST "/home/maintenance/CONF_RENETCOL/routersSMP1.txt" 
    61 #define SMP2_ROUTERS_LIST "/home/maintenance/CONF_RENETCOL/routersSMP2.txt" 
    62 #define SMP3_ROUTERS_LIST "/home/maintenance/CONF_RENETCOL/routersSMP3.txt" 
    63 #define SMP4_ROUTERS_LIST "/home/maintenance/CONF_RENETCOL/routersSMP4.txt" 
     60#define SMP1_ROUTERS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/routersSMP1.txt" 
     61#define SMP2_ROUTERS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/routersSMP2.txt" 
     62#define SMP3_ROUTERS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/routersSMP3.txt" 
     63#define SMP4_ROUTERS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/routersSMP4.txt" 
    6464 
    6565/* 
    6666 * FILE with your prefix/subnet 
    6767 */ 
    68 #define SUBNETS_LIST "/home/maintenance/CONF_RENETCOL/SUBNETSAGA.txt" 
     68#define SUBNETS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/SUBNETSAGA.txt" 
    6969 
    7070/* 
    7171 * FILE with your IPv6 prefixes list 
    7272 */ 
    73 #define SUBNETS_V6_LIST "/home/maintenance/CONF_RENETCOL/IPv6_Subnet_Aggregation_based_on_SNMP_index.txt" 
     73#define SUBNETS_V6_LIST "/home/maintenance/RSMP/CONF_RENETCOL/IPv6_Subnet_Aggregation_based_on_SNMP_index.txt" 
    7474 
    7575/* 
    7676 * FILE with the list of AS with accounting 
    7777 */ 
    78 #define AS_LIST "/home/maintenance/CONF_RENETCOL/AS_MS.txt" 
     78#define AS_LIST "/home/maintenance/RSMP/CONF_RENETCOL/AS_MS.txt" 
    7979 
    8080/* 
    8181 * constants, here a subnet is include in a prefix 
    8282 */ 
    83 #define MAX_IPV4_PREFIX 4247 
    84 #define MAX_IPV4_SUBNET 410 
    85 #define MAX_AS 559 
     83#define MAX_IPV4_PREFIX 4315 
     84#define MAX_IPV4_SUBNET 417 
     85#define MAX_AS 576 
    8686#define MAX_IPV6_PREFIX 500 
    8787#define MAX_IPV6_SUBNET 100 
     
    9494 * FILE for the rules 
    9595 */ 
    96 #define RULES_FILE "/home/maintenance/CONF_RENETCOL/rules.txt" 
     96#define RULES_FILE "/home/maintenance/RSMP/CONF_RENETCOL/rules.txt" 
    9797 
    9898/* 
     
    100100 * tagged "C"ustomers or "B"ackbone 
    101101 */ 
    102 #define SMP1_INTERFACES_TYPE_LIST "/home/maintenance/CONF_RENETCOL/SMP1_SNMP_INDEX.txt" 
    103 #define SMP2_INTERFACES_TYPE_LIST "/home/maintenance/CONF_RENETCOL/SMP2_SNMP_INDEX.txt" 
    104 #define SMP3_INTERFACES_TYPE_LIST "/home/maintenance/CONF_RENETCOL/SMP3_SNMP_INDEX.txt" 
    105 #define SMP4_INTERFACES_TYPE_LIST "/home/maintenance/CONF_RENETCOL/SMP4_SNMP_INDEX.txt" 
     102#define SMP1_INTERFACES_TYPE_LIST "/home/maintenance/RSMP/CONF_RENETCOL/SMP1_SNMP_INDEX.txt" 
     103#define SMP2_INTERFACES_TYPE_LIST "/home/maintenance/RSMP/CONF_RENETCOL/SMP2_SNMP_INDEX.txt" 
     104#define SMP3_INTERFACES_TYPE_LIST "/home/maintenance/RSMP/CONF_RENETCOL/SMP3_SNMP_INDEX.txt" 
     105#define SMP4_INTERFACES_TYPE_LIST "/home/maintenance/RSMP/CONF_RENETCOL/SMP4_SNMP_INDEX.txt" 
    106106 
    107107/* 
     
    113113 * maximum number of interfaces by router (one interface == one SNMP index) 
    114114 */ 
    115 #define MAX_INDEX_BY_ROUTER 150 
     115#define MAX_INDEX_BY_ROUTER 200 
    116116 
    117117/* 
    118118 * RRD files paths 
    119119 */ 
    120 #define PREFIX_RRD_LOCATION "/mnt/data/RRD/RENATER/IPv4_SUBNET/" 
    121 #define MATRIX_RRD_LOCATION "/mnt/data/RRD/RENATER/MATRIX/" 
    122 #define AS_RRD_LOCATION "/mnt/data/RRD/RENATER/AS/" 
    123 #define SNMP_INDEX_RRD_LOCATION "/mnt/data/RRD/RENATER/SNMP_INDEX/" 
    124 #define MIB_RRD_LOCATION "/mnt/data/RRD/RENATER/RENETCOL_MIB/" 
     120#define PREFIX_RRD_LOCATION "/home/RRD/RENATER/IPv4_SUBNET/" 
     121#define MATRIX_RRD_LOCATION "/home/RRD/RENATER/MATRIX/" 
     122#define AS_RRD_LOCATION "/home/RRD/RENATER/AS/" 
     123#define SNMP_INDEX_RRD_LOCATION "/home/RRD/RENATER/SNMP_INDEX/" 
     124#define MIB_RRD_LOCATION "/home/RRD/RENATER/RENETCOL_MIB/" 
    125125 
    126126/* 
     
    144144#define THIRD_CoS 8   /* CS1, Less than BE - dec 8, bin 001000 - 00100000 */ 
    145145#define FOURTH_CoS 0  /* Best Effort or All flows if not in the 3 others class */ 
     146/* 
     147 * FILES PATH/NAMES FOR RECORD FLOW OPTION, enabled via ./configure^M 
     148 * 2 files per process^M 
     149 */ 
     150#define RECORD_FILE_PATH "/home/FLOW_DATA/" 
     151#define SMP1_RECORD_FILE_1 "RENETCOL_SMP1_1_FLOWS" 
     152#define SMP1_RECORD_FILE_2 "RENETCOL_SMP1_1_FLOWS" 
     153#define SMP2_RECORD_FILE_1 "RENETCOL_SMP2_1_FLOWS" 
     154#define SMP2_RECORD_FILE_2 "RENETCOL_SMP2_1_FLOWS" 
     155#define SMP3_RECORD_FILE_1 "RENETCOL_SMP3_1_FLOWS" 
     156#define SMP3_RECORD_FILE_2 "RENETCOL_SMP3_1_FLOWS" 
     157#define SMP4_RECORD_FILE_1 "RENETCOL_SMP4_1_FLOWS" 
     158#define SMP4_RECORD_FILE_2 "RENETCOL_SMP4_1_FLOWS" 
    146159 
    147160/**************************************************************** 
  • branches/renetcolSMP/src/renetcolSMP1.c

    r163 r166  
    3737FILE *fIP;                                 /* pointer on the IP output file */ 
    3838FILE *fMPLS;                              /* pointer on the MPLS output file */ 
     39 
     40#if defined(RECORDFLOW) 
     41FILE *fRECORDF1; 
     42FILE *fRECORDF2; 
     43char    *bufRF1 = NULL; 
     44char    *bufRF2 = NULL; 
     45char *nameRF[128]; 
     46char *pathRF[256]; 
     47#endif 
    3948 
    4049struct sigaction myAction; /* handler for renetcolSender communication */ 
     
    118127    fprintf(stderr, "Couldn't open PCAP file %s: %s\n", myPcapFileName, errBuffer); 
    119128    exit(1); 
     129  } 
     130#endif 
     131 
     132#if defined(RECORDFLOW) 
     133  strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     134  strncpy(nameRF, SMP1_RECORD_FILE_1,sizeof(SMP1_RECORD_FILE_1)); 
     135  errno = 0; 
     136  prepend_timestamp ( nameRF, sizeof nameRF ); 
     137  if ( errno != ERANGE ) 
     138    printf ( "Timestamped: %s\n", nameRF ); 
     139  else { 
     140      /* Handle the error */ 
     141  } 
     142  strncat(pathRF,nameRF, sizeof(nameRF)); 
     143  if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     144    syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     145  } else { 
     146    fprintf(stderr,"fRECORDF1 %d",fRECORDF1); 
     147    bufRF1 = (char *)malloc (262144); 
     148    setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
    120149  } 
    121150#endif 
     
    379408} 
    380409 
     410char *prepend_timestamp ( char s[], size_t capacity ) 
     411{ 
     412    const char fmt[] = "%y-%m-%d_%H-%M"; 
     413    size_t n = sizeof ( fmt ); 
     414    size_t len = strlen ( s ); 
     415    if ( len + n < capacity ) { 
     416        time_t init = time ( NULL ); 
     417        memmove ( s + n, s, len + 1 ); 
     418        strftime ( s, n, fmt, localtime ( &init ) ); 
     419        s[n - 1] = '_'; 
     420    } 
     421    else 
     422        errno = ERANGE; 
     423 
     424    return s; 
     425} 
     426 
    381427/* 
    382428 * send his PID to another program via IPC message queue 
     
    553599  int dd = 0; 
    554600  FILE *TPLFILE; 
    555  
     601#if defined(RECORDFLOW) 
     602  FILE *currentRECORDFLOWFILE; 
     603#endif 
    556604  now = time((time_t *)NULL); 
    557605  tmPtr = localtime(&now); 
     
    559607  lastMPLSOutput = now; 
    560608  lastIPOutput = now; 
     609#if defined(RECORDFLOW)   
     610currentRECORDFLOWFILE = fRECORDF1; 
     611#endif 
    561612  do { 
    562613#ifdef DEBUG 
     
    566617      currentIntervalle = tmPtr->tm_min; 
    567618      if (shmForAgg->currentTable == 0) { 
    568         shmForAgg->currentTable = 1; 
    569         shmForAgg->secondTable = 0; 
     619              shmForAgg->currentTable = 1; 
     620              shmForAgg->secondTable = 0; 
     621#if defined(RECORDFLOW) 
     622        /*free(bufRF1);*/ 
     623        fflush(fRECORDF1); 
     624        if (fclose(fRECORDF1) == NULL){ 
     625          fprintf(stderr,"error fclose : %s",strerror(errno)); 
     626        } 
     627        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     628        strncpy(nameRF, SMP1_RECORD_FILE_2,sizeof(SMP1_RECORD_FILE_2)); 
     629        errno = 0; 
     630        prepend_timestamp ( nameRF, sizeof nameRF ); 
     631        if ( errno != ERANGE ) 
     632          printf ( "Timestamped: %s\n", nameRF ); 
     633        else { 
     634          /* Handle the error */ 
     635        } 
     636        strncat(pathRF, nameRF, sizeof(nameRF)); 
     637 
     638        if ((fRECORDF2 = fopen(pathRF, "w")) == NULL) { 
     639          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     640        } else { 
     641          bufRF2 = (char *)malloc (262144); 
     642          setvbuf (fRECORDF2, bufRF2, _IOFBF, 262144); 
     643        } 
     644        currentRECORDFLOWFILE = fRECORDF2; 
     645#endif 
    570646      }else{ 
    571         shmForAgg->currentTable = 0; 
    572         shmForAgg->secondTable = 1; 
     647              shmForAgg->currentTable = 0; 
     648        shmForAgg->secondTable = 1; 
     649#if defined(RECORDFLOW) 
     650    fprintf (stderr, "AVANT free(bufRF 2 ) *****************************************************"); 
     651        /*free(bufRF2);*/ 
     652        fflush(fRECORDF2); 
     653        fclose(fRECORDF2); 
     654        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     655        strncpy(nameRF, SMP1_RECORD_FILE_1,sizeof(SMP1_RECORD_FILE_1)); 
     656        errno = 0; 
     657        prepend_timestamp ( nameRF, sizeof nameRF ); 
     658        if ( errno != ERANGE ) 
     659          printf ( "Timestamped: %s\n", nameRF ); 
     660        else { 
     661          /* Handle the error */ 
     662        } 
     663        strncat(pathRF, nameRF, sizeof(nameRF)); 
     664        if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     665          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     666        } else { 
     667          bufRF1 = (char *)malloc (262144); 
     668          setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
     669        } 
     670        currentRECORDFLOWFILE = fRECORDF1; 
     671#endif 
    573672      } 
    574673      shmForAgg->readed = 1; 
     
    586685      /* FIXME : to delete : */ 
    587686      if (!(TPLFILE = fopen("/tmp/IPV6LINKAGGSMP1.txt", "w"))) { 
    588         syslog (LOG_ERR, "error during %s opening", "/tmp/IPV6LINKAGGSMP1.txt"); 
     687              syslog (LOG_ERR, "error during %s opening", "/tmp/IPV6LINKAGGSMP1.txt"); 
    589688      } 
    590689      tmp = routersListPtr; 
    591690      for (; tmp; tmp=tmp->next) { 
    592         for (dd=0;dd<MAX_INDEX_BY_ROUTER;dd++) { 
    593           if ( tmp->snmpIndexType[dd] != 2) { 
    594             fprintf(TPLFILE, 
    595                     "router: %lu.%lu.%lu.%lu dd: %hu , indexSNMP : %hu , type : %hu ,total bytes IN : %llu, OUT : %llu\n", 
    596                     (tmp->IpAddress>>24), 
    597                     (tmp->IpAddress<<8>>24), 
    598                     (tmp->IpAddress<<16>>24), 
    599                     (tmp->IpAddress<<24>>24), 
    600                     dd, 
    601                     tmp->snmpIndexID[dd], 
    602                     tmp->snmpIndexType[dd], 
    603                     ((struct IndexV6 *)((myPtrs.secondV6IndexTab) 
    604                                         +((tmp->ID)*MAX_INDEX_BY_ROUTER) 
    605                                         +(tmp->snmpIndexID[dd])))->bytesNbIN, 
    606                     ((struct IndexV6 *)((myPtrs.secondV6IndexTab) 
    607                                         +((tmp->ID)*MAX_INDEX_BY_ROUTER) 
    608                                         +(tmp->snmpIndexID[dd])))->bytesNbOUT 
    609                     ); 
    610           } 
    611         } 
     691              for (dd=0;dd<MAX_INDEX_BY_ROUTER;dd++) { 
     692                if ( tmp->snmpIndexType[dd] != 2) { 
     693                  fprintf(TPLFILE, 
     694              "router: %lu.%lu.%lu.%lu dd: %hu , indexSNMP : %hu , type : %hu ,total bytes IN : %llu, OUT : %llu\n", 
     695              (tmp->IpAddress>>24), 
     696                          (tmp->IpAddress<<8>>24), 
     697                          (tmp->IpAddress<<16>>24), 
     698              (tmp->IpAddress<<24>>24), 
     699                          dd, 
     700                          tmp->snmpIndexID[dd], 
     701                          tmp->snmpIndexType[dd], 
     702                          ((struct IndexV6 *)((myPtrs.secondV6IndexTab) 
     703                                              +((tmp->ID)*MAX_INDEX_BY_ROUTER) 
     704                +(tmp->snmpIndexID[dd])))->bytesNbIN, 
     705              ((struct IndexV6 *)((myPtrs.secondV6IndexTab) 
     706                                              +((tmp->ID)*MAX_INDEX_BY_ROUTER) 
     707                                              +(tmp->snmpIndexID[dd])))->bytesNbOUT 
     708                        ); 
     709                } 
     710              } 
    612711      } 
    613712      fclose(TPLFILE); /* <-- */ 
     
    702801          } 
    703802        } else if (currentFlowsetId > 255) { 
     803#if defined(RECORDFLOW) 
     804          if ( (shift = checkDataFlowSet(shift, 
     805                                         &myPtrs, 
     806                                         myQueue, 
     807                                         shmForAgg->prefixV4Tab[shmForAgg->currentTable], 
     808                                         (size_t) shmForAgg->v4PrefixNb, 
     809                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
     810                                         (size_t) shmForAgg->v4SubnetNb, 
     811                                         currentRECORDFLOWFILE) ) < 0 ) { 
     812#else 
    704813          if ( (shift = checkDataFlowSet(shift, 
    705814                                         &myPtrs, 
     
    709818                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
    710819                                         (size_t) shmForAgg->v4SubnetNb) ) < 0 ) { 
     820#endif 
    711821#ifdef DEBUG 
    712822            fprintf (stderr, "wd> "); 
  • branches/renetcolSMP/src/renetcolSMP1.h

    r164 r166  
    2929#include <unistd.h> 
    3030#include <stdio.h> 
     31#include <stdint.h> 
    3132#include <string.h> 
    3233#include <stdlib.h> 
     
    9394}; 
    9495 
     96char *prepend_timestamp ( char s[], size_t capacity ); 
    9597void setCache(RulesPtr); 
    9698void initCache(); 
  • branches/renetcolSMP/src/renetcolSMP2.c

    r165 r166  
    3737FILE *fIP;                                 /* pointer on the IP output file */ 
    3838FILE *fMPLS;                              /* pointer on the MPLS output file */ 
     39 
     40#if defined(RECORDFLOW) 
     41FILE *fRECORDF1; 
     42FILE *fRECORDF2; 
     43char    *bufRF1 = NULL; 
     44char    *bufRF2 = NULL; 
     45char *nameRF[128]; 
     46char *pathRF[256]; 
     47#endif 
    3948 
    4049struct sigaction myAction; /* handler for renetcolSender communication */ 
     
    118127    fprintf(stderr, "Couldn't open PCAP file %s: %s\n", myPcapFileName, errBuffer); 
    119128    exit(1); 
     129  } 
     130#endif 
     131 
     132#if defined(RECORDFLOW) 
     133  strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     134  strncpy(nameRF, SMP2_RECORD_FILE_1,sizeof(SMP2_RECORD_FILE_1)); 
     135  errno = 0; 
     136  prepend_timestamp ( nameRF, sizeof nameRF ); 
     137  if ( errno != ERANGE ) 
     138    printf ( "Timestamped: %s\n", nameRF ); 
     139  else { 
     140      /* Handle the error */ 
     141  } 
     142  strncat(pathRF,nameRF, sizeof(nameRF)); 
     143  if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     144    syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     145  } else { 
     146    fprintf(stderr,"fRECORDF1 %d",fRECORDF1); 
     147    bufRF1 = (char *)malloc (262144); 
     148    setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
    120149  } 
    121150#endif 
     
    379408} 
    380409 
     410char *prepend_timestamp ( char s[], size_t capacity ) 
     411{ 
     412    const char fmt[] = "%y-%m-%d_%H-%M"; 
     413    size_t n = sizeof ( fmt ); 
     414    size_t len = strlen ( s ); 
     415    if ( len + n < capacity ) { 
     416        time_t init = time ( NULL ); 
     417        memmove ( s + n, s, len + 1 ); 
     418        strftime ( s, n, fmt, localtime ( &init ) ); 
     419        s[n - 1] = '_'; 
     420    } 
     421    else 
     422        errno = ERANGE; 
     423 
     424    return s; 
     425} 
     426 
     427 
    381428/* 
    382429 * send his PID to another program via IPC message queue 
     
    553600  int dd = 0; 
    554601  FILE *TPLFILE; 
    555  
     602#if defined(RECORDFLOW) 
     603  FILE *currentRECORDFLOWFILE; 
     604#endif 
    556605  now = time((time_t *)NULL); 
    557606  tmPtr = localtime(&now); 
     
    559608  lastMPLSOutput = now; 
    560609  lastIPOutput = now; 
     610#if defined(RECORDFLOW)   
     611currentRECORDFLOWFILE = fRECORDF1; 
     612#endif 
    561613  do { 
    562614#ifdef DEBUG 
     
    568620        shmForAgg->currentTable = 1; 
    569621        shmForAgg->secondTable = 0; 
     622#if defined(RECORDFLOW) 
     623        /*free(bufRF1);*/ 
     624        fflush(fRECORDF1); 
     625        if (fclose(fRECORDF1) == NULL){ 
     626          fprintf(stderr,"error fclose : %s",strerror(errno)); 
     627        } 
     628        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     629        strncpy(nameRF, SMP2_RECORD_FILE_2,sizeof(SMP2_RECORD_FILE_2)); 
     630        errno = 0; 
     631        prepend_timestamp ( nameRF, sizeof nameRF ); 
     632        if ( errno != ERANGE ) 
     633          printf ( "Timestamped: %s\n", nameRF ); 
     634        else { 
     635          /* Handle the error */ 
     636        } 
     637        strncat(pathRF, nameRF, sizeof(nameRF)); 
     638 
     639        if ((fRECORDF2 = fopen(pathRF, "w")) == NULL) { 
     640          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     641        } else { 
     642          bufRF2 = (char *)malloc (262144); 
     643          setvbuf (fRECORDF2, bufRF2, _IOFBF, 262144); 
     644        } 
     645        currentRECORDFLOWFILE = fRECORDF2; 
     646#endif 
    570647      }else{ 
    571648        shmForAgg->currentTable = 0; 
    572649        shmForAgg->secondTable = 1; 
     650#if defined(RECORDFLOW) 
     651        /*free(bufRF2);*/ 
     652        fflush(fRECORDF2); 
     653        fclose(fRECORDF2); 
     654        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     655        strncpy(nameRF, SMP2_RECORD_FILE_1,sizeof(SMP2_RECORD_FILE_1)); 
     656        errno = 0; 
     657        prepend_timestamp ( nameRF, sizeof nameRF ); 
     658        if ( errno != ERANGE ) 
     659          printf ( "Timestamped: %s\n", nameRF ); 
     660        else { 
     661          /* Handle the error */ 
     662        } 
     663        strncat(pathRF, nameRF, sizeof(nameRF)); 
     664        if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     665          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     666        } else { 
     667          bufRF1 = (char *)malloc (262144); 
     668          setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
     669        } 
     670        currentRECORDFLOWFILE = fRECORDF1; 
     671#endif 
    573672      } 
    574673      shmForAgg->readed = 1; 
     
    702801          } 
    703802        } else if (currentFlowsetId > 255) { 
     803#if defined(RECORDFLOW) 
     804          if ( (shift = checkDataFlowSet(shift, 
     805                                         &myPtrs, 
     806                                         myQueue, 
     807                                         shmForAgg->prefixV4Tab[shmForAgg->currentTable], 
     808                                         (size_t) shmForAgg->v4PrefixNb, 
     809                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
     810                                         (size_t) shmForAgg->v4SubnetNb, 
     811           currentRECORDFLOWFILE )) < 0 ) { 
     812#else 
    704813          if ( (shift = checkDataFlowSet(shift, 
    705814                                         &myPtrs, 
     
    709818                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
    710819                                         (size_t) shmForAgg->v4SubnetNb) ) < 0 ) { 
     820#endif 
    711821#ifdef DEBUG 
    712822            fprintf (stderr, "wd> "); 
  • branches/renetcolSMP/src/renetcolSMP2.h

    r164 r166  
    9292}; 
    9393 
     94char *prepend_timestamp ( char s[], size_t capacity ); 
    9495void setCache(RulesPtr); 
    9596void initCache(); 
  • branches/renetcolSMP/src/renetcolSMP3.c

    r165 r166  
    3737FILE *fIP;                                 /* pointer on the IP output file */ 
    3838FILE *fMPLS;                              /* pointer on the MPLS output file */ 
     39 
     40#if defined(RECORDFLOW) 
     41FILE *fRECORDF1; 
     42FILE *fRECORDF2; 
     43char    *bufRF1 = NULL; 
     44char    *bufRF2 = NULL; 
     45char *nameRF[128]; 
     46char *pathRF[256]; 
     47#endif 
    3948 
    4049struct sigaction myAction; /* handler for renetcolSender communication */ 
     
    118127    fprintf(stderr, "Couldn't open PCAP file %s: %s\n", myPcapFileName, errBuffer); 
    119128    exit(1); 
     129  } 
     130#endif 
     131 
     132#if defined(RECORDFLOW) 
     133  strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     134  strncpy(nameRF, SMP3_RECORD_FILE_1,sizeof(SMP3_RECORD_FILE_1)); 
     135  errno = 0; 
     136  prepend_timestamp ( nameRF, sizeof nameRF ); 
     137  if ( errno != ERANGE ) 
     138    printf ( "Timestamped: %s\n", nameRF ); 
     139  else { 
     140      /* Handle the error */ 
     141  } 
     142  strncat(pathRF,nameRF, sizeof(nameRF)); 
     143  if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     144    syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     145  } else { 
     146    fprintf(stderr,"fRECORDF1 %d",fRECORDF1); 
     147    bufRF1 = (char *)malloc (262144); 
     148    setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
    120149  } 
    121150#endif 
     
    379408} 
    380409 
     410char *prepend_timestamp ( char s[], size_t capacity ) 
     411{ 
     412    const char fmt[] = "%y-%m-%d_%H-%M"; 
     413    size_t n = sizeof ( fmt ); 
     414    size_t len = strlen ( s ); 
     415    if ( len + n < capacity ) { 
     416        time_t init = time ( NULL ); 
     417        memmove ( s + n, s, len + 1 ); 
     418        strftime ( s, n, fmt, localtime ( &init ) ); 
     419        s[n - 1] = '_'; 
     420    } 
     421    else 
     422        errno = ERANGE; 
     423 
     424    return s; 
     425} 
     426 
    381427/* 
    382428 * send his PID to another program via IPC message queue 
     
    553599  int dd = 0; 
    554600  FILE *TPLFILE; 
    555  
     601#if defined(RECORDFLOW) 
     602  FILE *currentRECORDFLOWFILE; 
     603#endif 
    556604  now = time((time_t *)NULL); 
    557605  tmPtr = localtime(&now); 
     
    559607  lastMPLSOutput = now; 
    560608  lastIPOutput = now; 
     609#if defined(RECORDFLOW)   
     610currentRECORDFLOWFILE = fRECORDF1; 
     611#endif 
    561612  do { 
    562613#ifdef DEBUG 
     
    568619        shmForAgg->currentTable = 1; 
    569620        shmForAgg->secondTable = 0; 
     621#if defined(RECORDFLOW) 
     622        /*free(bufRF1);*/ 
     623        fflush(fRECORDF1); 
     624        if (fclose(fRECORDF1) == NULL){ 
     625          fprintf(stderr,"error fclose : %s",strerror(errno)); 
     626        } 
     627        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     628        strncpy(nameRF, SMP3_RECORD_FILE_2,sizeof(SMP3_RECORD_FILE_2)); 
     629        errno = 0; 
     630        prepend_timestamp ( nameRF, sizeof nameRF ); 
     631        if ( errno != ERANGE ) 
     632          printf ( "Timestamped: %s\n", nameRF ); 
     633        else { 
     634          /* Handle the error */ 
     635        } 
     636        strncat(pathRF, nameRF, sizeof(nameRF)); 
     637 
     638        if ((fRECORDF2 = fopen(pathRF, "w")) == NULL) { 
     639          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     640        } else { 
     641          bufRF2 = (char *)malloc (262144); 
     642          setvbuf (fRECORDF2, bufRF2, _IOFBF, 262144); 
     643        } 
     644        currentRECORDFLOWFILE = fRECORDF2; 
     645#endif 
    570646      }else{ 
    571647        shmForAgg->currentTable = 0; 
    572648        shmForAgg->secondTable = 1; 
     649#if defined(RECORDFLOW) 
     650        /*free(bufRF2);*/ 
     651        fflush(fRECORDF2); 
     652        fclose(fRECORDF2); 
     653        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     654        strncpy(nameRF, SMP3_RECORD_FILE_1,sizeof(SMP3_RECORD_FILE_1)); 
     655        errno = 0; 
     656        prepend_timestamp ( nameRF, sizeof nameRF ); 
     657        if ( errno != ERANGE ) 
     658          printf ( "Timestamped: %s\n", nameRF ); 
     659        else { 
     660          /* Handle the error */ 
     661        } 
     662        strncat(pathRF, nameRF, sizeof(nameRF)); 
     663        if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     664          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     665        } else { 
     666          bufRF1 = (char *)malloc (262144); 
     667          setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
     668        } 
     669        currentRECORDFLOWFILE = fRECORDF1; 
     670#endif 
    573671      } 
    574672      shmForAgg->readed = 1; 
     
    702800          } 
    703801        } else if (currentFlowsetId > 255) { 
     802#if defined(RECORDFLOW) 
     803          if ( (shift = checkDataFlowSet(shift, 
     804                                         &myPtrs, 
     805                                         myQueue, 
     806                                         shmForAgg->prefixV4Tab[shmForAgg->currentTable], 
     807                                         (size_t) shmForAgg->v4PrefixNb, 
     808                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
     809                                         (size_t) shmForAgg->v4SubnetNb, 
     810           currentRECORDFLOWFILE) ) < 0 ) { 
     811#else 
    704812          if ( (shift = checkDataFlowSet(shift, 
    705813                                         &myPtrs, 
     
    709817                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
    710818                                         (size_t) shmForAgg->v4SubnetNb) ) < 0 ) { 
     819#endif 
    711820#ifdef DEBUG 
    712821            fprintf (stderr, "wd> "); 
  • branches/renetcolSMP/src/renetcolSMP3.h

    r164 r166  
    9292}; 
    9393 
     94char *prepend_timestamp ( char s[], size_t capacity ); 
    9495void setCache(RulesPtr); 
    9596void initCache(); 
  • branches/renetcolSMP/src/renetcolSMP4.c

    r165 r166  
    3737FILE *fIP;                                 /* pointer on the IP output file */ 
    3838FILE *fMPLS;                              /* pointer on the MPLS output file */ 
     39 
     40#if defined(RECORDFLOW) 
     41FILE *fRECORDF1; 
     42FILE *fRECORDF2; 
     43char    *bufRF1 = NULL; 
     44char    *bufRF2 = NULL; 
     45char *nameRF[128]; 
     46char *pathRF[256]; 
     47#endif 
    3948 
    4049struct sigaction myAction; /* handler for renetcolSender communication */ 
     
    118127    fprintf(stderr, "Couldn't open PCAP file %s: %s\n", myPcapFileName, errBuffer); 
    119128    exit(1); 
     129  } 
     130#endif 
     131 
     132#if defined(RECORDFLOW) 
     133  strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     134  strncpy(nameRF, SMP4_RECORD_FILE_1,sizeof(SMP4_RECORD_FILE_1)); 
     135  errno = 0; 
     136  prepend_timestamp ( nameRF, sizeof nameRF ); 
     137  if ( errno != ERANGE ) 
     138    printf ( "Timestamped: %s\n", nameRF ); 
     139  else { 
     140      /* Handle the error */ 
     141  } 
     142  strncat(pathRF,nameRF, sizeof(nameRF)); 
     143  if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     144    syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     145  } else { 
     146    fprintf(stderr,"fRECORDF1 %d",fRECORDF1); 
     147    bufRF1 = (char *)malloc (262144); 
     148    setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
    120149  } 
    121150#endif 
     
    377406} 
    378407 
     408char *prepend_timestamp ( char s[], size_t capacity ) 
     409{ 
     410    const char fmt[] = "%y-%m-%d_%H-%M"; 
     411    size_t n = sizeof ( fmt ); 
     412    size_t len = strlen ( s ); 
     413    if ( len + n < capacity ) { 
     414        time_t init = time ( NULL ); 
     415        memmove ( s + n, s, len + 1 ); 
     416        strftime ( s, n, fmt, localtime ( &init ) ); 
     417        s[n - 1] = '_'; 
     418    } 
     419    else 
     420        errno = ERANGE; 
     421 
     422    return s; 
     423} 
     424 
     425 
    379426/* 
    380427 * send his PID to another program via IPC message queue 
     
    551598  int dd = 0; 
    552599  FILE *TPLFILE; 
    553  
     600#if defined(RECORDFLOW) 
     601  FILE *currentRECORDFLOWFILE; 
     602#endif 
    554603  now = time((time_t *)NULL); 
    555604  tmPtr = localtime(&now); 
     
    557606  lastMPLSOutput = now; 
    558607  lastIPOutput = now; 
     608#if defined(RECORDFLOW)   
     609currentRECORDFLOWFILE = fRECORDF1; 
     610#endif 
    559611  do { 
    560612#ifdef DEBUG 
     
    566618        shmForAgg->currentTable = 1; 
    567619        shmForAgg->secondTable = 0; 
     620#if defined(RECORDFLOW) 
     621        /*free(bufRF1);*/ 
     622        fflush(fRECORDF1); 
     623        if (fclose(fRECORDF1) == NULL){ 
     624          fprintf(stderr,"error fclose : %s",strerror(errno)); 
     625        } 
     626        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     627        strncpy(nameRF, SMP4_RECORD_FILE_2,sizeof(SMP4_RECORD_FILE_2)); 
     628        errno = 0; 
     629        prepend_timestamp ( nameRF, sizeof nameRF ); 
     630        if ( errno != ERANGE ) 
     631          printf ( "Timestamped: %s\n", nameRF ); 
     632        else { 
     633          /* Handle the error */ 
     634        } 
     635        strncat(pathRF, nameRF, sizeof(nameRF)); 
     636 
     637        if ((fRECORDF2 = fopen(pathRF, "w")) == NULL) { 
     638          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     639        } else { 
     640          bufRF2 = (char *)malloc (262144); 
     641          setvbuf (fRECORDF2, bufRF2, _IOFBF, 262144); 
     642        } 
     643        currentRECORDFLOWFILE = fRECORDF2; 
     644#endif 
    568645      }else{ 
    569646        shmForAgg->currentTable = 0; 
    570647        shmForAgg->secondTable = 1; 
     648#if defined(RECORDFLOW) 
     649        /*free(bufRF2);*/ 
     650        fflush(fRECORDF2); 
     651        fclose(fRECORDF2); 
     652        strncpy(pathRF, RECORD_FILE_PATH,sizeof(RECORD_FILE_PATH)); 
     653        strncpy(nameRF, SMP4_RECORD_FILE_1,sizeof(SMP4_RECORD_FILE_1)); 
     654        errno = 0; 
     655        prepend_timestamp ( nameRF, sizeof nameRF ); 
     656        if ( errno != ERANGE ) 
     657          printf ( "Timestamped: %s\n", nameRF ); 
     658        else { 
     659          /* Handle the error */ 
     660        } 
     661        strncat(pathRF, nameRF, sizeof(nameRF)); 
     662        if ((fRECORDF1 = fopen(pathRF, "w")) == NULL) { 
     663          syslog(LOG_ERR,"Error in %s opening : %s", pathRF, strerror(errno)); 
     664        } else { 
     665          bufRF1 = (char *)malloc (262144); 
     666          setvbuf (fRECORDF1, bufRF1, _IOFBF, 262144); 
     667        } 
     668        currentRECORDFLOWFILE = fRECORDF1; 
     669#endif 
    571670      } 
    572671      shmForAgg->readed = 1; 
     
    700799          } 
    701800        } else if (currentFlowsetId > 255) { 
     801#if defined(RECORDFLOW) 
     802          if ( (shift = checkDataFlowSet(shift, 
     803                                         &myPtrs, 
     804                                         myQueue, 
     805                                         shmForAgg->prefixV4Tab[shmForAgg->currentTable], 
     806                                         (size_t) shmForAgg->v4PrefixNb, 
     807                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
     808                                         (size_t) shmForAgg->v4SubnetNb, 
     809           currentRECORDFLOWFILE) ) < 0 ) { 
     810#else 
    702811          if ( (shift = checkDataFlowSet(shift, 
    703812                                         &myPtrs, 
     
    707816                                         shmForAgg->prefixV4SubnetTab[shmForAgg->currentTable], 
    708817                                         (size_t) shmForAgg->v4SubnetNb) ) < 0 ) { 
     818#endif 
    709819#ifdef DEBUG 
    710820            fprintf (stderr, "wd> "); 
  • branches/renetcolSMP/src/renetcolSMP4.h

    r164 r166  
    9292}; 
    9393 
     94char *prepend_timestamp ( char s[], size_t capacity ); 
    9495void setCache(RulesPtr); 
    9596void initCache(); 
  • branches/renetcolSMP/src/routers_mgmt.c

    r154 r166  
    6969  if ((tmp = notExistRouter(routersList,  
    7070                            address))==NULL) { 
    71     syslog(LOG_INFO,"Router Address not registered : %lu.%lu.%lu.%lu", 
     71  /*  syslog(LOG_INFO,"Router Address not registered : %lu.%lu.%lu.%lu", 
    7272           (address>>24), 
    7373           (address<<8>>24), 
    7474           (address<<16>>24), 
    75            (address<<24>>24)); 
     75           (address<<24>>24));*/ 
    7676    return routersList; 
    7777  } else {