Skip to content

Commit 53abf93

Browse files
author
Damir Zainullin
committed
++
1 parent 94247bd commit 53abf93

File tree

9 files changed

+128
-90
lines changed

9 files changed

+128
-90
lines changed

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

Lines changed: 33 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717

1818
#include "dnsSection.hpp"
1919
#include "dnsSectionReader.hpp"
20+
#include "dnsHeader.hpp"
2021

2122
namespace ipxp {
2223

@@ -42,15 +43,18 @@ parseSection(
4243
std::span<const std::byte> payload,
4344
std::span<const std::byte> fullDNSPayload,
4445
const uint16_t recordCount,
45-
std::function<bool(const DNSRecord& record)>& recordCallback) noexcept
46+
const std::function<bool(const DNSRecord& record)>& recordCallback) noexcept
4647
{
47-
const std::byte* lastRecordPayloadEnd = payload.data();
48-
DNSSectionReader reader(payload, fullDNSPayload, recordCount);
48+
std::size_t sectionSize{0};
49+
const auto sectionBegin = payload.begin();
50+
51+
DNSSectionReader reader(recordCount, payload, fullDNSPayload);
4952

5053
std::ranges::for_each(reader,
51-
[&recordCallback, &lastRecordPayloadEnd, needToCallCallback = true]
54+
[&, needToCallCallback = true]
5255
(const DNSRecord& record) mutable {
53-
lastRecordPayloadEnd = record.data.getSpan().end();
56+
sectionSize = static_cast<std::size_t>(
57+
std::distance(sectionBegin, record.payload.getSpan().end()));
5458
if (needToCallCallback) {
5559
needToCallCallback = !recordCallback(record);
5660
}
@@ -60,20 +64,27 @@ parseSection(
6064
m_firstAnswer = parsedSection->records[0];
6165
}*/
6266

63-
return lastRecordPayloadEnd - payload.data();
67+
return sectionSize;
6468
}
6569

66-
constexpr
67-
bool DNSParser::parse(
68-
std::span<const std::byte> payload,
69-
const bool isDnsOverTCP,
70-
std::function<bool(const DNSQuestion& query)>& queryCallback,
71-
std::function<bool(const DNSRecord& answer)>& answerCallback,
72-
std::function<bool(const DNSRecord& authorityRecord)>& authorityCallback,
73-
std::function<bool(const DNSRecord& additionalRecord)>& additionalCallback
70+
constexpr static
71+
std::optional<DNSHeader> parseHeader(std::span<const std::byte> payload) noexcept
72+
{
73+
if (payload.size() < sizeof(DNSHeader)) {
74+
return std::nullopt;
75+
}
76+
return *reinterpret_cast<const DNSHeader*>(payload.data());
77+
}
78+
79+
constexpr bool DNSParser::parse(
80+
std::span<const std::byte> payload, const bool isDNSOverTCP,
81+
const std::function<bool(const DNSQuestion& query)>& queryCallback,
82+
const std::function<bool(const DNSRecord& answer)>& answerCallback,
83+
const std::function<bool(const DNSRecord& authorityRecord)>& authorityCallback,
84+
const std::function<bool(const DNSRecord& additionalRecord)>& additionalCallback
7485
) noexcept
7586
{
76-
if (isDnsOverTCP) {
87+
if (isDNSOverTCP) {
7788
const std::optional<uint16_t> dnsDataLength
7889
= parseDNSOverTCPLength(payload);
7990
if (!dnsDataLength.has_value() ||
@@ -117,7 +128,7 @@ bool DNSParser::parse(
117128
}
118129

119130
const std::size_t authoritySectionOffset
120-
= questionSectionOffset + *parseQuestionSection;
131+
= questionSectionOffset + *questionSectionSize;
121132
const std::optional<std::size_t> authoritySectionSize
122133
= parseSection(
123134
payload.subspan(authoritySectionOffset),
@@ -143,21 +154,12 @@ bool DNSParser::parse(
143154
return true;
144155
}
145156

146-
constexpr static
147-
std::optional<DNSHeader> parseHeader(std::span<const std::byte> payload) noexcept
148-
{
149-
if (payload.size() < sizeof(DNSHeader)) {
150-
return std::nullopt;
151-
}
152-
return *reinterpret_cast<const DNSHeader*>(payload.data());
153-
}
154-
155157
constexpr
156158
std::optional<std::size_t> DNSParser::parseQuestionSection(
157159
std::span<const std::byte> payload,
158160
std::span<const std::byte> fullDNSPayload,
159161
const uint16_t questionCount,
160-
std::function<bool(const DNSQuestion& query)>& queryCallback) noexcept
162+
const std::function<bool(const DNSQuestion& query)>& queryCallback) noexcept
161163
{
162164
const std::byte* queriesBegin = payload.data();
163165
bool needToCallCallback = true;
@@ -181,10 +183,11 @@ std::optional<std::size_t> DNSParser::parseQuestionSection(
181183
payload = payload.subspan(name->length() + 2 * sizeof(uint16_t));
182184

183185
if (needToCallCallback) {
184-
needToCallCallback = !queryCallback(DNSQuery{
185-
.name = *name,
186-
.type = queryType,
187-
.class = queryClass
186+
needToCallCallback = !queryCallback(
187+
DNSQuestion{
188+
.name = *name,
189+
.type = static_cast<DNSQueryType>(queryType),
190+
.recordClass = queryClass
188191
});
189192
}
190193
}

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

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -54,9 +54,10 @@ class DNSParser {
5454
private:
5555

5656
constexpr std::optional<std::size_t> parseQuestionSection(
57-
std::span<const std::byte> payload,
58-
const std::byte* dnsBegin,
59-
const uint16_t questionCount) noexcept;
57+
std::span<const std::byte> payload,
58+
std::span<const std::byte> fullDNSPayload,
59+
const uint16_t questionCount,
60+
const std::function<bool(const DNSQuestion& query)>& queryCallback) noexcept;
6061

6162
/*constexpr std::optional<std::size_t> parseAnswerSection(
6263
std::span<const std::byte> payload,

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

896 KB
Binary file not shown.

‎process-plugin-api/process/common/dnsParser/dnsSection.cpp‎

Lines changed: 13 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,30 +1,38 @@
11
#include "dnsSection.hpp"
22

3+
#include <span>
4+
#include <ranges>
5+
#include <optional>
6+
#include <algorithm>
7+
38
#include "dnsSectionReader.hpp"
49

10+
11+
512
namespace ipxp
613
{
714

8-
constexpr
915
std::optional<DNSSection>
1016
DNSSection::parseSection(
1117
std::span<const std::byte> section,
12-
const std::byte* dnsBegin,
18+
std::span<const std::byte> fullDNSPayload,
1319
const std::size_t recordsCount) noexcept
1420
{
1521
auto res = std::make_optional<DNSSection>();
16-
DNSSectionReader reader(section, recordsCount, dnsBegin);
22+
DNSSectionReader reader(recordsCount, section, fullDNSPayload);
1723
std::ranges::copy(reader |
1824
std::views::take(res->records.capacity()),
1925
std::back_inserter(res->records));
2026

21-
if (!reader.parsedSuccessfully) {
27+
if (!reader.parsedSuccessfully()) {
2228
return std::nullopt;
2329
}
2430

2531
res->size = 0;
2632
if (recordsCount != 0) {
27-
res->size = res->records.back().data.end() - section.begin();
33+
res->size = static_cast<std::size_t>(std::distance(
34+
section.begin(),
35+
res->records.back().payload.getSpan().end()));
2836
}
2937
return res;
3038
}

‎process-plugin-api/process/common/dnsParser/dnsSection.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ struct DNSSection {
1414
boost::container::static_vector<DNSRecord, MAX_RECORDS> records;
1515
std::size_t size;
1616

17-
constexpr static std::optional<DNSSection> parseSection(
17+
static std::optional<DNSSection> parseSection(
1818
std::span<const std::byte> section,
19-
const std::byte* dnsBegin,
19+
std::span<const std::byte> fullDNSPayload,
2020
const std::size_t recordsCount) noexcept;
2121

2222
};

‎process-plugin-api/process/common/dnsParser/dnsSection.o‎

1.06 MB
Binary file not shown.

‎process-plugin-api/process/common/dnsParser/dnsSectionReader.hpp‎

Lines changed: 46 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -11,33 +11,28 @@
1111
namespace ipxp
1212
{
1313

14-
/*
15-
struct DNSSectionReaderFactory;
14+
class DNSSectionReader;
1615

17-
class DNSSectionReader : public RangeReader<DNSSectionReaderFactory> {
18-
public:
19-
DNSSectionReader(std::span<const std::byte> section,
20-
std::span<const std::byte> fullDNSPayload, const std::size_t itemCount)
21-
: RangeReader(section, DNSSectionReaderFactory{this, itemCount, fullDNSPayload.data()}) {}
22-
};*/
23-
24-
class DNSSectionReader : public RangeReader<DNSSectionReader> {
25-
public:
26-
27-
28-
auto init() noexcept
16+
struct DNSSectionReaderFactory
17+
{
18+
static auto makeReader(
19+
std::size_t itemCount,
20+
std::span<const std::byte> fullDNSPayload,
21+
std::span<const std::byte> section,
22+
ParsingState* parsingState
23+
) noexcept
2924
{
30-
return Generator::generate([this]() mutable
31-
-> const std::optional<DNSRecord>& {
32-
static auto res = std::make_optional<DNSRecord>();
33-
if (m_itemCount == 0) {
34-
setSuccess();
25+
return Generator::generate([section, itemCount, fullDNSPayload, parsingState]() mutable
26+
-> std::optional<DNSRecord> {
27+
auto res = std::make_optional<DNSRecord>();
28+
if (itemCount == 0) {
29+
parsingState->state = ParsingState::State::SUCCESS;
3530
return std::nullopt;
3631
}
37-
m_itemCount--;
32+
itemCount--;
3833

3934
std::optional<DNSName> name = DNSName::createFrom(
40-
section, m_fullDNSPayload);
35+
section, fullDNSPayload);
4136
if (!name.has_value()) {
4237
return std::nullopt;
4338
}
@@ -66,7 +61,7 @@ class DNSSectionReader : public RangeReader<DNSSectionReader> {
6661

6762
std::span<const std::byte> rawData = section.subspan(
6863
name->length() + 3 * sizeof(uint16_t) + sizeof(uint32_t), rawDataLength);
69-
res->payload = DNSRecordPayload(rawData, m_fullDNSPayload, res->type);
64+
res->payload = DNSRecordPayload(rawData, fullDNSPayload, res->type);
7065

7166
section = section.subspan(
7267
name->length() + 3 * sizeof(uint16_t) + sizeof(uint32_t) + rawDataLength);
@@ -79,6 +74,33 @@ class DNSSectionReader : public RangeReader<DNSSectionReader> {
7974
});
8075
}
8176

77+
};
78+
79+
/*
80+
class DNSSectionReader : public RangeReader<DNSSectionReaderFactory> {
81+
public:
82+
DNSSectionReader(std::span<const std::byte> section,
83+
std::span<const std::byte> fullDNSPayload, const std::size_t itemCount)
84+
: RangeReader(section, DNSSectionReaderFactory{this, itemCount, fullDNSPayload.data()}) {}
85+
};*/
86+
87+
class DNSSectionReader :
88+
public RangeReader<decltype(
89+
DNSSectionReaderFactory::makeReader({}, {}, {}, {}))> {
90+
91+
public:
92+
DNSSectionReader(
93+
const std::size_t itemCount,
94+
std::span<const std::byte> fullDNSPayload,
95+
std::span<const std::byte> section)
96+
: RangeReader(
97+
DNSSectionReaderFactory::makeReader(
98+
itemCount, fullDNSPayload, section, &m_state))
99+
{
100+
}
101+
102+
/*public:
103+
82104
DNSSectionReader(
83105
const std::size_t itemCount,
84106
std::span<const std::byte> fullDNSPayload,
@@ -87,11 +109,12 @@ class DNSSectionReader : public RangeReader<DNSSectionReader> {
87109
, m_fullDNSPayload(fullDNSPayload)
88110
, section(section)
89111
, m_callback(init()) {}
112+
90113
private:
91114
std::size_t m_itemCount{0};
92115
std::span<const std::byte> m_fullDNSPayload;
93116
std::span<const std::byte> section;
94-
decltype(std::declval<DNSSectionReader>().init()) m_callback;
117+
CallbackType m_callback;*/
95118
};
96119

97120

‎process-plugin-api/process/common/readers/rangeReader/parsingState.hpp‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
#pragma once
2+
3+
namespace ipxp
4+
{
5+
6+
struct ParsingState {
7+
/*constexpr void setSuccess() noexcept
8+
{
9+
m_state = State::SUCCESS;
10+
}*/
11+
enum class State {
12+
SUCCESS,
13+
FAILURE
14+
};
15+
State state{State::FAILURE};
16+
};
17+
18+
} // namespace ipxp

‎process-plugin-api/process/common/readers/rangeReader/rangeReader.hpp‎

Lines changed: 12 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,62 +1,47 @@
11
#pragma once
22

3+
#include "parsingState.hpp"
4+
35
namespace ipxp
46
{
57

6-
template<typename Derived>
8+
template<typename CallbackType>
79
class RangeReader {
8-
enum class ParsingState {
9-
SUCCESS,
10-
FAILURE
11-
};
12-
1310
public:
14-
RangeReader() noexcept
15-
//: m_callback(callback->init())
11+
RangeReader(CallbackType&& callback) noexcept
12+
: m_callback(std::move(callback))
1613
{
1714
}
1815

19-
auto getCallback() const noexcept
20-
{
21-
return static_cast<const Derived*>(this)->m_callback;
22-
}
23-
2416
constexpr auto begin() const noexcept
2517
{
26-
return getCallback().begin();
18+
return m_callback.begin();
2719
}
2820

2921
constexpr auto end() const noexcept
3022
{
31-
return getCallback().end();
23+
return m_callback.end();
3224
}
3325

34-
/*constexpr auto begin() noexcept
26+
constexpr auto begin() noexcept
3527
{
3628
return m_callback.begin();
3729
}
3830

3931
constexpr auto end() noexcept
4032
{
4133
return m_callback.end();
42-
}*/
34+
}
4335

4436
constexpr bool parsedSuccessfully() const noexcept
4537
{
46-
return m_state == ParsingState::SUCCESS;
38+
return m_state.state == ParsingState::State::SUCCESS;
4739
}
4840

4941
protected:
50-
51-
52-
constexpr void setSuccess() noexcept {
53-
m_state = ParsingState::SUCCESS;
54-
}
55-
56-
//decltype(std::declval<Derived>().init()) m_callback;
57-
42+
ParsingState m_state;
5843
private:
59-
ParsingState m_state{ParsingState::FAILURE};
44+
CallbackType m_callback;
6045
};
6146

6247

0 commit comments

Comments
 (0)