unittests: fail if TCP memory still in use

abort() so test can be analyzed.

src/stream-tcp-reassemble.c

@@ -83,6 +83,11 @@ TcpSegment *StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *);
 void StreamTcpCreateTestPacket(uint8_t *, uint8_t, uint8_t, uint8_t);
 void StreamTcpReassemblePseudoPacketCreate(TcpStream *, Packet *, PacketQueue *);
 
+void StreamTcpReassembleInitMemuse(void)
+{
+    SC_ATOMIC_INIT(ra_memuse);
+}
+
 /**
  *  \brief  Function to Increment the memory usage counter for the TCP reassembly
  *          segments
@@ -387,7 +392,7 @@ int StreamTcpReassemblyConfig(char quiet)
 int StreamTcpReassembleInit(char quiet)
 {
     /* init the memcap/use tracker */
-    SC_ATOMIC_INIT(ra_memuse);
+    StreamTcpReassembleInitMemuse();
 
     if (StreamTcpReassemblyConfig(quiet) < 0)
         return -1;

src/stream-tcp-reassemble.h

@@ -75,6 +75,7 @@ typedef struct TcpReassemblyThreadCtx_ {
 
 #define OS_POLICY_DEFAULT   OS_POLICY_BSD
 
+void StreamTcpReassembleInitMemuse(void);
 int StreamTcpReassembleHandleSegment(ThreadVars *, TcpReassemblyThreadCtx *, TcpSession *, TcpStream *, Packet *, PacketQueue *);
 int StreamTcpReassembleInit(char);
 void StreamTcpReassembleFree(char);
@@ -108,6 +109,7 @@ int StreamTcpReassembleDepthReached(Packet *p);
 void StreamTcpReassembleIncrMemuse(uint64_t size);
 void StreamTcpReassembleDecrMemuse(uint64_t size);
 int StreamTcpReassembleCheckMemcap(uint32_t size);
+uint64_t StreamTcpReassembleMemuseGlobalCounter(void);
 
 void StreamTcpDisableAppLayer(Flow *f);
 int StreamTcpAppLayerIsDisabled(Flow *f);

src/stream-tcp.c

@@ -119,6 +119,11 @@ SC_ATOMIC_DECLARE(uint64_t, st_memuse);
 /* stream engine running in "inline" mode. */
 int stream_inline = 0;
 
+void StreamTcpInitMemuse(void)
+{
+    SC_ATOMIC_INIT(st_memuse);
+}
+
 void StreamTcpIncrMemuse(uint64_t size)
 {
     (void) SC_ATOMIC_ADD(st_memuse, size);
@@ -598,7 +603,7 @@ void StreamTcpInitConfig(char quiet)
         SCLogConfig("stream.reassembly.raw: %s", enable_raw ? "enabled" : "disabled");
 
     /* init the memcap/use tracking */
-    SC_ATOMIC_INIT(st_memuse);
+    StreamTcpInitMemuse();
     StatsRegisterGlobalCounter("tcp.memuse", StreamTcpMemuseCounter);
 
     StreamTcpReassembleInit(quiet);

src/stream-tcp.h

@@ -103,9 +103,11 @@ void StreamTcpRegisterTests (void);
 
 void StreamTcpSessionPktFree (Packet *);
 
+void StreamTcpInitMemuse(void);
 void StreamTcpIncrMemuse(uint64_t);
 void StreamTcpDecrMemuse(uint64_t);
 int StreamTcpCheckMemcap(uint64_t);
+uint64_t StreamTcpMemuseCounter(void);
 uint64_t StreamTcpReassembleMemuseGlobalCounter(void);
 
 Packet *StreamTcpPseudoSetup(Packet *, uint8_t *, uint32_t);

src/util-unittest.c

@@ -39,6 +39,9 @@
 #include "util-time.h"
 #include "conf.h"
 
+#include "stream-tcp.h"
+#include "stream-tcp-reassemble.h"
+
 #ifdef UNITTESTS
 
 static pcre *parse_regex;
@@ -192,6 +195,9 @@ uint32_t UtRunTests(char *regex_arg)
     int ret = 0, rcomp = 0;
     int ov[MAX_SUBSTRINGS];
 
+    StreamTcpInitMemuse();
+    StreamTcpReassembleInitMemuse();
+
     rcomp = UtRegex(regex_arg);
 
     if(rcomp == 1){
@@ -207,7 +213,19 @@ uint32_t UtRunTests(char *regex_arg)
                 TimeSetToCurrentTime();
 
                 ret = ut->TestFn();
+
+                if (StreamTcpMemuseCounter() != 0) {
+                    printf("STREAM MEMORY IN USE %"PRIu64"\n", StreamTcpMemuseCounter());
+                    ret = 0;
+                }
+
+                if (StreamTcpReassembleMemuseGlobalCounter() != 0) {
+                    printf("STREAM REASSEMBLY MEMORY IN USE %"PRIu64"\n", StreamTcpReassembleMemuseGlobalCounter());
+                    ret = 0;
+                }
+
                 printf("%s\n", ret ? "pass" : "FAILED");
+
                 if (!ret) {
                     if (unittests_fatal == 1) {
                         fprintf(stderr, "ERROR: unittest failed.\n");