++

Author: Damir Zainullin

process-plugin-api/Makefile

@@ -1,14 +1,24 @@
 CXX := g++
 CXXFLAGS := -std=c++20 -Wall -Wextra -pedantic -Wunused -Wconversion -Wsign-conversion -g -fsanitize=address
 TARGET := ipx
-SRC := main.cpp $(wildcard process/*/src/*.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) $^ -I. -I../include/ipfixprobe/pluginFactory -Iprocess/common -o $@
+$(TARGET): $(OBJ)
+	$(CXX) $(CXXFLAGS) $(INCLUDE) $^ -o $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDE) -c $< -o $@
 
 clean:
 	rm -f $(TARGET)

process-plugin-api/ipx

@@ -1,7 +1,19 @@
-#pragma once
-
 #include "dnsName.hpp"
 
+#include <numeric>
+#include <span>
+#include <string>
+#include <optional>
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <arpa/inet.h>
+#include <boost/container/static_vector.hpp>
+#include <boost/static_string.hpp>
+
+#include <utils/stringViewUtils.hpp>
+#include <utils/toHostByteOrder.hpp>
+
 namespace ipxp
 {
 
@@ -14,30 +26,31 @@ constexpr static bool isPointer(const std::byte byte) noexcept
 constexpr static uint16_t getPointerOffset(const std::byte* pointer) noexcept
 {
 	constexpr uint16_t pointerMask = 0x3FFF;
-	return ntohs(*reinterpret_cast<const uint16_t*>(pointer)) & pointerMask;
+	return toHostByteOrder(*reinterpret_cast<const uint16_t*>(pointer)) & pointerMask;
 }
 
 constexpr static std::size_t calculateElementsLength(auto&& container) noexcept
 {
-    return std::ranges::accumulate(container, std::size_t{0},
+    return std::accumulate(
+        container.begin(), container.end(), std::size_t{0},
         [](std::size_t sum, auto&& element) {
             return sum + element.size();
         });
 }
 
 constexpr
 std::optional<DNSName> DNSName::createFrom(
-    std::span<const std::byte> payload, const std::byte* dnsBegin) noexcept
+    std::span<const std::byte> payload, 
+    std::span<const std::byte> fullDNSpayload) noexcept
 {
     auto dnsName = std::make_optional<DNSName>();
-    uint16_t labelCount = 0;
     while (!payload.empty()) {
         if (isPointer(*payload.data())) {
             if (payload.size() < sizeof(uint16_t)) {
                 return std::nullopt;
             }
             const uint16_t pointerOffset = getPointerOffset(payload.data());
-            if (pointerOffset >= payload.size()) {
+            if (pointerOffset >= fullDNSpayload.size()) {
                 return std::nullopt;
             }
 
@@ -46,9 +59,7 @@ std::optional<DNSName> DNSName::createFrom(
             dnsName->m_length = calculateElementsLength(
                 dnsName->m_labels) + lengthBytesCount + sizeof(pointerOffset);
 
-            payload = std::span<const std::byte>(
-                dnsBegin + pointerOffset, payload.end());
-
+            payload = fullDNSpayload.subspan(pointerOffset);
             continue;
         }
 
@@ -57,21 +68,30 @@ std::optional<DNSName> DNSName::createFrom(
             return std::nullopt;
         }
         if (labelLength == 0) {
-            break;
+            return dnsName;
         }
 
-        if (!dnsName->m_labels.full()) {
-            dnsName->m_labels.push_back(toStringView(
-                payload.subspan(sizeof(uint8_t), labelLength)));
+        if (dnsName->m_labels.size() == dnsName->m_labels.capacity()) {
+            return std::nullopt;
         }
 
+        dnsName->m_labels.push_back(toStringView(
+                payload.subspan(sizeof(uint8_t), labelLength)));
+
         payload = payload.subspan(labelLength + sizeof(uint8_t));
     }
 
-    return dnsName;
+    return std::nullopt;
+}
+
+bool DNSName::operator==(const DNSName& other) const noexcept
+{
+    return std::equal(
+        m_labels.begin(), m_labels.end(),
+        other.m_labels.begin(), other.m_labels.end());
 }
 
-constexpr std::string DNSName::toString(const char delimiter) const noexcept
+std::string DNSName::toString(const char delimiter) const noexcept
 {
     std::string res;
     std::ranges::for_each(m_labels, [&res, delimiter](std::string_view label) {

process-plugin-api/main.o

@@ -19,14 +19,15 @@ class DNSName {
 
     constexpr static
     std::optional<DNSName> createFrom(
-        std::span<const std::byte> payload, const std::byte* dnsBegin) noexcept;
+        std::span<const std::byte> payload, 
+        std::span<const std::byte> fullDNSpayload) noexcept;
 
     /**
      * @brief Converts DNS name to string
      * @param delimiter Delimiter to use between labels
      * @return Concatenated labels with delimiter
      */
-    constexpr std::string toString(const char delimiter = '.') const noexcept;
+    std::string toString(const char delimiter = '.') const noexcept;
 
     /**
      * @brief Get length of the DNS name
@@ -35,6 +36,8 @@ class DNSName {
      */
     constexpr std::size_t length() const noexcept;
 
+    bool operator==(const DNSName& other) const noexcept;
+
 private:
 	constexpr static uint16_t MAX_LABEL_COUNT = 15;
 

process-plugin-api/process/common/dnsParser/dnsName.cpp

@@ -17,10 +17,10 @@
 
 #include "dnsSection.hpp"
 
-namespace ipxp2 {
+namespace ipxp {
 
 constexpr static
-bool parseDnsOverTCPLength(std::span<const std::byte> payload) noexcept
+std::optional<std::size_t> parseDNSOverTCPLength(std::span<const std::byte> payload) noexcept
 {
 	if (payload.size() < sizeof(uint16_t)) {
 		return std::nullopt;
@@ -63,7 +63,7 @@ parseSection(
 }
 
 constexpr
-bool DnsParser::parse(
+bool DNSParser::parse(
     std::span<const std::byte> payload, 
     const bool isDnsOverTCP,
     std::function<bool(const DNSQuestion& query)>& queryCallback,
@@ -74,7 +74,7 @@ bool DnsParser::parse(
 {
 	if (isDnsOverTCP) {
         const std::optional<uint16_t> dnsDataLength 
-            = parseDnsOverTCPLength(payload);
+            = parseDNSOverTCPLength(payload);
         if (!dnsDataLength.has_value() || 
             sizeof(uint16_t) + *dnsDataLength > payload.size()) {
 			return false;
@@ -152,7 +152,7 @@ std::optional<DNSHeader> parseHeader(std::span<const std::byte> payload) noexcep
 }
 
 constexpr
-std::optional<std::size_t> DnsParser::parseQuestionSection(
+std::optional<std::size_t> DNSParser::parseQuestionSection(
     std::span<const std::byte> payload,
     std::span<const std::byte> fullDNSPayload, 
     const uint16_t questionCount,
@@ -186,6 +186,7 @@ std::optional<std::size_t> DnsParser::parseQuestionSection(
                 .class = queryClass
             });
         }
+    }
         /*if (questionIndex == 0) {
             m_parsedFirstQuestion = {ParsedQuestion {
                 .name = *name,

process-plugin-api/process/common/dnsParser/dnsName.hpp

@@ -12,19 +12,21 @@
 #include <optional>
 #include <span>
 #include <string_view>
+#include <functional>
 
 #include <boost/container/static_vector.hpp>
 
 #include "dnsRecord.hpp"
 #include "dnsQuestion.hpp"
 #include "optRecord.hpp"
+#include "dnsQuestion.hpp"
 
-namespace ipxp2 {
+namespace ipxp {
 
 /**
  * @brief DNS parser class
  */
-class DnsParser {
+class DNSParser {
 
 public:
 	/**
@@ -35,10 +37,10 @@ class DnsParser {
 	 */
 	constexpr bool parse(
     std::span<const std::byte> payload, const bool isDnsOverTCP,
-    std::function<bool(const DNSQuestion& query)>& queryCallback,
-    std::function<bool(const DNSRecord& answer)>& answerCallback,
-    std::function<bool(const DNSRecord& authorityRecord)>& authorityCallback,
-    std::function<bool(const DNSRecord& additionalRecord)>& additionalCallback) noexcept;
+    const std::function<bool(const DNSQuestion& query)>& queryCallback,
+    const std::function<bool(const DNSRecord& answer)>& answerCallback,
+    const std::function<bool(const DNSRecord& authorityRecord)>& authorityCallback,
+    const std::function<bool(const DNSRecord& additionalRecord)>& additionalCallback) noexcept;
 
     uint16_t answersCount;
     uint16_t id;
@@ -56,7 +58,7 @@ class DnsParser {
     const std::byte* dnsBegin, 
     const uint16_t questionCount) noexcept;
 
-    constexpr std::optional<std::size_t> parseAnswerSection(
+    /*constexpr std::optional<std::size_t> parseAnswerSection(
     std::span<const std::byte> payload, 
     const std::byte* dnsBegin, 
     const DNSHeader& header) noexcept;
@@ -69,9 +71,9 @@ class DnsParser {
     constexpr std::optional<std::size_t> parseAdditionalResourceRecordsSection(
     std::span<const std::byte> payload, 
     const std::byte* dnsBegin, 
-    const DNSHeader& header) noexcept;
+    const DNSHeader& header) noexcept;*/
 
 };
 
-} // namespace ipxp2
+} // namespace ipxp
 

process-plugin-api/process/common/dnsParser/dnsName.o

@@ -3,35 +3,37 @@
 #include <variant>
 
 #include "dnsQueryType.hpp"
-#include "../dnsRecordPayloadTypes/dnsARecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsAAAARecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsDSRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsHINFORecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsSDNRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsKEYRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsMINFORecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsMXRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsPTRRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsRRSIGRecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsSOARecord.hpp"
-#include "../dnsRecordPayloadTypes/dnsTXTRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsARecord.hpp"
+#include "dnsRecordPayloadTypes/dnsAAAARecord.hpp"
+#include "dnsRecordPayloadTypes/dnsDSRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsHINFORecord.hpp"
+#include "dnsRecordPayloadTypes/dnsISDNRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsKEYRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsMINFORecord.hpp"
+#include "dnsRecordPayloadTypes/dnsMXRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsPTRRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsRRSIGRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsSOARecord.hpp"
+#include "dnsRecordPayloadTypes/dnsSRVRecord.hpp"
+#include "dnsRecordPayloadTypes/dnsTXTRecord.hpp"
 
 namespace ipxp
 {
 
 using DNSRecordPayloadType = std::variant<
-    dnsARecord,
-    dnsAAAARecord,
-    dnsDSRecord,
-    dnsHINFORecord,
-    dnsSDNRecord,
-    dnsKEYRecord,
-    dnsMINFORecord,
-    dnsMXRecord,
-    dnsPTRRecord,
-    dnsRRSIGRecord,
-    dnsSOARecord,
-    dnsTXTRecord
+    DNSARecord,
+    DNSAAAARecord,
+    DNSDSRecord,
+    DNSHINFORecord,
+    DNSISDNRecord,
+    DNSKEYRecord,
+    DNSMINFORecord,
+    DNSMXRecord,
+    DNSPTRRecord,
+    DNSRRSIGRecord,
+    DNSSOARecord,
+    DNSSRVRecord,
+    DNSTXTRecord
 >;
 
 class DNSRecordPayload
@@ -50,39 +52,39 @@ class DNSRecordPayload
     {
         switch (m_type) {
         case DNSQueryType::A:
-            return dnsARecord::createFrom(m_data);
+            return DNSARecord::createFrom(m_data);
         case DNSQueryType::AAAA:
-            return dnsAAAARecord::createFrom(m_data);
+            return DNSAAAARecord::createFrom(m_data);
         case DNSQueryType::NS: [[fallthrough]];
         case DNSQueryType::CNAME: [[fallthrough]];
         case DNSQueryType::PTR:
-            return dnsPTRRecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSPTRRecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::SOA:
-            return dnsSOARecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSSOARecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::MX:
-            return dnsMXRecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSMXRecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::TXT:
-            return dnsTXTRecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSTXTRecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::ISDN:
-            return dnsISDNRecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSISDNRecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::HINFO:
-            return dnsHINFORecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSHINFORecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::MINFO:
-            return dnsMINFORecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSMINFORecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::SRV:
-            return dnsSRVRecord::createFrom(m_data, m_fullDNSPayload);
+            return DNSSRVRecord::createFrom(m_data, m_fullDNSPayload);
         case DNSQueryType::RRSIG:
-            return dnsRRSIGRecord::createFrom(m_data);
+            return DNSRRSIGRecord::createFrom(m_data);
         case DNSQueryType::DNSKEY:
-            return dnsKEYRecord::createFrom(m_data);
+            return DNSKEYRecord::createFrom(m_data);
         case DNSQueryType::DS:
-            return dnsDSRecord::createFrom(m_data);
+            return DNSDSRecord::createFrom(m_data);
         default:
             return std::nullopt;
         }
     }
 
-    constexpr std::span<const std::byte> getPayload() const noexcept
+    constexpr std::span<const std::byte> getSpan() const noexcept
     {
         return m_data;
     }