p_s->Total_Out = 20;
p_s->Decompr_Depth = 10;
REQUIRE(File_Decomp_SetBuf(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
TEST_CASE("File_Decomp_SetBuf-Compr_Depth-error", "[file_decomp]")
p_s->Total_In = 20;
p_s->Compr_Depth = 10;
REQUIRE(File_Decomp_SetBuf(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
TEST_CASE("File_Decomp_New", "[file_decomp]")
REQUIRE(p_s->Avail_Out == 0);
REQUIRE(p_s->Next_In == NULL);
REQUIRE(p_s->Next_Out == NULL);
+ File_Decomp_Free(p_s);
}
TEST_CASE("File_Decomp-null", "[file_decomp]")
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
REQUIRE(File_Decomp(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
TEST_CASE("File_Decomp-complete_state", "[file_decomp]")
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
p_s->State = STATE_COMPLETE;
REQUIRE(File_Decomp(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
TEST_CASE("Initialize_Decompression-not_active", "[file_decomp]")
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
REQUIRE(Initialize_Decompression(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
TEST_CASE("Process_Decompression-not_active", "[file_decomp]")
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
REQUIRE(Process_Decompression(p_s) == File_Decomp_Error);
+ File_Decomp_Free(p_s);
}
#endif
#ifdef UNIT_TEST
-TEST_CASE("File_Decomp_PDF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_PDF-null", "[file_decomp_pdf]")
{
REQUIRE(File_Decomp_PDF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_Init_PDF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_Init_PDF-null", "[file_decomp_pdf]")
{
REQUIRE(File_Decomp_Init_PDF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_End_PDF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_End_PDF-null", "[file_decomp_pdf]")
{
REQUIRE(File_Decomp_End_PDF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_PDF-not_pdf-error", "[file_decomp]")
+TEST_CASE("File_Decomp_PDF-not_pdf-error", "[file_decomp_pdf]")
{
fd_session_p_t p_s;
p_s->PDF = (fd_PDF_t*)snort_calloc(sizeof(fd_PDF_t));
p_s->File_Type = FILE_TYPE_SWF;
REQUIRE(File_Decomp_PDF(p_s) == File_Decomp_Error);
- snort_free(p_s->PDF);
+ p_s->File_Type = FILE_TYPE_PDF;
+ File_Decomp_Free(p_s);
}
-TEST_CASE("File_Decomp_PDF-bad_state-error", "[file_decomp]")
+TEST_CASE("File_Decomp_PDF-bad_state-error", "[file_decomp_pdf]")
{
fd_session_p_t p_s;
p_s->File_Type = FILE_TYPE_PDF;
p_s->PDF->State = PDF_STATE_NEW;
REQUIRE(File_Decomp_PDF(p_s) == File_Decomp_Error);
- snort_free(p_s->PDF);
+ File_Decomp_Free(p_s);
}
-TEST_CASE("File_Decomp_End_PDF-bad_type-error", "[file_decomp]")
+TEST_CASE("File_Decomp_End_PDF-bad_type-error", "[file_decomp_pdf]")
{
fd_session_p_t p_s;
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
p_s->PDF = (fd_PDF_t*)snort_calloc(sizeof(fd_PDF_t));
+ p_s->File_Type = FILE_TYPE_PDF;
p_s->PDF->Decomp_Type = FILE_COMPRESSION_TYPE_LZMA;
p_s->PDF->State = PDF_STATE_PROCESS_STREAM;
REQUIRE(File_Decomp_End_PDF(p_s) == File_Decomp_Error);
- snort_free(p_s->PDF);
+ File_Decomp_Free(p_s);
}
#endif
#ifdef UNIT_TEST
-TEST_CASE("File_Decomp_SWF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_SWF-null", "[file_decomp_swf]")
{
REQUIRE(File_Decomp_SWF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_Init_SWF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_Init_SWF-null", "[file_decomp_swf]")
{
REQUIRE(File_Decomp_Init_SWF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_End_SWF-null", "[file_decomp]")
+TEST_CASE("File_Decomp_End_SWF-null", "[file_decomp_swf]")
{
REQUIRE(File_Decomp_End_SWF((fd_session_p_t)NULL) == File_Decomp_Error);
}
-TEST_CASE("File_Decomp_SWF-not_swf-error", "[file_decomp]")
+TEST_CASE("File_Decomp_SWF-not_swf-error", "[file_decomp_swf]")
{
fd_session_p_t p_s;
p_s->SWF = (fd_SWF_t*)snort_calloc(sizeof(fd_SWF_t));
p_s->File_Type = FILE_TYPE_PDF;
REQUIRE(File_Decomp_SWF(p_s) == File_Decomp_Error);
- snort_free(p_s->SWF);
+ p_s->File_Type = FILE_TYPE_SWF;
+ File_Decomp_Free(p_s);
}
-TEST_CASE("File_Decomp_SWF-bad_state-error", "[file_decomp]")
+TEST_CASE("File_Decomp_SWF-bad_state-error", "[file_decomp_swf]")
{
fd_session_p_t p_s;
p_s->File_Type = FILE_TYPE_SWF;
p_s->SWF->State = SWF_STATE_NEW;
REQUIRE(File_Decomp_SWF(p_s) == File_Decomp_Error);
- snort_free(p_s->SWF);
+ File_Decomp_Free(p_s);
}
-TEST_CASE("File_Decomp_Init_SWF-bad_type-error", "[file_decomp]")
+TEST_CASE("File_Decomp_Init_SWF-bad_type-error", "[file_decomp_swf]")
{
fd_session_p_t p_s;
REQUIRE((p_s = File_Decomp_New()) != (fd_session_p_t)NULL);
- p_s->SWF = (fd_SWF_t*)snort_calloc(sizeof(fd_SWF_t));
+ p_s->File_Type = FILE_TYPE_SWF;
p_s->Decomp_Type = FILE_COMPRESSION_TYPE_DEFLATE;
REQUIRE(File_Decomp_Init_SWF(p_s) == File_Decomp_Error);
- snort_free(p_s->SWF);
+ File_Decomp_Free(p_s);
}
-TEST_CASE("File_Decomp_End_SWF-bad_type-error", "[file_decomp]")
+TEST_CASE("File_Decomp_End_SWF-bad_type-error", "[file_decomp_swf]")
{
fd_session_p_t p_s;
p_s->SWF = (fd_SWF_t*)snort_calloc(sizeof(fd_SWF_t));
p_s->Decomp_Type = FILE_COMPRESSION_TYPE_DEFLATE;
REQUIRE(File_Decomp_End_SWF(p_s) == File_Decomp_Error);
- snort_free(p_s->SWF);
+ p_s->File_Type = FILE_TYPE_SWF;
+ File_Decomp_Free(p_s);
}
+
#endif
#include "catch/catch.hpp"
-#include "main/snort_types.h"
-#include "main/snort_config.h"
#include "detection/rules.h"
#include "detection/treenodes.h"
-#include "sfip/sf_ip.h"
-#include "parser/parse_ip.h"
+#include "filters/rate_filter.h"
#include "filters/sfrf.h"
-#include "utils/util.h"
#include "hash/sfghash.h"
+#include "main/snort_types.h"
+#include "main/policy.h"
+#include "parser/parse_ip.h"
+#include "sfip/sf_ip.h"
+#include "utils/util.h"
//---------------------------------------------------------------
int expect;
} EventData;
-static RateFilterConfig rfc;
+static RateFilterConfig* rfc = nullptr;
//---------------------------------------------------------------
}
exit(0);
}
-
#endif
//---------------------------------------------------------------
static void Init(unsigned cap)
{
- unsigned i;
-
- memset(&rfc, 0, sizeof(rfc));
- rfc.memcap = cap;
-
- for ( i = 0; i < NUM_NODES; i++ )
+ // FIXIT-L must set policies because they may have been invalidated
+ // by prior tests with transient SnortConfigs. better to fix sfrf
+ // to use a SnortConfig parameter or make this a make check test
+ // with a separate executable.
+ set_default_policy();
+ rfc = RateFilter_ConfigNew();
+ rfc->memcap = cap;
+
+ for ( unsigned i = 0; i < NUM_NODES; i++ )
{
RateData* p = rfData + i;
tSFRFConfigNode cfg;
cfg.timeout = p->timeout;
cfg.applyTo = p->ip ? sfip_var_from_string(p->ip) : NULL;
- p->create = SFRF_ConfigAdd(snort_conf, &rfc, &cfg);
+ p->create = SFRF_ConfigAdd(nullptr, rfc, &cfg);
}
}
static void Term()
{
- int i;
-
- for (i = 0; i < SFRF_MAX_GENID; i++)
- {
- SFGHASH** h = rfc.genHash + i;
- if ( *h )
- sfghash_delete(*h);
- *h = NULL;
- }
SFRF_Delete();
+ RateFilter_ConfigFree(rfc);
+ rfc = nullptr;
}
static int SetupCheck(int i)
sfip_pton(p->dip, &dip);
status = SFRF_TestThreshold(
- &rfc, p->gid, p->sid, &sip, &dip, curtime, op);
+ rfc, p->gid, p->sid, &sip, &dip, curtime, op);
if ( status >= RULE_TYPE__MAX )
status -= RULE_TYPE__MAX;
return (ThresholdObjects*)snort_calloc(sizeof(ThresholdObjects));
}
-static void sfthd_node_free(void* node)
+void sfthd_node_free(void* node)
{
THD_NODE* sfthd_node = (THD_NODE*)node;
int count,
unsigned int seconds
);
+void sfthd_node_free(void*);
struct SnortConfig;
int sfthd_create_threshold(
#include "catch/catch.hpp"
-#include "sfip/sf_ip.h"
-#include "parser/parse_ip.h"
#include "filters/sfthd.h"
+#include "hash/sfxhash.h"
+#include "main/policy.h"
+#include "parser/parse_ip.h"
+#include "sfip/sf_ip.h"
#include "utils/util.h"
-#include "main/snort_config.h"
//---------------------------------------------------------------
static void Init(ThreshData* base, int max)
{
+ // FIXIT-L must set policies because they may have been invalidated
+ // by prior tests with transient SnortConfigs. better to fix sfthd
+ // to use a SnortConfig parameter or make this a make check test
+ // with a separate executable.
+ set_default_policy();
+
int i;
int id = 0;
{
sfip_var_t* set = p->ip ? sfip_var_from_string(p->ip) : NULL;
- p->create = sfthd_create_threshold(snort_conf,
+ p->create = sfthd_create_threshold(nullptr,
pThdObjs, p->gid, p->sid, p->tracking, p->type, PRIORITY,
p->count, p->seconds, set);
pThdObjs = NULL;
sfthd_free(pThd);
pThd = NULL;
+
+ for ( unsigned i = 0; i < NUM_RULS; i++ )
+ {
+ ThreshData* p = ruleData + i;
+
+ if ( p->rule )
+ {
+ sfthd_node_free(p->rule);
+ p->rule = nullptr;
+ }
+ }
+ sfxhash_delete(dThd);
}
static int SetupCheck(int i)
TEST_CASE("safety", "[trace]")
{
Trace TRACE_NAME(testing) = TRACE_SECTION_2 | TRACE_SECTION_3;
-
- char* message = new char[STD_BUF + 1];
+ char message[STD_BUF + 1];
for( int i = 0; i < STD_BUF; i++ )
message[i] = 'A';
testing_dump[0] = '\0';
trace_log(testing, message);
CHECK( strlen(testing_dump) == STD_BUF - 1 );
-
- delete message;
}
#endif
+
tc.implement_thread_affinity(STHREAD_TYPE_MAIN, 0);
hwloc_get_cpubind(topology, thread_cpuset, HWLOC_CPUBIND_THREAD);
CHECK(hwloc_bitmap_isequal(thread_cpuset, process_cpuset));
+
+ hwloc_bitmap_free(thread_cpuset);
}
}
#include "sfdaq_module.h"
+#include <assert.h>
+
#include "log/messages.h"
#include "main/snort_config.h"
{
if (!strcmp(fqn, "daq"))
config = new SFDAQConfig();
+
else if (!strcmp(fqn, "daq.instances"))
{
if (idx == 0)
return true;
+
+ assert(!instance_config);
instance_config = new SFDAQInstanceConfig();
+
instance_id = -1;
}
-
return true;
}
{
if (idx == 0)
return true;
- if (instance_id < 0)
+
+ if (instance_id < 0 or config->instances[instance_id])
{
- ParseError("%s - no DAQ instance ID specified", fqn);
+ ParseError("%s - duplicate or no DAQ instance ID specified", fqn);
+ delete instance_config;
+ instance_config = nullptr;
return false;
}
config->instances[instance_id] = instance_config;
{
if ( sc->daq_config )
delete sc->daq_config;
+
sc->daq_config = config;
config = nullptr;
}
Value no_promisc(true);
CHECK(sfdm.set("daq.no_promisc", no_promisc, &sc));
+ CHECK(sfdm.begin("daq.instances", 0, &sc));
CHECK(sfdm.begin("daq.instances", 1, &sc));
- CHECK_FALSE(sfdm.end("daq.instances", 1, &sc));
- CHECK(sfdm.begin("daq.instances", 1, &sc));
+ CHECK_FALSE(sfdm.end("daq.instances", 1, &sc));
+ CHECK(sfdm.begin("daq.instances", 2, &sc));
Value instance_id(static_cast<double>(5));
CHECK(sfdm.set("daq.instances.id", instance_id, &sc));
CHECK(sfdm.set("daq.instances.variables", instance_var1, &sc));
CHECK(sfdm.set("daq.instances.variables", instance_var2, &sc));
- CHECK(sfdm.end("daq.instances", 1, &sc));
+ CHECK(sfdm.end("daq.instances", 2, &sc));
+ CHECK(sfdm.end("daq.instances", 0, &sc));
CHECK(sfdm.end("daq", 0, &sc));
/* Validate the configuration */
//--------------------------------------------------------------------------
#ifdef UNIT_TEST
+// FIXIT-L these var tests are inadequate
TEST_CASE("config_set_var-success", "[vars]")
{
- SnortConfig* sc = new SnortConfig;
+ SnortConfig sc;
+ sc.var_list = NULL;
+ config_set_var(&sc, "A=B");
- sc->var_list = NULL;
-
- config_set_var(sc, "A=B");
-
- REQUIRE(sc->var_list != NULL);
- REQUIRE(sc->var_list->name != NULL);
- REQUIRE(sc->var_list->value != NULL);
- REQUIRE(*(sc->var_list->name) == 'A');
- REQUIRE(*(sc->var_list->value) == 'B');
+ REQUIRE(sc.var_list->name[0] == 'A');
+ REQUIRE(sc.var_list->value[0] == 'B');
}
TEST_CASE("config_set_var-existing-success", "[vars]")
{
- SnortConfig* sc = new SnortConfig;
- VarNode* vn1 = new VarNode;
- VarNode* vn2 = new VarNode;
-
- sc->var_list = vn1;
- vn1->name = (char*)"C";
- vn1->next = vn2;
- vn2->name = (char*)"D";
- vn2->next = NULL;
-
- config_set_var(sc, "A=B");
-
- REQUIRE(sc->var_list != NULL);
- REQUIRE(sc->var_list->name != NULL);
- REQUIRE(sc->var_list->value != NULL);
- REQUIRE(*(sc->var_list->name) == 'A');
- REQUIRE(*(sc->var_list->value) == 'B');
+ SnortConfig sc;
+
+ config_set_var(&sc, "C=D");
+ config_set_var(&sc, "A=B");
+
+ REQUIRE(sc.var_list->name[0] == 'A');
+ REQUIRE(sc.var_list->value[0] == 'B');
}
+// FIXIT-L missing CHECKs / REQUIREs
TEST_CASE("config_set_var-duplicate-error", "[vars]")
{
- SnortConfig* sc = new SnortConfig;
- VarNode* vn1 = new VarNode;
- VarNode* vn2 = new VarNode;
-
- sc->var_list = vn1;
- vn1->name = (char*)"C";
- vn1->next = vn2;
- vn2->name = (char*)"A";
- vn2->next = NULL;
-
- config_set_var(sc, "A=B");
+ SnortConfig sc;
+ config_set_var(&sc, "A=B");
}
TEST_CASE("config_set_var-no_equals_sign-error", "[vars]")
{
- SnortConfig* sc = new SnortConfig;
-
- config_set_var(sc, "A");
+ SnortConfig sc;
+ config_set_var(&sc, "A");
}
#endif
+
#include "framework/cursor.h"
+// FIXIT-L these tests need some TLC
TEST_CASE("IPS Stream Reassemble", "[ips_stream_reassemble][stream_tcp]")
{
// initialization code here
== STREAM_FLPOLICY_IGNORE ) );
}
#endif
+ delete pkt->flow->session;
+ delete pkt;
+ delete flow;
+ ips_stream_reassemble->mod_dtor(reassembler);
}
#endif
projects / thirdparty / snort3.git / commitdiff
