++

Author: Zainullin Damir

include/ipfixprobe/flowifc.hpp

@@ -233,11 +233,11 @@ struct Record {
 	virtual ~Record() { remove_extensions(); }
 };
 
-#define FLOW_END_INACTIVE 0x01
-#define FLOW_END_ACTIVE 0x02
-#define FLOW_END_EOF 0x03
-#define FLOW_END_FORCED 0x04
-#define FLOW_END_NO_RES 0x05
+//#define FLOW_END_INACTIVE 0x01
+//#define FLOW_END_ACTIVE 0x02
+//#define FLOW_END_EOF 0x03
+//#define FLOW_END_FORCED 0x04
+//#define FLOW_END_NO_RES 0x05
 
 /**
  * \brief Flow record struct constaining basic flow record data and extension headers.

include/ipfixprobe/outputPlugin.hpp include/ipfixprobe/outputPlugin.hpptinclude/ipfixprobe/outputPlugin.hpp renamed to include/ipfixprobe/outputPlugin.hppt

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "fieldManager.hpp"
+#include "flowRecord.hpp"
+#include "processPluginEntry.hpp"
+#include "../api.hpp"
+
+#include <vector>
+#include <string>
+#include <cstddef>
+#include <cstdint>
+
+//#include "../pluginFactory/pluginFactory.hpp"
+
+namespace ipxp {
+
+class IPXP_API OutputPlugin {
+public:
+	OutputPlugin(const FieldManager& fieldManager, const std::vector<ProcessPluginEntry>& plugins)
+		: m_fieldManager(fieldManager)
+		, m_plugins(plugins)
+	{
+	}
+
+	virtual void processRecord(FlowRecordUniquePtr& flowRecord) = 0;
+
+	std::size_t getDroppedCount() const noexcept
+	{
+		return m_dropped;
+	}
+
+	virtual ~OutputPlugin() = default;
+
+protected:
+	const FieldManager& m_fieldManager;
+	const std::vector<ProcessPluginEntry>& m_plugins;
+	std::size_t m_dropped = 0;
+};
+
+template<typename Base, typename... Args>
+class IPXP_API PluginFactory;
+
+/**
+ * @brief Type alias for the OutputPlugin factory.
+ *
+ * Provides a factory for creating OutputPlugin instances using a string-based constructor.
+ */
+using OutputPluginFactory = PluginFactory<OutputPlugin, const std::string&, const FieldManager&, const std::vector<ProcessPluginEntry>&>;
+
+} // namespace ipxp

include/ipfixprobe/outputPlugin/outputPlugin.hpp

@@ -43,7 +43,7 @@ class IPXP_API PluginFactory {
 	 *
 	 * @return A reference to the singleton `PluginFactory` instance.
 	 */
-	inline static PluginFactory& getInstance()
+	static PluginFactory& getInstance()
 	{
 		static PluginFactory instance;
 		return instance;
@@ -64,6 +64,8 @@ class IPXP_API PluginFactory {
 	void registerPlugin(const PluginManifest& manifest)
 	{
 		static_assert(std::is_base_of<Base, Derived>::value, "Derived must be a subclass of Base");
+		
+		std::cout << manifest.name << "=" << std::hex << std::size_t(this) << std::endl;
 
 		m_registeredPlugins[manifest] = createGenerators<Base, Derived, Args...>();
 	}

include/ipfixprobe/pluginFactory/pluginFactory.hpp

@@ -174,6 +174,6 @@ class IPXP_API PluginFactory;
  *
  * Provides a factory for creating ProcessPlugin instances using a string-based constructor.
  */
-using ProcessPluginFactory = PluginFactory<ProcessPlugin, const std::string&, int>;
+//using ProcessPluginFactory = PluginFactory<ProcessPlugin, const std::string&, int>;
 
 } // namespace ipxp

include/ipfixprobe/processPlugin.hpp include/ipfixprobe/processPlugin.hpptinclude/ipfixprobe/processPlugin.hpp renamed to include/ipfixprobe/processPlugin.hppt

@@ -0,0 +1,71 @@
+/**
+ * @file
+ * @author Pavel Siska <[email protected]>
+ * @brief Type traits and helpers for FieldSchema, including scalar/vector detection and
+ * element type extraction.
+ *
+ * This header defines compile-time utilities used by FieldSchema to:
+ * - Determine if an accessor is scalar or vector.
+ * - Extract element type from std::span or scalar type.
+ *
+ * @note These helpers are intended primarily for use within FieldSchema.
+ *
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
+ */
+
+#pragma once
+
+#include "fieldAccessor.hpp"
+
+#include <span>
+#include <type_traits>
+
+namespace ipxp {
+
+/**
+ * @brief Extracts the element type from a type, removing const/volatile qualifiers.
+ *
+ * - If the given type is a `std::span<T, Extent>`, the element type is `T` without cv-qualifiers.
+ * - Otherwise, the type itself (without cv-qualifiers) is returned.
+ *
+ * @tparam T Type to extract from.
+ */
+template<typename T>
+struct span_element_type {
+	using type = std::remove_cv_t<T>;
+};
+
+template<typename T, std::size_t Extent>
+struct span_element_type<std::span<T, Extent>> {
+	using type = std::remove_cv_t<T>;
+};
+
+/**
+ * @brief Trait to detect whether a given accessor template is ScalarAccessor.
+ *
+ * Defaults to `false`; specialized for `ScalarAccessor<T>`.
+ *
+ * @tparam Accessor Accessor template (e.g., ScalarAccessor or VectorAccessor)
+ * @tparam F Type argument to the accessor template
+ */
+template<template<typename> class Accessor, typename F>
+struct is_scalar_accessor : std::false_type {};
+
+template<typename T>
+struct is_scalar_accessor<ScalarAccessor, T> : std::true_type {};
+
+/**
+ * @brief Trait to detect whether a given accessor template is VectorAccessor.
+ *
+ * Defaults to `false`; specialized for `VectorAccessor<T>`.
+ *
+ * @tparam Accessor Accessor template
+ * @tparam F Type argument
+ */
+template<template<typename> class Accessor, typename F>
+struct is_vector_accessor : std::false_type {};
+
+template<typename T>
+struct is_vector_accessor<VectorAccessor, T> : std::true_type {};
+
+} // namespace ipxp

include/ipfixprobe/processPlugin/fieldGroupTypeTraits.hpp

@@ -4,6 +4,7 @@
 #include "flowKey.hpp"
 #include "directionalField.hpp"
 #include "tcpFlags.hpp"
+#include "packet.hpp"
 
 #include <array>
 #include <bitset>
@@ -46,6 +47,14 @@ struct DirectionalData {
 	TCPFlags tcpFlags = 0;
 };
 
+enum class FlowEndReason : uint8_t {
+	FLOW_END_INACTIVE = 0x01,
+	FLOW_END_ACTIVE = 0x02,
+	FLOW_END_EOF = 0x03,
+	FLOW_END_FORCED = 0x04,
+	FLOW_END_NO_RES = 0x05
+};
+
 class FlowRecord {
 public:
 	uint64_t hash;
@@ -57,14 +66,122 @@ class FlowRecord {
 
 	DirectionalField<DirectionalData> directionalData;
 
+	FlowEndReason endReason;
+
 	// Bitset of flow fields that were specified as present
 	mutable FieldsBitset fieldsAvailable = {};
 	// Bitset of successfully constructed plugins (constructor accepted packet)
 	PluginsBitset pluginsConstructed = {};
 	// Bitset of plugins that still wants to process packets of the flow
 	PluginsBitset pluginsUpdate = {};
 	// Bitset of plugins that are available for the flow
-	const PluginsBitset pluginsAvailable;
+	// TODO GET BACK CONST ?
+	PluginsBitset pluginsAvailable;
+
+	void erase()
+	{
+		hash = 0;
+		timeCreation = timeLastUpdate = {};
+		flowKey = {};
+		//directionalData = {};
+
+		/*memset(&m_flow.time_first, 0, sizeof(m_flow.time_first));
+		memset(&m_flow.time_last, 0, sizeof(m_flow.time_last));
+		m_flow.ip_version = 0;
+		m_flow.ip_proto = 0;
+		memset(&m_flow.src_ip, 0, sizeof(m_flow.src_ip));
+		memset(&m_flow.dst_ip, 0, sizeof(m_flow.dst_ip));
+		m_flow.src_port = 0;
+		m_flow.dst_port = 0;
+		m_flow.src_packets = 0;
+		m_flow.dst_packets = 0;
+		m_flow.src_bytes = 0;
+		m_flow.dst_bytes = 0;
+		m_flow.src_tcp_flags = 0;
+		m_flow.dst_tcp_flags = 0;*/
+	}
+
+	void reuse()
+	{
+		/*m_flow.remove_extensions();
+		m_flow.time_first = m_flow.time_last;
+		m_flow.src_packets = 0;
+		m_flow.dst_packets = 0;
+		m_flow.src_bytes = 0;
+		m_flow.dst_bytes = 0;
+		m_flow.src_tcp_flags = 0;
+		m_flow.dst_tcp_flags = 0;*/
+	}
+
+	inline __attribute__((always_inline)) bool is_empty() const
+	{
+		return hash == 0;
+	}
+
+	inline __attribute__((always_inline)) bool belongs(uint64_t value) const
+	{
+		return hash == value;
+	}
+
+	void create(const Packet& packet, uint64_t hash)
+	{
+		/*m_flow.src_packets = 1;
+
+		m_hash = hash;
+
+		m_flow.time_first = pkt.ts;
+		m_flow.time_last = pkt.ts;
+		m_flow.flow_hash = hash;
+
+		memcpy(m_flow.src_mac, pkt.src_mac, 6);
+		memcpy(m_flow.dst_mac, pkt.dst_mac, 6);
+
+		if (pkt.ip_version == IP::v4) {
+			m_flow.ip_version = pkt.ip_version;
+			m_flow.ip_proto = pkt.ip_proto;
+			m_flow.src_ip.v4 = pkt.src_ip.v4;
+			m_flow.dst_ip.v4 = pkt.dst_ip.v4;
+			m_flow.src_bytes = pkt.ip_len;
+		} else if (pkt.ip_version == IP::v6) {
+			m_flow.ip_version = pkt.ip_version;
+			m_flow.ip_proto = pkt.ip_proto;
+			memcpy(m_flow.src_ip.v6, pkt.src_ip.v6, 16);
+			memcpy(m_flow.dst_ip.v6, pkt.dst_ip.v6, 16);
+			m_flow.src_bytes = pkt.ip_len;
+		}
+
+		if (pkt.ip_proto == IPPROTO_TCP) {
+			m_flow.src_port = pkt.src_port;
+			m_flow.dst_port = pkt.dst_port;
+			m_flow.src_tcp_flags = pkt.tcp_flags;
+		} else if (pkt.ip_proto == IPPROTO_UDP) {
+			m_flow.src_port = pkt.src_port;
+			m_flow.dst_port = pkt.dst_port;
+		} else if (pkt.ip_proto == IPPROTO_ICMP || pkt.ip_proto == IPPROTO_ICMPV6) {
+			m_flow.src_port = pkt.src_port;
+			m_flow.dst_port = pkt.dst_port;
+		}*/
+	}
+
+	void update(const Packet& packet, bool src)
+	{
+		/*m_flow.time_last = pkt.ts;
+		if (src) {
+			m_flow.src_packets++;
+			m_flow.src_bytes += pkt.ip_len;
+
+			if (pkt.ip_proto == IPPROTO_TCP) {
+				m_flow.src_tcp_flags |= pkt.tcp_flags;
+			}
+		} else {
+			m_flow.dst_packets++;
+			m_flow.dst_bytes += pkt.ip_len;
+
+			if (pkt.ip_proto == IPPROTO_TCP) {
+				m_flow.dst_tcp_flags |= pkt.tcp_flags;
+			}
+		}*/
+	}
 
 	void* getPluginContext(std::size_t pluginIndex)
 	{

include/ipfixprobe/processPlugin/flowRecord.hpp

@@ -3,7 +3,7 @@
 #include "flowKey.hpp"
 #include "flowRecord.hpp"
 #include "ipAddress.hpp"
-#include "processPluginBuilder.hpp"
+//#include "processPluginBuilder.hpp"
 
 #include <cstddef>
 #include <memory>

include/ipfixprobe/processPlugin/flowRecordBuilder.hpp

@@ -19,7 +19,6 @@
 #include "packet.hpp"
 #include "fieldManager.hpp"
 #include "../api.hpp"
-#include "../pluginFactory/pluginFactory.hpp"
 
 namespace ipxp {
 
@@ -229,10 +228,23 @@ class IPXP_API ProcessPlugin {
 	[[nodiscard]] virtual PluginDataMemoryLayout getDataMemoryLayout() const noexcept = 0;
 };
 
-/*template<typename Base, typename... Args>
+/**
+ * @brief Factory template for creating plugins.
+ *
+ * This template allows dynamic creation of plugin instances based on the specified
+ * base class and constructor argument types.
+ *
+ * @tparam Base The base class for the plugin.
+ * @tparam Args The argument types required for the plugin constructor.
+ */
+template<typename Base, typename... Args>
 class IPXP_API PluginFactory;
 
+/**
+ * @brief Type alias for the ProcessPlugin factory.
+ *
+ * Provides a factory for creating ProcessPlugin instances using a string-based constructor.
+ */
 using ProcessPluginFactory = PluginFactory<ProcessPlugin, const std::string&, FieldManager&>;
-*/
 
 } // namespace ipxp