++

Author: Damir Zainullin

process-plugin-api/ipAddress.hpp

@@ -19,19 +19,19 @@ union IPAddress {
 	constexpr IPAddress() noexcept 
 	{ 
 		std::memset(&u8, 0, sizeof(IPAddress)); 
-	};
+	}
 
 	constexpr IPAddress(const uint32_t ipv4) noexcept
 	{
 		u32[0] = ipv4;
 		u32[1] = 0;
 		u32[2] = u32[3] = std::numeric_limits<uint32_t>::max();
-	};
+	}
 
 	constexpr IPAddress(const std::array<uint8_t, 16>& ipv6) noexcept
 	{
 		u8 = ipv6;
-	};
+	}
 
 	constexpr bool isIPv4() const noexcept
 	{

…plugin-api/process/dns/src/dnsHeader.hpp …i/process/common/dnsParser/dnsHeader.hppprocess-plugin-api/process/dns/src/dnsHeader.hpp renamed to process-plugin-api/process/common/dnsParser/dnsHeader.hpp process-plugin-api/process/dns/src/dnsHeader.hpp renamed to process-plugin-api/process/common/dnsParser/dnsHeader.hpp

@@ -35,11 +35,43 @@ bool parseDnsOverTCPLength(std::span<const std::byte> payload) noexcept
 	return dnsDataLength;
 }
 
+constexpr static
+std::optional<std::size_t>
+parseSection(
+    std::span<const std::byte> payload, 
+    std::span<const std::byte> fullDNSPayload, 
+    const uint16_t recordCount,
+    std::function<bool(const DNSRecord& record)>& recordCallback) noexcept
+{
+    const std::byte* lastRecordPayloadEnd = payload.data();
+    DNSSectionReader reader(payload, fullDNSPayload, recordCount);
+    
+    std::ranges::for_each(reader, 
+        [&recordCallback, &lastRecordPayloadEnd, needToCallCallback = true]
+        (const DNSRecord& record) mutable {
+            lastRecordPayloadEnd = record.data.getSpan().end();
+            if (needToCallCallback) {
+                needToCallCallback = !recordCallback(record);
+            }
+    });
+
+	/*if (!parsedSection->records.empty()) {
+		m_firstAnswer = parsedSection->records[0];
+	}*/
+
+	return lastRecordPayloadEnd - payload.data();
+}
+
 constexpr
 bool DnsParser::parse(
-    std::span<const std::byte> payload, const bool isDnsOverTCP) noexcept
+    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::byte* dnsBegin = payload.data();
 	if (isDnsOverTCP) {
         const std::optional<uint16_t> dnsDataLength 
             = parseDnsOverTCPLength(payload);
@@ -48,47 +80,61 @@ bool DnsParser::parse(
 			return false;
 		}
         payload = payload.subspan(sizeof(uint16_t), *dnsDataLength);
-        dnsBegin = payload.data();
+        
 	}
 
+    fullDNSPayload = payload;
+    
     const std::optional<DNSHeader> header = parseHeader(payload);
 	if (!header.has_value()) {
 		return false;
 	}
-    m_answersCount = ntohs(header->answerRecordCount);
-    m_id = header->id;
-    m_responseCode = header->flags.responseCode;
+    answersCount = ntohs(header->answerRecordCount);
+    id = header->id;
+    responseCode = header->flags.responseCode;
 
-    const std::span<const std::byte> originalDNSPayload = payload;
     constexpr std::size_t questionSectionOffset = sizeof(DNSHeader);
     const std::optional<std::size_t> questionSectionSize = parseQuestionSection(
-        originalDNSPayload,
-        originalDNSPayload.subspan(questionSectionOffset),
-        ntohs(header->questionRecordCount));
+        payload.subspan(questionSectionOffset),
+        fullDNSPayload,
+        ntohs(header->questionRecordCount),
+        queryCallback);
 	if (!questionSectionSize.has_value()) {
 		return false;
 	}
 
     const std::size_t answerSectionOffset 
         = questionSectionOffset + *questionSectionSize;
     const std::optional<std::size_t> answerSectionSize 
-        = parseAnswerSection(payload.subspan(answerSectionOffset), dnsBegin, *header);
+        = parseSection(
+            payload.subspan(answerSectionOffset), 
+            fullDNSPayload, 
+            ntohs(header->answerRecordCount),
+            answerCallback);
 	if (!answerSectionSize.has_value()) {
 		return false;
 	}
 
     const std::size_t authoritySectionOffset 
         = questionSectionOffset + *parseQuestionSection;
     const std::optional<std::size_t> authoritySectionSize 
-        = parseAuthorityResourceRecordsSection(payload.subspan(authoritySectionOffset), dnsBegin, *header);
+        = parseSection(
+            payload.subspan(authoritySectionOffset), 
+            fullDNSPayload, 
+            ntohs(header->authorityRecordCount),
+            authorityCallback);
 	if (!authoritySectionSize.has_value()) {
 		return false;
 	}
 
     const std::size_t additionalSectionOffset 
         = authoritySectionOffset + *authoritySectionSize;
     const std::optional<std::size_t> additionalSectionSize 
-        = parseAdditionalResourceRecordsSection(payload.subspan(additionalSectionOffset), dnsBegin, *header);
+        = parseSection(
+            payload.subspan(additionalSectionOffset), 
+            fullDNSPayload, 
+            ntohs(header->additionalRecordCount),
+            additionalCallback);
 	if (!additionalSectionSize.has_value()) {
 		return false;
 	}
@@ -108,13 +154,17 @@ std::optional<DNSHeader> parseHeader(std::span<const std::byte> payload) noexcep
 constexpr
 std::optional<std::size_t> DnsParser::parseQuestionSection(
     std::span<const std::byte> payload,
-    const std::byte* dnsBegin, 
-    const uint16_t questionCount) noexcept
+    std::span<const std::byte> fullDNSPayload, 
+    const uint16_t questionCount,
+    std::function<bool(const DNSQuestion& query)>& queryCallback) noexcept
 {
-	for (size_t questionIndex = 0; questionIndex < questionCount;
-		 questionIndex++) {
+    const std::byte* queriesBegin = payload.data();
+    bool needToCallCallback = true;
+
+	for (size_t questionIndex = 0; questionIndex < questionCount; questionIndex++) {
 
-		const std::optional<DNSName> name = DNSName::createFrom(payload, dnsBegin);
+		const std::optional<DNSName> name 
+            = DNSName::createFrom(payload, fullDNSPayload);
 		if (!name.has_value()) {
 			return std::nullopt;
 		}
@@ -129,17 +179,23 @@ std::optional<std::size_t> DnsParser::parseQuestionSection(
 
         payload = payload.subspan(name->length() + 2 * sizeof(uint16_t));
 
-        if (questionIndex == 0) {
-			m_parsedFirstQuestion = {ParsedQuestion {
-				.name = *name,
-				.type = queryType,
-				.recordClass = queryClass}};
-		}
-	}
+        if (needToCallCallback) {
+            needToCallCallback = !queryCallback(DNSQuery{
+                .name = *name,
+                .type = queryType,
+                .class = queryClass
+            });
+        }
+        /*if (questionIndex == 0) {
+            m_parsedFirstQuestion = {ParsedQuestion {
+                .name = *name,
+                .type = queryType,
+            .recordClass = queryClass}};
+        }*/
 
-	return static_cast<std::size_t>(questionBegin - m_dnsData.data());
+	return static_cast<std::size_t>(payload.data() - queriesBegin);
 }
-
+/*
 constexpr
 std::optional<std::size_t>
 DnsParser::parseAnswerSection(
@@ -208,7 +264,7 @@ DnsParser::parseAdditionalResourceRecordsSection(
     }
 
 	return parsedSection->records.back().data.end() - payload.data().begin();
-}
+}*/
 
-} // namespace ipxp2
+} // namespace ipxp
 

…n-api/process/dns/src/dnsHeaderFlags.hpp …cess/common/dnsParser/dnsHeaderFlags.hppprocess-plugin-api/process/dns/src/dnsHeaderFlags.hpp renamed to process-plugin-api/process/common/dnsParser/dnsHeaderFlags.hpp process-plugin-api/process/dns/src/dnsHeaderFlags.hpp renamed to process-plugin-api/process/common/dnsParser/dnsHeaderFlags.hpp

@@ -34,15 +34,19 @@ class DnsParser {
 	 * @return True of parsed successfully, false otherwise
 	 */
 	constexpr bool parse(
-    std::span<const std::byte> payload, const bool isDnsOverTCP) noexcept;
+    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;
 
     uint16_t answersCount;
     uint16_t id;
     uint8_t responseCode;
     std::optional<DNSQuestion> firstQuestion;
 	std::optional<DNSRecord> firstAnswer;
 	std::optional<OPTRecord> firstOPTRecord;
-    const std::byte* dnsBegin;
+    std::span<const std::byte> fullDNSPayload;
 
 
 private:

…s-plugin-api/process/dns/src/dnsName.cpp …api/process/common/dnsParser/dnsName.cppprocess-plugin-api/process/dns/src/dnsName.cpp renamed to process-plugin-api/process/common/dnsParser/dnsName.cpp process-plugin-api/process/dns/src/dnsName.cpp renamed to process-plugin-api/process/common/dnsParser/dnsName.cpp

@@ -7,6 +7,7 @@
 
 #include "dnsName.hpp"
 #include "dnsQueryType.hpp"
+#include "dnsRecordPayload.hpp"
 
 namespace ipxp
 {
@@ -19,9 +20,7 @@ struct DNSRecord {
     DNSQueryType type;
     uint16_t recordClass;
     uint32_t timeToLive;
-    std::span<const std::byte> data;
-
-    std::string toString() const noexcept;
+    DNSRecordPayload payload;
 };
 
 } // namespace ipxp