++

Author: Zadamsa

new-process-api/Makefile

@@ -1,17 +1,24 @@
 CXX := g++
 CXXFLAGS := -std=c++20 -Wall -Wextra -pedantic -Wunused -Wconversion -Wsign-conversion -g -fsanitize=address
-INCLUDES := -I/usr/include
-LDFLAGS := -lboost_system -lboost_filesystem
-
 TARGET := ipx
-SRC := main.cpp fieldManager.cpp icmp.cpp
+SRC := main.cpp \
+	$(wildcard process/common/*/*/*.cpp) \
+	$(wildcard process/common/*/*.cpp) \
+	$(wildcard process/*/src/*.cpp)
+
+INCLUDE := -I. -I../include/ipfixprobe/pluginFactory -Iprocess/common
+
+OBJ := $(SRC:.cpp=.o)
 
 .PHONY: all clean
 
 all: $(TARGET)
 
-$(TARGET): $(SRC)
-	$(CXX) $(CXXFLAGS) $(INCLUDES) $^ -o $@ $(LDFLAGS)
+$(TARGET): $(OBJ)
+	$(CXX) $(CXXFLAGS) $(INCLUDE) $^ -o $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDE) -c $< -o $@
 
 clean:
 	rm -f $(TARGET)

new-process-api/directionalField.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+enum Direction : std::size_t { Forward = 0, Reverse = 1 };
+
+template<typename T>
+struct DirectionalField {
+	T values[2]{};
+
+	constexpr T& operator[](Direction d) { return values[static_cast<std::size_t>(d)]; }
+	constexpr const T& operator[](Direction d) const { return values[static_cast<std::size_t>(d)]; }
+};

new-process-api/fieldSupportedTypes.hpp

@@ -44,7 +44,7 @@ using NumericFieldTypes = std::
  *
  * Contains specialized types like Timestamp, IP and MAC addresses.
  */
-using CustomFieldTypes = std::tuple<Timestamp, IpAddress, MacAddress>;
+using CustomFieldTypes = std::tuple<Timestamp, IPAddress, MacAddress>;
 
 /**
  * @brief Helper alias for compile-time concatenation of multiple `std::tuple` type lists.

new-process-api/flowKey.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstdint>
+
+#include "ipAddress.hpp"
+
+namespace ipxp {
+
+struct FlowKey {
+	IPAddress srcIp;
+	IPAddress dstIp;
+	uint16_t srcPort;
+	uint16_t dstPort;
+	uint8_t l4Protocol;
+
+    constexpr inline
+    std::size_t hash() const noexcept 
+    {
+        return 0; //XXH3_64bits(this, sizeof(*this), 0);
+    }
+};
+
+struct FlowKeyLayout {
+    std::size_t size;
+    std::size_t alignment;
+};
+
+} // namespace ipxp

new-process-api/flowRecord.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include "timestamp.hpp"
+#include "flowKey.hpp"
+#include "directionalField.hpp"
 
 #include <array>
 #include <bitset>
@@ -45,6 +47,15 @@ struct DirectionalData {
 
 class FlowRecord {
 public:
+	uint64_t hash;
+
+	uint64_t timeCreation;
+	uint64_t timeLastUpdate;
+
+	FlowKey flowKey;
+
+	DirectionalField<DirectionalData> directionalData;
+
 	// Bitset of flow fields that were specified as present
 	mutable FieldsBitset fieldsAvailable = {};
 	// Bitset of successfully constructed plugins (constructor accepted packet)

new-process-api/icmp.cpp new-process-api/icmp.cppxxnew-process-api/icmp.cpp renamed to new-process-api/icmp.cppxx

@@ -1,17 +1,97 @@
 #pragma once
 
 #include <iostream>
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <compare>
+#include <algorithm>
+#include <format>
 
 namespace ipxp {
 
-struct IpAddress {};
+union IPAddress {
+	std::array<uint8_t, 16> u8;
+	std::array<uint16_t, 8> u16;
+	std::array<uint32_t, 4> u32;
+	std::array<uint64_t, 2> u64;
 
-inline std::ostream& operator<<(std::ostream& os, const IpAddress& ip)
-{
-	(void) ip;
+	constexpr IPAddress() noexcept 
+	{ 
+		std::memset(&u8, 0, sizeof(IPAddress)); 
+	}
+
+	constexpr IPAddress(const uint32_t ipv4) noexcept
+	{
+		u32[0] = ipv4;
+		u32[1] = 0;
+		u32[2] = u32[3] = std::numeric_limits<uint32_t>::max();
+	}
+
+	constexpr IPAddress(const std::span<const std::byte, 16>& ipv6) noexcept
+	{
+		std::copy(
+			ipv6.begin(), ipv6.end(), reinterpret_cast<std::byte*>(u8.data()));
+	}
+
+	constexpr bool isIPv4() const noexcept
+	{
+		return u32[1] == 0 && 
+			u32[2] == std::numeric_limits<uint32_t>::max() && 
+			u32[3] == std::numeric_limits<uint32_t>::max();
+	}
+
+	constexpr bool isIPv6() const noexcept
+	{
+		return !isIPv4();
+	}
+
+	constexpr bool operator==(const IPAddress& other) const noexcept
+	{
+		return u8 == other.u8;
+	}
 
-	os << "IpAddress{}";
-	return os;
+	//constexpr std::strong_ordering operator<=>(const IPAddress& other) const noexcept = default;
+
+	constexpr IPAddress& operator=(const IPAddress& other) noexcept
+	{
+		if (this != &other) {	
+			u8 = other.u8;
+		}
+		return *this;
+	}
+
+	constexpr std::size_t size() const noexcept
+	{
+		return isIPv4() ? 4 : 16;
+	}
+
+	std::string toString() const noexcept 
+	{
+		std::string res;
+		constexpr std::size_t MAX_IP_AS_TEXT_SIZE = 30;
+		res.reserve(MAX_IP_AS_TEXT_SIZE);
+
+		if (isIPv4()) {
+			std::for_each_n(reinterpret_cast<const std::byte*>(u8.data()), size(), 
+			[&](const std::byte ipByte) {
+				std::format_to(std::back_inserter(res), "{}.", static_cast<int>(ipByte));
+			});
+		} else {
+			std::for_each_n(reinterpret_cast<const std::byte*>(u8.data()), size(),
+			[&](const std::byte ipByte) {
+				std::format_to(std::back_inserter(res), "{:02x}:", static_cast<int>(ipByte));
+			});
+		}
+		res.pop_back();
+		return res;
+	}
+};
+
+inline std::ostream& operator<<(std::ostream& os, const IPAddress& ip)
+{
+	return os << ip.toString();
 }
 
 } // namespace ipxp

new-process-api/ipAddress.hpp

@@ -19,6 +19,7 @@ int main()
 	processPlugins.disableProcessPlugin("TestDummy");
 	processPlugins.enableProcessPlugin("TestDummy");
 
+	const FlowKeyLayout VlanFlowKeyLayout{20, 4};
 	FlowRecordBuilder builder(processPlugins.getEntries(), VlanFlowKeyLayout);
 
 	builder.printLayoutInfo();

new-process-api/main.cpp

@@ -1,9 +1,36 @@
 #pragma once
 
-namespace ipxp {
+#include <cstdint>
+#include <sys/time.h>
+#include <span>
+#include <optional>
+
+#include "directionalField.hpp"
+#include "tcpData.hpp"
+#include "flowKey.hpp"
+
+namespace ipxp
+{
 
 struct Packet {
-	void* payload;
+    FlowKey flowKey{};
+
+    uint64_t timestamp{0};
+    uint8_t ipTTL{0};
+    uint8_t ipFlags{0};
+    uint16_t ipLength{0};
+
+    std::optional<TCPData> tcpData{std::nullopt};
+
+    uint32_t realLength{0};
+    //uint32_t receivedLength{0};
+
+    Direction direction{Direction::Forward};
+
+    std::span<const std::byte> payload;   
+    std::optional<uint32_t> mplsTopLabel;
+    std::optional<uint16_t> vlanId;
+
 };
 
 struct PacketFeatures {};