From: Mike Stepanek (mstepane) Date: Tue, 26 Mar 2019 13:33:37 +0000 (-0400) Subject: Merge pull request #1555 in SNORT/snort3 from ~PSHINDE2/snort3:stash_generic_object... X-Git-Tag: 3.0.0-251~10 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=d01bb3f4cdcc0ba6ffe378a04f2f9bd10d13297b;p=thirdparty%2Fsnort3.git Merge pull request #1555 in SNORT/snort3 from ~PSHINDE2/snort3:stash_generic_object to master Squashed commit of the following: commit 2d8ecbc8af7f804f5825fb3110e6b247524f7221 Author: Pratik Shinde Date: Tue Mar 19 14:52:32 2019 -0400 flow: Added a support to store generic objects in a stash --- diff --git a/src/flow/flow_stash.cc b/src/flow/flow_stash.cc index 59c033eaa..5ab509285 100644 --- a/src/flow/flow_stash.cc +++ b/src/flow/flow_stash.cc @@ -49,6 +49,11 @@ bool FlowStash::get(const string& key, string& val) return get(key, val, STASH_ITEM_TYPE_STRING); } +bool FlowStash::get(const std::string& key, StashGenericObject* &val) +{ + return get(key, val, STASH_ITEM_TYPE_GENERIC_OBJECT); +} + void FlowStash::store(const string& key, int32_t val) { store(key, val, STASH_ITEM_TYPE_INT32); @@ -59,19 +64,35 @@ void FlowStash::store(const string& key, const string& val) store(key, val, STASH_ITEM_TYPE_STRING); } -void FlowStash::store(const std::string& key, std::string* val) +void FlowStash::store(const std::string& key, StashGenericObject* val) { + store(key, val, STASH_ITEM_TYPE_GENERIC_OBJECT); +} + +void FlowStash::store(const string& key, StashGenericObject* &val, StashItemType type) +{ +#ifdef NDEBUG + UNUSED(type); +#endif auto item = new StashItem(val); auto it_and_status = container.emplace(make_pair(key, item)); if (!it_and_status.second) { - assert(it_and_status.first->second->get_type() == STASH_ITEM_TYPE_STRING); + StashGenericObject* stored_object; + assert(it_and_status.first->second->get_type() == type); + it_and_status.first->second->get_val(stored_object); + assert(stored_object->get_object_type() == val->get_object_type()); delete it_and_status.first->second; it_and_status.first->second = item; } } +void FlowStash::store(const std::string& key, std::string* val) +{ + store(key, val, STASH_ITEM_TYPE_STRING); +} + template bool FlowStash::get(const string& key, T& val, StashItemType type) { diff --git a/src/flow/flow_stash.h b/src/flow/flow_stash.h index 2373aa2aa..5e53d9844 100644 --- a/src/flow/flow_stash.h +++ b/src/flow/flow_stash.h @@ -28,17 +28,21 @@ #include "stash_item.h" -namespace snort { +namespace snort +{ -class FlowStash { +class FlowStash +{ public: ~FlowStash(); void reset(); bool get(const std::string& key, int32_t& val); bool get(const std::string& key, std::string& val); + bool get(const std::string& key, StashGenericObject* &val); void store(const std::string& key, int32_t val); void store(const std::string& key, const std::string& val); void store(const std::string& key, std::string* val); + void store(const std::string& key, StashGenericObject* val); private: std::map container; @@ -47,6 +51,7 @@ private: bool get(const std::string& key, T& val, StashItemType type); template void store(const std::string& key, T& val, StashItemType type); + void store(const std::string& key, StashGenericObject* &val, StashItemType type); }; } diff --git a/src/flow/stash_item.h b/src/flow/stash_item.h index a1ec98a84..df26f0f47 100644 --- a/src/flow/stash_item.h +++ b/src/flow/stash_item.h @@ -24,23 +24,41 @@ #include #include -namespace snort { +namespace snort +{ -enum StashItemType { +class StashGenericObject +{ +public: + StashGenericObject(int type) : object_type(type) + { + + } + + int get_object_type() + { + return object_type; + } +private: + int object_type; +}; + +enum StashItemType +{ STASH_ITEM_TYPE_INT32, - STASH_ITEM_TYPE_STRING + STASH_ITEM_TYPE_STRING, + STASH_ITEM_TYPE_GENERIC_OBJECT }; -union StashItemVal { +union StashItemVal +{ int32_t int32_val; std::string* str_val; + StashGenericObject* generic_obj_val; }; -class StashItem { -private: - StashItemType type; - StashItemVal val; - +class StashItem +{ public: StashItem(int32_t int32_val) { @@ -60,6 +78,12 @@ public: val.str_val = str_val; } + StashItem(StashGenericObject* obj) + { + type = STASH_ITEM_TYPE_GENERIC_OBJECT; + val.generic_obj_val = obj; + } + ~StashItem() { switch (type) @@ -67,6 +91,8 @@ public: case STASH_ITEM_TYPE_STRING: delete val.str_val; break; + case STASH_ITEM_TYPE_GENERIC_OBJECT: + delete val.generic_obj_val; default: break; } @@ -80,6 +106,13 @@ public: void get_val(std::string& str_val) const { str_val = *(val.str_val); } + + void get_val(StashGenericObject* &obj_val) const + { obj_val = val.generic_obj_val; } + +private: + StashItemType type; + StashItemVal val; }; } diff --git a/src/flow/test/flow_stash_test.cc b/src/flow/test/flow_stash_test.cc index a9537fb07..14751b04d 100644 --- a/src/flow/test/flow_stash_test.cc +++ b/src/flow/test/flow_stash_test.cc @@ -28,17 +28,20 @@ using namespace snort; using namespace std; -TEST_GROUP(stash_tests) +class TestStashObject : public StashGenericObject { - void setup() +public: + TestStashObject(int type) : StashGenericObject(type) { - } - void teardown() - { } }; +TEST_GROUP(stash_tests) +{ + +}; + TEST(stash_tests, new_int32_item) { FlowStash stash; @@ -112,13 +115,49 @@ TEST(stash_tests, non_existent_item) CHECK_FALSE(stash.get("item_2", val)); } +TEST(stash_tests, new_generic_object) +{ + FlowStash stash; + TestStashObject *test_object = new TestStashObject(111); + + stash.store("item_1", test_object); + + StashGenericObject *retrieved_object; + CHECK(stash.get("item_1", retrieved_object)); + POINTERS_EQUAL(test_object, retrieved_object); + CHECK_EQUAL(test_object->get_object_type(), ((TestStashObject*)retrieved_object)->get_object_type()); +} + +TEST(stash_tests, update_generic_object) +{ + FlowStash stash; + TestStashObject *test_object = new TestStashObject(111); + stash.store("item_1", test_object); + + TestStashObject *new_test_object = new TestStashObject(111); + stash.store("item_1", new_test_object); + + StashGenericObject *retrieved_object; + CHECK(stash.get("item_1", retrieved_object)); + POINTERS_EQUAL(new_test_object, retrieved_object); +} + +TEST(stash_tests, non_existent_generic_object) +{ + FlowStash stash; + StashGenericObject *retrieved_object; + CHECK_FALSE(stash.get("item_1", retrieved_object)); +} + TEST(stash_tests, mixed_items) { FlowStash stash; + TestStashObject *test_object = new TestStashObject(111); stash.store("item_1", 10); stash.store("item_2", "value_2"); stash.store("item_3", 30); + stash.store("item_4", test_object); int32_t int32_val; string str_val; @@ -129,6 +168,11 @@ TEST(stash_tests, mixed_items) STRCMP_EQUAL(str_val.c_str(), "value_2"); CHECK(stash.get("item_3", int32_val)); CHECK_EQUAL(int32_val, 30); + + StashGenericObject *retrieved_object; + CHECK(stash.get("item_4", retrieved_object)); + POINTERS_EQUAL(test_object, retrieved_object); + CHECK_EQUAL(test_object->get_object_type(), ((TestStashObject*)retrieved_object)->get_object_type()); } int main(int argc, char** argv)