++

Author: Zainullin Damir

include/ipfixprobe/processPlugin/directionalField.hpp

@@ -4,23 +4,24 @@
 
 class Direction {
 private:
-	enum class Value : std::size_t {Forward, Reverse};
+	enum class Value : std::size_t { Forward, Reverse };
 
-	constexpr Direction(const Value value) noexcept 
-	: m_value(value) {}
+	constexpr Direction(const Value value) noexcept
+		: m_value(value)
+	{
+	}
 
 public:
 	const static Direction Forward;
 	const static Direction Reverse;
 
-	constexpr Direction(const bool value) noexcept 
-	: m_value(static_cast<Value>(value)) {}
-
-	constexpr operator bool() const noexcept 
+	constexpr Direction(const bool value) noexcept
+		: m_value(static_cast<Value>(value))
 	{
-		return static_cast<bool>(m_value);
 	}
 
+	constexpr operator bool() const noexcept { return static_cast<bool>(m_value); }
+
 	constexpr Direction operator!() const noexcept
 	{
 		return Direction(!static_cast<bool>(m_value));
@@ -35,15 +36,9 @@ inline const Direction Direction::Reverse = Direction(Value::Reverse);
 
 template<typename T>
 struct DirectionalField {
-	T values[2]{};
+	T values[2] {};
 
-	constexpr T& operator[](const Direction d) 
-	{ 
-		return values[static_cast<bool>(d)];
-	}
+	constexpr T& operator[](const Direction d) { return values[static_cast<bool>(d)]; }
 
-	constexpr const T& operator[](const Direction d) const 
-	{
-		return values[static_cast<bool>(d)];
-	}
+	constexpr const T& operator[](const Direction d) const { return values[static_cast<bool>(d)]; }
 };

src/plugins/output/unirec/src/unirec.cpp

@@ -508,7 +508,8 @@ void UnirecExporter::processRecord(FlowRecordUniquePtr& flowRecord)
 	int ext_processed_cnd = 0;
 
 	std::ranges::for_each(m_fieldManager.getBiflowFields(), [&, index = 0](const FieldDescriptor& fieldDescriptor) mutable {
-		ext_processed_cnd++; 
+		ext_processed_cnd++;
+		std::cout << "Bit index is " << fieldDescriptor.getBitIndex() << "\n";
 		const void* pluginExportData = flowRecord->getPluginContext(fieldDescriptor.getBitIndex());
 		if (!fieldDescriptor.isInRecord(*flowRecord)) {
 			return;

src/plugins/process/basicPlus/README.md

@@ -0,0 +1,37 @@
+# BasicPlus Plugin
+
+The **BasicPlus Plugin** is a module for the IPFIXprobe exporter, designed to extend flow records with additional basic network information.
+
+## Features
+
+- Extends basic flow export data. 
+- Extracts and exports additional fields from network flows.
+
+
+## Output Fields
+
+| Field Name      | Data Type | Description                                                 |
+|-----------------|-----------|-------------------------------------------------------------|
+| IP_TTL          | uint8_t   | IP time-to-live in source-to-destination direction          |
+| IP_TTL_REV      | uint8_t   | IP time-to-live in destination-to-source direction          |
+| IP_FLG          | uint8_t   | IP flags in source-to-destination direction                 |
+| IP_FLG_REV      | uint8_t   | IP flags in destination-to-source direction                 |
+| TCP_WIN         | uint16_t  | TCP window size in source-to-destination direction          |
+| TCP_WIN_REV     | uint16_t  | TCP window size in destination-to-source direction          |
+| TCP_OPT         | uint8_t   | TCP options in source-to-destination direction              |
+| TCP_OPT_REV     | uint8_t   | TCP options in destination-to-source direction              |
+| TCP_MSS         | uint16_t  | TCP maximum segment size in source-to-destination direction |
+| TCP_MSS_REV     | uint16_t  | TCP maximum segment size in destination-to-source direction |
+| TCP_SYN_SIZE    | uint16_t  | TCP syn packet size (only one in bidirectional flow)        |
+
+## Usage
+
+Once enabled, the plugin will automatically process flows and add the export fields to each record.
+
+1. ``` make install ```.
+2. ``` ipfixprobe -p "basicplus" ... " ```
+3. Extracted values are exported to the output interface.
+
+## Support
+
+For issues or feature requests, please open an issue in the [IPFIXprobe repository](https://github.com/CESNET/ipfixprobe).

src/plugins/process/basicPlus/src/basicPlus.cpp

@@ -16,15 +16,12 @@
 
 #include <iostream>
 
-#include <ipfixprobe/pluginFactory/pluginManifest.hpp>
-#include <ipfixprobe/pluginFactory/pluginRegistrar.hpp>
-//#include <pluginManifest.hpp>
-//#include <pluginRegistrar.hpp>
-//#include <pluginFactory.hpp>
 #include <fieldGroup.hpp>
 #include <fieldManager.hpp>
-#include <tcpData.hpp>
 #include <ipfixprobe/options.hpp>
+#include <ipfixprobe/pluginFactory/pluginManifest.hpp>
+#include <ipfixprobe/pluginFactory/pluginRegistrar.hpp>
+#include <tcpData.hpp>
 
 namespace ipxp {
 
@@ -42,59 +39,83 @@ static const PluginManifest basicPlusPluginManifest = {
 		},
 };
 
-
-static FieldGroup createBasicPlusSchema(FieldManager& fieldManager, FieldHandlers<BasicPlusFields>& handlers)
+static FieldGroup
+createBasicPlusSchema(FieldManager& fieldManager, FieldHandlers<BasicPlusFields>& handlers)
 {
 	FieldGroup schema = fieldManager.createFieldGroup("basicplus");
 
 	auto [ipTTLField, ipTTLRevField] = schema.addScalarDirectionalFields(
-    "IP_TTL", "IP_TTL_REV",
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->ipTTL[Direction::Forward]; },
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->ipTTL[Direction::Reverse]; }
-	);
+		"IP_TTL",
+		"IP_TTL_REV",
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->ipTTL[Direction::Forward];
+		},
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->ipTTL[Direction::Reverse];
+		});
 	handlers.insert(BasicPlusFields::IP_TTL, ipTTLField);
 	handlers.insert(BasicPlusFields::IP_TTL_REV, ipTTLRevField);
 
 	auto [ipFlagField, ipFlagRevField] = schema.addScalarDirectionalFields(
-    "IP_FLG", "IP_FLG_REV",
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->ipFlag[Direction::Forward]; },
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->ipFlag[Direction::Reverse]; }
-	);
+		"IP_FLG",
+		"IP_FLG_REV",
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->ipFlag[Direction::Forward];
+		},
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->ipFlag[Direction::Reverse];
+		});
 	handlers.insert(BasicPlusFields::IP_FLG, ipFlagField);
 	handlers.insert(BasicPlusFields::IP_FLG_REV, ipFlagRevField);
 
 	auto [tcpWinField, tcpWinRevField] = schema.addScalarDirectionalFields(
-    "TCP_WIN", "TCP_WIN_REV",
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpWindow[Direction::Forward]; },
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpWindow[Direction::Reverse]; }
-	);
+		"TCP_WIN",
+		"TCP_WIN_REV",
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpWindow[Direction::Forward];
+		},
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpWindow[Direction::Reverse];
+		});
 	handlers.insert(BasicPlusFields::TCP_WIN, tcpWinField);
 	handlers.insert(BasicPlusFields::TCP_WIN_REV, tcpWinRevField);
 
 	auto [tcpOptField, tcpOptRevField] = schema.addScalarDirectionalFields(
-    "TCP_OPT", "TCP_OPT_REV",
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpOption[Direction::Forward]; },
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpOption[Direction::Reverse]; }
-	);
+		"TCP_OPT",
+		"TCP_OPT_REV",
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpOption[Direction::Forward];
+		},
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpOption[Direction::Reverse];
+		});
 	handlers.insert(BasicPlusFields::TCP_OPT, tcpOptField);
 	handlers.insert(BasicPlusFields::TCP_OPT_REV, tcpOptRevField);
 
 	auto [tcpMSSField, tcpMSSRevField] = schema.addScalarDirectionalFields(
-    "TCP_MSS", "TCP_MSS_REV",
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpMSS[Direction::Forward]; },
-		[](const void* context) { return reinterpret_cast<const BasicPlusData*>(context)->tcpMSS[Direction::Reverse]; }
-	);
+		"TCP_MSS",
+		"TCP_MSS_REV",
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpMSS[Direction::Forward];
+		},
+		[](const void* context) {
+			return reinterpret_cast<const BasicPlusData*>(context)->tcpMSS[Direction::Reverse];
+		});
 	handlers.insert(BasicPlusFields::TCP_MSS, tcpMSSField);
 	handlers.insert(BasicPlusFields::TCP_MSS_REV, tcpMSSRevField);
 
-	handlers.insert(BasicPlusFields::TCP_SYN_SIZE, schema.addScalarField("TCP_SYN_SIZE", [](const void* context) {
-		return static_cast<const BasicPlusData*>(context)->tcpSynSize;
-	}));
+	handlers.insert(
+		BasicPlusFields::TCP_SYN_SIZE,
+		schema.addScalarField("TCP_SYN_SIZE", [](const void* context) {
+			return static_cast<const BasicPlusData*>(context)->tcpSynSize;
+		}));
 
 	return schema;
 }
 
-BasicPlusPlugin::BasicPlusPlugin([[maybe_unused]]const std::string& params, FieldManager& fieldManager)
+BasicPlusPlugin::BasicPlusPlugin(
+	[[maybe_unused]] const std::string& params,
+	FieldManager& fieldManager)
 {
 	createBasicPlusSchema(fieldManager, m_fieldHandlers);
 }
@@ -142,8 +163,8 @@ PluginInitResult BasicPlusPlugin::onInit(const FlowContext& flowContext, void* p
 PluginUpdateResult BasicPlusPlugin::onUpdate(const FlowContext& flowContext, void* pluginContext)
 {
 	auto* pluginData = reinterpret_cast<BasicPlusData*>(pluginContext);
-	
-	pluginData->ipTTL[flowContext.packet.source_pkt] 
+
+	pluginData->ipTTL[flowContext.packet.source_pkt]
 		= std::min(pluginData->ipTTL[flowContext.packet.source_pkt], flowContext.packet.ip_ttl);
 
 	constexpr std::size_t TCP = 6;
@@ -184,7 +205,7 @@ PluginUpdateResult BasicPlusPlugin::onUpdate(const FlowContext& flowContext, voi
 	};
 }
 
-void BasicPlusPlugin::onDestroy(void* pluginContext) 
+void BasicPlusPlugin::onDestroy(void* pluginContext)
 {
 	std::destroy_at(reinterpret_cast<BasicPlusData*>(pluginContext));
 }
@@ -197,6 +218,7 @@ PluginDataMemoryLayout BasicPlusPlugin::getDataMemoryLayout() const noexcept
 	};
 }
 
-static const PluginRegistrar<BasicPlusPlugin, ProcessPluginFactory> basicPlusRegistrar(basicPlusPluginManifest);
+static const PluginRegistrar<BasicPlusPlugin, ProcessPluginFactory>
+	basicPlusRegistrar(basicPlusPluginManifest);
 
 } // namespace ipxp

src/plugins/process/basicPlus/src/basicPlus.hpp

@@ -14,21 +14,22 @@
 
 #pragma once
 
+#include "basicPlusData.hpp"
+#include "basicPlusFields.hpp"
+
 #include <sstream>
 #include <string>
 
-#include <processPlugin.hpp>
-#include <fieldManager.hpp>
 #include <fieldHandlersEnum.hpp>
-
-#include "basicPlusData.hpp"
-#include "basicPlusFields.hpp"
+#include <fieldManager.hpp>
+#include <processPlugin.hpp>
 
 namespace ipxp {
 
 /**
  * @class BasicPlusPlugin
- * @brief A plugin for collecting basic statistics about the flow: IP TTL, flags, TCP window, options, MSS and SYN length.
+ * @brief A plugin for collecting basic statistics about the flow: IP TTL, flags, TCP window,
+ * options, MSS and SYN length.
  */
 class BasicPlusPlugin : public ProcessPlugin {
 public:

src/plugins/process/basicPlus/src/basicPlusData.hpp

@@ -11,8 +11,7 @@
 
 #include <directionalField.hpp>
 
-namespace ipxp
-{
+namespace ipxp {
 
 /**
  * @struct BasicPlusExport
@@ -22,13 +21,12 @@ namespace ipxp
  * additional TCP-specific metrics.
  */
 struct BasicPlusData {
-	DirectionalField<uint8_t> ipTTL;        ///< Directional IP Time-To-Live value
-	DirectionalField<uint8_t> ipFlag;       ///< Directional IP flag value
-	DirectionalField<uint16_t> tcpWindow;   ///< Directional TCP window size
-	DirectionalField<uint64_t> tcpOption;   ///< Directional TCP option value
-	DirectionalField<uint32_t> tcpMSS;      ///< Directional TCP Maximum Segment Size
-	uint16_t tcpSynSize{0};                 ///< Size of TCP SYN packet
-};  
+	DirectionalField<uint8_t> ipTTL; ///< Directional IP Time-To-Live value
+	DirectionalField<uint8_t> ipFlag; ///< Directional IP flag value
+	DirectionalField<uint16_t> tcpWindow; ///< Directional TCP window size
+	DirectionalField<uint64_t> tcpOption; ///< Directional TCP option value
+	DirectionalField<uint32_t> tcpMSS; ///< Directional TCP Maximum Segment Size
+	uint16_t tcpSynSize {0}; ///< Size of TCP SYN packet
+};
 
 } // namespace ipxp
-

src/plugins/process/basicPlus/src/basicPlusFields.hpp

@@ -11,8 +11,7 @@
 
 #include <cstddef>
 
-namespace ipxp
-{
+namespace ipxp {
 
 /**
  * @enum BasicPlusFields
@@ -33,6 +32,6 @@ enum class BasicPlusFields : std::size_t {
 	TCP_MSS_REV,
 	TCP_SYN_SIZE,
 	FIELDS_SIZE,
-};    
-    
+};
+
 } // namespace ipxp