Skip to content

Commit d9d1bdc

Browse files
author
Damir Zainullin
committed
++
1 parent b811422 commit d9d1bdc

File tree

151 files changed

+17861
-128
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

151 files changed

+17861
-128
lines changed

‎process-plugin-api/Makefile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ SRC := main.cpp $(wildcard process/*/src/*.cpp)
88
all: $(TARGET)
99

1010
$(TARGET): $(SRC)
11-
$(CXX) $(CXXFLAGS) $^ -I. -I../include/ipfixprobe/pluginFactory -o $@
11+
$(CXX) $(CXXFLAGS) $^ -I. -I../include/ipfixprobe/pluginFactory -Iprocess/common -o $@
1212

1313
clean:
1414
rm -f $(TARGET)

‎process-plugin-api/dummyProcessPlugin.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -175,7 +175,7 @@ class DummyPlugin
175175
return FlowAction::RequestNoData;
176176
}
177177

178-
void onFlowExport() override {}
178+
void onFlowExport(FlowRecord& flowRecord) override {}
179179

180180
const void* getExportData() const noexcept override { return &m_exportData; }
181181

‎process-plugin-api/fieldManager.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ class FieldManager {
3838

3939
FieldSchemaHandler schemaHandler;
4040
for (const auto& field : schema.getFields()) {
41-
FieldHandler fieldHandler(m_fieldIndex);
41+
FieldHandler fieldHandler(static_cast<BitIndexType>(m_fieldIndex));
4242
schemaHandler.registerField(field.name, fieldHandler);
4343
m_fields.emplace_back(OutputField(field, m_fieldIndex));
4444

‎process-plugin-api/flowKey.hpp‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
#pragma once
2+
3+
#include <cstdint>
4+
5+
#include "ipAddress.hpp"
6+
7+
namespace ipxp {
8+
9+
struct FlowKey {
10+
IPAddress srcIp;
11+
IPAddress dstIp;
12+
uint16_t srcPort;
13+
uint16_t dstPort;
14+
uint8_t l4Protocol;
15+
16+
constexpr inline
17+
std::size_t hash() const noexcept
18+
{
19+
return 0; //XXH3_64bits(this, sizeof(*this), 0);
20+
}
21+
};
22+
23+
} // namespace ipxp

‎process-plugin-api/flowRecord.hpp‎

Lines changed: 4 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,9 @@
99
#include <functional>
1010
#include <iostream>
1111
#include <memory>
12+
#include "tcpFlags.hpp"
13+
14+
#include "flowKey.hpp"
1215

1316
namespace ipxp {
1417

@@ -18,39 +21,12 @@ static constexpr std::size_t MAX_PLUGIN_SIZE = 32;
1821
using PluginsBitset = std::bitset<MAX_PLUGIN_SIZE>;
1922
using FieldsBitset = std::bitset<MAX_FIELD_SIZE>;
2023

21-
union IPAddress {
22-
std::array<uint8_t, 16> u8;
23-
std::array<uint16_t, 8> u16;
24-
std::array<uint32_t, 4> u32;
25-
std::array<uint64_t, 2> u64;
26-
27-
IPAddress() { std::memset(&u8, 0, sizeof(u8)); };
28-
IPAddress(uint32_t ipv4)
29-
{
30-
(void) ipv4; // Suppress unused warning
31-
};
32-
IPAddress(const std::array<uint8_t, 16>& ipv6)
33-
{
34-
(void) ipv6; // Suppress unused warning
35-
};
36-
// const bool isIPv4() {};
37-
// const bool isIPv6() {};
38-
// TODO: comparison functions,...
39-
};
40-
4124
struct DirectionalData {
4225
uint64_t timeStart = 0;
4326
uint64_t timeEnd = 0;
4427
uint64_t packets = 0;
4528
uint64_t bytes = 0;
46-
};
47-
48-
struct FlowKey {
49-
IPAddress srcIp;
50-
IPAddress dstIp;
51-
uint16_t srcPort;
52-
uint16_t dstPort;
53-
uint8_t l4Protocol;
29+
TcpFlags tcpFlags{};
5430
};
5531

5632
class FlowRecord {

‎process-plugin-api/ipAddress.hpp‎

Lines changed: 90 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,90 @@
1+
#pragma once
2+
3+
#include <array>
4+
#include <cstdint>
5+
#include <cstring>
6+
#include <limits>
7+
#include <compare>
8+
#include <algorithm>
9+
#include <format>
10+
11+
namespace ipxp {
12+
13+
union IPAddress {
14+
std::array<uint8_t, 16> u8;
15+
std::array<uint16_t, 8> u16;
16+
std::array<uint32_t, 4> u32;
17+
std::array<uint64_t, 2> u64;
18+
19+
constexpr IPAddress() noexcept
20+
{
21+
std::memset(&u8, 0, sizeof(IPAddress));
22+
};
23+
24+
constexpr IPAddress(const uint32_t ipv4) noexcept
25+
{
26+
u32[0] = ipv4;
27+
u32[1] = 0;
28+
u32[2] = u32[3] = std::numeric_limits<uint32_t>::max();
29+
};
30+
31+
constexpr IPAddress(const std::array<uint8_t, 16>& ipv6) noexcept
32+
{
33+
u8 = ipv6;
34+
};
35+
36+
constexpr bool isIPv4() const noexcept
37+
{
38+
return u32[1] == 0 &&
39+
u32[2] == std::numeric_limits<uint32_t>::max() &&
40+
u32[3] == std::numeric_limits<uint32_t>::max();
41+
}
42+
43+
constexpr bool isIPv6() const noexcept
44+
{
45+
return !isIPv4();
46+
}
47+
48+
constexpr bool operator==(const IPAddress& other) const noexcept
49+
{
50+
return u8 == other.u8;
51+
}
52+
53+
//constexpr std::strong_ordering operator<=>(const IPAddress& other) const noexcept = default;
54+
55+
constexpr IPAddress& operator=(const IPAddress& other) noexcept
56+
{
57+
if (this != &other) {
58+
u8 = other.u8;
59+
}
60+
return *this;
61+
}
62+
63+
constexpr std::size_t size() const noexcept
64+
{
65+
return isIPv4() ? 4 : 16;
66+
}
67+
68+
std::string toString() const noexcept
69+
{
70+
std::string res;
71+
constexpr std::size_t MAX_IP_AS_TEXT_SIZE = 30;
72+
res.reserve(MAX_IP_AS_TEXT_SIZE);
73+
74+
if (isIPv4()) {
75+
std::for_each_n(reinterpret_cast<const std::byte*>(u8.data()), size(),
76+
[&](const std::byte ipByte) {
77+
std::format_to(std::back_inserter(res), "{}.", static_cast<int>(ipByte));
78+
});
79+
} else {
80+
std::for_each_n(reinterpret_cast<const std::byte*>(u8.data()), size(),
81+
[&](const std::byte ipByte) {
82+
std::format_to(std::back_inserter(res), "{:02x}:", static_cast<int>(ipByte));
83+
});
84+
}
85+
res.pop_back();
86+
return res;
87+
}
88+
};
89+
90+
} // namespace ipxp

‎process-plugin-api/ipx‎

10 MB
Binary file not shown.

‎process-plugin-api/packet.hpp‎

Lines changed: 20 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -2,27 +2,33 @@
22

33
#include <cstdint>
44
#include <sys/time.h>
5+
#include <span>
6+
#include <optional>
57

68
#include "directionalField.hpp"
7-
#include "tcpFlags.hpp"
9+
#include "tcpData.hpp"
10+
#include "flowKey.hpp"
811

912
namespace ipxp
1013
{
1114

1215
struct Packet {
13-
timeval timestamp;
14-
uint8_t ipTtl;
15-
uint8_t ipFlags;
16-
uint16_t ipLength;
17-
uint16_t tcpWindow;
18-
uint64_t tcpOptions;
19-
uint32_t tcpMss;
20-
TcpFlags tcpFlags;
21-
22-
uint32_t realLength;
23-
uint32_t receivedLength;
24-
25-
Direction direction;
16+
FlowKey flowKey{};
17+
18+
uint64_t timestamp{0};
19+
uint8_t ipTtl{0};
20+
uint8_t ipFlags{0};
21+
uint16_t ipLength{0};
22+
23+
std::optional<TCPData> tcpData{std::nullopt};
24+
25+
uint32_t realLength{0};
26+
//uint32_t receivedLength{0};
27+
28+
Direction direction{Direction::Forward};
29+
30+
std::span<const std::byte> payload;
31+
std::optional<uint32_t> mplsTopLabel;
2632

2733
};
2834

process-plugin-api/process/basicPlus/src/basicPlus.cpptttt renamed to process-plugin-api/process/basicPlus/src/basicPlus.cpp

Lines changed: 45 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -45,42 +45,52 @@ static FieldSchema createBasicPlusSchema()
4545
"IP_TTL",
4646
FieldDirection::Forward,
4747
offsetof(BasicPlusExport, ipTtl.values[Direction::Forward]));
48+
4849
schema.addScalarField<uint8_t>(
4950
"IP_TTL_REV",
5051
FieldDirection::Reverse,
5152
offsetof(BasicPlusExport, ipTtl.values[Direction::Reverse]));
53+
5254
schema.addScalarField<uint8_t>(
5355
"IP_FLG",
5456
FieldDirection::Forward,
5557
offsetof(BasicPlusExport, ipFlag.values[Direction::Forward]));
58+
5659
schema.addScalarField<uint8_t>(
5760
"IP_FLG_REV",
5861
FieldDirection::Reverse,
5962
offsetof(BasicPlusExport, ipFlag.values[Direction::Reverse]));
63+
6064
schema.addScalarField<uint16_t>(
6165
"TCP_WIN",
6266
FieldDirection::Forward,
6367
offsetof(BasicPlusExport, tcpWindow.values[Direction::Forward]));
68+
6469
schema.addScalarField<uint16_t>(
6570
"TCP_WIN_REV",
6671
FieldDirection::Reverse,
6772
offsetof(BasicPlusExport, tcpWindow.values[Direction::Reverse]));
73+
6874
schema.addScalarField<uint64_t>(
6975
"TCP_OPT",
7076
FieldDirection::Forward,
7177
offsetof(BasicPlusExport, tcpOption.values[Direction::Forward]));
78+
7279
schema.addScalarField<uint64_t>(
7380
"TCP_OPT_REV",
7481
FieldDirection::Reverse,
7582
offsetof(BasicPlusExport, tcpOption.values[Direction::Reverse]));
83+
7684
schema.addScalarField<uint32_t>(
7785
"TCP_MSS",
7886
FieldDirection::Forward,
7987
offsetof(BasicPlusExport, tcpMss.values[Direction::Forward]));
88+
8089
schema.addScalarField<uint32_t>(
8190
"TCP_MSS_REV",
8291
FieldDirection::Reverse,
8392
offsetof(BasicPlusExport, tcpMss.values[Direction::Reverse]));
93+
8494
schema.addScalarField<uint16_t>(
8595
"TCP_SYN_SIZE",
8696
FieldDirection::DirectionalIndifferent,
@@ -100,7 +110,6 @@ BasicPlusPlugin::BasicPlusPlugin([[maybe_unused]]const std::string& params, Fiel
100110
const FieldSchema schema = createBasicPlusSchema();
101111
const FieldSchemaHandler schemaHandler = manager.registerSchema(schema);
102112

103-
104113
m_fieldHandlers[BasicPlusFields::IP_TTL] = schemaHandler.getFieldHandler("IP_TTL");
105114
m_fieldHandlers[BasicPlusFields::IP_TTL_REV] = schemaHandler.getFieldHandler("IP_TTL_REV");
106115
m_fieldHandlers[BasicPlusFields::IP_FLG] = schemaHandler.getFieldHandler("IP_FLG");
@@ -123,55 +132,62 @@ FlowAction BasicPlusPlugin::onFlowCreate(FlowRecord& flowRecord, const Packet& p
123132
m_exportData.ipFlag[Direction::Forward] = packet.ipFlags;
124133
m_fieldHandlers[BasicPlusFields::IP_FLG].setAsAvailable(flowRecord);
125134

126-
m_exportData.tcpWindow[Direction::Forward] = packet.tcpWindow;
135+
if (!packet.tcpData.has_value()) {
136+
return FlowAction::RequestTrimmedData;
137+
}
138+
139+
m_exportData.tcpWindow[Direction::Forward] = packet.tcpData->window;
127140
m_fieldHandlers[BasicPlusFields::TCP_WIN].setAsAvailable(flowRecord);
128141

129-
m_exportData.tcpOption[Direction::Forward] = packet.tcpOptions;
142+
m_exportData.tcpOption[Direction::Forward] = packet.tcpData->options;
130143
m_fieldHandlers[BasicPlusFields::TCP_OPT].setAsAvailable(flowRecord);
131144

132-
m_exportData.tcpMss[Direction::Forward] = packet.tcpMss;
145+
m_exportData.tcpMss[Direction::Forward] = packet.tcpData->mss;
133146
m_fieldHandlers[BasicPlusFields::TCP_MSS].setAsAvailable(flowRecord);
134147

135-
if (packet.tcpFlags.flags.synchronize) { // check if SYN packet
148+
if (packet.tcpData->flags.bitfields.synchronize) { // check if SYN packet
136149
m_exportData.tcpSynSize = packet.ipLength;
137150
m_fieldHandlers[BasicPlusFields::TCP_SYN_SIZE].setAsAvailable(flowRecord);
138151
}
139152

140153
return FlowAction::RequestTrimmedData;
141154
}
142155

143-
FlowAction BasicPlusPlugin::onFlowUpdate(FlowRecord& flowRecord,
144-
const Packet& packet, const PacketOfFlowData& data)
156+
FlowAction BasicPlusPlugin::onFlowUpdate(FlowRecord& flowRecord, const Packet& packet)
145157
{
146-
m_exportData.ipTtl[Direction::Forward]
147-
= std::min(m_exportData.ipTtl[Direction::Forward], packet.ipTtl);
158+
m_exportData.ipTtl[packet.direction]
159+
= std::min(m_exportData.ipTtl[packet.direction], packet.ipTtl);
160+
161+
if (!packet.tcpData.has_value()) {
162+
return FlowAction::RequestTrimmedData;
163+
}
148164

149-
if (data.packetDirection == Direction::Reverse) {
150-
m_exportData.ipTtl[Direction::Reverse] = packet.ipTtl;
151-
m_fieldHandlers[BasicPlusFields::IP_TTL_REV].setAsAvailable(flowRecord);
152-
153-
m_exportData.ipFlag[Direction::Reverse] = packet.ipFlags;
154-
m_fieldHandlers[BasicPlusFields::IP_FLG_REV].setAsAvailable(flowRecord);
155-
156-
m_exportData.tcpWindow[Direction::Reverse] = packet.tcpWindow;
157-
m_fieldHandlers[BasicPlusFields::TCP_WIN_REV].setAsAvailable(flowRecord);
158-
159-
m_exportData.tcpOption[Direction::Reverse] = packet.tcpOptions;
160-
m_fieldHandlers[BasicPlusFields::TCP_OPT_REV].setAsAvailable(flowRecord);
161-
162-
m_exportData.tcpMss[Direction::Reverse] = packet.tcpMss;
163-
m_fieldHandlers[BasicPlusFields::TCP_MSS_REV].setAsAvailable(flowRecord);
164-
165-
m_exportData.processingState.destinationFilled = true;
165+
m_exportData.tcpOption[packet.direction] |= packet.tcpData->options;
166+
167+
if (packet.direction == Direction::Forward) {
168+
return FlowAction::RequestTrimmedData;
166169
}
167170

168-
m_exportData.tcpOption[data.packetDirection] |= packet.tcpOptions;
171+
m_exportData.ipTtl[Direction::Reverse] = packet.ipTtl;
172+
m_fieldHandlers[BasicPlusFields::IP_TTL_REV].setAsAvailable(flowRecord);
173+
174+
m_exportData.ipFlag[Direction::Reverse] = packet.ipFlags;
175+
m_fieldHandlers[BasicPlusFields::IP_FLG_REV].setAsAvailable(flowRecord);
176+
177+
m_exportData.tcpWindow[Direction::Reverse] = packet.tcpData->window;
178+
m_fieldHandlers[BasicPlusFields::TCP_WIN_REV].setAsAvailable(flowRecord);
179+
180+
m_exportData.tcpOption[Direction::Reverse] = packet.tcpData->options;
181+
m_fieldHandlers[BasicPlusFields::TCP_OPT_REV].setAsAvailable(flowRecord);
182+
183+
m_exportData.tcpMss[Direction::Reverse] = packet.tcpData->mss;
184+
m_fieldHandlers[BasicPlusFields::TCP_MSS_REV].setAsAvailable(flowRecord);
185+
186+
m_exportData.processingState.destinationFilled = true;
169187

170188
return FlowAction::RequestTrimmedData;
171189
}
172190

173-
void BasicPlusPlugin::onFlowExport() {}
174-
175191
ProcessPlugin* BasicPlusPlugin::clone(std::byte* constructAtAddress) const
176192
{
177193
return std::construct_at(reinterpret_cast<BasicPlusPlugin*>(constructAtAddress), *this);

0 commit comments

Comments
 (0)