Making final changes to the bug fix.

diff --git a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2ClusterMatcher.java b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2ClusterMatcher.java
index ab5f148f46d2809c6bba80ae1e89ae200f2b6585..bec7840723ce683c9c5bf00ab4f7929977ef7498 100644 (file)
--- a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2ClusterMatcher.java
+++ b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2ClusterMatcher.java
@@ -175,7 +175,8 @@ public class Layer2ClusterMatcher extends AbstractClusterMatcher implements Laye
             listMatchers.add(newMatcher);
         }
         // Present packet to the sequence matchers.
-        // Make a shallow copy of the list so that we can clean up the actual list when a matcher is terminated
+        // Make a shallow copy of the list so that we can clean up the actual list when a matcher is terminated.
+        // Otherwise, we would get an exception for changing the list while iterating on it.
         List<Layer2RangeMatcher> listMatchersCopy = new ArrayList<>(listMatchers);
         for(Layer2RangeMatcher matcher : listMatchersCopy) {
             Layer2RangeMatcher sm = matcher;
@@ -200,79 +201,6 @@ public class Layer2ClusterMatcher extends AbstractClusterMatcher implements Laye
         }
     }
 
-//    private void rangeBasedMatching(Layer2Flow flow, PcapPacket newPacket) {
-//        // TODO: For range-based matching, we only care about matching a range; therefore it is a matcher array.
-//        if (mPerFlowRangeMatcher.get(flow) == null) {
-//            // If this is the first time we encounter this flow, we need to set up a sequence matcher.
-//            // All sequences of the cluster have the same length, so we only need to compute the length of the
-//            // arrays once. We want to make room for a cluster matcher in each state, including the initial empty state
-//            // but excluding the final "full match" state (as there is no point in keeping a terminated sequence matcher
-//            // around), so the length of the array is simply the sequence length.
-//            Layer2RangeMatcher[] matcher = new Layer2RangeMatcher[mCluster.get(0).size()];
-//            // Prepare a "state 0" sequence matcher.
-//            matcher[0] = new Layer2RangeMatcher(mCluster.get(0), mCluster.get(1), mInclusionTimeMillis, mEps);
-//            // Associate the new sequence matcher table with the new flow.
-//            mPerFlowRangeMatcher.put(flow, matcher);
-//        }
-//        // Fetch table that contains sequence matchers for this flow.
-//        Layer2RangeMatcher[] matcher = mPerFlowRangeMatcher.get(flow);
-//        // Present packet to the sequence matcher.
-//        for (int j = matcher.length - 1; j >= 0; j--) {
-//            Layer2RangeMatcher sm = matcher[j];
-//            if (sm == null) {
-//                // There is currently no sequence matcher that has managed to match j packets.
-//                continue;
-//            }
-//            boolean matched = sm.matchPacket(newPacket);
-//
-//            // TODO: DEBUGGING
-//            long timeStamp = newPacket.getTimestamp().getEpochSecond();
-//            if (339 == newPacket.length() && timeStamp == 1542297773) {
-//                System.out.println("Timestamp of length 339: " + newPacket.getTimestamp().getEpochSecond());
-//                int length = matcher.length;
-//            }
-//            if (329 == newPacket.length() && timeStamp == 1542297773) {
-//                System.out.println("Timestamp of length 329: " + newPacket.getTimestamp().getEpochSecond());
-//            }
-//            if (364 <= newPacket.length() && newPacket.length() <= 365 && timeStamp == 1542297773) {
-//                System.out.println("Timestamp of length 364-365: " + newPacket.getTimestamp().getEpochSecond());
-//            }
-//            if (1061 <= newPacket.length() && newPacket.length() <= 1070 && timeStamp == 1542297773) {
-//                System.out.println("Timestamp of length 1061-1070: " + newPacket.getTimestamp().getEpochSecond());
-//            }
-//            // TODO: DEBUGGING
-//
-//            if (matched) {
-//                if (sm.getMatchedPacketsCount() == sm.getTargetSequencePacketCount()) {
-//                    // Sequence matcher has a match. Report it to observers.
-//                    mObservers.forEach(o -> o.onMatch(this, sm.getMatchedPackets()));
-//                    // Remove the now terminated sequence matcher.
-//                    matcher[j] = null;
-//                } else {
-//                    // Sequence matcher advanced one step, so move it to its corresponding new position iff the
-//                    // packet that advanced it has a later timestamp than that of the last matched packet of the
-//                    // sequence matcher at the new index, if any. In most traces, a small amount of the packets
-//                    // appear out of order (with regards to their timestamp), which is why this check is required.
-//                    // Obviously it would not be needed if packets where guaranteed to be processed in timestamp
-//                    // order here.
-//                    if (matcher[j+1] == null ||
-//                            newPacket.getTimestamp().isAfter(matcher[j+1].getLastPacket().getTimestamp())) {
-//                        matcher[j+1] = sm;
-//                        if (matcher[j+1].getTargetUpperBound().size() == 4 && matcher[j+1].mMatchedPackets.size() > 1) {
-//                            System.out.println("Got here");
-//                        }
-//                    }
-//                }
-//                // We always want to have a sequence matcher in state 0, regardless of if the one that advanced
-//                // from state zero completed its matching or if it replaced a different one in state 1 or not.
-//                if (sm.getMatchedPacketsCount() == 1) {
-//                    matcher[j] = new Layer2RangeMatcher(sm.getTargetLowerBound(), sm.getTargetUpperBound(),
-//                            mInclusionTimeMillis, mEps);
-//                }
-//            }
-//        }
-//    }
-
     @Override
     protected List<List<PcapPacket>> pruneCluster(List<List<PcapPacket>> cluster) {
         // Note: we assume that all sequences in the input cluster are of the same length and that their packet

diff --git a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2RangeMatcher.java b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2RangeMatcher.java
index 32bb732c174aa387246d5e40eb3bcd17240fcfa1..5f92df785183a0eaa66f54a2308eed49737feca1 100644 (file)
--- a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2RangeMatcher.java
+++ b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2RangeMatcher.java
@@ -73,8 +73,6 @@ public class Layer2RangeMatcher extends Layer2AbstractMatcher {
         PcapPacket expectedUpperBound = mUpperBound.get(mMatchedPackets.size());
         int lowerBound = expectedLowerBound.getOriginalLength();
         int upperBound = expectedUpperBound.getOriginalLength();
-//        int lowerBound = expectedLowerBound.getOriginalLength() - (int) mEps;
-//        int upperBound = expectedUpperBound.getOriginalLength() + (int) mEps;
         // Do strict matching if the lower and upper bounds are the same length
         // Do range matching with eps otherwise
         if (lowerBound != upperBound) {
@@ -105,8 +103,6 @@ public class Layer2RangeMatcher extends Layer2AbstractMatcher {
             if (!packet.getTimestamp().isAfter(mMatchedPackets.get(getMatchedPacketsCount()-1).getTimestamp())) {
                 return false;
             }
-//            if (packet.getTimestamp().isAfter(mMatchedPackets.get(0).getTimestamp().
-//                    plusMillis(TriggerTrafficExtractor.INCLUSION_WINDOW_MILLIS))) {
             if (packet.getTimestamp().isAfter(mMatchedPackets.get(0).getTimestamp().
                     plusMillis(mInclusionTimeMillis))) {
                 return false;

diff --git a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2SignatureDetector.java b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2SignatureDetector.java
index 362fd25381bf0d6667d06fef73708ceb8e0c52fe..83b5b91383c932d0f3584c71ee4b5f3888b7c439 100644 (file)
--- a/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2SignatureDetector.java
+++ b/Code/Projects/PacketLevelSignatureExtractor/src/main/java/edu/uci/iotproject/detection/layer2/Layer2SignatureDetector.java
@@ -162,9 +162,6 @@ public class Layer2SignatureDetector implements PacketListener, ClusterMatcherOb
         offDetector.addObserver((signature, match) -> {
             UserAction event = new UserAction(UserAction.Type.TOGGLE_OFF, match.get(0).get(0).getTimestamp());
             PrintWriterUtils.println(event, resultsWriter, DUPLICATE_OUTPUT_TO_STD_OUT);
-//            for (PcapPacket pcap : match.get(0)) {
-//                System.out.println(pcap.length() + " -> " + pcap.getTimestamp());
-//            }
             detectedEvents.add(event);
         });