mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 21:37:35 +00:00
LibDNS: Remove the 'DNS' prefix from the various type and class names
Since all types and class names live in the DNS namespace, we don't need to spell it out twice each time.
This commit is contained in:
parent
a3a1fe833b
commit
49de4d5f33
17 changed files with 219 additions and 219 deletions
|
@ -4,7 +4,7 @@
|
|||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include "DNSAnswer.h"
|
||||
#include "Answer.h"
|
||||
#include <AK/Stream.h>
|
||||
#include <LibIPC/Decoder.h>
|
||||
#include <LibIPC/Encoder.h>
|
||||
|
@ -12,7 +12,7 @@
|
|||
|
||||
namespace DNS {
|
||||
|
||||
DNSAnswer::DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush)
|
||||
Answer::Answer(Name const& name, RecordType type, RecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush)
|
||||
: m_name(name)
|
||||
, m_type(type)
|
||||
, m_class_code(class_code)
|
||||
|
@ -23,12 +23,12 @@ DNSAnswer::DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass cla
|
|||
time(&m_received_time);
|
||||
}
|
||||
|
||||
bool DNSAnswer::has_expired() const
|
||||
bool Answer::has_expired() const
|
||||
{
|
||||
return time(nullptr) >= m_received_time + m_ttl;
|
||||
}
|
||||
|
||||
unsigned DNSAnswer::hash() const
|
||||
unsigned Answer::hash() const
|
||||
{
|
||||
auto hash = pair_int_hash(CaseInsensitiveStringTraits::hash(name().as_string()), (u32)type());
|
||||
hash = pair_int_hash(hash, pair_int_hash((u32)class_code(), ttl()));
|
||||
|
@ -37,11 +37,11 @@ unsigned DNSAnswer::hash() const
|
|||
return hash;
|
||||
}
|
||||
|
||||
bool DNSAnswer::operator==(DNSAnswer const& other) const
|
||||
bool Answer::operator==(Answer const& other) const
|
||||
{
|
||||
if (&other == this)
|
||||
return true;
|
||||
if (!DNSName::Traits::equals(name(), other.name()))
|
||||
if (!Name::Traits::equals(name(), other.name()))
|
||||
return false;
|
||||
if (type() != other.type())
|
||||
return false;
|
||||
|
@ -58,26 +58,26 @@ bool DNSAnswer::operator==(DNSAnswer const& other) const
|
|||
|
||||
}
|
||||
|
||||
ErrorOr<void> AK::Formatter<DNS::DNSRecordType>::format(AK::FormatBuilder& builder, DNS::DNSRecordType value)
|
||||
ErrorOr<void> AK::Formatter<DNS::RecordType>::format(AK::FormatBuilder& builder, DNS::RecordType value)
|
||||
{
|
||||
switch (value) {
|
||||
case DNS::DNSRecordType::A:
|
||||
case DNS::RecordType::A:
|
||||
return builder.put_string("A");
|
||||
case DNS::DNSRecordType::NS:
|
||||
case DNS::RecordType::NS:
|
||||
return builder.put_string("NS");
|
||||
case DNS::DNSRecordType::CNAME:
|
||||
case DNS::RecordType::CNAME:
|
||||
return builder.put_string("CNAME");
|
||||
case DNS::DNSRecordType::SOA:
|
||||
case DNS::RecordType::SOA:
|
||||
return builder.put_string("SOA");
|
||||
case DNS::DNSRecordType::PTR:
|
||||
case DNS::RecordType::PTR:
|
||||
return builder.put_string("PTR");
|
||||
case DNS::DNSRecordType::MX:
|
||||
case DNS::RecordType::MX:
|
||||
return builder.put_string("MX");
|
||||
case DNS::DNSRecordType::TXT:
|
||||
case DNS::RecordType::TXT:
|
||||
return builder.put_string("TXT");
|
||||
case DNS::DNSRecordType::AAAA:
|
||||
case DNS::RecordType::AAAA:
|
||||
return builder.put_string("AAAA");
|
||||
case DNS::DNSRecordType::SRV:
|
||||
case DNS::RecordType::SRV:
|
||||
return builder.put_string("SRV");
|
||||
}
|
||||
|
||||
|
@ -86,10 +86,10 @@ ErrorOr<void> AK::Formatter<DNS::DNSRecordType>::format(AK::FormatBuilder& build
|
|||
return {};
|
||||
}
|
||||
|
||||
ErrorOr<void> AK::Formatter<DNS::DNSRecordClass>::format(AK::FormatBuilder& builder, DNS::DNSRecordClass value)
|
||||
ErrorOr<void> AK::Formatter<DNS::RecordClass>::format(AK::FormatBuilder& builder, DNS::RecordClass value)
|
||||
{
|
||||
switch (value) {
|
||||
case DNS::DNSRecordClass::IN:
|
||||
case DNS::RecordClass::IN:
|
||||
return builder.put_string("IN");
|
||||
}
|
||||
|
||||
|
@ -100,13 +100,13 @@ ErrorOr<void> AK::Formatter<DNS::DNSRecordClass>::format(AK::FormatBuilder& buil
|
|||
|
||||
namespace IPC {
|
||||
|
||||
bool encode(Encoder& encoder, DNS::DNSAnswer const& answer)
|
||||
bool encode(Encoder& encoder, DNS::Answer const& answer)
|
||||
{
|
||||
encoder << answer.name().as_string() << (u16)answer.type() << (u16)answer.class_code() << answer.ttl() << answer.record_data() << answer.mdns_cache_flush();
|
||||
return true;
|
||||
}
|
||||
|
||||
ErrorOr<void> decode(Decoder& decoder, DNS::DNSAnswer& answer)
|
||||
ErrorOr<void> decode(Decoder& decoder, DNS::Answer& answer)
|
||||
{
|
||||
String name;
|
||||
TRY(decoder.decode(name));
|
||||
|
@ -119,7 +119,7 @@ ErrorOr<void> decode(Decoder& decoder, DNS::DNSAnswer& answer)
|
|||
TRY(decoder.decode(record_data));
|
||||
bool cache_flush;
|
||||
TRY(decoder.decode(cache_flush));
|
||||
answer = { { name }, (DNS::DNSRecordType)record_type, (DNS::DNSRecordClass)class_code, ttl, record_data, cache_flush };
|
||||
answer = { { name }, (DNS::RecordType)record_type, (DNS::RecordClass)class_code, ttl, record_data, cache_flush };
|
||||
return {};
|
||||
}
|
||||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "DNSName.h"
|
||||
#include "Name.h"
|
||||
#include <AK/Format.h>
|
||||
#include <AK/String.h>
|
||||
#include <AK/Traits.h>
|
||||
|
@ -15,7 +15,7 @@
|
|||
|
||||
namespace DNS {
|
||||
|
||||
enum class DNSRecordType : u16 {
|
||||
enum class RecordType : u16 {
|
||||
A = 1,
|
||||
NS = 2,
|
||||
CNAME = 5,
|
||||
|
@ -27,20 +27,20 @@ enum class DNSRecordType : u16 {
|
|||
SRV = 33,
|
||||
};
|
||||
|
||||
enum class DNSRecordClass : u16 {
|
||||
enum class RecordClass : u16 {
|
||||
IN = 1
|
||||
};
|
||||
|
||||
#define MDNS_CACHE_FLUSH 0x8000
|
||||
|
||||
class DNSAnswer {
|
||||
class Answer {
|
||||
public:
|
||||
DNSAnswer() = default;
|
||||
DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush);
|
||||
Answer() = default;
|
||||
Answer(Name const& name, RecordType type, RecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush);
|
||||
|
||||
DNSName const& name() const { return m_name; }
|
||||
DNSRecordType type() const { return m_type; }
|
||||
DNSRecordClass class_code() const { return m_class_code; }
|
||||
Name const& name() const { return m_name; }
|
||||
RecordType type() const { return m_type; }
|
||||
RecordClass class_code() const { return m_class_code; }
|
||||
u16 raw_class_code() const { return (u16)m_class_code | (m_mdns_cache_flush ? MDNS_CACHE_FLUSH : 0); }
|
||||
u32 ttl() const { return m_ttl; }
|
||||
time_t received_time() const { return m_received_time; }
|
||||
|
@ -50,12 +50,12 @@ public:
|
|||
bool has_expired() const;
|
||||
|
||||
unsigned hash() const;
|
||||
bool operator==(DNSAnswer const&) const;
|
||||
bool operator==(Answer const&) const;
|
||||
|
||||
private:
|
||||
DNSName m_name;
|
||||
DNSRecordType m_type { 0 };
|
||||
DNSRecordClass m_class_code { 0 };
|
||||
Name m_name;
|
||||
RecordType m_type { 0 };
|
||||
RecordClass m_class_code { 0 };
|
||||
u32 m_ttl { 0 };
|
||||
time_t m_received_time { 0 };
|
||||
String m_record_data;
|
||||
|
@ -65,36 +65,36 @@ private:
|
|||
}
|
||||
|
||||
template<>
|
||||
struct AK::Traits<DNS::DNSAnswer> : public GenericTraits<DNS::DNSAnswer> {
|
||||
struct AK::Traits<DNS::Answer> : public GenericTraits<DNS::Answer> {
|
||||
static constexpr bool is_trivial() { return false; }
|
||||
static unsigned hash(DNS::DNSAnswer a) { return a.hash(); }
|
||||
static unsigned hash(DNS::Answer a) { return a.hash(); }
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AK::Formatter<DNS::DNSRecordType> : StandardFormatter {
|
||||
struct AK::Formatter<DNS::RecordType> : StandardFormatter {
|
||||
Formatter() = default;
|
||||
explicit Formatter(StandardFormatter formatter)
|
||||
: StandardFormatter(formatter)
|
||||
{
|
||||
}
|
||||
|
||||
ErrorOr<void> format(AK::FormatBuilder&, DNS::DNSRecordType);
|
||||
ErrorOr<void> format(AK::FormatBuilder&, DNS::RecordType);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AK::Formatter<DNS::DNSRecordClass> : StandardFormatter {
|
||||
struct AK::Formatter<DNS::RecordClass> : StandardFormatter {
|
||||
Formatter() = default;
|
||||
explicit Formatter(StandardFormatter formatter)
|
||||
: StandardFormatter(formatter)
|
||||
{
|
||||
}
|
||||
|
||||
ErrorOr<void> format(AK::FormatBuilder&, DNS::DNSRecordClass);
|
||||
ErrorOr<void> format(AK::FormatBuilder&, DNS::RecordClass);
|
||||
};
|
||||
|
||||
namespace IPC {
|
||||
|
||||
bool encode(Encoder&, DNS::DNSAnswer const&);
|
||||
ErrorOr<void> decode(Decoder&, DNS::DNSAnswer&);
|
||||
bool encode(Encoder&, DNS::Answer const&);
|
||||
ErrorOr<void> decode(Decoder&, DNS::Answer&);
|
||||
|
||||
}
|
|
@ -1,7 +1,7 @@
|
|||
set(SOURCES
|
||||
DNSAnswer.cpp
|
||||
DNSName.cpp
|
||||
DNSPacket.cpp
|
||||
Answer.cpp
|
||||
Name.cpp
|
||||
Packet.cpp
|
||||
)
|
||||
|
||||
serenity_lib(LibDNS dns)
|
||||
|
|
|
@ -1,49 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
* Copyright (c) 2021, Sergey Bugaev <bugaevc@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/Forward.h>
|
||||
#include <AK/String.h>
|
||||
|
||||
namespace DNS {
|
||||
|
||||
class DNSName {
|
||||
public:
|
||||
DNSName() = default;
|
||||
DNSName(String const&);
|
||||
|
||||
static DNSName parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level = 0);
|
||||
|
||||
size_t serialized_size() const;
|
||||
String const& as_string() const { return m_name; }
|
||||
|
||||
void randomize_case();
|
||||
|
||||
bool operator==(DNSName const& other) const { return Traits::equals(*this, other); }
|
||||
|
||||
class Traits : public AK::Traits<DNSName> {
|
||||
public:
|
||||
static unsigned hash(DNSName const& name);
|
||||
static bool equals(DNSName const&, DNSName const&);
|
||||
};
|
||||
|
||||
private:
|
||||
String m_name;
|
||||
};
|
||||
|
||||
OutputStream& operator<<(OutputStream& stream, DNSName const&);
|
||||
|
||||
}
|
||||
|
||||
template<>
|
||||
struct AK::Formatter<DNS::DNSName> : Formatter<StringView> {
|
||||
ErrorOr<void> format(FormatBuilder& builder, DNS::DNSName const& value)
|
||||
{
|
||||
return Formatter<StringView>::format(builder, value.as_string());
|
||||
}
|
||||
};
|
|
@ -5,14 +5,14 @@
|
|||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include "DNSName.h"
|
||||
#include "Name.h"
|
||||
#include <AK/Random.h>
|
||||
#include <AK/Vector.h>
|
||||
#include <ctype.h>
|
||||
|
||||
namespace DNS {
|
||||
|
||||
DNSName::DNSName(String const& name)
|
||||
Name::Name(String const& name)
|
||||
{
|
||||
if (name.ends_with('.'))
|
||||
m_name = name.substring(0, name.length() - 1);
|
||||
|
@ -20,7 +20,7 @@ DNSName::DNSName(String const& name)
|
|||
m_name = name;
|
||||
}
|
||||
|
||||
DNSName DNSName::parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level)
|
||||
Name Name::parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level)
|
||||
{
|
||||
if (recursion_level > 4)
|
||||
return {};
|
||||
|
@ -52,14 +52,14 @@ DNSName DNSName::parse(u8 const* data, size_t& offset, size_t max_offset, size_t
|
|||
}
|
||||
}
|
||||
|
||||
size_t DNSName::serialized_size() const
|
||||
size_t Name::serialized_size() const
|
||||
{
|
||||
if (m_name.is_empty())
|
||||
return 1;
|
||||
return m_name.length() + 2;
|
||||
}
|
||||
|
||||
void DNSName::randomize_case()
|
||||
void Name::randomize_case()
|
||||
{
|
||||
StringBuilder builder;
|
||||
for (char c : m_name) {
|
||||
|
@ -75,7 +75,7 @@ void DNSName::randomize_case()
|
|||
m_name = builder.to_string();
|
||||
}
|
||||
|
||||
OutputStream& operator<<(OutputStream& stream, DNSName const& name)
|
||||
OutputStream& operator<<(OutputStream& stream, Name const& name)
|
||||
{
|
||||
auto parts = name.as_string().split_view('.');
|
||||
for (auto& part : parts) {
|
||||
|
@ -86,12 +86,12 @@ OutputStream& operator<<(OutputStream& stream, DNSName const& name)
|
|||
return stream;
|
||||
}
|
||||
|
||||
unsigned DNSName::Traits::hash(DNSName const& name)
|
||||
unsigned Name::Traits::hash(Name const& name)
|
||||
{
|
||||
return CaseInsensitiveStringTraits::hash(name.as_string());
|
||||
}
|
||||
|
||||
bool DNSName::Traits::equals(DNSName const& a, DNSName const& b)
|
||||
bool Name::Traits::equals(Name const& a, Name const& b)
|
||||
{
|
||||
return CaseInsensitiveStringTraits::equals(a.as_string(), b.as_string());
|
||||
}
|
49
Userland/Libraries/LibDNS/Name.h
Normal file
49
Userland/Libraries/LibDNS/Name.h
Normal file
|
@ -0,0 +1,49 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
* Copyright (c) 2021, Sergey Bugaev <bugaevc@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/Forward.h>
|
||||
#include <AK/String.h>
|
||||
|
||||
namespace DNS {
|
||||
|
||||
class Name {
|
||||
public:
|
||||
Name() = default;
|
||||
Name(String const&);
|
||||
|
||||
static Name parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level = 0);
|
||||
|
||||
size_t serialized_size() const;
|
||||
String const& as_string() const { return m_name; }
|
||||
|
||||
void randomize_case();
|
||||
|
||||
bool operator==(Name const& other) const { return Traits::equals(*this, other); }
|
||||
|
||||
class Traits : public AK::Traits<Name> {
|
||||
public:
|
||||
static unsigned hash(Name const& name);
|
||||
static bool equals(Name const&, Name const&);
|
||||
};
|
||||
|
||||
private:
|
||||
String m_name;
|
||||
};
|
||||
|
||||
OutputStream& operator<<(OutputStream& stream, Name const&);
|
||||
|
||||
}
|
||||
|
||||
template<>
|
||||
struct AK::Formatter<DNS::Name> : Formatter<StringView> {
|
||||
ErrorOr<void> format(FormatBuilder& builder, DNS::Name const& value)
|
||||
{
|
||||
return Formatter<StringView>::format(builder, value.as_string());
|
||||
}
|
||||
};
|
|
@ -5,9 +5,9 @@
|
|||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include "DNSPacket.h"
|
||||
#include "DNSName.h"
|
||||
#include "DNSPacketHeader.h"
|
||||
#include "Packet.h"
|
||||
#include "Name.h"
|
||||
#include "PacketHeader.h"
|
||||
#include <AK/Debug.h>
|
||||
#include <AK/MemoryStream.h>
|
||||
#include <AK/StringBuilder.h>
|
||||
|
@ -16,23 +16,23 @@
|
|||
|
||||
namespace DNS {
|
||||
|
||||
void DNSPacket::add_question(DNSQuestion const& question)
|
||||
void Packet::add_question(Question const& question)
|
||||
{
|
||||
m_questions.empend(question);
|
||||
|
||||
VERIFY(m_questions.size() <= UINT16_MAX);
|
||||
}
|
||||
|
||||
void DNSPacket::add_answer(DNSAnswer const& answer)
|
||||
void Packet::add_answer(Answer const& answer)
|
||||
{
|
||||
m_answers.empend(answer);
|
||||
|
||||
VERIFY(m_answers.size() <= UINT16_MAX);
|
||||
}
|
||||
|
||||
ByteBuffer DNSPacket::to_byte_buffer() const
|
||||
ByteBuffer Packet::to_byte_buffer() const
|
||||
{
|
||||
DNSPacketHeader header;
|
||||
PacketHeader header;
|
||||
header.set_id(m_id);
|
||||
if (is_query())
|
||||
header.set_is_query();
|
||||
|
@ -62,8 +62,8 @@ ByteBuffer DNSPacket::to_byte_buffer() const
|
|||
stream << htons((u16)answer.type());
|
||||
stream << htons(answer.raw_class_code());
|
||||
stream << htonl(answer.ttl());
|
||||
if (answer.type() == DNSRecordType::PTR) {
|
||||
DNSName name { answer.record_data() };
|
||||
if (answer.type() == RecordType::PTR) {
|
||||
Name name { answer.record_data() };
|
||||
stream << htons(name.serialized_size());
|
||||
stream << name;
|
||||
} else {
|
||||
|
@ -96,21 +96,21 @@ private:
|
|||
|
||||
static_assert(sizeof(DNSRecordWithoutName) == 10);
|
||||
|
||||
Optional<DNSPacket> DNSPacket::from_raw_packet(u8 const* raw_data, size_t raw_size)
|
||||
Optional<Packet> Packet::from_raw_packet(u8 const* raw_data, size_t raw_size)
|
||||
{
|
||||
if (raw_size < sizeof(DNSPacketHeader)) {
|
||||
dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(DNSPacketHeader));
|
||||
if (raw_size < sizeof(PacketHeader)) {
|
||||
dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(PacketHeader));
|
||||
return {};
|
||||
}
|
||||
|
||||
auto& header = *(DNSPacketHeader const*)(raw_data);
|
||||
auto& header = *(PacketHeader const*)(raw_data);
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, "Got packet (ID: {})", header.id());
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, " Question count: {}", header.question_count());
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, " Answer count: {}", header.answer_count());
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, " Authority count: {}", header.authority_count());
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, "Additional count: {}", header.additional_count());
|
||||
|
||||
DNSPacket packet;
|
||||
Packet packet;
|
||||
packet.m_id = header.id();
|
||||
packet.m_query_or_response = header.is_response();
|
||||
packet.m_code = header.response_code();
|
||||
|
@ -119,10 +119,10 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(u8 const* raw_data, size_t raw_si
|
|||
if (packet.code() != Code::NOERROR)
|
||||
return packet;
|
||||
|
||||
size_t offset = sizeof(DNSPacketHeader);
|
||||
size_t offset = sizeof(PacketHeader);
|
||||
|
||||
for (u16 i = 0; i < header.question_count(); i++) {
|
||||
auto name = DNSName::parse(raw_data, offset, raw_size);
|
||||
auto name = Name::parse(raw_data, offset, raw_size);
|
||||
struct RawDNSAnswerQuestion {
|
||||
NetworkOrdered<u16> record_type;
|
||||
NetworkOrdered<u16> class_code;
|
||||
|
@ -130,14 +130,14 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(u8 const* raw_data, size_t raw_si
|
|||
auto& record_and_class = *(RawDNSAnswerQuestion const*)&raw_data[offset];
|
||||
u16 class_code = record_and_class.class_code & ~MDNS_WANTS_UNICAST_RESPONSE;
|
||||
bool mdns_wants_unicast_response = record_and_class.class_code & MDNS_WANTS_UNICAST_RESPONSE;
|
||||
packet.m_questions.empend(name, (DNSRecordType)(u16)record_and_class.record_type, (DNSRecordClass)class_code, mdns_wants_unicast_response);
|
||||
packet.m_questions.empend(name, (RecordType)(u16)record_and_class.record_type, (RecordClass)class_code, mdns_wants_unicast_response);
|
||||
offset += 4;
|
||||
auto& question = packet.m_questions.last();
|
||||
dbgln_if(LOOKUPSERVER_DEBUG, "Question #{}: name=_{}_, type={}, class={}", i, question.name(), question.record_type(), question.class_code());
|
||||
}
|
||||
|
||||
for (u16 i = 0; i < header.answer_count(); ++i) {
|
||||
auto name = DNSName::parse(raw_data, offset, raw_size);
|
||||
auto name = Name::parse(raw_data, offset, raw_size);
|
||||
|
||||
auto& record = *(DNSRecordWithoutName const*)(&raw_data[offset]);
|
||||
|
||||
|
@ -145,21 +145,21 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(u8 const* raw_data, size_t raw_si
|
|||
|
||||
offset += sizeof(DNSRecordWithoutName);
|
||||
|
||||
switch ((DNSRecordType)record.type()) {
|
||||
case DNSRecordType::PTR: {
|
||||
switch ((RecordType)record.type()) {
|
||||
case RecordType::PTR: {
|
||||
size_t dummy_offset = offset;
|
||||
data = DNSName::parse(raw_data, dummy_offset, raw_size).as_string();
|
||||
data = Name::parse(raw_data, dummy_offset, raw_size).as_string();
|
||||
break;
|
||||
}
|
||||
case DNSRecordType::CNAME:
|
||||
case RecordType::CNAME:
|
||||
// Fall through
|
||||
case DNSRecordType::A:
|
||||
case RecordType::A:
|
||||
// Fall through
|
||||
case DNSRecordType::TXT:
|
||||
case RecordType::TXT:
|
||||
// Fall through
|
||||
case DNSRecordType::AAAA:
|
||||
case RecordType::AAAA:
|
||||
// Fall through
|
||||
case DNSRecordType::SRV:
|
||||
case RecordType::SRV:
|
||||
data = { record.data(), record.data_length() };
|
||||
break;
|
||||
default:
|
||||
|
@ -170,7 +170,7 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(u8 const* raw_data, size_t raw_si
|
|||
dbgln_if(LOOKUPSERVER_DEBUG, "Answer #{}: name=_{}_, type={}, ttl={}, length={}, data=_{}_", i, name, record.type(), record.ttl(), record.data_length(), data);
|
||||
u16 class_code = record.record_class() & ~MDNS_CACHE_FLUSH;
|
||||
bool mdns_cache_flush = record.record_class() & MDNS_CACHE_FLUSH;
|
||||
packet.m_answers.empend(name, (DNSRecordType)record.type(), (DNSRecordClass)class_code, record.ttl(), data, mdns_cache_flush);
|
||||
packet.m_answers.empend(name, (RecordType)record.type(), (RecordClass)class_code, record.ttl(), data, mdns_cache_flush);
|
||||
offset += record.data_length();
|
||||
}
|
||||
|
|
@ -7,8 +7,8 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "DNSAnswer.h"
|
||||
#include "DNSQuestion.h"
|
||||
#include "Answer.h"
|
||||
#include "Question.h"
|
||||
#include <AK/Optional.h>
|
||||
#include <AK/Types.h>
|
||||
#include <AK/Vector.h>
|
||||
|
@ -20,11 +20,11 @@ enum class ShouldRandomizeCase {
|
|||
Yes
|
||||
};
|
||||
|
||||
class DNSPacket {
|
||||
class Packet {
|
||||
public:
|
||||
DNSPacket() = default;
|
||||
Packet() = default;
|
||||
|
||||
static Optional<DNSPacket> from_raw_packet(u8 const*, size_t);
|
||||
static Optional<Packet> from_raw_packet(u8 const*, size_t);
|
||||
ByteBuffer to_byte_buffer() const;
|
||||
|
||||
bool is_query() const { return !m_query_or_response; }
|
||||
|
@ -41,8 +41,8 @@ public:
|
|||
u16 id() const { return m_id; }
|
||||
void set_id(u16 id) { m_id = id; }
|
||||
|
||||
Vector<DNSQuestion> const& questions() const { return m_questions; }
|
||||
Vector<DNSAnswer> const& answers() const { return m_answers; }
|
||||
Vector<Question> const& questions() const { return m_questions; }
|
||||
Vector<Answer> const& answers() const { return m_answers; }
|
||||
|
||||
u16 question_count() const
|
||||
{
|
||||
|
@ -56,8 +56,8 @@ public:
|
|||
return m_answers.size();
|
||||
}
|
||||
|
||||
void add_question(DNSQuestion const&);
|
||||
void add_answer(DNSAnswer const&);
|
||||
void add_question(Question const&);
|
||||
void add_answer(Answer const&);
|
||||
|
||||
enum class Code : u8 {
|
||||
NOERROR = 0,
|
||||
|
@ -82,8 +82,8 @@ private:
|
|||
bool m_query_or_response { false };
|
||||
bool m_recursion_desired { true };
|
||||
bool m_recursion_available { true };
|
||||
Vector<DNSQuestion> m_questions;
|
||||
Vector<DNSAnswer> m_answers;
|
||||
Vector<Question> m_questions;
|
||||
Vector<Answer> m_answers;
|
||||
};
|
||||
|
||||
}
|
|
@ -11,9 +11,9 @@
|
|||
|
||||
namespace DNS {
|
||||
|
||||
class [[gnu::packed]] DNSPacketHeader {
|
||||
class [[gnu::packed]] PacketHeader {
|
||||
public:
|
||||
DNSPacketHeader()
|
||||
PacketHeader()
|
||||
: m_recursion_desired(false)
|
||||
, m_truncated(false)
|
||||
, m_authoritative_answer(false)
|
||||
|
@ -94,6 +94,6 @@ private:
|
|||
NetworkOrdered<u16> m_additional_count;
|
||||
};
|
||||
|
||||
static_assert(sizeof(DNSPacketHeader) == 12);
|
||||
static_assert(sizeof(PacketHeader) == 12);
|
||||
|
||||
}
|
|
@ -6,16 +6,16 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "DNSName.h"
|
||||
#include "Name.h"
|
||||
#include <AK/Types.h>
|
||||
|
||||
namespace DNS {
|
||||
|
||||
#define MDNS_WANTS_UNICAST_RESPONSE 0x8000
|
||||
|
||||
class DNSQuestion {
|
||||
class Question {
|
||||
public:
|
||||
DNSQuestion(DNSName const& name, DNSRecordType record_type, DNSRecordClass class_code, bool mdns_wants_unicast_response)
|
||||
Question(Name const& name, RecordType record_type, RecordClass class_code, bool mdns_wants_unicast_response)
|
||||
: m_name(name)
|
||||
, m_record_type(record_type)
|
||||
, m_class_code(class_code)
|
||||
|
@ -23,16 +23,16 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
DNSRecordType record_type() const { return m_record_type; }
|
||||
DNSRecordClass class_code() const { return m_class_code; }
|
||||
RecordType record_type() const { return m_record_type; }
|
||||
RecordClass class_code() const { return m_class_code; }
|
||||
u16 raw_class_code() const { return (u16)m_class_code | (m_mdns_wants_unicast_response ? MDNS_WANTS_UNICAST_RESPONSE : 0); }
|
||||
DNSName const& name() const { return m_name; }
|
||||
Name const& name() const { return m_name; }
|
||||
bool mdns_wants_unicast_response() const { return m_mdns_wants_unicast_response; }
|
||||
|
||||
private:
|
||||
DNSName m_name;
|
||||
DNSRecordType m_record_type { 0 };
|
||||
DNSRecordClass m_class_code { 0 };
|
||||
Name m_name;
|
||||
RecordType m_record_type { 0 };
|
||||
RecordClass m_class_code { 0 };
|
||||
bool m_mdns_wants_unicast_response { false };
|
||||
};
|
||||
|
|
@ -409,7 +409,7 @@ Optional<Certificate> Certificate::parse_asn1(ReadonlyBytes buffer, bool)
|
|||
break;
|
||||
case 2: {
|
||||
// DNS Name
|
||||
READ_OBJECT_OR_FAIL(IA5String, StringView, name, "Certificate::TBSCertificate::Extensions::$::Extension::extension_value::SubjectAlternativeName::$::DNSName");
|
||||
READ_OBJECT_OR_FAIL(IA5String, StringView, name, "Certificate::TBSCertificate::Extensions::$::Extension::extension_value::SubjectAlternativeName::$::Name");
|
||||
certificate.SAN.append(name);
|
||||
break;
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue