++

Author: Zainullin Damir

external/CMakeLists.txt

@@ -4,3 +4,4 @@ include(ExternalProject)
 set(FETCHCONTENT_QUIET OFF)
 
 include(telemetry.cmake)
+include(adaptmon.cmake)

external/adaptmon.cmake

@@ -0,0 +1,30 @@
+# Telemetry library (C++ library for telemetry data collection with Fuse integration)
+#
+# The Telemetry library consists of two libraries that can be added as dependency:
+#
+# - telemetry::telemetry (C++ library for telemetry data collection)
+# - telemetry::appFs     (C++ library that expose telemetry data as a Fuse filesystem)
+
+#set(TELEMETRY_BUILD_SHARED OFF)
+#set(TELEMETRY_INSTALL_TARGETS OFF)
+#set(TELEMETRY_PACKAGE_BUILDER OFF)
+#set(TELEMETRY_ENABLE_TESTS OFF)
+
+#set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(GIT_REPO https://gitlab.liberouter.org/monitoring/adaptmon.git)
+
+FetchContent_Declare(
+	adaptmon
+	GIT_REPOSITORY ${GIT_REPO}
+	GIT_TAG main
+)
+
+# Make sure that subproject accepts predefined build options without warnings.
+#set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+set(FETCHCONTENT_BASE_DIR "${CMAKE_SOURCE_DIR}/.deps")
+set(FETCHCONTENT_FULLY_DISCONNECTED OFF) 
+
+FetchContent_MakeAvailable(adaptmon)
+#include_directories(${adaptmon_SOURCE_DIR}/lib/include/public/amon)

include/ipfixprobe/processPlugin/flowRecord.hpp

@@ -3,7 +3,6 @@
 #include "directionalField.hpp"
 #include "flowKey.hpp"
 #include "macAddress.hpp"
-#include "packet.hpp"
 #include "tcpFlags.hpp"
 #include "timestamp.hpp"
 #include "xxhash.h"
@@ -19,6 +18,13 @@
 #include <memory>
 #include <span>
 
+#include <amon/Packet.hpp>
+#include <amon/layers/Ethernet.hpp>
+#include <amon/layers/IPv4.hpp>
+#include <amon/layers/IPv6.hpp>
+#include <amon/layers/TCP.hpp>
+#include <amon/layers/UDP.hpp>
+
 namespace ipxp {
 
 static constexpr std::size_t MAX_PLUGIN_COUNT = 32;
@@ -61,11 +67,11 @@ class FlowRecord {
 public:
 	uint64_t hash;
 
-	Timestamp timeCreation;
-	Timestamp timeLastUpdate;
+	amon::types::Timestamp timeCreation;
+	amon::types::Timestamp timeLastUpdate;
 
 	FlowKey flowKey;
-	DirectionalField<MACAddress> macAddress;
+	DirectionalField<amon::types::MACAddress> macAddress;
 
 	DirectionalField<DirectionalData> directionalData;
 
@@ -123,39 +129,66 @@ class FlowRecord {
 	}*/
 
 	// TODO remove hashval
-	void createFrom(const Packet& packet, uint64_t hashval)
+	void createFrom(const amon::Packet& packet, uint64_t hashval)
 	{
 		directionalData[Direction::Forward].packets = 1;
-		directionalData[Direction::Forward].bytes = packet.ip_len;
 
-		flowKey.srcPort = packet.src_port;
-		flowKey.dstPort = packet.dst_port;
-		flowKey.l4Protocol = packet.ip_proto;
+		const std::optional<amon::EthernetView> ethernetView
+			= packet.getLayerView<amon::EthernetView>();
+		if (!ethernetView.has_value()) {
+			return;
+		}
+
+		macAddress = {ethernetView->src(), ethernetView->dst()};
+
+		if (const std::optional<amon::layers::IPv4View> ipv4View
+			= packet.getLayerView<amon::layers::IPv4View>();
+			ipv4View.has_value()) {
+			flowKey.srcIp = ipv4View->srcIP();
+			flowKey.dstIp = ipv4View->dstIP();
+			flowKey.l4Protocol = ipv4View->protocol();
+			directionalData[Direction::Forward].bytes = ipv4View->totalLength();
+		} else if (const std::optional<amon::IPv6View> ipv6View
+				   = packet.getLayerView<amon::IPv6View>();
+				   ipv6View.has_value()) {
+			flowKey.srcIp = ipv6View->srcIP();
+			flowKey.dstIp = ipv6View->dstIP();
+			flowKey.l4Protocol = ipv6View->nextHeader();
+			directionalData[Direction::Forward].bytes = ipv6View->payloadLength();
+		} else {
+			return;
+		}
 
 		hash = hashval;
 
-		timeCreation = packet.ts;
-		timeLastUpdate = packet.ts;
+		timeCreation = packet.timestamp;
+		timeLastUpdate = packet.timestamp;
+
+		if (const std::optional<amon::TCPView> tcpView = packet.getLayerView<amon::TCPView>();
+			tcpView.has_value()) {
+			flowKey.srcPort = tcpView->srcPort();
+			flowKey.dstPort = tcpView->dstPort();
+			directionalData[Direction::Forward].bytes += tcpView->headerLength();
+			directionalData[Direction::Forward].tcpFlags = tcpView->flags();
+		} else if (const std::optional<amon::UDPView> udpView
+				   = packet.getLayerView<amon::UDPView>();
+				   udpView.has_value()) {
+			flowKey.srcPort = udpView->srcPort();
+			flowKey.dstPort = udpView->dstPort();
+			directionalData[Direction::Forward].bytes += udpView->headerLength();
+		} else {
+			flowKey.srcPort = 0;
+			flowKey.dstPort = 0;
+		}
 
-		macAddress[Direction::Forward]
+		/*macAddress[Direction::Forward]
 			= std::span<const std::byte, 6>(reinterpret_cast<const std::byte*>(packet.src_mac), 6);
 		macAddress[Direction::Reverse]
 			= std::span<const std::byte, 6>(reinterpret_cast<const std::byte*>(packet.dst_mac), 6);
-
-		if (packet.ip_version == IP::v4) {
-			flowKey.srcIp = packet.src_ip.v4;
-			flowKey.dstIp = packet.dst_ip.v4;
-		} else if (packet.ip_version == IP::v6) {
-			flowKey.srcIp = std::span<const std::byte, 16>(
-				reinterpret_cast<const std::byte*>(packet.src_ip.v6),
-				16);
-			flowKey.dstIp = std::span<const std::byte, 16>(
-				reinterpret_cast<const std::byte*>(packet.dst_ip.v6),
-				16);
-		}
+*/
 	}
 
-	void update(const Packet& packet, bool src)
+	void update(const amon::Packet& packet, bool src)
 	{
 		/*m_flow.time_last = pkt.ts;
 		if (src) {

include/ipfixprobe/processPlugin/ipAddress.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <iostream>
+#include <algorithm>
 #include <array>
+#include <compare>
 #include <cstdint>
 #include <cstring>
-#include <limits>
-#include <compare>
-#include <algorithm>
 #include <format>
+#include <iostream>
+#include <limits>
 
 #include <ipfixprobe/ipaddr.hpp>
 
@@ -19,10 +19,7 @@ union IPAddress {
 	std::array<uint32_t, 4> u32;
 	std::array<uint64_t, 2> u64;
 
-	constexpr IPAddress() noexcept 
-	{ 
-		std::memset(&u8, 0, sizeof(IPAddress)); 
-	}
+	constexpr IPAddress() noexcept { std::memset(&u8, 0, sizeof(IPAddress)); }
 
 	constexpr IPAddress(const uint32_t ipv4) noexcept
 	{
@@ -37,85 +34,85 @@ union IPAddress {
 	}
 
 	constexpr IPAddress(const ipaddr_t address, IP version) noexcept
-	: IPAddress(address.v4)
+		: IPAddress(address.v4)
 	{
 		if (version == IP::v6) {
 			std::memcpy(&u8, address.v6, 16);
 		}
 	}
 
-	constexpr IPAddress(const IPAddress& other) noexcept
+	// TODO remove. Added because of AMON compatibility
+	constexpr IPAddress(const auto& container)
 	{
-		u8 = other.u8;
-	}
+		if (container.size() != 4 && container.size() != 16) {
+			throw std::invalid_argument("IPAddress: container must have size 4 or 16");
+		}
 
-	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();
+		std::memcpy(&u8, container.data(), container.size());
+		if (container.size() == 4) {
+			u32[1] = 0;
+			u32[2] = u32[3] = std::numeric_limits<uint32_t>::max();
+		}
 	}
 
-	constexpr bool isIPv6() const noexcept
+	constexpr IPAddress(const IPAddress& other) noexcept { u8 = other.u8; }
+
+	constexpr bool isIPv4() const noexcept
 	{
-		return !isIPv4();
+		return u32[1] == 0 && u32[2] == std::numeric_limits<uint32_t>::max()
+			&& u32[3] == std::numeric_limits<uint32_t>::max();
 	}
 
-	//constexpr bool operator==(const IPAddress&) const noexcept = default;
+	constexpr bool isIPv6() const noexcept { return !isIPv4(); }
 
+	// constexpr bool operator==(const IPAddress&) const noexcept = default;
 
-	constexpr auto operator<=>(const IPAddress& other) const noexcept
-	{
-		return u64 <=> other.u64;
-	}
+	constexpr auto operator<=>(const IPAddress& other) const noexcept { return u64 <=> other.u64; }
 
-	constexpr bool operator==(const IPAddress& other) const noexcept
-	{
-		return u64 == other.u64;
-	}
+	constexpr bool operator==(const IPAddress& other) const noexcept { return u64 == other.u64; }
 
-	//constexpr std::strong_ordering operator<=>(const IPAddress& other) const noexcept = default;
+	// constexpr std::strong_ordering operator<=>(const IPAddress& other) const noexcept = default;
 
 	constexpr IPAddress& operator=(const IPAddress& other) noexcept
 	{
-		if (this != &other) {	
+		if (this != &other) {
 			u8 = other.u8;
 		}
 
 		return *this;
 	}
 
-	constexpr std::size_t size() const noexcept
-	{
-		return isIPv4() ? 4 : 16;
-	}
+	constexpr std::size_t size() const noexcept { return isIPv4() ? 4 : 16; }
 
-	std::string toString() const noexcept 
+	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));
-			});
+			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));
-			});
+			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;
 	}
-
 };
 
-/*friend constexpr auto operator<=>(const IPAddress& lhs, const IPAddress& rhs) noexcept 
+/*friend constexpr auto operator<=>(const IPAddress& lhs, const IPAddress& rhs) noexcept
 {
-    return lhs.u64 <=> rhs.u64;
+	return lhs.u64 <=> rhs.u64;
 }*/
 
 inline std::ostream& operator<<(std::ostream& os, const IPAddress& ip)

…lude/ipfixprobe/processPlugin/packet.hpp …ude/ipfixprobe/processPlugin/packet.hpptinclude/ipfixprobe/processPlugin/packet.hpp renamed to include/ipfixprobe/processPlugin/packet.hppt include/ipfixprobe/processPlugin/packet.hpp renamed to include/ipfixprobe/processPlugin/packet.hppt

@@ -14,18 +14,41 @@
 
 #pragma once
 
-#include <cstdint>
-#include "fieldManager.hpp"
 #include "../api.hpp"
+#include "fieldManager.hpp"
+#include "tcpOptions.hpp"
+
+#include <cstdint>
+#include <optional>
+
+#include <amon/Packet.hpp>
+#include <amon/layers/TCP.hpp>
 
 namespace ipxp {
 
 /**
  * @brief Forward declarations for packet processing classes.
  */
 class FlowRecord;
-class Packet;
-class PacketFeatures{};
+// class Packet;
+struct PacketFeatures {
+	Direction direction;
+
+	std::optional<amon::layers::TCPView> tcp;
+	std::optional<TCPOptions> tcpOptions;
+	uint16_t ipPayloadLength {0};
+
+	// TODO TCP view does not provide seq/ack getters
+	uint32_t tcpSequence {0};
+	uint32_t tcpAcknowledgment {0};
+};
+
+// TODO remove?
+constexpr std::span<const std::byte> getPayload(const amon::Packet& packet) noexcept
+{
+	return packet.data.subspan(
+		std::get<amon::PacketLayer>(packet.layers[*packet.layout.l7]).offset);
+}
 
 /**
  * @brief Context passed to plugin methods, containing references to flow and packet.
@@ -37,7 +60,7 @@ struct FlowContext {
 	/**< Reference to the flow record being processed. */
 	FlowRecord& flowRecord;
 	/**< Reference to the current packet being processed. */
-	Packet& packet;
+	amon::Packet& packet;
 	/**< Reference to extracted features of the current packet. */
 	PacketFeatures& features;
 };