add new table interval_statistics contains pktCount

code_boost/src/cxx/pcap_processor.cpp

@@ -119,7 +119,8 @@ void pcap_processor::collect_statistics() {
         std::chrono::duration<int, std::micro> timeInterval(10000000); // 5 sec
         std::chrono::microseconds intervalStartTimestamp = stats.getTimestampFirstPacket();
         std::chrono::microseconds firstTimestamp = stats.getTimestampFirstPacket();
-        int pktsInterval = 1000;
+        int pktsInterval = 1000;        
+        int previousPacketCount = 0;
         
         // Iterate over all packets and collect statistics
         for (; i != sniffer.end(); i++) {
@@ -133,14 +134,20 @@ void pcap_processor::collect_statistics() {
             std::chrono::microseconds lastPktTimestamp = i->timestamp();
             //Tins::Timestamp tt = i->timestamp();
             
+            
             std::chrono::microseconds currentCaptureDuration = lastPktTimestamp - firstTimestamp;
             std::chrono::microseconds barrier =  timeIntervalNum*timeInterval;
             if(currentCaptureDuration>barrier){
-                //std::cout<<"LastpkstTimstamp:" << lastPktTimestamp.count() << ", currentCaptureDuration:"<< currentCaptureDuration.count() << ", barrier:" <<barrier.count()<<", interval:" << timeIntervalNum << ", interval time:"<<timeInterval.count()<<"\n";                
+                //std::cout<<"LastpkstTimstamp:" << lastPktTimestamp.count() << ", currentCaptureDuration:"<< currentCaptureDuration.count() << ", barrier:" <<barrier.count()<<", interval:" << timeIntervalNum << ", interval time:"<<timeInterval.count()<<"\n";    
+                
+                stats.addIntervalStat(timeInterval, intervalStartTimestamp, previousPacketCount);
                 stats.calculateLastIntervalIPsEntropy(filePath, intervalStartTimestamp);
                 stats.calculateLastIntervalPacketRate(timeInterval, intervalStartTimestamp);
+                
+                
                 timeIntervalNum++;   
                 intervalStartTimestamp = lastPktTimestamp;
+                previousPacketCount = stats.getPacketCount();
             }
             
             stats.incrementPacketCount();

code_boost/src/cxx/statistics.cpp

@@ -188,6 +188,15 @@ void statistics::calculateLastIntervalPacketRate(std::chrono::duration<int, std:
         }
 }
 
+void statistics::addIntervalStat(std::chrono::duration<int, std::micro> interval, std::chrono::microseconds intervalStartTimestamp, int previousPacketCount){
+    //std::string filePath = "";
+    //calculateLastIntervalIPsEntropy(filePath, intervalStartTimestamp);
+    //calculateLastIntervalPacketRate(interval, intervalStartTimestamp);
+    std::string interval_start_str = std::to_string(intervalStartTimestamp.count());
+    interval_statistics[interval_start_str].pkts_count = packetCount - previousPacketCount;        
+}
+    
+    
 // Aidmar - incomplete
 /**
  * Calculate entropy for time intervals. After finishing statistics collecting, this method goes through
@@ -575,6 +584,13 @@ Tins::Timestamp statistics::getTimestampFirstPacket() {
 Tins::Timestamp statistics::getTimestampLastPacket() {
     return timestamp_lastPacket;
 }
+/**
+ * Getter for the packetCount field.
+ */
+int statistics::getPacketCount() {
+    return packetCount;
+}
+
 
 /**
  * Calculates the capture duration.
@@ -734,6 +750,7 @@ void statistics::writeToDatabase(std::string database_path) {
     db.writeStatisticsMss_dist(mss_distribution);
     db.writeStatisticsWin(win_distribution);
     db.writeStatisticsFlow(flow_statistics);
+    db.writeStatisticsInterval(interval_statistics);
 }
 
 /**

code_boost/src/cxx/statistics.h

@@ -180,7 +180,7 @@ struct entry_ipStat {
  * - IP destination entropy
  */
 struct entry_intervalStat {
-    long pkts_count;
+    int pkts_count;
     float ip_src_entropy;
     float ip_dst_entropy;
 
@@ -335,6 +335,7 @@ public:
     void addFlowStat(std::string ipAddressSender,int sport,std::string ipAddressReceiver,int dport, std::chrono::microseconds timestamp);
     void calculateLastIntervalIPsEntropy(std::string filePath, std::chrono::microseconds intervalStartTimestamp);
     void calculateLastIntervalPacketRate(std::chrono::duration<int, std::micro> interval, std::chrono::microseconds intervalStartTimestamp);
+    void addIntervalStat(std::chrono::duration<int, std::micro> interval, std::chrono::microseconds intervalStartTimestamp, int previousPacketCount);
 
     void incrementTTLcount(std::string ipAddress, int ttlValue);
 
@@ -357,6 +358,7 @@ public:
     
     // Aidmar
     void addIpStat_packetSent(std::string filePath, std::string ipAddressSender, std::string ipAddressReceiver, long bytesSent, std::chrono::microseconds timestamp);
+    int getPacketCount();
 
     void addMSS(std::string ipAddress, int MSSvalue);
 
@@ -400,6 +402,7 @@ private:
     std::unordered_map<ipAddress_win, int> win_distribution;
     // {IP Address A, Port A, IP Address B, Port B,   #packets_A_B, #packets_B_A}
     std::unordered_map<flow, entry_flowStat> flow_statistics;
+    std::unordered_map<std::string, entry_intervalStat> interval_statistics;
     
     // {IP Address, Protocol, count}
     std::unordered_map<ipAddress_protocol, int> protocol_distribution;

code_boost/src/cxx/statistics_db.cpp

@@ -360,39 +360,29 @@ void statistics_db::writeStatisticsFlow(std::unordered_map<flow, entry_flowStat>
 // Aidamr
 /**
  * Writes the interval statistics into the database.
- * @param intervalStatistics The flow from class statistics.
+ * @param intervalStatistics The interval entries from class statistics.
  */
 void statistics_db::writeStatisticsInterval(std::unordered_map<std::string, entry_intervalStat> intervalStatistics){          
-    try {
+    try {        
         db->exec("DROP TABLE IF EXISTS interval_statistics");
         SQLite::Transaction transaction(*db);
-        const char *createTable = "CREATE TABLE flow_statistics ("
-                "ipAddressA TEXT,"
-                "portA INTEGER,"
-                "ipAddressB TEXT,"              
-                "portB INTEGER,"
-                "pkts_A_B INTEGER,"
-                "pkts_B_A INTEGER,"
-                "medianDelay INTEGER,"
-                //"medianDelay TEXT,"
-                "PRIMARY KEY(ipAddressA,portA,ipAddressB,portB));";
+        const char *createTable = "CREATE TABLE interval_statistics ("
+                "timestamp TEXT,"
+                "pktsCount INTEGER,"
+                "ipSrcEntropy REAL,"      
+                "ipDstEntropy REAL,"  
+                "PRIMARY KEY(timestamp));";
         db->exec(createTable);
-        SQLite::Statement query(*db, "INSERT INTO flow_statistics VALUES (?, ?, ?, ?, ?, ?, ?)");
-        for (auto it = flowStatistics.begin(); it != flowStatistics.end(); ++it) {
-            flow f = it->first;
-            entry_flowStat e = it->second;
-            
-            // Compute the median delay
-            e.median_delay = e.pkts_delay[e.pkts_delay.size()/2];
+        SQLite::Statement query(*db, "INSERT INTO interval_statistics VALUES (?, ?, ?, ?)");
+        for (auto it = intervalStatistics.begin(); it != intervalStatistics.end(); ++it) {
+            std::string t = it->first;
+            entry_intervalStat e = it->second;        
             
-            query.bind(1, f.ipAddressA);
-            query.bind(2, f.portA);
-            query.bind(3, f.ipAddressB);
-            query.bind(4, f.portB);
-            query.bind(5, (int) e.pkts_A_B);
-            query.bind(6, (int) e.pkts_B_A);
-            query.bind(7, (int) e.median_delay.count());
-            //query.bind(7,  std::to_string(e.median_delay.count()));            
+            query.bind(1, t);
+            query.bind(2, (int)e.pkts_count);
+            query.bind(3, e.ip_src_entropy);
+            query.bind(4, e.ip_dst_entropy);
+
             query.exec();
             query.reset();
         }

id2t

@@ -4,4 +4,4 @@ ID2T_DIR=$(readlink -f $0)
 SCRIPT_PATH=${ID2T_DIR%/*}
 cd $SCRIPT_PATH
 # Execute ID2T
-exec ./code/CLI.py "$@" 
+exec ./code/CLI.py "$@"