++

Author: Zainullin Damir

include/ipfixprobe/processPlugin/fieldHandlersEnum.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "fieldHandler.hpp"
+
 #include <boost/container/static_vector.hpp>
 
 namespace ipxp {

include/ipfixprobe/processPlugin/flowRecord.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
-#include "timestamp.hpp"
-#include "flowKey.hpp"
 #include "directionalField.hpp"
-#include "tcpFlags.hpp"
+#include "flowKey.hpp"
+#include "macAddress.hpp"
 #include "packet.hpp"
+#include "tcpFlags.hpp"
+#include "timestamp.hpp"
 #include "xxhash.h"
 
 #include <array>
@@ -70,7 +71,6 @@ class FlowRecord {
 
 	FlowEndReason endReason;
 
-
 	// Bitset of flow fields that were specified as present
 	mutable FieldsBitset fieldsAvailable = {};
 	// Bitset of successfully constructed plugins (constructor accepted packet)
@@ -80,13 +80,12 @@ class FlowRecord {
 	// Bitset of plugins that are available for the flow
 	const PluginsBitset pluginsAvailable;
 
-
 	void erase()
 	{
 		hash = 0;
 		timeCreation = timeLastUpdate = {};
 		flowKey = {};
-		//directionalData = {};
+		// directionalData = {};
 
 		/*memset(&m_flow.time_first, 0, sizeof(m_flow.time_first));
 		memset(&m_flow.time_last, 0, sizeof(m_flow.time_last));
@@ -116,10 +115,7 @@ class FlowRecord {
 		m_flow.dst_tcp_flags = 0;*/
 	}
 
-	constexpr bool isEmpty() const noexcept
-	{
-		return hash == 0;
-	}
+	constexpr bool isEmpty() const noexcept { return hash == 0; }
 
 	/*constexpr bool belongs(uint64_t value) const noexcept
 	{
@@ -132,7 +128,6 @@ class FlowRecord {
 		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;
@@ -142,21 +137,21 @@ class FlowRecord {
 		timeCreation = packet.ts;
 		timeLastUpdate = packet.ts;
 
-		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);
+		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);
+				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);
+				reinterpret_cast<const std::byte*>(packet.dst_ip.v6),
+				16);
 		}
 	}
 

src/plugins/process/bstats/src/burst.hpp

@@ -11,6 +11,7 @@
 
 #include <directionalField.hpp>
 #include <sys/time.h>
+#include <timestamp.hpp>
 #include <utils.hpp>
 
 namespace ipxp {

src/plugins/process/common/utils/stringUtils.hpp

@@ -2,56 +2,48 @@
 
 #include <ranges>
 
-namespace ipxp
-{
+namespace ipxp {
+
+constexpr static inline auto integerToCharPtrView
+	= std::views::transform([](const auto& value) mutable {
+		  static std::array<char, 100> buffer;
+		  auto [end, _] = std::to_chars(buffer.data(), buffer.end(), value);
+		  return std::string_view(buffer.data(), end);
+	  });
 
-constexpr static inline 
-auto integerToCharPtrView = std::views::transform(
-    [](const auto& value) mutable {
-        static std::array<char, 100> buffer;
-        auto [end, _] = std::to_chars(buffer.data(), buffer.end(), value);
-        return std::string_view(buffer.data(), end);
-    });
-
-constexpr static inline
-bool pushBackWithDelimiter(
-    auto&& value, auto&& outputContainer, const char delimiter) noexcept
+constexpr static inline bool
+pushBackWithDelimiter(auto&& value, auto&& outputContainer, const char delimiter) noexcept
 {
-    if (outputContainer.size() + value.size() + sizeof(delimiter) 
-        > outputContainer.capacity()) {
-        return true;
-    }
+	if (outputContainer.size() + value.size() + sizeof(delimiter) > outputContainer.capacity()) {
+		return true;
+	}
 
-    outputContainer.append(value.begin(), value.end());
-    outputContainer.push_back(delimiter);
+	outputContainer.append(value.begin(), value.end());
+	outputContainer.push_back(delimiter);
 
-    return false;
+	return false;
 }
 
-constexpr static inline
-void concatenateRangeTo(
-    auto&& inputRange, 
-    auto&& outputContainer, 
-    const char delimiter,
-    const std::optional<char> terminator = std::nullopt) noexcept
+constexpr static inline void concatenateRangeTo(
+	auto&& inputRange,
+	auto&& outputContainer,
+	const char delimiter,
+	const std::optional<char> terminator = std::nullopt) noexcept
 {
-	const bool overflowed = std::ranges::any_of(inputRange,
-        [&](const auto& value) {
-            return pushBackWithDelimiter(
-                value, outputContainer, delimiter);
-        });
-
-    if (overflowed) {
-        return;
-    }
-
-    if (terminator.has_value()) {
-        outputContainer.back() = *terminator;
-    } else {
-        outputContainer.pop_back();
-    }
-
-    
+	const bool overflowed
+		= std::any_of(inputRange.begin(), inputRange.end(), [&](const auto& value) {
+			  return pushBackWithDelimiter(value, outputContainer, delimiter);
+		  });
+
+	if (overflowed) {
+		return;
+	}
+
+	if (terminator.has_value()) {
+		outputContainer.back() = *terminator;
+	} else {
+		outputContainer.pop_back();
+	}
 }
 
 } // namespace ipxp

src/plugins/process/http/src/httpParser.cpp

@@ -42,16 +42,7 @@ constexpr static bool isValidHTTPMethod(std::string_view payload) noexcept
 constexpr static bool hasHTTPVersionInRequest(std::string_view payload) noexcept
 {
 	constexpr std::string_view httpLabel = "HTTP";
-
-	auto spaces = payload | std::views::filter([](const char c) { return c == ' '; });
-
-	auto httpLabelBegin = std::ranges::next(spaces.begin(), 2);
-	auto httpLabelEnd = std::ranges::next(spaces.begin(), 3);
-	if (httpLabelBegin == spaces.end() || httpLabelEnd == spaces.end()) {
-		return false;
-	}
-
-	return std::string_view(&*std::next(httpLabelBegin), &*httpLabelEnd) == httpLabel;
+	return payload.contains(httpLabel);
 }
 
 constexpr static bool isRequest(std::string_view payload) noexcept
@@ -62,6 +53,7 @@ constexpr static bool isRequest(std::string_view payload) noexcept
 constexpr static bool hasHttpVersionInResponse(std::string_view payload) noexcept
 {
 	constexpr std::string_view httpLabel = "HTTP";
+
 	return payload.starts_with(httpLabel);
 }
 
@@ -109,20 +101,16 @@ constexpr bool HTTPParser::parseRequest(std::string_view payload) noexcept
 	if (methodEnd == std::string_view::npos) {
 		return false;
 	}
-	auto methodBegin
-		= std::ranges::find_if(payload, [](const unsigned char c) { return !std::isspace(c); });
-	const std::size_t methodBeginPos = std::distance(payload.begin(), methodBegin);
-	method = std::string_view(payload.substr(methodBeginPos, methodEnd - methodBeginPos));
+
+	auto methodBegin = payload.find_first_not_of(' ');
+	method = payload.substr(methodBegin, methodEnd - methodBegin);
 
 	const std::size_t uriEnd = payload.find(' ', methodEnd + 1);
 	if (uriEnd == std::string_view::npos) {
 		return false;
 	}
-	auto uriBegin = std::ranges::find_if(payload.substr(methodEnd + 1), [](const unsigned char c) {
-		return !std::isspace(c);
-	});
-	const std::size_t uriBeginPos = std::distance(payload.begin(), uriBegin);
-	uri = std::string_view(payload.substr(uriBeginPos, uriEnd - uriBeginPos));
+	auto uriBegin = payload.substr(methodEnd + 1).find_first_not_of(' ');
+	uri = payload.substr(uriBegin, uriEnd - uriBegin);
 
 	const std::size_t httpVersionEnd = payload.find('\n', uriEnd + 1);
 	if (httpVersionEnd == std::string_view::npos) {
@@ -147,7 +135,9 @@ bool HTTPParser::parseResponseHeaders(std::string_view payload) noexcept
 				cookies.emplace();
 			}
 			std::ranges::copy(
-				splitToVector(value) | std::views::transform(removeLeadingWhitespaces)
+				value | std::views::split(' ') | std::views::transform([](auto&& rng) {
+					return std::string_view(&*rng.begin(), std::ranges::distance(rng));
+				}) | std::views::transform(removeLeadingWhitespaces)
 					| std::views::take(cookies->capacity() - cookies->size()),
 				std::back_inserter(*cookies));
 		}
@@ -158,25 +148,24 @@ bool HTTPParser::parseResponseHeaders(std::string_view payload) noexcept
 
 constexpr bool HTTPParser::parseResponse(std::string_view payload) noexcept
 {
-	auto spaces = payload | std::views::filter([](const char c) { return c == ' '; });
-
-	auto statusCodeBegin = std::next(spaces.begin(), 1);
-	auto statusCodeEnd = std::next(spaces.begin(), 2);
-	if (statusCodeBegin == spaces.end() || statusCodeEnd == spaces.end()) {
-		return false;
-	}
-	const auto [_, errorCode] = std::from_chars(&*statusCodeBegin, &*statusCodeEnd, *statusCode);
-	if (errorCode != std::errc()) {
+	auto firstLine = payload.substr(0, payload.find('\n'));
+	if (firstLine.length() == payload.length()) {
 		return false;
 	}
 
-	const size_t statusMessageEnd
-		= payload.find('\n', std::distance(spaces.begin(), statusCodeEnd) + 1);
-	if (statusMessageEnd == std::string_view::npos) {
+	const std::size_t statusCodeBegin = firstLine.find(' ');
+	const std::size_t statusCodeEnd = firstLine.find(' ', statusCodeBegin + 1);
+	if (statusCodeBegin == std::string_view::npos || statusCodeEnd == std::string_view::npos
+		|| std::from_chars(
+			   firstLine.data() + statusCodeBegin + 1,
+			   firstLine.data() + statusCodeEnd,
+			   *statusCode)
+				.ec
+			!= std::errc()) {
 		return false;
 	}
 
-	return parseResponseHeaders(payload.substr(statusMessageEnd + 1));
+	return parseResponseHeaders(payload.substr(firstLine.size() + 1));
 }
 
 } // namespace ipxp

src/plugins/process/idpContent/src/idpContentData.hpp

@@ -14,6 +14,7 @@
 #include <span>
 
 #include <boost/container/static_vector.hpp>
+#include <directionalField.hpp>
 
 namespace ipxp {
 

src/plugins/process/passiveDns/src/passivedns.hpp

@@ -20,6 +20,7 @@
 #include <sstream>
 #include <string>
 
+#include <dnsParser/dnsRecord.hpp>
 #include <fieldHandlersEnum.hpp>
 #include <fieldManager.hpp>
 #include <processPlugin.hpp>

src/plugins/process/phists/src/packetHistogramData.hpp

@@ -10,6 +10,7 @@
 #pragma once
 
 #include <array>
+#include <optional>
 
 #include <directionalField.hpp>
 

src/plugins/process/pstats/src/packetStatsStorage.hpp

@@ -6,6 +6,7 @@
 
 #include <boost/container/static_vector.hpp>
 #include <tcpFlags.hpp>
+#include <timestamp.hpp>
 
 namespace ipxp {
 

src/plugins/process/rtsp/src/rtsp.cpp

@@ -1,14 +1,15 @@
 /**
  * @file
- * @brief Plugin for parsing basicplus traffic.
+ * @brief Plugin for parsing RTSP traffic.
  * @author Jiri Havranek <[email protected]>
  * @author Pavel Siska <[email protected]>
  * @author Damir Zainullin <[email protected]>
  * @date 2025
  *
- * Copyright (c) 2025 CESNET
+ * Provides a plugin that parses RTSP traffic,
+ * stores it in per-flow plugin data, and exposes that field via FieldManager.
  *
- * SPDX-License-Identifier: BSD-3-Clause
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
  */
 
 #include "rtsp.hpp"