Check out of bounds for inactive type1 packet

Author: magnusedgeware

ElasticFrameProtocol.cpp

@@ -168,8 +168,7 @@ ElasticFrameProtocolReceiver::unpackType1(const uint8_t *pSubPacket, size_t lPac
             return ElasticFrameMessages::memoryAllocationError;
         }
 
-        if (pThisBucket->mOfFragmentNo < lType1Frame->hFragmentNo ||
-            lType1Frame->hOfFragmentNo != pThisBucket->mOfFragmentNo) {
+        if (pThisBucket->mOfFragmentNo < lType1Frame->hFragmentNo) {
             EFP_LOGGER(true, LOGG_FATAL, "bufferOutOfBounds")
             mBucketMap.erase(pThisBucket->mDeliveryOrder);
             pThisBucket->mActive = false;
@@ -338,7 +337,7 @@ ElasticFrameProtocolReceiver::unpackType2(const uint8_t *pSubPacket, size_t lPac
     return ElasticFrameMessages::noError;
 }
 
-// Unpack method for type3 packets. Type3 packets are the parts of frames where the reminder data does not fit a type2 packet. Then a type 3 is added
+// Unpack method for type3 packets. Type3 packets are the parts of frames where the remainder data does not fit a type2 packet. Then a type 3 is added
 // in front of a type2 packet to catch the data overshoot.
 // Type 3 frames MUST be the same header size as type1 headers (FIXME part of the opportunistic data discussion)
 ElasticFrameMessages

unitTests/UnitTest24.cpp

@@ -1,28 +1,42 @@
 #include <gtest/gtest.h>
 
 #include <memory>
+#include <random>
 
 #include "ElasticFrameProtocol.h"
-#include "ElasticInternal.h"
 #include "UnitTestHelpers.h"
 
 // UnitTest24
-// Test unpack type1 packet
-TEST(UnitTest24, UnpackType1) {
-  const size_t FRAME_SIZE = ((MTU - ElasticFrameProtocolSender::getType1Size()) * 5) + 12;
+// Test receiving corrupted packages
+TEST(UnitTest24, SendPacketFrameType1AndFrameType2) {
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<uint8_t> dis(0, 255);
+
+  const size_t FRAME_SIZE =
+      (MTU - ElasticFrameProtocolSender::getType1Size()) + 1;
   std::unique_ptr<ElasticFrameProtocolReceiver> myEFPReceiver =
       std::make_unique<ElasticFrameProtocolReceiver>(50, 20);
-  ElasticFrameType1 lType1Frame;
+  std::unique_ptr<ElasticFrameProtocolSender> myEFPPacker =
+      std::make_unique<ElasticFrameProtocolSender>(MTU);
+
+  for (int i = 0; i < 10000; i++) {
+    myEFPPacker->sendCallback = [&](const std::vector<uint8_t> &subPacket,
+                                    uint8_t lStreamID,
+                                    ElasticFrameProtocolContext *pCTX) {
+      std::vector<uint8_t> garbage = subPacket;
+      for (size_t b = 0; b < garbage.size(); b++) {
+        garbage[b] = dis(gen);
+      }
+      ElasticFrameMessages info = myEFPReceiver->receiveFragment(garbage, 0);
+    };
 
-  // test with nice type1 packet
-  lType1Frame.hSuperFrameNo = 0;
-  lType1Frame.hFrameType = Frametype::type1;
-  ElasticFrameMessages result = myEFPReceiver->receiveFragmentFromPtr(reinterpret_cast<uint8_t*>(&lType1Frame), FRAME_SIZE, 0);
-  EXPECT_EQ(result, ElasticFrameMessages::noError);
+    std::vector<uint8_t> mydata;
+    mydata.resize(FRAME_SIZE);
 
-  // test with corrupt type1 packet
-  lType1Frame.hSuperFrameNo = 1;
-  lType1Frame.hFragmentNo = 12345;
-  result = myEFPReceiver->receiveFragmentFromPtr(reinterpret_cast<uint8_t*>(&lType1Frame), FRAME_SIZE, 0);
-  EXPECT_EQ(result, ElasticFrameMessages::bufferOutOfBounds);
+    uint8_t streamID = 4;
+    ElasticFrameMessages result = myEFPPacker->packAndSend(
+        mydata, ElasticFrameContent::adts, 1001, 1, 2, streamID, NO_FLAGS);
+    EXPECT_EQ(result, ElasticFrameMessages::noError);
+  }
 }