wanderer/ fastnetmon-rewritten
1
0
Fork 0
mirror of https://github.com/pavel-odintsov/fastnetmon synced 2024-06-15 06:06:17 +02:00
Code Issues Releases Activity

Added TCP flags support to the BGP Flow Spec class; Added tests for it; Added tests for serializers.

This commit is contained in:
Pavel Odintsov 2015-07-13 12:27:09 +02:00
parent cf2928ea6d
commit 032838205c
2 changed files with 154 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/bgp_flow_spec.h
View File

@ -39,6 +39,16 @@ enum flow_spec_fragmentation_types_t {
FLOW_NOT_A_FRAGMENT,
};
// TCP flags for Flow Spec
enum flow_spec_tcp_flags_t {
FLOW_TCP_FLAG_SYN,
FLOW_TCP_FLAG_FIN,
FLOW_TCP_FLAG_URG,
FLOW_TCP_FLAG_ACK,
FLOW_TCP_FLAG_PSH,
FLOW_TCP_FLAG_RST,
};
// Flow spec actions
enum bgp_flow_spec_action_types_t {
FLOW_SPEC_ACTION_DISCARD,
@ -84,6 +94,24 @@ std::ostream &operator<<(std::ostream &os, flow_spec_fragmentation_types_t const
}
}
std::ostream &operator<<(std::ostream &os, flow_spec_tcp_flags_t const &tcp_flag) {
if (tcp_flag == FLOW_TCP_FLAG_SYN) {
return os << "syn";
} else if (tcp_flag == FLOW_TCP_FLAG_ACK) {
return os << "ack";
} else if (tcp_flag == FLOW_TCP_FLAG_FIN) {
return os << "fin";
} else if (tcp_flag == FLOW_TCP_FLAG_URG) {
return os << "urgent";
} else if (tcp_flag == FLOW_TCP_FLAG_PSH) {
return os << "push";
} else if(tcp_flag == FLOW_TCP_FLAG_RST) {
return os << "rst";
} else {
return os;
}
}
class bgp_flow_spec_action_t {
public:
bgp_flow_spec_action_t() {
@ -208,10 +236,16 @@ class flow_spec_rule_t {
return output_buffer.str();
}
/*
std::string tcp_flags;
bool tcp_flags_used;
std::string serialize_tcp_flags() {
std::ostringstream output_buffer;
output_buffer << "tcp-flags [ " << serialize_vector_by_string(this->tcp_flags, " ") << " ];";
return output_buffer.str();
}
/*
std::string icmp_flags;
bool icmp_flags_used;
@ -226,6 +260,10 @@ class flow_spec_rule_t {
this->fragmentation_flags.push_back(flag);
}
void add_tcp_flag(flow_spec_tcp_flags_t flag) {
this->tcp_flags.push_back(flag);
}
void set_action(bgp_flow_spec_action_t action) {
this->action = action;
}
@ -242,6 +280,7 @@ class flow_spec_rule_t {
std::vector<uint16_t> packet_lengths;
std::vector<bgp_flow_spec_protocol_t> protocols;
std::vector<flow_spec_fragmentation_types_t> fragmentation_flags;
std::vector<flow_spec_tcp_flags_t> tcp_flags;
bgp_flow_spec_action_t action;
};
@ -306,6 +345,14 @@ class exabgp_flow_spec_rule_t : public flow_spec_rule_t {
buffer << four_spaces << four_spaces << this->serialize_protocols() << "\n";
}
// If we have TCP in protocols list explicitly, we add flags
if (find(this->protocols.begin(), this->protocols.end(), FLOW_SPEC_PROTOCOL_TCP)
!= this->protocols.end() ) {
if (!this->tcp_flags.empty()) {
buffer << four_spaces << four_spaces << this->serialize_tcp_flags() << "\n";
}
}
if (!this->source_ports.empty()) {
buffer << four_spaces << four_spaces << this->serialize_source_ports() << "\n";

107
src/fastnetmon_tests.cpp
View File

@ -140,7 +140,108 @@ TEST(BgpFlowSpec, fragmentation_fragments) {
EXPECT_EQ(exabgp_rule.serialize_fragmentation_flags(), "fragment [ not-a-fragment ];");
}
// exabgp_rule.add_fragmentation_flag(FLOW_SPEC_IS_A_FRAGMENT);
// exabgp_rule.add_fragmentation_flag(FLOW_SPEC_DONT_FRAGMENT);
//
// tcp flags tests
TEST(BgpFlowSpec, syn) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_SYN);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ syn ];" );
}
TEST(BgpFlowSpec, rst) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_RST);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ rst ];" );
}
TEST(BgpFlowSpec, ack) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_ACK);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ ack ];" );
}
TEST(BgpFlowSpec, fin) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_FIN);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ fin ];" );
}
TEST(BgpFlowSpec, psh) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_PSH);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ push ];" );
}
TEST(BgpFlowSpec, urg) {
exabgp_flow_spec_rule_t exabgp_rule;
exabgp_rule.add_tcp_flag(FLOW_TCP_FLAG_URG);
EXPECT_EQ(exabgp_rule.serialize_tcp_flags(), "tcp-flags [ urgent ];" );
}
// Flow Spec actions tests
TEST(BgpFlowSpecAction, rate_limit) {
bgp_flow_spec_action_t my_action;
my_action.set_type(FLOW_SPEC_ACTION_RATE_LIMIT);
my_action.set_rate_limit(1024);
EXPECT_EQ( my_action.serialize(), "rate-limit 1024;");
}
TEST(BgpFlowSpecAction, discard) {
bgp_flow_spec_action_t my_action;
my_action.set_type(FLOW_SPEC_ACTION_DISCARD);
EXPECT_EQ( my_action.serialize(), "discard;");
}
TEST(BgpFlowSpecAction, accept) {
bgp_flow_spec_action_t my_action;
my_action.set_type(FLOW_SPEC_ACTION_ACCEPT);
EXPECT_EQ( my_action.serialize(), "accept;");
}
TEST(BgpFlowSpecAction, default_constructor) {
bgp_flow_spec_action_t my_action;
EXPECT_EQ( my_action.serialize(), "accept;");
}
// Serializers tests
TEST(serialize_vector_by_string, single_element) {
std::vector<std::string> vect;
vect.push_back("123");
EXPECT_EQ( serialize_vector_by_string(vect, ","), "123");
}
TEST(serialize_vector_by_string, few_elements) {
std::vector<std::string> vect;
vect.push_back("123");
vect.push_back("456");
EXPECT_EQ( serialize_vector_by_string(vect, ","), "123,456");
}
TEST(serialize_vector_by_string_with_prefix, single_element) {
std::vector<uint16_t> vect;
vect.push_back(123);
EXPECT_EQ( serialize_vector_by_string_with_prefix(vect, ",", "^"), "^123");
}
TEST(serialize_vector_by_string_with_prefix, few_elements) {
std::vector<uint16_t> vect;
vect.push_back(123);
vect.push_back(456);
EXPECT_EQ( serialize_vector_by_string_with_prefix(vect, ",", "^"), "^123,^456");
}